DIRECTORY
SVCoordSys, SVGraphics, Imager, ImagerPath, ImagerTransformation, SVMatrix3d, SV2d, SV3d, SVBoundBox, SVBoundSphere, SVDraw3d, SVMatrix2d, SVModelTypes, SVSceneTypes, SVVector2d, SVVector3d;

SVDraw3dImpl: CEDAR PROGRAM
IMPORTS SVCoordSys, SVGraphics, Imager, ImagerPath, ImagerTransformation, SVBoundBox, SVBoundSphere, SVMatrix3d, SVVector2d, SVVector3d
EXPORTS SVDraw3d =
BEGIN

Camera: TYPE = SVModelTypes.Camera;
Composite: TYPE = SVSceneTypes.Composite;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CSGTree: TYPE = SVSceneTypes.CSGTree;
Matrix4by4: TYPE = SV3d.Matrix4by4;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
Primitive: TYPE = SVSceneTypes.Primitive;
SelectionClass: TYPE = SVSceneTypes.SelectionClass;
Vector3d: TYPE = SV3d.Vector3d;
Vector2d: TYPE = SV2d.Vector2d;

DrawCoordSys: PUBLIC PROC [dc: Imager.Context, csCAMERA: Matrix4by4, camera: Camera] = {
origin: Point3d;
xAxis, yAxis, zAxis: Vector3d;
length: REAL = 50.0;
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ SVVector3d.Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ SVVector3d.Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ SVVector3d.Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
xAxis _ SVVector3d.Scale[xAxis, length];
yAxis _ SVVector3d.Scale[yAxis, length];
zAxis _ SVVector3d.Scale[zAxis, length];
DrawVector[dc, xAxis, origin, camera];
SVGraphics.DrawChar[dc, 'x, camera];
DrawVector[dc, yAxis, origin, camera];
SVGraphics.DrawChar[dc, 'y, camera];
DrawVector[dc, zAxis, origin, camera];
SVGraphics.DrawChar[dc, 'z, camera];
};

alpha: REAL _ 0.25;

DrawSkitter: PUBLIC PROC [dc: Imager.Context, csCAMERA: Matrix4by4, camera: Camera] = {
OPEN SVVector3d;
origin: Point3d;
xAxis, yAxis, zAxis: Vector3d;
c, d: Point3d;
length: REAL = 50.0;
Imager.SetStrokeWidth[dc, 1.0];
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
xAxis _ Scale[xAxis, length];
yAxis _ Scale[yAxis, length];
zAxis _ Scale[zAxis, length];
DrawVector[dc, xAxis, origin, camera];
SVGraphics.DrawChar[dc, 'x, camera];
DrawVector[dc, yAxis, origin, camera];
SVGraphics.DrawChar[dc, 'y, camera];
DrawVector[dc, zAxis, origin, camera];
c _ Add[origin, Add[zAxis, Scale[yAxis, alpha]]];
d _ Add[origin, Add[zAxis, Scale[yAxis, -alpha]]];
SVGraphics.SetCPAbsolute[dc, origin, camera];
SVGraphics.DrawToAbsolute[dc, c, camera];
SVGraphics.DrawToAbsolute[dc, d, camera];
SVGraphics.DrawToAbsolute[dc, origin, camera];
};

DrawTargetCoordSys: PUBLIC PROC [dc: Imager.Context, csCAMERA: Matrix4by4, camera: Camera] = {
origin: Point3d;
xAxis, yAxis, zAxis: Vector3d;
upLeftVector, upRightVector, downRightVector, downLeftVector: Vector3d;
length: REAL = 50.0;
scalar: REAL = 0.8;
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ SVVector3d.Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ SVVector3d.Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ SVVector3d.Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
xAxis _ SVVector3d.Scale[xAxis, length];
yAxis _ SVVector3d.Scale[yAxis, length];
zAxis _ SVVector3d.Scale[zAxis, length];
DrawVector[dc, xAxis, origin, camera];
SVGraphics.DrawChar[dc, 'x, camera];
DrawVector[dc, yAxis, origin, camera];
SVGraphics.DrawChar[dc, 'y, camera];
DrawVector[dc, zAxis, origin, camera];
SVGraphics.DrawChar[dc, 'z, camera];
upLeftVector _ SVVector3d.Sub[yAxis, xAxis];
upRightVector _ SVVector3d.Add[yAxis, xAxis];
downRightVector _ SVVector3d.Negate[upLeftVector];
downLeftVector _ SVVector3d.Negate[upRightVector];
upLeftVector _ SVVector3d.Scale[upLeftVector, scalar];
upRightVector _ SVVector3d.Scale[upRightVector, scalar];
downRightVector _ SVVector3d.Scale[downRightVector, scalar];
downLeftVector _ SVVector3d.Scale[downLeftVector, scalar];
SVGraphics.SetCPAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
};

scalar: REAL _ 4.0;
DrawAnchor: PUBLIC PROC [dc: Imager.Context, csCAMERA: Matrix4by4, camera: Camera] = {
OPEN SVVector3d, SVGraphics;
origin: Point3d;
xAxis, yAxis, zAxis: Vector3d;
plusX, minusX, plusY, minusY: Vector3d;
plusXWing, minusXWing, plusYWing, minusYWing: Vector3d;
widthX, widthY, nearStab, farStab, nearSide, downVec, bitDown, bitIn: Vector3d;
width: REAL _ 6.0*scalar;
side: REAL _ 3.5*scalar;
sideAndWing: REAL _ 7.5*scalar;
down: REAL _ 8.5*scalar;
bit: REAL _ scalar;
Triangle: PROC [] = {
path: ImagerPath.Trajectory;
path _ SVGraphics.MoveToAbsolute[Add[origin, nearStab], camera];
path _ SVGraphics.LineToAbsolute[path, Add[origin, farStab], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, nearStab], downVec], camera];
Imager.MaskFillTrajectory[dc, path];
};
Rectangle: PROC [] = {
path: ImagerPath.Trajectory;
path _ SVGraphics.MoveToAbsolute[Add[origin, nearSide], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, nearSide], bitDown], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, nearStab], bitDown], camera];
path _ SVGraphics.LineToAbsolute[path, Add[origin, nearStab], camera];
Imager.MaskFillTrajectory[dc, path];
};
SquareSide: PROC [] = {
path: ImagerPath.Trajectory;
path _ SVGraphics.MoveToAbsolute[Add[origin, nearStab], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, nearStab], bitDown], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, farStab], bitDown], camera];
path _ SVGraphics.LineToAbsolute[path, Add[origin, farStab], camera];
Imager.MaskFillTrajectory[dc, path];
path _ SVGraphics.MoveToAbsolute[Add[origin, nearStab], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, nearStab], bitIn], camera];
path _ SVGraphics.LineToAbsolute[path, Add[Add[origin, farStab], bitIn], camera];
path _ SVGraphics.LineToAbsolute[path, Add[origin, farStab], camera];
Imager.MaskFillTrajectory[dc, path];
};
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ SVVector3d.Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ SVVector3d.Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ SVVector3d.Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
bitDown _ SVVector3d.Scale[zAxis, bit];
Imager.SetStrokeWidth[dc, 2.0];
Imager.SetColor[dc, Imager.black];
Imager.SetStrokeEnd[dc, square];
Imager.SetStrokeJoint[dc, round];
plusX _ Scale[xAxis, side];
minusX _ Scale[xAxis, -side];
plusY _ Scale[yAxis, side];
minusY _ Scale[yAxis, -side];
nearStab _ Add[minusX, plusY]; farStab _ Add[plusX, plusY];
bitIn _ Scale[yAxis, -bit]; SquareSide[];
nearStab _ farStab; farStab _ Add[plusX, minusY];
bitIn _ Scale[xAxis, -bit]; SquareSide[];
nearStab _ farStab; farStab _ Add[minusX, minusY];
bitIn _ Scale[yAxis, bit]; SquareSide[];
nearStab _ farStab; farStab _ Add[minusX, plusY];
bitIn _ Scale[xAxis, bit]; SquareSide[];
plusXWing _ SVVector3d.Scale[xAxis, sideAndWing];
minusXWing _ SVVector3d.Scale[xAxis, -sideAndWing];
plusYWing _ SVVector3d.Scale[yAxis, sideAndWing];
minusYWing _ SVVector3d.Scale[yAxis, -sideAndWing];
downVec _ SVVector3d.Scale[zAxis, down];
widthX _ SVVector3d.Scale[xAxis, width];
widthY _ SVVector3d.Scale[yAxis, width];
nearStab _ plusXWing; farStab _ Add[plusXWing, widthX];  Triangle[];
nearSide _ plusX; Rectangle[];
nearStab _ minusXWing; farStab _ Sub[minusXWing, widthX];  Triangle[];
nearSide _ minusX; Rectangle[];
nearStab _ plusYWing; farStab _ Add[plusYWing, widthY];  Triangle[];
nearSide _ plusY; Rectangle[];
nearStab _ minusYWing; farStab _ Sub[minusYWing, widthY];  Triangle[];
nearSide _ minusY; Rectangle[];
};


