DIRECTORY
BasicTime, CoordSys, DisplayListToTree, Feedback, Imager, ImagerInterpress, IO, Matrix3d, Preprocess3d, Rope, SV2d, SV3d, SVAssembly, SVBasicTypes, SVCaret, SVCastRays, SVEditUser, SVEvent, SVInterfaceTypes, SVMasterObject, SVMasterObjectTypes, SVModelTypes, SVRay, SVRefresh, SVScene, SVSceneTypes, SVSelect, SVSelections, SVState, SVTransforms, SVUserInput, SVUtility, SVVector3d, SVViewersOnScene, SVViewerTools, SVWindow, TIPUser, ViewerClasses, ViewerTools;

SVEventImplC: CEDAR PROGRAM
IMPORTS BasicTime, CoordSys, DisplayListToTree, Feedback, Imager, ImagerInterpress, IO, Matrix3d, Preprocess3d, SVAssembly, SVCaret, SVCastRays, SVEditUser, SVEvent, SVRay, SVRefresh, SVScene, SVSelect, SVSelections, SVState, SVTransforms, SVUtility, SVVector3d, SVViewersOnScene, SVViewerTools, SVWindow, ViewerTools
EXPORTS SVEvent =

BEGIN
Artwork: TYPE = SVModelTypes.Artwork;
ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;
Slice: TYPE = SVSceneTypes.Slice;
SliceList: TYPE = SVSceneTypes.SliceList;
BoundBox: TYPE = SVBasicTypes.BoundBox;
BoundSphere: TYPE = SVBasicTypes.BoundSphere;
Camera: TYPE = SVModelTypes.Camera;
Classification: TYPE = SVSceneTypes.Classification;
Color: TYPE = Imager.Color;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CSGTree: TYPE = SVSceneTypes.CSGTree;
CylinderRec: TYPE = SVMasterObjectTypes.CylinderRec;
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 = SVSceneTypes.Primitive;
Ray: TYPE = SVSceneTypes.Ray;
Scene: TYPE = SVSceneTypes.Scene;
SearchDepth: TYPE = SVSceneTypes.SearchDepth;
Selection: TYPE = SVInterfaceTypes.Selection;
SelectionGenerator: TYPE = SVInterfaceTypes.SelectionGenerator;
Shape: TYPE = SVSceneTypes.Shape;
Skitter: TYPE = SVSceneTypes.Skitter;
SkitterMode: TYPE = SVSceneTypes.SkitterMode;
ToolData: TYPE = SVSceneTypes.ToolData;
TrigLine: TYPE = SV2d.TrigLine;
Vector3d: TYPE = SV3d.Vector3d;
SVData: TYPE = SVInterfaceTypes.SVData;


SelectAll: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ svData.scene;
SVSelect.DeselectAll[svData.scene, normal];
SVSelect.SelectAll[svData.scene, normal];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $SelectionChanged, editToolData: editToolData, scene: scene, edited: FALSE];
};
pointsPerIn: REAL = 72.0;
pointsPerCm: REAL = 72.0/2.54;
cmPerIn: REAL = 2.54;

ScaleUnitFromSegment: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
ScaleUnitFromValue: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
ScaleUnitFromSelection: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {

};
InchScaleUnit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
ScaleUnitAux[svData, pointsPerIn]; -- one inch in screen dots
};
ScaleUnitAux: PROC [svData: SVData, distance: REAL] = {
SVState.SetScaleUnit[svData, distance]; -- in screen dots
PrintScaleUnit[event: NIL, svData: svData];
SVWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, svData: svData, remake: alignBag, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
};
CentimeterScaleUnit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
ScaleUnitAux[svData, pointsPerCm];
};
PointsScaleUnit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
ScaleUnitAux[svData, 1];
};
PrintScaleUnit: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
inches: REAL _ SVState.GetScaleUnit[svData];
Feedback.PutF[svData.feedback, oneLiner, "Current scale is %g points = %g inches = %g centimeters", [real[inches*pointsPerIn]], [real[inches]], [real[inches/cmPerIn]] ];
};
IPSnapShot: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
DoMakeInterpress: PROC [dc: Imager.Context] = {
ENABLE UNWIND => {
svData.camera.displayStyle _ tempStyle;
};
DoItInterpress: PROC = {
Imager.ScaleT[dc, metersPerPixel];
svData.camera.displayStyle _ print;
SVRefresh.SnapShot[dc, svData];
svData.camera.displayStyle _ tempStyle;
};
Imager.DoSave[dc, DoItInterpress];
};
ipRef: ImagerInterpress.Ref;
fullName: Rope.ROPE;
success: BOOL;
metersPerPixel: REAL = 0.0254/72.0;
startTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
msgRope: Rope.ROPE;
tempStyle: SVModelTypes.DisplayStyle _ svData.camera.displayStyle;

[fullName, success] _ SVUtility.GetInterpressFileName["snapshot.ip", svData.currentWDir, svData.feedback];
IF NOT success THEN RETURN;
ipRef _ ImagerInterpress.Create[fullName];
msgRope _ IO.PutFR["Writing to IP file: %g . . . ", [rope[fullName]]];
Feedback.Append[svData.feedback, msgRope, begin];
startTime _ BasicTime.Now[];
ImagerInterpress.DoPage[ipRef, DoMakeInterpress, 1.0];
ImagerInterpress.Close[ipRef];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
msgRope _ IO.PutFR[" Done in time (%r)", [integer[totalTime]]];
Feedback.Append[svData.feedback, msgRope, end];
};

