wined3d: Don't make wgl calls from under the GL lock.
[wine] / 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 <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 #define GLINFO_LOCATION (*gl_info)
346 void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info)
347 {
348     if(!GL_SUPPORT(ARB_MULTITEXTURE)) {
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_SUPPORT(EXT_FOG_COORD)) {
384         /* This emulation isn't perfect. There are a number of potential problems, but they should
385          * not matter in practise:
386          *
387          * Fog vs fragment shader: If we are using GL_ARB_fragment_program with the fog option, the
388          * glDisable(GL_FOG) here won't matter. However, if we have GL_ARB_fragment_program, it is pretty
389          * unlikely that we don't have GL_EXT_fog_coord. Besides, we probably have GL_ARB_vertex_program
390          * too, which would allow fog coord emulation in a fixed function vertex pipeline replacement.
391          *
392          * Fog vs texture: We apply the fog in the vertex color. An app could set up texturing settings which
393          * ignore the vertex color, thus effectively disabing our fog. However, in D3D this type of fog is
394          * a per-vertex fog too, so the apps shouldn't do that.
395          *
396          * Fog vs lighting: The app could in theory use D3DFOG_NONE table and D3DFOG_NONE vertex fog with
397          * untransformed vertices. That enables lighting and fog coords at the same time, and the lighting
398          * calculations could affect the already blended in fog color. There's nothing we can do against that,
399          * but most apps using fog color do their own lighting too and often even use RHW vertices. So live
400          * with it.
401          */
402         TRACE("Applying GL_ARB_fog_coord emulation hooks\n");
403
404         /* This probably means that the implementation doesn't advertise the extension, but implicitly supports
405          * it via the GL core version, or someone messed around in the extension table in directx.c. Add version-
406          * dependent loading for this extension if we ever hit this situation
407          */
408         if(GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
409             FIXME("GL implementation supports GL_ARB_fragment_program but not GL_EXT_fog_coord\n");
410             FIXME("The fog coord emulation will most likely fail\n");
411         } else if(GL_SUPPORT(ARB_FRAGMENT_SHADER)) {
412             FIXME("GL implementation supports GL_ARB_fragment_shader but not GL_EXT_fog_coord\n");
413             FIXME("The fog coord emulation will most likely fail\n");
414         }
415
416         if(old_fogcoord_glFogi) {
417             FIXME("GL_EXT_fogcoord glFogi hook already applied\n");
418         } else {
419             old_fogcoord_glFogi = glFogi;
420             glFogi = wine_glFogi;
421         }
422         if(old_fogcoord_glFogiv) {
423             FIXME("GL_EXT_fogcoord glFogiv hook already applied\n");
424         } else {
425             old_fogcoord_glFogiv = glFogiv;
426             glFogiv = wine_glFogiv;
427         }
428         if(old_fogcoord_glFogf) {
429             FIXME("GL_EXT_fogcoord glFogf hook already applied\n");
430         } else {
431             old_fogcoord_glFogf = glFogf;
432             glFogf = wine_glFogf;
433         }
434         if(old_fogcoord_glFogfv) {
435             FIXME("GL_EXT_fogcoord glFogfv hook already applied\n");
436         } else {
437             old_fogcoord_glFogfv = glFogfv;
438             glFogfv = wine_glFogfv;
439         }
440         if(old_fogcoord_glEnable) {
441             FIXME("GL_EXT_fogcoord glEnable hook already applied\n");
442         } else {
443             old_fogcoord_glEnable = glEnableWINE;
444             glEnableWINE = wine_glEnable;
445         }
446         if(old_fogcoord_glDisable) {
447             FIXME("GL_EXT_fogcoord glDisable hook already applied\n");
448         } else {
449             old_fogcoord_glDisable = glDisableWINE;
450             glDisableWINE = wine_glDisable;
451         }
452
453         if(old_fogcoord_glVertex4f) {
454             FIXME("GL_EXT_fogcoord glVertex4f hook already applied\n");
455         } else {
456             old_fogcoord_glVertex4f = glVertex4f;
457             glVertex4f = wine_glVertex4f;
458         }
459         if(old_fogcoord_glVertex4fv) {
460             FIXME("GL_EXT_fogcoord glVertex4fv hook already applied\n");
461         } else {
462             old_fogcoord_glVertex4fv = glVertex4fv;
463             glVertex4fv = wine_glVertex4fv;
464         }
465         if(old_fogcoord_glVertex3f) {
466             FIXME("GL_EXT_fogcoord glVertex3f hook already applied\n");
467         } else {
468             old_fogcoord_glVertex3f = glVertex3f;
469             glVertex3f = wine_glVertex3f;
470         }
471         if(old_fogcoord_glVertex3fv) {
472             FIXME("GL_EXT_fogcoord glVertex3fv hook already applied\n");
473         } else {
474             old_fogcoord_glVertex3fv = glVertex3fv;
475             glVertex3fv = wine_glVertex3fv;
476         }
477
478         if(old_fogcoord_glColor4f) {
479             FIXME("GL_EXT_fogcoord glColor4f hook already applied\n");
480         } else {
481             old_fogcoord_glColor4f = glColor4f;
482             glColor4f = wine_glColor4f;
483         }
484         if(old_fogcoord_glColor4fv) {
485             FIXME("GL_EXT_fogcoord glColor4fv hook already applied\n");
486         } else {
487             old_fogcoord_glColor4fv = glColor4fv;
488             glColor4fv = wine_glColor4fv;
489         }
490         if(old_fogcoord_glColor3f) {
491             FIXME("GL_EXT_fogcoord glColor3f hook already applied\n");
492         } else {
493             old_fogcoord_glColor3f = glColor3f;
494             glColor3f = wine_glColor3f;
495         }
496         if(old_fogcoord_glColor3fv) {
497             FIXME("GL_EXT_fogcoord glColor3fv hook already applied\n");
498         } else {
499             old_fogcoord_glColor3fv = glColor3fv;
500             glColor3fv = wine_glColor3fv;
501         }
502         if(old_fogcoord_glColor4ub) {
503             FIXME("GL_EXT_fogcoord glColor4ub hook already applied\n");
504         } else {
505             old_fogcoord_glColor4ub = glColor4ub;
506             glColor4ub = wine_glColor4ub;
507         }
508
509         if(old_fogcoord_glFogCoordfEXT) {
510             FIXME("GL_EXT_fogcoord glFogCoordfEXT hook already applied\n");
511         } else {
512             old_fogcoord_glFogCoordfEXT = gl_info->glFogCoordfEXT;
513             gl_info->glFogCoordfEXT = wine_glFogCoordfEXT;
514         }
515         if(old_fogcoord_glFogCoordfvEXT) {
516             FIXME("GL_EXT_fogcoord glFogCoordfvEXT hook already applied\n");
517         } else {
518             old_fogcoord_glFogCoordfvEXT = gl_info->glFogCoordfvEXT;
519             gl_info->glFogCoordfvEXT = wine_glFogCoordfvEXT;
520         }
521         if(old_fogcoord_glFogCoorddEXT) {
522             FIXME("GL_EXT_fogcoord glFogCoorddEXT hook already applied\n");
523         } else {
524             old_fogcoord_glFogCoorddEXT = gl_info->glFogCoorddEXT;
525             gl_info->glFogCoorddEXT = wine_glFogCoorddEXT;
526         }
527         if(old_fogcoord_glFogCoorddvEXT) {
528             FIXME("GL_EXT_fogcoord glFogCoorddvEXT hook already applied\n");
529         } else {
530             old_fogcoord_glFogCoorddvEXT = gl_info->glFogCoorddvEXT;
531             gl_info->glFogCoorddvEXT = wine_glFogCoorddvEXT;
532         }
533         gl_info->supported[EXT_FOG_COORD] = TRUE;
534     }
535 }
536 #undef GLINFO_LOCATION