ReactOS 0.4.15-dev-8138-g1e75ea8
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
78void
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
124void
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
154void
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
184void
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
213void
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
242void
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
278void
279ArcTessellator::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
323void
324ArcTessellator::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 long order = bezierArc->order;
385 for( step=1, ++vert; step<nsteps; step++, vert++ ) {
386 REAL p = dp * step;
387 REAL u = pow_u[0];
388 REAL v = pow_v[0];
389 REAL w = pow_w[0];
390 for( 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 long order = bezierArc->order;
448 for( step=1, ++vert; step<nsteps; step++, vert++ ) {
449 REAL p = dp * step;
450 REAL u = pow_u[0];
451 REAL v = pow_v[0];
452 for( 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 */
591void
593{
594 int stride = bez_arc->stride;
595 int order = bez_arc->order;
596 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 REAL s = 0.0;
605 REAL *point = base;
606 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}
#define steps_function(large, small, rate)
Definition: arctess.cc:52
void pwl_right(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:155
void pwl_top(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:185
static void trim_power_coeffs(BezierArc *, REAL[MAXORDER], int)
Definition: arctess.cc:592
TrimVertexPool & trimvertexpool
Definition: arctess.h:62
static const REAL gl_Bernstein[][MAXORDER][MAXORDER]
Definition: arctess.h:60
void pwl_bottom(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:214
void bezier(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:79
void tessellateNonlinear(Arc_ptr, REAL, REAL, int)
Definition: arctess.cc:324
void pwl_left(Arc_ptr, REAL, REAL, REAL, REAL)
Definition: arctess.cc:125
ArcTessellator(TrimVertexPool &, Pool &)
Definition: arctess.cc:59
~ArcTessellator(void)
Definition: arctess.cc:69
void tessellateLinear(Arc_ptr, REAL, REAL, int)
Definition: arctess.cc:279
void pwl(Arc_ptr, REAL, REAL, REAL, REAL, REAL)
Definition: arctess.cc:243
Pool & pwlarcpool
Definition: arctess.h:61
Definition: arc.h:55
void clearside()
Definition: arc.h:94
int isTessellated()
Definition: arc.h:82
void clearbezier()
Definition: arc.h:85
arc_side getside()
Definition: arc.h:96
BezierArc * bezierArc
Definition: arc.h:64
void setbezier()
Definition: arc.h:84
void makeSide(PwlArc *, arc_side)
Definition: arc.cc:62
PwlArc * pwlArc
Definition: arc.h:65
Definition: bufpool.h:50
Definition: pwlarc.h:44
int npts
Definition: pwlarc.h:47
TrimVertex * pts
Definition: pwlarc.h:46
TrimVertex * get(int)
REAL param[2]
Definition: trimvertex.h:45
#define NULL
Definition: types.h:112
@ arc_left
Definition: arc.h:52
@ arc_none
Definition: arc.h:52
@ arc_bottom
Definition: arc.h:52
@ arc_top
Definition: arc.h:52
@ arc_right
Definition: arc.h:52
#define MAXORDER
Definition: defines.h:45
float REAL
Definition: types.h:41
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
#define assert(x)
Definition: debug.h:53
POINTL point
Definition: edittest.c:50
const GLdouble * v
Definition: gl.h:2040
GLdouble s
Definition: gl.h:2039
GLdouble GLdouble t
Definition: gl.h:2047
GLsizeiptr size
Definition: glext.h:5919
GLsizei stride
Definition: glext.h:5848
GLuint coord
Definition: glext.h:9511
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLfloat GLfloat p
Definition: glext.h:8902
GLfloat param
Definition: glext.h:5796
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:6102
const GLfloat * m
Definition: glext.h:10848
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
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
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
#define ds
Definition: i386-dis.c:443
#define abort()
Definition: i386-dis.c:34
struct S1 s1
struct S2 s2
int rate
Definition: pcmconverter.c:97
REAL glu_abs(REAL x)
Definition: simplemath.h:50
REAL * cpts
Definition: bezierarc.h:44
int stride
Definition: bezierarc.h:46
int order
Definition: bezierarc.h:45
#define max(a, b)
Definition: svc.c:63