ReactOS  0.4.14-dev-552-g2fad488
Patch Class Reference

#include <patch.h>

Collaboration diagram for Patch:

Public Member Functions

 Patch (Quilt *, REAL *, REAL *, Patch *)
 
 Patch (Patch &, int, REAL, Patch *)
 
void bbox (void)
 
void clamp (void)
 
void getstepsize (void)
 
int cullCheck (void)
 
int needsSubdivision (int)
 
int needsSamplingSubdivision (void)
 
int needsNonSamplingSubdivision (void)
 
int get_uorder ()
 
int get_vorder ()
 

Private Member Functions

void checkBboxConstraint (void)
 

Private Attributes

Mapdescmapdesc
 
Patchnext
 
int cullval
 
int notInBbox
 
int needsSampling
 
REAL cpts [MAXORDER *MAXORDER *MAXCOORDS]
 
REAL spts [MAXORDER *MAXORDER *MAXCOORDS]
 
REAL bpts [MAXORDER *MAXORDER *MAXCOORDS]
 
Patchspec pspec [2]
 
REAL bb [2][MAXCOORDS]
 

Friends

class Subdivider
 
class Quilt
 
class Patchlist
 

Detailed Description

Definition at line 62 of file patch.h.

Constructor & Destructor Documentation

◆ Patch() [1/2]

Patch::Patch ( Quilt ,
REAL ,
REAL ,
Patch  
)

◆ Patch() [2/2]

Patch::Patch ( Patch upper,
int  param,
REAL  value,
Patch n 
)

Definition at line 136 of file patch.cc.

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 }
REAL spts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:88
void checkBboxConstraint(void)
Definition: patch.cc:235
int stride
Definition: patch.h:56
int order
Definition: patch.h:55
int cullval
Definition: patch.h:84
GLdouble n
Definition: glext.h:7729
Patch * next
Definition: patch.h:83
Definition: patch.h:62
REAL bpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:89
#define CULL_ACCEPT
Definition: defines.h:42
#define d
Definition: ke_i.h:81
Patchspec pspec[2]
Definition: patch.h:90
int notInBbox
Definition: patch.h:85
GLfloat param
Definition: glext.h:5796
void subdivide(REAL *, REAL *, REAL, int, int)
Definition: mapdesc.cc:577
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLsizei const GLfloat * value
Definition: glext.h:6069
int isBboxSubdividing(void)
Definition: mapdesc.h:267
REAL cpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:87
int needsSampling
Definition: patch.h:86
REAL bb[2][MAXCOORDS]
Definition: patch.h:92
float REAL
Definition: types.h:41
Mapdesc * mapdesc
Definition: patch.h:82
REAL range[3]
Definition: patch.h:47

Member Function Documentation

◆ bbox()

void Patch::bbox ( void  )

Definition at line 245 of file patch.cc.

246 {
247  if( mapdesc->isBboxSubdividing() )
248  mapdesc->surfbbox( bb );
249 }
void surfbbox(REAL bb[2][MAXCOORDS])
Definition: mapdesc.cc:99
int isBboxSubdividing(void)
Definition: mapdesc.h:267
REAL bb[2][MAXCOORDS]
Definition: patch.h:92
Mapdesc * mapdesc
Definition: patch.h:82

◆ checkBboxConstraint()

void Patch::checkBboxConstraint ( void  )
private

Definition at line 235 of file patch.cc.

236 {
237  if( notInBbox &&
239  pspec[0].order, pspec[1].order, bb ) != 1 ) {
240  notInBbox = 0;
241  }
242 }
int stride
Definition: patch.h:56
int order
Definition: patch.h:55
REAL bpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:89
int bboxTooBig(REAL *, int, int, int, int, REAL [2][MAXCOORDS])
Definition: mapdesc.cc:663
Patchspec pspec[2]
Definition: patch.h:90
int notInBbox
Definition: patch.h:85
REAL bb[2][MAXCOORDS]
Definition: patch.h:92
Mapdesc * mapdesc
Definition: patch.h:82

Referenced by Patch().

◆ clamp()

void Patch::clamp ( void  )

Definition at line 215 of file patch.cc.

216 {
217  if( mapdesc->clampfactor != N_NOCLAMPING ) {
220  }
221 }
#define N_NOCLAMPING
Definition: nurbsconsts.h:45
Patchspec pspec[2]
Definition: patch.h:90
void clamp(REAL)
Definition: patch.cc:224
REAL clampfactor
Definition: mapdesc.h:107
Mapdesc * mapdesc
Definition: patch.h:82

◆ cullCheck()

int Patch::cullCheck ( void  )

Definition at line 497 of file patch.cc.

498 {
499  if( cullval == CULL_ACCEPT )
501  pspec[1].order, pspec[1].stride );
502  return cullval;
503 }
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
int cullval
Definition: patch.h:84
int cullCheck(REAL *, int, int)
Definition: mapdesc.cc:425
#define CULL_ACCEPT
Definition: defines.h:42
GLsizei stride
Definition: glext.h:5848
Patchspec pspec[2]
Definition: patch.h:90
REAL cpts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:87
Mapdesc * mapdesc
Definition: patch.h:82

◆ get_uorder()

int Patch::get_uorder ( )
inline

Definition at line 77 of file patch.h.

