DIRECTORY
AtomButtonsTypes, CoordSys, Feedback, FunctionCache, Imager, ImagerColor, ImagerColorPrivate, Matrix3d, PriorityQueue, Real, Rope, SV2d, SV3d, SVArtwork, SVAssembly, SVBasicTypes, SVBoundBox, SVDraw3d, SVMatrixOps, SVModelTypes, SVRayTypes, SVScene, SVSceneTypes, SVToolObject, SVTransforms, SVUtility, ViewerClasses;

SVAssemblyImpl: CEDAR PROGRAM
IMPORTS CoordSys, Feedback, FunctionCache, Imager, ImagerColor, ImagerColorPrivate, Matrix3d, PriorityQueue, Rope, SVArtwork, SVBoundBox, SVDraw3d, SVMatrixOps, SVScene, SVToolObject, SVTransforms, SVUtility
EXPORTS SVAssembly
 =
BEGIN

Artwork: TYPE = SVModelTypes.Artwork;
Slice: TYPE = SVSceneTypes.Slice;
SliceList: TYPE = SVSceneTypes.SliceList;
SliceListObj: TYPE = SVSceneTypes.SliceListObj;
SliceObj: TYPE = SVSceneTypes.SliceObj;
BoundBox: TYPE = SVBasicTypes.BoundBox;
BoundHedron: TYPE = SVBasicTypes.BoundHedron;
Camera: TYPE = SVModelTypes.Camera;
Color: TYPE = Imager.Color;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
FeedbackData: TYPE = AtomButtonsTypes.FeedbackData;
LightSourceList: TYPE = SVSceneTypes.LightSourceList;
Line3d: TYPE = SV3d.Line3d;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Matrix4by4: TYPE = SV3d.Matrix4by4;
PlanarSurface: TYPE = SVSceneTypes.PlanarSurface;
PlanarSurfaceList: TYPE = SVSceneTypes.PlanarSurfaceList;
Point2d: TYPE = SV2d.Point2d;	
Point3d: TYPE = SV3d.Point3d;
PointAndDone: TYPE = SVSceneTypes.PointAndDone;
PointGenerator: TYPE = SVSceneTypes.PointGenerator;
PointSetOp: TYPE = SVRayTypes.PointSetOp;	-- {union, intersection, difference}
Scene: TYPE = SVSceneTypes.Scene;
SelectionClass: TYPE = SVSceneTypes.SelectionClass;
SelectMode: TYPE = SVSceneTypes.SelectMode;
Shape: TYPE = SVSceneTypes.Shape;
ShapeObj: TYPE = SVSceneTypes.ShapeObj;
ShowAsType: TYPE = SVSceneTypes.ShowAsType;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
SliceDescriptorObj: TYPE = SVSceneTypes.SliceDescriptorObj;
SliceParts: TYPE = SVSceneTypes.SliceParts;
ToolData: TYPE = SVSceneTypes.ToolData;
Vector3d: TYPE = SV3d.Vector3d;
Viewer: TYPE = ViewerClasses.Viewer;

Problem: SIGNAL [msg: Rope.ROPE] = Feedback.Problem;

bBoxCacheSize: NAT = 3;