JackPivotX: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
JackPivotAux[event, svData, 1];
};
JackPivotY: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
JackPivotAux[event, svData, 2];
};
JackPivotZ: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
JackPivotAux[event, svData, 3];
};


JackPivotAux: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData, axis: [1..3]] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ svData.scene;
degrees: REAL _ NARROW[event.rest.first, REF REAL]^;
targetSel: Selection;
coincident: Slice;
targetSel _ SVSelections.TopTarget[];
IF targetSel = NIL THEN RETURN;
coincident _ targetSel.coincident;
SVTransforms.Rotate[coincident, scene, axis, degrees, coincident.coordSys, TRUE];
SVViewersOnScene.PaintSceneAllViewers[paintAction: $SelectionChanged, editToolData: editToolData, scene: scene, edited: TRUE];
};

SourcePivotX: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SourcePivotAux[event, svData, 1];
};
SourcePivotY: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SourcePivotAux[event, svData, 2];
};
SourcePivotZ: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
SourcePivotAux[event, svData, 3];
};

SourcePivotAux: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData, axis: [1..3]] = {
editToolData: EditToolData _ svData.editToolData;
scene: Scene _ svData.scene;
degrees: REAL _ NARROW[event.rest.first, REF REAL]^;
sourceSel: Selection;
jack, indirect: Slice;
sourceSel _ SVSelections.TopMovee[];
IF sourceSel = NIL THEN RETURN;
SELECT sourceSel.referentType FROM
hook => {
jack _ sourceSel.coincident;
indirect _ sourceSel.indirect;
};
coordSys => {
jack _ sourceSel.coincident;
indirect _ sourceSel.coincident;
};
ENDCASE => ERROR;
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVTransforms.Rotate[indirect, scene, axis, degrees, jack.coordSys, TRUE];
svData.refresh.addedObject _ indirect;
SVViewersOnScene.PaintSceneAllViewers[$ObjectChangedBoundBoxProvided, editToolData, scene];
};

ArrowShoot: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
source, target: Slice;
sourceSel, firstTargetSel: Selection;
editToolData: EditToolData;

sourceSel _ SVSelections.PopMovee[];
IF sourceSel = NIL THEN RETURN;
source _ sourceSel.coincident;
svData _ sourceSel.svData;
editToolData _ svData.editToolData;

firstTargetSel _ SVSelections.PopTarget[];
IF firstTargetSel = NIL THEN RETURN;
FOR targetSel: Selection _ firstTargetSel, SVSelections.NextTarget[] UNTIL targetSel = NIL DO
IF targetSel.svData # sourceSel.svData THEN {
Feedback.Append[svData.feedback, "Can't shoot arrows between viewers.", oneLiner];
Feedback.Blink[svData.feedback];
LOOP;
};
target _ targetSel.coincident;
ArrowShootAux[source.coordSys, target.coordSys, svData];
ENDLOOP;
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVViewersOnScene.PaintSceneAllViewers[$PaintEntireScene, svData.editToolData, svData.scene];
};

ArrowShootAux: PROC [sourceCS, targetCS: CoordSystem, svData: SVData] = {
sOriginWorld, tOriginWorld: Point3d;
tree: CSGTree;
ray: Ray;
class: Classification;
t: REAL;
worldDirection, primitiveNormal, worldNormal: Vector3d;
selectionMat: Matrix4by4;
surfacePtInWorld: Point3d;
primitive: Primitive;
assembly: Slice;
scene: Scene;
camera: Camera;
skitter: Skitter _ svData.editToolData.skitter;

scene _ svData.scene;
camera _ svData.camera;
tree _ DisplayListToTree.AssemblyToTree[scene.assembly, scene, camera];
[] _ Preprocess3d.PreprocessForCatScan[tree, camera];

sOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[sourceCS]];
tOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[targetCS]];

ray _ SVRay.GetRayFromPool[];
worldDirection _ SVVector3d.Sub[tOriginWorld, sOriginWorld];
SVRay.StuffWorldRay[ray, sOriginWorld, worldDirection, camera];
class _ SVCastRays.RayCastBoundingSpheres[ray, tree.son];
FOR i: NAT IN [1..class.count] DO
t _ class.params[i]; -- the parameter of the ray intersection
primitiveNormal _ class.normals[i];
primitive _ class.primitives[i];
worldNormal _ Matrix3d.UpdateVectorWithInverse[primitive.worldWRTPrim, primitiveNormal];
surfacePtInWorld[1] _ sOriginWorld[1] + t*worldDirection[1];
surfacePtInWorld[2] _ sOriginWorld[2] + t*worldDirection[2];
surfacePtInWorld[3] _ sOriginWorld[3] + t*worldDirection[3];
assembly _ NARROW[primitive.assembly];
selectionMat _ MakeAlignedMat[worldNormal, surfacePtInWorld, assembly.coordSys];
SVCaret.SetAssemblyAndPrimitive[skitter, assembly, primitive];
SVCaret.PositionFromMatrix[skitter, [0,0], selectionMat];
SVSelections.SetModeSkitter[svData, surface];
SVEvent.SkitterMakes[NIL, svData];
ENDLOOP;
SVCastRays.ReturnClassToPool[class];
SVRay.ReturnRayToPool[ray];
};

