[Cyan]<ISLCedar>SolidViews>SVViewerUserImplB.mesa!1

File: SVViewerUserImplB.mesa

Author: Eric Bier in October 1982

Last edited by Bier on August 18, 1983 5:52 pm

Contents: Code to respond to button presses made in an SVViewer

DIRECTORY

AIS,

Buttons,

CastRays,

CGDevice,

ColorMap,

Containers,

CoordSys,

CSG,

CSGGraphics,

DisplayList3d,

DitherAIS,

Draw3d,

FileIO,

Graphics,

GraphicsBasic,

GraphicsColor,

GraphicsToPress,

IO,

Labels,

Map,

Matrix3d,

Menus,

MessageWindow,

Preprocess3d,

Real,

Rope,

SV2d,

SVBoundBox,

SVEditUser,

SVFiles,

SVImage,

SVTransforms,

SVVector3d,

SVViewerTool,

SVViewerTools,

SVViewerUser,

System,

TFO3d,

Time,

ViewerClasses,

ViewerTools;

SVViewerUserImplB: CEDAR PROGRAM

IMPORTS AIS, Buttons, CastRays, ColorMap, CoordSys, CSGGraphics, DisplayList3d, DitherAIS, Draw3d, FileIO, Graphics, GraphicsToPress, IO, Labels, Map, Matrix3d, MessageWindow, Preprocess3d, Real, Rope, SVBoundBox, SVEditUser, SVFiles, SVImage, SVTransforms, SVViewerUser, SVViewerTools, TFO3d, Time, ViewerTools

EXPORTS GraphicsBasic, SVViewerUser =

BEGIN

Assembly: TYPE = DisplayList3d.Assembly;

BoundBox: TYPE = SVBoundBox.BoundBox;

Camera: TYPE = CSGGraphics.Camera;

Color: TYPE = GraphicsColor.Color;

CoordSysGenerator: TYPE = DisplayList3d.CoordSysGenerator;

CSGTree: TYPE = DisplayList3d.CSGTree;

DeviceObject: PUBLIC TYPE = CGDevice.Rep;

DrawStyle: TYPE = CSGGraphics.DrawStyle;

EditToolData: TYPE = SVEditUser.EditToolData;

FrameBox: TYPE = CSGGraphics.FrameBox;

MasterObject: TYPE = DisplayList3d.MasterObject;

Matrix4by4: TYPE = Matrix3d.Matrix4by4;

MouseButton: TYPE = Menus.MouseButton;

Point2d: TYPE = SV2d.Point2d;

Primitive: TYPE = CSG.Primitive;

Scene: TYPE = DisplayList3d.Scene;

Selection: TYPE = SVEditUser.Selection;

Vector: TYPE = SVVector3d.Vector;

Viewer: TYPE = ViewerClasses.Viewer;

ViewerToolData: TYPE = REF ViewerToolDataObj;

ViewerToolDataObj: TYPE = SVViewerTool.ViewerToolDataObj;

ViewerTextData: TYPE = SVViewerTool.ViewerTextData;

ViewerPictureData: TYPE = REF ViewerPictureDataObj;

ViewerPictureDataObj: TYPE = SVViewerUser.ViewerPictureDataObj;

InteractionMode: TYPE = SVViewerUser.InteractionMode;-- {select, cast};

DCProc: TYPE = SVViewerUser.DCProc;

GLOBAL VARIABLES

globalTable: Map.ColorTable;

globalSceneStyleCount: NAT = 3;

globalSceneStyleArray: ARRAY[1..globalSceneStyleCount] OF Rope.ROPE ←
["WireFrame", "Shaded", "Normals"];

globalBandsDeviceCount: NAT = 3;

globalBandsDeviceArray: ARRAY[1..globalBandsDeviceCount] OF Rope.ROPE ←
["Hornet", "Screen", "Platemaker"];

Press: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

camera: Camera ← viewerPictureData.camera;

TIMING VARABLES