CreatePrimitive: PUBLIC PROC [name: Rope.ROPE, object: Rope.ROPE, scene: Scene, artwork: Artwork _ NIL, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [prim: Slice, masterObjectFound: BOOL, success: BOOL] = {
masterObject: MasterObject;
toolMasterObject: MasterObject;
shape: Shape;
toolName: Rope.ROPE;

BEGIN
success _ TRUE;
IF SVScene.AssemblyNameIsPresent[name, scene] THEN GOTO NameAlreadyPresent;
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ CoordSys.NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
[masterObject, masterObjectFound] _ SVScene.FindObjectFromName[object, scene];
IF NOT masterObjectFound THEN RETURN;
IF artwork = NIL THEN artwork _
SVArtwork.CreateColorArtwork[ImagerColor.ColorFromRGB[[.6,.6,.8]], plastic]; -- light blue
shape _ NEW[ShapeObj];
shape.mo _ masterObject;
prim _ NEW[SliceObj _ [
name: name,
coordSys: NIL,
shape: shape,
bBoxCache: FunctionCache.Create[maxEntries: bBoxCacheSize],
artwork: artwork,
showAs: normal,
isTool: isTool,
toolMasterObject: toolMasterObject
]];
EXITS
NameAlreadyPresent => {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Slice ", name, " already present."], oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN[NIL, TRUE, FALSE];
};
END;
};
AddPrimitive: PUBLIC PROC [prim: Slice, size: Vector3d, parent: Slice, mat: Matrix4by4, scene: Scene] RETURNS [success: BOOL] = {
scalarName: Rope.ROPE;
shape: Shape;
IF ISTYPE[parent.shape, SliceList] THEN { -- add to old SliceList
alist: SliceList _ NARROW[parent.shape];
cs: CoordSystem;
scalarCS: CoordSystem;
cs _ CoordSys.CreateCoordSysInTree[prim.name, mat, parent.coordSys, scene.coordSysRoot
!CoordSys.NameAlreadyExists => ERROR];
prim.coordSys _ cs;
scalarName _ CoordSys.NameWithSuffix[prim.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ CoordSys.CreateScalarsOnlyCoordSysInTree[scalarName, size, cs, scene.coordSysRoot
!CoordSys.NameAlreadyExists => ERROR];
shape _ NARROW[prim.shape];
shape.coordSys _ scalarCS;
parent.shape _ SVUtility.AppendToAssemblyList[prim, alist];
success _ TRUE;
}
ELSE {
Feedback.AppendRaw[$Solidviews, "Attempt to add subassembly to primitive.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN[FALSE];
};
};
CreatePrimitiveAtExistingCoordSys: PUBLIC PROC [name: Rope.ROPE, object: Rope.ROPE, size: Vector3d, scene: Scene, coordSys: CoordSystem, artwork: Artwork _ NIL, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Slice, masterObjectFound: BOOL] = {
masterObject: MasterObject;
toolMasterObject: MasterObject;
shape: Shape;
scalarCS: CoordSystem;
toolName, scalarName: Rope.ROPE;

IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ CoordSys.NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
[masterObject, masterObjectFound] _ SVScene.FindObjectFromName[object, scene];
IF NOT masterObjectFound THEN {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Couldn't add assembly ", name, ". Master object ", object, " not found."], oneLiner];
Feedback.BlinkRaw[$Solidviews];
};
IF artwork = NIL THEN artwork _
SVArtwork.CreateColorArtwork[ImagerColor.ColorFromRGB[[.6,.6,.8]], plastic]; -- light blue
shape _ NEW[ShapeObj];
shape.mo _ masterObject;
assembly _ NEW[SliceObj _ [
name: name,
coordSys: NIL,
shape: shape,
bBoxCache: FunctionCache.Create[maxEntries: bBoxCacheSize],
artwork: artwork,
showAs: normal,
isTool: isTool,
toolMasterObject: toolMasterObject
]];
assembly.coordSys _ coordSys;
scalarName _ CoordSys.NameWithSuffix[assembly.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ CoordSys.CreateScalarsOnlyCoordSysInTree[scalarName, size, coordSys, scene.coordSysRoot];
shape.coordSys _ scalarCS;
};


CreateCluster: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp _ union, scene: Scene, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Slice, success: BOOL] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[Imager.white, plastic]; -- white
toolMasterObject: MasterObject;
toolName: Rope.ROPE;

BEGIN
success _ TRUE;
IF SVScene.AssemblyNameIsPresent[name, scene] THEN GOTO NameInUse;
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ CoordSys.NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
assembly _ NEW[SliceObj _ [
name: name,
coordSys: NIL,
shape: NEW[SliceListObj _ [NIL, pointSetOp]],
bBoxCache: FunctionCache.Create[maxEntries: bBoxCacheSize],
artwork: artwork,
showAs: normal,
isTool: isTool,
toolMasterObject: toolMasterObject
]];
EXITS
NameInUse => {
Feedback.AppendRaw[$Solidviews, Rope.Cat["Composite name ", name, " is already registered.  Try another."], oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN[NIL, FALSE];
};
END;
};

AddCluster: PUBLIC PROC [cluster: Slice, parent: Slice, mat: Matrix4by4, scene: Scene] RETURNS [success: BOOL] = {
IF IsComposite[parent] THEN{ -- add to old SliceList
alist: SliceList _ NARROW[parent.shape];
cluster.coordSys _ CoordSys.CreateCoordSysInTree[cluster.name, mat, parent.coordSys, scene.coordSysRoot];
parent.shape _ SVUtility.AppendToAssemblyList[cluster, alist];
}
ELSE {
Feedback.AppendRaw[$Solidviews, "Attempt to add subassembly to primitive.", oneLiner];
Feedback.BlinkRaw[$Solidviews];
RETURN[FALSE];
};
};

CreateClusterAssemblyAtExistingCoordSys: PUBLIC PROC [name: Rope.ROPE, pointSetOp: PointSetOp, scene: Scene, coordSys: CoordSystem, isTool: BOOL _ FALSE, toolData: ToolData _ NIL] RETURNS [assembly: Slice] = {
artwork: Artwork _ SVArtwork.CreateColorArtwork[Imager.white, plastic]; -- white
toolMasterObject: MasterObject;
toolName: Rope.ROPE;
IF toolData = NIL THEN toolMasterObject _ NIL
ELSE {
toolName _ CoordSys.NameWithSuffix[name, "$$tool", scene.coordSysRoot];
toolMasterObject _ SVToolObject.ToolMakeMasterObject[toolName, toolData];
};
assembly _ NEW[SliceObj _ [
name: name,
coordSys: NIL,
shape: NEW[SliceListObj _ [NIL, pointSetOp]],
bBoxCache: FunctionCache.Create[maxEntries: bBoxCacheSize],
artwork: artwork,
showAs: normal,
isTool: isTool,
toolMasterObject: toolMasterObject
]];
assembly.coordSys _ coordSys;
};



AttemptToAddSubassemblyToPrimitive: PUBLIC SIGNAL = CODE;
ConnectAssemblyToParent: PUBLIC PROC [assembly: Slice, parent: Slice] = {
IF IsComposite[parent] THEN { -- add to old SliceList
alist: SliceList _ NARROW[parent.shape];
parent.shape _ SVUtility.AppendToAssemblyList[assembly, alist];
}
ELSE SIGNAL AttemptToAddSubassemblyToPrimitive;
};


IsComposite: PUBLIC PROC [assem: Slice] RETURNS [BOOL] = {
RETURN[ISTYPE [assem.shape, SliceList] OR assem.shape = NIL];
};

GetHedron: PUBLIC PROC [mo: MasterObject] RETURNS [hedron: BoundHedron] = {
hedron _ mo.class.getHedron[mo];
};

BoundBoxEntry: TYPE = REF BoundBoxEntryObj;
BoundBoxEntryObj: TYPE = RECORD [
bBox: BoundBox,
ok: BOOL _ FALSE
];

GetBoundBox: PUBLIC PROC [assem: Slice, parts: SliceParts, camera: Camera] RETURNS [bBox: BoundBox] = {
CompareEntries2: PROC [argument: FunctionCache.Domain] RETURNS [good: BOOL] = {
thisName: Rope.ROPE _ NARROW[argument];
good _ Rope.Equal[thisName, camera.viewName, FALSE];
};
bBoxCache: FunctionCache.Cache _ assem.bBoxCache;
oldEntryAny: REF ANY;
oldEntry: BoundBoxEntry;
ok: BOOL;
BEGIN
[oldEntryAny, ok] _ FunctionCache.Lookup[bBoxCache, CompareEntries2];
IF NOT ok THEN GOTO UpdateTheCache -- not in cache
ELSE {
oldEntry _ NARROW[oldEntryAny];
IF NOT oldEntry.ok THEN GOTO UpdateTheCache -- cache out of date
ELSE bBox _ oldEntry.bBox;
};
EXITS
UpdateTheCache => {
UpdateBoundBoxForCamera[assem, camera];
bBox _ GetBoundBox[assem, parts, camera]; -- recursive call
};
END;
};

UpdateBoundBoxForCamera: PUBLIC PROC [assem: Slice, camera: Camera] = {
CompareEntries: PROC [argument: FunctionCache.Domain] RETURNS [good: BOOL] = {
thisName: Rope.ROPE _ NARROW[argument];
good _ Rope.Equal[thisName, camera.viewName, FALSE];
};
bBoxCache: FunctionCache.Cache _ assem.bBoxCache;
oldEntryAny: REF ANY;
oldEntry: BoundBoxEntry;
ok: BOOL _ FALSE;

[oldEntryAny, ok] _ FunctionCache.Lookup[bBoxCache, CompareEntries];
IF ok THEN {
oldEntry _ NARROW[oldEntryAny];
FillBox[oldEntry.bBox, assem, camera];
oldEntry.ok _ TRUE;
}
ELSE {
newEntry: BoundBoxEntry _ NEW[BoundBoxEntryObj];
newEntry.bBox _ SVBoundBox.NullBoundBox[];
FillBox[newEntry.bBox, assem, camera];
newEntry.ok _ TRUE;
FunctionCache.Insert[bBoxCache, camera.viewName, newEntry, 0];
};
};

FillBox: PROC [bBox: BoundBox, slice: Slice, camera: Camera] = {
shape: Shape _ NARROW[slice.shape];
hedron: BoundHedron;
mo: MasterObject _ shape.mo;
hedron _ GetHedron[mo];
SVBoundBox.FillBoundBoxFromBoundHedron[hedron, camera, shape.coordSys, bBox];
EnlargeByOffset[bBox, 2.0]; -- allow for stroke width
};

EnlargeByOffset: PROC [bBox: BoundBox, offset: REAL] = {
IF bBox.null OR bBox.infinite THEN RETURN;
bBox.loX _ bBox.loX - offset;
bBox.hiX _ bBox.hiX + offset;
bBox.loY _ bBox.loY - offset;
bBox.hiY _ bBox.hiY + offset;
};

UpdateBoundBoxes: PROC [slice: Slice, cameraList: LIST OF Camera _ NIL] = {
oldEntry: BoundBoxEntry;
bBoxCache: FunctionCache.Cache _ slice.bBoxCache;
allCache: LIST OF FunctionCache.CacheEntry _ FunctionCache.GetList[bBoxCache];
FOR list: LIST OF FunctionCache.CacheEntry _ allCache, list.rest UNTIL list = NIL DO
oldEntry _ NARROW[list.first.value];
IF oldEntry # NIL THEN oldEntry.ok _ FALSE;
ENDLOOP;
FOR list: LIST OF Camera _ cameraList, list.rest UNTIL list = NIL DO
UpdateBoundBoxForCamera[slice, list.first];
ENDLOOP;
};
DrawTransform: PUBLIC PROC [sliceD: SliceDescriptor, dc: Imager.Context, scene: Scene, camera: Camera, transform: Matrix4by4] = {

SELECT camera.style FROM
wire => DrawWireAssemblyTransform[sliceD, dc, camera, transform];
shaded => ERROR; -- use AddPolygonsToBufferTransform
normals => {
assem: Slice _ sliceD.slice;
oldAssemblyWORLD: Matrix4by4 _ CoordSys.WRTWorld[assem.coordSys];
newAssemblyWORLD: Matrix4by4 _ Matrix3d.Mult[oldAssemblyWORLD, transform];
AbsTransf[assem, scene, newAssemblyWORLD];
DrawNormalsAssembly[dc, assem, scene, camera];
AbsTransf[assem, scene, oldAssemblyWORLD];
};
ENDCASE => SIGNAL NotYetImplemented;
};

DeeperPlanarPolygon: PROC [x,y: PriorityQueue.Item, data: REF _ NIL] RETURNS [BOOL] = {
xS: PlanarSurface _ NARROW[x];
yS: PlanarSurface _ NARROW[y];
RETURN[xS.depth < yS.depth];
};

DrawParts: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL, dc: Imager.Context, scene: Scene, camera: Camera, quick: BOOL] = {
IF parts = NIL THEN Draw[slice, dc, scene, camera];
};
Draw: PUBLIC PROC [assem: Slice, dc: Imager.Context, scene: Scene, camera: Camera] = {
sliceD: SliceDescriptor _ NewParts[assem, NIL, [0,0,0], slice];
DrawTransform[sliceD, dc, scene, camera, Matrix3d.Identity[]];
};

DrawWireAssembly: PROC [assembly: Slice, dc: Imager.Context, camera: Camera] = {
SetColor[dc, camera, Imager.black];
SELECT assembly.showAs FROM
tool => {
toolMasterObject: MasterObject _ assembly.toolMasterObject;
IF toolMasterObject = NIL THEN {
Feedback.AppendTypescriptRaw[$Solidviews, Rope.Cat["Slice ", assembly.name, " is a tool but has no tool data.  Contact implementor."], oneLiner];
RETURN;
};
toolMasterObject.class.lineDraw[assembly, dc, camera];
};
normal => {
WITH assembly.shape SELECT FROM
assems: SliceList => {
FOR subassemblies: LIST OF Slice _ assems.list, subassemblies.rest
UNTIL subassemblies = NIL DO
DrawWireAssembly[subassemblies.first, dc, camera];
ENDLOOP;
};
shape: Shape => {
shape.mo.class.lineDraw[assembly, dc, camera];
};
ENDCASE => ERROR;
};
invisible => {};
both => ERROR Feedback.Problem[msg: "Can't have both"];
ENDCASE => ERROR;
};

DrawWireAssemblyTransform: PROC [sliceD: SliceDescriptor, dc: Imager.Context, camera: Camera, transform: Matrix4by4] = {
assembly: Slice _ sliceD.slice;
SetColor[dc, camera, Imager.black];
SELECT assembly.showAs FROM
normal => {
WITH assembly.shape SELECT FROM
assems: SliceList => {
SIGNAL Problem[msg: "LineDraw not implemented for composite assemblies"];
};
shape: Shape => {
shape.mo.class.lineDrawTransform[sliceD, dc, camera, transform];
};
ENDCASE => ERROR;
};
invisible, tool => {};
both => ERROR Feedback.Problem[msg: "Can't have both"];
ENDCASE => ERROR;
};


AddPolygonsToBuffer: PUBLIC PROC [surfaceQueue: PriorityQueue.Ref, assembly: Slice, camera: Camera] = {
PutAssemblyOnQueue[assembly, surfaceQueue, camera.coordSys];
};

AddPolygonsToBufferTransform: PUBLIC PROC [surfaceQueue: PriorityQueue.Ref, sliceD: SliceDescriptor, scene: Scene, camera: Camera, transform: Matrix4by4] = {
PutAssemblyOnQueueTransform[sliceD, surfaceQueue, camera.coordSys, transform];
};
DrawBuffer: PUBLIC PROC [dc: Imager.Context, surfaceQueue: PriorityQueue.Ref, scene: Scene, camera: Camera] = {
DoDrawBuffer: PROC = {
thisPlanarSurf: PlanarSurface;
mo: MasterObject;
FOR i: INT IN[1..PriorityQueue.Size[surfaceQueue]] DO
thisPlanarSurf _ NARROW[PriorityQueue.Remove[surfaceQueue]];
mo _ thisPlanarSurf.mo;
mo.class.drawSurf[dc, thisPlanarSurf, scene.lightSources, camera];
ENDLOOP;
};
Imager.DoSaveAll[dc, DoDrawBuffer];
};

DrawNormalsAssembly: PROC [dc: Imager.Context, assembly: Slice, scene: Scene, camera: Camera] = {
lightSources: LightSourceList _ scene.lightSources;
SetColor[dc, camera, Imager.black];
WITH assembly.shape SELECT FROM
assems: SliceList => {
FOR subassemblies: LIST OF Slice _ assems.list, subassemblies.rest
UNTIL subassemblies = NIL DO
DrawNormalsAssembly[dc, subassemblies.first, scene, camera];
ENDLOOP;
};
shape: Shape => {
shape.mo.class.normalsDraw[dc, shape.mo.shadeBody, camera, shape.coordSys];
};
ENDCASE => ERROR;
};

DrawSelectionFeedback: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
pointGen: SVSceneTypes.PointGenerator;
selectedD: SliceDescriptor _ DescriptorFromParts[slice, selectedParts];
pointGen _ PointsInDescriptor[selectedD];
FOR pointAndDone: SVSceneTypes.PointAndDone _ NextPoint[pointGen], NextPoint[pointGen] UNTIL pointAndDone.done DO
SVDraw3d.DrawSelectedJoint[dc, pointAndDone.point, camera];
ENDLOOP;
};

CountSurfacesInAssembly: PROC [assembly: Slice] RETURNS [surfCount: NAT] = {
WITH assembly.shape SELECT FROM
assems: SliceList => surfCount _ CountSurfacesInAssemblyList[assems];
shape: Shape => surfCount _ shape.mo.class.countSurf[shape.mo];
ENDCASE => ERROR;
};

CountSurfacesInAssemblyList: PROC [asl: SliceList] RETURNS [surfCount: NAT] = {
surfCount _ 0;
FOR list: LIST OF Slice _ asl.list, list.rest UNTIL list = NIL DO
surfCount _ surfCount + CountSurfacesInAssembly[list.first];
ENDLOOP;
};

PutAssemblyOnQueue: PROC [assembly: Slice, q: PriorityQueue.Ref, cameraCS: CoordSystem] = {
thisSurf: PlanarSurface;
cameraNormal: Vector3d;
surfList: PlanarSurfaceList;

SELECT assembly.showAs FROM
tool => {
toolMasterObject: MasterObject _ assembly.toolMasterObject;
surfList _ toolMasterObject.class.getSurf[assembly, cameraCS];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
thisSurf _ surfList.first;
cameraNormal _ Matrix3d.UpdateVectorWithInverse[CoordSys.FindCameraInTermsOf[assembly.coordSys, cameraCS], thisSurf.normal];
thisSurf.normal _ cameraNormal;
PriorityQueue.Insert[q, thisSurf];
ENDLOOP;
};
normal => {
WITH assembly.shape SELECT FROM
assems: SliceList => {
FOR list: LIST OF Slice _ assems.list, list.rest UNTIL list = NIL DO
PutAssemblyOnQueue[list.first, q, cameraCS];
ENDLOOP;
};
shape: Shape => {
surfList _ shape.mo.class.getSurf[assembly, cameraCS];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
thisSurf _ surfList.first;
cameraNormal _ Matrix3d.UpdateVectorWithInverse[CoordSys.FindCameraInTermsOf[shape.coordSys, cameraCS], thisSurf.normal];
thisSurf.normal _ cameraNormal;
IF thisSurf.normal[3] >0 THEN PriorityQueue.Insert[q,thisSurf];
ENDLOOP;
};
ENDCASE => ERROR;
};
invisible => {};
both => ERROR Feedback.Problem[msg: "Can't have both."];
ENDCASE => ERROR;
};	-- end of PutAssemblyOnQueue

PutAssemblyOnQueueTransform: PROC [sliceD: SliceDescriptor, q: PriorityQueue.Ref, cameraCS: CoordSystem, transform: Matrix4by4] = {
thisSurf: PlanarSurface;
cameraNormal: Vector3d;
surfList: PlanarSurfaceList;
assembly: Slice _ sliceD.slice;

SELECT assembly.showAs FROM
tool => {};
normal => {
WITH assembly.shape SELECT FROM
assems: SliceList => {
FOR list: LIST OF Slice _ assems.list, list.rest UNTIL list = NIL DO
PutAssemblyOnQueue[list.first, q, cameraCS];
ENDLOOP;
};
shape: Shape => {
surfList _ shape.mo.class.getSurfTransform[sliceD, cameraCS, transform];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
thisSurf _ surfList.first;
cameraNormal _ Matrix3d.UpdateVectorWithInverse[CoordSys.FindCameraInTermsOf[shape.coordSys, cameraCS], thisSurf.normal];
thisSurf.normal _ cameraNormal;
IF thisSurf.normal[3] >0 THEN PriorityQueue.Insert[q,thisSurf];
ENDLOOP;
};
ENDCASE => ERROR;
};
invisible => {};
both => ERROR Feedback.Problem[msg: "Can't have both."];
ENDCASE => ERROR;
};	-- end of PutAssemblyOnQueue


SetColor: PROC [dc: Imager.Context, camera: Camera, color: Color] = {
IF camera.colorFilm THEN Imager.SetColor[dc, color]
ELSE {
intensity: REAL _ ImagerColorPrivate.IntensityFromColor[NARROW[color]];
Imager.SetColor[dc, ImagerColor.ColorFromGray[1.0-intensity]]};
};
NotYetImplemented: PUBLIC SIGNAL = CODE;

Transform: PUBLIC PROC [sliceD: SliceDescriptor, scene: Scene, transform: Matrix4by4] = {

shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
mo.class.transform[sliceD, scene, transform];
UpdateBoundBoxes[sliceD.slice];
};

IncTransf: PUBLIC PROC [c: Slice, scene: Scene, m: Matrix4by4, d: CoordSystem _ NIL, dFixed: BOOL _ FALSE, cameraList: LIST OF Camera _ NIL] = {
assemCS: CoordSystem _ c.coordSys;
IF d = NIL THEN d _ scene.coordSysRoot;
IncTransfCS[assemCS, d, m, dFixed];
UpdateBoundBoxes[c, cameraList];
};

IncTransfCS: PUBLIC PROC [c: CoordSystem, d: CoordSystem, m: Matrix4by4, dFixed: BOOL _ FALSE] = {
p: CoordSystem;
cWorld, dWorld, pWorld: Matrix4by4;

IF MatrixHasScaling[m] THEN {
SIGNAL Feedback.Problem[msg: "SVTransform.IncTransf got illegal matrix.  Ignored."];
RETURN};
p _ CoordSys.Parent[c];
IF p = NIL THEN ERROR; -- cannot translate WORLD for now
IF d = NIL THEN ERROR;

cWorld _ CoordSys.WRTWorld[c];
pWorld _ CoordSys.WRTWorld[p];
dWorld _ CoordSys.WRTWorld[d];
CoordSys.SetMat[c, SVMatrixOps.IncTransf[cWorld, pWorld, dWorld, m]];

IF dFixed THEN SVTransforms.AbsTransfMatrix[d, Matrix3d.Identity[], dWorld];
};

AbsTransf: PUBLIC PROC [c: Slice, scene: Scene, n: Matrix4by4, d: CoordSystem _ NIL, dFixed: BOOL _ FALSE, cameraList: LIST OF Camera _ NIL] = {
assemCS: CoordSystem _ c.coordSys;
IF d = NIL THEN d _ scene.coordSysRoot;
AbsTransfCS[assemCS, d, n, dFixed];
UpdateBoundBoxes[c, cameraList];
};
AbsTransfCS: PUBLIC PROC [c: CoordSystem, d: CoordSystem, n: Matrix4by4, dFixed: BOOL _ FALSE] = {
p: CoordSystem;
dWorld, pWorld: Matrix4by4;

IF Rope.Equal[CoordSys.Name[c], "SCREEN", TRUE] THEN {CoordSys.SetMat[c, n]; RETURN};
p _ CoordSys.Parent[c];
IF p = NIL THEN ERROR; -- cannot transform WORLD.
IF d = NIL THEN ERROR;

dWorld _ CoordSys.WRTWorld[d];
pWorld _ CoordSys.WRTWorld[p];
CoordSys.SetMat[c, SVMatrixOps.AbsTransf[pWorld, dWorld, n]];
IF dFixed THEN SVTransforms.AbsTransfMatrix[d, Matrix3d.Identity[], dWorld];
};

TugTransf: PUBLIC PROC [c: Slice, scene: Scene, tugBoat: CoordSystem, n: Matrix4by4, d: CoordSystem _ NIL, cameraList: LIST OF Camera _ NIL] = {
assemCS: CoordSystem _ c.coordSys;
IF d = NIL THEN d _ scene.coordSysRoot;
TugTransfCS[assemCS, tugBoat, d, n];
UpdateBoundBoxes[c, cameraList];
};

TugTransfCS: PUBLIC PROC [C: CoordSystem, tugBoat: CoordSystem, D: CoordSystem, N: Matrix4by4] = {
F: Matrix4by4 _ CoordSys.FindAInTermsOfB[C, tugBoat];
AbsTransfCS[tugBoat, D, N];
AbsTransfCS[C, tugBoat, F];
};

TugTransfLeaveTug: PUBLIC PROC [c: Slice, scene: Scene, tugBoat: CoordSystem, n: Matrix4by4, d: CoordSystem _ NIL, cameraList: LIST OF Camera _ NIL] = {
assemCS: CoordSystem _ c.coordSys;
IF d = NIL THEN d _ scene.coordSysRoot;
TugTransfLeaveTugCS[assemCS, tugBoat, d, n];
UpdateBoundBoxes[c, cameraList];
};

TugTransfLeaveTugCS: PUBLIC PROC [C: CoordSystem, tugBoat: CoordSystem, D: CoordSystem, N: Matrix4by4] = {
F: Matrix4by4;
saveTugMat: Matrix4by4 _ CoordSys.GetMat[tugBoat];

F _ CoordSys.FindAInTermsOfB[C, tugBoat];
AbsTransfCS[tugBoat, D, N];
AbsTransfCS[C, tugBoat, F];
CoordSys.SetMat[tugBoat, saveTugMat];
};

ScalePrimitive: PUBLIC PROC [c: Slice, sx, sy, sz: REAL, cameraList: LIST OF Camera _ NIL] = {
shape: Shape;
scalarCS: CoordSystem;
scalars: Vector3d;
IF NOT ISTYPE[c.shape, Shape] THEN ERROR;
shape _ NARROW[c.shape];
scalarCS _ shape.coordSys;
scalars _ CoordSys.GetScalars[scalarCS];
scalars[1] _ scalars[1]*sx;
scalars[2] _ scalars[2]*sy;
scalars[3] _ scalars[3]*sz;
CoordSys.SetScalars[scalarCS, scalars];
UpdateBoundBoxes[c, cameraList];
};

MatrixHasScaling: PRIVATE PROC [mat: Matrix4by4] RETURNS [BOOL] = {
sx, sy, sz: REAL;
almostZero: REAL _ 1.0e-4;
[sx, sy, sz] _ Matrix3d.ScaleFromMatrix[mat];
IF ABS[sx - 1.0] > almostZero OR ABS[sy-1.0] > almostZero OR ABS[sz - 1.0] > almostZero
THEN RETURN[TRUE]
ELSE RETURN [FALSE];
};

Describe: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [rope: Rope.ROPE] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
RETURN[mo.class.describe[sliceD]];
};
DescribeHit: PUBLIC PROC [slice: Slice, hitData: REF ANY] RETURNS [rope: Rope.ROPE] = {
shape: Shape _ NARROW[slice.shape];
mo: MasterObject _ shape.mo;
RETURN[mo.class.describeHit[mo, hitData]];
};
EmptyParts: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [BOOL] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
IF sliceD.parts = NIL THEN RETURN[TRUE];
RETURN[mo.class.emptyParts[sliceD]];
};
NewParts: PUBLIC PROC [slice: Slice, hitData: REF ANY, hitPoint: Point3d, mode: SelectMode] RETURNS [sliceD: SliceDescriptor] = {
shape: Shape _ NARROW[slice.shape];
mo: MasterObject _ shape.mo;
RETURN[mo.class.newParts[slice, hitData, hitPoint, mode]];
};

