<<>> <> <> <> <> DIRECTORY Atom, Basics, CedarProcess, Convert, FileNames, FS, G2dBasic, G3dBasic, G3dIO, G3dMatrix, G3dPolygon, G3dQuaternion, G3dShape, G3dVector, IO, PFS, Process, Real, RealFns, Rope; G3dShapeImpl: CEDAR PROGRAM IMPORTS Atom, Basics, CedarProcess, Convert, FileNames, FS, G2dBasic, G3dBasic, G3dIO, G3dMatrix, G3dPolygon, G3dQuaternion, G3dVector, IO, PFS, Process, Real, RealFns, Rope EXPORTS G3dShape ~ BEGIN <> PropList: TYPE ~ Atom.PropList; Box3d: TYPE ~ G3dBasic.Box; IntegerSequence: TYPE ~ G3dBasic.IntegerSequence; IntegerSequenceRep: TYPE ~ G3dBasic.IntegerSequenceRep; NatSequence: TYPE ~ G3dBasic.NatSequence; NatSequenceRep: TYPE ~ G3dBasic.NatSequenceRep; NatTable: TYPE ~ G3dBasic.NatTable; Surface: TYPE ~ G3dBasic.Surface; SurfaceSequence: TYPE ~ G3dBasic.SurfaceSequence; SurfaceSequenceRep: TYPE ~ G3dBasic.SurfaceSequenceRep; Pair: TYPE ~ G3dBasic.Pair; PairSequence: TYPE ~ G3dBasic.PairSequence; PairSequenceRep: TYPE ~ G3dBasic.PairSequenceRep; Ray: TYPE ~ G3dBasic.Ray; RealSequence: TYPE ~ G3dBasic.RealSequence; RealSequenceRep: TYPE ~ G3dBasic.RealSequenceRep; Triple: TYPE ~ G3dBasic.Triple; TripleSequence: TYPE ~ G3dBasic.TripleSequence; TripleSequenceRep: TYPE ~ G3dBasic.TripleSequenceRep; Matrix: TYPE ~ G3dMatrix.Matrix; AxisAngle: TYPE ~ G3dQuaternion.AxisAngle; Quaternion: TYPE ~ G3dQuaternion.Quaternion; Edge: TYPE ~ G3dShape.Edge; EdgeRep: TYPE ~ G3dShape.EdgeRep; EdgeSequence: TYPE ~ G3dShape.EdgeSequence; Face: TYPE ~ G3dShape.Face; FaceRep: TYPE ~ G3dShape.FaceRep; FaceSequence: TYPE ~ G3dShape.FaceSequence; FaceSequenceRep: TYPE ~ G3dShape.FaceSequenceRep; ScreenSequence: TYPE ~ G3dShape.ScreenSequence; Shape: TYPE ~ G3dShape.Shape; ShapeRep: TYPE ~ G3dShape.ShapeRep; ShapeSequence: TYPE ~ G3dShape.ShapeSequence; ShapeSequenceRep: TYPE ~ G3dShape.ShapeSequenceRep; SurfaceProc: TYPE ~ G3dShape.SurfaceProc; Validity: TYPE ~ G3dShape.Validity; Vertex: TYPE ~ G3dShape.Vertex; VertexRep: TYPE ~ G3dShape.VertexRep; VertexSequence: TYPE ~ G3dShape.VertexSequence; VertexSequenceRep: TYPE ~ G3dShape.VertexSequenceRep; STREAM: TYPE ~ IO.STREAM; ROPE: TYPE ~ Rope.ROPE; huge: REAL ~ Real.LargestNumber; Error: PUBLIC SIGNAL [code: ATOM, reason: ROPE] = CODE; <> ShapeFromFile: PUBLIC PROC [fileName: ROPE] RETURNS [s: Shape] ~ { in: STREAM Ź PFS.StreamOpen[PFS.PathFromRope[FileNames.ResolveRelativePath[fileName]]]; < Error[error.code, error.explanation]];>> s Ź ShapeFromStream[in]; s.fileName Ź fileName; s.name Ź FileNames.GetShortName[fileName]; IO.Close[in]; }; ShapeFromStream: PUBLIC PROC [in: STREAM] RETURNS [s: Shape] ~ { Eq: PROC [r1, r2: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[r1, r2, FALSE]]}; nVerts, nPolys: INT Ź 0; line: G3dIO.Line Ź G3dIO.ObtainLine[]; countFromOne, triangulated, tallyOnPolys: BOOL Ź FALSE; map: IntegerSequence Ź NIL; IF in = NIL THEN RETURN; s Ź NEW[ShapeRep]; DO ENABLE G3dIO.Error => G3dIO.Error[reason, lineText, lineNumber]; -- raise error here Types: TYPE ~ RECORD[SEQUENCE max: INT OF {xyz,nrm,col,tex,tra,map,vtx,prop,tally}]; TestEndData: PROC ~ { index: INT Ź IO.GetIndex[in]; line Ź G3dIO.GetLine[in, line ! IO.EndOfStream => GOTO EOF]; IF line.type = data THEN G3dIO.Error["Excessive data found", line.rope, G3dIO.LineNumber[line]]; IO.SetIndex[in, index]; EXITS EOF => NULL; }; PutProp: PROC [key: ROPE, value: REF ANY] ~ { prop: REF ANY Ź Convert.AtomFromRope[key]; IF Atom.GetPropFromList[s.props, prop] # NIL THEN { IO.SetIndex[in, index]; line Ź G3dIO.GetLine[in, line]; G3dIO.Error[IO.PutFR1["Redundant key (%g)", IO.rope[key]], line.rope, G3dIO.LineNumber[line]]; }; s.props Ź Atom.PutPropOnList[s.props, Convert.AtomFromRope[key], value]; }; StopAtComma: PROC [rope: ROPE] RETURNS [ROPE] ~ { RETURN[Rope.Substr[rope, 0, Rope.Index[rope, 0, ","]]]; }; GetIntegerCheckingComma: PROC [line: G3dIO.Line] RETURNS [i: INT] ~ { word: ROPE Ź StopAtComma[G3dIO.GetWord[line]]; i Ź Convert.IntFromRope[word ! Convert.Error => G3dIO.ErrorReport[convert, line]]; }; SubE: PROC [r: ROPE] RETURNS [b: BOOL] ~ {b Ź Eq[Rope.Substr[rope,, Rope.Size[r]], r]}; GetTriple: PROC [l: G3dIO.Line, n: INT] RETURNS [t: Triple] ~ { Skip: PROC [l: G3dIO.Line] ~ { [] Ź G3dIO.GetWord[l]; [] Ź G3dIO.GetWord[l]; [] Ź G3dIO.GetWord[l]; }; <> t Ź G3dIO.GetTriple[line]; }; SetProps: PROC [fields: G3dIO.FieldSequence, types: REF Types] ~ { FOR f: INT IN [0..fields.length) DO IF types[f] = prop THEN PutProp[fields[f].id, fields[f].sequence]; ENDLOOP; }; AllocateFields: PROC [field: G3dIO.Field, nLines: INT] ~ { field.sequence Ź SELECT field.type FROM integer => NEW[IntegerSequenceRep[nLines]], real => NEW[RealSequenceRep[nLines]], pair => NEW[PairSequenceRep[nLines]], triple => NEW[TripleSequenceRep[nLines]], nats => NEW[SurfaceSequenceRep[nLines]], ENDCASE => NIL; }; ReadProp: PROC [line: G3dIO.Line, f: G3dIO.Field, n: INT] ~ { SELECT f.type FROM integer => NARROW[f.sequence, IntegerSequence][n] Ź G3dIO.GetInteger[line]; real => NARROW[f.sequence, RealSequence][n] Ź G3dIO.GetReal[line]; pair => NARROW[f.sequence, PairSequence][n] Ź G3dIO.GetPair[line]; triple => NARROW[f.sequence, TripleSequence][n] Ź GetTriple[line, n]; nats => NARROW[f.sequence, NatTable][n] Ź G3dIO.GetNats[line]; ENDCASE => NULL; }; rope: ROPE; key: ROPE Ź G3dIO.NextKeyWord[in ! G3dIO.Error => EXIT]; index: INT Ź IO.GetIndex[in]; -- may need this later to report PutProp error SELECT TRUE FROM Eq[key, "SurfaceType"] => { -- read shape information <> line Ź G3dIO.FindKeyWord[in, key,,, line]; DO ENABLE G3dIO.Error => CONTINUE; IF (rope Ź G3dIO.GetWord[line]) = NIL THEN EXIT; IF Rope.Find[rope, "--"] = 0 THEN EXIT; -- ignore remaining comment SELECT TRUE FROM SubE["Triangulated"] => triangulated Ź TRUE; SubE["InsideVisible"] => s.showBackfaces Ź TRUE; SubE["CountFromOne"] => countFromOne Ź TRUE; SubE["TallyOnPolys"] => tallyOnPolys Ź TRUE; ENDCASE => s.type Ź Atom.MakeAtom[StopAtComma[rope]]; ENDLOOP; }; Eq[key, "DataSize"] => { -- read vertex/surface sizes: <> line Ź G3dIO.FindKeyWord[in, key,,, line]; DO ENABLE Error => CONTINUE; IF (rope Ź G3dIO.GetWord[line]) = NIL THEN EXIT; IF Rope.Find[rope, "--"] = 0 THEN EXIT; -- ignore remaining comment SELECT TRUE FROM SubE["Vertices"] => nVerts Ź GetIntegerCheckingComma[line]; SubE["Polygons"], SubE["Surfaces"], SubE["Patch"], SubE["Bezier"] => nPolys Ź GetIntegerCheckingComma[line]; ENDCASE; ENDLOOP; }; Eq[key, "Vertices"] => { -- read vertices <> dum: G3dIO.Line Ź line Ź G3dIO.FindKeyWord[in, key,,, line]; fields: G3dIO.FieldSequence Ź G3dIO.InitializeFields[line]; types: REF Types Ź NEW[Types[fields.length]]; IF nVerts = 0 THEN nVerts Ź G3dIO.NumberOfLinesToConvert[in]; s.vertices Ź NEW[VertexSequenceRep[nVerts]]; s.vertices.length Ź nVerts; FOR n: INT IN [0..fields.length) DO f: G3dIO.Field Ź fields[n]; SELECT TRUE FROM Eq[f.id, "index"] => types[n] Ź map; Eq[f.id, "xyzCoords"] => types[n] Ź xyz; Eq[f.id, "normalVec"] => {types[n] Ź nrm; s.vertices.valid[normal] Ź TRUE}; Eq[f.id, "rgbColor"] => {types[n] Ź col; s.vertices.valid[color] Ź TRUE}; Eq[f.id, "textureCoords"] => {types[n] Ź tex; s.vertices.valid[texture] Ź TRUE}; Eq[f.id, "transmittance"] => {types[n] Ź tra; s.vertices.valid[transmit] Ź TRUE}; ENDCASE => {types[n] Ź prop; AllocateFields[f, nVerts]}; IF types[n] = map THEN map Ź NEW[IntegerSequenceRep[nVerts]]; ENDLOOP; FOR n: INT IN [0..nVerts) DO -- line by line data conversions v: Vertex Ź s.vertices[n] Ź NEW[VertexRep]; CedarProcess.CheckAbort[]; line Ź G3dIO.GetDataLine[in, line ! IO.EndOfStream => GOTO eof]; FOR f: INT IN [0..fields.length) DO SELECT types[f] FROM xyz => v.point Ź GetTriple[line, n]; nrm => v.normal Ź GetTriple[line, n]; col => v.color Ź GetTriple[line, n]; tex => v.texture Ź G3dIO.GetPair[line]; tra => v.transmittance Ź G3dIO.GetReal[line]; map => map[n] Ź G3dIO.GetInteger[line]; prop => ReadProp[line, fields[f], n]; ENDCASE => NULL; ENDLOOP; REPEAT eof => NULL; ENDLOOP; TestEndData[]; SetProps[fields, types]; }; Eq[key, "Surfaces"] => { -- read polygons <> tallied: BOOL Ź FALSE; dum: G3dIO.Line Ź line Ź G3dIO.FindKeyWord[in, key,,, line]; fields: G3dIO.FieldSequence Ź G3dIO.InitializeFields[line]; types: REF Types Ź NEW[Types[fields.length]]; IF nPolys = 0 THEN nPolys Ź G3dIO.NumberOfLinesToConvert[in]; s.surfaces Ź NEW[SurfaceSequenceRep[nPolys]]; s.surfaces.length Ź nPolys; FOR f: INT IN [0..fields.length) DO NewFaces: PROC ~ {IF s.faces=NIL THEN s.faces ŹNEW[FaceSequenceRep[nPolys]]}; types[f] Ź SELECT TRUE FROM Eq[fields[f].id, "index"] => map, Eq[fields[f].id, "nSides"] => tally, Eq[fields[f].id, "vertices"] => vtx, Eq[fields[f].id, "normalVec"] => nrm, Eq[fields[f].id, "rgbColor"] => col, Eq[fields[f].id, "transmittance"] => tra, ENDCASE => prop; SELECT types[f] FROM tally => tallied Ź TRUE; nrm => {NewFaces[]; s.faces.valid[normal] Ź TRUE}; col => {NewFaces[]; s.faces.valid[color] Ź TRUE}; tra => {NewFaces[]; s.faces.valid[transmit] Ź TRUE}; prop => AllocateFields[fields[f], nPolys]; ENDCASE; ENDLOOP; FOR n: INT IN [0..nPolys) DO -- line by line data conversions nSides: INT Ź 3; face: Face Ź IF s.faces # NIL THEN (s.faces[n] Ź NEW[FaceRep]) ELSE NIL; CedarProcess.CheckAbort[]; line Ź G3dIO.GetDataLine[in, line ! IO.EndOfStream => GOTO eof]; FOR f: INT IN [0..fields.length) DO SELECT types[f] FROM map => [] Ź G3dIO.GetWord[line]; -- skip the surface index tally => nSides Ź G3dIO.GetInteger[line]; -- should speed things vtx => SELECT TRUE FROM triangulated, tallied => { seq: NatSequence Ź s.surfaces[n].vertices Ź NEW[NatSequenceRep[nSides]]; seq.length Ź nSides; FOR i: INT IN [0..nSides) DO seq[i] Ź Convert.IntFromRope[G3dIO.GetWord[line] ! Convert.Error => G3dIO.ErrorReport[convert, line]]; ENDLOOP; }; ENDCASE => s.surfaces[n].vertices Ź G3dIO.GetNats[line]; nrm => face.normal Ź GetTriple[line, n]; col => face.color Ź GetTriple[line, n]; tra => face.transmittance Ź G3dIO.GetReal[line]; prop => ReadProp[line, fields[f], n]; ENDCASE => NULL; ENDLOOP; REPEAT eof => NULL; ENDLOOP; TestEndData[]; SetProps[fields, types]; }; ENDCASE => { line Ź G3dIO.GetLine[in, line]; PutProp[key, Rope.Substr[line.rope, Rope.Length[key]+1]]; }; ENDLOOP; G3dIO.ReleaseLine[line]; IF s.surfaces # NIL THEN { -- tests IF map # NIL THEN -- take care of indexed vertices: FOR n: INT IN [0..map.length) DO IF map[n] # n THEN { -- map is not a no-op FOR n: INT IN [0..s.surfaces.length) DO poly: NatSequence Ź s.surfaces[n].vertices; FOR nn: INT IN [0..poly.length) DO poly[nn] Ź map[poly[nn]]; ENDLOOP; ENDLOOP; EXIT; }; ENDLOOP; IF countFromOne THEN FOR n: INT IN [0..s.surfaces.length) DO poly: NatSequence Ź s.surfaces[n].vertices; FOR nn: INT IN [0..poly.length) DO poly[nn] Ź poly[nn]-1; ENDLOOP; ENDLOOP; s.triangulated Ź TRUE; FOR n: INT IN [0..s.surfaces.length) DO -- check polygon validity: poly: NatSequence Ź s.surfaces[n].vertices; IF poly = NIL THEN G3dIO.Error[IO.PutFR1["non existent polygon %g", IO.int[n]], NIL, 0]; IF poly.length # 3 AND s.triangulated THEN s.triangulated Ź FALSE; FOR nn: INT IN [0..poly.length) DO IF poly[nn] >= nVerts THEN G3dIO.Error[ IO.PutFR1["polygon %g refers to non-existent vertex", IO.int[n]], NIL, 0]; ENDLOOP; ENDLOOP; s.matrix Ź G3dMatrix.Identity[]; s.objectExtent Ź BoundingBox[s]; }; }; ShapeToFile: PUBLIC PROC [ fileName: ROPE, shape: Shape, index: BOOL Ź FALSE, tallyOnPolys: BOOL Ź FALSE, comment: ROPE Ź NIL] ~ { IF fileName # NIL AND shape # NIL THEN { out: IO.STREAM Ź FS.StreamOpen[FileNames.ResolveRelativePath[fileName], $create]; IF comment # NIL THEN IO.PutF1[out, "Comment~ %g\n\n", IO.rope[comment]]; ShapeToStream[shape, out, index, tallyOnPolys]; }; }; ShapeToStream: PUBLIC PROC [ shape: Shape, out: STREAM, index: BOOL Ź FALSE, tallyOnPolys: BOOL Ź FALSE] ~ { IO.PutF1[out, "ShapeName~ %g\n", IO.rope[shape.name]]; IO.PutF1[out, "SurfaceType~ %g\n", IO.rope[Atom.GetPName[shape.type]]]; IO.PutF[out, "DataSize~ vertices: %g, polygons: %g\n\n", IO.int[shape.vertices.length], IO.int[shape.surfaces.length]]; IO.PutRope[out, "Vertices~"]; IF index THEN IO.PutRope[out, " index: integer"]; IO.PutRope[out, " xyzCoords: triple"]; IF shape.vertices.valid[normal] THEN IO.PutRope[out, " normalVec: triple"]; IF shape.vertices.valid[color] THEN IO.PutRope[out, " rgbColor: triple"]; IF shape.vertices.valid[texture] THEN IO.PutRope[out, " textureCoords: pair"]; IO.PutRope[out, "\n\n"]; FOR n: INT IN [0..shape.vertices.length) DO v: Vertex Ź shape.vertices[n]; IF index THEN IO.PutF1[out, "%g\t", IO.int[n]]; G3dIO.WriteTriple[out, v.point]; IF shape.vertices.valid[normal] THEN G3dIO.WriteTriple[out, v.normal]; IF shape.vertices.valid[color] THEN G3dIO.WriteTriple[out, v.color]; <> <> <> IF shape.vertices.valid[texture] THEN G3dIO.WritePair[out, v.texture]; IO.PutRope[out, "\n"]; ENDLOOP; IO.PutRope[out, "\nSurfaces~ "]; IF index THEN IO.PutRope[out, " index: integer"]; IO.PutRope[out, " vertices: nats\n\n"]; FOR n: INT IN [0..shape.surfaces.length) DO polygon: NatSequence ~ shape.surfaces[n].vertices; IF index THEN IO.PutF1[out, "%g\t", IO.int[n]]; IF tallyOnPolys THEN IO.PutF1[out, "%g\t", IO.int[polygon.length]]; FOR nn: INT IN [0..polygon.length) DO IO.PutF1[out, "%5g ", IO.int[polygon[nn]]]; ENDLOOP; IO.PutRope[out, "\n"]; ENDLOOP; IO.Close[out]; }; ShapeToStreamPerFormat: PUBLIC PROC [shape: Shape, out: STREAM, format: ATOM] RETURNS [success: BOOL Ź TRUE] ~ { WriteShapeAsQuad: PROC ~ { <> <> <

> <> <> <> <> <> WriteQuad: PROC [surface: Surface, start: CARD] ~ { WriteVertex: PROC [v: Vertex] ~ { G3dIO.WriteTriple[out, v.point]; IF shape.vertices.valid[normal] THEN G3dIO.WriteTriple[out, v.normal]; IF shape.vertices.valid[color] THEN { G3dIO.WriteTriple[out, v.color]; IO.PutRope[out, "1.0 "]; }; IO.PutRope[out, "\n"]; }; WriteVertex[shape.vertices[surface.vertices[0]]]; WriteVertex[shape.vertices[surface.vertices[start]]]; WriteVertex[shape.vertices[surface.vertices[MIN[start+1, surface.vertices.length-1]]]]; WriteVertex[shape.vertices[surface.vertices[MIN[start+2, surface.vertices.length-1]]]]; IO.PutRope[out, "\n"]; }; IF shape.vertices.valid[color] THEN IO.PutRope[out, "C"]; IF shape.vertices.valid[normal] THEN IO.PutRope[out, "N"]; IO.PutRope[out, "POLY\n"]; FOR s: INT IN [0..shape.surfaces.length) DO surface: Surface Ź shape.surfaces[s]; lastWritten: INT Ź 1; WHILE lastWritten < INT[surface.vertices.length] DO IF surface.vertices.length-lastWritten > 1 THEN WriteQuad[surface, lastWritten]; lastWritten Ź lastWritten+2; ENDLOOP; ENDLOOP; }; WriteShapeAsDotNone: PROC ~ { <<.none format for University of Calgary's GraphicsJungle>> huskFileType: CHAR ~ 'x; huskOpenObject: CHAR ~ 'o; huskCloseObject: CHAR ~ 'O; huskPolygon: CHAR ~ 'p; huskNormalPoly: CHAR ~ 133+0C; huskColourfulPoly: CHAR ~ 129+0C; oneDRealRep: PACKED ARRAY [0..1] OF CARD32 ~ LOOPHOLE[DREAL[1.0]]; drealHi: [0..1] ~ IF oneDRealRep[1] = 0 THEN 0 ELSE 1; drealLo: [0..1] ~ 1-drealHi; WriteShort: PROC [i: INTEGER] ~ {IO.PutHWord[out, Basics.HFromInt16[i]]}; --16 bit int WriteDouble: PROC [dreal: DREAL] ~ { -- 64 bit double precision real <> a: PACKED ARRAY [0..1] OF CARD32 Ź LOOPHOLE[dreal]; IO.PutFWord[out, Basics.FFromCard32[a[drealHi]]]; IO.PutFWord[out, Basics.FFromCard32[a[drealLo]]]; }; WritePoint: PROC [p: Triple] ~ { WriteDouble[p.x]; WriteDouble[p.y]; WriteDouble[p.z]; }; WriteChar: PROC [c: CHAR] ~ {IO.PutChar[out, c]}; WriteString: PROC [r: ROPE] ~ {IO.PutRope[out, r]; IO.PutChar[out, 0C]}; WriteOpcode: PROC [c: CHAR, n: INTEGER] ~ {WriteChar[c]; WriteShort[n]}; WriteOpcode[huskFileType, 0]; WriteOpcode[huskOpenObject, Rope.Length[shape.name]+1]; WriteString[shape.name]; FOR s: INT IN [0..shape.surfaces.length) DO polygon: G3dShape.NatSequence Ź shape.surfaces[s].vertices; dsize: INT Ź 3*polygon.length*8; -- 8 = sizeof(double) ssize: INT Ź 3*polygon.length*2; -- 2 = sizeof(short) IF polygon.length < 3 THEN LOOP; WriteOpcode[huskColourfulPoly, ssize+2]; WriteShort[polygon.length]; FOR i: INT IN [0..polygon.length) DO -- color for each vertex color: Triple Ź shape.vertices[polygon[i]].color; IF NOT shape.vertices.valid[color] THEN color Ź [1.0, 1.0, 1.0]; WriteShort[Real.Round[65535.0*color.x]]; WriteShort[Real.Round[65535.0*color.y]]; WriteShort[Real.Round[65535.0*color.z]]; ENDLOOP; WriteOpcode[huskNormalPoly, dsize+2]; WriteShort[polygon.length]; FOR i: INT IN [0..polygon.length) DO -- normal for each vertex WritePoint[shape.vertices[polygon[i]].normal]; ENDLOOP; WriteOpcode[huskPolygon, dsize+2]; WriteShort[polygon.length]; FOR i: INT IN [0..polygon.length) DO -- position for each vertex WritePoint[shape.vertices[polygon[i]].point]; ENDLOOP; ENDLOOP; WriteOpcode[huskCloseObject, 0]; }; IF shape = NIL OR out = NIL OR shape.vertices = NIL OR shape.vertices.length = 0 OR shape.surfaces = NIL OR shape.surfaces.length = 0 THEN RETURN[FALSE] ELSE SELECT format FROM $Quad => WriteShapeAsQuad[]; $DotNone => WriteShapeAsDotNone[]; ENDCASE; }; <> ShapeFromData: PUBLIC PROC [ name: ROPE Ź NIL, surfaces: SurfaceSequence, vertices: TripleSequence, normals: TripleSequence Ź NIL, colors: TripleSequence Ź NIL, transmittances: RealSequence Ź NIL, textures: PairSequence Ź NIL, showBackfaces: BOOL Ź TRUE, faceted: BOOL Ź FALSE, type: ATOM Ź $ConvexPolygon] RETURNS [s: Shape] ~ { <> s Ź NEW[ShapeRep]; s Ź [name: name, surfaces: surfaces, showBackfaces: showBackfaces, type: type]; s.vertices Ź NEW[VertexSequenceRep[vertices.length]]; s.vertices.length Ź vertices.length; s.vertices.valid[normal] Ź normals # NIL; s.vertices.valid[color] Ź colors # NIL; s.vertices.valid[texture] Ź textures # NIL; s.vertices.valid[transmit] Ź transmittances # NIL; FOR n: CARDINAL IN [0..vertices.length) DO v: Vertex Ź s.vertices[n] Ź NEW[VertexRep Ź [point: vertices[n]]]; IF normals # NIL AND normals.length > n THEN v.normal Ź normals[n]; IF colors # NIL AND colors.length > n THEN v.color Ź colors[n]; IF transmittances # NIL AND transmittances.length > n THEN v.transmittance Ź transmittances[n]; IF textures # NIL AND textures.length > n THEN v.texture Ź textures[n]; ENDLOOP; }; <> CopyShape: PUBLIC PROC [shape: Shape] RETURNS [s: Shape] ~ { s Ź NEW[ShapeRep Ź []]; -- default top-level fields s.clientData Ź shape.clientData; s.sphereExtent Ź shape.sphereExtent; -- computed when original read in s.objectExtent Ź shape.objectExtent; s.showBackfaces Ź shape.showBackfaces; s.triangulated Ź shape.triangulated; s.matrix Ź G3dMatrix.CopyMatrix[shape.matrix]; s.props Ź NIL; -- make physical copy of proplist FOR list: PropList Ź shape.props, list.rest UNTIL list = NIL DO element: Atom.DottedPair Ź NEW[Atom.DottedPairNode Ź list.first]; s.props Ź CONS[element, s.props]; ENDLOOP; IF shape.vertices # NIL THEN { s.vertices Ź NEW[VertexSequenceRep[shape.vertices.length]]; -- copy vertices s.vertices.valid Ź shape.vertices.valid; s.vertices.length Ź shape.vertices.length; FOR i: INT IN [0..shape.vertices.length) DO s.vertices[i] Ź NEW[VertexRep Ź shape.vertices[i]]; ENDLOOP; }; IF s.faces # NIL THEN { s.faces Ź NEW[FaceSequenceRep[shape.faces.length]]; -- copy face data s.faces.valid Ź shape.faces.valid; s.faces.length Ź shape.faces.length; FOR i: INT IN [0..shape.faces.length) DO s.faces[i] Ź NEW[FaceRep Ź shape.faces[i]]; ENDLOOP; }; s.surfaces Ź G3dBasic.CopySurfaceSequence[shape.surfaces]; -- copy surface definition }; CombineShapes: PUBLIC PROC [shape1, shape2: Shape] RETURNS [s: Shape] ~ { q1: Quaternion Ź shape1.orientation; q2: Quaternion Ź shape2.orientation; q2a: Quaternion Ź IF G3dQuaternion.Dot[q1, q2] < 0 THEN G3dQuaternion.Neg[q2] ELSE q2; q: Quaternion Ź G3dQuaternion.Bisect[q1, q2a]; a: AxisAngle Ź G3dQuaternion.ToAxisAngle[q]; midPos: Triple Ź G3dVector.Midpoint[shape1.translation, shape2.translation]; midBase: Triple Ź G3dVector.Midpoint[shape1.rotationBase, shape2.rotationBase]; s Ź NEW[ShapeRep]; s.clientData Ź IF shape1.clientData # NIL THEN shape1.clientData ELSE shape2.clientData; s.name Ź Rope.Concat[shape1.name, shape2.name]; FOR l: PropList Ź shape1.props, l.rest WHILE l#NIL DO s.props Ź CONS[l.first, s.props]; ENDLOOP; FOR l: PropList Ź shape2.props, l.rest WHILE l#NIL DO s.props Ź CONS[l.first, s.props]; ENDLOOP; TransformShape[s, midPos, [midBase, a.unitAxis], a.theta, 0.5*(shape1.scale+shape2.scale)]; SELECT TRUE FROM shape1 = NIL OR shape1.vertices = NIL OR shape1.surfaces = NIL => RETURN[shape2]; shape2 = NIL OR shape2.vertices = NIL OR shape2.surfaces = NIL => RETURN[shape1]; ENDCASE => { CopyVertex: PROC [v: Vertex] RETURNS [vv: Vertex] ~ {vv Ź NEW[VertexRep Ź v]}; s.vertices Ź NEW[VertexSequenceRep[shape1.vertices.length+shape2.vertices.length]]; s.vertices.length Ź s.vertices.maxLength; FOR i: INT IN [0..shape1.vertices.length) DO s.vertices[i] Ź CopyVertex[shape1.vertices[i]]; ENDLOOP; FOR i: INT IN [0..shape2.vertices.length) DO s.vertices[i+shape1.vertices.length] Ź CopyVertex[shape2.vertices[i]]; ENDLOOP; s.surfaces Ź NEW[SurfaceSequenceRep[shape1.surfaces.length+shape2.surfaces.length]]; s.surfaces.length Ź s.surfaces.maxLength; FOR i: INT IN [0..shape1.surfaces.length) DO s.surfaces[i] Ź [NIL, G2dBasic.CopyNatSequence[shape1.surfaces[i].vertices]]; ENDLOOP; FOR i: INT IN [0..shape2.surfaces.length) DO n: NatSequence Ź G2dBasic.CopyNatSequence[shape2.surfaces[i].vertices]; FOR j: INT IN [0..n.length) DO n[j] Ź n[j]+shape1.vertices.length; ENDLOOP; s.surfaces[i+shape1.surfaces.length] Ź [NIL, n]; ENDLOOP; }; }; <> ComputeMatrix: PUBLIC PROC [shape: Shape] ~ { a: AxisAngle Ź G3dQuaternion.ToAxisAngle[shape.orientation]; TransformShape[shape, shape.translation, [shape.rotationBase, a.unitAxis], a.theta, shape.scale]; }; <<>> SetMatrix: PUBLIC PROC [shape: Shape, matrix: Matrix] ~ { shape.matrix Ź matrix; }; <<>> MatrixFromPars: PROC [translate: Triple, axis: Ray, rotation, scale: REAL, out: Matrix] RETURNS [m: Matrix] ~ { m Ź G3dMatrix.Scale[out, scale, m]; IF rotation # 0.0 THEN m Ź G3dMatrix.Rotate[m, axis.axis, rotation,, axis.base, m]; m Ź G3dMatrix.Translate[m, translate, m]; }; TransformShape: PUBLIC PROC [ shape: Shape, translate: Triple Ź [], axis: Ray Ź G3dShape.zAxis, rotation: REAL Ź 0.0, scale: REAL Ź 1.0, concat: BOOL Ź FALSE] ~ { q: Quaternion Ź shape.orientation; IF rotation # 0.0 AND axis.axis # [] THEN q Ź G3dQuaternion.FromAxisAngle[axis.axis, rotation]; IF NOT concat THEN { shape.rotationBase Ź axis.base; shape.orientation Ź q; shape.translation Ź translate; shape.scale Ź scale; }; IF NOT concat THEN shape.matrix Ź G3dMatrix.Identity[shape.matrix]; shape.matrix Ź MatrixFromPars[translate, axis, rotation, scale, shape.matrix]; shape.renderValid Ź FALSE; }; <<>> TransformVertices: PUBLIC PROC [shape: Shape, matrix: Matrix] ~ { IF shape # NIL AND shape.vertices # NIL THEN { nMatrix: Matrix Ź G3dMatrix.MakeVectorTransform[matrix, G3dMatrix.ObtainMatrix[]]; FOR n: INT IN [0..shape.vertices.length) DO v: Vertex Ź shape.vertices[n]; v.point Ź G3dMatrix.Transform[v.point, matrix]; v.normal Ź G3dMatrix.Transform[v.normal, nMatrix]; ENDLOOP; G3dMatrix.ReleaseMatrix[nMatrix]; shape.renderValid Ź FALSE; }; }; ApplyTransformsToShape: PUBLIC PROC [shape: Shape] ~ { IF shape = NIL THEN RETURN; TransformVertices[shape, shape.matrix]; shape.matrix Ź G3dMatrix.Identity[]; shape.objectExtent Ź BoundingBox[shape]; shape.sphereExtent Ź BoundingSphere[shape]; shape.renderValid Ź FALSE; IF shape.faces # NIL THEN { shape.faces.valid[normal] Ź FALSE; shape.faces.valid[center] Ź FALSE; }; IF shape.vertices # NIL THEN shape.vertices.valid[normal] Ź TRUE; }; <> DoWithVertices: PUBLIC PROC [shape: Shape, vertexProc: G3dShape.VertexProc] ~ { IF shape # NIL AND shape.vertices # NIL AND vertexProc # NIL THEN FOR n: INT IN [0..shape.vertices.length) DO IF NOT vertexProc[shape.vertices[n], n] THEN EXIT; ENDLOOP; }; VertexValid: PUBLIC PROC [shape: Shape, test: Validity] RETURNS [b: BOOL Ź FALSE] ~ { IF shape # NIL AND shape.vertices # NIL THEN RETURN[shape.vertices.valid[test]]; }; SetVertexNormals: PUBLIC PROC [shape: Shape] ~ { IF shape.vertices = NIL THEN RETURN; shape.vertices.valid[normal] Ź TRUE; IF NOT FaceValid[shape, normal] THEN SetFaceNormals[shape, FALSE]; FOR i: INT IN [0..shape.vertices.length) DO shape.vertices[i].normal Ź [0.0, 0.0, 0.0]; ENDLOOP; FOR i: INT IN [0..shape.surfaces.length) DO poly: NatSequence Ź shape.surfaces[i].vertices; faceNormal: Triple Ź shape.faces[i].normal; vPrev: Vertex Ź shape.vertices[poly[poly.length-1]]; v: Vertex Ź shape.vertices[poly[0]]; vec1: Triple Ź G3dVector.Unit[G3dVector.Sub[vPrev.point, v.point]]; FOR j: INT IN [0..poly.length) DO vNext: Vertex Ź shape.vertices[poly[(j+1) MOD poly.length]]; <> <<1-cos(>> vec2: Triple Ź G3dVector.Unit[G3dVector.Sub[vNext.point, v.point]]; weight: REAL Ź 1.0-G3dVector.Dot[vec1, vec2]; v.normal Ź G3dVector.Mul[G3dVector.Add[v.normal, faceNormal], weight]; vPrev Ź v; v Ź vNext; vec1 Ź G3dVector.Negate[vec2]; ENDLOOP; ENDLOOP; FOR i: INT IN [0..shape.vertices.length) DO v: Vertex Ź shape.vertices[i]; v.normal Ź G3dVector.Unit[v.normal]; ENDLOOP; }; SetFwdFacingVertices: PUBLIC PROC [shape: Shape, view: Matrix, screens: ScreenSequence] ~ { Action: SurfaceProc ~ { FOR i: INT IN [0..surface.length) DO screens[surface[i]].fwdFacing Ź TRUE; ENDLOOP; }; IF shape = NIL OR shape.vertices = NIL OR screens = NIL THEN RETURN; FOR n: INT IN [0..shape.vertices.length) DO screens[n].fwdFacing Ź FALSE; ENDLOOP; DoWithFacingPolygons[shape, view, Action]; }; UnitizeVertexNormals: PUBLIC PROC [shape: Shape] ~ { IF shape # NIL AND shape.vertices # NIL THEN FOR i: INT IN [0..shape.vertices.length) DO shape.vertices[i].normal Ź G3dVector.Unit[shape.vertices[i].normal]; ENDLOOP; }; NegateVertexNormals: PUBLIC PROC [shape: Shape] ~ { IF shape = NIL OR shape.vertices = NIL THEN RETURN; FOR n: INT IN [0..shape.vertices.length) DO shape.vertices[n].normal Ź G3dVector.Negate[shape.vertices[n].normal]; ENDLOOP; shape.renderValid Ź FALSE; shape.normalsNegated Ź NOT shape.normalsNegated; }; NumberOfVertices: PUBLIC PROC [shapes: ShapeSequence] RETURNS [num: INT Ź 0] ~ { IF shapes # NIL THEN FOR n: INT IN [0..shapes.length) DO s: Shape Ź shapes[n]; IF s # NIL AND s.vertices # NIL THEN num Ź num+s.vertices.length; ENDLOOP; }; SetExtent: PUBLIC PROC [screens: ScreenSequence] ~ { b: G2dBasic.Box Ź [[huge, huge], [-huge, -huge]]; FOR i: INT IN [0..screens.length) DO p: Pair Ź screens[i].pos; b Ź [[MIN[b.min.x, p.x], MIN[b.min.y, p.y]], [MAX[b.max.x, p.x], MAX[b.max.y, p.y]]]; ENDLOOP; screens.extent Ź b; screens.extentValid Ź TRUE; }; InterpolateVertex: PUBLIC PROC [t: REAL, v0, v1: Vertex] RETURNS [v: Vertex] ~ { InterpPair: PROC [t: REAL, p0, p1: Pair] RETURNS [Pair] ~ { RETURN[[p0.x+t*(p1.x-p0.x), p0.y+t*(p1.y-p0.y)]]; }; v Ź NEW[VertexRep]; v.point Ź G3dVector.Interp[t, v0.point, v1.point]; IF v0.normal # [] OR v1.normal # [] THEN v.normal Ź G3dVector.Unit[G3dVector.Interp[t, v0.normal, v1.normal]]; IF v0.color # [] OR v1.color # [] THEN v.color Ź G3dVector.Interp[t, v0.color, v1.color]; IF v0.texture#[0,0] OR v1.texture#[0,0] THEN v.texture Ź InterpPair[t, v0.texture, v1.texture]; }; <> DoWithAllPolygons: PUBLIC PROC [shape: Shape, action: SurfaceProc] ~ { IF shape # NIL AND action # NIL THEN FOR n: INT IN [0..shape.faces.length) DO Process.CheckForAbort[]; IF NOT action[shape.surfaces[n].vertices, n] THEN RETURN; ENDLOOP; }; DoWithFacingPolygons: PUBLIC PROC [ shape: Shape, view: Matrix, frontFacingAction, backFacingAction: SurfaceProc Ź NIL] ~ { IF shape # NIL AND view # NIL AND (frontFacingAction # NIL OR backFacingAction # NIL) THEN { persp: BOOL Ź G3dMatrix.HasPerspective[view]; inverse: Matrix Ź IF persp THEN G3dMatrix.Invert[view, G3dMatrix.ObtainMatrix[] ! G3dMatrix.singular => GOTO BadMatrix] ELSE NIL; q: G3dBasic.Quad Ź [inverse[3][0], inverse[3][1], inverse[3][2], inverse[3][3]]; camera: Triple Ź [q.x/q.w, q.y/q.w, q.z/q.w]; IF NOT FaceValid[shape, normal] THEN SetFaceNormals[shape]; IF NOT FaceValid[shape, center] THEN SetFaceCenters[shape]; FOR i: INT IN [0..shape.faces.length) DO visible: BOOL; poly: NatSequence Ź shape.surfaces[i].vertices; Process.CheckForAbort[]; IF poly.length < 3 THEN visible Ź TRUE ELSE { f: Face Ź shape.faces[i]; visible Ź IF persp <> THEN G3dVector.Dot[G3dVector.Sub[camera, f.center], f.normal] > 0.0 ELSE G3dVector.FrontFacingNoPerspective[f.normal, view]; }; IF visible AND frontFacingAction # NIL THEN {IF NOT frontFacingAction[poly, i] THEN RETURN}; IF NOT visible AND backFacingAction # NIL THEN {IF NOT backFacingAction[poly, i] THEN RETURN}; ENDLOOP; IF persp THEN G3dMatrix.ReleaseMatrix[inverse]; }; EXITS BadMatrix => NULL; }; FaceValid: PUBLIC PROC [shape: Shape, test: Validity] RETURNS [b: BOOL Ź FALSE] ~ { IF shape # NIL AND shape.faces # NIL THEN RETURN[shape.faces.valid[test]]; }; SetFwdFacingFaces: PUBLIC PROC [shape: Shape, view: Matrix] ~ { BackFaces: SurfaceProc ~ {shape.faces[index].fwdFacing Ź FALSE}; FrontFaces: SurfaceProc ~ {shape.faces[index].fwdFacing Ź TRUE}; DoWithFacingPolygons[shape, view, FrontFaces, BackFaces]; }; GetPolygonPoints: PUBLIC PROC [shape: Shape, nPoly: INT, points: TripleSequence Ź NIL] RETURNS [TripleSequence] ~ { poly: NatSequence Ź shape.surfaces[nPoly].vertices; IF poly = NIL OR shape.vertices = NIL THEN RETURN[NIL]; IF points = NIL OR points.maxLength < poly.length THEN points Ź NEW[TripleSequenceRep[poly.length]]; points.length Ź poly.length; FOR n: INT IN [0..poly.length) DO points[n] Ź shape.vertices[poly[n]].point; ENDLOOP; RETURN[points]; }; NewFaces: PROC [shape: Shape] ~ { shape.faces Ź NEW[FaceSequenceRep[shape.surfaces.length]]; FOR n: INT IN [0..shape.faces.length Ź shape.surfaces.length) DO poly: NatSequence Ź shape.surfaces[n].vertices; color: Triple Ź [0.0, 0.0, 0.0]; FOR i: INT IN [0..poly.length) DO color Ź G3dVector.Add[color, shape.vertices[poly[i]].color]; ENDLOOP; shape.faces[n] Ź NEW[FaceRep Ź [color: G3dVector.Div[color, REAL[poly.length]]]]; ENDLOOP; }; SetFaceNormals: PUBLIC PROC [shape: Shape, complyWithVertices: BOOL Ź TRUE] ~ { IF NOT FaceValid[shape, normal] THEN { points: TripleSequence Ź NEW[TripleSequenceRep[100]]; IF shape.faces = NIL THEN NewFaces[shape]; shape.faces.valid[normal] Ź TRUE; FOR n: INT IN [0..shape.surfaces.length) DO points Ź GetPolygonPoints[shape, n, points]; shape.faces[n].normal Ź G3dPolygon.PolygonNormal[points,, TRUE]; ENDLOOP; IF complyWithVertices AND shape.vertices # NIL <> THEN FOR n: INT IN [0..shape.surfaces.length) DO poly: NatSequence Ź shape.surfaces[n].vertices; normal: Triple Ź shape.faces[n].normal; IF G3dVector.Dot[normal, shape.vertices[poly[0]].normal] < 0.0 THEN shape.faces[n].normal Ź G3dVector.Negate[normal]; ENDLOOP; }; }; SetFaceCenters: PUBLIC PROC [shape: Shape] ~ { IF NOT FaceValid[shape, center] THEN { points: TripleSequence Ź NEW[TripleSequenceRep[100]]; IF shape.faces = NIL OR shape.faces.length < shape.surfaces.length THEN NewFaces[shape]; shape.faces.valid[center] Ź TRUE; FOR n: INT IN [0..shape.surfaces.length) DO points Ź GetPolygonPoints[shape, n, points]; shape.faces[n].center Ź G3dPolygon.PolygonCenter[points]; ENDLOOP; }; }; UnitizeFaceNormals: PUBLIC PROC [shape: Shape] ~ { IF shape # NIL AND shape.faces # NIL THEN FOR i: INT IN [0..shape.faces.length) DO shape.faces[i].normal Ź G3dVector.Unit[shape.faces[i].normal]; ENDLOOP; }; ReversePolygons: PUBLIC PROC [shape: Shape] ~ { IF shape = NIL OR shape.surfaces = NIL THEN RETURN; FOR n: INT IN [0..shape.surfaces.length) DO shape.surfaces[n].vertices Ź G3dPolygon.PolygonReverse[shape.surfaces[n].vertices]; ENDLOOP; <> shape.surfacesReversed Ź NOT shape.surfacesReversed; shape.renderValid Ź FALSE; }; NegateFaceNormals: PUBLIC PROC [shape: Shape] ~ { IF shape = NIL OR shape.vertices = NIL OR NOT shape.vertices.valid[normal] THEN RETURN; FOR n: INT IN [0..shape.faces.length) DO face: Face Ź shape.faces[n]; face.normal Ź G3dVector.Negate[face.normal]; ENDLOOP; shape.renderValid Ź FALSE; }; Triangulate: PUBLIC PROC [shape: Shape] ~ { old: SurfaceSequence Ź shape.surfaces; IF shape = NIL OR shape.surfaces = NIL THEN RETURN; shape.surfaces Ź NEW[SurfaceSequenceRep[old.length]]; FOR i: INT IN [0..old.length) DO poly: NatSequence Ź old[i].vertices; n0: INT Ź poly[0]; n1: INT Ź poly[1]; FOR ii: INT IN [2..poly.length) DO n2: INT Ź poly[ii]; nats: NatSequence Ź NEW[NatSequenceRep[3]]; nats[0] Ź n0; nats[1] Ź n1; nats[2] Ź n2; nats.length Ź 3; shape.surfaces Ź G3dBasic.AddToSurfaceSequence[shape.surfaces, [NIL, nats]]; n1 Ź n2; ENDLOOP; ENDLOOP; shape.renderValid Ź FALSE; shape.triangulated Ź TRUE; }; NumberOfPolygons: PUBLIC PROC [shapes: ShapeSequence] RETURNS [num: INT Ź 0] ~ { IF shapes # NIL THEN FOR n: INT IN [0..shapes.length) DO s: Shape Ź shapes[n]; IF s # NIL AND s.surfaces # NIL THEN num Ź num+s.surfaces.length; ENDLOOP; }; <> MakeEdges: PUBLIC PROC [shape: Shape] RETURNS [edges: EdgeSequence] ~ { EdgeInfo: TYPE ~ RECORD [maxV, poly0, poly1: INT Ź -1]; ListSequence: TYPE ~ RECORD [ length: INT Ź 0, element: SEQUENCE maxLength: INT OF LIST OF EdgeInfo ]; MaxNEdges: PROC RETURNS [max: INT Ź 0] ~ { FOR n: INT IN [0..shape.surfaces.length) DO max Ź max+shape.surfaces[n].vertices.length; ENDLOOP; }; IF shape # NIL AND shape.surfaces # NIL THEN { maxNEdges: INT Ź MaxNEdges[]; lists: REF ListSequence Ź NEW[ListSequence[maxNEdges]]; edges Ź NEW[G3dShape.EdgeSequenceRep[maxNEdges]]; FOR poly: INT IN [0..shape.surfaces.length) DO polygon: NatSequence ~ shape.surfaces[poly].vertices; n0: INT Ź polygon[polygon.length-1]; FOR i: INT IN [0..polygon.length) DO minV, maxV: INT; n1: INT Ź polygon[i]; IF n0 < n1 THEN {minV Ź n0; maxV Ź n1} ELSE {minV Ź n1; maxVŹ n0}; <> <> IF minV+1 > lists.length THEN { IF lists.maxLength <= minV+1 THEN { new: REF ListSequence Ź NEW[ListSequence[2*(minV+1)]]; -- fudge it high FOR n: INT IN [0..lists.length) DO new[n] Ź lists[n]; ENDLOOP; lists Ź new; }; lists.length Ź minV+1; }; FOR l: LIST OF EdgeInfo Ź lists[minV], l.rest WHILE l # NIL DO <> IF l.first.maxV = maxV THEN { l.first.poly1 Ź poly; EXIT; }; REPEAT <> FINISHED => { lists[minV] Ź CONS[[maxV: maxV, poly0: poly], lists[minV]]; }; ENDLOOP; n0 Ź n1; ENDLOOP; ENDLOOP; FOR minV: INT IN [0..lists.length) DO FOR l: LIST OF EdgeInfo Ź lists[minV], l.rest WHILE l # NIL DO e: Edge Ź edges[edges.length] Ź NEW[EdgeRep]; e Ź [minV, l.first.maxV, l.first.poly0, l.first.poly1]; edges.length Ź edges.length+1; ENDLOOP; ENDLOOP; }; }; FindEdge: PUBLIC PROC [edges: EdgeSequence, v0, v1: INT] RETURNS [index: INT Ź 0] ~ { IF edges = NIL OR edges.length = 0 THEN RETURN[-1]; IF v0 > v1 THEN {temp: INT Ź v0; v0 Ź v1; v1 Ź temp}; WHILE edges[index].v0 < v0 DO index Ź index+1; IF index = INT[edges.length] THEN RETURN[-1]; ENDLOOP; DO IF index = INT[edges.length] OR v0 # edges[index].v0 THEN RETURN[-1]; IF v1 = edges[index].v1 THEN RETURN[index]; index Ź index+1; ENDLOOP; }; <> ObjectScale: PUBLIC PROC [shape: Shape] RETURNS [REAL Ź 1.0] ~ { IF shape # NIL THEN { i: G3dBasic.Box Ź shape.objectExtent; b:REALŹMAX[ABS[i.min.x],ABS[i.min.y],ABS[i.min.z],ABS[i.max.x],ABS[i.max.y],ABS[i.max.z]]; RETURN[IF b > 0.0001 THEN 1.0/b ELSE 1.0]; }; }; PointsFromShape: PUBLIC PROC [shape: Shape, points: TripleSequence Ź NIL] RETURNS [TripleSequence] ~ { IF points = NIL OR points.maxLength < shape.vertices.length THEN points Ź NEW[TripleSequenceRep[shape.vertices.length]]; FOR n: INT IN [0..shape.vertices.length) DO points[n] Ź shape.vertices[n].point; ENDLOOP; points.length Ź shape.vertices.length; RETURN[points]; }; FindShape: PUBLIC PROC [shapes: ShapeSequence, shapeName: ROPE] RETURNS [s: Shape] ~ { IF shapes # NIL THEN FOR n: INT IN [0..shapes.length) DO IF Rope.Equal[shapes[n].name, shapeName, FALSE] THEN RETURN[shapes[n]]; ENDLOOP; }; SetTextureCoords: PUBLIC PROC [shape: Shape, textures: PairSequence] ~ { IF shape # NIL AND textures # NIL THEN FOR n: INT IN [0..MIN[shape.vertices.length, textures.length]) DO shape.vertices[n].texture Ź textures[n]; ENDLOOP; }; <> BoundingBox: PUBLIC PROC [shape: Shape] RETURNS [mm: Box3d] ~ { mm Ź [[huge, huge, huge], [-huge, -huge, -huge]]; FOR i: INT IN [0..shape.vertices.length) DO p: Triple ~ shape.vertices[i].point; IF p.x < mm.min.x THEN mm.min.x Ź p.x; IF p.x > mm.max.x THEN mm.max.x Ź p.x; IF p.y < mm.min.y THEN mm.min.y Ź p.y; IF p.y > mm.max.y THEN mm.max.y Ź p.y; IF p.z < mm.min.z THEN mm.min.z Ź p.z; IF p.z > mm.max.z THEN mm.max.z Ź p.z; ENDLOOP; }; BoundingSphere: PUBLIC PROC [shape: Shape] RETURNS [s: G3dShape.Sphere] ~ { box3d: Box3d Ź BoundingBox[shape]; s.center Ź G3dVector.Midpoint[box3d.min, box3d.max]; s.radius Ź 0.0; FOR n: INT IN [0..shape.vertices.length) DO -- find radius r: REAL Ź G3dVector.SquareDistance[shape.vertices[n].point, s.center]; IF r > s.radius THEN s.radius Ź r; ENDLOOP; s.radius Ź RealFns.SqRt[s.radius]; }; <> CopyShapeSequence: PUBLIC PROC [shapes: ShapeSequence] RETURNS [s: ShapeSequence] ~ { IF shapes = NIL THEN RETURN; s Ź NEW[ShapeSequenceRep[shapes.length]]; s.length Ź shapes.length; FOR n: INT IN [0..shapes.length) DO s[n] Ź shapes[n]; ENDLOOP; }; AddToShapeSequence: PUBLIC PROC [shapes: ShapeSequence, shape: Shape] RETURNS [ShapeSequence] ~ { IF shapes = NIL THEN shapes Ź NEW[ShapeSequenceRep[1]]; IF shapes.length = shapes.maxLength THEN shapes Ź LengthenShapeSequence[shapes]; shapes[shapes.length] Ź shape; shapes.length Ź shapes.length+1; RETURN[shapes]; }; <<>> LengthenShapeSequence: PUBLIC PROC [shapes: ShapeSequence, amount: REAL Ź 1.3] RETURNS [new: ShapeSequence] ~ { newLength: INT Ź MAX[Real.Ceiling[amount*shapes.maxLength], 3]; new Ź NEW[ShapeSequenceRep[newLength]]; FOR i: INT IN [0..shapes.length) DO new[i] Ź shapes[i]; ENDLOOP; new.length Ź shapes.length; }; CopyVertexSequence: PUBLIC PROC [vertices: VertexSequence] RETURNS [i: VertexSequence] ~ { IF vertices = NIL THEN RETURN; i Ź NEW[VertexSequenceRep[vertices.length]]; i.length Ź vertices.length; FOR n: INT IN [0..vertices.length) DO i[n] Ź vertices[n]; ENDLOOP; }; AddToVertexSequence: PUBLIC PROC [vertices: VertexSequence, vertex: Vertex] RETURNS [new: VertexSequence] ~ { IF (new Ź vertices) = NIL THEN new Ź NEW[VertexSequenceRep[1]]; IF new.length = new.maxLength THEN new Ź LengthenVertexSequence[new]; new[new.length] Ź vertex; new.length Ź new.length+1; }; <<>> LengthenVertexSequence: PUBLIC PROC [vertices: VertexSequence, amount: REAL Ź 1.3] RETURNS [new: VertexSequence] ~ { newLength: INT Ź 5+Real.Round[amount*vertices.length]; new Ź NEW[VertexSequenceRep[newLength]]; new.valid Ź vertices.valid; FOR i: INT IN [0..vertices.length) DO new[i] Ź vertices[i]; ENDLOOP; new.length Ź vertices.length; }; CopyFaceSequence: PUBLIC PROC [faces: FaceSequence] RETURNS [i: FaceSequence] ~ { IF faces = NIL THEN RETURN; i Ź NEW[FaceSequenceRep[faces.length]]; i.length Ź faces.length; FOR n: INT IN [0..faces.length) DO i[n] Ź faces[n]; ENDLOOP; }; AddToFaceSequence: PUBLIC PROC [faces: FaceSequence, face: Face] RETURNS [new: FaceSequence] ~ { IF (new Ź faces) = NIL THEN new Ź NEW[FaceSequenceRep[1]]; IF new.length = new.maxLength THEN new Ź LengthenFaceSequence[new]; new[new.length] Ź face; new.length Ź new.length+1; }; <<>> LengthenFaceSequence: PUBLIC PROC [faces: FaceSequence, amount: REAL Ź 1.3] RETURNS [new: FaceSequence] ~ { newLength: INT Ź MAX[Real.Round[amount*faces.length], 3]; new Ź NEW[FaceSequenceRep[newLength]]; new.valid Ź faces.valid; FOR i: INT IN [0..faces.length) DO new[i] Ź faces[i]; ENDLOOP; new.length Ź faces.length; }; END.