startTime: System.GreenwichMeanTime;

endTime: System.GreenwichMeanTime;

totalTime: LONG CARDINAL;

timeStream: IO.STREAM;

outStream: IO.STREAM ← SVEditUser.GetOutHandle[];

timeRope: Rope.ROPE;

PRESS VARIABLES

pressName: Rope.ROPE;

pressStream: IO.STREAM;

pressContext: Graphics.Context;

START TIMING

startTime ← Time.Current[];

START PRESSING

pressName ← ViewerTools.GetContents[viewerToolData.textSection.ais];

pressName ← Rope.Concat[SVFiles.FilenameMinusExtension[pressName], ".press"];

pressStream ← FileIO.Open[pressName, overwrite, none];

pressContext ← GraphicsToPress.NewContextFromStream[

outputStream: pressStream,

fileNameForHeaderPage: pressName,

resolution: 384];

CSGGraphics.SetQualityCamera[camera, quality];-- make a high quality image

CSGGraphics.ColorFilmCamera[camera, FALSE];-- but only black and white

SVViewerUser.DrawSceneEtc[pressContext, viewerToolData];

CSGGraphics.ColorFilmCamera[camera, TRUE];-- restore to color mode

CSGGraphics.SetQualityCamera[camera, fast];-- restore to fast mode for interactive editting

GraphicsToPress.Close[pressContext];

endTime ← Time.Current[];

totalTime ← endTime - startTime;

timeStream ← IO.CreateOutputStreamToRope[];

timeStream.PutF[" Done. Pressing took (%r)",[cardinal[totalTime]]];

outStream.PutF[" Done. Pressing took (%r)",[cardinal[totalTime]]];

timeRope ← timeStream.GetOutputStreamRope[];

MessageWindow.Append[timeRope, TRUE];

};

PressAIS: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

scene: Scene ← viewerPictureData.scene;

camera: Camera ← viewerPictureData.camera;

minX, minY, maxX, maxY: REAL;

tree: CSGTree;

aisRope: Rope.ROPE ← ViewerTools.GetContents[viewerToolData.textSection.ais];

TIMING VARABLES

startTime: System.GreenwichMeanTime;

endTime: System.GreenwichMeanTime;

totalTime: LONG CARDINAL;

timeStream: IO.STREAM;

timeRope: Rope.ROPE;

PRESS VARIABLES

pressName: Rope.ROPE;

pressStream: IO.STREAM;

outStream: IO.STREAM ← SVEditUser.GetOutHandle[];

pressContext: Graphics.Context;

START TIMING

startTime ← Time.Current[];

START PRESSING

pressName ← ViewerTools.GetContents[viewerToolData.textSection.ais];

pressName ← Rope.Concat[SVFiles.FilenameMinusExtension[pressName], ".press"];

pressStream ← FileIO.Open[pressName, overwrite, none];

pressContext ← GraphicsToPress.NewContextFromStream[

outputStream: pressStream,

fileNameForHeaderPage: pressName,

resolution: 384];

tree ← DisplayList3d.SceneToTree[scene, camera];

[minX, minY, maxX, maxY] ← MinAndMaxFromCameraAndTree[camera, tree];

SVImage.DrawAndScaleColorImage[pressContext, aisRope, [camera.screenCS.mat[1][4], camera.screenCS.mat[2][4]], minX, minY, maxX, maxY];

GraphicsToPress.Close[pressContext];

endTime ← Time.Current[];

totalTime ← endTime - startTime;

timeStream ← IO.CreateOutputStreamToRope[];

timeStream.PutF[" Done. Pressing AIS took (%r)",[cardinal[totalTime]]];

outStream.PutF[" Done. Pressing AIS took (%r)",[cardinal[totalTime]]];

timeRope ← timeStream.GetOutputStreamRope[];

MessageWindow.Append[timeRope, TRUE];

};

PressBWAIS: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

editToolData: EditToolData ← NARROW[viewerToolData.editToolData];

