DIRECTORY
BasicObject3d,
DisplayList3d,
Graphics,
IO,
ObjectCast,
PredefSweeps,
Rope,
SV2d,
SV3d,
SVBoundBox,
SVBoundSphere,
SVFaces,
SVModelTypes,
SVPolygon2d,
SVPolygon3d,
SVRayTypes,
SVSceneTypes,
SweepCast,
SweepGeometry,
TFI3d,
TFO3d;

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



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

BoundHedron: TYPE = SVModelTypes.BoundHedron;
Camera: TYPE = SVModelTypes.Camera;
LinearMeshArray: TYPE = SweepGeometry.LinearMeshArray;
RevoluteMeshArray: TYPE = SweepGeometry.RevoluteMeshArray;
Path: TYPE = SV2d.Path;
Point2d: TYPE = SV2d.Point2d;
Poly3d: TYPE = SV3d.Poly3d;
Polygon: TYPE = SV2d.Polygon;
LinearMesh: TYPE = REF LinearMeshRecord;
LinearMeshRecord: TYPE = SweepGeometry.LinearMeshRecord;
RevoFace: TYPE = SweepCast.RevoFace;
RevoluteMesh: TYPE = REF RevoluteMeshRecord;
RevoluteMeshRecord: TYPE = SweepGeometry.RevoluteMeshRecord;
Shape: TYPE = SVSceneTypes.Shape;
ToroidalMesh: TYPE = REF ToroidalMeshRecord;
ToroidalMeshRecord: TYPE = SweepGeometry.ToroidalMeshRecord;

SubBoxesBody: TYPE = REF SubBoxesBodyObj;
SubBoxesBodyObj: TYPE = SweepCast.SubBoxesBodyObj;
SubSpheresBody: TYPE = REF SubSpheresBodyObj;
SubSpheresBodyObj: TYPE = SweepCast.SubSpheresBodyObj;


BoundBox: TYPE = SVModelTypes.BoundBox;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
LightSourceList: TYPE = SVModelTypes.LightSourceList;
PlanarSurface: TYPE = SVSceneTypes.PlanarSurface;
PlanarSurfaceList: TYPE = SVSceneTypes.PlanarSurfaceList;


Assembly: TYPE = SVSceneTypes.Assembly;
Classification: TYPE =  SVRayTypes.Classification;
Composite: TYPE = SVRayTypes.Composite;
MasterObject: TYPE = SVSceneTypes.MasterObject;
MasterObjectClass: TYPE = SVSceneTypes.MasterObjectClass;
MasterObjectClassList: TYPE = SVSceneTypes.MasterObjectClassList; -- LIST OF MasterObjectClass
Primitive: TYPE = SVRayTypes.Primitive;
Ray: TYPE = SVRayTypes.Ray;

RayCastProc: TYPE = SVRayTypes.RayCastProc;
PreprocessProc: TYPE = SVSceneTypes.PreprocessProc;
LineDrawProc: TYPE = SVSceneTypes.LineDrawProc;
NormalsDrawProc: TYPE = SVSceneTypes.NormalsDrawProc;
CountPlanarSurfacesProc: TYPE = SVSceneTypes.CountPlanarSurfacesProc;
GetPlanarSurfacesProc: TYPE = SVSceneTypes.GetPlanarSurfacesProc;
DrawPlanarSurfaceProc: TYPE = SVSceneTypes.DrawPlanarSurfaceProc;
DrawSubBoxesProc: TYPE = SVSceneTypes.DrawSubBoxesProc;

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

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]];
};

SphereRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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];
};
SphereFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
revMesh: RevoluteMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListRevolute[f, revMesh];
};


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]];
};
BlockRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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"];
};
BlockFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
linMesh: LinearMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListLinear[f, linMesh];
};


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]];
};

CylinderRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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"];
};
CylinderFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
revMesh: RevoluteMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListRevolute[f, revMesh];
};

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]];};
ConeRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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"];
};
ConeFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
revMesh: RevoluteMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListRevolute[f, revMesh];
};

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]]];
};
TorusRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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
TorusFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
torMesh: ToroidalMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListToroidal[f, torMesh];
};

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];
};
LinSweepRayCastBoundingSpheres: 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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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];
};
LinearFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
linMesh: LinearMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListLinear[f, 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,
spheres: SubSpheresBody];
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]];
};
RevoSweepRayCastBoundingSpheres: PUBLIC PROC [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.RevoCastBoundSpheres[localRay, prim, rayCastBody.faces, revoHint.spheres]];
};
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;
spheres: SubSpheresBody;
worldCS: CoordSystem _ camera.coordSys.parent;

