<> <> <> <> <<>> 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.