scene: Scene ← viewerPictureData.scene;

camera: Camera ← viewerPictureData.camera;

minX, minY, maxX, maxY: REAL;

tree: CSGTree;

aisRope: Rope.ROPE ← ViewerTools.GetContents[viewerToolData.textSection.ais];

TIMING VARABLES

startTime: System.GreenwichMeanTime;

endTime: System.GreenwichMeanTime;

totalTime: LONG CARDINAL;

timeStream: IO.STREAM;

timeRope: Rope.ROPE;

PRESS VARIABLES

pressName: Rope.ROPE;

pressStream: IO.STREAM;

outStream: IO.STREAM ← SVEditUser.GetOutHandle[];

pressContext: Graphics.Context;

START TIMING

startTime ← Time.Current[];

START PRESSING

pressName ← ViewerTools.GetContents[viewerToolData.textSection.ais];

pressName ← Rope.Concat[SVFiles.FilenameMinusExtension[pressName], ".press"];

pressStream ← FileIO.Open[pressName, overwrite, none];

pressContext ← GraphicsToPress.NewContextFromStream[

outputStream: pressStream,

fileNameForHeaderPage: pressName,

resolution: 384];

tree ← DisplayList3d.SceneToTree[scene, camera];

[minX, minY, maxX, maxY] ← MinAndMaxFromCameraAndTree[camera, tree];

SVImage.DrawAndScaleBlackAndWhiteImage[pressContext, aisRope, [camera.screenCS.mat[1][4], camera.screenCS.mat[2][4]], minX, minY, maxX, maxY];

GraphicsToPress.Close[pressContext];

endTime ← Time.Current[];

totalTime ← endTime - startTime;

timeStream ← IO.CreateOutputStreamToRope[];

timeStream.PutF[" Done. Pressing AIS took (%r)",[cardinal[totalTime]]];

outStream.PutF[" Done. Pressing AIS took (%r)",[cardinal[totalTime]]];

timeRope ← timeStream.GetOutputStreamRope[];

MessageWindow.Append[timeRope, TRUE];

};

CrossHairs: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewer is the crossHairs button

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

camera: Camera ← viewerPictureData.camera;

DoCrossHairs: PROC [dc: Graphics.Context] = TRUSTED {

Draw3d.Draw2dCoordSys[dc, [0,0], camera];

};

SVViewerUser.Painter[DoCrossHairs, viewerToolData];

}; -- end of CrossHairs

Dither: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

baseName, redName, greenName, blueName, FSFilename: Rope.ROPE;

baseName ← ViewerTools.GetContents[viewerToolData.textSection.ais];

baseName ← SVFiles.FilenameMinusExtension[baseName];

redName ← Rope.Concat[baseName, "-red.ais"];

greenName ← Rope.Concat[baseName, "-green.ais"];

blueName ← Rope.Concat[baseName, "-blue.ais"];

FSFilename ← Rope.Concat[baseName, "-std.ais"];

BEGIN

globalTable ← Preprocess3d.GetGlobalTable[];

DitherAIS.Squash[redName, greenName, blueName, FSFilename, MyMap

! AIS.Error => {

outStream: IO.STREAM ← SVEditUser.GetOutHandle[];

outStream.PutF["%g -*.ais - Bad file names", [rope[baseName]]];

MessageWindow.Append[Rope.Concat[baseName, "-*.ais - Bad file names"], TRUE];

GOTO giveUp}];

If the dither has worked, fake a button press of DrawDither:

DrawDither[parent, clientData, mouseButton, shift, control];

EXITS

giveUp => NULL;

END;

};

MyMap: DitherAIS.UserMapProc = TRUSTED {

rb, gb, bb: Map.ColorMapSize;

palix ← Map.GetIndex[r, g, b, globalTable];

[rb, gb, bb] ← ColorMap.GetColor[palix]; -- ought to use the table

re ← r - rb;

ge ← g - gb;

be ← b - bb;

};

