
<<File: SVFileInImpl.mesa>>
<<Last edited by Bier on May 5, 1987 11:45:15 pm PDT>>
<<Copyright © 1984 by Xerox Corporation.  All rights reserved.>>
<<Contents: Recreates a 3d database from a 3d text file of the sort produced by Fileout3d.mesa.>>
<<Note: When you change this file, you may wish to update versionRope in SVSceneImplA.>>

DIRECTORY
AtomButtonsTypes, CoordSys, SVRay, Feedback, SVScene, SVFileIn, FS, Imager, ImagerColor, IO, Rope, SV2d, SV3d, SVArtwork, 
SVAssembly, SVMasterObject, SVModelTypes, SVSceneTypes, SweepGeometry, TFI3d, ViewerClasses;

SVFileInImpl: CEDAR PROGRAM
IMPORTS CoordSys, SVRay, SVScene, FS, ImagerColor, IO, Rope, SVArtwork, SVAssembly, Feedback, SVMasterObject, TFI3d
EXPORTS SVFileIn =
BEGIN

ArtworkClass: TYPE = SVModelTypes.ArtworkClass;
Slice: TYPE = SVSceneTypes.Slice;
SliceList: TYPE = SVSceneTypes.SliceList;
Artwork: TYPE = SVModelTypes.Artwork;
Color: TYPE = Imager.Color;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CoordSysList: TYPE = SVModelTypes.CoordSysList;
FeedbackData: TYPE = AtomButtonsTypes.FeedbackData;
FileCamera: TYPE = SVSceneTypes.FileCamera;
LightSource: TYPE = SVModelTypes.LightSource;
LightSourceList: TYPE = LIST OF LightSource;
MasterObject: TYPE = SVSceneTypes.MasterObject;
MasterObjectList: TYPE = SVSceneTypes.MasterObjectList;
MasterObjectClass: TYPE = SVSceneTypes.MasterObjectClass;
Material: TYPE = SVModelTypes.Material;
Matrix3by3: TYPE = SV2d.Matrix3by3;
Matrix4by4: TYPE = SV3d.Matrix4by4;
NameList: TYPE = LIST OF Rope.ROPE;
OMap: TYPE = SVModelTypes.OMap;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
PointSetOp: TYPE = SVSceneTypes.PointSetOp; -- {union, intersection, difference}
Scene: TYPE = SVSceneTypes.Scene;
SMap: TYPE = SVModelTypes.SMap;
SpaceFunction: TYPE = REF SpaceFunctionObj;
SpaceFunctionObj: TYPE = SVModelTypes.SpaceFunctionObj;
Vector3d: TYPE = SV3d.Vector3d;
Viewer: TYPE = ViewerClasses.Viewer;

LinearMesh: TYPE = REF LinearMeshRecord;
LinearMeshRecord: TYPE = SweepGeometry.LinearMeshRecord;
RevoluteMesh: TYPE = REF RevoluteMeshRecord;
RevoluteMeshRecord: TYPE = SweepGeometry.RevoluteMeshRecord;

LinearMeshArray: TYPE = SweepGeometry.LinearMeshArray;
RevoluteMeshArray: TYPE = SweepGeometry.RevoluteMeshArray;

FileinScene: PUBLIC PROC [scene: Scene, f: IO.STREAM, wdirForAIS: Rope.ROPE, feedback: FeedbackData] = {
csList: CoordSysList;
worldCS: CoordSystem;
sceneName: Rope.ROPE;
version: REAL;
restOfVersionRope: Rope.ROPE;
TFI3d.ReadBlankAndRope[f, "File:"];
TFI3d.ReadBlank[f];
[] _ TFI3d.ReadWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "3D file for scene:"];
TFI3d.ReadBlank[f];
sceneName _ TFI3d.ReadWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "Produced by Solidviews Version"];
TFI3d.ReadBlank[f];
version _ TFI3d.ReadReal[f];
restOfVersionRope _ TFI3d.ReadLine[f];
IF version >= 2.0 THEN ReadOptions[f, scene];
IF scene.lightSources = NIL THEN {
ambientLight: LightSource _ SVScene.CreateAmbientLightSource["Ambient", ImagerColor.ColorFromRGB[[0.2,0.2,0.2]]];
scene.lightSources _ CONS[ambientLight, NIL];
};
TFI3d.ReadBlank[f];
csList _ FileinCoordSystems[f, scene];
FileinLightSources[f, scene];
worldCS _ CoordSys.FindCoordSysInList["WORLD", csList];
FileinObjects[f, scene, version];
scene.assembly _ FileinAssembly[f, scene, csList, version, wdirForAIS, feedback];
IF version >= 3.0 THEN FileinCameras[f, scene, csList, version]
ELSE scene.cameras _ SVScene.InitialCameraList[];
IF version >= 3.0 THEN FileinCameraOrder[f, scene]
ELSE scene.cameraOrder _ LIST["Front"];
TFI3d.ReadBlank[f];
TFI3d.ReadRope[f, "END"];
f.Close[];
};

