<<>>
<<ImplicitWingCmdImpl.mesa>>
<<Copyright Ó 1991 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, August 11, 1992 4:02 pm PDT>>

DIRECTORY Commander, CommanderOps, Controls, Draw2d, FileNames, G3dBasic, G3dDraw, G3dMatrix, G3dTube, G3dSpline, G3dTool, 
G3dVector, ImplicitConvolve, ImplicitDefs, ImplicitDesign, IO, Menus, Rope, TerminalIO;

ImplicitPetalCmdImpl: CEDAR PROGRAM
IMPORTS CommanderOps, Controls, FileNames, G3dBasic, G3dDraw, G3dTube, G3dSpline, G3dTool, G3dVector, ImplicitConvolve, 
ImplicitDesign, IO, Rope

~ BEGIN
<<Imported Types>>
RealSequence:            TYPE ~ G3dBasic.RealSequence;
Triple:                    TYPE ~ G3dBasic.Triple;
TripleSequence:            TYPE ~ G3dBasic.TripleSequence;
TripleSequenceRep:        TYPE ~ G3dBasic.TripleSequenceRep;
Spline:                    TYPE ~ G3dSpline.Spline;
SplineSequence:            TYPE ~ G3dSpline.SplineSequence;
Tube:                        TYPE ~ G3dTube.Tube;
ClickProc:                TYPE ~ Menus.ClickProc;
ROPE:                        TYPE ~ Rope.ROPE;
Primitive:                    TYPE ~ ImplicitConvolve.Primitive;
PrimitiveList:            TYPE ~ ImplicitConvolve.PrimitiveList;
TripleList:                TYPE ~ ImplicitConvolve.TripleList;
<<The Long Awaited ~WING~>>
WingData:                TYPE ~ REF WingDataRep;
WingDataRep:            TYPE ~ RECORD [
tool:                                ImplicitDesign.Tool Ź NIL,
tube:                                Tube Ź NIL,
primitives:                        PrimitiveList Ź NIL,
c0, c1:                            Spline Ź NIL,
lofts:                                SplineSequence Ź NIL,
kHeight:                            REAL Ź 0.5,
kWidth:                            REAL Ź 0.25,
kSag:                                REAL Ź -0.2,
thickness:                        REAL Ź 0.01,
doWeb, doVeins:                BOOL Ź TRUE,
showLofts, showSplines:        BOOL Ź TRUE,
showLines:                        BOOL Ź FALSE
];

WingCmd: Commander.CommandProc ~ {
argv: CommanderOps.ArgumentVector Ź CommanderOps.Parse[cmd];
FOR n: NAT IN [0..argv.argc-1) DO
IF Rope.Equal[argv[n], "-tube", FALSE] THEN {Wing[cmd, argv[n+1]]; RETURN};
ENDLOOP;
RETURN[$Failure, "must specify -tube <name>"];
};

Wing: PROC [cmd: Commander.Handle, tubeName: ROPE] ~ {
w: WingData Ź NEW[WingDataRep];
w.tube Ź G3dTube.TubeFromFile[FileNames.ResolveRelativePath[tubeName]];
IF w.tube = NIL OR G3dTube.NBranches[w.tube, TRUE] # 2
THEN IO.PutF[cmd.out, "bad tube\n"]
ELSE {
G3dTube.SelectAll[w.tube];
G3dTube.Make[w.tube];
MakeWing[w, 6];
w.tool Ź ImplicitConvolve.MakeTool[
cmd: cmd,
name: "WINGing it!",
polys: w.primitives,
extraButtons: LIST[
Controls.ClickButton["Height", KHeight, w, 1],
Controls.ClickButton["Width", KWidth, w, 1],
Controls.ClickButton["Sag", KSag, w, 1],
Controls.ClickButton["NLofts", NLofts, w, 1],
Controls.ClickButton["Thick", Thickness, w, 1],
Controls.ClickButton["Veins-On", ToggleVeins, w, 1],
Controls.ClickButton["Web-On", ToggleWeb, w, 1]],
<<Controls.ClickButton["Lofts-On", ToggleLoft, w, 2],>>
<<Controls.ClickButton["Lines-Off", ToggleLine, w, 2],>>
<<Controls.ClickButton["Splines-On", ToggleSpline, w, 2],>>
draw: Draw,
data: w,
toolSettings: [trackSize: .015, threshold: 0.25]
]
};
};
<<Display >>
MakeWing: PROC [w: WingData, nLofts: NAT, repaint: BOOL Ź FALSE] ~ {
MakeLofts[w, nLofts];
MakePrimitives[w];
IF repaint THEN ImplicitDesign.Repaint[w.tool];
};