Extend: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

Get the edittool to extend the current secondary selection.

SVEditUser.ExtendSecondary[];

};

Move: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

newMat: Matrix4by4;

primary, secondary: Selection;

primary ← SVEditUser.GetPrimarySelection[];

secondary ← SVEditUser.GetSecondarySelection[];

IF primary = NIL THEN RETURN[];

IF primary.assembly = NIL THEN RETURN;

IF secondary = NIL THEN RETURN[];

IF secondary.assembly = NIL THEN RETURN;

If the two selections are in different viewers, then see if these viewers refer to different scenes. If so do a scene to scene copy before doing any aligning and abutting.

IF primary.viewerToolData # secondary.viewerToolData THEN {

primaryPicture: ViewerPictureData ← NARROW[primary.viewerToolData.viewerPicture.data];

secondaryPicture: ViewerPictureData ← NARROW[secondary.viewerToolData.viewerPicture.data];

IF primaryPicture.scene # secondaryPicture.scene THEN {

copyAssembly: Assembly ← DisplayList3d.MergeAssemblyIntoScene[secondary.assembly, secondaryPicture.scene, primaryPicture.scene.assembly, primaryPicture.scene];

The new assembly has the same relationship to scene assembly as the last assembly had to its parent. This will do for now.

SVViewerUser.SceneNewVersion[primary.viewerToolData];

SVViewerUser.DrawSceneInternal[NIL, primary.viewerToolData, red, FALSE, FALSE];

SVViewerUser.DrawSceneInternal[NIL, secondary.viewerToolData, red, FALSE, FALSE];

RETURN;

};

newMat ← Matrix3d.MakeRotateYMat[180];

SVTransforms.PlaceIndirect[secondary.assembly, secondary.coordSys, primary.coordSys, newMat];

Rotate them so they are tangent in an exterior fashion.

SVViewerUser.SceneNewVersion[primary.viewerToolData];

SVViewerUser.DrawSceneInternal[NIL, primary.viewerToolData, red, FALSE, FALSE];

};

DrawPt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

camera: Camera ← viewerPictureData.camera;

get x and y from appropriate slots. Interpret this as camera coordinates and draw a cross.

x, y: REAL;

DoDrawPt: PROC [dc: Graphics.Context] = TRUSTED {

Draw3d.DrawX[dc, [x, y], camera];

};

[x, y] ← SVViewerUser.ReadTwoReals[viewerToolData.textSection.xyz];

SVViewerUser.Painter[DoDrawPt, viewerToolData];

};

MinAndMaxFromCameraAndTree: PRIVATE PROC [camera: Camera, tree: CSGTree] RETURNS [minX, minY, maxX, maxY: REAL] = TRUSTED {

frame: FrameBox ← camera.frame;

boundBox: BoundBox;

IF frame.fullScreen THEN {

boundBox ← Preprocess3d.Preprocess[tree, camera];

minX ← boundBox.minVert[1]; minY ← boundBox.minVert[2];

maxX ← boundBox.maxVert[1]; maxY ← boundBox.maxVert[2];

}

ELSE {

minX ← frame.downLeft[1]; minY ← frame.downLeft[2];

maxX ← frame.upRight[1]; maxY ← frame.upRight[2];

};

DrawColor: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

parent is the DrawColor button

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

scene: Scene ← viewerPictureData.scene;

resolution: REAL;

boundBox: BoundBox;

minX, minY, maxX, maxY: REAL;

camera: Camera ← viewerPictureData.camera;

tree: CSGTree;

aisRope: Rope.ROPE ← ViewerTools.GetContents[viewerToolData.textSection.ais];

DoDrawColor: PROC [dc: Graphics.Context] = TRUSTED {

SVImage.DrawAlignedColorImage[dc, aisRope, resolution, [camera.screenCS.mat[1][4], camera.screenCS.mat[2][4]], boundBox];

};

resolution ← camera.resolution;

tree ← DisplayList3d.SceneToTree[scene, camera];

[minX, minY, maxX, maxY] ← MinAndMaxFromCameraAndTree[camera, tree];

boundBox ← SVBoundBox.BoundBoxFromValues[minX, minY, maxX, maxY];

SVViewerUser.Painter[DoDrawColor, viewerToolData];

}; -- end of DrawColor

