<<>> <> <> <> <> <> <> DIRECTORY Args, Ascii, Atom, CedarProcess, Commander, CommanderOps, FileNames, G3dBasic, G3dLight, G3dMatrix, G3dRender, G3dScene, G3dShape, G3dTimeTrees, IO, MessageWindow, PFS, Random, Real, RealFns, Rope, TiogaAccess, TiogaOps, ViewerOps, ViewerTools; G3dSceneImpl: CEDAR PROGRAM IMPORTS Args, Atom, CedarProcess, CommanderOps, FileNames, G3dMatrix, G3dRender, G3dTimeTrees, IO, MessageWindow, PFS, Random, Real, RealFns, Rope, TiogaOps, ViewerOps, ViewerTools EXPORTS G3dScene ~ BEGIN <> Arg: TYPE ~ Args.Arg; NatSequence: TYPE ~ G3dBasic.NatSequence; SurfaceSequence: TYPE ~ G3dBasic.SurfaceSequence; Pair: TYPE ~ G3dBasic.Pair; Triple: TYPE ~ G3dBasic.Triple; Light: TYPE ~ G3dLight.Light; RGB: TYPE ~ G3dRender.RGB; Context3d: TYPE ~ G3dRender.Context3d; RenderData: TYPE ~ G3dRender.RenderData; RenderStyle: TYPE ~ G3dRender.RenderStyle; TextureStyle: TYPE ~ G3dRender.TextureStyle; LogProc: TYPE ~ G3dScene.LogProc; Material: TYPE ~ G3dScene.Material; ParseState: TYPE ~ G3dScene.ParseState; ParseStateRep: TYPE ~ G3dScene.ParseStateRep; Registry: TYPE ~ G3dScene.Registry; Variable: TYPE ~ G3dScene.Variable; VariableSequence: TYPE ~ G3dScene.VariableSequence; VariableSequenceRep: TYPE ~ G3dScene.VariableSequenceRep; SceneProc: TYPE ~ G3dScene.SceneProc; Shape: TYPE ~ G3dShape.Shape; ShapeRep: TYPE ~ G3dShape.ShapeRep; ShapeSequence: TYPE ~ G3dShape.ShapeSequence; VertexSequenceRep: TYPE ~ G3dShape.VertexSequenceRep; TimeTree: TYPE ~ G3dTimeTrees.TimeTree; STREAM: TYPE ~ IO.STREAM; RandomStream: TYPE ~ Random.RandomStream; ROPE: TYPE ~ Rope.ROPE; Writer: TYPE ~ TiogaAccess.Writer; SelPos: TYPE ~ ViewerTools.SelPos; Viewer: TYPE ~ ViewerTools.Viewer; SourceText: TYPE ~ G3dScene.SourceText; SourceTextRep: TYPE ~ G3dScene.SourceTextRep; <> <> <<>> <> <> <> <> <> <<>> <> <> <> <> <> <> <> <<};>> <<>> <> <> < {Blink[expl]; CONTINUE}];>> <<};>> <> <>> <> < {Blink[error.explanation]; CONTINUE}];>> <>> <> < {Blink[error.explanation]; CONTINUE}]>> < TiogaOps.CallWithLocks[WriteToViewer];>> <<};>> <<>> <> <> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <<>> <> <<>> <> <> <<};>> <<>> <> <> <<};>> <<>> <> <> <<};>> <<>> <> <> << IO.rope[name], IO.real[t.x], IO.real[t.y], IO.real[t.z]]];>> <<};>> <<>> <> <> <<};>> <<>> <> <> << IO.rope[name], IO.real[v1], IO.real[v2], IO.real[v3], IO.real[v4]]];>> <<};>> <<>> <> <> <> <<};>> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <<>> <> <> <> <> <> <> <<};>> <<>> <> <> <> <> <> <> <> <> <<};>> <<>> <> <> <> <> <> <> <> <<};>> <<>> <> <> <> <<};>> <<>> <> <> <<};>> <<>> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <> <<};>> <> ReadInfo: TYPE ~ RECORD [operations: ROPE, v: Viewer, sel: SelPos, fileName: ROPE ¬ NIL]; GetReaderInfo: PROC RETURNS [i: ReadInfo] ~ { i.operations ¬ ViewerTools.GetSelectionContents[]; IF Rope.Length[i.operations] = 0 THEN RETURN[[NIL, NIL, NIL]]; IF Rope.Length[i.operations] < 100 THEN { i.fileName ¬ FileNames.ResolveRelativePath[i.operations]; i.fileName ¬ PFS.RopeFromPath[PFS.FileInfo[PFS.PathFromRope[i.fileName] ! PFS.Error => {i.fileName ¬ NIL; CONTINUE}].fullFName]; IF i.fileName # NIL THEN i.operations ¬ PFS.RopeOpen[PFS.PathFromRope[i.fileName]].rope; } ELSE i.sel ¬ ViewerTools.GetSelection[i.v ¬ ViewerTools.GetSelectedViewer[]]; }; MakeFrameFromFile: PUBLIC PROC [context3d: Context3d, fileName: ROPE] ~ { [] ¬ ReadParameters[context3d, fileName]; <> }; ReadParameters: PUBLIC PROC [ context3d: Context3d, fileName: ROPE ¬ NIL, cmdOut: STREAM ¬ NIL] RETURNS [shouldRepaint: BOOL] ~ { i: ReadInfo ¬ IF fileName = NIL THEN GetReaderInfo[] ELSE [PFS.RopeOpen[PFS.PathFromRope[fileName]].rope, NIL, NIL, fileName]; shouldRepaint ¬ Parse[context3d, i.operations, cmdOut,, TRUE ! ParseError => {IO.PutRope[cmdOut, explanation]; CONTINUE}].shouldRepaint; }; Blink: PROC [r: ROPE] ~ { MessageWindow.Append[Rope.Concat["\t\t", r], TRUE]; MessageWindow.Blink[]; }; <> ParseError: PUBLIC ERROR [explanation: ROPE] = CODE; GetRope: PROC [in: STREAM] RETURNS [r: ROPE] ~ { Skip[in]; r ¬ IO.GetTokenRope[in, IO.IDProc].token; }; GetBool: PROC [in: STREAM] RETURNS [b: BOOL] ~ {Skip[in]; b ¬ IO.GetBool[in]}; GetReal: PROC [in: STREAM] RETURNS [r: REAL] ~ {Skip[in]; r ¬ IO.GetReal[in]}; GetInt: PROC [in: STREAM] RETURNS [i: INTEGER] ~ {Skip[in]; i ¬ IO.GetInt[in]}; GetPair: PROC [in: STREAM] RETURNS [p: Pair] ~ {p.x ¬ GetReal[in]; p.y ¬ GetReal[in]}; GetRGB: PROC [in: STREAM] RETURNS [r: RGB] ~ {t: Triple ¬ GetTriple[in]; r ¬ [t.x, t.y, t.z]}; GetTriple: PROC [in: STREAM] RETURNS [t: Triple]~{ t.x ¬ GetReal[in]; t.y ¬ GetReal[in]; t.z ¬ GetReal[in]; }; 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; }; WriteLog: PUBLIC PROC [ps: ParseState, msg: ROPE] ~ { IF ps.logProc = NIL THEN RETURN; THROUGH [0..ps.nesting) DO msg ¬ Rope.Concat["*", msg]; ENDLOOP; ps.logProc[msg, ps.clientData]; }; Eq: PROC [r1, r2: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[r1, r2, FALSE]]}; ShapeOk: PROC [ps: ParseState] RETURNS [ok: BOOL ¬ FALSE] ~ { IF ps.currentShape # NIL THEN RETURN[TRUE]; Blink[Rope.Concat["No shape to perform: ", ps.command]]; }; Parse: PUBLIC PROC [ context3d: Context3d, operation: ROPE, cmdOut: STREAM ¬ NIL, logProc: LogProc ¬ NIL, logErrors: BOOL ¬ TRUE, fileName: ROPE ¬ NIL, clientData: REF ANY ¬ NIL, parseState: ParseState ¬ NIL] RETURNS [ParseState] ~ { InnerParse: PROC [operation: ROPE] ~ { ENABLE { IO.EndOfStream => { IF logErrors AND nErrors > 0 THEN { ps.errorMessage ¬ IO.PutFR["\t%g error", IO.int[nErrors]]; IF nErrors > 1 THEN ps.errorMessage ¬ Rope.Cat[ps.errorMessage, "s"]; }; CONTINUE; }; IO.Error => {IF logErrors THEN ps.errorMessage ¬ "Error during read"; CONTINUE}; }; DoRegisteredOp: PROC [args: ROPE] RETURNS [BOOL] ~ { FOR r: Registry ¬ registry, r.rest WHILE r # NIL DO IF Eq[ps.command, r.first.key] THEN { <> <> r.first.proc[ps, args, r.first.data ! ParseError => {LogError[explanation]; CONTINUE}]; RETURN[TRUE]; }; REPEAT FINISHED => RETURN[FALSE]; ENDLOOP; }; LogError: PROC [errMsg: ROPE] ~ { lastLoc: TiogaOps.Location; IF ps.errorViewer = NIL THEN { name: ROPE ¬ NIL; IF ps.fileName # NIL THEN { i: INT ¬ MAX[Rope.FindBackward[ps.fileName,"/"], Rope.FindBackward[ps.fileName,">"]]; n: INT ¬ Rope.FindBackward[ps.fileName, "."]; IF n > i THEN name ¬ Rope.Cat[Rope.Substr[ps.fileName, 0, n], ".sceneErrors"]; IF i = -1 THEN name ¬ Rope.Cat[ps.directory, name]; }; IF name = NIL THEN name ¬ Rope.Cat[ps.directory, "List.sceneErrors"]; ps.errorViewer ¬ ViewerTools.MakeNewTextViewer[[name: name, file: name, column: right]]; ViewerOps.OpenIcon[ps.errorViewer]; }; lastLoc ¬ TiogaOps.LastLocWithin[TiogaOps.ViewerDoc[ps.errorViewer]]; TiogaOps.SetSelection[ps.errorViewer, lastLoc, lastLoc]; TiogaOps.SetLooks["b"]; TiogaOps.InsertRope[IO.PutFR["Error on line %g, file %g, position %g", IO.int[lineNumber], IO.rope[ps.fileName], IO.int[ps.index]]]; TiogaOps.SetLooks[" "]; TiogaOps.Break[]; TiogaOps.Nest[]; IO.SetIndex[in, ps.index]; TiogaOps.InsertRope[GetRope[in ! IO.EndOfStream => CONTINUE]]; TiogaOps.InsertRope[IO.GetLineRope[in ! IO.EndOfStream => CONTINUE]]; IF errMsg # NIL THEN {TiogaOps.Break[]; TiogaOps.InsertRope[errMsg]}; TiogaOps.Break[]; TiogaOps.UnNest[]; nErrors ¬ nErrors+1; }; lineNumber: INT ¬ 0; in: STREAM ¬ IO.RIS[operation]; DO args: ROPE; CedarProcess.CheckAbort[]; ps.index ¬ IO.GetIndex[in]; ps.command ¬ GetRope[in]; args ¬ IO.GetLineRope[in ! IO.EndOfStream => CONTINUE]; IF NOT Eq[ps.command, "Set"] THEN { -- variable substitution before interpretation: s: STREAM ¬ IO.RIS[SubstituteVariables[ps.variables, Rope.Cat[ps.command, " ", args], ps.randomStream]]; ps.command ¬ IO.GetTokenRope[s, IO.IDProc].token; args ¬ IO.GetLineRope[s ! IO.EndOfStream => CONTINUE]; IF Rope.Find[args, ";"] # -1 THEN { -- treat as several commands: Translate: Rope.TranslatorType ~ {RETURN[IF old = '; THEN '\n ELSE old]}; args ¬ Rope.Translate[args,,, Translate]; InnerParse[Rope.Cat[ps.command, " ", args]]; ps.command ¬ ""; }; }; SELECT TRUE FROM DoRegisteredOp[args] => NULL; Eq[ps.command, "ReadScene"] => { save: ROPE ¬ ps.fileName; name: ROPE ¬ GetRope[IO.RIS[args]]; WriteLog[ps, Rope.Cat["Reading scene: ", name]]; ps.nesting ¬ ps.nesting+1; ps.fileName ¬ name; InnerParse[PFS.RopeOpen[PFS.PathFromRope[name]].rope]; ps.fileName ¬ save; ps.nesting ¬ ps.nesting-1; }; Eq[ps.command, ""] => { ps.command ¬ " "; }; ENDCASE => LogError[Rope.Cat["Unknown command: ", ps.command]]; lineNumber ¬ lineNumber+1; ENDLOOP; }; nErrors: INT ¬ 0; ps: ParseState ¬ IF parseState # NIL THEN parseState ELSE NEW[ParseStateRep]; ps.errorMessage ¬ NIL; ps.fileName ¬ fileName; ps.context3d ¬ context3d; ps.logProc ¬ logProc; ps.clientData ¬ clientData; IF ps.timeTree = NIL THEN { ps.timeTree ¬ G3dTimeTrees.CreateTimeTree[]; G3dTimeTrees.InitializeGraphicsTimeTree[ps.timeTree]; }; <> <> ps.cmdHandle ¬ NEW[Commander.CommandObject]; ps.directory ¬ PFS.RopeFromPath[PFS.GetWDir[]]; CommanderOps.AddSearchRule[ps.cmdHandle, ps.directory]; CommanderOps.AddSearchRule[ps.cmdHandle, "///7.0/Commands/"]; CommanderOps.AddSearchRule[ps.cmdHandle, "///7.0/System/"]; ps.cmdHandle.err ¬ ps.cmdHandle.out ¬ cmdOut; ps.ctm ¬ G3dMatrix.Identity[]; InnerParse[operation]; RETURN[ps]; }; <> InheritMaterial: PUBLIC PROC [ps: ParseState] ~ { SetTexture: PROC [name: ROPE, style: TextureStyle] ~ { IF name # NIL THEN error ¬ Rope.Cat[error, G3dRender.SetTextureMap[shape, name, style]]; G3dRender.OffsetTextureCoords[shape, material.textureOffset]; G3dRender.SetTextureScale[shape, name, material.textureScale]; G3dRender.SetBumpHeight[shape, name, material.bumpScale]; G3dRender.SetTextureFiltering[shape, name, material.textureFiltering]; }; error: ROPE ¬ NIL; shape: Shape ¬ ps.currentShape; material: Material ¬ ps.currentMaterial; firstChar: ROPE ¬ Rope.Substr[ps.fileName, 0, 1]; fullName: ROPE ¬ IF Rope.Equal[firstChar, "["] OR Rope.Equal[firstChar, "/"] THEN ps.fileName ELSE Rope.Cat[ps.directory, ps.fileName]; G3dRender.SetRenderStyle[shape, material.renderStyle]; G3dRender.SetColor[shape, [material.color.x, material.color.y, material.color.z]]; G3dRender.SetShininess[shape, material.shininess]; G3dRender.SetTransmittance[shape, material.transmittance]; IF material.backFaces THEN G3dRender.ShowBackfaces[shape] ELSE G3dRender.HideBackfaces[shape]; IF material.visible THEN G3dRender.SetVisible[shape] ELSE G3dRender.SetInvisible[shape]; SetTexture[material.textureIntensityName, intensity]; SetTexture[material.textureColorName, color]; SetTexture[material.textureBumpName, bump]; G3dTimeTrees.SetLocalTransform[ps.timeTree, ps.ctm]; shape.hierarchyData ¬ G3dTimeTrees.SetNodeObject[ps.timeTree, shape]; ps.timeTree.activeNode.clientData ¬ NEW[SourceTextRep ¬ [fullName, ps.index]]; IF error # NIL THEN ParseError[error]; }; <> registry: Registry ¬ NIL; RegisterProc: PUBLIC PROC [key: ROPE, proc: SceneProc, data: REF ANY ¬ NIL] ~ { UnregisterProc[key]; registry ¬ CONS[[key, proc, data], registry]; }; UnregisterProc: PUBLIC PROC [key: ROPE] ~ { IF registry = NIL THEN RETURN; IF Rope.Equal[registry.first.key, key] THEN registry ¬ registry.rest ELSE FOR r: Registry ¬ registry, r.rest WHILE r.rest # NIL DO IF Rope.Equal[r.rest.first.key, key] THEN {r.rest ¬ r.rest.rest; EXIT}; ENDLOOP; }; GetRegistry: PUBLIC PROC RETURNS [Registry] ~ {RETURN[registry]}; ResetRegistry: PUBLIC PROC ~ {registry ¬ NIL}; <> Comment: SceneProc ~ {}; Echo: SceneProc ~ {WriteLog[ps, args]}; Command: SceneProc ~ { result: REF; name: ROPE ¬ GetRope[IO.RIS[args]]; WriteLog[ps, IO.PutFR["Command: %g\n%l", IO.rope[name], IO.rope["i"]]]; WriteLog[ps, IO.PutFR["%l", IO.rope["I"]]]; result ¬ CommanderOps.DoCommand[args, ps.cmdHandle]; IF result # NIL THEN WriteLog[ps, IO.PutFR["(%g)", IO.refAny[result]]]; }; <> MakeTransformNode: PUBLIC PROC [ps: ParseState] ~ { IF Atom.GetPropFromList[ps.changes, $transform] = NIL THEN RETURN; G3dTimeTrees.SetLocalTransform[ps.timeTree, ps.ctm]; G3dTimeTrees.PushTimeTree[ps.timeTree]; ps.changes ¬ Atom.RemPropFromList[ps.changes, $transform]; ps.ctm ¬ G3dMatrix.Identity[]; }; MakeKeysNode: PUBLIC PROC [ps: ParseState] ~ { G3dTimeTrees.PushTimeTree[ps.timeTree]; ps.changes ¬ Atom.RemPropFromList[ps.changes, $transform]; ps.ctm ¬ G3dMatrix.Identity[]; }; MakeShapeNode: PUBLIC PROC [ps: ParseState] ~ { shape: Shape ¬ ps.currentShape; <> <> <> <<};>> <> <> G3dTimeTrees.SetLocalTransform[ps.timeTree, ps.ctm]; shape.hierarchyData ¬ G3dTimeTrees.SetNodeObject[ps.timeTree, shape]; <> <> }; <> AssignCtmToShape: PUBLIC PROC [ps: ParseState, shape: Shape] ~ { shape.matrix ¬ G3dMatrix.CopyMatrix[ps.ctm]; shape.renderValid ¬ FALSE; }; GetArgs: PUBLIC PROC [ps: ParseState, input, format: ROPE] RETURNS [Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg,Arg] ~ { <> a: ARRAY [0..18) OF Arg; [a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17]] ¬ Args.ArgsGetFromRope[input, format, FALSE ! Args.Error => ParseError[IO.PutFR["line actually interpreted: %g %g", [rope[ps.command]], [rope[input]]]]]; RETURN[a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15], a[16], a[17]]; }; SubstituteVariables: PUBLIC PROC [variables: VariableSequence, input: ROPE, rs: RandomStream ¬ NIL] RETURNS [out: ROPE] ~ { IDProc: IO.BreakProc ~ { RETURN[SELECT char FROM IN [IO.NUL..IO.SP], ',, ':, '), '( => sepr, ENDCASE => other]; }; OnePass: PROC ~ { in: STREAM ¬ IO.RIS[input]; out ¬ NIL; DO r: ROPE ¬ IO.GetTokenRope[in, IDProc ! IO.EndOfStream => EXIT].token; out ¬ Rope.Cat[out, ExpandRope[in, variables, r, rs], " "]; ENDLOOP; }; len: INT ¬ Rope.Length[input]; new: ROPE ¬ NIL; start: INT ¬ 0; DO skipTo: INT ¬ Rope.SkipTo[input, start, ";"]; new ¬ Rope.Cat[new, Rope.Substr[input, start, skipTo-start]]; IF skipTo < len THEN new ¬ Rope.Cat[new, " ; "]; IF skipTo = len THEN EXIT; start ¬ skipTo+1; ENDLOOP; DO OnePass[]; IF Rope.Equal[input, out] THEN EXIT ELSE input ¬ out; ENDLOOP; }; ExpandRope: PUBLIC PROC [in: STREAM, variables: VariableSequence, name: ROPE, rs: RandomStream ¬ NIL] RETURNS [ROPE] ~ { Eq: PROC [r1, r2: ROPE] RETURNS [b: BOOL] ~ {b ¬ Rope.Equal[r1, r2, FALSE]}; RandomUnit: PROC [] RETURNS [REAL] ~ { RETURN[REAL[Random.NextInt[rs]]/REAL[LAST[INT]]]; }; name ¬ LookupVariable[variables, name]; SELECT TRUE FROM Eq[name, "RandomInt"] => { lo: INT ¬ IO.GetInt[in]; hi: INT ¬ IO.GetInt[in]; v: INT ¬ Real.Round[lo + RandomUnit[] * (hi - lo)]; RETURN[IO.PutFR["%g", IO.int[v]]]; }; Eq[name, "RandomReal"] => { lo: REAL ¬ IO.GetReal[in]; hi: REAL ¬ IO.GetReal[in]; v: REAL ¬ lo + RandomUnit[] * (hi - lo); RETURN[IO.PutFR["%g", IO.real[v]]]; }; Eq[name, "RandomTriple"] => { lo: REAL ¬ IO.GetReal[in]; hi: REAL ¬ IO.GetReal[in]; x: REAL ¬ 2.0 * (RandomUnit[] - 0.5); y: REAL ¬ 2.0 * (RandomUnit[] - 0.5); z: REAL ¬ 2.0 * (RandomUnit[] - 0.5); len: REAL ¬ RealFns.SqRt[(x*x)+(y*y)+(z*z)]; newlen: REAL ¬ lo + RandomUnit[] * (hi - lo); scl: REAL ¬ IF len # 0.0 THEN newlen / len ELSE 1.0; RETURN[IO.PutFR["%g %g %g", IO.real[x*scl], IO.real[y*scl], IO.real[z*scl]]]; }; ENDCASE; RETURN[name]; }; LookupVariable: PUBLIC PROC [variables: VariableSequence, name: ROPE] RETURNS [ROPE] ~ { Eq: PROC [r1, r2: ROPE] RETURNS [b: BOOL] ~ {b ¬ Rope.Equal[r1, r2, FALSE]}; IF variables # NIL THEN FOR i: INT IN [0..variables.length) DO IF Eq[variables[i].name, name] THEN RETURN[variables[i].value]; ENDLOOP; RETURN[name]; }; <> RegisterProc["--", Comment]; RegisterProc["Echo", Echo]; RegisterProc["Command", Command]; END. .. <> ViewerSelection: TYPE ~ RECORD [viewer: Viewer, selection: SelPos]; ReadParameters: PUBLIC PROC [context3d: Context3d, fileName: ROPE ¬ NIL, cmdOut: STREAM ¬ NIL] RETURNS [shouldRepaint: BOOL] ~ { i: ReadInfo ¬ IF fileName = NIL THEN GetReaderInfo[] ELSE [PFS.RopeOpen[fileName], NIL, NIL, fileName].rope; RETURN[Parse[context3d, i.operations, cmdOut,, TRUE, i.fileName, [i.v, i.sel] ! ParseError => CONTINUE]]; }; Parse: PROC [ context3d: Context3d, operation: ROPE, cmdOut: STREAM ¬ NIL, log: LogProc ¬ NIL, showErrors: BOOL ¬ TRUE, fileName: ROPE ¬ NIL, viewerSelection: ViewerSelection ¬ [NIL, NIL]] RETURNS [shouldRepaint: BOOL]; ParseError: PUBLIC ERROR [position: NAT, fileName: ROPE, viewer: Viewer] = CODE; <> PositionAndRaiseError: PROC [file, out: STREAM, fileName, err: ROPE, vs: ViewerSelection] ~ { position: INT ¬ IO.GetIndex[file]; IF vs.viewer # NIL AND vs.selection # NIL THEN { position ¬ position+vs.selection.start; vs.selection­ ¬ [position, 10]; ViewerTools.SetSelection[vs.viewer, vs.selection]; IO.PutRope[out, "Error during read"]; } ELSE { IF out # NIL THEN IO.PutF[out, "%g, file position = %g\n", IO.rope[err], IO.int[position]]; IF fileName # NIL THEN { name: ROPE ¬ PFSNames.StripVersionNumber[PFS.FileInfo[fileName].fullFName]; v: Viewer ¬ ViewerOps.FindViewer[name]; IF v = NIL THEN { v ¬ ViewerOps.CreateViewer[flavor: $Text, paint: FALSE, info: [iconic: TRUE, column: right, openHeight: 140]]; TiogaMenuOps.Load[v, fileName]; }; ViewerOps.OpenIcon[icon: v, bottom: FALSE, paint: FALSE]; ViewerTools.SetSelection[v,NEW[ViewerTools.SelPosRec¬[MAX[0,position-4],4,FALSE]]]; }; }; ParseError[position, fileName, vs.viewer]; }; GetRope: PROC RETURNS [r: ROPE] ~ { <> <> < sepr,>> <<'[, '], '(, '), '{, '}, '", '+, '*, '@, '_ => break,>> < other];>> <<};>> CedarProcess.CheckAbort[]; Skip[]; r ¬ IO.GetTokenRope[in, IO.IDProc].token; }; The following procs replaced by world coordinate transformations: ScaleShape: SceneProc ~ { IF ShapeOk[ps] THEN { s: REAL ¬ GetReal[IO.RIS[args]]; WriteLog[ps, IO.PutFR["Set %g scale to %g", [rope[ps.currentShape.name]], [real[s]]]]; G3dShape.TransformShape[shape: ps.currentShape, scale: s, concat: TRUE]; }; }; TranslateShape: SceneProc ~ { IF ShapeOk[ps] THEN { t: Triple ¬ GetTriple[IO.RIS[args]]; WriteLog[ps, IO.PutFR["%g trans: (%g, %g, %g)", [rope[ps.currentShape.name]], [real[t.x]], [real[t.y]], [real[t.z]]]]; G3dShape.TransformShape[shape: ps.currentShape, translate: t, concat: TRUE]; }; }; RotateShape: SceneProc ~ { IF ShapeOk[ps] THEN { in: STREAM ¬ IO.RIS[args]; p0: Triple ¬ GetTriple[in]; p1: Triple ¬ GetTriple[in]; axis: G3dBasic.Ray ¬ [p0, G3dVector.Sub[p1, p0]]; r: REAL ¬ GetReal[in]; WriteLog[ps, IO.PutFR["%g rotate: %g", IO.rope[ps.currentShape.name], IO.real[r]]]; WriteLog[ps, Rope.Cat["Rotate ", ps.currentShape.name]]; G3dShape.TransformShape[shape: ps.currentShape, axis: axis, rotation: r, concat: TRUE]; }; };