Draw: Draw2d.DrawProc ~ {
    Action: PROC ~ {
        IF w.showLines THEN G3dTube.DrawLines[context, w.tube, view];
        IF w.showSplines THEN G3dTube.DrawSplines[context, w.tube, view];
    IF w.showLofts THEN G3dDraw.DrawCurves[context, w.lofts, view];
    };
w: WingData Ź NARROW[clientData];
    view: G3dMatrix.Matrix Ź G3dTool.GetViewTransform[viewer];
    <<WrapInCG6[context, Action];>>
    };
<<Geometry>>
MakePrimitives: PROC [w: WingData] ~ {
AddPrimitive: PROC [list: TripleList, intensity, extent: REAL, intensities: RealSequence Ź NIL]
~ {
ScaleOffset: PROC [list: TripleList, scale, zOffset: REAL] RETURNS [p: TripleSequence] ~ {
p Ź G3dBasic.TripleSequenceFromList[list];
FOR n: NAT IN [0..p.length) DO
p[n] Ź G3dVector.Sub[G3dVector.Mul[p[n], scale], [0, 0, zOffset]];
ENDLOOP;
};
pts: TripleSequence Ź ScaleOffset[list, 1.75, .5];
p: Primitive Ź ImplicitConvolve.MakePrimitive[pts, extent,, intensity, intensities,, [55, 55]];
p.display Ź display;
display Ź IF (count Ź count+1) MOD 6 = 0
THEN [5, display.y+p.res.y+5]
ELSE [display.x+p.res.x+5, display.y];
w.primitives Ź CONS[p, w.primitives];
};
AddSegment: PROC [p1, p2: Triple, intensities: RealSequence Ź NIL] ~ {
AddPrimitive[LIST[p1, p2], 1.0, .04, intensities];
};
AddRectangle: PROC [p1, p2, p3, p4: Triple] ~ {AddPrimitive[LIST[p1, p2, p3, p4], .75, .015]};
MakeRectangles: PROC [res: NAT] ~ {
pts1: TripleSequence Ź NEW[TripleSequenceRep[res+1]];
pts2: TripleSequence Ź NEW[TripleSequenceRep[res+1]];
FOR n: NAT IN [0..res] DO pts1[n] Ź w.tube.p1; ENDLOOP;
FOR n: NAT IN [0..w.lofts.length) DO
FOR i: NAT IN [0..res] DO
pts2[i] Ź G3dSpline.Position[w.lofts[n], REAL[i]/REAL[res]];
ENDLOOP;
FOR i: NAT IN [0..res) DO AddRectangle[pts1[i], pts1[i+1], pts2[i+1], pts2[i]]; ENDLOOP;
{temp: TripleSequence Ź pts1; pts1 Ź pts2; pts2 Ź temp};
ENDLOOP;
};
MakeSegments: PROC [s: Spline, res: NAT] ~ {
p1: Triple Ź w.tube.p1;
FOR i: NAT IN [1..res] DO
t: REAL Ź REAL[i]/REAL[res];
p2: Triple Ź G3dSpline.Position[s, REAL[i]/REAL[res]];
intensities: RealSequence Ź NEW[G3dBasic.RealSequenceRep[2]];
intensities[0] Ź 1.0-REAL[i]/REAL[res];
intensities[1] Ź 1.0-REAL[i-1]/REAL[res];
AddSegment[p1, p2, intensities];
p1 Ź p2;
ENDLOOP;
};
count: NAT Ź 0;
display: ImplicitConvolve.NatPair Ź [5, 5];
MakeSegments[w.c0, w.lofts.length];
MakeSegments[w.c1, w.lofts.length];
MakeRectangles[w.lofts.length];
};