DrawBlackAndWhite: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

parent is the DrawB&W button

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

resolution: REAL;

scene: Scene ← viewerPictureData.scene;

boundBox: BoundBox;

minX, minY, maxX, maxY: REAL;

camera: Camera ← viewerPictureData.camera;

tree: CSGTree;

aisRope: Rope.ROPE ← ViewerTools.GetContents[viewerToolData.textSection.ais];

DoDrawBlackAndWhite: PROC [dc: Graphics.Context] = TRUSTED {

SVImage.DrawAlignedBlackAndWhiteImage[dc, aisRope, resolution, [camera.screenCS.mat[1][4], camera.screenCS.mat[2][4]], boundBox, FALSE];

};

resolution ← camera.resolution;

tree ← DisplayList3d.SceneToTree[scene, camera];

[minX, minY, maxX, maxY] ← MinAndMaxFromCameraAndTree[camera, tree];

boundBox ← SVBoundBox.BoundBoxFromValues[minX, minY, maxX, maxY];

SVViewerUser.Painter[DoDrawBlackAndWhite, viewerToolData];

}; -- end of DrawBlackAndWhite

DrawDither: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

parent is the DrawDither button

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

resolution: REAL;

scene: Scene ← viewerPictureData.scene;

boundBox: BoundBox;

minX, minY, maxX, maxY: REAL;

camera: Camera ← viewerPictureData.camera;

tree: CSGTree;

aisRope: Rope.ROPE ← ViewerTools.GetContents[viewerToolData.textSection.ais];

DoDrawBlackAndWhite: PROC [dc: Graphics.Context] = TRUSTED {

SVImage.DrawAlignedBlackAndWhiteImage[dc, aisRope, resolution, [camera.screenCS.mat[1][4], camera.screenCS.mat[2][4]], boundBox, TRUE];

};

resolution ← camera.resolution;

aisRope ← Rope.Concat[SVFiles.FilenameMinusExtension[aisRope], "-std.ais"];

tree ← DisplayList3d.SceneToTree[scene, camera];

[minX, minY, maxX, maxY] ← MinAndMaxFromCameraAndTree[camera, tree];

boundBox ← SVBoundBox.BoundBoxFromValues[minX, minY, maxX, maxY];

SVViewerUser.Painter[DoDrawBlackAndWhite, viewerToolData];

}; -- end of DrawDither

SetFocalLength: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

viewerPictureData.camera.focalLength ← SVViewerTools.GetReal[viewerToolData.textSection.focalLength, 1800];

}; -- end of SetFocalLength

MakeBands: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

camera: Camera ← viewerPictureData.camera;

deviceType: DeviceType;

deviceName: Rope.ROPE;

TIMING VARABLES

startTime: System.GreenwichMeanTime;

endTime: System.GreenwichMeanTime;

totalTime: LONG CARDINAL;

timeStream: IO.STREAM;

outStream: IO.STREAM ← SVEditUser.GetOutHandle[];

timeRope: Rope.ROPE;

BANDS VARIABLES

bandContext: Graphics.Context;

bandDevice: BandsClient.Device;

START TIMING

startTime ← Time.Current[];

START BANDS

deviceName ← globalBandsDeviceArray[viewerPictureData.bandsDeviceIndex];

SELECT TRUE FROM

Rope.Equal[deviceName, "Hornet"] => deviceType ← hornet;

Rope.Equal[deviceName, "Screen"] => deviceType ← screen;

Rope.Equal[deviceName, "Platemaker"] => deviceType ← platemaker;

ENDCASE => ERROR;

