src/glu/sgi/libnurbs/interface/glcurveval.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  * glcurveval.c++
  37  *
  38  */
  39
  40 /* Polynomial Evaluator Interface */
  41
  42 #include "gluos.h"
  43 #include "glimports.h"
  44 #include "glrenderer.h"
  45 #include "glcurveval.h"
  46 #include "nurbsconsts.h"
  47
  48 OpenGLCurveEvaluator::OpenGLCurveEvaluator(void)
  49 {
  50   //no default callback functions
  51   beginCallBackN = NULL;
  52   endCallBackN = NULL;
  53   vertexCallBackN = NULL;
  54   normalCallBackN = NULL;
  55   colorCallBackN = NULL;
  56   texcoordCallBackN = NULL;
  57   beginCallBackData = NULL;
  58   endCallBackData = NULL;
  59   vertexCallBackData = NULL;
  60   normalCallBackData = NULL;
  61   colorCallBackData = NULL;
  62   texcoordCallBackData = NULL;
  63
  64   userData = NULL;
  65
  66   vertex_flag = 0;
  67   normal_flag = 0;
  68   color_flag = 0;
  69   texcoord_flag = 0;
  70
  71   em_vertex.uprime = -1.0;
  72   em_normal.uprime = -1.0;
  73   em_color.uprime = -1.0;
  74   em_texcoord.uprime = -1.0;
  75   output_triangles = 0; // don't output triangles by default
  76 }
  77
  78 OpenGLCurveEvaluator::~OpenGLCurveEvaluator(void)
  79 {
  80 }
  81
  82 /* added nonsense to avoid the warning messages at compile time */
  83 void
  84 OpenGLCurveEvaluator::addMap(CurveMap *m)
  85 {
  86         m = m;
  87 }
  88
  89 void
  90 OpenGLCurveEvaluator::range1f(long type, REAL *from, REAL *to)
  91 {
  92         type = type;
  93         from = from;
  94         to = to;
  95 }
  96
  97 void
  98 OpenGLCurveEvaluator::domain1f(REAL ulo, REAL uhi)
  99 {
 100         ulo = ulo;
 101         uhi = uhi;
 102 }
 103
 104 void
 105 OpenGLCurveEvaluator::bgnline(void)
 106 {
 107   if(output_triangles)
 108     beginCallBack(GL_LINE_STRIP, userData);
 109   else
 110     glBegin((GLenum) GL_LINE_STRIP);
 111 }
 112
 113 void
 114 OpenGLCurveEvaluator::endline(void)
 115 {
 116   if(output_triangles)
 117     endCallBack(userData);
 118   else
 119     glEnd();
 120 }
 121
 122 /*---------------------------------------------------------------------------
 123  * disable - turn off a curve map
 124  *---------------------------------------------------------------------------
 125  */
 126 void
 127 OpenGLCurveEvaluator::disable(long type)
 128 {
 129     glDisable((GLenum) type);
 130 }
 131
 132 /*---------------------------------------------------------------------------
 133  * enable - turn on a curve map
 134  *---------------------------------------------------------------------------
 135  */
 136 void
 137 OpenGLCurveEvaluator::enable(long type)
 138 {
 139     glEnable((GLenum) type);
 140 }
 141
 142 /*-------------------------------------------------------------------------
 143  * mapgrid1f - define a lattice of points with origin and offset
 144  *-------------------------------------------------------------------------
 145  */
 146 void
 147 OpenGLCurveEvaluator::mapgrid1f(long nu, REAL u0, REAL u1)
 148 {
 149   if(output_triangles)
 150     {
 151       global_grid_u0 = u0;
 152       global_grid_u1 = u1;
 153       global_grid_nu = (int) nu;
 154     }
 155   else
 156     glMapGrid1f((GLint) nu, (GLfloat) u0, (GLfloat) u1);
 157 }
 158
 159 /*-------------------------------------------------------------------------
 160  * bgnmap1 - preamble to curve definition and evaluations
 161  *-------------------------------------------------------------------------
 162  */
 163 void
 164 OpenGLCurveEvaluator::bgnmap1f(long)
 165 {
 166   if(output_triangles)
 167     {
 168       //initialized so that no maps are set initially
 169       vertex_flag = 0;
 170       normal_flag = 0;
 171       color_flag = 0;
 172       texcoord_flag = 0;
 173       //no need to worry about gl states when doing callback
 174     }
 175   else
 176     glPushAttrib((GLbitfield) GL_EVAL_BIT);
 177 }
 178
 179 /*-------------------------------------------------------------------------
 180  * endmap1 - postamble to a curve map
 181  *-------------------------------------------------------------------------
 182  */
 183 void
 184 OpenGLCurveEvaluator::endmap1f(void)
 185 {
 186   if(output_triangles)
 187     {
 188
 189     }
 190   else
 191     glPopAttrib();
 192 }
 193
 194 /*-------------------------------------------------------------------------
 195  * map1f - pass a desription of a curve map
 196  *-------------------------------------------------------------------------
 197  */
 198 void
 199 OpenGLCurveEvaluator::map1f(
 200     long type,                  /* map type */
 201     REAL ulo,                   /* lower parametric bound */
 202     REAL uhi,                   /* upper parametric bound */
 203     long stride,                /* distance to next point in REALS */
 204     long order,                 /* parametric order */
 205     REAL *pts                   /* control points */
 206 )
 207 {
 208   if(output_triangles)
 209     {
 210       int dimension = 0;
 211       int which = 0;
 212       switch(type){
 213       case GL_MAP1_VERTEX_3:
 214         which = 0;
 215         dimension = 3;
 216         break;
 217       case GL_MAP1_VERTEX_4:
 218         which=0;
 219         dimension = 4;
 220         break;
 221       case GL_MAP1_INDEX:
 222         which=2;
 223         dimension = 1;
 224         break;
 225       case GL_MAP1_COLOR_4:
 226         which=2;
 227         dimension = 4;
 228         break;
 229       case GL_MAP1_NORMAL:
 230         which=1;
 231         dimension = 3;
 232         break;
 233       case GL_MAP1_TEXTURE_COORD_1:
 234         which=3;
 235         dimension = 1;
 236         break;
 237       case GL_MAP1_TEXTURE_COORD_2:
 238         which=3;
 239         dimension = 2;
 240         break;
 241
 242       case GL_MAP1_TEXTURE_COORD_3:
 243         which=3;
 244         dimension = 3;
 245         break;
 246       case GL_MAP1_TEXTURE_COORD_4:
 247         which=3;
 248         dimension = 4;
 249         break;
 250       }
 251       inMap1f(which, dimension, ulo, uhi, stride, order, pts);
 252     }
 253   else
 254     glMap1f((GLenum) type, (GLfloat) ulo, (GLfloat) uhi, (GLint) stride,
 255             (GLint) order, (const GLfloat *) pts);
 256 }
 257
 258 /*-------------------------------------------------------------------------
 259  * mapmesh1f - evaluate a mesh of points on lattice
 260  *-------------------------------------------------------------------------
 261  */
 262 void OpenGLCurveEvaluator::mapmesh1f(long style, long from, long to)
 263 {
 264   if(output_triangles)
 265     {
 266       inMapMesh1f((int) from, (int) to);
 267     }
 268   else
 269     {
 270       switch(style) {
 271       default:
 272       case N_MESHFILL:
 273       case N_MESHLINE:
 274         glEvalMesh1((GLenum) GL_LINE, (GLint) from, (GLint) to);
 275         break;
 276       case N_MESHPOINT:
 277         glEvalMesh1((GLenum) GL_POINT, (GLint) from, (GLint) to);
 278         break;
 279       }
 280     }
 281 }
 282
 283 /*-------------------------------------------------------------------------
 284  * evalpoint1i - evaluate a point on a curve
 285  *-------------------------------------------------------------------------
 286  */
 287 void OpenGLCurveEvaluator::evalpoint1i(long i)
 288 {
 289     glEvalPoint1((GLint) i);
 290 }
 291
 292 /*-------------------------------------------------------------------------
 293  * evalcoord1f - evaluate a point on a curve
 294  *-------------------------------------------------------------------------
 295  */
 296 void OpenGLCurveEvaluator::evalcoord1f(long, REAL u)
 297 {
 298     glEvalCoord1f((GLfloat) u);
 299 }
 300
 301 void
 302 #ifdef _WIN32
 303 OpenGLCurveEvaluator::putCallBack(GLenum which, void (GLAPIENTRY *fn)())
 304 #else
 305 OpenGLCurveEvaluator::putCallBack(GLenum which, _GLUfuncptr fn)
 306 #endif
 307 {
 308   switch(which)
 309   {
 310     case GLU_NURBS_BEGIN:
 311       beginCallBackN = (void (GLAPIENTRY *) (GLenum)) fn;
 312       break;
 313     case GLU_NURBS_END:
 314       endCallBackN = (void (GLAPIENTRY *) (void)) fn;
 315       break;
 316     case GLU_NURBS_VERTEX:
 317       vertexCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
 318       break;
 319     case GLU_NURBS_NORMAL:
 320       normalCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
 321       break;
 322     case GLU_NURBS_COLOR:
 323       colorCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
 324       break;
 325     case GLU_NURBS_TEXTURE_COORD:
 326       texcoordCallBackN = (void (GLAPIENTRY *) (const GLfloat*)) fn;
 327       break;
 328     case GLU_NURBS_BEGIN_DATA:
 329       beginCallBackData = (void (GLAPIENTRY *) (GLenum, void*)) fn;
 330       break;
 331     case GLU_NURBS_END_DATA:
 332       endCallBackData = (void (GLAPIENTRY *) (void*)) fn;
 333       break;
 334     case GLU_NURBS_VERTEX_DATA:
 335       vertexCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
 336       break;
 337     case GLU_NURBS_NORMAL_DATA:
 338       normalCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
 339       break;
 340     case GLU_NURBS_COLOR_DATA:
 341       colorCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
 342       break;
 343     case GLU_NURBS_TEXTURE_COORD_DATA:
 344       texcoordCallBackData = (void (GLAPIENTRY *) (const GLfloat*, void*)) fn;
 345       break;
 346   }
 347 }
 348
 349 void
 350 OpenGLCurveEvaluator::beginCallBack(GLenum which, void *data)
 351 {
 352   if(beginCallBackData)
 353     beginCallBackData(which, data);
 354   else if(beginCallBackN)
 355     beginCallBackN(which);
 356 }
 357
 358 void
 359 OpenGLCurveEvaluator::endCallBack(void *data)
 360 {
 361   if(endCallBackData)
 362     endCallBackData(data);
 363   else if(endCallBackN)
 364     endCallBackN();
 365 }
 366
 367 void
 368 OpenGLCurveEvaluator::vertexCallBack(const GLfloat *vert, void* data)
 369 {
 370   if(vertexCallBackData)
 371     vertexCallBackData(vert, data);
 372   else if(vertexCallBackN)
 373     vertexCallBackN(vert);
 374 }
 375
 376
 377 void
 378 OpenGLCurveEvaluator::normalCallBack(const GLfloat *normal, void* data)
 379 {
 380   if(normalCallBackData)
 381     normalCallBackData(normal, data);
 382   else if(normalCallBackN)
 383     normalCallBackN(normal);
 384 }
 385
 386 void
 387 OpenGLCurveEvaluator::colorCallBack(const GLfloat *color, void* data)
 388 {
 389   if(colorCallBackData)
 390     colorCallBackData(color, data);
 391   else if(colorCallBackN)
 392     colorCallBackN(color);
 393 }
 394
 395 void
 396 OpenGLCurveEvaluator::texcoordCallBack(const GLfloat *texcoord, void* data)
 397 {
 398   if(texcoordCallBackData)
 399     texcoordCallBackData(texcoord, data);
 400   else if(texcoordCallBackN)
 401     texcoordCallBackN(texcoord);
 402 }