DIRECTORY
BasicObject3d,
CastRays,
CoordSys,
CSG,
CSGGraphics,
DisplayList3d,
Graphics,
IO,
ObjectCast,
PredefSweeps,
Rope,
Shading,
SV2d,
SVBoundBox,
SVFaces,
SVPolygon2d,
SVPolygon3d,
SweepCast,
SweepGeometry,
TFI3d,
TFO3d;

BasicObject3dImpl: PROGRAM
IMPORTS DisplayList3d, IO, ObjectCast, PredefSweeps, SVBoundBox, SVPolygon2d, SVPolygon3d, SweepCast, SweepGeometry, TFI3d, TFO3d
EXPORTS BasicObject3d =
BEGIN



Cone: TYPE = SVFaces.Cone;
DiskRing: TYPE = SVFaces.DiskRing;
Cylinder: TYPE = SVFaces.Cylinder;

BoundHedron: TYPE = REF BoundHedronObj;
BoundHedronObj: TYPE = SVBoundBox.BoundHedronObj;
Camera: TYPE = CSGGraphics.Camera;
LinearMeshArray: TYPE = SweepGeometry.LinearMeshArray;
RevoluteMeshArray: TYPE = SweepGeometry.RevoluteMeshArray;
Path: TYPE = REF PathObj;
PathObj: TYPE = SV2d.PathObj;
Point2d: TYPE = SV2d.Point2d;
Poly3d: TYPE = REF Poly3dObj;
Poly3dObj: TYPE = SVPolygon3d.Poly3dObj;
Polygon: TYPE = REF PolygonObj;
PolygonObj: TYPE = SV2d.PolygonObj;
LinearMesh: TYPE = REF LinearMeshRecord;
LinearMeshRecord: TYPE = SweepGeometry.LinearMeshRecord;
RevoFace: TYPE = SweepCast.RevoFace;
RevoluteMesh: TYPE = REF RevoluteMeshRecord;
RevoluteMeshRecord: TYPE = SweepGeometry.RevoluteMeshRecord;
SubBoxesBody: TYPE = REF SubBoxesBodyObj;
SubBoxesBodyObj: TYPE = SweepCast.SubBoxesBodyObj;
ToroidalMesh: TYPE = REF ToroidalMeshRecord;
ToroidalMeshRecord: TYPE = SweepGeometry.ToroidalMeshRecord;



BoundBox: TYPE = SVBoundBox.BoundBox;
CoordSystem: TYPE = REF CoordSysObj;
CoordSysObj: TYPE = CoordSys.CoordSysObj;
LightSourceList: TYPE = Shading.LightSourceList;
PlanarSurface: TYPE = REF PlanarSurfaceObj;
PlanarSurfaceObj: TYPE = DisplayList3d.PlanarSurfaceObj;
PlanarSurfaceList: TYPE = DisplayList3d.PlanarSurfaceList;



Classification: TYPE =  REF ClassificationObj;
ClassificationObj: TYPE = CastRays.ClassificationObj;

Ray: TYPE = REF RayObj;
RayObj: TYPE = CSG.RayObj;


Assembly: TYPE = REF AssemblyObj;
AssemblyObj: TYPE = DisplayList3d.AssemblyObj;

MasterObject: TYPE = REF MasterObjectRec;
MasterObjectRec: TYPE = DisplayList3d.MasterObjectRec;

MasterObjectClass: TYPE = REF MasterObjectClassObj;
MasterObjectClassObj: TYPE = DisplayList3d.MasterObjectClassObj;
MasterObjectClassList: TYPE = DisplayList3d.MasterObjectClassList; -- LIST OF MasterObjectClass


RayCastProc: TYPE = CSG.RayCastProc;
PreprocessProc: TYPE = DisplayList3d.PreprocessProc;
LineDrawProc: TYPE = DisplayList3d.LineDrawProc;
NormalsDrawProc: TYPE = DisplayList3d.NormalsDrawProc;
CountPlanarSurfacesProc: TYPE = DisplayList3d.CountPlanarSurfacesProc;
GetPlanarSurfacesProc: TYPE = DisplayList3d.GetPlanarSurfacesProc;
DrawPlanarSurfaceProc: TYPE = DisplayList3d.DrawPlanarSurfaceProc;
DrawSubBoxesProc: TYPE = DisplayList3d.DrawSubBoxesProc;

SurfaceArray: TYPE = REF SurfaceArrayObj;
SurfaceArrayObj: TYPE = CSG.SurfaceArrayObj;

Primitive: TYPE = REF PrimitiveObj;
PrimitiveObj: TYPE = CSG.PrimitiveObj;

Composite: TYPE = REF CompositeObj;
CompositeObj: TYPE = CSG.CompositeObj;

RectSurface: TYPE = REF RectSurfaceObj;
RectSurfaceObj: TYPE = ObjectCast.RectSurfaceObj;

TubeSurface: TYPE = REF TubeSurfaceObj;
TubeSurfaceObj: TYPE = ObjectCast.TubeSurfaceObj;

DiskSurface: TYPE = REF DiskSurfaceObj;
DiskSurfaceObj: TYPE = ObjectCast.DiskSurfaceObj;

ShellSurface: TYPE = REF ShellSurfaceObj;
ShellSurfaceObj: TYPE = ObjectCast.ShellSurfaceObj;

ConeSurface: TYPE = REF ConeSurfaceObj;
ConeSurfaceObj: TYPE = ObjectCast.ConeSurfaceObj;

ToroidalSurface: TYPE = REF ToroidalSurfaceObj;
ToroidalSurfaceObj: TYPE = ObjectCast.ToroidalSurfaceObj;



SphereRec: TYPE = REF SphereRecObj;
SphereRecObj: TYPE = BasicObject3d.SphereRecObj;

BlockRec: TYPE = REF BlockRecObj;
BlockRecObj: TYPE = BasicObject3d.BlockRecObj;

CylinderRec: TYPE = REF CylinderRecObj;
CylinderRecObj: TYPE = BasicObject3d.CylinderRecObj;

ConeRec: TYPE = REF ConeRecObj;
ConeRecObj: TYPE = BasicObject3d.ConeRecObj;

TorusRec: TYPE = REF TorusRecObj;
TorusRecObj: TYPE = BasicObject3d.TorusRecObj;

sphereClass, blockClass, cylinderClass, coneClass, torusClass, linClass, revoClass: MasterObjectClass;

WrongTypeOfData: PUBLIC SIGNAL = CODE;

SphereBody: PRIVATE PROC RETURNS [sphereRec: SphereRec] = {
sphereRec _ NEW[SphereRecObj];
sphereRec.radius _ 1;
};

