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