<<>>
<<G3dToolViewerImpl.mesa>>
<<Copyright Š 1985 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, April 8, 1993 0:04 am PDT>>
    <<Heckbert, August 9, 1988 5:51:51 pm PDT>>
    <<Glassner, July 18, 1990 2:25:48 pm PDT>>
    <<Shoemake, November 6, 1989 11:57:54 pm PST>>
<<3d Tool: Creation and Miscellany>>
DIRECTORY BasicTime, CedarProcess,  Commander, CommanderOps, Controls, Cursors, FS, FileNames, G2dBasic, G3dBasic, G3dControl, 
G3dLight, G3dMatrix, G3dRender, G3dTimeTrees, G3dTool, G3dView, Icons, ImagerSample, IO, Process, ProcessProps, RawViewers, Real, 
Rope, TEditSelection, TiogaMenuOps, UnixSpawnTCP, ViewerClasses, ViewerOps, ViewerSpecs, ViewersWorldInstance;

G3dToolViewerImpl: CEDAR PROGRAM
IMPORTS BasicTime, CedarProcess,  CommanderOps, Controls, Cursors, FileNames, FS, G3dControl, G3dLight, G3dMatrix, G3dRender, 
G3dTool, G3dView, Icons, ImagerSample, IO, Process, ProcessProps, RawViewers, Rope, TEditSelection, TiogaMenuOps, UnixSpawnTCP, 
ViewerOps, ViewerSpecs, ViewersWorldInstance
EXPORTS G3dTool

~ BEGIN
<<Types>>
ForkableProc:            TYPE ~ CedarProcess.ForkableProc;
ButtonList:                TYPE ~ Controls.ButtonList;
ClickProc:                TYPE ~ Controls.ClickProc;
ControlList:            TYPE ~ Controls.ControlList;
ControlProc:            TYPE ~ Controls.ControlProc;
ControlSizes:            TYPE ~ Controls.ControlSizes;
DestroyProc:            TYPE ~ Controls.DestroyProc;
GraphicsData:            TYPE ~ Controls.GraphicsData;
MouseProc:                TYPE ~ Controls.MouseProc;
Viewer:                    TYPE ~ Controls.Viewer;
Box2d:                    TYPE ~ G2dBasic.Box;
Pair:                        TYPE ~ G3dBasic.Pair;
Triple:                    TYPE ~ G3dBasic.Triple;
CameraControl:        TYPE ~ G3dControl.CameraControl;
Matrix:                    TYPE ~ G3dMatrix.Matrix;
Viewport:                TYPE ~ G3dMatrix.Viewport;
Context3d:                TYPE ~ G3dRender.Context3d;
Client:                    TYPE ~ G3dTool.Client;
NamedBuffer:            TYPE ~ G3dTool.NamedBuffer;
Operations:                TYPE ~ G3dTool.Operations;
ScreenSequence:        TYPE ~ G3dTool.ScreenSequence;
Tool:                        TYPE ~ G3dTool.Tool;
ToolRep:                TYPE ~ G3dTool.ToolRep;
View:                    TYPE ~ G3dTool.View;
ViewProc:                TYPE ~ G3dTool.ViewProc;
ViewRep:                TYPE ~ G3dTool.ViewRep;
ViewSequence:        TYPE ~ G3dTool.ViewSequence;
TTNode:                    TYPE ~ G3dTimeTrees.Node;
Camera:                    TYPE ~ G3dView.Camera;
CameraRep:            TYPE ~ G3dView.CameraRep;
SampleMap:            TYPE ~ ImagerSample.SampleMap;
ROPE:                    TYPE ~ Rope.ROPE;
IconFlavor:            TYPE ~ ViewerClasses.IconFlavor;
<<Tool Creation and Control>>
defaultIcon: IconFlavor Ź Icons.NewIconFromFile["G3dUser.icons", 0];

