ReactOS 0.4.15-dev-7942-gd23573b
Public Member Functions | Private Member Functions | Private Attributes | Friends | List of all members
Patch Class Reference

#include <patch.h>

Collaboration diagram for Patch:
Collaboration graph
[legend]

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

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

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}
Mapdesc::surfbbox
void surfbbox(REAL bb[2][MAXCOORDS])
Definition: mapdesc.cc:99

◆ checkBboxConstraint()

void Patch::checkBboxConstraint ( void  )
private

Definition at line 235 of file patch.cc.

236{
237 if( notInBbox &&
238 mapdesc->bboxTooBig( bpts, pspec[0].stride, pspec[1].stride,
239 pspec[0].order, pspec[1].order, bb ) != 1 ) {
240 notInBbox = 0;
241 }
242}
Mapdesc::bboxTooBig
int bboxTooBig(REAL *, int, int, int, int, REAL[2][MAXCOORDS])
Definition: mapdesc.cc:663

Referenced by Patch().

◆ clamp()

void Patch::clamp ( void  )

Definition at line 215 of file patch.cc.

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

◆ cullCheck()

int Patch::cullCheck ( void  )

Definition at line 497 of file patch.cc.

498{
499 if( cullval == CULL_ACCEPT )
500 cullval = mapdesc->cullCheck( cpts, pspec[0].order, pspec[0].stride,
501 pspec[1].order, pspec[1].stride );
502 return cullval;
503}
Mapdesc::cullCheck
int cullCheck(REAL *, int, int)
Definition: mapdesc.cc:425
stride
GLsizei stride
Definition: glext.h:5848
order
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194

◆ get_uorder()

int Patch::get_uorder ( )
inline

Definition at line 77 of file patch.h.

77{return pspec[0].order;}

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;}

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;
261 pspec[0].needsSubdivision = pspec[1].needsSubdivision = 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
267 pspec[0].getstepsize( mapdesc->maxsrate );
268 pspec[1].getstepsize( mapdesc->maxtrate );
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
281 REAL tmp[MAXORDER][MAXORDER][MAXCOORDS];
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
294 pspec[0].getstepsize( mapdesc->maxsrate );
295 pspec[1].getstepsize( mapdesc->maxtrate );
296 } else {
297 REAL t1 = mapdesc->getProperty( N_PIXEL_TOLERANCE );
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;
303 if( mapdesc->isParametricDistanceSampling() ||
304 mapdesc->isObjectSpaceParaSampling() ) {
305
306 REAL t2;
307 t2 = mapdesc->getProperty( N_ERROR_TOLERANCE );
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() ||
369 mapdesc->isObjectSpacePathSampling()) {
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
446 if( mapdesc->minsavings != N_NOSAVINGSSUBDIVISION ) {
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 ) {
453 pspec[0].needsSubdivision = pspec[1].needsSubdivision = 1;
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;
459 needsSampling = (needsSampling ? needsSamplingSubdivision() : 0);
460}
Mapdesc::calcPartialVelocity
REAL calcPartialVelocity(REAL *, int, int, int, REAL)
Definition: mapdescv.cc:54
Mapdesc::isObjectSpaceParaSampling
int isObjectSpaceParaSampling(void)
Definition: mapdesc.h:222
Mapdesc::isConstantSampling
int isConstantSampling(void)
Definition: mapdesc.h:204
Mapdesc::minsavings
REAL minsavings
Definition: mapdesc.h:108
Mapdesc::isObjectSpacePathSampling
int isObjectSpacePathSampling(void)
Definition: mapdesc.h:228
Mapdesc::isDomainSampling
int isDomainSampling(void)
Definition: mapdesc.h:210
Mapdesc::isParametricDistanceSampling
int isParametricDistanceSampling(void)
Definition: mapdesc.h:216
Mapdesc::maxsrate
REAL maxsrate
Definition: mapdesc.h:110
Mapdesc::getProperty
REAL getProperty(long)
Definition: mapdesc.cc:769
Mapdesc::project
int project(REAL *, int, REAL *, int, int)
Definition: mapdesc.cc:647
Mapdesc::isPathLengthSampling
int isPathLengthSampling(void)
Definition: mapdesc.h:240
Mapdesc::isSurfaceAreaSampling
int isSurfaceAreaSampling(void)
Definition: mapdesc.h:234
Mapdesc::maxtrate
REAL maxtrate
Definition: mapdesc.h:111
Patch::needsSamplingSubdivision
int needsSamplingSubdivision(void)
Definition: patch.cc:479
MAXCOORDS
#define MAXCOORDS
Definition: defines.h:48
MAXORDER
#define MAXORDER
Definition: defines.h:45
assert
#define assert(x)
Definition: debug.h:53
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
range
GLenum GLint * range
Definition: glext.h:7539
val
GLuint GLfloat * val
Definition: glext.h:7180
ss
#define ss
Definition: i386-dis.c:441
ds
#define ds
Definition: i386-dis.c:443
sqrtf
#define sqrtf(x)
Definition: mymath.h:59
N_NOSAVINGSSUBDIVISION
#define N_NOSAVINGSSUBDIVISION
Definition: nurbsconsts.h:47
N_PIXEL_TOLERANCE
#define N_PIXEL_TOLERANCE
Definition: nurbsconsts.h:89
N_ERROR_TOLERANCE
#define N_ERROR_TOLERANCE
Definition: nurbsconsts.h:90
area
static Real area(Real A[2], Real B[2], Real C[2])
Definition: polyDBG.cc:50
Patchspec::getstepsize
void getstepsize(REAL)
Definition: patch.cc:469
Patchspec::singleStep
void singleStep(void)
Definition: patch.cc:463
Pspec::sidestep
REAL sidestep[2]
Definition: patch.h:48
Pspec::needsSubdivision
int needsSubdivision
Definition: patch.h:51
Pspec::stepsize
REAL stepsize
Definition: patch.h:49
Pspec::minstepsize
REAL minstepsize
Definition: patch.h:50

◆ needsNonSamplingSubdivision()

int Patch::needsNonSamplingSubdivision ( void  )

Definition at line 485 of file patch.cc.

486{
487 return notInBbox;
488}

◆ 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}
Patch::needsSubdivision
int needsSubdivision(int)
Definition: patch.cc:491

Referenced by getstepsize().

◆ needsSubdivision()

int Patch::needsSubdivision ( int  param)

Definition at line 491 of file patch.cc.

492{
493 return pspec[param].needsSubdivision;
494}

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

Patchspec Patch::pspec[2]
private

Definition at line 90 of file patch.h.

Referenced by checkBboxConstraint(), clamp(), cullCheck(), get_uorder(), get_vorder(), getstepsize(), needsSamplingSubdivision(), needsSubdivision(), and Patch().

◆ 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: