1 /* Direct3D Common functions
2 * Copyright (c) 1998 Lionel ULMER
4 * This file contains all MESA common code
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include "wine/debug.h"
29 #include "mesa_private.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(ddraw
);
33 GLenum
convert_D3D_compare_to_GL(D3DCMPFUNC dwRenderState
)
35 switch (dwRenderState
) {
36 case D3DCMP_NEVER
: return GL_NEVER
;
37 case D3DCMP_LESS
: return GL_LESS
;
38 case D3DCMP_EQUAL
: return GL_EQUAL
;
39 case D3DCMP_LESSEQUAL
: return GL_LEQUAL
;
40 case D3DCMP_GREATER
: return GL_GREATER
;
41 case D3DCMP_NOTEQUAL
: return GL_NOTEQUAL
;
42 case D3DCMP_GREATEREQUAL
: return GL_GEQUAL
;
43 case D3DCMP_ALWAYS
: return GL_ALWAYS
;
44 default: ERR("Unexpected compare type %d !\n", dwRenderState
);
49 GLenum
convert_D3D_stencilop_to_GL(D3DSTENCILOP dwRenderState
)
51 switch (dwRenderState
) {
52 case D3DSTENCILOP_KEEP
: return GL_KEEP
;
53 case D3DSTENCILOP_ZERO
: return GL_ZERO
;
54 case D3DSTENCILOP_REPLACE
: return GL_REPLACE
;
55 case D3DSTENCILOP_INCRSAT
: return GL_INCR
;
56 case D3DSTENCILOP_DECRSAT
: return GL_DECR
;
57 case D3DSTENCILOP_INVERT
: return GL_INVERT
;
58 case D3DSTENCILOP_INCR
: WARN("D3DSTENCILOP_INCR not properly handled !\n"); return GL_INCR
;
59 case D3DSTENCILOP_DECR
: WARN("D3DSTENCILOP_DECR not properly handled !\n"); return GL_DECR
;
60 default: ERR("Unexpected compare type %d !\n", dwRenderState
);
65 GLenum
convert_D3D_blendop_to_GL(D3DBLEND dwRenderState
)
67 switch ((D3DBLEND
) dwRenderState
) {
68 case D3DBLEND_ZERO
: return GL_ZERO
;
69 case D3DBLEND_ONE
: return GL_ONE
;
70 case D3DBLEND_SRCALPHA
: return GL_SRC_ALPHA
;
71 case D3DBLEND_INVSRCALPHA
: return GL_ONE_MINUS_SRC_ALPHA
;
72 case D3DBLEND_DESTALPHA
: return GL_DST_ALPHA
;
73 case D3DBLEND_INVDESTALPHA
: return GL_ONE_MINUS_DST_ALPHA
;
74 case D3DBLEND_DESTCOLOR
: return GL_DST_COLOR
;
75 case D3DBLEND_INVDESTCOLOR
: return GL_ONE_MINUS_DST_COLOR
;
76 case D3DBLEND_SRCALPHASAT
: return GL_SRC_ALPHA_SATURATE
;
77 case D3DBLEND_SRCCOLOR
: return GL_SRC_COLOR
;
78 case D3DBLEND_INVSRCCOLOR
: return GL_ONE_MINUS_SRC_COLOR
;
79 default: ERR("Unhandled blend mode %d !\n", dwRenderState
); return GL_ZERO
;
83 void set_render_state(IDirect3DDeviceImpl
* This
,
84 D3DRENDERSTATETYPE dwRenderStateType
, STATEBLOCK
*lpStateBlock
)
86 DWORD dwRenderState
= lpStateBlock
->render_state
[dwRenderStateType
- 1];
89 TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType
), dwRenderState
);
91 /* First, all the stipple patterns */
92 if ((dwRenderStateType
>= D3DRENDERSTATE_STIPPLEPATTERN00
) &&
93 (dwRenderStateType
<= D3DRENDERSTATE_STIPPLEPATTERN31
)) {
94 ERR("Unhandled dwRenderStateType stipple %d!\n",dwRenderStateType
);
98 /* All others state variables */
99 switch (dwRenderStateType
) {
100 case D3DRENDERSTATE_TEXTUREHANDLE
: { /* 1 */
101 IDirectDrawSurfaceImpl
*tex
= (IDirectDrawSurfaceImpl
*) dwRenderState
;
104 IDirect3DDevice7_SetTexture(ICOM_INTERFACE(This
, IDirect3DDevice7
),
106 ICOM_INTERFACE(tex
, IDirectDrawSurface7
));
110 case D3DRENDERSTATE_TEXTUREADDRESSU
: /* 44 */
111 case D3DRENDERSTATE_TEXTUREADDRESSV
: /* 45 */
112 case D3DRENDERSTATE_TEXTUREADDRESS
: { /* 3 */
113 D3DTEXTURESTAGESTATETYPE d3dTexStageStateType
;
115 if (dwRenderStateType
== D3DRENDERSTATE_TEXTUREADDRESS
) d3dTexStageStateType
= D3DTSS_ADDRESS
;
116 else if (dwRenderStateType
== D3DRENDERSTATE_TEXTUREADDRESSU
) d3dTexStageStateType
= D3DTSS_ADDRESSU
;
117 else d3dTexStageStateType
= D3DTSS_ADDRESSV
;
120 IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This
, IDirect3DDevice7
),
121 0, d3dTexStageStateType
,
126 case D3DRENDERSTATE_TEXTUREPERSPECTIVE
: /* 4 */
128 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_NICEST
);
130 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_FASTEST
);
133 case D3DRENDERSTATE_WRAPU
: /* 5 */
134 case D3DRENDERSTATE_WRAPV
: /* 6 */
135 case D3DRENDERSTATE_WRAP0
: /* 128 */
136 case D3DRENDERSTATE_WRAP1
: /* 129 */
137 case D3DRENDERSTATE_WRAP2
: /* 130 */
138 case D3DRENDERSTATE_WRAP3
: /* 131 */
139 case D3DRENDERSTATE_WRAP4
: /* 132 */
140 case D3DRENDERSTATE_WRAP5
: /* 133 */
141 case D3DRENDERSTATE_WRAP6
: /* 134 */
142 case D3DRENDERSTATE_WRAP7
: /* 135 */
144 ERR("Texture WRAP modes unsupported by OpenGL.. Expect graphical glitches !\n");
147 case D3DRENDERSTATE_ZENABLE
: /* 7 */
148 /* To investigate : in OpenGL, if we disable the depth test, the Z buffer will NOT be
149 updated either.. No idea about what happens in D3D.
151 Maybe replacing the Z function by ALWAYS would be a better idea. */
152 if (dwRenderState
== D3DZB_TRUE
)
153 glEnable(GL_DEPTH_TEST
);
154 else if (dwRenderState
== D3DZB_FALSE
)
155 glDisable(GL_DEPTH_TEST
);
157 glEnable(GL_DEPTH_TEST
);
158 WARN(" w-buffering not supported.\n");
162 case D3DRENDERSTATE_FILLMODE
: /* 8 */
163 switch ((D3DFILLMODE
) dwRenderState
) {
165 glPolygonMode(GL_FRONT_AND_BACK
,GL_POINT
);
167 case D3DFILL_WIREFRAME
:
168 glPolygonMode(GL_FRONT_AND_BACK
,GL_LINE
);
171 glPolygonMode(GL_FRONT_AND_BACK
,GL_FILL
);
174 ERR("Unhandled fill mode %ld !\n",dwRenderState
);
178 case D3DRENDERSTATE_SHADEMODE
: /* 9 */
179 switch ((D3DSHADEMODE
) dwRenderState
) {
181 glShadeModel(GL_FLAT
);
183 case D3DSHADE_GOURAUD
:
184 glShadeModel(GL_SMOOTH
);
187 ERR("Unhandled shade mode %ld !\n",dwRenderState
);
191 case D3DRENDERSTATE_ZWRITEENABLE
: /* 14 */
193 glDepthMask(GL_TRUE
);
195 glDepthMask(GL_FALSE
);
198 case D3DRENDERSTATE_ALPHATESTENABLE
: /* 15 */
200 glEnable(GL_ALPHA_TEST
);
202 glDisable(GL_ALPHA_TEST
);
205 case D3DRENDERSTATE_TEXTUREMAG
: { /* 17 */
206 DWORD tex_mag
= 0xFFFFFFFF;
208 switch ((D3DTEXTUREFILTER
) dwRenderState
) {
209 case D3DFILTER_NEAREST
:
210 tex_mag
= D3DTFG_POINT
;
212 case D3DFILTER_LINEAR
:
213 tex_mag
= D3DTFG_LINEAR
;
216 ERR("Unhandled texture mag %ld !\n",dwRenderState
);
219 if (tex_mag
!= 0xFFFFFFFF) {
221 IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This
, IDirect3DDevice7
), 0, D3DTSS_MAGFILTER
, tex_mag
);
226 case D3DRENDERSTATE_TEXTUREMIN
: { /* 18 */
227 DWORD tex_min
= 0xFFFFFFFF;
229 switch ((D3DTEXTUREFILTER
) dwRenderState
) {
230 case D3DFILTER_NEAREST
:
231 tex_min
= D3DTFN_POINT
;
233 case D3DFILTER_LINEAR
:
234 tex_min
= D3DTFN_LINEAR
;
237 ERR("Unhandled texture min %ld !\n",dwRenderState
);
240 if (tex_min
!= 0xFFFFFFFF) {
242 IDirect3DDevice7_SetTextureStageState(ICOM_INTERFACE(This
, IDirect3DDevice7
), 0, D3DTSS_MINFILTER
, tex_min
);
247 case D3DRENDERSTATE_SRCBLEND
: /* 19 */
248 case D3DRENDERSTATE_DESTBLEND
: /* 20 */
249 glBlendFunc(convert_D3D_blendop_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_SRCBLEND
- 1]),
250 convert_D3D_blendop_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_DESTBLEND
- 1]));
253 case D3DRENDERSTATE_TEXTUREMAPBLEND
: /* 21 */
254 switch ((D3DTEXTUREBLEND
) dwRenderState
) {
255 case D3DTBLEND_MODULATE
:
256 case D3DTBLEND_MODULATEALPHA
:
257 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_MODULATE
);
260 ERR("Unhandled texture environment %ld !\n",dwRenderState
);
264 case D3DRENDERSTATE_CULLMODE
: /* 22 */
265 switch ((D3DCULL
) dwRenderState
) {
267 glDisable(GL_CULL_FACE
);
270 glEnable(GL_CULL_FACE
);
275 glEnable(GL_CULL_FACE
);
280 ERR("Unhandled cull mode %ld !\n",dwRenderState
);
284 case D3DRENDERSTATE_ZFUNC
: /* 23 */
285 glDepthFunc(convert_D3D_compare_to_GL(dwRenderState
));
288 case D3DRENDERSTATE_ALPHAREF
: /* 24 */
289 case D3DRENDERSTATE_ALPHAFUNC
: /* 25 */
290 glAlphaFunc(convert_D3D_compare_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_ALPHAFUNC
- 1]),
291 (lpStateBlock
->render_state
[D3DRENDERSTATE_ALPHAREF
- 1] & 0x000000FF) / 255.0);
294 case D3DRENDERSTATE_DITHERENABLE
: /* 26 */
298 glDisable(GL_DITHER
);
301 case D3DRENDERSTATE_ALPHABLENDENABLE
: /* 27 */
309 case D3DRENDERSTATE_FOGENABLE
: /* 28 */
310 /* Nothing to do here. Only the storage matters :-) */
313 case D3DRENDERSTATE_SPECULARENABLE
: /* 29 */
315 ERR(" Specular Lighting not supported yet.\n");
318 case D3DRENDERSTATE_SUBPIXEL
: /* 31 */
319 case D3DRENDERSTATE_SUBPIXELX
: /* 32 */
320 /* We do not support this anyway, so why protest :-) */
323 case D3DRENDERSTATE_STIPPLEDALPHA
: /* 33 */
325 ERR(" Stippled Alpha not supported yet.\n");
328 case D3DRENDERSTATE_FOGCOLOR
: { /* 34 */
330 color
[0] = ((dwRenderState
>> 16) & 0xFF)/255.0f
;
331 color
[1] = ((dwRenderState
>> 8) & 0xFF)/255.0f
;
332 color
[2] = ((dwRenderState
>> 0) & 0xFF)/255.0f
;
333 color
[3] = ((dwRenderState
>> 24) & 0xFF)/255.0f
;
334 glFogfv(GL_FOG_COLOR
,color
);
335 /* Note: glFogiv does not seem to work */
338 case D3DRENDERSTATE_FOGTABLEMODE
: /* 35 */
339 case D3DRENDERSTATE_FOGVERTEXMODE
: /* 140 */
340 case D3DRENDERSTATE_FOGSTART
: /* 36 */
341 case D3DRENDERSTATE_FOGEND
: /* 37 */
342 /* Nothing to do here. Only the storage matters :-) */
345 case D3DRENDERSTATE_FOGDENSITY
: /* 38 */
346 glFogi(GL_FOG_DENSITY
,*(float*)&dwRenderState
);
349 case D3DRENDERSTATE_COLORKEYENABLE
: /* 41 */
350 /* This needs to be fixed. */
357 case D3DRENDERSTATE_ZBIAS
: /* 47 */
358 /* This is a tad bit hacky.. But well, no idea how to do it better in OpenGL :-/ */
359 if (dwRenderState
== 0) {
360 glDisable(GL_POLYGON_OFFSET_FILL
);
361 glDisable(GL_POLYGON_OFFSET_LINE
);
362 glDisable(GL_POLYGON_OFFSET_POINT
);
364 glEnable(GL_POLYGON_OFFSET_FILL
);
365 glEnable(GL_POLYGON_OFFSET_LINE
);
366 glEnable(GL_POLYGON_OFFSET_POINT
);
367 glPolygonOffset(1.0, dwRenderState
* 1.0);
371 case D3DRENDERSTATE_FLUSHBATCH
: /* 50 */
374 case D3DRENDERSTATE_STENCILENABLE
: /* 52 */
376 glEnable(GL_STENCIL_TEST
);
378 glDisable(GL_STENCIL_TEST
);
381 case D3DRENDERSTATE_STENCILFAIL
: /* 53 */
382 case D3DRENDERSTATE_STENCILZFAIL
: /* 54 */
383 case D3DRENDERSTATE_STENCILPASS
: /* 55 */
384 glStencilOp(convert_D3D_stencilop_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILFAIL
- 1]),
385 convert_D3D_stencilop_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILZFAIL
- 1]),
386 convert_D3D_stencilop_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILPASS
- 1]));
389 case D3DRENDERSTATE_STENCILFUNC
: /* 56 */
390 case D3DRENDERSTATE_STENCILREF
: /* 57 */
391 case D3DRENDERSTATE_STENCILMASK
: /* 58 */
392 glStencilFunc(convert_D3D_compare_to_GL(lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILFUNC
- 1]),
393 lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILREF
- 1],
394 lpStateBlock
->render_state
[D3DRENDERSTATE_STENCILMASK
- 1]);
397 case D3DRENDERSTATE_STENCILWRITEMASK
: /* 59 */
398 glStencilMask(dwRenderState
);
401 case D3DRENDERSTATE_CLIPPING
: /* 136 */
402 case D3DRENDERSTATE_CLIPPLANEENABLE
: { /* 152 */
406 if (dwRenderStateType
== D3DRENDERSTATE_CLIPPING
) {
407 mask
= ((dwRenderState
) ?
408 (This
->state_block
.render_state
[D3DRENDERSTATE_CLIPPLANEENABLE
- 1]) : (0x0000));
410 mask
= dwRenderState
;
412 for (i
= 0, runner
= 0x00000001; i
< This
->max_clipping_planes
; i
++, runner
= (runner
<< 1)) {
414 glEnable(GL_CLIP_PLANE0
+ i
);
416 glDisable(GL_CLIP_PLANE0
+ i
);
422 case D3DRENDERSTATE_LIGHTING
: /* 137 */
424 glEnable(GL_LIGHTING
);
426 glDisable(GL_LIGHTING
);
429 case D3DRENDERSTATE_AMBIENT
: { /* 139 */
432 light
[0] = ((dwRenderState
>> 16) & 0xFF) / 255.0;
433 light
[1] = ((dwRenderState
>> 8) & 0xFF) / 255.0;
434 light
[2] = ((dwRenderState
>> 0) & 0xFF) / 255.0;
435 light
[3] = ((dwRenderState
>> 24) & 0xFF) / 255.0;
436 glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, (float *) light
);
439 case D3DRENDERSTATE_COLORVERTEX
: /* 141 */
440 /* Nothing to do here.. Only storage matters */
443 case D3DRENDERSTATE_LOCALVIEWER
: /* 142 */
445 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, GL_TRUE
);
447 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, GL_FALSE
);
450 case D3DRENDERSTATE_NORMALIZENORMALS
: /* 143 */
452 glEnable(GL_NORMALIZE
);
453 glEnable(GL_RESCALE_NORMAL
);
455 glDisable(GL_NORMALIZE
);
456 glDisable(GL_RESCALE_NORMAL
);
460 case D3DRENDERSTATE_DIFFUSEMATERIALSOURCE
: /* 145 */
461 case D3DRENDERSTATE_SPECULARMATERIALSOURCE
: /* 146 */
462 case D3DRENDERSTATE_AMBIENTMATERIALSOURCE
: /* 147 */
463 case D3DRENDERSTATE_EMISSIVEMATERIALSOURCE
: /* 148 */
464 /* Nothing to do here. Only the storage matters :-) */
468 ERR("Unhandled dwRenderStateType %s (%08x) value : %08lx !\n",
469 _get_renderstate(dwRenderStateType
), dwRenderStateType
, dwRenderState
);
475 void store_render_state(IDirect3DDeviceImpl
*This
,
476 D3DRENDERSTATETYPE dwRenderStateType
, DWORD dwRenderState
, STATEBLOCK
*lpStateBlock
)
478 TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType
), dwRenderState
);
480 /* Some special cases first.. */
481 if (dwRenderStateType
== D3DRENDERSTATE_SRCBLEND
) {
482 if (dwRenderState
== D3DBLEND_BOTHSRCALPHA
) {
483 lpStateBlock
->render_state
[D3DRENDERSTATE_SRCBLEND
- 1] = D3DBLEND_SRCALPHA
;
484 lpStateBlock
->render_state
[D3DRENDERSTATE_DESTBLEND
- 1] = D3DBLEND_SRCALPHA
;
486 } else if (dwRenderState
== D3DBLEND_BOTHINVSRCALPHA
) {
487 lpStateBlock
->render_state
[D3DRENDERSTATE_SRCBLEND
- 1] = D3DBLEND_INVSRCALPHA
;
488 lpStateBlock
->render_state
[D3DRENDERSTATE_DESTBLEND
- 1] = D3DBLEND_INVSRCALPHA
;
491 } else if (dwRenderStateType
== D3DRENDERSTATE_TEXTUREADDRESS
) {
492 lpStateBlock
->render_state
[D3DRENDERSTATE_TEXTUREADDRESSU
- 1] = dwRenderState
;
493 lpStateBlock
->render_state
[D3DRENDERSTATE_TEXTUREADDRESSV
- 1] = dwRenderState
;
494 } else if (dwRenderStateType
== D3DRENDERSTATE_WRAPU
) {
496 lpStateBlock
->render_state
[D3DRENDERSTATE_WRAP0
] |= D3DWRAP_U
;
498 lpStateBlock
->render_state
[D3DRENDERSTATE_WRAP0
] &= ~D3DWRAP_U
;
499 } else if (dwRenderStateType
== D3DRENDERSTATE_WRAPV
) {
501 lpStateBlock
->render_state
[D3DRENDERSTATE_WRAP0
] |= D3DWRAP_V
;
503 lpStateBlock
->render_state
[D3DRENDERSTATE_WRAP0
] &= ~D3DWRAP_V
;
507 lpStateBlock
->render_state
[dwRenderStateType
- 1] = dwRenderState
;
510 void get_render_state(IDirect3DDeviceImpl
*This
,
511 D3DRENDERSTATETYPE dwRenderStateType
, LPDWORD lpdwRenderState
, STATEBLOCK
*lpStateBlock
)
513 *lpdwRenderState
= lpStateBlock
->render_state
[dwRenderStateType
- 1];
515 TRACE("%s = %08lx\n", _get_renderstate(dwRenderStateType
), *lpdwRenderState
);
518 void apply_render_state(IDirect3DDeviceImpl
*This
, STATEBLOCK
*lpStateBlock
)
521 TRACE("(%p,%p)\n", This
, lpStateBlock
);
522 for(i
= 0; i
< HIGHEST_RENDER_STATE
; i
++)
523 if (lpStateBlock
->set_flags
.render_state
[i
])
524 set_render_state(This
, i
+ 1, lpStateBlock
);