SphereMakeMasterObject: PUBLIC PROC [name: Rope.ROPE] RETURNS [mo: MasterObject] = {
mainBody: SphereRec _ SphereBody[];
lineBody: REF ANY _ PredefSweeps.GetUnitSphere[];
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ SphereGetRayCastBody[];
mo _ DisplayList3d.CreateMasterObject[name, sphereClass, mainBody, lineBody, shadeBody, rayCastBody];
};

SphereBoundHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
hedron _ SVBoundBox.HexagonalBoundHedron[1, 1];
};

SphereGetRayCastBody: PRIVATE PROC [] RETURNS [shellS: ShellSurface] = {
shellS _ NEW[ShellSurfaceObj];
};

SphereRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.SphereCast[localRay, NARROW[mo.rayCastBody], prim]];
};

SphereRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.SphereCast[localRay, NARROW[mo.rayCastBody], prim]];
};

SphereLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawRevoluteSweep[dc, revMesh, camera, localCS];
};
SphereDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsRevoluteSweep[dc, revMesh, camera, localCS];
};
SphereCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesRevoluteSweep[revMesh];
};
SphereCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesRevoluteSweep[revMesh];
};
SphereGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesRevoluteSweep[revMesh, assembly, camera];
};
SphereDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceRevoluteSweep[dc, ps, lightSources, camera];
};

SphereFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
f.PutChar[IO.TAB];
f.PutF["data: procedural\n"];
};
SphereFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
TFI3d.ReadRope[f, "data: procedural"];
TFI3d.ReadBlank[f];
mo _ SphereMakeMasterObject[name];
};

BlockBody: PRIVATE PROC RETURNS [blockRec: BlockRec] = {
blockRec _ NEW[BlockRecObj];
blockRec.x _ 2; blockRec.y _ 2; blockRec.z _ 2;
};

BlockMakeMasterObject: PUBLIC PROC [name: Rope.ROPE] RETURNS [mo: MasterObject] = {
mainBody: BlockRec _ BlockBody[];
lineBody: REF ANY _ PredefSweeps.GetUnitCube[];
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ BlockGetRayCastBody[];
mo _ DisplayList3d.CreateMasterObject[name, blockClass, mainBody, lineBody, shadeBody, rayCastBody];
};

BlockBoundHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
hedron _ SVBoundBox.RectangularBoundHedron[2, 2, 2];
};

BlockGetRayCastBody: PRIVATE PROC [] RETURNS [surfaceArray: SurfaceArray] = {
upS, downS, frontS, backS, rightS, leftS: RectSurface;
surfaceArray  _ NEW[SurfaceArrayObj];
upS _ NEW[RectSurfaceObj _ [up]];
downS _ NEW[RectSurfaceObj _ [down]];
frontS _ NEW[RectSurfaceObj _ [front]];
backS _ NEW[RectSurfaceObj _ [back]];
rightS _ NEW[RectSurfaceObj _ [right]];
leftS _ NEW[RectSurfaceObj _ [left]];
surfaceArray[1] _ upS;
surfaceArray[2] _ downS;
surfaceArray[3] _ frontS;
surfaceArray[4] _ backS;
surfaceArray[5] _ rightS;
surfaceArray[6] _ leftS;
}; -- end of BlockGetRayCastBody

BlockRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.BlockCast[localRay, NARROW[mo.rayCastBody], prim]];
};

BlockRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.BlockCast[localRay, NARROW[mo.rayCastBody], prim]];
};

BlockLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
linMesh: LinearMesh;
IF ISTYPE[data, LinearMesh]
THEN linMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawLinearSweep[dc, linMesh, camera, localCS];
};
BlockDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
linMesh: LinearMesh;
IF ISTYPE[data, LinearMesh]
THEN linMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsLinearSweep[dc, linMesh, camera, localCS];
};
BlockCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesLinearSweep[linMesh];
};
BlockCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesLinearSweep[linMesh];
};
BlockGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesLinearSweep[linMesh, assembly, camera];
};
BlockDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceLinearSweep[dc, ps, lightSources, camera];
};

BlockFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
TFI3d.ReadRope[f, "data: procedural"];
TFI3d.ReadBlank[f];
mo _ BlockMakeMasterObject[name];
};
BlockFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
f.PutF["data: procedural\n"];
};

CylinderBody: PRIVATE PROC RETURNS [cylinderRec: CylinderRec] = {
cylinderRec _ NEW[CylinderRecObj];
cylinderRec.radius _ 1; cylinderRec.height _ 2;
};

CylinderMakeMasterObject: PUBLIC PROC [name: Rope.ROPE] RETURNS [mo: MasterObject] = {
mainBody: CylinderRec _ CylinderBody[];
lineBody: REF ANY _ PredefSweeps.GetUnitCylinder[];
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ CylinderGetRayCastBody[];
mo _ DisplayList3d.CreateMasterObject[name, cylinderClass, mainBody, lineBody, shadeBody, rayCastBody];
};

CylinderBoundHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
hedron _ SVBoundBox.HexagonalBoundHedron[1,1];
};

CylinderGetRayCastBody: PRIVATE PROC [] RETURNS [surfaceArray: SurfaceArray] = {
topS, bottomS: DiskSurface;
tubeS: TubeSurface;
surfaceArray  _ NEW[SurfaceArrayObj];
topS _ NEW[DiskSurfaceObj _ [top]];
bottomS _ NEW[DiskSurfaceObj _ [bottom]];
tubeS _ NEW[TubeSurfaceObj];
surfaceArray[1] _ topS;
surfaceArray[2] _ bottomS;
surfaceArray[3] _ tubeS;
}; -- end of CylinderGetRayCastBody

CylinderRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.CylinderCast[localRay, NARROW[mo.rayCastBody], prim]];
};

CylinderRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.CylinderCast[localRay, NARROW[mo.rayCastBody], prim]];
};

CylinderLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawRevoluteSweep[dc, revMesh, camera, localCS]; 
};
CylinderDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsRevoluteSweep[dc, revMesh, camera, localCS]; 
};
CylinderCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesRevoluteSweep[revMesh];
};
CylinderCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesRevoluteSweep[revMesh];
};
CylinderGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesRevoluteSweep[revMesh, assembly, camera];
};
CylinderDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceRevoluteSweep[dc, ps, lightSources, camera];
};

CylinderFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
TFI3d.ReadRope[f, "data: procedural"];
TFI3d.ReadBlank[f];
mo _ CylinderMakeMasterObject[name];
};
CylinderFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
f.PutF["data: procedural\n"];
};

ConeBody: PRIVATE PROC RETURNS [coneRec: ConeRec] = {
coneRec _ NEW[ConeRecObj];
coneRec.radius _ 1; coneRec.height _ 1;
};