77 {return pspec[0].order;}
int order
Definition: patch.h:55
Patchspec pspec[2]
Definition: patch.h:90

Referenced by Patchlist::get_uorder().

◆ get_vorder()

int Patch::get_vorder ( )
inline

Definition at line 78 of file patch.h.

78 {return pspec[1].order;}
int order
Definition: patch.h:55
Patchspec pspec[2]
Definition: patch.h:90

Referenced by Patchlist::get_vorder().

◆ getstepsize()

void Patch::getstepsize ( void  )

Definition at line 258 of file patch.cc.

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 }
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
REAL spts[MAXORDER *MAXORDER *MAXCOORDS]
Definition: patch.h:88
#define N_ERROR_TOLERANCE
Definition: nurbsconsts.h:90
void singleStep(void)
Definition: patch.cc:463
REAL calcPartialVelocity(REAL *, int, int, int, REAL)
Definition: mapdescv.cc:54
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
REAL getProperty(long)
Definition: mapdesc.cc:769
REAL sidestep[2]
Definition: patch.h:48
int isSurfaceAreaSampling(void)
Definition: mapdesc.h:234
int isParametricDistanceSampling(void)
Definition: mapdesc.h:216
#define N_PIXEL_TOLERANCE
Definition: nurbsconsts.h:89
REAL maxtrate
Definition: mapdesc.h:111
#define MAXORDER
Definition: defines.h:45
GLuint GLfloat * val
Definition: glext.h:7180
#define N_NOSAVINGSSUBDIVISION
Definition: nurbsconsts.h:47
GLsizei stride
Definition: glext.h:5848
Patchspec pspec[2]
Definition: patch.h:90
void getstepsize(REAL)
Definition: patch.cc:469
GLenum GLint * range
Definition: glext.h:7539
REAL minstepsize
Definition: patch.h:50
int isObjectSpaceParaSampling(void)
Definition: mapdesc.h:222
int needsSampling
Definition: patch.h:86
static Real area(Real A[2], Real B[2], Real C[2])
Definition: polyDBG.cc:50
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
#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
int isObjectSpacePathSampling(void)
Definition: mapdesc.h:228
REAL range[3]
Definition: patch.h:47

◆ needsNonSamplingSubdivision()

int Patch::needsNonSamplingSubdivision ( void  )

Definition at line 485 of file patch.cc.

486 {
487  return notInBbox;
488 }
int notInBbox
Definition: patch.h:85

◆ needsSamplingSubdivision()

int Patch::needsSamplingSubdivision ( void  )

Definition at line 479 of file patch.cc.

480 {
481  return (pspec[0].needsSubdivision || pspec[1].needsSubdivision) ? 1 : 0;
482 }
int needsSubdivision(int)
Definition: patch.cc:491
Patchspec pspec[2]
Definition: patch.h:90

Referenced by getstepsize().

◆ needsSubdivision()

int Patch::needsSubdivision ( int  param)

Definition at line 491 of file patch.cc.

492 {
493  return pspec[param].needsSubdivision;
494 }
Patchspec pspec[2]
Definition: patch.h:90
GLfloat param
Definition: glext.h:5796
int needsSubdivision
Definition: patch.h:51

Referenced by needsSamplingSubdivision().

Friends And Related Function Documentation

◆ Patchlist

friend class Patchlist
friend

Definition at line 66 of file patch.h.

◆ Quilt

friend class Quilt
friend

Definition at line 65 of file patch.h.

◆ Subdivider

friend class Subdivider
friend

Definition at line 64 of file patch.h.

Member Data Documentation

◆ bb

REAL Patch::bb[2][MAXCOORDS]
private

Definition at line 92 of file patch.h.

Referenced by bbox(), checkBboxConstraint(), and Patch().

◆ bpts

REAL Patch::bpts[MAXORDER *MAXORDER *MAXCOORDS]
private

Definition at line 89 of file patch.h.

Referenced by checkBboxConstraint(), and Patch().

◆ cpts

REAL Patch::cpts[MAXORDER *MAXORDER *MAXCOORDS]
private

Definition at line 87 of file patch.h.

Referenced by cullCheck(), and Patch().

◆ cullval

int Patch::cullval
private

Definition at line 84 of file patch.h.

Referenced by cullCheck(), and Patch().

◆ mapdesc

Mapdesc* Patch::mapdesc
private

Definition at line 82 of file patch.h.

Referenced by bbox(), checkBboxConstraint(), clamp(), cullCheck(), getstepsize(), and Patch().

◆ needsSampling

int Patch::needsSampling
private

Definition at line 86 of file patch.h.

Referenced by getstepsize(), and Patch().

◆ next

Patch* Patch::next
private

Definition at line 83 of file patch.h.

Referenced by Patch(), Patchlist::Patchlist(), and Patchlist::~Patchlist().

◆ notInBbox

int Patch::notInBbox
private

Definition at line 85 of file patch.h.

Referenced by checkBboxConstraint(), needsNonSamplingSubdivision(), and Patch().

◆ pspec

◆ spts

REAL Patch::spts[MAXORDER *MAXORDER *MAXCOORDS]
private

Definition at line 88 of file patch.h.

Referenced by getstepsize(), and Patch().


The documentation for this class was generated from the following files: