<<>>
<<G3dBasicImpl.mesa>>
<<Copyright Ó 1984, 1988, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
<<Bloomenthal, July 14, 1992 2:06 pm PDT>>
<<Heckbert, August 11, 1988 5:18:40 pm PDT>>
<<Glassner, July 5, 1989 7:02:04 pm PDT>>

DIRECTORY G2dBasic, G3dBasic, Real;

G3dBasicImpl: CEDAR PROGRAM
IMPORTS G2dBasic, Real 
EXPORTS G3dBasic

~ BEGIN
<<Types>>
NatSequence:                TYPE ~ G2dBasic.NatSequence;
NatTable:                    TYPE ~ G3dBasic.NatTable;
NatTableRep:                TYPE ~ G3dBasic.NatTableRep;
Triple:                    TYPE ~ G2dBasic.Triple;
TripleSequence:            TYPE ~ G2dBasic.TripleSequence;
TripleSequenceRep:        TYPE ~ G2dBasic.TripleSequenceRep;
BoolSequence:            TYPE ~ G3dBasic.BoolSequence;
BoolSequenceRep:        TYPE ~ G3dBasic.BoolSequenceRep;
Surface:                    TYPE ~ G3dBasic.Surface;
SurfaceSequence:        TYPE ~ G3dBasic.SurfaceSequence;
SurfaceSequenceRep:    TYPE ~ G3dBasic.SurfaceSequenceRep;
Quad:                        TYPE ~ G3dBasic.Quad;
QuadSequence:            TYPE ~ G3dBasic.QuadSequence;
QuadSequenceRep:        TYPE ~ G3dBasic.QuadSequenceRep;
RefSequence:                TYPE ~ G3dBasic.RefSequence;
RefSequenceRep:            TYPE ~ G3dBasic.RefSequenceRep;
Segment:                    TYPE ~ G3dBasic.Segment;
SegmentSequence:        TYPE ~ G3dBasic.SegmentSequence;
SegmentSequenceRep:    TYPE ~ G3dBasic.SegmentSequenceRep;
<<Sequence Miscellany>>
TripleSequenceFromList: PUBLIC PROC [triples: LIST OF Triple]
RETURNS [s: TripleSequence]
~ {
len: NAT Ź 0;
FOR l: LIST OF Triple Ź triples, l.rest WHILE l # NIL DO len Ź len+1; ENDLOOP;
s Ź NEW[G3dBasic.TripleSequenceRep[len]];
s.length Ź len;
FOR n: NAT IN [0..s.length Ź len) DO {s[n] Ź triples.first; triples Ź triples.rest}; ENDLOOP;
};
<<Sequence Copying>>
CopyBoolSequence: PUBLIC PROC [bools: BoolSequence] RETURNS [BoolSequence] ~ {
copy: BoolSequence Ź NIL;
IF bools # NIL THEN {
copy Ź NEW[BoolSequenceRep[bools.length]];
copy.length Ź bools.length;
FOR n: NAT IN [0..bools.length) DO copy[n] Ź bools[n]; ENDLOOP;
};
RETURN[copy];
};

CopyNatTable: PUBLIC PROC [nats: NatTable]
RETURNS [NatTable] ~ {
copy: NatTable Ź NIL;
IF nats # NIL THEN {
copy Ź NEW[NatTableRep[nats.length]];
copy.length Ź nats.length;
FOR n: NAT IN [0..nats.length) DO copy[n] Ź nats[n]; ENDLOOP;
};
RETURN[copy];
};

CopyTripleSequence: PUBLIC PROC [triples: TripleSequence]
RETURNS [TripleSequence] ~ {
copy: TripleSequence Ź NIL;
IF triples # NIL THEN {
copy Ź NEW[TripleSequenceRep[triples.length]];
copy.length Ź triples.length;
FOR n: NAT IN [0..triples.length) DO copy[n] Ź triples[n]; ENDLOOP;
};
RETURN[copy];
};

CopyQuadSequence: PUBLIC PROC [quads: QuadSequence]
RETURNS [QuadSequence]
~ {
copy: QuadSequence Ź NIL;
IF quads # NIL THEN {
copy Ź NEW[QuadSequenceRep[quads.length]];
copy.length Ź quads.length;
FOR n: NAT IN [0..quads.length) DO copy[n] Ź quads[n]; ENDLOOP;
};
RETURN[copy];
};

CopySegmentSequence: PUBLIC PROC [segments: SegmentSequence]
RETURNS [SegmentSequence] ~ {
copy: SegmentSequence Ź NIL;
IF segments # NIL THEN {
copy Ź NEW[SegmentSequenceRep[segments.length]];
copy.length Ź segments.length;
FOR n: NAT IN [0..segments.length) DO copy[n] Ź segments[n]; ENDLOOP;
};
RETURN[copy];
};

CopySurfaceSequence: PUBLIC PROC [surfaces: SurfaceSequence]
RETURNS [SurfaceSequence] ~ {
copy: SurfaceSequence Ź NIL;
IF surfaces # NIL THEN {
copy Ź NEW[SurfaceSequenceRep[surfaces.length]];
copy.length Ź surfaces.length;
FOR n: NAT IN [0..surfaces.length) DO
s: Surface Ź surfaces[n];
copy[n] Ź [s.clientData, G2dBasic.CopyNatSequence[s.vertices]];
ENDLOOP;
};
RETURN[copy];
};

CopyRefSequence: PUBLIC PROC [refAnys: RefSequence]
RETURNS [RefSequence] ~ {
copy: RefSequence Ź NIL;
IF refAnys # NIL THEN {
copy Ź NEW[RefSequenceRep[refAnys.length]];
copy.length Ź refAnys.length;
FOR n: NAT IN [0..refAnys.length) DO copy[n] Ź refAnys[n]; ENDLOOP;
};
RETURN[copy];
};
<<Adding to a Sequence>>
AddToBoolSequence: PUBLIC PROC [bools: BoolSequence, bool: BOOL] RETURNS [BoolSequence]
~ {
IF bools = NIL THEN bools Ź NEW[BoolSequenceRep[1]];
IF bools.length = bools.maxLength THEN bools Ź LengthenBoolSequence[bools];
bools[bools.length] Ź bool;
bools.length Ź bools.length+1;
RETURN[bools];
};
<<>>
AddToNatTable: PUBLIC PROC [nats: NatTable, natSequence: NatSequence]
RETURNS [NatTable]
~ {
IF nats = NIL THEN nats Ź NEW[NatTableRep[1]];
IF nats.length = nats.maxLength THEN nats Ź LengthenNatTable[nats];
nats[nats.length] Ź natSequence;
nats.length Ź nats.length+1;
RETURN[nats];
};
<<>>
AddToTripleSequence: PUBLIC PROC [triples: TripleSequence, triple: Triple]
RETURNS [TripleSequence]
~ {
IF triples = NIL THEN triples Ź NEW[TripleSequenceRep[1]];
IF triples.length = triples.maxLength THEN triples Ź LengthenTripleSequence[triples];
triples[triples.length] Ź triple;
triples.length Ź triples.length+1;
RETURN[triples];
};
<<>>
AddToQuadSequence: PUBLIC PROC [quads: QuadSequence, quad: Quad]
RETURNS [QuadSequence]
~ {
IF quads = NIL THEN quads Ź NEW[QuadSequenceRep[1]];
IF quads.length = quads.maxLength THEN quads Ź LengthenQuadSequence[quads];
quads[quads.length] Ź quad;
quads.length Ź quads.length+1;
RETURN[quads];
};
<<>>
AddToSegmentSequence: PUBLIC PROC [segments: SegmentSequence, segment: Segment]
RETURNS [SegmentSequence]
~ {
IF segments = NIL THEN segments Ź NEW[SegmentSequenceRep[1]];
IF segments.length = segments.maxLength
THEN segments Ź LengthenSegmentSequence[segments];
segments[segments.length] Ź segment;
segments.length Ź segments.length+1;
RETURN[segments];
};
<<>>
AddToSurfaceSequence: PUBLIC PROC [surfaces: SurfaceSequence, surface: Surface]
RETURNS [SurfaceSequence]
~ {
IF surfaces = NIL THEN surfaces Ź NEW[SurfaceSequenceRep[1]];
IF surfaces.length = surfaces.maxLength
THEN surfaces Ź LengthenSurfaceSequence[surfaces];
surfaces[surfaces.length] Ź surface;
surfaces.length Ź surfaces.length+1;
RETURN[surfaces];
};
<<>>
AddToRefSequence: PUBLIC PROC [refs: RefSequence, ref: REF] RETURNS [RefSequence] ~ {
IF refs = NIL THEN refs Ź NEW[RefSequenceRep[1]];
IF refs.length = refs.maxLength THEN refs Ź LengthenRefSequence[refs];
refs[refs.length] Ź ref;
refs.length Ź refs.length+1;
RETURN[refs];
};
<<Lengthening a Sequence>>
LengthenBoolSequence: PUBLIC PROC [bools: BoolSequence, amount: REAL Ź 1.3]
RETURNS [new: BoolSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*bools.maxLength], 3];
new Ź NEW[BoolSequenceRep[newLength]];
FOR i: NAT IN [0..bools.length) DO new[i] Ź bools[i]; ENDLOOP;
new.length Ź bools.length;
};

