DIRECTORY
AtomButtonsTypes, Feedback, FunctionCache, GGBoundBox, Imager, ImagerColor, ImagerColorPrivate, PriorityQueue, Real, Rope, SV2d, SV3d, SVArtwork, SVAssembly, SVBasicTypes, SVBoundBox, SVCoordSys, SVGraphics, SVMasterObject, SVMatrix3d, SVMatrixOps, SVModelTypes, SVScene, SVSceneTypes, SVToolObject, SVTransforms, SVUtility, ViewerClasses;

SVAssemblyImpl: CEDAR PROGRAM
IMPORTS Feedback, FunctionCache, GGBoundBox, Imager, ImagerColor, ImagerColorPrivate, PriorityQueue, Rope, SVArtwork, SVBoundBox, SVCoordSys, SVGraphics, SVMasterObject, SVMatrix3d, SVMatrixOps, SVScene, SVToolObject, SVTransforms, SVUtility
EXPORTS SVAssembly
 =
BEGIN

Artwork: TYPE = SVModelTypes.Artwork;
BoundBlock: TYPE = REF BoundBlockObj;
BoundBlockObj: TYPE = SVBasicTypes.BoundBlockObj;
BoundBox: TYPE = SVBasicTypes.BoundBox;
BoundHedron: TYPE = SVBasicTypes.BoundHedron;
Camera: TYPE = SVModelTypes.Camera;
Classification: TYPE = SVSceneTypes.Classification;
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;
PointPairAndDone: TYPE = SVSceneTypes.PointPairAndDone;
PointGenerator: TYPE = SVSceneTypes.PointGenerator;
PointPairGenerator: TYPE = SVSceneTypes.PointPairGenerator;
PointSetOp: TYPE = SVSceneTypes.PointSetOp;	-- {union, intersection, difference}
Primitive: TYPE = SVSceneTypes.Primitive;
Ray: TYPE = SVSceneTypes.Ray;
Scene: TYPE = SVSceneTypes.Scene;
SelectionClass: TYPE = SVSceneTypes.SelectionClass;
SelectMode: TYPE = SVSceneTypes.SelectMode;
Shape: TYPE = SVSceneTypes.Shape;
ShapeObj: TYPE = SVSceneTypes.ShapeObj;
ShowAsType: TYPE = SVSceneTypes.ShowAsType;
Slice: TYPE = SVSceneTypes.Slice;
SliceList: TYPE = SVSceneTypes.SliceList;
SliceListObj: TYPE = SVSceneTypes.SliceListObj;
SliceObj: TYPE = SVSceneTypes.SliceObj;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
SliceDescriptorObj: TYPE = SVSceneTypes.SliceDescriptorObj;
SliceParts: TYPE = SVSceneTypes.SliceParts;
ToolData: TYPE = SVSceneTypes.ToolData;
Vector3d: TYPE = SV3d.Vector3d;
Viewer: TYPE = ViewerClasses.Viewer;

SurfaceSeq: TYPE = REF SurfaceSeqObj;
SurfaceSeqObj: TYPE = RECORD [
surfs: SEQUENCE len: NAT OF PlanarSurface
];
SurfaceGenerator: TYPE = REF SurfaceGeneratorObj;
SurfaceGeneratorObj: TYPE = RECORD [
surfs: SurfaceSeq
];

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 _ SVCoordSys.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 _ SVCoordSys.CreateCoordSysInTree[prim.name, mat, parent.coordSys, scene.coordSysRoot];
prim.coordSys _ cs;
scalarName _ SVCoordSys.NameWithSuffix[prim.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ SVCoordSys.CreateScalarsOnlyCoordSysInTree[scalarName, size, cs, scene.coordSysRoot];
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 _ SVCoordSys.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 _ SVCoordSys.NameWithSuffix[assembly.name, "$$Scalars", scene.coordSysRoot];
scalarCS _ SVCoordSys.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 _ SVCoordSys.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 _ SVCoordSys.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 _ SVCoordSys.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];
};