DescriptorFromParts: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [sliceD: SliceDescriptor] = {
sliceD _ NEW[SliceDescriptorObj _ [slice, parts]];
};
UnionParts: PUBLIC PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aPlusB: SliceDescriptor] = {
shape: Shape;
mo: MasterObject;
IF partsA = NIL AND partsB = NIL THEN RETURN[NIL];
IF partsA = NIL THEN shape _ NARROW[partsB.slice.shape]
ELSE shape _ NARROW[partsA.slice.shape];
mo _ shape.mo;
RETURN[mo.class.unionParts[partsA, partsB]];
};
DifferenceParts: PUBLIC PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aMinusB: SliceDescriptor] = {
shape: Shape;
mo: MasterObject;
IF partsA = NIL AND partsB = NIL THEN RETURN[NIL];
IF partsA = NIL THEN shape _ NARROW[partsB.slice.shape]
ELSE shape _ NARROW[partsA.slice.shape];
mo _ shape.mo;
RETURN[mo.class.differenceParts[partsA, partsB]];
};
MovingParts: PUBLIC PROC [slice: Slice, selectedParts: SliceParts] RETURNS [background, overlay, rubber, drag: SliceDescriptor] = {
shape: Shape _ NARROW[slice.shape];
mo: MasterObject _ shape.mo;
[background, overlay, rubber, drag] _ mo.class.movingParts[slice, selectedParts];
};