Sign: PROC [r: REAL] RETURNS [INT] = {
IF r = 0.0 THEN RETURN[2];
IF r < 0.0 THEN RETURN[-1]
ELSE RETURN[1];
};

AntiParallel: PRIVATE PROC [v1, v2: Vector3d] RETURNS [BOOL] = {
RETURN[Sign[v1[1]] = -Sign[v2[1]] OR
Sign[v1[2]] = -Sign[v2[2]] OR
Sign[v1[3]] = -Sign[v2[3]] ];
};

MakeAlignedMat: PRIVATE PROC [worldNormal: Vector3d, surfacePtInWorld: Point3d, cs: CoordSystem] RETURNS [mat: Matrix4by4] = {
yAxisOfCS: Vector3d _ Matrix3d.YAxisOfMatrix[CoordSys.WRTWorld[cs]];
xAxis: Vector3d;
IF SVVector3d.Parallel[yAxisOfCS, worldNormal] THEN {
xAxis _ Matrix3d.XAxisOfMatrix[CoordSys.WRTWorld[cs]];
IF AntiParallel[yAxisOfCS, worldNormal] THEN xAxis _ SVVector3d.Negate[xAxis];
}
ELSE xAxis _ SVVector3d.CrossProduct[yAxisOfCS, worldNormal];
mat _ Matrix3d.MakeMatFromZandXAxis[worldNormal, xAxis, surfacePtInWorld];
};

MoveUntilTouch: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
source, target: Slice;
sourceSel, targetSel: Selection;
editToolData: EditToolData;

sourceSel _ SVSelections.PopMovee[];
IF sourceSel = NIL THEN RETURN;
source _ sourceSel.coincident;
svData _ sourceSel.svData;
editToolData _ svData.editToolData;

targetSel _ SVSelections.PopTarget[];
IF targetSel = NIL THEN RETURN;
IF targetSel.svData # sourceSel.svData THEN {
Feedback.Append[svData.feedback, "Can't skewer between viewers.", oneLiner];
Feedback.Blink[svData.feedback];
RETURN;
};
target _ targetSel.coincident;
MoveUntilTouchAux[source, target, svData];
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVViewersOnScene.PaintSceneAllViewers[$PaintEntireScene, svData.editToolData, svData.scene];
};

MoveUntilTouchAux: PROC [source, target: Slice, svData: SVData] = {
sOriginWorld, tOriginWorld: Point3d;
tree, sourceTree: CSGTree;
worldDirection: Vector3d;
scene: Scene;
camera: Camera;
boundSphere: BoundSphere;
R: REAL;
basisMat: Matrix4by4;

scene _ svData.scene;
camera _ svData.camera;
sourceTree _ DisplayListToTree.AssemblyToTree[source, scene, camera];
boundSphere _ Preprocess3d.PreprocessForCatScan[sourceTree, camera];
R _ boundSphere.radius;
tree _ DisplayListToTree.AssemblyToTree[scene.assembly, scene, camera];
[] _ Preprocess3d.PreprocessForCatScan[tree, camera];

sOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[source.coordSys]];
tOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[target.coordSys]];

worldDirection _ SVVector3d.Sub[tOriginWorld, sOriginWorld];

basisMat _ Matrix3d.MakeHorizontalMatFromZAxis[worldDirection, sOriginWorld];

MoveUntilTouchAuxAux[source, basisMat, worldDirection, R, scene, camera, tree];
}; -- end of MoveUntilTouchAux

