
DIRECTORY G2dBasic, G3dBasic, Real;

G3dBasicImpl: CEDAR PROGRAM
IMPORTS G2dBasic, Real 
EXPORTS G3dBasic

~ BEGIN
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;
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;
};
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];
};
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];
};
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.


   <  
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
Types
Sequence Miscellany
Sequence Copying
Adding to a Sequence


Lengthening a Sequence
 Э╩	є  ХNewlineDelimiter
Ц"cedarcode" styleЩ ЩJЪЬ
╧eЬCЩNJЩ&JЩ(JЩ%JШ JЪ╧k	ЬШ#JШ ЧЪ╨blЬЮЬЮШJЪЮЬШJЪЮЬ	ШJШ ЧJЪЬЮШheadЪ╧lЩJЪЬЮЬШ,JЪЬЮЬШ'JЪЬЮЬШ,JЪЬ	ЮЬШ#JЪЬЮЬШ1JЪЬЮЬШ6JЪЬЮЬШ-JЪЬЮЬШ2JЪЬ
ЮЬШ%JЪЬЮЬШ2JЪЬЮЬШ7JЪЬЮЬШ JЪЬЮЬШ-JЪЬЮЬШ2JЪЬЮЬШ,JЪЬЮЬШ1JЪЬ
ЮЬШ%JЪЬЮЬШ2JЪЬЮЬШ7ЧЪаЩЪ╧nЬЮЬЮЬЮЬШ=JЪЮЬШJЪЬШJЪЬЮЬШJЪЮЬЮЬЮЬЮЬЮЬЮЬЮЬШNJЪЬЮЬ"Ш)JШJЪ
ЮЬЮЬЮЬЮЬ1ЮЬШ]JШЧЧЪаЩЪбЬЮЬЮЬЮЬШNJЪЬЮЬШЪЮЬ	ЮЬЮЬШJЪЬЮЬ Ш*JШJЪ
ЮЬЮЬЮЬЮЬЮЬШ?JШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ*JЪЮЬШJЪЬЮЬШЪЮЬЮЬЮЬШJЪЬЮЬШ%JШJЪ
ЮЬЮЬЮЬЮЬЮЬШ=JШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ9JЪЮЬШJЪЬЮЬШЪЮЬЮЬЮЬШJЪЬЮЬ$Ш.JШJЪ
ЮЬЮЬЮЬЮЬЮЬШCJШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ3JЪЮЬШJШJЪЬЮЬШЪЮЬ	ЮЬЮЬШJЪЬЮЬ Ш*JШJЪ
ЮЬЮЬЮЬЮЬЮЬШ?JШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ<JЪЮЬШJЪЬЮЬШЪЮЬЮЬЮЬШJЪЬЮЬ&Ш0JШJЪ
ЮЬЮЬЮЬЮЬЮЬШEJШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ<JЪЮЬШJЪЬЮЬШЪЮЬЮЬЮЬШJЪЬЮЬ&Ш0JШЪЮЬЮЬЮЬЮШ%JШJШ?JЪЮЬШЧJШЧJЪЮЬШJШJШ ЧЪбЬЮЬШ3JЪЮЬШJЪЬЮЬШЪЮЬЮЬЮЬШJЪЬЮЬ!Ш+JШJЪ
ЮЬЮЬЮЬЮЬЮЬШCJШЧJЪЮЬШJШЧЧЪаЩЪ
бЬЮЬЮЬЮЬЮЬШWJШJЪЮЬ	ЮЬЮЬ	ЮЬШ4JЪЮЬ ЮЬ%ШKJШJШJЪЮЬШJШJЩ ЧЪбЬЮЬ+ШEJЪЮЬШJШJЪЮЬЮЬЮЬЮЬШ.JЪЮЬЮЬШCJШ JШJЪЮЬШJШJЩ ЧЪбЬЮЬ*ШJJЪЮЬШJШJЪЮЬЮЬЮЬЮЬШ:JЪЮЬ$ЮЬ+ШUJШ!JШ"JЪЮЬ
ШJШJЩ ЧЪбЬЮЬЮЬ"Ш@JЪЮЬШJШJЪЮЬ	ЮЬЮЬ	ЮЬШ4JЪЮЬ ЮЬ%ШKJШJШJЪЮЬШJШJЩ ЧЪбЬЮЬ.ШOJЪЮЬШJШJЪЮЬЮЬЮЬЮЬШ=ЪЮЬ%Ш'JЪЮЬ.Ш2ЧJШ$JШ$JЪЮЬШJШJЩ ЧЪбЬЮЬ.ШOJЪЮЬШJШJЪЮЬЮЬЮЬЮЬШ=ЪЮЬ%Ш'JЪЮЬ.Ш2ЧJШ$JШ$JЪЮЬШJШJЩ ЧЪ
бЬЮЬЮЬЮЬЮЬШUJЪЮЬЮЬЮЬЮЬШ1JЪЮЬЮЬ"ШFJШJШJЪЮЬШJШЧЧЪаЩЪбЬЮЬЮЬЮЬШKJЪЮЬШJЪЬЮЬЮЬ*Ш>JЪЬЮЬШ&JЪ
ЮЬЮЬЮЬЮЬЮЬШ>JШJШJШ ЧЪбЬЮЬ#ЮЬШQJЪЮЬШ!JЪЬЮЬЮЬ,Ш@JЪЬЮЬШ(JЪ
ЮЬЮЬЮЬЮЬЮЬШBJШJШJШ ЧЪбЬЮЬЮЬШBJЪЮЬШJЪЬЮЬЮЬ)Ш=JЪЬЮЬШ"JЪ
ЮЬЮЬЮЬЮЬЮЬШ<JШJШJШ ЧЪбЬЮЬЮЬШKJЪЮЬШJЪЬЮЬЮЬ*Ш>JЪЬЮЬШ&JЪ
ЮЬЮЬЮЬЮЬЮЬШ>JШJШJШ ЧЪбЬЮЬШ&JШJЪЬЮЬШJЪЮЬШJШJЪЬЮЬЮЬ-ШAJЪЬЮЬ Ш)JЪ
ЮЬЮЬЮЬЮЬЮЬШDJШJШJШ ЧЪбЬЮЬШ&JЪЬШJЪЬЮЬШJЪЮЬШJШJЪЬЮЬЮЬ-ШAJЪЬЮЬ Ш)JЪ
ЮЬЮЬЮЬЮЬЮЬШDJШJШJШ ЧЪбЬЮЬЮЬШHJЪЮЬШJЪЬЮЬЮЬ)Ш=JЪЬЮЬШ%JЪ
ЮЬЮЬЮЬЮЬЮЬШ<JШJШЧJШ ЧJЪЮЬШJШ JШ Ч ЕЧ    м  )█  