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 "wined3d_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(gl_compat);
  24 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  25
  26 /* Start GL_ARB_multitexture emulation */
  27 static void WINE_GLAPI wine_glMultiTexCoord1fARB(GLenum target, GLfloat s) {
  28     if(target != GL_TEXTURE0) {
  29         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  30         return;
  31     }
  32     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord1f(s);
  33 }
  34
  35 static void WINE_GLAPI wine_glMultiTexCoord1fvARB(GLenum target, const GLfloat *v) {
  36     if(target != GL_TEXTURE0) {
  37         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  38         return;
  39     }
  40     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord1fv(v);
  41 }
  42
  43 static void WINE_GLAPI wine_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) {
  44     if(target != GL_TEXTURE0) {
  45         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  46         return;
  47     }
  48     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord2f(s, t);
  49 }
  50
  51 static void WINE_GLAPI wine_glMultiTexCoord2fvARB(GLenum target, const GLfloat *v) {
  52     if(target != GL_TEXTURE0) {
  53         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  54         return;
  55     }
  56     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord2fv(v);
  57 }
  58
  59 static void WINE_GLAPI wine_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) {
  60     if(target != GL_TEXTURE0) {
  61         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  62         return;
  63     }
  64     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord3f(s, t, r);
  65 }
  66
  67 static void WINE_GLAPI wine_glMultiTexCoord3fvARB(GLenum target, const GLfloat *v) {
  68     if(target != GL_TEXTURE0) {
  69         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  70         return;
  71     }
  72     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord3fv(v);
  73 }
  74
  75 static void WINE_GLAPI wine_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
  76     if(target != GL_TEXTURE0) {
  77         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  78         return;
  79     }
  80     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord4f(s, t, r, q);
  81 }
  82
  83 static void WINE_GLAPI wine_glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) {
  84     if(target != GL_TEXTURE0) {
  85         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  86         return;
  87     }
  88     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord4fv(v);
  89 }
  90
  91 static void WINE_GLAPI wine_glMultiTexCoord2svARB(GLenum target, const GLshort *v) {
  92     if(target != GL_TEXTURE0) {
  93         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
  94         return;
  95     }
  96     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord2sv(v);
  97 }
  98
  99 static void WINE_GLAPI wine_glMultiTexCoord4svARB(GLenum target, const GLshort *v) {
 100     if(target != GL_TEXTURE0) {
 101         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 102         return;
 103     }
 104     context_get_current()->gl_info->gl_ops.gl.p_glTexCoord4sv(v);
 105 }
 106
 107 static void WINE_GLAPI wine_glActiveTexture(GLenum texture)
 108 {
 109     if(texture != GL_TEXTURE0) {
 110         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 111         return;
 112     }
 113 }
 114
 115 static void WINE_GLAPI wine_glClientActiveTextureARB(GLenum texture) {
 116     if(texture != GL_TEXTURE0) {
 117         ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
 118         return;
 119     }
 120 }
 121
 122 static void (WINE_GLAPI *old_multitex_glGetIntegerv) (GLenum pname, GLint* params) = NULL;
 123 static void WINE_GLAPI wine_glGetIntegerv(GLenum pname, GLint* params) {
 124     switch(pname) {
 125         case GL_ACTIVE_TEXTURE:         *params = 0;    break;
 126         case GL_MAX_TEXTURE_UNITS_ARB:  *params = 1;    break;
 127         default: old_multitex_glGetIntegerv(pname, params);
 128     }
 129 }
 130
 131 static void (WINE_GLAPI *old_multitex_glGetFloatv) (GLenum pname, GLfloat* params) = NULL;
 132 static void WINE_GLAPI wine_glGetFloatv(GLenum pname, GLfloat* params) {
 133     if (pname == GL_ACTIVE_TEXTURE) *params = 0.0f;
 134     else old_multitex_glGetFloatv(pname, params);
 135 }
 136
 137 static void (WINE_GLAPI *old_multitex_glGetDoublev) (GLenum pname, GLdouble* params) = NULL;
 138 static void WINE_GLAPI wine_glGetDoublev(GLenum pname, GLdouble* params) {
 139     if(pname == GL_ACTIVE_TEXTURE) *params = 0.0;
 140     else old_multitex_glGetDoublev(pname, params);
 141 }
 142
 143 /* Start GL_EXT_fogcoord emulation */
 144 static void (WINE_GLAPI *old_fogcoord_glEnable) (GLenum cap) = NULL;
 145 static void WINE_GLAPI wine_glEnable(GLenum cap) {
 146     if(cap == GL_FOG) {
 147         struct wined3d_context *ctx = context_get_current();
 148         ctx->fog_enabled = 1;
 149         if(ctx->gl_fog_source != GL_FRAGMENT_DEPTH_EXT) return;
 150     }
 151     old_fogcoord_glEnable(cap);
 152 }
 153
 154 static void (WINE_GLAPI *old_fogcoord_glDisable) (GLenum cap) = NULL;
 155 static void WINE_GLAPI wine_glDisable(GLenum cap) {
 156     if(cap == GL_FOG) {
 157         struct wined3d_context *ctx = context_get_current();
 158         ctx->fog_enabled = 0;
 159         if(ctx->gl_fog_source != GL_FRAGMENT_DEPTH_EXT) return;
 160     }
 161     old_fogcoord_glDisable(cap);
 162 }
 163
 164 static void (WINE_GLAPI *old_fogcoord_glFogi) (GLenum pname, GLint param) = NULL;
 165 static void WINE_GLAPI wine_glFogi(GLenum pname, GLint param) {
 166     struct wined3d_context *ctx = context_get_current();
 167
 168     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 169         ctx->gl_fog_source = param;
 170         if(param == GL_FRAGMENT_DEPTH_EXT) {
 171             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 172         } else {
 173             WARN_(d3d_perf)("Fog coords activated, but not supported. Using slow emulation\n");
 174             old_fogcoord_glDisable(GL_FOG);
 175         }
 176     } else {
 177         if(pname == GL_FOG_START) {
 178             ctx->fogstart = (float) param;
 179         } else if(pname == GL_FOG_END) {
 180             ctx->fogend = (float) param;
 181         }
 182         old_fogcoord_glFogi(pname, param);
 183     }
 184 }
 185
 186 static void (WINE_GLAPI *old_fogcoord_glFogiv) (GLenum pname, const GLint *param) = NULL;
 187 static void WINE_GLAPI wine_glFogiv(GLenum pname, const GLint *param) {
 188     struct wined3d_context *ctx = context_get_current();
 189     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 190         ctx->gl_fog_source = *param;
 191         if(*param == GL_FRAGMENT_DEPTH_EXT) {
 192             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 193         } else {
 194             WARN_(d3d_perf)("Fog coords activated, but not supported. Using slow emulation\n");
 195             old_fogcoord_glDisable(GL_FOG);
 196         }
 197     } else {
 198         if(pname == GL_FOG_START) {
 199             ctx->fogstart = (float) *param;
 200         } else if(pname == GL_FOG_END) {
 201             ctx->fogend = (float) *param;
 202         }
 203         old_fogcoord_glFogiv(pname, param);
 204     }
 205 }
 206
 207 static void (WINE_GLAPI *old_fogcoord_glFogf) (GLenum pname, GLfloat param) = NULL;
 208 static void WINE_GLAPI wine_glFogf(GLenum pname, GLfloat param) {
 209     struct wined3d_context *ctx = context_get_current();
 210     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 211         ctx->gl_fog_source = (GLint) param;
 212         if(param == GL_FRAGMENT_DEPTH_EXT) {
 213             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 214         } else {
 215             WARN_(d3d_perf)("Fog coords activated, but not supported. Using slow emulation\n");
 216             old_fogcoord_glDisable(GL_FOG);
 217         }
 218     } else {
 219         if(pname == GL_FOG_START) {
 220             ctx->fogstart = param;
 221         } else if(pname == GL_FOG_END) {
 222             ctx->fogend = param;
 223         }
 224         old_fogcoord_glFogf(pname, param);
 225     }
 226 }
 227
 228 static void (WINE_GLAPI *old_fogcoord_glFogfv) (GLenum pname, const GLfloat *param) = NULL;
 229 static void WINE_GLAPI wine_glFogfv(GLenum pname, const GLfloat *param) {
 230     struct wined3d_context *ctx = context_get_current();
 231     if(pname == GL_FOG_COORDINATE_SOURCE_EXT) {
 232         ctx->gl_fog_source = (GLint) *param;
 233         if(*param == GL_FRAGMENT_DEPTH_EXT) {
 234             if(ctx->fog_enabled) old_fogcoord_glEnable(GL_FOG);
 235         } else {
 236             WARN_(d3d_perf)("Fog coords activated, but not supported. Using slow emulation\n");
 237             old_fogcoord_glDisable(GL_FOG);
 238         }
 239     } else {
 240         if(pname == GL_FOG_COLOR) {
 241             ctx->fogcolor[0] = param[0];
 242             ctx->fogcolor[1] = param[1];
 243             ctx->fogcolor[2] = param[2];
 244             ctx->fogcolor[3] = param[3];
 245         } else if(pname == GL_FOG_START) {
 246             ctx->fogstart = *param;
 247         } else if(pname == GL_FOG_END) {
 248             ctx->fogend = *param;
 249         }
 250         old_fogcoord_glFogfv(pname, param);
 251     }
 252 }
 253
 254 static void (WINE_GLAPI *old_fogcoord_glVertex4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w) = NULL;
 255 static void (WINE_GLAPI *old_fogcoord_glColor4f) (GLfloat r, GLfloat g, GLfloat b, GLfloat a) = NULL;
 256
 257 static void WINE_GLAPI wine_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
 258     struct wined3d_context *ctx = context_get_current();
 259
 260     /* This can be called from draw_test_quad() and at that point there is no
 261      * wined3d_context current. */
 262     if (!ctx)
 263     {
 264         old_fogcoord_glVertex4f(x, y, z, w);
 265         return;
 266     }
 267     if(ctx->gl_fog_source == GL_FOG_COORDINATE_EXT && ctx->fog_enabled) {
 268         GLfloat c[4] = {ctx->color[0], ctx->color[1], ctx->color[2], ctx->color[3]};
 269         GLfloat i;
 270
 271         i = (ctx->fogend - ctx->fog_coord_value) / (ctx->fogend - ctx->fogstart);
 272         c[0] = i * c[0] + (1.0f - i) * ctx->fogcolor[0];
 273         c[1] = i * c[1] + (1.0f - i) * ctx->fogcolor[1];
 274         c[2] = i * c[2] + (1.0f - i) * ctx->fogcolor[2];
 275
 276         old_fogcoord_glColor4f(c[0], c[1], c[2], c[3]);
 277         old_fogcoord_glVertex4f(x, y, z, w);
 278     } else {
 279         old_fogcoord_glVertex4f(x, y, z, w);
 280     }
 281 }
 282
 283 static void WINE_GLAPI wine_glVertex4fv(const GLfloat *pos) {
 284     wine_glVertex4f(pos[0], pos[1], pos[2], pos[3]);
 285 }
 286
 287 static void WINE_GLAPI wine_glVertex3f(GLfloat x, GLfloat y, GLfloat z) {
 288     wine_glVertex4f(x, y, z, 1.0f);
 289 }
 290
 291 static void WINE_GLAPI wine_glVertex3fv(const GLfloat *pos) {
 292     wine_glVertex4f(pos[0], pos[1], pos[2], 1.0f);
 293 }
 294
 295 static void WINE_GLAPI wine_glColor4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
 296     struct wined3d_context *ctx = context_get_current();
 297
 298     /* This can be called from draw_test_quad() and at that point there is no
 299      * wined3d_context current. */
 300     if (!ctx)
 301     {
 302         old_fogcoord_glColor4f(r, g, b, a);
 303         return;
 304     }
 305     ctx->color[0] = r;
 306     ctx->color[1] = g;
 307     ctx->color[2] = b;
 308     ctx->color[3] = a;
 309     old_fogcoord_glColor4f(r, g, b, a);
 310 }
 311
 312 static void WINE_GLAPI wine_glColor4fv(const GLfloat *c) {
 313     wine_glColor4f(c[0], c[1], c[2], c[3]);
 314 }
 315
 316 static void WINE_GLAPI wine_glColor3f(GLfloat r, GLfloat g, GLfloat b) {
 317     wine_glColor4f(r, g, b, 1.0f);
 318 }
 319
 320 static void WINE_GLAPI wine_glColor3fv(const GLfloat *c) {
 321     wine_glColor4f(c[0], c[1], c[2], 1.0f);
 322 }
 323
 324 static void WINE_GLAPI wine_glColor4ub(GLubyte r, GLubyte g, GLubyte b, GLubyte a) {
 325     wine_glColor4f(r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f);
 326 }
 327
 328 /* In D3D the fog coord is a UBYTE, so there's no problem with using the single
 329  * precision function
 330  */
 331 static void WINE_GLAPI wine_glFogCoordfEXT(GLfloat f) {
 332     struct wined3d_context *ctx = context_get_current();
 333     ctx->fog_coord_value = f;
 334 }
 335 static void WINE_GLAPI wine_glFogCoorddEXT(GLdouble f) {
 336     wine_glFogCoordfEXT((GLfloat) f);
 337 }
 338 static void WINE_GLAPI wine_glFogCoordfvEXT(const GLfloat *f) {
 339     wine_glFogCoordfEXT(*f);
 340 }
 341 static void WINE_GLAPI wine_glFogCoorddvEXT(const GLdouble *f) {
 342     wine_glFogCoordfEXT((GLfloat) *f);
 343 }
 344
 345 /* End GL_EXT_fog_coord emulation */
 346
 347 void install_gl_compat_wrapper(struct wined3d_gl_info *gl_info, enum wined3d_gl_extension ext)
 348 {
 349     switch (ext)
 350     {
 351         case ARB_MULTITEXTURE:
 352             if (gl_info->supported[ARB_MULTITEXTURE])
 353                 return;
 354             if (gl_info->gl_ops.ext.p_glActiveTexture == wine_glActiveTexture)
 355             {
 356                 FIXME("ARB_multitexture emulation hooks already applied.\n");
 357                 return;
 358             }
 359             TRACE("Applying GL_ARB_multitexture emulation hooks.\n");
 360             gl_info->gl_ops.ext.p_glActiveTexture           = wine_glActiveTexture;
 361             gl_info->gl_ops.ext.p_glClientActiveTextureARB  = wine_glClientActiveTextureARB;
 362             gl_info->gl_ops.ext.p_glMultiTexCoord1fARB      = wine_glMultiTexCoord1fARB;
 363             gl_info->gl_ops.ext.p_glMultiTexCoord1fvARB     = wine_glMultiTexCoord1fvARB;
 364             gl_info->gl_ops.ext.p_glMultiTexCoord2fARB      = wine_glMultiTexCoord2fARB;
 365             gl_info->gl_ops.ext.p_glMultiTexCoord2fvARB     = wine_glMultiTexCoord2fvARB;
 366             gl_info->gl_ops.ext.p_glMultiTexCoord3fARB      = wine_glMultiTexCoord3fARB;
 367             gl_info->gl_ops.ext.p_glMultiTexCoord3fvARB     = wine_glMultiTexCoord3fvARB;
 368             gl_info->gl_ops.ext.p_glMultiTexCoord4fARB      = wine_glMultiTexCoord4fARB;
 369             gl_info->gl_ops.ext.p_glMultiTexCoord4fvARB     = wine_glMultiTexCoord4fvARB;
 370             gl_info->gl_ops.ext.p_glMultiTexCoord2svARB     = wine_glMultiTexCoord2svARB;
 371             gl_info->gl_ops.ext.p_glMultiTexCoord4svARB     = wine_glMultiTexCoord4svARB;
 372             old_multitex_glGetIntegerv = gl_info->gl_ops.gl.p_glGetIntegerv;
 373             gl_info->gl_ops.gl.p_glGetIntegerv = wine_glGetIntegerv;
 374             old_multitex_glGetFloatv = gl_info->gl_ops.gl.p_glGetFloatv;
 375             gl_info->gl_ops.gl.p_glGetFloatv = wine_glGetFloatv;
 376             old_multitex_glGetDoublev = gl_info->gl_ops.gl.p_glGetDoublev;
 377             gl_info->gl_ops.gl.p_glGetDoublev = wine_glGetDoublev;
 378             gl_info->supported[ARB_MULTITEXTURE] = TRUE;
 379             return;
 380
 381         case EXT_FOG_COORD:
 382             /* This emulation isn't perfect. There are a number of potential problems, but they should
 383              * not matter in practise:
 384              *
 385              * Fog vs fragment shader: If we are using GL_ARB_fragment_program with the fog option, the
 386              * glDisable(GL_FOG) here won't matter. However, if we have GL_ARB_fragment_program, it is pretty
 387              * unlikely that we don't have GL_EXT_fog_coord. Besides, we probably have GL_ARB_vertex_program
 388              * too, which would allow fog coord emulation in a fixed function vertex pipeline replacement.
 389              *
 390              * Fog vs texture: We apply the fog in the vertex color. An app could set up texturing settings which
 391              * ignore the vertex color, thus effectively disabling our fog. However, in D3D this type of fog is
 392              * a per-vertex fog too, so the apps shouldn't do that.
 393              *
 394              * Fog vs lighting: The app could in theory use D3DFOG_NONE table and D3DFOG_NONE vertex fog with
 395              * untransformed vertices. That enables lighting and fog coords at the same time, and the lighting
 396              * calculations could affect the already blended in fog color. There's nothing we can do against that,
 397              * but most apps using fog color do their own lighting too and often even use RHW vertices. So live
 398              * with it.
 399              */
 400             if (gl_info->supported[EXT_FOG_COORD])
 401                 return;
 402             if (gl_info->gl_ops.gl.p_glFogi == wine_glFogi)
 403             {
 404                 FIXME("EXT_fog_coord emulation hooks already applied.\n");
 405                 return;
 406             }
 407             TRACE("Applying GL_ARB_fog_coord emulation hooks\n");
 408
 409             /* This probably means that the implementation doesn't advertise the extension, but implicitly supports
 410              * it via the GL core version, or someone messed around in the extension table in directx.c. Add version-
 411              * dependent loading for this extension if we ever hit this situation
 412              */
 413             if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
 414             {
 415                 FIXME("GL implementation supports GL_ARB_fragment_program but not GL_EXT_fog_coord\n");
 416                 FIXME("The fog coord emulation will most likely fail\n");
 417             }
 418             else if (gl_info->supported[ARB_FRAGMENT_SHADER])
 419             {
 420                 FIXME("GL implementation supports GL_ARB_fragment_shader but not GL_EXT_fog_coord\n");
 421                 FIXME("The fog coord emulation will most likely fail\n");
 422             }
 423
 424             old_fogcoord_glFogi = gl_info->gl_ops.gl.p_glFogi;
 425             gl_info->gl_ops.gl.p_glFogi = wine_glFogi;
 426             old_fogcoord_glFogiv = gl_info->gl_ops.gl.p_glFogiv;
 427             gl_info->gl_ops.gl.p_glFogiv = wine_glFogiv;
 428             old_fogcoord_glFogf = gl_info->gl_ops.gl.p_glFogf;
 429             gl_info->gl_ops.gl.p_glFogf = wine_glFogf;
 430             old_fogcoord_glFogfv = gl_info->gl_ops.gl.p_glFogfv;
 431             gl_info->gl_ops.gl.p_glFogfv = wine_glFogfv;
 432             old_fogcoord_glEnable = glEnableWINE;
 433             glEnableWINE = wine_glEnable;
 434             old_fogcoord_glDisable = glDisableWINE;
 435             glDisableWINE = wine_glDisable;
 436
 437             old_fogcoord_glVertex4f = gl_info->gl_ops.gl.p_glVertex4f;
 438             gl_info->gl_ops.gl.p_glVertex4f = wine_glVertex4f;
 439             gl_info->gl_ops.gl.p_glVertex4fv = wine_glVertex4fv;
 440             gl_info->gl_ops.gl.p_glVertex3f = wine_glVertex3f;
 441             gl_info->gl_ops.gl.p_glVertex3fv = wine_glVertex3fv;
 442
 443             old_fogcoord_glColor4f = gl_info->gl_ops.gl.p_glColor4f;
 444             gl_info->gl_ops.gl.p_glColor4f = wine_glColor4f;
 445             gl_info->gl_ops.gl.p_glColor4fv = wine_glColor4fv;
 446             gl_info->gl_ops.gl.p_glColor3f = wine_glColor3f;
 447             gl_info->gl_ops.gl.p_glColor3fv = wine_glColor3fv;
 448             gl_info->gl_ops.gl.p_glColor4ub = wine_glColor4ub;
 449
 450             gl_info->gl_ops.ext.p_glFogCoordfEXT = wine_glFogCoordfEXT;
 451             gl_info->gl_ops.ext.p_glFogCoordfvEXT = wine_glFogCoordfvEXT;
 452             gl_info->gl_ops.ext.p_glFogCoorddEXT = wine_glFogCoorddEXT;
 453             gl_info->gl_ops.ext.p_glFogCoorddvEXT = wine_glFogCoorddvEXT;
 454             gl_info->supported[EXT_FOG_COORD] = TRUE;
 455             return;
 456
 457         default:
 458             FIXME("Extension %u emulation not supported.\n", ext);
 459     }
 460 }