ConeMakeMasterObject: PUBLIC PROC [name: Rope.ROPE] RETURNS [mo: MasterObject] = {
mainBody: ConeRec _ ConeBody[];
lineBody: REF ANY _ PredefSweeps.GetUnitCone[];
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ ConeGetRayCastBody[];
mo _ DisplayList3d.CreateMasterObject[name, coneClass, mainBody, lineBody, shadeBody, rayCastBody];
};

ConeBoundHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
hedron _ SVBoundBox.HexPyramidBoundHedron[1,1];
};

ConeGetRayCastBody: PRIVATE PROC [] RETURNS [surfaceArray: SurfaceArray] = {
coneS: ConeSurface;
diskS: DiskSurface;
surfaceArray  _ NEW[SurfaceArrayObj];
coneS _ NEW[ConeSurfaceObj];
diskS _ NEW[DiskSurfaceObj];
surfaceArray[1] _ coneS;
surfaceArray[2] _ diskS;
}; -- end of ConeGetRayCastBody

ConeRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.ConeCast[localRay, NARROW[mo.rayCastBody], prim]];};

ConeRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
RETURN[ObjectCast.ConeCast[localRay, NARROW[mo.rayCastBody], prim]];};

ConeLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawRevoluteSweep[dc, revMesh, camera, localCS];
};
ConeDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsRevoluteSweep[dc, revMesh, camera, localCS];
};
ConeCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesRevoluteSweep[revMesh];
};

ConeCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesRevoluteSweep[revMesh];
};

ConeGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesRevoluteSweep[revMesh, assembly, camera];
};
ConeDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceRevoluteSweep[dc, ps, lightSources, camera];
};

ConeFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
TFI3d.ReadRope[f, "data: procedural"];
TFI3d.ReadBlank[f];
mo _ ConeMakeMasterObject[name];
};
ConeFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
f.PutF["data: procedural\n"];
};

TorusBody: PRIVATE PROC [bigRadius: REAL, sectionRadius: REAL] RETURNS [torusRec: TorusRec] = {
torusRec _ NEW[TorusRecObj];
torusRec.bigRadius _ bigRadius;
torusRec.sectionRadius _ sectionRadius;
};

TorusMakeMasterObject: PUBLIC PROC [name: Rope.ROPE, bigRadius: REAL, sectionRadius: REAL] RETURNS [mo: MasterObject] = {
mainBody: TorusRec _ TorusBody[bigRadius, sectionRadius];
lineBody: REF ANY _ PredefSweeps.CreateTorus[mainBody.bigRadius, mainBody.sectionRadius];
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ TorusGetRayCastBody[];
mo _ DisplayList3d.CreateMasterObject[name, torusClass, mainBody, lineBody, shadeBody, rayCastBody];
};

TorusBoundHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
torusRec: TorusRec _ NARROW[mo.mainBody];
hedron _
SVBoundBox.HexagonalBoundHedron[torusRec.bigRadius + torusRec.sectionRadius,
torusRec.sectionRadius];
};

TorusGetRayCastBody: PRIVATE PROC [] RETURNS [surfaceArray: SurfaceArray] = {
torusS: ToroidalSurface;
surfaceArray  _ NEW[SurfaceArrayObj];
torusS _ NEW[ToroidalSurfaceObj];
surfaceArray[1] _ torusS;
}; -- end of TorusGetRayCastBody

TorusRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
surfaceArray: SurfaceArray _ NARROW[mo.rayCastBody];
RETURN[ObjectCast.ToroidCast[localRay, prim, mo.mainBody, surfaceArray[1]]];
};

TorusRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
surfaceArray: SurfaceArray _ NARROW[mo.rayCastBody];
RETURN[ObjectCast.ToroidCast[localRay, prim, mo.mainBody, surfaceArray[1]]];
};

TorusLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
torMesh: ToroidalMesh;
IF ISTYPE[data, ToroidalMesh]
THEN torMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawToroidalSweep[dc, torMesh, camera, localCS];
};
TorusDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
torMesh: ToroidalMesh;
IF ISTYPE[data, ToroidalMesh]
THEN torMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsToroidalSweep[dc, torMesh, camera, localCS];
};

TorusCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
torMesh: ToroidalMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesToroidalSweep[torMesh];
};
TorusCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
torMesh: ToroidalMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesToroidalSweep[torMesh];
};
TorusGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
torMesh: ToroidalMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesToroidalSweep[torMesh, assembly, camera];
};
TorusDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceToroidalSweep[dc, ps, lightSources, camera];
};

TorusFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
bigRadius, sectionRadius: REAL;
TFI3d.ReadBlankAndRope[f, "bigRadius:"];
bigRadius _ TFI3d.ReadBlankAndReal[f];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlankAndRope[f, "sectionRadius:"];
sectionRadius _ TFI3d.ReadBlankAndReal[f];
mo _ TorusMakeMasterObject[name, bigRadius, sectionRadius];
};

TorusFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
torusRec: TorusRec _ NARROW[mo.mainBody];
f.PutF["bigRadius: %g, sectionRadius: %g\n", [real[torusRec.bigRadius]],
[real[torusRec.sectionRadius]] ];
};-- end of TorusFileout

LinSweepMakeMasterObject: PUBLIC PROC [name: Rope.ROPE, linMesh: LinearMesh] RETURNS [mo: MasterObject] = {
mainBody: REF ANY _ NIL;
lineBody: REF ANY _ linMesh;
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ LinSweepGetRayCastBody[linMesh];
mo _ DisplayList3d.CreateMasterObject[name, linClass, mainBody, lineBody, shadeBody, rayCastBody];
};

LinSweepBoundHedron: PUBLIC PROC [masterObject: MasterObject] RETURNS [hedron: BoundHedron] = {
linMesh: LinearMesh _ NARROW[masterObject.lineBody];
vertCount: NAT _ 2*linMesh.len;
hedron _ SVBoundBox.CreateBoundHedron[vertCount];
FOR i: NAT IN[1..linMesh.len] DO
FOR j: NAT IN[1..2] DO
SVBoundBox.AddBoundHedronPoint[hedron, linMesh.array[i][j]];
ENDLOOP;
ENDLOOP;
};

LinSweepFaces: TYPE = SweepCast.LinSweepFaces;
LinSweepHint: TYPE = REF LinSweepHintObj;
LinSweepHintObj: TYPE = RECORD [linMesh: LinearMesh, faces: LinSweepFaces];

LinSweepGetRayCastBody: PRIVATE PROC [linMesh: LinearMesh] RETURNS [hint: LinSweepHint] = {
hint _ NEW[LinSweepHintObj];
hint.linMesh _ linMesh;
hint.faces _ SweepCast.MakeLinSweepFaces[linMesh];
};

GetLinSweepData: PUBLIC PROC RETURNS [linMesh: LinearMesh] = {
linMesh _ PredefSweeps.GetUnitCube[];-- for now.
};

LinSweepRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
rayCastBody: LinSweepHint _ NARROW[mo.rayCastBody];
class _ SweepCast.LinCast[localRay, prim, rayCastBody.linMesh, rayCastBody.faces];
};

LinSweepRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
rayCastBody: LinSweepHint _ NARROW[mo.rayCastBody];
class _ SweepCast.LinCast[localRay, prim, rayCastBody.linMesh, rayCastBody.faces];
};

LinSweepLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
linMesh: LinearMesh;
IF ISTYPE[data, LinearMesh]
THEN linMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawLinearSweep[dc, linMesh, camera, localCS];
};
LinSweepDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
linMesh: LinearMesh;
IF ISTYPE[data, LinearMesh]
THEN linMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsLinearSweep[dc, linMesh, camera, localCS];
};
LinSweepCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesLinearSweep[linMesh];
};
LinSweepCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesLinearSweep[linMesh];
};
LinSweepGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
linMesh: LinearMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesLinearSweep[linMesh, assembly, camera];
};
LinSweepDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceLinearSweep[dc, ps, lightSources, camera];
};

LinearFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
linMesh: LinearMesh _ NARROW[mo.lineBody];
lma: LinearMeshArray _ linMesh.array;
len: NAT _ linMesh.len;
f.PutF["name: %g\n",[rope[mo.name]]];
f.PutF["frontDepth: %g, backDepth: %g\n",[real[lma[1][1][3]]],[real[lma[1][2][3]]]];
f.PutF["DataPoints [%g]: ",[integer[len]]];
FOR i: NAT IN[1..len-1] DO
TFO3d.FileoutPoint3dAsPoint2d[f, lma[i][1]];
f.PutF[","];
ENDLOOP;
TFO3d.FileoutPoint3dAsPoint2d[f, lma[len][1]];
f.PutChar[IO.CR];
};

LinearFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
count: NAT;
frontDepth, backDepth: REAL;
poly: Polygon;
instanceName: Rope.ROPE;
linMesh: LinearMesh;
TFI3d.ReadRope[f, "name:"];
instanceName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlankAndRope[f, "frontDepth:"];
frontDepth _ TFI3d.ReadBlankAndReal[f];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlankAndRope[f, "backDepth:"];
backDepth _ TFI3d.ReadBlankAndReal[f];
TFI3d.ReadBlankAndRope[f, "DataPoints ["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];
TFI3d.ReadBlank[f];
poly _ SVPolygon2d.CreatePoly[count];
FOR i: NAT IN[1..count-1] DO
poly _ SVPolygon2d.PutPolyPoint[poly, i-1, TFI3d.ReadPoint2d[f]];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlank[f];
ENDLOOP;
poly _ SVPolygon2d.PutPolyPoint[poly, count-1, TFI3d.ReadPoint2d[f]];
TFI3d.ReadBlank[f];
linMesh _ SweepGeometry.LinearSweep[poly, frontDepth, backDepth];
mo _ LinSweepMakeMasterObject[name, linMesh];
};

RevoSweepMakeMasterObject: PUBLIC PROC [name: Rope.ROPE, revMesh: RevoluteMesh] RETURNS [mo: MasterObject] = {
mainBody: REF ANY _ NIL;
lineBody: REF ANY _ revMesh;
shadeBody: REF ANY _ lineBody;
rayCastBody: REF ANY _ RevoSweepGetRayCastBody[revMesh];
mo _ DisplayList3d.CreateMasterObject[name, revoClass, mainBody, lineBody, shadeBody, rayCastBody];
};

RevoSweepBoundHedron: PUBLIC PROC [masterObject: MasterObject] RETURNS [hedron: BoundHedron] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
vertCount: NAT _ revMesh.linesOfLatitude*6;-- hexagons*6
hex: Poly3d;
hedron _ SVBoundBox.CreateBoundHedron[vertCount];

FOR i: NAT IN[1..revMesh.linesOfLatitude] DO
hex _ SVPolygon3d.CircumHexagon[revMesh.array[i][1][2],
revMesh.array[i][revMesh.linesOfLongitude][1]];
SVBoundBox.AddBoundHedronPoly[hedron, hex];
ENDLOOP;
};

RevoSweepHint: TYPE = REF RevoSweepHintObj;
RevoSweepHintObj: TYPE = RECORD [boxes: SubBoxesBody];
RevoSweepFaces: TYPE = SweepCast.RevoSweepFaces;
RevoSweepRayCastBody: TYPE = REF RevoSweepRayCastBodyObj;
RevoSweepRayCastBodyObj: TYPE = RECORD [faces: RevoSweepFaces];

RevoSweepGetRayCastBody: PRIVATE PROC [revMesh: RevoluteMesh] RETURNS [rayCastBody: RevoSweepRayCastBody] = {
rayCastBody _ NEW[RevoSweepRayCastBodyObj];
rayCastBody.faces _ SweepCast.MakeRevoSweepFaces[revMesh];
};

RevoSweepRayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
rayCastBody: RevoSweepRayCastBody _ NARROW[mo.rayCastBody];
revoHint: RevoSweepHint _ NARROW[prim.hints];
RETURN[SweepCast.RevoCast[cameraPoint, localRay, prim, rayCastBody.faces, revoHint.boxes]];
};

RevoSweepRayCastNoBBoxes: PUBLIC PROC [localRay: Ray, masterObject: REF ANY, prim: Primitive] RETURNS [class: Classification] = {
mo: MasterObject _ NARROW[masterObject];
rayCastBody: RevoSweepRayCastBody _ NARROW[mo.rayCastBody];
RETURN[SweepCast.RevoCastNoBBoxes[localRay, prim, rayCastBody.faces]];
};

RevoSweepPreprocess: PUBLIC PROC [prim: Primitive, camera: Camera] = {
revoSweepHint: RevoSweepHint _ NEW[RevoSweepHintObj];
mo: MasterObject _ NARROW[prim.mo];
rayCastBody: RevoSweepRayCastBody _ NARROW[mo.rayCastBody];
faces: RevoSweepFaces _ rayCastBody.faces;
boxes: SubBoxesBody;
revoSweepHint.boxes _ NEW[SubBoxesBodyObj[faces.len]];
boxes _ revoSweepHint.boxes;
FOR i: NAT IN[0..faces.len) DO
WITH faces[i] SELECT FROM
cone: Cone => boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[cone.boundHedron, camera, prim.primWRTAssembly];
ring: DiskRing=> boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[ring.boundHedron, camera, prim.primWRTAssembly];
cyl: Cylinder=> boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[cyl.boundHedron, camera, prim.primWRTAssembly];
ENDCASE => ERROR;
boxes.len _ faces.len;
ENDLOOP;
prim.hints _ revoSweepHint;
};