ReadOptions: PROCEDURE [f: IO.STREAM, scene: Scene] = {
keyWord, option: Rope.ROPE;
good: BOOL;
nextChar: CHAR;
twoCRsFound: BOOL _ FALSE;
TFI3d.ReadBlank[f];
UNTIL twoCRsFound DO
[keyWord, good] _ TFI3d.ReadKeyWord[f];
IF NOT good THEN {
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
LOOP};
good _ TFI3d.ReadHorizontalBlank[f];
IF NOT good THEN {
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
LOOP};
option _ TFI3d.ReadLine[f];
ProcessOption[keyWord, option, scene];
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
ENDLOOP;
};

ProcessOption: PROC [keyWord: Rope.ROPE, option: Rope.ROPE, scene: Scene] = {
SELECT TRUE FROM
<<Known Options>>
Rope.Equal[keyWord, "background color", FALSE] => {
scene.backgroundColor _ TFI3d.ReadColor[IO.RIS[option]];
};
Rope.Equal[keyWord, "shadows", FALSE] => {
good, truth: BOOL;
[truth, good] _ TFI3d.ReadBool[IO.RIS[option]];
IF NOT good THEN RETURN;
scene.shadows _ truth;
};
Rope.Equal[keyWord, "ambient", FALSE] => {
color: Color;
ls: LightSource;
color _ TFI3d.ReadColor[IO.RIS[option]];
ls _ SVScene.CreateAmbientLightSource["Ambient", color];
SVScene.AddLightSourceToScene[ls, scene];
};
ENDCASE;
}; -- end of ProcessOption

FileinCoordSystems: PROC [f: IO.STREAM, scene: Scene] RETURNS [csList: CoordSysList] = {
count: NAT;
mat: Matrix4by4;
newCS: CoordSystem;
csName, wrtName: Rope.ROPE;
csList _ NIL;
TFI3d.ReadRope[f, "CoordSystems"];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"]; TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadRope[f, "CoordSys:"];
csName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "mat:"];
TFI3d.ReadBlank[f];
mat _ TFI3d.FileinMatrix[f];
TFI3d.ReadBlankAndRope[f, "withRespectTo:"];
wrtName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
SELECT TRUE FROM
Rope.Equal[csName,"WORLD"] => {
newCS _ CoordSys.CreateRoot["WORLD"];
<<WORLD must be defined with respect to NIL, and must be the identity matrix.>>
scene.coordSysRoot _ newCS;
csList _ AppendToCoordSystems[newCS, csList];
};
Rope.Equal[csName,"SCREEN"] => {};
<<SCREEN must be in terms of NIL.>>
<<The matrix between them must be a translation>>
<<SCREEN is ignored since it depends on viewer size and shouldn't be in these files anyway.>>
ENDCASE => {
<<Other coord systems are unrestricted.  Create them with the new data.>>
wrtCS: CoordSystem _ CoordSys.FindCoordSysInList[wrtName, csList];
newCS _ CoordSys.CreateCoordSysInTree[csName,mat,wrtCS,scene.coordSysRoot];
csList _ AppendToCoordSystems[newCS, csList];
};
<<All coordinate systems other than screen and world will be added to the scene's coord sys list (not the same as csList!) when 
assemblies (see FileinAssemblies) are added.>>
ENDLOOP;
}; -- end of FileinCoordSystems

