src/glu/sgi/libnurbs/interface/glsurfeval.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  * glsurfeval.c++
  37  *
  38  */
  39
  40 /* Polynomial Evaluator Interface */
  41 #include "gluos.h"
  42 #include <stdio.h>
  43 #include "glimports.h"
  44 #include "glrenderer.h"
  45 #include "glsurfeval.h"
  46 #include "nurbsconsts.h"
  47 #include "bezierPatchMesh.h"
  48
  49
  50 //extern int surfcount;
  51 //int surfcount=0;
  52
  53 /*#define USE_INTERNAL_EVAL*/ //use internal evaluator
  54
  55 /*whether do evaluation or not*/
  56 /*#define NO_EVALUATION*/
  57
  58 //#define USE_LOD //for LOD test, have to turn on USE_LOD in insurfeval.c++ too
  59
  60 /*for statistics*/
  61 //#define STATISTICS
  62 #ifdef STATISTICS
  63 static int STAT_num_of_triangles=0;
  64 static int STAT_num_of_eval_vertices=0;
  65 static int STAT_num_of_quad_strips=0;
  66 #endif
  67
  68 /*for output triangles*/
  69 /*#define OUTPUT_TRIANGLES*/
  70
  71
  72 /*#define FOR_CHRIS*/
  73 #ifdef FOR_CHRIS
  74 extern "C"  {  void                evalUStripExt(int n_upper, REAL v_upper, REAL* upper_val,
  75                                    int n_lower, REAL v_lower, REAL* lower_val);}
  76
  77 extern "C" {   void                evalVStripExt(int n_left, REAL u_left, REAL* left_val,
  78                                    int n_right, REAL u_right, REAL* right_val);
  79              }
  80 #endif
  81
  82
  83 /**************begin for LOD_eval_list***********/
  84 void OpenGLSurfaceEvaluator::LOD_eval_list(int level)
  85 {
  86   if(level == 0)
  87     LOD_eval_level = 1;
  88   else if(level == 1)
  89     LOD_eval_level = 2;
  90   else if(level == 2)
  91     LOD_eval_level = 4;
  92   else
  93     LOD_eval_level = 8;
  94
  95   inBPMListEvalEM(global_bpm);
  96 }
  97
  98
  99 OpenGLSurfaceEvaluator::OpenGLSurfaceEvaluator()
 100 {
 101     int i;
 102
 103     for (i=0; i<VERTEX_CACHE_SIZE; i++) {
 104         vertexCache[i] = new StoredVertex;
 105     }
 106     tmeshing = 0;
 107     which = 0;
 108     vcount = 0;
 109
 110     global_uorder = 0;
 111     global_vorder = 0;
 112     global_uprime = -1.0;
 113     global_vprime = -1.0;
 114     global_vprime_BV = -1.0;
 115     global_uprime_BU = -1.0;
 116     global_uorder_BU = 0;
 117     global_vorder_BU = 0;
 118     global_uorder_BV = 0;
 119     global_vorder_BV = 0;
 120     global_baseData = NULL;
 121
 122     global_bpm = NULL;
 123     output_triangles = 0; //don't output triangles by default
 124
 125     //no default callback functions
 126     beginCallBackN = NULL;
 127     endCallBackN = NULL;
 128     vertexCallBackN = NULL;
 129     normalCallBackN = NULL;
 130     colorCallBackN = NULL;
 131     texcoordCallBackN = NULL;
 132     beginCallBackData = NULL;
 133     endCallBackData = NULL;
 134     vertexCallBackData = NULL;
 135     normalCallBackData = NULL;
 136     colorCallBackData = NULL;
 137     texcoordCallBackData = NULL;
 138
 139     userData = NULL;
 140
 141     auto_normal_flag = 0;
 142     callback_auto_normal = 0; //default of GLU_CALLBACK_AUTO_NORMAL is 0
 143     vertex_flag = 0;
 144     normal_flag = 0;
 145     color_flag = 0;
 146     texcoord_flag = 0;
 147
 148     em_vertex.uprime = -1.0;
 149     em_vertex.vprime = -1.0;
 150     em_normal.uprime = -1.0;
 151     em_normal.vprime = -1.0;
 152     em_color.uprime = -1.0;
 153     em_color.vprime = -1.0;
 154     em_texcoord.uprime = -1.0;
 155     em_texcoord.vprime = -1.0;
 156
 157 #ifdef USE_LOD
 158     LOD_eval_level = 1;
 159 #endif
 160 }
 161
 162 OpenGLSurfaceEvaluator::~OpenGLSurfaceEvaluator()
 163 {
 164    for (int ii= 0; ii< VERTEX_CACHE_SIZE; ii++) {
 165       delete vertexCache[ii];
 166       vertexCache[ii]= 0;
 167    }
 168 }
 169
 170 /*---------------------------------------------------------------------------
 171  * disable - turn off a map
 172  *---------------------------------------------------------------------------
 173  */
 174 void
 175 OpenGLSurfaceEvaluator::disable(long type)
 176 {
 177     glDisable((GLenum) type);
 178 }
 179
 180 /*---------------------------------------------------------------------------
 181  * enable - turn on a map
 182  *---------------------------------------------------------------------------
 183  */
 184 void
 185 OpenGLSurfaceEvaluator::enable(long type)
 186 {
 187     glEnable((GLenum) type);
 188 }
 189
 190 /*-------------------------------------------------------------------------
 191  * mapgrid2f - define a lattice of points with origin and offset
 192  *-------------------------------------------------------------------------
 193  */
 194 void
 195 OpenGLSurfaceEvaluator::mapgrid2f(long nu, REAL u0, REAL u1, long nv, REAL v0, REAL v1)
 196 {
 197 #ifdef USE_INTERNAL_EVAL
 198   inMapGrid2f((int) nu, (REAL) u0, (REAL) u1, (int) nv,
 199               (REAL) v0, (REAL) v1);
 200 #else
 201
 202   if(output_triangles)
 203     {
 204       global_grid_u0 = u0;
 205       global_grid_u1 = u1;
 206       global_grid_nu = nu;
 207       global_grid_v0 = v0;
 208       global_grid_v1 = v1;
 209       global_grid_nv = nv;
 210     }
 211   else
 212     glMapGrid2d((GLint) nu, (GLdouble) u0, (GLdouble) u1, (GLint) nv,
 213             (GLdouble) v0, (GLdouble) v1);
 214
 215 #endif
 216 }
 217
 218 void
 219 OpenGLSurfaceEvaluator::polymode(long style)
 220 {
 221   if(! output_triangles)
 222     {
 223       switch(style) {
 224       default:
 225       case N_MESHFILL:
 226
 227         glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_FILL);
 228         break;
 229       case N_MESHLINE:
 230         glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_LINE);
 231         break;
 232       case N_MESHPOINT:
 233         glPolygonMode((GLenum) GL_FRONT_AND_BACK, (GLenum) GL_POINT);
 234         break;
 235       }
 236     }
 237 }
 238
 239 void
 240 OpenGLSurfaceEvaluator::bgnline(void)
 241 {
 242   if(output_triangles)
 243     bezierPatchMeshBeginStrip(global_bpm, GL_LINE_STRIP);
 244   else
 245     glBegin((GLenum) GL_LINE_STRIP);
 246 }
 247
 248 void
 249 OpenGLSurfaceEvaluator::endline(void)
 250 {
 251   if(output_triangles)
 252     bezierPatchMeshEndStrip(global_bpm);
 253   else
 254     glEnd();
 255 }
 256
 257 void
 258 OpenGLSurfaceEvaluator::range2f(long type, REAL *from, REAL *to)
 259 {
 260 }
 261
 262 void
 263 OpenGLSurfaceEvaluator::domain2f(REAL ulo, REAL uhi, REAL vlo, REAL vhi)
 264 {
 265 }
 266
 267 void
 268 OpenGLSurfaceEvaluator::bgnclosedline(void)
 269 {
 270   if(output_triangles)
 271     bezierPatchMeshBeginStrip(global_bpm, GL_LINE_LOOP);
 272   else
 273     glBegin((GLenum) GL_LINE_LOOP);
 274 }
 275
 276 void
 277 OpenGLSurfaceEvaluator::endclosedline(void)
 278 {
 279   if(output_triangles)
 280     bezierPatchMeshEndStrip(global_bpm);
 281   else
 282     glEnd();
 283 }
 284
 285
 286
 287
 288
 289 void
 290 OpenGLSurfaceEvaluator::bgntmesh(void)
 291 {
 292
 293     tmeshing = 1;
 294     which = 0;
 295     vcount = 0;
 296
 297     if(output_triangles)
 298       bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLES);
 299     else
 300       glBegin((GLenum) GL_TRIANGLES);
 301
 302 }
 303
 304 void
 305 OpenGLSurfaceEvaluator::swaptmesh(void)
 306 {
 307     which = 1 - which;
 308
 309 }
 310
 311 void
 312 OpenGLSurfaceEvaluator::endtmesh(void)
 313 {
 314     tmeshing = 0;
 315
 316
 317     if(output_triangles)
 318       bezierPatchMeshEndStrip(global_bpm);
 319     else
 320       glEnd();
 321 }
 322
 323 void
 324 OpenGLSurfaceEvaluator::bgntfan(void)
 325 {
 326
 327   if(output_triangles)
 328     bezierPatchMeshBeginStrip(global_bpm, GL_TRIANGLE_FAN);
 329   else
 330     glBegin((GLenum) GL_TRIANGLE_FAN);
 331
 332 }
 333 void
 334 OpenGLSurfaceEvaluator::endtfan(void)
 335 {
 336   if(output_triangles)
 337         bezierPatchMeshEndStrip(global_bpm);
 338   else
 339     glEnd();
 340 }
 341
 342 void
 343 OpenGLSurfaceEvaluator::evalUStrip(int n_upper, REAL v_upper, REAL* upper_val, int n_lower, REAL v_lower, REAL* lower_val)
 344 {
 345 #ifdef USE_INTERNAL_EVAL
 346   inEvalUStrip(n_upper, v_upper, upper_val,
 347         n_lower, v_lower, lower_val);
 348 #else
 349
 350 #ifdef FOR_CHRIS
 351   evalUStripExt(n_upper, v_upper, upper_val,
 352                  n_lower, v_lower, lower_val);
 353   return;
 354
 355 #endif
 356   int i,j,k,l;
 357   REAL leftMostV[2];
 358
 359   /*
 360    *the algorithm works by scanning from left to right.
 361    *leftMostV: the left most of the remaining verteces (on both upper and lower).
 362    *           it could an element of upperVerts or lowerVerts.
 363    *i: upperVerts[i] is the first vertex to the right of leftMostV on upper line
 364    *j: lowerVerts[j] is the first vertex to the right of leftMostV on lower line
 365    */
 366
 367   /*initialize i,j,and leftMostV
 368    */
 369   if(upper_val[0] <= lower_val[0])
 370     {
 371       i=1;
 372       j=0;
 373
 374       leftMostV[0] = upper_val[0];
 375       leftMostV[1] = v_upper;
 376     }
 377   else
 378     {
 379       i=0;
 380       j=1;
 381
 382       leftMostV[0] = lower_val[0];
 383       leftMostV[1] = v_lower;
 384
 385     }
 386
 387   /*the main loop.
 388    *the invariance is that:
 389    *at the beginning of each loop, the meaning of i,j,and leftMostV are
 390    *maintained
 391    */
 392   while(1)
 393     {
 394       if(i >= n_upper) /*case1: no more in upper*/
 395         {
 396           if(j<n_lower-1) /*at least two vertices in lower*/
 397             {
 398               bgntfan();
 399               coord2f(leftMostV[0], leftMostV[1]);
 400 //            glNormal3fv(leftMostNormal);
 401 //              glVertex3fv(leftMostXYZ);
 402
 403               while(j<n_lower){
 404                 coord2f(lower_val[j], v_lower);
 405 //              glNormal3fv(lowerNormal[j]);
 406 //              glVertex3fv(lowerXYZ[j]);
 407                 j++;
 408
 409               }
 410               endtfan();
 411             }
 412           break; /*exit the main loop*/
 413         }
 414       else if(j>= n_lower) /*case2: no more in lower*/
 415         {
 416           if(i<n_upper-1) /*at least two vertices in upper*/
 417             {
 418               bgntfan();
 419               coord2f(leftMostV[0], leftMostV[1]);
 420 //            glNormal3fv(leftMostNormal);
 421 //            glVertex3fv(leftMostXYZ);
 422
 423               for(k=n_upper-1; k>=i; k--) /*reverse order for two-side lighting*/
 424                 {
 425                   coord2f(upper_val[k], v_upper);
 426 //                glNormal3fv(upperNormal[k]);
 427 //                glVertex3fv(upperXYZ[k]);
 428                 }
 429
 430               endtfan();
 431             }
 432           break; /*exit the main loop*/
 433         }
 434       else /* case3: neither is empty, plus the leftMostV, there is at least one triangle to output*/
 435         {
 436           if(upper_val[i] <= lower_val[j])
 437             {
 438               bgntfan();
 439               coord2f(lower_val[j], v_lower);
 440 //            glNormal3fv(lowerNormal[j]);
 441 //            glVertex3fv(lowerXYZ[j]);
 442
 443               /*find the last k>=i such that
 444                *upperverts[k][0] <= lowerverts[j][0]
 445                */
 446               k=i;
 447
 448               while(k<n_upper)
 449                 {
 450                   if(upper_val[k] > lower_val[j])
 451                     break;
 452                   k++;
 453
 454                 }
 455               k--;
 456
 457
 458               for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
 459                 {
 460                   coord2f(upper_val[l], v_upper);
 461 //                glNormal3fv(upperNormal[l]);
 462 //                glVertex3fv(upperXYZ[l]);
 463
 464                 }
 465               coord2f(leftMostV[0], leftMostV[1]);
 466 //            glNormal3fv(leftMostNormal);
 467 //            glVertex3fv(leftMostXYZ);
 468
 469               endtfan();
 470
 471               /*update i and leftMostV for next loop
 472                */
 473               i = k+1;
 474
 475               leftMostV[0] = upper_val[k];
 476               leftMostV[1] = v_upper;
 477 //            leftMostNormal = upperNormal[k];
 478 //            leftMostXYZ = upperXYZ[k];
 479             }
 480           else /*upperVerts[i][0] > lowerVerts[j][0]*/
 481             {
 482               bgntfan();
 483               coord2f(upper_val[i], v_upper);
 484 //            glNormal3fv(upperNormal[i]);
 485 //            glVertex3fv(upperXYZ[i]);
 486
 487               coord2f(leftMostV[0], leftMostV[1]);
 488 //              glNormal3fv(leftMostNormal);
 489 //            glVertex3fv(leftMostXYZ);
 490
 491
 492               /*find the last k>=j such that
 493                *lowerverts[k][0] < upperverts[i][0]
 494                */
 495               k=j;
 496               while(k< n_lower)
 497                 {
 498                   if(lower_val[k] >= upper_val[i])
 499                     break;
 500                   coord2f(lower_val[k], v_lower);
 501 //                glNormal3fv(lowerNormal[k]);
 502 //                glVertex3fv(lowerXYZ[k]);
 503
 504                   k++;
 505                 }
 506               endtfan();
 507
 508               /*update j and leftMostV for next loop
 509                */
 510               j=k;
 511               leftMostV[0] = lower_val[j-1];
 512               leftMostV[1] = v_lower;
 513
 514 //            leftMostNormal = lowerNormal[j-1];
 515 //            leftMostXYZ = lowerXYZ[j-1];
 516             }
 517         }
 518     }
 519   //clean up
 520 //  free(upperXYZ);
 521 //  free(lowerXYZ);
 522 //  free(upperNormal);
 523 //  free(lowerNormal);
 524 #endif
 525
 526 }
 527
 528
 529 void
 530 OpenGLSurfaceEvaluator::evalVStrip(int n_left, REAL u_left, REAL* left_val, int n_right, REAL u_right, REAL* right_val)
 531 {
 532 #ifdef USE_INTERNAL_EVAL
 533         inEvalVStrip(n_left, u_left, left_val,
 534         n_right, u_right, right_val);
 535 #else
 536
 537 #ifdef FOR_CHRIS
 538         evalVStripExt(n_left, u_left, left_val,
 539                       n_right, u_right, right_val);
 540         return;
 541
 542 #endif
 543
 544   int i,j,k,l;
 545   REAL botMostV[2];
 546   /*
 547    *the algorithm works by scanning from bot to top.
 548    *botMostV: the bot most of the remaining verteces (on both left and right).
 549    *           it could an element of leftVerts or rightVerts.
 550    *i: leftVerts[i] is the first vertex to the top of botMostV on left line
 551    *j: rightVerts[j] is the first vertex to the top of botMostV on rightline
 552    */
 553
 554   /*initialize i,j,and botMostV
 555    */
 556   if(left_val[0] <= right_val[0])
 557     {
 558       i=1;
 559       j=0;
 560
 561       botMostV[0] = u_left;
 562       botMostV[1] = left_val[0];
 563     }
 564   else
 565     {
 566       i=0;
 567       j=1;
 568
 569       botMostV[0] = u_right;
 570       botMostV[1] = right_val[0];
 571     }
 572
 573   /*the main loop.
 574    *the invariance is that:
 575    *at the beginning of each loop, the meaning of i,j,and botMostV are
 576    *maintained
 577    */
 578   while(1)
 579     {
 580       if(i >= n_left) /*case1: no more in left*/
 581         {
 582           if(j<n_right-1) /*at least two vertices in right*/
 583             {
 584               bgntfan();
 585               coord2f(botMostV[0], botMostV[1]);
 586               while(j<n_right){
 587                 coord2f(u_right, right_val[j]);
 588 //              glNormal3fv(rightNormal[j]);
 589 //              glVertex3fv(rightXYZ[j]);
 590                 j++;
 591
 592               }
 593               endtfan();
 594             }
 595           break; /*exit the main loop*/
 596         }
 597       else if(j>= n_right) /*case2: no more in right*/
 598         {
 599           if(i<n_left-1) /*at least two vertices in left*/
 600             {
 601               bgntfan();
 602               coord2f(botMostV[0], botMostV[1]);
 603 //            glNormal3fv(botMostNormal);
 604 //            glVertex3fv(botMostXYZ);
 605
 606               for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
 607                 {
 608                   coord2f(u_left, left_val[k]);
 609 //                glNormal3fv(leftNormal[k]);
 610 //                glVertex3fv(leftXYZ[k]);
 611                 }
 612
 613               endtfan();
 614             }
 615           break; /*exit the main loop*/
 616         }
 617       else /* case3: neither is empty, plus the botMostV, there is at least one triangle to output*/
 618         {
 619           if(left_val[i] <= right_val[j])
 620             {
 621               bgntfan();
 622               coord2f(u_right, right_val[j]);
 623 //            glNormal3fv(rightNormal[j]);
 624 //            glVertex3fv(rightXYZ[j]);
 625
 626               /*find the last k>=i such that
 627                *leftverts[k][0] <= rightverts[j][0]
 628                */
 629               k=i;
 630
 631               while(k<n_left)
 632                 {
 633                   if(left_val[k] > right_val[j])
 634                     break;
 635                   k++;
 636
 637                 }
 638               k--;
 639
 640
 641               for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
 642                 {
 643                   coord2f(u_left, left_val[l]);
 644 //                glNormal3fv(leftNormal[l]);
 645 //                glVertex3fv(leftXYZ[l]);
 646
 647                 }
 648               coord2f(botMostV[0], botMostV[1]);
 649 //            glNormal3fv(botMostNormal);
 650 //            glVertex3fv(botMostXYZ);
 651
 652               endtfan();
 653
 654               /*update i and botMostV for next loop
 655                */
 656               i = k+1;
 657
 658               botMostV[0] = u_left;
 659               botMostV[1] = left_val[k];
 660 //            botMostNormal = leftNormal[k];
 661 //            botMostXYZ = leftXYZ[k];
 662             }
 663           else /*left_val[i] > right_val[j])*/
 664             {
 665               bgntfan();
 666               coord2f(u_left, left_val[i]);
 667 //            glNormal3fv(leftNormal[i]);
 668 //            glVertex3fv(leftXYZ[i]);
 669
 670               coord2f(botMostV[0], botMostV[1]);
 671 //            glNormal3fv(botMostNormal);
 672 //            glVertex3fv(botMostXYZ);
 673
 674
 675               /*find the last k>=j such that
 676                *rightverts[k][0] < leftverts[i][0]
 677                */
 678               k=j;
 679               while(k< n_right)
 680                 {
 681                   if(right_val[k] >= left_val[i])
 682                     break;
 683                   coord2f(u_right, right_val[k]);
 684 //                glNormal3fv(rightNormal[k]);
 685 //                glVertex3fv(rightXYZ[k]);
 686
 687                   k++;
 688                 }
 689               endtfan();
 690
 691               /*update j and botMostV for next loop
 692                */
 693               j=k;
 694               botMostV[0] = u_right;
 695               botMostV[1] = right_val[j-1];
 696
 697 //            botMostNormal = rightNormal[j-1];
 698 //            botMostXYZ = rightXYZ[j-1];
 699             }
 700         }
 701     }
 702   //clean up
 703 //  free(leftXYZ);
 704 //  free(leftNormal);
 705 //  free(rightXYZ);
 706 //  free(rightNormal);
 707 #endif
 708 }
 709
 710
 711 void
 712 OpenGLSurfaceEvaluator::bgnqstrip(void)
 713 {
 714   if(output_triangles)
 715     bezierPatchMeshBeginStrip(global_bpm, GL_QUAD_STRIP);
 716   else
 717     glBegin((GLenum) GL_QUAD_STRIP);
 718
 719 #ifdef STATISTICS
 720         STAT_num_of_quad_strips++;
 721 #endif
 722 }
 723
 724 void
 725 OpenGLSurfaceEvaluator::endqstrip(void)
 726 {
 727   if(output_triangles)
 728     bezierPatchMeshEndStrip(global_bpm);
 729   else
 730     glEnd();
 731
 732 }
 733
 734 /*-------------------------------------------------------------------------
 735  * bgnmap2f - preamble to surface definition and evaluations
 736  *-------------------------------------------------------------------------
 737  */
 738 void
 739 OpenGLSurfaceEvaluator::bgnmap2f(long)
 740 {
 741   if(output_triangles)
 742     {
 743       /*deallocate the space which may has been
 744        *allocated by global_bpm previously
 745        */
 746       if(global_bpm != NULL) {
 747         bezierPatchMeshListDelete(global_bpm);
 748         global_bpm = NULL;
 749       }
 750
 751
 752       /*
 753         auto_normal_flag = 1; //always output normal in callback mode.
 754                               //we could have used the following code,
 755                               //but Inspector doesn't have gl context
 756                               //before it calls tessellator.
 757                               //this way is temporary.
 758         */
 759       //NEWCALLBACK
 760       //if one of the two normal callback functions are set,
 761       //then set
 762       if(normalCallBackN != NULL ||
 763          normalCallBackData != NULL)
 764         auto_normal_flag = 1;
 765       else
 766         auto_normal_flag = 0;
 767
 768       //initialize so that no maps initially
 769       vertex_flag = 0;
 770       normal_flag = 0;
 771       color_flag = 0;
 772       texcoord_flag = 0;
 773
 774       /*
 775       if(glIsEnabled(GL_AUTO_NORMAL) == GL_TRUE)
 776         auto_normal_flag = 1;
 777       else if (callback_auto_normal == 1)
 778         auto_normal_flag = 1;
 779       else
 780         auto_normal_flag = 0;
 781         */
 782           glPushAttrib((GLbitfield) GL_EVAL_BIT);
 783
 784     }
 785   else
 786     {
 787       glPushAttrib((GLbitfield) GL_EVAL_BIT);
 788
 789       /*to avoid side effect, we restor the opengl state for GL_POLYGON_MODE
 790        */
 791       glGetIntegerv(GL_POLYGON_MODE, gl_polygon_mode);
 792     }
 793
 794 }
 795
 796 /*-------------------------------------------------------------------------
 797  * endmap2f - postamble to a map
 798  *-------------------------------------------------------------------------
 799  */
 800 void
 801 OpenGLSurfaceEvaluator::endmap2f(void)
 802 {
 803
 804   if(output_triangles)
 805     {
 806       //bezierPatchMeshListDelDeg(global_bpm);
 807
 808       //    bezierPatchMeshListEval(global_bpm);
 809
 810       //surfcount++;
 811       //printf("surfcount=%i\n", surfcount);
 812       //if(surfcount == 8) exit(0);
 813
 814       inBPMListEvalEM(global_bpm);
 815
 816
 817
 818 /*
 819     global_bpm = bezierPatchMeshListReverse(global_bpm);
 820     {
 821       float *vertex_array;
 822       float *normal_array;
 823       int *length_array;
 824       int *type_array;
 825       int num_strips;
 826       bezierPatchMeshListCollect(global_bpm, &vertex_array, &normal_array, &length_array, &type_array, &num_strips);
 827       drawStrips(vertex_array, normal_array, length_array, type_array, num_strips);
 828       free(vertex_array);
 829       free(normal_array);
 830       free(length_array);
 831       free(type_array);
 832     }
 833 */
 834
 835     //bezierPatchMeshListPrint(global_bpm);
 836     //bezierPatchMeshListDraw(global_bpm);
 837
 838 //        printf("num triangles=%i\n", bezierPatchMeshListNumTriangles(global_bpm));
 839
 840 #ifdef USE_LOD
 841 #else
 842     bezierPatchMeshListDelete(global_bpm);
 843     global_bpm = NULL;
 844 #endif
 845         glPopAttrib();
 846   }
 847 else
 848   {
 849 #ifndef USE_LOD
 850     glPopAttrib();
 851 #endif
 852
 853 #ifdef STATISTICS
 854     fprintf(stderr, "num_vertices=%i,num_triangles=%i,num_quads_strips=%i\n", STAT_num_of_eval_vertices,STAT_num_of_triangles,STAT_num_of_quad_strips);
 855 #endif
 856
 857     /*to restore the gl_polygon_mode
 858      */
 859 #ifndef USE_LOD
 860     glPolygonMode( GL_FRONT, (GLenum) gl_polygon_mode[0]);
 861     glPolygonMode( GL_BACK,  (GLenum) gl_polygon_mode[1]);
 862 #endif
 863 }
 864
 865 }
 866
 867 /*-------------------------------------------------------------------------
 868  * map2f - pass a desription of a surface map
 869  *-------------------------------------------------------------------------
 870  */
 871 void
 872 OpenGLSurfaceEvaluator::map2f(
 873     long _type,
 874     REAL _ulower,       /* u lower domain coord         */
 875     REAL _uupper,       /* u upper domain coord         */
 876     long _ustride,      /* interpoint distance          */
 877     long _uorder,       /* parametric order             */
 878     REAL _vlower,       /* v lower domain coord         */
 879     REAL _vupper,       /* v upper domain coord         */
 880     long _vstride,      /* interpoint distance          */
 881     long _vorder,       /* parametric order             */
 882     REAL *pts)  /* control points               */
 883 {
 884 #ifdef USE_INTERNAL_EVAL
 885    inMap2f((int) _type, (REAL) _ulower, (REAL) _uupper,
 886             (int) _ustride, (int) _uorder, (REAL) _vlower,
 887             (REAL) _vupper, (int) _vstride, (int) _vorder,
 888             (REAL *) pts);
 889 #else
 890
 891
 892
 893    if(output_triangles)
 894      {
 895        if(global_bpm == NULL)
 896          global_bpm = bezierPatchMeshMake2(10,10);
 897        if(
 898           (global_bpm->bpatch == NULL &&
 899           (_type == GL_MAP2_VERTEX_3 || _type == GL_MAP2_VERTEX_4))
 900           ||
 901           (global_bpm->bpatch_normal == NULL &&
 902            (_type == GL_MAP2_NORMAL))
 903           ||
 904           (global_bpm->bpatch_color == NULL &&
 905            (_type == GL_MAP2_INDEX || _type == GL_MAP2_COLOR_4))
 906           ||
 907           (global_bpm->bpatch_texcoord == NULL &&
 908            (_type == GL_MAP2_TEXTURE_COORD_1 ||
 909             _type == GL_MAP2_TEXTURE_COORD_2 ||
 910             _type == GL_MAP2_TEXTURE_COORD_3 ||
 911             _type == GL_MAP2_TEXTURE_COORD_4 )
 912            ))
 913          {
 914            bezierPatchMeshPutPatch(global_bpm, (int) _type, _ulower, _uupper,(int)  _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
 915          }
 916        else /*new surface patch (with multiple maps) starts*/
 917          {
 918            bezierPatchMesh *temp = bezierPatchMeshMake2(10,10);
 919            bezierPatchMeshPutPatch(temp, (int) _type, _ulower, _uupper,(int)  _ustride,(int) _uorder,_vlower, _vupper, (int) _vstride, (int) _vorder, pts);
 920            global_bpm = bezierPatchMeshListInsert(global_bpm, temp);
 921
 922            /*
 923            global_bpm = bezierPatchMeshListInsert(global_bpm,
 924                                                   bezierPatchMeshMake(
 925                                                                       (int) _type, _ulower, _uupper,(int)  _ustride, (int) _uorder, _vlower, _vupper, (int) _vstride, (int) _vorder, pts, 10, 10));
 926            */
 927          }
 928      }
 929    else /*not output triangles*/
 930      {
 931        glMap2f((GLenum) _type, (GLfloat) _ulower, (GLfloat) _uupper,
 932                (GLint) _ustride, (GLint) _uorder, (GLfloat) _vlower,
 933                (GLfloat) _vupper, (GLint) _vstride, (GLint) _vorder,
 934                (const GLfloat *) pts);
 935      }
 936
 937 #endif
 938 }
 939
 940
 941 /*-------------------------------------------------------------------------
 942  * mapmesh2f - evaluate a mesh of points on lattice
 943  *-------------------------------------------------------------------------
 944  */
 945 void
 946 OpenGLSurfaceEvaluator::mapmesh2f(long style, long umin, long umax, long vmin, long vmax)
 947 {
 948 #ifdef NO_EVALUATION
 949 return;
 950 #endif
 951
 952 #ifdef USE_INTERNAL_EVAL
 953     inEvalMesh2((int)umin, (int)vmin, (int)umax, (int)vmax);
 954 #else
 955
 956
 957
 958 if(output_triangles)
 959 {
 960 #ifdef USE_LOD
 961   bezierPatchMeshBeginStrip(global_bpm, GL_POLYGON);
 962   bezierPatchMeshInsertUV(global_bpm, global_grid_u0, global_grid_v0);
 963   bezierPatchMeshInsertUV(global_bpm, global_grid_u1, global_grid_v1);
 964   bezierPatchMeshInsertUV(global_bpm, (REAL)global_grid_nu, (REAL)global_grid_nv);
 965   bezierPatchMeshInsertUV(global_bpm, (REAL)umin, (REAL)vmin);
 966   bezierPatchMeshInsertUV(global_bpm, (REAL)umax, (REAL)vmax);
 967   bezierPatchMeshEndStrip(global_bpm);
 968
 969 #else
 970
 971   REAL du, dv;
 972   long i,j;
 973   if(global_grid_nu == 0 || global_grid_nv == 0)
 974     return; /*no points need to be output*/
 975   du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
 976   dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
 977
 978   if(global_grid_nu >= global_grid_nv){
 979
 980     for(i=umin; i<umax; i++){
 981       REAL u1 = (i==global_grid_nu)? global_grid_u1:(global_grid_u0 + i*du);
 982       REAL u2 = ((i+1) == global_grid_nu)? global_grid_u1: (global_grid_u0+(i+1)*du);
 983
 984       bgnqstrip();
 985       for(j=vmax; j>=vmin; j--){
 986         REAL v1 = (j == global_grid_nv)? global_grid_v1: (global_grid_v0 +j*dv);
 987
 988         coord2f(u1, v1);
 989         coord2f(u2, v1);
 990       }
 991       endqstrip();
 992     }
 993   }
 994   else{
 995
 996     for(i=vmin; i<vmax; i++){
 997       REAL v1 = (i==global_grid_nv)? global_grid_v1:(global_grid_v0 + i*dv);
 998       REAL v2 = ((i+1) == global_grid_nv)? global_grid_v1: (global_grid_v0+(i+1)*dv);
 999
1000       bgnqstrip();
1001       for(j=umax; j>=umin; j--){
1002         REAL u1 = (j == global_grid_nu)? global_grid_u1: (global_grid_u0 +j*du);
1003         coord2f(u1, v2);
1004         coord2f(u1, v1);
1005       }
1006       endqstrip();
1007     }
1008   }
1009 #endif
1010 }
1011 else
1012 {
1013     switch(style) {
1014     default:
1015     case N_MESHFILL:
1016         glEvalMesh2((GLenum) GL_FILL, (GLint) umin, (GLint) umax,
1017                 (GLint) vmin, (GLint) vmax);
1018         break;
1019     case N_MESHLINE:
1020         glEvalMesh2((GLenum) GL_LINE, (GLint) umin, (GLint) umax,
1021                 (GLint) vmin, (GLint) vmax);
1022         break;
1023     case N_MESHPOINT:
1024         glEvalMesh2((GLenum) GL_POINT, (GLint) umin, (GLint) umax,
1025                 (GLint) vmin, (GLint) vmax);
1026         break;
1027     }
1028   }
1029
1030 #endif
1031
1032 #ifdef STATISTICS
1033         STAT_num_of_quad_strips += (umax-umin)*(vmax-vmin);
1034 #endif
1035 }
1036
1037 /*-------------------------------------------------------------------------
1038  * evalcoord2f - evaluate a point on a surface
1039  *-------------------------------------------------------------------------
1040  */
1041 void
1042 OpenGLSurfaceEvaluator::evalcoord2f(long, REAL u, REAL v)
1043 {
1044
1045
1046 #ifdef NO_EVALUATION
1047 return;
1048 #endif
1049
1050
1051     newtmeshvert(u, v);
1052 }
1053
1054 /*-------------------------------------------------------------------------
1055  * evalpoint2i - evaluate a grid point
1056  *-------------------------------------------------------------------------
1057  */
1058 void
1059 OpenGLSurfaceEvaluator::evalpoint2i(long u, long v)
1060 {
1061 #ifdef NO_EVALUATION
1062 return;
1063 #endif
1064
1065     newtmeshvert(u, v);
1066 }
1067
1068 void
1069 OpenGLSurfaceEvaluator::point2i( long u, long v )
1070 {
1071 #ifdef NO_EVALUATION
1072 return;
1073 #else
1074
1075 #ifdef USE_INTERNAL_EVAL
1076     inEvalPoint2( (int)u,  (int)v);
1077 #else
1078
1079
1080 if(output_triangles)
1081 {
1082
1083   REAL du, dv;
1084   REAL fu,fv;
1085   du = (global_grid_u1 - global_grid_u0) / (REAL)global_grid_nu;
1086   dv = (global_grid_v1 - global_grid_v0) / (REAL)global_grid_nv;
1087   fu = (u==global_grid_nu)? global_grid_u1:(global_grid_u0 + u*du);
1088   fv = (v == global_grid_nv)? global_grid_v1: (global_grid_v0 +v*dv);
1089   coord2f(fu,fv);
1090 }
1091 else
1092     glEvalPoint2((GLint) u, (GLint) v);
1093
1094
1095 #endif
1096
1097 #ifdef STATISTICS
1098   STAT_num_of_eval_vertices++;
1099 #endif
1100
1101 #endif
1102
1103 }
1104
1105 void
1106 OpenGLSurfaceEvaluator::coord2f( REAL u, REAL v )
1107 {
1108 #ifdef NO_EVALUATION
1109 return;
1110 #else
1111
1112 #ifdef USE_INTERNAL_EVAL
1113     inEvalCoord2f( u, v);
1114 #else
1115
1116
1117 if(output_triangles)
1118     bezierPatchMeshInsertUV(global_bpm, u,v);
1119 else
1120     glEvalCoord2f((GLfloat) u, (GLfloat) v);
1121
1122
1123 #endif
1124
1125
1126 #ifdef STATISTICS
1127   STAT_num_of_eval_vertices++;
1128 #endif
1129
1130 #endif
1131 }
1132
1133 void
1134 OpenGLSurfaceEvaluator::newtmeshvert( long u, long v )
1135 {
1136 #ifdef NO_EVALUATION
1137 return;
1138 #else
1139
1140     if (tmeshing) {
1141
1142         if (vcount == 2) {
1143             vertexCache[0]->invoke(this);
1144             vertexCache[1]->invoke(this);
1145             point2i( u,  v);
1146
1147         } else {
1148             vcount++;
1149         }
1150
1151         vertexCache[which]->saveEvalPoint(u, v);
1152         which = 1 - which;
1153     } else {
1154         point2i( u,  v);
1155     }
1156 #endif
1157 }
1158
1159 void
1160 OpenGLSurfaceEvaluator::newtmeshvert( REAL u, REAL v )
1161 {
1162 #ifdef NO_EVALUATION
1163 return;
1164 #else
1165     if (tmeshing) {
1166
1167
1168         if (vcount == 2) {
1169             vertexCache[0]->invoke(this);
1170             vertexCache[1]->invoke(this);
1171             coord2f(u,v);
1172
1173         } else {
1174             vcount++;
1175         }
1176
1177         vertexCache[which]->saveEvalCoord(u, v);
1178         which = 1 - which;
1179     } else {
1180
1181         coord2f( u,  v);
1182     }
1183 #endif
1184
1185 }
1186
1187 #ifdef _WIN32
1188 void OpenGLSurfaceEvaluator::putCallBack(GLenum which, void (GLAPIENTRY *fn)() )
1189 #else
1190 void OpenGLSurfaceEvaluator::putCallBack(GLenum which, _GLUfuncptr fn )
1191 #endif
1192 {
1193   switch(which)
1194     {
1195     case GLU_NURBS_BEGIN:
1196       beginCallBackN = (void (GLAPIENTRY *) (GLenum)) fn;
1197       break;
1198     case GLU_NURBS_END:
1199       endCallBackN = (void (GLAPIENTRY *) (void)) fn;
1200       break;
1201     case GLU_NURBS_VERTEX:
1202       vertexCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
1203       break;
1204     case GLU_NURBS_NORMAL:
1205       normalCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
1206       break;
1207     case GLU_NURBS_COLOR:
1208       colorCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
1209       break;
1210     case GLU_NURBS_TEXTURE_COORD:
1211       texcoordCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
1212       break;
1213     case GLU_NURBS_BEGIN_DATA:
1214       beginCallBackData = (void (GLAPIENTRY *) (GLenum, void*)) fn;
1215       break;
1216     case GLU_NURBS_END_DATA:
1217       endCallBackData = (void (GLAPIENTRY *) (void*)) fn;
1218       break;
1219     case GLU_NURBS_VERTEX_DATA:
1220       vertexCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
1221       break;
1222     case GLU_NURBS_NORMAL_DATA:
1223       normalCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
1224       break;
1225     case GLU_NURBS_COLOR_DATA:
1226       colorCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
1227       break;
1228     case GLU_NURBS_TEXTURE_COORD_DATA:
1229       texcoordCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
1230       break;
1231
1232     }
1233 }
1234
1235
1236 void
1237 OpenGLSurfaceEvaluator::beginCallBack(GLenum which, void *data)
1238 {
1239   if(beginCallBackData)
1240     beginCallBackData(which, data);
1241   else if(beginCallBackN)
1242     beginCallBackN(which);
1243 }
1244
1245 void
1246 OpenGLSurfaceEvaluator::endCallBack(void *data)
1247 {
1248   if(endCallBackData)
1249     endCallBackData(data);
1250   else if(endCallBackN)
1251     endCallBackN();
1252 }
1253
1254 void
1255 OpenGLSurfaceEvaluator::vertexCallBack(const GLfloat *vert, void* data)
1256 {
1257   if(vertexCallBackData)
1258     vertexCallBackData(vert, data);
1259   else if(vertexCallBackN)
1260     vertexCallBackN(vert);
1261 }
1262
1263
1264 void
1265 OpenGLSurfaceEvaluator::normalCallBack(const GLfloat *normal, void* data)
1266 {
1267   if(normalCallBackData)
1268     normalCallBackData(normal, data);
1269   else if(normalCallBackN)
1270     normalCallBackN(normal);
1271 }
1272
1273 void
1274 OpenGLSurfaceEvaluator::colorCallBack(const GLfloat *color, void* data)
1275 {
1276   if(colorCallBackData)
1277     colorCallBackData(color, data);
1278   else if(colorCallBackN)
1279     colorCallBackN(color);
1280 }
1281
1282 void
1283 OpenGLSurfaceEvaluator::texcoordCallBack(const GLfloat *texcoord, void* data)
1284 {
1285   if(texcoordCallBackData)
1286     texcoordCallBackData(texcoord, data);
1287   else if(texcoordCallBackN)
1288     texcoordCallBackN(texcoord);
1289 }
1290
1291
1292
1293