DrawJack: PUBLIC PROC [dc: Imager.Context, cs: CoordSystem, camera: Camera] = {
csCAMERA: Matrix4by4 _ SVCoordSys.WRTCamera[cs, camera.coordSys];
DrawCoordSys[dc, csCAMERA, camera];
};

DrawMovee: PUBLIC PROC [dc: Imager.Context, cs: CoordSystem, camera: Camera] = {
origin: Point3d;
xAxis, yAxis, zAxis: Vector3d;
csCAMERA: Matrix4by4 _ SVCoordSys.WRTCamera[cs, camera.coordSys];
upLeftVector, upRightVector, downRightVector, downLeftVector: Vector3d;
length: REAL = 50.0;
scalar: REAL = 0.2;
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ SVVector3d.Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ SVVector3d.Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ SVVector3d.Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
xAxis _ SVVector3d.Scale[xAxis, length];
yAxis _ SVVector3d.Scale[yAxis, length];
zAxis _ SVVector3d.Scale[zAxis, length];
DrawVector[dc, xAxis, origin, camera];
SVGraphics.DrawChar[dc, 'x, camera];
DrawVector[dc, yAxis, origin, camera];
SVGraphics.DrawChar[dc, 'y, camera];
DrawVector[dc, zAxis, origin, camera];
SVGraphics.DrawChar[dc, 'z, camera];
upLeftVector _ SVVector3d.Sub[yAxis, xAxis];
upRightVector _ SVVector3d.Add[yAxis, xAxis];
downRightVector _ SVVector3d.Negate[upLeftVector];
downLeftVector _ SVVector3d.Negate[upRightVector];
upLeftVector _ SVVector3d.Scale[upLeftVector, scalar];
upRightVector _ SVVector3d.Scale[upRightVector, scalar];
downRightVector _ SVVector3d.Scale[downRightVector, scalar];
downLeftVector _ SVVector3d.Scale[downLeftVector, scalar];
SVGraphics.SetCPAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
};

DrawPlaneSelection: PUBLIC PROC [dc: Imager.Context, cs: CoordSystem, planeNum: NAT, camera: Camera] = {
origin: Point3d;
csCAMERA: Matrix4by4 _ SVCoordSys.WRTCamera[cs, camera.coordSys];
xAxis, yAxis, zAxis: Vector3d;
tightRopeStart, tightRopeEnd: Point3d;
upLeftVector, upRightVector, downRightVector, downLeftVector: Vector3d;
length: REAL = 50.0;
SELECT planeNum FROM
1 => { -- x = 0 plane
csCAMERA _ SVMatrix3d.LocalRotateY[csCAMERA, -90];
};
2 => { -- y = 0 plane
csCAMERA _ SVMatrix3d.LocalRotateX[csCAMERA, 90];
};
3 => { -- z = 0 plane
};
ENDCASE => ERROR;
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
xAxis _ SVVector3d.Normalize[SVMatrix3d.XAxisOfMatrix[csCAMERA]];
yAxis _ SVVector3d.Normalize[SVMatrix3d.YAxisOfMatrix[csCAMERA]];
zAxis _ SVVector3d.Normalize[SVMatrix3d.ZAxisOfMatrix[csCAMERA]];
xAxis _ SVVector3d.Scale[xAxis, length];
yAxis _ SVVector3d.Scale[yAxis, length];
zAxis _ SVVector3d.Scale[zAxis, length];
upLeftVector _ SVVector3d.Sub[yAxis, xAxis];
upRightVector _ SVVector3d.Add[yAxis, xAxis];
downRightVector _ SVVector3d.Negate[upLeftVector];
downLeftVector _ SVVector3d.Negate[upRightVector];
SVGraphics.SetCPAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downRightVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, downLeftVector], camera];
SVGraphics.DrawToAbsolute[dc, SVVector3d.Add[origin, upLeftVector], camera];
tightRopeStart _ SVVector3d.Sub[origin, zAxis];
tightRopeEnd _ SVVector3d.Add[origin, zAxis];
SVGraphics.SetCPAbsolute[dc, tightRopeStart, camera];
SVGraphics.DrawToAbsolute[dc, tightRopeEnd, camera];
};

DrawPlane: PUBLIC PROC [dc: Imager.Context, left, right, down, up: REAL, cs: CoordSystem, camera: Camera, plane: [1..3] _ 1] = {
localCamera: Matrix4by4 _ SVCoordSys.WRTCamera[cs, camera.coordSys];
IF plane # 1 THEN ERROR; -- not implemented
SVGraphics.SetCP[dc, [0, up, left], camera, localCamera];
SVGraphics.DrawTo[dc, [0, up, right], camera, localCamera];
SVGraphics.DrawTo[dc, [0, down, right], camera, localCamera];
SVGraphics.DrawTo[dc, [0, down, left], camera, localCamera];
SVGraphics.DrawTo[dc, [0, up, left], camera, localCamera];
};
DrawVector: PUBLIC PROC [dc: Imager.Context, v: Vector3d, origin: Point3d, camera: Camera, strokeWidth: REAL _ 1.0] = {
tip: Point3d;
originOnScreen, tipOnScreen, textOnScreen: Point2d;
vProjected: Vector2d;
mag: REAL;
epsilon: REAL = 1.0e-3;
tip _ SVVector3d.Add[origin, v];
SVGraphics.SetCPAbsolute[dc, origin, camera];
SVGraphics.DrawToAbsolute[dc, tip, camera, strokeWidth];
originOnScreen _ SVGraphics.DoProjection[origin, camera];
tipOnScreen _ SVGraphics.DoProjection[tip, camera];
vProjected _ SVVector2d.Sub[tipOnScreen, originOnScreen];
mag _ SVVector2d.Magnitude[vProjected];
IF mag < epsilon  THEN vProjected _ [-7.0, 0.0]
ELSE vProjected _ SVVector2d.Scale[vProjected, 7.0/mag];
textOnScreen _ SVVector2d.Add[tipOnScreen, vProjected];
SVGraphics.SetCPAbsolute[dc, [textOnScreen[1], textOnScreen[2], 0.0],  camera];
};

DrawLocalVector: PUBLIC PROC [dc: Imager.Context, v: Vector3d, origin: Point3d, camera: Camera, localCS: CoordSystem, strokeWidth: REAL _ 1.0] = {
tip: Point3d;
localCamera: Matrix4by4 _ SVCoordSys.WRTCamera[localCS, camera.coordSys];
tip _ SVVector3d.Add[origin, v];
SVGraphics.SetCP[dc, origin, camera, localCamera];
SVGraphics.DrawTo[dc, tip, camera, localCamera, strokeWidth];
};

Draw2dCoordSys: PUBLIC PROC [dc: Imager.Context, origin: Point2d, camera: Camera] = {
originScreen: Point2d;
big: REAL = 9999.0;
originScreen _ SVCoordSys.CameraToScreen[origin, camera.screenCS];

Imager.MaskVector[dc, [originScreen[1]-big, originScreen[2]],

[originScreen[1]+big, originScreen[2]]];

Imager.MaskVector[dc, [originScreen[1], originScreen[2] + big], [originScreen[1], originScreen[2] - big]];
};
DrawX: PUBLIC PROC [dc: Imager.Context, point: Point2d, camera: Camera] = {
origin: Point2d;
side: REAL _ 7.0;
origin _ SVCoordSys.CameraToScreen[point, camera.screenCS];
Imager.MaskVector[dc, [origin[1]-side, origin[2] + side], [origin[1]+side, origin[2] - side]];
Imager.MaskVector[dc, [origin[1] + side, origin[2] + side], [origin[1]-side, origin[2] - side]];
};

DrawFilledSquare: PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera, side: REAL] = {
halfSide: REAL _ side/2.0;
DoDrawFilledSquare: PROC = {
Imager.SetXY[dc, [screenPt[1], screenPt[2]] ];   -- set the current position
Imager.Move[dc];
Imager.SetColor[dc, Imager.black];
Imager.MaskRectangle[dc, [- halfSide, - halfSide, side, side]];
};
worldCamera: Matrix4by4 _ SVCoordSys.FindWorldInTermsOf[camera.coordSys];
cameraPt: Point3d _ SVMatrix3d.Update[worldPt, worldCamera];
screenPt: Point2d;

screenPt _ SVGraphics.DoProjection[cameraPt, camera];
screenPt _ SVCoordSys.CameraToScreen[screenPt, camera.screenCS];
Imager.DoSave[dc, DoDrawFilledSquare];
};

