ReactOS  0.4.14-dev-604-gcfdd483
sampleCompRight.cc
Go to the documentation of this file.
1 /*
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:
9 **
10 ** http://oss.sgi.com/projects/FreeB
11 **
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.
17 **
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.
23 **
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.
33 **
34 */
35 /*
36 */
37 
38 //#include <stdlib.h>
39 //#include <stdio.h>
40 //#include "gluos.h"
41 //#include "glimports.h"
42 //#include "zlassert.h"
43 #include "sampleCompRight.h"
44 
45 #define max(a,b) ((a>b)? a:b)
46 #define min(a,b) ((a>b)? b:a)
47 
48 
49 
50 #ifdef NOT_TAKEOUT
51 
52 /*notice that we need leftChain because the
53  *corners could be on the leftChain.
54  */
55 void sampleCompRight(Real* topVertex, Real* botVertex,
56  vertexArray* leftChain,
57  Int leftStartIndex, Int leftEndIndex,
58  vertexArray* rightChain,
59  Int rightStartIndex, Int rightEndIndex,
60  gridBoundaryChain* rightGridChain,
61  Int gridIndex1, Int gridIndex2,
62  Int up_rightCornerWhere,
63  Int up_rightCornerIndex,
64  Int down_rightCornerWhere,
65  Int down_rightCornerIndex,
66  primStream* pStream)
67 {
68  /*find out whether there is a trim vertex which is
69  *inbetween the top and bot grid lines or not.
70  */
71  Int midIndex1;
72  Int midIndex2;
73  Int gridMidIndex1 = 0, gridMidIndex2 = 0;
74  //midIndex1: array[i] <= v, array[i+1] > v
75  //midIndex2: array[i] >= v, array[i+1] < v
76  midIndex1 = rightChain->findIndexBelowGen(rightGridChain->get_v_value(gridIndex1),
77  rightStartIndex,
78  rightEndIndex);
79  midIndex2 = -1; //initilization
80  if(midIndex1 <= rightEndIndex && gridIndex1 < gridIndex2)
81  if(rightChain->getVertex(midIndex1)[1] >= rightGridChain->get_v_value(gridIndex2))
82  {
83  //midIndex2 must exist:
84  midIndex2 = rightChain->findIndexAboveGen(rightGridChain->get_v_value(gridIndex2),
85  midIndex1, //midIndex1<=midIndex2
86  rightEndIndex);
87  //find gridMidIndex1 so that either it=gridIndex1 when the gridline is
88  // at the same height as trim vertex midIndex1, or it is the last one
89  //which is strictly above midIndex1.
90  {
91  Real temp = rightChain->getVertex(midIndex1)[1];
92  if(rightGridChain->get_v_value(gridIndex1) == temp)
93  gridMidIndex1 = gridIndex1;
94  else
95  {
96  gridMidIndex1 = gridIndex1;
97  while(rightGridChain->get_v_value(gridMidIndex1) > temp)
98  gridMidIndex1++;
99  gridMidIndex1--;
100  }
101  }//end of find gridMindIndex1
102  //find gridMidIndex2 so that it is the (first one below or equal
103  //midIndex) last one above or equal midIndex2
104  {
105  Real temp = rightChain->getVertex(midIndex2)[1];
106  for(gridMidIndex2 = gridMidIndex1+1; gridMidIndex2 <= gridIndex2; gridMidIndex2++)
107  if(rightGridChain->get_v_value(gridMidIndex2) <= temp)
108  break;
109 
110  assert(gridMidIndex2 <= gridIndex2);
111  }//end of find gridMidIndex2
112  }
113 
114 
115 
116  //to interprete the corner information
117  Real* cornerTop;
118  Real* cornerBot;
119  Int cornerRightStart;
120  Int cornerRightEnd;
121  Int cornerLeftUpEnd;
122  Int cornerLeftDownStart;
123  if(up_rightCornerWhere == 2) //right corner is on right chain
124  {
125  cornerTop = rightChain->getVertex(up_rightCornerIndex);
126  cornerRightStart = up_rightCornerIndex+1;
127  cornerLeftUpEnd = -1; //no left
128  }
129  else if(up_rightCornerWhere == 1) //right corner is on top
130  {
131  cornerTop = topVertex;
132  cornerRightStart = rightStartIndex;
133  cornerLeftUpEnd = -1; //no left
134  }
135  else //right corner is on left chain
136  {
137  cornerTop = topVertex;
138  cornerRightStart = rightStartIndex;
139  cornerLeftUpEnd = up_rightCornerIndex;
140  }
141 
142  if(down_rightCornerWhere == 2) //right corner is on right chan
143  {
144  cornerBot = rightChain->getVertex(down_rightCornerIndex);
145  cornerRightEnd = down_rightCornerIndex-1;
146  cornerLeftDownStart = leftEndIndex+1; //no left
147  }
148  else if (down_rightCornerWhere == 1) //right corner is at bot
149  {
150  cornerBot = botVertex;
151  cornerRightEnd = rightEndIndex;
152  cornerLeftDownStart = leftEndIndex+1; //no left
153  }
154  else //right corner is on the left chain
155  {
156  cornerBot = botVertex;
157  cornerRightEnd = rightEndIndex;
158  cornerLeftDownStart = down_rightCornerIndex;
159  }
160 
161  //sample
162  if(midIndex2 >= 0) //there is a trm point between grid lines
163  {
164 
165  sampleRightSingleTrimEdgeRegionGen(cornerTop, rightChain->getVertex(midIndex1),
166  rightChain,
167  cornerRightStart,
168  midIndex1-1,
169  rightGridChain,
170  gridIndex1,
171  gridMidIndex1,
172  leftChain,
173  leftStartIndex,
174  cornerLeftUpEnd,
175  0, //no left down section,
176  -1,
177  pStream);
178 
179  sampleRightSingleTrimEdgeRegionGen(rightChain->getVertex(midIndex2),
180  cornerBot,
181  rightChain,
182  midIndex2+1,
183  cornerRightEnd,
184  rightGridChain,
185  gridMidIndex2,
186  gridIndex2,
187  leftChain,
188  0, //no left up section
189  -1,
190  cornerLeftDownStart,
191  leftEndIndex,
192  pStream);
193 
194  sampleRightStripRecF(rightChain,
195  midIndex1,
196  midIndex2,
197  rightGridChain,
198  gridMidIndex1,
199  gridMidIndex2,
200  pStream);
201 
202  }
203  else
204  {
205  sampleRightSingleTrimEdgeRegionGen(cornerTop, cornerBot,
206  rightChain,
207  cornerRightStart,
208  cornerRightEnd,
209  rightGridChain,
210  gridIndex1,
211  gridIndex2,
212  leftChain,
213  leftStartIndex,
214  cornerLeftUpEnd,
215  cornerLeftDownStart,
216  leftEndIndex,
217  pStream);
218  }
219 }
220 
221 void sampleRightSingleTrimEdgeRegionGen(Real topVertex[2], Real botVertex[2],
222  vertexArray* rightChain,
223  Int rightStart,
224  Int rightEnd,
225  gridBoundaryChain* gridChain,
226  Int gridBeginIndex,
227  Int gridEndIndex,
228  vertexArray* leftChain,
229  Int leftUpBegin,
230  Int leftUpEnd,
231  Int leftDownBegin,
232  Int leftDownEnd,
233  primStream* pStream)
234 {
235  Int i,k;
236  /*creat an array to store all the up and down secments of the left chain,
237  *and the right end grid points
238  *
239  *although vertex array is a dynamic array, but to gain efficiency,
240  *it is better to initiliza the exact array size
241  */
242  vertexArray vArray(gridEndIndex-gridBeginIndex+1 +
243  max(0,leftUpEnd - leftUpBegin+1)+
244  max(0,leftDownEnd - leftDownBegin+1));
245  //append the vertices on the up section of the left chain
246  for(i=leftUpBegin; i<= leftUpEnd; i++)
247  vArray.appendVertex(leftChain->getVertex(i));
248 
249  //append the vertices of the right extremal grid points,
250  //and at the same time, perform triangulation for the stair cases
251  vArray.appendVertex(gridChain->get_vertex(gridBeginIndex));
252 
253  for(k=1, i=gridBeginIndex+1; i<= gridEndIndex; i++, k++)
254  {
255  vArray.appendVertex(gridChain->get_vertex(i));
256 
257  //output the fan of the grid points of the (i)th and (i-1)th grid line.
258  gridChain->rightEndFan(i, pStream);
259  }
260 
261  //append all the vertices on the down section of the left chain
262  for(i=leftDownBegin; i<= leftDownEnd; i++)
263  vArray.appendVertex(leftChain->getVertex(i));
264  monoTriangulationRecGen(topVertex, botVertex,
265  &vArray, 0, vArray.getNumElements()-1,
266  rightChain, rightStart, rightEnd,
267  pStream);
268 }
269 
270 void sampleRightSingleTrimEdgeRegion(Real upperVert[2], Real lowerVert[2],
271  gridBoundaryChain* gridChain,
272  Int beginIndex,
273  Int endIndex,
274  primStream* pStream)
275 {
276  Int i,k;
277  vertexArray vArray(endIndex-beginIndex+1);
278  vArray.appendVertex(gridChain->get_vertex(beginIndex));
279  for(k=1, i=beginIndex+1; i<= endIndex; i++, k++)
280  {
281  vArray.appendVertex(gridChain->get_vertex(i));
282  //output the fan of the grid points of the (i)_th and i-1th gridLine
283  gridChain->rightEndFan(i, pStream);
284  }
285  monoTriangulation2(upperVert, lowerVert, &vArray, 0, endIndex-beginIndex,
286  1, //increase chain (to the left)
287  pStream);
288 }
289 
290 
291 /*the gridlines from rightGridChainStartIndex to
292  *rightGridChainEndIndex are assumed to form a
293  *connected componenet
294  *the trm vertex of topRightIndex is assumed to be below
295  *or equal the first gridLine, and the trm vertex of
296  *botRightIndex is assumed to be above or equal the last gridline
297  **there could be multipe trm vertices equal to the last gridline, but
298  **only one could be equal to top gridline. shape: ____| (recall that
299  **for left chain recF, we allow shape: |----
300  *if botRightIndex<topRightIndex, then no connected componenet exists, and
301  *no triangles are generated.
302  *Othewise, botRightIndex>= topRightIndex, there is at least one triangles to
303  *output
304  */
306  Int topRightIndex,
307  Int botRightIndex,
308  gridBoundaryChain* rightGridChain,
309  Int rightGridChainStartIndex,
310  Int rightGridChainEndIndex,
311  primStream* pStream
312  )
313 {
314 
315  //sstop conditionL: if topRightIndex > botRightIndex, then stop
316  if(topRightIndex > botRightIndex)
317  return;
318 
319  //if there is only one grid line, return
320  if(rightGridChainStartIndex >= rightGridChainEndIndex)
321  return;
322 
323 
324  assert(rightChain->getVertex(topRightIndex)[1] <= rightGridChain->get_v_value(rightGridChainStartIndex) &&
325  rightChain->getVertex(botRightIndex)[1] >= rightGridChain->get_v_value(rightGridChainEndIndex));
326 
327  //firstfind the first trim vertex which is strictly below the second top
328  //grid line: index1.
329  Real secondGridChainV = rightGridChain->get_v_value(rightGridChainStartIndex+1);
330  Int index1 = topRightIndex;
331  while(rightChain->getVertex(index1)[1] >= secondGridChainV){
332  index1++;
333  if(index1 > botRightIndex)
334  break;
335  }
336  //now rightChain->getVertex(index1-1)[1] >= secondGridChainV and
337  //rightChain->getVertex(index1)[1] < secondGridChainV and
338  //we should include index1-1 to perform a gridStep
339  index1--;
340 
341  //now we have rightChain->getVertex(index1)[1] >= secondGridChainV, and
342  //rightChain->getVertex(index1+1)[1] < secondGridChainV
343  sampleRightOneGridStep(rightChain, topRightIndex, index1, rightGridChain, rightGridChainStartIndex, pStream);
344 
345  //if rightChain->getVertex(index1)[1] ==secondGridChainV then we can
346  //recurvesively to the rest
347  if(rightChain->getVertex(index1)[1] == secondGridChainV)
348  {
349 
350 
351  sampleRightStripRecF(rightChain, index1, botRightIndex, rightGridChain, rightGridChainStartIndex+1, rightGridChainEndIndex, pStream);
352  }
353  else if(index1 < botRightIndex)
354  {
355  //otherwise, we have rightChain->getVertex(index1)[1] > secondV
356  //let the next trim vertex be nextTrimVertex, (which should be strictly
357  //below the second grid line). Find the last grid line index2 which is STRICTLY ABOVE
358  //nextTrimVertex.
359  //sample one trm edge region.
360  Real *uppervert, *lowervert;
361  uppervert = rightChain->getVertex(index1);
362  lowervert = rightChain->getVertex(index1+1); //okay since index1<botRightindex
363  Int index2 = rightGridChainStartIndex+1;
364  while(rightGridChain->get_v_value(index2) > lowervert[1])
365  {
366  index2++;
367  if(index2 > rightGridChainEndIndex)
368  break;
369  }
370  index2--;
371 
372  sampleRightSingleTrimEdgeRegion(uppervert, lowervert, rightGridChain, rightGridChainStartIndex+1, index2, pStream);
373 
374  //recursion
375  sampleRightStripRecF(rightChain, index1+1, botRightIndex, rightGridChain, index2, rightGridChainEndIndex, pStream);
376  }
377 }
378 
379 //the degenerate case of sampleRightOneGridStep
381  Int beginRightIndex,
382  Int endRightIndex,
383  gridBoundaryChain* rightGridChain,
384  Int rightGridChainStartIndex,
385  primStream* pStream)
386 {
387  /*since there is no middle, there is at most one point which is on the
388  *second grid line, there could be multiple points on the first (top)
389  *grid line.
390  */
391  rightGridChain->rightEndFan(rightGridChainStartIndex+1, pStream);
392  monoTriangulation2(rightGridChain->get_vertex(rightGridChainStartIndex),
393  rightGridChain->get_vertex(rightGridChainStartIndex+1),
394  rightChain,
395  beginRightIndex,
396  endRightIndex,
397  0, //decrease chain
398  pStream);
399 }
400 
401 //sampling the right area in between two grid lines
402 //shape: _________|
404  Int beginRightIndex,
405  Int endRightIndex,
406  gridBoundaryChain* rightGridChain,
407  Int rightGridChainStartIndex,
408  primStream* pStream)
409 {
410  if(checkMiddle(rightChain, beginRightIndex, endRightIndex,
411  rightGridChain->get_v_value(rightGridChainStartIndex),
412  rightGridChain->get_v_value(rightGridChainStartIndex+1))<0)
413  {
414  sampleRightOneGridStepNoMiddle(rightChain, beginRightIndex, endRightIndex, rightGridChain, rightGridChainStartIndex, pStream);
415  return;
416  }
417 
418  //copy into a polygn
419  {
420  directedLine* poly = NULL;
421  sampledLine* sline;
422  directedLine* dline;
423  gridWrap* grid = rightGridChain->getGrid();
424  float vert1[2];
425  float vert2[2];
426  Int i;
427 
428  Int innerInd = rightGridChain->getInnerIndex(rightGridChainStartIndex+1);
429  Int upperInd = rightGridChain->getUlineIndex(rightGridChainStartIndex);
430  Int lowerInd = rightGridChain->getUlineIndex(rightGridChainStartIndex+1);
431  Real upperV = rightGridChain->get_v_value(rightGridChainStartIndex);
432  Real lowerV = rightGridChain->get_v_value(rightGridChainStartIndex+1);
433 
434  //the upper gridline
435  vert1[1]=vert2[1]=upperV;
436  for(i=upperInd;
437  i>innerInd;
438  i--)
439  {
440  vert1[0]=grid->get_u_value(i);
441  vert2[0]=grid->get_u_value(i-1);
442  sline = new sampledLine(vert1, vert2);
443  dline = new directedLine(INCREASING, sline);
444  if(poly == NULL)
445  poly = dline;
446  else
447  poly->insert(dline);
448  }
449 
450  //the vertical grid line segment
451  vert1[0]=vert2[0] = grid->get_u_value(innerInd);
452  vert1[1]=upperV;
453  vert2[1]=lowerV;
454  sline=new sampledLine(vert1, vert2);
455  dline=new directedLine(INCREASING, sline);
456  if(poly == NULL)
457  poly = dline;
458  else
459  poly->insert(dline);
460 
461  //the lower grid line
462  vert1[1]=vert2[1]=lowerV;
463  for(i=innerInd; i<lowerInd; i++)
464  {
465  vert1[0] = grid->get_u_value(i);
466  vert2[0] = grid->get_u_value(i+1);
467  sline = new sampledLine(vert1, vert2);
468  dline = new directedLine(INCREASING, sline);
469  poly->insert(dline);
470  }
471 
472  //the edge connecting lower grid to right chain
473  vert1[0]=grid->get_u_value(lowerInd);
474  sline = new sampledLine(vert1, rightChain->getVertex(endRightIndex));
475  dline = new directedLine(INCREASING, sline);
476  poly->insert(dline);
477 
478 
479  //the right Chain
480  for(i=endRightIndex; i>beginRightIndex; i--)
481  {
482  sline = new sampledLine(rightChain->getVertex(i), rightChain->getVertex(i-1));
483  dline = new directedLine(INCREASING, sline);
484  poly->insert(dline);
485  }
486 
487  //the edge connecting right chain with upper grid
488  vert2[1]=upperV;
489  vert2[0]=grid->get_u_value(upperInd);
490  sline = new sampledLine(rightChain->getVertex(beginRightIndex), vert2);
491  dline = new directedLine(INCREASING, sline);
492  poly->insert(dline);
493  monoTriangulationOpt(poly, pStream);
494  //clean up
496 
497  return;
498  }
499 
500  //this following code cannot be reached, but leave it for debuggig purpose.
501  Int i;
502  //find the maximal U-monotone chain of beginRightIndex, beginRightIndex+1,...
503  i=beginRightIndex;
504  Real prevU = rightChain->getVertex(i)[0];
505  for(i=beginRightIndex+1; i<= endRightIndex; i++){
506  Real thisU = rightChain->getVertex(i)[0];
507  if(thisU < prevU)
508  prevU = thisU;
509  else
510  break;
511  }
512  //from beginRightIndex to i-1 is strictly U-monotne
513  //if(i-1==beginRightIndex and the vertex of rightchain is on the first
514  //gridline, then we should use 2 vertices on the right chain. Of we only
515  //use one (begin), we would output degenrate triangles.
516  if(i-1 == beginRightIndex && rightChain->getVertex(beginRightIndex)[1] == rightGridChain->get_v_value(rightGridChainStartIndex))
517  i++;
518 
519  Int j = endRightIndex -1;
520  if(rightGridChain->getInnerIndex(rightGridChainStartIndex+1) < rightGridChain->getUlineIndex(rightGridChainStartIndex+1))
521  {
522  j = rightChain->findDecreaseChainFromEnd(i-1/*beginRightIndex*/, endRightIndex);
523  Int temp = endRightIndex;
524  //now from j+1 to end is strictly U-monotone.
525  //if j+1 is on the last grid line, then we wat to skip to the vertex
526  //whcih is strictly above the second grid line. This vertex must exist
527  //since there is a middle vertex
528  if(j+1 == endRightIndex)
529  {
530  while(rightChain->getVertex(j+1)[1] == rightGridChain->get_v_value(rightGridChainStartIndex+1))
531  j--;
532 
533  monoTriangulation2(rightChain->getVertex(j+1),
534  rightGridChain->get_vertex(rightGridChainStartIndex+1),
535  rightChain,
536  j+2,
537  endRightIndex,
538  0, //a decrease chain
539  pStream);
540 
541  temp = j+1;
542  }
543 
544  stripOfFanRight(rightChain, temp, j+1, rightGridChain->getGrid(),
545  rightGridChain->getVlineIndex(rightGridChainStartIndex+1),
546  rightGridChain->getInnerIndex(rightGridChainStartIndex+1),
547  rightGridChain->getUlineIndex(rightGridChainStartIndex+1),
548  pStream,
549  0 //the grid line is below the trim line
550  );
551 
552  }
553 
554 
555  stripOfFanRight(rightChain, i-1, beginRightIndex, rightGridChain->getGrid(),
556  rightGridChain->getVlineIndex(rightGridChainStartIndex),
557  rightGridChain->getInnerIndex(rightGridChainStartIndex+1),
558  rightGridChain->getUlineIndex(rightGridChainStartIndex),
559  pStream,
560  1 //the grid line is above the trm lines
561  );
562 
563  //monotone triangulate the remaining rightchain together with the
564  //two vertices on the two grid v-lines
565  Real vert[2][2];
566  vert[0][0] = vert[1][0] = rightGridChain->getInner_u_value(rightGridChainStartIndex+1);
567  vert[0][1] = rightGridChain->get_v_value(rightGridChainStartIndex);
568  vert[1][1] = rightGridChain->get_v_value(rightGridChainStartIndex+1);
569 
570  monoTriangulation2(&vert[0][0],
571  &vert[1][0],
572  rightChain,
573  i-1,
574  j+1,
575  0,
576  pStream);
577 }
578 
579 #endif
580 
581 void stripOfFanRight(vertexArray* rightChain,
582  Int largeIndex,
583  Int smallIndex,
584  gridWrap* grid,
585  Int vlineIndex,
586  Int ulineSmallIndex,
587  Int ulineLargeIndex,
588  primStream* pStream,
589  Int gridLineUp /*1 if the grid line is above the trim lines*/
590  )
591 {
592  assert(largeIndex >= smallIndex);
593 
594  Real grid_v_value;
595  grid_v_value = grid->get_v_value(vlineIndex);
596 
597  Real2* trimVerts=(Real2*) malloc(sizeof(Real2)* (largeIndex-smallIndex+1));
598  assert(trimVerts);
599 
600 
601  Real2* gridVerts=(Real2*) malloc(sizeof(Real2)* (ulineLargeIndex-ulineSmallIndex+1));
602  assert(gridVerts);
603 
604  Int k,i;
605  if(! gridLineUp) /*trim line is above grid line, so trim vertices are going right when index increases*/
606  for(k=0, i=smallIndex; i<=largeIndex; i++, k++)
607  {
608  trimVerts[k][0] = rightChain->getVertex(i)[0];
609  trimVerts[k][1] = rightChain->getVertex(i)[1];
610  }
611  else
612  for(k=0, i=largeIndex; i>=smallIndex; i--, k++)
613  {
614  trimVerts[k][0] = rightChain->getVertex(i)[0];
615  trimVerts[k][1] = rightChain->getVertex(i)[1];
616  }
617 
618  for(k=0, i=ulineSmallIndex; i<= ulineLargeIndex; i++, k++)
619  {
620  gridVerts[k][0] = grid->get_u_value(i);
621  gridVerts[k][1] = grid_v_value;
622  }
623 
624  if(gridLineUp)
626  ulineLargeIndex-ulineSmallIndex+1, gridVerts,
627  largeIndex-smallIndex+1, trimVerts,
628  pStream);
629  else
630  triangulateXYMono(largeIndex-smallIndex+1, trimVerts,
631  ulineLargeIndex-ulineSmallIndex+1, gridVerts,
632  pStream);
633  free(trimVerts);
634  free(gridVerts);
635 }
636 
637 
638 
639 
640 
641 
642 
643 
644 
Int getVlineIndex(Int i)
Definition: gridWrap.h:119
void sampleRightSingleTrimEdgeRegionGen(Real topVertex[2], Real botVertex[2], vertexArray *rightChain, Int rightStart, Int rightEnd, gridBoundaryChain *gridChain, Int gridBeginIndex, Int gridEndIndex, vertexArray *leftChain, Int leftUpBegin, Int leftUpEnd, Int leftDownBegin, Int leftDownEnd, primStream *pStream)
void monoTriangulationRecGen(Real *topVertex, Real *botVertex, vertexArray *inc_chain, Int inc_current, Int inc_end, vertexArray *dec_chain, Int dec_current, Int dec_end, primStream *pStream)
void rightEndFan(Int i, primStream *pStream)
Definition: gridWrap.cc:249
void triangulateXYMono(Int n_upper, Real upperVerts[][2], Int n_lower, Real lowerVerts[][2], primStream *pStream)
void appendVertex(Real *ptr)
#define free
Definition: debug_ros.c:5
#define assert(x)
Definition: debug.h:53
void deleteSinglePolygonWithSline()
Real get_v_value(Int j)
Definition: gridWrap.h:83
void sampleRightSingleTrimEdgeRegion(Real upperVert[2], Real lowerVert[2], gridBoundaryChain *gridChain, Int beginIndex, Int endIndex, primStream *pStream)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Real * get_vertex(Int i)
Definition: gridWrap.h:127
Real get_u_value(Int i)
Definition: gridWrap.h:78
Int findIndexBelowGen(Real v, Int startIndex, Int EndIndex)
smooth NULL
Definition: ftsmooth.c:416
Real getInner_u_value(Int i)
Definition: gridWrap.h:125
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Int getUlineIndex(Int i)
Definition: gridWrap.h:120
#define max(a, b)
gridWrap * getGrid()
Definition: gridWrap.h:128
Real get_v_value(Int i)
Definition: gridWrap.h:122
void sampleRightStripRecF(vertexArray *rightChain, Int topRightIndex, Int botRightIndex, gridBoundaryChain *rightGridChain, Int rightGridChainStartIndex, Int rightGridChainEndIndex, primStream *pStream)
void sampleCompRight(Real *topVertex, Real *botVertex, vertexArray *leftChain, Int leftStartIndex, Int leftEndIndex, vertexArray *rightChain, Int rightStartIndex, Int rightEndIndex, gridBoundaryChain *rightGridChain, Int gridIndex1, Int gridIndex2, Int up_rightCornerWhere, Int up_rightCornerIndex, Int down_rightCornerWhere, Int down_rightCornerIndex, primStream *pStream)
void sampleRightOneGridStepNoMiddle(vertexArray *rightChain, Int beginRightIndex, Int endRightIndex, gridBoundaryChain *rightGridChain, Int rightGridChainStartIndex, primStream *pStream)
Int getInnerIndex(Int i)
Definition: gridWrap.h:124
static calc_node_t temp
Definition: rpn_ieee.c:38
void monoTriangulationOpt(directedLine *poly, primStream *pStream)
float Real
Definition: definitions.h:36
void stripOfFanRight(vertexArray *rightChain, Int largeIndex, Int smallIndex, gridWrap *grid, Int vlineIndex, Int ulineSmallIndex, Int ulineLargeIndex, primStream *pStream, Int gridLineUp)
void sampleRightOneGridStep(vertexArray *rightChain, Int beginRightIndex, Int endRightIndex, gridBoundaryChain *rightGridChain, Int rightGridChainStartIndex, primStream *pStream)
#define malloc
Definition: debug_ros.c:4
Real Real2[2]
Definition: definitions.h:38
Int findDecreaseChainFromEnd(Int begin, Int end)
void monoTriangulation2(Real *topVertex, Real *botVertex, vertexArray *inc_chain, Int inc_smallIndex, Int inc_largeIndex, Int is_increase_chain, primStream *pStream)
Real * getVertex(Int i)
Int checkMiddle(vertexArray *chain, Int begin, Int end, Real vup, Real vbelow)
int k
Definition: mpi.c:3369
void insert(directedLine *nl)
Int findIndexAboveGen(Real v, Int startIndex, Int EndIndex)
int Int
Definition: definitions.h:37