DIRECTORY
CoordSys,
CSGGraphics,
DisplayList3d,
DisplayList3dPrivate,
GraphicsColor,
IO,
Matrix3d,
Rope,
SV2d,
SV3d,
SVArtwork,
SVError,
SVModelTypes,
SVPolygon3d,
SVSceneTypes,
SVRayTypes,
SVToolObject;

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

BEGIN

versionRope: PUBLIC Rope.ROPE _ "Solidviews Version 5.3 OF June 12, 1985 10:17:19 am PDT";
Artwork: TYPE = SVModelTypes.Artwork;
Camera: TYPE = CSGGraphics.Camera;
Classification: TYPE = SVRayTypes.Classification;
Color: TYPE = GraphicsColor.Color;
CoordSysList: TYPE = SVModelTypes.CoordSysList;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CSGTree: TYPE = SVRayTypes.CSGTree;
DrawStyle: TYPE = SVModelTypes.DrawStyle;
FrameBox: TYPE = REF FrameBoxObj;
FrameBoxObj: TYPE = SVModelTypes.FrameBoxObj;
Matrix4by4: TYPE = SV3d.Matrix4by4;
Plane: TYPE = SV3d.Plane;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
PointSetOp: TYPE = SVRayTypes.PointSetOp;-- {union, intersection, difference}
Poly3d: TYPE = SV3d.Poly3d;
Primitive: TYPE = SVRayTypes.Primitive;
Projection: TYPE = SVModelTypes.Projection;
Ray: TYPE = SVRayTypes.Ray;
Shape: TYPE = REF ShapeObj;
ShapeObj: TYPE = SVSceneTypes.ShapeObj; -- allocated in CreateAndAddPrimitiveAssembly, etc.
Vector: TYPE = SV3d.Vector;
Database: TYPE = REF DatabaseObj;
DatabaseObj: TYPE = SVSceneTypes.DatabaseObj;

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

Assembly: TYPE = REF AssemblyObj;
AssemblyObj: TYPE = SVSceneTypes.AssemblyObj;
ToolData: TYPE = REF ToolDataObj;
ToolDataObj: TYPE = SVSceneTypes.ToolDataObj;
FrameBlock: TYPE = REF FrameBlockObj;
FrameBlockObj: TYPE = SVSceneTypes.FrameBlockObj;
AssemblyList: TYPE = REF AssemblyListObj;
AssemblyListObj: TYPE = SVSceneTypes.AssemblyListObj;

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

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

FileoutProc: TYPE = SVSceneTypes.FileoutProc;
FileinProc: TYPE = SVSceneTypes.FileinProc;
FileoutPolyProc: TYPE = SVSceneTypes.FileoutPolyProc;
MasterObject: TYPE = REF MasterObjectRec;
MasterObjectRec: TYPE = SVSceneTypes.MasterObjectRec;
MasterObjectList: TYPE = SVSceneTypes.MasterObjectList;

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