MakeLofts: PROC [w: WingData, nLofts: NAT] ~ {
Loft: PROC [c0, c1: Spline, t, kWide, kHigh, kSag: REAL, out: Spline] RETURNS [Spline] ~ {
p0, p1, v0, v1, p0p1, pMid, vSum, beam, pp0, pp1, cross, sag: Triple;
[p0, v0] Ź G3dSpline.PositionAndVelocity[c0, t];
[p1, v1] Ź G3dSpline.PositionAndVelocity[c1, t];
p0p1 Ź [p1.x-p0.x, p1.y-p0.y, p1.z-p0.z];
beam Ź [p0p1.x*kWide, p0p1.y*kWide, p0p1.z*kWide];
pMid Ź [0.5*(p0.x+p1.x), 0.5*(p0.y+p1.y), 0.5*(p0.z+p1.z)];
vSum Ź [v0.x+v1.x, v0.y+v1.y, v0.z+v1.z];
pp0 Ź [pMid.x-beam.x, pMid.y-beam.y, pMid.z-beam.z];
pp1 Ź [pMid.x+beam.x, pMid.y+beam.y, pMid.z+beam.z];
cross ŹG3dVector.SetVectorLength[G3dVector.Cross[v0,v1],kHigh*G3dVector.Length[p0p1]];
sag Ź G3dVector.SetVectorLength[vSum, -t*t*kSag];
pp0 Ź [pp0.x+cross.x+sag.x, pp0.y+cross.y+sag.y, pp0.z+cross.z+sag.z];
pp1 Ź [pp1.x+cross.x+sag.x, pp1.y+cross.y+sag.y, pp1.z+cross.z+sag.z];
RETURN[G3dSpline.SplineFromBezier[[p0, pp0, pp1, p1], out]];
};
w.c0 Ź G3dTube.GetBranch[w.tube, 0].spline;
w.c1 Ź G3dTube.GetBranch[w.tube, 1].spline;
IF w.lofts = NIL THEN w.lofts Ź NEW[G3dSpline.SplineSequenceRep[nLofts]];
IF w.lofts.maxLength < nLofts THEN {
old: SplineSequence Ź w.lofts;
w.lofts Ź NEW [G3dSpline.SplineSequenceRep[nLofts]];
FOR n: NAT IN [0..old.length) DO w.lofts[n] Ź old[n]; ENDLOOP;
};
w.lofts.length Ź nLofts;
FOR n: NAT IN [1..nLofts] DO
t: REAL Ź REAL[n]/REAL[nLofts];
w.lofts[n-1] Ź Loft[w.c0, w.c1, t, w.kWidth, w.kHeight, w.kSag, w.lofts[n-1]];
ENDLOOP;
};
<< [Artwork node; type 'Artwork on' to command tool] >>
<<Diagram of lofts>>
<<Buttons>>
NLofts: ClickProc ~ {
w: WingData Ź NARROW[clientData];
MakeWing[w, MAX[1, Controls.GetNat[w.tool.typescript, "NLofts", w.lofts.length]], TRUE];
};

Thickness: ClickProc ~ {
w: WingData Ź NARROW[clientData];
w.thickness Ź Controls.TypescriptReadValue[w.tool.typescript, "Thickness", w.thickness];
};

KHeight: ClickProc ~ {
w: WingData Ź NARROW[clientData];
w.kHeight Ź Controls.TypescriptReadValue[w.tool.typescript, "KHeight", w.kHeight];
MakeWing[w, w.lofts.length, TRUE];
};

KWidth: ClickProc ~ {
w: WingData Ź NARROW[clientData];
w.kWidth Ź Controls.TypescriptReadValue[w.tool.typescript, "KWidth", w.kWidth];
MakeWing[w, w.lofts.length, TRUE];
};

KSag: ClickProc ~ {
w: WingData Ź NARROW[clientData];
w.kSag Ź Controls.TypescriptReadValue[w.tool.typescript, "KSag", w.kSag];
MakeWing[w, w.lofts.length, TRUE];
};

Option: TYPE ~ {web, veins, lofts, lines, splines};

ToggleWeb:            ClickProc ~ {Toggle[clientData, mouseButton, web,        "Web"]};
ToggleVeins:        ClickProc ~ {Toggle[clientData, mouseButton, veins,        "Veins"]};
ToggleLoft:            ClickProc ~ {Toggle[clientData, mouseButton, lofts,        "Lofts"]};
ToggleLine:        ClickProc ~ {Toggle[clientData, mouseButton, lines,        "Lines"]};
ToggleSpline:        ClickProc ~ {Toggle[clientData, mouseButton, splines,        "Splines"]};

Toggle: PROC [ref: REF, button: Menus.MouseButton, option: Option, name: ROPE] ~ {
w: WingData Ź NARROW[ref];
state: BOOL Ź SELECT option FROM
web        => w.doWeb                Ź NOT w.doWeb,
veins        => w.doVeins            Ź NOT w.doVeins,
lofts        => w.showLofts            Ź NOT w.showLofts,
lines        => w.showLines            Ź NOT w.showLines,
splines    => w.showSplines        Ź NOT w.showSplines,
ENDCASE => TRUE;
Controls.ButtonToggle[
w.tool.renderTool.outerData, state, Rope.Cat[name, "-On"], Rope.Cat[name, "-Off"]];
IF button = blue THEN ImplicitDesign.Repaint[w.tool, NIL];
    };
<<Start Code>>
ImplicitDesign.Register["Wing", WingCmd, "\ta wing?", "ImplicitConvolve"];

END.