DIRECTORY
CoordSys,
CSG,
CSGGraphics,
DisplayList3d,
DisplayList3dPrivate,
GraphicsColor,
IO,
Matrix3d,
Rope,
Shading,
SV2d,
SVArtwork,
SVDisplayListFiling,
SVPolygon3d,
SVVector3d;

DisplayList3dImplA: PROGRAM
IMPORTS CSGGraphics, CoordSys, DisplayList3d, DisplayList3dPrivate, GraphicsColor, IO, Matrix3d, Rope, SVArtwork, SVDisplayListFiling, SVPolygon3d
EXPORTS DisplayList3d, DisplayList3dPrivate, SVDisplayListFiling =

BEGIN

versionRope: PUBLIC Rope.ROPE _ "Solidviews Version 3.0 OF August 5, 1983 9:46 pm";
Artwork: TYPE = REF ArtworkObj;
ArtworkObj: TYPE = SVArtwork.ArtworkObj;
Camera: TYPE = REF CameraObj;
CameraObj: TYPE = CSGGraphics.CameraObj;
Classification: TYPE = REF ClassificationObj;
ClassificationObj: TYPE = CSG.ClassificationObj;
Color: TYPE = GraphicsColor.Color;
CoordSysList: TYPE = CoordSys.CoordSysList;
CoordSysObj: TYPE = CoordSys.CoordSysObj;
CoordSystem: TYPE = REF CoordSysObj;
CSGTree: TYPE = REF CSGTreeObj;
CSGTreeObj: TYPE = CSG.CSGTreeObj;
DrawStyle: TYPE = CSGGraphics.DrawStyle;
FrameBox: TYPE = REF FrameBoxObj;
FrameBoxObj: TYPE = CSGGraphics.FrameBoxObj;
Matrix4by4: TYPE = Matrix3d.Matrix4by4;
Plane: TYPE = SVPolygon3d.Plane;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = Matrix3d.Point3d;
PointSetOp: TYPE = CSG.PointSetOp;-- {union, intersection, difference}
Poly3d: TYPE = SVPolygon3d.Poly3d;
Primitive: TYPE = REF PrimitiveObj;
PrimitiveObj: TYPE = CSG.PrimitiveObj;
Ray: TYPE = REF RayObj;
RayObj: TYPE = CSG.RayObj;
Vector: TYPE = SVVector3d.Vector;
Database: TYPE = REF DatabaseObj;
DatabaseObj: TYPE = DisplayList3d.DatabaseObj;

Scene: TYPE = REF SceneObj;
SceneObj: TYPE = DisplayList3d.SceneObj;

Assembly: TYPE = REF AssemblyObj;
AssemblyObj: TYPE = DisplayList3d.AssemblyObj;
AssemblyList: TYPE = REF AssemblyListObj;
AssemblyListObj: TYPE = DisplayList3d.AssemblyListObj;

LightSource: TYPE = REF LightSourceObj;
LightSourceObj: TYPE = Shading.LightSourceObj;
LightSourceList: TYPE = Shading.LightSourceList;

FileCamera: TYPE = REF FileCameraObj;
FileCameraObj: TYPE = DisplayList3d.FileCameraObj;
FileCameraList: TYPE = DisplayList3d.FileCameraList;
MasterObjectClass: TYPE = REF MasterObjectClassObj;
MasterObjectClassObj: TYPE = DisplayList3d.MasterObjectClassObj;
MasterObjectClassList: TYPE = DisplayList3d.MasterObjectClassList;

FileoutProc: TYPE = DisplayList3d.FileoutProc;
FileinProc: TYPE = DisplayList3d.FileinProc;
MasterObject: TYPE = REF MasterObjectRec;
MasterObjectRec: TYPE = DisplayList3d.MasterObjectRec;
MasterObjectList: TYPE = DisplayList3d.MasterObjectList;

RayCastProc: TYPE = CSG.RayCastProc;
RayCastNoBBoxesProc: TYPE = CSG.RayCastNoBBoxesProc;
BoundHedronProc: TYPE = DisplayList3d.BoundHedronProc;
PreprocessProc: TYPE = DisplayList3d.PreprocessProc;
LineDrawProc: TYPE = DisplayList3d.LineDrawProc;
NormalsDrawProc: TYPE = DisplayList3d.NormalsDrawProc;
CountPlanarSurfacesProc: TYPE = DisplayList3d.CountPlanarSurfacesProc;
GetPlanarSurfacesProc: TYPE = DisplayList3d.GetPlanarSurfacesProc;
PlanarSurface: TYPE = REF PlanarSurfaceObj;
PlanarSurfaceObj: TYPE = DisplayList3d.PlanarSurfaceObj;
PlanarSurfaceList: TYPE = DisplayList3d.PlanarSurfaceList;
DrawPlanarSurfaceProc: TYPE = DisplayList3d.DrawPlanarSurfaceProc;
DrawSubBoxesProc: TYPE = DisplayList3d.DrawSubBoxesProc;
globalDatabase: Database;
globalClassList: MasterObjectClassList _ NIL;
globalMOList: MasterObjectList _ NIL;
RegisterMasterObjectClass: PUBLIC PROC [
name: Rope.ROPE,
filein: FileinProc,
fileout: FileoutProc,
rayCast: RayCastProc,
rayCastNoBBoxes: RayCastNoBBoxesProc,
getHedron: BoundHedronProc,
preprocess: PreprocessProc,
lineDraw: LineDrawProc,
normalsDraw: NormalsDrawProc,
countSurf: CountPlanarSurfacesProc,
getSurf: GetPlanarSurfacesProc,
drawSurf: DrawPlanarSurfaceProc,
drawSubBoxes: DrawSubBoxesProc]
RETURNS [moClass: MasterObjectClass] = {
moClass _ NEW[MasterObjectClassObj _ [name, filein, fileout, rayCast, rayCastNoBBoxes, getHedron, preprocess, lineDraw, normalsDraw, countSurf, getSurf, drawSurf, drawSubBoxes]];
globalClassList _ AppendClassToList[moClass, globalClassList];
};

RegisterMasterObject: PUBLIC PROC [mo: MasterObject] = {
globalMOList _ AppendToMasterObjects[mo, globalMOList];
};
CreateScene: PUBLIC PROC [name: Rope.ROPE] RETURNS [scene: Scene] = {
initialCS: CoordSysList _ CoordSys.InitialCoordSysList[];
worldCS: CoordSystem _ CoordSys.FindCoordSysFromName["WORLD", initialCS];
sceneAssemblyCS: CoordSystem;
sceneAssembly: Assembly _ CreateClusterAssembly["sceneAssembly", union];
defaultRedLight: LightSource _ CreateLightSource["RedLight",[200,200,400], GraphicsColor.red];
defaultGreenLight: LightSource _ CreateLightSource["GreenLight",[-200,200,400], GraphicsColor.green];
defaultWhiteLight: LightSource _ CreateLightSource["WhiteLight",[800,800,1000],GraphicsColor.white];
cameras: FileCameraList _ DisplayList3d.InitialCameraList[];

scene _ NEW[SceneObj _ [
name: name,
worldCS: worldCS,
coordSystems: initialCS,
lightSources: CONS[defaultWhiteLight, NIL],
masterObjects: DisplayList3dPrivate.CopyMasterObjectList[globalMOList], -- Copies the list structure but not the objects.
assembly: sceneAssembly,
cameras: cameras,
cameraOrder: LIST["Front"],
backgroundColor: GraphicsColor.white,
shadows: FALSE,
dirty: FALSE]];
sceneAssemblyCS _ CoordSys.CreateCoordSys["sceneAssembly", Matrix3d.Identity[], scene.worldCS];
DisplayList3d.AddCoordSysToScene[sceneAssemblyCS, scene];
scene.assembly.coordSys _ sceneAssemblyCS;
globalDatabase _ AppendToDatabase[scene, globalDatabase];
};

CreateEmptyScene: PUBLIC PROC [name: Rope.ROPE] RETURNS [scene: Scene] = {
scene _ NEW[SceneObj _ [name: name,
worldCS: NIL,
coordSystems: NIL, lightSources: NIL,
masterObjects: NIL,
assembly: NIL,
cameras: NIL,
cameraOrder: NIL,
backgroundColor: GraphicsColor.white,
shadows: FALSE,
dirty: FALSE]];
globalDatabase _ AppendToDatabase[scene, globalDatabase];
};

CreateMasterObject: PUBLIC PROC [
name: Rope.ROPE,
class: MasterObjectClass,
mainBody: REF ANY,
lineBody: REF ANY,
shadeBody: REF ANY,
rayCastBody: REF ANY] RETURNS [mo: MasterObject] = {
mo _ NEW[MasterObjectRec _
[name, class, mainBody, lineBody, shadeBody, rayCastBody]];
};

CopyMasterObject: PUBLIC PROC [mo: MasterObject] RETURNS [copy: MasterObject] = {
copy _ NEW[MasterObjectRec];
copy.name _ mo.name;
copy.class _ mo.class;
copy.mainBody _ mo.mainBody;
copy.lineBody _ mo.lineBody;
copy.shadeBody _ mo.shadeBody;
copy.rayCastBody _ mo.rayCastBody;
};