RegisterMasterObject: PUBLIC PROC [mo: MasterObject] = {
globalMOList _ AppendToMasterObjects[mo, globalMOList];
};
CreateScene: PUBLIC PROC [name: Rope.ROPE] RETURNS [scene: Scene] = {
worldCS: CoordSystem _ CoordSys.CreateRoot["WORLD"];
sceneAssemblyCS: CoordSystem;
sceneAssembly: Assembly;
ambientLight: LightSource _ CreateAmbientLightSource["Ambient", GraphicsColor.RGBToColor[0.2,0.2,0.2]];
defaultWhiteLight: LightSource _ CreateLightSource["WhiteLight",[800,800,1000],GraphicsColor.white];
cameras: FileCameraList _ DisplayList3d.InitialCameraList[];

sceneAssemblyCS _ CoordSys.CreateCoordSysInTree["sceneAssembly", Matrix3d.Identity[], worldCS, worldCS];
sceneAssembly _ CreateSceneAssembly["sceneAssembly", union, sceneAssemblyCS, FALSE, NIL];
scene _ NEW[SceneObj _ [
name: name,
coordSysRoot: worldCS,
lightSources: CONS[ambientLight, 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]];
globalDatabase _ AppendToDatabase[scene, globalDatabase];
};

CreateEmptyScene: PUBLIC PROC [name: Rope.ROPE] RETURNS [scene: Scene] = {
scene _ NEW[SceneObj _ [name: name,
coordSysRoot: 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;
};

NameWithSuffix: PROC [oldName: Rope.ROPE, suffix: Rope.ROPE, root: CoordSystem] RETURNS [probablyUnique: Rope.ROPE] = {
base: Rope.ROPE;
num: NAT;
[base, num] _ CoordSys.BaseAndNumber[oldName];
probablyUnique _ IO.PutFR["%g%g.%g", [rope[base]], [rope[suffix]], [integer[num]]];
};

CreateAndAddPrimitiveAssembly: PUBLIC PROC [name: Rope.ROPE, object: Rope.ROPE, size: Vector, scene: Scene, parent: Assembly, mat: Matrix4by4, artwork: Artwork _ NIL, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Assembly, masterObjectFound: BOOL, success: BOOL] = {
masterObject: MasterObject;
toolMasterObject: MasterObject;
shape: Shape;
toolName: Rope.ROPE;
scalarName: Rope.ROPE;

success _ FALSE;
IF AssemblyNameIsPresent[name, scene] THEN {
SVError.Append[Rope.Cat["Assembly ", name, " already present."], TRUE, TRUE];
SVError.Blink[];
RETURN[NIL, TRUE, FALSE];
};
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
[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
shape _ NEW[ShapeObj];
shape.mo _ masterObject;
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, showAs: normal, isTool: isTool, toolMasterObject: toolMasterObject, shape: shape]];
IF ISTYPE[parent.shape, AssemblyList] THEN { -- add to old AssemblyList
alist: AssemblyList _ NARROW[parent.shape];
cs: CoordSystem;
scalarCS: CoordSystem;
cs _ CoordSys.CreateCoordSysInTree[assembly.name, mat, parent.coordSys, scene.coordSysRoot
!CoordSys.NameAlreadyExists => ERROR];
assembly.coordSys _ cs;
scalarName _ NameWithSuffix[assembly.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ CoordSys.CreateScalarsOnlyCoordSysInTree[scalarName, size, cs, scene.coordSysRoot
!CoordSys.NameAlreadyExists => ERROR];
shape.coordSys _ scalarCS;
parent.shape _ AppendToAssemblyList[assembly, alist];
success _ TRUE;
}
ELSE {
SVError.Append["Attempt to add subassembly to primitive.", TRUE, TRUE];
SVError.Blink[];
RETURN[NIL, TRUE, FALSE];
};
};

ConnectAssemblyToParent: PUBLIC PROC [assembly: Assembly, parent: Assembly] = {
IF IsComposite[parent] THEN { -- add to old AssemblyList
alist: AssemblyList _ NARROW[parent.shape];
parent.shape _ AppendToAssemblyList[assembly, alist];
}
ELSE SIGNAL AttemptToAddSubassemblyToPrimitive;
};

CreatePrimitiveAtExistingCoordSys: PUBLIC PROC [name: Rope.ROPE, object: Rope.ROPE, size: Vector, scene: Scene, coordSys: CoordSystem, artwork: Artwork _ NIL, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Assembly, masterObjectFound: BOOL] = {
masterObject: MasterObject;
toolMasterObject: MasterObject;
shape: Shape;
scalarCS: CoordSystem;
toolName, scalarName: Rope.ROPE;

IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
[masterObject, masterObjectFound] _ FindObjectFromName[object, scene];
IF NOT masterObjectFound THEN {
SVError.Append[Rope.Cat["Couldn't add assembly ", name, ". Master object ", object, " not found."], TRUE, TRUE];
SVError.Blink[];
};
IF artwork = NIL THEN artwork _
SVArtwork.CreateColorArtwork[GraphicsColor.RGBToColor[.6,.6,.8], plastic]; -- light blue
shape _ NEW[ShapeObj];
shape.mo _ masterObject;
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, showAs: normal, isTool: isTool, toolMasterObject: toolMasterObject, shape: shape]];
assembly.coordSys _ coordSys;
scalarName _ NameWithSuffix[assembly.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ CoordSys.CreateScalarsOnlyCoordSysInTree[scalarName, size, coordSys, scene.coordSysRoot];
shape.coordSys _ scalarCS;
};

CreateAndAddClusterAssembly: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp _ union, scene: Scene, parent: Assembly, mat: Matrix4by4, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Assembly, success: BOOL] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[GraphicsColor.IntensityToColor[1], plastic]; -- white
toolMasterObject: MasterObject;
toolName: Rope.ROPE;

success _ FALSE;
IF AssemblyNameIsPresent[name, scene] THEN {
SVError.Append[Rope.Cat["Composite name ", name, " is already registered.  Try another."], TRUE, TRUE];
SVError.Blink[];
RETURN[NIL, FALSE];
};
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, showAs: normal, isTool: isTool,
 toolMasterObject: toolMasterObject, shape: NEW[AssemblyListObj _ [NIL, pointSetOp]] ]];
IF IsComposite[parent] THEN{ -- add to old AssemblyList
alist: AssemblyList _ NARROW[parent.shape];
cs: CoordSystem _ CoordSys.CreateCoordSysInTree[assembly.name, mat, parent.coordSys, scene.coordSysRoot];
assembly.coordSys _ cs;
parent.shape _ AppendToAssemblyList[assembly, alist];
}
ELSE {
SVError.Append["Attempt to add subassembly to primitive.", TRUE, TRUE];
SVError.Blink[];
RETURN[NIL, FALSE];
};
};

