gl/mesa/src/glu/sgi/libnurbs/internals/nurbstess.cc

   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