ReactOS  0.4.14-dev-57-g333b8f1
arctess.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  * arctessellator.c++
37  *
38  */
39 
40 //#include "glimports.h"
41 //#include "mystdio.h"
42 //#include "myassert.h"
43 #include "arctess.h"
44 //#include "bufpool.h"
45 #include "simplemath.h"
46 #include "bezierarc.h"
47 //#include "trimvertex.h"
48 #include "trimvertpool.h"
49 
50 #define NOELIMINATION
51 
52 #define steps_function(large, small, rate) (max(1, 1+ (int) ((large-small)/rate)));
53 
54 /*-----------------------------------------------------------------------------
55  * ArcTessellator - construct an ArcTessellator
56  *-----------------------------------------------------------------------------
57  */
58 
60  : pwlarcpool(p), trimvertexpool(t)
61 {
62 }
63 
64 /*-----------------------------------------------------------------------------
65  * ~ArcTessellator - destroy an ArcTessellator
66  *-----------------------------------------------------------------------------
67  */
68 
70 {
71 }
72 
73 /*-----------------------------------------------------------------------------
74  * bezier - construct a bezier arc and attach it to an Arc
75  *-----------------------------------------------------------------------------
76  */
77 
78 void
80 {
81  assert( arc != 0 );
82  assert( ! arc->isTessellated() );
83 
84 #ifndef NDEBUG
85  switch( arc->getside() ) {
86  case arc_left:
87  assert( s1 == s2 );
88  assert( t2 < t1 );
89  break;
90  case arc_right:
91  assert( s1 == s2 );
92  assert( t1 < t2 );
93  break;
94  case arc_top:
95  assert( t1 == t2 );
96  assert( s2 < s1 );
97  break;
98  case arc_bottom:
99  assert( t1 == t2 );
100  assert( s1 < s2 );
101  break;
102  case arc_none:
103  (void) abort();
104  break;
105  }
106 #endif
107 
109  arc->pwlArc = new(pwlarcpool) PwlArc( 2, p );
110  p[0].param[0] = s1;
111  p[0].param[1] = t1;
112  p[1].param[0] = s2;
113  p[1].param[1] = t2;
114  assert( (s1 == s2) || (t1 == t2) );
115  arc->setbezier();
116 }
117 
118 
119 /*-----------------------------------------------------------------------------
120  * pwl_left - construct a left boundary pwl arc and attach it to an arc
121  *-----------------------------------------------------------------------------
122  */
123 
124 void
126 {
127  assert( t2 < t1 );
128 
129 /* if(rate <= 0.06) rate = 0.06;*/
130 /* int nsteps = 1 + (int) ((t1 - t2) / rate ); */
131  int nsteps = steps_function(t1, t2, rate);
132 
133 
134  REAL stepsize = (t1 - t2) / (REAL) nsteps;
135 
136  TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
137  int i;
138  for( i = nsteps; i > 0; i-- ) {
139  newvert[i].param[0] = s;
140  newvert[i].param[1] = t2;
141  t2 += stepsize;
142  }
143  newvert[i].param[0] = s;
144  newvert[i].param[1] = t1;
145 
146  arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_left );
147 }
148 
149 /*-----------------------------------------------------------------------------
150  * pwl_right - construct a right boundary pwl arc and attach it to an arc
151  *-----------------------------------------------------------------------------
152  */
153 
154 void
156 {
157  assert( t1 < t2 );
158 
159 /* if(rate <= 0.06) rate = 0.06;*/
160 
161 /* int nsteps = 1 + (int) ((t2 - t1) / rate ); */
162  int nsteps = steps_function(t2,t1,rate);
163  REAL stepsize = (t2 - t1) / (REAL) nsteps;
164 
165  TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
166  int i;
167  for( i = 0; i < nsteps; i++ ) {
168  newvert[i].param[0] = s;
169  newvert[i].param[1] = t1;
170  t1 += stepsize;
171  }
172  newvert[i].param[0] = s;
173  newvert[i].param[1] = t2;
174 
175  arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_right );
176 }
177 
178 
179 /*-----------------------------------------------------------------------------
180  * pwl_top - construct a top boundary pwl arc and attach it to an arc
181  *-----------------------------------------------------------------------------
182  */
183 
184 void
186 {
187  assert( s2 < s1 );
188 
189 /* if(rate <= 0.06) rate = 0.06;*/
190 
191 /* int nsteps = 1 + (int) ((s1 - s2) / rate ); */
192  int nsteps = steps_function(s1,s2,rate);
193  REAL stepsize = (s1 - s2) / (REAL) nsteps;
194 
195  TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
196  int i;
197  for( i = nsteps; i > 0; i-- ) {
198  newvert[i].param[0] = s2;
199  newvert[i].param[1] = t;
200  s2 += stepsize;
201  }
202  newvert[i].param[0] = s1;
203  newvert[i].param[1] = t;
204 
205  arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_top );
206 }
207 
208 /*-----------------------------------------------------------------------------
209  * pwl_bottom - construct a bottom boundary pwl arc and attach it to an arc
210  *-----------------------------------------------------------------------------
211  */
212 
213 void
215 {
216  assert( s1 < s2 );
217 
218 /* if(rate <= 0.06) rate = 0.06;*/
219 
220 /* int nsteps = 1 + (int) ((s2 - s1) / rate ); */
221  int nsteps = steps_function(s2,s1,rate);
222  REAL stepsize = (s2 - s1) / (REAL) nsteps;
223 
224  TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
225  int i;
226  for( i = 0; i < nsteps; i++ ) {
227  newvert[i].param[0] = s1;
228  newvert[i].param[1] = t;
229  s1 += stepsize;
230  }
231  newvert[i].param[0] = s2;
232  newvert[i].param[1] = t;
233 
234  arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom );
235 }
236 
237 /*-----------------------------------------------------------------------------
238  * pwl - construct a pwl arc and attach it to an arc
239  *-----------------------------------------------------------------------------
240  */
241 
242 void
244 {
245 
246 /* if(rate <= 0.06) rate = 0.06;*/
247 
248  int snsteps = 1 + (int) (glu_abs(s2 - s1) / rate );
249  int tnsteps = 1 + (int) (glu_abs(t2 - t1) / rate );
250  int nsteps = max(1,max( snsteps, tnsteps ));
251 
252  REAL sstepsize = (s2 - s1) / (REAL) nsteps;
253  REAL tstepsize = (t2 - t1) / (REAL) nsteps;
254  TrimVertex *newvert = trimvertexpool.get( nsteps+1 );
255  long i;
256  for( i = 0; i < nsteps; i++ ) {
257  newvert[i].param[0] = s1;
258  newvert[i].param[1] = t1;
259  s1 += sstepsize;
260  t1 += tstepsize;
261  }
262  newvert[i].param[0] = s2;
263  newvert[i].param[1] = t2;
264 
265  /* arc->makeSide( new(pwlarcpool) PwlArc( nsteps+1, newvert ), arc_bottom ); */
266  arc->pwlArc = new(pwlarcpool) PwlArc( nsteps+1, newvert );
267 
268  arc->clearbezier();
269  arc->clearside( );
270 }
271 
272 
273 /*-----------------------------------------------------------------------------
274  * tessellateLinear - constuct a linear pwl arc and attach it to an Arc
275  *-----------------------------------------------------------------------------
276  */
277 
278 void
279 ArcTessellator::tessellateLinear( Arc *arc, REAL geo_stepsize, REAL arc_stepsize, int isrational )
280 {
281  assert( arc->pwlArc == NULL );
282  REAL s1, s2, t1, t2;
283 
284  //we don't need to scale by arc_stepsize if the trim curve
285  //is piecewise linear. Reason: In pwl_right, pwl_left, pwl_top, pwl_left,
286  //and pwl, the nsteps is computed by deltaU (or V) /stepsize.
287  //The quantity deltaU/arc_stepsize doesn't have any meaning. And
288  //it causes problems: see bug 517641
289  REAL stepsize = geo_stepsize; /* * arc_stepsize*/;
290 
291  BezierArc *b = arc->bezierArc;
292 
293  if( isrational ) {
294  s1 = b->cpts[0] / b->cpts[2];
295  t1 = b->cpts[1] / b->cpts[2];
296  s2 = b->cpts[b->stride+0] / b->cpts[b->stride+2];
297  t2 = b->cpts[b->stride+1] / b->cpts[b->stride+2];
298  } else {
299  s1 = b->cpts[0];
300  t1 = b->cpts[1];
301  s2 = b->cpts[b->stride+0];
302  t2 = b->cpts[b->stride+1];
303  }
304  if( s1 == s2 )
305  if( t1 < t2 )
306  pwl_right( arc, s1, t1, t2, stepsize );
307  else
308  pwl_left( arc, s1, t1, t2, stepsize );
309  else if( t1 == t2 )
310  if( s1 < s2 )
311  pwl_bottom( arc, t1, s1, s2, stepsize );
312  else
313  pwl_top( arc, t1, s1, s2, stepsize );
314  else
315  pwl( arc, s1, s2, t1, t2, stepsize );
316 }
317 
318 /*-----------------------------------------------------------------------------
319  * tessellateNonlinear - constuct a nonlinear pwl arc and attach it to an Arc
320  *-----------------------------------------------------------------------------
321  */
322 
323 void
324 ArcTessellator::tessellateNonlinear( Arc *arc, REAL geo_stepsize, REAL arc_stepsize, int isrational )
325 {
326  assert( arc->pwlArc == NULL );
327 
328  REAL stepsize = geo_stepsize * arc_stepsize;
329 
330  BezierArc *bezierArc = arc->bezierArc;
331 
332  REAL size; //bounding box size of the curve in UV
333  {
334  int i,j;
335  REAL min_u, min_v, max_u,max_v;
336  min_u = max_u = bezierArc->cpts[0];
337  min_v = max_v = bezierArc->cpts[1];
338  for(i=1, j=bezierArc->stride; i<bezierArc->order; i++, j+= bezierArc->stride)
339  {
340  if(bezierArc->cpts[j] < min_u)
341  min_u = bezierArc->cpts[j];
342  if(bezierArc->cpts[j] > max_u)
343  max_u = bezierArc->cpts[j];
344  if(bezierArc->cpts[j+1] < min_v)
345  min_v = bezierArc->cpts[j+1];
346  if(bezierArc->cpts[j+1] > max_v)
347  max_v = bezierArc->cpts[j+1];
348  }
349 
350  size = max_u - min_u;
351  if(size < max_v - min_v)
352  size = max_v - min_v;
353  }
354 
355  /*int nsteps = 1 + (int) (1.0/stepsize);*/
356 
357  int nsteps = (int) (size/stepsize);
358  if(nsteps <=0)
359  nsteps=1;
360 
361  TrimVertex *vert = trimvertexpool.get( nsteps+1 );
362  REAL dp = 1.0/nsteps;
363 
364 
365  arc->pwlArc = new(pwlarcpool) PwlArc();
366  arc->pwlArc->pts = vert;
367 
368  if( isrational ) {
369  REAL pow_u[MAXORDER], pow_v[MAXORDER], pow_w[MAXORDER];
370  trim_power_coeffs( bezierArc, pow_u, 0 );
371  trim_power_coeffs( bezierArc, pow_v, 1 );
372  trim_power_coeffs( bezierArc, pow_w, 2 );
373 
374  /* compute first point exactly */
375  REAL *b = bezierArc->cpts;
376  vert->param[0] = b[0]/b[2];
377  vert->param[1] = b[1]/b[2];
378 
379  /* strength reduction on p = dp * step would introduce error */
380  int step;
381 #ifndef NOELIMINATION
382  int ocanremove = 0;
383 #endif
384  register long order = bezierArc->order;
385  for( step=1, ++vert; step<nsteps; step++, vert++ ) {
386  register REAL p = dp * step;
387  register REAL u = pow_u[0];
388  register REAL v = pow_v[0];
389  register REAL w = pow_w[0];
390  for( register int i = 1; i < order; i++ ) {
391  u = u * p + pow_u[i];
392  v = v * p + pow_v[i];
393  w = w * p + pow_w[i];
394  }
395  vert->param[0] = u/w;
396  vert->param[1] = v/w;
397 #ifndef NOELIMINATION
398  REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
399  REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
400  int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
401  REAL ods=0.0, odt=0.0;
402 
403  if( ocanremove && canremove ) {
404  REAL nds = ds + ods;
405  REAL ndt = dt + odt;
406  if( nds<geo_stepsize && ndt<geo_stepsize ) {
407  // remove previous point
408  --vert;
409  vert[0].param[0] = vert[1].param[0];
410  vert[0].param[1] = vert[1].param[1];
411  ods = nds;
412  odt = ndt;
413  ocanremove = 1;
414  } else {
415  ocanremove = canremove;
416  ods = ds;
417  odt = dt;
418  }
419  } else {
420  ocanremove = canremove;
421  ods = ds;
422  odt = dt;
423  }
424 #endif
425  }
426 
427  /* compute last point exactly */
428  b += (order - 1) * bezierArc->stride;
429  vert->param[0] = b[0]/b[2];
430  vert->param[1] = b[1]/b[2];
431 
432  } else {
433  REAL pow_u[MAXORDER], pow_v[MAXORDER];
434  trim_power_coeffs( bezierArc, pow_u, 0 );
435  trim_power_coeffs( bezierArc, pow_v, 1 );
436 
437  /* compute first point exactly */
438  REAL *b = bezierArc->cpts;
439  vert->param[0] = b[0];
440  vert->param[1] = b[1];
441 
442  /* strength reduction on p = dp * step would introduce error */
443  int step;
444 #ifndef NOELIMINATION
445  int ocanremove = 0;
446 #endif
447  register long order = bezierArc->order;
448  for( step=1, ++vert; step<nsteps; step++, vert++ ) {
449  register REAL p = dp * step;
450  register REAL u = pow_u[0];
451  register REAL v = pow_v[0];
452  for( register int i = 1; i < bezierArc->order; i++ ) {
453  u = u * p + pow_u[i];
454  v = v * p + pow_v[i];
455  }
456  vert->param[0] = u;
457  vert->param[1] = v;
458 #ifndef NOELIMINATION
459  REAL ds = glu_abs(vert[0].param[0] - vert[-1].param[0]);
460  REAL dt = glu_abs(vert[0].param[1] - vert[-1].param[1]);
461  int canremove = (ds<geo_stepsize && dt<geo_stepsize) ? 1 : 0;
462  REAL ods=0.0, odt=0.0;
463 
464  if( ocanremove && canremove ) {
465  REAL nds = ds + ods;
466  REAL ndt = dt + odt;
467  if( nds<geo_stepsize && ndt<geo_stepsize ) {
468  // remove previous point
469  --vert;
470  vert[0].param[0] = vert[1].param[0];
471  vert[0].param[1] = vert[1].param[1];
472  ods = nds;
473  odt = ndt;
474  ocanremove = 1;
475  } else {
476  ocanremove = canremove;
477  ods = ds;
478  odt = dt;
479  }
480  } else {
481  ocanremove = canremove;
482  ods = ds;
483  odt = dt;
484  }
485 #endif
486  }
487 
488  /* compute last point exactly */
489  b += (order - 1) * bezierArc->stride;
490  vert->param[0] = b[0];
491  vert->param[1] = b[1];
492  }
493  arc->pwlArc->npts = vert - arc->pwlArc->pts + 1;
494 /*
495  for( TrimVertex *vt=pwlArc->pts; vt != vert-1; vt++ ) {
496  if( tooclose( vt[0].param[0], vt[1].param[0] ) )
497  vt[1].param[0] = vt[0].param[0];
498  if( tooclose( vt[0].param[1], vt[1].param[1] ) )
499  vt[1].param[1] = vt[0].param[1];
500  }
501 */
502 }
503 
505  {
506  {1, 0, 0, 0, 0, 0, 0, 0 },
507  {0, 0, 0, 0, 0, 0, 0, 0 },
508  {0, 0, 0, 0, 0, 0, 0, 0 },
509  {0, 0, 0, 0, 0, 0, 0, 0 },
510  {0, 0, 0, 0, 0, 0, 0, 0 },
511  {0, 0, 0, 0, 0, 0, 0, 0 },
512  {0, 0, 0, 0, 0, 0, 0, 0 },
513  {0, 0, 0, 0, 0, 0, 0, 0 }
514  },
515  {
516  {-1, 1, 0, 0, 0, 0, 0, 0 },
517  {1, 0, 0, 0, 0, 0, 0, 0 },
518  {0, 0, 0, 0, 0, 0, 0, 0 },
519  {0, 0, 0, 0, 0, 0, 0, 0 },
520  {0, 0, 0, 0, 0, 0, 0, 0 },
521  {0, 0, 0, 0, 0, 0, 0, 0 },
522  {0, 0, 0, 0, 0, 0, 0, 0 },
523  {0, 0, 0, 0, 0, 0, 0, 0 }
524  },
525  {
526  {1, -2, 1, 0, 0, 0, 0, 0 },
527  {-2, 2, 0, 0, 0, 0, 0, 0 },
528  {1, 0, 0, 0, 0, 0, 0, 0 },
529  {0, 0, 0, 0, 0, 0, 0, 0 },
530  {0, 0, 0, 0, 0, 0, 0, 0 },
531  {0, 0, 0, 0, 0, 0, 0, 0 },
532  {0, 0, 0, 0, 0, 0, 0, 0 },
533  {0, 0, 0, 0, 0, 0, 0, 0 }
534  },
535  {
536  {-1, 3, -3, 1, 0, 0, 0, 0 },
537  {3, -6, 3, 0, 0, 0, 0, 0 },
538  {-3, 3, 0, 0, 0, 0, 0, 0 },
539  {1, 0, 0, 0, 0, 0, 0, 0 },
540  {0, 0, 0, 0, 0, 0, 0, 0 },
541  {0, 0, 0, 0, 0, 0, 0, 0 },
542  {0, 0, 0, 0, 0, 0, 0, 0 },
543  {0, 0, 0, 0, 0, 0, 0, 0 }
544  },
545  {
546  {1, -4, 6, -4, 1, 0, 0, 0 },
547  {-4, 12, -12, 4, 0, 0, 0, 0 },
548  {6, -12, 6, 0, 0, 0, 0, 0 },
549  {-4, 4, 0, 0, 0, 0, 0, 0 },
550  {1, 0, 0, 0, 0, 0, 0, 0 },
551  {0, 0, 0, 0, 0, 0, 0, 0 },
552  {0, 0, 0, 0, 0, 0, 0, 0 },
553  {0, 0, 0, 0, 0, 0, 0, 0 }
554  },
555  {
556  {-1, 5, -10, 10, -5, 1, 0, 0 },
557  {5, -20, 30, -20, 5, 0, 0, 0 },
558  {-10, 30, -30, 10, 0, 0, 0, 0 },
559  {10, -20, 10, 0, 0, 0, 0, 0 },
560  {-5, 5, 0, 0, 0, 0, 0, 0 },
561  {1, 0, 0, 0, 0, 0, 0, 0 },
562  {0, 0, 0, 0, 0, 0, 0, 0 },
563  {0, 0, 0, 0, 0, 0, 0, 0 }
564  },
565  {
566  {1, -6, 15, -20, 15, -6, 1, 0 },
567  {-6, 30, -60, 60, -30, 6, 0, 0 },
568  {15, -60, 90, -60, 15, 0, 0, 0 },
569  {-20, 60, -60, 20, 0, 0, 0, 0 },
570  {15, -30, 15, 0, 0, 0, 0, 0 },
571  {-6, 6, 0, 0, 0, 0, 0, 0 },
572  {1, 0, 0, 0, 0, 0, 0, 0 },
573  {0, 0, 0, 0, 0, 0, 0, 0 }
574  },
575  {
576  {-1, 7, -21, 35, -35, 21, -7, 1 },
577  {7, -42, 105, -140, 105, -42, 7, 0 },
578  {-21, 105, -210, 210, -105, 21, 0, 0 },
579  {35, -140, 210, -140, 35, 0, 0, 0 },
580  {-35, 105, -105, 35, 0, 0, 0, 0 },
581  {21, -42, 21, 0, 0, 0, 0, 0 },
582  {-7, 7, 0, 0, 0, 0, 0, 0 },
583  {1, 0, 0, 0, 0, 0, 0, 0 }
584  }};
585 
586 
587 /*-----------------------------------------------------------------------------
588  * trim_power_coeffs - compute power basis coefficients from bezier coeffients
589  *-----------------------------------------------------------------------------
590  */
591 void
593 {
594  register int stride = bez_arc->stride;
595  register int order = bez_arc->order;
596  register REAL *base = bez_arc->cpts + coord;
597 
598  REAL const (*mat)[MAXORDER][MAXORDER] = &gl_Bernstein[order-1];
599  REAL const (*lrow)[MAXORDER] = &(*mat)[order];
600 
601  /* WIN32 didn't like the following line within the for-loop */
602  REAL const (*row)[MAXORDER] = &(*mat)[0];
603  for( ; row != lrow; row++ ) {
604  register REAL s = 0.0;
605  register REAL *point = base;
606  register REAL const *mlast = *row + order;
607  for( REAL const *m = *row; m != mlast; m++, point += stride )
608  s += *(m) * (*point);
609  *(p++) = s;
610  }
611 }
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 * u
Definition: glfuncs.h:240
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
#define max(a, b)
Definition: svc.c:63
int npts
Definition: pwlarc.h:47
struct S2 s2
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
Definition: arc.h:52
REAL glu_abs(REAL x)
Definition: simplemath.h:50
void setbezier()
Definition: arc.h:84
TrimVertexPool & trimvertexpool
Definition: arctess.h:62
Definition: pwlarc.h:44
GLdouble GLdouble t
Definition: gl.h:2047
#define ds
Definition: i386-dis.c:434
#define assert(x)
Definition: debug.h:53
void pwl_top(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:185
int rate
Definition: pcmconverter.c:98
#define steps_function(large, small, rate)
Definition: arctess.cc:52
POINTL point
Definition: edittest.c:50
const GLfloat * m
Definition: glext.h:10848
Definition: arc.h:55
GLuint coord
Definition: glext.h:9511
void makeSide(PwlArc *, arc_side)
Definition: arc.cc:62
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
void clearbezier()
Definition: arc.h:85
void tessellateNonlinear(Arc_ptr, REAL, REAL, int)
Definition: arctess.cc:324
GLuint base
Definition: 3dtext.c:35
void tessellateLinear(Arc_ptr, REAL, REAL, int)
Definition: arctess.cc:279
Definition: arc.h:52
Definition: arc.h:52
smooth NULL
Definition: ftsmooth.c:416
Pool & pwlarcpool
Definition: arctess.h:61
void pwl_bottom(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:214
REAL * cpts
Definition: bezierarc.h:44
TrimVertex * get(int)
int isTessellated()
Definition: arc.h:82
#define MAXORDER
Definition: defines.h:45
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
void clearside()
Definition: arc.h:94
void bezier(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:79
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLsizei stride
Definition: glext.h:5848
GLsizeiptr size
Definition: glext.h:5919
struct S1 s1
ArcTessellator(TrimVertexPool &, Pool &)
Definition: arctess.cc:59
GLfloat param
Definition: glext.h:5796
Definition: bufpool.h:50
void pwl_right(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:155
void pwl(Arc_ptr, REAL, REAL, REAL, REAL, REAL)
Definition: arctess.cc:243
GLdouble s
Definition: gl.h:2039
Definition: arc.h:52
static const REAL gl_Bernstein[][MAXORDER][MAXORDER]
Definition: arctess.h:60
PwlArc * pwlArc
Definition: arc.h:65
const GLdouble * v
Definition: gl.h:2040
arc_side getside()
Definition: arc.h:96
#define abort()
Definition: i386-dis.c:35
void pwl_left(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:125
~ArcTessellator(void)
Definition: arctess.cc:69
REAL param[2]
Definition: trimvertex.h:45
int stride
Definition: bezierarc.h:46
GLfloat GLfloat p
Definition: glext.h:8902
float REAL
Definition: types.h:41
TrimVertex * pts
Definition: pwlarc.h:46
BezierArc * bezierArc
Definition: arc.h:64
static void trim_power_coeffs(BezierArc *, REAL[MAXORDER], int)
Definition: arctess.cc:592
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
Definition: arc.h:52
int order
Definition: bezierarc.h:45