2 ** License Applicability. Except to the extent portions of this file are
3 ** made subject to an alternative license as permitted in the SGI Free
4 ** Software License B, Version 1.1 (the "License"), the contents of this
5 ** file are subject only to the provisions of the License. You may not use
6 ** this file except in compliance with the License. You may obtain a copy
7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
10 ** http://oss.sgi.com/projects/FreeB
12 ** Note that, as provided in the License, the Software is distributed on an
13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
21 ** Copyright in any portions created by third parties is as indicated
22 ** elsewhere herein. All Rights Reserved.
24 ** Additional Notice Provisions: The application programming interfaces
25 ** established by SGI in conjunction with the Original Code are The
26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
31 ** published by SGI, but has not been independently verified as being
32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
40 #include "glimports.h"
41 #include "sampleComp.h"
42 #include "sampleCompTop.h"
43 #include "sampleCompBot.h"
44 #include "sampleCompRight.h"
48 #define max(a,b) ((a>b)? a:b)
49 #define min(a,b) ((a>b)? b:a)
51 void sampleConnectedComp(Real
* topVertex
, Real
* botVertex
,
52 vertexArray
* leftChain
,
53 Int leftStartIndex
, Int leftEndIndex
,
54 vertexArray
* rightChain
,
55 Int rightStartIndex
, Int rightEndIndex
,
56 gridBoundaryChain
* leftGridChain
,
57 gridBoundaryChain
* rightGridChain
,
58 Int gridIndex1
, Int gridIndex2
,
59 Int up_leftCornerWhere
,
60 Int up_leftCornerIndex
,
61 Int up_rightCornerWhere
,
62 Int up_rightCornerIndex
,
63 Int down_leftCornerWhere
,
64 Int down_leftCornerIndex
,
65 Int down_rightCornerWhere
,
66 Int down_rightCornerIndex
,
68 rectBlockArray
* rbArray
72 sampleCompLeft(topVertex
, botVertex
,
74 leftStartIndex
, leftEndIndex
,
76 rightStartIndex
, rightEndIndex
,
87 sampleCompRight(topVertex
, botVertex
,
89 leftStartIndex
, leftEndIndex
,
94 gridIndex1
, gridIndex2
,
97 down_rightCornerWhere
,
98 down_rightCornerIndex
,
102 sampleCompTop(topVertex
,
116 sampleCompBot(botVertex
,
124 down_leftCornerWhere
,
125 down_leftCornerIndex
,
126 down_rightCornerWhere
,
127 down_rightCornerIndex
,
133 rbArray
->insert(new rectBlock(leftGridChain
, rightGridChain
, gridIndex1
, gridIndex2
));
138 /*notice that we need rightChain because the
139 *corners could be on the rightChain.
140 *here comp means component.
142 void sampleCompLeft(Real
* topVertex
, Real
* botVertex
,
143 vertexArray
* leftChain
,
144 Int leftStartIndex
, Int leftEndIndex
,
145 vertexArray
* rightChain
,
146 Int rightStartIndex
, Int rightEndIndex
,
147 gridBoundaryChain
* leftGridChain
,
148 Int gridIndex1
, Int gridIndex2
,
149 Int up_leftCornerWhere
,
150 Int up_leftCornerIndex
,
151 Int down_leftCornerWhere
,
152 Int down_leftCornerIndex
,
155 /*find out whether there is a trim vertex which is
156 *inbetween the top and bot grid lines or not.
160 Int gridMidIndex1
= 0, gridMidIndex2
= 0;
161 //midIndex1: array[i] <= v, array[i-1] > v
162 //midIndex2: array[i] >= v, array[i+1] < v
163 // v(gridMidIndex1) >= v(midindex1) > v(gridMidIndex1+1)
164 // v(gridMidIndex2-1) >= v(midIndex2) > v(gridMidIndex2) ??
165 midIndex1
= leftChain
->findIndexBelowGen(
166 leftGridChain
->get_v_value(gridIndex1
),
170 midIndex2
= -1; /*initilization*/
171 if(midIndex1
<= leftEndIndex
&& gridIndex1
<gridIndex2
)
172 if(leftChain
->getVertex(midIndex1
)[1] >= leftGridChain
->get_v_value(gridIndex2
))
174 midIndex2
= leftChain
->findIndexAboveGen(
175 leftGridChain
->get_v_value(gridIndex2
),
176 midIndex1
, //midIndex1 <= midIndex2.
178 gridMidIndex1
= leftGridChain
->lookfor(leftChain
->getVertex(midIndex1
)[1],
179 gridIndex1
, gridIndex2
);
180 gridMidIndex2
= 1+leftGridChain
->lookfor(leftChain
->getVertex(midIndex2
)[1],
181 gridMidIndex1
, gridIndex2
);
185 /*to interprete the corner information*/
190 Int cornerRightUpEnd
;
191 Int cornerRightDownStart
;
192 if(up_leftCornerWhere
== 0) /*left corner is on left chain*/
194 cornerTop
= leftChain
->getVertex(up_leftCornerIndex
);
195 cornerLeftStart
= up_leftCornerIndex
+1;
196 cornerRightUpEnd
= -1; /*no right*/
198 else if(up_leftCornerWhere
== 1) /*left corner is on top*/
200 cornerTop
= topVertex
;
201 cornerLeftStart
= leftStartIndex
;
202 cornerRightUpEnd
= -1; /*no right*/
204 else /*left corner is on right chain*/
206 cornerTop
= topVertex
;
207 cornerLeftStart
= leftStartIndex
;
208 cornerRightUpEnd
= up_leftCornerIndex
;
211 if(down_leftCornerWhere
== 0) /*left corner is on left chain*/
213 cornerBot
= leftChain
->getVertex(down_leftCornerIndex
);
214 cornerLeftEnd
= down_leftCornerIndex
-1;
215 cornerRightDownStart
= rightEndIndex
+1; /*no right*/
217 else if(down_leftCornerWhere
== 1) /*left corner is on bot*/
219 cornerBot
= botVertex
;
220 cornerLeftEnd
= leftEndIndex
;
221 cornerRightDownStart
= rightEndIndex
+1; /*no right*/
223 else /*left corner is on the right chian*/
225 cornerBot
= botVertex
;
226 cornerLeftEnd
= leftEndIndex
;
227 cornerRightDownStart
= down_leftCornerIndex
;
234 if(midIndex2
>= 0) /*there is a trim point inbewteen grid lines*/
237 sampleLeftSingleTrimEdgeRegionGen(cornerTop
, leftChain
->getVertex(midIndex1
),
247 0, //no right down section
251 sampleLeftSingleTrimEdgeRegionGen(leftChain
->getVertex(midIndex2
),
260 0, //no right up section
262 cornerRightDownStart
,
267 sampleLeftStripRecF(leftChain
,
277 sampleLeftSingleTrimEdgeRegionGen(cornerTop
, cornerBot
,
287 cornerRightDownStart
,
293 void sampleLeftSingleTrimEdgeRegionGen(Real topVert
[2], Real botVert
[2],
294 vertexArray
* leftChain
,
297 gridBoundaryChain
* gridChain
,
300 vertexArray
* rightChain
,
309 /*creat an array to store all the up and down secments of the right chain,
310 *and the left end grid points
312 *although vertex array is a dynamic array, but to gain efficiency,
313 *it is better to initiliza the exact array size
315 vertexArray
vArray(gridEndIndex
-gridBeginIndex
+1 +
316 max(0,rightUpEnd
- rightUpBegin
+1)+
317 max(0,rightDownEnd
- rightDownBegin
+1));
319 /*append the vertices on the up section of thr right chain*/
320 for(i
=rightUpBegin
; i
<= rightUpEnd
; i
++)
321 vArray
.appendVertex(rightChain
->getVertex(i
));
323 /*append the vertices of the left extremal grid points,
324 *and at the same time, perform triangulation for the stair cases
326 vArray
.appendVertex(gridChain
->get_vertex(gridBeginIndex
));
328 for(k
=1, i
=gridBeginIndex
+1; i
<=gridEndIndex
; i
++, k
++)
330 vArray
.appendVertex(gridChain
->get_vertex(i
));
332 /*output the fan of the grid points of the (i)th and (i-1)th grid line.
334 if(gridChain
->getUlineIndex(i
) < gridChain
->getUlineIndex(i
-1))
337 pStream
->insert(gridChain
->get_vertex(i
-1));
338 for(j
=gridChain
->getUlineIndex(i
); j
<= gridChain
->getUlineIndex(i
-1); j
++)
339 pStream
->insert(gridChain
->getGrid()->get_u_value(j
), gridChain
->get_v_value(i
));
340 pStream
->end(PRIMITIVE_STREAM_FAN
);
342 else if(gridChain
->getUlineIndex(i
) > gridChain
->getUlineIndex(i
-1))
345 pStream
->insert(gridChain
->get_vertex(i
));
346 for(j
=gridChain
->getUlineIndex(i
); j
>= gridChain
->getUlineIndex(i
-1); j
--)
347 pStream
->insert(gridChain
->getGrid()->get_u_value(j
), gridChain
->get_v_value(i
-1));
348 pStream
->end(PRIMITIVE_STREAM_FAN
);
350 /*otherwisem, the two are equal, so there is no fan to outout*/
353 /*then append all the vertices on the down section of the right chain*/
354 for(i
=rightDownBegin
; i
<= rightDownEnd
; i
++)
355 vArray
.appendVertex(rightChain
->getVertex(i
));
357 monoTriangulationRecGen(topVert
, botVert
,
358 leftChain
, leftStart
, leftEnd
,
359 &vArray
, 0, vArray
.getNumElements()-1,