CreatePrimitiveAssembly: PUBLIC PROC [name: Rope.ROPE, object: Rope.ROPE, size: Vector, scene: Scene, artwork: Artwork _ NIL, isTool: BOOL _ FALSE]
RETURNS [assembly: Assembly, masterObjectFound: BOOL] = {
masterObject: MasterObject;
masterObjectFound _ TRUE;
[masterObject, masterObjectFound] _ FindObjectFromName[object, scene];
IF NOT masterObjectFound THEN RETURN;
IF artwork = NIL THEN artwork _
SVArtwork.CreateColorArtwork[GraphicsColor.RGBToColor[.6,.6,.8], plastic]; -- light blue
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, scalars: size, visible: TRUE, isTool: isTool, object: masterObject]];
};

CreateClusterAssembly: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp _ union, isTool: BOOL _ FALSE] RETURNS [assembly: Assembly] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[GraphicsColor.IntensityToColor[1], plastic]; -- white
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, scalars: [1,1,1],
 object: NEW[AssemblyListObj _ [NIL, pointSetOp] ], isTool: isTool, visible: TRUE]];
};

CreateLightSource: PUBLIC PROC [name: Rope.ROPE, position: Point3d, color: Color] RETURNS [ls: LightSource] = {
vector: Vector _ position;
ls _ NEW[LightSourceObj _ [name, position, color]];
};

CreateFileCamera: PUBLIC PROC [name: Rope.ROPE, origin: Point3d, focusPoint: Point3d, slant: REAL, resolution: REAL, focalLength: REAL, clippingPlanes: LIST OF Plane, visibleAssemblies: LIST OF Rope.ROPE] RETURNS [fileCamera: FileCamera] = {
frameBox: FrameBox _ NEW[FrameBoxObj _ [[0,0], [0,0], TRUE]];
fileCamera _ NEW[FileCameraObj _ [name, origin, focusPoint, slant, resolution, focalLength, frameBox, clippingPlanes, visibleAssemblies]];
};

CameraFromFileCamera: PUBLIC PROC [fileCamera: FileCamera, worldCS: CoordSystem, screenCS: CoordSystem, style: DrawStyle] RETURNS [camera: Camera] = {
colorFilm: BOOL _ TRUE;
abort: BOOL _ FALSE;
coordSys: CoordSystem _ CoordSys.CreateCoordSys[name: fileCamera.name, mat: Matrix3d.Identity[], withRespectTo: worldCS]; -- to start with
camera _ NEW[CameraObj _ [fileCamera.name, coordSys, screenCS, fileCamera.resolution, fileCamera.focalLength, fileCamera.frame, fileCamera.clippingPlanes, fileCamera.visibleAssemblies, style, colorFilm, fast, abort]];
CSGGraphics.PlaceCamera[camera, fileCamera.focusPoint, fileCamera.origin, fileCamera.slant];
};

