ReactOS  0.4.15-dev-316-g938df97
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 
58 Patch::Patch( Quilt_ptr geo, REAL *pta, REAL *ptb, Patch *n )
59 {
60 /* pspec[i].range is uninit here */
61  mapdesc = geo->mapdesc;
63  notInBbox = mapdesc->isBboxSubdividing() ? 1 : 0;
65  pspec[0].order = geo->qspec[0].order;
66  pspec[1].order = geo->qspec[1].order;
67  pspec[0].stride = pspec[1].order * MAXCOORDS;
68  pspec[1].stride = MAXCOORDS;
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
202  if( mapdesc->isBboxSubdividing() && ! notInBbox )
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 
214 void
216 {
217  if( mapdesc->clampfactor != N_NOCLAMPING ) {
220  }
221 }
222 
223 void
224 Patchspec::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 
234 void
236 {
237  if( notInBbox &&
239  pspec[0].order, pspec[1].order, bb ) != 1 ) {
240  notInBbox = 0;
241  }
242 }
243 
244 void
245 Patch::bbox( void )
246 {
247  if( mapdesc->isBboxSubdividing() )
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 
257 void
259 {
260  pspec[0].minstepsize = pspec[1].minstepsize = 0;
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
273  pspec[0].getstepsize( mapdesc->maxsrate * pspec[0].range[2] );
274  pspec[1].getstepsize( mapdesc->maxtrate * pspec[1].range[2] );
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 
462 void
464 {
465  stepsize = sidestep[0] = sidestep[1] = glu_abs(range[2]);
466 }
467 
468 void
469 Patchspec::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) {
473  stepsize = -stepsize;
474  }
476 }
477 
478 int
480 {
481  return (pspec[0].needsSubdivision || pspec[1].needsSubdivision) ? 1 : 0;
482 }
483 
484 int
486 {
487  return notInBbox;
488 }
489 
490 int
492 {
493  return pspec[param].needsSubdivision;
494 }
495 
496 int
498 {
499  if( cullval == CULL_ACCEPT )
501  pspec[1].order, pspec[1].stride );
502  return cullval;
503 }
504 
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
#define max(a, b)
Definition: svc.c:63
REAL spts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:88
void checkBboxConstraint(void)
Definition: patch.cc:235
#define N_ERROR_TOLERANCE
Definition: nurbsconsts.h:90
int stride
Definition: patch.h:56
int order
Definition: patch.h:55
int needsSubdivision(int)
Definition: patch.cc:491
void xformCulling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:472
int cullval
Definition: patch.h:84
#define N_NOCLAMPING
Definition: nurbsconsts.h:45
void singleStep(void)
Definition: patch.cc:463
REAL glu_abs(REAL x)
Definition: simplemath.h:50
REAL calcPartialVelocity(REAL *, int, int, int, REAL)
Definition: mapdescv.cc:54
void getstepsize(void)
Definition: patch.cc:258
GLdouble n
Definition: glext.h:7729
void surfbbox(REAL bb[2][MAXCOORDS])
Definition: mapdesc.cc:99
REAL maxsrate
Definition: mapdesc.h:110
#define ds
Definition: i386-dis.c:434
#define assert(x)
Definition: debug.h:53
int needsSamplingSubdivision(void)
Definition: patch.cc:479
int isDomainSampling(void)
Definition: mapdesc.h:210
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
int project(REAL *, int, REAL *, int, int)
Definition: mapdesc.cc:647
Patch * next
Definition: patch.h:83
REAL getProperty(long)
Definition: mapdesc.cc:769
REAL sidestep[2]
Definition: patch.h:48
int isSurfaceAreaSampling(void)
Definition: mapdesc.h:234
void xformBounding(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:460
int cullCheck(REAL *, int, int)
Definition: mapdesc.cc:425
int isParametricDistanceSampling(void)
Definition: mapdesc.h:216
int needsNonSamplingSubdivision(void)
Definition: patch.cc:485
Definition: patch.h:62
#define N_PIXEL_TOLERANCE
Definition: nurbsconsts.h:89
REAL bpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:89
#define CULL_ACCEPT
Definition: defines.h:42
class Quilt * Quilt_ptr
Definition: quilt.h:90
REAL maxtrate
Definition: mapdesc.h:111
#define MAXORDER
Definition: defines.h:45
int bboxTooBig(REAL *, int, int, int, int, REAL [2][MAXCOORDS])
Definition: mapdesc.cc:663
GLuint GLfloat * val
Definition: glext.h:7180
#define N_NOSAVINGSSUBDIVISION
Definition: nurbsconsts.h:47
void bbox(void)
Definition: patch.cc:245
GLsizei stride
Definition: glext.h:5848
#define d
Definition: ke_i.h:81
Patchspec pspec[2]
Definition: patch.h:90
int notInBbox
Definition: patch.h:85
void clamp(REAL)
Definition: patch.cc:224
GLfloat param
Definition: glext.h:5796
void clamp(void)
Definition: patch.cc:215
void subdivide(REAL *, REAL *, REAL, int, int)
Definition: mapdesc.cc:577
void xformSampling(REAL *, int, int, REAL *, int)
Definition: mapdesc.cc:454
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
void getstepsize(REAL)
Definition: patch.cc:469
GLsizei const GLfloat * value
Definition: glext.h:6069
GLenum GLint * range
Definition: glext.h:7539
int isBboxSubdividing(void)
Definition: mapdesc.h:267
REAL cpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:87
REAL minstepsize
Definition: patch.h:50
int isObjectSpaceParaSampling(void)
Definition: mapdesc.h:222
#define CULL_TRIVIAL_ACCEPT
Definition: defines.h:41
int needsSampling
Definition: patch.h:86
static Real area(Real A[2], Real B[2], Real C[2])
Definition: polyDBG.cc:50
REAL bb[2][MAXCOORDS]
Definition: patch.h:92
int isRangeSampling(void)
Definition: mapdesc.h:246
int isPathLengthSampling(void)
Definition: mapdesc.h:240
int needsSubdivision
Definition: patch.h:51
#define sqrtf(x)
Definition: mymath.h:59
REAL stepsize
Definition: patch.h:49
REAL clampfactor
Definition: mapdesc.h:107
#define MAXCOORDS
Definition: defines.h:48
float REAL
Definition: types.h:41
int isConstantSampling(void)
Definition: mapdesc.h:204
#define ss
Definition: i386-dis.c:432
REAL minsavings
Definition: mapdesc.h:108
Mapdesc * mapdesc
Definition: patch.h:82
Patch(Quilt *, REAL *, REAL *, Patch *)
int isObjectSpacePathSampling(void)
Definition: mapdesc.h:228
int isCulling(void)
Definition: mapdesc.h:261
REAL range[3]
Definition: patch.h:47
int cullCheck(void)
Definition: patch.cc:497