dlls/wined3d/gl_compat.c

   1 /*
   2  * Compatibility functions for older GL implementations
   3  *
   4  * Copyright 2008 Stefan Dösinger for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #ifdef HAVE_FLOAT_H
  26 # include <float.h>
  27 #endif
  28
  29 #include "wined3d_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(gl_compat);
  32
  33 /* Start GL_ARB_multitexture emulation */
  34 static void WINE_GLAPI wine_glMultiTexCoord1fARB(GLenum target, GLfloat s) {
  35     if(target != GL_TEXTURE0) {
  36         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  37         return;
  38     }
  39     glTexCoord1f(s);
  40 }
  41
  42 static void WINE_GLAPI wine_glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) {
  43     if(target != GL_TEXTURE0) {
  44         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  45         return;
  46     }
  47     glTexCoord1fv(v);
  48 }
  49
  50 static void WINE_GLAPI wine_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) {
  51     if(target != GL_TEXTURE0) {
  52         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  53         return;
  54     }
  55     glTexCoord2f(s, t);
  56 }
  57
  58 static void WINE_GLAPI wine_glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) {
  59     if(target != GL_TEXTURE0) {
  60         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  61         return;
  62     }
  63     glTexCoord2fv(v);
  64 }
  65
  66 static void WINE_GLAPI wine_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) {
  67     if(target != GL_TEXTURE0) {
  68         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  69         return;
  70     }
  71     glTexCoord3f(s, t, r);
  72 }
  73
  74 static void WINE_GLAPI wine_glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) {
  75     if(target != GL_TEXTURE0) {
  76         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  77         return;
  78     }
  79     glTexCoord3fv(v);
  80 }
  81
  82 static void WINE_GLAPI wine_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
  83     if(target != GL_TEXTURE0) {
  84         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  85         return;
  86     }
  87     glTexCoord4f(s, t, r, q);
  88 }
  89
  90 static void WINE_GLAPI wine_glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) {
  91     if(target != GL_TEXTURE0) {
  92         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  93         return;
  94     }
  95     glTexCoord4fv(v);
  96 }
  97
  98 static void WINE_GLAPI wine_glMultiTexCoord2svARB(GLenum target, const GLshort *v) {
  99     if(target != GL_TEXTURE0) {
 100         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 101         return;
 102     }
 103     glTexCoord2sv(v);
 104 }
 105
 106 static void WINE_GLAPI wine_glMultiTexCoord4svARB(GLenum target, const GLshort *v) {
 107     if(target != GL_TEXTURE0) {
 108         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 109         return;
 110     }
 111     glTexCoord4sv(v);
 112 }
 113
 114 static void WINE_GLAPI wine_glActiveTextureARB(GLenum texture) {
 115     if(texture != GL_TEXTURE0) {
 116         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 117         return;
 118     }
 119 }
 120
 121 static void WINE_GLAPI wine_glClientActiveTextureARB(GLenum texture) {
 122     if(texture != GL_TEXTURE0) {
 123         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 124         return;
 125     }
 126 }
 127
 128 static void (WINE_GLAPI *old_multitex_glGetIntegerv) (GLenum pname, GLint* params) = NULL;
 129 static void WINE_GLAPI wine_glGetIntegerv(GLenum pname, GLint* params) {
 130     switch(pname) {
 131         case GL_ACTIVE_TEXTURE:         *params = 0;    break;
 132         case GL_MAX_TEXTURE_UNITS_ARB:  *params = 1;    break;
 133         default: old_multitex_glGetIntegerv(pname, params);
 134     }
 135 }
 136
 137 static void (WINE_GLAPI *old_multitex_glGetFloatv) (GLenum pname, GLfloat* params) = NULL;
 138 static void WINE_GLAPI wine_glGetFloatv(GLenum pname, GLfloat* params) {
 139     if (pname == GL_ACTIVE_TEXTURE) *params = 0.0f;
 140     else old_multitex_glGetFloatv(pname, params);
 141 }
 142
 143 static void (WINE_GLAPI *old_multitex_glGetDoublev) (GLenum pname, GLdouble* params) = NULL;
 144 static void WINE_GLAPI wine_glGetDoublev(GLenum pname, GLdouble* params) {
 145     if(pname == GL_ACTIVE_TEXTURE) *params = 0.0;
 146     else old_multitex_glGetDoublev(pname, params);
 147 }
 148
 149 /* Start GL_EXT_fogcoord emulation */
 150 static void (WINE_GLAPI *old_fogcoord_glEnable) (GLenum cap) = NULL;
 151 static void WINE_GLAPI wine_glEnable(GLenum cap) {
 152     if(cap == GL_FOG) {
 153         struct wined3d_context *ctx = context_get_current();
 154         ctx->fog_enabled = 1;
 155         if(ctx->gl_fog_source != GL_FRAGMENT_DEPTH_EXT) return;
 156     }
 157     old_fogcoord_glEnable(cap);
 158 }
 159
 160 static void (WINE_GLAPI *old_fogcoord_glDisable) (GLenum cap) = NULL;
 161 static void WINE_GLAPI wine_glDisable(GLenum cap) {
 162     if(cap == GL_FOG) {
 163         struct wined3d_context *ctx = context_get_current();
 164         ctx->fog_enabled = 0;
 165         if(ctx->gl_fog_source != GL_FRAGMENT_DEPTH_EXT) return;
 166     }
 167     old_fogcoord_glDisable(cap);
 168 }
 169
 170 static void (WINE_GLAPI *old_fogcoord_glFogi) (GLenum pname, GLint param) = NULL;
 171 static void WINE_GLAPI wine_glFogi(GLenum pname, GLint param) {
 172     struct wined3d_context *ctx = context_get_current();
 173
 174     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 175         ctx->gl_fog_source = param;
 176         if(param == GL_FRAGMENT_DEPTH_EXT) {
 177             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 178         } else {
 179             WARN("Fog coords activated, but not supported. Using slow emulation\n");
 180             old_fogcoord_glDisable(GL_FOG);
 181         }
 182     } else {
 183         if(pname == GL_FOG_START) {
 184             ctx->fogstart = (float) param;
 185         } else if(pname == GL_FOG_END) {
 186             ctx->fogend = (float) param;
 187         }
 188         old_fogcoord_glFogi(pname, param);
 189     }
 190 }
 191
 192 static void (WINE_GLAPI *old_fogcoord_glFogiv) (GLenum pname, const GLint *param) = NULL;
 193 static void WINE_GLAPI wine_glFogiv(GLenum pname, const GLint *param) {
 194     struct wined3d_context *ctx = context_get_current();
 195     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 196         ctx->gl_fog_source = *param;
 197         if(*param == GL_FRAGMENT_DEPTH_EXT) {
 198             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 199         } else {
 200             WARN("Fog coords activated, but not supported. Using slow emulation\n");
 201             old_fogcoord_glDisable(GL_FOG);
 202         }
 203     } else {
 204         if(pname == GL_FOG_START) {
 205             ctx->fogstart = (float) *param;
 206         } else if(pname == GL_FOG_END) {
 207             ctx->fogend = (float) *param;
 208         }
 209         old_fogcoord_glFogiv(pname, param);
 210     }
 211 }
 212
 213 static void (WINE_GLAPI *old_fogcoord_glFogf) (GLenum pname, GLfloat param) = NULL;
 214 static void WINE_GLAPI wine_glFogf(GLenum pname, GLfloat param) {
 215     struct wined3d_context *ctx = context_get_current();
 216     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 217         ctx->gl_fog_source = (GLint) param;
 218         if(param == GL_FRAGMENT_DEPTH_EXT) {
 219             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 220         } else {
 221             WARN("Fog coords activated, but not supported. Using slow emulation\n");
 222             old_fogcoord_glDisable(GL_FOG);
 223         }
 224     } else {
 225         if(pname == GL_FOG_START) {
 226             ctx->fogstart = param;
 227         } else if(pname == GL_FOG_END) {
 228             ctx->fogend = param;
 229         }
 230         old_fogcoord_glFogf(pname, param);
 231     }
 232 }
 233
 234 static void (WINE_GLAPI *old_fogcoord_glFogfv) (GLenum pname, const GLfloat *param) = NULL;
 235 static void WINE_GLAPI wine_glFogfv(GLenum pname, const GLfloat *param) {
 236     struct wined3d_context *ctx = context_get_current();
 237     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 238         ctx->gl_fog_source = (GLint) *param;
 239         if(*param == GL_FRAGMENT_DEPTH_EXT) {
 240             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 241         } else {
 242             WARN("Fog coords activated, but not supported. Using slow emulation\n");
 243             old_fogcoord_glDisable(GL_FOG);
 244         }
 245     } else {
 246         if(pname == GL_FOG_COLOR) {
 247             ctx->fogcolor[0] = param[0];
 248             ctx->fogcolor[1] = param[1];
 249             ctx->fogcolor[2] = param[2];
 250             ctx->fogcolor[3] = param[3];
 251         } else if(pname == GL_FOG_START) {
 252             ctx->fogstart = *param;
 253         } else if(pname == GL_FOG_END) {
 254             ctx->fogend = *param;
 255         }
 256         old_fogcoord_glFogfv(pname, param);
 257     }
 258 }
 259
 260 static void (WINE_GLAPI *old_fogcoord_glVertex4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w) = NULL;
 261 static void (WINE_GLAPI *old_fogcoord_glVertex4fv) (const GLfloat *pos) = NULL;
 262 static void (WINE_GLAPI *old_fogcoord_glVertex3f) (GLfloat x, GLfloat y, GLfloat z) = NULL;
 263 static void (WINE_GLAPI *old_fogcoord_glVertex3fv) (const GLfloat *pos) = NULL;
 264 static void (WINE_GLAPI *old_fogcoord_glColor4f) (GLfloat r, GLfloat g, GLfloat b, GLfloat a) = NULL;
 265 static void (WINE_GLAPI *old_fogcoord_glColor4fv) (const GLfloat *color) = NULL;
 266 static void (WINE_GLAPI *old_fogcoord_glColor3f) (GLfloat r, GLfloat g, GLfloat b) = NULL;
 267 static void (WINE_GLAPI *old_fogcoord_glColor3fv) (const GLfloat *color) = NULL;
 268 static void (WINE_GLAPI *old_fogcoord_glColor4ub) (GLubyte r, GLubyte g, GLubyte b, GLubyte a) = NULL;
 269 static void (WINE_GLAPI *old_fogcoord_glFogCoordfEXT) (GLfloat f) = NULL;
 270 static void (WINE_GLAPI *old_fogcoord_glFogCoorddEXT) (GLdouble f) = NULL;
 271 static void (WINE_GLAPI *old_fogcoord_glFogCoordfvEXT) (const GLfloat *f) = NULL;
 272 static void (WINE_GLAPI *old_fogcoord_glFogCoorddvEXT) (const GLdouble *f) = NULL;
 273
 274 static void WINE_GLAPI wine_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
 275     struct wined3d_context *ctx = context_get_current();
 276     if(ctx->gl_fog_source == GL_FOG_COORDINATE_EXT && ctx->fog_enabled) {
 277         GLfloat c[4] = {ctx->color[0], ctx->color[1], ctx->color[2], ctx->color[3]};
 278         GLfloat i;
 279
 280         i = (ctx->fogend - ctx->fog_coord_value) / (ctx->fogend - ctx->fogstart);
 281         c[0] = i * c[0] + (1.0f - i) * ctx->fogcolor[0];
 282         c[1] = i * c[1] + (1.0f - i) * ctx->fogcolor[1];
 283         c[2] = i * c[2] + (1.0f - i) * ctx->fogcolor[2];
 284
 285         old_fogcoord_glColor4f(c[0], c[1], c[2], c[3]);
 286         old_fogcoord_glVertex4f(x, y, z, w);
 287     } else {
 288         old_fogcoord_glVertex4f(x, y, z, w);
 289     }
 290 }
 291
 292 static void WINE_GLAPI wine_glVertex4fv(const GLfloat *pos) {
 293     wine_glVertex4f(pos[0], pos[1], pos[2], pos[3]);
 294 }
 295
 296 static void WINE_GLAPI wine_glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
 297     wine_glVertex4f(x, y, z, 1.0f);
 298 }
 299
 300 static void WINE_GLAPI wine_glVertex3fv(const GLfloat *pos) {
 301     wine_glVertex4f(pos[0], pos[1], pos[2], 1.0f);
 302 }
 303
 304 static void WINE_GLAPI wine_glColor4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
 305     struct wined3d_context *ctx = context_get_current();
 306     ctx->color[0] = r;
 307     ctx->color[1] = g;
 308     ctx->color[2] = b;
 309     ctx->color[3] = a;
 310     old_fogcoord_glColor4f(r, g, b, a);
 311 }
 312
 313 static void WINE_GLAPI wine_glColor4fv(const GLfloat *c) {
 314     wine_glColor4f(c[0], c[1], c[2], c[3]);
 315 }
 316
 317 static void WINE_GLAPI wine_glColor3f(GLfloat r, GLfloat g, GLfloat b) {
 318     wine_glColor4f(r, g, b, 1.0f);
 319 }
 320
 321 static void WINE_GLAPI wine_glColor3fv(const GLfloat *c) {
 322     wine_glColor4f(c[0], c[1], c[2], 1.0f);
 323 }
 324
 325 static void WINE_GLAPI wine_glColor4ub(GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
 326     wine_glColor4f(r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f);
 327 }
 328
 329 /* In D3D the fog coord is a UBYTE, so there's no problem with using the single
 330  * precision function
 331  */
 332 static void WINE_GLAPI wine_glFogCoordfEXT(GLfloat f) {
 333     struct wined3d_context *ctx = context_get_current();
 334     ctx->fog_coord_value = f;
 335 }
 336 static void WINE_GLAPI wine_glFogCoorddEXT(GLdouble f) {
 337     wine_glFogCoordfEXT((GLfloat) f);
 338 }
 339 static void WINE_GLAPI wine_glFogCoordfvEXT(const GLfloat *f) {
 340     wine_glFogCoordfEXT(*f);
 341 }
 342 static void WINE_GLAPI wine_glFogCoorddvEXT(const GLdouble *f) {
 343     wine_glFogCoordfEXT((GLfloat) *f);
 344 }
 345
 346 /* End GL_EXT_fog_coord emulation */
 347
 348 void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info)
 349 {
 350     if (!gl_info->supported[ARB_MULTITEXTURE])
 351     {
 352         TRACE("Applying GL_ARB_multitexture emulation hooks\n");
 353         gl_info->glActiveTextureARB         = wine_glActiveTextureARB;
 354         gl_info->glClientActiveTextureARB   = wine_glClientActiveTextureARB;
 355         gl_info->glMultiTexCoord1fARB       = wine_glMultiTexCoord1fARB;
 356         gl_info->glMultiTexCoord1fvARB      = wine_glMultiTexCoord1fvARB;
 357         gl_info->glMultiTexCoord2fARB       = wine_glMultiTexCoord2fARB;
 358         gl_info->glMultiTexCoord2fvARB      = wine_glMultiTexCoord2fvARB;
 359         gl_info->glMultiTexCoord3fARB       = wine_glMultiTexCoord3fARB;
 360         gl_info->glMultiTexCoord3fvARB      = wine_glMultiTexCoord3fvARB;
 361         gl_info->glMultiTexCoord4fARB       = wine_glMultiTexCoord4fARB;
 362         gl_info->glMultiTexCoord4fvARB      = wine_glMultiTexCoord4fvARB;
 363         gl_info->glMultiTexCoord2svARB      = wine_glMultiTexCoord2svARB;
 364         gl_info->glMultiTexCoord4svARB      = wine_glMultiTexCoord4svARB;
 365         if(old_multitex_glGetIntegerv) {
 366             FIXME("GL_ARB_multitexture glGetIntegerv hook already applied\n");
 367         } else {
 368             old_multitex_glGetIntegerv = glGetIntegerv;
 369             glGetIntegerv = wine_glGetIntegerv;
 370         }
 371         if(old_multitex_glGetFloatv) {
 372             FIXME("GL_ARB_multitexture glGetGloatv hook already applied\n");
 373         } else {
 374             old_multitex_glGetFloatv = glGetFloatv;
 375             glGetFloatv = wine_glGetFloatv;
 376         }
 377         if(old_multitex_glGetDoublev) {
 378             FIXME("GL_ARB_multitexture glGetDoublev hook already applied\n");
 379         } else {
 380             old_multitex_glGetDoublev = glGetDoublev;
 381             glGetDoublev = wine_glGetDoublev;
 382         }
 383         gl_info->supported[ARB_MULTITEXTURE] = TRUE;
 384     }
 385
 386     if (!gl_info->supported[EXT_FOG_COORD])
 387     {
 388         /* This emulation isn't perfect. There are a number of potential problems, but they should
 389          * not matter in practise:
 390          *
 391          * Fog vs fragment shader: If we are using GL_ARB_fragment_program with the fog option, the
 392          * glDisable(GL_FOG) here won't matter. However, if we have GL_ARB_fragment_program, it is pretty
 393          * unlikely that we don't have GL_EXT_fog_coord. Besides, we probably have GL_ARB_vertex_program
 394          * too, which would allow fog coord emulation in a fixed function vertex pipeline replacement.
 395          *
 396          * Fog vs texture: We apply the fog in the vertex color. An app could set up texturing settings which
 397          * ignore the vertex color, thus effectively disabling our fog. However, in D3D this type of fog is
 398          * a per-vertex fog too, so the apps shouldn't do that.
 399          *
 400          * Fog vs lighting: The app could in theory use D3DFOG_NONE table and D3DFOG_NONE vertex fog with
 401          * untransformed vertices. That enables lighting and fog coords at the same time, and the lighting
 402          * calculations could affect the already blended in fog color. There's nothing we can do against that,
 403          * but most apps using fog color do their own lighting too and often even use RHW vertices. So live
 404          * with it.
 405          */
 406         TRACE("Applying GL_ARB_fog_coord emulation hooks\n");
 407
 408         /* This probably means that the implementation doesn't advertise the extension, but implicitly supports
 409          * it via the GL core version, or someone messed around in the extension table in directx.c. Add version-
 410          * dependent loading for this extension if we ever hit this situation
 411          */
 412         if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
 413         {
 414             FIXME("GL implementation supports GL_ARB_fragment_program but not GL_EXT_fog_coord\n");
 415             FIXME("The fog coord emulation will most likely fail\n");
 416         }
 417         else if (gl_info->supported[ARB_FRAGMENT_SHADER])
 418         {
 419             FIXME("GL implementation supports GL_ARB_fragment_shader but not GL_EXT_fog_coord\n");
 420             FIXME("The fog coord emulation will most likely fail\n");
 421         }
 422
 423         if(old_fogcoord_glFogi) {
 424             FIXME("GL_EXT_fogcoord glFogi hook already applied\n");
 425         } else {
 426             old_fogcoord_glFogi = glFogi;
 427             glFogi = wine_glFogi;
 428         }
 429         if(old_fogcoord_glFogiv) {
 430             FIXME("GL_EXT_fogcoord glFogiv hook already applied\n");
 431         } else {
 432             old_fogcoord_glFogiv = glFogiv;
 433             glFogiv = wine_glFogiv;
 434         }
 435         if(old_fogcoord_glFogf) {
 436             FIXME("GL_EXT_fogcoord glFogf hook already applied\n");
 437         } else {
 438             old_fogcoord_glFogf = glFogf;
 439             glFogf = wine_glFogf;
 440         }
 441         if(old_fogcoord_glFogfv) {
 442             FIXME("GL_EXT_fogcoord glFogfv hook already applied\n");
 443         } else {
 444             old_fogcoord_glFogfv = glFogfv;
 445             glFogfv = wine_glFogfv;
 446         }
 447         if(old_fogcoord_glEnable) {
 448             FIXME("GL_EXT_fogcoord glEnable hook already applied\n");
 449         } else {
 450             old_fogcoord_glEnable = glEnableWINE;
 451             glEnableWINE = wine_glEnable;
 452         }
 453         if(old_fogcoord_glDisable) {
 454             FIXME("GL_EXT_fogcoord glDisable hook already applied\n");
 455         } else {
 456             old_fogcoord_glDisable = glDisableWINE;
 457             glDisableWINE = wine_glDisable;
 458         }
 459
 460         if(old_fogcoord_glVertex4f) {
 461             FIXME("GL_EXT_fogcoord glVertex4f hook already applied\n");
 462         } else {
 463             old_fogcoord_glVertex4f = glVertex4f;
 464             glVertex4f = wine_glVertex4f;
 465         }
 466         if(old_fogcoord_glVertex4fv) {
 467             FIXME("GL_EXT_fogcoord glVertex4fv hook already applied\n");
 468         } else {
 469             old_fogcoord_glVertex4fv = glVertex4fv;
 470             glVertex4fv = wine_glVertex4fv;
 471         }
 472         if(old_fogcoord_glVertex3f) {
 473             FIXME("GL_EXT_fogcoord glVertex3f hook already applied\n");
 474         } else {
 475             old_fogcoord_glVertex3f = glVertex3f;
 476             glVertex3f = wine_glVertex3f;
 477         }
 478         if(old_fogcoord_glVertex3fv) {
 479             FIXME("GL_EXT_fogcoord glVertex3fv hook already applied\n");
 480         } else {
 481             old_fogcoord_glVertex3fv = glVertex3fv;
 482             glVertex3fv = wine_glVertex3fv;
 483         }
 484
 485         if(old_fogcoord_glColor4f) {
 486             FIXME("GL_EXT_fogcoord glColor4f hook already applied\n");
 487         } else {
 488             old_fogcoord_glColor4f = glColor4f;
 489             glColor4f = wine_glColor4f;
 490         }
 491         if(old_fogcoord_glColor4fv) {
 492             FIXME("GL_EXT_fogcoord glColor4fv hook already applied\n");
 493         } else {
 494             old_fogcoord_glColor4fv = glColor4fv;
 495             glColor4fv = wine_glColor4fv;
 496         }
 497         if(old_fogcoord_glColor3f) {
 498             FIXME("GL_EXT_fogcoord glColor3f hook already applied\n");
 499         } else {
 500             old_fogcoord_glColor3f = glColor3f;
 501             glColor3f = wine_glColor3f;
 502         }
 503         if(old_fogcoord_glColor3fv) {
 504             FIXME("GL_EXT_fogcoord glColor3fv hook already applied\n");
 505         } else {
 506             old_fogcoord_glColor3fv = glColor3fv;
 507             glColor3fv = wine_glColor3fv;
 508         }
 509         if(old_fogcoord_glColor4ub) {
 510             FIXME("GL_EXT_fogcoord glColor4ub hook already applied\n");
 511         } else {
 512             old_fogcoord_glColor4ub = glColor4ub;
 513             glColor4ub = wine_glColor4ub;
 514         }
 515
 516         if(old_fogcoord_glFogCoordfEXT) {
 517             FIXME("GL_EXT_fogcoord glFogCoordfEXT hook already applied\n");
 518         } else {
 519             old_fogcoord_glFogCoordfEXT = gl_info->glFogCoordfEXT;
 520             gl_info->glFogCoordfEXT = wine_glFogCoordfEXT;
 521         }
 522         if(old_fogcoord_glFogCoordfvEXT) {
 523             FIXME("GL_EXT_fogcoord glFogCoordfvEXT hook already applied\n");
 524         } else {
 525             old_fogcoord_glFogCoordfvEXT = gl_info->glFogCoordfvEXT;
 526             gl_info->glFogCoordfvEXT = wine_glFogCoordfvEXT;
 527         }
 528         if(old_fogcoord_glFogCoorddEXT) {
 529             FIXME("GL_EXT_fogcoord glFogCoorddEXT hook already applied\n");
 530         } else {
 531             old_fogcoord_glFogCoorddEXT = gl_info->glFogCoorddEXT;
 532             gl_info->glFogCoorddEXT = wine_glFogCoorddEXT;
 533         }
 534         if(old_fogcoord_glFogCoorddvEXT) {
 535             FIXME("GL_EXT_fogcoord glFogCoorddvEXT hook already applied\n");
 536         } else {
 537             old_fogcoord_glFogCoorddvEXT = gl_info->glFogCoorddvEXT;
 538             gl_info->glFogCoorddvEXT = wine_glFogCoorddvEXT;
 539         }
 540         gl_info->supported[EXT_FOG_COORD] = TRUE;
 541     }
 542 }