<<>>
<<G3dSceneProcsImpl.mesa>>
<<Copyright Ó 1985, 1992 by Xerox Corporation. All rights reserved.>>
<<Glassner, July 5, 1990 1:48:22 pm PDT>>
<<Bloomenthal, July 15, 1992 11:31 pm PDT>>
<<>>
DIRECTORY Args, Ascii, Atom, Convert, FileNames, G3dBasic, G3dMatrix, G3dRender, G3dScene, G3dShape, G3dSweep, G3dTimeTrees, 
G3dVector, IO, Random, Real, Rope;

G3dSceneProcsImpl: CEDAR PROGRAM
IMPORTS Atom, Convert, FileNames, G3dMatrix, G3dScene, G3dShape, G3dRender, G3dTimeTrees, G3dVector, IO, Random, Real, Rope 

~ BEGIN
<<Imported Types>>
Arg:                        TYPE ~ Args.Arg;    
PropList:                    TYPE ~ Atom.PropList;
Pair:                        TYPE ~ G3dBasic.Pair;
Triple:                    TYPE ~ G3dBasic.Triple;
Matrix:                    TYPE ~ G3dMatrix.Matrix;
MatrixRep:                TYPE ~ G3dMatrix.MatrixRep;
Shape:                    TYPE ~ G3dShape.Shape;
ShapeSequence:            TYPE ~ G3dShape.ShapeSequence;
Context3d:                TYPE ~ G3dRender.Context3d;
RGB:                        TYPE ~ G3dRender.RGB;
RenderStyle:                TYPE ~ G3dRender.RenderStyle;
TextureStyle:                TYPE ~ G3dRender.TextureStyle;
ParseState:                TYPE ~ G3dScene.ParseState;
Material:                    TYPE ~ G3dScene.Material;
MaterialSequence:        TYPE ~ G3dScene.MaterialSequence;
MaterialSequenceRep:    TYPE ~ G3dScene.MaterialSequenceRep;
SceneProc:                TYPE ~ G3dScene.SceneProc;
SurfaceDescription:        TYPE ~ G3dSweep.SurfaceDescription;
SurfaceDescriptionRep:    TYPE ~ G3dSweep.SurfaceDescriptionRep;
Variable:                    TYPE ~ G3dScene.Variable;
VariableSequence:        TYPE ~ G3dScene.VariableSequence;
VariableSequenceRep:    TYPE ~ G3dScene.VariableSequenceRep;
SourceText:                TYPE ~ G3dScene.SourceText;
SourceTextRep:            TYPE ~ G3dScene.SourceTextRep;
InterpolationType:        TYPE ~ G3dTimeTrees.InterpolationType;
STREAM:                    TYPE ~ IO.STREAM;
ROPE:                        TYPE ~ Rope.ROPE;
<<Matrix Procedures>>
StartBranch: SceneProc ~ {
IF ps.inKey THEN {
G3dScene.WriteLog[ps, "ERROR: can't StartBranch from within a key definition"];
RETURN;
};
G3dTimeTrees.SetLocalTransform[ps.timeTree, ps.ctm];
G3dTimeTrees.PushTimeTree[ps.timeTree];
ps.matrixStack Ź CONS[ps.ctm, ps.matrixStack];
ps.ctm Ź G3dMatrix.Identity[];
G3dScene.WriteLog[ps, "Starting a new branch"];
ps.timeTree.activeNode.clientData Ź NEW[SourceTextRep Ź [ps.fileName, ps.index]];
};

EndBranch: SceneProc ~ {
IF ps.inKey THEN {
G3dScene.WriteLog[ps, "ERROR: can't EndBranch from within a key definition"];
RETURN;
};
G3dTimeTrees.PopTimeTree[ps.timeTree];
ps.ctm Ź ps.matrixStack.first;
ps.matrixStack Ź ps.matrixStack.rest;
ps.changes Ź Atom.PutPropOnList[ps.changes, $transform, $true];
G3dScene.WriteLog[ps, "Ending a branch"];
};

IdentityMatrix: SceneProc ~ {
ps.ctm Ź G3dMatrix.Identity[];
G3dScene.WriteLog[ps, "Current transformation set to identity"];
ps.changes Ź Atom.PutPropOnList[ps.changes, $transform, $true];
};

Translate: SceneProc ~ {
t: Triple Ź [0.0, 0.0, 0.0];
axisA, factorA, yA, zA: Arg;
[axisA, factorA, yA, zA] Ź G3dScene.GetArgs[ps, args, "%sr[rr"];
SELECT TRUE FROM
Eq[axisA.rope, "X"] => t.x Ź factorA.real;
Eq[axisA.rope, "Y"] => t.y Ź factorA.real;
Eq[axisA.rope, "Z"] => t.z Ź factorA.real;
Eq[axisA.rope, "XYZ"] => IF yA.ok AND zA.ok
THEN t Ź [factorA.real, yA.real, zA.real]
ELSE G3dScene.ParseError["Translate XYZ requires 3 arguments"];
ENDCASE => G3dScene.ParseError["Translate axis must be X, Y, Z, or XYZ"];
UpdateCtm[G3dMatrix.MakeTranslate[t], ps];
G3dScene.WriteLog[ps, IO.PutFR["Translate by (%g %g %g)", [real[t.x]],[real[t.y]],[real[t.z]]]];
};

Scale: SceneProc ~ {
t: Triple Ź [1.0, 1.0, 1.0];
axisA, factorA, yA, zA: Arg;
[axisA, factorA, yA, zA] Ź G3dScene.GetArgs[ps, args, "%sr[rr"];
SELECT TRUE FROM
Eq[axisA.rope, "X"] => t.x Ź factorA.real;
Eq[axisA.rope, "Y"] => t.y Ź factorA.real;
Eq[axisA.rope, "Z"] => t.z Ź factorA.real;
Eq[axisA.rope, "Uniform"] => t.x Ź t.y Ź t.z Ź factorA.real;
Eq[axisA.rope, "XYZ"] => IF yA.ok AND zA.ok
THEN t Ź [factorA.real, yA.real, zA.real]
ELSE G3dScene.ParseError["Scale XYZ requires 3 arguments"];
ENDCASE => G3dScene.ParseError["Scale axis must be X, Y, Z, or XYZ"];
UpdateCtm[G3dMatrix.MakeScale[t], ps];
G3dScene.WriteLog[ps, IO.PutFR["Scaling by (%g %g %g)", [real[t.x]], [real[t.y]], [real[t.z]]]];
};