CreateSceneAssembly: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp, coordSys: CoordSystem, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Assembly] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[GraphicsColor.IntensityToColor[1], plastic]; -- white
toolMasterObject: MasterObject;
toolName, base: Rope.ROPE;
num: NAT;

IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
[base, num] _ CoordSys.BaseAndNumber[name];
IF num > 0 THEN toolName _ Rope.Cat[base, "$$tool.", IO.PutFR["%g", [integer[num]]]]
ELSE toolName _ Rope.Concat[base, "$$tool"];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, showAs: normal, isTool: isTool,
 toolMasterObject: toolMasterObject, shape: NEW[AssemblyListObj _ [NIL, pointSetOp]] ]];
assembly.coordSys _ coordSys;
};


CreateClusterAssemblyAtExistingCoordSys: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp, scene: Scene, coordSys: CoordSystem, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Assembly] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[GraphicsColor.IntensityToColor[1], plastic]; -- white
toolMasterObject: MasterObject;
toolName: Rope.ROPE;
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
assembly _ NEW[AssemblyObj _
[name: name, coordSys: NIL, artwork: artwork, showAs: normal,
 shape: NEW[AssemblyListObj _ [NIL, pointSetOp] ], isTool: isTool, toolMasterObject: toolMasterObject]];
assembly.coordSys _ coordSys;
};


AttemptToAddSubassemblyToPrimitive: PUBLIC SIGNAL = CODE;

CreateToolData: PUBLIC PROC [loX, hiX, loY, hiY, loZ, hiZ: REAL, plane: NAT, infinite: BOOL _ FALSE, clientData: REF ANY _ NIL] RETURNS [toolData: ToolData] = {
block: FrameBlock _ NEW[FrameBlockObj _ [loX, hiX, loY, hiY, loZ, hiZ]];
toolData _ NEW[ToolDataObj _ [block, infinite, plane, clientData]];
};
CreateAmbientLightSource: PUBLIC PROC [name: Rope.ROPE, color: Color] RETURNS [ls: LightSource] = {
ls _ NEW[LightSourceObj _ [name, [0,0,0], color, ambient]];
};

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

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

CreateCamera: PUBLIC PROC [worldCS: CoordSystem, screenCS: CoordSystem] RETURNS [camera: Camera] =  {
cameraName: Rope.ROPE _ CoordSys.UniqueNameFrom["Camera", worldCS];
coordSys: CoordSystem _ CoordSys.CreateCoordSysInTree[name: cameraName, mat: Matrix3d.Identity[], parent: worldCS, root: worldCS]; -- to start with
resolution: REAL _ 72.0;
focalLength: REAL _ 1800.0;
projection: Projection _ perspective;
frame: FrameBox _ NIL;
clippingPlanes: LIST OF Plane _ NIL;
visibleAssemblies: LIST OF Rope.ROPE _ NIL;
style: DrawStyle _ wire;
colorFilm: BOOL _ TRUE;
useBoundBoxes: BOOL _ TRUE;
useBoundSpheresForShadows: BOOL _ TRUE;

camera _ CSGGraphics.CreateCamera["NoPlace", coordSys, screenCS, resolution, focalLength, projection, frame, clippingPlanes, visibleAssemblies, style, colorFilm, useBoundBoxes, useBoundSpheresForShadows];
};

