dlls/glu32/glu.c

   1 /*
   2  * Copyright 2001 Marcus Meissner
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(glu);
  27
  28 /* The only non-trivial bit of this is the *Tess* functions.  Here we
  29    need to wrap the callbacks up in a thunk to switch calling
  30    conventions, so we use our own tesselator type to store the
  31    application's callbacks.  wine_gluTessCallback always sets the
  32    *_DATA type of callback so that we have access to the polygon_data
  33    (which is in fact just wine_tess_t), in the thunk itself we can
  34    check whether we should call the _DATA or non _DATA type. */
  35
  36 typedef struct {
  37     void *tess;
  38     void *polygon_data;
  39     void (CALLBACK *cb_tess_begin)(int);
  40     void (CALLBACK *cb_tess_begin_data)(int, void *);
  41     void (CALLBACK *cb_tess_vertex)(void *);
  42     void (CALLBACK *cb_tess_vertex_data)(void *, void *);
  43     void (CALLBACK *cb_tess_end)(void);
  44     void (CALLBACK *cb_tess_end_data)(void *);
  45     void (CALLBACK *cb_tess_error)(int);
  46     void (CALLBACK *cb_tess_error_data)(int, void *);
  47     void (CALLBACK *cb_tess_edge_flag)(int);
  48     void (CALLBACK *cb_tess_edge_flag_data)(int, void *);
  49     void (CALLBACK *cb_tess_combine)(double *, void *, float *, void **);
  50     void (CALLBACK *cb_tess_combine_data)(double *, void *, float *, void **, void *);
  51 } wine_tess_t;
  52
  53 #define GLU_TESS_BEGIN          100100
  54 #define GLU_TESS_VERTEX         100101
  55 #define GLU_TESS_END            100102
  56 #define GLU_TESS_ERROR          100103
  57 #define GLU_TESS_EDGE_FLAG      100104
  58 #define GLU_TESS_COMBINE        100105
  59 #define GLU_TESS_BEGIN_DATA     100106
  60 #define GLU_TESS_VERTEX_DATA    100107
  61 #define GLU_TESS_END_DATA       100108
  62 #define GLU_TESS_ERROR_DATA     100109
  63 #define GLU_TESS_EDGE_FLAG_DATA 100110
  64 #define GLU_TESS_COMBINE_DATA   100111
  65
  66 /***********************************************************************
  67  *              gluLookAt (GLU32.@)
  68  */
  69 extern int gluLookAt(double arg0,double arg1,double arg2,double arg3,double arg4,double arg5,double arg6,double arg7,double arg8);
  70 int WINAPI wine_gluLookAt(double arg0,double arg1,double arg2,double arg3,double arg4,double arg5,double arg6,double arg7,double arg8) {
  71         return gluLookAt(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  72 }
  73
  74 /***********************************************************************
  75  *              gluOrtho2D (GLU32.@)
  76  */
  77 extern int gluOrtho2D(double arg0,double arg1,double arg2,double arg3);
  78 int WINAPI wine_gluOrtho2D(double arg0,double arg1,double arg2,double arg3) {
  79         return gluOrtho2D(arg0,arg1,arg2,arg3);
  80 }
  81
  82 /***********************************************************************
  83  *              gluPerspective (GLU32.@)
  84  */
  85 extern int gluPerspective(double arg0,double arg1,double arg2,double arg3);
  86 int WINAPI wine_gluPerspective(double arg0,double arg1,double arg2,double arg3) {
  87         return gluPerspective(arg0,arg1,arg2,arg3);
  88 }
  89
  90 /***********************************************************************
  91  *              gluPickMatrix (GLU32.@)
  92  */
  93 extern int gluPickMatrix(double arg0,double arg1,double arg2,double arg3,void *arg4);
  94 int WINAPI wine_gluPickMatrix(double arg0,double arg1,double arg2,double arg3,void *arg4) {
  95         return gluPickMatrix(arg0,arg1,arg2,arg3,arg4);
  96 }
  97
  98 /***********************************************************************
  99  *              gluProject (GLU32.@)
 100  */
 101 extern int gluProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8);
 102 int WINAPI wine_gluProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8) {
 103         return gluProject(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
 104 }
 105
 106 /***********************************************************************
 107  *              gluUnProject (GLU32.@)
 108  */
 109 extern int gluUnProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8);
 110 int WINAPI wine_gluUnProject(double arg0,double arg1,double arg2,void *arg3,void *arg4,void *arg5,void *arg6,void *arg7,void *arg8) {
 111         return gluUnProject(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
 112 }
 113
 114 /***********************************************************************
 115  *              gluErrorString (GLU32.@)
 116  */
 117 extern int gluErrorString(int arg0);
 118 int WINAPI wine_gluErrorString(int arg0) {
 119         return gluErrorString(arg0);
 120 }
 121
 122 /***********************************************************************
 123  *              gluScaleImage (GLU32.@)
 124  */
 125 extern int gluScaleImage(int arg0,int arg1,int arg2,int arg3,void *arg4,int arg5,int arg6,int arg7,void *arg8);
 126 int WINAPI wine_gluScaleImage(int arg0,int arg1,int arg2,int arg3,void *arg4,int arg5,int arg6,int arg7,void *arg8) {
 127         return gluScaleImage(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
 128 }
 129
 130 /***********************************************************************
 131  *              gluBuild1DMipmaps (GLU32.@)
 132  */
 133 extern int gluBuild1DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,void *arg5);
 134 int WINAPI wine_gluBuild1DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,void *arg5) {
 135         return gluBuild1DMipmaps(arg0,arg1,arg2,arg3,arg4,arg5);
 136 }
 137
 138 /***********************************************************************
 139  *              gluBuild2DMipmaps (GLU32.@)
 140  */
 141 extern int gluBuild2DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,int arg5,void *arg6);
 142 int WINAPI wine_gluBuild2DMipmaps(int arg0,int arg1,int arg2,int arg3,int arg4,int arg5,void *arg6) {
 143         return gluBuild2DMipmaps(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
 144 }
 145
 146 /***********************************************************************
 147  *              gluNewQuadric (GLU32.@)
 148  */
 149 extern int gluNewQuadric();
 150 int WINAPI wine_gluNewQuadric() {
 151         return gluNewQuadric();
 152 }
 153
 154 /***********************************************************************
 155  *              gluDeleteQuadric (GLU32.@)
 156  */
 157 extern int gluDeleteQuadric(void *arg0);
 158 int WINAPI wine_gluDeleteQuadric(void *arg0) {
 159         return gluDeleteQuadric(arg0);
 160 }
 161
 162 /***********************************************************************
 163  *              gluQuadricDrawStyle (GLU32.@)
 164  */
 165 extern int gluQuadricDrawStyle(void *arg0,int arg1);
 166 int WINAPI wine_gluQuadricDrawStyle(void *arg0,int arg1) {
 167         return gluQuadricDrawStyle(arg0,arg1);
 168 }
 169
 170 /***********************************************************************
 171  *              gluQuadricOrientation (GLU32.@)
 172  */
 173 extern int gluQuadricOrientation(void *arg0,int arg1);
 174 int WINAPI wine_gluQuadricOrientation(void *arg0,int arg1) {
 175         return gluQuadricOrientation(arg0,arg1);
 176 }
 177
 178 /***********************************************************************
 179  *              gluQuadricNormals (GLU32.@)
 180  */
 181 extern int gluQuadricNormals(void *arg0,int arg1);
 182 int WINAPI wine_gluQuadricNormals(void *arg0,int arg1) {
 183         return gluQuadricNormals(arg0,arg1);
 184 }
 185
 186 /***********************************************************************
 187  *              gluQuadricTexture (GLU32.@)
 188  */
 189 extern int gluQuadricTexture(void *arg0,int arg1);
 190 int WINAPI wine_gluQuadricTexture(void *arg0,int arg1) {
 191         return gluQuadricTexture(arg0,arg1);
 192 }
 193
 194 /***********************************************************************
 195  *              gluQuadricCallback (GLU32.@)
 196  */
 197 extern int gluQuadricCallback(void *arg0,int arg1,void *arg2);
 198 int WINAPI wine_gluQuadricCallback(void *arg0,int arg1,void *arg2) {
 199         return gluQuadricCallback(arg0,arg1,arg2);
 200 }
 201
 202 /***********************************************************************
 203  *              gluCylinder (GLU32.@)
 204  */
 205 extern int gluCylinder(void *arg0,double arg1,double arg2,double arg3,int arg4,int arg5);
 206 int WINAPI wine_gluCylinder(void *arg0,double arg1,double arg2,double arg3,int arg4,int arg5) {
 207         return gluCylinder(arg0,arg1,arg2,arg3,arg4,arg5);
 208 }
 209
 210 /***********************************************************************
 211  *              gluSphere (GLU32.@)
 212  */
 213 extern int gluSphere(void *arg0,double arg1,int arg2,int arg3);
 214 int WINAPI wine_gluSphere(void *arg0,double arg1,int arg2,int arg3) {
 215         return gluSphere(arg0,arg1,arg2,arg3);
 216 }
 217
 218 /***********************************************************************
 219  *              gluDisk (GLU32.@)
 220  */
 221 extern int gluDisk(void *arg0,double arg1,double arg2,int arg3,int arg4);
 222 int WINAPI wine_gluDisk(void *arg0,double arg1,double arg2,int arg3,int arg4) {
 223         return gluDisk(arg0,arg1,arg2,arg3,arg4);
 224 }
 225
 226 /***********************************************************************
 227  *              gluPartialDisk (GLU32.@)
 228  */
 229 extern int gluPartialDisk(void *arg0,double arg1,double arg2,int arg3,int arg4,double arg5,double arg6);
 230 int WINAPI wine_gluPartialDisk(void *arg0,double arg1,double arg2,int arg3,int arg4,double arg5,double arg6) {
 231         return gluPartialDisk(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
 232 }
 233
 234 /***********************************************************************
 235  *              gluNewNurbsRenderer (GLU32.@)
 236  */
 237 extern int gluNewNurbsRenderer();
 238 int WINAPI wine_gluNewNurbsRenderer() {
 239         return gluNewNurbsRenderer();
 240 }
 241
 242 /***********************************************************************
 243  *              gluDeleteNurbsRenderer (GLU32.@)
 244  */
 245 extern int gluDeleteNurbsRenderer(void *arg0);
 246 int WINAPI wine_gluDeleteNurbsRenderer(void *arg0) {
 247         return gluDeleteNurbsRenderer(arg0);
 248 }
 249
 250 /***********************************************************************
 251  *              gluLoadSamplingMatrices (GLU32.@)
 252  */
 253 extern int gluLoadSamplingMatrices(void *arg0,void *arg1,void *arg2,void *arg3);
 254 int WINAPI wine_gluLoadSamplingMatrices(void *arg0,void *arg1,void *arg2,void *arg3) {
 255         return gluLoadSamplingMatrices(arg0,arg1,arg2,arg3);
 256 }
 257
 258 /***********************************************************************
 259  *              gluNurbsProperty (GLU32.@)
 260  */
 261 extern int gluNurbsProperty(void *arg0,int arg1,int arg2);
 262 int WINAPI wine_gluNurbsProperty(void *arg0,int arg1,int arg2) {
 263         return gluNurbsProperty(arg0,arg1,arg2);
 264 }
 265
 266 /***********************************************************************
 267  *              gluGetNurbsProperty (GLU32.@)
 268  */
 269 extern int gluGetNurbsProperty(void *arg0,int arg1,void *arg2);
 270 int WINAPI wine_gluGetNurbsProperty(void *arg0,int arg1,void *arg2) {
 271         return gluGetNurbsProperty(arg0,arg1,arg2);
 272 }
 273
 274 /***********************************************************************
 275  *              gluBeginCurve (GLU32.@)
 276  */
 277 extern int gluBeginCurve(void *arg0);
 278 int WINAPI wine_gluBeginCurve(void *arg0) {
 279         return gluBeginCurve(arg0);
 280 }
 281
 282 /***********************************************************************
 283  *              gluEndCurve (GLU32.@)
 284  */
 285 extern int gluEndCurve(void *arg0);
 286 int WINAPI wine_gluEndCurve(void *arg0) {
 287         return gluEndCurve(arg0);
 288 }
 289
 290 /***********************************************************************
 291  *              gluNurbsCurve (GLU32.@)
 292  */
 293 extern int gluNurbsCurve(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6);
 294 int WINAPI wine_gluNurbsCurve(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6) {
 295         return gluNurbsCurve(arg0,arg1,arg2,arg3,arg4,arg5,arg6);
 296 }
 297
 298 /***********************************************************************
 299  *              gluBeginSurface (GLU32.@)
 300  */
 301 extern int gluBeginSurface(void *arg0);
 302 int WINAPI wine_gluBeginSurface(void *arg0) {
 303         return gluBeginSurface(arg0);
 304 }
 305
 306 /***********************************************************************
 307  *              gluEndSurface (GLU32.@)
 308  */
 309 extern int gluEndSurface(void *arg0);
 310 int WINAPI wine_gluEndSurface(void *arg0) {
 311         return gluEndSurface(arg0);
 312 }
 313
 314 /***********************************************************************
 315  *              gluNurbsSurface (GLU32.@)
 316  */
 317 extern int gluNurbsSurface(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6,void *arg7,int arg8,int arg9,int arg10);
 318 int WINAPI wine_gluNurbsSurface(void *arg0,int arg1,void *arg2,int arg3,void *arg4,int arg5,int arg6,void *arg7,int arg8,int arg9,int arg10) {
 319         return gluNurbsSurface(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
 320 }
 321
 322 /***********************************************************************
 323  *              gluBeginTrim (GLU32.@)
 324  */
 325 extern int gluBeginTrim(void *arg0);
 326 int WINAPI wine_gluBeginTrim(void *arg0) {
 327         return gluBeginTrim(arg0);
 328 }
 329
 330 /***********************************************************************
 331  *              gluEndTrim (GLU32.@)
 332  */
 333 extern int gluEndTrim(void *arg0);
 334 int WINAPI wine_gluEndTrim(void *arg0) {
 335         return gluEndTrim(arg0);
 336 }
 337
 338 /***********************************************************************
 339  *              gluPwlCurve (GLU32.@)
 340  */
 341 extern int gluPwlCurve(void *arg0,int arg1,void *arg2,int arg3,int arg4);
 342 int WINAPI wine_gluPwlCurve(void *arg0,int arg1,void *arg2,int arg3,int arg4) {
 343         return gluPwlCurve(arg0,arg1,arg2,arg3,arg4);
 344 }
 345
 346 /***********************************************************************
 347  *              gluNurbsCallback (GLU32.@)
 348  */
 349 extern int gluNurbsCallback(void *arg0,int arg1,void *arg2);
 350 int WINAPI wine_gluNurbsCallback(void *arg0,int arg1,void *arg2) {
 351         return gluNurbsCallback(arg0,arg1,arg2);
 352 }
 353
 354 /***********************************************************************
 355  *              gluBeginPolygon (GLU32.@)
 356  */
 357 extern int gluBeginPolygon(void *arg0);
 358 int WINAPI wine_gluBeginPolygon(void *arg0) {
 359         return gluBeginPolygon(arg0);
 360 }
 361
 362 /***********************************************************************
 363  *              gluEndPolygon (GLU32.@)
 364  */
 365 extern int gluEndPolygon(void *arg0);
 366 int WINAPI wine_gluEndPolygon(void *arg0) {
 367         return gluEndPolygon(arg0);
 368 }
 369
 370 /***********************************************************************
 371  *              gluNextContour (GLU32.@)
 372  */
 373 extern int gluNextContour(void *arg0,int arg1);
 374 int WINAPI wine_gluNextContour(void *arg0,int arg1) {
 375         return gluNextContour(arg0,arg1);
 376 }
 377
 378 /***********************************************************************
 379  *              gluGetString (GLU32.@)
 380  */
 381 extern int gluGetString(int arg0);
 382 int WINAPI wine_gluGetString(int arg0) {
 383         return gluGetString(arg0);
 384 }
 385
 386 /***********************************************************************
 387  *              gluCheckExtension (GLU32.@)
 388  */
 389 int WINAPI
 390 wine_gluCheckExtension( const char *extName, void *extString ) {
 391     return 0;
 392 }
 393
 394 extern void *gluNewTess(void);
 395 extern void gluDeleteTess(void *);
 396
 397 /***********************************************************************
 398  *              gluNewTess (GLU32.@)
 399  */
 400 void * WINAPI wine_gluNewTess(void)
 401 {
 402     void *tess;
 403     wine_tess_t *ret;
 404
 405     if((tess = gluNewTess()) == NULL)
 406        return NULL;
 407
 408     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
 409     if(!ret) {
 410         gluDeleteTess(tess);
 411         return NULL;
 412     }
 413     ret->tess = tess;
 414     return ret;
 415 }
 416
 417 /***********************************************************************
 418  *              gluDeleteTess (GLU32.@)
 419  */
 420 void WINAPI wine_gluDeleteTess(void *tess)
 421 {
 422     wine_tess_t *wine_tess = tess;
 423     gluDeleteTess(wine_tess->tess);
 424     HeapFree(GetProcessHeap(), 0, wine_tess);
 425     return;
 426 }
 427
 428 /***********************************************************************
 429  *              gluTessBeginPolygon (GLU32.@)
 430  */
 431 extern void gluTessBeginPolygon(void *, void *);
 432 void WINAPI wine_gluTessBeginPolygon(void *tess, void *polygon_data)
 433 {
 434     wine_tess_t *wine_tess = tess;
 435     wine_tess->polygon_data = polygon_data;
 436
 437     gluTessBeginPolygon(wine_tess->tess, wine_tess);
 438 }
 439
 440 /***********************************************************************
 441  *              gluTessEndPolygon (GLU32.@)
 442  */
 443 extern void gluTessEndPolygon(void *);
 444 void WINAPI wine_gluTessEndPolygon(void *tess)
 445 {
 446     wine_tess_t *wine_tess = tess;
 447     gluTessEndPolygon(wine_tess->tess);
 448 }
 449
 450
 451 void wine_glu_tess_begin_data(int type, wine_tess_t *wine_tess)
 452 {
 453     if(wine_tess->cb_tess_begin_data)
 454         wine_tess->cb_tess_begin_data(type, wine_tess->polygon_data);
 455     else
 456         wine_tess->cb_tess_begin(type);
 457 }
 458
 459 void wine_glu_tess_vertex_data(void *vertex_data, wine_tess_t *wine_tess)
 460 {
 461     if(wine_tess->cb_tess_vertex_data)
 462         wine_tess->cb_tess_vertex_data(vertex_data, wine_tess->polygon_data);
 463     else
 464         wine_tess->cb_tess_vertex(vertex_data);
 465 }
 466
 467 void wine_glu_tess_end_data(wine_tess_t *wine_tess)
 468 {
 469     if(wine_tess->cb_tess_end_data)
 470         wine_tess->cb_tess_end_data(wine_tess->polygon_data);
 471     else
 472         wine_tess->cb_tess_end();
 473 }
 474
 475 void wine_glu_tess_error_data(int error, wine_tess_t *wine_tess)
 476 {
 477     if(wine_tess->cb_tess_error_data)
 478         wine_tess->cb_tess_error_data(error, wine_tess->polygon_data);
 479     else
 480         wine_tess->cb_tess_error(error);
 481 }
 482
 483 void wine_glu_tess_edge_flag_data(int flag, wine_tess_t *wine_tess)
 484 {
 485     if(wine_tess->cb_tess_edge_flag_data)
 486         wine_tess->cb_tess_edge_flag_data(flag, wine_tess->polygon_data);
 487     else
 488         wine_tess->cb_tess_edge_flag(flag);
 489 }
 490
 491 void wine_glu_tess_combine_data(double *coords, void *vertex_data, float *weight, void **outData,
 492                                 wine_tess_t *wine_tess)
 493 {
 494     if(wine_tess->cb_tess_combine_data)
 495         wine_tess->cb_tess_combine_data(coords, vertex_data, weight, outData, wine_tess->polygon_data);
 496     else
 497         wine_tess->cb_tess_combine(coords, vertex_data, weight, outData);
 498 }
 499
 500
 501 /***********************************************************************
 502  *              gluTessCallback (GLU32.@)
 503  */
 504 extern void gluTessCallback(void *,int,void *);
 505 void WINAPI wine_gluTessCallback(void *tess,int which,void *fn)
 506 {
 507     wine_tess_t *wine_tess = tess;
 508     switch(which) {
 509     case GLU_TESS_BEGIN:
 510         wine_tess->cb_tess_begin = fn;
 511         fn = wine_glu_tess_begin_data;
 512         which += 6;
 513         break;
 514     case GLU_TESS_VERTEX:
 515         wine_tess->cb_tess_vertex = fn;
 516         fn = wine_glu_tess_vertex_data;
 517         which += 6;
 518         break;
 519     case GLU_TESS_END:
 520         wine_tess->cb_tess_end = fn;
 521         fn = wine_glu_tess_end_data;
 522         which += 6;
 523         break;
 524     case GLU_TESS_ERROR:
 525         wine_tess->cb_tess_error = fn;
 526         fn = wine_glu_tess_error_data;
 527         which += 6;
 528         break;
 529     case GLU_TESS_EDGE_FLAG:
 530         wine_tess->cb_tess_edge_flag = fn;
 531         fn = wine_glu_tess_edge_flag_data;
 532         which += 6;
 533         break;
 534     case GLU_TESS_COMBINE:
 535         wine_tess->cb_tess_combine = fn;
 536         fn = wine_glu_tess_combine_data;
 537         which += 6;
 538         break;
 539     case GLU_TESS_BEGIN_DATA:
 540         wine_tess->cb_tess_begin_data = fn;
 541         fn = wine_glu_tess_begin_data;
 542         break;
 543     case GLU_TESS_VERTEX_DATA:
 544         wine_tess->cb_tess_vertex_data = fn;
 545         fn = wine_glu_tess_vertex_data;
 546         break;
 547     case GLU_TESS_END_DATA:
 548         wine_tess->cb_tess_end_data = fn;
 549         fn = wine_glu_tess_end_data;
 550         break;
 551     case GLU_TESS_ERROR_DATA:
 552         wine_tess->cb_tess_error_data = fn;
 553         fn = wine_glu_tess_error_data;
 554         break;
 555     case GLU_TESS_EDGE_FLAG_DATA:
 556         wine_tess->cb_tess_edge_flag_data = fn;
 557         fn = wine_glu_tess_edge_flag_data;
 558         break;
 559     case GLU_TESS_COMBINE_DATA:
 560         wine_tess->cb_tess_combine_data = fn;
 561         fn = wine_glu_tess_combine_data;
 562         break;
 563     default:
 564         ERR("Unknown callback %d\n", which);
 565         break;
 566     }
 567     gluTessCallback(wine_tess->tess, which, fn);
 568 }
 569
 570 /***********************************************************************
 571  *              gluTessBeginContour (GLU32.@)
 572  */
 573 extern void gluTessBeginContour(void *);
 574 void WINAPI wine_gluTessBeginContour(void *tess)
 575 {
 576     wine_tess_t *wine_tess = tess;
 577     gluTessBeginContour(wine_tess->tess);
 578 }
 579
 580 /***********************************************************************
 581  *              gluTessEndContour (GLU32.@)
 582  */
 583 extern void gluTessEndContour(void *);
 584 void WINAPI wine_gluTessEndContour(void *tess)
 585 {
 586     wine_tess_t *wine_tess = tess;
 587     gluTessEndContour(wine_tess->tess);
 588 }
 589
 590 /***********************************************************************
 591  *              gluTessVertex (GLU32.@)
 592  */
 593 extern void gluTessVertex(void *, void *, void *);
 594 void WINAPI wine_gluTessVertex(void *tess,void *arg1,void *arg2)
 595 {
 596     wine_tess_t *wine_tess = tess;
 597     gluTessVertex(wine_tess->tess, arg1, arg2);
 598 }
 599
 600
 601 /***********************************************************************
 602  *              gluTessProperty (GLU32.@)
 603  */
 604 extern void gluTessProperty(void *, int, double);
 605 void WINAPI wine_gluTessProperty(void *tess, int arg1, double arg2)
 606 {
 607     wine_tess_t *wine_tess = tess;
 608     gluTessProperty(wine_tess->tess, arg1, arg2);
 609 }
 610
 611 /***********************************************************************
 612  *              gluTessNormal (GLU32.@)
 613  */
 614 extern void gluTessNormal(void *, double, double, double);
 615 void WINAPI wine_gluTessNormal(void *tess, double arg1, double arg2, double arg3)
 616 {
 617     wine_tess_t *wine_tess = tess;
 618     gluTessNormal(wine_tess->tess, arg1, arg2, arg3);
 619 }