Shear: SceneProc ~ {
ReplaceElementMatrix: PROC [x, y: INT, v: REAL] RETURNS [m: Matrix] ~ {
m Ź G3dMatrix.Identity[];
m[y][x] Ź v;
};
row, column: INT Ź 0;
axis1A, axis2A, factorA: Arg;
[axis1A, axis2A, factorA] Ź G3dScene.GetArgs[ps, args, "%ssr"];
row Ź SELECT TRUE FROM
Eq[axis1A.rope, "X"] => 0,
Eq[axis1A.rope, "Y"] => 1,
Eq[axis1A.rope, "Z"] => 2,
ENDCASE => G3dScene.ParseError["Shear axis must be X, Y, or Z"];
column Ź SELECT TRUE FROM
Eq[axis2A.rope, "X"] => 0,
Eq[axis2A.rope, "Y"] => 1,
Eq[axis2A.rope, "Z"] => 2,
ENDCASE => G3dScene.ParseError["Shear axis must be X, Y, or Z"];
UpdateCtm[ReplaceElementMatrix[row, column, factorA.real], ps];
G3dScene.WriteLog[ps, IO.PutFR["Shearing along axis %g with respect to axis %g by %g",
IO.rope[axis1A.rope], IO.rope[axis2A.rope], IO.real[factorA.real]]];
};

Rotate: SceneProc ~ {
axis: Triple Ź [0.0, 0.0, 0.0];
axisA, thetaA, radiansA, ccwA: Arg;
theta: REAL;
[axisA, thetaA, radiansA, ccwA] Ź G3dScene.GetArgs[ps, args, "%sr-radians%b-ccw%b"];
axis Ź SELECT TRUE FROM
Eq[axisA.rope, "X"] => [1.0, 0.0, 0.0],
Eq[axisA.rope, "Y"] => [0.0, 1.0, 0.0],
Eq[axisA.rope, "Z"] => [0.0, 0.0, 1.0],
ENDCASE => G3dScene.ParseError["Rotation axis must be X, Y, or Z"];
theta Ź thetaA.real;
IF ccwA.ok THEN theta Ź -theta;
UpdateCtm[G3dMatrix.MakeRotate[axis, theta, NOT radiansA.ok], ps];
G3dScene.WriteLog[ps, IO.PutFR["Rotating around axis (%g %g %g) by %g", IO.real[axis.x], IO.real[axis.y], IO.real[axis.z], 
IO.real[thetaA.real]]];
};

RotateAxis: SceneProc ~ {
axis: Triple Ź [0.0, 0.0, 1.0];
base: Triple Ź [0.0, 0.0, 0.0];
xA, yA, zA, tA, rA, bxA, byA, bzA: Arg;
[xA, yA, zA, tA, rA, bxA, byA, bzA] Ź
G3dScene.GetArgs[ps, args, "-axis%rrr-angle%r-radians%b-base%rrr"];
axis Ź [xA.real, yA.real, zA.real];
IF bxA.ok THEN base Ź [bxA.real, byA.real, bzA.real];
UpdateCtm[G3dMatrix.MakeRotateAbout[axis, tA.real, NOT rA.ok, base], ps];
G3dScene.WriteLog[ps, IO.PutFR["Scaling around axis (%g %g %g) by %g",
IO.real[axis.x], IO.real[axis.y], IO.real[axis.z], IO.real[tA.real]]];
};

ExplicitMatrix: SceneProc ~ {
m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33: Arg;
abs: Arg;
m: Matrix Ź G3dMatrix.Identity[];
[m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33, abs] Ź
G3dScene.GetArgs[ps, args, "%rrrrrrrrrrrrrrrr-absolute%b"];
m[0][0] Ź m00.real; m[0][1] Ź m01.real; m[0][2] Ź m02.real; m[0][3] Ź m03.real;
m[1][0] Ź m10.real; m[1][1] Ź m11.real; m[1][2] Ź m12.real; m[1][3] Ź m13.real;
m[2][0] Ź m20.real; m[2][1] Ź m21.real; m[2][2] Ź m22.real; m[2][3] Ź m23.real;
m[3][0] Ź m30.real; m[3][1] Ź m31.real; m[3][2] Ź m32.real; m[3][3] Ź m33.real;
IF abs.ok THEN ps.ctm Ź G3dMatrix.Identity[];
UpdateCtm[m, ps]; 
G3dScene.WriteLog[ps, "Appended absolute matrix to current transformation"];
};

UpdateCtm: PROC [m: Matrix, ps: ParseState] ~ {
ps.ctm Ź G3dMatrix.Mul[m, ps.ctm];
ps.changes Ź Atom.PutPropOnList[ps.changes, $transform, $true];
};
<<Material Procedures>>
SaveMaterial: SceneProc ~ {
name: ROPE Ź GetRope[ps, args];
ps.materials Ź AddToMaterialSequence[ps.materials, ps.currentMaterial];
ps.materials[ps.materials.length-1].name Ź name;
G3dScene.WriteLog[ps, IO.PutFR["Saved material %g", IO.rope[name]]];
};

