DIRECTORY List, GGBasicTypes, GGBoundBox, GGGravity, GGInterfaceTypes, GGMultiGravity, GGObjects, GGOutline, GGModelTypes, GGSceneType, GGSegment, GGSegmentTypes, GGSelect, GGSequence, GGTraj, GGUtility, GList, Imager, ImagerPath, Rope; GGObjectsImpl: CEDAR PROGRAM IMPORTS List, GGBoundBox, GGGravity, GGMultiGravity, GGObjects, GGOutline, GGSelect, GGSegment, GGSequence, GGTraj, GGUtility, GList, Imager EXPORTS GGObjects, GGModelTypes = BEGIN BoundBox: TYPE = GGModelTypes.BoundBox; BoundBoxGenerator: TYPE = REF BoundBoxGeneratorObj; BoundBoxGeneratorObj: TYPE = GGModelTypes.BoundBoxGeneratorObj; CurveType: TYPE = {line, bezier, conic}; EntityGenerator: TYPE = REF EntityGeneratorObj; EntityGeneratorObj: TYPE = GGModelTypes.EntityGeneratorObj; Joint: TYPE = REF JointObj; JointGenerator: TYPE = REF JointGeneratorObj; JointGeneratorObj: TYPE = GGModelTypes.JointGeneratorObj; JointObj: TYPE = GGSegmentTypes.JointObj; Outline: TYPE = REF OutlineObj; OutlineObj: TYPE = GGModelTypes.OutlineObj; OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor; OutlineGenerator: TYPE = REF OutlineGeneratorObj; OutlineGeneratorObj: TYPE = GGModelTypes.OutlineGeneratorObj; Point: TYPE = GGBasicTypes.Point; Segment: TYPE = REF SegmentObj; SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator; SegmentObj: TYPE = GGSegmentTypes.SegmentObj; Sequence: TYPE = REF SequenceObj; SequenceGenerator: TYPE = GGModelTypes.SequenceGenerator; SequenceObj: TYPE = GGModelTypes.SequenceObj; Slice: TYPE = GGModelTypes.Slice; SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor; SliceGenerator: TYPE = REF SliceGeneratorObj; SliceGeneratorObj: TYPE = GGModelTypes.SliceGeneratorObj; Traj: TYPE = REF TrajObj; TrajEnd: TYPE = GGModelTypes.TrajEnd; -- {lo, hi}; TrajGenerator: TYPE = REF TrajGeneratorObj; TrajGeneratorObj: TYPE = GGModelTypes.TrajGeneratorObj; TrajObj: TYPE = GGModelTypes.TrajObj; Vector: TYPE = GGBasicTypes.Vector; GargoyleData: TYPE = GGInterfaceTypes.GargoyleData; SceneRef: TYPE = REF SceneObj; SceneObj: PUBLIC TYPE = GGSceneType.SceneObj; NotYetImplemented: PUBLIC SIGNAL = CODE; Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = CODE; fillColor: PUBLIC Imager.Color _ Imager.MakeGray[0.5]; DeleteSequence: PUBLIC PROC [seq: Sequence, scene: SceneRef] RETURNS [oldOutline: Outline, newOutlines: LIST OF Outline] = { oldOutline _ GGOutline.OutlineOfTraj[seq.traj]; SELECT seq.traj.role FROM hole => { smallerOutline: Outline; newOutlines _ OutlinesOfTrajMinusSequence[seq]; smallerOutline _ OutlineMinusHole[oldOutline, seq.traj]; AddOutline[scene, smallerOutline, -1]; AddOutlinesToScene[newOutlines, scene]; -- put the deflated holes on top. newOutlines _ CONS[smallerOutline, newOutlines]; }; open => { newOutlines _ OutlinesOfTrajMinusSequence[seq]; AddOutlinesToScene[newOutlines, scene]; }; fence => { fenceParts, freedHoles: LIST OF Outline; fenceParts _ OutlinesOfTrajMinusSequence[seq]; AddOutlinesToScene[fenceParts, scene]; freedHoles _ OutlinesFromOutlineExcept[oldOutline, seq.traj]; AddOutlinesToScene[freedHoles, scene]; newOutlines _ AppendOutlines[fenceParts, freedHoles]; }; ENDCASE => ERROR; DeleteOutline[scene, oldOutline]; }; AddOutlinesToScene: PROC [outlines: LIST OF Outline, scene: SceneRef] = { FOR list: LIST OF Outline _ outlines, list.rest UNTIL list = NIL DO AddOutline[scene, list.first, -1]; ENDLOOP; }; OutlinesOfTrajMinusSequence: PROC [seq: Sequence] RETURNS [newOutlines: LIST OF Outline] = { diff, wholeTraj: Sequence; IF GGSequence.IsComplete[seq] THEN RETURN[NIL]; wholeTraj _ GGSequence.CreateComplete[seq.traj]; IF NOT GGSequence.IsEmpty[seq] AND seq.traj.segCount=1 THEN GGSegment.OpenUpSegment[GGTraj.FetchSegment[seq.traj, 0]]; -- cyclic segments must become acyclic diff _ GGSequence.Difference[wholeTraj, seq]; [newOutlines] _ GroupPieces[diff]; }; GroupPieces: PROC [seq: Sequence] RETURNS [newOutlines: LIST OF Outline] = { seqGen: SequenceGenerator; newTraj: Traj; newOutline, oldOutline: Outline; runCount: NAT; joint: Joint; newOutlines _ NIL; oldOutline _ GGOutline.OutlineOfTraj[seq.traj]; [seqGen, runCount] _ GGSequence.RunsInSequence[seq]; FOR run: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL run = NIL DO IF run.segCount=0 THEN LOOP; -- special case needed by BS command. [newTraj] _ GGTraj.CopyTrajFromRun[run]; joint _ GGTraj.FetchJoint[newTraj, 0]; joint.TselectedInFull.active _ FALSE; joint _ GGTraj.FetchJoint[newTraj, GGTraj.HiJoint[newTraj]]; joint.TselectedInFull.active _ FALSE; newTraj.role _ open; newOutline _ GGOutline.CreateOutline[newTraj, oldOutline.lineEnds, oldOutline.fillColor]; newOutlines _ CONS[newOutline, newOutlines]; ENDLOOP; }; OutlinesFromOutlineExcept: PROC [outline: Outline, except: Traj] RETURNS [newOutlines: LIST OF Outline] = { trajGen: TrajGenerator; newTraj: Traj; newOutline: Outline; ptr: LIST OF Outline; trajGen _ GGOutline.TrajsInOutline[outline]; [newOutlines, ptr] _ StartOutlineList[]; FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO IF traj = except THEN LOOP; newTraj _ GGTraj.CopyTraj[traj]; newOutline _ GGOutline.CreateOutline[newTraj, outline.lineEnds, outline.fillColor]; [newOutlines, ptr] _ AddOutlineToList[newOutline, newOutlines, ptr]; ENDLOOP; }; OutlineMinusHole: PROC [outline: Outline, except: Traj] RETURNS [newOutline: Outline] = { holeGen: TrajGenerator; newTraj, fence: Traj; fence _ GGOutline.FenceOfOutline[outline]; newTraj _ GGTraj.CopyTraj[fence]; newOutline _ GGOutline.CreateOutline[newTraj, outline.lineEnds, outline.fillColor]; holeGen _ GGOutline.HolesOfOutline[outline]; FOR hole: Traj _ GGObjects.NextTraj[holeGen], GGObjects.NextTraj[holeGen] UNTIL hole = NIL DO IF hole = except THEN LOOP; newTraj _ GGTraj.CopyTraj[hole]; newOutline _ GGOutline.AddHole[newOutline, newTraj]; ENDLOOP; }; AppendOutlines: PROC [list1, list2: LIST OF Outline] RETURNS [result: LIST OF Outline] = { pos: LIST OF Outline; newCell: LIST OF Outline; IF list1 = NIL THEN RETURN[list2]; result _ CONS[list1.first, NIL]; pos _ result; FOR l: LIST OF Outline _ list1.rest, l.rest UNTIL l = NIL DO newCell _ CONS[l.first, NIL]; pos.rest _ newCell; pos _ newCell; ENDLOOP; pos.rest _ list2; }; StartOutlineList: PROC [] RETURNS [entityList, ptr: LIST OF Outline] = { ptr _ entityList _ NIL; }; AddOutlineToList: PROC [entity: Outline, entityList, ptr: LIST OF Outline] RETURNS [newList, newPtr: LIST OF Outline] = { IF ptr = NIL THEN { IF NOT entityList = NIL THEN ERROR; newPtr _ newList _ CONS[entity, NIL]; RETURN; } ELSE { newList _ entityList; ptr.rest _ CONS[entity, NIL]; newPtr _ ptr.rest; }; }; DeleteOutline: PUBLIC PROC [scene: SceneRef, outline: Outline] = { DeleteEntity[scene, outline]; }; CreateScene: PUBLIC PROC [] RETURNS [scene: SceneRef] = { scene _ NEW[SceneObj _ [] ]; }; AddOutline: PUBLIC PROC [scene: SceneRef, outline: Outline, priority: INT _ -1] = { AppendEntity[scene, outline]; }; AddSlice: PUBLIC PROC [scene: SceneRef, slice: Slice, priority: INT _ -1] = { AppendEntity[scene, slice]; }; AddEntities: PUBLIC PROC [scene: SceneRef, entities: LIST OF REF ANY] = { FOR list: LIST OF REF ANY _ entities, list.rest UNTIL list = NIL DO AppendEntity[scene, list.first]; ENDLOOP; }; AddEntity: PUBLIC PROC [scene: SceneRef, entity: REF ANY, priority: INT] = { IF priority = -1 THEN AppendEntity[scene, entity] ELSE IF priority = 0 THEN { scene.ptrValid _ FALSE; scene.entities _ CONS[entity, scene.entities]; }; }; AppendEntity: PROC [scene: SceneRef, entity: REF ANY] = { IF NOT scene.ptrValid THEN { -- restore ptr IF scene.entities=NIL THEN scene.ptr _ NIL ELSE FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list=NIL DO scene.ptr _ list; ENDLOOP; scene.ptrValid _ TRUE; }; [scene.entities, scene.ptr] _ GGUtility.AddEntity[entity, scene.entities, scene.ptr]; }; DeleteEntity: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = { scene.ptrValid _ FALSE; scene.entities _ List.DRemove[entity, scene.entities]; }; undeleteSize: INT _ 20; -- temporarily hardwired size of undelete stack PushScene: PUBLIC PROC [scene: SceneRef] = { CopyList: PROC [list: LIST OF REF ANY] RETURNS [copy: LIST OF REF ANY] = { entityList, ptr: LIST OF REF ANY; [entityList, ptr] _ GGUtility.StartList[]; FOR entity: LIST OF REF ANY _ list, entity.rest UNTIL entity=NIL DO [entityList, ptr] _ GGUtility.AddEntity[entity.first, entityList, ptr]; ENDLOOP; copy _ entityList; }; tList: LIST OF LIST OF REF ANY; scene.oldEntities _ CONS[ CopyList[scene.entities], scene.oldEntities]; tList _ scene.oldEntities; FOR index: INT IN [0..undeleteSize) DO IF tList#NIL THEN tList _ tList.rest; ENDLOOP; IF tList#NIL THEN tList.rest _ NIL; -- truncate the undelete stack }; EmptySceneStack: PUBLIC PROC [scene: SceneRef] RETURNS [BOOL] = { RETURN[scene.oldEntities=NIL OR scene.oldEntities.first=NIL]; }; PopScene: PUBLIC PROC [scene: SceneRef] = { IF EmptySceneStack[scene] THEN ERROR; scene.entities _ scene.oldEntities.first; scene.oldEntities _ scene.oldEntities.rest; }; MergeScenes: PUBLIC PROC [back: SceneRef, front: SceneRef] RETURNS [combined: SceneRef] = { combined _ NEW[SceneObj _ []]; combined.entities _ NARROW[GList.Append[back.entities, front.entities]]; }; UpOne: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = { ExchangeWithNextEntity: PROC [scene: SceneRef, entity: REF ANY] = { previous, next: LIST OF REF ANY _ NIL; FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list = NIL DO IF list.first=entity THEN { -- exchange this entity with its next neighbor next _ list.rest; IF next=NIL THEN RETURN; -- entity already at end (i.e. top) of list list.rest _ next.rest; next.rest _ list; IF previous#NIL THEN previous.rest _ next ELSE scene.entities _ next; } ELSE previous _ list; ENDLOOP; }; trueEntity: REF ANY; WITH entity SELECT FROM slice: Slice => trueEntity _ slice; outline: Outline => trueEntity _ outline; traj: Traj => trueEntity _ GGOutline.OutlineOfTraj[traj]; seq: Sequence => trueEntity _ GGOutline.OutlineOfTraj[seq.traj]; ENDCASE => ERROR; ExchangeWithNextEntity[scene, trueEntity]; }; DownOne: PUBLIC PROC [scene: SceneRef, entity: REF ANY] = { ExchangeWithPreviousEntity: PROC [scene: SceneRef, entity: REF ANY] = { preprev, previous: LIST OF REF ANY _ NIL; FOR list: LIST OF REF ANY _ scene.entities, list.rest UNTIL list=NIL DO IF list.first=entity THEN { -- exchange this entity with its previous neighbor SELECT TRUE FROM preprev=NIL AND previous=NIL => RETURN; -- entity already on bottom preprev=NIL AND previous#NIL => { -- special case. Second from bottom previous.rest _ list.rest; list.rest _ previous; scene.entities _ list; RETURN; }; preprev#NIL AND previous=NIL => ERROR; -- Assert: can't happen preprev#NIL AND previous#NIL => { -- usual case. Exchange list elements previous.rest _ list.rest; list.rest _ previous; preprev.rest _ list; RETURN; }; ENDCASE => ERROR; -- Assert: can't happen } ELSE { preprev _ previous; previous _ list; }; ENDLOOP; }; trueEntity: REF ANY; WITH entity SELECT FROM slice: Slice => trueEntity _ slice; outline: Outline => trueEntity _ outline; traj: Traj => trueEntity _ GGOutline.OutlineOfTraj[traj]; seq: Sequence => trueEntity _ GGOutline.OutlineOfTraj[seq.traj]; ENDCASE => ERROR; ExchangeWithPreviousEntity[scene, trueEntity]; }; TopLevelEntitiesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [entityGenerator: EntityGenerator] = { entityGenerator _ NEW[EntityGeneratorObj _ [ list: scene.entities, countValid: FALSE, count: 0 ]]; }; NextEntity: PUBLIC PROC [g: EntityGenerator] RETURNS [next: REF ANY] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; EntityCount: PUBLIC PROC [g: EntityGenerator] RETURNS [count: NAT] = { IF g.countValid THEN RETURN[g.count]; count _ 0; FOR list: LIST OF REF ANY _ g.list, list.rest UNTIL list = NIL DO count _ count + 1; ENDLOOP; }; IsTopLevel: PUBLIC PROC [entity: REF ANY] RETURNS [BOOL] = { WITH entity SELECT FROM slice: Slice => RETURN[slice.parent = NIL]; outline: Outline => RETURN[outline.parent = NIL OR outline.parent.parent = NIL]; traj: Traj => RETURN[traj.parent.parent = NIL OR traj.parent.parent.parent = NIL]; seq: Sequence => RETURN[IsTopLevel[seq.traj.parent]]; ENDCASE => ERROR; }; TrajsInScene: PUBLIC PROC [scene: SceneRef] RETURNS [trajGen: TrajGenerator] = { list: LIST OF Traj _ ListTrajsInScene[scene]; trajGen _ NEW[TrajGeneratorObj _ [ list: list ]]; }; OutlinesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [outlineGen: OutlineGenerator] = { list: LIST OF Outline _ ListOutlinesInScene[scene]; outlineGen _ NEW[OutlineGeneratorObj _ [ list: list ]]; }; NextTraj: PUBLIC PROC [g: TrajGenerator] RETURNS [next: Traj] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; NextOutline: PUBLIC PROC [g: OutlineGenerator] RETURNS [next: Outline] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; SlicesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [sliceGen: SliceGenerator] = { list: LIST OF Slice _ ListSlicesInScene[scene]; sliceGen _ NEW[SliceGeneratorObj _ [ list: list ]]; }; NextSlice: PUBLIC PROC [g: SliceGenerator] RETURNS [next: Slice] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; BoundBoxesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBoxGen: BoundBoxGenerator] = { list: LIST OF BoundBox _ ListBoxesInScene[scene]; bBoxGen _ NEW[BoundBoxGeneratorObj _ [ list: list ]]; }; TightBoxesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBoxGen: BoundBoxGenerator] = { list: LIST OF BoundBox _ ListTightBoxesInScene[scene]; bBoxGen _ NEW[BoundBoxGeneratorObj _ [ list: list ]]; }; NextBox: PUBLIC PROC [g: BoundBoxGenerator] RETURNS [next: BoundBox] = { IF g.list = NIL THEN RETURN[NIL] ELSE { next _ g.list.first; g.list _ g.list.rest; }; }; ListBoxesInScene: PROC [scene: SceneRef] RETURNS [allBoxes: LIST OF BoundBox] = { thisBox: BoundBox; allBoxes _ NIL; FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO WITH entities.first SELECT FROM slice: Slice => { thisBox _ slice.class.getBoundBox[slice, NIL]; allBoxes _ CONS[thisBox, allBoxes]; }; outline: Outline => { thisBox _ outline.class.getBoundBox[outline, NIL]; allBoxes _ CONS[thisBox, allBoxes]; }; ENDCASE => ERROR; ENDLOOP; }; ListTightBoxesInScene: PROC [scene: SceneRef] RETURNS [allBoxes: LIST OF BoundBox] = { thisBox: BoundBox; allBoxes _ NIL; FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO WITH entities.first SELECT FROM slice: Slice => { thisBox _ slice.class.getTightBox[slice, NIL]; allBoxes _ CONS[thisBox, allBoxes]; }; outline: Outline => { thisBox _ outline.class.getTightBox[outline, NIL]; allBoxes _ CONS[thisBox, allBoxes]; }; ENDCASE => ERROR; ENDLOOP; }; BoundBoxOfScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBox: BoundBox] = { bbGen: GGModelTypes.BoundBoxGenerator _ BoundBoxesInScene[scene]; bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list]; -- cheating to go inside generator }; TightBoxOfScene: PUBLIC PROC [scene: SceneRef] RETURNS [bBox: BoundBox] = { bbGen: GGModelTypes.BoundBoxGenerator _ TightBoxesInScene[scene]; bBox _ GGBoundBox.BoundBoxOfBoxes[bbGen.list]; -- cheating to go inside generator }; AppendTrajs: PUBLIC PROC [l1, l2: LIST OF Traj] RETURNS [result: LIST OF Traj] = { z: LIST OF Traj _ l1; IF z = NIL THEN RETURN[l2]; UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP; z.rest _ l2; RETURN[l1]; }; AppendBoxes: PUBLIC PROC [l1, l2: LIST OF BoundBox] RETURNS [result: LIST OF BoundBox] = { z: LIST OF BoundBox _ l1; IF z = NIL THEN RETURN[l2]; UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP; z.rest _ l2; RETURN[l1]; }; ListTrajsInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allTrajs: LIST OF Traj] = { allTrajs _ NIL; FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO WITH entities.first SELECT FROM slice: Slice => { }; outline: Outline => { FOR trajs: LIST OF Traj _ outline.children, trajs.rest UNTIL trajs = NIL DO allTrajs _ CONS[trajs.first, allTrajs]; ENDLOOP; }; ENDCASE => ERROR; ENDLOOP; }; ListOutlinesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allOutlines: LIST OF Outline] = { allOutlines _ NIL; FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO WITH entities.first SELECT FROM slice: Slice => { }; outline: Outline => { allOutlines _ CONS[outline, allOutlines]; }; ENDCASE => ERROR; ENDLOOP; }; ListSlicesInScene: PUBLIC PROC [scene: SceneRef] RETURNS [allSlices: LIST OF Slice] = { allSlices _ NIL; FOR entities: LIST OF REF ANY _ scene.entities, entities.rest UNTIL entities = NIL DO WITH entities.first SELECT FROM slice: Slice => { allSlices _ CONS[slice, allSlices]; }; outline: Outline => {}; ENDCASE => ERROR; ENDLOOP; }; ListTrajsInOutline: PROC [outline: Outline] RETURNS [trajList: LIST OF Traj] = { trajList _ outline.children; }; ListHolesOfOutline: PROC [outline: Outline] RETURNS [trajList: LIST OF Traj] = { trajList _ outline.children.rest; }; ListSegmentsInTraj: PROC [traj: Traj] RETURNS [segList: LIST OF Segment] = { segList _ NIL; FOR i: NAT DECREASING IN [0..GGTraj.HiSegment[traj]] DO segList _ CONS[GGTraj.FetchSegment[traj, i], segList]; ENDLOOP; }; NearestTrajectoryInScene: PUBLIC PROC [scene: SceneRef, worldPt: Point, gargoyleData: GargoyleData] RETURNS [traj: Traj] = { feature: GGModelTypes.FeatureData; resultPoint: Point; sceneObjects: GGInterfaceTypes.TriggerBag; sceneObjects _ NARROW[gargoyleData.hitTest.sceneTriggerBag]; [resultPoint, feature] _ GGMultiGravity.StrictDistance[worldPt, gargoyleData.hitTest.criticalR, GGGravity.emptyObjectBag, sceneObjects, gargoyleData]; RETURN[IF feature=NIL OR feature.type=slice THEN NIL ELSE NARROW[feature.shape, Sequence].traj]; }; SaveSelections: PUBLIC PROC [scene: SceneRef] = { scene.savedSelected.normal _ List.Append[scene.selected.normal, NIL]; }; RestoreSelections: PUBLIC PROC [scene: SceneRef] = { normalSelectedList: LIST OF REF ANY _ scene.savedSelected.normal; GGSelect.DeselectAll[scene, normal]; -- get rid of any transient selections FOR list: LIST OF REF ANY _ normalSelectedList, list.rest UNTIL list = NIL DO WITH list.first SELECT FROM cD: SliceDescriptor => GGSelect.SelectSlice[cD.slice, cD.parts, scene, normal]; oD: OutlineDescriptor => GGSelect.SelectOutline[oD.slice, oD.parts, scene, normal]; ENDCASE => ERROR; ENDLOOP; }; GetSelections: PUBLIC PROC [scene: SceneRef, selectClass: GGSegmentTypes.SelectionClass] RETURNS [selected: LIST OF REF ANY] = { SELECT selectClass FROM normal => selected _ scene.selected.normal; hot => selected _ scene.selected.hot; active => selected _ scene.selected.active; ENDCASE => ERROR; }; END. ŽGGObjectsImpl.mesa Copyright c 1985 by Xerox Corporation. All rights reserved. Last edited by Bier on January 27, 1987 1:06:17 am PST Contents: The procedural interface to the Gargoyle object modeler. Stone, August 5, 1985 4:13:18 pm PDT Pier, December 11, 1986 4:59:23 pm PST Kurlander August 28, 1986 6:15:29 pm PDT The scene object has a list of entities, a "finger" REF (ptr) to the end of the list for quick appends, and a BOOL which is TRUE when ptr in fact points to the end. ptr MUST BE invalidated by setting ptrValid _ FALSE whenever a remove or delete is done from the entities. Any use of ptr must check ptrValid and recalculate its value if it is invalid. The only place that happens in here is in AppendEntity. entities are kept in back to front order so that the list can be painted with a single traversal. Destroying and Modifying Sequences. Sequences are created via GGSequence. Takes the trajectory of which seq is a part. What is the role of this trajectory? If role = hole, then create a new outline (and new trajectories), identical to seq.traj.outline, but without the hole. The index corresponding to this outline will be 0. Make separate outlines corresponding to those parts of the hole which were not deleted. The index for each of these outlines will be the segment number, in the original hole traj, of segment 0 in the new outline. The old outline (and all of its parts) is now obsolete. If role = fence, then create new outlines and new trajectories for all of the parts of seq.traj.outline which remain. The index for each of these outlines will be the segment number, in the original fence traj, of segment 0 in the new outline. The old outline (and all of its parts) is now obsolete. If role = open, then create new outlines and new trajectories for all of the parts of seq.traj which remain. The index for each of these outlines will be the segment number, in the original fence traj, of segment 0 in the new outline. The old outline is obsolete. The parts of the hole become top level parts of the scene. The rest of the outline is replaced by a single new outline. Parts of the trajectory are in the sequence. Take the segments which remain, and all the joints that they touch. Make sure the end joints of the run are not active selected. They can be normal or hot selected. This is important for the delete operation. Non-destructive (copies the first list). Creating, Modifying and Destroying Outlines scene.ptrValid _ FALSE; scene.entities _ GGUtility.DeleteEntityFromList[outline, scene.entities]; Building and Destroying Clusters MakeCluster: PUBLIC PROC [entities: LIST OF REF ANY] RETURNS [newCluster: Slice]; BreakCluster: PUBLIC PROC [oldCluster: Slice] RETURNS [entities: LIST OF REF ANY]; Creating, Modifying Scenes Add the given outline to the scene with the given priority (the lower the priority number, the closer the outline is to the front. If priority is -1, the outline will be the rear-most entity. If an entity with the given priority already exists, all priority numbers greater than or equal to it will be increased by one. Like AddOutline, but adds a slice. Adds the entities, assumed to be in back to front order, to the scene. FOR list: LIST OF REF ANY _ entities, list.rest UNTIL list = NIL DO scene.entities _ CONS[list.first, scene.entities]; ENDLOOP; Adds the entity to the scene. If priority = 0, it becomes the rearmost entity. IF priority = -1, it becomes the frontmost entity. Removes the named entity from the scene. If the entity is not on the list, no action is taken. Makes a copy of the current scene list, and pushes it on a stack. For use in Undelete. Lets scene be the most recently pushed scene, that has not yet been popped. combined.entities _ NARROW[GList.Append[front.entities, back.entities]]; Moves the named entity one step closer to the front in the priority order. Moves the named entity one step closer to the back in the priority order. Browsing the Scene Hierarchy -- Generators Generates all of the outlines and slices in the scene. list: LIST OF REF ANY _ List.Reverse[scene.entities]; -- KAP October 22, 1986 Returns the unique fence trajectory of outline. Generates all of the trajectories in the scene, wherever they occur. Generates all of the outlines in the scene, wherever they occur. Bounding Boxes Generates all of the boundBoxes in the scene, whereever they occur. Generates all of the boundBoxes in the scene, whereever they occur. box is in local IP coordinates box is in local IP coordinates Utility Routines Destructive append. Destructive append. Doesn't work on Gargoyle slices. Hit Testing -- Outline-Specific routines. These should go away when Outlines become Slices. Selections this is a trick to make a copy of the list quickly. The list will be modified in place later on. Pier, December 5, 1985 10:13:59 am PST changes to: removed camera from definitions Bier, January 7, 1986 4:42:32 pm PST changes to: Reordered procedures to match GGObjects. ΚZ˜code™Kšœ Οmœ1™šœžœžœ žœ %˜GKšœHžœ˜OKšœ˜—Kšžœžœ ˜)—K˜—Kšžœ+˜/Kšžœ˜—K˜—Kšœ žœžœ˜šžœžœž˜Kšœ#˜#Kšœ)˜)Kšœ9˜9Kšœ@˜@Kšžœžœ˜—Kšœ.˜.K˜K˜—K™Kšœ ‘ ™*K˜šŸœžœžœžœ(˜fK™6Kš œžœžœžœžœ8™Mšœžœ˜,Kšœ˜Kšœ žœ˜K˜K˜—K˜K˜—š Ÿ œžœžœžœžœžœ˜HKš žœ žœžœžœžœ˜ šžœ˜Kšœ˜K˜K˜—K˜K˜—š Ÿ œžœžœžœ žœ˜FKšžœžœžœ ˜%Kšœ ˜ šžœžœžœžœžœžœžœž˜AKšœ˜Kšžœ˜—K˜K˜—šŸ œžœžœ žœžœžœžœ˜