[Indigo]<3DGraphics>NewThreeDRender>ThreeDDemoImpl.mesa!3

ThreeDDemoImpl.mesa

Last Edited by: Crow, March 14, 1989 4:03:14 pm PST

Bloomenthal, September 26, 1988 12:04:57 pm PDT

DIRECTORY

Atom USING [ GetPropFromList, PutPropOnList, RemPropFromList ],

BasicTime USING [ GMT, Period, PulsesToSeconds, GetClockPulses ],

FS USING [ FileInfo ],

List USING [ Memb ],

CedarProcess USING [ Abort, CheckAbort, Process, Fork, ForkableProc ],

Commander USING [ CommandProc, Register ],

Process USING [ PauseMsec, Yield ],

Rope USING [ Equal, Length, ROPE ],

Real USING [ Fix, Float, Round ],

Random USING [ Create, NextInt, RandomStream ],

ViewerTools USING [ GetSelectionContents ],

Terminal USING [ GetColorCursorPosition ],

Imager USING [ Context ],

ThreeDBasics USING [ Context, Create, Error, ImagerProcRec, IntegerPair,
LoadDisplayType, Pair, Patch, Pixel, Rectangle, RGB, SetView,
ShadingClass, ShapeInstance, ShapeSequence, Triple ],

ThreeDViewer USING [ ButtonDesc, DrawInViewer, MakeViewer, MouseProc,
SwitchDisplayTo, ViewerUpdate ],

ColorDisplayRender USING [ Orbit, StuffBuf, LoadStd8BitClrMap ],

ImageTwiddle USING [ SetUpTerrainColors ],

AISAnimation USING [ CacheNumberedAISFiles, FrameSequence, GetAIS,
GetLogFileName, PutAIS, ShowNextAISCacheFrame ],

SurfaceRender USING [ ShowShapes, ValidateContext ],

RenderWithImager USING [ MakeInterpressPage ],

RenderWithPixels USING [ AntiAliasing, BufferRendering, DepthBuffering, MakeFrame,
PolygonTiler, AllocatePixelMemory ],

SceneUtilities USING [ AddShapeAt, CopyContextShapes, CopyShapeDirect,
GetTmpContext, NameBackgroundColor, OrientShape,
RotateShapeLocal, SetAmbientLight, SetColor, SetDull,
SetFaceted, SetHiddenLines, SetLight, SetLines,
SetNormaledLines, SetShadedLines, SetShiny, SetSmooth,
SetTransparent, SetWindow, SetViewPort, StartLog ];

ThreeDDemoImpl: CEDAR MONITOR

IMPORTS AISAnimation, Atom, BasicTime, CedarProcess, ColorDisplayRender, Commander, FS, ImageTwiddle, List, Process, Random, Real, RenderWithImager, RenderWithPixels, Rope, SceneUtilities, SurfaceRender, Terminal, ThreeDBasics, ThreeDViewer, ViewerTools

~ BEGIN

Types

ROPE: TYPE ~ Rope.ROPE;

Context: TYPE ~ ThreeDBasics.Context;

IntegerPair: TYPE ~ ThreeDBasics.IntegerPair;

Pair: TYPE ~ ThreeDBasics.Pair;

Pixel: TYPE ~ ThreeDBasics.Pixel;

Triple: TYPE ~ ThreeDBasics.Triple;

Rectangle: TYPE ~ ThreeDBasics.Rectangle;

RGB: TYPE ~ ThreeDBasics.RGB;

ShadingClass: TYPE ~ ThreeDBasics.ShadingClass;

ShapeInstance: TYPE ~ ThreeDBasics.ShapeInstance;

ShapeSequence: TYPE ~ ThreeDBasics.ShapeSequence;

ImagerProcRec: TYPE ~ ThreeDBasics.ImagerProcRec;

LORA: TYPE ~ LIST OF REF ANY;

Global Variables

context3d, offScreenCtx: REF Context; -- , onScreenCtx

currentScene, scene1, scene2, scene3: REF ShapeSequence ← NIL;

lastDemoCalled: PROC[makeFrame: BOOLEAN ← FALSE];

frames: REF AISAnimation.FrameSequence;

xNow, yNow, zNow: REAL ← 3.0;

xPosition, yPosition: REAL ← 0.0;

cursorRange: REAL ← 64.0;

quadTime: REAL;

animation: BOOLEAN ← FALSE;

movieProcess: CedarProcess.Process ← NIL;

cachedViewPort: Rectangle ← [0.0, 0.0, 0.0, 0.0];

windowStack, viewPortStack: LIST OF Rectangle ← NIL;

mouseWaiting: ATOM ← NIL;

mouseRectangle: REF Rectangle ← NIL;

Menu and Button Procs