GetBoundBlock: PUBLIC PROC [slice: Slice, parts: SliceParts _ NIL] RETURNS [bBlock: BoundBlock] = {
mo: MasterObject _ NARROW[slice.shape, Shape].mo;
hedron: BoundHedron _ GetHedron[mo];
point: Point3d;
shape: Shape _ NARROW[slice.shape];
shapeWorld: Matrix4by4 _ SVCoordSys.WRTWorld[shape.coordSys];
bBlock _ NEW[BoundBlockObj];
point _ hedron[0];
point _ SVMatrix3d.Update[point, shapeWorld];
bBlock.loX _ bBlock.hiX _ point[1];
bBlock.loY _ bBlock.hiY _ point[2];
bBlock.loZ _ bBlock.hiZ _ point[3];
bBlock.null _ bBlock.infinite _ FALSE;
FOR i: NAT IN [1..hedron.len) DO
point _ hedron[i];
point _ SVMatrix3d.Update[point, shapeWorld];
bBlock.loX _ MIN[bBlock.loX, point[1]];
bBlock.loY _ MIN[bBlock.loY, point[2]];
bBlock.loZ _ MIN[bBlock.loZ, point[3]];
bBlock.hiX _ MAX[bBlock.hiX, point[1]];
bBlock.hiY _ MAX[bBlock.hiY, point[2]];
bBlock.hiZ _ MAX[bBlock.hiZ, point[3]];
ENDLOOP;
};

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 _ GGBoundBox.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, hiddenLine => ERROR; -- use AddPolygonsToBufferTransform
normals => {
assem: Slice _ sliceD.slice;
oldAssemblyWORLD: Matrix4by4 _ SVCoordSys.WRTWorld[assem.coordSys];
newAssemblyWORLD: Matrix4by4 _ SVMatrix3d.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, SVMatrix3d.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, eyeWorld: Point3d] = {
PutAssemblyOnQueue[assembly, surfaceQueue, camera.coordSys, eyeWorld];
};

AddPolygonsToBufferTransform: PUBLIC PROC [surfaceQueue: PriorityQueue.Ref, sliceD: SliceDescriptor, scene: Scene, camera: Camera, eyeWorld: Point3d, transform: Matrix4by4] = {
PutAssemblyOnQueueTransform[sliceD, surfaceQueue, camera.coordSys, eyeWorld, transform];
};

DrawBuffer: PUBLIC PROC [dc: Imager.Context, surfaceQueue: PriorityQueue.Ref, scene: Scene, camera: Camera, hiddenLine: BOOL] = {
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, eyeWorld, hiddenLine];
ENDLOOP;
};
eyeWorld: Point3d _ SVGraphics.LocalToWorld[[0,0,camera.focalLength], camera.coordSys];
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;
};

RayCast: PUBLIC PROC [cameraPoint: Point2d, localRay: Ray, sliceD: SliceDescriptor, prim: Primitive] RETURNS [class: Classification] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
class _ mo.class.rayCast[cameraPoint, localRay, sliceD, prim];
};
RayCastNoBBoxes: PUBLIC PROC [localRay: Ray, sliceD: SliceDescriptor, prim: Primitive, positiveTOnly: BOOL _ TRUE] RETURNS [class: Classification] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
class _ mo.class.rayCastNoBBoxes[localRay, sliceD, prim, positiveTOnly];
};
RayCastBoundingSpheres: PUBLIC PROC [localRay: Ray, sliceD: SliceDescriptor, prim: Primitive, positiveTOnly: BOOL _ TRUE] RETURNS [class: Classification] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
class _ mo.class.rayCastBoundingSpheres[localRay, sliceD, prim, positiveTOnly];
};
DrawSelectionFeedback: PUBLIC PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
shape: Shape _ NARROW[slice.shape];
mo: MasterObject _ shape.mo;
mo.class.drawSelectionFeedback[slice, selectedParts, hotParts, dc, camera, dragInProgress, caretIsMoving, hideHot, quick];
};