StuffCameraFromFileCamera: PUBLIC PROC [camera: Camera, fileCamera: FileCamera, style: DrawStyle] = {
camera.viewName _ fileCamera.name;
camera.resolution _ fileCamera.resolution;
camera.focalLength _ fileCamera.focalLength;
camera.projection _ fileCamera.projection;
camera.frame _ fileCamera.frame;
camera.clippingPlanes _ fileCamera.clippingPlanes;
camera.visibleAssemblies _ fileCamera.visibleAssemblies;
camera.style _ style;
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;
frame: FrameBox _ NEW[FrameBoxObj _ [[0,0], [0,0], TRUE]];
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, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
bottom _ CreateFileCamera[name: "Bottom", origin: [0,-1800,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
left _ CreateFileCamera[name: "Left", origin: [-1800,0,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
right _ CreateFileCamera[name: "Right", origin: [1800,0,0], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
front _ CreateFileCamera[name: "Front", origin: [0,0,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
upLeft _ CreateFileCamera[name: "UpLeft", origin: [-600,1200,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, clippingPlanes: LIST[hither], visibleAssemblies: sAList];
upRight _ CreateFileCamera[name: "UpRight", origin: [600,1200,1800], focusPoint: [0,0,0], slant: 0, resolution: defaultResolution, focalLength: defaultFocalLength, projection: perspective, frame: frame, 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];
};

AddOrResizeToolToAssembly: PUBLIC PROC [assembly: Assembly, scene: Scene] = {
toolMasterObject: MasterObject;
toolData: SVToolObject.ToolData;
toolName: Rope.ROPE;
IF assembly.toolMasterObject = NIL THEN {
toolData _ DisplayList3d.CreateToolData[-100, 100, -100, 100, -100, 100, 3, FALSE];
toolName _ NameWithSuffix[assembly.name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
assembly.toolMasterObject _ toolMasterObject;
};
toolData _ NARROW[assembly.toolMasterObject.mainBody];
SVToolObject.SizeToFit[toolData, assembly];
};
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];
};

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;
};

IsComposite: PROC [assem: Assembly] RETURNS [BOOL] = {
RETURN[ISTYPE [assem.shape, AssemblyList] OR assem.shape = NIL];
};

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 IsComposite[to] THEN SIGNAL AttemptToAddSubassemblyToPrimitive;
parentList _ NARROW[parent.shape];
[parent.shape, found] _ DisplayList3dPrivate.TemporaryRemoveFromAssemblyList[assem, parentList, scene];
IF NOT found THEN ERROR;-- it was found just a few lines ago.  What happened?
[] _ CoordSys.PutAInTermsOfB[assem.coordSys, to.coordSys];
to.shape _ AppendToAssemblyList[assem, NARROW[to.shape]]
}; -- end of MoveSubassembly

MoveToFrontOfAssembly: PUBLIC PROC [subassembly: Assembly, assembly: Assembly, scene: Scene] = {
aList: AssemblyList _ NARROW[assembly.shape];
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;

MergeAssemblyIntoScene: PUBLIC PROC [originalAssembly: Assembly, fromScene: Scene, parentAssembly: Assembly, toScene: Scene] RETURNS [copyAssembly: Assembly] = {
copyAssembly _ DisplayList3d.CopyAssemblyAndSonsUniqueNames [assembly: originalAssembly, oldScene: fromScene, newScene: toScene, parent: parentAssembly];
};

MergeSceneIntoScene: PUBLIC PROC [fromScene: Scene, toScene: Scene] RETURNS [success: BOOL] = {
fromList: AssemblyList _ NARROW[fromScene.assembly.shape];
toSceneAssembly: Assembly _ toScene.assembly;
FOR list: LIST OF Assembly _ fromList.list, list.rest UNTIL list = NIL DO
[] _ MergeAssemblyIntoScene[list.first, fromScene, toSceneAssembly, toScene];
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.shape 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.shape SELECT FROM
shape: Shape => 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];
};


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] = {
RETURN[CoordSys.CoordSysNameIsPresent[name, scene.coordSysRoot]];
};

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];
};

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



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, TRUE] 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: CoordSys.MakeListFromTree[scene.coordSysRoot]]];
};
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.shape 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;
thisShape: Shape;
l _ NIL;
FOR list: LIST OF Assembly _ primList, list.rest UNTIL list = NIL DO
thisShape _ NARROW[list.first.shape];
thisMO _ thisShape.mo;
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.shape SELECT FROM
aList: AssemblyList => primList _ ListOfPrimAssembliesFromAssemblyList[aList.list, scene];
shape: Shape => 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 May 23, 1985 11:08:50 pm PDT
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Author: Eric Bier in July, 1982
Don't add any more to this file.  It won't compile.

Version Rope
Used for version stamps and initial greeting.  Exported to DisplayList3d.
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).

defaultRedLight: LightSource _ CreateLightSource["RedLight",[200,200,400], GraphicsColor.red];
defaultGreenLight: LightSource _ CreateLightSource["GreenLight",[-200,200,400], GraphicsColor.green];
Creates scene and adds scene to database.
Used in place of CoordSys.UniqueNameWithSuffix, which takes too long.  We just split up oldName into its base and number and splice in the suffix.  We assume that if oldName is unique, probablyUnique will be as well.

We will wire up the shape to a scalars coordinate frame below.
Now wire up the assembly to its parent.
We will wire up the shape to a scalars coordinate frame below.
Now wire up the assembly to its parent.
Now wire up the assembly to its parent.
plane = 1, 2, 3 corresponds to the x=0, y=0, and z=0 planes respectively.  plane = 4 means all three of them. ToolDatas are needed by CreatePrimitiveAssembly and CreateClusterAssembly above if the assembly is to be a tool.