demoMenu: LIST OF ThreeDViewer.ButtonDesc ~ LIST [

[ proc: SetScene, -- Select Scene

choices: LIST[

[$Scene1, "Polyhedra on Checkerboard"], -- left mouse button

[$Scene2, "Glass, Banana and Egg"], -- middle mouse button

[$Scene3, "Bezier Teapot"], -- right mouse button

[$OneShape, "Show One Shape (name from selection)"], -- shift left

[NIL, NIL], -- shift middle

[NIL, NIL], -- shift right

[$Window, "2 Clicks in image define part of scene to display"], -- control left

[$ViewPort, "2 Clicks in image define new screen area"], -- control middle

[NIL, NIL], -- control right

[$RestoreW, "Restore previous window"], -- control shift left

[$RestoreVP, "Restore previous viewport"] -- control shift middle

label: "Select Shapes",

purpose: "Chooses scene to manipulate"

[ proc: SetShading, -- Shading Style

choices: LIST[

[$Lines, "Line Drawing"], -- left mouse button

[$Facets, "Faceted Shading"], -- middle mouse button

[$Smooth, "Smooth Shading"], -- right mouse button

[$Hidden, "Hidden Line Drawing"], -- shift left

[$Shiny, "Faceted Shading with Highlights"], -- shift middle

[$Hilights, "Smooth Shading with Highlights"], -- shift right

[$SmoLines, "Smooth Shading on Lines"], -- control left

[$Normals, "Line drawing with normal vectors"] -- control middle

label: "Shading Style",

purpose: "Chooses shading for surfaces in current scene"

[ proc: SetRenderingStyle, -- Rendering Style

choices: LIST[

[$Jaggy, "Aliased"], -- left mouse button

[$NoJaggy, "AntiAliased"], -- middle mouse button

[NIL, NIL], -- right mouse button

[$Visible, "Build Image On Display"], -- shift left

[$Buffered, "Double Buffer Image"], -- shift middle

[NIL, NIL], -- shift right

[$Imager, "Use Imager (faceted only)"], -- control left

[$Pixels, "Use fancier tiler/shaders"], -- control middle

[NIL, NIL], -- control right

[$ZBuffer, "Use depth buffer for hidden surfaces"], -- control shift left

[$Sorted, "Use sorting for hidden surfaces"], -- control shift middle

[NIL, NIL], -- control shift right

[$PseudoClr, "8-bit mapped color"],

[$Gray, "8-bit grayscale"],

[$FullClr, "24-bit full color"]

label: "Rendering Style",

purpose: "Chooses display type, antialising, and double buffering"

[ proc: DoCommands, -- Commands

choices: LIST[

[$Display, "Make a frame with the current scene"], -- left mouse button

[$StoreImage, "Store image in file (name from selection)"], -- middle mouse button

[$Interpress, "Interpress file (name from selection)"] -- right mouse button

label: "Do It",

purpose: "Make/Store images"

[ proc: ShowMotion, -- Animation

choices: LIST[

[$Orbit, "Orbit about scene computing frames on the fly"], -- left mouse button

[$SelectDthr, "Take 8-bit dithered sequence name from selection"], -- middle button

[$SelectGray, "Take 8-bit grayscale sequence name from selection"], -- right button

[$Shapes, "Play back Banana, Glass, Egg scene"], -- shift left

[$Terrain, "Play back Terrain flyover"], -- shift middle

[NIL, NIL], -- shift right

[$Web1, "Play back front view Paper web"], -- control left

[$Web2, "Play back top view Paper web"], -- control middle

label: "Animation",

purpose: "Chooses various animations"

[ proc: ShowPicture, -- Gallery

choices: LIST[

[$SelectColor, "Take rgb file name from selection"], -- left mouse button

[$SelectDthr, "Take 8-bit dithered file name from selection"], -- middle mouse button

[$SelectGray, "Take 8-bit grayscale file name from selection"], -- right mouse button

[$Spoon, "Newell's Bezier patch spoon"], -- shift left

[$Bananas, "A field of bananas"], -- shift middle

[$Compare, "Shading Comparison on Eggs"], -- shift right

[$Bowl, "Sugar bowl with spoon"], -- control left

[$TeaPot, "Teapot with Perlin texture"], -- control middle

[$Eggtxtr, "Multi-textured Egg"], -- control right

[$Heart, "Heart from two Bezier patches"], -- control shift left

[$Objects, "Five objects on a checkerboard"], -- control shift middle

[$Extents, "Five objects with bounding boxes"], -- control shift right

[$HexTiles, "Objects on hex-tiled plane"],

[$MikHead, "Mik leers over the curvaceous glass"],

[$MikTrees, "Mik leers over scanned-in trees"],

[$BallPage, "A sphere with a page of text"],

[$BallPages, "A sphere with many pages of text"],

[$TeaPages, "Teapot with pages of text"],

[$SolidLines, "Drawing with fat lines"]

label: "Gallery",

purpose: "Chooses a pretty picture to display"

[ proc: StopEverything, -- STOP! button

choices: LIST[], -- No Choices, just calls proc

label: "STOP!",

purpose: "Panic button, stops all 3D activity"

[ proc: DoReset, -- Reset button

choices: LIST[], -- No Choices, just calls proc

label: "Reset",

purpose: "Reset button, can often get things unwedged"

]

];

SetScene: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

{ ENABLE UNWIND => NULL; -- get out and release lock if error, etc.

SELECT key FROM

$Scene1 => SetScene1[];

$Scene2 => SetScene2[];

$Scene3 => SetScene3[];

$OneShape => OneShape[];

$Window => GetWindow[];

$ViewPort => GetViewPort[];

$RestoreW => RestoreWindow[];

$RestoreVP => RestoreViewPort[];

ENDCASE;

};

SetShading: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

{ ENABLE UNWIND => NULL;

SELECT key FROM

$Lines => LinesDemo[];

$Facets => { SetDull[]; FacetedDemo[]; };

$Smooth => { SetDull[]; SmoothDemo[]; };

$Hidden => HiddenLinesDemo[];

$Shiny => { SetShiny[]; FacetedDemo[]; };

$Hilights => { SetShiny[]; SmoothDemo[]; };

$SmoLines => IF context.class.displayType # $PseudoColor

OR ThreeDViewer.SwitchDisplayTo[context, $FullColor]

THEN { -- only for $Gray and $FullColor

context.preferredRenderMode ← $Pixels;

ShadedLinesDemo[];

};

$Normals => NormaledLinesDemo[];

ENDCASE;

};

SetRenderingStyle: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

SELECT key FROM

$Jaggy => RenderWithPixels.AntiAliasing[context, FALSE];

$Visible => RenderWithPixels.BufferRendering[context, FALSE];

$Imager => context.preferredRenderMode ← $Imager;

$NoJaggy => IF context.class.displayType # $PseudoColor

OR ThreeDViewer.SwitchDisplayTo[context, $FullColor]

THEN {

context.preferredRenderMode ← $Pixels;

RenderWithPixels.AntiAliasing[context, TRUE];

};

$Buffered => RenderWithPixels.BufferRendering[context, TRUE];

$Pixels => context.preferredRenderMode ← $Pixels;

$ZBuffer => RenderWithPixels.DepthBuffering[context, TRUE];

$Sorted => RenderWithPixels.DepthBuffering[context, FALSE];

$PseudoClr => [] ← ThreeDViewer.SwitchDisplayTo[context, $PseudoColor];

$Gray => [] ← ThreeDViewer.SwitchDisplayTo[context, $Gray];

$FullClr => [] ← ThreeDViewer.SwitchDisplayTo[context, $FullColor];

ENDCASE;

{ ENABLE UNWIND => NULL;

ThreeDViewer.DrawInViewer[context, NIL];

};

DoCommands: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

{ ENABLE UNWIND => NULL;

SELECT key FROM

$Display => {

IF DemoErrorMessages[] THEN RETURN;

SELECT lastDemoCalled FROM

LinesDemo => MakeFrame[];

ShadedLinesDemo => MakeFrame[];

HiddenLinesDemo => HiddenLinesDemo[TRUE];

NormaledLinesDemo => NormaledLinesDemo[TRUE];

FacetedDemo => MakeFrame[];

SmoothDemo => MakeFrame[];

ENDCASE => MakeFrame[];

};

$StoreImage => AISAnimation.PutAIS[ context3d, ViewerTools.GetSelectionContents[] ];

$Interpress => InterpressDemo[];

ENDCASE;

};

ShowMotion: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

{ ENABLE UNWIND => NULL;

IF key = $Orbit OR context.class.displayType # $FullColor

OR ThreeDViewer.SwitchDisplayTo[context, $PseudoColor] -- ensure 8-bit display

THEN SELECT key FROM

$Orbit => Orbit[];

$SelectDthr => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $PseudoColor];

SetUpMovie[ fileRoot: ViewerTools.GetSelectionContents[] ];

};

$SelectGray => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $Gray];

SetUpMovie[ fileRoot: ViewerTools.GetSelectionContents[] ];

};

$Shapes => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $PseudoColor];

SetUpMovie[

fileRoot: "/Pixel/Crow/Animation/StillCloser.ais", numFiles: 40, start: 1

];

};

$Terrain => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $PseudoColor];

SetUpMovie[ fileRoot: "/Cyan/AIS/Animation/LakeSceneTest.ais", numFiles: 64 ];

ImageTwiddle.SetUpTerrainColors[context.terminal];

};

$Web1 => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $Gray];

SetUpMovie[ fileRoot: "/Pixel/Crow/Animation/Paper4Web.ais", numFiles: 40 ];

};

$Web2 => {

[] ← ThreeDViewer.SwitchDisplayTo[context, $Gray];

SetUpMovie[ fileRoot: "/Pixel/Crow/Animation/Paper5Web.ais", numFiles: 40 ];

};

ENDCASE;

IF key # $Orbit THEN movieProcess ← CedarProcess.Fork[PlayBackbyFrame];

};

ShowPicture: ENTRY PROC[context: REF Context, key: ATOM] ~ {

context.stopMe^ ← FALSE; -- unstick stop button

{ ENABLE UNWIND => NULL;

SELECT key FROM

$SelectDthr => IF context.class.displayType # $PseudoColor THEN

IF ThreeDViewer.SwitchDisplayTo[context, $PseudoColor] THEN -- switch to dithered

{ [] ← CedarProcess.Fork[ WaitThenShowPicture, LIST[context, key] ]; RETURN; };

$SelectGray => IF context.class.displayType # $Gray THEN

IF ThreeDViewer.SwitchDisplayTo[context, $Gray] THEN -- switch to 8-bit gray

{ [] ← CedarProcess.Fork[ WaitThenShowPicture, LIST[context, key] ]; RETURN; };

ENDCASE => IF context.class.displayType # $FullColor THEN

IF ThreeDViewer.SwitchDisplayTo[context, $FullColor] THEN -- switch to full color

{ [] ← CedarProcess.Fork[ WaitThenShowPicture, LIST[context, key] ]; RETURN; };

SELECT key FROM

$SelectDthr, $SelectGray, $SelectColor =>

[] ← AISAnimation.GetAIS[context3d, ViewerTools.GetSelectionContents[] ];

$Spoon => [] ← AISAnimation.GetAIS[context3d, "/cyan/AIS/Crow/Spoon.ais" ];

$Bananas => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/FieldOfBanana.ais" ];

$Compare => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/ComparisonEggs.ais" ];

$Bowl => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/BowlAndSpoon.ais" ];

$TeaPot => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/ZebraBurlTeaPot.ais" ];

$Eggtxtr => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/MultiTxtrdEgg2.ais" ];

$Heart => [] ← AISAnimation.GetAIS[context3d, "/cyan/AIS/Crow/Heart.ais" ];

$Objects => [] ← AISAnimation.GetAIS[context3d, "/cyan/AIS/Crow/TestScene2.ais" ];

$Extents => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/FiveObjWBoxes.ais" ];

$HexTiles => [] ← AISAnimation.GetAIS[context3d, "/cyan/AIS/Crow/HexTiles.ais" ];

$MikHead => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/Lamming6Scene.ais" ];

$MikTrees => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/Lamming7Scene.ais" ];

$BallPage => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/SphereWithPage.ais" ];

$BallPages => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/SphereWithPages.ais" ];

$TeaPages => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/PagedTeaPot.ais" ];

$SolidLines => [] ← AISAnimation.GetAIS[context3d,
"/cyan/AIS/Crow/StillLines.ais" ];

ENDCASE

};

WaitThenShowPicture: CedarProcess.ForkableProc ~ {

PROC [data: REF] RETURNS [results: REF ← NIL];

Forking this process frees button, reducing likelihood of deadlocks, at least I think that's why this is done this way

list: LORA ← NARROW[data];

context: REF Context ← NARROW[list.first];

key: ATOM ← NARROW[list.rest.first];

WHILE Atom.GetPropFromList[ context.displayProps, $ViewerAdjusted ] # NIL DO

Process.PauseMsec[ 500 ]; ENDLOOP; -- wait for viewer paint proc to complete

ShowPicture[context, key];

};

StopEverything: PROC[context: REF Context, key: ATOM] ~ { -- panic stop

bkgrdContext: REF Context ← NIL;

WITH Atom.GetPropFromList[context.props, $BackGround] SELECT FROM

bkGrdCtx: REF Context => bkgrdContext ← bkGrdCtx;

ENDCASE;

context.stopMe^ ← TRUE;

WHILE bkgrdContext # NIL DO -- stop chain of background contexts

tmpCtx: REF Context ← bkgrdContext;

tmpCtx.stopMe^ ← TRUE;

bkgrdContext ← NARROW[Atom.GetPropFromList[tmpCtx.props, $BackGround]];

ENDLOOP;

IF movieProcess # NIL THEN {

Process.Yield[];

CedarProcess.Abort[movieProcess];

movieProcess ← NIL;

Process.Yield[];

SceneUtilities.SetViewPort[ context, cachedViewPort ];

};

DoReset: PROC [context: REF Context, key: ATOM] ~ { -- get out of stuckness, start over

StopEverything[context, NIL];

Process.PauseMsec[ 3000 ]; -- wait 3 seconds for processes to stop

context3d.stopMe^ ← FALSE; -- get stop flag unstuck, if necessary

context3d.window ← NIL;

context3d.shapes ← context3d.visibleShapes ← context3d.lightSources ← NIL;

ThreeDBasics.SetView[ context3d, [2.0, -10.0, 3.0], [0.0, 0.0, 0.0] ];

SceneUtilities.SetLight[context3d, "Default", [-100., -200., 50.] ];

SceneUtilities.SetViewPort[context3d, [0.0, 0.0, 65536.0, 65536.0] ];

windowStack ← viewPortStack ← NIL;

mouseWaiting ← NIL;

mouseRectangle ← NIL;

currentScene ← NIL;

frames ← NIL;

context3d.props ← Atom.RemPropFromList[ context3d.props, $SinglePatch ];

context3d.props ← Atom.RemPropFromList[ context3d.props, $SingleVtx ];

context3d.class.render[context3d]; -- update everything

};

Context and Interactive Control

ThreeDDemoCommand: Commander.CommandProc ~ {

context3d ← ThreeDBasics.Create[];

context3d.preferredRenderMode ← $Pixels; -- $Pixels, Imager;

ThreeDViewer.MakeViewer[

context: context3d,

displayType: $PseudoColor, -- $Gray, ImagerDithered

bannerName: "ThreeDWorld Demonstration",

menu: demoMenu,

mouseAction: MouseControl,

verticalMenu: FALSE

];

SceneUtilities.NameBackgroundColor[ context3d, "Darkish Blue" ]; -- set background color

SceneUtilities.SetAmbientLight[ context3d, "Darkish Gray" ]; -- set ambient light

SceneUtilities.SetLight[context3d, "Default", [-100., -200., 50.] ];

ThreeDBasics.SetView[ context3d, [2.0, -10.0, 3.0], [0.0, 0.0, 0.0] ];

};

Reset: PROCEDURE [] ~ {

DoReset[context3d, NIL];

};

InitNoViewer: PROC[] ~ {

context3d ← ThreeDBasics.Create[];

ThreeDBasics.LoadDisplayType[context3d, $PseudoColor];

SceneUtilities.NameBackgroundColor[ context3d, "Darkish Blue" ]; -- set background color

SceneUtilities.SetAmbientLight[ context3d, "Darkish Gray" ]; -- set ambient light

SceneUtilities.SetLight[context3d, "Default", [-100., -200., 50.] ];

ThreeDBasics.SetView[ context3d, [2.0, -10.0, 3.0], [0.0, 0.0, 0.0] ];

SetScene1[];

};

MouseControl: ThreeDViewer.MouseProc ~ {

PROC[context: REF Context, bttn, ctlShft: ATOM, x, y: REAL]

bttn in { $LeftButton, $LeftHeld, $MiddleButton, $MiddleHeld, $RightButton, $RightHeld }

ctlShft in { NIL, $Shift, $Control, $ControlShift }

This will be called whenever the mouse is moved or a mouse button is pushed.

width, height: INTEGER;

divisor: REAL;

IF mouseWaiting # NIL

THEN { IF bttn = $LeftButton THEN GetMouseRectangle[x, y]; RETURN; };

IF context.viewer # NIL

THEN { width ← context.viewer.ww; height ← context.viewer.wh; }

ELSE { width ← context.pixels.box.max.f - context.pixels.box.min.f;

height ← context.pixels.box.max.s - context.pixels.box.min.s; };

divisor ← ((width/2.0) * (width/2.0)) / cursorRange;

x ← x - width / 2.0; -- center mouse coords

y ← y - height / 2.0;

SELECT bttn FROM

$LeftButton, $LeftHeld => IF movieProcess # NIL

THEN frameRate ← INTEGER[Real.Fix[x / 10.]]

ELSE {

xNow ← (x * ABS[x] / divisor) + context3d.ptOfInterest.x;

yNow ← (y * ABS[y] / divisor) + context3d.ptOfInterest.y;

ThreeDBasics.SetView[ context, [xNow, yNow, zNow], context.ptOfInterest, context.fieldOfView, context.rollAngle, context.upDirection, context.hitherLimit, context.yonLimit ];

DoCommands[context, $Display];

};

$MiddleButton, $MiddleHeld => {

xLight: REAL ← x * 1.0; -- roughly plus or minus 300-500

yLight: REAL ← y * 1.0;

[] ← SceneUtilities.SetLight[ context, "Default", [xLight, yLight, 50.0] ];

DoCommands[context, $Display];

};

$RightButton, $RightHeld => {

zNow ← (y * ABS[y] / divisor) + context3d.ptOfInterest.z;

ThreeDBasics.SetView[ context, [xNow, yNow, zNow], context.ptOfInterest, context.fieldOfView, context.rollAngle, context.upDirection, context.hitherLimit, context.yonLimit ];

DoCommands[context, $Display];

};

ENDCASE;

};

MoveToCursor: PROC[] ~ {

width, height, offset: INTEGER;

sPos: IntegerPair;

IF context3d.viewer # NIL

THEN {

width ← context3d.viewer.ww; height ← context3d.viewer.wh; offset ← 28;

}

ELSE {

width ← context3d.pixels.box.max.f - context3d.pixels.box.min.f;

height ← context3d.pixels.box.max.s - context3d.pixels.box.min.s;

offset ← context3d.pixels.box.min.s

};

[[sPos.x, sPos.y]] ← Terminal.GetColorCursorPosition[context3d.terminal];

xPosition ← 1.0 * sPos.x / width;

yPosition ← 1.0 * (height - sPos.y + offset) / height;

};

DrawToCursor: PROC[ color: RGB ← [1.0,1.0,1.0] ] ~ {

width, height, offset: INTEGER;

sPos: IntegerPair;

newPos: Pair;

clrPxl: Pixel ← [Real.Fix[color.R*255], Real.Fix[color.G*255], Real.Fix[color.B*255], 0, 0];

IF context3d.viewer # NIL

THEN {

width ← context3d.viewer.ww; height ← context3d.viewer.wh; offset ← 28;

}

ELSE {

width ← context3d.pixels.box.max.f - context3d.pixels.box.min.f;

height ← context3d.pixels.box.max.s - context3d.pixels.box.min.s;

offset ← context3d.pixels.box.min.s

};

[[sPos.x, sPos.y]] ← Terminal.GetColorCursorPosition[context3d.terminal];

newPos ← [1.0 * sPos.x / width, 1.0 * (height - sPos.y + offset) / height];

context3d.class.draw2DLine[ context3d, [xPosition, yPosition], newPos, clrPxl ];

xPosition ← newPos.x;

yPosition ← newPos.y;

};

TextAtCursor: PROC[ rope: ROPE, color: RGB ← [1.0,1.0,1.0], size: REAL ← 20.0,
font: ROPE ← NIL ] ~ {

sPos: IntegerPair;

pos: Pair;

width, height, offset: INTEGER;

clrPxl: Pixel ← [Real.Fix[color.R*255], Real.Fix[color.G*255], Real.Fix[color.B*255], 0, 0];

IF context3d.viewer # NIL

THEN {

width ← context3d.viewer.ww; height ← context3d.viewer.wh; offset ← 28;

}

ELSE {

width ← context3d.pixels.box.max.f - context3d.pixels.box.min.f;

height ← context3d.pixels.box.max.s - context3d.pixels.box.min.s;

offset ← context3d.pixels.box.min.s

};

[[sPos.x, sPos.y]] ← Terminal.GetColorCursorPosition[context3d.terminal];

pos ← [1.0 * sPos.x / width, 1.0 * (height - sPos.y + offset) / height];

IF font = NIL THEN font ← "Xerox/Pressfonts/TimesRoman-MRR";

context3d.class.draw2DRope[context3d, rope, pos, clrPxl, size, font];

};

GetOffScreenCtx: PROC[context: REF Context, width, height: NAT] ~ {

offScreenCtx ← SceneUtilities.GetTmpContext[context];

offScreenCtx.viewer ← NIL;

offScreenCtx.viewPort ← NEW[ -- set viewport directly to define pixelMap size

Rectangle ← [ x: 0.0, y: 0.0, w: Real.Float[width], h: Real.Float[height] ]

];

RenderWithPixels.AllocatePixelMemory[offScreenCtx]; -- get display memory

SceneUtilities.SetViewPort[ offScreenCtx, [0.0, 0.0, Real.Float[width], Real.Float[height]] ];

IF context.antiAliasing THEN RenderWithPixels.AntiAliasing[offScreenCtx];-- get state straight

IF context.depthBuffering THEN RenderWithPixels.DepthBuffering[offScreenCtx];

[] ← SceneUtilities.StartLog[offScreenCtx];

FOR i: NAT IN [0..offScreenCtx.shapes.length) DO

offScreenCtx.shapes[i].vtcesInValid ← TRUE;

ENDLOOP;

SurfaceRender.ValidateContext[offScreenCtx];

SurfaceRender.ValidateContext[context]; -- just in case it hasn't been used yet

};

GetOnScreenCtx: PROC[context: REF Context, width, height: NAT] ~ {

Makes a new view of the supplied context, useful for using two portions of the screen differently, etc.

onScreenCtx: REF Context ← SceneUtilities.GetTmpContext[context];

SceneUtilities.SetViewPort[ onScreenCtx, [0.0, 0.0, Real.Float[width], Real.Float[height]] ];

onScreenCtx.class.render ← RenderWithPixels.MakeFrame; -- load direct memory procs

onScreenCtx.class.displayPolygon ← RenderWithPixels.PolygonTiler;

IF context.antiAliasing THEN RenderWithPixels.AntiAliasing[onScreenCtx];

IF context.depthBuffering THEN RenderWithPixels.DepthBuffering[onScreenCtx];

FOR i: NAT IN [0..onScreenCtx.shapes.length) DO

onScreenCtx.shapes[i].vtcesInValid ← TRUE;

ENDLOOP;

SurfaceRender.ValidateContext[onScreenCtx];

SurfaceRender.ValidateContext[context]; -- just in case it hasn't been used yet

};

Demos

DemoErrorMessages: PROCEDURE [] RETURNS[ error: BOOLEAN ← FALSE ] ~ {

NoSurfaces: PROCEDURE [shapes: REF ShapeSequence] RETURNS[BOOLEAN]~{

FOR i: NAT IN [0..shapes.length) DO

IF shapes[i].surface # NIL THEN RETURN[FALSE];

ENDLOOP;

RETURN[TRUE];

};

IF context3d.shapes = NIL OR NoSurfaces[context3d.shapes] THEN SetScene1[];

IF context3d.shapes = NIL OR NoSurfaces[context3d.shapes] THEN {

context3d.class.draw2DRope[context3d, "No objects, nothing to display", [60, 340] ];

error ← TRUE;

};

IF context3d.antiAliasing

AND NOT List.Memb[ context3d.class.displayType, LIST[$Gray, $FullColor] ]

THEN {

context3d.class.draw2DRope[context3d,

"NoJaggy needs GrayScale or 24-bit Color", [60, 300] ];

error ← TRUE;

};

LinesDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

IF DemoErrorMessages[] THEN RETURN;

FOR i: NAT IN [0..context3d.shapes.length) DO

IF context3d.shapes[i].surface # NIL

THEN SceneUtilities.SetLines[ context3d, context3d.shapes[i].name ];

ENDLOOP;

IF makeFrame THEN context3d.class.render[context3d];

lastDemoCalled ← LinesDemo;

};

ShadedLinesDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

IF DemoErrorMessages[] THEN RETURN;

FOR i: NAT IN [0..context3d.shapes.length) DO

IF context3d.shapes[i].surface # NIL

THEN SceneUtilities.SetShadedLines[ context3d, context3d.shapes[i].name ];

ENDLOOP;

IF makeFrame THEN context3d.class.render[context3d];

lastDemoCalled ← ShadedLinesDemo;

};

HiddenLinesDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

tmpContext: REF Context ← SceneUtilities.GetTmpContext[context3d]; -- get modifiable context

IF DemoErrorMessages[] THEN RETURN;

SceneUtilities.NameBackgroundColor[ tmpContext, "White" ];

SceneUtilities.CopyContextShapes[tmpContext, context3d]; -- insulate shapes from changes

FOR i: NAT IN [0..context3d.shapes.length) DO

SceneUtilities.SetColor[ tmpContext, tmpContext.shapes[i].name, [1.0, 1.0, 1.0] ];

IF tmpContext.shapes[i].surface # NIL

THEN SceneUtilities.SetHiddenLines[ tmpContext, tmpContext.shapes[i].name ];

ENDLOOP;

IF makeFrame THEN tmpContext.class.render[tmpContext];

lastDemoCalled ← HiddenLinesDemo;

};

NormaledLinesDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

tmpContext: REF Context ← SceneUtilities.GetTmpContext[context3d]; -- get modifiable context

IF DemoErrorMessages[] THEN RETURN;

SceneUtilities.NameBackgroundColor[ tmpContext, "White" ];

SceneUtilities.CopyContextShapes[tmpContext, context3d]; -- insulate shapes from changes

FOR i: NAT IN [0..context3d.shapes.length) DO

SceneUtilities.SetColor[ tmpContext, tmpContext.shapes[i].name, [1.0, 1.0, 1.0] ];

IF tmpContext.shapes[i].surface # NIL

THEN SceneUtilities.SetNormaledLines[ tmpContext, tmpContext.shapes[i].name ];

ENDLOOP;

IF makeFrame THEN tmpContext.class.render[tmpContext];

lastDemoCalled ← NormaledLinesDemo;

};

FacetedDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

IF DemoErrorMessages[] THEN RETURN;

FOR i: NAT IN [0..context3d.shapes.length) DO IF context3d.shapes[i].surface # NIL THEN

SceneUtilities.SetFaceted[ context3d, context3d.shapes[i].name ];

ENDLOOP;

IF makeFrame THEN context3d.class.render[context3d];

lastDemoCalled ← FacetedDemo;

};

