AIS,

CastRays,

CoordSys,

CSG,

CSGGraphics,

DisplayList3d,

DisplayListToTree,

Graphics,

GraphicsColor,

InputFocus,

IO,

Matrix3d,

Preprocess3d,

Real,

SV2d,

SV3d,

SVArtworkUser,

SVError,

SVInterfaceTypes,

SVLines2d,

SVMatrix2d,

SVModelTypes,

SVRayTypes,

SVSceneTypes,

SVSelections,

SVVector3d,

SVViewerInput,

SVViewerUser,

TIPUser,

ViewerClasses;

IMPORTS AIS, CastRays, CoordSys, CSG, CSGGraphics, DisplayList3d, DisplayListToTree, Graphics, GraphicsColor, InputFocus, --IO, --Matrix3d, Preprocess3d, Real, SVArtworkUser, SVError, SVLines2d, SVMatrix2d, SVSelections, SVViewerInput, SVViewerUser, SVVector3d

EXPORTS SVViewerInput =

Artwork: TYPE = SVModelTypes.Artwork;

ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;

Assembly: TYPE = SVSceneTypes.Assembly;

AssemblyList: TYPE = SVSceneTypes.AssemblyList;

BoundBox: TYPE = SVModelTypes.BoundBox;

Camera: TYPE = SVModelTypes.Camera;

Classification: TYPE = SVRayTypes.Classification;

Color: TYPE = GraphicsColor.Color;

CoordSystem: TYPE = SVModelTypes.CoordSystem;

EditToolData: TYPE = SVInterfaceTypes.EditToolData;

FileCamera: TYPE = SVSceneTypes.FileCamera;

FrameBox: TYPE = SVModelTypes.FrameBox;

MasterObject: TYPE = SVSceneTypes.MasterObject;

Matrix4by4: TYPE = SV3d.Matrix4by4;

Point2d: TYPE = SV2d.Point2d;

Point3d: TYPE = SV3d.Point3d;

Primitive: TYPE = SVRayTypes.Primitive;

Ray: TYPE = SVRayTypes.Ray;

Scene: TYPE = SVSceneTypes.Scene;

SearchDepth: TYPE = SVInterfaceTypes.SearchDepth;

Selection: TYPE = SVInterfaceTypes.Selection;

SelectionGenerator: TYPE = SVInterfaceTypes.SelectionGenerator;

Shape: TYPE = SVSceneTypes.Shape;

SkitterMode: TYPE = SVInterfaceTypes.SkitterMode;

ToolData: TYPE = SVSceneTypes.ToolData;

TrigLine: TYPE = SV2d.TrigLine;

Vector: TYPE = SV3d.Vector;

ViewerToolData: TYPE = SVInterfaceTypes.ViewerToolData;

SELECT searchDepth FROM

first =>

lastOfFirst =>

last =>

lastOfLevel1 =>

ENDCASE => ERROR;

};

SELECT searchDepth FROM

first => [assembly, primitive] ← CastRays.NthAssemblyAndPrimitive[class, 1];

lastOfFirst => [assembly, primitive] ← CastRays.NthAssemblyAndPrimitive[class, 1];

last => [assembly, primitive] ← CastRays.NthAssemblyAndPrimitive[class, class.count];

lastOfLevel1 => [assembly, primitive] ← CastRays.LastTopLevelAssemAndPrim[class, root];

ENDCASE => ERROR;

};

Use the distinguished target assembly's coordinate system as the platform for each tight rope step. We key off of the plane of the target's tool. If plane = 1, we stay along the x-axis, 2 the y-axis, 3 the z-axis. 4 currently works as the x-axis, but might someday compute the nearest axis.

planeSel: Selection;

planeAssem: Assembly;

scene: Scene ← viewerToolData.scene;

planeSel ← SVSelections.TopPlane[];

SVSelections.SetModeSkitter[tightrope];

IF planeSel = NIL THEN {

planeAssem ← planeSel.coincident;

DuringTightRope[viewerToolData, cameraPoint];

};