LengthenTripleSequence: PUBLIC PROC [triples: TripleSequence, amount: REAL Ź 1.3]
RETURNS [new: TripleSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*triples.maxLength], 3];
new Ź NEW[TripleSequenceRep[newLength]];
FOR i: NAT IN [0..triples.length) DO new[i] Ź triples[i]; ENDLOOP;
new.length Ź triples.length;
};

LengthenNatTable: PUBLIC PROC [nats: NatTable, amount: REAL Ź 1.3]
RETURNS [new: NatTable] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*nats.maxLength], 3];
new Ź NEW[NatTableRep[newLength]];
FOR i: NAT IN [0..nats.length) DO new[i] Ź nats[i]; ENDLOOP;
new.length Ź nats.length;
};

LengthenQuadSequence: PUBLIC PROC [quads: QuadSequence, amount: REAL Ź 1.3]
RETURNS [new: QuadSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*quads.maxLength], 3];
new Ź NEW[QuadSequenceRep[newLength]];
FOR i: NAT IN [0..quads.length) DO new[i] Ź quads[i]; ENDLOOP;
new.length Ź quads.length;
};

LengthenSegmentSequence: PUBLIC PROC [
segments: SegmentSequence,
amount: REAL Ź 1.3]
RETURNS [new: SegmentSequence]
~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*segments.maxLength], 3];
new Ź NEW[SegmentSequenceRep[newLength]];
FOR i: NAT IN [0..segments.length) DO new[i] Ź segments[i]; ENDLOOP;
new.length Ź segments.length;
};

LengthenSurfaceSequence: PUBLIC PROC [
surfaces: SurfaceSequence,
amount: REAL Ź 1.3]
RETURNS [new: SurfaceSequence]
~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*surfaces.maxLength], 3];
new Ź NEW[SurfaceSequenceRep[newLength]];
FOR i: NAT IN [0..surfaces.length) DO new[i] Ź surfaces[i]; ENDLOOP;
new.length Ź surfaces.length;
};

LengthenRefSequence: PUBLIC PROC [refs: RefSequence, amount: REAL Ź 1.3]
RETURNS [new: RefSequence] ~ {
newLength: NAT Ź MAX[Real.Ceiling[amount*refs.maxLength], 3];
new Ź NEW[RefSequenceRep[newLength]];
FOR i: NAT IN [0..refs.length) DO new[i] Ź refs[i]; ENDLOOP;
new.length Ź refs.length;
};

END.