DrawAttractorFeedback: PUBLIC PROC [sliceD: SliceDescriptor, selectedParts: SliceParts, dragInProgress: BOOL, dc: Imager.Context, camera: Camera] = {
shape: Shape _ NARROW[sliceD.slice.shape];
mo: MasterObject _ shape.mo;
mo.class.drawAttractorFeedback[sliceD, selectedParts, dragInProgress, dc, camera];
};

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, eyeWorld: Point3d] = {
surfList: PlanarSurfaceList;

SELECT assembly.showAs FROM
tool => {
toolMasterObject: MasterObject _ assembly.toolMasterObject;
surfList _ toolMasterObject.class.getSurf[assembly, cameraCS, eyeWorld];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
PriorityQueue.Insert[q, surfList.first];
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, eyeWorld];
ENDLOOP;
};
shape: Shape => {
cameraShape: Matrix4by4;
cameraShape _ SVCoordSys.FindCameraInTermsOf[shape.coordSys, cameraCS];
surfList _ shape.mo.class.getSurf[assembly, cameraCS, eyeWorld];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
PriorityQueue.Insert[q, surfList.first];
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, eyeWorld: Point3d, transform: Matrix4by4] = {
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, eyeWorld];
ENDLOOP;
};
shape: Shape => {
surfList _ shape.mo.class.getSurfTransform[sliceD, cameraCS, eyeWorld, transform];
FOR surfList _ surfList, surfList.rest UNTIL surfList = NIL DO
PriorityQueue.Insert[q, surfList.first];
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];
};

IncTransfMatrix: PUBLIC PROC [c: Slice, dWorld: Matrix4by4, m: Matrix4by4, cameraList: LIST OF Camera _ NIL] = {
p: CoordSystem;
cWorld, pWorld: Matrix4by4;
assemCS: CoordSystem _ c.coordSys;

p _ SVCoordSys.Parent[assemCS];
IF p = NIL THEN ERROR; -- cannot translate WORLD for now

cWorld _ SVCoordSys.WRTWorld[assemCS];
pWorld _ SVCoordSys.WRTWorld[p];
SVCoordSys.SetMat[assemCS, SVMatrixOps.IncTransf[cWorld, pWorld, dWorld, m]];
UpdateBoundBoxes[c, cameraList];
};

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

p _ SVCoordSys.Parent[c];
IF p = NIL THEN ERROR; -- cannot translate WORLD for now
IF d = NIL THEN ERROR;

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

IF dFixed THEN SVTransforms.AbsTransfMatrix[d, SVMatrix3d.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[SVCoordSys.Name[c], "SCREEN", TRUE] THEN {SVCoordSys.SetMat[c, n]; RETURN};
p _ SVCoordSys.Parent[c];
IF p = NIL THEN ERROR; -- cannot transform WORLD.
IF d = NIL THEN ERROR;

dWorld _ SVCoordSys.WRTWorld[d];
pWorld _ SVCoordSys.WRTWorld[p];
SVCoordSys.SetMat[c, SVMatrixOps.AbsTransf[pWorld, dWorld, n]];
IF dFixed THEN SVTransforms.AbsTransfMatrix[d, SVMatrix3d.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 _ SVCoordSys.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 _ SVCoordSys.GetMat[tugBoat];

F _ SVCoordSys.FindAInTermsOfB[C, tugBoat];
AbsTransfCS[tugBoat, D, N];
AbsTransfCS[C, tugBoat, F];
SVCoordSys.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 _ SVCoordSys.GetScalars[scalarCS];
scalars[1] _ scalars[1]*sx;
scalars[2] _ scalars[2]*sy;
scalars[3] _ scalars[3]*sz;
SVCoordSys.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] _ SVMatrix3d.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]];
};
IsEmptyParts: 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.isEmptyParts[sliceD]];
};
IsCompleteParts: 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.isCompleteParts[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, centroids: BOOL] RETURNS [PointGenerator] = {
assembly: Slice;
mo: MasterObject;
shape: Shape;
assembly _ sliceD.slice;
shape _ NARROW[assembly.shape];
mo _ shape.mo;
RETURN[mo.class.pointsInDescriptor[sliceD, centroids]];
};
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 _ SVCoordSys.WRTWorld[shape.coordSys];
pointAndDone.point _ SVMatrix3d.Update[ptBlockandDone.point, blockWORLD];
pointAndDone.done _ FALSE;
};