Must be done whenever a new scene is to be viewed (including whenever a solidviewer is created.  Adding the camera to the scene tree is probably one of the first acts after creating a new coordinate system tree.
A conversion from the viewer-independent to the viewer-dependent type of camera.  Must be done whenever camera name (Front, Top, etc) or changes (and thus whenever the scene changes).
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.
This is just a default size.  It is resized below.
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 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.
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".
Copies over any master objects which toScene will need to support newAssembly. Makes a copy of the newAssembly tree, adding suffix numbers to make the names unique 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.
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;
};
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.
UniqueAssemblyNameFrom: PUBLIC PROC [name: Rope.ROPE, scene: Scene] RETURNS [unique: Rope.ROPE] = {
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.
maxNum: NAT _ 0;
targetBase, base: Rope.ROPE;
g: AssemblyGenerator _ GetAssemblyGenerator[scene];
targetNum, num: NAT;

[targetBase, targetNum] _ BaseAndNumber[name];
FOR assem: Assembly _ NextAssembly[g], NextAssembly[g] UNTIL assem = NIL DO
[base, num] _ BaseAndNumber[assem.name];
IF Rope.Equal[base, targetBase, TRUE] THEN maxNum _ MAX[num, maxNum];
ENDLOOP;
unique _ IO.PutFR["%g.%g",[rope[targetBase]], [integer[maxNum+1]]];
};
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˜Ihead–

"Cedar" styleš
œ™Iproc–

"Cedar" styleš
œ3™3Jšœ
Ïm
œ1™<Lš
œ™L™3L™–

"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š
œ˜L–

"Cedar" styleš
œ
˜
L–

"Cedar" style˜—–

"Cedar" stylešœž˜L–

"Cedar" stylešžœLžœ?˜”
L–

"Cedar" stylešžœ&˜-—L–

"Cedar" style˜š
ž˜
head1™L˜šœ
žœžœ=˜ZIbodyš
œI™I——š
œ™N–

"Cedar" stylešœdÐbiœŸœŸ
œ'ŸÏi
Ÿ
œŸ	 
Ÿ
œ%ŸœVŸ
œ¡
Ÿœ�Ÿœ
™’——š
œ™Jšœ	žœ˜%Jšœžœ˜"Jšœžœ˜1Jšœžœ˜"Jšœžœ˜/Jšœ
žœ˜-Jšœ	žœ˜#Jšœžœ˜)Jšœ
žœžœ
˜!Jšœ
žœ˜-Jšœžœ˜#Jšœžœ˜Jšœ	žœ˜Jšœ	žœ˜JšœžœÏc$˜MJšœžœ˜Jšœžœ˜'Jšœžœ˜+Jšœžœ˜Jšœžœžœ
˜Jšœ
žœ¡3˜[Jšœžœ˜—š
œ™Ihead2š
œ/™/Jšœ
žœžœ
˜!Jšœ
žœ˜-J˜Jšœžœžœ
˜Jšœ
žœ˜'J˜Jšœ
žœžœ
˜!Jšœ
žœ˜-Jšœ
žœžœ
˜!Jšœ
žœ˜-Jšœžœžœ˜%Jšœžœ˜1Jšœžœžœ˜)Jšœžœ ˜5J˜Jšœ
žœžœ˜'Jšœžœ˜3Jšœžœ ˜5J˜Jšœžœžœ˜%Jšœžœ˜1Jšœžœ˜3Oš
œ™Jšœžœžœ˜3Jšœžœ%˜?Jšœžœ&˜AJ˜Jšœ
žœ˜-Jšœžœ˜+Jšœžœ ˜5Oš
œ™Jšœžœžœ˜)Jšœžœ ˜5Jšœžœ!˜7J˜Jšœ
žœ˜+Jšœžœ"˜;Jšœžœ)˜IJšœžœ ˜5Jšœžœ˜3Jšœžœ˜/Jšœžœ ˜5Jšœžœ(˜Ešœžœ&˜AJšœžœžœ˜+Jšœžœ!˜7Jšœžœ"˜9—Jšœžœ&˜AJšœžœ!˜7Jšœžœ#˜;—š
œ™Jš
œ˜Jšœ)žœ
˜-Jšœ!žœ
˜%Mš
œ™šÏnœžœ
žœ˜(JšÏbœžœ
˜Jš£œ
˜Jš£œ˜Jš£œ˜Jš£œ˜Jš£œ˜%Jš£œ˜3Jš£	œ˜Jš£
œ˜Jš£œ˜Jš£œ˜Jš£	œ˜#Jš£œ˜Jš£œ˜ Jš£œ˜Jš£œ˜#—šžœ!˜(Jšœ
žœÚ
˜ç
Jš
œ>˜>Jš
œ˜—J˜š¢œžœ
žœ˜8Jš
œ7˜7Jš
œ˜——š
œ™š
¢œžœ
žœ
žœžœ˜EN–

"Cedar" styleš
œœ™œN–

"Cedar" style™Jš
œ4˜4Jš
œ˜Jš
œ˜Jš
œ^™^Jš
œe™eJš
œg˜gJš
œd˜dJš
œ<˜<J˜Jš
œh˜hJšœMžœžœ˜Yšœžœ
˜Jš
œ˜Jš
œ˜Jšœžœžœžœ˜?JšœH¡1˜yJš
œ˜Jš
œ˜Jšœ
žœ
˜Jš
œ%˜%Jšœ	žœ
˜Jšœžœ˜—Jš
œ9˜9Jš
œ˜J˜—š
¢œžœ
žœ
žœžœ˜JJš
œ)™)šœžœ˜#Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœ
žœ
˜Jšœ	žœ
˜
Jšœ
žœ
˜Jš
œ%˜%Jšœ	žœ
˜Jšœžœ˜—Jš
œ9˜9Jš
œ˜J˜—š¢œžœ
žœ˜!Jš£œžœ
˜Jš£œ˜Jš£œžœ
žœ
˜Jš£œžœ
žœ
˜Jš£	œžœ
žœ
˜Jš£œžœ
žœžœ˜4šœžœ˜Jš
œ;˜;—Jš
œ˜J˜—š¢œžœ
žœžœ˜QJšœžœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜J˜—š¢œžœžœžœžœžœ˜wJš
ϯ
™Ø
Jšœžœ
˜Jšœžœ
˜	Jš
œ.˜.Jšœžœ@˜SJ˜—J˜š¢œžœ
žœ
žœžœTžœ
žœžœžœžœ)žœžœ˜ŸJš
œ˜Jš
œ˜J˜
Jšœžœ
˜Jšœžœ
˜J˜Jšœ
žœ
˜šžœ$žœ˜,JšœAžœžœ˜MJš
œ˜Jšžœ
žœžœžœ˜J˜—Jšžœžœ
žœž˜-šžœ˜Jšœ£œ%˜>Jš
œI˜IJ˜—Jš
œF˜FJšžœ
žœžœ
žœ
˜%šžœžœ
žœ
˜JšœK¡
˜X—Jšœžœ˜š
œ˜J™J™>—šœÐbk£œžœg˜ž
J™'—šžœ
žœžœ¡˜GJšœžœ˜+Jš
œ˜Jš
œ˜šœ£œ8˜ZJšœžœ˜&—Jš
œ˜Jš
œL˜Lšœ£œ)˜\Jšœžœ˜&—Jš
œ˜Jš
œ5˜5Jšœ
žœ
˜J˜
—šžœ˜Lšœ;žœžœ˜GLš
œ˜Jšžœ
žœžœžœ˜J˜—Jš
œ˜J˜—–