DrawEmptySquare: PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera, side: REAL] = {
halfSide: REAL _ side/2.0;
DoDrawEmptySquare: PROC = {
Imager.SetXY[dc, [screenPt[1], screenPt[2]]];   -- set the current position
Imager.Move[dc];
Imager.SetColor[dc, Imager.black];
Imager.MaskRectangle[dc, [- halfSide, - halfSide, side, side]];
Imager.SetColor[dc, Imager.white];
Imager.MaskRectangle[dc, [- halfSide+1, - halfSide+1, side-2, side-2]];
};
worldCamera: Matrix4by4 _ SVCoordSys.FindWorldInTermsOf[camera.coordSys];
cameraPt: Point3d _ SVMatrix3d.Update[worldPt, worldCamera];
screenPt: Point2d;

screenPt _ SVGraphics.DoProjection[cameraPt, camera];
screenPt _ SVCoordSys.CameraToScreen[screenPt, camera.screenCS];
Imager.DoSave[dc, DoDrawEmptySquare];
};

DrawSelectedJoint: PUBLIC PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera, selectClass: SelectionClass] = {
jointSize: REAL = 6.0;
hotJointSize: REAL = 10.0;

IF selectClass=hot THEN DrawEmptySquare[dc, worldPt, camera, hotJointSize]
ELSE IF selectClass=normal THEN DrawFilledSquare[dc, worldPt, camera, jointSize]
ELSE {DrawEmptySquare[dc, worldPt, camera, jointSize]; DrawFilledSquare[dc, worldPt, camera, 2.0]};
};

