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 * backend.c++ 37 * 38 */ 39 40 /* Bezier surface backend 41 - interprets display mode (wireframe,shaded,...) 42 */ 43 #include <stdio.h> 44 #include "glimports.h" 45 #include "mystdio.h" 46 #include "backend.h" 47 #include "basiccrveval.h" 48 #include "basicsurfeval.h" 49 50 #define NOWIREFRAME 51 52 53 /*------------------------------------------------------------------------- 54 * bgnsurf - preamble to surface definition and evaluations 55 *------------------------------------------------------------------------- 56 */ 57 void 58 Backend::bgnsurf( int wiretris, int wirequads, long nuid ) 59 { 60 /*#ifndef NOWIREFRAME*/ //need this for old version 61 wireframetris = wiretris; 62 wireframequads = wirequads; 63 /*#endif*/ 64 65 /*in the spec, GLU_DISPLAY_MODE is either 66 * GLU_FILL 67 * GLU_OUTLINE_POLY 68 * GLU_OUTLINE_PATCH. 69 *In fact, GLU_FLL is has the same effect as 70 * set GL_FRONT_AND_BACK to be GL_FILL 71 * and GLU_OUTLINE_POLY is the same as set 72 * GL_FRONT_AND_BACK to be GL_LINE 73 *It is more efficient to do this once at the beginning of 74 *each surface than to do it for each primitive. 75 * The internal has more options: outline_triangle and outline_quad 76 *can be seperated. But since this is not in spec, and more importantly, 77 *this is not so useful, so we don't need to keep this option. 78 */ 79 80 surfaceEvaluator.bgnmap2f( nuid ); 81 82 if(wiretris) 83 surfaceEvaluator.polymode(N_MESHLINE); 84 else 85 surfaceEvaluator.polymode(N_MESHFILL); 86 } 87 88 void 89 Backend::patch( REAL ulo, REAL uhi, REAL vlo, REAL vhi ) 90 { 91 surfaceEvaluator.domain2f( ulo, uhi, vlo, vhi ); 92 } 93 94 void 95 Backend::surfbbox( long type, REAL *from, REAL *to ) 96 { 97 surfaceEvaluator.range2f( type, from, to ); 98 } 99 100 /*------------------------------------------------------------------------- 101 * surfpts - pass a desription of a surface map 102 *------------------------------------------------------------------------- 103 */ 104 void 105 Backend::surfpts( 106 long type, /* geometry, color, texture, normal */ 107 REAL *pts, /* control points */ 108 long ustride, /* distance to next point in u direction */ 109 long vstride, /* distance to next point in v direction */ 110 int uorder, /* u parametric order */ 111 int vorder, /* v parametric order */ 112 REAL ulo, /* u lower bound */ 113 REAL uhi, /* u upper bound */ 114 REAL vlo, /* v lower bound */ 115 REAL vhi ) /* v upper bound */ 116 { 117 surfaceEvaluator.map2f( type,ulo,uhi,ustride,uorder,vlo,vhi,vstride,vorder,pts ); 118 surfaceEvaluator.enable( type ); 119 } 120 121 /*------------------------------------------------------------------------- 122 * surfgrid - define a lattice of points with origin and offset 123 *------------------------------------------------------------------------- 124 */ 125 void 126 Backend::surfgrid( REAL u0, REAL u1, long nu, REAL v0, REAL v1, long nv ) 127 { 128 surfaceEvaluator.mapgrid2f( nu, u0, u1, nv, v0, v1 ); 129 } 130 131 /*------------------------------------------------------------------------- 132 * surfmesh - evaluate a mesh of points on lattice 133 *------------------------------------------------------------------------- 134 */ 135 void 136 Backend::surfmesh( long u, long v, long n, long m ) 137 { 138 #ifndef NOWIREFRAME 139 if( wireframequads ) { 140 long v0, v1; 141 long u0f = u, u1f = u+n; 142 long v0f = v, v1f = v+m; 143 long parity = (u & 1); 144 145 for( v0 = v0f, v1 = v0f++ ; v0<v1f; v0 = v1, v1++ ) { 146 surfaceEvaluator.bgnline(); 147 for( long u = u0f; u<=u1f; u++ ) { 148 if( parity ) { 149 surfaceEvaluator.evalpoint2i( u, v0 ); 150 surfaceEvaluator.evalpoint2i( u, v1 ); 151 } else { 152 surfaceEvaluator.evalpoint2i( u, v1 ); 153 surfaceEvaluator.evalpoint2i( u, v0 ); 154 } 155 parity = 1 - parity; 156 } 157 surfaceEvaluator.endline(); 158 } 159 } else { 160 surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m ); 161 } 162 #else 163 if( wireframequads ) { 164 165 surfaceEvaluator.mapmesh2f( N_MESHLINE, u, u+n, v, v+m ); 166 } else { 167 168 surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m ); 169 } 170 #endif 171 } 172 173 /*------------------------------------------------------------------------- 174 * endsurf - postamble to surface 175 *------------------------------------------------------------------------- 176 */ 177 void 178 Backend::endsurf( void ) 179 { 180 surfaceEvaluator.endmap2f(); 181 } 182 183 /***************************************/ 184 void 185 Backend::bgntfan( void ) 186 { 187 surfaceEvaluator.bgntfan(); 188 /* 189 if(wireframetris) 190 surfaceEvaluator.polymode( N_MESHLINE ); 191 else 192 surfaceEvaluator.polymode( N_MESHFILL ); 193 */ 194 } 195 196 void 197 Backend::endtfan( void ) 198 { 199 surfaceEvaluator.endtfan(); 200 } 201 202 void 203 Backend::bgnqstrip( void ) 204 { 205 surfaceEvaluator.bgnqstrip(); 206 /* 207 if(wireframequads) 208 surfaceEvaluator.polymode( N_MESHLINE ); 209 else 210 surfaceEvaluator.polymode( N_MESHFILL ); 211 */ 212 } 213 214 void 215 Backend::endqstrip( void ) 216 { 217 surfaceEvaluator.endqstrip(); 218 } 219 220 void 221 Backend::evalUStrip(int n_upper, REAL v_upper, REAL* upper_val, 222 int n_lower, REAL v_lower, REAL* lower_val 223 ) 224 { 225 surfaceEvaluator.evalUStrip(n_upper, v_upper, upper_val, 226 n_lower, v_lower, lower_val); 227 } 228 229 void 230 Backend::evalVStrip(int n_left, REAL u_left, REAL* left_val, 231 int n_right, REAL u_right, REAL* right_val 232 ) 233 { 234 surfaceEvaluator.evalVStrip(n_left, u_left, left_val, 235 n_right, u_right, right_val); 236 } 237 238 /***************************************/ 239 240 241 /*------------------------------------------------------------------------- 242 * bgntmesh - preamble to a triangle mesh 243 *------------------------------------------------------------------------- 244 */ 245 void 246 Backend::bgntmesh( const char * ) 247 { 248 #ifndef NOWIREFRAME 249 250 meshindex = 0; /* I think these need to be initialized to zero */ 251 npts = 0; 252 253 if( !wireframetris ) { 254 surfaceEvaluator.bgntmesh(); 255 } 256 #else 257 258 if( wireframetris ) { 259 surfaceEvaluator.bgntmesh(); 260 surfaceEvaluator.polymode( N_MESHLINE ); 261 } else { 262 surfaceEvaluator.bgntmesh(); 263 surfaceEvaluator.polymode( N_MESHFILL ); 264 } 265 #endif 266 } 267 268 void 269 Backend::tmeshvert( GridTrimVertex *v ) 270 { 271 if( v->isGridVert() ) { 272 tmeshvert( v->g ); 273 } else { 274 tmeshvert( v->t ); 275 } 276 } 277 278 void 279 Backend::tmeshvertNOGE(TrimVertex *t) 280 { 281 // surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], temp, ttt); 282 #ifdef USE_OPTTT 283 surfaceEvaluator.inDoEvalCoord2NOGE( t->param[0], t->param[1], t->cache_point, t->cache_normal); 284 #endif 285 } 286 287 //opt for a line with the same u. 288 void 289 Backend::tmeshvertNOGE_BU(TrimVertex *t) 290 { 291 #ifdef USE_OPTTT 292 surfaceEvaluator.inDoEvalCoord2NOGE_BU( t->param[0], t->param[1], t->cache_point, t->cache_normal); 293 #endif 294 } 295 296 //opt for a line with the same v. 297 void 298 Backend::tmeshvertNOGE_BV(TrimVertex *t) 299 { 300 #ifdef USE_OPTTT 301 surfaceEvaluator.inDoEvalCoord2NOGE_BV( t->param[0], t->param[1], t->cache_point, t->cache_normal); 302 #endif 303 } 304 305 void 306 Backend::preEvaluateBU(REAL u) 307 { 308 surfaceEvaluator.inPreEvaluateBU_intfac(u); 309 } 310 311 void 312 Backend::preEvaluateBV(REAL v) 313 { 314 surfaceEvaluator.inPreEvaluateBV_intfac(v); 315 } 316 317 318 /*------------------------------------------------------------------------- 319 * tmeshvert - evaluate a point on a triangle mesh 320 *------------------------------------------------------------------------- 321 */ 322 void 323 Backend::tmeshvert( TrimVertex *t ) 324 { 325 326 #ifndef NOWIREFRAME 327 const long nuid = t->nuid; 328 #endif 329 const REAL u = t->param[0]; 330 const REAL v = t->param[1]; 331 332 #ifndef NOWIREFRAME 333 npts++; 334 if( wireframetris ) { 335 if( npts >= 3 ) { 336 surfaceEvaluator.bgnclosedline(); 337 if( mesh[0][2] == 0 ) 338 surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] ); 339 else 340 surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); 341 if( mesh[1][2] == 0 ) 342 surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] ); 343 else 344 surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); 345 surfaceEvaluator.evalcoord2f( nuid, u, v ); 346 surfaceEvaluator.endclosedline(); 347 } 348 mesh[meshindex][0] = u; 349 mesh[meshindex][1] = v; 350 mesh[meshindex][2] = 0; 351 mesh[meshindex][3] = nuid; 352 meshindex = (meshindex+1) % 2; 353 } else { 354 surfaceEvaluator.evalcoord2f( nuid, u, v ); 355 } 356 #else 357 358 surfaceEvaluator.evalcoord2f( 0, u, v ); 359 //for uninitial memory read surfaceEvaluator.evalcoord2f( nuid, u, v ); 360 #endif 361 } 362 363 //the same as tmeshvert(trimvertex), for efficiency purpose 364 void 365 Backend::tmeshvert( REAL u, REAL v ) 366 { 367 #ifndef NOWIREFRAME 368 const long nuid = 0; 369 370 npts++; 371 if( wireframetris ) { 372 if( npts >= 3 ) { 373 surfaceEvaluator.bgnclosedline(); 374 if( mesh[0][2] == 0 ) 375 surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] ); 376 else 377 surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); 378 if( mesh[1][2] == 0 ) 379 surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] ); 380 else 381 surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); 382 surfaceEvaluator.evalcoord2f( nuid, u, v ); 383 surfaceEvaluator.endclosedline(); 384 } 385 mesh[meshindex][0] = u; 386 mesh[meshindex][1] = v; 387 mesh[meshindex][2] = 0; 388 mesh[meshindex][3] = nuid; 389 meshindex = (meshindex+1) % 2; 390 } else { 391 surfaceEvaluator.evalcoord2f( nuid, u, v ); 392 } 393 #else 394 395 surfaceEvaluator.evalcoord2f( 0, u, v ); 396 #endif 397 } 398 399 /*------------------------------------------------------------------------- 400 * tmeshvert - evaluate a grid point of a triangle mesh 401 *------------------------------------------------------------------------- 402 */ 403 void 404 Backend::tmeshvert( GridVertex *g ) 405 { 406 const long u = g->gparam[0]; 407 const long v = g->gparam[1]; 408 409 #ifndef NOWIREFRAME 410 npts++; 411 if( wireframetris ) { 412 if( npts >= 3 ) { 413 surfaceEvaluator.bgnclosedline(); 414 if( mesh[0][2] == 0 ) 415 surfaceEvaluator.evalcoord2f( (long) mesh[0][3], mesh[0][0], mesh[0][1] ); 416 else 417 surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); 418 if( mesh[1][2] == 0 ) 419 surfaceEvaluator.evalcoord2f( (long) mesh[1][3], mesh[1][0], mesh[1][1] ); 420 else 421 surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); 422 surfaceEvaluator.evalpoint2i( u, v ); 423 surfaceEvaluator.endclosedline(); 424 } 425 mesh[meshindex][0] = u; 426 mesh[meshindex][1] = v; 427 mesh[meshindex][2] = 1; 428 meshindex = (meshindex+1) % 2; 429 } else { 430 surfaceEvaluator.evalpoint2i( u, v ); 431 } 432 #else 433 surfaceEvaluator.evalpoint2i( u, v ); 434 #endif 435 } 436 437 /*------------------------------------------------------------------------- 438 * swaptmesh - perform a swap of the triangle mesh pointers 439 *------------------------------------------------------------------------- 440 */ 441 void 442 Backend::swaptmesh( void ) 443 { 444 #ifndef NOWIREFRAME 445 if( wireframetris ) { 446 meshindex = 1 - meshindex; 447 } else { 448 surfaceEvaluator.swaptmesh(); 449 } 450 #else 451 surfaceEvaluator.swaptmesh(); 452 #endif 453 } 454 455 /*------------------------------------------------------------------------- 456 * endtmesh - postamble to triangle mesh 457 *------------------------------------------------------------------------- 458 */ 459 void 460 Backend::endtmesh( void ) 461 { 462 #ifndef NOWIREFRAME 463 if( ! wireframetris ) 464 surfaceEvaluator.endtmesh(); 465 #else 466 surfaceEvaluator.endtmesh(); 467 /* surfaceEvaluator.polymode( N_MESHFILL );*/ 468 #endif 469 } 470 471 472 /*------------------------------------------------------------------------- 473 * bgnoutline - preamble to outlined rendering 474 *------------------------------------------------------------------------- 475 */ 476 void 477 Backend::bgnoutline( void ) 478 { 479 surfaceEvaluator.bgnline(); 480 } 481 482 /*------------------------------------------------------------------------- 483 * linevert - evaluate a point on an outlined contour 484 *------------------------------------------------------------------------- 485 */ 486 void 487 Backend::linevert( TrimVertex *t ) 488 { 489 surfaceEvaluator.evalcoord2f( t->nuid, t->param[0], t->param[1] ); 490 } 491 492 /*------------------------------------------------------------------------- 493 * linevert - evaluate a grid point of an outlined contour 494 *------------------------------------------------------------------------- 495 */ 496 void 497 Backend::linevert( GridVertex *g ) 498 { 499 surfaceEvaluator.evalpoint2i( g->gparam[0], g->gparam[1] ); 500 } 501 502 /*------------------------------------------------------------------------- 503 * endoutline - postamble to outlined rendering 504 *------------------------------------------------------------------------- 505 */ 506 void 507 Backend::endoutline( void ) 508 { 509 surfaceEvaluator.endline(); 510 } 511 512 /*------------------------------------------------------------------------- 513 * triangle - output a triangle 514 *------------------------------------------------------------------------- 515 */ 516 void 517 Backend::triangle( TrimVertex *a, TrimVertex *b, TrimVertex *c ) 518 { 519 /* bgntmesh( "spittriangle" );*/ 520 bgntfan(); 521 tmeshvert( a ); 522 tmeshvert( b ); 523 tmeshvert( c ); 524 endtfan(); 525 /* endtmesh();*/ 526 } 527 528 void 529 Backend::bgncurv( void ) 530 { 531 curveEvaluator.bgnmap1f( 0 ); 532 } 533 534 void 535 Backend::segment( REAL ulo, REAL uhi ) 536 { 537 curveEvaluator.domain1f( ulo, uhi ); 538 } 539 540 void 541 Backend::curvpts( 542 long type, /* geometry, color, texture, normal */ 543 REAL *pts, /* control points */ 544 long stride, /* distance to next point */ 545 int order, /* parametric order */ 546 REAL ulo, /* lower parametric bound */ 547 REAL uhi ) /* upper parametric bound */ 548 549 { 550 curveEvaluator.map1f( type, ulo, uhi, stride, order, pts ); 551 curveEvaluator.enable( type ); 552 } 553 554 void 555 Backend::curvgrid( REAL u0, REAL u1, long nu ) 556 { 557 curveEvaluator.mapgrid1f( nu, u0, u1 ); 558 } 559 560 void 561 Backend::curvmesh( long from, long n ) 562 { 563 curveEvaluator.mapmesh1f( N_MESHFILL, from, from+n ); 564 } 565 566 void 567 Backend::curvpt(REAL u) 568 { 569 curveEvaluator.evalcoord1f( 0, u ); 570 } 571 572 void 573 Backend::bgnline( void ) 574 { 575 curveEvaluator.bgnline(); 576 } 577 578 void 579 Backend::endline( void ) 580 { 581 curveEvaluator.endline(); 582 } 583 584 void 585 Backend::endcurv( void ) 586 { 587 curveEvaluator.endmap1f(); 588 } 589
Indexes created Sun Jul 26 00:24:00 UTC 2026