RevoSweepLineDraw: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.LineDrawRevoluteSweep[dc, revMesh, camera, localCS];
};
RevoSweepDrawNormals: PUBLIC PROC[dc: Graphics.Context, data: REF ANY, camera: Camera, localCS: CoordSystem] = {
revMesh: RevoluteMesh;
IF ISTYPE[data, RevoluteMesh]
THEN revMesh _ NARROW[data]
ELSE SIGNAL WrongTypeOfData;
SweepGeometry.DrawNormalsRevoluteSweep[dc, revMesh, camera, localCS];
};

RevoSweepCountSurf: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountPlanarSurfacesRevoluteSweep[revMesh];
};
RevoSweepCountVert: PUBLIC PROC [masterObject: MasterObject] RETURNS [len: NAT] = {
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
len _ SweepGeometry.CountVerticesRevoluteSweep[revMesh];
};
RevoSweepGetSurf: PUBLIC PROC [assembly: Assembly, camera: CoordSystem] RETURNS [psl: PlanarSurfaceList] = {
masterObject: MasterObject _ NARROW[assembly.object];
revMesh: RevoluteMesh _ NARROW[masterObject.shadeBody];
psl _ SweepGeometry.PlanarSurfacesRevoluteSweep[revMesh, assembly, camera];
};
RevoSweepDrawSurf: PUBLIC PROC [dc: Graphics.Context, ps: PlanarSurface, lightSources: LightSourceList, camera: Camera] = {
SweepGeometry.DrawPlanarSurfaceRevoluteSweep[dc, ps, lightSources, camera];
};
RevoSweepDrawSubBoxes: PUBLIC PROC [dc: Graphics.Context, prim: Primitive, screenCS: CoordSystem] = {
revoHint: RevoSweepHint _ NARROW[prim.hints]; 
boxes: SubBoxesBody _ revoHint.boxes;
FOR i: NAT IN [0..boxes.len) DO
SVBoundBox.DrawBoundBox[dc, boxes[i], screenCS];
ENDLOOP;
};

RevoluteFileout: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
rma: RevoluteMeshArray;
revMesh: RevoluteMesh _ NARROW[mo.lineBody];
lat, long: NAT;
rma _ revMesh.array;
lat _ revMesh.linesOfLatitude;
long _ revMesh.linesOfLongitude;
f.PutF["lat: %g, long: %g\npoints [%g]:\n", -- TAB
[integer[lat]],[integer[long]],[integer[lat]]];
FOR i: NAT IN[1..lat-1] DO
TFO3d.FileoutPoint3dAsPoint2d[f, rma[i][long]];
f.PutF[","];
IF (i/3)*3 = i THEN f.PutF["\n"]; -- CR TAB
ENDLOOP;
TFO3d.FileoutPoint3dAsPoint2d[f, rma[lat][long]];
f.PutChar[IO.CR];
};

RevoluteFilein: PUBLIC PROC [f: IO.STREAM, name: Rope.ROPE] RETURNS [mo: MasterObject] = {
lat, long, count: NAT;
revMesh: RevoluteMesh;
path: Path;
TFI3d.ReadBlankAndRope[f, "lat:"];
lat _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlankAndRope[f, "long:"];
long _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "points"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];
TFI3d.ReadBlank[f];
path _ SVPolygon2d.CreatePath[count];
FOR i: NAT IN[1..count-1] DO
SVPolygon2d.PutPathPoint[path, i-1, TFI3d.ReadPoint2d[f]];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlank[f];
ENDLOOP;
SVPolygon2d.PutPathPoint[path, lat-1, TFI3d.ReadPoint2d[f]];
TFI3d.ReadBlank[f];
revMesh _ SweepGeometry.RevoluteSweep[path, long];
mo _ RevoSweepMakeMasterObject[name, revMesh];
};

Init: PROC = {
sphere, block, cylinder, cone: MasterObject;

sphereClass _ DisplayList3d.RegisterMasterObjectClass[
"sphere",
SphereFilein,
SphereFileout,
SphereRayCast,
SphereRayCastNoBBoxes,
SphereBoundHedron,
DisplayList3d.NoOpPreprocess,
SphereLineDraw,
SphereDrawNormals,
SphereCountSurf,
SphereGetSurf,
SphereDrawSurf,
DisplayList3d.NoOpDrawSubBoxes];

blockClass _ DisplayList3d.RegisterMasterObjectClass[
"block",
BlockFilein,
BlockFileout,
BlockRayCast,
BlockRayCastNoBBoxes,
BlockBoundHedron,
DisplayList3d.NoOpPreprocess,
BlockLineDraw,
BlockDrawNormals,
BlockCountSurf,
BlockGetSurf,
BlockDrawSurf,
DisplayList3d.NoOpDrawSubBoxes];

cylinderClass _ DisplayList3d.RegisterMasterObjectClass[
"cylinder",
CylinderFilein,
CylinderFileout,
CylinderRayCast,
CylinderRayCastNoBBoxes,
CylinderBoundHedron,
DisplayList3d.NoOpPreprocess,
CylinderLineDraw,
CylinderDrawNormals,
CylinderCountSurf,
CylinderGetSurf,
CylinderDrawSurf,
DisplayList3d.NoOpDrawSubBoxes];

coneClass _ DisplayList3d.RegisterMasterObjectClass[
"cone",
ConeFilein,
ConeFileout,
ConeRayCast,
ConeRayCastNoBBoxes,
ConeBoundHedron,
DisplayList3d.NoOpPreprocess,
ConeLineDraw,
ConeDrawNormals,
ConeCountSurf,
ConeGetSurf,
ConeDrawSurf,
DisplayList3d.NoOpDrawSubBoxes];

torusClass _ DisplayList3d.RegisterMasterObjectClass[
"torus",
TorusFilein, 
TorusFileout,
TorusRayCast,
TorusRayCastNoBBoxes,
TorusBoundHedron,
DisplayList3d.NoOpPreprocess,
TorusLineDraw,
TorusDrawNormals,
TorusCountSurf,
TorusGetSurf,
TorusDrawSurf,
DisplayList3d.NoOpDrawSubBoxes];

linClass _ DisplayList3d.RegisterMasterObjectClass[
"linearSweep",
LinearFilein,
LinearFileout,
LinSweepRayCast,
LinSweepRayCastNoBBoxes,
LinSweepBoundHedron,
DisplayList3d.NoOpPreprocess,
LinSweepLineDraw,
LinSweepDrawNormals,
LinSweepCountSurf,
LinSweepGetSurf,
LinSweepDrawSurf,
DisplayList3d.NoOpDrawSubBoxes
];

revoClass _ DisplayList3d.RegisterMasterObjectClass[
"revoluteSweep",
RevoluteFilein,
RevoluteFileout,
RevoSweepRayCast,
RevoSweepRayCastNoBBoxes,
RevoSweepBoundHedron,
RevoSweepPreprocess,
RevoSweepLineDraw,
RevoSweepDrawNormals,
RevoSweepCountSurf,
RevoSweepGetSurf,
RevoSweepDrawSurf,
RevoSweepDrawSubBoxes];


sphere _ SphereMakeMasterObject["sphere"];
block _ BlockMakeMasterObject["block"];
cylinder _ CylinderMakeMasterObject["cylinder"];
cone _ ConeMakeMasterObject["cone"];

DisplayList3d.RegisterMasterObject[sphere];
DisplayList3d.RegisterMasterObject[block];
DisplayList3d.RegisterMasterObject[cylinder];
DisplayList3d.RegisterMasterObject[cone];
};