SmoothDemo: PROCEDURE [makeFrame: BOOLEAN ← FALSE] ~ {

IF DemoErrorMessages[] THEN RETURN;

FOR i: NAT IN [0..context3d.shapes.length) DO IF context3d.shapes[i].surface # NIL THEN

SceneUtilities.SetSmooth[context3d, context3d.shapes[i].name];

ENDLOOP;

lastDemoCalled ← SmoothDemo;

IF makeFrame THEN context3d.class.render[context3d];

};

SetShiny: PROCEDURE [] ~ {

FOR i: NAT IN [0..context3d.shapes.length) DO IF context3d.shapes[i].surface # NIL THEN {

shininess: REAL ← context3d.shapes[i].shadingClass.shininess;

IF shininess <= 0.0 THEN SceneUtilities.SetShiny[ context3d, context3d.shapes[i].name ];

};

ENDLOOP;

};

SetDull: PROCEDURE [] ~ {

FOR i: NAT IN [0..context3d.shapes.length) DO IF context3d.shapes[i].surface # NIL THEN

SceneUtilities.SetDull[ context3d, context3d.shapes[i].name ]; -- no highlights

ENDLOOP;

};

InterpressDemo: PROCEDURE [] ~ {

fileName: Rope.ROPE ← ViewerTools.GetSelectionContents[];

IF Rope.Length[fileName] < 1 THEN {

SIGNAL ThreeDBasics.Error[[$MisMatch, "No selection for file name"]];

RETURN;

};

IF DemoErrorMessages[] THEN RETURN;

IF lastDemoCalled # HiddenLinesDemo AND lastDemoCalled # NormaledLinesDemo

THEN

RenderWithImager.MakeInterpressPage[context3d, fileName ]

ELSE {

tmpContext: REF Context ← SceneUtilities.GetTmpContext[context3d]; -- get mod. context

SceneUtilities.NameBackgroundColor[ tmpContext, "White" ];

SceneUtilities.CopyContextShapes[tmpContext, context3d]; -- insulate shapes from change

FOR i: NAT IN [0..context3d.shapes.length) DO

SceneUtilities.SetColor[ tmpContext, tmpContext.shapes[i].name, [1.0, 1.0, 1.0] ];

IF tmpContext.shapes[i].surface # NIL

THEN IF lastDemoCalled # NormaledLinesDemo

THEN SceneUtilities.SetHiddenLines[ tmpContext, tmpContext.shapes[i].name ]

ELSE SceneUtilities.SetNormaledLines[ tmpContext, tmpContext.shapes[i].name ];

ENDLOOP;

RenderWithImager.MakeInterpressPage[tmpContext, fileName ]

};

RandomQuads: PROCEDURE [context: REF Context] ~ {

x, y: REAL;

time: REAL ← BasicTime.PulsesToSeconds[BasicTime.GetClockPulses[]];

width: REAL ← context.viewPort.w; height: REAL ← context.viewPort.h;

aspectRatio: REAL ← height / width;

rs: Random.RandomStream ← Random.Create[Real.Round[width]]; -- limit to display width

p: REF ThreeDBasics.Patch ← NEW[ ThreeDBasics.Patch[4] ];

shape: REF ShapeInstance ← NEW[ShapeInstance];

shape.shadingClass ← NEW[ShadingClass];

shape.shadingClass.shadingType ← $Smooth;

p.props ← Atom.PutPropOnList[ p.props, $Shape, shape ];

p.nVtces ← 4;

FOR i: NAT IN [0..1000) DO

IF context.stopMe^ THEN EXIT;

x ← Random.NextInt[rs]; y ← Random.NextInt[rs] * aspectRatio;

FOR j: NAT IN [0..4) DO

xSgn, ySgn: INTEGER;

xSgn ← IF j < 1 OR j > 3 THEN -1 ELSE 1; ySgn ← IF j < 2 THEN 1 ELSE -1;

p[j].coord.sx ← MAX[0, MIN[ width-1, x + xSgn * Random.NextInt[rs] * 0.1]];

p[j].coord.sy ← MAX[0, MIN[ height-1, y+ySgn * Random.NextInt[rs] *0.1 *aspectRatio]];

p[j].shade.er ← Random.NextInt[rs] / width;

p[j].shade.eg ← Random.NextInt[rs] / width;

p[j].shade.eb ← Random.NextInt[rs] / width;

ENDLOOP;

[] ← context.class.displayPolygon[context, p];

ENDLOOP;

quadTime ← BasicTime.PulsesToSeconds[BasicTime.GetClockPulses[]] - time;

};

Scene Definition

SetScene1: PROCEDURE [] ~ {

IF scene1 = NIL THEN {

Reset[];

SceneUtilities.AddShapeAt[ context3d,

"CheckerBoard", -- internal name

"CheckerBoard.shape", -- file name

[-8.0, -8.0, -2.0] -- position

];

SceneUtilities.AddShapeAt[ context3d, "Icosahedron", "Icosahedron.shape", [2.0, 0.0, 0.0] ];

SceneUtilities.SetColor[ context3d, "Icosahedron", [1., 1., 1.] ];

SceneUtilities.AddShapeAt[ context3d, "SoccerBall", "SoccerBall.shape", [-2.0, 0.0, 0.0] ];

SceneUtilities.SetColor[ context3d, "SoccerBall", [1., 1., 1.] ];

SceneUtilities.AddShapeAt[ context3d, "CutCube", "CutCube.shape", [0.0, 3.0, 0.0] ];

SceneUtilities.SetColor[ context3d, "CheckerBoard", [.8, .4, .2] ]; -- add shading

SceneUtilities.SetColor[ context3d, "CutCube", [.9, .8, .5] ];

scene1 ← NEW[ShapeSequence[context3d.shapes.length]];

FOR i: NAT IN [0..context3d.shapes.length) DO

scene1[i] ← SceneUtilities.CopyShapeDirect[ context3d.shapes[i] ];

ENDLOOP;

scene1.length ← context3d.shapes.length;

}

ELSE {

FOR i: NAT IN [0..scene1.length) DO

context3d.shapes[i] ← SceneUtilities.CopyShapeDirect[ scene1[i] ];

ENDLOOP;

context3d.shapes.length ← scene1.length;

};

RenderWithPixels.DepthBuffering[context3d, FALSE];

currentScene ← scene1;

};

SetScene2: PROCEDURE [] ~ {

IF scene2 = NIL THEN {

Reset[];

SceneUtilities.AddShapeAt[context3d, "ChampagneGlass", "ChampagneGlass.shape",
[2.0, 0.0, 0.0] ];

SceneUtilities.RotateShapeLocal[ context: context3d, shapeName: "ChampagneGlass", theta: 45 ];

SceneUtilities.SetColor[context3d, "ChampagneGlass", [1.,0.,1.] ];

SceneUtilities.SetTransparent[ context3d, "ChampagneGlass" ];

SceneUtilities.AddShapeAt[context3d, "UtahEgg", "UtahEgg.shape", [-2.0, .0, .0] ];

SceneUtilities.OrientShape[ context: context3d, shapeName: "UtahEgg", axis: [-1, 1, 0] ];

SceneUtilities.SetColor[context3d, "UtahEgg", [1.0, .8, .5] ];

SceneUtilities.AddShapeAt[context3d, "Banana", "Banana.shape", [0.0, .0, .0] ];

SceneUtilities.SetColor[context3d, "Banana", [1.0, .9, .1] ];

scene2 ← NEW[ShapeSequence[context3d.shapes.length]];

FOR i: NAT IN [0..context3d.shapes.length) DO

scene2[i] ← SceneUtilities.CopyShapeDirect[ context3d.shapes[i] ];

ENDLOOP;

scene2.length ← context3d.shapes.length;

}

ELSE {

FOR i: NAT IN [0..scene2.length) DO

context3d.shapes[i] ← SceneUtilities.CopyShapeDirect[ scene2[i] ];

ENDLOOP;

context3d.shapes.length ← scene2.length;

};

RenderWithPixels.DepthBuffering[context3d, FALSE];

currentScene ← scene2;

};

SetScene3: PROCEDURE [] ~ {

IF scene3 = NIL THEN {

Reset[];

SceneUtilities.AddShapeAt[context3d, "TeaPot", "TeaPotWithBot.shape", [0.0, 0.0, -1.25] ];

scene3 ← NEW[ShapeSequence[context3d.shapes.length]];

FOR i: NAT IN [0..context3d.shapes.length) DO

scene3[i] ← SceneUtilities.CopyShapeDirect[ context3d.shapes[i] ];

ENDLOOP;

scene3.length ← context3d.shapes.length;

ThreeDBasics.SetView[context3d, [3.0, -10.0, 3.0], [0.0, 0.0, 0.0] ];

}

ELSE {

FOR i: NAT IN [0..scene3.length) DO

context3d.shapes[i] ← SceneUtilities.CopyShapeDirect[ scene3[i] ];

ENDLOOP;

context3d.shapes.length ← scene3.length;

};

currentScene ← scene3;

};

OneShape: PROCEDURE [] ~ {

Reset[];

SceneUtilities.AddShapeAt[context3d, "Shape0", ViewerTools.GetSelectionContents[] ];

ThreeDBasics.SetView[context3d, [0.0, -10.0, 3.0], [0.0, 0.0, 0.0] ];

};

GetMouseRectangle: PROCEDURE[x, y: REAL] ~ {

IF mouseRectangle # NIL

THEN {

mouseRectangle.w ← x - mouseRectangle.x;

IF mouseRectangle.w < 0.0 THEN {

mouseRectangle.x ← mouseRectangle.x + mouseRectangle.w;

mouseRectangle.w ← -mouseRectangle.w;

};

mouseRectangle.h ← y - mouseRectangle.y;

IF mouseRectangle.h < 0.0 THEN {

mouseRectangle.y ← mouseRectangle.y + mouseRectangle.h;

mouseRectangle.h ← -mouseRectangle.h;

};

SELECT mouseWaiting FROM

$Window => {

mouseRectangle.x ← mouseRectangle.x - context3d.viewPort.x;

mouseRectangle.y ← mouseRectangle.y - context3d.viewPort.y;

mouseRectangle.w ← MIN[mouseRectangle.w, context3d.viewPort.w];

mouseRectangle.x ← 2.0 * (mouseRectangle.x / context3d.viewPort.w - 0.5); -- center

mouseRectangle.y ←

2.0 * (mouseRectangle.y - context3d.viewPort.h/2.0) / context3d.viewPort.w;

mouseRectangle.w ← 2.0 * mouseRectangle.w / context3d.viewPort.w;

mouseRectangle.h ← mouseRectangle.w * context3d.viewPort.h/context3d.viewPort.w;

windowStack ← CONS[ context3d.window^, windowStack ];

SceneUtilities.SetWindow[ context3d, mouseRectangle^ ];

mouseRectangle ← NIL;

mouseWaiting ← NIL;

};

$ViewPort => {

viewPortStack ← CONS[ context3d.viewPort^, viewPortStack ];

SceneUtilities.SetViewPort[ context3d, mouseRectangle^ ];

mouseRectangle ← NIL;

mouseWaiting ← NIL;

};

ENDCASE => SIGNAL ThreeDBasics.Error[[$MisMatch, "Unknown Mouse Atom"]];

}

ELSE mouseRectangle ← NEW[ Rectangle ← [x, y, 0.0, 0.0] ];

};

GetWindow: PROCEDURE[] ~ {

mouseWaiting ← $Window

};

RestoreWindow: PROCEDURE[] ~ {

IF windowStack # NIL

THEN {

SceneUtilities.SetWindow[ context3d, windowStack.first ];

windowStack ← windowStack.rest;

}

ELSE SIGNAL ThreeDBasics.Error[[$MisMatch, "No previous window"]];

};

GetViewPort: PROCEDURE [] ~ {

mouseWaiting ← $ViewPort

};

RestoreViewPort: PROCEDURE[] ~ {

IF viewPortStack # NIL

THEN {

SceneUtilities.SetViewPort[ context3d, viewPortStack.first ];

viewPortStack ← viewPortStack.rest;

}

ELSE SIGNAL ThreeDBasics.Error[[$MisMatch, "No previous viewport"]];

};

ShowSinglePatch: PROCEDURE[ shapeNumber, patchNumber: NAT, keep: BOOL ← FALSE ] ~ {

context3d.props ← Atom.PutPropOnList[

context3d.props, $SinglePatch, NEW[ IntegerPair ← [shapeNumber, patchNumber] ]

];

DoCommands[context3d, $Display];

IF NOT keep THEN context3d.props ← Atom.RemPropFromList[ context3d.props, $SinglePatch ];

};

ShowPatchesOnVtx: PROCEDURE[ shapeNumber, vtxNumber: NAT, keep: BOOL ← FALSE ] ~ {

context3d.props ← Atom.PutPropOnList[

context3d.props, $SingleVtx, NEW[ IntegerPair ← [shapeNumber, vtxNumber] ]

];

DoCommands[context3d, $Display];

IF NOT keep THEN context3d.props ← Atom.RemPropFromList[ context3d.props, $SingleVtx ];

};

Frame Generation and Animation

Orbit: PROCEDURE [] ~ {

IF DemoErrorMessages[] THEN RETURN;

animation ← TRUE;

ColorDisplayRender.Orbit[

context: context3d,

lookingFrom: context3d.eyePoint,

lookingAt: context3d.ptOfInterest,

axis: [0.3, 0.0, 1.0],

base: context3d.ptOfInterest,

framesPerRev: 53

! UNWIND => animation ← FALSE

];

animation ← FALSE;

};

MakeFrame: PROC ~ {

context3d.class.render[context3d ]; -- clear and make new frame

};

ShowPixels: PROC ~ {

context3d.class.drawInViewer[ context3d,
NEW[ImagerProcRec ← [ColorDisplayRender.StuffBuf, NIL]]
];

};

ShowShapes: PROC ~ {

SurfaceRender.ShowShapes[context3d ]; -- show shapes without clearing

};

movieFileRoot: Rope.ROPE;

movieFileLog: Rope.ROPE;

movieFileLogTime: BasicTime.GMT;

movieNumFiles: NAT;

movieStart: NAT;

SetUpMovie: PROC[fileRoot: Rope.ROPE, numFiles, start: NAT ← 0] ~ {

fileUpdated: BOOLEAN ← FALSE;

IF frames # NIL AND Rope.Equal[movieFileRoot, fileRoot]

THEN {

latestTime: BasicTime.GMT;

[created: latestTime] ← FS.FileInfo[ AISAnimation.GetLogFileName[fileRoot] ];

IF BasicTime.Period[from: movieFileLogTime, to: latestTime] > 0

THEN fileUpdated ← TRUE;

}

ELSE frames ← NIL;

IF frames = NIL OR fileUpdated THEN {

movieFileRoot ← fileRoot;

[fullFName: movieFileLog, created: movieFileLogTime] ← FS.FileInfo[

AISAnimation.GetLogFileName[fileRoot]

];

movieNumFiles ← numFiles;

movieStart ← start;

frames ← NIL;

};

frameRate: INTEGER ← 6; -- playback rate in frames/second, negative plays backwards

PlayBackbyFrame: CedarProcess.ForkableProc ~ {

CleanUp: PROC ~ {

SceneUtilities.SetViewPort[ context3d, cachedViewPort ];

IF context3d.class.displayType = $PseudoColor

THEN ColorDisplayRender.LoadStd8BitClrMap[context3d.terminal];

};

size, posn: Pair;

SurfaceRender.ValidateContext[context3d];

cachedViewPort ← context3d.viewPort^;

context3d.class.loadBackground[context3d];

IF frames = NIL THEN {

frames ← AISAnimation.CacheNumberedAISFiles[

context3d, movieFileRoot, movieNumFiles, movieStart

];

};

Construct viewPort from cached frame size

IF context3d.stopMe^ THEN { CleanUp[]; RETURN[]; };

size ← [frames[0].box.max.f - frames[0].box.min.f, frames[0].box.max.s - frames[0].box.min.s];

posn ← IF context3d.viewer # NIL

THEN [ context3d.viewer.cx + (context3d.viewer.cw/2 - size.x/2),
context3d.viewer.cy + (context3d.viewer.ch/2 - size.y/2) ]

ELSE [ context3d.pixels.box.max.f/2 - size.x/2, context3d.pixels.box.max.s/2 - size.y/2 ];

SceneUtilities.SetViewPort[ context3d, [ posn.x, posn.y, size.x, size.y ] ];

IF context3d.viewer # NIL THEN ThreeDViewer.ViewerUpdate[context3d]; -- install viewport

context3d.class.draw2DRope[context3d, "Control frame rate using left button", [140, 50] ];

WHILE TRUE DO

ENABLE UNWIND => CleanUp[];

IF context3d.stopMe^ THEN { CleanUp[]; RETURN[]; };

AISAnimation.ShowNextAISCacheFrame[context3d, frames, frameRate];

CedarProcess.CheckAbort[];

ENDLOOP;

};

Commander.Register["ThreeDDemo", ThreeDDemoCommand, "\nDemonstrate ThreeDWorld"];

END.