AugmentParts: PUBLIC PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] RETURNS [more: SliceDescriptor] = {
mo: MasterObject;
mo _ NARROW[sliceD.slice.shape, Shape].mo;
more _ mo.class.augmentParts[sliceD, selectClass];
};
PointsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [PointGenerator] = {
assembly: Slice;
mo: MasterObject;
shape: Shape;
assembly _ sliceD.slice;
shape _ NARROW[assembly.shape];
mo _ shape.mo;
RETURN[mo.class.pointsInDescriptor[sliceD]];
};
NextPoint: PUBLIC PROC [pointGen: PointGenerator] RETURNS [pointAndDone: PointAndDone] = {
assembly: Slice;
mo: MasterObject;
shape: Shape;
ptBlockandDone: PointAndDone;
blockWORLD: Matrix4by4;
assembly _ pointGen.sliceD.slice;
shape _ NARROW[assembly.shape];
mo _ shape.mo;
ptBlockandDone _ mo.class.nextPoint[pointGen];
IF ptBlockandDone.done THEN RETURN[[[0,0,0], TRUE]];
blockWORLD _ CoordSys.WRTWorld[shape.coordSys];
pointAndDone.point _ Matrix3d.Update[ptBlockandDone.point, blockWORLD];
pointAndDone.done _ FALSE;
};

