dlls/glu32/glu.c

   1 /*
   2  * Copyright 2001 Marcus Meissner
   3  * Copyright 2017 Alexandre Julliard
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27
  28 #include "wine/wgl.h"
  29 #include "wine/library.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(glu);
  33
  34 typedef struct GLUnurbs GLUnurbs;
  35 typedef struct GLUquadric GLUquadric;
  36 typedef struct GLUtesselator GLUtesselator;
  37 typedef void (*_GLUfuncptr)(void);
  38
  39 /* The only non-trivial bit of this is the *Tess* functions.  Here we
  40    need to wrap the callbacks up in a thunk to switch calling
  41    conventions, so we use our own tesselator type to store the
  42    application's callbacks.  wine_gluTessCallback always sets the
  43    *_DATA type of callback so that we have access to the polygon_data
  44    (which is in fact just wine_GLUtesselator), in the thunk itself we can
  45    check whether we should call the _DATA or non _DATA type. */
  46
  47 typedef struct {
  48     GLUtesselator *tess;
  49     void *polygon_data;
  50     void (CALLBACK *cb_tess_begin)(int);
  51     void (CALLBACK *cb_tess_begin_data)(int, void *);
  52     void (CALLBACK *cb_tess_vertex)(void *);
  53     void (CALLBACK *cb_tess_vertex_data)(void *, void *);
  54     void (CALLBACK *cb_tess_end)(void);
  55     void (CALLBACK *cb_tess_end_data)(void *);
  56     void (CALLBACK *cb_tess_error)(int);
  57     void (CALLBACK *cb_tess_error_data)(int, void *);
  58     void (CALLBACK *cb_tess_edge_flag)(int);
  59     void (CALLBACK *cb_tess_edge_flag_data)(int, void *);
  60     void (CALLBACK *cb_tess_combine)(double *, void *, float *, void **);
  61     void (CALLBACK *cb_tess_combine_data)(double *, void *, float *, void **, void *);
  62 } wine_GLUtesselator;
  63
  64 #define GLU_TESS_BEGIN          100100
  65 #define GLU_TESS_VERTEX         100101
  66 #define GLU_TESS_END            100102
  67 #define GLU_TESS_ERROR          100103
  68 #define GLU_TESS_EDGE_FLAG      100104
  69 #define GLU_TESS_COMBINE        100105
  70 #define GLU_TESS_BEGIN_DATA     100106
  71 #define GLU_TESS_VERTEX_DATA    100107
  72 #define GLU_TESS_END_DATA       100108
  73 #define GLU_TESS_ERROR_DATA     100109
  74 #define GLU_TESS_EDGE_FLAG_DATA 100110
  75 #define GLU_TESS_COMBINE_DATA   100111
  76
  77 static void  (*p_gluBeginCurve)( GLUnurbs* nurb );
  78 static void  (*p_gluBeginSurface)( GLUnurbs* nurb );
  79 static void  (*p_gluBeginTrim)( GLUnurbs* nurb );
  80 static GLint (*p_gluBuild1DMipmaps)( GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data );
  81 static GLint (*p_gluBuild2DMipmaps)( GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data );
  82 static void  (*p_gluCylinder)( GLUquadric* quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks );
  83 static void  (*p_gluDeleteNurbsRenderer)( GLUnurbs* nurb );
  84 static void  (*p_gluDeleteQuadric)( GLUquadric* quad );
  85 static void  (*p_gluDeleteTess)( GLUtesselator* tess );
  86 static void  (*p_gluDisk)( GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops );
  87 static void  (*p_gluEndCurve)( GLUnurbs* nurb );
  88 static void  (*p_gluEndSurface)( GLUnurbs* nurb );
  89 static void  (*p_gluEndTrim)( GLUnurbs* nurb );
  90 static const GLubyte * (*p_gluErrorString)( GLenum error );
  91 static void  (*p_gluGetNurbsProperty)( GLUnurbs* nurb, GLenum property, GLfloat* data );
  92 static const GLubyte * (*p_gluGetString)( GLenum name );
  93 static void  (*p_gluGetTessProperty)( GLUtesselator* tess, GLenum which, GLdouble* data );
  94 static void  (*p_gluLoadSamplingMatrices)( GLUnurbs* nurb, const GLfloat *model, const GLfloat *perspective, const GLint *view );
  95 static void  (*p_gluLookAt)( GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ );
  96 static GLUnurbs* (*p_gluNewNurbsRenderer)(void);
  97 static GLUquadric* (*p_gluNewQuadric)(void);
  98 static GLUtesselator* (*p_gluNewTess)(void);
  99 static void  (*p_gluNurbsCallback)( GLUnurbs* nurb, GLenum which, _GLUfuncptr CallBackFunc );
 100 static void  (*p_gluNurbsCurve)( GLUnurbs* nurb, GLint knotCount, GLfloat *knots, GLint stride, GLfloat *control, GLint order, GLenum type );
 101 static void  (*p_gluNurbsProperty)( GLUnurbs* nurb, GLenum property, GLfloat value );
 102 static void  (*p_gluNurbsSurface)( GLUnurbs* nurb, GLint sKnotCount, GLfloat* sKnots, GLint tKnotCount, GLfloat* tKnots, GLint sStride, GLint tStride, GLfloat* control, GLint sOrder, GLint tOrder, GLenum type );
 103 static void  (*p_gluOrtho2D)( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top );
 104 static void  (*p_gluPartialDisk)( GLUquadric* quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep );
 105 static void  (*p_gluPerspective)( GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar );
 106 static void  (*p_gluPickMatrix)( GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint *viewport );
 107 static GLint (*p_gluProject)( GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* winX, GLdouble* winY, GLdouble* winZ );
 108 static void  (*p_gluPwlCurve)( GLUnurbs* nurb, GLint count, GLfloat* data, GLint stride, GLenum type );
 109 static void  (*p_gluQuadricCallback)( GLUquadric* quad, GLenum which, _GLUfuncptr CallBackFunc );
 110 static void  (*p_gluQuadricDrawStyle)( GLUquadric* quad, GLenum draw );
 111 static void  (*p_gluQuadricNormals)( GLUquadric* quad, GLenum normal );
 112 static void  (*p_gluQuadricOrientation)( GLUquadric* quad, GLenum orientation );
 113 static void  (*p_gluQuadricTexture)( GLUquadric* quad, GLboolean texture );
 114 static GLint (*p_gluScaleImage)( GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void *dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid* dataOut );
 115 static void  (*p_gluSphere)( GLUquadric* quad, GLdouble radius, GLint slices, GLint stacks );
 116 static void  (*p_gluTessBeginContour)( GLUtesselator* tess );
 117 static void  (*p_gluTessBeginPolygon)( GLUtesselator* tess, GLvoid* data );
 118 static void  (*p_gluTessCallback)( GLUtesselator* tess, GLenum which, _GLUfuncptr CallBackFunc );
 119 static void  (*p_gluTessEndContour)( GLUtesselator* tess );
 120 static void  (*p_gluTessEndPolygon)( GLUtesselator* tess );
 121 static void  (*p_gluTessNormal)( GLUtesselator* tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ );
 122 static void  (*p_gluTessProperty)( GLUtesselator* tess, GLenum which, GLdouble data );
 123 static void  (*p_gluTessVertex)( GLUtesselator* tess, GLdouble *location, GLvoid* data );
 124 static GLint (*p_gluUnProject)( GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble *model, const GLdouble *proj, const GLint *view, GLdouble* objX, GLdouble* objY, GLdouble* objZ );
 125
 126 static BOOL load_libglu(void)
 127 {
 128     char error[256];
 129     void *handle = wine_dlopen( SONAME_LIBGLU, RTLD_NOW, error, sizeof(error) );
 130
 131     if (!handle)
 132     {
 133         ERR( "Failed to load %s: %s\n", SONAME_LIBGLU, error );
 134         return FALSE;
 135     }
 136 #define LOAD_FUNCPTR(f) if (!(p_##f = wine_dlsym( handle, #f, NULL, 0 ))) { ERR( "Can't find %s in %s\n", #f, SONAME_LIBGLU ); return FALSE; }
 137     LOAD_FUNCPTR(gluBeginCurve);
 138     LOAD_FUNCPTR(gluBeginSurface);
 139     LOAD_FUNCPTR(gluBeginTrim);
 140     LOAD_FUNCPTR(gluBuild1DMipmaps);
 141     LOAD_FUNCPTR(gluBuild2DMipmaps);
 142     LOAD_FUNCPTR(gluCylinder);
 143     LOAD_FUNCPTR(gluDeleteNurbsRenderer);
 144     LOAD_FUNCPTR(gluDeleteQuadric);
 145     LOAD_FUNCPTR(gluDeleteTess);
 146     LOAD_FUNCPTR(gluDisk);
 147     LOAD_FUNCPTR(gluEndCurve);
 148     LOAD_FUNCPTR(gluEndSurface);
 149     LOAD_FUNCPTR(gluEndTrim);
 150     LOAD_FUNCPTR(gluErrorString);
 151     LOAD_FUNCPTR(gluGetNurbsProperty);
 152     LOAD_FUNCPTR(gluGetString);
 153     LOAD_FUNCPTR(gluGetTessProperty);
 154     LOAD_FUNCPTR(gluLoadSamplingMatrices);
 155     LOAD_FUNCPTR(gluLookAt);
 156     LOAD_FUNCPTR(gluNewNurbsRenderer);
 157     LOAD_FUNCPTR(gluNewQuadric);
 158     LOAD_FUNCPTR(gluNewTess);
 159     LOAD_FUNCPTR(gluNurbsCallback);
 160     LOAD_FUNCPTR(gluNurbsCurve);
 161     LOAD_FUNCPTR(gluNurbsProperty);
 162     LOAD_FUNCPTR(gluNurbsSurface);
 163     LOAD_FUNCPTR(gluOrtho2D);
 164     LOAD_FUNCPTR(gluPartialDisk);
 165     LOAD_FUNCPTR(gluPerspective);
 166     LOAD_FUNCPTR(gluPickMatrix);
 167     LOAD_FUNCPTR(gluProject);
 168     LOAD_FUNCPTR(gluPwlCurve);
 169     LOAD_FUNCPTR(gluQuadricCallback);
 170     LOAD_FUNCPTR(gluQuadricDrawStyle);
 171     LOAD_FUNCPTR(gluQuadricNormals);
 172     LOAD_FUNCPTR(gluQuadricOrientation);
 173     LOAD_FUNCPTR(gluQuadricTexture);
 174     LOAD_FUNCPTR(gluScaleImage);
 175     LOAD_FUNCPTR(gluSphere);
 176     LOAD_FUNCPTR(gluTessBeginContour);
 177     LOAD_FUNCPTR(gluTessBeginPolygon);
 178     LOAD_FUNCPTR(gluTessCallback);
 179     LOAD_FUNCPTR(gluTessEndContour);
 180     LOAD_FUNCPTR(gluTessEndPolygon);
 181     LOAD_FUNCPTR(gluTessNormal);
 182     LOAD_FUNCPTR(gluTessProperty);
 183     LOAD_FUNCPTR(gluTessVertex);
 184     LOAD_FUNCPTR(gluUnProject);
 185 #undef LOAD_FUNCPTR
 186     TRACE( "loaded %s\n", SONAME_LIBGLU );
 187     return TRUE;
 188 }
 189
 190
 191 /***********************************************************************
 192  *              DllMain
 193  */
 194 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
 195 {
 196     switch (reason)
 197     {
 198     case DLL_PROCESS_ATTACH:
 199         DisableThreadLibraryCalls( inst );
 200         return load_libglu();
 201     }
 202     return TRUE;
 203 }
 204
 205 /***********************************************************************
 206  *              gluLookAt (GLU32.@)
 207  */
 208 void WINAPI wine_gluLookAt( GLdouble eyex, GLdouble eyey, GLdouble eyez,
 209                             GLdouble centerx, GLdouble centery, GLdouble centerz,
 210                             GLdouble upx, GLdouble upy, GLdouble upz )
 211 {
 212     p_gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz );
 213 }
 214
 215 /***********************************************************************
 216  *              gluOrtho2D (GLU32.@)
 217  */
 218 void WINAPI wine_gluOrtho2D( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top )
 219 {
 220     p_gluOrtho2D( left, right, bottom, top );
 221 }
 222
 223 /***********************************************************************
 224  *              gluPerspective (GLU32.@)
 225  */
 226 void WINAPI wine_gluPerspective( GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar )
 227 {
 228     p_gluPerspective( fovy, aspect, zNear, zFar );
 229 }
 230
 231 /***********************************************************************
 232  *              gluPickMatrix (GLU32.@)
 233  */
 234 void WINAPI wine_gluPickMatrix( GLdouble x, GLdouble y, GLdouble width, GLdouble height, GLint viewport[4])
 235 {
 236     p_gluPickMatrix( x, y, width, height, viewport );
 237 }
 238
 239 /***********************************************************************
 240  *              gluProject (GLU32.@)
 241  */
 242 int WINAPI wine_gluProject( GLdouble objx, GLdouble objy, GLdouble objz, const GLdouble modelMatrix[16],
 243                             const GLdouble projMatrix[16], const GLint viewport[4],
 244                             GLdouble *winx, GLdouble *winy, GLdouble *winz )
 245 {
 246     return p_gluProject( objx, objy, objz, modelMatrix, projMatrix, viewport, winx, winy, winz );
 247 }
 248
 249 /***********************************************************************
 250  *              gluUnProject (GLU32.@)
 251  */
 252 int WINAPI wine_gluUnProject( GLdouble winx, GLdouble winy, GLdouble winz, const GLdouble modelMatrix[16],
 253                               const GLdouble projMatrix[16], const GLint viewport[4],
 254                               GLdouble *objx, GLdouble *objy, GLdouble *objz )
 255 {
 256     return p_gluUnProject( winx, winy, winz, modelMatrix, projMatrix, viewport, objx, objy, objz );
 257 }
 258
 259 /***********************************************************************
 260  *              gluErrorString (GLU32.@)
 261  */
 262 const GLubyte * WINAPI wine_gluErrorString( GLenum errCode )
 263 {
 264     return p_gluErrorString( errCode );
 265 }
 266
 267 /***********************************************************************
 268  *              gluScaleImage (GLU32.@)
 269  */
 270 int WINAPI wine_gluScaleImage( GLenum format, GLint widthin, GLint heightin, GLenum typein, const void *datain,
 271                                GLint widthout, GLint heightout, GLenum typeout, void *dataout )
 272 {
 273     return p_gluScaleImage( format, widthin, heightin, typein, datain,
 274                             widthout, heightout, typeout, dataout );
 275 }
 276
 277 /***********************************************************************
 278  *              gluBuild1DMipmaps (GLU32.@)
 279  */
 280 int WINAPI wine_gluBuild1DMipmaps( GLenum target, GLint components, GLint width,
 281                                    GLenum format, GLenum type, const void *data )
 282 {
 283     return p_gluBuild1DMipmaps( target, components, width, format, type, data );
 284 }
 285
 286 /***********************************************************************
 287  *              gluBuild2DMipmaps (GLU32.@)
 288  */
 289 int WINAPI wine_gluBuild2DMipmaps( GLenum target, GLint components, GLint width, GLint height,
 290                                    GLenum format, GLenum type, const void *data )
 291 {
 292     return p_gluBuild2DMipmaps( target, components, width, height, format, type, data );
 293 }
 294
 295 /***********************************************************************
 296  *              gluNewQuadric (GLU32.@)
 297  */
 298 GLUquadric * WINAPI wine_gluNewQuadric(void)
 299 {
 300     return p_gluNewQuadric();
 301 }
 302
 303 /***********************************************************************
 304  *              gluDeleteQuadric (GLU32.@)
 305  */
 306 void WINAPI wine_gluDeleteQuadric( GLUquadric *state )
 307 {
 308     p_gluDeleteQuadric( state );
 309 }
 310
 311 /***********************************************************************
 312  *              gluQuadricDrawStyle (GLU32.@)
 313  */
 314 void WINAPI wine_gluQuadricDrawStyle( GLUquadric *quadObject, GLenum drawStyle )
 315 {
 316     p_gluQuadricDrawStyle( quadObject, drawStyle );
 317 }
 318
 319 /***********************************************************************
 320  *              gluQuadricOrientation (GLU32.@)
 321  */
 322 void WINAPI wine_gluQuadricOrientation( GLUquadric *quadObject, GLenum orientation )
 323 {
 324     p_gluQuadricOrientation( quadObject, orientation );
 325 }
 326
 327 /***********************************************************************
 328  *              gluQuadricNormals (GLU32.@)
 329  */
 330 void WINAPI wine_gluQuadricNormals( GLUquadric *quadObject, GLenum normals )
 331 {
 332     p_gluQuadricNormals( quadObject, normals );
 333 }
 334
 335 /***********************************************************************
 336  *              gluQuadricTexture (GLU32.@)
 337  */
 338 void WINAPI wine_gluQuadricTexture( GLUquadric *quadObject, GLboolean textureCoords )
 339 {
 340     p_gluQuadricTexture( quadObject, textureCoords );
 341 }
 342
 343 /***********************************************************************
 344  *              gluQuadricCallback (GLU32.@)
 345  */
 346 void WINAPI wine_gluQuadricCallback( GLUquadric *qobj, GLenum which, void (CALLBACK *fn)(void) )
 347 {
 348     /* FIXME: callback calling convention */
 349     p_gluQuadricCallback( qobj, which, (_GLUfuncptr)fn );
 350 }
 351
 352 /***********************************************************************
 353  *              gluCylinder (GLU32.@)
 354  */
 355 void WINAPI wine_gluCylinder( GLUquadric *qobj, GLdouble baseRadius, GLdouble topRadius,
 356                               GLdouble height, GLint slices, GLint stacks )
 357 {
 358     p_gluCylinder( qobj, baseRadius, topRadius, height, slices, stacks );
 359 }
 360
 361 /***********************************************************************
 362  *              gluSphere (GLU32.@)
 363  */
 364 void WINAPI wine_gluSphere( GLUquadric *qobj, GLdouble radius, GLint slices, GLint stacks )
 365 {
 366     p_gluSphere( qobj, radius, slices, stacks );
 367 }
 368
 369 /***********************************************************************
 370  *              gluDisk (GLU32.@)
 371  */
 372 void WINAPI wine_gluDisk( GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
 373                           GLint slices, GLint loops )
 374 {
 375     p_gluDisk( qobj, innerRadius, outerRadius, slices, loops );
 376 }
 377
 378 /***********************************************************************
 379  *              gluPartialDisk (GLU32.@)
 380  */
 381 void WINAPI wine_gluPartialDisk( GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
 382                                  GLint slices, GLint loops, GLdouble startAngle, GLdouble sweepAngle )
 383 {
 384     p_gluPartialDisk( qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle );
 385 }
 386
 387 /***********************************************************************
 388  *              gluNewNurbsRenderer (GLU32.@)
 389  */
 390 GLUnurbs * WINAPI wine_gluNewNurbsRenderer(void)
 391 {
 392     return p_gluNewNurbsRenderer();
 393 }
 394
 395 /***********************************************************************
 396  *              gluDeleteNurbsRenderer (GLU32.@)
 397  */
 398 void WINAPI wine_gluDeleteNurbsRenderer( GLUnurbs *nobj )
 399 {
 400     p_gluDeleteNurbsRenderer( nobj );
 401 }
 402
 403 /***********************************************************************
 404  *              gluLoadSamplingMatrices (GLU32.@)
 405  */
 406 void WINAPI wine_gluLoadSamplingMatrices( GLUnurbs *nobj, const GLfloat modelMatrix[16],
 407                                           const GLfloat projMatrix[16], const GLint viewport[4] )
 408 {
 409     p_gluLoadSamplingMatrices( nobj, modelMatrix, projMatrix, viewport );
 410 }
 411
 412 /***********************************************************************
 413  *              gluNurbsProperty (GLU32.@)
 414  */
 415 void WINAPI wine_gluNurbsProperty( GLUnurbs *nobj, GLenum property, GLfloat value )
 416 {
 417     p_gluNurbsProperty( nobj, property, value );
 418 }
 419
 420 /***********************************************************************
 421  *              gluGetNurbsProperty (GLU32.@)
 422  */
 423 void WINAPI wine_gluGetNurbsProperty( GLUnurbs *nobj, GLenum property, GLfloat *value )
 424 {
 425     p_gluGetNurbsProperty( nobj, property, value );
 426 }
 427
 428 /***********************************************************************
 429  *              gluBeginCurve (GLU32.@)
 430  */
 431 void WINAPI wine_gluBeginCurve( GLUnurbs *nobj )
 432 {
 433     p_gluBeginCurve( nobj );
 434 }
 435
 436 /***********************************************************************
 437  *              gluEndCurve (GLU32.@)
 438  */
 439 void WINAPI wine_gluEndCurve( GLUnurbs *nobj )
 440 {
 441     p_gluEndCurve( nobj );
 442 }
 443
 444 /***********************************************************************
 445  *              gluNurbsCurve (GLU32.@)
 446  */
 447 void WINAPI wine_gluNurbsCurve( GLUnurbs *nobj, GLint nknots, GLfloat *knot,
 448                                 GLint stride, GLfloat *ctlarray, GLint order, GLenum type )
 449 {
 450     p_gluNurbsCurve( nobj, nknots, knot, stride, ctlarray, order, type );
 451 }
 452
 453 /***********************************************************************
 454  *              gluBeginSurface (GLU32.@)
 455  */
 456 void WINAPI wine_gluBeginSurface( GLUnurbs *nobj )
 457 {
 458     p_gluBeginSurface( nobj );
 459 }
 460
 461 /***********************************************************************
 462  *              gluEndSurface (GLU32.@)
 463  */
 464 void WINAPI wine_gluEndSurface( GLUnurbs *nobj )
 465 {
 466     p_gluEndSurface( nobj );
 467 }
 468
 469 /***********************************************************************
 470  *              gluNurbsSurface (GLU32.@)
 471  */
 472 void WINAPI wine_gluNurbsSurface( GLUnurbs *nobj, GLint sknot_count, float *sknot, GLint tknot_count,
 473                                   GLfloat *tknot, GLint s_stride, GLint t_stride, GLfloat *ctlarray,
 474                                   GLint sorder, GLint torder, GLenum type )
 475 {
 476     p_gluNurbsSurface( nobj, sknot_count, sknot, tknot_count, tknot,
 477                        s_stride, t_stride, ctlarray, sorder, torder, type );
 478 }
 479
 480 /***********************************************************************
 481  *              gluBeginTrim (GLU32.@)
 482  */
 483 void WINAPI wine_gluBeginTrim( GLUnurbs *nobj )
 484 {
 485     p_gluBeginTrim( nobj );
 486 }
 487
 488 /***********************************************************************
 489  *              gluEndTrim (GLU32.@)
 490  */
 491 void WINAPI wine_gluEndTrim( GLUnurbs *nobj )
 492 {
 493     p_gluEndTrim( nobj );
 494 }
 495
 496 /***********************************************************************
 497  *              gluPwlCurve (GLU32.@)
 498  */
 499 void WINAPI wine_gluPwlCurve( GLUnurbs *nobj, GLint count, GLfloat *array, GLint stride, GLenum type )
 500 {
 501     p_gluPwlCurve( nobj, count, array, stride, type );
 502 }
 503
 504 /***********************************************************************
 505  *              gluNurbsCallback (GLU32.@)
 506  */
 507 void WINAPI wine_gluNurbsCallback( GLUnurbs *nobj, GLenum which, void (CALLBACK *fn)(void) )
 508 {
 509     /* FIXME: callback calling convention */
 510     p_gluNurbsCallback( nobj, which, (_GLUfuncptr)fn );
 511 }
 512
 513 /***********************************************************************
 514  *              gluGetString (GLU32.@)
 515  */
 516 const GLubyte * WINAPI wine_gluGetString( GLenum name )
 517 {
 518     return p_gluGetString( name );
 519 }
 520
 521 /***********************************************************************
 522  *              gluCheckExtension (GLU32.@)
 523  */
 524 GLboolean WINAPI wine_gluCheckExtension( const GLubyte *extName, const GLubyte *extString )
 525 {
 526     return 0;
 527 }
 528
 529 /***********************************************************************
 530  *              gluNewTess (GLU32.@)
 531  */
 532 wine_GLUtesselator * WINAPI wine_gluNewTess(void)
 533 {
 534     void *tess;
 535     wine_GLUtesselator *ret;
 536
 537     if((tess = p_gluNewTess()) == NULL)
 538        return NULL;
 539
 540     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
 541     if(!ret) {
 542         p_gluDeleteTess(tess);
 543         return NULL;
 544     }
 545     ret->tess = tess;
 546     return ret;
 547 }
 548
 549 /***********************************************************************
 550  *              gluDeleteTess (GLU32.@)
 551  */
 552 void WINAPI wine_gluDeleteTess( wine_GLUtesselator *wine_tess )
 553 {
 554     p_gluDeleteTess(wine_tess->tess);
 555     HeapFree(GetProcessHeap(), 0, wine_tess);
 556     return;
 557 }
 558
 559 /***********************************************************************
 560  *              gluTessBeginPolygon (GLU32.@)
 561  */
 562 void WINAPI wine_gluTessBeginPolygon( wine_GLUtesselator *wine_tess, void *polygon_data )
 563 {
 564     wine_tess->polygon_data = polygon_data;
 565
 566     p_gluTessBeginPolygon(wine_tess->tess, wine_tess);
 567 }
 568
 569 /***********************************************************************
 570  *              gluTessEndPolygon (GLU32.@)
 571  */
 572 void WINAPI wine_gluTessEndPolygon( wine_GLUtesselator *wine_tess )
 573 {
 574     p_gluTessEndPolygon(wine_tess->tess);
 575 }
 576
 577
 578 static void wine_glu_tess_begin_data(int type, wine_GLUtesselator *wine_tess)
 579 {
 580     if(wine_tess->cb_tess_begin_data)
 581         wine_tess->cb_tess_begin_data(type, wine_tess->polygon_data);
 582     else
 583         wine_tess->cb_tess_begin(type);
 584 }
 585
 586 static void wine_glu_tess_vertex_data(void *vertex_data, wine_GLUtesselator *wine_tess)
 587 {
 588     if(wine_tess->cb_tess_vertex_data)
 589         wine_tess->cb_tess_vertex_data(vertex_data, wine_tess->polygon_data);
 590     else
 591         wine_tess->cb_tess_vertex(vertex_data);
 592 }
 593
 594 static void wine_glu_tess_end_data(wine_GLUtesselator *wine_tess)
 595 {
 596     if(wine_tess->cb_tess_end_data)
 597         wine_tess->cb_tess_end_data(wine_tess->polygon_data);
 598     else
 599         wine_tess->cb_tess_end();
 600 }
 601
 602 static void wine_glu_tess_error_data(int error, wine_GLUtesselator *wine_tess)
 603 {
 604     if(wine_tess->cb_tess_error_data)
 605         wine_tess->cb_tess_error_data(error, wine_tess->polygon_data);
 606     else
 607         wine_tess->cb_tess_error(error);
 608 }
 609
 610 static void wine_glu_tess_edge_flag_data(int flag, wine_GLUtesselator *wine_tess)
 611 {
 612     if(wine_tess->cb_tess_edge_flag_data)
 613         wine_tess->cb_tess_edge_flag_data(flag, wine_tess->polygon_data);
 614     else
 615         wine_tess->cb_tess_edge_flag(flag);
 616 }
 617
 618 static void wine_glu_tess_combine_data(double *coords, void *vertex_data, float *weight, void **outData,
 619                                        wine_GLUtesselator *wine_tess)
 620 {
 621     if(wine_tess->cb_tess_combine_data)
 622         wine_tess->cb_tess_combine_data(coords, vertex_data, weight, outData, wine_tess->polygon_data);
 623     else
 624         wine_tess->cb_tess_combine(coords, vertex_data, weight, outData);
 625 }
 626
 627
 628 /***********************************************************************
 629  *              gluTessCallback (GLU32.@)
 630  */
 631 void WINAPI wine_gluTessCallback( wine_GLUtesselator *tess, GLenum which, void (CALLBACK *fn)(void))
 632 {
 633     void *new_fn;
 634
 635     switch(which) {
 636     case GLU_TESS_BEGIN:
 637         tess->cb_tess_begin = (void *)fn;
 638         new_fn = wine_glu_tess_begin_data;
 639         which += 6;
 640         break;
 641     case GLU_TESS_VERTEX:
 642         tess->cb_tess_vertex = (void *)fn;
 643         new_fn = wine_glu_tess_vertex_data;
 644         which += 6;
 645         break;
 646     case GLU_TESS_END:
 647         tess->cb_tess_end = (void *)fn;
 648         new_fn = wine_glu_tess_end_data;
 649         which += 6;
 650         break;
 651     case GLU_TESS_ERROR:
 652         tess->cb_tess_error = (void *)fn;
 653         new_fn = wine_glu_tess_error_data;
 654         which += 6;
 655         break;
 656     case GLU_TESS_EDGE_FLAG:
 657         tess->cb_tess_edge_flag = (void *)fn;
 658         new_fn = wine_glu_tess_edge_flag_data;
 659         which += 6;
 660         break;
 661     case GLU_TESS_COMBINE:
 662         tess->cb_tess_combine = (void *)fn;
 663         new_fn = wine_glu_tess_combine_data;
 664         which += 6;
 665         break;
 666     case GLU_TESS_BEGIN_DATA:
 667         tess->cb_tess_begin_data = (void *)fn;
 668         new_fn = wine_glu_tess_begin_data;
 669         break;
 670     case GLU_TESS_VERTEX_DATA:
 671         tess->cb_tess_vertex_data = (void *)fn;
 672         new_fn = wine_glu_tess_vertex_data;
 673         break;
 674     case GLU_TESS_END_DATA:
 675         tess->cb_tess_end_data = (void *)fn;
 676         new_fn = wine_glu_tess_end_data;
 677         break;
 678     case GLU_TESS_ERROR_DATA:
 679         tess->cb_tess_error_data = (void *)fn;
 680         new_fn = wine_glu_tess_error_data;
 681         break;
 682     case GLU_TESS_EDGE_FLAG_DATA:
 683         tess->cb_tess_edge_flag_data = (void *)fn;
 684         new_fn = wine_glu_tess_edge_flag_data;
 685         break;
 686     case GLU_TESS_COMBINE_DATA:
 687         tess->cb_tess_combine_data = (void *)fn;
 688         new_fn = wine_glu_tess_combine_data;
 689         break;
 690     default:
 691         ERR("Unknown callback %d\n", which);
 692         return;
 693     }
 694     p_gluTessCallback(tess->tess, which, new_fn);
 695 }
 696
 697 /***********************************************************************
 698  *              gluTessBeginContour (GLU32.@)
 699  */
 700 void WINAPI wine_gluTessBeginContour( wine_GLUtesselator *tess )
 701 {
 702     p_gluTessBeginContour(tess->tess);
 703 }
 704
 705 /***********************************************************************
 706  *              gluTessEndContour (GLU32.@)
 707  */
 708 void WINAPI wine_gluTessEndContour( wine_GLUtesselator *tess )
 709 {
 710     p_gluTessEndContour(tess->tess);
 711 }
 712
 713 /***********************************************************************
 714  *              gluTessVertex (GLU32.@)
 715  */
 716 void WINAPI wine_gluTessVertex( wine_GLUtesselator *tess, GLdouble coords[3], void *data )
 717 {
 718     p_gluTessVertex( tess->tess, coords, data );
 719 }
 720
 721 /***********************************************************************
 722  *              gluGetTessProperty (GLU32.@)
 723  */
 724 void WINAPI wine_gluGetTessProperty( wine_GLUtesselator *tess, GLenum which, GLdouble *value )
 725 {
 726     p_gluGetTessProperty( tess->tess, which, value );
 727 }
 728
 729 /***********************************************************************
 730  *              gluTessProperty (GLU32.@)
 731  */
 732 void WINAPI wine_gluTessProperty( wine_GLUtesselator *tess, GLenum which, GLdouble value )
 733 {
 734     p_gluTessProperty( tess->tess, which, value );
 735 }
 736
 737 /***********************************************************************
 738  *              gluTessNormal (GLU32.@)
 739  */
 740 void WINAPI wine_gluTessNormal( wine_GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z )
 741 {
 742     p_gluTessNormal( tess->tess, x, y, z );
 743 }
 744
 745 /***********************************************************************
 746  *      gluBeginPolygon (GLU32.@)
 747  */
 748 void WINAPI wine_gluBeginPolygon( wine_GLUtesselator *tess )
 749 {
 750     tess->polygon_data = NULL;
 751     p_gluTessBeginPolygon(tess->tess, tess);
 752     p_gluTessBeginContour(tess->tess);
 753 }
 754
 755 /***********************************************************************
 756  *      gluEndPolygon (GLU32.@)
 757  */
 758 void WINAPI wine_gluEndPolygon( wine_GLUtesselator *tess )
 759 {
 760     p_gluTessEndContour(tess->tess);
 761     p_gluTessEndPolygon(tess->tess);
 762 }
 763
 764 /***********************************************************************
 765  *      gluNextContour (GLU32.@)
 766  */
 767 void WINAPI wine_gluNextContour( wine_GLUtesselator *tess, GLenum type )
 768 {
 769     p_gluTessEndContour(tess->tess);
 770     p_gluTessBeginContour(tess->tess);
 771 }