ReactOS 0.4.15-dev-5664-g3bf4ef6
patch.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 * patch.c++
37 *
38 */
39
40//#include <stdio.h>
41//#include "glimports.h"
42//#include "mystdio.h"
43//#include "myassert.h"
44#include "mymath.h"
45//#include "mystring.h"
46#include "patch.h"
47#include "mapdesc.h"
48#include "quilt.h"
49//#include "nurbsconsts.h"
50#include "simplemath.h" //for glu_abs function in ::singleStep();
51
52
53/*--------------------------------------------------------------------------
54 * Patch - copy patch from quilt and transform control points
55 *--------------------------------------------------------------------------
56 */
57
58Patch::Patch( Quilt_ptr geo, REAL *pta, REAL *ptb, Patch *n )
59{
60/* pspec[i].range is uninit here */
61 mapdesc = geo->mapdesc;
65 pspec[0].order = geo->qspec[0].order;
66 pspec[1].order = geo->qspec[1].order;
69
70 /* transform control points to sampling and culling spaces */
71 REAL *ps = geo->cpts;
72 geo->select( pta, ptb );
73 ps += geo->qspec[0].offset;
74 ps += geo->qspec[1].offset;
75 ps += geo->qspec[0].index * geo->qspec[0].order * geo->qspec[0].stride;
76 ps += geo->qspec[1].index * geo->qspec[1].order * geo->qspec[1].stride;
77
78 if( needsSampling ) {
79 mapdesc->xformSampling( ps, geo->qspec[0].order, geo->qspec[0].stride,
80 geo->qspec[1].order, geo->qspec[1].stride,
81 spts, pspec[0].stride, pspec[1].stride );
82 }
83
84 if( cullval == CULL_ACCEPT ) {
85 mapdesc->xformCulling( ps, geo->qspec[0].order, geo->qspec[0].stride,
86 geo->qspec[1].order, geo->qspec[1].stride,
87 cpts, pspec[0].stride, pspec[1].stride );
88 }
89
90 if( notInBbox ) {
91 mapdesc->xformBounding( ps, geo->qspec[0].order, geo->qspec[0].stride,
92 geo->qspec[1].order, geo->qspec[1].stride,
93 bpts, pspec[0].stride, pspec[1].stride );
94 }
95
96 /* set scale range */
97 pspec[0].range[0] = geo->qspec[0].breakpoints[geo->qspec[0].index];
98 pspec[0].range[1] = geo->qspec[0].breakpoints[geo->qspec[0].index+1];
99 pspec[0].range[2] = pspec[0].range[1] - pspec[0].range[0];
100
101 pspec[1].range[0] = geo->qspec[1].breakpoints[geo->qspec[1].index];
102 pspec[1].range[1] = geo->qspec[1].breakpoints[geo->qspec[1].index+1];
103 pspec[1].range[2] = pspec[1].range[1] - pspec[1].range[0];
104
105 // may need to subdivide to match range of sub-patch
106 if( pspec[0].range[0] != pta[0] ) {
107 assert( pspec[0].range[0] < pta[0] );
108 Patch lower( *this, 0, pta[0], 0 );
109 *this = lower;
110 }
111
112 if( pspec[0].range[1] != ptb[0] ) {
113 assert( pspec[0].range[1] > ptb[0] );
114 Patch upper( *this, 0, ptb[0], 0 );
115 }
116
117 if( pspec[1].range[0] != pta[1] ) {
118 assert( pspec[1].range[0] < pta[1] );
119 Patch lower( *this, 1, pta[1], 0 );
120 *this = lower;
121 }
122
123 if( pspec[1].range[1] != ptb[1] ) {
124 assert( pspec[1].range[1] > ptb[1] );
125 Patch upper( *this, 1, ptb[1], 0 );
126 }
128 next = n;
129}
130
131/*--------------------------------------------------------------------------
132 * Patch - subdivide a patch along an isoparametric line
133 *--------------------------------------------------------------------------
134 */
135
137{
138 Patch& lower = *this;
139
140 lower.cullval = upper.cullval;
141 lower.mapdesc = upper.mapdesc;
142 lower.notInBbox = upper.notInBbox;
143 lower.needsSampling = upper.needsSampling;
144 lower.pspec[0].order = upper.pspec[0].order;
145 lower.pspec[1].order = upper.pspec[1].order;
146 lower.pspec[0].stride = upper.pspec[0].stride;
147 lower.pspec[1].stride = upper.pspec[1].stride;
148 lower.next = n;
149
150 /* reset scale range */
151 switch( param ) {
152 case 0: {
153 REAL d = (value-upper.pspec[0].range[0]) / upper.pspec[0].range[2];
154 if( needsSampling )
155 mapdesc->subdivide( upper.spts, lower.spts, d, pspec[1].order,
156 pspec[1].stride, pspec[0].order, pspec[0].stride );
157
158 if( cullval == CULL_ACCEPT )
159 mapdesc->subdivide( upper.cpts, lower.cpts, d, pspec[1].order,
160 pspec[1].stride, pspec[0].order, pspec[0].stride );
161
162 if( notInBbox )
163 mapdesc->subdivide( upper.bpts, lower.bpts, d, pspec[1].order,
164 pspec[1].stride, pspec[0].order, pspec[0].stride );
165
166 lower.pspec[0].range[0] = upper.pspec[0].range[0];
167 lower.pspec[0].range[1] = value;
168 lower.pspec[0].range[2] = value - upper.pspec[0].range[0];
169 upper.pspec[0].range[0] = value;
170 upper.pspec[0].range[2] = upper.pspec[0].range[1] - value;
171
172 lower.pspec[1].range[0] = upper.pspec[1].range[0];
173 lower.pspec[1].range[1] = upper.pspec[1].range[1];
174 lower.pspec[1].range[2] = upper.pspec[1].range[2];
175 break;
176 }
177 case 1: {
178 REAL d = (value-upper.pspec[1].range[0]) / upper.pspec[1].range[2];
179 if( needsSampling )
180 mapdesc->subdivide( upper.spts, lower.spts, d, pspec[0].order,
181 pspec[0].stride, pspec[1].order, pspec[1].stride );
182 if( cullval == CULL_ACCEPT )
183 mapdesc->subdivide( upper.cpts, lower.cpts, d, pspec[0].order,
184 pspec[0].stride, pspec[1].order, pspec[1].stride );
185 if( notInBbox )
186 mapdesc->subdivide( upper.bpts, lower.bpts, d, pspec[0].order,
187 pspec[0].stride, pspec[1].order, pspec[1].stride );
188 lower.pspec[0].range[0] = upper.pspec[0].range[0];
189 lower.pspec[0].range[1] = upper.pspec[0].range[1];
190 lower.pspec[0].range[2] = upper.pspec[0].range[2];
191
192 lower.pspec[1].range[0] = upper.pspec[1].range[0];
193 lower.pspec[1].range[1] = value;
194 lower.pspec[1].range[2] = value - upper.pspec[1].range[0];
195 upper.pspec[1].range[0] = value;
196 upper.pspec[1].range[2] = upper.pspec[1].range[1] - value;
197 break;
198 }
199 }
200
201 // inherit bounding box
203 memcpy( lower.bb, upper.bb, sizeof( bb ) );
204
205 lower.checkBboxConstraint();
206 upper.checkBboxConstraint();
207}
208
209/*--------------------------------------------------------------------------
210 * clamp - clamp the sampling rate to a given maximum
211 *--------------------------------------------------------------------------
212 */
213
214void
216{
220 }
221}
222
223void
224Patchspec::clamp( REAL clampfactor )
225{
226 if( sidestep[0] < minstepsize )
227 sidestep[0] = clampfactor * minstepsize;
228 if( sidestep[1] < minstepsize )
229 sidestep[1] = clampfactor * minstepsize;
230 if( stepsize < minstepsize )
231 stepsize = clampfactor * minstepsize;
232}
233
234void
236{
237 if( notInBbox &&
239 pspec[0].order, pspec[1].order, bb ) != 1 ) {
240 notInBbox = 0;
241 }
242}
243
244void
246{
248 mapdesc->surfbbox( bb );
249}
250
251/*--------------------------------------------------------------------------
252 * getstepsize - compute the sampling density across the patch
253 * and determine if patch needs to be subdivided
254 *--------------------------------------------------------------------------
255 */
256
257void
259{
262
263 if( mapdesc->isConstantSampling() ) {
264 // fixed number of samples per patch in each direction
265 // maxsrate is number of s samples per patch
266 // maxtrate is number of t samples per patch
269
270 } else if( mapdesc->isDomainSampling() ) {
271 // maxsrate is number of s samples per unit s length of domain
272 // maxtrate is number of t samples per unit t length of domain
275
276 } else if( ! needsSampling ) {
277 pspec[0].singleStep();
278 pspec[1].singleStep();
279 } else {
280 // upper bound on path length between sample points
282 const int trstride = sizeof(tmp[0]) / sizeof(REAL);
283 const int tcstride = sizeof(tmp[0][0]) / sizeof(REAL);
284
285 assert( pspec[0].order <= MAXORDER );
286
287 /* points have been transformed, therefore they are homogeneous */
288
289 int val = mapdesc->project( spts, pspec[0].stride, pspec[1].stride,
290 &tmp[0][0][0], trstride, tcstride,
291 pspec[0].order, pspec[1].order );
292 if( val == 0 ) {
293 // control points cross infinity, therefore partials are undefined
296 } else {
298// REAL t2 = mapdesc->getProperty( N_ERROR_TOLERANCE );
299 pspec[0].minstepsize = ( mapdesc->maxsrate > 0.0 ) ?
300 (pspec[0].range[2] / mapdesc->maxsrate) : 0.0;
301 pspec[1].minstepsize = ( mapdesc->maxtrate > 0.0 ) ?
302 (pspec[1].range[2] / mapdesc->maxtrate) : 0.0;
305
306 REAL t2;
308
309 // t2 is upper bound on the distance between surface and tessellant
310 REAL ssv[2], ttv[2];
311 REAL ss = mapdesc->calcPartialVelocity( ssv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 2, 0, pspec[0].range[2], pspec[1].range[2], 0 );
312 REAL st = mapdesc->calcPartialVelocity( 0, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 1, 1, pspec[0].range[2], pspec[1].range[2], -1 );
313 REAL tt = mapdesc->calcPartialVelocity( ttv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 0, 2, pspec[0].range[2], pspec[1].range[2], 1 );
314 //make sure that ss st and tt are nonnegative:
315 if(ss <0) ss = -ss;
316 if(st <0) st = -st;
317 if(tt <0) tt = -tt;
318
319 if( ss != 0.0 && tt != 0.0 ) {
320 /* printf( "ssv[0] %g ssv[1] %g ttv[0] %g ttv[1] %g\n",
321 ssv[0], ssv[1], ttv[0], ttv[1] ); */
322 REAL ttq = sqrtf( (float) ss );
323 REAL ssq = sqrtf( (float) tt );
324 REAL ds = sqrtf( 4 * t2 * ttq / ( ss * ttq + st * ssq ) );
325 REAL dt = sqrtf( 4 * t2 * ssq / ( tt * ssq + st * ttq ) );
326 pspec[0].stepsize = ( ds < pspec[0].range[2] ) ? ds : pspec[0].range[2];
327 REAL scutoff = 2.0 * t2 / ( pspec[0].range[2] * pspec[0].range[2]);
328 pspec[0].sidestep[0] = (ssv[0] > scutoff) ? sqrtf( 2.0 * t2 / ssv[0] ) : pspec[0].range[2];
329 pspec[0].sidestep[1] = (ssv[1] > scutoff) ? sqrtf( 2.0 * t2 / ssv[1] ) : pspec[0].range[2];
330
331 pspec[1].stepsize = ( dt < pspec[1].range[2] ) ? dt : pspec[1].range[2];
332 REAL tcutoff = 2.0 * t2 / ( pspec[1].range[2] * pspec[1].range[2]);
333 pspec[1].sidestep[0] = (ttv[0] > tcutoff) ? sqrtf( 2.0 * t2 / ttv[0] ) : pspec[1].range[2];
334 pspec[1].sidestep[1] = (ttv[1] > tcutoff) ? sqrtf( 2.0 * t2 / ttv[1] ) : pspec[1].range[2];
335 } else if( ss != 0.0 ) {
336 REAL x = pspec[1].range[2] * st;
337 REAL ds = ( sqrtf( x * x + 8.0 * t2 * ss ) - x ) / ss;
338 pspec[0].stepsize = ( ds < pspec[0].range[2] ) ? ds : pspec[0].range[2];
339 REAL scutoff = 2.0 * t2 / ( pspec[0].range[2] * pspec[0].range[2]);
340 pspec[0].sidestep[0] = (ssv[0] > scutoff) ? sqrtf( 2.0 * t2 / ssv[0] ) : pspec[0].range[2];
341 pspec[0].sidestep[1] = (ssv[1] > scutoff) ? sqrtf( 2.0 * t2 / ssv[1] ) : pspec[0].range[2];
342 pspec[1].singleStep();
343 } else if( tt != 0.0 ) {
344 REAL x = pspec[0].range[2] * st;
345 REAL dt = ( sqrtf( x * x + 8.0 * t2 * tt ) - x ) / tt;
346 pspec[0].singleStep();
347 REAL tcutoff = 2.0 * t2 / ( pspec[1].range[2] * pspec[1].range[2]);
348 pspec[1].stepsize = ( dt < pspec[1].range[2] ) ? dt : pspec[1].range[2];
349 pspec[1].sidestep[0] = (ttv[0] > tcutoff) ? sqrtf( 2.0 * t2 / ttv[0] ) : pspec[1].range[2];
350 pspec[1].sidestep[1] = (ttv[1] > tcutoff) ? sqrtf( 2.0 * t2 / ttv[1] ) : pspec[1].range[2];
351 } else {
352 if( 4.0 * t2 > st * pspec[0].range[2] * pspec[1].range[2] ) {
353 pspec[0].singleStep();
354 pspec[1].singleStep();
355 } else {
356 REAL area = 4.0 * t2 / st;
357 REAL ds = sqrtf( area * pspec[0].range[2] / pspec[1].range[2] );
358 REAL dt = sqrtf( area * pspec[1].range[2] / pspec[0].range[2] );
359 pspec[0].stepsize = ( ds < pspec[0].range[2] ) ? ds : pspec[0].range[2];
360 pspec[0].sidestep[0] = pspec[0].range[2];
361 pspec[0].sidestep[1] = pspec[0].range[2];
362
363 pspec[1].stepsize = ( dt < pspec[1].range[2] ) ? dt : pspec[1].range[2];
364 pspec[1].sidestep[0] = pspec[1].range[2];
365 pspec[1].sidestep[1] = pspec[1].range[2];
366 }
367 }
368 } else if( mapdesc->isPathLengthSampling() ||
370 // t1 is upper bound on path length
371 REAL msv[2], mtv[2];
372 REAL ms = mapdesc->calcPartialVelocity( msv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 1, 0, pspec[0].range[2], pspec[1].range[2], 0 );
373 REAL mt = mapdesc->calcPartialVelocity( mtv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 0, 1, pspec[0].range[2], pspec[1].range[2], 1 );
374 REAL side_scale = 1.0;
375
376 if( ms != 0.0 ) {
377 if( mt != 0.0 ) {
378/* REAL d = t1 / ( ms * ms + mt * mt );*/
379/* REAL ds = mt * d;*/
380 REAL ds = t1 / (2.0*ms);
381/* REAL dt = ms * d;*/
382 REAL dt = t1 / (2.0*mt);
383 pspec[0].stepsize = ( ds < pspec[0].range[2] ) ? ds : pspec[0].range[2];
384 pspec[0].sidestep[0] = ( msv[0] * pspec[0].range[2] > t1 ) ? (side_scale* t1 / msv[0]) : pspec[0].range[2];
385 pspec[0].sidestep[1] = ( msv[1] * pspec[0].range[2] > t1 ) ? (side_scale* t1 / msv[1]) : pspec[0].range[2];
386
387 pspec[1].stepsize = ( dt < pspec[1].range[2] ) ? dt : pspec[1].range[2];
388 pspec[1].sidestep[0] = ( mtv[0] * pspec[1].range[2] > t1 ) ? (side_scale*t1 / mtv[0]) : pspec[1].range[2];
389 pspec[1].sidestep[1] = ( mtv[1] * pspec[1].range[2] > t1 ) ? (side_scale*t1 / mtv[1]) : pspec[1].range[2];
390 } else {
391 pspec[0].stepsize = ( t1 < ms * pspec[0].range[2] ) ? (t1 / ms) : pspec[0].range[2];
392 pspec[0].sidestep[0] = ( msv[0] * pspec[0].range[2] > t1 ) ? (t1 / msv[0]) : pspec[0].range[2];
393 pspec[0].sidestep[1] = ( msv[1] * pspec[0].range[2] > t1 ) ? (t1 / msv[1]) : pspec[0].range[2];
394
395 pspec[1].singleStep();
396 }
397 } else {
398 if( mt != 0.0 ) {
399 pspec[0].singleStep();
400
401 pspec[1].stepsize = ( t1 < mt * pspec[1].range[2] ) ? (t1 / mt) : pspec[1].range[2];
402 pspec[1].sidestep[0] = ( mtv[0] * pspec[1].range[2] > t1 ) ? (t1 / mtv[0]) : pspec[1].range[2];
403 pspec[1].sidestep[1] = ( mtv[1] * pspec[1].range[2] > t1 ) ? (t1 / mtv[1]) : pspec[1].range[2];
404 } else {
405 pspec[0].singleStep();
406 pspec[1].singleStep();
407 }
408 }
409 } else if( mapdesc->isSurfaceAreaSampling() ) {
410 // t is the square root of area
411/*
412 REAL msv[2], mtv[2];
413 REAL ms = mapdesc->calcPartialVelocity( msv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 1, 0, pspec[0].range[2], pspec[1].range[2], 0 );
414 REAL mt = mapdesc->calcPartialVelocity( mtv, &tmp[0][0][0], trstride, tcstride, pspec[0].order, pspec[1].order, 0, 1, pspec[0].range[2], pspec[1].range[2], 1 );
415 if( ms != 0.0 && mt != 0.0 ) {
416 REAL d = 1.0 / (ms * mt);
417 t *= M_SQRT2;
418 REAL ds = t * sqrtf( d * pspec[0].range[2] / pspec[1].range[2] );
419 REAL dt = t * sqrtf( d * pspec[1].range[2] / pspec[0].range[2] );
420 pspec[0].stepsize = ( ds < pspec[0].range[2] ) ? ds : pspec[0].range[2];
421 pspec[0].sidestep[0] = ( msv[0] * pspec[0].range[2] > t ) ? (t / msv[0]) : pspec[0].range[2];
422 pspec[0].sidestep[1] = ( msv[1] * pspec[0].range[2] > t ) ? (t / msv[1]) : pspec[0].range[2];
423
424 pspec[1].stepsize = ( dt < pspec[1].range[2] ) ? dt : pspec[1].range[2];
425 pspec[1].sidestep[0] = ( mtv[0] * pspec[1].range[2] > t ) ? (t / mtv[0]) : pspec[1].range[2];
426 pspec[1].sidestep[1] = ( mtv[1] * pspec[1].range[2] > t ) ? (t / mtv[1]) : pspec[1].range[2];
427 } else {
428 pspec[0].singleStep();
429 pspec[1].singleStep();
430 }
431*/
432 } else {
433 pspec[0].singleStep();
434 pspec[1].singleStep();
435 }
436 }
437 }
438
439#ifdef DEBUG
440 _glu_dprintf( "sidesteps %g %g %g %g, stepsize %g %g\n",
441 pspec[0].sidestep[0], pspec[0].sidestep[1],
442 pspec[1].sidestep[0], pspec[1].sidestep[1],
443 pspec[0].stepsize, pspec[1].stepsize );
444#endif
445
447 REAL savings = 1./(pspec[0].stepsize * pspec[1].stepsize) ;
448 savings-= (2./( pspec[0].sidestep[0] + pspec[0].sidestep[1] )) *
449 (2./( pspec[1].sidestep[0] + pspec[1].sidestep[1] ));
450
451 savings *= pspec[0].range[2] * pspec[1].range[2];
452 if( savings > mapdesc->minsavings ) {
454 }
455 }
456
457 if( pspec[0].stepsize < pspec[0].minstepsize ) pspec[0].needsSubdivision = 1;
458 if( pspec[1].stepsize < pspec[1].minstepsize ) pspec[1].needsSubdivision = 1;
460}
461
462void
464{
465 stepsize = sidestep[0] = sidestep[1] = glu_abs(range[2]);
466}
467
468void
469Patchspec::getstepsize( REAL max ) // max is number of samples for entire patch
470{
471 stepsize = ( max >= 1.0 ) ? range[2] / max : range[2];
472 if (stepsize < 0.0) {
474 }
476}
477
478int
480{
481 return (pspec[0].needsSubdivision || pspec[1].needsSubdivision) ? 1 : 0;
482}
483
484int
486{
487 return notInBbox;
488}
489
490int
492{
494}
495
496int
498{
499 if( cullval == CULL_ACCEPT )
501 pspec[1].order, pspec[1].stride );
502 return cullval;
503}
504
REAL calcPartialVelocity(REAL *, int, int, int, REAL)
Definition: mapdescv.cc:54
int isObjectSpaceParaSampling(void)
Definition: mapdesc.h:222
REAL clampfactor
Definition: mapdesc.h:107
void xformCulling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:472
int isConstantSampling(void)
Definition: mapdesc.h:204
int isCulling(void)
Definition: mapdesc.h:261
REAL minsavings
Definition: mapdesc.h:108
int isObjectSpacePathSampling(void)
Definition: mapdesc.h:228
int isBboxSubdividing(void)
Definition: mapdesc.h:267
void subdivide(REAL *, REAL *, REAL, int, int)
Definition: mapdesc.cc:577
int isDomainSampling(void)
Definition: mapdesc.h:210
int isParametricDistanceSampling(void)
Definition: mapdesc.h:216
int cullCheck(REAL *, int, int)
Definition: mapdesc.cc:425
REAL maxsrate
Definition: mapdesc.h:110
void xformBounding(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:460
int isRangeSampling(void)
Definition: mapdesc.h:246
REAL getProperty(long)
Definition: mapdesc.cc:769
int project(REAL *, int, REAL *, int, int)
Definition: mapdesc.cc:647
int isPathLengthSampling(void)
Definition: mapdesc.h:240
void xformSampling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:454
int isSurfaceAreaSampling(void)
Definition: mapdesc.h:234
void surfbbox(REAL bb[2][MAXCOORDS])
Definition: mapdesc.cc:99
REAL maxtrate
Definition: mapdesc.h:111
int bboxTooBig(REAL *, int, int, int, int, REAL[2][MAXCOORDS])
Definition: mapdesc.cc:663
Definition: patch.h:62
Patchspec pspec[2]
Definition: patch.h:90
Patch(Quilt *, REAL *, REAL *, Patch *)
int needsNonSamplingSubdivision(void)
Definition: patch.cc:485
int cullCheck(void)
Definition: patch.cc:497
REAL cpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:87
Mapdesc * mapdesc
Definition: patch.h:82
int notInBbox
Definition: patch.h:85
REAL bpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:89
REAL spts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:88
void clamp(void)
Definition: patch.cc:215
int needsSampling
Definition: patch.h:86
int needsSamplingSubdivision(void)
Definition: patch.cc:479
int needsSubdivision(int)
Definition: patch.cc:491
void checkBboxConstraint(void)
Definition: patch.cc:235
void bbox(void)
Definition: patch.cc:245
REAL bb[2][MAXCOORDS]
Definition: patch.h:92
Patch * next
Definition: patch.h:83
void getstepsize(void)
Definition: patch.cc:258
int cullval
Definition: patch.h:84
#define MAXCOORDS
Definition: defines.h:48
#define CULL_TRIVIAL_ACCEPT
Definition: defines.h:41
#define MAXORDER
Definition: defines.h:45
#define CULL_ACCEPT
Definition: defines.h:42
float REAL
Definition: types.h:41
#define assert(x)
Definition: debug.h:53
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLdouble n
Definition: glext.h:7729
GLsizei stride
Definition: glext.h:5848
GLenum GLint * range
Definition: glext.h:7539
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat param
Definition: glext.h:5796
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
#define ss
Definition: i386-dis.c:442
#define ds
Definition: i386-dis.c:444
#define d
Definition: ke_i.h:81
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define sqrtf(x)
Definition: mymath.h:59
#define N_NOSAVINGSSUBDIVISION
Definition: nurbsconsts.h:47
#define N_PIXEL_TOLERANCE
Definition: nurbsconsts.h:89
#define N_NOCLAMPING
Definition: nurbsconsts.h:45
#define N_ERROR_TOLERANCE
Definition: nurbsconsts.h:90
static Real area(Real A[2], Real B[2], Real C[2])
Definition: polyDBG.cc:50
class Quilt * Quilt_ptr
Definition: quilt.h:90
REAL glu_abs(REAL x)
Definition: simplemath.h:50
void getstepsize(REAL)
Definition: patch.cc:469
void clamp(REAL)
Definition: patch.cc:224
int stride
Definition: patch.h:56
void singleStep(void)
Definition: patch.cc:463
int order
Definition: patch.h:55
REAL sidestep[2]
Definition: patch.h:48
int needsSubdivision
Definition: patch.h:51
REAL range[3]
Definition: patch.h:47
REAL stepsize
Definition: patch.h:49
REAL minstepsize
Definition: patch.h:50
#define max(a, b)
Definition: svc.c:63
Definition: pdh_main.c:94