BandsClient.SetUpSeparation[none, Tentfilter];

[bandContext, bandDevice] ← BandsClient.OpenBands[deviceType];

CSGGraphics.SetQualityCamera[camera, quality];-- make a high quality image

CSGGraphics.ColorFilmCamera[camera, FALSE];-- but only black and white

SVViewerUser.DrawSceneEtc[bandContext, viewerToolData];

CSGGraphics.ColorFilmCamera[camera, TRUE];-- restore to color mode

CSGGraphics.SetQualityCamera[camera, fast];-- restore to fast mode for interactive editting

BandsClient.CloseBands[bandDevice, deviceType];

endTime ← Time.Current[];

totalTime ← endTime - startTime;

timeStream ← IO.CreateOutputStreamToRope[];

timeStream.PutF[" Done. Bands took (%r)",[cardinal[totalTime]]];

outStream.PutF[" Done. Bands took (%r)",[cardinal[totalTime]]];

timeRope ← timeStream.GetOutputStreamRope[];

MessageWindow.Append[timeRope, TRUE];

};

Tentfilter: PROC [x,y: REAL] RETURNS [val: REAL] = TRUSTED {

RETURN [1.0-ABS[x]];

};

PROMPTS

AISPrompt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

ViewerTools.SetSelection[viewerToolData.textSection.ais];

};

XYZPrompt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

ViewerTools.SetSelection[viewerToolData.textSection.xyz];

};

FocalLengthPrompt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

ViewerTools.SetSelection[viewerToolData.textSection.focalLength];

};

TextPrompt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

ViewerTools.SetSelection[viewerToolData.textSection.text];

};

PROMPTS WHICH CYCLE THROUGH POSSIBILITIES

StylePrompt: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

newStyle: DrawStyle;

scene: Scene ← viewerPictureData.scene;

viewerPictureData.sceneStyleIndex ← IF viewerPictureData.sceneStyleIndex = globalSceneStyleCount THEN 1 ELSE viewerPictureData.sceneStyleIndex + 1;

Labels.Set[viewerToolData.textSection.viewStyle, globalSceneStyleArray[viewerPictureData.sceneStyleIndex]];

SELECT globalSceneStyleArray[viewerPictureData.sceneStyleIndex] FROM

"WireFrame" => newStyle ← wire;

"Shaded" => newStyle ← shaded;

"Normals" => newStyle ← normals;

"RayCast" => newStyle ← rayCast;

ENDCASE => ERROR;

viewerPictureData.camera.style ← newStyle;

};

ON/OFF SWITCHES

DoubleBuffer: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

button: Buttons.Button ← NARROW[parent];

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

IF viewerPictureData.doubleBuffer THEN {

viewerPictureData.doubleBuffer ← NOT viewerPictureData.doubleBuffer;

Buttons.SetDisplayStyle[button, $BlackOnWhite];

}

ELSE {

viewerPictureData.doubleBuffer ← NOT viewerPictureData.doubleBuffer;

Buttons.SetDisplayStyle[button, $WhiteOnBlack];

};

}; -- end of DoubleBuffer

ShowCoordsMode: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

button: Buttons.Button ← NARROW[parent];

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

IF viewerPictureData.showCoordSys THEN {

viewerPictureData.showCoordSys ← NOT viewerPictureData.showCoordSys;

Buttons.SetDisplayStyle[button, $BlackOnWhite];

}

ELSE {

viewerPictureData.showCoordSys ← NOT viewerPictureData.showCoordSys;

Buttons.SetDisplayStyle[button, $WhiteOnBlack];

};

}; -- end of ShowCoordsMode

OPTIONS LISTERS

BandsDevice: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

viewerToolData: ViewerToolData ← NARROW[clientData];

thisButton: Viewer ← NARROW[parent];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

scene: Scene ← viewerPictureData.scene;

viewerPictureData.bandsDeviceIndex ← IF viewerPictureData.bandsDeviceIndex = globalBandsDeviceCount THEN 1 ELSE viewerPictureData.bandsDeviceIndex + 1;