PointPairsInDescriptor: PUBLIC PROC [sliceD: SliceDescriptor] RETURNS [pointPairGen: PointPairGenerator] = {
assembly: Slice;
mo: MasterObject;
shape: Shape;
assembly _ sliceD.slice;
shape _ NARROW[assembly.shape];
mo _ shape.mo;
RETURN[mo.class.pointPairsInDescriptor[sliceD]];
};

NextPointPair: PUBLIC PROC [pointPairGen: PointPairGenerator] RETURNS [pointPairAndDone: PointPairAndDone] = {
assembly: Slice;
mo: MasterObject;
shape: Shape;
pointPairShapeandDone: PointPairAndDone;
shapeWorld: Matrix4by4;
assembly _ pointPairGen.sliceD.slice;
shape _ NARROW[assembly.shape];
mo _ shape.mo;
pointPairShapeandDone _ mo.class.nextPointPair[pointPairGen];
IF pointPairShapeandDone.done THEN RETURN[[[0,0,0], [0,0,0], TRUE]];
shapeWorld _ SVCoordSys.WRTWorld[shape.coordSys];
pointPairAndDone.lo _ SVMatrix3d.Update[pointPairShapeandDone.lo, shapeWorld];
pointPairAndDone.hi _ SVMatrix3d.Update[pointPairShapeandDone.hi, shapeWorld];
pointPairAndDone.done _ FALSE;
};

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

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

ClosestSegmentToLine: PUBLIC PROC [sliceD: SliceDescriptor, cameraPoint: Point2d, line3d: Line3d, t: REAL, camera: Camera] RETURNS [bestDist: REAL, pointWorld: Point3d, normalWorld: Vector3d, hitData: REF ANY, success: BOOL] = {
mo: MasterObject;
mo _ NARROW[sliceD.slice.shape, Shape].mo;
[bestDist, pointWorld, normalWorld, hitData, success] _ mo.class.closestSegmentToLine[sliceD, cameraPoint, line3d, t, 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, jointNormal, newHitData, success] _ ClosestPointToPoint[sliceD, worldPt, Real.LargestNumber, FALSE];
IF NOT success THEN ERROR;
};

WithinBoundBlock: PUBLIC PROC [slice: Slice, boundBlockWorld: BoundBlock, parts: SliceParts _ NIL] RETURNS [withinParts: SliceDescriptor] = {
mo: MasterObject;
mo _ NARROW[slice.shape, Shape].mo;
withinParts _ mo.class.withinBoundBlock[slice, boundBlockWorld, parts];
};


SetStrokeColor: PUBLIC PROC [slice: Slice, parts: SliceParts, color: Color _ NIL] = {
mo: MasterObject;
mo _ NARROW[slice.shape, Shape].mo;
mo.class.setStrokeColor[slice, parts, color];
};

GetStrokeColor: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [color: Color _ NIL] = {
mo: MasterObject;
mo _ NARROW[slice.shape, Shape].mo;
color _ mo.class.getStrokeColor[slice, parts];
};

SetFillColor: PUBLIC PROC [slice: Slice, parts: SliceParts, artwork: Artwork] = {
mo: MasterObject;
mo _ NARROW[slice.shape, Shape].mo;
mo.class.setFillColor[slice, parts, artwork];
};

GetFillColor: PUBLIC PROC [slice: Slice, parts: SliceParts] RETURNS [artwork: Artwork] = {
mo: MasterObject;
mo _ NARROW[slice.shape, Shape].mo;
artwork _ mo.class.getFillColor[slice, parts];
};