"Cedar" styleš¢œžœ
žœ+˜Ošžœžœ¡˜8Jšœžœ˜+Jš
œ5˜5J˜
—Jšžœ
žœ$˜/J˜J–

"Cedar" style˜—–

"Cedar" styleš¢!œžœ
žœ
žœžœHžœ
žœžœžœžœ)žœ˜ˆJš
œ˜Jš
œ˜J˜
Jš
œ˜Jšœžœ
˜ J˜Jšžœžœ
žœž˜-šžœ˜Jš
œ>˜>Jš
œI˜IJ˜—Jš
œF˜Fšžœ
žœžœ˜Jšœdžœžœ˜pJš
œ˜J˜—šžœžœ
žœ
˜JšœK¡
˜X—Jšœžœ˜š
œ˜J™>—šœ¤£œžœg˜ž
J™'—Jš
œ˜Jš
œL˜LJšœ£œ1˜dJš
œ˜Jš
œ˜J˜—š¢œžœ
žœ
žœ[žœžœžœžœžœ˜ë
Jšœ]¡˜eJš
œ˜Jšœžœ
˜J˜Jš
œ˜šžœ$žœ˜,Jšœ[žœžœ˜gJš
œ˜Jšžœ
žœžœ˜Jš
œ˜—Jšžœžœ
žœž˜-šžœ˜Jš
œ>˜>Jš
œI˜IJ˜—šœ¤£œ˜Jšœžœ3˜MJšœ,žœžœ˜XJš
£'™'—šžœžœ¡˜7Jšœžœ˜+Jš
œi˜iJš
œ˜Jš
œ5˜5J˜
—šžœ˜Jšœ;žœžœ˜GJš
œ˜Jšžœ
žœžœ˜J˜—Jš
œ˜J˜—–

"Cedar" styleš¢œžœ
žœ
žœ9žœžœžœžœ˜²
Jšœ]¡˜eJš
œ˜Jšœžœ
˜J˜	J˜Jšžœžœ
žœž˜-šžœ˜Jš
œ+˜+Jš
œT˜TJš
œ,˜,Jš
œI˜IJ˜—šœžœ˜Jšœžœ3˜MJšœ,žœžœ˜X—Jš
œ˜Jš
œ˜J–