Buttons.ReLabel[thisButton, globalBandsDeviceArray[viewerPictureData.bandsDeviceIndex]];

};

UTILITIES

Selected: PUBLIC PROC [parent: REF ANY, clientData: REF ANY, mouseButton: MouseButton, shift, control: BOOL] = TRUSTED {

This window has been selected. Show its Selected button as WhiteOnBlack.

viewerToolData: ViewerToolData ← NARROW[clientData];

SVEditUser.ReSelectViewer[viewerToolData];

};

Deselected: PUBLIC PROC [viewerToolData: ViewerToolData] = TRUSTED {

This window has been deselected. Show its Selected button as BlackOnWhite.

IF viewerToolData = NIL THEN RETURN;

viewerToolData.textSection.isSelected ← FALSE;

Labels.SetDisplayStyle[viewerToolData.textSection.selected, $BlackOnWhite, TRUE];

};

Input Notify Procs

SingleRay: PUBLIC PROC [viewerToolData: ViewerToolData, cameraPoint: Point2d] = TRUSTED {

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

f: IO.STREAM ← SVEditUser.GetOutHandle[];

color: Color;

xInt, yInt: INTEGER;

tree: CSGTree;

scene: Scene ← viewerPictureData.scene;

camera: Camera ← viewerPictureData.camera;

xInt ← Real.FixI[cameraPoint[1]]; yInt ← Real.FixI[cameraPoint[2]];

tree ← DisplayList3d.SceneToTree[scene, camera];

color ← CastRays.SingleRay[xInt, yInt, tree, scene.lightSources, camera, TRUE, f];

f.PutF["[%g,%g]: ",[real[cameraPoint[1]]], [real[cameraPoint[2]]]];

TFO3d.FileoutColor[f, color];

};

PointAt: PUBLIC PROC [viewerToolData: ViewerToolData, cameraPoint: Point2d] = TRUSTED {

Adds a new assembly to the scene of class "CoordSys", isTool is true. The first one will be pointer.0, the second pointer.1 and so on. Pointer will be defined with respect to the parent of the assembly which we are pointing at. If we are not pointing at anything, don't create a pointer. Just return.

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

f: IO.STREAM ← SVEditUser.GetOutHandle[];

tree: CSGTree;

normal: Vector;

prim: Primitive;

scene: Scene ← viewerPictureData.scene;

camera: Camera ← viewerPictureData.camera;

class: CSG.Classification;

tree ← DisplayList3d.SceneToTree[scene, camera];

class ← CastRays.SingleRay2[cameraPoint, tree, scene.lightSources, camera, TRUE, f];

IF class.count = 0 THEN RETURN;

prim ← class.primitives[1];

normal ← class.normals[1];

};

RayCastProgress: PUBLIC CastRays.NotifyOfProgressProc = TRUSTED {

PROC [currentY, minX, minY, maxX, maxY: REAL, clientData: REF ANY];

Draw a box of width 10 and length currentY-minY+1 with origin at (minX, minY)

viewerToolData: ViewerToolData ← NARROW[clientData];

viewerPictureData: ViewerPictureData ← NARROW[viewerToolData.viewerPicture.data];

camera: Camera ← viewerPictureData.camera;

width: REAL ← 10;

box: Graphics.Box;

lowLeft, upRight: Point2d;

DoRayCastProgress: PROC [dc: Graphics.Context] = TRUSTED {

Graphics.SetColor[dc, GraphicsColor.black];

Graphics.DrawBox[dc, box];

};

lowLeft ← CoordSys.CameraToScreen[[minX, minY], camera.screenCS];

upRight ← CoordSys.CameraToScreen[[maxX, currentY], camera.screenCS];

box ← [lowLeft[1], lowLeft[2], upRight[1], upRight[2]];

SVViewerUser.Painter[DoRayCastProgress, viewerToolData];

};

END.