VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/gl_compat.c@ 22652

Last change on this file since 22652 was 22496, checked in by vboxsync, 15 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette