<<>>
<<ImplicitConvolveCmdsImpl.mesa>>
<<Copyright Ó 1990 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, November 21, 1992 7:37 pm PST>>

DIRECTORY Commander, G3dBasic, G3dSpline, G3dTool, G3dVector, ImplicitConvolve, ImplicitDefs, ImplicitDesign, IO, RealFns, Rope;

ImplicitConvolveCmdsImpl: CEDAR PROGRAM
IMPORTS G3dBasic, G3dSpline, G3dVector, ImplicitConvolve, ImplicitDesign, IO, RealFns

~ BEGIN
<<Types>>
Triple:                TYPE ~ G3dBasic.Triple;
TripleSequence:        TYPE ~ G3dBasic.TripleSequence;
AnimProc:            TYPE ~ G3dTool.AnimateProc;
Primitive:                TYPE ~ ImplicitConvolve.Primitive;
PrimitiveList:        TYPE ~ ImplicitConvolve.PrimitiveList;
Tool:                    TYPE ~ ImplicitConvolve.Tool;
TripleList:            TYPE ~ ImplicitConvolve.TripleList;
ROPE:                    TYPE ~ Rope.ROPE;
<<Simple Commands>>
Data: TYPE ~ RECORD [tool: Tool];

MakeTool: PROC [name: ROPE, level: REAL, primitives: PrimitiveList, anim: AnimProc Ź NIL] ~ {
data: REF Data Ź NEW[Data];
data.tool Ź ImplicitConvolve.MakeTool[
name: name,
client: [animate: anim, data: data],
toolSettings: [level: level],
primitives: primitives];
};

Triangle: Commander.CommandProc ~ {
primitives: PrimitiveList Ź MakePolys[LIST[LIST[[0, 0, 0], [-.4, 0, .4], [.4, 0, .4]]]];
MakeTool["triangle", 0.2, primitives];
};

SegTri: Commander.CommandProc ~ {
a: Triple Ź [-.4, 0, .4];            -- upper left triangle
b: Triple Ź [.4, 0, .4];            -- upper right triangle
c: Triple Ź [.096, 0, 0];            -- lower right triangle, upper right segment
d: Triple Ź [-.096, 0, 0];         -- lower left triangle, upper left segment
e: Triple Ź [.096, 0, -.45];         -- lower right segment
f: Triple Ź [-.096, 0, -.45];     -- lower left segment
primitives: PrimitiveList Ź MakePolys[LIST[LIST[a, b, c, d], LIST[c, d, f, e]]];
MakeTool["segtri", 0.1, primitives];
};

Sticks: Commander.CommandProc ~ {
primitives: PrimitiveList Ź MakePolys[LIST[LIST[[0, 0, -.5], [0, 0, .5]], LIST[[-.5, 0, 0], [.5, 0, 0]]]];
MakeTool["sticks", 0.1, primitives];
};

Cylinder: Commander.CommandProc ~ {
primitives: PrimitiveList Ź MakePolys[LIST[LIST[[-.5, 0, 0], [.5, 0, 0]]]];
MakeTool["cylinder", 0.2, primitives];
};

Twist: Commander.CommandProc ~ {
a: Triple Ź [.4, 0, -.2];             -- lower right
b: Triple Ź [-.4, 0, -.2];         -- lower left
c: Triple Ź [-.4, 0, .2];             -- upper left
d: Triple Ź [.4, 0, .2];            -- upper right
twist: ImplicitConvolve.Twist Ź [0.0, 90.0*3.1415926535/180.0, [-.4, 0, 0], [.4, 0, 0]];
triples: TripleSequence Ź G3dBasic.TripleSequenceFromList[LIST[a, b, c, d]];
twister: Primitive Ź ImplicitConvolve.MakePrimitive[points: triples, extent: 0.1, twist: twist];
MakeTool["twist", 0.1, LIST[twister]];
};
<<Animated Curve>>
CurveMake: PROC [
bez0: G3dSpline.Bezier Ź [[-.5, -.2, -.25], [-.25, -.1, .25], [.25, .1, .25], [.5, .2, -.25]];
bez1: G3dSpline.Bezier Ź [[-.15, -.1, -.3], [-.05, -.05, .3], [.05, .05, .3], [.15, .1, -.3]];
bez: G3dSpline.Bezier Ź [
G3dVector.Interp[a, bez0.b0, bez1.b0],
G3dVector.Interp[a, bez0.b1, bez1.b1],
G3dVector.Interp[a, bez0.b2, bez1.b2],
G3dVector.Interp[a, bez0.b3, bez1.b3]];
spline: G3dSpline.Spline Ź G3dSpline.SplineFromBezier[bez];
p0: Triple Ź G3dSpline.Position[spline, 0.0];
IF nPts > 2 THEN FOR n: NAT IN [1..nPts) DO
p1: Triple Ź G3dSpline.Position[spline, REAL[n]/REAL[nPts-1]];
l Ź CONS[LIST[p0, p1], l];
p0 Ź p1;
ENDLOOP;
};