DrawCP: PUBLIC PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera] = {
DoDrawEmptySquare: PROC [dc: Imager.Context] = {
halfJointSize: REAL = 3.0;
jointSize: REAL = 6.0;
Imager.SetColor[dc, Imager.black];
Imager.MaskRectangle[dc, [-halfJointSize, -halfJointSize, jointSize, jointSize]];
Imager.SetColor[dc, Imager.white];
Imager.MaskRectangle[dc, [-halfJointSize+1, -halfJointSize+1, jointSize-2, jointSize-2]];
};
DrawPointAux[dc, worldPt, camera, DoDrawEmptySquare];
};

DrawGlow: PUBLIC PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera] = {
DoDrawGlow: PROC [dc: Imager.Context] = {
cos30, sin30, xr, xR, yr, yR: REAL;
r: REAL = 3.0;
R: REAL = 7.0;
cos30 _ 0.8660254;
sin30 _ 0.5;
Imager.SetColor[dc, Imager.black];
Imager.SetStrokeWidth[dc, 2.0];
Imager.MaskVector[dc, [0.0, r], [0.0, R]];
Imager.MaskVector[dc, [0.0, -r], [0.0, -R]];

xr _ cos30*r;
xR _ cos30*R;
yr _ sin30*r;
yR _ sin30*R;
Imager.MaskVector[dc, [xr, yr], [xR, yR]];
Imager.MaskVector[dc, [-xr, -yr], [-xR, -yR]];

Imager.MaskVector[dc, [-xr, yr], [-xR, yR]];
Imager.MaskVector[dc, [xr, -yr], [xR, -yR]];
};
DrawPointAux[dc, worldPt, camera, DoDrawGlow];
};