MoveUntilTouchAuxAux: PROC [source: Slice, basisMat: Matrix4by4, worldDirection: Vector3d, R: REAL, scene: Scene, camera: Camera, tree: CSGTree] = {
ray: Ray;
minDeltaT, lastSourceT, firstOtherT: REAL;
class: Classification;
success, someData: BOOL;
basisBasePt, worldBasePt: Point3d;
moveVector: Vector3d;
raysPerHalfSide: NAT = 20;
raysPerHalfSideF: REAL = 20.0;
ray _ SVRay.GetRayFromPool[];
someData _ FALSE;
FOR i: INT IN [-raysPerHalfSide..raysPerHalfSide-1] DO
basisBasePt[1] _ (i+0.5)*R/raysPerHalfSideF;
FOR j: INT IN [-raysPerHalfSide..raysPerHalfSide-1] DO
basisBasePt[2] _ (j+0.5)*R/raysPerHalfSideF;
basisBasePt[3] _ 0.0;
worldBasePt _ Matrix3d.Update[basisBasePt, basisMat];
SVRay.StuffWorldRay[ray, worldBasePt, worldDirection, camera];
class _ SVCastRays.RayCastBoundingSpheres[ray, tree.son, FALSE];
[lastSourceT, firstOtherT, success] _ SourceAndOtherT[class, source];
IF NOT success THEN {
SVCastRays.ReturnClassToPool[class];
LOOP;
};
IF firstOtherT < lastSourceT THEN {
Feedback.AppendRaw[$Solidviews, "Source is already touching.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN;
};
IF NOT someData THEN {
minDeltaT _ firstOtherT-lastSourceT;
someData _ TRUE;
}
ELSE minDeltaT _ MIN[minDeltaT, firstOtherT-lastSourceT];
SVCastRays.ReturnClassToPool[class];
ENDLOOP; -- j
ENDLOOP; -- i
IF NOT someData THEN {
Feedback.AppendRaw[$Solidviews, "No Obstacles Found.  Object NOT moved.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN;
};
moveVector _ SVVector3d.Scale[worldDirection, minDeltaT];
SVTransforms.Translate[source, scene, moveVector];
SVRay.ReturnRayToPool[ray];
};

SourceAndOtherT: PROC [class: Classification, source: Slice] RETURNS [lastSourceT, firstOtherT: REAL, success: BOOL _ FALSE] = {
sourceFound, otherFound: BOOL;
thisAssembly: Slice;
sourceFound _ FALSE;
otherFound _ FALSE;
IF class.count = 0 THEN RETURN [0,0,FALSE];
FOR i: NAT IN [1..class.count] DO
thisAssembly _ NARROW[class.primitives[i].assembly];
IF DisplayListToTree.IsSuccessorOf[thisAssembly, source] THEN {
lastSourceT _ class.params[i];
sourceFound _ TRUE;
}
ELSE IF NOT otherFound THEN {
firstOtherT _ class.params[i];
otherFound _ TRUE;
};
ENDLOOP;
success _ sourceFound AND otherFound;
};

Skewer: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
source, target: Slice;
sourceSel, firstTargetSel: Selection;
editToolData: EditToolData;

sourceSel _ SVSelections.PopMovee[];
IF sourceSel = NIL THEN RETURN;
source _ sourceSel.coincident;
svData _ sourceSel.svData;
editToolData _ svData.editToolData;

firstTargetSel _ SVSelections.PopTarget[];
IF firstTargetSel = NIL THEN RETURN;
IF firstTargetSel.svData # sourceSel.svData THEN {
Feedback.Append[svData.feedback, "Can't skewer between viewers.", oneLiner];
Feedback.Blink[svData.feedback];
RETURN;
};
target _ firstTargetSel.coincident;
SkewerAux[source, target, svData];
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVViewersOnScene.PaintSceneAllViewers[$PaintEntireScene, svData.editToolData, svData.scene];
};

SkewerAux: PROC [source, target: Slice, svData: SVData] = {
sOriginWorld, tOriginWorld: Point3d;
tree: CSGTree;
ray: Ray;
class: Classification;
t: REAL;
directionWorld: Vector3d;
surfacePtInWorld, lastSurfacePtInWorld: Point3d;
primitive: Primitive;
assembly, lastAssembly: Slice;
moveVector, totalVector, localDiff: Vector3d;
scene: Scene;
camera: Camera;
sourceCS, targetCS: CoordSystem;

sourceCS _ source.coordSys;
targetCS _ target.coordSys;
scene _ svData.scene;
camera _ svData.camera;
tree _ DisplayListToTree.AssemblyToTree[scene.assembly, scene, camera];
[] _ Preprocess3d.PreprocessForCatScan[tree, camera];

sOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[sourceCS]];
tOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[targetCS]];

ray _ SVRay.GetRayFromPool[];
directionWorld _ SVVector3d.Sub[tOriginWorld, sOriginWorld];
sOriginWorld _ SVVector3d.Sub[sOriginWorld, SVVector3d.Scale[directionWorld, 0.3]];
directionWorld _ SVVector3d.Scale[directionWorld, 1.6];
SVRay.StuffWorldRay[ray, sOriginWorld, directionWorld, camera];
class _ SVCastRays.RayCastBoundingSpheres[ray, tree.son, FALSE];
SVCastRays.SortClassByPrimitive[class];
IF class.count = 0 THEN {
SVCastRays.ReturnClassToPool[class];
SVRay.ReturnRayToPool[ray];
RETURN;
};
lastAssembly _ NARROW[class.primitives[1].assembly];
t _ class.params[1];
lastSurfacePtInWorld[1] _ sOriginWorld[1] + t*directionWorld[1];
lastSurfacePtInWorld[2] _ sOriginWorld[2] + t*directionWorld[2];
lastSurfacePtInWorld[3] _ sOriginWorld[3] + t*directionWorld[3];
totalVector _ [0,0,0];
FOR i: NAT IN [2..class.count] DO
t _ class.params[i]; -- the parameter of the ray intersection
IF t > 1.0 THEN EXIT; -- Compression occurs only BETWEEN source and target.
primitive _ class.primitives[i];
surfacePtInWorld[1] _ sOriginWorld[1] + t*directionWorld[1];
surfacePtInWorld[2] _ sOriginWorld[2] + t*directionWorld[2];
surfacePtInWorld[3] _ sOriginWorld[3] + t*directionWorld[3];
assembly _ NARROW[primitive.assembly];
IF lastAssembly # assembly THEN {
localDiff _ SVVector3d.Sub[lastSurfacePtInWorld, surfacePtInWorld];
moveVector _ SVVector3d.Add[localDiff, totalVector];
totalVector _ SVVector3d.Add[totalVector, localDiff];
SVTransforms.Translate[assembly, scene, moveVector];
};
lastAssembly _ assembly;
lastSurfacePtInWorld _ surfacePtInWorld;
ENDLOOP;
SVCastRays.ReturnClassToPool[class];
SVRay.ReturnRayToPool[ray];
};