UseMaterial: SceneProc ~ {
name: ROPE Ź GetRope[ps, args];
FOR i: INT IN [0..ps.materials.length) DO 
IF NOT Eq[name, ps.materials[i].name] THEN LOOP;
ps.currentMaterial Ź ps.materials[i];
G3dScene.WriteLog[ps, IO.PutFR["Using material %g", IO.rope[ps.currentMaterial.name]]];
EXIT;
ENDLOOP;
G3dScene.WriteLog[ps, IO.PutFR["Could not retrieve material %g", IO.rope[name]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $diffuse, $true];
ps.changes Ź Atom.PutPropOnList[ps.changes, $specular, $true];
ps.changes Ź Atom.PutPropOnList[ps.changes, $metallicity, $true];
ps.changes Ź Atom.PutPropOnList[ps.changes, $shininess, $true];
ps.changes Ź Atom.PutPropOnList[ps.changes, $transmittance, $true];
ps.changes Ź Atom.PutPropOnList[ps.changes, $color, $true];
};

MaterialBackFacesVisible: SceneProc ~ {
b: BOOL Ź ps.currentMaterial.backFaces Ź Convert.BoolFromRope[GetRope[ps, args]];
G3dScene.WriteLog[ps, IO.PutFR["Back faces visible: %g", IO.bool[b]]];
};

MaterialRenderStyle: SceneProc ~ {
style: ROPE Ź GetRope[ps, args];
ps.currentMaterial.renderStyle Ź SELECT TRUE FROM
Eq[style, "default"], Eq[style, "faceted"] => faceted,
Eq[style, "smooth"] => smooth,
Eq[style, "lines"] => lines,
Eq[style, "shadedLines"] => shadedLines,
Eq[style, "hiddenLines"] => hiddenLines,
Eq[style, "linesWnormals"] => linesWnormals,
Eq[style, "controlPoints"] => controlPoints,
ENDCASE => G3dScene.ParseError["no such render style"];
G3dScene.WriteLog[ps, Rope.Cat["Material render style set to: ", style]];
};

MaterialColor: SceneProc ~ {
t: Triple;
rA, gA, bA, scaleA: Arg;
[rA, gA, bA, scaleA] Ź G3dScene.GetArgs[ps, args, "%rrr-scale%b"];
t Ź [rA.real, gA.real, bA.real];
ps.currentMaterial.color Ź IF scaleA.ok 
THEN G3dVector.MulVectors[ps.currentMaterial.color, t] ELSE t;
G3dScene.WriteLog[ps, IO.PutFR["Color set to (%g, %g, %g)", [real[t.x]],[real[t.y]],[real[t.z]]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $color, $true];
};

MaterialDiffuse: SceneProc ~ {
sA, scaleA: Arg;
[sA, scaleA] Ź G3dScene.GetArgs[ps, args, "%r-scale%b"];
ps.currentMaterial.diffuseReflectivity Ź
IF scaleA.ok THEN ps.currentMaterial.diffuseReflectivity*sA.real ELSE sA.real;
G3dScene.WriteLog[ps, IO.PutFR["Diffuse Reflectivity set to %g", IO.real[ps.currentMaterial.diffuseReflectivity]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $diffuse, $true];
};

MaterialSpecular: SceneProc ~ {
sA, scaleA: Arg;
[sA, scaleA] Ź G3dScene.GetArgs[ps, args, "%r-scale%b"];
ps.currentMaterial.specularReflectivity Ź
IF scaleA.ok THEN ps.currentMaterial.specularReflectivity*sA.real ELSE sA.real;
G3dScene.WriteLog[ps, IO.PutFR["Specular Reflectivity set to %g", IO.real[ps.currentMaterial.specularReflectivity]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $specular, $true];
};

MaterialMetallicity: SceneProc ~ {
sA, scaleA: Arg;
[sA, scaleA] Ź G3dScene.GetArgs[ps, args, "%r-scale%b"];
ps.currentMaterial.metallicity Ź
IF scaleA.ok THEN ps.currentMaterial.metallicity*sA.real ELSE sA.real;
G3dScene.WriteLog[ps, IO.PutFR["Metallicity set to %g", IO.real[ps.currentMaterial.metallicity]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $metallicity, $true];
};

MaterialShininess: SceneProc ~ {
sA, scaleA: Arg;
[sA, scaleA] Ź G3dScene.GetArgs[ps, args, "%r-scale%b"];
ps.currentMaterial.shininess Ź
IF scaleA.ok THEN ps.currentMaterial.shininess*sA.real ELSE sA.real;
G3dScene.WriteLog[ps, IO.PutFR["Shininess set to %g", IO.real[ps.currentMaterial.shininess]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $shininess, $true];
};

MaterialTransmittance: SceneProc ~ {
sA, scaleA: Arg;
[sA, scaleA] Ź G3dScene.GetArgs[ps, args, "%r-scale%b"];
ps.currentMaterial.transmittance Ź IF scaleA.ok 
THEN ps.currentMaterial.transmittance*sA.real ELSE sA.real;
G3dScene.WriteLog[ps, IO.PutFR["Transmittance set to %g", IO.real[ps.currentMaterial.transmittance]]];
ps.changes Ź Atom.PutPropOnList[ps.changes, $transmittance, $true];
};

MaterialVisible: SceneProc ~ {
b: BOOL Ź ps.currentMaterial.visible Ź Convert.BoolFromRope[GetRope[ps, args]];
G3dScene.WriteLog[ps, IO.PutFR["Material visibility: %g", IO.bool[b]]];
};
<<Context3d Procedures>>
AddProperty: SceneProc ~ {
in: IO.STREAM Ź IO.RIS[args];
G3dScene.WriteLog[ps, "Adding property"];
ps.context3d.props Ź Atom.PutPropOnList[ps.context3d.props,IO.GetRefAny[in],IO.GetRefAny[in]];
};
<<Rendering Procedures>>
Render: SceneProc ~ {
error: ROPE;
G3dScene.WriteLog[ps, "Render"];
G3dTimeTrees.ReportTimeTree[ps.timeTree];
error Ź G3dRender.Render[ps.context3d, NIL, FALSE];
IF error # NIL THEN G3dScene.WriteLog[ps, error];
};

AntiAliasing: SceneProc ~ {
in: STREAM Ź IO.RIS[args];
Skip[in];
G3dScene.WriteLog[ps, "Anti aliasing set"];
G3dRender.SetAntiAliasing[ps.context3d, IO.GetBool[in]];
};

DisplayMode: SceneProc ~ {
mode: ROPE Ź GetRope[ps, args];
G3dScene.WriteLog[ps, Rope.Cat["Set display mode: ", mode]];
<<G3dRender.LoadDisplayClass[ps.context3d, SELECT TRUE FROM Eq[mode, "fullColor"] => $FullColor, Eq[mode, "dither"] => 
$PseudoColor, ENDCASE => $Gray];>>
};

DepthBuffering: SceneProc ~ {
in: STREAM Ź IO.RIS[args];
Skip[in];
G3dScene.WriteLog[ps, "Depth Buffering set"];
<<G3dRenderWithPixels.DepthBuffering[ps.context3d, IO.GetBool[in]];>>
};

NormalCoding: SceneProc ~ {
in: STREAM Ź IO.RIS[args];
Skip[in];
G3dScene.WriteLog[ps, "Depth Buffering set"];
<<G3dRenderWithPixels.NormalBuffering[ps.context3d, IO.GetBool[in]];>>
};

DisplayRegion: SceneProc ~ {
xy: Pair Ź GetPair[ps, args];
wh: Pair Ź GetPair[ps, args];
G3dScene.WriteLog[ps, IO.PutFR["DisplayRegion: [%g, %g, %g, %g]",
IO.real[xy.x], IO.real[xy.y], IO.real[wh.x], IO.real[wh.y]]];
G3dRender.SetWindow[ps.context3d, [xy.x, xy.y, wh.x, wh.y]];
};

Viewport: SceneProc ~ {
xy: Pair Ź GetPair[ps, args];
wh: Pair Ź GetPair[ps, args];
G3dScene.WriteLog[ps, IO.PutFR["Viewport: [%g, %g, %g, %g]",
IO.real[xy.x], IO.real[xy.y], IO.real[wh.x], IO.real[wh.y]]];
G3dRender.SetViewport[ps.context3d, [xy.x, xy.y, wh.x, wh.y]];
};
<<Backgound Procedures>>
BackgroundColor: SceneProc ~ {
t: Triple Ź GetTriple[ps, args];
G3dScene.WriteLog[ps, IO.PutFR["Background: (%g, %g, %g)",
[real[t.x]], [real[t.y]], [real[t.z]]]];
G3dRender.SetBackgroundColor[ps.context3d, [t.x, t.y, t.z]];
};

BackgroundImage: SceneProc ~ {
name: ROPE Ź GetRope[ps, args];
G3dScene.WriteLog[ps, Rope.Cat["Background image: ", name]];
G3dRender.SetBackgroundImage[ps.context3d, name];
};

EnableBackground: SceneProc ~ {
G3dScene.WriteLog[ps, "EnableBackground set"];
G3dRender.EnableClear[ps.context3d, IO.GetBool[IO.RIS[args]]];
};
<<Camera Procedures>>
UpdateCamera: SceneProc ~ {
AddRealToMsg: PROC [r: REAL] ~ {msg Ź Rope.Cat[msg, IO.PutFR["%g", IO.real[r]]]};
AddTripleToMsg: PROC [t: Triple] ~ {
msg Ź Rope.Cat[msg, IO.PutFR["(%g, %g, %g)", [real[t.x]], [real[t.y]], [real[t.z]]]];
};
msg: ROPE Ź IO.PutFR["Set camera %g: ", IO.refAny[data]];
ps.shouldRepaint Ź TRUE;
SELECT data FROM
$FieldOfView => AddRealToMsg[ps.context3d.fieldOfView Ź GetReal[ps, args]];
$Roll => AddRealToMsg[ps.context3d.rollAngle Ź GetReal[ps, args]];
ENDCASE => {
t: Triple Ź GetTriple[ps, args];
AddTripleToMsg[t];
SELECT data FROM
$EyePoint    => ps.context3d.eyePoint Ź t;
$LookAt        => ps.context3d.lookAt Ź t;
$Up            => ps.context3d.upDirection Ź t;
ENDCASE;
};
G3dScene.WriteLog[ps, msg];
};
<<Shape Procedures>>
ReadShape: SceneProc ~ {
name, instanceName: ROPE Ź NIL;
nameA, instanceNameA: Arg;
[nameA, instanceNameA] Ź G3dScene.GetArgs[ps, args, "%s[s"];
name Ź nameA.rope;
IF instanceNameA.ok THEN instanceName Ź instanceNameA.rope;
IF instanceName = NIL THEN {
index: INT Ź IF ps.context3d.shapes # NIL THEN ps.context3d.shapes.length ELSE 0;
instanceName Ź IO.PutFR["%g.%g", IO.rope[FileNames.GetShortName[name]], IO.int[index]];
};
IF Rope.Find[name, "/"] = -1 AND Rope.Find[name, ">"] = -1
THEN name Ź Rope.Cat[ps.directory, name];
G3dRender.AddShapeFromFile[ps.context3d, instanceName, name
! G3dShape.Error => G3dScene.ParseError[reason]];
ps.currentShape Ź ps.context3d.shapes[ps.context3d.shapes.length-1];
G3dScene.AssignCtmToShape[ps, ps.currentShape];
G3dScene.InheritMaterial[ps];
G3dScene.WriteLog[ps, Rope.Cat["Read shape: ", name, " [", instanceName, "]"]];
};

WriteShape: SceneProc ~ {
fileName: ROPE;
shapes: ShapeSequence Ź ps.context3d.shapes;
shapeNameA, fileNameA, transformA: Arg;
[shapeNameA, fileNameA, transformA] Ź G3dScene.GetArgs[ps, args, "%s-fileName%s-transform%b"];
fileName Ź IF fileNameA.ok THEN fileNameA.rope ELSE Rope.Cat[shapeNameA.rope, ".shape"];
FOR i: NAT IN [0..shapes.length) DO
shape: Shape Ź shapes[i];
IF NOT Eq[shape.name, shapeNameA.rope] THEN LOOP;
shape Ź G3dShape.CopyShape[shapes[i]];
IF transformA.ok THEN G3dShape.TransformVertices[shape, shape.matrix];
G3dShape.ShapeToFile[fileName, shape, TRUE, FALSE, "shape written from context3d"];
EXIT;
ENDLOOP;
G3dScene.WriteLog[ps, Rope.Cat["Wrote shape ", shapeNameA.rope, " to file ", fileName]];
};

WriteAllShapes: SceneProc ~ {
shapes: ShapeSequence Ź ps.context3d.shapes;
FOR i: NAT IN [0..shapes.length) DO
fileName: ROPE Ź Rope.Cat[ps.directory, shapes[i].name];
shape: Shape Ź G3dShape.CopyShape[shapes[i]];
shape.matrix Ź shapes[i].matrix;
G3dShape.TransformVertices[shape, shape.matrix];
G3dShape.UnitizeVertexNormals[shape];
G3dShape.ShapeToFile[fileName, shape, TRUE, FALSE, "shape written from context3d"];
ENDLOOP;
G3dScene.WriteLog[ps, "Wrote all shapes to files"];
};

DeleteShape: SceneProc ~ {
shapeName: ROPE Ź GetRope[ps, args];
G3dRender.DeleteShape[ps.context3d, shapeName];
};

DeleteAllShapes: SceneProc ~ {
G3dRender.DeleteAllShapes[ps.context3d];
};
<<Shape Processing>>
InvertNormals: SceneProc ~ {
IF ps.currentShape # NIL THEN {
G3dScene.WriteLog[ps, Rope.Cat["Negate normals of ", ps.currentShape.name]];
G3dShape.NegateVertexNormals[ps.currentShape];
};
};

Triangulate: SceneProc ~ {
G3dScene.WriteLog[ps, Rope.Cat["Triangulate shape: ", ps.currentShape.name]];
G3dShape.Triangulate[ps.currentShape];
};

ReversePolygons: SceneProc ~ {
G3dScene.WriteLog[ps, Rope.Cat["Reverse polygons of ", ps.currentShape.name]];
G3dShape.ReversePolygons[ps.currentShape];
};

OpenContours: SceneProc ~ {
sd: SurfaceDescription Ź NEW[SurfaceDescriptionRep Ź []];
sd.open Ź TRUE;
FOR i: INT IN [0 .. ps.currentShape.surfaces.length) DO
ps.currentShape.surfaces[i].clientData Ź sd;
ENDLOOP;
G3dScene.WriteLog[ps, Rope.Cat["Making an open surface of ", ps.currentShape.name]];
};

AddAxes: SceneProc ~ {
nReticles: NAT Ź 20;
size: REAL Ź 1.0;
scale: Triple Ź [1, 1, 1];
origin: Triple Ź [0, 0, 0];
x, y, z, s, sx, sy, sz, n: Arg;
[x, y, z, s, sx, sy, sz, n] Ź
G3dScene.GetArgs[ps, args, "-origin%rrr-size%r-scale%rrr-nReticles%i"];
IF x.ok AND y.ok AND z.ok THEN origin Ź [x.real, y.real, z.real];
IF sx.ok AND sy.ok AND sz.ok THEN scale Ź [sx.real, sy.real, sz.real];
IF s.ok THEN size Ź s.real;
IF n.ok THEN nReticles Ź n.int;
G3dScene.WriteLog[ps, "Adding axes"];
G3dRender.AddAxes[ps.context3d, origin, size, scale, nReticles];
};
<<Texturing Procedures>>
SetTexture: SceneProc ~ {
typeA, filenameA: Arg;
[typeA, filenameA] Ź G3dScene.GetArgs[ps, args, "%ss"];
SELECT TRUE FROM
Eq[typeA.rope, "intensity"] => ps.currentMaterial.textureIntensityName Ź filenameA.rope;
Eq[typeA.rope, "color"] => ps.currentMaterial.textureColorName Ź filenameA.rope;
Eq[typeA.rope, "bump"] => ps.currentMaterial.textureBumpName Ź filenameA.rope;
ENDCASE => G3dScene.ParseError["Texture type must be intensity, color, or bump"];
G3dScene.WriteLog[ps, Rope.Cat["Enabled texture of type ", typeA.rope, " from file ", filenameA.rope]];
};

DisableAllTextures: SceneProc ~ {
ps.currentMaterial.textureIntensityName Ź NIL;
ps.currentMaterial.textureColorName Ź NIL;
ps.currentMaterial.textureBumpName Ź NIL;
G3dScene.WriteLog[ps, "Disabled all textures"];
};

DisableTexture: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
SELECT TRUE FROM
Eq[type, "intensity"] => ps.currentMaterial.textureIntensityName Ź NIL;
Eq[type, "color"] => ps.currentMaterial.textureColorName Ź NIL;
Eq[type, "bump"] => ps.currentMaterial.textureBumpName Ź NIL;
ENDCASE => G3dScene.ParseError["Texture type must be intensity, color, or bump"];
G3dScene.WriteLog[ps, Rope.Concat["Disabled texture of type ", type]];
};

OffsetTexture: SceneProc ~ {
p: Pair Ź ps.currentMaterial.textureOffset Ź GetPair[ps, args];
G3dScene.WriteLog[ps, IO.PutFR["Set texture offset to %g %g", [real[p.x]], [real[p.y]]]];
};

ScaleTexture: SceneProc ~ {
p: Pair Ź ps.currentMaterial.textureScale Ź GetPair[ps, args];
G3dScene.WriteLog[ps, IO.PutFR["Set texture scale to %g %g", [real[p.x]], [real[p.y]]]];
};

ScaleBumps: SceneProc ~ {
scale: REAL Ź Convert.RealFromRope[GetRope[ps, args]];
ps.currentMaterial.bumpScale Ź scale;
G3dScene.WriteLog[ps, IO.PutFR["Set bump scale to %g", IO.real[scale]]];
};

FilterTexture: SceneProc ~ {
b: BOOL Ź ps.currentMaterial.textureFiltering Ź Convert.BoolFromRope[GetRope[ps, args]];
G3dScene.WriteLog[ps, IO.PutFR["Texture filtering set to %b", IO.bool[b]]];
};
<<Lighting Procedures>>
AmbientLight: SceneProc ~ {                    
t: Triple Ź GetTriple[ps, args];
G3dRender.SetAmbientLight[ps.context3d, [t.x, t.y, t.z]];
G3dScene.WriteLog[ps, IO.PutFR["Ambient light set to (%g %g %g)",
IO.real[t.x], IO.real[t.y], IO.real[t.z]]];
};

AddLight: SceneProc ~ {
AutoLightName: PROC [context3d: Context3d, type: ROPE] RETURNS [ROPE] ~ {
index: INT Ź IF context3d.lightSources = NIL THEN 0 ELSE context3d.lightSources.length;
RETURN[IO.PutFR["%g%g", IO.rope[type], IO.int[index]]];
};
name: ROPE Ź AutoLightName[ps.context3d, "AutoLight"];
nameA, xA, yA, zA, rA, gA, bA: Arg;
rgb: RGB Ź [1.0, 1.0, 1.0];
[xA, yA, zA, rA, gA, bA, nameA] Ź G3dScene.GetArgs[ps, args, "-position%rrr-color%rrr-name%s"];
IF nameA.ok THEN name Ź nameA.rope;
IF rA.ok THEN rgb Ź [rA.real, gA.real, bA.real];
IF xA.ok AND rA.ok
THEN G3dRender.AddLight[ps.context3d, name, [xA.real, yA.real, zA.real], rgb];
G3dScene.WriteLog[ps, IO.PutFLR["Light %g placed at (%g %g %g) with color (%g %g %g)",
LIST[IO.rope[name], IO.real[xA.real], IO.real[yA.real], IO.real[zA.real],
IO.real[rgb.R], IO.real[rgb.G], IO.real[rgb.B]]]];
};
<<Variable Procedures>>
SetVariable: SceneProc ~ {
Translate: Rope.TranslatorType ~ {RETURN[IF old = '\t THEN '  ELSE old]};
v: Variable;
cleanArgs: ROPE Ź Rope.Translate[StripLeadingBlanks[args],,, Translate];
endOfName: INT Ź Rope.Find[cleanArgs, " "];
IF endOfName < 0 THEN RETURN;
v.name Ź Rope.Substr[cleanArgs, 0, endOfName];
v.value Ź Rope.Substr[cleanArgs, endOfName+1]; 
<<v.value _ G3dScene.SubstituteVariables[ps.variables, v.value];>>
IF ps.variables = NIL THEN {
ps.variables Ź AddToVariableSequence[NIL, v];
RETURN;
};
FOR i: INT IN [0..ps.variables.length) DO
IF NOT Eq[ps.variables[i].name, v.name] THEN LOOP;
ps.variables[i].value Ź v.value;
RETURN;
ENDLOOP;
ps.variables Ź AddToVariableSequence[ps.variables, v];
G3dScene.WriteLog[ps, IO.PutFR["Set variable <%g> to value <%g>",
IO.rope[v.name], IO.rope[v.value]]];
};

UnSetVariable: SceneProc ~ {
key: ROPE Ź GetRope[ps, args];
IF ps.variables # NIL AND ps.variables.length > 0 THEN
FOR i: INT IN [0..ps.variables.length) DO
IF NOT Eq[ps.variables[i].name, key] THEN LOOP;
FOR j: INT IN [i+1..ps.variables.length) DO ps.variables[j-1] Ź ps.variables[j]; ENDLOOP;
ps.variables.length Ź ps.variables.length-1;
EXIT;
ENDLOOP;
G3dScene.WriteLog[ps, Rope.Cat["Unset variable <", key, ">"]];
};

RandomSeed: SceneProc ~ {
seed: INT Ź GetInt[ps, args];
ps.randomStream Ź Random.Create[0, seed];
};
<<Animation Procedures>>
LockNode: SceneProc ~ {
G3dTimeTrees.LockActiveNode[ps.timeTree];
};

UnlockNode: SceneProc ~ {
G3dTimeTrees.UnlockActiveNode[ps.timeTree];
};

GetInterpolationType: PROC [r: ROPE] RETURNS [InterpolationType] ~ {
SELECT TRUE FROM
Rope.Equal[r, "constant", FALSE] => RETURN[constant];
Rope.Equal[r, "linear", FALSE] => RETURN[linear];
Rope.Equal[r, "smooth", FALSE] => RETURN[smooth];
ENDCASE => RETURN[smooth];
};

DiffuseInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetDiffuseInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

SpecularInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetSpecularInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

MetallicityInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetMetallicityInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

ShininessInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetShininessInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

TransmittanceInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetTransmittanceInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

ColorInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetColorInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

TransformInterpolation: SceneProc ~ {
type: ROPE Ź GetRope[ps, args];
G3dTimeTrees.SetTransformInterpolationType[ps.timeTree, GetInterpolationType[type]];
};

StartKeys: SceneProc ~ {
IF ps.inKey THEN {
G3dScene.WriteLog[ps, "ERROR: can't StartKey from within a key definition"];
RETURN;
};
<<G3dScene.MakeTransformNode[ps];>>
ps.inKey Ź TRUE;
ps.ctm Ź G3dMatrix.Identity[];
ps.changes Ź NIL;
};

EndKeys: SceneProc ~ {
<<G3dScene.MakeKeysNode[ps];>>
ps.inKey Ź FALSE;
ps.changes Ź NIL;
ps.ctm Ź G3dMatrix.Identity[];
};

Time: SceneProc ~ {
time: REAL Ź GetReal[ps, args];
<<attach the relevant information to the timeTree, based on changes field in ps>>

IF Atom.GetPropFromList[ps.changes, $diffuse] # NIL THEN
G3dTimeTrees.AssignDiffuse[ps.timeTree, time, ps.currentMaterial.diffuseReflectivity];

IF Atom.GetPropFromList[ps.changes, $specular] # NIL THEN
G3dTimeTrees.AssignSpecular[ps.timeTree, time, ps.currentMaterial.specularReflectivity];

IF Atom.GetPropFromList[ps.changes, $metallicity] # NIL THEN
G3dTimeTrees.AssignMetallicity[ps.timeTree, time, ps.currentMaterial.metallicity];

IF Atom.GetPropFromList[ps.changes, $shininess] # NIL THEN
G3dTimeTrees.AssignShininess[ps.timeTree, time, ps.currentMaterial.shininess];

IF Atom.GetPropFromList[ps.changes, $transmittance] # NIL THEN
G3dTimeTrees.AssignTransmittance[ps.timeTree, time, ps.currentMaterial.transmittance];

IF Atom.GetPropFromList[ps.changes, $color] # NIL THEN
G3dTimeTrees.AssignColor[ps.timeTree, time, ps.currentMaterial.color];

IF Atom.GetPropFromList[ps.changes, $transform] # NIL THEN
G3dTimeTrees.AssignTransform[ps.timeTree, time, ps.ctm];
};

StrobeScene: SceneProc ~ {
time: REAL Ź GetReal[ps, args];
G3dTimeTrees.StrobeTimeTree[ps.timeTree, time];
};
<<Support Procedures>>
Skip: PROC [in: STREAM] ~ {
DO
c: CHAR Ź IO.PeekChar[in]; 
IF c=') OR c='( OR c=': OR c=', OR c=Ascii.SP OR c='\t THEN [] Ź IO.GetChar[in] ELSE EXIT;
ENDLOOP;
};

RealFromStream: PROC [in: STREAM] RETURNS [r: REAL] ~ {Skip[in]; r Ź IO.GetReal[in]};

IntFromStream: PROC [in: STREAM] RETURNS [i: INT] ~ {Skip[in]; i Ź IO.GetInt[in]};

GetInt: PROC [ps: ParseState, args: ROPE] RETURNS [i: INT] ~ {
i Ź IntFromStream[IO.RIS[G3dScene.SubstituteVariables[ps.variables, args]]];
};

GetReal: PROC [ps: ParseState, args: ROPE] RETURNS [r: REAL] ~ {
r Ź RealFromStream[IO.RIS[G3dScene.SubstituteVariables[ps.variables, args]]];
};

GetPair: PROC [ps: ParseState, args: ROPE] RETURNS [p: Pair] ~ {
in: STREAM Ź IO.RIS[G3dScene.SubstituteVariables[ps.variables, args]];
p.x Ź RealFromStream[in]; p.y Ź RealFromStream[in];
};

GetTriple: PROC [ps: ParseState, args: ROPE] RETURNS [t: Triple] ~ {
in: STREAM Ź IO.RIS[G3dScene.SubstituteVariables[ps.variables, args]];
t.x Ź RealFromStream[in]; t.y Ź RealFromStream[in]; t.z Ź RealFromStream[in];
};

GetRope: PROC [ps: ParseState, args: ROPE] RETURNS [r: ROPE] ~ {
in: STREAM Ź IO.RIS[G3dScene.SubstituteVariables[ps.variables, args]];
Skip[in];
r Ź IO.GetTokenRope[in, IO.IDProc].token;
};

StripLeadingBlanks: PROC [input: ROPE] RETURNS [ROPE] ~ {
RETURN[Rope.Substr[input, IO.SkipWhitespace[IO.RIS[input]]]];
};

Eq: PROC [r1, r2: ROPE] RETURNS [b: BOOL] ~ {b Ź Rope.Equal[r1, r2, FALSE]};
<<Sequence Support>>
AddToVariableSequence: PROC [variables: VariableSequence, variable: Variable]
RETURNS [VariableSequence] ~ {
IF variables = NIL THEN variables Ź NEW[VariableSequenceRep[1]];
IF variables.length = variables.maxLength THEN variables Ź LengthenVariables[variables];
variables[variables.length] Ź variable;
variables.length Ź variables.length+1;
RETURN[variables];
};
<<>>
LengthenVariables: PROC [variables: VariableSequence, amount: REAL Ź 1.3]
RETURNS [new: VariableSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*variables.maxLength], 3];
new Ź NEW[VariableSequenceRep[newLength]];
FOR i: NAT IN [0..variables.length) DO new[i] Ź variables[i]; ENDLOOP;
new.length Ź variables.length;
};

AddToMaterialSequence: PROC [materials: MaterialSequence, material: Material]
RETURNS [MaterialSequence] ~ {
IF materials = NIL THEN materials Ź NEW[MaterialSequenceRep[1]];
IF materials.length = materials.maxLength THEN materials Ź LengthenMaterials[materials];
materials[materials.length] Ź material;
materials.length Ź materials.length+1;
RETURN[materials];
};
<<>>
LengthenMaterials: PROC [materials: MaterialSequence, amount: REAL Ź 1.3]
RETURNS [new: MaterialSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*materials.maxLength], 3];
new Ź NEW[MaterialSequenceRep[newLength]];
FOR i: NAT IN [0..materials.length) DO new[i] Ź materials[i]; ENDLOOP;
new.length Ź materials.length;
};
<<Initialization>>
RegisterProcs: PROC ~ {
<<matrix stack control        >>
G3dScene.RegisterProc["Identity",                            IdentityMatrix];
G3dScene.RegisterProc["StartBranch",                        StartBranch];
G3dScene.RegisterProc["{",                                    StartBranch];
G3dScene.RegisterProc["EndBranch",                        EndBranch];
G3dScene.RegisterProc["}",                                    EndBranch];
<<translation>>
G3dScene.RegisterProc["Translate",                        Translate];
G3dScene.RegisterProc["T",                                    Translate];
<<scaling>>
G3dScene.RegisterProc["Scale",                                Scale];
G3dScene.RegisterProc["S",                                    Scale];
<<shearing>>
G3dScene.RegisterProc["Shear",                            Shear];
<<rotation>>
G3dScene.RegisterProc["Rotate",                            Rotate];
G3dScene.RegisterProc["R",                                    Rotate];
G3dScene.RegisterProc["RotateAxis",                        RotateAxis];
<<experts>>
G3dScene.RegisterProc["ExplicitMatrix",                    ExplicitMatrix];
<<lighting control>>
G3dScene.RegisterProc["AmbientLight",                    AmbientLight];
G3dScene.RegisterProc["AddLight",                        AddLight];
<<context3d>>
G3dScene.RegisterProc["AddProperty",                    AddProperty];
<<rendering>>
G3dScene.RegisterProc["Render", Render];
G3dScene.RegisterProc["AntiAliasing",                    AntiAliasing];
G3dScene.RegisterProc["DisplayMode",                    DisplayMode];
G3dScene.RegisterProc["DepthBuffering",                    DepthBuffering];
G3dScene.RegisterProc["NormalCoding",                    NormalCoding];
G3dScene.RegisterProc["DisplayRegion",                    DisplayRegion];
G3dScene.RegisterProc["Viewport",                        Viewport];
<<background>>
G3dScene.RegisterProc["BackgroundColor",                BackgroundColor];
G3dScene.RegisterProc["BackgroundImage",                BackgroundImage];
G3dScene.RegisterProc["EnableBackground",                EnableBackground];
<<camera>>
G3dScene.RegisterProc["FieldOfView",                    UpdateCamera, $FieldOfView];
G3dScene.RegisterProc["EyePoint",                        UpdateCamera, $EyePoint];
G3dScene.RegisterProc["LookAt",                            UpdateCamera, $LookAt];
G3dScene.RegisterProc["Up",                                UpdateCamera, $Up];
G3dScene.RegisterProc["Roll",                                UpdateCamera, $Roll];
<<shape io>>
G3dScene.RegisterProc["ReadShape",                        ReadShape];
G3dScene.RegisterProc["WriteShape",                        WriteShape];
G3dScene.RegisterProc["WriteAllShapes",                    WriteAllShapes];
G3dScene.RegisterProc["DeleteShape",                        DeleteShape];
G3dScene.RegisterProc["DeleteAllShapes",                DeleteAllShapes];
<<shapes>>
G3dScene.RegisterProc["InvertNormals",                    InvertNormals];
G3dScene.RegisterProc["Triangulate",                        Triangulate];
G3dScene.RegisterProc["ReversePolygons",                ReversePolygons];
G3dScene.RegisterProc["OpenContours",                    OpenContours];
G3dScene.RegisterProc["AddAxes",                        AddAxes];
<<materials>>
G3dScene.RegisterProc["SaveMaterial",                    SaveMaterial];
G3dScene.RegisterProc["UseMaterial",                        UseMaterial];
G3dScene.RegisterProc["BackFacesVisible",                MaterialBackFacesVisible];
G3dScene.RegisterProc["RenderStyle",                        MaterialRenderStyle];
G3dScene.RegisterProc["Color",                                MaterialColor];
G3dScene.RegisterProc["Diffuse",                            MaterialDiffuse];
G3dScene.RegisterProc["Specular",                            MaterialSpecular];
G3dScene.RegisterProc["Metallicity",                        MaterialMetallicity];
G3dScene.RegisterProc["Shininess",                        MaterialShininess];
G3dScene.RegisterProc["Transmittance",                    MaterialTransmittance];
G3dScene.RegisterProc["Visible",                            MaterialVisible];
<<texturing>>
G3dScene.RegisterProc["OffsetTexture",                    OffsetTexture];
G3dScene.RegisterProc["ScaleTexture",                    ScaleTexture];
G3dScene.RegisterProc["ScaleBumps",                        ScaleBumps];
G3dScene.RegisterProc["FilterTexture",                    FilterTexture];
G3dScene.RegisterProc["SetTexture",                        SetTexture];
G3dScene.RegisterProc["DisableTexture",                    DisableTexture];
G3dScene.RegisterProc["DisableAllTextures",                DisableAllTextures];
<<variables>>
G3dScene.RegisterProc["Set",                                SetVariable];
G3dScene.RegisterProc["UnSet",                            UnSetVariable];
G3dScene.RegisterProc["RandomSeed",                        RandomSeed];
<<animation>>
G3dScene.RegisterProc["StartKeys",                        StartKeys];
G3dScene.RegisterProc["EndKeys",                        EndKeys];
G3dScene.RegisterProc["Time",                                Time];
G3dScene.RegisterProc["StrobeScene",                        StrobeScene];
G3dScene.RegisterProc["DiffuseInterpolation",            DiffuseInterpolation];
G3dScene.RegisterProc["SpecularInterpolation",            SpecularInterpolation];
G3dScene.RegisterProc["MetallicityInterpolation",        MetallicityInterpolation];
G3dScene.RegisterProc["ShininessInterpolation",            ShininessInterpolation];
G3dScene.RegisterProc["TransmittanceInterpolation",    TransmittanceInterpolation];
G3dScene.RegisterProc["ColorInterpolation",                ColorInterpolation];
G3dScene.RegisterProc["TransformInterpolation",            TransformInterpolation];
G3dScene.RegisterProc["LockNode",                        LockNode];
G3dScene.RegisterProc["UnlockNode",                        UnlockNode];
};
<<Start Procedures>>
RegisterProcs[];

END.
..