DrawProc: TYPE = PROC [dc: Imager.Context];
DrawPointAux: PROC [dc: Imager.Context, worldPt: Point3d, camera: Camera, drawProc: DrawProc] = {
DoDrawBody: PROC = {
Imager.SetXY[dc, [screenPt[1], screenPt[2]]];   -- set the current position
Imager.Move[dc];
drawProc[dc];
};
worldCamera: Matrix4by4 _ SVCoordSys.FindWorldInTermsOf[camera.coordSys];
cameraPt: Point3d _ SVMatrix3d.Update[worldPt, worldCamera];
screenPt: Point2d;
screenPt _ SVGraphics.DoProjection[cameraPt, camera];
screenPt _ SVCoordSys.CameraToScreen[screenPt, camera.screenCS];
Imager.DoSaveAll[dc, DoDrawBody];
};

DrawBoundBoxes: PUBLIC PROC [dc: Imager.Context, tree: CSGTree, camera: Camera] = {
DrawBoundBoxNode[dc, tree.son, camera];
};

DrawBoundBoxNode: PROC [dc: Imager.Context, node: REF ANY, camera: Camera] = {
IF node = NIL THEN RETURN;
WITH node SELECT FROM
composite: Composite => {
SVBoundBox.DrawBoundBox[dc, composite.boundBox, camera.screenCS];
DrawBoundBoxNode[dc, composite.leftSolid, camera];
DrawBoundBoxNode[dc, composite.rightSolid, camera];
};
prim: Primitive => {
SVBoundBox.DrawBoundBox[dc, prim.boundBox, camera.screenCS];
};
ENDCASE => ERROR;
};

DrawBoundBox: PUBLIC PROC [dc: Imager.Context, node: REF ANY, camera: Camera, xor: BOOL] = {};

DrawBoundSpheres: PUBLIC PROC [dc: Imager.Context, tree: CSGTree, camera: Camera] = {
DrawBoundSphereNode[dc, tree.son, camera];
};
DrawBoundSphereNode: PROC [dc: Imager.Context, node: REF ANY, camera: Camera] = {
IF node = NIL THEN RETURN;
WITH node SELECT FROM
composite: Composite => {
SVBoundSphere.DrawBoundSphere[dc, composite.boundSphere, camera];
DrawBoundSphereNode[dc, composite.leftSolid, camera];
DrawBoundSphereNode[dc, composite.rightSolid, camera];
};
prim: Primitive => {
SVBoundSphere.DrawBoundSphere[dc, prim.boundSphere, camera];
};
ENDCASE => ERROR;
};