ClosestPointToPoint: PUBLIC PROC [sliceD: SliceDescriptor, testPoint: Point3d, criticalR: REAL] RETURNS [bestDist: REAL, pointWORLD: Point3d, hitData: REF ANY, success: BOOL] = {
mo: MasterObject;
mo _ NARROW[sliceD.slice.shape, Shape].mo;
[bestDist, pointWORLD, hitData, success] _ mo.class.closestPointToPoint[sliceD, testPoint, criticalR];
};

ClosestPointToLine: PUBLIC PROC [sliceD: SliceDescriptor, cameraPoint: Point2d, line3d: Line3d, criticalR: REAL, camera: Camera] RETURNS [bestDist: REAL, pointWORLD: Point3d, hitData: REF ANY, success: BOOL] = {
mo: MasterObject;
mo _ NARROW[sliceD.slice.shape, Shape].mo;
[bestDist, pointWORLD, hitData, success] _ mo.class.closestPointToLine[sliceD, cameraPoint, line3d, criticalR, camera];
};

ClosestSegmentToLine: PUBLIC PROC [sliceD: SliceDescriptor, cameraPoint: Point2d, line3d: Line3d, criticalR: REAL, camera: Camera] RETURNS [bestDist: REAL, pointWORLD: Point3d, hitData: REF ANY, success: BOOL] = {
mo: MasterObject;
mo _ NARROW[sliceD.slice.shape, Shape].mo;
[bestDist, pointWORLD, hitData, success] _ mo.class.closestSegmentToLine[sliceD, cameraPoint, line3d, criticalR, camera];
};

ClosestJointToHitData: PUBLIC PROC [sliceD: SliceDescriptor, worldPt: Point3d, normal: Vector3d, hitData: REF ANY] RETURNS [jointD: SliceDescriptor, jointPos: Point3d, jointNormal: Vector3d] = {
newHitData: REF ANY;
success: BOOL;
dist: REAL;
jointD _ sliceD;
[dist, jointPos, newHitData, success] _ ClosestPointToPoint[sliceD, worldPt, Real.LargestNumber];
IF NOT success THEN ERROR;
jointNormal _ normal;
};

END.


ขSVAssemblyImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by Bier on February 24, 1987 2:11:06 pm PST
Contents:  Solidviews assemblies are like Gargoyle slices.  They draw themselves as a unit.  They update their bounding boxes.  Their parts can be selected.  This module is to Solidviews what GGSlice is to Gargoyle.


We will wire up the shape to a scalars coordinate frame below.
Create a primitive assembly, based on the master object named object, in scene.  Its surface looks are described by artwork.  It will look normal to start with (as opposed to as a "Tool" or invisible).  If toolData is not provided, a close-fitting tool will be computed when needed.
Object must be on the master object list of scene.  Use AddMasterObjectToScene below.
If success is FALSE, a message is written to the message window and nothing is done (NameAlreadyPresent and AttemptToAddSubassemblyToPrimitive are failure reasons).

Scale the primitive assembly by size and add it as a child of parent, so that assemblyparent will be mat.

