
<<File: 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>>

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


<<GENERAL TYPES>>

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;


<<SHADING TYPES>>

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;


<<RAY CASTING TYPES >>

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;

<<GLOBAL VARIABLES>>

<<Basic Shapes>>

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] = {
<<Spheres can be recovered from scratch.>>
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] = {
<<Blocks can be recovered from scratch.>>
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] = {
<<Cylinder can be recovered from scratch.>>
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] = {
<<Cone can be recovered from scratch.>>
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] = {
<<Torus can be recovered from bigRadius and sectionRadius.>>
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]]];
<<Assume that the defining contour has not been rotated.  Output elements [i][1]>>
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
<<the radius at this line of latitude is revMesh.array[i][revMesh.linesOfLongitude][1];>>
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]];
<<prim.hints is a set of bounding 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;
<<assume that the defining contour has not been rotated. Output the [i][long] points>>
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.