DrawTransformedShape: PUBLIC PROC [dc: Imager.Context, csCAMERA: Matrix4by4, camera: Camera, path: Imager.PathProc] = {
DrawIt: PROC = {
DrawPath: Imager.PathProc = {
ImagerPath.Transform[path, projection, moveTo, lineTo, curveTo, conicTo, arcTo];
};
Imager.SetStrokeWidth[dc, 3.0];
Imager.MaskStroke[context: dc, path: DrawPath, closed: TRUE];
};
xAxis, yAxis: Vector3d;
origin: Point3d;
projection, localCamera, cameraScreen: ImagerTransformation.Transformation;
xAxis _ SVMatrix3d.XAxisOfMatrix[csCAMERA];
yAxis _ SVMatrix3d.YAxisOfMatrix[csCAMERA];
origin _ SVMatrix3d.OriginOfMatrix[csCAMERA];
localCamera _ ImagerTransformation.Create[xAxis[1], yAxis[1], origin[1], xAxis[2], yAxis[2], origin[2]];
cameraScreen _ CameraWRTScreen[camera];
projection _ ImagerTransformation.Concat[localCamera, cameraScreen];
Imager.DoSaveAll[dc, DrawIt];
};

CameraWRTScreen: PROC [camera: Camera] RETURNS [cameraScreen: ImagerTransformation.Transformation] = {
screenCoordSys: CoordSystem _ camera.screenCS;
screenMat: Matrix4by4 _ SVCoordSys.GetMat[screenCoordSys];
cameraScreen _ ImagerTransformation.Translate[t:
[- screenMat[1][4], - screenMat[2][4]]
];
};


END.