We will wire up the shape to a scalars coordinate frame below.
Now wire up the assembly to its parent.
Like CreatePrimitive but adds an assembly which can have children (can be passed as "parent" later.
Now wire up the assembly to its parent.
Not for general use.  Used in conjunction with Create*AtExistingCoordSys to wire up children to parents.  Text filein uses this.
Fundamentals
Returns a bounding polyhedron in master object coordinates.
A camera has moved, or we are using this camera for the first time.  Update the entry for this camera (adding an entry if needed).
We have moved assembly, so its bounding boxes have changed in all views.  For each camera in cameraList, update its entry to be correct (add an entry if necessary).  Mark all other entries as incorrect.

Drawing
DrawShadedAssembly: PROC [dc: Imager.Context, assembly: Slice, scene: Scene, camera: Camera] = {
Count the total number of surfaces and make a priority queue of the appropriate size.
predictedQueueSize: NAT _ CountSurfacesInAssembly[assembly];
surfaceQueue: PriorityQueue.Ref _
PriorityQueue.Predict[predictedQueueSize, DeeperPlanarPolygon];
mo: MasterObject;
thisPlanarSurf: PlanarSurface;
DrawShadedAssemblyAux: PROC = {
Now put the surfaces on the queue
PutAssemblyOnQueue[assembly, surfaceQueue, camera.coordSys];

Take the surfaces off the queue in order and draw them
FOR i: INT IN[1..PriorityQueue.Size[surfaceQueue]] DO
thisPlanarSurf _ NARROW[PriorityQueue.Remove[surfaceQueue]];
mo _ thisPlanarSurf.mo;
mo.class.drawSurf[dc, thisPlanarSurf, scene.lightSources, camera];
ENDLOOP;
};
Imager.DoSaveAll[dc, DrawShadedAssemblyAux];
};

oldAssemblyWORLD: Matrix4by4 _ CoordSys.WRTWorld[assembly.coordSys];
newAssemblyWORLD: Matrix4by4 _ Matrix3d.Mult[oldAssemblyWORLD, transform];
AbsTransf[assembly, scene, newAssemblyWORLD];
AbsTransf[assembly, scene, oldAssemblyWORLD];
IF assembly = except THEN RETURN;
Eliminate most back-facing surfaces at this point by a simple test.
Eliminate most back-facing surfaces at this point by a simple test.
Transforming
Four ways to move an assembly C.  If d is NIL, the anchor is assumed to be WORLD.
Incrementally transform C with respect to D by M.  If D is a descendent of C, this could result in D moving as well.  If this is not desired, set DFixed to TRUE and IncTransf makes sure that D doesn't move.
Incrementally transform C with respect to D by M.  If D is a descendent of C, this could result in D moving as well.  If this is not desired, set DFixed to TRUE and IncTransf makes sure that D doesn't move.
Absolutely transform C with respect to D by M.  If D is a descendent of C, this could result in D moving as well.  If this is not desired, set DFixed to TRUE and AbsTransf makes sure that D doesn't move.

Absolutely transform C with respect to D by M.  If D is a descendent of C, this could result in D moving as well.  If this is not desired, set DFixed to TRUE and AbsTransf makes sure that D doesn't move.
IF MatrixHasScaling[n] THEN {
SIGNAL Feedback.Problem[msg: "SVTransform.AbsTransf got illegal matrix.  Ignored."];
RETURN}; -- commented out by Bier on May 27, 1987 3:27:32 pm PDT
Absolutely transforms tugBoat with respect to D and then C with respect to tugBoat.
Like TugTransf, but returns tugBoat to its original location.
Like TugTransf, but returns the Tugboat to its original position.

Parts

Part Generators
Hit Testing
This is an incomplete implementation, just to get off the ground.
ส$*˜J˜Icodeš
œ™Kšœ
ฯm
œ1™<Kš
œ7™7Kš
œื
™ื
K™š
ฯk	˜	Jš
œฝ˜ฝ—K˜šœžœ
ž˜Jšžœศ
˜ฯ
šžœ˜Kš
œ˜——Kš
ž˜˜J–

"Cedar" stylešœ	žœ˜%J–

"Cedar" stylešœžœ˜!J–

"Cedar" stylešœžœ˜)J–

"Cedar" stylešœžœ˜/J–

"Cedar" stylešœ
žœ˜'J–

"Cedar" stylešœ
žœ˜'J–

"Cedar" stylešœ
žœ˜-J–

"Cedar" stylešœžœ˜#J–

"Cedar" stylešœžœ˜Jšœ
žœ˜-Jšœžœ!˜3J–

"Cedar" stylešœžœ ˜5Kšœžœ˜Jšœžœ˜/Jšœžœ˜#J–

"Cedar" stylešœžœ˜1J–

"Cedar" stylešœžœ"˜9Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜/Jšœžœ˜3Jšœžœฯc$˜NJ–

"Cedar" stylešœžœ˜!Jšœžœ˜3Jšœžœ˜+Jšœžœ˜!Jšœ
žœ˜'Jšœžœ˜+J–

"Cedar" stylešœžœ ˜5J–

"Cedar" stylešœžœ#˜;J–

"Cedar" stylešœžœ˜+J–

"Cedar" stylešœ
žœ˜'Jšœ
žœ˜Jšœžœ˜$J˜—Jšฯnœžœžœ˜4J–

"Cedar" style˜J–

"Cedar" stylešœžœ˜J–

"Cedar" style˜š œžœ
žœ
žœžœ#žœ
žœžœžœžœ"žœžœ˜ู
Jš
œ˜Jš
œ˜J˜
Jšœžœ
˜J˜š
ž˜Jšœ
žœ
˜Jšžœ,žœ
žœ˜KJšžœžœ
žœž˜-šžœ˜Jš
œG˜GJš
œI˜IJ˜—Jš
œN˜NJšžœ
žœžœ
žœ
˜%šžœžœ
žœ
˜JšœMŸ
˜Z—Jšœžœ˜š
œ˜J™J™>—šœžœ
˜Jš
œ˜Jšœ
žœ
˜Jš
œ
˜
J•StartOfExpansion:[maxEntries: 
INT _ 10, maxTotalSize: 
INT _ 2147483647]š
œ;˜;Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—š
ž˜š
œ˜Jš
œY˜YJš
œ˜Jšžœ
žœžœžœ˜J˜——Jšžœ
˜—J˜J–

"Cedar" styleš
œš™šJ–

"Cedar" styleš
œU™UJ–

"Cedar" styleš
œค
™ค
J–

"Cedar" style™—š
 œžœ
žœMžœžœ˜
J–

"Cedar" stylešœVฯuœ
™iJšœžœ
˜J˜
šžœ
žœžœŸ˜AJšœžœ˜(Jš
œ˜Jš
œ˜šœฯbœ4˜VJšœžœ˜&—Jš
œ˜Jš
œQ˜Qšœขœ)˜\Jšœžœ˜&—Jšœžœ
˜Jš
œ˜Jš
œ;˜;Jšœ
žœ
˜J˜
—šžœ˜Iprocš
œV˜VLš
œ˜Jšžœ
žœ˜J˜—J˜J–

"Cedar" style™—–

"Cedar" styleš !œžœ
žœ
žœžœJžœ
žœžœžœžœ&žœ˜‡Jš
œ˜Jš
œ˜J˜
Jš
œ˜Jšœžœ
˜ J˜Jšžœžœ
žœž˜-šžœ˜Jš
œG˜GJš
œI˜IJ˜—Jš
œN˜Nšžœ
žœžœ˜Jš
œ˜Jš
œ˜J˜—šžœžœ
žœ
˜JšœMŸ
˜Z—Jšœžœ˜š
œ˜J™>—šœžœ
˜Jš
œ˜Jšœ
žœ
˜Jš
œ
˜
J–:[maxEntries: 
INT _ 10, maxTotalSize: 
INT _ 2147483647]š
œ;˜;Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜J™'—Jš
œ˜Jš
œU˜UJšœขœ1˜dJš
œ˜Jš
œ˜J˜—J˜–

"Cedar" styleš 
œžœ
žœ
žœ8žœžœžœžœžœ˜ท
J–

"Cedar" styleš
œc™cJšœHŸ˜PJš
œ˜Jšœžœ
˜J˜š
ž˜Jšœ
žœ
˜Jšžœ,žœ
žœ˜BJšžœžœ
žœž˜-šžœ˜Jš
œG˜GJš
œI˜IJ˜—šœžœ
˜Jš
œ˜Jšœ
žœ
˜Jšœžœžœ˜-J–:[maxEntries: 
INT _ 10, maxTotalSize: 
INT _ 2147483647]š
œ;˜;Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—–