AddCylinder: PUBLIC PROC [event: LIST OF REF ANY, svData: SVData] = {
sourceSel, firstTargetSel: Selection;
sourceCS, targetCS: CoordSystem;
editToolData: EditToolData;
radius: REAL;
scene: Scene;

sourceSel _ SVSelections.PopMovee[];
IF sourceSel = NIL THEN RETURN;
firstTargetSel _ SVSelections.PopTarget[];
IF firstTargetSel = NIL THEN RETURN;
IF sourceSel.svData # firstTargetSel.svData THEN {
Feedback.Append[svData.feedback, "Can't add cylinder between viewers.", oneLiner];
Feedback.Blink[svData.feedback];
RETURN;
};
svData _ sourceSel.svData;
scene _ svData.scene;
editToolData _ svData.editToolData;

sourceCS _ sourceSel.coincident.coordSys;
radius _ SVViewerTools.GetReal[editToolData.cylinderSection.radius, 20];

FOR targetSel: Selection _ firstTargetSel, SVSelections.NextTarget[] UNTIL targetSel = NIL DO
targetCS _ targetSel.coincident.coordSys;
AddCylinderAux[sourceCS, targetCS, radius, editToolData, scene];
ENDLOOP;
SVViewersOnScene.SceneNewVersion[editToolData.currentSVData];
SVViewersOnScene.PaintSceneAllViewers[$PaintEntireScene, editToolData, svData.scene];
};

AddCylinderAux: PROC [sourceCS, targetCS: CoordSystem, radius: REAL, editToolData: EditToolData, scene: Scene] = {
cylMO: MasterObject;
moFound: BOOL;
cylinderRec: CylinderRec;
sOriginWorld, tOriginWorld, midPointWorld: Point3d;
cylWorld, superWorld, cylSuper: Matrix4by4;
cylinderY: Vector3d;
height: REAL;
newAssembly, superAssembly: Slice;
success: BOOL;
addSucceeds: BOOL _ TRUE;
cylName: Rope.ROPE;

[cylMO, moFound] _ SVScene.FindObjectFromName["cylinder", scene];
IF NOT moFound THEN ERROR;
cylinderRec _ NARROW[cylMO.mainBody];

sOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[sourceCS]];
tOriginWorld _ Matrix3d.OriginOfMatrix[CoordSys.WRTWorld[targetCS]];
midPointWorld _ SVVector3d.Add[sOriginWorld, tOriginWorld];
midPointWorld _ SVVector3d.Scale[midPointWorld, 0.5];
cylinderY _ SVVector3d.Sub[tOriginWorld, sOriginWorld];
height _ SVVector3d.Magnitude[cylinderY];
cylWorld _ MakeHorizontalMatFromYAxis[cylinderY, midPointWorld];

radius _ radius/cylinderRec.radius;  height _ height/cylinderRec.height;
cylName _ ViewerTools.GetContents[editToolData.sceneSection.new];
cylName _ CoordSys.UniqueNameFrom[cylName, scene.coordSysRoot];

[superAssembly, success] _ SVEditUser.GetParent[editToolData];
IF NOT success THEN RETURN;
superWorld _ CoordSys.WRTWorld[superAssembly.coordSys];
cylSuper _ Matrix3d.AInTermsOfB[cylWorld, superWorld];

[newAssembly, ----, addSucceeds] _ SVAssembly.CreatePrimitive[cylName, "cylinder", scene];
IF NOT addSucceeds THEN RETURN;
addSucceeds _ SVAssembly.AddPrimitive[newAssembly, [radius, height, radius], superAssembly, cylSuper, scene];
}; -- end of AddCylinderAux


MakeHorizontalMatFromYAxis: PROC [yAxis: Vector3d, origin: Point3d] RETURNS [mat: Matrix4by4] = {
xAxis: Vector3d;
IF yAxis[1] = 0 AND yAxis[3] = 0 THEN xAxis _ [1,0,0]
ELSE xAxis _ SVVector3d.CrossProduct[[0,1,0], yAxis];
mat _ Matrix3d.MakeMatFromYandXAxis[yAxis, xAxis, origin];
};

END.

œFile: SVEventImplC.mesa
Last edited by Bier on July 12, 1987 1:54:27 pm PDT
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Contents: Procedures for responding to button clicks made in a solidviewer.
Bloomenthal, June 16, 1987 7:52:46 pm PDT
Select Menu

Units Menu