AppendToCoordSystems: PROC [cs: CoordSystem, list: CoordSysList]  RETURNS [CoordSysList] = {
<<A copy of List.Nconc1 for CoordSysList instead of LIST OF REF ANY>>
z: CoordSysList _ list;
IF z = NIL THEN RETURN[CONS[cs,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[cs,NIL];
RETURN[list];
};

FileinLightSources: PROC [f: IO.STREAM, scene: Scene] = {
count: NAT;
thisLS: LightSource;
lsName: Rope.ROPE;
point3d: Point3d;
color: Color;
TFI3d.ReadRope[f, "LightSources"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadRope[f, "LightSource:"];
lsName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlankAndRope[f, "position:"];
TFI3d.ReadBlank[f];
point3d _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
TFI3d.ReadWhiteSpace[f];
thisLS _ SVScene.CreateLightSource[lsName, point3d, color];
SVScene.AddLightSourceToScene[thisLS, scene];
ENDLOOP;
};
FileinCameras: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL] = {
worldCS: CoordSystem _ CoordSys.FindCoordSysInList["WORLD", csList];
count: NAT;
fileCamera: FileCamera;
TFI3d.ReadBlankAndRope[f, "Cameras"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
fileCamera _ TFI3d.ReadCamera[f, worldCS, scene, version];
SVScene.AddCameraToScene[fileCamera, scene];
ENDLOOP;
};

FileinCameraOrder: PROC [f: IO.STREAM, scene: Scene] = {
count: NAT;
fileCameraName: Rope.ROPE;
TFI3d.ReadBlankAndRope[f, "Initial Camera Order"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];
IF count > 0 THEN {
TFI3d.ReadBlank[f];
fileCameraName _ TFI3d.ReadWord[f];
SVScene.AddCameraOrderNameToScene[fileCameraName, scene];
FOR i: NAT IN[2..count] DO
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlank[f];
fileCameraName _ TFI3d.ReadWord[f];
SVScene.AddCameraOrderNameToScene[fileCameraName, scene];
ENDLOOP;
};
TFI3d.ReadBlank[f];
};

ReadArtwork: PROC [f: IO.STREAM, csList: CoordSysList, defaultCS: CoordSystem, wdir: Rope.ROPE, version: REAL, feedback: 
FeedbackData] RETURNS [artwork: Artwork] = {
source, isColorRope, nextWord, aisFileName: Rope.ROPE _ NIL;
surface: REF ANY;
material: Material;
mat: Matrix3by3;
color: Imager.Color;
isColorFile: BOOL;
sMap: SMap;
oMap: OMap;
resolution: REAL;
success: BOOL;
csName, className: Rope.ROPE;
coordSys: CoordSystem;
class: ArtworkClass;

IF version > 5.2 THEN {
TFI3d.ReadBlankAndRope[f, "coordSys: "];
csName _ TFI3d.ReadBlankAndWord[f];
IF Rope.Equal[csName, "NIL"] THEN coordSys _ NIL
ELSE coordSys _ CoordSys.FindCoordSysInList[csName, csList];
TFI3d.ReadBlankAndRope[f, "class: "];
className _ TFI3d.ReadBlankAndWord[f];
class _ RopeToArtworkClass[className];
}
ELSE {
coordSys _ defaultCS;
class _ simpleSurface;
};
TFI3d.ReadBlankAndRope[f, "material:"];
TFI3d.ReadBlank[f];
material _ TFI3d.ReadMaterial[f];
TFI3d.ReadBlankAndRope[f, "surface:"];
surface _ TFI3d.ReadSurface[f];

IF (surface # NIL) AND class # spaceFunction THEN {
nextWord _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[nextWord, "source:"] => {-- oMap and sMap are defaulted
source _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
ISTYPE[surface, SVModelTypes.Tube] => {oMap _  tubeO; sMap _ tubeS};
ISTYPE[surface, SVModelTypes.Box] => {oMap _  orthogonal; sMap _ unfoldedBox};
ENDCASE => ERROR;
};
Rope.Equal[nextWord, "SMap:"] => {
TFI3d.ReadBlank[f];
sMap _ TFI3d.ReadSMap[f];
TFI3d.ReadBlankAndRope[f, "OMap:"];
TFI3d.ReadBlank[f];
oMap _ TFI3d.ReadOMap[f];
TFI3d.ReadBlankAndRope[f, "source:"];
source _ TFI3d.ReadBlankAndWord[f];
};
ENDCASE => ERROR;
isColorRope _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[isColorRope, "colorFile", FALSE] => isColorFile _ TRUE;
Rope.Equal[isColorRope, "bwFile", FALSE] => isColorFile _ FALSE;
ENDCASE => ERROR;
TFI3d.ReadBlankAndRope[f, "resolution:"];
TFI3d.ReadBlank[f];
resolution _ TFI3d.ReadReal[f];
TFI3d.ReadBlankAndRope[f, "mat:"];
TFI3d.ReadBlank[f];
mat _ TFI3d.FileinMatrix3by3[f];
success _ TRUE;
[aisFileName,,] _ FS.ExpandName[source, wdir
! FS.Error =>  {
IF error.group = user THEN {
success _ FALSE;
Feedback.Append[feedback, error.explanation, oneLiner];
CONTINUE;
};
}];
IF NOT success THEN ERROR SVArtwork.FileNotFound;
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
artwork _ SVArtwork.CreateFileArtwork[coordSys, material, surface, oMap, sMap, aisFileName, isColorFile, color, resolution, mat]; 
-- may generate ERROR SVArtwork.FileNotFound
}
ELSE {
IF surface = NIL AND class#spaceFunction THEN {
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
artwork _ SVArtwork.CreateColorArtwork[color, material]
}
ELSE {
spaceFunction: SpaceFunction;
TFI3d.ReadBlankAndRope[f, "scalars:"];
spaceFunction _ NEW[SpaceFunctionObj];
TFI3d.ReadBlank[f];
spaceFunction.scalars _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "func: colorcube"];
artwork _ SVArtwork.Create3DArtwork[coordSys, material, spaceFunction];
};
};
};

RopeToArtworkClass: PROC [className: Rope.ROPE] RETURNS [class: ArtworkClass] = {
SELECT TRUE FROM
Rope.Equal[className, "justColor"] => class _ justColor;
Rope.Equal[className, "simpleSurface"] => class _ simpleSurface;
Rope.Equal[className, "spaceFunction"] => class _ spaceFunction;
ENDCASE => ERROR;
};

FileinAssembly: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL, wdirForAIS: Rope.ROPE, feedback: 
FeedbackData] RETURNS [thisA: Slice] = {
thisCS: CoordSystem;
artwork: Artwork;
scalars: Vector3d;
primOrComp: Rope.ROPE;
asName, csName, opRope, chairName: Rope.ROPE;
pointSetOp: PointSetOp;
subAssemblies: LIST OF Slice;

TFI3d.ReadBlankAndRope[f, "Assembly:"];
asName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlankAndRope[f, "coordSys:"];
csName _ TFI3d.ReadBlankAndWord[f];
thisCS _ CoordSys.FindCoordSysInList[csName, csList];
TFI3d.ReadBlankAndRope[f, ","];
primOrComp _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[primOrComp, "Composite", FALSE] => {
TFI3d.ReadBlankAndRope[f, "artwork:"];
TFI3d.ReadBlank[f];
artwork _ ReadArtwork[f, csList, thisCS, wdirForAIS, version, feedback];
TFI3d.ReadBlankAndRope[f, "subassemblies"];
TFI3d.ReadBlankAndRope[f, "["];
IF version < 5.2 THEN TFI3d.ReadBlankAndRope[f, "point set op:"];
opRope _ TFI3d.ReadBlankAndWord[f];
pointSetOp _ SVRay.RopeToPointSetOp[opRope];
TFI3d.ReadBlankAndRope[f, "]"];
TFI3d.ReadWhiteSpace[f];
[] _ FileinSubassemblyNames[f];
thisA _ SVAssembly.CreateClusterAssemblyAtExistingCoordSys[asName, pointSetOp, scene, thisCS, FALSE, NIL];
thisA.artwork _ artwork;
subAssemblies _ FileinAssemblies[f, scene, csList, version, wdirForAIS, feedback];
WireUpAssemblyToSubassemblies[thisA, subAssemblies, scene];
};
Rope.Equal[primOrComp, "Primitive", FALSE] => {
obName: Rope.ROPE;
masterObjectFound: BOOL;
TFI3d.ReadBlankAndRope[f, "scalars:"];
TFI3d.ReadBlank[f];
scalars _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "artwork:"];
TFI3d.ReadBlank[f];
artwork _ ReadArtwork[f, csList, thisCS, wdirForAIS, version, feedback];
TFI3d.ReadBlankAndRope[f, "object:"];
obName _ TFI3d.ReadBlankAndWord[f];
[thisA, masterObjectFound] _
SVAssembly.CreatePrimitiveAtExistingCoordSys[asName, obName, scalars, scene, thisCS, artwork, FALSE, NIL];
IF NOT masterObjectFound THEN ERROR MasterObjectNotFound;
IF version >= 5.3 AND Rope.Equal[obName, "jack", FALSE] THEN {
TFI3d.ReadBlankAndRope[f, "sittingOn:"];
chairName _ TFI3d.ReadBlankAndWord[f];
IF Rope.Equal[chairName, "NIL", FALSE] THEN thisA.sittingOn _ NIL
ELSE thisA.sittingOn _ chairName;
};
};
ENDCASE => SIGNAL ErrorInAssemblyFileout;
}; -- end of FileinAssembly
MasterObjectNotFound: PUBLIC ERROR = CODE;