"Cedar" styleš
ž˜–

"Cedar" styleš
œ˜Jš
œv˜vJš
œ˜Jšžœ
žœžœ˜Jš
œ˜——J–

"Cedar" stylešžœ
˜—J–

"Cedar" style˜J–

"Cedar" style˜—–

"Cedar" styleš
 
œžœ
žœ@žœžœ˜rJš
ข'™'šžœžœŸ˜4Jšœžœ˜(Jš
œi˜iJš
œ>˜>J˜
—šžœ˜Jš
œV˜VJš
œ˜Jšžœ
žœ˜J˜—J–

"Cedar" style˜J–

"Cedar" style˜—–

"Cedar" styleš 'œžœ
žœ
žœGžœžœžœžœ˜ั
JšœHŸ˜PJš
œ˜Jšœžœ
˜Jšžœžœ
žœž˜-šžœ˜Jš
œG˜GJš
œI˜IJ˜—šœžœ
˜Jš
œ˜Jšœ
žœ
˜Jšœžœžœ˜-J–:[maxEntries: 
INT _ 10, maxTotalSize: 
INT _ 2147483647]˜;Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜—Jš
œ˜Jš
œ˜J–

"Cedar" style˜J˜—J˜Jšข"œžœ
žœžœ
˜9–

"Cedar" styleš œžœ
žœ%˜IšžœžœŸ˜5Jšœžœ˜(Jš
œ?˜?J˜
—Jšžœ
žœ$˜/J˜J–

"Cedar" style˜J–

"Cedar" styleš
œ€
™€
—K˜š œžœžœžœ˜:Jšžœ
žœžœžœ˜=J˜J˜—J™š 	œžœ
žœžœ˜KK™;Kš
œ ˜ K˜K˜—Kšœžœžœ˜+šœžœžœ˜!K˜Kšœž˜K˜K˜—š œžœ
žœ3žœ˜gš œžœ"žœžœ˜OKšœžœžœ˜'Kšœ-žœ˜4K˜—Kš
œ1˜1Kšœ
žœ
žœ
˜Kš
œ˜Kšœžœ
˜	š
ž˜Kš
œE˜EKš	žœ
žœžœ
žœŸ˜2šžœ˜Kšœžœ˜Kš	žœ
žœ
žœ
žœŸ˜@Kšžœ˜K˜—š
ž˜˜Kš
œ'˜'Kšœ*Ÿ˜;K˜——Kšžœ
˜—K˜K˜—š œžœ#˜GK™‚
š œžœ"žœžœ˜NKšœžœžœ˜'Kšœ-žœ˜4K˜—Kš
œ1˜1Kšœ
žœ
žœ
˜Kš
œ˜Kšœžœžœ
˜K˜Kš
œD˜Dšžœžœ˜Kšœžœ˜Kš
œ&˜&Kšœžœ
˜K˜
—šžœ˜Kšœžœ˜0Kš
œ*˜*Kš
œ&˜&Kšœžœ
˜Kš
œ>˜>K˜—K˜K˜—š œžœ3˜@Kšœžœ˜#Kš
œ˜Kš
œ˜Kš
œ˜Kš
œM˜MKšœŸ˜5K˜K˜—š œžœžœ˜8Kšžœžœžœ
žœ
˜*Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—š
 œžœžœ
žœ
žœ˜KKš
œส
™ส
Kš
œ˜Kš
œ1˜1Kšœ
žœ
žœ=˜Nšžœžœ
žœ0žœžœ
ž˜TKšœžœ˜$Kšžœžœ
žœžœ
˜+Kšžœ
˜—šžœžœ
žœ žœžœ
ž˜DJš
œ+˜+Jšžœ
˜—K˜—J™J™š 
œžœ
žœg˜
J˜šžœž˜Jš
œA˜AJšœ
žœŸ#˜4š
œ˜Jš
œ˜Jšœกœ1˜AJšœกœ(กœ
˜JJšœ#กœ˜*Jš
œ.˜.Jšœ#กœ˜*J˜—Jšžœžœ˜$—K˜K˜—š œžœH™`Jš
œU™UJšœžœ%™<š
œ!™!Jš
œ?™?—Jš
œ™Jš
œ™š œžœ™Jš
œ!™!Jš
œ<™<J™Jš
œ6™6šžœžœ
žœ&ž™5Jšœžœ%™<Jš
œ™Jš
œB™BJšžœ
™—J™—Jš
œ,™,Jš
œ™J™—š œžœ!žœžœžœžœ˜WJšœžœ˜Jšœžœ˜Jšžœ˜Jš
œ˜J˜—š
 	œžœ
žœ$žœ;žœ˜
Jšžœ	žœ
žœ ˜3J˜—š œžœ
žœE˜VJšœ*žœ˜?Jš
œ>˜>Jš
œ˜J˜—š œžœ:˜PJš
œ#˜#šžœž˜š
œ	˜	Jš
œ;˜;šžœžœ
žœ˜ Jš
œ‘
˜‘
Jšžœ
˜J˜—Jš
œ6˜6J˜—š
œ˜Jšžœžœ
ž˜š
œ˜Jšžœžœ
žœ(˜Bšžœžœ
ž˜Jš
œ2˜2Jšžœ
˜—Jš
œ˜—š
œ˜Jš
œ.˜.Jš
œ˜—Jšžœžœ
˜J˜—Jš
œ˜Jšœžœ*˜7Jšžœžœ
˜—Jš
œ˜J˜—š œžœY˜xJš
œ˜Jš
œ#˜#šžœž˜š
œ˜Jšžœžœ
ž˜š
œ˜JšžœC˜IJš
œ˜—š
œ˜Jš
œ@˜@Jš
œ˜—Jšžœžœ
˜J˜—Jš
œ˜Jšœžœ*˜7Jšžœžœ
˜—Jš
œ˜J˜J˜—š œžœG˜gJš
œ<˜<Jš
œ˜J˜—š œžœ
žœt˜
Jšœกœ4™DJšœกœ(กœ
™JJšœ&กœ™-Jšœ&กœ™-Jš
œN˜NJ˜—š 
œžœX˜oš œžœ˜Jš
œ˜Jš
œ˜šžœžœ
žœ&ž˜5Jšœžœ%˜<Jš
œ˜Jš
œB˜BJšžœ
˜—J˜—Jš
œ#˜#J˜J˜—š œžœH˜aJš
œ3˜3Jš
œ#˜#Jšžœžœ
ž˜š
œ˜Jšžœžœ
žœ(˜BJšžœžœ
ž˜Jš
œ<˜<Jšžœ
˜Jš
œ˜—š
œ˜Jš
œK˜KJš
œ˜—Jšžœžœ
˜Jš
œ˜J˜—š œžœ
žœ”
žœ˜ฟ
Jš
œ&˜&Jš
œG˜GJš
œ)˜)šžœTžœž˜qJš
œ;˜;Jšžœ
˜—K˜—J˜š œžœžœ
žœ˜Lšžœžœ
ž˜Jš
œE˜EJš
œ?˜?Jšžœžœ
˜—Jš
œ˜J˜—š œžœžœ
žœ˜OJš
œ˜šžœžœ
žœžœžœ
ž˜AJš
œ<˜<Jšžœ
˜—Jš
œ˜J˜—š œžœC˜[Jš
œ˜Jš
œ˜Jš
œ˜J˜šžœž˜š
œ	˜	Jš
œ;˜;Jš
œ>˜>šžœ$žœžœ
ž˜>Jš
œ˜Jš
œ|˜|Jš
œ˜Jš
œ"˜"Jšžœ
˜—J˜—š
œ˜šžœžœ
ž˜š
œ˜šžœžœ
žœ žœžœ
ž˜DJš
œ,˜,Jšžœ
˜—J˜—š
œ˜Jšžœžœ
žœ
™!Jš
œ6˜6šžœ$žœžœ
ž˜>Jš
œ˜Jš
œy˜yš
œ˜Jš
ขC™C—Jšžœžœ"˜?Jšžœ
˜—Jš
œ˜—Jšžœžœ
˜—J˜—Jš
œ˜Jšœžœ+˜8Jšžœžœ
˜—JšœŸ˜J˜—š œžœb˜ƒ
Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜šžœž˜Jš
œ˜š
œ˜šžœžœ
ž˜š
œ˜šžœžœ
žœ žœžœ
ž˜DJš
œ,˜,Jšžœ
˜—J˜—š
œ˜Jš
œH˜Hšžœ$žœžœ
ž˜>Jš
œ˜Jš
œy˜yš
œ˜Jš
ขC™C—Jšžœžœ"˜?Jšžœ
˜—Jš
œ˜—Jšžœžœ
˜—J˜—Jš
œ˜Jšœžœ+˜8Jšžœžœ
˜—JšœŸ˜J˜J˜—š œžœ7˜EJšžœžœ˜3šžœ˜Lšœžœ)žœ	˜GLš
œ?˜?—Jš
œ˜—Jšขœžœ
žœžœ˜)K™š 	œžœ
žœC˜YJ˜Jšœžœ˜*Jš
œ˜Jš
œ-˜-Kš
œ˜K˜K˜—K™Qš 	œžœ
žœ:žœ
žœžœžœ
žœ
žœ˜
Jšœœ
žœ.™ฮ
Kš
œ"˜"Kšžœžœ
žœ˜'Kš
œ#˜#Kš
œ ˜ K˜K˜—š
 œžœ
žœ9žœžœ˜bJšœœ
žœ.™ฮ
Lš
œ˜Lšœ
กœกœกœ
˜#L˜šžœžœ˜JšžœN˜TJšžœ˜—Lš
œ˜Lš	žœžœ
žœ
žœŸ!˜8Lšžœžœ
žœ
žœ
˜L˜Lšœ
กœ˜Lšœ
กœ˜Lšœ
กœ˜Lšœ*กœกœกœ˜EL˜Lšžœžœ7กœ˜LLš
œ˜L˜—š 	œžœ
žœ:žœ
žœžœžœ
žœ
žœ˜
Jšœž
œž
œž
œž
œž
œž
œ8žœž
œ™ห
Kš
œ"˜"Kšžœžœ
žœ˜'Kš œ˜#Kš
œ ˜ K˜J™—š
 œžœ
žœ9žœžœ˜bJšœž
œž
œž
œž
œž
œž
œ8žœž
œ™ห
Lš
œ˜Lšœ
กœ
กœ
˜L˜Lšžœ(žœžœžœ˜ULš
œ˜Lš	žœžœ
žœ
žœŸ˜1Lš
žœ
ž
œžœ
žœ
žœ
˜šžœžœ™JšžœN™TJšžœ:™@—L˜Lšœ
กœ˜Lšœ
กœ˜Lšœ*กœกœ˜=Lšžœžœ7กœ˜LLš
œ˜L˜—š 	œžœ
žœPžœžœ
žœ
žœ˜
Jšœ.ž
œ$™SKš
œ"˜"Kšžœžœ
žœ˜'Kš
œ$˜$Kš
œ ˜ J˜J˜—š œžœ
žœž
œ%ž
œž
œ˜bJšž
œ(ž
œ˜5Jšœž
œž
œ˜Jšœž
œž
œ˜J˜J˜—š œžœ
žœPžœžœ
žœ
žœ˜˜
Jš
œ=™=Kš
œ"˜"Kšžœžœ
žœ˜'Kš
œ,˜,Kš
œ ˜ J˜J˜—š
ะbnœžœž
œ%ž
œž
œ˜jJ™AJšž
œ
˜Jš
œ2˜2J˜Jšž
œž
œ˜)Jšœž
œž
œ˜Jšœž
œž
œ˜Jš
œ%˜%J˜J˜—š œžœ
žœžœžœ
žœ
žœ˜^Jš
œ
˜
J˜Jš
œ˜Jš
žœ
žœ
žœžœ
žœ
˜)Jšœžœ
˜Jš
œ˜Jš
œ(˜(Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ'˜'Kš
œ ˜ Jš
œ˜J˜—š
 œžœ
žœžœžœ˜CJšœžœ
˜Jšœžœ
˜Jš
œ-˜-Jšžœ
žœžœ
žœžœ
žœ˜WJšžœ
žœ
žœ
˜Jšžœ
žœžœ˜Jš
œ˜J˜—š
 œžœ
žœžœ
žœ˜MKšœžœ˜*Kš
œ˜Kšžœ˜"K˜—š œžœ
žœžœ
žœžœ
žœ˜WKšœžœ˜#Kš
œ˜Kšžœ$˜*K˜—K™K™š
ฃ
œžœ
žœžœžœ˜DKšœžœ˜*Kš
œ˜Kš
žœžœ
žœ
žœ
žœ˜(Kšžœ˜$K˜—š œžœ
žœžœ
žœ'žœ˜
Kšœžœ˜#Kš
œ˜Kšžœ4˜:K˜K˜—š œžœ
žœ#žœ˜hKšœ	žœ&˜2K˜—K™š 
œžœ
žœ4žœ˜pKš
œ
˜
Kš
œ˜Kšžœ
žœ
žœ
žœ
žœ
žœ
žœ˜2Kšžœ
žœ
žœ	žœ˜7Kšžœ	žœ˜(Kš
œ˜Kšžœ&˜,K˜—š	ฃข
œ
žœ
žœ4žœ˜vKš
œ
˜
Kš
œ˜Kšžœ
žœ
žœ
žœ
žœ
žœ
žœ˜2Kšžœ
žœ
žœ	žœ˜7Kšžœ	žœ˜(Kš
œ˜Kšžœ+˜1K˜—š œžœ
žœ+žœ9˜ƒ
Kšœžœ˜#Kš
œ˜Kš
œQ˜QK˜K˜—šฃœžœ
žœ8žœ˜tK˜Kšœžœ˜*Kš
œ2˜2K˜—Kš
œ™š œžœ
žœžœ˜VKš
œ˜K˜K˜
Kš
œ˜Kšœžœ˜Kš
œ˜Kšžœ&˜,K˜—–

"Cedar" styleš 	œžœ
žœžœ!˜ZKš
œ˜K˜K˜
Kšœกœ˜Kšœกœ
˜Kš
œ!˜!Kšœžœ˜Kš
œ˜Kšœกœ'˜.Kšžœžœ
žœžœ˜4Kšœกœ%˜/Kšœ'กœกœ˜GKšœžœ
˜J–

"Cedar" styleš
œ˜—K˜Kš
œ™š œžœ
žœ:žœžœžœกœžœ
žœžœ˜ฒ
K˜Kšœžœ˜*KšœกœQ˜fK˜K˜—š œžœ
žœLžœžœžœกœžœ
žœžœ˜ำ
K˜Kšœžœ˜*Kšœกœb˜wK˜—K˜š œžœ
žœLžœžœžœกœžœ
žœžœ˜ี
K˜Kšœžœ˜*Kšœกœd˜yK˜—K˜š œžœ
žœHžœ
žœžœH˜ย
K™AKšœžœ
žœ
˜Kšœ	žœ
˜Kšœžœ
˜Kš
œ˜Kš
œa˜aKšžœ
žœ	žœ
žœ
˜Kš
œ˜K˜K˜—Kšžœ
˜K˜J˜—…—mขา