MakeBlockSlice: PUBLIC PROC [loX, loY, loZ, hiX, hiY, hiZ: REAL, corner: [0..7], transform: Matrix4by4, scene: Scene, feedback: FeedbackData] RETURNS [sliceD: SliceDescriptor] = {
sliceParts: SliceParts;
slice: Slice;
mo: MasterObject;
masterObjectFound, success: BOOL _ TRUE;

name: Rope.ROPE _ SVScene.UniqueAssemblyNameFrom["Block", scene];
[sliceParts, mo] _ SVMasterObject.MakeBlockSlice[name, loX, loY, loZ, hiX, hiY, hiZ, corner];
BEGIN
moFound: BOOL _ TRUE;
addSucceeds: BOOL _ TRUE;
SVScene.AddMasterObjectToScene[mo, scene
! SVScene.NameAlreadyPresent => {
Feedback.PutF[feedback, oneLiner, "%g name %g is already registered.  Try another.", [rope[mo.class.name]], [rope[mo.name]]];
Feedback.Blink[feedback]; addSucceeds _ FALSE; CONTINUE}
];
IF NOT addSucceeds THEN RETURN;
END;
[slice, masterObjectFound, success] _ CreatePrimitive[name, name, scene];
IF NOT masterObjectFound OR NOT success THEN ERROR;
sliceD _ DescriptorFromParts[slice, sliceParts];
};

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.

Hidden Surface

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
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.
IF MatrixHasScaling[m] THEN...
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.
jointNormal _ normal;

Style
ส*ท˜J˜Icodeš
œ™Kšœ
ฯm
œ1™<Kš
œ7™7Kš
œื
™ื
K™š
ฯk	˜	Jš
œำ˜ำ—K˜šœžœ
ž˜Jšžœ๊
˜๑
šžœ˜Kš
œ˜——Kš
ž˜˜J–

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

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

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

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

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

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

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

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

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

"Cedar" stylešœžœ"˜9Jšœ	žœ˜Jšœ	žœ˜Jšœžœ˜/Jšœžœ!˜7Jšœžœ˜3Jšœžœ#˜;Jšœžœฯc$˜PJšœžœ˜)Jšœžœ˜J–

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

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

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

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

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

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

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

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

"Cedar" stylešœ
žœ˜'Jšœ
žœ˜Jšœžœ˜$J˜—Ihead–

"Cedar" style™Idefault–

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

"Cedar" stylešœžœžœ˜M–

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

"Cedar" style˜—M–

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

"Cedar" stylešœžœžœ˜$M–

"Cedar" style˜M–

"Cedar" style˜M–

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

"Cedar" style˜J–

"Cedar" stylešœžœ˜J–