MakeTool: PUBLIC PROC [
name:                ROPE,
extraButtons:        ButtonList Ź NIL,
extraControls:    ControlList Ź NIL,
controlSizes:        ControlSizes Ź [],
ops:                Operations Ź [],
client:                Client Ź [],
nViews:            NAT Ź 1,
noOpen:            BOOL Ź FALSE,
useArcBalls:        BOOL Ź TRUE,
arcBallSize:        INTEGER Ź 136,
graphicsHeight:    INTEGER Ź 475,
icon:                IconFlavor Ź document,
useExistingTool:    BOOL Ź FALSE,
camera:            CameraRep Ź [[0.0, 2.0, 0.0], [], 1.0, 60.0],
background:        Triple Ź [1.0, 1.0, 1.0],
typescriptHeight: INT Ź 36,
toolSettings:        ToolRep Ź []]
RETURNS [t: Tool]
~ {
IF useExistingTool AND activeTool # NIL
THEN {
t Ź NEW[ToolRep Ź activeTool^];
t.outerData Ź Controls.OuterViewer[name: name, column: left, buttons: extraButtons, controls: extraControls, controlSizes: 
controlSizes, destroyProc: OuterDestroy, icon: icon];
IF client # [] THEN {
activeClients Ź CONS[client, activeClients];
ViewerOps.AddProp[t.outerData.parent, $ToolClient, NEW[Client Ź client]];
};
IF NOT noOpen THEN ViewerOps.OpenIcon[t.outerData.parent];
}
ELSE {
Enumerate: ViewerOps.EnumProc ~ {ViewerOps.PaintViewer[v, caption]};
NewButton: PROC [name: ROPE, proc: ClickProc, guarded: BOOL Ź FALSE] ~ {
t.buttons Ź CONS[Controls.ClickButton[name, proc, t, 0,,,,,, guarded], t.buttons];
};
RawViewers.SetColorWorld[ViewersWorldInstance.GetWorld[], $dense];
ViewerOps.EnumerateViewers[Enumerate]; -- fix up caption and icon colors
SetActiveTool[t Ź NEW[ToolRep Ź toolSettings]];
IF t.ipStrokeWidth = 2.0 THEN t.ipStrokeWidth Ź 1.0; -- better default
<<(actually, add another field: strokeWidth, for use with screen display)>>
t.activeViews Ź LIST[0];
t.ops Ź ops;
t.client Ź client;
IF t.cmd = NIL THEN
t.cmd Ź NARROW[ProcessProps.GetProp[$CommanderHandle], Commander.Handle];
IF NOT Rope.IsEmpty[name] THEN t.name Ź name;
t.camera Ź G3dControl.InitCameraControl[
proc: G3dTool.Controller,
clientData: t,
fieldOfView: camera.fieldOfView,
proxyMode: eye,
scale: camera.scale,
move: camera.move,
rotate: camera.rotate];
G3dControl.SetArcBallSize[t.camera.arcBall, arcBallSize];
Context3dOk[t];
t.background Ź background;
t.buttons Ź extraButtons;
IF ops.io            THEN NewButton["IO",                G3dTool.IOOpsButton];
IF ops.lines        THEN NewButton["Draw",            G3dTool.DrawOpsButton];
IF ops.light        THEN NewButton["Light",            G3dTool.LightOpsButton];
IF ops.shape        THEN NewButton["Shapes",        G3dTool.ShapeOpsButton];
IF ops.render     THEN NewButton["Render",        G3dTool.RenderOpsButton];
<<IF ops.render        THEN NewButton["Render",        G3dTool.RenderButton];>>
<<IF ops.animation    THEN NewButton["Animate",        G3dTool.AnimateOpsButton];>>
<<IF ops.scene        THEN NewButton["Scene",            G3dTool.SceneOpsButton];>>
<<IF ops.texture    THEN NewButton["Texture",        G3dTool.TextureOpsButton];>>
<<IF ops.render    THEN NewButton["Abort Render", G3dTool.AbortButton, TRUE];>>
<<IF ops.help        THEN NewButton["Help",            G3dTool.HelpButton];>>
IF ops.stop        THEN NewButton["STOP",            G3dTool.StopButton, TRUE];
t.controls Ź G3dControl.AddCameraControl[extraControls, t.camera, useArcBalls];
IF nViews > 0 THEN {
t.outerData Ź Controls.OuterViewer[
name: name,
column: left,
buttons: t.buttons,
controls: t.controls,
controlSizes: controlSizes,
typescriptHeight: typescriptHeight,
graphicsHeight: graphicsHeight,
mouseProc: G3dTool.Mouse,
destroyProc: Destroy,
drawProc: DoDraw,
noOpen: TRUE,
icon: IF icon # document THEN icon ELSE defaultIcon,
clientData: t];
t.outer Ź t.outerData.parent;
t.outer.label Ź name;
t.typescript Ź t.outerData.typescript;
t.graphics Ź t.outerData.graphics;
t.views Ź MakeViews[t, nViews];
IF NOT noOpen THEN [] Ź CedarProcess.Fork[OpenViewer, t];
<<Only upon return does the application have a Tool, which it needs if it is to draw.>>
<<Thus, we give the client some time with a Tool before drawing the viewer:>>
};
};
t.directory Ź FileNames.CurrentWorkingDirectory[];
};