"Cedar" style˜—J–

"Cedar" style˜–

"Cedar" styleš¢'œžœ
žœ
žœGžœžœžœžœ˜Ô
Jšœ]¡˜eJš
œ˜Jšœžœ
˜Jšžœžœ
žœž˜-šžœ˜Jš
œ>˜>Jš
œI˜IJ˜—šœžœ˜Jšœžœ#˜=JšœžœžœF˜hJš
œ˜—Jš
œ˜J–

"Cedar" style˜J˜—Jš£"œžœ
žœžœ
˜9J˜š¢œžœ
žœ žœ	žœžœžœžœ
žœžœžœ˜ 
Jš
œÞ
™Þ
Jšœžœ1˜HJšœžœ5˜CJ˜J™—š
¢œžœ
žœ
žœžœ˜cJšœžœ3˜;Jš
œ˜—š
¢œžœ
žœ
žœ#žœ˜oJšœžœ2˜:Jš
œ˜—š¢œžœ
žœ
žœ/žœžœžœ;žœ
žœžœ
žœžœžœ˜šLšœ
žœƒ
˜“
J˜—š¢œžœ
žœ/žœ˜eJ™Ó
Jšœžœ.˜CJšœƒ
¡˜“
Jšœžœ˜Jšœ
žœ
˜Jš
œ%˜%Jšœžœ
˜Jšœžœ
žœ	žœ
˜$Jš	œžœ
žœžœžœ
˜+Jš
œ˜Jšœžœžœ
˜Jšœžœžœ
˜Jšœžœžœ
˜'J˜Jš
œÌ
˜Ì
J˜J˜—š¢œžœ
žœ?˜eJ™·
Jš
œ"˜"Jš
œ*˜*Jš
œ,˜,Jš
œ*˜*Jš
œ ˜ Jš
œ2˜2Jš
œ8˜8Jš
œ˜Jš
œ\˜\J˜—š¢œžœ
žœžœ˜GJ™€
J™RJš
œ=˜=Jšœžœ˜ 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š
œ˜—–

"Cedar" styleš¢œžœ
žœ'˜MJ–

"Cedar" styleš
œ˜J–

"Cedar" styleš
œ ˜ J–

"Cedar" stylešœžœ
˜–

"Cedar" stylešžœžœ
žœ˜)šœLžœ˜SJ™2—Jš
œG˜GJšœ £œ˜IJš
œ-˜-L˜—J–

"Cedar" stylešœžœ%˜6J–

"Cedar" stylešœ
£	œ˜+J–