ξFile: SVDraw3dImpl.mesa
Last edited by Bier on December 18, 1982 1:19 am
Author: Eric Bier on September 23, 1987 7:41:14 pm PDT
Reconstructed from memory on July 18, 1985 1:02:55 pm PDT
Contents: Some useful combinations of Imager operations
SVGraphics.DrawChar[dc, 'z, camera];
Now draw the landing pad (in the z = 0 plane).
sideAndWingF: REAL _ 7.0*scalar;
Draw the square in the middle.
Draw the Four Wings and the Four Stabilizers
Now draw the landing pad (in the z = 0 plane).
Now draw the landing pad (in the z = 0 plane).
Now draw the tightrope (along the z axis).
Draw the square bounded by left, right, down, and up (left-right = z, down-up = y) in the x = 0 plane of cs.  In other words, draw the square [left, up], [right, up], [right, down], [left, down] defined in the coordinates of cs.

Assumes v and origin are in camera coords.
Now set current position in case the caller wants to draw a character after this vector.
Assumes v and origin are in localCS coords.

Two Dimensional Objects
Poorly named.  This function draws cross hairs.  origin is in camera coordinates.

Used by Draw Point to indicate a point of interest.  Would be in SVDraw, except that the point is in camera coordinates.
Draw a six pointed star-burst of outer radius R and inner radius r.
Any two dimensional shape that can be drawn with the Imager, can be drawn as though its sheet of paper has been embedded in 3-space, rotated, scaled, and translated by csCAMERA.  This procedure only works for the orthogonal projection.
ΚΌ˜Iheadš
œ™Iprocš
œ0™0Lš
œ6™6L™9Lš
œ7™7L˜š
Οk	˜	Lš
œΎ
˜Ύ
—L˜šœ
˜Lšœ€
˜‡
Lšœ˜—Lš
˜˜Lšœœ˜#Lšœœ˜)Lšœ
œ˜-Lšœ	œ˜%Lšœœ˜#Lšœ	œ˜Lšœ	œ˜Lšœœ˜)Lšœœ˜3Lšœ
œ˜Lšœ
œ˜L˜—šΟnœœ
œΟuœ!˜XL˜Lš
œ˜Lšœœ˜Lšœ%Ÿœ˜-Lšœ8Ÿœ˜ALšœ8Ÿœ˜ALšœ8Ÿœ˜ALš
œ(˜(Lš
œ(˜(Lš
œ(˜(Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$˜$L˜L˜—Lšœœ˜L˜šžœœ
œŸœ!˜WLšœ˜L˜Lš
œ˜L˜Lšœœ˜L˜Lšœ%Ÿœ˜-Lšœ-Ÿœ˜6Lšœ-Ÿœ˜6Lšœ-Ÿœ˜6Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$™$Lš
œ1˜1Lš
œ2˜2Lš
œ-˜-Lš
œ)˜)Lš
œ)˜)Lš
œ.˜.L˜L˜—šžœœ
œŸœ!˜^L˜Lš
œ˜L˜GLšœœ˜Lšœœ˜Lšœ%Ÿœ˜-Lšœ8Ÿœ˜ALšœ8Ÿœ˜ALšœ8Ÿœ˜ALš
œ(˜(Lš
œ(˜(Lš
œ(˜(Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&š
œ$˜$L™.—Lš
œ,˜,Lš
œ-˜-Lš
œ2˜2Lš
œ2˜2Lš
œ6˜6Lš
œ8˜8Lš
œ<˜<Lš
œ:˜:Lš
œK˜KLš
œM˜MLš
œO˜OLš
œN˜NLš
œL˜LL˜L˜—Lšœœ˜šž
œœ
œŸœ!˜VLšœ˜L˜Lš
œ˜L˜'Lš
œ7˜7Lš
œO˜OLšœœ˜Icodešœœ™ Lšœœ˜Lšœ
œ˜Mšœœ˜Mšœœ
˜šžœœ˜Mš
œ˜Mšœžœ ˜@Mšœžœ%˜EMšœžœ4˜TMš
œ$˜$M˜—šž	œœ˜Mš
œ˜Mšœžœ ˜@Mšœžœ4˜TMšœžœ4˜TMšœžœ&˜FMš
œ$˜$M˜—šž
œœ˜Mš
œ˜Mšœžœ ˜@Mšœžœ4˜TMšœžœ3˜SMšœžœ%˜EMš
œ$˜$Mšœžœ ˜@Mšœžœ2˜RMšœžœ1˜QMšœžœ%˜EMš
œ$˜$M˜—Lšœ%Ÿœ˜-Lšœ8Ÿœ˜ALšœ8Ÿœ˜ALšœ8Ÿœ˜ALš
œ'˜'M˜M˜"M˜ Mš
œ!˜!Mš
œ˜Mš
œ˜Mš
œ˜Mš
œ˜Mš
Οb™š
œ;˜;Mš
œ)˜)—š
œ1˜1Mš
œ)˜)—š
œ2˜2Mš
œ(˜(—š
œ1˜1Mš
œ(˜(—Lš
 ,™,Mš
œ1˜1Mš
œ3˜3Mš
œ1˜1Mš
œ3˜3Lš
œ(˜(Lš
œ(˜(Lš
œ(˜(š
œD˜DLš
œ˜—š
œF˜FLš
œ˜—š
œD˜DLš
œ˜—š
œF˜FLš
œ˜—L˜L˜L˜—šžœœ
œ:˜OLšœŸœ9˜ALšœŸœ
˜#L˜L˜—šž	œœ
œ:˜PL˜Lš
œ˜LšœŸœ9˜AL˜GLšœœ˜Lšœœ˜Lšœ%Ÿœ˜-Lšœ8Ÿœ˜ALšœ8Ÿœ˜ALšœ8Ÿœ˜ALš
œ(˜(Lš
œ(˜(Lš
œ(˜(Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&Lš
œ$˜$Lš
œ&˜&š
œ$˜$L™.—Lš
œ,˜,Lš
œ-˜-Lš
œ2˜2Lš
œ2˜2Lš
œ6˜6Lš
œ8˜8Lš
œ<˜<Lš
œ:˜:Lš
œK˜KLš
œM˜MLš
œO˜OLš
œN˜NLš
œL˜LL˜L˜—šžœœ
œ1œ˜hL˜LšœŸœ9˜ALš
œ˜Lš
œ&˜&L˜GLšœœ˜Lšœ
˜šœΟc˜LšœŸœŸœ˜2L˜—šœ‘˜LšœŸœŸœ˜1L˜—šœ‘˜L˜—Lšœœ
˜Lšœ%Ÿœ˜-Lšœ8Ÿœ˜ALšœ8Ÿœ˜ALšœ8Ÿœ˜ALš
œ(˜(Lš
œ(˜(š
œ(˜(L™.—Lš
œ,˜,Lš
œ-˜-Lš
œ2˜2Lš
œ2˜2Lš
œK˜KLš
œM˜MLš
œO˜OLš
œN˜Nš
œL˜LL™*—Lš
œ/˜/Lš
œ-˜-Lš
œ5˜5Lš
œ4˜4L˜L˜—šž	œœ
œ-œ9˜€
L™δ
LšœŸœ9˜DLšœœ
œ‘˜+Lšœ1Ÿœ˜9Lšœ3Ÿœ˜;Lšœ5Ÿœ˜=Lšœ4Ÿœ˜<Lšœ2Ÿœ˜:L˜L™—šž
œœ
œQœ˜wLš‘œ‘™*L˜
Lš
œ3˜3Lš
œ˜Lšœœ
˜
L˜Lš
œ ˜ Lš
œ-˜-š
œ8˜8L™X—Lš
œ9˜9Lš
œ3˜3Lš
œ9˜9Lš
œ'˜'Lšœœ˜/Lšœ4˜8Lš
œ7˜7Lš
œO˜OL˜L˜—šžœœ
œgœ˜’
Lš
œ+™+L˜
LšœŸœ>˜ILš
œ ˜ Lšœ*Ÿœ˜2Lšœ(Ÿœ˜=L˜L™—L˜L™šžœœ
œ:˜ULš
œQ™QLšœŸœ
˜Lšœœ
˜LšœŸœ6˜BL˜Lš
œ=˜=˜LšœŸœŸœ˜(—L˜LšœGŸœŸœ˜jL˜L™—šžœœ
œ9˜KL™xL˜Lšœœ˜Lš
œ;˜;Lš
œ^˜^Lš
œ`˜`L˜L˜—šžœœ>œ˜]Mšœ
œ˜šžœœ˜Mšœ1‘˜LMš
œ˜Mš
œ"˜"Mš
œ?˜?M˜—LšœŸœ>˜ILšœ4Ÿœ˜<L˜M˜Lš
œ5˜5Lš
œ@˜@Mš
œ&˜&M˜M˜—šžœœ>œ˜\šœ
œ˜šžœœ˜Mšœ0‘˜KMš
œ˜Mš
œ"˜"Mš
œ?˜?M˜"Mš
œG˜GM˜——LšœŸœ>˜ILšœ4Ÿœ˜<L˜M˜Lš
œ5˜5Lš
œ@˜@Mš
œ%˜%M˜M˜—šžœœ
œX˜vLšœœ˜Lšœœ˜L˜Mšœœ3˜JMšœ
œœ1˜PMšœ_˜cL˜L˜—šžœœ
œ;˜Nšžœœ˜0Lšœœ˜Lšœœ˜Mš
œ"˜"Mš
œQ˜QM˜"Mš
œY˜YM˜—Lš
œ5˜5L˜L˜—šžœœ
œ;˜PL™Cšž
œœ˜)Lšœœ
˜#Lšœœ˜Lšœœ˜Lš
œ˜Lš
œ˜Lš
œ"˜"Lš
œ˜L˜*L˜,L˜Lš
œ
˜
Lš
œ
˜
Lš
œ
˜
Lš
œ
˜
Lš
œ*˜*Lš
œ.˜.L˜Lš
œ,˜,Lš
œ,˜,L˜—Lš
œ.˜.L˜L˜—Lšœ
œœ˜+šžœœO˜ašž
œœ˜Mšœ0‘˜KMš
œ˜Mš
œ
˜
M˜—Lš
œI˜ILš
œ<˜<L˜Lš
œ5˜5Lš
œ@˜@Mš
œ!˜!L˜L˜—šžœœ
œ8˜SLš
œ'˜'Lš
œ˜L˜—šžœœœ
œ˜NLšœœ
œ
œ
˜Lšœœ
˜˜Lš
œA˜ALš
œ2˜2Lš
œ3˜3L˜—š
œ˜Lš
œ<˜<L˜—Lšœœ
˜˜L˜——Lšžœœ
œœ
œœ˜^L˜šžœœ
œ8˜ULš
œ*˜*Lš
œ˜—šžœœœ
œ˜QLšœœ
œ
œ
˜Lšœœ
˜˜Lš
œA˜ALš
œ5˜5Lš
œ6˜6L˜—š
œ˜Lš
œ<˜<L˜—Lšœœ
˜˜L˜——˜L˜—šΠbnœœ
œŸœ8˜wLšœͺ
Ÿœ;™λ
šžœœ˜šžœ˜Lšœ 
œ+˜PL˜—L•StartOfExpansionP[context: 
Imager.Context, path: 
ImagerPath.PathProc, closed: 
BOOL _ FALSE]š
œ˜Lšœ% œ
œ˜=L˜—L˜L˜LšœŸœ
Ÿ
œŸœ&˜KLšœ#Ÿœ˜+Lšœ#Ÿœ˜+Lšœ%Ÿœ˜-LšœŸœ]˜hLšœŸœ˜'Lšœ.ŸœŸœ˜DL˜Lš
œ˜L˜—šžœœœŸœ*˜fL–
[t: 
VEC]š
œ.˜.Lš
œ:˜:šœŸœ$˜0Lš
œ&˜&Lš
œ˜—L˜L˜—L˜Lšœ
˜J˜—…—NdΎ