DoDraw: Controls.DrawProc ~ {
t: Tool Ź NARROW[clientData];
v: G3dTool.View Ź G3dTool.GetView[viewer, t];
G3dTool.Draw[context, viewer, whatChanged, v.camera.matrix, v.viewport, v, t, t]; 
};

OpenViewer: ForkableProc ~ {
Process.PauseMsec[250];    -- should be plenty
ViewerOps.OpenIcon[NARROW[data, Tool].outer];
};

OuterDestroy: Controls.DestroyProc ~ {
ref: REF ANY Ź ViewerOps.FetchProp[viewer, $ToolClient];
IF ref # NIL THEN {
client: Client Ź NARROW[ref, REF Client]^;
IF activeClients.first = client
THEN activeClients Ź activeClients.rest
ELSE FOR c: LIST OF Client Ź activeClients, c.rest WHILE c.rest # NIL DO
IF c.rest.first = client THEN {c.rest Ź c.rest.rest; EXIT};
ENDLOOP;
};
};

Destroy: Controls.DestroyProc ~ {
t: Tool Ź NARROW[clientData];
IF t = NIL THEN RETURN;
IF t.unixSpawn # NIL THEN UnixSpawnTCP.Kill[t.unixSpawn];
IF t.client.destroy # NIL THEN t.client.destroy[viewer, $ToolKilled, t.client.data];
IF t = activeTool THEN {
FOR c: LIST OF Client Ź activeClients, c.rest WHILE c # NIL DO
IF c.first.destroy # NIL THEN c.first.destroy[viewer, $ToolKilled, c.first.data];
IF c.first.change # NIL THEN c.first.change[activeTool, NIL, c.first.data];
ENDLOOP;
activeTool Ź NIL;
};
IF t.views # NIL THEN
FOR i: INTEGER IN [0..t.views.length) DO
FOR l: LIST OF G3dTool.NamedBuffer Ź t.views[i].idBuffer, l.rest WHILE l # NIL DO
ImagerSample.ReleaseScratchMap[l.first.map];
ENDLOOP;
ENDLOOP;
};

Context3dOk: PUBLIC PROC [tool: Tool] ~ {
IF tool.context3d = NIL THEN {
tool.context3d Ź G3dRender.Create[];
tool.lights Ź G3dLight.AddLight[tool.lights, "Light1", [-.2, .2, .3], [.2, -.2, -.3]];
G3dTool.SetRenderView[tool.context3d, tool.camera];
};
};

activeTool, previousTool: Tool;
activeClients: LIST OF Client Ź NIL;

SetActiveTool: PUBLIC PROC [tool: Tool] ~ {
IF tool = activeTool THEN RETURN;
previousTool Ź activeTool;
activeTool Ź tool;
FOR c: LIST OF Client Ź activeClients, c.rest WHILE c # NIL DO
IF c.first.change # NIL THEN c.first.change[previousTool, activeTool, c.first.data];
ENDLOOP;
};

GetActiveTool: PUBLIC PROC RETURNS [Tool] ~ {RETURN[activeTool]};
GetActiveClients: PUBLIC PROC RETURNS [LIST OF Client] ~ {RETURN[activeClients]};