Init[];

END.

DFile: BasicObject3dImpl.mesa
Last edited by Bier on December 18, 1982 1:35 am
Author: Eric Bier on August 16, 1983 9:32 am
Contents: Defines a simple set of objects which can be display with ray casting, line drawing, or shaded planar-surface approximation
GENERAL TYPES
SHADING TYPES
RAY CASTING TYPES 
GLOBAL VARIABLES
Basic Shapes
Spheres can be recovered from scratch.
Blocks can be recovered from scratch.
Cylinder can be recovered from scratch.
Cone can be recovered from scratch.
Torus can be recovered from bigRadius and sectionRadius.
Assume that the defining contour has not been rotated.  Output elements [i][1]
the radius at this line of latitude is revMesh.array[i][revMesh.linesOfLongitude][1];
prim.hints is a set of bounding boxes
assume that the defining contour has not been rotated. Output the [i][long] points
ส%๖–

"cedar" style˜Iheadš
œ™Iprocš
œ0™0Lš
œ,™,Lš
œ…
™…
L˜š
ฯk	˜	Lš
œ˜Lš
œ	˜	Lš
œ	˜	Lšœ
˜Lš
œ˜Lš
œ˜Lš
œ	˜	Lšœ
˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜—L˜šœ˜Lšœœh˜
Lšœ˜—Lš
˜L˜L˜Lš
œ
™
˜Lšœœ˜Lšœ
œ˜"Lšœ
œ˜"L˜Lšœ
œœ˜'Lšœœ˜1Lšœœ˜"Lšœœ!˜6Lšœœ#˜:Lšœœœ	˜Lšœ	œ˜Lšœ	œ˜Lšœœœ˜Lšœœ˜(Lšœ	œœ˜Lšœœ˜#Lšœœœ˜(Lšœœ"˜8Lšœ
œ˜$Lšœœœ˜,Lšœœ$˜<Lšœœœ˜)Lšœœ˜2Lšœœœ˜,Lšœœ$˜<—L˜L˜Lš
œ
™
˜Lšœ
œ˜%Lšœ
œœ
˜$Lšœ
œ˜)Lšœœ˜0Lšœœœ˜+Lšœœ"˜8Lšœœ#˜:—L˜L˜Lš
œ™˜Lšœœœ˜.Lšœœ˜5L˜Lšœœœ˜Lšœœœ˜L˜L˜Lšœ
œœ
˜!Lšœ
œ˜.L˜Lšœœœ˜)Lšœœ!˜6L˜Lšœœœ˜3Lšœœ&˜@Lšœœ(ฯc˜_L˜L˜Lšœ
œœ
˜$Lšœœ ˜4Lšœœ˜0Lšœœ!˜6Lšœœ)˜FLšœœ'˜BLšœœ'˜BLšœœ"˜8L˜Lšœœœ˜)Lšœœœ˜,L˜Lšœœœ˜#Lšœœœ˜&L˜Lšœœœ˜#Lšœœœ˜&L˜Lšœ
œœ˜'Lšœœ˜1L˜Lšœ
œœ˜'Lšœœ˜1L˜Lšœ
œœ˜'Lšœœ˜1L˜Lšœœœ˜)Lšœœ˜3L˜Lšœ
œœ˜'Lšœœ˜1L˜Lšœœœ˜/Lšœœ!˜9—L˜Lš
œ™˜Lš
œ™L˜Lšœœœ˜#Lšœœ˜0L˜Lšœ
œœ
˜!Lšœ
œ˜.L˜Lšœ
œœ˜'Lšœœ ˜4L˜Lšœ	œœ˜Lšœœ˜,L˜Lšœ
œœ
˜!Lšœ
œ˜.L˜Lš
œf˜fL˜Lšœœ
œœ
˜&—˜šฯn
œœ
œ
œ˜;Lšœœ˜Lš
œ˜Lš
œ˜—L˜š
Ÿœœ
œ
œœ˜TLš
œ#˜#Lšœ
œ
œ ˜1Lšœœ
œ˜Lšœ
œ
œ˜.Lš
œe˜eLš
œ˜—L˜šŸœœ
œœ˜SLš
œ/˜/Lš
œ˜—L˜šŸœœ
œœ˜HLšœ	œ˜Lš
œ˜—L˜šŸ
œœ
œ5œ
œœ˜Œ
Lšœœ˜(Lšœ!œ˜FLš
œ˜—L˜šŸœœ
œœ
œœ˜~Lšœœ˜(Lšœ!œ˜FLš
œ˜—L˜š
Ÿœœ
œœ
œ+˜jLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œB˜BLš
œ˜—š
Ÿœœ
œœ
œ+˜mLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œE˜ELš
œ˜—š
Ÿœœ
œœœ˜PLšœœ˜7Lš
œ>˜>Lš
œ˜—š
Ÿœœ
œœœ˜PLšœœ˜7Lš
œ8˜8Lš
œ˜—šŸ
œœ
œ+œ˜iLšœœ˜5Lšœœ˜7Lš
œK˜KLš
œ˜—šŸœœ
œ]˜xLš
œK˜KLš
œ˜—L˜š
Ÿ
œœ
œœ
œ˜?Lš
œ&™&Lšœ
œ
œ˜Lš
œ˜Lš
œ˜—šŸœœ
œœ
œ
œœ˜XLš
œ&˜&Lš
œ˜Lš
œ"˜"Lš
œ˜—L˜šŸ	œœ
œ
œ˜8Lšœœ˜Lš
œ/˜/Lš
œ˜—L˜š
Ÿœœ
œ
œœ˜SLš
œ!˜!Lšœ
œ
œ˜/Lšœœ
œ˜Lšœ
œ
œ˜-Lš
œd˜dLš
œ˜—L˜šŸœœ
œœ˜RLš
œ4˜4Lš
œ˜—L˜šŸœœ
œœ!˜MLš
œ6˜6Lšœœ˜%Lšœœ˜!Lšœœ˜%Lšœ	œ˜'Lšœœ˜%Lšœ	œ˜'Lšœœ˜%Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lšœž˜ —L˜šŸœœ
œ5œ
œœ˜‹
Lšœœ˜(Lšœ œ˜ELš
œ˜—L˜šŸœœ
œœ
œœ˜}Lšœœ˜(Lšœ œ˜ELš
œ˜—L˜š
Ÿ
œœ
œœ
œ+˜iLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œ@˜@Lš
œ˜—š
Ÿœœ
œœ
œ+˜lLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œC˜CLš
œ˜—š
Ÿœœ
œœœ˜OLšœœ˜5Lš
œ<˜<Lš
œ˜—š
Ÿœœ
œœœ˜OLšœœ˜5Lš
œ6˜6Lš
œ˜—šŸœœ
œ+œ˜hLšœœ˜5Lšœœ˜5Lš
œI˜ILš
œ˜—šŸ
œœ
œ]˜wLš
œI˜ILš
œ˜—L˜šŸœœ
œœ
œ
œœ˜WLš
œ&˜&Lš
œ˜Lš
œ!˜!Lš
œ˜—š
Ÿœœ
œœ
œ˜>Lš
œ%™%Lš
œ˜Lš
œ˜—L˜šŸœœ
œ
œ˜ALšœœ˜"Lš
œ/˜/Lš
œ˜—L˜š
Ÿœœ
œ
œœ˜VLš
œ'˜'Lšœ
œ
œ"˜3Lšœœ
œ˜Lšœ
œ
œ˜0Lš
œg˜gLš
œ˜—L˜šŸœœ
œœ˜ULš
œ.˜.Lš
œ˜—L˜šŸœœ
œœ!˜PLš
œ˜Lš
œ˜Lšœœ˜%Lšœœ˜#Lšœ
œ˜)Lšœœ˜Lš
œ˜Lš
œ˜Lš
œ˜Lšœž ˜#—L˜šŸœœ
œ5œ
œœ˜Ž
Lšœœ˜(Lšœ#œ˜HLš
œ˜—L˜šŸœœ
œœ
œœ˜€
Lšœœ˜(Lšœ#œ˜HLš
œ˜—L˜š
Ÿœœ
œœ
œ+˜lLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œC˜CLš
œ˜—š
Ÿœœ
œœ
œ+˜oLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œF˜FLš
œ˜—š
Ÿœœ
œœœ˜RLšœœ˜7Lš
œ>˜>Lš
œ˜—š
Ÿœœ
œœœ˜RLšœœ˜7Lš
œ8˜8Lš
œ˜—šŸœœ
œ+œ˜kLšœœ˜5Lšœœ˜7Lš
œK˜KLš
œ˜—šŸœœ
œ]˜zLš
œK˜KLš
œ˜—L˜šŸœœ
œœ
œ
œœ˜ZLš
œ&˜&Lš
œ˜Lš
œ$˜$Lš
œ˜—š
Ÿœœ
œœ
œ˜ALš
œ'™'Lš
œ˜Lš
œ˜—L˜šŸœœ
œ
œ˜5Lšœ
œ
˜Lš
œ'˜'Lš
œ˜—L˜š
Ÿœœ
œ
œœ˜RLš
œ˜Lšœ
œ
œ˜/Lšœœ
œ˜Lšœ
œ
œ˜,Lš
œc˜cLš
œ˜—L˜šŸœœ
œœ˜QLš
œ/˜/Lš
œ˜—L˜šŸœœ
œœ!˜LLš
œ˜Lš
œ˜Lšœœ˜%Lšœœ˜Lšœœ˜Lš
œ˜Lš
œ˜Lšœž˜—L˜šŸœœ
œ5œ
œœ˜Š
Lšœœ˜(Lšœœ˜F—L˜šŸœœ
œœ
œœ˜|Lšœœ˜(Lšœœ˜F—L˜š
Ÿœœ
œœ
œ+˜hLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œB˜BLš
œ˜—š
Ÿœœ
œœ
œ+˜kLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œE˜ELš
œ˜—š
Ÿ
œœ
œœœ˜NLšœœ˜7Lš
œ>˜>Lš
œ˜—L˜š
Ÿ
œœ
œœœ˜NLšœœ˜7Lš
œ8˜8Lš
œ˜—L˜šŸœœ
œ+œ˜gLšœœ˜5Lšœœ˜7Lš
œK˜KLš
œ˜—šŸœœ
œ]˜vLš
œK˜KLš
œ˜—L˜šŸ
œœ
œœ
œ
œœ˜VLš
œ&˜&Lš
œ˜Lš
œ ˜ Lš
œ˜—š
Ÿœœ
œœ
œ˜=Lš
œ#™#Lš
œ˜Lš
œ˜—L˜šŸ	œœ
œ
œœœ˜_Lšœœ˜Lš
œ˜Lš
œ'˜'Lš
œ˜—L˜šŸœœ
œ
œ
œœœ˜yLš
œ9˜9Lšœ
œ
œH˜YLšœœ
œ˜Lšœ
œ
œ˜-Lš
œd˜dLš
œ˜—L˜šŸœœ
œœ˜RLšœœ˜)Lš
œ˜Lš
œL˜LLš
œ˜Lš
œ˜—L˜šŸœœ
œœ!˜MLš
œ˜Lšœœ˜%Lšœ	œ˜!Lš
œ˜Lšœž˜ —L˜šŸœœ
œ5œ
œœ˜‹
Lšœœ˜(Lšœœ˜4LšœF˜LLš
œ˜—L˜šŸœœ
œœ
œœ˜}Lšœœ˜(Lšœœ˜4LšœF˜LLš
œ˜—L˜š
Ÿ
œœ
œœ
œ+˜iLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œB˜BLš
œ˜—š
Ÿœœ
œœ
œ+˜lLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œE˜ELš
œ˜—L˜š
Ÿœœ
œœœ˜OLšœœ˜7Lš
œ>˜>Lš
œ˜—š
Ÿœœ
œœœ˜OLšœœ˜7Lš
œ8˜8Lš
œ˜—šŸœœ
œ+œ˜hLšœœ˜5Lšœœ˜7Lš
œK˜KLš
œ˜—šŸ
œœ
œ]˜wLš
œK˜KLš
œ˜—L˜šŸœœ
œœ
œ
œœ˜WLšœœ
˜Lš
œ(˜(Lš
œ&˜&Lš
œ˜Lš
œ,˜,Lš
œ*˜*Lš
œ;˜;Lš
œ˜—L˜š
Ÿœœ
œœ
œ˜>Lš
œ8™8Lšœœ˜)Lš
œH˜HLš
œ!˜!Lšœž˜—L˜š
Ÿœœ
œ
œœ˜kLšœ
œ
œœ
˜Lšœ
œ
œ˜Lšœœ
œ˜Lšœ
œ
œ#˜7Lš
œb˜bLš
œ˜—L˜šŸœœ
œœ˜_Lšœœ˜4Lšœœ˜Lš
œ1˜1Lšœœ
œ˜ Lšœœ
œ˜Lš
œ<˜<Lšœ
˜Lšœ
˜Lš
œ˜—L˜Lšœœ˜.Lšœœœ˜)Lšœœœ-˜KL˜šŸœœ
œœ˜[Lšœœ˜Lš
œ˜Lš
œ2˜2Lš
œ˜—L˜šŸœœ
œ
œ˜>Lšœ%ž˜0Lš
œ˜—L˜šŸœœ
œ5œ
œœ˜Ž
Lšœœ˜(Lšœœ˜3Lš
œR˜RLš
œ˜—L˜šŸœœ
œœ
œœ˜€
Lšœœ˜(Lšœœ˜3Lš
œR˜RLš
œ˜—L˜š
Ÿœœ
œœ
œ+˜lLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œ@˜@Lš
œ˜—š
Ÿœœ
œœ
œ+˜oLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œC˜CLš
œ˜—š
Ÿœœ
œœœ˜RLšœœ˜5Lš
œ<˜<Lš
œ˜—š
Ÿœœ
œœœ˜RLšœœ˜5Lš
œ6˜6Lš
œ˜—šŸœœ
œ+œ˜kLšœœ˜5Lšœœ˜5Lš
œI˜ILš
œ˜—šŸœœ
œ]˜zLš
œI˜ILš
œ˜—L˜š
Ÿ
œœ
œœ
œ˜?Lšœœ˜*Lš
œ%˜%Lšœœ˜Lš
œ%˜%Lš
œN™NLš
œT˜TLš
œ+˜+Lšœœ
œ˜Lš
œ,˜,Lš
œ˜Lšœ
˜Lš
œ.˜.Lšœ
œ
œ˜Lš
œ˜—L˜šŸœœ
œœ
œ
œœ˜XLšœœ
˜Lšœœ
˜Lš
œ˜Lšœœ
˜Lš
œ˜Lš
œ˜Lš
œ)˜)Lš
œ)˜)Lš
œ'˜'Lš
œ˜Lš
œ(˜(Lš
œ&˜&Lš
œ*˜*Lš
œ˜Lš
œ ˜ Lš
œ˜Lš
œ%˜%šœœ
œ
˜Lš
œA˜ALš
œ˜Lš
œ˜—Lšœ
˜Lš
œE˜ELš
œ˜Lš
œA˜ALš
œ-˜-Lš
œ˜—L˜š
Ÿœœ
œ
œœ˜nLšœ
œ
œœ
˜Lšœ
œ
œ˜Lšœœ
œ˜Lšœ
œ
œ$˜8Lš
œc˜cLš
œ˜—L˜šŸœœ
œœ˜`Lšœœ˜7Lšœœž
˜8Lš
œ˜Lš
œ1˜1L˜Lšœœ
œ˜,Lš
œU™ULš
œ7˜7Lš
œ/˜/Lš
œ+˜+Lšœ
˜Lš
œ˜—L˜Lšœœœ˜+Lšœœœ˜6Lšœœ˜0Lšœœœ˜9Lšœœœ˜?L˜šŸœœ
œœ(˜mLšœœ˜+Lš
œ:˜:Lš
œ˜—L˜šŸœœ
œ5œ
œœ˜
Lšœœ˜(Lšœ$œ˜;Lšœœ
˜-LšœU˜[Lš
œ%™%Lš
œ˜—L˜šŸœœ
œœ
œœ˜
Lšœœ˜(Lšœ$œ˜;Lšœ@˜FLš
œ˜—L˜šŸœœ
œ&˜FLšœœ˜5Lšœœ
˜#Lšœ$œ˜;Lš
œ*˜*Lš
œ˜Lšœœ˜6Lš
œ˜šœœ
œ˜šœ
œ
˜Lš
œl˜lLš
œo˜oLš
œm˜mLšœœ
˜—Lš
œ˜—Lšœ
˜Lš
œ˜Lš
œ˜—L˜š
Ÿœœ
œœ
œ+˜mLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œB˜BLš
œ˜—š
Ÿœœ
œœ
œ+˜pLš
œ˜Lšœ
œ˜Lšœœ˜Lšœ
œ˜Lš
œE˜ELš
œ˜—L˜š
Ÿœœ
œœœ˜SLšœœ˜7Lš
œ>˜>Lš
œ˜—š
Ÿœœ
œœœ˜SLšœœ˜7Lš
œ8˜8Lš
œ˜—šŸœœ
œ+œ˜lLšœœ˜5Lšœœ˜7Lš
œK˜KLš
œ˜—šŸœœ
œ]˜{Lš
œK˜KLš
œ˜—šŸœœ
œC˜eLšœœ˜.Lš
œ%˜%Lšœœ
œ˜Lš
œ0˜0Lšœ
˜Lš
œ˜—L˜š
Ÿœœ
œœ
œ˜ALš
œ˜Lšœœ˜,Lšœœ
˜Lš
œ˜Lš
œ˜Lš
œ ˜ Lš
œR™RLšœ,ž˜2Lš
œ/˜/Lšœœ
œ˜Lš
œ/˜/Lš
œ˜Lšœ
œž	˜+Lšœ
˜Lš
œ1˜1Lšœ
œ
œ˜Lš
œ˜—L˜šŸœœ
œœ
œ
œœ˜ZLšœœ
˜Lš
œ˜Lš
œ˜Lš
œ"˜"Lš
œ˜Lš
œ˜Lš
œ#˜#Lš
œ ˜ Lš
œ$˜$Lš
œ˜Lš
œ!˜!Lš
œ ˜ Lš
œ˜Lš
œ%˜%šœœ
œ
˜Lš
œ:˜:Lš
œ˜Lš
œ˜—Lšœ
˜Lš
œ<˜<Lš
œ˜Lš
œ2˜2Lš
œ.˜.Lš
œ˜—L˜šŸœœ˜Lš
œ,˜,L˜Lš
œ6˜6Lš
œ	˜	Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ L˜Lš
œ5˜5Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ ˜ L˜Lš
œ8˜8Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ L˜Lš
œ4˜4Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ ˜ L˜Lš
œ5˜5Lš
œ˜Lš
œ
˜
Lš
œ
˜
Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ ˜ L˜Lš
œ3˜3Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜L˜Lš
œ4˜4Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜L˜L˜Lš
œ*˜*Lš
œ'˜'Lš
œ0˜0Lš
œ$˜$L˜Lš
œ+˜+Lš
œ*˜*Lš
œ-˜-Lš
œ)˜)Lš
œ˜—L˜Lš
œ˜—L˜Lšœ
˜L˜—…—…„ฎพ