revoSweepHint.boxes _ NEW[SubBoxesBodyObj[faces.len]];
revoSweepHint.spheres _ NEW[SubSpheresBodyObj[faces.len]];
boxes _ revoSweepHint.boxes;
spheres _ revoSweepHint.spheres;
FOR i: NAT IN[0..faces.len) DO
WITH faces[i] SELECT FROM
cone: Cone => {
boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[cone.boundHedron, camera, prim.primWRTAssembly];
spheres[i] _ SVBoundSphere.BoundSphereFromBoundHedron[cone.boundHedron, worldCS, prim.primWRTAssembly];
};
ring: DiskRing=> {
boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[ring.boundHedron, camera, prim.primWRTAssembly];
spheres[i] _ SVBoundSphere.BoundSphereFromBoundHedron[ring.boundHedron, worldCS, prim.primWRTAssembly];
};
cyl: Cylinder=> {
boxes[i] _ SVBoundBox.BoundBoxFromBoundHedron[cyl.boundHedron, camera, prim.primWRTAssembly];
spheres[i] _ SVBoundSphere.BoundSphereFromBoundHedron[cyl.boundHedron, worldCS, prim.primWRTAssembly];
};
ENDCASE => ERROR;
ENDLOOP;
spheres.len _ faces.len;
boxes.len _ faces.len;
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] = {
shape: Shape _ NARROW[assembly.shape];
masterObject: MasterObject _ shape.mo;
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;
};
RevoSweepDrawSubSpheres: PUBLIC PROC [dc: Graphics.Context, prim: Primitive, camera: Camera] = {
revoHint: RevoSweepHint _ NARROW[prim.hints]; 
spheres: SubSpheresBody _ revoHint.spheres;
FOR i: NAT IN [0..spheres.len) DO
SVBoundSphere.DrawBoundSphere[dc, spheres[i], camera];
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];
};
RevoluteFileoutPoly: PUBLIC PROC [f: IO.STREAM, mo: MasterObject] = {
revMesh: RevoluteMesh _ NARROW[mo.shadeBody];
SweepGeometry.PolyListRevolute[f, revMesh];
};

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

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

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

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

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

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

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

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


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.