FileinAssemblies: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL, wdirForAIS: Rope.ROPE, feedback: 
FeedbackData] RETURNS [asList: LIST OF Slice] = {
count: NAT;
thisA: Slice;
asList _ NIL;-- initially
TFI3d.ReadBlankAndRope[f, "Subassemblies"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
thisA _ FileinAssembly[f, scene, csList, version, wdirForAIS, feedback];
asList _ AppendToAssemblyList[thisA, asList];
ENDLOOP;
};

ErrorInAssemblyFileout: PUBLIC SIGNAL = CODE;
WireUpAssemblyToSubassemblies: PROC [assem: Slice, subA: LIST OF Slice, scene: Scene] = {
thisSub: Slice;
FOR al: LIST OF Slice _ subA, al.rest UNTIL al = NIL DO
thisSub _ al.first;
SVAssembly.ConnectAssemblyToParent[thisSub, assem];
ENDLOOP;
};
AppendToAssemblyList: PROC [as: Slice, list: LIST OF Slice] RETURNS [LIST OF Slice] = {
<<A copy of List.Nconc1 for AssemblyListObj instead of LIST OF REF ANY>>
z: LIST OF Slice _ list;
IF z = NIL THEN RETURN[CONS[as,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[as,NIL];
RETURN[list];
};
AppendToNameList: PROC [name: Rope.ROPE, list: NameList] RETURNS [NameList] = {
<<A copy of List.Nconc1 for NameList instead of LIST OF REF ANY.>>
z: NameList _ list;
IF z = NIL THEN RETURN[CONS[name,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[name,NIL];
RETURN[list];
};
FileinSubassemblyNames: PROC [f: IO.STREAM] RETURNS [nameList: NameList] = {
count: NAT;
thisName: Rope.ROPE;
nameList _ NIL;
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];
TFI3d.ReadBlankAndRope[f, "("];
IF count = 0 THEN {TFI3d.ReadBlankAndRope[f, ")"]; RETURN;};
thisName _ TFI3d.ReadBlankAndWord[f];
nameList _ AppendToNameList[thisName, nameList];
FOR i: NAT IN[2..count] DO
TFI3d.ReadRope[f, ", "];
thisName _ TFI3d.ReadBlankAndWord[f];
nameList _ AppendToNameList[thisName, nameList];
ENDLOOP;
TFI3d.ReadBlankAndRope[f, ")"];
TFI3d.ReadWhiteSpace[f];
};
FileinObjects: PROC [f: IO.STREAM, scene: Scene, version: REAL] = {
count: NAT;
obName, obClass: Rope.ROPE;
moClass: MasterObjectClass;
moClassFound: BOOL;
mo: MasterObject;

TFI3d.ReadRope[f, "Objects"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];
TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadBlankAndRope[f, "Master Object:"];
obName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "class:"];
obClass _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlank[f];
[moClass, moClassFound] _ SVMasterObject.FindClassFromName[obClass];
IF NOT moClassFound THEN ERROR MasterObjectClassNotFound;
mo _ moClass.filein[f, obName, version];
SVScene.AddMasterObjectToScene[mo, scene];
ENDLOOP;-- next master object
TFI3d.ReadBlank[f];
}; -- end of FileinObjects
MasterObjectClassNotFound: PUBLIC ERROR = CODE;

END.