Compute the new position of the skitter given the mouse position in CAMERA coordinates. This is somewhat tricky. The effect I would like is this: We are constraining the skitter to move along an axis (a line) in 3-space. This line projects onto a line on the screen (using the current camera projection). If we drop a perpendicular from the mousept to this 2d line, that is where the skitter should appear in 2-space. Compute the corresponding point in 3-space and we are done.

skitterTarget: Matrix4by4;

newOriginCamera, newOriginTarget: Point3d;

plane: NAT;

toolData: ToolData;

cameraDir: Vector;

camera1, camera2: Point3d;

screen1, screen2, q: Point2d;

ropeShadow, normalLine: TrigLine;

parallel: BOOL;

camera: Camera ← viewerToolData.camera;

targetCS: CoordSystem ← target.coordSys;

worldCS: CoordSystem ← viewerToolData.scene.coordSysRoot;

cameraCS: CoordSystem ← camera.coordSys;

DoDrawIntersection: PROC [dc: Graphics.Context] = {

camera1 ← Matrix3d.OriginOfMatrix[targetCS.wrtCamera];

toolData ← NARROW[target.toolMasterObject.mainBody];

plane ← toolData.plane;

plane ← IF plane > 3 THEN 3 ELSE plane;

SELECT plane FROM

ENDCASE => ERROR;

camera2 ← SVVector3d.Add[camera1, cameraDir];

screen1 ← CSGGraphics.DoProjection[camera1, camera];

screen2 ← CSGGraphics.DoProjection[camera2, camera];

ropeShadow ← SVLines2d.TrigLineFromPoints[screen1, screen2];

normalLine ← SVLines2d.TrigLineNormalToTrigLineThruPoint[ropeShadow, cameraPoint];

[q, parallel] ← SVLines2d.TrigLineMeetsTrigLine[ropeShadow, normalLine];

IF parallel THEN ERROR;

SVViewerUser.Painter[DoDrawIntersection, viewerToolData];

Now for the hard part. If we represent the tightrope parametrically as:

BEGIN

END;

newOriginTarget ← CoordSys.FromCSToCS[newOriginCamera, cameraCS, targetCS];

skitterTarget ← Matrix3d.MakeTranslateMat[newOriginTarget[1], newOriginTarget[2], newOriginTarget[3]];

skitterWORLD ← CoordSys.FromCSToCSMat[skitterTarget, targetCS, worldCS];

};

First find the cameraPoint in the coordinate system of the target. Use only the plane-th component of the resulting point in 3-space. Draw a line from the target origin to the new skitter origin.

planeAssem: Assembly;

planeSel: Selection;

skitterWORLD: Matrix4by4;

camera: Camera ← viewerToolData.camera;

planeSel ← SVSelections.TopPlane[];

IF planeSel = NIL THEN RETURN;

planeAssem ← planeSel.coincident;

skitterWORLD ← TightRopeAux[viewerToolData, cameraPoint, planeAssem];

SVViewerInput.ComplementSkitter[]; -- erase any old skitter

SVSelections.UpdateSkitter[NIL, NIL, viewerToolData];

SVSelections.PositionSkitter[cameraPoint, skitterWORLD];

SVViewerInput.ComplementSkitter[]; -- draw new skitter

};

DuringTightRope[viewerToolData, cameraPoint];

};

planeSel: Selection;

planeAssem: Assembly;

scene: Scene ← viewerToolData.scene;

planeSel ← SVSelections.TopPlane[];

SVSelections.SetModeSkitter[tightrope];

IF planeSel = NIL THEN {

planeAssem ← planeSel.coincident;

DuringWallWalk[viewerToolData, cameraPoint];

};

Cast a ray at the target plane (like for dragging). Use the intersection point as the new skitter origin.

planeAssem: Assembly;

planeSel: Selection;

targetWORLD, skitterWORLD: Matrix4by4;

hitPointWORLD: Point3d;

camera: Camera ← viewerToolData.camera;

scene: Scene ← viewerToolData.scene;

worldCS: CoordSystem ← scene.coordSysRoot;

toolData: ToolData;

parallel: BOOL;

planeSel ← SVSelections.TopPlane[];

IF planeSel = NIL THEN RETURN;

planeAssem ← planeSel.coincident;