hFile: BasicObject3dImpl.mesa
Last edited by: Eric Bier on January 8, 1985 1:13:29 pm PST
Copyright c 1984 by Xerox Corporation.  All rights reserved.
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 
Basic Object Shapes
GLOBAL VARIABLES

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š
œ;™;Jšœ
Οm
œ1™<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šžœžœw˜
Lšžœ˜—Lš
ž˜L˜L˜Lš
œ
™
˜Lšœžœ˜Lšœ
žœ˜"Lšœ
žœ˜"L˜Lšœ
žœ˜-Lšœžœ˜#Lšœžœ!˜6Lšœžœ#˜:Lšœžœ
˜Lšœ	žœ˜Lšœžœ˜Lšœ	žœ˜Lšœžœžœ˜(Lšœžœ"˜8Lšœ
žœ˜$Lšœžœžœ˜,Lšœžœ$˜<Lšœžœ˜!Lšœžœžœ˜,Lšœžœ$˜<L˜Lšœžœžœ˜)Lšœžœ˜2Lšœžœžœ˜-Lšœžœ˜6L˜—Lš
œ
™
˜Lšœ
žœ˜'Lšœ
žœ˜-Lšœžœ ˜5Lšœžœ˜1Lšœžœ"˜9L˜—Lš
œ™˜Lšœ
žœ˜'Lšœžœ˜2Lšœžœ˜'Lšœžœ˜/Lšœžœ"˜9Lšœžœ'Οc˜^Lšœžœ˜'Lšœžœ˜L˜LšΟbœžœ˜+Lš œžœ˜3Lš œžœ˜/Lš œžœ ˜5Lš œžœ(˜ELš œžœ&˜ALš œžœ&˜ALš œžœ!˜7L˜Lšœžœžœ˜)Lšœžœ˜3L˜Lšœ
žœžœ˜'Lšœžœ˜1L˜Lšœ
žœžœ˜'Lšœžœ˜1L˜Lšœ
žœžœ˜'Lšœžœ˜1L˜Lšœžœžœ˜)Lšœžœ˜3L˜Lšœ
žœžœ˜'Lšœžœ˜1L˜Lšœžœžœ˜/Lšœžœ!˜9L˜—L˜š
œ™L˜Lšœžœžœ˜#Lšœžœ˜0L˜Lšœ
žœžœ
˜!Lšœ
žœ˜.L˜Lšœ
žœžœ˜'Lšœžœ ˜4L˜Lšœ	žœžœ˜Lšœžœ˜,L˜Lšœ
žœžœ
˜!Lšœ
žœ˜.L˜—Lš
œ™™Lš
œf˜fL˜Lšœžœ
žœžœ
˜&L˜—šΟn
œžœ
žœ
žœ˜;Lšœžœ˜Lš
œ˜Lš
œ˜—š
‘œžœ
žœ
žœžœ˜TLš
œ#˜#Lšœ
žœ
žœ ˜1Lšœžœ
žœ˜Lšœ
žœ
žœ˜.Lš
œe˜eLš
œ˜—š‘œžœ
žœžœ˜SLš
œ/˜/Lš
œ˜—š‘œžœ
žœžœ˜HLšœ	žœ˜Lš
œ˜—š‘
œžœ
žœ5žœ
žœžœ˜Œ
Lšœžœ˜(Lšžœ!žœ˜FLš
œ˜—š‘œžœ
žœžœ
žœžœ˜~Lšœžœ˜(Lšžœ!žœ˜FLš
œ˜L˜—š‘œžœ
žœžœ
žœžœ˜…
Lšœžœ˜(Lšžœ!žœ˜FLš
œ˜—š
‘œžœ
žœžœ
žœ+˜jLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œB˜BLš
œ˜—š
‘œžœ
žœžœ
žœ+˜mLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œE˜ELš
œ˜—š
‘œžœ
žœžœžœ˜PLšœžœ˜7Lš
œ>˜>Lš
œ˜—š
‘œžœ
žœžœžœ˜PLšœžœ˜7Lš
œ8˜8Lš
œ˜—š‘
œžœ
žœ+žœ˜iLšœžœ˜&Lš
œ&˜&Lšœžœ˜7Lš
œK˜KLš
œ˜—š‘œžœ
žœ]˜xLš
œK˜KLš
œ˜—š
‘
œžœ
žœžœ
žœ˜?Lš
œ&™&Lšœ
žœ
žœ˜Lš
œ˜Lš
œ˜—š‘œžœ
žœžœ
žœ
žœžœ˜XLš
œ&˜&Lš
œ˜Lš
œ"˜"Lš
œ˜—š
‘œžœ
žœžœ
žœ˜CLšœžœ˜-Lš
œ+˜+L˜L˜—L˜š‘	œžœ
žœ
žœ˜8Lšœžœ˜Lš
œ/˜/Lš
œ˜—š
‘œžœ
žœ
žœžœ˜SLš
œ!˜!Lšœ
žœ
žœ˜/Lšœžœ
žœ˜Lšœ
žœ
žœ˜-Lš
œd˜dLš
œ˜—š‘œžœ
žœžœ˜RLš
œ4˜4Lš
œ˜—š‘œžœ
žœžœ!˜MLš
œ6˜6Lšœžœ˜%Lšœžœ˜!Lšœžœ˜%Lšœ	žœ˜'Lšœžœ˜%Lšœ	žœ˜'Lšœžœ˜%Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜LšœŸ˜ —š‘œžœ
žœ5žœ
žœžœ˜‹
Lšœžœ˜(Lšžœ žœ˜ELš
œ˜—š‘œžœ
žœžœ
žœžœ˜}Lšœžœ˜(Lšžœ žœ˜ELš
œ˜—š‘œžœ
žœžœ
žœžœ˜„
Lšœžœ˜(Lšžœ žœ˜ELš
œ˜—š
‘
œžœ
žœžœ
žœ+˜iLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œ@˜@Lš
œ˜—š
‘œžœ
žœžœ
žœ+˜lLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œC˜CLš
œ˜—š
‘œžœ
žœžœžœ˜OLšœžœ˜5Lš
œ<˜<Lš
œ˜—š
‘œžœ
žœžœžœ˜OLšœžœ˜5Lš
œ6˜6Lš
œ˜—š‘œžœ
žœ+žœ˜hLšœžœ˜&Lš
œ&˜&Lšœžœ˜5Lš
œI˜ILš
œ˜—š‘
œžœ
žœ]˜wLš
œI˜ILš
œ˜—š‘œžœ
žœžœ
žœ
žœžœ˜WLš
œ&˜&Lš
œ˜Lš
œ!˜!Lš
œ˜—š
‘œžœ
žœžœ
žœ˜>Lš
œ%™%Lš
œ˜Lš
œ˜—š
‘œžœ
žœžœ
žœ˜BLšœžœ˜+Lš
œ)˜)L˜L˜—L˜š‘œžœ
žœ
žœ˜ALšœžœ˜"Lš
œ/˜/Lš
œ˜—š
‘œžœ
žœ
žœžœ˜VLš
œ'˜'Lšœ
žœ
žœ"˜3Lšœžœ
žœ˜Lšœ
žœ
žœ˜0Lš
œg˜gLš
œ˜—š‘œžœ
žœžœ˜ULš
œ.˜.Lš
œ˜—š‘œžœ
žœžœ!˜PLš
œ˜Lš
œ˜Lšœžœ˜%Lšœžœ˜#Lšœ
žœ˜)Lšœžœ˜Lš
œ˜Lš
œ˜Lš
œ˜LšœŸ ˜#—š‘œžœ
žœ5žœ
žœžœ˜Ž
Lšœžœ˜(Lšžœ#žœ˜HLš
œ˜—š‘œžœ
žœžœ
žœžœ˜€
Lšœžœ˜(Lšžœ#žœ˜HLš
œ˜L˜—š‘œžœ
žœžœ
žœžœ˜‡
Lšœžœ˜(Lšžœ#žœ˜HLš
œ˜—š
‘œžœ
žœžœ
žœ+˜lLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œC˜CLš
œ˜—š
‘œžœ
žœžœ
žœ+˜oLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œF˜FLš
œ˜—š
‘œžœ
žœžœžœ˜RLšœžœ˜7Lš
œ>˜>Lš
œ˜—š
‘œžœ
žœžœžœ˜RLšœžœ˜7Lš
œ8˜8Lš
œ˜—š‘œžœ
žœ+žœ˜kLšœžœ˜&Lš
œ&˜&Lšœžœ˜7Lš
œK˜KLš
œ˜—š‘œžœ
žœ]˜zLš
œK˜KLš
œ˜—š‘œžœ
žœžœ
žœ
žœžœ˜ZLš
œ&˜&Lš
œ˜Lš
œ$˜$Lš
œ˜—š
‘œžœ
žœžœ
žœ˜ALš
œ'™'Lš
œ˜L˜—š
‘œžœ
žœžœ
žœ˜ELšœžœ˜-Lš
œ+˜+L˜—L˜š‘œžœ
žœ
žœ˜5Lšœ
žœ
˜Lš
œ'˜'Lš
œ˜—š
‘œžœ
žœ
žœžœ˜RLš
œ˜Lšœ
žœ
žœ˜/Lšœžœ
žœ˜Lšœ
žœ
žœ˜,Lš
œc˜cLš
œ˜—š‘œžœ
žœžœ˜QLš
œ/˜/Lš
œ˜—š‘œžœ
žœžœ!˜LLš
œ˜Lš
œ˜Lšœžœ˜%Lšœžœ˜Lšœžœ˜Lš
œ˜Lš
œ˜LšœŸ˜—š‘œžœ
žœ5žœ
žœžœ˜Š
Lšœžœ˜(Lšžœžœ˜F—š‘œžœ
žœžœ
žœžœ˜|Lšœžœ˜(Lšžœžœ˜F—š‘œžœ
žœžœ
žœžœ˜ƒ
Lšœžœ˜(Lšžœžœ˜F—š
‘œžœ
žœžœ
žœ+˜hLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œB˜BLš
œ˜—š
‘œžœ
žœžœ
žœ+˜kLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œE˜ELš
œ˜—š
‘
œžœ
žœžœžœ˜NLšœžœ˜7Lš
œ>˜>Lš
œ˜—š
‘
œžœ
žœžœžœ˜NLšœžœ˜7Lš
œ8˜8Lš
œ˜—š‘œžœ
žœ+žœ˜gLšœžœ˜&Lš
œ&˜&Lšœžœ˜7Lš
œK˜KLš
œ˜—š‘œžœ
žœ]˜vLš
œK˜KLš
œ˜—š‘
œžœ
žœžœ
žœ
žœžœ˜VLš
œ&˜&Lš
œ˜Lš
œ ˜ Lš
œ˜—š
‘œžœ
žœžœ
žœ˜=Lš
œ#™#Lš
œ˜Lš
œ˜—š
‘œžœ
žœžœ
žœ˜ALšœžœ˜-Lš
œ+˜+L˜—L˜š‘	œžœ
žœ
žœžœžœ˜_Lšœžœ˜Lš
œ˜Lš
œ'˜'Lš
œ˜—š‘œžœ
žœ
žœ
žœžœžœ˜yLš
œ9˜9Lšœ
žœ
žœH˜YLšœžœ
žœ˜Lšœ
žœ
žœ˜-Lš
œd˜dLš
œ˜—š‘œžœ
žœžœ˜RLšœžœ˜)Lš
œ˜Lš
œL˜LLš
œ˜Lš
œ˜—š‘œžœ
žœžœ!˜MLš
œ˜Lšœžœ˜%Lšœ	žœ˜!Lš
œ˜LšœŸ˜ —š‘œžœ
žœ5žœ
žœžœ˜‹
Lšœžœ˜(Lšœžœ˜4LšžœF˜LLš
œ˜—š‘œžœ
žœžœ
žœžœ˜}Lšœžœ˜(Lšœžœ˜4LšžœF˜LLš
œ˜—š‘œžœ
žœžœ
žœžœ˜„
Lšœžœ˜(Lšœžœ˜4LšžœF˜LLš
œ˜—š
‘
œžœ
žœžœ
žœ+˜iLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œB˜BLš
œ˜—š
‘œžœ
žœžœ
žœ+˜lLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œE˜ELš
œ˜—š
‘œžœ
žœžœžœ˜OLšœžœ˜7Lš
œ>˜>Lš
œ˜—š
‘œžœ
žœžœžœ˜OLšœžœ˜7Lš
œ8˜8Lš
œ˜—š‘œžœ
žœ+žœ˜hLšœžœ˜&Lš
œ&˜&Lšœžœ˜7Lš
œK˜KLš
œ˜—š‘
œžœ
žœ]˜wLš
œK˜KLš
œ˜—š‘œžœ
žœžœ
žœ
žœžœ˜WLšœžœ
˜Lš
œ(˜(Lš
œ&˜&Lš
œ˜Lš
œ,˜,Lš
œ*˜*Lš
œ;˜;Lš
œ˜—š
‘œžœ
žœžœ
žœ˜>Lš
œ8™8Lšœžœ˜)Lš
œH˜HLš
œ!˜!LšœŸ˜—š
‘œžœ
žœžœ
žœ˜BLšœžœ˜-Lš
œ+˜+L˜—L˜š
‘œžœ
žœ
žœžœ˜kLšœ
žœ
žœžœ
˜Lšœ
žœ
žœ˜Lšœžœ
žœ˜Lšœ
žœ
žœ#˜7Lš
œb˜bLš
œ˜—š‘œžœ
žœžœ˜_Lšœžœ˜4Lšœžœ˜Lš
œ1˜1Lšžœžœ
žœž˜ Lšžœžœ
žœž˜Lš
œ<˜<Lšžœ
˜Lšžœ
˜Lš
œ˜—Lšœžœ˜.Lšœžœžœ˜)Lšœžœžœ-˜Kš‘œžœ
žœžœ˜[Lšœžœ˜Lš
œ˜Lš
œ2˜2Lš
œ˜—š‘œžœ
žœ
žœ˜>Lšœ%Ÿ˜0Lš
œ˜—š‘œžœ
žœ5žœ
žœžœ˜Ž
Lšœžœ˜(Lšœžœ˜3Lš
œR˜RLš
œ˜—š‘œžœ
žœžœ
žœžœ˜€
Lšœžœ˜(Lšœžœ˜3Lš
œR˜RLš
œ˜—š‘œžœ
žœžœ
žœžœ˜‡
Lšœžœ˜(Lšœžœ˜3Lš
œR˜RLš
œ˜—š
‘œžœ
žœžœ
žœ+˜lLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œ@˜@Lš
œ˜—š
‘œžœ
žœžœ
žœ+˜oLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œC˜CLš
œ˜—š
‘œžœ
žœžœžœ˜RLšœžœ˜5Lš
œ<˜<Lš
œ˜—š
‘œžœ
žœžœžœ˜RLšœžœ˜5Lš
œ6˜6Lš
œ˜—š‘œžœ
žœ+žœ˜kLšœžœ˜&Lš
œ&˜&Lšœžœ˜5Lš
œI˜ILš
œ˜—š‘œžœ
žœ]˜zLš
œI˜ILš
œ˜—š
‘
œžœ
žœžœ
žœ˜?Lšœžœ˜*Lš
œ%˜%Lšœžœ˜Lš
œ%˜%Lš
œN™NLš
œT˜TLš
œ+˜+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š
œ˜—š
‘œžœ
žœžœ
žœ˜CLšœžœ˜+Lš
œ)˜)L˜—L˜š
‘œžœ
žœ
žœžœ˜nLšœ
žœ
žœžœ
˜Lšœ
žœ
žœ˜Lšœžœ
žœ˜Lšœ
žœ
žœ$˜8Lš
œc˜cLš
œ˜—š‘œžœ
žœžœ˜`Lšœžœ˜7LšœžœŸ
˜8Lš
œ˜Lš
œ1˜1L˜Lšžœžœ
žœž˜,Lš
œU™ULš
œ7˜7Lš
œ/˜/Lš
œ+˜+Lšžœ
˜Lš
œ˜—Lšœžœžœ˜+šœžœžœ˜!Lš
œ˜Lš
œ˜—Lšœžœ˜0Lšœžœžœ˜9Lšœžœžœ˜?š‘œžœ
žœžœ(˜mLšœžœ˜+Lš
œ:˜:Lš
œ˜—š‘œžœ
žœ5žœ
žœžœ˜
Lšœžœ˜(Lšœ$žœ˜;Lšœžœ
˜-LšžœU˜[Lš
œ%™%Lš
œ˜—š‘œžœ
žœžœ
žœžœ˜
Lšœžœ˜(Lšœ$žœ˜;Lšžœ@˜FLš
œ˜—š‘œžœ
žœžœ
žœžœ˜ˆ
Lšœžœ˜(Lšœ$žœ˜;Lšœžœ
˜-LšžœV˜\Lš
œ˜—š‘œžœ
žœ&˜FLšœžœ˜5Lšœžœ
˜#Lšœ$žœ˜;Lš
œ*˜*Lš
œ˜L˜Lš
œ.˜.L˜Lšœžœ˜6Lšœžœ˜:Lš
œ˜Lš
œ ˜ šžœžœ
žœž˜šžœ
žœ
ž˜š
œ˜Lš
œ^˜^Lš
œg˜gL˜—š
œ˜Lš
œ^˜^Lš
œg˜gL˜—š
œ˜Lš
œ]˜]Lš
œf˜fL˜—Lšžœžœ
˜——Lšžœ
˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜—š
‘œžœ
žœžœ
žœ+˜mLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œB˜BLš
œ˜—š
‘œžœ
žœžœ
žœ+˜pLš
œ˜Lšžœ
žœ˜Lšžœžœ˜Lšžœ
žœ˜Lš
œE˜ELš
œ˜—š
‘œžœ
žœžœžœ˜SLšœžœ˜7Lš
œ>˜>Lš
œ˜—š
‘œžœ
žœžœžœ˜SLšœžœ˜7Lš
œ8˜8Lš
œ˜—š‘œžœ
žœ+žœ˜lLšœžœ˜&Lš
œ&˜&Lšœžœ˜7Lš
œK˜KLš
œ˜—š‘œžœ
žœ]˜{Lš
œK˜KLš
œ˜—š‘œžœ
žœC˜eLšœžœ˜.Lš
œ%˜%šžœžœ
žœž˜Lš
œ0˜0—Lšžœ
˜Lš
œ˜—š‘œžœ
žœ<˜`Lšœžœ˜.Lš
œ+˜+šžœžœ
žœž˜!Lš
œ6˜6—Lšžœ
˜Lš
œ˜—š
‘œžœ
žœžœ
žœ˜ALš
œ˜Lšœžœ˜,Lšœžœ
˜Lš
œ˜Lš
œ˜Lš
œ ˜ Lš
œR™RLšœ,Ÿ˜2Lš
œ/˜/Lšžœžœ
žœž˜Lš
œ/˜/Lš
œ˜Lšžœ
žœŸ	˜+Lšžœ
˜Lš
œ1˜1Lšœ
žœ
žœ˜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š
œ˜—š
‘œžœ
žœžœ
žœ˜ELšœžœ˜-Lš
œ+˜+L˜—L˜š‘œžœ˜Lš
œ,˜,L˜Lš
œ6˜6Lš
œ	˜	Lš
œ
˜
Lš
œ˜Lš
œ˜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š
œ˜Lš
œ"˜"L˜Lš
œ8˜8Lš
œ˜Lš
œ˜Lš
œ˜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š
œ5˜5Lš
œ˜Lš
œ
˜
Lš
œ
˜
Lš
œ˜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š
œ"˜"L˜Lš
œ4˜4Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜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˜—…—–0Β°