"Cedar" style˜——š
œ.™.š¢œžœ$žœ˜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š
œ˜—š¢œžœ
žœ,žœ˜lJš
œE™EJš
œ˜Jšžœžœ
žœ
žœ
žœžœ˜%Jšžœ
žœ
žœ
žœ
˜*Jšœ	žœžœ˜Jšžœ˜
Jš
œ˜—J˜š¢œžœ7žœ˜qJš
œJ™JJš
œ ˜ Jšžœžœ
žœ
žœ
žœžœ˜&Jšžœ
žœ
žœ
žœ
˜*Jšœ	žœžœ˜Jšžœ˜
Jš
œ˜——š
œ™J˜š¢œžœ
žœ!žœ˜SJš
œ/™/Jš
œ˜Jš
œ˜Jš
œ˜—J˜š¢œžœžœžœ˜6Jšžœ
žœžœžœ˜@J˜J˜—š¢œžœ
žœ2˜NJš
œð
™ð
Jš
œ$˜$Jš
œ˜Jšœžœ
˜Jš
œ ˜ Jš
œF˜FJšžœžœ
žœ
˜(šžœ
žœžœ$˜FJš
œ%™%—Jšœ
žœ˜"Jš
œg˜gš	žœ
žœžœ
žœ
¡5˜MJš
œ�
™�
—š
œ:˜:Jš
œ™—Jšœ'žœ˜8Jšœ¡˜J˜—š¢œžœ
žœ>˜`Jš
œC™CJš
œ7™7Jšœžœ˜-Jšœ	žœžœ
˜šžœžœ
žœ"žœžœ
ž˜FJšžœžœ	žœ
˜.—Jšžœ
˜Jšžœ
žœ	žœ
žœ˜.Jš
œc˜cJšžœ
žœ	žœ
žœ˜.Jšœ
žœ˜+Jš
œ˜Jš£œžœ
žœžœ
˜)J˜—š¢œžœ
žœZžœ˜¡
Jš
œÞ
™Þ
Jš
Ϫ
˜™
J˜J˜—š
¢œžœ
žœ$žœžœ˜_Jš
τ
™Ñ
Jšœžœ˜:Jš
œ-˜-šžœžœ
žœ%žœžœ
ž˜IJšœ£œ2˜M—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˜JJšžœ	žœ
žœ
˜—Jšœ
žœ
˜	Jš	œ
žœžœžœžœ˜Jš
œ˜—šžœ¡0˜;Jšžœ
žœ
žœ
žœ˜—Jš
œ˜—J˜š
¢œžœ
žœ$žœžœ˜YJšžœ-žœ
žœžœ˜BJšžœžœ
ž˜Jšœžœ
žœ˜Jšœžœ-˜JJšžœžœ
žœ˜Jš
œ˜—J˜š
¢œžœ
žœ,žœžœ˜hšžœžœ
žœ)žœžœ
ž˜MJšžœ+žœ
žœžœ˜@—Jšžœ
˜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˜š¢œžœ
žœ
žœžœžœ˜UJšžœ;˜AJ˜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š
œ˜—š¢œžœ
žœ
žœžœžœ˜aJš
œ³
™³
Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jš
œ7˜7šžœ5žœžœ
ž˜IJš
œ4˜4Jšžœžœžœ
žœ˜E—Jšžœ
˜Jšœ	žœ8˜CJš
œ˜J˜—–

"Cedar" styleš¢œžœ
žœ
žœžœžœ™cJš
œ³
™³
Jšœžœ™Jšœžœ
™Jš
œ3™3Jšœžœ
™J™Jš
œ.™.šžœ4žœ	žœ
ž™KJš
œ(™(Jšžœžœžœ
žœ™E—Jšžœ
™Jšœ	žœ8™CJš
œ™—J˜J˜š¢$œžœ
žœžœžœ2žœ˜¢
Jš
œ*™*Jšœžœ
˜Jš
œ˜Jšœžœ
˜
Jšžœžœ
žœ
žœ
žœžœžœžœ˜-šžœžœ
ž˜Jšžœ"žœžœ˜0Jšœ,žœ˜4Jš
œ
˜
Jš
œ˜—Jšžœ
˜Jš
žœ
žœžœžœžœ˜Jš
œ˜—J˜š
¢#œžœ
žœžœžœ-˜’
Jš
œ0™0Jšœžœ
˜Jš
œ˜Jšžœžœ
žœ
žœ˜*šžœžœ
ž˜Jšžœ"žœ˜*Jšœ,žœ˜4Jš
œ
˜
Jš
œ˜—Jšžœ
˜Jšžœ˜Jš
œ˜—J˜Jšœžœ
žœžœ
˜*J˜—š
œ ™ Oš
œ™š¢œžœ
žœ
žœ˜>Jšœžœ:˜AJš
œ˜—Jšœžœžœ˜-Jšœžœ#˜:š¢	œžœ
žœžœ˜EJš
žœžœ
žœ
žœ
žœ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Oš
œ™š¢œžœ
žœžœ˜SJšœžœU˜\Jš
œ˜—Jšœžœžœ˜3Jšœžœ&˜@š¢œžœ
žœžœ˜NJš
žœžœ
žœ
žœ
žœ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Oš
œ™š¢œžœ
žœžœ	žœ
žœ˜_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š
œ˜—Oš
œ™š¢œžœ
žœžœ˜YJšœžœ=˜DJš
œ˜—Jšœžœžœ˜9Jšœžœ)˜Fš¢	œžœ
žœžœ˜NJš
žœžœ
žœ
žœ
žœ˜'Jš
œ˜Jš
œ!˜!Jš
œ˜—Oš
œ™š¢œžœ
žœžœ˜RJš
œ˜Jš
œ˜J˜—š¢œžœ
žœ$žœ˜iJ™_Jšœ
žœ
žœ2˜CJš
œ˜Jš
œ˜Jšœžœ
˜šžœžœ
žœ žœžœ
ž˜DJšœžœ˜%Jš
œ˜Jšœžœ˜—Jšžœ
˜Jš
œ/˜/Jš
œ˜—Oš
œ™š¢œžœ
žœ$žœžœ
žœ˜mJš
žœžœ
žœ
žœ
žœ˜#šžœžœ
ž˜Jš
œZ˜ZJšœžœžœ˜/Jšžœžœ
˜—Jš
œ˜—J˜š¢$œžœ
žœ	žœ
žœžœžœ
žœ˜ƒ
Jšœ
žœ
žœ
˜Jš
žœ	žœ
žœ
žœ
žœ˜ Jš
œ4˜4Jšžœžœ
žœC˜YJšžœ1˜5Jš
œ9˜9Jš
œ˜——š
œ™Jš¢œžœ˜š
œ™Jšœžœžœ˜2Jš
œ˜—J˜Jš
œ˜J˜Jšžœ
˜——…—†ÔÒå