toolData ← NARROW[planeAssem.toolMasterObject.mainBody];

IF toolData = NIL THEN {

[hitPointWORLD, parallel] ← RayMeetsTopPlane[cameraPoint, planeAssem, 0, toolData.plane, camera];

IF parallel THEN {

targetWORLD ← planeAssem.coordSys.wrtWorld;

skitterWORLD ← Matrix3d.Translate[targetWORLD, hitPointWORLD[1], hitPointWORLD[2], hitPointWORLD[3]];

SVViewerInput.ComplementSkitter[]; -- erase any old skitter

SVSelections.UpdateSkitter[NIL, NIL, viewerToolData];

SVSelections.PositionSkitter[cameraPoint, skitterWORLD];

SVViewerInput.ComplementSkitter[]; -- draw new skitter

};

DuringWallWalk[viewerToolData, cameraPoint];

};

IF r = 0.0 THEN RETURN[2];

IF r < 0.0 THEN RETURN[-1]

ELSE RETURN[1];

};

RETURN[Sign[v1[1]] = -Sign[v2[1]] OR

};

Create a Matrix4by4 with origin at surfacePtInWorld whose z axis is parallel to worldNormal and whose x zxis is orthogonal to both worldNormal and the y axis of cs in WORLD coordinates. Assume that cs.wrtWorld is accurate

yAxisOfCS: Vector ← Matrix3d.YAxisOfMatrix[cs.wrtWorld];

xAxis: Vector;

IF SVVector3d.Parallel[yAxisOfCS, worldNormal] THEN {

ELSE xAxis ← SVVector3d.CrossProduct[yAxisOfCS, worldNormal];

mat ← Matrix3d.MakeMatFromZandXAxis[worldNormal, xAxis, surfacePtInWorld];

};

targetPlanePt is in CAMERA coords.

newRay: Ray;

newRay ← CSG.GetRayFromPool[];

CSG.StuffWorldRayFromCamera[newRay, cameraPoint, camera];

[planePtWorld, parallel] ← CastRays.RayMeetsPlaneOfCoordSystem[target.coordSys, newRay, plane, depth];

CSG.ReturnRayToPool[newRay];

};

Compute the ray tracing tree for the current scene here so we don't have to recompute it each time the mouse position is sampled (SetTargetSelection).

selectionMat: Matrix4by4;

surfacePtWorld: Point3d;

normalWorld: Vector;

assembly: Assembly;

primitive: Primitive;

class: Classification;

rayWorld: Ray;

scene: Scene ← viewerToolData.scene;

camera: Camera ← viewerToolData.camera;

IF viewerToolData.treeOutOfDate THEN {

[class, rayWorld] ← CastRays.SingleRay2[cameraPoint, viewerToolData.tree, viewerToolData.camera];

[assembly, primitive] ← AssemblyAndPrimitiveAtSearchDepth[class, searchDepth, scene.assembly];

IF class.count > 0 THEN

CSG.ReturnRayToPool[rayWorld];

CastRays.ReturnClassToPool[class];

SVViewerInput.ComplementSkitter[]; -- erase any old skitter

IF assembly # NIL THEN {

SVSelections.SetModeSkitter[surface];

SVViewerInput.ComplementSkitter[]; -- draw new skitter

SVViewerUser.Selected[NIL, viewerToolData, red, FALSE, FALSE];

InputFocus.SetInputFocus[viewerToolData.viewerPicture];

}; -- end of StartSkitter

Cast a ray into the scene from this point. If it hits anything, use the surface normal at that point to derive a coordinate system whose z axis is the parallel to the normal.

surfacePtWorld: Point3d;

normalWorld: Vector;

assembly: Assembly;

primitive: Primitive;

selectionMat: Matrix4by4;

camera: Camera ← viewerToolData.camera;

scene: Scene ← viewerToolData.scene;

class: Classification;

rayWorld: Ray;

[class, rayWorld] ← CastRays.SingleRay2[cameraPoint, viewerToolData.tree, camera];

[assembly, primitive] ← AssemblyAndPrimitiveAtSearchDepth[class, searchDepth, scene.assembly];

IF class.count > 0 THEN

