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 * nurbstess.c++ 37 * 38 */ 39 40 #include "glimports.h" 41 #include "myassert.h" 42 #include "mysetjmp.h" 43 #include "mystdio.h" 44 #include "nurbsconsts.h" 45 #include "nurbstess.h" 46 #include "bufpool.h" 47 #include "quilt.h" 48 #include "knotvector.h" 49 #include "mapdesc.h" 50 #include "maplist.h" 51 52 void 53 NurbsTessellator::set_domain_distance_u_rate(REAL u_rate) 54 { 55 subdivider.set_domain_distance_u_rate(u_rate); 56 } 57 58 void 59 NurbsTessellator::set_domain_distance_v_rate(REAL v_rate) 60 { 61 subdivider.set_domain_distance_v_rate(v_rate); 62 } 63 64 void 65 NurbsTessellator::set_is_domain_distance_sampling(int flag) 66 { 67 subdivider.set_is_domain_distance_sampling(flag); 68 } 69 70 void 71 NurbsTessellator::resetObjects( void ) 72 { 73 subdivider.clear(); 74 } 75 76 void 77 NurbsTessellator::makeobj( int ) 78 { 79 #ifndef NDEBUG 80 _glu_dprintf( "makeobj\n" ); 81 #endif 82 } 83 84 void 85 NurbsTessellator::closeobj( void ) 86 { 87 #ifndef NDEBUG 88 _glu_dprintf( "closeobj\n" ); 89 #endif 90 } 91 92 void 93 NurbsTessellator::bgnrender( void ) 94 { 95 #ifndef NDEBUG 96 _glu_dprintf( "bgnrender\n" ); 97 #endif 98 } 99 100 void 101 NurbsTessellator::endrender( void ) 102 { 103 #ifndef NDEBUG 104 _glu_dprintf( "endrender\n" ); 105 #endif 106 } 107 108 /*----------------------------------------------------------------------------- 109 * do_freebgnsurface - free o_surface structure 110 * 111 * Client: do_freeall(), bgnsurface() 112 *----------------------------------------------------------------------------- 113 */ 114 void 115 NurbsTessellator::do_freebgnsurface( O_surface *o_surface ) 116 { 117 o_surface->deleteMe( o_surfacePool ); 118 } 119 120 121 /*----------------------------------------------------------------------------- 122 * do_bgnsurface - begin the display of a surface 123 * 124 * Client: bgnsurface() 125 *----------------------------------------------------------------------------- 126 */ 127 void 128 NurbsTessellator::do_bgnsurface( O_surface *o_surface ) 129 { 130 if( inSurface ) { 131 do_nurbserror( 27 ); 132 endsurface(); 133 } 134 inSurface = 1; 135 136 if( ! playBack ) bgnrender(); 137 138 isTrimModified = 0; 139 isSurfaceModified = 0; 140 isDataValid = 1; 141 numTrims = 0; 142 currentSurface = o_surface; 143 nextTrim = &( currentSurface->o_trim ); 144 nextNurbssurface = &( currentSurface->o_nurbssurface ); 145 } 146 147 /*----------------------------------------------------------------------------- 148 * do_bgncurve - begin the display of a curve 149 * 150 * Client: bgncurve() 151 *----------------------------------------------------------------------------- 152 */ 153 void 154 NurbsTessellator::do_bgncurve( O_curve *o_curve ) 155 { 156 if ( inCurve ) { 157 do_nurbserror( 6 ); 158 endcurve(); 159 } 160 161 inCurve = 1; 162 currentCurve = o_curve; 163 currentCurve->curvetype = ct_none; 164 165 if( inTrim ) { 166 if( *nextCurve != o_curve ) { 167 isCurveModified = 1; 168 *nextCurve = o_curve; 169 } 170 } else { 171 if( ! playBack ) bgnrender(); 172 isDataValid = 1; 173 } 174 nextCurve = &(o_curve->next); 175 nextPwlcurve = &(o_curve->curve.o_pwlcurve); 176 nextNurbscurve = &(o_curve->curve.o_nurbscurve); 177 } 178 179 /*----------------------------------------------------------------------------- 180 * do_endcurve - 181 * 182 * Client: endcurve() 183 *----------------------------------------------------------------------------- 184 */ 185 186 void 187 NurbsTessellator::do_endcurve( void ) 188 { 189 if( ! inCurve ) { 190 do_nurbserror( 7 ); 191 return; 192 } 193 inCurve = 0; 194 195 *nextCurve = 0; 196 if (currentCurve->curvetype == ct_nurbscurve) 197 *nextNurbscurve = 0; 198 else 199 *nextPwlcurve = 0; 200 201 if ( ! inTrim ) { 202 if( ! isDataValid ) { 203 do_freecurveall( currentCurve ); 204 return; 205 } 206 207 int errval; 208 errval = ::mysetjmp( jumpbuffer ); 209 if( errval == 0 ) { 210 if( currentCurve->curvetype == ct_nurbscurve ) { 211 subdivider.beginQuilts(); 212 for( O_nurbscurve *n = currentCurve->curve.o_nurbscurve; n != 0; n = n->next ) 213 subdivider.addQuilt( n->bezier_curves ); 214 subdivider.endQuilts(); 215 subdivider.drawCurves(); 216 if( ! playBack ) endrender(); 217 } else { 218 /* XXX */ 219 if( ! playBack ) endrender(); 220 /*do_draw_pwlcurve( currentCurve->curve.o_pwlcurve ) */; 221 do_nurbserror( 9 ); 222 } 223 } else { 224 if( ! playBack ) endrender(); 225 do_nurbserror( errval ); 226 } 227 do_freecurveall( currentCurve ); 228 resetObjects(); 229 } 230 } 231 232 /*----------------------------------------------------------------------------- 233 * do_endsurface - mark end of surface, display surface, free immediate data 234 * 235 * Client: 236 *----------------------------------------------------------------------------- 237 */ 238 void 239 NurbsTessellator::do_endsurface( void ) 240 { 241 if( inTrim ) { 242 do_nurbserror( 12 ); 243 endtrim(); 244 } 245 246 if( ! inSurface ) { 247 do_nurbserror( 13 ); 248 return; 249 } 250 inSurface = 0; 251 252 *nextNurbssurface = 0; 253 254 if( ! isDataValid ) { 255 do_freeall( ); 256 return; 257 } 258 259 if( *nextTrim != 0 ) { 260 isTrimModified = 1; 261 *nextTrim = 0; 262 } 263 264 int errval; 265 266 errval = ::mysetjmp( jumpbuffer ); 267 if( errval == 0 ) { 268 if( numTrims > 0 ) { 269 270 subdivider.beginTrims(); 271 for( O_trim *trim = currentSurface->o_trim; trim; trim = trim->next ) { 272 subdivider.beginLoop(); 273 for( O_curve *curve = trim->o_curve; curve; curve = curve->next ) { 274 curve->used = 0; 275 assert( curve->curvetype != ct_none ); 276 if (curve->curvetype == ct_pwlcurve) { 277 O_pwlcurve *c = curve->curve.o_pwlcurve; 278 subdivider.addArc( c->npts, c->pts, curve->nuid ); 279 } else { 280 Quilt *quilt = curve->curve.o_nurbscurve->bezier_curves; 281 Quiltspec *qspec = quilt->qspec; 282 REAL *cpts = quilt->cpts + qspec->offset; 283 REAL *cptsend = cpts + (qspec->width * qspec->order * qspec->stride); 284 for( ; cpts != cptsend; cpts += qspec->order*qspec->stride ) 285 subdivider.addArc( cpts, quilt, curve->nuid ); 286 } 287 } 288 subdivider.endLoop(); 289 } 290 subdivider.endTrims(); 291 } 292 293 subdivider.beginQuilts(); 294 for( O_nurbssurface *n = currentSurface->o_nurbssurface; n; n = n->next ) 295 subdivider.addQuilt( n->bezier_patches ); 296 subdivider.endQuilts(); 297 subdivider.drawSurfaces( currentSurface->nuid ); 298 if( ! playBack ) endrender(); 299 } else { 300 if( ! playBack ) endrender(); 301 do_nurbserror( errval ); 302 } 303 304 do_freeall( ); 305 resetObjects(); 306 } 307 308 /*----------------------------------------------------------------------------- 309 * do_freeall - free all data allocated in immediate mode 310 * 311 * Client: 312 *----------------------------------------------------------------------------- 313 */ 314 void 315 NurbsTessellator::do_freeall( void ) 316 { 317 for( O_trim *o_trim = currentSurface->o_trim; o_trim; ) { 318 O_trim *next_o_trim = o_trim->next; 319 for( O_curve *curve = o_trim->o_curve; curve; ) { 320 O_curve *next_o_curve = curve->next; 321 do_freecurveall( curve ); 322 curve = next_o_curve; 323 } 324 if( o_trim->save == 0 ) do_freebgntrim( o_trim ); 325 o_trim = next_o_trim; 326 } 327 328 O_nurbssurface *nurbss, *next_nurbss; 329 for( nurbss= currentSurface->o_nurbssurface; nurbss; nurbss = next_nurbss) { 330 next_nurbss = nurbss->next; 331 if( nurbss->save == 0 ) 332 do_freenurbssurface( nurbss ); 333 else 334 nurbss->used = 0; 335 } 336 337 if( currentSurface->save == 0 ) do_freebgnsurface( currentSurface ); 338 } 339 340 void 341 NurbsTessellator::do_freecurveall( O_curve *curve ) 342 { 343 assert( curve->curvetype != ct_none ); 344 345 if( curve->curvetype == ct_nurbscurve ) { 346 O_nurbscurve *ncurve, *next_ncurve; 347 for( ncurve=curve->curve.o_nurbscurve; ncurve; ncurve=next_ncurve ) { 348 next_ncurve = ncurve->next; 349 if( ncurve->save == 0 ) 350 do_freenurbscurve( ncurve ); 351 else 352 ncurve->used = 0; 353 } 354 } else { 355 O_pwlcurve *pcurve, *next_pcurve; 356 for( pcurve=curve->curve.o_pwlcurve; pcurve; pcurve=next_pcurve ) { 357 next_pcurve = pcurve->next; 358 if( pcurve->save == 0 ) 359 do_freepwlcurve( pcurve ); 360 else 361 pcurve->used = 0; 362 } 363 } 364 if( curve->save == 0 ) 365 do_freebgncurve( curve ); 366 } 367 368 369 /*----------------------------------------------------------------------------- 370 * do_freebgntrim - free the space allocated for a trim loop 371 * 372 * Client: 373 *----------------------------------------------------------------------------- 374 */ 375 void 376 NurbsTessellator::do_freebgntrim( O_trim *o_trim ) 377 { 378 o_trim->deleteMe( o_trimPool ); 379 } 380 381 382 /*----------------------------------------------------------------------------- 383 * do_bgntrim - link in a trim loop to the current trimmed surface description 384 * 385 * Client: bgntrim() 386 *----------------------------------------------------------------------------- 387 */ 388 void 389 NurbsTessellator::do_bgntrim( O_trim *o_trim ) 390 { 391 392 if( ! inSurface ) { 393 do_nurbserror( 15 ); 394 bgnsurface( 0 ); 395 inSurface = 2; 396 } 397 398 if( inTrim ) { 399 do_nurbserror( 16 ); 400 endtrim(); 401 } 402 inTrim = 1; 403 404 if( *nextTrim != o_trim ) { 405 isTrimModified = 1; 406 *nextTrim = o_trim; 407 } 408 409 currentTrim = o_trim; 410 nextTrim = &(o_trim->next); 411 nextCurve = &(o_trim->o_curve); 412 } 413 414 415 /*----------------------------------------------------------------------------- 416 * do_endtrim - mark the end of the current trim loop 417 * 418 * Client: endtrim() 419 *----------------------------------------------------------------------------- 420 */ 421 void 422 NurbsTessellator::do_endtrim( void ) 423 { 424 if( ! inTrim ) { 425 do_nurbserror( 17 ); 426 return; 427 } 428 inTrim = 0; 429 430 if( currentTrim->o_curve == 0 ) { 431 do_nurbserror( 18 ); 432 isDataValid = 0; 433 } 434 435 numTrims++; 436 437 if( *nextCurve != 0 ) { 438 isTrimModified = 1; 439 *nextCurve = 0; 440 } 441 } 442 443 /*----------------------------------------------------------------------------- 444 * do_freepwlcurve - 445 * 446 * Client: 447 *----------------------------------------------------------------------------- 448 */ 449 void 450 NurbsTessellator::do_freepwlcurve( O_pwlcurve *o_pwlcurve ) 451 { 452 o_pwlcurve->deleteMe( o_pwlcurvePool ); 453 } 454 455 void 456 NurbsTessellator::do_freebgncurve( O_curve *o_curve ) 457 { 458 o_curve->deleteMe( o_curvePool ); 459 } 460 461 /*----------------------------------------------------------------------------- 462 * do_pwlcurve - link in pwl trim loop to the current surface description 463 * 464 * Client: pwlcurve() 465 *----------------------------------------------------------------------------- 466 */ 467 void 468 NurbsTessellator::do_pwlcurve( O_pwlcurve *o_pwlcurve ) 469 { 470 if( ! inTrim ) { 471 do_nurbserror( 19 ); 472 if( o_pwlcurve->save == 0 ) 473 do_freepwlcurve(o_pwlcurve ); 474 return; 475 } 476 477 if( ! inCurve ) { 478 bgncurve( 0 ); 479 inCurve = 2; 480 } 481 482 if( o_pwlcurve->used ) { 483 do_nurbserror( 20 ); 484 isDataValid = 0; 485 return; 486 } else 487 o_pwlcurve->used = 1; 488 489 if( currentCurve->curvetype == ct_none ) { 490 currentCurve->curvetype = ct_pwlcurve; 491 } else if( currentCurve->curvetype != ct_pwlcurve ) { 492 do_nurbserror( 21 ); 493 isDataValid = 0; 494 return; 495 } 496 497 if( *nextPwlcurve != o_pwlcurve ) { 498 isCurveModified = 1; 499 *nextPwlcurve = o_pwlcurve; 500 } 501 nextPwlcurve = &(o_pwlcurve->next); 502 503 if( o_pwlcurve->owner != currentCurve ) { 504 isCurveModified = 1; 505 o_pwlcurve->owner = currentCurve; 506 } 507 508 if( inCurve == 2 ) 509 endcurve(); 510 } 511 512 513 /*----------------------------------------------------------------------------- 514 * do_freenurbscurve - 515 * 516 * Client: 517 *----------------------------------------------------------------------------- 518 */ 519 void 520 NurbsTessellator::do_freenurbscurve( O_nurbscurve *o_nurbscurve ) 521 { 522 o_nurbscurve->bezier_curves->deleteMe( quiltPool ); 523 o_nurbscurve->deleteMe( o_nurbscurvePool ); 524 } 525 526 527 /*----------------------------------------------------------------------------- 528 * do_nurbscurve - 529 * 530 * Client: nurbscurve() 531 *----------------------------------------------------------------------------- 532 */ 533 void 534 NurbsTessellator::do_nurbscurve( O_nurbscurve *o_nurbscurve ) 535 { 536 if ( ! inCurve ) { 537 bgncurve( 0 ); 538 inCurve = 2; 539 } 540 541 if( o_nurbscurve->used ) { 542 /* error - curve was already called in current surface */ 543 do_nurbserror( 23 ); 544 isDataValid = 0; 545 return; 546 } else 547 o_nurbscurve->used = 1; 548 549 if( currentCurve->curvetype == ct_none ) { 550 currentCurve->curvetype = ct_nurbscurve; 551 } else if( currentCurve->curvetype != ct_nurbscurve ) { 552 do_nurbserror( 24 ); 553 isDataValid = 0; 554 return; 555 } 556 557 if( *nextNurbscurve != o_nurbscurve ) { 558 isCurveModified = 1; 559 *nextNurbscurve = o_nurbscurve; 560 } 561 562 nextNurbscurve = &(o_nurbscurve->next); 563 564 if( o_nurbscurve->owner != currentCurve ) { 565 isCurveModified = 1; 566 o_nurbscurve->owner = currentCurve; 567 } 568 569 if( o_nurbscurve->owner == 0 ) 570 isCurveModified = 1; 571 572 if( inCurve == 2 ) 573 endcurve(); 574 } 575 576 577 /*----------------------------------------------------------------------------- 578 * do_freenurbssurface - 579 * 580 * Client: 581 *----------------------------------------------------------------------------- 582 */ 583 584 void 585 NurbsTessellator::do_freenurbssurface( O_nurbssurface *o_nurbssurface ) 586 { 587 o_nurbssurface->bezier_patches->deleteMe( quiltPool ); 588 o_nurbssurface->deleteMe( o_nurbssurfacePool ); 589 } 590 591 /*----------------------------------------------------------------------------- 592 * do_nurbssurface - 593 * 594 * Client: nurbssurface() 595 *----------------------------------------------------------------------------- 596 */ 597 void 598 NurbsTessellator::do_nurbssurface( O_nurbssurface *o_nurbssurface ) 599 { 600 if( ! inSurface ) { 601 bgnsurface( 0 ); 602 inSurface = 2; 603 } 604 605 if( o_nurbssurface->used ) { 606 /* error - surface was already called in current block */ 607 do_nurbserror( 25 ); 608 isDataValid = 0; 609 return; 610 } else 611 o_nurbssurface->used = 1; 612 613 if( *nextNurbssurface != o_nurbssurface ) { 614 isSurfaceModified = 1; 615 *nextNurbssurface = o_nurbssurface; 616 } 617 618 if( o_nurbssurface->owner != currentSurface ) { 619 isSurfaceModified = 1; 620 o_nurbssurface->owner = currentSurface; 621 } 622 nextNurbssurface = &(o_nurbssurface->next); 623 624 if( inSurface == 2 ) 625 endsurface(); 626 } 627 628 629 /*----------------------------------------------------------------------------- 630 * do_freenurbsproperty 631 * 632 *----------------------------------------------------------------------------- 633 */ 634 635 void 636 NurbsTessellator::do_freenurbsproperty( Property *prop ) 637 { 638 prop->deleteMe( propertyPool ); 639 } 640 641 642 /*----------------------------------------------------------------------------- 643 * do_setnurbsproperty - 644 * 645 *----------------------------------------------------------------------------- 646 */ 647 648 void 649 NurbsTessellator::do_setnurbsproperty( Property *prop ) 650 { 651 renderhints.setProperty( prop->tag, prop->value ); 652 if( prop->save == 0 ) 653 do_freenurbsproperty( prop ); 654 } 655 656 void 657 NurbsTessellator::do_setnurbsproperty2( Property *prop ) 658 { 659 Mapdesc *mapdesc = maplist.find( prop->type ); 660 661 mapdesc->setProperty( prop->tag, prop->value ); 662 if( prop->save == 0 ) 663 do_freenurbsproperty( prop ); 664 } 665 666 void 667 NurbsTessellator::errorHandler( int ) 668 { 669 } 670 671 void 672 NurbsTessellator::do_nurbserror( int msg ) 673 { 674 errorHandler( msg ); 675 } 676 677 int 678 NurbsTessellator::do_check_knots( Knotvector *knots, const char *msg ) 679 { 680 int status = knots->validate(); 681 if( status ) { 682 do_nurbserror( status ); 683 if( renderhints.errorchecking != N_NOMSG ) knots->show( msg ); 684 } 685 return status; 686 } 687 688 689 690 691 692
Indexes created Thu Jul 23 00:25:05 UTC 2026