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