InitialCameraList: PUBLIC PROC [] RETURNS [cameras: FileCameraList] = {
top, bottom, left, right, front, upLeft, upRight: FileCamera;
defaultFocalLength: REAL = 1800;
defaultResolution: REAL _ 72.0;
hither: Plane _ SVPolygon3d.PlaneFromPointAndNormal[[0,0,0], [0,0,1]];
sAList: LIST OF Rope.ROPE _ LIST["sceneAssembly"];


top _ CreateFileCamera[name: "Top", origin: [0,1800,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
bottom _ CreateFileCamera[name: "Bottom", origin: [0,-1800,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
left _ CreateFileCamera[name: "Left", origin: [-1800,0,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
right _ CreateFileCamera[name: "Right", origin: [1800,0,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
front _ CreateFileCamera[name: "Front", origin: [0,0,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
upLeft _ CreateFileCamera[name: "UpLeft", origin: [-600,1200,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
upRight _ CreateFileCamera[name: "UpRight", origin: [600,1200,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
cameras _ LIST[top, bottom, left, right, front, upLeft, upRight];
};

NameAlreadyPresent: PUBLIC SAFE SIGNAL = CODE;

AddMasterObjectToScene: PUBLIC PROC [mo: MasterObject, scene: Scene] = {
IF ObjectNameIsPresent[mo.name, scene] THEN SIGNAL NameAlreadyPresent;
scene.masterObjects _
AppendToMasterObjects[mo, scene.masterObjects];
};

AddLightSourceToScene: PUBLIC PROC [ls: LightSource, scene: Scene] = {
IF LightSourceNameIsPresent[ls.name, scene] THEN SIGNAL NameAlreadyPresent;
scene.lightSources _ AppendToLightSourceList[ls, scene.lightSources];
};

AddCameraToScene: PUBLIC PROC [fileCamera: FileCamera, scene: Scene] = {
IF FileCameraNameIsPresent[fileCamera.name, scene] THEN SIGNAL NameAlreadyPresent;
scene.cameras _ AppendToFileCameraList[fileCamera, scene.cameras];
};

AddCameraOrderNameToScene: PUBLIC PROC [name: Rope.ROPE, scene: Scene] = {
IF CameraOrderNameIsPresent[name, scene] THEN SIGNAL NameAlreadyPresent;
scene.cameraOrder _ AppendToCameraOrderList[name, scene.cameraOrder];
};

AddCoordSysToScene: PUBLIC PROC [cs: CoordSystem, scene: Scene] = {
IF CoordSysNameIsPresent[cs.name, scene] THEN SIGNAL NameAlreadyPresent;
scene.coordSystems _ AppendToCoordSystems[cs, scene.coordSystems];
};

AddAssemblyToScene: PUBLIC PROC [assembly: Assembly, scene: Scene, mat: Matrix4by4] = {
cs: CoordSystem _ CoordSys.CreateCoordSys[assembly.name, mat, scene.assembly.coordSys];
AddCoordSysToScene[cs, scene];
assembly.coordSys _ cs;
scene.assembly.object _ AppendToAssemblyList[assembly, NARROW[scene.assembly.object]];
};

AddSubassemblyToAssembly: PUBLIC PROC [subassembly: Assembly, assembly: Assembly, scene: Scene, mat: Matrix4by4] = {
SELECT TRUE FROM
ISTYPE[assembly.object,AssemblyList] => { -- add to old AssemblyList
alist: AssemblyList _ NARROW[assembly.object];
cs: CoordSystem _ CoordSys.CreateCoordSys[subassembly.name, mat, assembly.coordSys];
AddCoordSysToScene[cs, scene];
subassembly.coordSys _ cs;
alist _ AppendToAssemblyList[subassembly, alist]};
ENDCASE => SIGNAL AttemptToAddSubassemblyToPrimitive;
};

AttemptToAddSubassemblyToPrimitive: PUBLIC SIGNAL = CODE;

AddSubassemblyToAssemblyWithCS: PUBLIC PROC [subassembly: Assembly, assembly: Assembly, scene: Scene, coordSys: CoordSystem] = {
SELECT TRUE FROM
ISTYPE[assembly.object,AssemblyList] => { -- add to old AssemblyList
alist: AssemblyList _ NARROW[assembly.object];
coordSys.withRespectTo _ assembly.coordSys;
   AddCoordSysToScene[coordSys, scene];
   subassembly.coordSys _ coordSys;
alist _ AppendToAssemblyList[subassembly, alist]};
ENDCASE => SIGNAL AttemptToAddSubassemblyToPrimitive;
};
AppendToDatabase: PROC [scene: Scene, database: Database] RETURNS [Database] = {
z: LIST OF Scene _ database.scenes;
IF z = NIL THEN {database.scenes _ CONS[scene,NIL]; RETURN[database]};
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[scene,NIL];
RETURN[database];
};

AppendToAssemblyList: PROC [assembly: Assembly, list: AssemblyList] RETURNS [AssemblyList] = {
z: LIST OF Assembly _ list.list;
IF z = NIL THEN {list.list _ CONS[assembly, NIL]; RETURN[list]};
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[assembly,NIL];
RETURN[list];
};

AppendToLightSourceList: PROC [ls: LightSource, list: LightSourceList] RETURNS [LightSourceList] = {
z: LightSourceList _ list;
IF z = NIL THEN RETURN[CONS[ls,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[ls,NIL];
RETURN[list];
};

AppendToFileCameraList: PROC [fileCamera: FileCamera, list: FileCameraList] RETURNS [FileCameraList] = {
z: FileCameraList _ list;
IF z = NIL THEN RETURN[CONS[fileCamera,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[fileCamera,NIL];
RETURN[list];
};

AppendToCameraOrderList: PROC [name: Rope.ROPE, list: LIST OF Rope.ROPE] RETURNS [LIST OF Rope.ROPE] = {
z: LIST OF Rope.ROPE _ list;
IF z = NIL THEN RETURN[CONS[name,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[name,NIL];
RETURN[list];
};

AppendToCoordSystems: PROC [cs: CoordSystem, list: CoordSysList]  RETURNS [CoordSysList] = {
z: CoordSysList _ list;
IF z = NIL THEN RETURN[CONS[cs,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[cs,NIL];
RETURN[list];
};

AppendToMasterObjects: PUBLIC PROC [mo: MasterObject, list: MasterObjectList] RETURNS [MasterObjectList] = {
z: MasterObjectList _ list;
IF z = NIL THEN RETURN[CONS[mo,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[mo,NIL];
RETURN[list];
};

AppendClassToList: PROC [moc: MasterObjectClass, list: MasterObjectClassList] RETURNS [MasterObjectClassList] = {
z: MasterObjectClassList _ list;
IF z = NIL THEN RETURN[CONS[moc,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[moc,NIL];
RETURN[list];
};

RenameAssembly: PUBLIC PROC [assem: Assembly, newName: Rope.ROPE, scene: Scene] = {
assem.name _ newName;
assem.coordSys.name _ newName;
};

CopyAssemblyAndSons: PUBLIC PROC [assembly: Assembly, scene: Scene, prefix: Rope.ROPE] RETURNS [copy: Assembly] = {
moFound: BOOL;
IF NewNamesAlreadyPresent[assembly, scene, prefix] THEN SIGNAL NameAlreadyPresent;
WITH assembly.object SELECT FROM
alist: AssemblyList => {-- assembly is a composite assembly.
copy _ CreateClusterAssembly[Rope.Concat[prefix, assembly.name], alist.pointSetOp];
copy.coordSys _ CoordSys.CreateCoordSys[name: copy.name, mat: Matrix3d.Identity[], withRespectTo: NIL];
CopySubassemblies[copy, alist, scene, prefix];
};
mo: MasterObject => { -- assembly is a primitive assembly
artworkCopy: Artwork _ SVArtwork.Copy[assembly.artwork];
[copy, moFound] _ CreatePrimitiveAssembly[Rope.Concat[prefix, assembly.name], mo.name, assembly.scalars, scene, artworkCopy, assembly.isTool];
IF NOT moFound THEN ERROR;-- for some reason the master object which assembly refers to is not registered in the scene (report this to SolidviewsSupport).
copy.coordSys _ CoordSys.CreateCoordSys[name: copy.name, mat: Matrix3d.Identity[], withRespectTo: NIL];
};
ENDCASE => ERROR;
}; -- end of CopyAssemblyAndSons

CopyAssemblyAndSonsUsingNewSceneMOs: PUBLIC PROC [assembly: Assembly, newScene: Scene] RETURNS [copy: Assembly] = {
moFound: BOOL;
IF AnyNamesAlreadyPresent[assembly, newScene] THEN SIGNAL NameAlreadyPresent;
WITH assembly.object SELECT FROM
alist: AssemblyList => {-- assembly is a composite assembly.
copy _ CreateClusterAssembly[assembly.name, alist.pointSetOp];
copy.coordSys _ CoordSys.CreateCoordSys[name: copy.name, mat: Matrix3d.Identity[], withRespectTo: NIL];
CopySubassembliesUsingNewMOs[copy, alist, newScene];
};
mo: MasterObject => { -- assembly is a primitive assembly
artworkCopy: Artwork _ SVArtwork.Copy[assembly.artwork];
[copy, moFound] _ CreatePrimitiveAssembly[assembly.name, mo.name, assembly.scalars, newScene, artworkCopy, assembly.isTool];
IF NOT moFound THEN ERROR;-- for some reason the master object which assembly refers to is not registered in the scene (report this to SolidviewsSupport).
copy.coordSys _ CoordSys.CreateCoordSys[name: copy.name, mat: Matrix3d.Identity[], withRespectTo: NIL];
};
ENDCASE => ERROR;
}; -- end of CopyAssemblyAndSonsUsingNewSceneMOs

CopySubassemblies: PRIVATE PROC [assembly: Assembly, alist: AssemblyList, scene: Scene, prefix: Rope.ROPE] = {
thisA: Assembly;
FOR list: LIST OF Assembly _ alist.list, list.rest UNTIL list = NIL DO
thisA _ CopyAssemblyAndSons[list.first, scene, prefix];
thisA.coordSys.mat _ list.first.coordSys.mat;
AddSubassemblyToAssemblyWithCS[thisA, assembly, scene, thisA.coordSys];
ENDLOOP;
};

CopySubassembliesUsingNewMOs: PRIVATE PROC [assembly: Assembly, alist: AssemblyList, newScene: Scene] = {
thisA: Assembly;
FOR list: LIST OF Assembly _ alist.list, list.rest UNTIL list = NIL DO
thisA _ CopyAssemblyAndSonsUsingNewSceneMOs[list.first, newScene];
thisA.coordSys.mat _ list.first.coordSys.mat;
AddSubassemblyToAssemblyWithCS[thisA, assembly, newScene, thisA.coordSys];
ENDLOOP;
};

MoveSubassembly: PUBLIC PROC [assem: Assembly, to: Assembly, scene: Scene] = {
assemWithSameName, parent: Assembly;
parentList: AssemblyList;
found: BOOL;
toCS: CoordSystem _ to.coordSys;
[assemWithSameName, parent] _ FindAssemblyFromName[assem.name, scene];
IF assemWithSameName # assem THEN ERROR;
IF NOT(ISTYPE [to.object, AssemblyList] OR to.object = NIL) THEN
SIGNAL AttemptToAddSubassemblyToPrimitive;
parentList _ NARROW[parent.object];
[parent.object, found] _ DisplayList3dPrivate.TemporaryRemoveFromAssemblyList[assem, parentList, scene];
IF NOT found THEN ERROR;-- it was found just a few lines ago.  What happened?
[] _ CoordSys.TPutAinTermsOfB[assem.coordSys, to.coordSys];
to.object _ AppendToAssemblyList[assem, NARROW[to.object]]
}; -- end of MoveSubassembly

MoveToFrontOfAssembly: PUBLIC PROC [subassembly: Assembly, assembly: Assembly, scene: Scene] = {
aList: AssemblyList _ NARROW[assembly.object];
success: BOOL _ FALSE;
FOR list: LIST OF Assembly _ aList.list, list.rest UNTIL list = NIL DO
IF list.first = subassembly THEN success_TRUE;
ENDLOOP;
IF NOT success THEN ERROR SubassemblyNotFound;
[aList, success] _ DisplayList3dPrivate.TemporaryRemoveFromAssemblyList[subassembly, aList, scene];
IF NOT success THEN ERROR SubassemblyNotFound;
aList.list _ CONS[subassembly, aList.list];
};
SubassemblyNotFound: PUBLIC ERROR = CODE;

AddMOsToScene: PRIVATE PROC [moList: MasterObjectList, scene: Scene] = {
FOR list: MasterObjectList _ moList, list.rest UNTIL list = NIL DO
scene.masterObjects _ AppendToMasterObjects[list.first, scene.masterObjects];
ENDLOOP;
};

CopyMOList: PRIVATE PROC [moList: MasterObjectList] RETURNS [copyList: MasterObjectList] = {
copyList _ NIL;
FOR list: MasterObjectList _ moList, list.rest UNTIL list = NIL DO
copyList _ AppendToMasterObjects[CopyMasterObject[list.first], copyList];
ENDLOOP;
};

MergeAssemblyIntoScene: PUBLIC PROC [newAssembly: Assembly, fromScene: Scene, parentAssembly: Assembly, toScene: Scene] RETURNS [copyAssembly: Assembly] = {
moList: MasterObjectList _ MasterObjectsOfAssembly[newAssembly, fromScene];
toMoList: MasterObjectList _ MasterObjectsOfScene[toScene];
neededList: MasterObjectList _ DisplayList3dPrivate.MoListMinusMoList[moList, toMoList];
neededList _ CopyMOList[neededList];
AddMOsToScene[neededList, toScene];
copyAssembly _ CopyAssemblyAndSonsUsingNewSceneMOs [assembly: newAssembly, newScene: toScene];
copyAssembly.coordSys.mat _ newAssembly.coordSys.mat;
SVDisplayListFiling.AddSubassemblyToAssemblyWithCS[copyAssembly,
parentAssembly, toScene, copyAssembly.coordSys];
};

MergeSceneIntoScene: PUBLIC PROC [fromScene: Scene, toScene: Scene] RETURNS [success: BOOL] = {
fromList: AssemblyList _ NARROW[fromScene.assembly.object];
fromScene.assembly.name _ Rope.Concat[fromScene.name, "SceneAssembly"];
IF AnyNamesAlreadyPresent[fromScene.assembly, toScene] THEN RETURN[FALSE];
AddCoordSystemsInAssemblyToScene[fromScene.assembly, toScene];
FOR list: LIST OF Assembly _ fromList.list, list.rest UNTIL list = NIL DO
AddSubassemblyToAssemblyWithCS [subassembly: list.first, assembly: toScene.assembly,
scene: toScene, coordSys: list.first.coordSys];
ENDLOOP;
};

AddCoordSystemsInAssemblyToScene: PRIVATE PROC [assembly: Assembly, scene: Scene] = {
WITH assembly.object SELECT FROM
alist: AssemblyList => {
AddCoordSysToScene[assembly.coordSys, scene];
AddCoordSystemsInAssemblyListToScene[alist, scene];
};
mo: MasterObject =>
AddCoordSysToScene[assembly.coordSys, scene];
ENDCASE => ERROR;
};

AddCoordSystemsInAssemblyListToScene: PRIVATE PROC [assemblyList: AssemblyList, scene: Scene] = {
FOR list: LIST OF Assembly _ assemblyList.list, list.rest UNTIL list = NIL DO
AddCoordSystemsInAssemblyToScene[list.first, scene];
ENDLOOP;
};

SetArtworkAssembly: PUBLIC PROC [assembly: Assembly, artwork: Artwork, scene: Scene] = {
 FOR list: LIST OF Assembly _ ListOfPrimAssemblies[assembly, scene], list.rest
 UNTIL list = NIL DO
 list.first.artwork _ artwork;
 ENDLOOP;
 };
FindSceneFromName: PUBLIC PROC [name: Rope.ROPE] RETURNS [scene: Scene] = {
l: LIST OF Scene _ globalDatabase.scenes;
IF l = NIL THEN ERROR DatabaseEmpty;
UNTIL l = NIL DO
IF Rope.Equal[l.first.name, name, FALSE] THEN BEGIN scene _ l.first; RETURN END;
l _ l.rest;
ENDLOOP;
SIGNAL SceneNotFound;
};
DatabaseEmpty: PUBLIC SIGNAL = CODE;
SceneNotFound: PUBLIC SIGNAL = CODE;

FindAssemblyFromName: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [assembly: Assembly, superAssembly: Assembly] = {
t: Assembly _ scene.assembly;
success: BOOL;
[assembly, superAssembly, success] _ FindAssemblyInTree[name, t, NIL];
IF success = FALSE THEN SIGNAL AssemblyNotFound;
};
AssemblyNotFound: PUBLIC SIGNAL = CODE;

AssemblyNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
dummy1, dummy2: Assembly;
isPresent: BOOL;
[dummy1, dummy2, isPresent] _ FindAssemblyInTree[name, scene.assembly, NIL];
RETURN[isPresent];
};

FindAssemblyInTree: PRIVATE PROC [name: Rope.ROPE, t: Assembly, super: Assembly] RETURNS [assembly: Assembly, superAssembly: Assembly, success: BOOL] = {
IF t = NIL THEN RETURN[NIL,NIL,FALSE];
IF Rope.Equal[t.name, name] THEN RETURN[t, super, TRUE];
WITH t.object SELECT FROM
as: AssemblyList => {
 FOR l: LIST OF Assembly _ as.list, l.rest UNTIL l = NIL DO
[assembly, superAssembly, success] _ FindAssemblyInTree[name, l.first, t];
IF success THEN RETURN;
 ENDLOOP;
 RETURN [NIL, NIL, FALSE];
 };
ENDCASE => -- t is a primitive assembly with the wrong name
RETURN[NIL,NIL,FALSE];
};

AnyNamesAlreadyPresent: PUBLIC PROC [assembly: Assembly, scene: Scene] RETURNS [BOOL] = {
IF AssemblyNameIsPresent[assembly.name, scene] THEN RETURN [TRUE];
WITH assembly.object SELECT FROM
mo: MasterObject => RETURN[FALSE];
aList: AssemblyList => RETURN[AnyNamesAlreadyPresentInList[aList, scene]];
ENDCASE => RETURN[FALSE];
};

AnyNamesAlreadyPresentInList: PRIVATE PROC [assemblyList: AssemblyList, scene: Scene] RETURNS [BOOL] = {
FOR list: LIST OF Assembly _ assemblyList.list, list.rest UNTIL list = NIL DO
IF AnyNamesAlreadyPresent[list.first, scene] THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
};

NewNamesAlreadyPresent: PUBLIC PROC [assembly: Assembly, scene: Scene, prefix: Rope.ROPE] RETURNS [BOOL] = {
newName: Rope.ROPE _ Rope.Concat[prefix, assembly.name];
IF AssemblyNameIsPresent[newName, scene] THEN RETURN [TRUE];
WITH assembly.object SELECT FROM
mo: MasterObject => RETURN[FALSE];
aList: AssemblyList => RETURN[NewNamesAlreadyPresentInList[aList, scene, prefix]];
ENDCASE => RETURN[FALSE];
};

NewNamesAlreadyPresentInList: PRIVATE PROC [assemblyList: AssemblyList, scene: Scene, prefix: Rope.ROPE] RETURNS [BOOL] = {
FOR list: LIST OF Assembly _ assemblyList.list, list.rest UNTIL list = NIL DO
IF NewNamesAlreadyPresent[list.first, scene, prefix] THEN RETURN [TRUE];
ENDLOOP;
RETURN [FALSE];
};

FindClassFromName: PUBLIC PROC [name: Rope.ROPE] RETURNS [moClass: MasterObjectClass, success: BOOL] = {
FOR moClassList: MasterObjectClassList _ globalClassList, moClassList.rest
UNTIL moClassList = NIL DO
IF Rope.Equal[moClassList.first.name, name, TRUE] THEN RETURN [moClassList.first, TRUE];
ENDLOOP;
RETURN[NIL, FALSE];
};

FindObjectFromName: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [object: MasterObject, success: BOOL] = {
FOR ol: MasterObjectList _ scene.masterObjects, ol.rest UNTIL ol = NIL DO
IF Rope.Equal[ol.first.name, name, TRUE] THEN RETURN [ol.first, TRUE];
ENDLOOP;
RETURN[NIL, FALSE];
};

ObjectNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
FOR ol: MasterObjectList _ scene.masterObjects, ol.rest UNTIL ol = NIL DO
IF Rope.Equal[ol.first.name, name, TRUE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE];
};

CoordSysNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
FOR cl: CoordSysList _ scene.coordSystems, cl.rest UNTIL cl = NIL DO
IF Rope.Equal[cl.first.name, name, TRUE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE];
};

FindLightFromName: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [light: LightSource, success: BOOL] = {
FOR list: LightSourceList _ scene.lightSources, list.rest UNTIL list = NIL DO
IF Rope.Equal[list.first.name, name, TRUE] THEN RETURN [list.first, TRUE];
ENDLOOP;
RETURN [NIL, FALSE];
};

LightSourceNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
FOR ll: LightSourceList _ scene.lightSources, ll.rest UNTIL ll = NIL DO
IF Rope.Equal[ll.first.name, name, TRUE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE];
};

FindFileCameraFromName: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [fileCamera: FileCamera, success: BOOL] = {
FOR list: FileCameraList _ scene.cameras, list.rest UNTIL list = NIL DO
IF Rope.Equal[list.first.name, name, TRUE] THEN RETURN [list.first, TRUE];
ENDLOOP;
RETURN [NIL, FALSE];
};

FileCameraNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
FOR list: FileCameraList _ scene.cameras, list.rest UNTIL list = NIL DO
IF Rope.Equal[list.first.name, name, TRUE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE];
};

CameraOrderNameIsPresent: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [BOOL] = {
FOR list: LIST OF Rope.ROPE _ scene.cameraOrder, list.rest UNTIL list = NIL DO
IF Rope.Equal[list.first, name, TRUE] THEN RETURN [TRUE];
ENDLOOP;
RETURN[FALSE];
};

UniqueNameFrom: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [unique: Rope.ROPE] = {
maxNum: NAT _ 0;
uniqueStream: IO.STREAM;
targetBase, base: Rope.ROPE;
targetNum, num: NAT;
[targetBase, targetNum] _ BaseAndNumber[name];
FOR ol: MasterObjectList _ scene.masterObjects, ol.rest UNTIL ol = NIL DO
[base, num] _ BaseAndNumber[ol.first.name];
IF Rope.Equal[base, targetBase, TRUE] THEN maxNum _ Max[num, maxNum];
ENDLOOP;
uniqueStream _ IO.CreateOutputStreamToRope[];
uniqueStream.PutF["%g.%g",[rope[targetBase]], [integer[maxNum+1]]];
unique _ IO.GetOutputStreamRope[uniqueStream];
};

Max: PRIVATE PROC [a, b: NAT] RETURNS [NAT] = {
RETURN[IF a > b THEN a ELSE b];
};

BaseAndNumber: PRIVATE PROC [name: Rope.ROPE] RETURNS [base: Rope.ROPE, number: NAT] = {
noNumber: BOOL _ FALSE;
nameStream: IO.STREAM;
next: CHAR;
nameStream _ IO.CreateInputStreamFromRope[name];
base _ ReadAlpha[nameStream];
next _ nameStream.GetChar[
!IO.EndOfStream => {noNumber _ TRUE; CONTINUE}];
IF noNumber THEN number _ 0 ELSE 
IF next = '. THEN number _ IO.GetInt[nameStream]
ELSE number _ 0;
};

ReadAlpha: PRIVATE PROC [s: IO.STREAM] RETURNS [base: Rope.ROPE] = {
base _ IO.GetToken[s, AlphaBreakProc];
};

AlphaBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
RETURN[IF char = '. THEN break ELSE other] 
};

FindMasterObjectAndNeighborsFromName: PUBLIC PROC [moName: Rope.ROPE, moList: MasterObjectList] RETURNS [beforeMo, mo, afterMo: MasterObjectList, found: BOOL] = {
lastL: MasterObjectList _ NIL;
l: MasterObjectList _ moList;
found _ TRUE;
IF l = NIL THEN RETURN[NIL, NIL, NIL, FALSE];
UNTIL l = NIL DO
IF Rope.Equal[l.first.name, moName] THEN {
beforeMo _ lastL; mo _ l; afterMo _ l.rest; RETURN};
lastL _ l;
l _ l.rest;
ENDLOOP;
RETURN[NIL, NIL, NIL, FALSE];
};

FindLightSourceAndNeighborsFromName: PUBLIC PROC [lsName: Rope.ROPE, lsList: LightSourceList] RETURNS [beforeLS, ls, afterLS: LightSourceList] = {
lastL: LightSourceList _ NIL;
l: LightSourceList _ lsList;
IF l = NIL THEN ERROR LightSourceNotFound;
UNTIL l = NIL DO
IF Rope.Equal[l.first.name, lsName] THEN {
beforeLS _ lastL; ls _ l; afterLS _ l.rest; RETURN};
lastL _ l;
l _ l.rest;
ENDLOOP;
SIGNAL LightSourceNotFound;
};

LightSourceNotFound: PUBLIC SIGNAL = CODE;

GetSceneGenerator: PUBLIC PROC RETURNS [g: SceneGenerator] = {
g _ NEW[SceneGeneratorObj _ [currentPtr: globalDatabase.scenes]];
};
SceneGenerator: TYPE = REF SceneGeneratorObj;
SceneGeneratorObj: TYPE = DisplayList3d.SceneGeneratorObj;
NextScene: PUBLIC PROC [g: SceneGenerator] RETURNS [scene: Scene] = {
IF g.currentPtr = NIL THEN RETURN[NIL];
scene _ g.currentPtr.first;
g.currentPtr _ g.currentPtr.rest;
};
GetCoordSysGenerator: PUBLIC PROC [scene: Scene] RETURNS [g: CoordSysGenerator] = {
g _ NEW[CoordSysGeneratorObj _ [currentPtr: scene.coordSystems]];
};
CoordSysGenerator: TYPE = REF CoordSysGeneratorObj;
CoordSysGeneratorObj: TYPE = DisplayList3d.CoordSysGeneratorObj;
NextCoordSys: PUBLIC PROC [g: CoordSysGenerator] RETURNS [cs: CoordSystem] = {
IF g.currentPtr = NIL THEN RETURN[NIL];
cs _ g.currentPtr.first;
g.currentPtr _ g.currentPtr.rest;
};
GetListOfAssembliesFromScene: PRIVATE PROC [scene: Scene] RETURNS [aList: LIST OF Assembly] = {
aList _ GetListOfAssembliesFromAssembly[scene.assembly];
};

GetListOfAssembliesFromAssembly: PRIVATE PROC [assem: Assembly] RETURNS [aList: LIST OF Assembly] = {
aList _ NIL;
WITH assem.object SELECT FROM
al: AssemblyList => aList _ CONS[assem, GetListOfAssembliesFromAssemblyList[al]];
ENDCASE => aList _ CONS[assem, NIL];
};

GetListOfAssembliesFromAssemblyList: PRIVATE PROC [al: AssemblyList] RETURNS [aList: LIST OF Assembly] = {
aList _ NIL;
FOR list: LIST OF Assembly _ al.list, list.rest UNTIL list = NIL DO
aList _ AppendDestructiveAssemblies[aList, GetListOfAssembliesFromAssembly[list.first]];
ENDLOOP;
};

AppendDestructiveAssemblies: PRIVATE PROC [list1, list2: LIST OF Assembly] RETURNS [LIST OF Assembly] = {
list: LIST OF Assembly;
IF list1 = NIL THEN RETURN [list2];
list _ list1;
UNTIL list.rest = NIL DO
list _ list.rest;
ENDLOOP;
list.rest _ list2;
RETURN[list1];
}; -- end of AppendDestructiveAssemblies


GetAssemblyGenerator: PUBLIC PROC [scene: Scene] RETURNS [g: AssemblyGenerator] = {
aList: LIST OF Assembly _ GetListOfAssembliesFromScene[scene];
g _ NEW[AssemblyGeneratorObj _ [currentPtr: aList]];
};

AssemblyGenerator: TYPE = REF AssemblyGeneratorObj;
AssemblyGeneratorObj: TYPE = DisplayList3d.AssemblyGeneratorObj;

NextAssembly: PUBLIC PROC [g: AssemblyGenerator] RETURNS [a: Assembly] = {
IF g.currentPtr = NIL THEN RETURN[NIL];
a _ g.currentPtr.first;
g.currentPtr _ g.currentPtr.rest;
};
GetLightSourceGenerator: PUBLIC PROC [scene: Scene] RETURNS [g: LightSourceGenerator] = {
g _ NEW[LightSourceGeneratorObj _ [currentPtr: scene.lightSources]];
};
LightSourceGenerator: TYPE = REF LightSourceGeneratorObj;
LightSourceGeneratorObj: TYPE = DisplayList3d.LightSourceGeneratorObj;
NextLight: PUBLIC PROC [g: LightSourceGenerator] RETURNS [ls: LightSource] = {
IF g.currentPtr = NIL THEN RETURN[NIL];
ls _ g.currentPtr.first;
g.currentPtr _ g.currentPtr.rest;
};
MasterObjectsOfScene: PUBLIC PROC [scene: Scene] RETURNS [l: MasterObjectList] = {
l _ scene.masterObjects;
};

MasterObjectsOfAssembly: PUBLIC PROC [assembly: Assembly, scene: Scene] RETURNS [l: MasterObjectList] = {
primList: LIST OF Assembly _ ListOfPrimAssemblies[assembly, scene];
thisMO: MasterObject;
l _ NIL;
FOR list: LIST OF Assembly _ primList, list.rest UNTIL list = NIL DO
thisMO _ NARROW[list.first.object];
l _ CONS[thisMO, l];
ENDLOOP;
l _ DisplayList3dPrivate.RemoveDuplicateMOs[l];
};
ListOfPrimAssemblies: PUBLIC PROC [assembly: Assembly, scene: Scene] RETURNS [primList: LIST OF Assembly] = {
IF assembly = NIL THEN RETURN[NIL];
WITH assembly.object SELECT FROM
aList: AssemblyList => primList _ ListOfPrimAssembliesFromAssemblyList[aList.list, scene];
mo: MasterObject => primList _ CONS[assembly, NIL];
ENDCASE => ERROR;
};

ListOfPrimAssembliesFromAssemblyList: PRIVATE PROC [aList: LIST OF Assembly, scene: Scene] RETURNS [primList: LIST OF Assembly] = {
thisList: LIST OF Assembly;
IF aList = NIL THEN RETURN[NIL];
thisList _ ListOfPrimAssemblies[aList.first, scene];
IF thisList = NIL THEN primList _ ListOfPrimAssembliesFromAssemblyList[aList.rest, scene]
ELSE primList _ AppendDestructiveAssemblies[thisList,
ListOfPrimAssembliesFromAssemblyList[aList.rest, scene]];
};
Init: PROC = {
globalDatabase _ NEW[DatabaseObj _ [scenes: NIL]];
};

Init[];

END.
ÎDisplayList3dImplA.mesa
Last edited by Bier on August 18, 1983 11:24 am
Author: Eric Bier in July, 1982
Don't add any more to this file.  It won't compile.

Used for version stamps and initial greeting.  Exported by DisplayList3dImpl.
Introduction
Contents: The Solidviews System is involved with the creation and manipulation of three dimensional scenes.  A scene is a list of lightsources, and a tree of assemblies.  Intermediate nodes in this tree are cluster assemblies.  The leaves of this tree are primitive assemblies.  Each cluster assembly specifies a point set operation describing how its children should be combined.  Each primitive assembly refers to a master object (a shape) and a triplet of scalars describing how this master object should be scaled before being displayed.  All assemblies (cluster or primitive) refer to a coordinate system which describes how the object should be positioned and oriented with respect to its parent coordinate system (from which we can derive how it will be positioned in the scene's master coordinate system known as WORLD).  Each master object is an instance of a class of shapes called a master object class.
Imported Types
DisplayList Types
Databases, Scenes, Assemblies, and Lightsources
Master Object Class Types
Master Object Types
Global Variables
Set Up the System
Create Entities
Creates scene and adds scene to database.  Includes default coordinate systems (WORLD, CAMERA, and SCENE), one default light source, five default master objects (cube, sphere, cone, cylinder, and torus) and seven default cameras (Top, Bottom, Left, Right, Front, UpLeft, and UpRight).

Creates scene and adds scene to database.
Adds the named object to the scene's master object list.
Calculate vector from position as follows: LightSources are positioned in WORLD coordinates.  Assume that objects will be placed near the origin of this coordinate system.  Hence the position is also the vector from the objects to the lightsource.
A conversion from the viewer-independent to the viewer-dependent type of camera.
An initial list of cameras provided with a new scene (or an old scene which was made before named file cameras were introduced).
topMat, bottomMat, leftMat, rightMat, frontMat, upLeftMat, upRightMat: Matrix4by4;
topMat _ Matrix3d.MatMult[Matrix3d.MakeRotateXMat[90], Matrix3d.MakeTranslateMat[0,0,1800]];
bottomMat _ Matrix3d.MatMult[Matrix3d.MakeRotateXMat[-90], Matrix3d.MakeTranslateMat[0,0,1800]];
leftMat _ Matrix3d.MatMult[Matrix3d.MakeRotateYMat[-90], Matrix3d.MakeTranslateMat[0,0,1800]];
rightMat _ Matrix3d.MatMult[Matrix3d.MakeRotateYMat[90], Matrix3d.MakeTranslateMat[0,0,1800]];
frontMat _ Matrix3d.MakeTranslateMat[0,0,1800];
upLeftMat _ Matrix3d.MatMult[Matrix3d.MakeRotateYMat[-20], Matrix3d.MakeTranslateMat[0,0,1800]];
upLeftMat _ Matrix3d.MatMult[Matrix3d.MakeRotateXMat[20], upLeftMat];
upRightMat _ Matrix3d.MatMult[Matrix3d.MakeRotateYMat[20], Matrix3d.MakeTranslateMat[0,0,1800]];
upRightMat _ Matrix3d.MatMult[Matrix3d.MakeRotateXMat[20], upRightMat];
Build the Scene Tree
The names of those cameras which should open automatically with the pic file is loaded are added to the scene in order.
Add assembly to the top level list of assemblies in the current scene
Automatically makes coordsys of subassembly refer to coordsys of super assembly.
List Append Auxiliaries For the Add Procedures
a copy of List.Nconc1 for LIST OF Scene instead of LIST OF REF ANY
A copy of List.Nconc1 for LIST OF Assembly instead of LIST OF REF ANY
A copy of List.Nconc1 for LightSourceList instead of LIST OF REF ANY
A copy of List.Nconc1 for CoordSysList instead of LIST OF REF ANY
A copy of List.Nconc1 for LIST OF Rope.ROPE instead of LIST OF REF ANY
A copy of List.Nconc1 for CoordSysList instead of LIST OF REF ANY
A copy of List.Nconc1 for MasterObjectList instead of LIST OF REF ANY
A copy of List.Nconc1 for MasterObjectClassList instead of LIST OF REF ANY
Restructure the Tree
Rename this assembly and its coordinate system.
CopyAssemblyAndSons returns an assembly which has a coordinate system whose mat and withRespectTo are null.  We must fill in the mat manually. AddSubassemblyToAssembly will fill in the withRespectTo automatically.
assembly.coordSys must exist at this point.
CopySubassembliesUsingNewMOs returns an assembly which has a coordinate system whose mat and withRespectTo are null.  We must fill in the mat manually. AddSubassemblyToAssembly will fill in the withRespectTo automatically.
assembly.coordSys must exist at this point.
Find assem's parent.  Remove links from parent to assem.  Create links from 'to' to assem.  Likewise, assem's coordsys must now refer to the new parent's coordsys.  Alter assem's coordinate system matrix so its doesn't actually move at all.
Remove links from parent to assembly.
Remove links from assem's coordsys to parent by pointing to new parent's CS.  And update assem's coordsys's matrix so it doesn't actually move.
Create link from 'to' to assem.
Moves subassembly to the first position of assembly's assemblylist.
Make sure "subassembly" is a subassembly of "assembly".
We assume that none of the mo's in moList is already in scene
Makes a list of all of the masterobjects needed.  Compares this list to the list of masterobjects available in the new scene, subtracting any that are available.  Copies those that are still needed and adds them to the new scene.  Makes a copy of the newAssembly tree (without changing names) but refering to master objects in the new scene.  Wires up the new assembly to its parent.
Takes all of the assemblies from fromScene which are directly under sceneAssembly and adds them to the sceneAssembly of toScene.  Makes sure that all assemblies in fromScene have names unique in toScene first.  This currently destroys fromScene.
Find Scene Entities from their Names
Finds the named assembly and its immediate superior. superAssembly is NIL if assembly is top level.
Finds any digits on the end of the name.  Looks through the scene extracting a digit and base name from each name.  Finds the maximum number, adds one, reconcatenates and returns.
returns found = FALSE if that is the case.
Signals LightSourceNotFound if that is the case.
Get Generators of Scene Entities
Scene Generator
CoordSystem Generator
Assembly Generator
A pretty dumb generator.  Walks the tree, makes the whole list and then feeds it to you one item at a time.
LightSource Generator
MasterObject Generator
Get a list of the leaves of the tree and extract a master object from each.  Remove duplicates.
List of Primitive Assemblies
Initialization
Create a database.
�Ê+[–

"Cedar" style˜Ihead1–

"Cedar" styleš
œ™Iproc–

"Cedar" styleš
œ/™/Lš
œ™L™3™–

"Cedar" styleš
Ïk	˜	L–

"Cedar" styleš
œ	˜	L–

"Cedar" styleš�œ
˜L–

"Cedar" style˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš�œ
˜L–

"Cedar" styleš
œ	˜	L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ
˜
L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜L–

"Cedar" styleš
œ˜—L–

"Cedar" style˜–

"Cedar" stylešœ�˜L–

"Cedar" styleš�œL�œ=˜’
L–

"Cedar" styleš�œ;˜B—L–

"Cedar" style˜š
�˜L˜šœ
�œ�œ6˜SIbodyš
œM™M——š
œ™M–

"Cedar" stylešœdÐbiœžœž
œ'žÏi
ž
œž	Ÿ
ž
œ%žœVž
œ¡
žœ�žœ
™’——š
œ™Jšœ	�œ�œ˜Jšœ�œ˜(Jšœ�œ�œ˜Jšœ�œ˜(Jšœ�œ�œ˜-Jšœ�œ�œ˜0Jšœ�œ˜"Jšœ�œ˜+Jšœ
�œ˜)Jšœ
�œ�œ
˜$Jšœ	�œ�œ˜Jšœ�œ�œ˜"Jšœ�œ˜(Jšœ
�œ�œ
˜!Jšœ
�œ˜,Jšœ�œ˜'Jšœ�œ˜ Jšœ	�œ˜Jšœ	�œ˜!Jšœ�œ�œÏc$˜FJšœ�œ˜"Jšœ�œ�œ˜#Jšœ�œ�œ˜&Jšœ�œ�œ˜Jšœ�œ�œ˜Jšœ�œ˜!—š
œ™Ihead2š
œ/™/Jšœ
�œ�œ
˜!Jšœ
�œ˜.J˜Jšœ�œ�œ
˜Jšœ
�œ˜(J˜Jšœ
�œ�œ
˜!Jšœ
�œ˜.Jšœ�œ�œ˜)Jšœ�œ!˜6J˜Jšœ
�œ�œ˜'Jšœ�œ˜.Jšœ�œ˜0J˜Jšœ�œ�œ˜%Jšœ�œ˜2Jšœ�œ ˜4Nš
œ™Jšœ�œ�œ˜3Jšœ�œ&˜@Jšœ�œ'˜BJ˜Jšœ
�œ˜.Jšœ�œ˜,Nš
œ™Jšœ�œ�œ˜)Jšœ�œ!˜6Jšœ�œ"˜8J˜Jšœ
�œ�œ
˜$Jšœ�œ�œ˜4Jšœ�œ!˜6Jšœ�œ ˜4Jšœ�œ˜0Jšœ�œ!˜6Jšœ�œ)˜Fšœ�œ'˜BJšœ�œ�œ˜+Jšœ�œ"˜8Jšœ�œ#˜:—Jšœ�œ'˜BJšœ�œ"˜8—š
œ™Jš
œ˜Jšœ)�œ
˜-Jšœ!�œ
˜%Kš
œ™šÏnœ�œ
�œ˜(JšÏbœ�œ
˜Jš¢œ
˜Jš¢œ˜Jš¢œ˜Jš¢œ˜%Jš¢	œ˜Jš¢
œ˜Jš¢œ˜Jš¢œ˜Jš¢	œ˜#Jš¢œ˜Jš¢œ˜ Jš¢œ˜—Jš�œ!˜(Jšœ
�œ¥
˜²
Jš
œ>˜>Jš
œ˜J˜Jš¡œ�œ
�œ˜8Jš
œ7˜7Jš
œ˜—š
œ™š
¡œ�œ
�œ
�œ�œ˜EM–

"Cedar" styleš
œœ™œM–

"Cedar" style™Jš
œ9˜9Jš
œI˜IJš
œ˜Jš
œH˜HJš
œ^˜^Jš
œe˜eJš
œd˜dJš
œ<˜<J˜šœ�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ�œ˜+JšœH 1˜yJš
œ˜Jš
œ˜Jšœ
�œ
˜Jš
œ%˜%Jšœ	�œ
˜Jšœ�œ˜—Jš
œ_˜_Jš
œ9˜9Jš
œ*˜*Jš
œ9˜9Jš
œ˜J˜—š
¡œ�œ
�œ
�œ�œ˜JJš
œ)™)šœ�œ˜#Jšœ	�œ
˜
Jšœ�œ�œ
˜%Jšœ�œ
˜Jšœ
�œ
˜Jšœ	�œ
˜
Jšœ
�œ
˜Jš
œ%˜%Jšœ	�œ
˜Jšœ�œ˜—Jš
œ9˜9Jš
œ˜J˜—š¡œ�œ
�œ˜!Jš¢œ�œ
˜Jš¢œ˜Jš¢œ�œ
�œ
˜Jš¢œ�œ
�œ
˜Jš¢	œ�œ
�œ
˜š¢œ�œ
�œ�œ˜4Jš
œ8™8—Jšœ�œ˜Jš
œ;˜;Jš
œ˜J˜—š¡œ�œ
�œ�œ˜QJšœ�œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜J˜—Jš¡œ�œ
�œ
�œ�œ1�œ
�œ�œ
˜“
š�œ)�œ˜9Jš
œ˜Jšœ�œ
˜Jš
œF˜FJš�œ
�œ�œ
�œ
˜%Jš�œ�œ
�œ
˜JšœK 
˜XJšœ�œ&�œ,�œ)˜�
Jš
œ˜J˜—š¡œ�œ
�œ
�œ*�œ�œ�œ˜‹
Jšœ] ˜ešœ�œ˜Jšœ�œ%˜?Jšœ	�œ�œ*�œ˜T—Jš
œ˜J˜—š
¡œ�œ
�œ
�œ#�œ˜oJš
œ÷
™÷
Jš
œ˜Jšœ�œ+˜3Jš
œ˜—š¡œ�œ
�œ
�œ/�œ�œ�œ�œ
�œ�œ
�œ�œ�œ˜ñ
Jšœ�œ�œ˜=Lšœ
�œz˜Š
J˜—š¡œ�œ
�œY�œ˜–
J™PJšœ�œ�œ
˜Jšœ�œ�œ
˜Jšœz ˜Š
Jšœ	�œÍ
˜Ù
Jš
œ\˜\J˜—š¡œ�œ
�œ�œ˜GJ™€
J™RJš
œ=˜=Jšœ�œ˜ Jšœ�œ˜Jš
œF˜FJš	œ�œ
�œ�œ�œ˜2J˜Jš
œ\™\Jš
œ`™`Jš
œ^™^Jš
œ^™^Jš
œ/™/Jš
œ`™`Jš
œE™EJš
œ`™`Jš
œG™GJ˜Jšœ§
�œ%˜Ð
Jšœ®
�œ%˜×
Jšœª
�œ%˜Ó
Jšœ«
�œ%˜Ô
Jšœ«
�œ%˜Ô
Jšœ³
�œ%˜Ü
Jšœ´
�œ%˜Ý
Jšœ
�œ3˜AJ˜——š
œ™Jš	œ�œ
�œ
�œ�œ
˜.J˜š¡œ�œ
�œ%˜HJš�œ%�œ
�œ˜FJš
œ˜Jš
œ/˜/Jš
œ˜J˜—š¡œ�œ
�œ$˜FJš�œ*�œ
�œ˜KJš
œE˜EJš
œ˜—š¡œ�œ+˜HJš�œ1�œ
�œ˜RJš
œB˜BJš
œ˜J˜—–

"Cedar" styleš¡œ�œ
�œ˜JJ–

"Cedar" styleš
œw™wJ–

"Cedar" styleš�œ'�œ
�œ˜HJš
œE˜EJš
œ˜—š¡œ�œ
�œ$˜CJš�œ'�œ
�œ˜HJš
œB˜BJš
œ˜J˜—š¡œ�œ
�œ8˜WJš
œE™EJš
œW˜WJš
œ˜Jš
œ˜Jšœ7�œ˜VJš
œ˜J˜—š¡œ�œ
�œO˜tš�œ
�œ
�˜š�œ$ ˜DJšœ�œ˜.Jš
œT˜TJš
œ˜—Jš
œ˜Jš
œ2˜2—Jš�œ�œ$˜5Jš
œ˜J˜—Jš¢"œ�œ
�œ�œ
˜9J˜š¡œ�œ
�œU˜€
Jš
œP™PJš�œ
�œ
�˜š�œ$ ˜DJšœ�œ˜.Jš
œ+˜+—Jš
œ'˜'š
œ#˜#Jš
œ2˜2—Jš�œ�œ$˜5Jš
œ˜——š
œ.™.Jš¡œ�œ$�œ˜PJš
œB™BJšœ�œ
�œ˜#Jš�œ�œ
�œ�œ�œ�œ˜Fš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜—Jš�œ˜Jš
œ˜J˜š¡œ�œ*�œ˜^Jš
œE™EJšœ�œ
�œ˜ Jš�œ�œ
�œ�œ�œ�œ˜@Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ
�œ˜Jš�œ˜
Jš
œ˜—J˜š¡œ�œ*�œ˜dJš
œD™DJš
œ˜Jš�œ�œ
�œ
�œ
�œ�œ˜%Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜—J˜š¡œ�œ0�œ˜hJš
œA™AJš
œ˜Jš�œ�œ
�œ
�œ
�œ�œ˜-Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜—š¡œ�œ
�œ�œ
�œ�œ�œ�œ
�œ�œ˜hJš
œF™FJšœ�œ
�œ�œ˜Jš�œ�œ
�œ
�œ
�œ�œ˜'Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜—š¡œ�œ(�œ˜\Jš
œA™AJš
œ˜Jš�œ�œ
�œ
�œ
�œ�œ˜%Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜—J˜š¡œ�œ,�œ˜lJš
œE™EJš
œ˜Jš�œ�œ
�œ
�œ
�œ�œ˜%Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜—J˜š¡œ�œ7�œ˜qJš
œJ™JJš
œ ˜ Jš�œ�œ
�œ
�œ
�œ�œ˜&Jš�œ
�œ
�œ
�œ
˜*Jšœ	�œ�œ˜Jš�œ˜
Jš
œ˜——š
œ™J˜š¡œ�œ
�œ!�œ˜SJš
œ/™/Jš
œ˜Jš
œ˜Jš
œ˜—J˜š
¡œ�œ
�œ1�œ�œ˜sJšœ	�œ
˜Jš�œ1�œ
�œ˜RJš�œ�œ
�˜ šœ $˜<Jš
œS˜SJšœb�œ˜gJš
œ.˜.Jš
œ˜—šœ #˜9Jš
œ8˜8Jš
œŽ
˜Ž
Jš	�œ
�œ	�œ
�œ
 €
˜š
Jšœb�œ˜gJš
œ˜—Jš�œ�œ
˜Jšœ ˜ —J˜š¡#œ�œ
�œ'�œ˜sJšœ	�œ
˜Jš�œ,�œ
�œ˜MJš�œ�œ
�˜ šœ $˜<Jš
œ>˜>Jšœb�œ˜gJš
œ4˜4Jš
œ˜—šœ #˜9Jš
œ8˜8Jš
œ|˜|Jš	�œ
�œ	�œ
�œ
 €
˜š
Jšœb�œ˜gJš
œ˜—Jš�œ�œ
˜Jšœ -˜0J˜—š¡œ�œ
�œF�œ˜nJš
œ˜š�œ�œ
�œ"�œ�œ
�˜Fš
œ7˜7Jš
œÕ
™Õ
Jš
œ+™+—Jš
œ-˜-Jš
œG˜G—Jš�œ
˜Jš
œ˜J˜—š¡œ�œ
�œ?˜iJš
œ˜š�œ�œ
�œ"�œ�œ
�˜Fš
œB˜BJš
œÞ
™Þ
Jš
œ+™+—Jš
œ-˜-Jš
œJ˜J—Jš�œ
˜Jš
œ˜J˜—š¡œ�œ
�œ2˜NJš
œð
™ð
Jš
œ$˜$Jš
œ˜Jšœ�œ
˜Jš
œ ˜ Jš
œF˜FJš�œ�œ
�œ
˜(Jš�œ
�œ
�œ�œ
�œ�˜@š�œ$˜*Jš
œ%™%—Jšœ
�œ˜#Jš
œh˜hš	�œ
�œ�œ
�œ
 5˜MJš
œ�
™�
—š
œ;˜;Jš
œ™—Jšœ(�œ˜:Jšœ ˜J˜—š¡œ�œ
�œ>˜`Jš
œC™CJš
œ7™7Jšœ�œ˜.Jšœ	�œ�œ
˜š�œ�œ
�œ"�œ�œ
�˜FJš�œ�œ	�œ
˜.—Jš�œ
˜Jš�œ
�œ	�œ
�œ˜.Jš
œc˜cJš�œ
�œ	�œ
�œ˜.Jšœ
�œ˜+Jš
œ˜Jš¢œ�œ
�œ�œ
˜)J˜—š¡
œ�œ
�œ-˜HJ™=š�œ,�œ�œ
�˜BJš
œM˜M—Jš�œ
˜J˜J˜—š¡
œ�œ
�œ�œ!˜\Jšœ�œ
˜š�œ,�œ�œ
�˜BJš
œI˜I—Jš�œ
˜J˜J˜—š¡œ�œ
�œU�œ˜œ
J™ÿJš
œK˜KJš
œ;˜;Jš
œX˜XJš
œ$˜$Jš
œ#˜#Jš
œ^˜^Jš
œ5˜5Jš
œ@˜@Jš
œ0˜0J˜J˜—š
¡œ�œ
�œ$�œ�œ˜_Jš
ϛ
™õ
Jšœ�œ˜;Jš
œG˜GJš�œ5�œ
�œ
�œ˜JJš
œ>˜>š�œ�œ
�œ%�œ�œ
�˜IJš
œT˜TJš
œ/˜/—Jš�œ
˜Jš
œ˜J˜—š¡ œ�œ
�œ'˜Uš�œ�œ
�˜ š
œ˜Jš
œ-˜-Jš
œ3˜3Jš
œ˜—š
œ˜Jš
œ-˜-—Jš�œ�œ
˜—Jš
œ˜—J˜š¡$œ�œ
�œ/˜aš�œ�œ
�œ)�œ�œ
�˜MJš
œ4˜4—Jš�œ
˜Jš
œ˜—J˜š¡œ�œ
�œ9˜XJšœ
�œ�œ
�œ<˜Nšœ
�œ�œ
�˜Jš
œ˜—Jšœ
�œ
˜	Jš
œ˜——š
œ$™$š
¡œ�œ
�œ
�œ�œ˜KJšœ�œ
�œ˜)Jš�œ�œ
�œ
�œ˜$š�œ�œ
�˜Jš�œ �œ�œ
�œ�œ
�œ
˜PJš
œ˜—Jš�œ
˜Jš�œ˜Jš
œ˜Jš¢
œ�œ
�œ�œ
˜$Jš¢
œ�œ
�œ�œ
˜$J˜—š
¡œ�œ
�œ
�œ�œ2˜{Jš
œc™cJš
œ˜Jšœ	�œ
˜JšœA�œ˜FJš�œ�œ
�œ
�œ˜0Jš
œ˜Jš¢œ�œ
�œ�œ
˜'J˜—š¡œ�œ
�œ
�œ�œ�œ˜UJš
œ˜Jšœ�œ
˜JšœG�œ˜LJš�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ �œ8�œ˜™
Jš�œ�œ
�œ
�œ
�œ
�œ
�œ˜&Jš�œ�œ
�œ�œ˜8Jš�œ
�œ
�˜Jš
œ˜šœ
�œ�œ
�œ�œ�œ
�˜;Jš
œJ˜JJš�œ	�œ
�œ
˜—Jšœ
�œ
˜	Jš	œ
�œ�œ�œ�œ˜Jš
œ˜Jš�œ 0˜;Jš�œ
�œ
�œ
�œ˜Jš
œ˜—J˜š
¡œ�œ
�œ$�œ�œ˜YJš�œ-�œ
�œ�œ˜Bš�œ�œ
�˜ Jšœ�œ
�œ˜"Jšœ�œ-˜JJš�œ�œ
�œ˜—Jš
œ˜—J˜š
¡œ�œ
�œ,�œ�œ˜hš�œ�œ
�œ)�œ�œ
�˜MJš�œ+�œ
�œ�œ˜@—Jš�œ
˜Jš�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ1�œ�œ�œ˜lJšœ�œ&˜8Jš�œ'�œ
�œ�œ˜<š�œ�œ
�˜ Jšœ�œ
�œ˜"Jšœ�œ5˜RJš�œ�œ
�œ˜—Jš
œ˜—J˜š¡œ�œ
�œ9�œ�œ�œ˜{š�œ�œ
�œ)�œ�œ
�˜MJš�œ3�œ
�œ�œ˜H—Jš�œ
˜Jš�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ'�œ˜hš�œG˜JJš�œ�œ
�˜Jš
�œ*�œ�œ
�œ�œ˜X—Jš�œ
˜Jš�œ
�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ!�œ˜qš�œ5�œ�œ
�˜IJš
�œ!�œ�œ
�œ�œ˜F—Jš�œ
˜Jš�œ
�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ�œ˜Sš�œ5�œ�œ
�˜IJš
�œ!�œ�œ
�œ�œ˜<—Jš�œ
˜Jš�œ
�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ�œ˜Uš�œ0�œ�œ
�˜DJš
�œ!�œ�œ
�œ�œ˜<—Jš�œ
˜Jš�œ
�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ�œ˜nš�œ7�œ�œ
�˜MJš
�œ#�œ�œ
�œ�œ˜J—Jš�œ
˜Jš�œ�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ�œ˜XJš�œ3�œ�œ
�˜GJš
�œ!�œ�œ
�œ�œ˜<Jš�œ
˜Jš�œ
�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ#�œ˜wš�œ1�œ�œ
�˜GJš
�œ#�œ�œ
�œ�œ˜J—Jš�œ
˜Jš�œ�œ�œ˜Jš
œ˜—J˜š¡œ�œ
�œ
�œ�œ�œ˜Wš�œ1�œ�œ
�˜GJš
�œ#�œ�œ
�œ�œ˜>—Jš�œ
˜Jš�œ
�œ˜Jš
œ˜J˜—š¡œ�œ
�œ
�œ�œ�œ˜Xš
�œ�œ
�œ�œ �œ�œ
�˜NJš
�œ�œ�œ
�œ�œ˜9—Jš�œ
˜Jš�œ
�œ˜Jš
œ˜—š¡œ�œ
�œ
�œ�œ�œ˜[Jš
œ³
™³
Jšœ�œ˜Jšœ�œ
�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ.˜.š�œ5�œ�œ
�˜IJš
œ+˜+Jš�œ�œ�œ˜E—Jš�œ
˜Jšœ�œ˜-Jš
œC˜CJšœ	�œ#˜.Jš
œ˜—J˜š¡œ�œ
�œ�œ�œ�œ˜/Jš�œ
�œ�œ�œ˜Jš
œ˜—J˜š¡
œ�œ
�œ
�œ�œ
�œ
�œ˜XJšœ
�œ�œ
˜Jšœ�œ
�œ
˜Jšœ�œ
˜Jšœ
�œ!˜0Jš
œ˜š
œ˜Jšœ
�œ�œ�œ˜0—Jš�œ
�œ�œ
˜!Jš�œ�œ
�œ˜0Jš�œ˜Jš
œ˜—J˜š¡	œ�œ
�œ�œ
�œ�œ
�œ˜DJšœ�œ˜&Jš
œ˜—J˜š¡œ�œ
�œ�œ�œ�œ�œ˜IJš�œ
�œ�œ�œ˜+Jš
œ˜—J˜š¡$œ�œ
�œ�œ�œ2�œ˜¢
Jš
œ*™*Jšœ�œ
˜Jš
œ˜Jšœ�œ
˜
Jš�œ�œ
�œ
�œ
�œ�œ�œ�œ˜-š�œ�œ
�˜Jš�œ"�œ˜*Jšœ,�œ˜4Jš
œ
˜
Jš
œ˜—Jš�œ
˜Jš
�œ
�œ�œ�œ�œ˜Jš
œ˜—J˜š
¡#œ�œ
�œ�œ�œ-˜’
Jš
œ0™0Jšœ�œ
˜Jš
œ˜Jš�œ�œ
�œ
�œ˜*š�œ�œ
�˜Jš�œ"�œ˜*Jšœ,�œ˜4Jš
œ
˜
Jš
œ˜—Jš�œ
˜Jš�œ˜Jš
œ˜—J˜Jšœ�
œ�œ
˜*J˜—š
œ ™ Nš
œ™š¡œ�œ
�œ
�œ˜>Jšœ�œ:˜AJš
œ˜—Jšœ�œ�œ˜-Jšœ�œ#˜:š¡	œ�œ
�œ�œ˜EJš
�œ�œ
�œ
�œ
�œ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Nš
œ™š¡œ�œ
�œ�œ˜SJšœ�œ:˜AJš
œ˜—Jšœ�œ�œ˜3Jšœ�œ&˜@š¡œ�œ
�œ�œ˜NJš
�œ�œ
�œ
�œ
�œ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Nš
œ™š¡œ�œ
�œ�œ	�œ
�œ˜_Jš
œ8˜8Jš
œ˜—J˜š¡œ�œ
�œ�œ	�œ
�œ˜eJšœ�œ
˜š�œ�œ
�˜Jšœ�œ1˜QJš�œ�œ�œ˜$—Jš
œ˜—J˜š¡#œ�œ
�œ�œ	�œ
�œ˜jJšœ�œ
˜š�œ�œ
�œ�œ�œ
�˜CJš
œX˜X—Jš�œ
˜Jš
œ˜—J˜š¡œ�œ
�œ�œ
�œ�œ�œ
�œ˜iJšœ�œ
�œ
˜Jš�œ	�œ
�œ
�œ	˜#Jš
œ
˜
š�œ
�œ
�˜Jš
œ˜—Jš�œ
˜Jš
œ˜Jš�œ˜Jšœ %˜(—J˜J˜š¡œ�œ
�œ�œ˜SJš
œk™kJšœ�œ
�œ0˜>Jšœ�œ-˜4Jš
œ˜—J˜Jšœ�œ�œ˜3Jšœ�œ&˜@J˜š¡œ�œ
�œ�œ˜JJš
�œ�œ
�œ
�œ
�œ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Nš
œ™š¡œ�œ
�œ�œ˜YJšœ�œ=˜DJš
œ˜—Jšœ�œ�œ˜9Jšœ�œ)˜Fš¡	œ�œ
�œ�œ˜NJš
�œ�œ
�œ
�œ
�œ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Nš
œ™š¡œ�œ
�œ�œ˜RJš
œ˜Jš
œ˜J˜—š¡œ�œ
�œ$�œ˜iJ™_Jšœ
�œ
�œ2˜CJš
œ˜Jšœ�œ
˜š�œ�œ
�œ �œ�œ
�˜DJšœ	�œ˜#Jšœ�œ˜—Jš�œ
˜Jš
œ/˜/Jš
œ˜—Nš
œ™š¡œ�œ
�œ$�œ�œ
�œ˜mJš
�œ�œ
�œ
�œ
�œ˜#š�œ�œ
�˜ Jš
œZ˜ZJšœ�œ�œ˜3Jš�œ�œ
˜—Jš
œ˜—J˜š¡$œ�œ
�œ	�œ
�œ�œ�œ
�œ˜ƒ
Jšœ
�œ
�œ
˜Jš
�œ	�œ
�œ
�œ
�œ˜ Jš
œ4˜4Jš�œ�œ
�œC˜YJš�œ1˜5Jš
œ9˜9Jš
œ˜——š
œ™Jš¡œ�œ˜š
œ™Jšœ�œ�œ˜2Jš
œ˜—J˜Jš
œ˜J˜Jš�œ
˜——…—…œÊÅ