ToolBusy: PUBLIC PROC [tool: Tool] RETURNS [BOOL] ~ {
RETURN[tool.process # NIL AND CedarProcess.GetStatus[tool.process] = busy];
};

ForceFork: PUBLIC PROC [tool: Tool, proc: ForkableProc] ~ {
IF ToolBusy[tool] THEN Stop[tool, NIL, TRUE];
tool.process Ź CedarProcess.Fork[proc, tool, [background, TRUE]]
};

MaybeFork: PUBLIC PROC [tool: Tool, proc: ForkableProc, data: REF ANY Ź NIL]
RETURNS [forked: BOOL]
~ {
IF (forked Ź NOT ToolBusy[tool])
THEN tool.process Ź
CedarProcess.Fork[proc, IF data = NIL THEN tool ELSE data, [background, TRUE]]
ELSE TSWrite[tool, "Tool is busy!\n"];
};

Stop: PUBLIC PROC [tool: Tool, reason: ROPE Ź NIL, waitTilAborted: BOOL Ź FALSE] ~ {
IF tool.unixSpawn # NIL THEN {
UnixSpawnTCP.Kill[tool.unixSpawn];
tool.unixSpawn Ź NIL;
};
IF tool.process # NIL AND NOT tool.process.abortRequested THEN {
CedarProcess.Abort[tool.process];
IF waitTilAborted THEN [] Ź CedarProcess.Join[tool.process];
IF tool.client.stop # NIL THEN tool.client.stop[tool.client.data, reason];
};
IF reason # NIL THEN TSWrite[tool, reason];
};
<<View Operations>>
MakeViews: PUBLIC PROC [tool: Tool, nViews: NAT] RETURNS [views: ViewSequence] ~ {
g: Viewer Ź tool.graphics;
w: NAT Ź SELECT g.column FROM
left => ViewerSpecs.openLeftWidth,
right => ViewerSpecs.openRightWidth,
ENDCASE =>  ViewerSpecs.colorScreenWidth;
views Ź NEW[G3dTool.ViewSequenceRep[nViews]];
ViewerOps.AddProp[g, $Width, NEW[INTEGER Ź w]]; -- redundant over ControlsOuter
ViewerOps.AddProp[g, $Height, NEW[INTEGER Ź g.ch]];
FOR n: NAT IN [0..nViews) DO
MakeViewer: PROC [x, y, w, h: NAT] RETURNS [vwr: Viewer] ~ {
data: GraphicsData Ź NEW[Controls.GraphicsDataRep Ź NARROW[g.data, GraphicsData]^];
vwr Ź data.viewer Ź ViewerOps.CreateViewer[flavor: $Graphics, paint: FALSE, info: [wx: x, wy: y, ww: w, wh: h, data: data, 
scrollable: FALSE,  border: nViews > 1, parent: g]];
ViewerOps.AddProp[vwr, $View, v]; -- property not there on initial opening!?
ViewerOps.AddProp[vwr, $CreatedInOuterViewer, $True]; -- avoid Controls.AdjustProc
};
v: View Ź views[n] Ź NEW[ViewRep];
v.screens Ź NEW[G3dTool.ShapeScreensRep[10]];
v.tool Ź tool;
v.index Ź n;
IF nViews = 1
THEN v.viewer Ź MakeViewer[0, 0, w, g.ch]
ELSE {
miniW: NAT Ź w/MIN[nViews, 3];
v.viewer Ź MakeViewer[n*miniW, 0, miniW, g.wh]
};
G3dControl.SaveState[tool.camera, v.camera Ź NEW[CameraRep]];
ENDLOOP;
};

DoWithViews: PUBLIC PROC [tool: Tool, action: ViewProc, activeOnly: BOOL Ź TRUE] ~ {
IF tool = NIL THEN RETURN;
IF activeOnly
THEN FOR l: LIST OF NAT Ź tool.activeViews, l.rest WHILE l # NIL DO
IF NOT action[tool.views[l.first]] THEN EXIT;
ENDLOOP
ELSE FOR i: NAT IN [0..tool.views.length) DO
IF NOT action[tool.views[i]] THEN EXIT;
ENDLOOP;
};

GetFirstActiveView: PUBLIC PROC [tool: Tool] RETURNS [v: View] ~ {
IF tool # NIL AND tool.views # NIL AND tool.activeViews # NIL
THEN v Ź tool.views[tool.activeViews.first]; 
};

GetView: PUBLIC PROC [viewer: Viewer, tool: Tool Ź NIL] RETURNS [v: View] ~ {
IF viewer # NIL THEN {
ref: REF Ź ViewerOps.FetchProp[viewer, $View];
IF ref # NIL THEN v Ź NARROW[ref];
};
IF v = NIL AND tool # NIL THEN v Ź tool.views[tool.activeViews.first];
IF viewer = NIL AND v # NIL THEN viewer Ź v.viewer;
IF v # NIL THEN v.viewport Ź G3dView.GetViewport[viewer];
};

GetViewTransform: PUBLIC PROC [
viewer: Viewer Ź NIL,
tool: Tool Ź NIL,
out: Matrix Ź NIL]
RETURNS [m: Matrix]
~ {
v: View Ź GetView[viewer, tool];
IF v # NIL THEN m Ź G3dMatrix.CopyMatrix[v.camera.matrix, out];
};

GetBufferedSampleMap: PUBLIC PROC [view: View, id: ATOM Ź $Frame]
RETURNS [map: SampleMap]
~ {
IF view # NIL THEN 
FOR l: LIST OF NamedBuffer Ź view.idBuffer, l.rest WHILE l # NIL DO
IF l.first.id = id THEN RETURN[l.first.map];
ENDLOOP;
};

SetBufferedSampleMap: PUBLIC PROC [map: SampleMap, view: View, id: ATOM Ź $Frame]~ {
nb: NamedBuffer Ź [id, map];
IF view = NIL THEN RETURN;
FOR l: LIST OF NamedBuffer Ź view.idBuffer, l.rest WHILE l # NIL DO
IF l.first.id = id THEN {l.first Ź nb; RETURN};
ENDLOOP;
view.idBuffer Ź CONS[nb, view.idBuffer];
};

