<<>> <> <> <> DIRECTORY CedarProcess, Draw2d, G3dBasic, G3dCubeDraw, G3dDraw, G3dMatrix, G3dOctree, G3dPlane, G3dPolygon, G3dShape, G3dVector, Imager, ImagerPath, ImplicitDraw, ImplicitDefs, ImplicitPoints, ImplicitPolygons, ImplicitSurface, Real; ImplicitDrawImpl: CEDAR PROGRAM IMPORTS CedarProcess, G3dCubeDraw, G3dDraw, G3dOctree, G3dVector, Imager, ImagerPath, ImplicitPoints, ImplicitPolygons, ImplicitSurface, Real EXPORTS ImplicitDraw ~ BEGIN MarkType: TYPE ~ Draw2d.MarkType; NatSequence: TYPE ~ G3dBasic.NatSequence; Triple: TYPE ~ G3dBasic.Triple; Cube: TYPE ~ G3dOctree.Cube; Octant: TYPE ~ G3dOctree.Octant; <> DiagramProgress: PUBLIC PROC [ context: Imager.Context, surface: ImplicitDefs.Surface, whatChanged: REF ANY, refAny: REF ANY, view: G3dMatrix.Matrix, viewport: G3dMatrix.Viewport Ź [], currentCube: Cube Ź NIL, drawEdges: BOOL Ź FALSE, drawPolygons: BOOL Ź FALSE, drawRoots: BOOL Ź FALSE] ~ { Mark: PROC [mark: MarkType] ~ { vertex: G3dShape.Vertex Ź NARROW[refAny]; SELECT mark FROM x => G3dDraw.Mark[context, vertex.point, view, vp,, x]; dot => G3dDraw.Box[context, vertex.point, view, vp, 3, 3]; ENDCASE; }; root: Cube Ź IF surface # NIL AND surface.octree # NIL THEN surface.octree.root ELSE NIL; vp: G3dMatrix.Viewport Ź viewport; SELECT whatChanged FROM $NewCube, $MakeOctree => { IF drawEdges THEN G3dCubeDraw.SimpleCube[context, currentCube, view, vp,, dotted]; IF drawRoots THEN G3dCubeDraw.SimpleCube[context, root, view, vp, TRUE, solid]; }; $NewRoot => IF drawRoots THEN G3dCubeDraw.SimpleCube[context, root, view, vp, TRUE, solid]; $AdaptOctree => { m: MarkType Ź SELECT refAny FROM $Dot => dot, $Cross => cross, ENDCASE => x; G3dDraw.Mark[context, G3dOctree.Center[currentCube], view, vp,, m]; }; $SetCorners => G3dCubeDraw.SimpleCube[context, currentCube, view, vp,, solid]; $MakePolygons => IF drawPolygons THEN DrawPolygon[context, surface, NARROW[refAny, NatSequence]]; $MakeVertices => IF drawPolygons THEN Mark[dot]; $MakeTextures => IF drawPolygons THEN Mark[x]; NIL => { IF drawEdges THEN G3dCubeDraw.TerminalCubes[context, root, view, vp, dotted]; IF drawRoots THEN G3dCubeDraw.SimpleCube[context, root, view, vp, TRUE, solid]; }; ENDCASE; }; DrawPolygon: PUBLIC PROC [ context: Imager.Context, surface: ImplicitDefs.Surface, polygon: NatSequence, clipCube: Cube Ź NIL, directionSelect: G3dOctree.DirectionSelect Ź xyz, forInterpress: BOOL Ź FALSE] ~ { IF polygon = NIL OR polygon.length < 3 OR clipCube = NIL OR surface = NIL THEN RETURN; FOR i: NAT IN [0..polygon.length) DO IF NOT G3dOctree.PointInCube[surface.vertices[polygon[i]].point, clipCube, .05] THEN RETURN; ENDLOOP; IF forInterpress THEN { t: Imager.Trajectory Ź ImagerPath.MoveTo[surface.screens[polygon[0]].pos]; FOR n: NAT IN [1..polygon.length) DO t Ź ImagerPath.LineTo[t, surface.screens[polygon[n]].pos]; ENDLOOP; Imager.SetStrokeJoint[context, round]; Imager.MaskStrokeTrajectory[context, t, TRUE]; } ELSE { Eq: PROC [r, s: REAL] RETURNS [b: BOOL] ~ INLINE {b Ź ABS[r-s] < 0.0001}; Rnd: PROC [r: REAL] RETURNS [i: INT] ~ INLINE {i Ź Real.Round[r]}; s0, s1: G3dBasic.Pair; n0, n1: NAT Ź polygon[polygon.length-1]; p0, p1: Triple Ź surface.vertices[n0].point; FOR i: NAT IN [0..polygon.length) DO n0 Ź n1; p0 Ź p1; p1 Ź surface.vertices[n1 Ź polygon[i]].point; IF directionSelect # xyz THEN SELECT directionSelect FROM x => IF Eq[p0.x, p1.x] THEN LOOP; y => IF Eq[p0.y, p1.y] THEN LOOP; z => IF Eq[p0.z, p1.z] THEN LOOP; xy => IF Eq[p0.x, p1.x] OR Eq[p0.y, p1.y] THEN LOOP; xz => IF Eq[p0.x, p1.x] OR Eq[p0.z, p1.z] THEN LOOP; yz => IF Eq[p0.y, p1.y] OR Eq[p0.z, p1.z] THEN LOOP; ENDCASE; s0 Ź surface.screens[n0].pos; s1 Ź surface.screens[n1].pos; G3dDraw.Line2d[context, [Rnd[s0.x], Rnd[s0.y]], [Rnd[s1.x], Rnd[s1.y]], solid]; ENDLOOP; }; }; <> DoWithPlanarContours: PUBLIC PROC [ octree: G3dOctree.Octree, edgeMode: ImplicitDefs.EdgeMode, valueProc: ImplicitDefs.ValueProc, threshold: REAL Ź 1.0, connectProc: ImplicitDefs.ConnectProc, clientData: REF ANY, normal: Triple, -- normal should be unit length wMin, wMax, wDelta: REAL] ~ { DoWithPlanarContour: PROC [plane: G3dPlane.Plane] ~ { UnSet: G3dOctree.CubeProc ~ { FOR o: Octant IN Octant DO cube.corners[o].valueSet Ź FALSE; ENDLOOP; }; Set: G3dOctree.CubeProc ~ { FOR o: Octant IN Octant DO c: G3dOctree.Corner ~ cube.corners[o]; IF NOT c.valueSet THEN ImplicitPoints.SetCornerValue[ c, c.point.x*plane.x+c.point.y*plane.y+c.point.z*plane.z+plane.w]; ENDLOOP; }; Converge: PROC [p0, p1: Triple, v0, v1: REAL, nTriesLimit: NAT] RETURNS [t: Triple] ~ { pIn, pOut: Triple; vIn, vOut: REAL; IF v0 > 0.0 THEN {pIn Ź p0; pOut Ź p1; vIn Ź v0; vOut Ź v1} ELSE {pIn Ź p1; pOut Ź p0; vIn Ź v1; vOut Ź v0}; t Ź ImplicitSurface.SegmentConverge[pIn, pOut, vIn, vOut, HLEValue, threshold, clientData,, octree.mode.tolerance,, nTriesLimit].point; }; polygonProc: G3dPolygon.PolygonProc ~ { Contour: PROC [p0, p1: Triple, depth, nTriesLimit: NAT] ~ { IF depth = 3 THEN connectProc[p0, p1] ELSE { SetValues: PROC [mul: REAL] ~ { xMul: Triple Ź G3dVector.Mul[x, mul*len]; x0 Ź G3dVector.Add[m, xMul]; x1 Ź G3dVector.Sub[m, xMul]; v0 Ź HLEValue[x0, clientData]; v1 Ź HLEValue[x1, clientData]; }; m, x0, x1: Triple Ź G3dVector.Midpoint[p0, p1]; dif: Triple Ź G3dVector.Sub[p1, p0]; len, v0, v1: REAL Ź G3dVector.Length[dif]; x: Triple Ź G3dVector.Unit[G3dVector.Cross[normal, dif]]; SetValues[0.2]; IF (v0 > 0.0) = (v1 > 0.0) THEN SetValues[0.4]; IF (v0 > 0.0) # (v1 > 0.0) THEN { p: Triple Ź Converge[x0, x1, v0, v1, nTriesLimit]; Contour[p0, p, depth+1, nTriesLimit-1]; Contour[p, p1, depth+1, nTriesLimit-1]; }; }; }; p0, p1: Triple Ź []; i0: NAT Ź polygon[polygon.length-1]; FOR n: NAT IN [0..polygon.length) DO i: NAT Ź polygon[n]; values[i] Ź HLEValue[vertices[i], clientData]; ENDLOOP; FOR n: NAT IN [0..polygon.length) DO i1: NAT Ź polygon[n]; IF (values[i0] > 0.0) # (values[i1] > 0.0) THEN { p: Triple Ź Converge[vertices[i0], vertices[i1], values[i0], values[i1], 6]; IF p0 = [] THEN p0 Ź p ELSE IF p1 = [] THEN p1 Ź p ELSE EXIT; }; i0 Ź i1; ENDLOOP; IF p0 # [] AND p1 # [] THEN Contour[p0, p1, 1, 15]; }; SetPlaneCrossings: PROC [cube: Cube] ~ { id: NAT Ź 0; crossedEdges: G3dOctree.CrossedEdges Ź ImplicitPoints.CubeCrossedEdges[cube]; FOR e: G3dOctree.Edge IN G3dOctree.Edge DO x: G3dOctree.CrossedEdge Ź crossedEdges[e]; IF x.cIn # NIL THEN { NewCross: PROC RETURNS [cross: G3dOctree.Cross] ~ { dif: REAL Ź x.cIn.value-x.cOut.value; point: Triple Ź x.cIn.point; IF dif # 0.0 THEN { alpha: REAL Ź x.cIn.value/dif; SELECT d FROM l, r => point.x Ź (1.0-alpha)*x.cIn.point.x+alpha*x.cOut.point.x; b, t => point.y Ź (1.0-alpha)*x.cIn.point.y+alpha*x.cOut.point.y; n, f => point.z Ź (1.0-alpha)*x.cIn.point.z+alpha*x.cOut.point.z; ENDCASE => ERROR; }; vertices[id] Ź point; cross Ź NEW[G3dOctree.CrossRep Ź [id: id]]; id Ź id+1; }; d: G3dOctree.Direction Ź G3dOctree.DirectionFromOctants[x.oIn, x.oOut]; c: G3dOctree.Corner ~ SELECT d FROM l, b, n => x.cIn, ENDCASE => x.cOut; SELECT d FROM l, r => c.lCross Ź NewCross[]; b, t => c.bCross Ź NewCross[]; n, f => c.nCross Ź NewCross[]; ENDCASE => ERROR; }; ENDLOOP; }; OctreeDescend: PROC [cube: Cube] ~ { CedarProcess.CheckAbort[]; IF cube = NIL OR NOT ImplicitPoints.IsCrossed[cube] THEN RETURN; IF cube.terminal THEN { SetPlaneCrossings[cube]; [] Ź ImplicitPolygons.PolygonizeCube[cube, polygonProc, polygon, FALSE]; } ELSE FOR o: Octant IN Octant DO OctreeDescend[cube.kids[o]]; ENDLOOP; }; HLEValue: ImplicitDefs.ValueProc ~ { -- heart of the HLE value Ź valueProc[point, clientData]; FOR n: NAT IN [0..nPreviousSlices) DO point Ź G3dVector.Sub[point, normalDelta]; value Ź MAX[value, valueProc[point, clientData]]; IF value >= threshold THEN EXIT; -- hidden ENDLOOP; }; G3dOctree.Apply[octree.root, UnSet]; CedarProcess.CheckAbort[]; G3dOctree.Apply[octree.root, Set]; OctreeDescend[octree.root]; }; polygon: NatSequence Ź NEW[G3dBasic.NatSequenceRep[24]]; vertices: G3dBasic.TripleSequence Ź NEW[G3dBasic.TripleSequenceRep[24]]; values: G3dBasic.RealSequence Ź NEW[G3dBasic.RealSequenceRep[24]]; normalDelta: Triple Ź G3dVector.Mul[normal, wDelta]; nPreviousSlices: NAT Ź 0; IF octree # NIL THEN FOR w: REAL Ź wMin, w+wDelta WHILE w <= wMax DO DoWithPlanarContour[[normal.x, normal.y, normal.z, wMax+wMin-w]]; -- wMax to wMin nPreviousSlices Ź nPreviousSlices+1; ENDLOOP; }; END. .. <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<~ {>> <> <> <> <> <> <> <> < limit THEN RETURN;>> <> <> <<};>> <> <> <> <> <<}>> <> <> <> <<};>> <<};>> <> <> <> <> <> <> <> <<};>> <> <<};>> <> <> <> <> <<};>> <> <> < CONTINUE;>> <