CSG.ReturnRayToPool[rayWorld];

CastRays.ReturnClassToPool[class];

SVViewerInput.ComplementSkitter[]; -- erase any old skitter

IF assembly # NIL THEN {

ELSE SVSelections.UpdateSkitter[NIL, NIL, viewerToolData];

SVViewerInput.ComplementSkitter[]; -- draw new skitter

}; -- end DuringSkitter

DuringSkitter[viewerToolData, cameraPoint, searchDepth]; -- set the skitter to the final point.

};

Using the previous skitter assembly as one node and the current value as another, find the common root and set the skitter assembly to this value. If current is NIL, leave the skitter assembly as it is. Set skitter assembly to the new value.

oldAssembly, assem, commonAncestor: Assembly;

oldPrimitive, prim: Primitive;

oldViewerToolData, vtd: ViewerToolData;

scene: Scene;

scene ← viewerToolData.scene;

[oldAssembly, oldPrimitive, oldViewerToolData] ← SVSelections.GetSkitterData[];

DuringSkitter[viewerToolData, cameraPoint, searchDepth];

[assem, prim, vtd] ← SVSelections.GetSkitterData[];

IF vtd # oldViewerToolData THEN {

IF assem = NIL THEN SVSelections.UpdateSkitter[oldAssembly, oldPrimitive, vtd]

ELSE {

};

Using the previous skitter assembly as one node and the current value as another, find the common root and set the skitter assembly to this value. If current is NIL, leave the skitter assembly as it is. Set skitter assembly to the new value.

oldAssembly, assem, commonAncestor: Assembly;

oldPrimitive, prim: Primitive;

oldViewerToolData, vtd: ViewerToolData;

scene: Scene;

scene ← viewerToolData.scene;

[oldAssembly, oldPrimitive, oldViewerToolData] ← SVSelections.GetSkitterData[];

DuringCoordSkitter[viewerToolData, cameraPoint];

[assem, prim, vtd] ← SVSelections.GetSkitterData[];

IF vtd # oldViewerToolData THEN {

IF assem = NIL THEN SVSelections.UpdateSkitter[oldAssembly, oldPrimitive, vtd]

ELSE {

};

sonD: REAL;

sonA: Assembly;

origin: Point3d;

WITH root.shape SELECT FROM

shape: Shape => { -- A primitive. Just compute distance.

alist: AssemblyList => { -- Take the minimum of myself and my subtrees, giving preference to the subtrees

ENDCASE => ERROR;

};

SVViewerUser.Selected[NIL, viewerToolData, red, FALSE, FALSE];

InputFocus.SetInputFocus[viewerToolData.viewerPicture];

DuringCoordSkitter[viewerToolData, cameraPoint];

};

The user is trying to point at an existing coordinate frame. The skitter will highlight the frame which is nearest (in Euclidean distance) to the ray from eyepoint thru mouse point.

cameraRay: Ray ← CSG.GetRayFromPool[];

camera: Camera ← viewerToolData.camera;

scene: Scene ← viewerToolData.scene;

nearest: Assembly;

CSG.StuffCameraRay[cameraRay, cameraPoint, camera];

[nearest, ----] ← NearestAssemblyToRay[cameraRay, scene.assembly];

CSG.ReturnRayToPool[cameraRay];

SVViewerInput.ComplementSkitter[]; -- erase any old skitter

SVSelections.UpdateSkitter[nearest, NIL, viewerToolData];

SVSelections.PositionSkitter[cameraPoint, nearest.coordSys.wrtWorld];

SVSelections.SetModeSkitter[coordframe];

SVViewerInput.ComplementSkitter[]; -- draw new skitter

};

Move the skitter as usual. Compute the corresponding artwork point as the artwork "Position" operation. Find the corresponding ais pixels as in ray tracing. Color in a block of them with the current artworkToolData.paintColor.

editToolData: EditToolData ← viewerToolData.editToolData;

artworkToolData: ArtworkToolData ← NARROW[editToolData.artworkTool.data];

camera: Camera ← viewerToolData.camera;

artwork: Artwork ← artworkToolData.artwork;

assembly: Assembly;

skitterWORLD, assemWORLD, skitterassem, worldCamera: Matrix4by4;

imagePoint: Point2d;

skitterPoint, surfPtassem: Point3d;

normal: Vector;

paintColor: Color ← artworkToolData.paintColor;

path: Graphics.Path ← Graphics.NewPath[4];

DoDrawBrush: PROC [dc: Graphics.Context] = {

DuringSkitter[viewerToolData, cameraPoint, first];

[assembly, ----, viewerToolData] ← SVSelections.GetSkitterData[];

[----, skitterWORLD] ← SVSelections.GetPositionSkitter[];

assemWORLD ← assembly.coordSys.wrtWorld;

skitterassem ← Matrix3d.WorldToLocal[assemWORLD, skitterWORLD];

normal ← Matrix3d.ZAxisOfMatrix[skitterassem];

Our paint brush is the set of points [{-2,-1,0,1,2}, {-2,-1,0,1,2}] in the coordinate system of the skitter. We convert them to master object coordinates and then to image points.

FOR i: INT IN [-2..2] DO

ENDLOOP;

worldCamera ← CoordSys.FindWorldInTermsOf[camera.coordSys];

CSGGraphics.MoveToAbsolute[path, Matrix3d.Update[worldCamera, Matrix3d.Update[skitterWORLD, [-2, -2, 0]]], camera];

CSGGraphics.LineToAbsolute[path, Matrix3d.Update[worldCamera, Matrix3d.Update[skitterWORLD, [-2, 2, 0]]], camera];

CSGGraphics.LineToAbsolute[path, Matrix3d.Update[worldCamera, Matrix3d.Update[skitterWORLD, [2, 2, 0]]], camera];

CSGGraphics.LineToAbsolute[path, Matrix3d.Update[worldCamera, Matrix3d.Update[skitterWORLD, [2, -2, 0]]], camera];

SVViewerUser.Painter[DoDrawBrush, viewerToolData];

};

Assume for now that artwork.file is an 8 bit-per-pixel ais file with rd scanning with origin in its lower left corner.

imagePoint is in screen dots.

Find the bounding box of the AIS file.

artworkPoint: Point2d;

IF artwork.source = NIL THEN RETURN;

BEGIN

END;

}; -- end of SetImageColorAtPoint

Controlpoint is in camera coordinates.

camera: Camera ← viewerToolData.camera;

oldMode: Graphics.PaintMode;

DoDrawFrame: SAFE PROC [dc: Graphics.Context] = TRUSTED {

SVViewerUser.Painter[DoDrawFrame, viewerToolData]; -- erase old frame

camera.frame.fullScreen ← FALSE;

camera.frame.downLeft[1] ← cameraPoint[1];

camera.frame.upRight[2] ← cameraPoint[2];

camera.frame.downLeft[2] ← cameraPoint[2] - 50.0; -- Just to give the frame an initial size.

camera.frame.upRight[1] ← cameraPoint[1] + 50.0;

SVViewerUser.Painter[DoDrawFrame, viewerToolData];

};

Controlpoint is in camera coordinates.

camera: Camera ← viewerToolData.camera;

oldMode: Graphics.PaintMode;

DoDrawFrame: SAFE PROC [dc: Graphics.Context] = TRUSTED {

SVViewerUser.Painter[DoDrawFrame, viewerToolData];

camera.frame.downLeft[2] ← cameraPoint[2];

camera.frame.upRight[1] ← cameraPoint[1];

SVViewerUser.Painter[DoDrawFrame, viewerToolData];

};

camera: Camera ← viewerToolData.camera;

fileCamera: FileCamera;

success: BOOL;

FrameDownRightMove[viewerToolData, cameraPoint];

[fileCamera, success] ← DisplayList3d.FindFileCameraFromName[camera.viewName, viewerToolData.scene];

IF success THEN {

};

camera: Camera ← viewerToolData.camera;

frame: FrameBox ← camera.frame;

oldMode: Graphics.PaintMode;

DoDrawFrame: SAFE PROC [dc: Graphics.Context] = TRUSTED {

SVViewerUser.Painter[DoDrawFrame, viewerToolData];

frame.fullScreen ← TRUE;

};