"Cedar" style˜š œžœ
žœ
žœžœ#žœ
žœžœžœžœ"žœžœ˜ู
Jš
œ˜Jš
œ˜J˜
Jšœžœ
˜J˜š
ž˜Jšœ
žœ
˜Jšžœ,žœ
žœ˜KJšžœžœ
žœž˜-šžœ˜Jš
œI˜IJš
œ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š
œ˜Jšœฯbœ6˜ZJš
œ˜Jš
œS˜SJšœขœ+˜`Jšœžœ
˜Jš
œ˜Jš
œ;˜;Jšœ
žœ
˜J˜
—šžœ˜Iprocš
œV˜VNš
œ˜Jšžœ
žœ˜J˜—J˜J–

"Cedar" style™—–

"Cedar" styleš !œžœ
žœ
žœžœJžœ
žœžœžœžœ&žœ˜‡Jš
œ˜Jš
œ˜J˜
Jš
œ˜Jšœžœ
˜ J˜Jšžœžœ
žœž˜-šžœ˜Jš
œI˜IJš
œ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š
œW˜WJšœขœ1˜fJš
œ˜Jš
œ˜J˜—J˜–

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

"Cedar" styleš
œc™cJšœHŸ˜PJš
œ˜Jšœžœ
˜J˜š
ž˜Jšœ
žœ
˜Jšžœ,žœ
žœ˜BJšžœžœ
žœž˜-šžœ˜Jš
œI˜IJš
œ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š
œk˜kJš
œ>˜>J˜
—šžœ˜Jš
œV˜VJš
œ˜Jšžœ
žœ˜J˜—J–

"Cedar" style˜J–

"Cedar" style˜—–

"Cedar" styleš 'œžœ
žœ
žœGžœžœžœžœ˜ั
JšœHŸ˜PJš
œ˜Jšœžœ
˜Jšžœžœ
žœž˜-šžœ˜Jš
œI˜IJš
œ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˜—š
 
œžœ
žœ$žœžœ˜cKšœžœ˜1Kš
œ$˜$Kš
œ˜Kšœžœ˜#Kšœกœ3˜=Kšœ	žœ˜Jš
œ˜Jšœ&กœ˜-Kš
œ#˜#Kš
œ#˜#Kš
œ#˜#Kšœ žœ
˜&šžœžœ
žœž˜ Jš
œ˜Jšœ&กœ˜-Jšœ
žœ˜'Jšœ
žœ˜'Jšœ
žœ˜'Jšœ
žœ˜'Jšœ
žœ˜'Jšœ
žœ˜'Jšžœ
˜—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šœžœŸ#˜@š
œ˜Jš
œ˜Jšœกœ3˜CJšœกœ*กœ
˜LJšœ#กœ˜*Jš
œ.˜.Jšœ#กœ˜*J˜—Jšžœžœ˜$—K˜K˜—š œžœ!žœžœžœžœ˜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กœ˜zJšœ?กœ˜FJš
œ˜J˜—š œžœ
žœ]กœ%˜ฐ
JšœFกœ
˜XJ˜J˜—š 
œžœ
žœažœ˜
š œžœ˜Jš
œ˜Jš
œ˜šžœžœ
žœ&ž˜5Jšœžœ%˜<Jš
œ˜JšœEกœ˜XJšžœ
˜—J˜—JšœกœO˜WJš
œ#˜#J˜J˜—š œžœH˜aJš
œ3˜3Jš
œ#˜#Jšžœžœ
ž˜š
œ˜Jšžœžœ
žœ(˜BJšžœžœ
ž˜Jš
œ<˜<Jšžœ
˜Jš
œ˜—š
œ˜Jš
œK˜KJš
œ˜—Jšžœžœ
˜Jš
œ˜J˜—š œžœ
žœQžœ˜ˆ
Kšœžœ˜*Kš
œ˜Kš
œ>˜>N˜—š œžœ
žœJžœžœžœ˜–
Kšœžœ˜*Kš
œ˜Kš
œH˜HN˜—š œžœ
žœJžœžœžœ˜
Kšœžœ˜*Kš
œ˜Kš
œO˜ON˜—š œžœ
žœ”
žœ˜ฟ
Kšœžœ˜#Kš
œ˜Kš
œz˜zK˜—J˜šะbnœžœ
žœFžœ)˜•
Kšœžœ˜*Kš
œ˜Kš
œR˜RK˜K˜—š œžœžœ
žœ˜Lšžœžœ
ž˜Jš
œE˜EJš
œ?˜?Jšžœžœ
˜—Jš
œ˜J˜—š œžœžœ
žœ˜OJš
œ˜šžœžœ
žœžœžœ
ž˜AJš
œ<˜<Jšžœ
˜—Jš
œ˜J˜—š œžœCกœ˜nJš
œ˜J˜šžœž˜š
œ	˜	Jš
œ;˜;JšœAกœ˜Hšžœ$žœžœ
ž˜>Jš
œ(˜(Jšžœ
˜—J˜—š
œ˜šžœžœ
ž˜š
œ˜šžœžœ
žœ žœžœ
ž˜DJšœ/กœ˜6Jšžœ
˜—J˜—š
œ˜Jšœกœ
˜Jšœกœ<˜GJšœ9กœ˜@šžœ$žœžœ
ž˜>Jš
œ(˜(Jšžœ
˜—Jš
œ˜—Jšžœžœ
˜—J˜—Jš
œ˜Jšœžœ+˜8Jšžœžœ
˜—JšœŸ˜J˜—š œžœKกœ%˜–
Jš
œ˜Jš
œ˜J˜šžœž˜Jš
œ˜š
œ˜šžœžœ
ž˜š
œ˜šžœžœ
žœ žœžœ
ž˜DJšœ/กœ˜6Jšžœ
˜—J˜—š
œ˜Jšœ@กœ
˜Ršžœ$žœžœ
ž˜>Jš
œ(˜(Jšžœ
˜—Jš
œ˜—Jšžœžœ
˜—J˜—Jš
œ˜Jšœžœ+˜8Jšžœžœ
˜—JšœŸ˜J˜J˜—š œžœ7˜EJšžœžœ˜3šžœ˜Nšœžœ)žœ	˜GNš
œ?˜?—Jš
œ˜—Jšขœžœ
žœžœ˜)K™š 	œžœ
žœC˜YJ˜Jšœžœ˜*Jš
œ˜Jš
œ-˜-Kš
œ˜K˜K˜—K™Qš 	œžœ
žœ:žœ
žœžœžœ
žœ
žœ˜
Jšœœ
žœ.™ฮ
Kš
œ"˜"Kšžœžœ
žœ˜'Kš
œ#˜#Kš
œ ˜ K˜K˜—š œžœ
žœ
กœ)žœ
žœ
žœ˜pNš
œ˜Nšœ
กœกœ
˜Kš
œ"˜"N˜Nš
œ˜Nš	žœžœ
žœ
žœŸ!˜8N˜Nšœ
กœ ˜&Nšœ
กœž
œ˜ Nš
œขœกœกœž
ะkuœ˜MKš
œ ˜ Nš
œ˜N˜—š
 œžœ
žœ9žœžœ˜bJšœœ
žœ.™ฮ
Nš
œ˜Nšœ
กœกœกœ
˜#N˜Jšžœžœ™Nš
œ˜Nš	žœžœ
žœ
žœŸ!˜8Nšžœžœ
žœ
žœ
˜N˜Nšœ
กœ˜ Nšœ
กœ˜ Nšœ
กœ˜ Nšœ,กœกœกœ˜GN˜Nšžœžœ9กœ˜NNš
œ˜N˜—š 	œžœ
žœ:žœ
žœžœžœ
žœ
žœ˜
Jšœž
œž
œž
œž
œž
œž
œ8žœž
œ™ห
Kš
œ"˜"Kšžœžœ
žœ˜'Kš œ˜#Kš
œ ˜ K˜J™—š
 œžœ
žœ9žœžœ˜bJšœž
œž
œž
œž
œž
œž
œ8žœž
œ™ห
Nš
œ˜Nšœ
กœ
กœ
˜N˜Nšžœ*žœžœžœ˜YNš
œ˜Nš	žœžœ
žœ
žœŸ˜1Nš
žœ
ž
œžœ
žœ
žœ
˜šžœžœ™JšžœN™TJšžœ:™@—N˜Nšœ
กœ˜ Nšœ
กœ˜ Nšœ,กœกœ˜?Nšžœžœ9กœ˜NNš
œ˜N˜—š 	œžœ
žœPžœžœ
žœ
žœ˜
Jšœ.ž
œ$™SKš
œ"˜"Kšžœžœ
žœ˜'Kš
œ$˜$Kš
œ ˜ J˜J˜—š œžœ
žœž
œ%ž
œž
œ˜bJšž
œ*ž
œ˜7Jšœž
œž
œ˜Jšœž
œž
œ˜J˜J˜—š œžœ
žœPžœžœ
žœ
žœ˜˜
Jš
œ=™=Kš
œ"˜"Kšžœžœ
žœ˜'Kš
œ,˜,Kš
œ ˜ J˜J˜—š
ฃœžœž
œ%ž
œž
œ˜jJ™AJšž
œ
˜Jš
œ4˜4J˜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™š
ฃœžœ
žœžœžœ˜FKšœžœ˜*Kš
œ˜Kš
žœžœ
žœ
žœ
žœ˜(Kšžœ ˜&K˜—š
ฃœžœ
žœžœžœ˜IKšœžœ˜*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˜Kš
œ™š
 œžœ
žœ&žœžœ˜gKš
œ˜K˜K˜
Kš
œ˜Kšœžœ˜Kš
œ˜Kšžœ1˜7K˜—–

"Cedar" styleš 	œžœ
žœžœ!˜ZKš
œ˜K˜K˜
Kšœกœ˜Kšœกœ
˜Kš
œ!˜!Kšœžœ˜Kš
œ˜Kšœกœ'˜.Kšžœžœ
žœžœ˜4Kšœกœ'˜1Kšœ)กœกœ˜IKšœžœ
˜J–

"Cedar" styleš
œ˜—K˜–

"Cedar" styleš œžœ
žœžœ'˜lKš
œ˜K˜K˜
Kš
œ˜Kšœžœ˜Kš
œ˜Kšžœ*˜0J–

"Cedar" style˜J–

"Cedar" style˜—–

"Cedar" styleš 
œžœ
žœ$žœ)˜nKš
œ˜K˜K˜
Kšœ	กœ˜(Kšœกœ
˜Kš
œ%˜%Kšœžœ˜Kš
œ˜Kšœ	กœ/˜=Kš
žœ
กœ
žœ
žœžœ˜DKšœกœ'˜1Kšœ1กœกœ˜NKšœ1กœกœ˜NKšœžœ
˜J–

"Cedar" style˜J–

"Cedar" style˜—Kš
œ™š œžœ
žœ2žœ
žœžœžœกœกœžœ
žœžœ˜า
K˜Kšœžœ˜*KšœกœกœT˜vK˜K˜—š œžœ
žœDžœžœžœžœกœกœžœ
žœžœ˜๓
K˜Kšœžœ˜*Kšœกœกœe˜‡
K˜—K˜š œžœ
žœDžœžœžœกœกœžœ
žœžœ˜ไ
K˜Kšœžœ˜*Kšœกœกœ\˜~K˜—K˜š œžœ
žœHžœ
žœžœH˜ย
K™AKšœžœ
žœ
˜Kšœ	žœ
˜Kšœžœ
˜Kš
œ˜Kšœnžœ˜uKšžœ
žœ	žœ
žœ
˜Kš
œ™K˜K˜—K™š œžœ
žœกœ"žœžœ#˜
K˜Kšœžœ˜#Kšœ9กœ	˜GK˜K˜—Kš
œ™K˜š œžœ
žœ2žœ˜UK˜Kšœžœ˜#Kš
œ-˜-K˜K˜—š
 œžœ
žœ#žœžœ˜^K˜Kšœžœ˜#Kš
œ.˜.K˜K˜—š œžœ
žœ8˜QK˜Kšœžœ˜#Kš
œ-˜-K˜K˜—š œžœ
žœ#žœ˜ZK˜Kšœžœ˜#Kš
œ.˜.K˜—K˜š
 œžœ
žœ žœOžœ˜ณ
Kš
œ˜K˜
K˜Kšœžœžœ
˜(K˜Kšœžœ2˜AKš
œ]˜]š
ž˜Nšœ	žœžœ
˜Nšœ
žœžœ
˜š
œ(˜(š
œ!˜!Nš
œ}˜}Nšœ(žœžœ
˜8Nš
œ˜——Nšžœ
žœ
žœ
žœ
˜Kšžœ
˜—Kš
œI˜IKšžœ
žœžœ
žœ	žœ
žœ
˜3Kš
œ0˜0K˜—K˜Kšžœ
˜K˜Jš
ก
˜
—…—„Fผ