<> <> <> <> <> <<>> DIRECTORY CoordSys, CSGGraphics, DisplayList3d, DisplayList3dPrivate, Imager, ImagerColor, IO, Matrix3d, Rope, SV2d, SV3d, SVArtwork, SVError, SVModelTypes, SVPolygon3d, SVSceneTypes, SVRayTypes, SVToolObject; DisplayList3dImplA: PROGRAM IMPORTS CoordSys, CSGGraphics, DisplayList3d, DisplayList3dPrivate, Imager, ImagerColor, 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 = Imager.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", ImagerColor.ColorFromRGB[[0.2,0.2,0.2]]]; defaultWhiteLight: LightSource _ CreateLightSource["WhiteLight",[800,800,1000], Imager.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: Imager.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: Imager.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[ImagerColor.ColorFromRGB[[.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[ImagerColor.ColorFromRGB[[.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[Imager.white, 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[Imager.white, 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[Imager.white, 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; }; <> <> < {>> <> <> <<};>> <>> <> < ERROR;>> <<};>> <> <> <> <> <<};>> 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]]]; }; <> <> <> <> <> <> <<>> <<[targetBase, targetNum] _ BaseAndNumber[name];>> <> <<[base, num] _ BaseAndNumber[assem.name];>> <> <> <> <<};>> 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.