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 1294
Indexes created Tue Jul 28 00:24:17 UTC 2026