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