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 */ 37 38 #include "gluos.h" 39 #include <GL/gl.h> 40 #include <GL/glu.h> 41 #include <stdio.h> 42 #include "glimports.h" 43 #include "glrenderer.h" 44 #include "nurbsconsts.h" 45 46 //#define DOWN_LOAD_NURBS 47 #ifdef DOWN_LOAD_NURBS 48 49 #include "oglTrimNurbs.h" 50 static int surfcount = 0; 51 static oglTrimNurbs* otn = NULL; 52 nurbSurf* tempNurb = NULL; 53 oglTrimLoops* tempTrim = NULL; 54 #endif 55 56 57 //for LOD 58 extern "C" {void glu_LOD_eval_list(GLUnurbs *nurb, int level);} 59 60 void glu_LOD_eval_list(GLUnurbs *nurb, int level) 61 { 62 nurb->LOD_eval_list(level); 63 } 64 65 GLUnurbs * GLAPIENTRY 66 gluNewNurbsRenderer(void) 67 { 68 GLUnurbs *t; 69 70 t = new GLUnurbs(); 71 return t; 72 } 73 74 void GLAPIENTRY 75 gluDeleteNurbsRenderer(GLUnurbs *r) 76 { 77 delete r; 78 } 79 80 extern "C" 81 void GLAPIENTRY 82 83 gluDeleteNurbsTessellatorEXT(GLUnurbsObj *r) 84 { 85 delete r; 86 } 87 88 void GLAPIENTRY 89 gluBeginSurface(GLUnurbs *r) 90 { 91 #ifdef DOWN_LOAD_NURBS 92 surfcount++; 93 tempTrim = OTL_make(10,10); 94 #endif 95 r->bgnsurface(0); 96 } 97 98 void GLAPIENTRY 99 gluBeginCurve(GLUnurbs *r) 100 { 101 r->bgncurve(0); 102 } 103 104 void GLAPIENTRY 105 gluEndCurve(GLUnurbs *r) 106 { 107 r->endcurve(); 108 } 109 110 void GLAPIENTRY 111 gluEndSurface(GLUnurbs *r) 112 { 113 #ifdef DOWN_LOAD_NURBS 114 if(surfcount == 1) 115 otn = OTN_make(1); 116 OTN_insert(otn, tempNurb, tempTrim); 117 if(surfcount >= 1) 118 { 119 #ifdef DEBUG 120 printf("write file\n"); 121 #endif 122 OTN_write(otn, "out.otn"); 123 124 } 125 #endif 126 127 r->endsurface(); 128 } 129 130 void GLAPIENTRY 131 gluBeginTrim(GLUnurbs *r) 132 { 133 #ifdef DOWN_LOAD_NURBS 134 OTL_bgnTrim(tempTrim); 135 #endif 136 137 r->bgntrim(); 138 } 139 140 void GLAPIENTRY 141 gluEndTrim(GLUnurbs *r) 142 { 143 #ifdef DOWN_LOAD_NURBS 144 OTL_endTrim(tempTrim); 145 #endif 146 r->endtrim(); 147 } 148 149 void GLAPIENTRY 150 gluPwlCurve(GLUnurbs *r, GLint count, INREAL array[], 151 GLint stride, GLenum type) 152 { 153 #ifdef DOWN_LOAD_NURBS 154 OTL_pwlCurve(tempTrim, count, array, stride, type); 155 #endif 156 157 int realType; 158 switch(type) { 159 case GLU_MAP1_TRIM_2: 160 realType = N_P2D; 161 break; 162 case GLU_MAP1_TRIM_3: 163 realType = N_P2DR; 164 break; 165 default: 166 realType = type; 167 break; 168 } 169 r->pwlcurve(count, array, sizeof(INREAL) * stride, realType); 170 } 171 172 void GLAPIENTRY 173 gluNurbsCurve(GLUnurbs *r, GLint nknots, INREAL knot[], GLint stride, 174 INREAL ctlarray[], GLint order, GLenum type) 175 { 176 #ifdef DOWN_LOAD_NURBS 177 OTL_nurbsCurve(tempTrim, nknots, knot, stride, ctlarray, order, type); 178 #endif 179 180 int realType; 181 182 switch(type) { 183 case GLU_MAP1_TRIM_2: 184 realType = N_P2D; 185 break; 186 case GLU_MAP1_TRIM_3: 187 realType = N_P2DR; 188 break; 189 default: 190 realType = type; 191 break; 192 } 193 194 r->nurbscurve(nknots, knot, sizeof(INREAL) * stride, ctlarray, order, 195 realType); 196 } 197 198 void GLAPIENTRY 199 gluNurbsSurface(GLUnurbs *r, GLint sknot_count, GLfloat *sknot, 200 GLint tknot_count, GLfloat *tknot, 201 GLint s_stride, GLint t_stride, 202 GLfloat *ctlarray, GLint sorder, GLint torder, 203 GLenum type) 204 { 205 #ifdef DOWN_LOAD_NURBS 206 { 207 int dimension; 208 switch(type){ 209 case GL_MAP2_VERTEX_3: 210 dimension = 3; 211 break; 212 case GL_MAP2_VERTEX_4: 213 dimension = 4; 214 break; 215 default: 216 fprintf(stderr, "error in glinterface.c++, type no implemented\n"); 217 exit(1); 218 } 219 tempNurb = nurbSurfMake(sknot_count, sknot, 220 tknot_count, tknot, 221 sorder, torder, 222 dimension, 223 ctlarray, 224 s_stride, t_stride); 225 226 } 227 #endif 228 229 r->nurbssurface(sknot_count, sknot, tknot_count, tknot, 230 sizeof(INREAL) * s_stride, sizeof(INREAL) * t_stride, 231 ctlarray, sorder, torder, type); 232 } 233 234 void GLAPIENTRY 235 gluLoadSamplingMatrices(GLUnurbs *r, const GLfloat modelMatrix[16], 236 const GLfloat projMatrix[16], 237 const GLint viewport[4]) 238 { 239 r->useGLMatrices(modelMatrix, projMatrix, viewport); 240 } 241 242 void GLAPIENTRY 243 gluNurbsProperty(GLUnurbs *r, GLenum property, GLfloat value) 244 { 245 GLfloat nurbsValue; 246 247 switch (property) { 248 case GLU_AUTO_LOAD_MATRIX: 249 r->setautoloadmode(value); 250 return; 251 252 case GLU_CULLING: 253 if (value != 0.0) { 254 nurbsValue = N_CULLINGON; 255 } else { 256 nurbsValue = N_NOCULLING; 257 } 258 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, nurbsValue); 259 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLING, nurbsValue); 260 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLING, nurbsValue); 261 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLING, nurbsValue); 262 return; 263 264 case GLU_SAMPLING_METHOD: 265 if (value == GLU_PATH_LENGTH) { 266 nurbsValue = N_PATHLENGTH; 267 } else if (value == GLU_PARAMETRIC_ERROR) { 268 nurbsValue = N_PARAMETRICDISTANCE; 269 } else if (value == GLU_DOMAIN_DISTANCE) { 270 nurbsValue = N_DOMAINDISTANCE; 271 r->set_is_domain_distance_sampling(1); //optimzing untrimmed case 272 273 } else if (value == GLU_OBJECT_PARAMETRIC_ERROR) { 274 nurbsValue = N_OBJECTSPACE_PARA; 275 r->setautoloadmode( 0.0 ); 276 r->setSamplingMatrixIdentity(); 277 } else if (value == GLU_OBJECT_PATH_LENGTH) { 278 nurbsValue = N_OBJECTSPACE_PATH; 279 r->setautoloadmode( 0.0 ); 280 r->setSamplingMatrixIdentity(); 281 } else { 282 r->postError(GLU_INVALID_VALUE); 283 return; 284 } 285 286 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue); 287 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue); 288 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue); 289 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue); 290 return; 291 292 case GLU_SAMPLING_TOLERANCE: 293 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value); 294 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, value); 295 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, value); 296 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, value); 297 return; 298 299 case GLU_PARAMETRIC_TOLERANCE: 300 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value); 301 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, value); 302 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, value); 303 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, value); 304 return; 305 306 307 case GLU_DISPLAY_MODE: 308 309 if (value == GLU_FILL) { 310 nurbsValue = N_FILL; 311 } else if (value == GLU_OUTLINE_POLYGON) { 312 nurbsValue = N_OUTLINE_POLY; 313 } else if (value == GLU_OUTLINE_PATCH) { 314 nurbsValue = N_OUTLINE_PATCH; 315 } else { 316 r->postError(GLU_INVALID_VALUE); 317 return; 318 } 319 r->setnurbsproperty(N_DISPLAY, nurbsValue); 320 321 break; 322 323 case GLU_U_STEP: 324 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, value); 325 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, value); 326 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value); 327 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, value); 328 329 //added for optimizing untrimmed case 330 r->set_domain_distance_u_rate(value); 331 break; 332 333 case GLU_V_STEP: 334 r->setnurbsproperty(GL_MAP1_VERTEX_3, N_T_STEPS, value); 335 r->setnurbsproperty(GL_MAP1_VERTEX_4, N_T_STEPS, value); 336 r->setnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value); 337 r->setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, value); 338 339 //added for optimizing untrimmed case 340 r->set_domain_distance_v_rate(value); 341 break; 342 343 case GLU_NURBS_MODE: 344 if(value == GLU_NURBS_RENDERER) 345 r->put_callbackFlag(0); 346 else if(value == GLU_NURBS_TESSELLATOR) 347 r->put_callbackFlag(1); 348 else 349 r->postError(GLU_INVALID_ENUM); 350 break; 351 352 default: 353 r->postError(GLU_INVALID_ENUM); 354 return; 355 } 356 } 357 358 void GLAPIENTRY 359 gluGetNurbsProperty(GLUnurbs *r, GLenum property, GLfloat *value) 360 { 361 GLfloat nurbsValue; 362 363 switch(property) { 364 case GLU_AUTO_LOAD_MATRIX: 365 if (r->getautoloadmode()) { 366 *value = GL_TRUE; 367 } else { 368 *value = GL_FALSE; 369 } 370 break; 371 case GLU_CULLING: 372 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, &nurbsValue); 373 if (nurbsValue == N_CULLINGON) { 374 *value = GL_TRUE; 375 } else { 376 *value = GL_FALSE; 377 } 378 break; 379 case GLU_SAMPLING_METHOD: 380 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, value); 381 if(*value == N_PATHLENGTH) 382 *value = GLU_PATH_LENGTH; 383 else if(*value == N_PARAMETRICDISTANCE) 384 *value = GLU_PARAMETRIC_ERROR; 385 else if(*value == N_DOMAINDISTANCE) 386 *value = GLU_DOMAIN_DISTANCE; 387 else if(*value == N_OBJECTSPACE_PATH) 388 *value = GLU_OBJECT_PATH_LENGTH; 389 else if(*value == N_OBJECTSPACE_PARA) 390 *value = GLU_OBJECT_PARAMETRIC_ERROR; 391 break; 392 case GLU_SAMPLING_TOLERANCE: 393 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value); 394 break; 395 case GLU_PARAMETRIC_TOLERANCE: 396 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value); 397 break; 398 399 case GLU_U_STEP: 400 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value); 401 break; 402 case GLU_V_STEP: 403 r->getnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value); 404 break; 405 case GLU_DISPLAY_MODE: 406 r->getnurbsproperty(N_DISPLAY, &nurbsValue); 407 if (nurbsValue == N_FILL) { 408 *value = GLU_FILL; 409 } else if (nurbsValue == N_OUTLINE_POLY) { 410 *value = GLU_OUTLINE_POLYGON; 411 } else { 412 *value = GLU_OUTLINE_PATCH; 413 } 414 break; 415 416 case GLU_NURBS_MODE: 417 if(r->is_callback()) 418 *value = GLU_NURBS_TESSELLATOR; 419 else 420 *value = GLU_NURBS_RENDERER; 421 break; 422 423 default: 424 r->postError(GLU_INVALID_ENUM); 425 return; 426 } 427 } 428 429 extern "C" void GLAPIENTRY 430 gluNurbsCallback(GLUnurbs *r, GLenum which, _GLUfuncptr fn ) 431 { 432 switch (which) { 433 case GLU_NURBS_BEGIN: 434 case GLU_NURBS_END: 435 case GLU_NURBS_VERTEX: 436 case GLU_NURBS_NORMAL: 437 case GLU_NURBS_TEXTURE_COORD: 438 case GLU_NURBS_COLOR: 439 case GLU_NURBS_BEGIN_DATA: 440 case GLU_NURBS_END_DATA: 441 case GLU_NURBS_VERTEX_DATA: 442 case GLU_NURBS_NORMAL_DATA: 443 case GLU_NURBS_TEXTURE_COORD_DATA: 444 case GLU_NURBS_COLOR_DATA: 445 r->putSurfCallBack(which, fn); 446 break; 447 448 case GLU_NURBS_ERROR: 449 r->errorCallback = (void (APIENTRY *)( GLenum e )) fn; 450 break; 451 default: 452 r->postError(GLU_INVALID_ENUM); 453 return; 454 } 455 } 456 457 extern "C" 458 void GLAPIENTRY 459 gluNurbsCallbackDataEXT(GLUnurbs* r, void* userData) 460 { 461 r->setNurbsCallbackData(userData); 462 } 463 464 extern "C" 465 void GLAPIENTRY 466 gluNurbsCallbackData(GLUnurbs* r, void* userData) 467 { 468 gluNurbsCallbackDataEXT(r,userData); 469 } 470
Indexes created Tue Jul 21 00:24:56 UTC 2026