CurveAnim: AnimProc ~ {SetPolysFromPoints[clientData, CurveMake[alpha]]};

Curve: Commander.CommandProc ~ {
MakeTool["curve", 0.2, MakePolys[CurveMake[0.0]], CurveAnim];
};
<<Animated Cross>>
CrossRectangles: PROC [degrees: REAL] RETURNS [LIST OF TripleList] ~ {
MakeRectangle: PROC [p0, p1: Triple] RETURNS [rect: TripleList] ~ {
axis: Triple Ź G3dVector.Sub[p1, p0];
v: Triple Ź G3dVector.SetVectorLength[G3dVector.Cross[axis, [0, 0, 1]], 0.5];
v Ź G3dVector.RotateAbout[v, axis, degrees];
rect Ź LIST[p0, G3dVector.Add[p0, v], G3dVector.Add[p1, v], p1];
};
square: TripleList Ź LIST[[-.1, -.1, 0], [-.1, .1, 0], [.1, .1, 0], [.1, -.1, 0]];
left: TripleList Ź MakeRectangle[[-.1, .1, 0], [-.1, -.1, 0]];
right: TripleList Ź MakeRectangle[[.1, .1, 0], [-.1, .1, 0]];
top: TripleList Ź MakeRectangle[[.1, -.1, 0], [.1, .1, 0]];
bottom: TripleList Ź MakeRectangle[[-.1, -.1, 0], [.1, -.1, 0]];
RETURN[LIST[square, left, right, top, bottom]];
};

CrossAnim: AnimProc ~ {SetPolysFromPoints[clientData, CrossRectangles[90.0*alpha]]};

Cross: Commander.CommandProc ~ {
MakeTool["cross", 0.2, MakePolys[CrossRectangles[0]], CrossAnim];
};
<<Animated Rectangles>>
RectsPoints: PROC [angle: REAL] RETURNS [points: LIST OF TripleList] ~ {
x: REAL Ź 0.4*RealFns.Cos[angle];
y: REAL Ź 0.4*RealFns.Sin[angle];
a: Triple Ź [x, .4, y];            -- upper right rectangle1
b: Triple Ź [-x, .4, -y];            -- upper left rectangle1
c: Triple Ź [-x, 0, -y];            -- lower left rectangle1
d: Triple Ź [x, 0, y];             -- lower right rectangle1
e: Triple Ź [.4, 0, 0];            -- upper right rectangle2
f: Triple Ź [-.4, 0, 0];             -- upper left rectangle2
g: Triple Ź [-.4, -.4, 0];         -- lower left rectangle2
h: Triple Ź [.4, -.4, 0];             -- lower right rectangle2
points Ź LIST[LIST[e, f, g, h], LIST[a, b, c, d]];
};

RectsAnim: AnimProc ~ {SetPolysFromPoints[clientData, RectsPoints[0.5*3.1415926535*alpha]]};

Rects: Commander.CommandProc ~ {
MakeTool["rectangles", .2, MakePolys[RectsPoints[0]], RectsAnim];
};
<<Support>>
SetPolysFromPoints: PROC [data: REF ANY, points: LIST OF TripleList] ~ {
t: Tool Ź NARROW[data, REF Data].tool;
t.primitives Ź MakePolys[points];
IO.PutRope[t.cmd.out, "SetPolysFromPoints: calling make maps\n"];
ImplicitConvolve.DoMakeMaps[t];
};
 
MakePolys: PROC [points: LIST OF TripleList] RETURNS [primitives: PrimitiveList Ź NIL] ~ {
FOR l: LIST OF TripleList Ź points, l.rest WHILE l # NIL DO
triples: TripleSequence Ź G3dBasic.TripleSequenceFromList[l.first];
primitives Ź CONS[ImplicitConvolve.MakePrimitive[points: triples, extent: 0.15, color: [0, 0, 0]], primitives];
ENDLOOP;
};
<<Start Code>>
ImplicitDesign.Register["Triangle", Triangle, "a triangle", "ImplicitConvolve"];
ImplicitDesign.Register["SegTri", SegTri, "a segment and triangle", "ImplicitConvolve"];
ImplicitDesign.Register["Cylinder", Cylinder, "a cylinder", "ImplicitConvolve"];
ImplicitDesign.Register["Rects", Rects, "two rectangles", "ImplicitConvolve"];
ImplicitDesign.Register["Cross", Cross, "a cross", "ImplicitConvolve"];
ImplicitDesign.Register["Sticks", Sticks, "\ttwo sticks", "ImplicitConvolve"];
ImplicitDesign.Register["Twist", Twist, "\ttwisted rectangle", "ImplicitConvolve"];
ImplicitDesign.Register["Curve", Curve, "a curve in several segments", "ImplicitConvolve"];

END.