TIP Table Functions
This command is executed in the middle of a dragging operation to make an interpress master of the current state of the screen.  Luckily, all dragging operations use the same painting commands, namely:
SVWindow.RestoreScreenAndInvariants[paintAction: $DuringMotion, svData: svData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
We wish to have the same effect as these commands except written to an interpress master.  We will create an interpress master named snapshot.ip and use SVRefresh.SnapShot to draw the scene into it.
Rotate the distinguished target coincident with respect to itself by degrees.  This makes sense for both hook and coordsys targets.
Erases the target shape.  For a jack, this leaves nothing.  For another object, this leaves the object.
Rotate the distinguished source indirect with respect to the distinguished source coincident.  If the selection is not a hook jack, then indirect and coincident are identical.
Cast a ray from the distinguished source to each of the targets.  Create a hook at each intersection point, aligned with the surface normal at that point.
Cast a ray from source to target.  Create a hook at each intersection point, aligned with the surface normal at that point.
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 CoordSys.WRTWorld[cs] is accurate
Allows positioning code to distinguish between top surfaces and bottom surfaces.
Consider a line from the distinguished source to the distinguished target.  Using translation along the ray direction (only) move the distinguish source towards the distinguished target until it touches something other than itself.  If the distinguished source already touches something else, leave it alone.
Cast a set of rays parallel to the line from source to target and starting on a plane normal to that line a bounding sphere's radius behind source.  Using translation along the ray direction (only) move the source until it touches something (anything).
Shoot many rays in this direction starting from the plane of points x satisfying (x-sOriginWorld).w = 0.  First, let's find two basis vectors for this plane.  They are the x and y axes of the basis matrix.
Shoot a ray from the distinguished source to the distinguished target.  Using translation along the ray direction (only) bring all intersected objects together so they are touching at the ray intersection points.
Cast a ray from source to target.  Using translation along the ray direction (only) bring all intersected objects together so they are touching at the ray intersection points.  The skewer extends from the earliest point hit on the source object (by the infinite line) to the last point hit on the target object.  For now, a kludge:  Cast a ray from 30% behind the source to 30% after the target.
Here comes the kludge
End of kludge.
Add a cylinder whose radius is taken from the editTool and whose height is just large enough so it stretches from the distinguished source to the distinguished target.
Add a cylinder whose radius is taken from the editTool and whose height is just large enough so it stretches from sourceCS to targetCS.
Uses yAxis as it is.  Finds a horizontal x axis orthogonal to zAxis.  If yAxis is vertical, then there are infinitely many.  Chooses [1,0,0] in this case.
Κ2˜Iheadš
œ™Jš
œ3™3Jšœ
Οm
œ1™<š
œK™KIcode™)—J˜š
Οk	˜	JšœLžœ€˜Ξ—J˜šœž
˜JšžœMžœη
˜½Jšžœ
˜—J˜š
ž˜Jšœ	žœ˜%Jšœžœ$˜9Jšœžœ˜!Jšœžœ˜)Jšœ
žœ˜'Jšœ
žœ˜-Jšœžœ˜#Jšœžœ˜3Jšœžœ˜Jšœ
žœ˜-Jšœ	žœ˜%Jšœ
žœ#˜4Jšœžœ!˜3Jšœžœ˜+Jšœ
žœ˜'Jšœžœ˜/Jšœžœ˜#Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜)Jšœžœ˜Jšœžœ˜!Jšœ
žœ˜-Jšœžœ˜-Jšœžœ'˜?Jšœžœ˜!Jšœ	žœ˜%Jšœ
žœ˜-Jšœ
žœ˜'Jšœ
žœ˜Jšœ
žœ˜Jšœžœ˜'J˜—J˜Iproc™šΟn	œžœ
žœ	žœ
žœ
žœ
žœ˜CJš
œ1˜1Jš
œ˜Lš
œ+˜+Lš
œ)˜)Jšœxžœ˜M˜—J™Lš
œ
™
Lšœ
žœ˜Lšœ
žœ
˜Lšœ	žœ˜M˜šŸœžœ
žœ	žœ
žœ
žœ
žœ˜NM˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜LM˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜PM˜M˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜GLšœ#Οc˜=M˜—šŸœžœžœ˜7Lšœ( ˜9Lšœžœ˜+L•StartOfExpansion§
[paintAction: 
ATOM, gargoyleData: 
GGInterfaceTypes.GargoyleData, remake: 
GGWindow.ForegroundParts _ triggerBag, backgndOK: 
BOOL _ FALSE, edited: 
BOOL _ TRUE]šœvžœ
žœžœ˜€
L˜L™—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜MMš
œ"˜"M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜IMš
œ˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜HLšœžœ ˜,Lš
ϩ
˜©
L˜—J™J™šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DL™Ι
Lšœižœ
žœžœ™˜
L™Ζ
šŸœžœ˜/šžœ
žœ˜Lš
œ'˜'L˜—šŸœžœ˜L˜"Lš
œ#˜#Lš
œ˜Lš
œ'˜'L˜—LšœŸœ˜"L˜—Lš
œ˜Lšœžœ
˜Lšœ	žœ
˜Lšœžœ˜#Lšœžœ
˜Lšœžœ
˜Lšœžœ
˜Lšœžœ
˜Lš
œB˜BL˜Lš
œj˜jLšžœ
žœ	žœ
žœ
˜Lš
œ*˜*Lšœ
žœ:˜FLš
œ1˜1Lš
Οb˜Lš
œ6˜6Lš
œ˜Lš
‘˜Lš
œ1˜1Lšœ
žœ3˜?Lš
œ/˜/J˜—M˜šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DJš
œ˜J˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DJš
œ˜J˜—šŸ
œžœ
žœ	žœ
žœ
žœ
žœ˜DJš
œ˜J˜J˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ#˜TJ™ƒ
Jš
œ1˜1Jš
œ˜Jš	œ	žœžœžœ
žœ˜4J˜J˜Jš
œ%˜%Jšžœ
žœ
žœ
žœ
˜š
œ"˜"J™g—JšœKžœ˜QJš
œ~˜~M˜M˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FJš
œ!˜!J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FJš
œ!˜!J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ˜FJš
œ!˜!J˜J˜—šŸœžœ
žœ	žœ
žœ
žœ
žœ#˜VJ™―
Jš
œ1˜1Jš
œ˜Jš	œ	žœžœžœ
žœ˜4J˜J˜Jš
œ$˜$Jšžœ
žœ
žœ
žœ
˜Jšžœž˜"š
œ	˜	Jš
œ˜Jš
œ˜J˜—š
œ
˜
Jš
œ˜Jš
œ ˜ J˜—Jšžœžœ
˜Jš
œ=˜=JšœCžœ˜IJš
œ&˜&Jš
œ[˜[M˜M˜—šŸ
œžœ	žœ
žœ
žœ
žœ˜DJ™š
J˜Jš
œ%˜%J˜J˜Jš‘	œ˜$Jšžœ
žœ
žœ
žœ
˜Jš
œ˜Jš
œ˜Jš
œ#˜#J˜Jš‘œ˜*Jšžœžœ
žœ
žœ
˜$šžœBžœ
žœ
ž˜]šžœ%žœ˜-Jš
œR˜RJš
œ ˜ Jšžœ
˜J˜—Jš
œ˜Jš
œ8˜8—Jšžœ
˜Jš
œ=˜=Jš
œ\˜\J˜J˜—šŸ
œžœ6˜IJš
œ{™{MšœΟuœ	’œ
˜$Jš
œ˜Jš
œ	˜	J˜Jšœžœ
˜Jš
œ7˜7Jš
œ˜Jš
œ˜Jš
œ˜J˜Jš
œ
˜
Jš
œ˜Jš
œ/˜/M˜Jš
œ˜Jš
œ˜Jšœ‘œ ˜GJšœ‘œ˜5J˜Mšœ’œ8˜DMšœ’œ8˜DM˜Jš
œ˜Jšœ'’œ	’œ˜<Jšžœ’œ˜?Jš
œ9˜9šžœžœ
žœž˜!Jšœ‘
œ )˜=Jš
œ#˜#Jš
œ ˜ Jš‘œM˜XJš‘œ
’œ˜<Jš‘œ
’œ˜<Jš‘œ
’œ˜<Jšœžœ˜&Jšœ‘œ
‘œ‘œ˜PJšœŸœ˜>Jš
œ9˜9Jšœ
‘œ˜-Jšœ‘œ
žœ
˜"Jšžœ
˜—Jš
œ$˜$Jš
œ˜J˜J˜—š
Ÿœžœžœžœžœ˜&Jšžœ	žœ
žœ˜Jšžœ	žœ
žœ˜Jšžœ
žœ˜J˜J˜—š
Ÿœžœ
žœžœžœ˜@šžœž˜$Jšœž˜Jš
œ˜—J˜J˜—šŸœžœ
žœEžœ˜~Jš
œθ
™θ
Jš
œD˜DJš
œ˜šžœ-žœ˜5Jš
œ6˜6Jšžœ&žœ"˜NJ™PJ˜
—Jšžœ9˜=Jš
œJ˜JJš
œ˜J˜—šŸœžœ	žœ
žœ
žœ
žœ˜HJ™΄J˜Jš
œ ˜ J˜J˜Jš‘	œ˜$Jšžœ
žœ
žœ
žœ
˜Jš
œ˜Jš
œ˜Jš
œ#˜#J˜Jš‘	œ˜%Jšžœ
žœ
žœ
žœ
˜šžœ%žœ˜-Jš
œL˜LJš
œ ˜ Jšžœ
˜J˜—Jš
œ˜Jš‘œ˜*Jš
œ=˜=Jš
œ\˜\J˜M˜—šŸœžœ,˜CJš
œό
™ό
Mšœ’œ	’œ
˜$Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜J˜Jšž
œžœ
˜J˜M˜Jš
œ˜Jš
œ˜Jšœ‘œ˜EJšœ‘œ˜DJšΠbk
œ˜Jš‘œ‘œ ˜GJšœ‘œ˜5J˜Mšœ’œ?˜KMšœ’œ?˜KM˜Jš‘œ’œ	’œ˜<˜Jšœ[’œm™Ν
—Jš‘œ>’œ˜MJ˜Jš‘œ#ž
œ˜OJšœ ˜J˜—šŸœžœAž
œžœ2˜”
Jš
œ	˜	Jšœ%žœ
˜*J˜Jšœžœ
˜Jš
œ"˜"J˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ
˜šžœžœ
žœ'ž˜6Jšœž
œ˜,šžœžœ
žœ'ž˜6Jšœž
œ˜,Jš
œ˜Jš
œ5˜5Jšžœ9˜>Jšœ‘œžœ˜@Jšœ&‘œ˜Ešžœ
žœ	žœ˜Jš
œ$˜$Jšžœ
˜J˜—šžœžœ˜#Jš
œI˜IJš
œ˜Jšžœ
˜J˜—šžœ
žœ
žœ˜Jš
œ$˜$Jšœžœ
˜J˜
—Jšžœ
žœ%˜9Jš
œ$˜$—Jšžœ ˜
—Jšžœ ˜
šžœ
žœ
žœ˜Jš
œT˜TJš
œ˜Jšžœ
˜J˜—Jš
œ9˜9Jš
œ2˜2Jšžœ˜J˜J˜—šŸœžœ(žœžœžœžœ˜€
Jšœžœ
˜Jš
œ˜Jšœžœ
˜Jšœ
žœ
˜Jšžœžœ
žœžœ˜+šžœžœ
žœž˜!Jšœžœ˜4šžœ7žœ˜?Jš
œ˜Jšœžœ
˜J˜
—šžœ
žœ
žœžœ˜Jš
œ˜Jšœ
žœ
˜J˜——Jšžœ
˜Jšœžœ˜%J˜J˜—šŸœžœ	žœ
žœ
žœ
žœ˜@J™Τ
J˜Jš
œ%˜%J˜J˜Jš‘	œ˜$Jšžœ
žœ
žœ
žœ
˜Jš
œ˜Jš
œ˜Jš
œ#˜#J˜Jš‘œ˜*Jšžœžœ
žœ
žœ
˜$šžœ*žœ˜2Jš
œL˜LJš
œ ˜ Jšžœ
˜J˜—Jš
œ#˜#JšŸ	œ˜"Jš
œ=˜=Jš
œ\˜\J˜J˜—šŸ	œžœ,˜;Jš
œ‹™‹Mšœ’œ	’œ
˜$Jš
œ˜Jš
œ	˜	J˜Jšœžœ
˜Jšœ	’œ˜Jš
œ0˜0Jš
œ˜Jš
œ˜J˜-Jš
œ
˜
Jš
œ˜Jš
œ ˜ M˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ‘œ ˜GJšœ‘œ˜5J˜Mšœ’œ8˜DMšœ’œ8˜DM˜Jšœžœ˜šœ	’œ’œ	’œ˜<J™—Jšœ’œ’œ’œ˜Sšœ	’œ’œ˜7J™—Jšžœ’œ’œ
˜?Jšœ‘œžœ˜@JšœŸœ˜'šžœžœ˜Jš
œ$˜$Jšžœ˜Jšžœ
˜J˜—Jšœžœ˜4Jš
œ˜Jšœ!’œ’œ˜@Jšœ!’œ’œ˜@Jšœ!’œ’œ˜@Jš
œ˜šžœžœ
žœž˜!Jšœ‘
œ )˜=Jšžœ	žœ
žœ 5˜KJš
œ ˜ Jš‘œ
’œ’œ˜<Jš‘œ
’œ’œ˜<Jš‘œ
’œ’œ˜<Jšœžœ˜&šžœžœ˜!Jš
œC˜CJš
œ4˜4Jš
œ5˜5Jšœ
‘	œ˜4J˜—Jš
œ˜Jš
œ(˜(—Jšžœ
˜Jš
œ$˜$Jšžœ˜J˜J˜J˜—šŸœžœ	žœ
žœ
žœ
žœ˜EJ™§
Jš
œ%˜%J˜ Jš
œ˜Mšœžœ
˜
M˜
J˜Jš‘	œ˜$Jšžœ
žœ
žœ
žœ
˜Jš‘œ˜*Jšžœžœ
žœ
žœ
˜$šžœ
‘	œ žœ˜2Jš
œR˜RJš
œ ˜ Jšžœ
˜J˜—Jš
œ˜Jš
œ˜Jš
œ#˜#J˜Jšœ‘	œ˜)Jš
œH˜HJ˜šžœBžœ
žœ
ž˜]Jš
œ)˜)Jš
œ@˜@—Jšžœ
˜Jš
œ=˜=Jš
œU˜UJ˜J˜—šŸœžœ+žœ/˜rJš
œ‡
™‡
Mš
œ˜Mšœ	žœ
˜Mš
œ˜Mšœ’œ	’œ
’œ
˜3Mšœ’œ’œ’œ
˜+M˜Mšœžœ
˜
Mš
œ"˜"Mšœ	žœ
˜Mšœ
žœžœ
˜Mšœžœ
˜M˜Mš
œA˜AMšžœ
žœ	žœ
žœ
˜Mšœžœ˜%M˜Mšœ’œ8˜DMšœ’œ8˜DMšœ’œ’œ	’œ˜;Mšœ’œ’œ˜5Mšœ"’œ	’œ˜7Mš
œ)˜)Mšœ’œ1’œ˜@M˜Mš
œH˜HMšœ<‘œ˜AMš
œ?˜?M˜Mšœ&‘	œ˜>Mšžœ
žœ	žœ
žœ
˜Mšœ’œ-˜7Mšœ’œ’œ’œ˜6M˜Mšœ œŸœ˜ZMšžœ
žœ
žœ
žœ
˜MšœŸœ:’œ	˜mMšœ ˜M˜J˜—šŸœžœ$žœ˜aMš
œš
™š
Mš
œ˜Mšžœžœžœ˜5Mšžœ1˜5Mš
œ:˜:Mš
œ˜M˜—Jšžœ
˜J˜—…—Q6w