InvalidateViewScreens: PUBLIC PROC [view: View] ~ {
IF view # NIL AND view.screens # NIL THEN
FOR i: INTEGER IN [0..view.screens.length) DO
view.screens[i].screensValid Ź FALSE;
ENDLOOP;
};
<<Stop, Finish, and Help>>
FinishButton: PUBLIC ClickProc ~ {
t: Tool Ź NARROW[clientData];
IF t.cmd = NIL
THEN G3dTool.TSWrite[t, "No command handle!\n"]
ELSE {
prompt: ROPE Ź "When done with a forked process, do: ";
IF t.command # NIL THEN prompt Ź Rope.Cat[prompt, "(presently ", t.command, ") "];
t.command Ź Controls.TypescriptRead[t.typescript, prompt];
};
};

Finish: PUBLIC PROC [tool: Tool, reason: ROPE] ~ {
IF tool.client.stop # NIL THEN tool.client.stop[tool.client.data, reason];
IF tool.command # NIL AND tool.cmd # NIL
THEN [] Ź CommanderOps.DoCommand[tool.command, tool.cmd];
};

HelpButton: PUBLIC ClickProc ~ {OpenHelp["A tool for line drawings or shaded images"]};

StopButton: PUBLIC ClickProc ~ {Stop[NARROW[clientData], " . . . aborted\n"]};
<<Miscellany>>
doc: ROPE Ź "Graphics3dDoc.tioga";
docProp: REF ROPE Ź NEW[ROPE Ź "Yo!"];

OpenHelp: PUBLIC PROC [key: ROPE] ~ {
name: ROPE Ź doc;
vHelp: Viewer;
PropProc: ViewerOps.EnumProc
~ {
WITH ViewerOps.FetchProp[v, $G3dHelp] SELECT FROM
r: REF ROPE => IF r = docProp THEN {vHelp Ź v; RETURN[FALSE]};
ENDCASE => RETURN[TRUE];
};
name Ź FileNames.StripVersionNumber[FS.FileInfo[doc ! FS.Error => CONTINUE].fullFName];
vHelp Ź ViewerOps.FindViewer[name];
IF vHelp = NIL THEN ViewerOps.EnumerateViewers[PropProc];
IF vHelp # NIL
THEN {IF vHelp.column # right THEN ViewerOps.ChangeColumn[vHelp, right]}
ELSE {
vHelp Ź ViewerOps.CreateViewer[
flavor: $Text, paint: FALSE, info: [iconic: TRUE, column: right, openHeight: 140]];
TiogaMenuOps.Load[viewer: vHelp, fileName: doc];
ViewerOps.AddProp[viewer: vHelp, prop: $G3dHelp, val: docProp];
};
ViewerOps.SetOpenHeight[viewer: vHelp, clientHeight: 140];
ViewerOps.OpenIcon[icon: vHelp, bottom: FALSE, paint: FALSE]; -- must do Open before Top
ViewerOps.TopViewer[viewer: vHelp, paint: FALSE];
ViewerOps.ComputeColumn[right];
TEditSelection.FindRope[vHelp, key];
};

SetCursor: PUBLIC PROC [tool: Tool, waiting: BOOL] ~ {
IF waiting
THEN Cursors.SetCursor[tool.outer.class.cursor Ź tool.graphics.class.cursor Ź hourGlass]
ELSE Cursors.SetCursor[tool.outer.class.cursor Ź tool.graphics.class.cursor Ź textPointer];
};

StartTimer: PUBLIC PROC [tool: Tool] ~ {
tool.clock Ź BasicTime.PulsesToSeconds[BasicTime.GetClockPulses[]];
};

ElapsedTime: PUBLIC PROC [tool: Tool] RETURNS [seconds: REAL] ~ {
RETURN[BasicTime.PulsesToSeconds[BasicTime.GetClockPulses[]]-tool.clock];
};

PrintElapsedTime: PUBLIC PROC [tool: Tool, elapsedTime: REAL Ź 0.0, action: ROPE Ź NIL] ~ {
IF action = NIL THEN action Ź "elapsed";
IF elapsedTime = 0.0 THEN elapsedTime Ź ElapsedTime[tool];
TSWrite[tool, IO.PutFR["%g time: %6.3f seconds.", IO.rope[action], IO.real[elapsedTime]]]
};

TSWrite: PUBLIC PROC [tool: Tool, message: ROPE] ~ {
IF tool.outer # NIL
THEN Controls.TypescriptWrite[tool.typescript, Rope.Concat[message, "\n"]]
ELSE IO.PutRope[tool.cmd.out, message];
};

END.