2 * Direct3D state management
4 * Copyright 2002 Lionel Ulmer
5 * Copyright 2002-2005 Jason Edmeades
6 * Copyright 2003-2004 Raphael Junqueira
7 * Copyright 2004 Christian Costa
8 * Copyright 2005 Oliver Stieber
9 * Copyright 2006 Henri Verbeet
10 * Copyright 2006-2007 Stefan Dösinger for CodeWeavers
12 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
32 #include "wined3d_private.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
35 WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
37 #define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
39 static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
40 /* Used for states which are not mapped to a gl state as-is, but used somehow different,
41 * e.g as a parameter for drawing, or which are unimplemented in windows d3d
43 if(STATE_IS_RENDER(state)) {
44 WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
45 TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
47 /* Shouldn't have an unknown type here */
48 FIXME("%d no direct mapping to gl of state with unknown type\n", state);
52 static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
53 /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
54 * list without causing confusing terminal output. Deliberately no special debug name here
55 * because its undefined.
57 WARN("undefined state %d\n", state);
60 static void state_fillmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
61 WINED3DFILLMODE Value = stateblock->renderState[WINED3DRS_FILLMODE];
64 case WINED3DFILL_POINT:
65 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
66 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
68 case WINED3DFILL_WIREFRAME:
69 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
70 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
72 case WINED3DFILL_SOLID:
73 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
74 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
77 FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
81 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
84 /* Lighting is not enabled if transformed vertices are drawn
85 * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
86 * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
87 * vertex declaration appplying function calls this function for updating
90 if(isStateDirty(context, STATE_VDECL)) {
94 transformed = ((stateblock->wineD3DDevice->strided_streams.u.s.position.lpData != NULL ||
95 stateblock->wineD3DDevice->strided_streams.u.s.position.VBO != 0) &&
96 stateblock->wineD3DDevice->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
98 if (stateblock->renderState[WINED3DRS_LIGHTING] && !transformed) {
99 glEnable(GL_LIGHTING);
100 checkGLcall("glEnable GL_LIGHTING");
102 glDisable(GL_LIGHTING);
103 checkGLcall("glDisable GL_LIGHTING");
107 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
108 /* No z test without depth stencil buffers */
109 if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
110 glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
111 checkGLcall("glDisable GL_DEPTH_TEST");
115 switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
116 case WINED3DZB_FALSE:
117 glDisable(GL_DEPTH_TEST);
118 checkGLcall("glDisable GL_DEPTH_TEST");
121 glEnable(GL_DEPTH_TEST);
122 checkGLcall("glEnable GL_DEPTH_TEST");
125 glEnable(GL_DEPTH_TEST);
126 checkGLcall("glEnable GL_DEPTH_TEST");
127 FIXME("W buffer is not well handled\n");
130 FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock->renderState[WINED3DRS_ZENABLE]);
134 static void state_cullmode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
135 /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
137 /* If we are culling "back faces with clockwise vertices" then
138 set front faces to be counter clockwise and enable culling
140 switch ((WINED3DCULL) stateblock->renderState[WINED3DRS_CULLMODE]) {
141 case WINED3DCULL_NONE:
142 glDisable(GL_CULL_FACE);
143 checkGLcall("glDisable GL_CULL_FACE");
146 glEnable(GL_CULL_FACE);
147 checkGLcall("glEnable GL_CULL_FACE");
148 if (stateblock->wineD3DDevice->render_offscreen) {
150 checkGLcall("glFrontFace GL_CW");
153 checkGLcall("glFrontFace GL_CCW");
157 case WINED3DCULL_CCW:
158 glEnable(GL_CULL_FACE);
159 checkGLcall("glEnable GL_CULL_FACE");
160 if (stateblock->wineD3DDevice->render_offscreen) {
162 checkGLcall("glFrontFace GL_CCW");
165 checkGLcall("glFrontFace GL_CW");
170 FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock->renderState[WINED3DRS_CULLMODE]);
174 static void state_shademode(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
175 switch ((WINED3DSHADEMODE) stateblock->renderState[WINED3DRS_SHADEMODE]) {
176 case WINED3DSHADE_FLAT:
177 glShadeModel(GL_FLAT);
178 checkGLcall("glShadeModel(GL_FLAT)");
180 case WINED3DSHADE_GOURAUD:
181 glShadeModel(GL_SMOOTH);
182 checkGLcall("glShadeModel(GL_SMOOTH)");
184 case WINED3DSHADE_PHONG:
185 FIXME("WINED3DSHADE_PHONG isn't supported\n");
188 FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock->renderState[WINED3DRS_SHADEMODE]);
192 static void state_ditherenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
193 if (stateblock->renderState[WINED3DRS_DITHERENABLE]) {
195 checkGLcall("glEnable GL_DITHER");
197 glDisable(GL_DITHER);
198 checkGLcall("glDisable GL_DITHER");
202 static void state_zwritenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
203 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
204 * this has to be merged with ZENABLE and ZFUNC
206 if (stateblock->renderState[WINED3DRS_ZWRITEENABLE]) {
208 checkGLcall("glDepthMask(1)");
211 checkGLcall("glDepthMask(0)");
215 static void state_zfunc(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
216 int glParm = CompareFunc(stateblock->renderState[WINED3DRS_ZFUNC]);
220 checkGLcall("glDepthFunc");
224 static void state_ambient(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
226 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_AMBIENT], col);
228 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
229 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
230 checkGLcall("glLightModel for MODEL_AMBIENT");
233 static void state_blend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
234 int srcBlend = GL_ZERO;
235 int dstBlend = GL_ZERO;
237 /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
238 if (stateblock->renderState[WINED3DRS_ALPHABLENDENABLE] ||
239 stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
240 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
242 checkGLcall("glEnable GL_BLEND");
245 checkGLcall("glDisable GL_BLEND");
246 /* Nothing more to do - get out */
250 switch (stateblock->renderState[WINED3DRS_SRCBLEND]) {
251 case WINED3DBLEND_ZERO : srcBlend = GL_ZERO; break;
252 case WINED3DBLEND_ONE : srcBlend = GL_ONE; break;
253 case WINED3DBLEND_SRCCOLOR : srcBlend = GL_SRC_COLOR; break;
254 case WINED3DBLEND_INVSRCCOLOR : srcBlend = GL_ONE_MINUS_SRC_COLOR; break;
255 case WINED3DBLEND_SRCALPHA : srcBlend = GL_SRC_ALPHA; break;
256 case WINED3DBLEND_INVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA; break;
257 case WINED3DBLEND_DESTALPHA : srcBlend = GL_DST_ALPHA; break;
258 case WINED3DBLEND_INVDESTALPHA : srcBlend = GL_ONE_MINUS_DST_ALPHA; break;
259 case WINED3DBLEND_DESTCOLOR : srcBlend = GL_DST_COLOR; break;
260 case WINED3DBLEND_INVDESTCOLOR : srcBlend = GL_ONE_MINUS_DST_COLOR; break;
261 case WINED3DBLEND_SRCALPHASAT : srcBlend = GL_SRC_ALPHA_SATURATE; break;
263 case WINED3DBLEND_BOTHSRCALPHA : srcBlend = GL_SRC_ALPHA;
264 dstBlend = GL_SRC_ALPHA;
267 case WINED3DBLEND_BOTHINVSRCALPHA : srcBlend = GL_ONE_MINUS_SRC_ALPHA;
268 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
271 case WINED3DBLEND_BLENDFACTOR : srcBlend = GL_CONSTANT_COLOR; break;
272 case WINED3DBLEND_INVBLENDFACTOR : srcBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
274 FIXME("Unrecognized src blend value %d\n", stateblock->renderState[WINED3DRS_SRCBLEND]);
277 switch (stateblock->renderState[WINED3DRS_DESTBLEND]) {
278 case WINED3DBLEND_ZERO : dstBlend = GL_ZERO; break;
279 case WINED3DBLEND_ONE : dstBlend = GL_ONE; break;
280 case WINED3DBLEND_SRCCOLOR : dstBlend = GL_SRC_COLOR; break;
281 case WINED3DBLEND_INVSRCCOLOR : dstBlend = GL_ONE_MINUS_SRC_COLOR; break;
282 case WINED3DBLEND_SRCALPHA : dstBlend = GL_SRC_ALPHA; break;
283 case WINED3DBLEND_INVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA; break;
284 case WINED3DBLEND_DESTALPHA : dstBlend = GL_DST_ALPHA; break;
285 case WINED3DBLEND_INVDESTALPHA : dstBlend = GL_ONE_MINUS_DST_ALPHA; break;
286 case WINED3DBLEND_DESTCOLOR : dstBlend = GL_DST_COLOR; break;
287 case WINED3DBLEND_INVDESTCOLOR : dstBlend = GL_ONE_MINUS_DST_COLOR; break;
288 case WINED3DBLEND_SRCALPHASAT : dstBlend = GL_SRC_ALPHA_SATURATE; break;
290 case WINED3DBLEND_BOTHSRCALPHA : dstBlend = GL_SRC_ALPHA;
291 srcBlend = GL_SRC_ALPHA;
294 case WINED3DBLEND_BOTHINVSRCALPHA : dstBlend = GL_ONE_MINUS_SRC_ALPHA;
295 srcBlend = GL_ONE_MINUS_SRC_ALPHA;
298 case WINED3DBLEND_BLENDFACTOR : dstBlend = GL_CONSTANT_COLOR; break;
299 case WINED3DBLEND_INVBLENDFACTOR : dstBlend = GL_ONE_MINUS_CONSTANT_COLOR; break;
301 FIXME("Unrecognized dst blend value %d\n", stateblock->renderState[WINED3DRS_DESTBLEND]);
304 if(stateblock->renderState[WINED3DRS_EDGEANTIALIAS] ||
305 stateblock->renderState[WINED3DRS_ANTIALIASEDLINEENABLE]) {
306 glEnable(GL_LINE_SMOOTH);
307 checkGLcall("glEnable(GL_LINE_SMOOTH)");
308 if(srcBlend != GL_SRC_ALPHA) {
309 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
310 srcBlend = GL_SRC_ALPHA;
312 if(dstBlend != GL_ONE_MINUS_SRC_ALPHA) {
313 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
314 dstBlend = GL_ONE_MINUS_SRC_ALPHA;
317 glDisable(GL_LINE_SMOOTH);
318 checkGLcall("glDisable(GL_LINE_SMOOTH)");
321 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
322 glBlendFunc(srcBlend, dstBlend);
323 checkGLcall("glBlendFunc");
326 static void state_blendfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
329 TRACE("Setting BlendFactor to %d\n", stateblock->renderState[WINED3DRS_BLENDFACTOR]);
330 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_BLENDFACTOR], col);
331 glBlendColor (col[0],col[1],col[2],col[3]);
332 checkGLcall("glBlendColor");
335 static void state_alpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
338 BOOL enable_ckey = FALSE;
340 IWineD3DSurfaceImpl *surf;
342 /* Find out if the texture on the first stage has a ckey set
343 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
344 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
345 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
346 * in case it finds some texture+colorkeyenable combination which needs extra care.
348 if(stateblock->textures[0] && stateblock->textureDimensions[0] == GL_TEXTURE_2D) {
349 surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *)stateblock->textures[0])->surfaces[0];
351 if(surf->CKeyFlags & WINEDDSD_CKSRCBLT) {
352 const PixelFormatDesc *fmt = getFormatDescEntry(surf->resource.format);
353 /* The surface conversion does not do color keying conversion for surfaces that have an alpha
354 * channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
355 * surface has alpha bits
357 if(fmt->alphaMask == 0x00000000) {
363 if(enable_ckey || context->last_was_ckey) {
364 StateTable[STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP)].apply(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
366 context->last_was_ckey = enable_ckey;
368 if (stateblock->renderState[WINED3DRS_ALPHATESTENABLE] ||
369 (stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey)) {
370 glEnable(GL_ALPHA_TEST);
371 checkGLcall("glEnable GL_ALPHA_TEST");
373 glDisable(GL_ALPHA_TEST);
374 checkGLcall("glDisable GL_ALPHA_TEST");
375 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
381 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && enable_ckey) {
382 glParm = GL_NOTEQUAL;
385 ref = ((float) stateblock->renderState[WINED3DRS_ALPHAREF]) / 255.0f;
386 glParm = CompareFunc(stateblock->renderState[WINED3DRS_ALPHAFUNC]);
389 glAlphaFunc(glParm, ref);
390 checkGLcall("glAlphaFunc");
394 static void state_clipping(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
395 DWORD enable = 0xFFFFFFFF;
396 DWORD disable = 0x00000000;
398 if (use_vs(stateblock->wineD3DDevice)) {
399 /* The spec says that opengl clipping planes are disabled when using shaders. Direct3D planes aren't,
400 * so that is an issue. The MacOS ATI driver keeps clipping planes activated with shaders in some
401 * contitions I got sick of tracking down. The shader state handler disables all clip planes because
402 * of that - don't do anything here and keep them disabled
404 if(stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
405 static BOOL warned = FALSE;
407 FIXME("Clipping not supported with vertex shaders\n");
414 /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
415 * of already set values
418 /* If enabling / disabling all
419 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
421 if (stateblock->renderState[WINED3DRS_CLIPPING]) {
422 enable = stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
423 disable = ~stateblock->renderState[WINED3DRS_CLIPPLANEENABLE];
425 disable = 0xffffffff;
429 if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
430 if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
431 if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
432 if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
433 if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
434 if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
436 if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
437 if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
438 if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
439 if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
440 if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
441 if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
443 /** update clipping status */
445 stateblock->clip_status.ClipUnion = 0;
446 stateblock->clip_status.ClipIntersection = 0xFFFFFFFF;
448 stateblock->clip_status.ClipUnion = 0;
449 stateblock->clip_status.ClipIntersection = 0;
453 static void state_blendop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
454 int glParm = GL_FUNC_ADD;
456 if(!GL_SUPPORT(EXT_BLEND_MINMAX)) {
457 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
461 switch ((WINED3DBLENDOP) stateblock->renderState[WINED3DRS_BLENDOP]) {
462 case WINED3DBLENDOP_ADD : glParm = GL_FUNC_ADD; break;
463 case WINED3DBLENDOP_SUBTRACT : glParm = GL_FUNC_SUBTRACT; break;
464 case WINED3DBLENDOP_REVSUBTRACT : glParm = GL_FUNC_REVERSE_SUBTRACT; break;
465 case WINED3DBLENDOP_MIN : glParm = GL_MIN; break;
466 case WINED3DBLENDOP_MAX : glParm = GL_MAX; break;
468 FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock->renderState[WINED3DRS_BLENDOP]);
471 TRACE("glBlendEquation(%x)\n", glParm);
472 GL_EXTCALL(glBlendEquation(glParm));
473 checkGLcall("glBlendEquation");
477 state_specularenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
478 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
479 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
480 * specular color. This is wrong:
481 * Separate specular color means the specular colour is maintained separately, whereas
482 * single color means it is merged in. However in both cases they are being used to
484 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
485 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
489 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
490 * Instead, we need to setup the FinalCombiner properly.
492 * The default setup for the FinalCombiner is:
494 * <variable> <input> <mapping> <usage>
495 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
496 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
497 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
498 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
499 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
500 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
501 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
503 * That's pretty much fine as it is, except for variable B, which needs to take
504 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
505 * whether WINED3DRS_SPECULARENABLE is enabled or not.
508 TRACE("Setting specular enable state\n");
509 /* TODO: Add to the material setting functions */
510 if (stateblock->renderState[WINED3DRS_SPECULARENABLE]) {
511 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &stateblock->material.Specular);
512 checkGLcall("glMaterialfv");
513 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
514 glEnable(GL_COLOR_SUM_EXT);
516 TRACE("Specular colors cannot be enabled in this version of opengl\n");
518 checkGLcall("glEnable(GL_COLOR_SUM)");
520 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
521 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
522 checkGLcall("glFinalCombinerInputNV()");
525 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
527 /* for the case of enabled lighting: */
528 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
529 checkGLcall("glMaterialfv");
531 /* for the case of disabled lighting: */
532 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
533 glDisable(GL_COLOR_SUM_EXT);
535 TRACE("Specular colors cannot be disabled in this version of opengl\n");
537 checkGLcall("glDisable(GL_COLOR_SUM)");
539 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
540 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
541 checkGLcall("glFinalCombinerInputNV()");
546 static void state_texfactor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
549 /* Note the texture color applies to all textures whereas
550 * GL_TEXTURE_ENV_COLOR applies to active only
553 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_TEXTUREFACTOR], col);
555 if (!GL_SUPPORT(NV_REGISTER_COMBINERS)) {
556 /* And now the default texture color as well */
557 for (i = 0; i < GL_LIMITS(texture_stages); i++) {
558 /* Note the WINED3DRS value applies to all textures, but GL has one
559 * per texture, so apply it now ready to be used!
561 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
562 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
563 checkGLcall("glActiveTextureARB");
565 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
568 glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
569 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
572 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV, &col[0]));
577 renderstate_stencil_twosided(IWineD3DStateBlockImpl *stateblock, GLint face, GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass ) {
578 #if 0 /* Don't use OpenGL 2.0 calls for now */
579 if(GL_EXTCALL(glStencilFuncSeparate) && GL_EXTCALL(glStencilOpSeparate)) {
580 GL_EXTCALL(glStencilFuncSeparate(face, func, ref, mask));
581 checkGLcall("glStencilFuncSeparate(...)");
582 GL_EXTCALL(glStencilOpSeparate(face, stencilFail, depthFail, stencilPass));
583 checkGLcall("glStencilOpSeparate(...)");
587 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE)) {
588 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
589 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
590 GL_EXTCALL(glActiveStencilFaceEXT(face));
591 checkGLcall("glActiveStencilFaceEXT(...)");
592 glStencilFunc(func, ref, mask);
593 checkGLcall("glStencilFunc(...)");
594 glStencilOp(stencilFail, depthFail, stencilPass);
595 checkGLcall("glStencilOp(...)");
596 } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL)) {
597 GL_EXTCALL(glStencilFuncSeparateATI(face, func, ref, mask));
598 checkGLcall("glStencilFuncSeparateATI(...)");
599 GL_EXTCALL(glStencilOpSeparateATI(face, stencilFail, depthFail, stencilPass));
600 checkGLcall("glStencilOpSeparateATI(...)");
602 ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
607 state_stencil(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
608 DWORD onesided_enable = FALSE;
609 DWORD twosided_enable = FALSE;
610 GLint func = GL_ALWAYS;
611 GLint func_ccw = GL_ALWAYS;
614 GLint stencilFail = GL_KEEP;
615 GLint depthFail = GL_KEEP;
616 GLint stencilPass = GL_KEEP;
617 GLint stencilFail_ccw = GL_KEEP;
618 GLint depthFail_ccw = GL_KEEP;
619 GLint stencilPass_ccw = GL_KEEP;
621 /* No stencil test without a stencil buffer */
622 if(stateblock->wineD3DDevice->stencilBufferTarget == NULL) {
623 glDisable(GL_STENCIL_TEST);
624 checkGLcall("glDisable GL_STENCIL_TEST");
628 if( stateblock->set.renderState[WINED3DRS_STENCILENABLE] )
629 onesided_enable = stateblock->renderState[WINED3DRS_STENCILENABLE];
630 if( stateblock->set.renderState[WINED3DRS_TWOSIDEDSTENCILMODE] )
631 twosided_enable = stateblock->renderState[WINED3DRS_TWOSIDEDSTENCILMODE];
632 if( stateblock->set.renderState[WINED3DRS_STENCILFUNC] )
633 if( !( func = CompareFunc(stateblock->renderState[WINED3DRS_STENCILFUNC]) ) )
635 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFUNC] )
636 if( !( func_ccw = CompareFunc(stateblock->renderState[WINED3DRS_CCW_STENCILFUNC]) ) )
638 if( stateblock->set.renderState[WINED3DRS_STENCILREF] )
639 ref = stateblock->renderState[WINED3DRS_STENCILREF];
640 if( stateblock->set.renderState[WINED3DRS_STENCILMASK] )
641 mask = stateblock->renderState[WINED3DRS_STENCILMASK];
642 if( stateblock->set.renderState[WINED3DRS_STENCILFAIL] )
643 stencilFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILFAIL]);
644 if( stateblock->set.renderState[WINED3DRS_STENCILZFAIL] )
645 depthFail = StencilOp(stateblock->renderState[WINED3DRS_STENCILZFAIL]);
646 if( stateblock->set.renderState[WINED3DRS_STENCILPASS] )
647 stencilPass = StencilOp(stateblock->renderState[WINED3DRS_STENCILPASS]);
648 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILFAIL] )
649 stencilFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILFAIL]);
650 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILZFAIL] )
651 depthFail_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILZFAIL]);
652 if( stateblock->set.renderState[WINED3DRS_CCW_STENCILPASS] )
653 stencilPass_ccw = StencilOp(stateblock->renderState[WINED3DRS_CCW_STENCILPASS]);
655 TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
656 "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
657 "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
658 onesided_enable, twosided_enable, ref, mask,
659 func, stencilFail, depthFail, stencilPass,
660 func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
662 if (twosided_enable) {
663 renderstate_stencil_twosided(stateblock, GL_FRONT, func, ref, mask, stencilFail, depthFail, stencilPass);
664 renderstate_stencil_twosided(stateblock, GL_BACK, func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
666 if (onesided_enable) {
667 glEnable(GL_STENCIL_TEST);
668 checkGLcall("glEnable GL_STENCIL_TEST");
669 glStencilFunc(func, ref, mask);
670 checkGLcall("glStencilFunc(...)");
671 glStencilOp(stencilFail, depthFail, stencilPass);
672 checkGLcall("glStencilOp(...)");
674 glDisable(GL_STENCIL_TEST);
675 checkGLcall("glDisable GL_STENCIL_TEST");
680 static void state_stencilwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
681 if(stateblock->wineD3DDevice->stencilBufferTarget) {
682 glStencilMask(stateblock->renderState[WINED3DRS_STENCILWRITEMASK]);
686 checkGLcall("glStencilMask");
689 static void state_fog(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
690 /* TODO: Put this into the vertex type block once that is in the state table */
691 BOOL fogenable = stateblock->renderState[WINED3DRS_FOGENABLE];
692 BOOL is_ps3 = use_ps(stateblock->wineD3DDevice)
693 && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.hex_version >= WINED3DPS_VERSION(3,0);
694 float fogstart, fogend;
702 /* No fog? Disable it, and we're done :-) */
704 checkGLcall("glDisable GL_FOG");
705 if( use_ps(stateblock->wineD3DDevice)
706 && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.hex_version < WINED3DPS_VERSION(3,0) ) {
707 /* disable fog in the pixel shader
708 * NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
709 * -1/(e-s) and e/(e-s) respectively.
711 glFogf(GL_FOG_START, 0.0f);
712 checkGLcall("glFogf(GL_FOG_START, fogstart");
713 glFogf(GL_FOG_END, 1.0f);
714 checkGLcall("glFogf(GL_FOG_END, fogend");
719 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGSTART];
720 fogstart = tmpvalue.f;
721 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGEND];
726 * With fixed function vertex processing, Direct3D knows 2 different fog input sources.
727 * It can use the Z value of the vertex, or the alpha component of the specular color.
728 * This depends on the fog vertex, fog table and the vertex declaration. If the Z value
729 * is used, fogstart, fogend and the equation type are used, otherwise linear fog with
730 * start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
732 * FOGTABLEMODE != NONE:
733 * The Z value is used, with the equation specified, no matter what vertex type.
735 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
736 * Per vertex fog is calculated using the specified fog equation and the parameters
738 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
739 * FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
740 * Linear fog with start = 255.0, end = 0.0, input comes from the specular color
743 * Rules for vertex fog with shaders:
745 * When mixing fixed function functionality with the programmable pipeline, D3D expects
746 * the fog computation to happen during transformation while openGL expects it to happen
747 * during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
748 * the pixel shader while openGL always expects the pixel shader to handle the blending.
749 * To solve this problem, WineD3D does:
750 * 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
752 * and 2) disables the fog computation (in either the fixed function or programmable
753 * rasterizer) if using a vertex program.
756 * If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
761 if( !use_vs(stateblock->wineD3DDevice)
762 && stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE ) {
763 FIXME("Implement vertex fog for pixel shader >= 3.0 and fixed function pipeline\n");
767 if (use_vs(stateblock->wineD3DDevice)
768 && ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.fog) {
769 if( stateblock->renderState[WINED3DRS_FOGTABLEMODE] != WINED3DFOG_NONE ) {
770 if(!is_ps3) FIXME("Implement table fog for foggy vertex shader\n");
774 /* Set fog computation in the rasterizer to pass through the value (just blend it) */
775 glFogi(GL_FOG_MODE, GL_LINEAR);
776 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
780 context->last_was_foggy_shader = TRUE;
782 else if( use_ps(stateblock->wineD3DDevice) ) {
783 /* NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
784 * -1/(e-s) and e/(e-s) respectively to simplify fog computation in the shader.
787 context->last_was_foggy_shader = FALSE;
789 /* If both fogmodes are set use the table fog mode */
790 if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
791 mode = stateblock->renderState[WINED3DRS_FOGVERTEXMODE];
793 mode = stateblock->renderState[WINED3DRS_FOGTABLEMODE];
797 case WINED3DFOG_EXP2:
798 if(!is_ps3) FIXME("Implement non linear fog for pixel shader < 3.0\n");
803 case WINED3DFOG_LINEAR:
804 fogstart = -1.0f/(fogend-fogstart);
808 case WINED3DFOG_NONE:
809 if(!is_ps3) FIXME("Implement software vertex fog for pixel shader < 3.0\n");
813 default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
816 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
817 * the system will apply only pixel(=table) fog effects."
819 else if(stateblock->renderState[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE) {
820 glHint(GL_FOG_HINT, GL_FASTEST);
821 checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
822 context->last_was_foggy_shader = FALSE;
824 switch (stateblock->renderState[WINED3DRS_FOGVERTEXMODE]) {
825 /* If processed vertices are used, fall through to the NONE case */
826 case WINED3DFOG_EXP: {
827 if(!context->last_was_rhw) {
828 glFogi(GL_FOG_MODE, GL_EXP);
829 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
830 if(GL_SUPPORT(EXT_FOG_COORD)) {
831 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
832 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
837 case WINED3DFOG_EXP2: {
838 if(!context->last_was_rhw) {
839 glFogi(GL_FOG_MODE, GL_EXP2);
840 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
841 if(GL_SUPPORT(EXT_FOG_COORD)) {
842 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
843 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
848 case WINED3DFOG_LINEAR: {
849 if(!context->last_was_rhw) {
850 glFogi(GL_FOG_MODE, GL_LINEAR);
851 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
852 if(GL_SUPPORT(EXT_FOG_COORD)) {
853 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
854 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
859 case WINED3DFOG_NONE: {
860 /* Both are none? According to msdn the alpha channel of the specular
861 * color contains a fog factor. Set it in drawStridedSlow.
862 * Same happens with Vertexfog on transformed vertices
864 if(GL_SUPPORT(EXT_FOG_COORD)) {
865 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
866 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
867 glFogi(GL_FOG_MODE, GL_LINEAR);
868 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
872 /* Disable GL fog, handle this in software in drawStridedSlow */
877 default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock->renderState[WINED3DRS_FOGVERTEXMODE]);
880 glHint(GL_FOG_HINT, GL_NICEST);
881 checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
882 context->last_was_foggy_shader = FALSE;
884 switch (stateblock->renderState[WINED3DRS_FOGTABLEMODE]) {
886 glFogi(GL_FOG_MODE, GL_EXP);
887 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
888 if(GL_SUPPORT(EXT_FOG_COORD)) {
889 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
890 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
894 case WINED3DFOG_EXP2:
895 glFogi(GL_FOG_MODE, GL_EXP2);
896 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
897 if(GL_SUPPORT(EXT_FOG_COORD)) {
898 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
899 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
903 case WINED3DFOG_LINEAR:
904 glFogi(GL_FOG_MODE, GL_LINEAR);
905 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
906 if(GL_SUPPORT(EXT_FOG_COORD)) {
907 glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
908 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
912 case WINED3DFOG_NONE: /* Won't happen */
914 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock->renderState[WINED3DRS_FOGTABLEMODE]);
920 checkGLcall("glEnable GL_FOG");
922 glFogfv(GL_FOG_START, &fogstart);
923 checkGLcall("glFogf(GL_FOG_START, fogstart");
924 TRACE("Fog Start == %f\n", fogstart);
926 glFogfv(GL_FOG_END, &fogend);
927 checkGLcall("glFogf(GL_FOG_END, fogend");
928 TRACE("Fog End == %f\n", fogend);
931 checkGLcall("glDisable GL_FOG");
932 if( use_ps(stateblock->wineD3DDevice) ) {
933 /* disable fog in the pixel shader
934 * NOTE: For pixel shader, GL_FOG_START and GL_FOG_END don't hold fog start s and end e but
935 * -1/(e-s) and e/(e-s) respectively.
937 glFogf(GL_FOG_START, 0.0f);
938 checkGLcall("glFogf(GL_FOG_START, fogstart");
939 glFogf(GL_FOG_END, 1.0f);
940 checkGLcall("glFogf(GL_FOG_END, fogend");
944 if (GL_SUPPORT(NV_FOG_DISTANCE)) {
945 glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
949 static void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
951 D3DCOLORTOGLFLOAT4(stateblock->renderState[WINED3DRS_FOGCOLOR], col);
952 glFogfv(GL_FOG_COLOR, &col[0]);
953 checkGLcall("glFog GL_FOG_COLOR");
956 static void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
961 tmpvalue.d = stateblock->renderState[WINED3DRS_FOGDENSITY];
962 glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
963 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
966 /* TODO: Merge with primitive type + init_materials()!! */
967 static void state_colormat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
968 IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)stateblock->wineD3DDevice;
970 WineDirect3DStridedData *diffuse = &device->strided_streams.u.s.diffuse;
971 BOOL isDiffuseSupplied;
973 /* Depends on the decoded vertex declaration to read the existence of diffuse data.
974 * The vertex declaration will call this function if the fixed function pipeline is used.
977 if(isStateDirty(context, STATE_VDECL)) {
981 isDiffuseSupplied = diffuse->lpData || diffuse->VBO;
983 if (isDiffuseSupplied && stateblock->renderState[WINED3DRS_COLORVERTEX]) {
984 TRACE("diff %d, amb %d, emis %d, spec %d\n",
985 stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE],
986 stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE],
987 stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE],
988 stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE]);
990 if (stateblock->renderState[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
991 if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
992 Parm = GL_AMBIENT_AND_DIFFUSE;
996 } else if (stateblock->renderState[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1) {
998 } else if (stateblock->renderState[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1000 } else if (stateblock->renderState[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1) {
1005 /* Nothing changed, return. */
1006 if (Parm == context->tracking_parm) return;
1009 glDisable(GL_COLOR_MATERIAL);
1010 checkGLcall("glDisable GL_COLOR_MATERIAL");
1012 glColorMaterial(GL_FRONT_AND_BACK, Parm);
1013 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1014 glEnable(GL_COLOR_MATERIAL);
1015 checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1018 /* Apparently calls to glMaterialfv are ignored for properties we're
1019 * tracking with glColorMaterial, so apply those here. */
1020 switch (context->tracking_parm) {
1021 case GL_AMBIENT_AND_DIFFUSE:
1022 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1023 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1024 checkGLcall("glMaterialfv");
1028 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*)&device->updateStateBlock->material.Diffuse);
1029 checkGLcall("glMaterialfv");
1033 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*)&device->updateStateBlock->material.Ambient);
1034 checkGLcall("glMaterialfv");
1038 glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*)&device->updateStateBlock->material.Emissive);
1039 checkGLcall("glMaterialfv");
1043 /* Only change material color if specular is enabled, otherwise it is set to black */
1044 if (device->stateBlock->renderState[WINED3DRS_SPECULARENABLE]) {
1045 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*)&device->updateStateBlock->material.Specular);
1046 checkGLcall("glMaterialfv");
1048 float black[4] = {0.0f, 0.0f, 0.0f, 0.0f};
1049 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
1050 checkGLcall("glMaterialfv");
1055 context->tracking_parm = Parm;
1058 static void state_linepattern(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1061 WINED3DLINEPATTERN lp;
1063 tmppattern.d = stateblock->renderState[WINED3DRS_LINEPATTERN];
1065 TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1067 if (tmppattern.lp.wRepeatFactor) {
1068 glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
1069 checkGLcall("glLineStipple(repeat, linepattern)");
1070 glEnable(GL_LINE_STIPPLE);
1071 checkGLcall("glEnable(GL_LINE_STIPPLE);");
1073 glDisable(GL_LINE_STIPPLE);
1074 checkGLcall("glDisable(GL_LINE_STIPPLE);");
1078 static void state_zbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1084 if (stateblock->renderState[WINED3DRS_ZBIAS]) {
1085 tmpvalue.d = stateblock->renderState[WINED3DRS_ZBIAS];
1086 TRACE("ZBias value %f\n", tmpvalue.f);
1087 glPolygonOffset(0, -tmpvalue.f);
1088 checkGLcall("glPolygonOffset(0, -Value)");
1089 glEnable(GL_POLYGON_OFFSET_FILL);
1090 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
1091 glEnable(GL_POLYGON_OFFSET_LINE);
1092 checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
1093 glEnable(GL_POLYGON_OFFSET_POINT);
1094 checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
1096 glDisable(GL_POLYGON_OFFSET_FILL);
1097 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
1098 glDisable(GL_POLYGON_OFFSET_LINE);
1099 checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
1100 glDisable(GL_POLYGON_OFFSET_POINT);
1101 checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
1106 static void state_normalize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1107 if (stateblock->renderState[WINED3DRS_NORMALIZENORMALS]) {
1108 glEnable(GL_NORMALIZE);
1109 checkGLcall("glEnable(GL_NORMALIZE);");
1111 glDisable(GL_NORMALIZE);
1112 checkGLcall("glDisable(GL_NORMALIZE);");
1116 static void state_psize(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1122 /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
1123 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE];
1124 TRACE("Set point size to %f\n", tmpvalue.f);
1125 glPointSize(tmpvalue.f);
1126 checkGLcall("glPointSize(...);");
1129 static void state_psizemin(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1135 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MIN];
1136 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1137 GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, tmpvalue.f);
1138 checkGLcall("glPointParameterfARB(...");
1140 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1141 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, tmpvalue.f);
1142 checkGLcall("glPointParameterfEXT(...);");
1143 } else if(tmpvalue.f != 1.0) {
1144 FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
1148 static void state_psizemax(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1154 tmpvalue.d = stateblock->renderState[WINED3DRS_POINTSIZE_MAX];
1155 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1156 GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, tmpvalue.f);
1157 checkGLcall("glPointParameterfARB(...");
1159 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1160 GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, tmpvalue.f);
1161 checkGLcall("glPointParameterfEXT(...);");
1162 } else if(tmpvalue.f != 64.0) {
1163 FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
1167 static void state_pscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1168 /* TODO: Group this with the viewport */
1170 * POINTSCALEENABLE controls how point size value is treated. If set to
1171 * true, the point size is scaled with respect to height of viewport.
1172 * When set to false point size is in pixels.
1174 * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
1177 /* Default values */
1178 GLfloat att[3] = {1.0f, 0.0f, 0.0f};
1181 * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
1182 * This means that OpenGL will clamp really small point sizes to 1.0f.
1183 * To correct for this we need to multiply by the scale factor when sizes
1184 * are less than 1.0f. scale_factor = 1.0f / point_size.
1186 GLfloat pointSize = *((float*)&stateblock->renderState[WINED3DRS_POINTSIZE]);
1187 if(pointSize > 0.0f) {
1188 GLfloat scaleFactor;
1190 if(pointSize < 1.0f) {
1191 scaleFactor = pointSize * pointSize;
1196 if(stateblock->renderState[WINED3DRS_POINTSCALEENABLE]) {
1197 att[0] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_A]) /
1198 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1199 att[1] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_B]) /
1200 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1201 att[2] = *((float*)&stateblock->renderState[WINED3DRS_POINTSCALE_C]) /
1202 (stateblock->viewport.Height * stateblock->viewport.Height * scaleFactor);
1206 if(GL_SUPPORT(ARB_POINT_PARAMETERS)) {
1207 GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
1208 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
1210 else if(GL_SUPPORT(EXT_POINT_PARAMETERS)) {
1211 GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
1212 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
1214 TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
1218 static void state_colorwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1219 DWORD Value = stateblock->renderState[WINED3DRS_COLORWRITEENABLE];
1221 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1222 Value & WINED3DCOLORWRITEENABLE_RED ? 1 : 0,
1223 Value & WINED3DCOLORWRITEENABLE_GREEN ? 1 : 0,
1224 Value & WINED3DCOLORWRITEENABLE_BLUE ? 1 : 0,
1225 Value & WINED3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
1226 glColorMask(Value & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
1227 Value & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
1228 Value & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
1229 Value & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
1230 checkGLcall("glColorMask(...)");
1232 /* depends on WINED3DRS_COLORWRITEENABLE. */
1233 if(stateblock->renderState[WINED3DRS_COLORWRITEENABLE1] != 0x0000000F ||
1234 stateblock->renderState[WINED3DRS_COLORWRITEENABLE2] != 0x0000000F ||
1235 stateblock->renderState[WINED3DRS_COLORWRITEENABLE3] != 0x0000000F ) {
1236 ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1237 stateblock->renderState[WINED3DRS_COLORWRITEENABLE1],
1238 stateblock->renderState[WINED3DRS_COLORWRITEENABLE2],
1239 stateblock->renderState[WINED3DRS_COLORWRITEENABLE3]);
1243 static void state_localviewer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1244 if(stateblock->renderState[WINED3DRS_LOCALVIEWER]) {
1245 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
1246 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1248 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
1249 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1253 static void state_lastpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1254 if(stateblock->renderState[WINED3DRS_LASTPIXEL]) {
1255 TRACE("Last Pixel Drawing Enabled\n");
1257 static BOOL first = TRUE;
1259 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1262 TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1267 static void state_pointsprite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1271 /* TODO: NV_POINT_SPRITE */
1272 if (!GL_SUPPORT(ARB_POINT_SPRITE)) {
1273 TRACE("Point sprites not supported\n");
1277 if (stateblock->renderState[WINED3DRS_POINTSPRITEENABLE]) {
1283 for (i = 0; i < GL_LIMITS(textures); i++) {
1284 /* Note the WINED3DRS value applies to all textures, but GL has one
1285 * per texture, so apply it now ready to be used!
1287 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1288 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
1289 checkGLcall("glActiveTextureARB");
1291 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1295 glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, val);
1296 checkGLcall((val?"glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE)":
1297 "glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_FALSE)"));
1301 static void state_wrap(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1303 http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1304 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1305 http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1306 Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1307 http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1309 so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1312 if(stateblock->renderState[WINED3DRS_WRAP0] ||
1313 stateblock->renderState[WINED3DRS_WRAP1] ||
1314 stateblock->renderState[WINED3DRS_WRAP2] ||
1315 stateblock->renderState[WINED3DRS_WRAP3] ||
1316 stateblock->renderState[WINED3DRS_WRAP4] ||
1317 stateblock->renderState[WINED3DRS_WRAP5] ||
1318 stateblock->renderState[WINED3DRS_WRAP6] ||
1319 stateblock->renderState[WINED3DRS_WRAP7] ||
1320 stateblock->renderState[WINED3DRS_WRAP8] ||
1321 stateblock->renderState[WINED3DRS_WRAP9] ||
1322 stateblock->renderState[WINED3DRS_WRAP10] ||
1323 stateblock->renderState[WINED3DRS_WRAP11] ||
1324 stateblock->renderState[WINED3DRS_WRAP12] ||
1325 stateblock->renderState[WINED3DRS_WRAP13] ||
1326 stateblock->renderState[WINED3DRS_WRAP14] ||
1327 stateblock->renderState[WINED3DRS_WRAP15] ) {
1328 FIXME("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1332 static void state_multisampleaa(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1333 if( GL_SUPPORT(ARB_MULTISAMPLE) ) {
1334 if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1335 glEnable(GL_MULTISAMPLE_ARB);
1336 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1338 glDisable(GL_MULTISAMPLE_ARB);
1339 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1342 if(stateblock->renderState[WINED3DRS_MULTISAMPLEANTIALIAS]) {
1343 ERR("Multisample antialiasing not supported by gl\n");
1348 static void state_scissor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1349 if(stateblock->renderState[WINED3DRS_SCISSORTESTENABLE]) {
1350 glEnable(GL_SCISSOR_TEST);
1351 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1353 glDisable(GL_SCISSOR_TEST);
1354 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1358 static void state_depthbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1364 if(stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS] ||
1365 stateblock->renderState[WINED3DRS_DEPTHBIAS]) {
1366 tmpvalue.d = stateblock->renderState[WINED3DRS_SLOPESCALEDEPTHBIAS];
1367 glEnable(GL_POLYGON_OFFSET_FILL);
1368 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1369 glPolygonOffset(tmpvalue.f, *((float*)&stateblock->renderState[WINED3DRS_DEPTHBIAS]));
1370 checkGLcall("glPolygonOffset(...)");
1372 glDisable(GL_POLYGON_OFFSET_FILL);
1373 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1377 static void state_perspective(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1378 if (stateblock->renderState[WINED3DRS_TEXTUREPERSPECTIVE]) {
1379 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
1380 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1382 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
1383 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1387 static void state_stippledalpha(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1389 if (stateblock->renderState[WINED3DRS_STIPPLEDALPHA])
1390 FIXME(" Stippled Alpha not supported yet.\n");
1393 static void state_antialias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1395 if (stateblock->renderState[WINED3DRS_ANTIALIAS])
1396 FIXME(" Antialias not supported yet.\n");
1399 static void state_multisampmask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1401 if (stateblock->renderState[WINED3DRS_MULTISAMPLEMASK] != 0xFFFFFFFF)
1402 FIXME("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_MULTISAMPLEMASK]);
1405 static void state_patchedgestyle(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1407 if (stateblock->renderState[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
1408 FIXME("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_PATCHEDGESTYLE]);
1411 static void state_patchsegments(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1419 if (stateblock->renderState[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
1421 static BOOL displayed = FALSE;
1423 tmpvalue.d = stateblock->renderState[WINED3DRS_PATCHSEGMENTS];
1425 FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
1431 static void state_positiondegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1433 if (stateblock->renderState[WINED3DRS_POSITIONDEGREE] != WINED3DDEGREE_CUBIC)
1434 FIXME("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_POSITIONDEGREE]);
1437 static void state_normaldegree(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1439 if (stateblock->renderState[WINED3DRS_NORMALDEGREE] != WINED3DDEGREE_LINEAR)
1440 FIXME("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_NORMALDEGREE]);
1443 static void state_tessellation(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1445 if(stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION])
1446 FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
1450 static void state_srgbwrite(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1451 if(stateblock->renderState[WINED3DRS_SRGBWRITEENABLE])
1452 FIXME("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1455 static void state_seperateblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1457 if(stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE])
1458 FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock->renderState[WINED3DRS_SEPARATEALPHABLENDENABLE]);
1461 static void state_wrapu(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1462 if(stateblock->renderState[WINED3DRS_WRAPU]) {
1463 FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1467 static void state_wrapv(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1468 if(stateblock->renderState[WINED3DRS_WRAPV]) {
1469 FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1473 static void state_monoenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1474 if(stateblock->renderState[WINED3DRS_MONOENABLE]) {
1475 FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1479 static void state_rop2(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1480 if(stateblock->renderState[WINED3DRS_ROP2]) {
1481 FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1485 static void state_planemask(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1486 if(stateblock->renderState[WINED3DRS_PLANEMASK]) {
1487 FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1491 static void state_subpixel(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1492 if(stateblock->renderState[WINED3DRS_SUBPIXEL]) {
1493 FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1497 static void state_subpixelx(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1498 if(stateblock->renderState[WINED3DRS_SUBPIXELX]) {
1499 FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1503 static void state_stippleenable(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1504 if(stateblock->renderState[WINED3DRS_STIPPLEENABLE]) {
1505 FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1509 static void state_bordercolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1510 if(stateblock->renderState[WINED3DRS_BORDERCOLOR]) {
1511 FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1515 static void state_mipmaplodbias(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1516 if(stateblock->renderState[WINED3DRS_MIPMAPLODBIAS]) {
1517 FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1521 static void state_anisotropy(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1522 if(stateblock->renderState[WINED3DRS_ANISOTROPY]) {
1523 FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1527 static void state_flushbatch(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1528 if(stateblock->renderState[WINED3DRS_FLUSHBATCH]) {
1529 FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1533 static void state_translucentsi(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1534 if(stateblock->renderState[WINED3DRS_TRANSLUCENTSORTINDEPENDENT]) {
1535 FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1539 static void state_extents(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1540 if(stateblock->renderState[WINED3DRS_EXTENTS]) {
1541 FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1545 static void state_ckeyblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1546 if(stateblock->renderState[WINED3DRS_COLORKEYBLENDENABLE]) {
1547 FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1551 /* Activates the texture dimension according to the bound D3D texture.
1552 * Does not care for the colorop or correct gl texture unit(when using nvrc)
1553 * Requires the caller to activate the correct unit before
1555 static void activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1556 BOOL bumpmap = FALSE;
1558 if(stage > 0 && (stateblock->textureState[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE ||
1559 stateblock->textureState[stage - 1][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP)) {
1561 context->texShaderBumpMap |= (1 << stage);
1563 context->texShaderBumpMap &= ~(1 << stage);
1566 if(stateblock->textures[stage]) {
1567 switch(stateblock->textureDimensions[stage]) {
1569 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1570 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, bumpmap ? GL_OFFSET_TEXTURE_2D_NV : GL_TEXTURE_2D);
1572 glDisable(GL_TEXTURE_3D);
1573 checkGLcall("glDisable(GL_TEXTURE_3D)");
1574 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1575 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1576 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1578 glEnable(GL_TEXTURE_2D);
1579 checkGLcall("glEnable(GL_TEXTURE_2D)");
1583 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1584 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D);
1586 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1587 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1588 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1590 glDisable(GL_TEXTURE_2D);
1591 checkGLcall("glDisable(GL_TEXTURE_2D)");
1592 glEnable(GL_TEXTURE_3D);
1593 checkGLcall("glEnable(GL_TEXTURE_3D)");
1594 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_3D);
1597 case GL_TEXTURE_CUBE_MAP_ARB:
1598 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1599 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB);
1601 glDisable(GL_TEXTURE_2D);
1602 checkGLcall("glDisable(GL_TEXTURE_2D)");
1603 glDisable(GL_TEXTURE_3D);
1604 checkGLcall("glDisable(GL_TEXTURE_3D)");
1605 glEnable(GL_TEXTURE_CUBE_MAP_ARB);
1606 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1607 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_TEXTURE_CUBE_MAP_ARB);
1612 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1613 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
1615 glDisable(GL_TEXTURE_2D);
1616 checkGLcall("glDisable(GL_TEXTURE_2D)");
1617 glDisable(GL_TEXTURE_3D);
1618 checkGLcall("glDisable(GL_TEXTURE_3D)");
1619 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1620 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1621 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1623 /* Binding textures is done by samplers. A dummy texture will be bound */
1628 static void tex_colorop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1629 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1630 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1632 TRACE("Setting color op for stage %d\n", stage);
1634 if (stateblock->pixelShader && stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE &&
1635 ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
1636 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1640 if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
1642 if (mapped_stage != -1) {
1643 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1644 if (mapped_stage >= GL_LIMITS(textures)) {
1645 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1646 stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1647 FIXME("Attempt to enable unsupported stage!\n");
1651 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1652 checkGLcall("glActiveTextureARB");
1653 } else if (stage > 0) {
1654 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1659 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1660 if(stateblock->lowest_disabled_stage > 0) {
1661 glEnable(GL_REGISTER_COMBINERS_NV);
1662 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV, stateblock->lowest_disabled_stage));
1664 glDisable(GL_REGISTER_COMBINERS_NV);
1667 if(stage >= stateblock->lowest_disabled_stage) {
1668 TRACE("Stage disabled\n");
1669 if (mapped_stage != -1) {
1670 /* Disable everything here */
1671 glDisable(GL_TEXTURE_2D);
1672 checkGLcall("glDisable(GL_TEXTURE_2D)");
1673 glDisable(GL_TEXTURE_3D);
1674 checkGLcall("glDisable(GL_TEXTURE_3D)");
1675 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
1676 glDisable(GL_TEXTURE_CUBE_MAP_ARB);
1677 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1680 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1681 glTexEnvi(GL_TEXTURE_SHADER_NV, GL_SHADER_OPERATION_NV, GL_NONE);
1687 /* The sampler will also activate the correct texture dimensions, so no need to do it here
1688 * if the sampler for this stage is dirty
1690 if(!isStateDirty(context, STATE_SAMPLER(stage))) {
1691 if (mapped_stage != -1) activate_dimensions(stage, stateblock, context);
1694 /* Set the texture combiners */
1695 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1696 set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1697 stateblock->textureState[stage][WINED3DTSS_COLOROP],
1698 stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1699 stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1700 stateblock->textureState[stage][WINED3DTSS_COLORARG0],
1703 /* In register combiners bump mapping is done in the stage AFTER the one that has the bump map operation set,
1704 * thus the texture shader may have to be updated
1706 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
1707 BOOL usesBump = (stateblock->textureState[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAPLUMINANCE ||
1708 stateblock->textureState[stage][WINED3DTSS_COLOROP] == WINED3DTOP_BUMPENVMAP) ? TRUE : FALSE;
1709 BOOL usedBump = (context->texShaderBumpMap & 1 << (stage + 1)) ? TRUE : FALSE;
1710 if(usesBump != usedBump) {
1711 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage + 1));
1712 checkGLcall("glActiveTextureARB");
1713 activate_dimensions(stage + 1, stateblock, context);
1714 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1715 checkGLcall("glActiveTextureARB");
1719 set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, FALSE, stage,
1720 stateblock->textureState[stage][WINED3DTSS_COLOROP],
1721 stateblock->textureState[stage][WINED3DTSS_COLORARG1],
1722 stateblock->textureState[stage][WINED3DTSS_COLORARG2],
1723 stateblock->textureState[stage][WINED3DTSS_COLORARG0]);
1727 static void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1728 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1729 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1730 DWORD op, arg1, arg2, arg0;
1732 TRACE("Setting alpha op for stage %d\n", stage);
1733 /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
1734 if (mapped_stage != -1) {
1735 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1736 if (stage >= GL_LIMITS(textures)) {
1737 if (stateblock->textureState[stage][WINED3DTSS_COLOROP] != WINED3DTOP_DISABLE &&
1738 stateblock->textureState[stage][WINED3DTSS_COLOROP] != 0) {
1739 FIXME("Attempt to enable unsupported stage!\n");
1743 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1744 checkGLcall("glActiveTextureARB");
1745 } else if (stage > 0) {
1746 /* We can't do anything here */
1747 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1752 op = stateblock->textureState[stage][WINED3DTSS_ALPHAOP];
1753 arg1 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG1];
1754 arg2 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG2];
1755 arg0 = stateblock->textureState[stage][WINED3DTSS_ALPHAARG0];
1757 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && stage == 0 &&
1758 stateblock->textures[0] && stateblock->textureDimensions[0] == GL_TEXTURE_2D) {
1759 IWineD3DSurfaceImpl *surf = (IWineD3DSurfaceImpl *) ((IWineD3DTextureImpl *) stateblock->textures[0])->surfaces[0];
1761 if(surf->CKeyFlags & WINEDDSD_CKSRCBLT &&
1762 getFormatDescEntry(surf->resource.format)->alphaMask == 0x00000000) {
1764 /* Color keying needs to pass alpha values from the texture through to have the alpha test work properly.
1765 * On the other hand applications can still use texture combiners apparently. This code takes care that apps
1766 * cannot remove the texture's alpha channel entirely.
1768 * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires D3DTOP_MODULATE to work
1769 * on color keyed surfaces.
1771 * What to do with multitexturing? So far no app has been found that uses color keying with multitexturing
1773 if(op == WINED3DTOP_DISABLE) op = WINED3DTOP_SELECTARG1;
1774 if(op == WINED3DTOP_SELECTARG1) arg1 = WINED3DTA_TEXTURE;
1775 else if(op == WINED3DTOP_SELECTARG2) arg2 = WINED3DTA_TEXTURE;
1779 TRACE("Setting alpha op for stage %d\n", stage);
1780 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1781 set_tex_op_nvrc((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1782 op, arg1, arg2, arg0,
1785 set_tex_op((IWineD3DDevice *)stateblock->wineD3DDevice, TRUE, stage,
1786 op, arg1, arg2, arg0);
1790 static void transform_texture(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1791 DWORD texUnit = state - STATE_TRANSFORM(WINED3DTS_TEXTURE0);
1792 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[texUnit];
1794 if (mapped_stage < 0) return;
1796 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1797 if(mapped_stage >= GL_LIMITS(textures)) {
1800 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1801 checkGLcall("glActiveTextureARB");
1802 } else if (mapped_stage > 0) {
1803 /* We can't do anything here */
1804 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1808 set_texture_matrix((float *)&stateblock->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
1809 stateblock->textureState[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
1810 (stateblock->textureState[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU);
1814 static void unloadTexCoords(IWineD3DStateBlockImpl *stateblock) {
1817 for (texture_idx = 0; texture_idx < GL_LIMITS(textures); ++texture_idx) {
1818 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
1819 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1823 static void loadTexCoords(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd, GLint *curVBO) {
1824 UINT *offset = stateblock->streamOffset;
1825 unsigned int mapped_stage = 0;
1826 unsigned int textureNo = 0;
1828 /* The code below uses glClientActiveTexture and glMultiTexCoord* which are all part of the GL_ARB_multitexture extension. */
1829 /* Abort if we don't support the extension. */
1830 if (!GL_SUPPORT(ARB_MULTITEXTURE)) {
1831 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1835 for (textureNo = 0; textureNo < GL_LIMITS(texture_stages); ++textureNo) {
1836 int coordIdx = stateblock->textureState[textureNo][WINED3DTSS_TEXCOORDINDEX];
1838 mapped_stage = stateblock->wineD3DDevice->texUnitMap[textureNo];
1839 if (mapped_stage == -1) continue;
1841 if (coordIdx < MAX_TEXTURES && (sd->u.s.texCoords[coordIdx].lpData || sd->u.s.texCoords[coordIdx].VBO)) {
1842 TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
1843 textureNo, mapped_stage, coordIdx, sd->u.s.texCoords[coordIdx].lpData);
1845 if (*curVBO != sd->u.s.texCoords[coordIdx].VBO) {
1846 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.texCoords[coordIdx].VBO));
1847 checkGLcall("glBindBufferARB");
1848 *curVBO = sd->u.s.texCoords[coordIdx].VBO;
1851 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1852 checkGLcall("glClientActiveTextureARB");
1854 /* The coords to supply depend completely on the fvf / vertex shader */
1856 WINED3D_ATR_SIZE(sd->u.s.texCoords[coordIdx].dwType),
1857 WINED3D_ATR_GLTYPE(sd->u.s.texCoords[coordIdx].dwType),
1858 sd->u.s.texCoords[coordIdx].dwStride,
1859 sd->u.s.texCoords[coordIdx].lpData + stateblock->loadBaseVertexIndex * sd->u.s.texCoords[coordIdx].dwStride + offset[sd->u.s.texCoords[coordIdx].streamNo]);
1860 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1862 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + mapped_stage, 0, 0, 0, 1));
1865 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
1866 /* The number of the mapped stages increases monotonically, so it's fine to use the last used one */
1867 for (textureNo = mapped_stage + 1; textureNo < GL_LIMITS(textures); ++textureNo) {
1868 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
1873 static void tex_coordindex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
1874 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
1875 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage];
1877 if (mapped_stage == -1) {
1878 TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
1882 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
1883 if(mapped_stage >= GL_LIMITS(samplers)) {
1886 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
1887 checkGLcall("glActiveTextureARB");
1888 } else if (stage > 0) {
1889 /* We can't do anything here */
1890 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1894 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1896 * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1897 * one flag, you can still specify an index value, which the system uses to
1898 * determine the texture wrapping mode.
1899 * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1900 * means use the vertex position (camera-space) as the input texture coordinates
1901 * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1902 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1903 * to the TEXCOORDINDEX value
1907 * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1909 switch (stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX] & 0xFFFF0000) {
1910 case WINED3DTSS_TCI_PASSTHRU:
1911 /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1912 glDisable(GL_TEXTURE_GEN_S);
1913 glDisable(GL_TEXTURE_GEN_T);
1914 glDisable(GL_TEXTURE_GEN_R);
1915 glDisable(GL_TEXTURE_GEN_Q);
1916 checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1919 case WINED3DTSS_TCI_CAMERASPACEPOSITION:
1920 /* CameraSpacePosition means use the vertex position, transformed to camera space,
1921 * as the input texture coordinates for this stage's texture transformation. This
1922 * equates roughly to EYE_LINEAR
1925 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1926 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1927 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1928 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1929 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1931 glMatrixMode(GL_MODELVIEW);
1934 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1935 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1936 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1937 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1940 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1941 glEnable(GL_TEXTURE_GEN_S);
1942 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1943 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1944 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1945 glEnable(GL_TEXTURE_GEN_T);
1946 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1947 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1948 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1949 glEnable(GL_TEXTURE_GEN_R);
1950 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1951 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
1952 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1956 case WINED3DTSS_TCI_CAMERASPACENORMAL:
1958 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1959 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1960 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1961 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1962 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1963 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1965 glMatrixMode(GL_MODELVIEW);
1968 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
1969 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
1970 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
1971 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
1974 glEnable(GL_TEXTURE_GEN_S);
1975 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1976 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1977 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1978 glEnable(GL_TEXTURE_GEN_T);
1979 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1980 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1981 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1982 glEnable(GL_TEXTURE_GEN_R);
1983 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1984 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
1985 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1990 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
1992 if (GL_SUPPORT(NV_TEXGEN_REFLECTION)) {
1993 float s_plane[] = { 1.0, 0.0, 0.0, 0.0 };
1994 float t_plane[] = { 0.0, 1.0, 0.0, 0.0 };
1995 float r_plane[] = { 0.0, 0.0, 1.0, 0.0 };
1996 float q_plane[] = { 0.0, 0.0, 0.0, 1.0 };
1997 TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1999 glMatrixMode(GL_MODELVIEW);
2002 glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
2003 glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
2004 glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
2005 glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
2008 glEnable(GL_TEXTURE_GEN_S);
2009 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
2010 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2011 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2012 glEnable(GL_TEXTURE_GEN_T);
2013 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
2014 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2015 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2016 glEnable(GL_TEXTURE_GEN_R);
2017 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
2018 glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
2019 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
2024 /* Unhandled types: */
2027 /* ? disable GL_TEXTURE_GEN_n ? */
2028 glDisable(GL_TEXTURE_GEN_S);
2029 glDisable(GL_TEXTURE_GEN_T);
2030 glDisable(GL_TEXTURE_GEN_R);
2031 glDisable(GL_TEXTURE_GEN_Q);
2032 FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock->textureState[stage][WINED3DTSS_TEXCOORDINDEX]);
2036 /* Update the texture matrix */
2037 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
2038 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage), stateblock, context);
2041 if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
2042 /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
2043 * source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
2044 * and do all the things linked to it
2045 * TODO: Tidy that up to reload only the arrays of the changed unit
2047 GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2049 unloadTexCoords(stateblock);
2050 loadTexCoords(stateblock, &stateblock->wineD3DDevice->strided_streams, &curVBO);
2054 static void tex_bumpenvlscale(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2055 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2061 tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
2062 if(tmpvalue.f != 0.0) {
2063 FIXME("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
2067 static void tex_bumpenvloffset(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2068 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2074 tmpvalue.d = stateblock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
2075 if(tmpvalue.f != 0.0) {
2076 FIXME("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
2080 static void tex_resultarg(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2081 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2083 if(stage >= GL_LIMITS(texture_stages)) {
2087 if(stateblock->textureState[stage][WINED3DTSS_RESULTARG] != WINED3DTA_CURRENT) {
2088 FIXME("WINED3DTSS_RESULTARG not supported yet\n");
2092 static void sampler(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2093 DWORD sampler = state - STATE_SAMPLER(0);
2094 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[sampler];
2100 TRACE("Sampler: %d\n", sampler);
2101 /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
2102 * only has to bind textures and set the per texture states
2105 if (mapped_stage == -1) {
2106 TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
2110 if (GL_SUPPORT(ARB_MULTITEXTURE)) {
2111 if (mapped_stage >= GL_LIMITS(samplers)) {
2114 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2115 checkGLcall("glActiveTextureARB");
2116 } else if (sampler > 0) {
2117 /* We can't do anything here */
2118 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
2122 if(stateblock->textures[sampler]) {
2123 BOOL texIsPow2 = FALSE;
2125 /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
2126 * IWineD3DBaseTexture::ApplyStateChanges multiplies the set matrix with a fixup matrix. Before the
2127 * scaling is reapplied or removed, the texture matrix has to be reapplied
2129 if(!GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO) && sampler < MAX_TEXTURES) {
2130 if(stateblock->textureDimensions[sampler] == GL_TEXTURE_2D) {
2131 if(((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorX != 1.0 ||
2132 ((IWineD3DTextureImpl *) stateblock->textures[sampler])->pow2scalingFactorY != 1.0 ) {
2135 } else if(stateblock->textureDimensions[sampler] == GL_TEXTURE_CUBE_MAP_ARB) {
2136 if(((IWineD3DCubeTextureImpl *) stateblock->textures[sampler])->pow2scalingFactor != 1.0) {
2141 if(texIsPow2 || context->lastWasPow2Texture[sampler]) {
2142 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stateblock->wineD3DDevice->texUnitMap[sampler]), stateblock, context);
2143 context->lastWasPow2Texture[sampler] = texIsPow2;
2147 IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture *) stateblock->textures[sampler]);
2148 IWineD3DBaseTexture_ApplyStateChanges(stateblock->textures[sampler], stateblock->textureState[sampler], stateblock->samplerState[sampler]);
2150 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS)) {
2151 tmpvalue.d = stateblock->samplerState[sampler][WINED3DSAMP_MIPMAPLODBIAS];
2152 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
2153 GL_TEXTURE_LOD_BIAS_EXT,
2155 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
2158 if (stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader &&
2159 ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function) {
2160 /* Using a pixel shader? Verify the sampler types */
2162 /* Make sure that the texture dimensions are enabled. I don't have to disable the other
2163 * dimensions because the shader knows from which texture type to sample from. For the sake of
2164 * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
2165 * dimensions. This should make wrong sampling sources visible :-)
2167 glEnable(stateblock->textureDimensions[sampler]);
2168 checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
2169 } else if(sampler < stateblock->lowest_disabled_stage) {
2170 if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
2171 activate_dimensions(sampler, stateblock, context);
2174 if(stateblock->renderState[WINED3DRS_COLORKEYENABLE] && sampler == 0) {
2175 /* If color keying is enabled update the alpha test, it depends on the existence
2176 * of a color key in stage 0
2178 state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
2181 } else if(sampler < GL_LIMITS(texture_stages)) {
2182 if(sampler < stateblock->lowest_disabled_stage) {
2183 /* TODO: What should I do with pixel shaders here ??? */
2184 if(!isStateDirty(context, STATE_TEXTURESTAGE(sampler, WINED3DTSS_COLOROP))) {
2185 activate_dimensions(sampler, stateblock, context);
2187 } /* Otherwise tex_colorop disables the stage */
2188 glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler]);
2189 checkGLcall("glBindTexture(GL_TEXTURE_2D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
2193 static void shaderconstant(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2194 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2196 /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
2197 * has an update pending
2199 if(isStateDirty(context, STATE_VDECL) ||
2200 isStateDirty(context, STATE_PIXELSHADER)) {
2204 device->shader_backend->shader_load_constants((IWineD3DDevice *) device, use_ps(device), use_vs(device));
2207 static void pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2208 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
2209 BOOL use_pshader = use_ps(device);
2210 BOOL use_vshader = use_vs(device);
2211 BOOL update_fog = FALSE;
2215 if(!context->last_was_pshader) {
2216 /* Former draw without a pixel shader, some samplers
2217 * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
2218 * make sure to enable them
2220 for(i=0; i < MAX_SAMPLERS; i++) {
2221 if(!isStateDirty(context, STATE_SAMPLER(i))) {
2222 sampler(STATE_SAMPLER(i), stateblock, context);
2227 /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
2228 * if a different texture was bound. I don't have to do anything.
2232 /* Compile and bind the shader */
2233 IWineD3DPixelShader_CompileShader(stateblock->pixelShader);
2235 /* Disabled the pixel shader - color ops weren't applied
2236 * while it was enabled, so re-apply them.
2238 for(i=0; i < MAX_TEXTURES; i++) {
2239 if(!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP))) {
2240 tex_colorop(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
2243 if(context->last_was_pshader)
2247 if(!isStateDirty(context, StateTable[STATE_VSHADER].representative)) {
2248 device->shader_backend->shader_select((IWineD3DDevice *)stateblock->wineD3DDevice, use_pshader, use_vshader);
2250 if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader || use_pshader)) {
2251 shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
2256 state_fog(state, stateblock, context);
2258 context->last_was_pshader = use_pshader;
2261 static void tex_bumpenvmat(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2262 DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE;
2264 if(stateblock->pixelShader && stage != 0 &&
2265 ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->needsbumpmat == stage) {
2266 /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
2269 if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
2270 !isStateDirty(context, STATE_PIXELSHADER)) {
2271 shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
2275 if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2276 if(stage >= GL_LIMITS(texture_stages)) {
2277 WARN("Bump env matrix of unsupported stage set\n");
2278 } else if(GL_SUPPORT(ARB_MULTITEXTURE)) {
2279 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stage));
2280 checkGLcall("GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + stage))");
2282 GL_EXTCALL(glTexBumpParameterfvATI(GL_BUMP_ROT_MATRIX_ATI,
2283 (float *) &(stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00])));
2284 checkGLcall("glTexBumpParameterfvATI");
2286 if(GL_SUPPORT(NV_TEXTURE_SHADER2)) {
2287 /* Direct3D sets the matrix in the stage reading the perturbation map. The result is used to
2288 * offset the destination stage(always stage + 1 in d3d). In GL_NV_texture_shader, the bump
2289 * map offseting is done in the stage reading the bump mapped texture, and the perturbation
2290 * map is read from a specified source stage(always stage - 1 for d3d). Thus set the matrix
2291 * for stage + 1. Keep the nvrc tex unit mapping in mind too
2293 DWORD mapped_stage = stateblock->wineD3DDevice->texUnitMap[stage + 1];
2295 if(mapped_stage < GL_LIMITS(textures)) {
2296 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
2297 checkGLcall("GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage))");
2299 glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV,
2300 (float *) &(stateblock->textureState[stage][WINED3DTSS_BUMPENVMAT00]));
2301 checkGLcall("glTexEnvfv(GL_TEXTURE_SHADER_NV, GL_OFFSET_TEXTURE_MATRIX_NV, mat)\n");
2306 static void transform_world(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2307 /* This function is called by transform_view below if the view matrix was changed too
2309 * Deliberately no check if the vertex declaration is dirty because the vdecl state
2310 * does not always update the world matrix, only on a switch between transformed
2311 * and untrannsformed draws. It *may* happen that the world matrix is set 2 times during one
2312 * draw, but that should be rather rare and cheaper in total.
2314 glMatrixMode(GL_MODELVIEW);
2315 checkGLcall("glMatrixMode");
2317 if(context->last_was_rhw) {
2319 checkGLcall("glLoadIdentity()");
2321 /* In the general case, the view matrix is the identity matrix */
2322 if (stateblock->wineD3DDevice->view_ident) {
2323 glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2324 checkGLcall("glLoadMatrixf");
2326 glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2327 checkGLcall("glLoadMatrixf");
2328 glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
2329 checkGLcall("glMultMatrixf");
2334 static void clipplane(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2335 UINT index = state - STATE_CLIPPLANE(0);
2337 if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW)) || index >= GL_LIMITS(clipplanes)) {
2341 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
2342 glMatrixMode(GL_MODELVIEW);
2344 glLoadMatrixf((float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2346 TRACE("Clipplane [%f,%f,%f,%f]\n",
2347 stateblock->clipplane[index][0],
2348 stateblock->clipplane[index][1],
2349 stateblock->clipplane[index][2],
2350 stateblock->clipplane[index][3]);
2351 glClipPlane(GL_CLIP_PLANE0 + index, stateblock->clipplane[index]);
2352 checkGLcall("glClipPlane");
2357 static void transform_worldex(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2358 UINT matrix = state - STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
2360 TRACE("Setting world matrix %d\n", matrix);
2362 if(matrix >= GL_LIMITS(blends)) {
2363 WARN("Unsupported blend matrix set\n");
2365 } else if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
2369 /* GL_MODELVIEW0_ARB: 0x1700
2370 * GL_MODELVIEW1_ARB: 0x0x850a
2371 * GL_MODELVIEW2_ARB: 0x8722
2372 * GL_MODELVIEW3_ARB: 0x8723
2374 * GL_MODELVIEW31_ARB: 0x873F
2376 if(matrix == 1) glMat = GL_MODELVIEW1_ARB;
2377 else glMat = GL_MODELVIEW2_ARB - 2 + matrix;
2379 glMatrixMode(glMat);
2380 checkGLcall("glMatrixMode(glMat)");
2382 /* World matrix 0 is multiplied with the view matrix because d3d uses 3 matrices while gl uses only 2. To avoid
2383 * weighting the view matrix incorrectly it has to be multiplied into every gl modelview matrix
2385 if(stateblock->wineD3DDevice->view_ident) {
2386 glLoadMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
2387 checkGLcall("glLoadMatrixf")
2389 glLoadMatrixf(&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2390 checkGLcall("glLoadMatrixf")
2391 glMultMatrixf(&stateblock->transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
2392 checkGLcall("glMultMatrixf")
2396 static void state_vertexblend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2397 WINED3DVERTEXBLENDFLAGS val = stateblock->renderState[WINED3DRS_VERTEXBLEND];
2400 case WINED3DVBF_1WEIGHTS:
2401 case WINED3DVBF_2WEIGHTS:
2402 case WINED3DVBF_3WEIGHTS:
2403 if(GL_SUPPORT(ARB_VERTEX_BLEND)) {
2404 glEnable(GL_VERTEX_BLEND_ARB);
2405 checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
2407 /* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
2408 * creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
2410 GL_EXTCALL(glVertexBlendARB(stateblock->renderState[WINED3DRS_VERTEXBLEND] + 1));
2412 if(!stateblock->wineD3DDevice->vertexBlendUsed) {
2414 for(i = 1; i < GL_LIMITS(blends); i++) {
2415 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)))) {
2416 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)), stateblock, context);
2419 stateblock->wineD3DDevice->vertexBlendUsed = TRUE;
2422 /* TODO: Implement vertex blending in drawStridedSlow */
2423 FIXME("Vertex blending enabled, but not supported by hardware\n");
2427 case WINED3DVBF_DISABLE:
2428 case WINED3DVBF_0WEIGHTS: /* for Indexed vertex blending - not supported */
2429 if(GL_SUPPORT(ARB_VERTEX_BLEND)) {
2430 glDisable(GL_VERTEX_BLEND_ARB);
2431 checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
2433 TRACE("Vertex blending disabled\n");
2437 case WINED3DVBF_TWEENING:
2438 /* Just set the vertex weight for weight 0, enable vertex blending and hope the app doesn't have
2439 * vertex weights in the vertices?
2440 * For now we don't report that as supported, so a warn should suffice
2442 WARN("Tweening not supported yet\n");
2447 static void transform_view(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2450 /* If we are changing the View matrix, reset the light and clipping planes to the new view
2451 * NOTE: We have to reset the positions even if the light/plane is not currently
2452 * enabled, since the call to enable it will not reset the position.
2453 * NOTE2: Apparently texture transforms do NOT need reapplying
2456 PLIGHTINFOEL *light = NULL;
2458 glMatrixMode(GL_MODELVIEW);
2459 checkGLcall("glMatrixMode(GL_MODELVIEW)");
2460 glLoadMatrixf((float *)(float *) &stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
2461 checkGLcall("glLoadMatrixf(...)");
2463 /* Reset lights. TODO: Call light apply func */
2464 for(k = 0; k < stateblock->wineD3DDevice->maxConcurrentLights; k++) {
2465 light = stateblock->activeLights[k];
2466 if(!light) continue;
2467 glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
2468 checkGLcall("glLightfv posn");
2469 glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
2470 checkGLcall("glLightfv dirn");
2473 /* Reset Clipping Planes */
2474 for (k = 0; k < GL_LIMITS(clipplanes); k++) {
2475 if(!isStateDirty(context, STATE_CLIPPLANE(k))) {
2476 clipplane(STATE_CLIPPLANE(k), stateblock, context);
2480 if(context->last_was_rhw) {
2482 checkGLcall("glLoadIdentity()");
2483 /* No need to update the world matrix, the identity is fine */
2487 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
2488 * No need to do it here if the state is scheduled for update.
2490 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
2491 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
2494 /* Avoid looping over a number of matrices if the app never used the functionality */
2495 if(stateblock->wineD3DDevice->vertexBlendUsed) {
2496 for(k = 1; k < GL_LIMITS(blends); k++) {
2497 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)))) {
2498 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)), stateblock, context);
2504 static const GLfloat invymat[16] = {
2505 1.0f, 0.0f, 0.0f, 0.0f,
2506 0.0f, -1.0f, 0.0f, 0.0f,
2507 0.0f, 0.0f, 1.0f, 0.0f,
2508 0.0f, 0.0f, 0.0f, 1.0f};
2510 static void transform_projection(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
2511 glMatrixMode(GL_PROJECTION);
2512 checkGLcall("glMatrixMode(GL_PROJECTION)");
2514 checkGLcall("glLoadIdentity");
2516 if(context->last_was_rhw) {
2517 double X, Y, height, width, minZ, maxZ;
2519 X = stateblock->viewport.X;
2520 Y = stateblock->viewport.Y;
2521 height = stateblock->viewport.Height;
2522 width = stateblock->viewport.Width;
2523 minZ = stateblock->viewport.MinZ;
2524 maxZ = stateblock->viewport.MaxZ;
2526 if(!stateblock->wineD3DDevice->untransformed) {
2527 /* Transformed vertices are supposed to bypass the whole transform pipeline including
2528 * frustum clipping. This can't be done in opengl, so this code adjusts the Z range to
2529 * suppress depth clipping. This can be done because it is an orthogonal projection and
2530 * the Z coordinate does not affect the size of the primitives
2532 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
2533 if(stateblock->wineD3DDevice->render_offscreen) {
2534 glOrtho(X, X + width, -Y, -Y - height, -minZ, -maxZ);
2536 glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
2539 /* If the app mixes transformed and untransformed primitives we can't use the coordinate system
2540 * trick above because this would mess up transformed and untransformed Z order. Pass the z position
2541 * unmodified to opengl.
2543 * If the app depends on mixed types and disabled clipping we're out of luck without a pipeline
2544 * replacement shader.
2546 TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, 1.0, -1.0);
2547 if(stateblock->wineD3DDevice->render_offscreen) {
2548 glOrtho(X, X + width, -Y, -Y - height, 1.0, -1.0);
2550 glOrtho(X, X + width, Y + height, Y, 1.0, -1.0);
2553 checkGLcall("glOrtho");
2555 /* Window Coord 0 is the middle of the first pixel, so translate by 3/8 pixels */
2556 glTranslatef(0.375, 0.375, 0);
2557 checkGLcall("glTranslatef(0.375, 0.375, 0)");
2558 /* D3D texture coordinates are flipped compared to OpenGL ones, so
2559 * render everything upside down when rendering offscreen. */
2560 if (stateblock->wineD3DDevice->render_offscreen) {
2561 glMultMatrixf(invymat);
2562 checkGLcall("glMultMatrixf(invymat)");
2565 /* The rule is that the window coordinate 0 does not correspond to the
2566 beginning of the first pixel, but the center of the first pixel.
2567 As a consequence if you want to correctly draw one line exactly from
2568 the left to the right end of the viewport (with all matrices set to
2569 be identity), the x coords of both ends of the line would be not
2570 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
2572 glTranslatef(0.9 / stateblock->viewport.Width, -0.9 / stateblock->viewport.Height, 0);
2573 checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
2575 /* D3D texture coordinates are flipped compared to OpenGL ones, so
2576 * render everything upside down when rendering offscreen. */
2577 if (stateblock->wineD3DDevice->render_offscreen) {
2578 glMultMatrixf(invymat);
2579 checkGLcall("glMultMatrixf(invymat)");
2581 glMultMatrixf((float *) &stateblock->transforms[WINED3DTS_PROJECTION].u.m[0][0]);
2582 checkGLcall("glLoadMatrixf");
2586 /* This should match any arrays loaded in loadVertexData.
2587 * stateblock impl is required for GL_SUPPORT
2588 * TODO: Only load / unload arrays if we have to.
2590 static inline void unloadVertexData(IWineD3DStateBlockImpl *stateblock) {
2591 glDisableClientState(GL_VERTEX_ARRAY);
2592 glDisableClientState(GL_NORMAL_ARRAY);
2593 glDisableClientState(GL_COLOR_ARRAY);
2594 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2595 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
2597 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2598 glDisableClientState(GL_WEIGHT_ARRAY_ARB);
2599 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2600 glDisableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2602 unloadTexCoords(stateblock);
2605 /* This should match any arrays loaded in loadNumberedArrays
2606 * TODO: Only load / unload arrays if we have to.
2608 static inline void unloadNumberedArrays(IWineD3DStateBlockImpl *stateblock) {
2609 /* disable any attribs (this is the same for both GLSL and ARB modes) */
2613 /* Leave all the attribs disabled */
2614 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
2615 /* MESA does not support it right not */
2616 if (glGetError() != GL_NO_ERROR)
2618 for (i = 0; i < maxAttribs; ++i) {
2619 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2620 checkGLcall("glDisableVertexAttribArrayARB(reg);");
2624 static inline void loadNumberedArrays(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *strided) {
2625 GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2627 UINT *offset = stateblock->streamOffset;
2629 /* Default to no instancing */
2630 stateblock->wineD3DDevice->instancedDraw = FALSE;
2632 for (i = 0; i < MAX_ATTRIBS; i++) {
2634 if (!strided->u.input[i].lpData && !strided->u.input[i].VBO)
2637 /* Do not load instance data. It will be specified using glTexCoord by drawprim */
2638 if(stateblock->streamFlags[strided->u.input[i].streamNo] & WINED3DSTREAMSOURCE_INSTANCEDATA) {
2639 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2640 stateblock->wineD3DDevice->instancedDraw = TRUE;
2644 TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, strided->u.input[i].VBO);
2646 if(strided->u.input[i].dwStride) {
2647 if(curVBO != strided->u.input[i].VBO) {
2648 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, strided->u.input[i].VBO));
2649 checkGLcall("glBindBufferARB");
2650 curVBO = strided->u.input[i].VBO;
2652 GL_EXTCALL(glVertexAttribPointerARB(i,
2653 WINED3D_ATR_SIZE(strided->u.input[i].dwType),
2654 WINED3D_ATR_GLTYPE(strided->u.input[i].dwType),
2655 WINED3D_ATR_NORMALIZED(strided->u.input[i].dwType),
2656 strided->u.input[i].dwStride,
2657 strided->u.input[i].lpData + stateblock->loadBaseVertexIndex * strided->u.input[i].dwStride + offset[strided->u.input[i].streamNo]) );
2658 GL_EXTCALL(glEnableVertexAttribArrayARB(i));
2660 /* Stride = 0 means always the same values. glVertexAttribPointerARB doesn't do that. Instead disable the pointer and
2661 * set up the attribute statically. But we have to figure out the system memory address.
2663 BYTE *ptr = strided->u.input[i].lpData + offset[strided->u.input[i].streamNo];
2664 if(strided->u.input[i].VBO) {
2665 IWineD3DVertexBufferImpl *vb = (IWineD3DVertexBufferImpl *) stateblock->streamSource[strided->u.input[i].streamNo];
2666 ptr += (long) vb->resource.allocatedMemory;
2668 GL_EXTCALL(glDisableVertexAttribArrayARB(i));
2670 switch(strided->u.input[i].dwType) {
2671 case WINED3DDECLTYPE_FLOAT1:
2672 GL_EXTCALL(glVertexAttrib1fvARB(i, (float *) ptr));
2674 case WINED3DDECLTYPE_FLOAT2:
2675 GL_EXTCALL(glVertexAttrib2fvARB(i, (float *) ptr));
2677 case WINED3DDECLTYPE_FLOAT3:
2678 GL_EXTCALL(glVertexAttrib3fvARB(i, (float *) ptr));
2680 case WINED3DDECLTYPE_FLOAT4:
2681 GL_EXTCALL(glVertexAttrib4fvARB(i, (float *) ptr));
2684 case WINED3DDECLTYPE_UBYTE4:
2685 GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2687 case WINED3DDECLTYPE_UBYTE4N:
2688 case WINED3DDECLTYPE_D3DCOLOR:
2689 GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
2692 case WINED3DDECLTYPE_SHORT2:
2693 GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2695 case WINED3DDECLTYPE_SHORT4:
2696 GL_EXTCALL(glVertexAttrib4svARB(i, (GLshort *) ptr));
2699 case WINED3DDECLTYPE_SHORT2N:
2701 GLshort s[4] = {((short *) ptr)[0], ((short *) ptr)[1], 0, 1};
2702 GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
2705 case WINED3DDECLTYPE_USHORT2N:
2707 GLushort s[4] = {((unsigned short *) ptr)[0], ((unsigned short *) ptr)[1], 0, 1};
2708 GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
2711 case WINED3DDECLTYPE_SHORT4N:
2712 GL_EXTCALL(glVertexAttrib4NsvARB(i, (GLshort *) ptr));
2714 case WINED3DDECLTYPE_USHORT4N:
2715 GL_EXTCALL(glVertexAttrib4NusvARB(i, (GLushort *) ptr));
2718 case WINED3DDECLTYPE_UDEC3:
2719 FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
2720 /*glVertexAttrib3usvARB(i, (GLushort *) ptr); Does not exist */
2722 case WINED3DDECLTYPE_DEC3N:
2723 FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
2724 /*glVertexAttrib3NusvARB(i, (GLushort *) ptr); Does not exist */
2727 case WINED3DDECLTYPE_FLOAT16_2:
2728 /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
2729 * byte float according to the IEEE standard
2731 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
2733 case WINED3DDECLTYPE_FLOAT16_4:
2734 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
2737 case WINED3DDECLTYPE_UNUSED:
2739 ERR("Unexpected declaration in stride 0 attributes\n");
2747 /* Used from 2 different functions, and too big to justify making it inlined */
2748 static void loadVertexData(IWineD3DStateBlockImpl *stateblock, WineDirect3DVertexStridedData *sd) {
2749 UINT *offset = stateblock->streamOffset;
2750 GLint curVBO = GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT) ? -1 : 0;
2752 TRACE("Using fast vertex array code\n");
2754 /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
2755 stateblock->wineD3DDevice->instancedDraw = FALSE;
2757 /* Blend Data ---------------------------------------------- */
2758 if( (sd->u.s.blendWeights.lpData) || (sd->u.s.blendWeights.VBO) ||
2759 (sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO) ) {
2761 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2762 TRACE("Blend %d %p %d\n", WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2763 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride, sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
2765 glEnableClientState(GL_WEIGHT_ARRAY_ARB);
2766 checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
2768 GL_EXTCALL(glVertexBlendARB(WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) + 1));
2770 VTRACE(("glWeightPointerARB(%d, GL_FLOAT, %d, %p)\n",
2771 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType) ,
2772 sd->u.s.blendWeights.dwStride,
2773 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]));
2775 if(curVBO != sd->u.s.blendWeights.VBO) {
2776 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.blendWeights.VBO));
2777 checkGLcall("glBindBufferARB");
2778 curVBO = sd->u.s.blendWeights.VBO;
2781 GL_EXTCALL(glWeightPointerARB)(
2782 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2783 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2784 sd->u.s.blendWeights.dwStride,
2785 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride + offset[sd->u.s.blendWeights.streamNo]);
2787 checkGLcall("glWeightPointerARB");
2789 if((sd->u.s.blendMatrixIndices.lpData) || (sd->u.s.blendMatrixIndices.VBO)){
2790 static BOOL showfixme = TRUE;
2792 FIXME("blendMatrixIndices support\n");
2796 } else if (GL_SUPPORT(EXT_VERTEX_WEIGHTING)) {
2797 /* FIXME("TODO\n");*/
2800 GL_EXTCALL(glVertexWeightPointerEXT)(
2801 WINED3D_ATR_SIZE(sd->u.s.blendWeights.dwType),
2802 WINED3D_ATR_GLTYPE(sd->u.s.blendWeights.dwType),
2803 sd->u.s.blendWeights.dwStride,
2804 sd->u.s.blendWeights.lpData + stateblock->loadBaseVertexIndex * sd->u.s.blendWeights.dwStride);
2805 checkGLcall("glVertexWeightPointerEXT(numBlends, ...)");
2806 glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT);
2807 checkGLcall("glEnableClientState(GL_VERTEX_WEIGHT_ARRAY_EXT)");
2811 /* TODO: support blends in drawStridedSlow
2812 * No need to write a FIXME here, this is done after the general vertex decl decoding
2814 WARN("unsupported blending in openGl\n");
2817 if (GL_SUPPORT(ARB_VERTEX_BLEND)) {
2818 static const GLbyte one = 1;
2819 GL_EXTCALL(glWeightbvARB(1, &one));
2820 checkGLcall("glWeightivARB(GL_LIMITS(blends), weights)");
2824 #if 0 /* FOG ----------------------------------------------*/
2825 if (sd->u.s.fog.lpData || sd->u.s.fog.VBO) {
2827 if (GL_SUPPORT(EXT_FOG_COORD) {
2828 glEnableClientState(GL_FOG_COORDINATE_EXT);
2829 (GL_EXTCALL)(FogCoordPointerEXT)(
2830 WINED3D_ATR_GLTYPE(sd->u.s.fog.dwType),
2831 sd->u.s.fog.dwStride,
2832 sd->u.s.fog.lpData + stateblock->loadBaseVertexIndex * sd->u.s.fog.dwStride);
2834 /* don't bother falling back to 'slow' as we don't support software FOG yet. */
2835 /* FIXME: fixme once */
2836 TRACE("Hardware support for FOG is not avaiable, FOG disabled.\n");
2839 if (GL_SUPPRT(EXT_FOR_COORD) {
2840 /* make sure fog is disabled */
2841 glDisableClientState(GL_FOG_COORDINATE_EXT);
2846 #if 0 /* tangents ----------------------------------------------*/
2847 if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO ||
2848 sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2850 if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2851 if (sd->u.s.tangent.lpData || sd->u.s.tangent.VBO) {
2852 glEnable(GL_TANGENT_ARRAY_EXT);
2853 (GL_EXTCALL)(TangentPointerEXT)(
2854 WINED3D_ATR_GLTYPE(sd->u.s.tangent.dwType),
2855 sd->u.s.tangent.dwStride,
2856 sd->u.s.tangent.lpData + stateblock->loadBaseVertexIndex * sd->u.s.tangent.dwStride);
2858 glDisable(GL_TANGENT_ARRAY_EXT);
2860 if (sd->u.s.binormal.lpData || sd->u.s.binormal.VBO) {
2861 glEnable(GL_BINORMAL_ARRAY_EXT);
2862 (GL_EXTCALL)(BinormalPointerEXT)(
2863 WINED3D_ATR_GLTYPE(sd->u.s.binormal.dwType),
2864 sd->u.s.binormal.dwStride,
2865 sd->u.s.binormal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.binormal.dwStride);
2867 glDisable(GL_BINORMAL_ARRAY_EXT);
2871 /* don't bother falling back to 'slow' as we don't support software tangents and binormals yet . */
2872 /* FIXME: fixme once */
2873 TRACE("Hardware support for tangents and binormals is not avaiable, tangents and binormals disabled.\n");
2876 if (GL_SUPPORT(EXT_COORDINATE_FRAME) {
2877 /* make sure fog is disabled */
2878 glDisable(GL_TANGENT_ARRAY_EXT);
2879 glDisable(GL_BINORMAL_ARRAY_EXT);
2884 /* Point Size ----------------------------------------------*/
2885 if (sd->u.s.pSize.lpData || sd->u.s.pSize.VBO) {
2887 /* no such functionality in the fixed function GL pipeline */
2888 TRACE("Cannot change ptSize here in openGl\n");
2889 /* TODO: Implement this function in using shaders if they are available */
2893 /* Vertex Pointers -----------------------------------------*/
2894 if (sd->u.s.position.lpData != NULL || sd->u.s.position.VBO != 0) {
2895 /* Note dwType == float3 or float4 == 2 or 3 */
2896 VTRACE(("glVertexPointer(%d, GL_FLOAT, %d, %p)\n",
2897 sd->u.s.position.dwStride,
2898 sd->u.s.position.dwType + 1,
2899 sd->u.s.position.lpData));
2901 if(curVBO != sd->u.s.position.VBO) {
2902 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.position.VBO));
2903 checkGLcall("glBindBufferARB");
2904 curVBO = sd->u.s.position.VBO;
2907 /* min(WINED3D_ATR_SIZE(position),3) to Disable RHW mode as 'w' coord
2908 handling for rhw mode should not impact screen position whereas in GL it does.
2909 This may result in very slightly distored textures in rhw mode, but
2910 a very minimal different. There's always the other option of
2911 fixing the view matrix to prevent w from having any effect
2913 This only applies to user pointer sources, in VBOs the vertices are fixed up
2915 if(sd->u.s.position.VBO == 0) {
2916 glVertexPointer(3 /* min(WINED3D_ATR_SIZE(sd->u.s.position.dwType),3) */,
2917 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
2918 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
2921 WINED3D_ATR_SIZE(sd->u.s.position.dwType),
2922 WINED3D_ATR_GLTYPE(sd->u.s.position.dwType),
2923 sd->u.s.position.dwStride, sd->u.s.position.lpData + stateblock->loadBaseVertexIndex * sd->u.s.position.dwStride + offset[sd->u.s.position.streamNo]);
2925 checkGLcall("glVertexPointer(...)");
2926 glEnableClientState(GL_VERTEX_ARRAY);
2927 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
2930 /* Normals -------------------------------------------------*/
2931 if (sd->u.s.normal.lpData || sd->u.s.normal.VBO) {
2932 /* Note dwType == float3 or float4 == 2 or 3 */
2933 VTRACE(("glNormalPointer(GL_FLOAT, %d, %p)\n",
2934 sd->u.s.normal.dwStride,
2935 sd->u.s.normal.lpData));
2936 if(curVBO != sd->u.s.normal.VBO) {
2937 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.normal.VBO));
2938 checkGLcall("glBindBufferARB");
2939 curVBO = sd->u.s.normal.VBO;
2942 WINED3D_ATR_GLTYPE(sd->u.s.normal.dwType),
2943 sd->u.s.normal.dwStride,
2944 sd->u.s.normal.lpData + stateblock->loadBaseVertexIndex * sd->u.s.normal.dwStride + offset[sd->u.s.normal.streamNo]);
2945 checkGLcall("glNormalPointer(...)");
2946 glEnableClientState(GL_NORMAL_ARRAY);
2947 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
2950 glNormal3f(0, 0, 1);
2951 checkGLcall("glNormal3f(0, 0, 1)");
2954 /* Diffuse Colour --------------------------------------------*/
2955 /* WARNING: Data here MUST be in RGBA format, so cannot */
2956 /* go directly into fast mode from app pgm, because */
2957 /* directx requires data in BGRA format. */
2958 /* currently fixupVertices swizels the format, but this isn't */
2959 /* very practical when using VBOS */
2960 /* NOTE: Unless we write a vertex shader to swizel the colour */
2961 /* , or the user doesn't care and wants the speed advantage */
2963 if (sd->u.s.diffuse.lpData || sd->u.s.diffuse.VBO) {
2964 /* Note dwType == float3 or float4 == 2 or 3 */
2965 VTRACE(("glColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2966 sd->u.s.diffuse.dwStride,
2967 sd->u.s.diffuse.lpData));
2969 if(curVBO != sd->u.s.diffuse.VBO) {
2970 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.diffuse.VBO));
2971 checkGLcall("glBindBufferARB");
2972 curVBO = sd->u.s.diffuse.VBO;
2974 glColorPointer(4, GL_UNSIGNED_BYTE,
2975 sd->u.s.diffuse.dwStride,
2976 sd->u.s.diffuse.lpData + stateblock->loadBaseVertexIndex * sd->u.s.diffuse.dwStride + offset[sd->u.s.diffuse.streamNo]);
2977 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
2978 glEnableClientState(GL_COLOR_ARRAY);
2979 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
2982 glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
2983 checkGLcall("glColor4f(1, 1, 1, 1)");
2986 /* Specular Colour ------------------------------------------*/
2987 if (sd->u.s.specular.lpData || sd->u.s.specular.VBO) {
2988 TRACE("setting specular colour\n");
2989 /* Note dwType == float3 or float4 == 2 or 3 */
2990 VTRACE(("glSecondaryColorPointer(4, GL_UNSIGNED_BYTE, %d, %p)\n",
2991 sd->u.s.specular.dwStride,
2992 sd->u.s.specular.lpData));
2993 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
2994 if(curVBO != sd->u.s.specular.VBO) {
2995 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, sd->u.s.specular.VBO));
2996 checkGLcall("glBindBufferARB");
2997 curVBO = sd->u.s.specular.VBO;
2999 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE,
3000 sd->u.s.specular.dwStride,
3001 sd->u.s.specular.lpData + stateblock->loadBaseVertexIndex * sd->u.s.specular.dwStride + offset[sd->u.s.specular.streamNo]);
3002 vcheckGLcall("glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, ...)");
3003 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
3004 vcheckGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
3007 /* Missing specular color is not critical, no warnings */
3008 VTRACE(("Specular colour is not supported in this GL implementation\n"));
3012 if (GL_SUPPORT(EXT_SECONDARY_COLOR)) {
3013 GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
3014 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
3017 /* Missing specular color is not critical, no warnings */
3018 VTRACE(("Specular colour is not supported in this GL implementation\n"));
3022 /* Texture coords -------------------------------------------*/
3023 loadTexCoords(stateblock, sd, &curVBO);
3026 static inline void drawPrimitiveTraceDataLocations(
3027 WineDirect3DVertexStridedData *dataLocations) {
3029 /* Dump out what parts we have supplied */
3030 TRACE("Strided Data:\n");
3031 TRACE_STRIDED((dataLocations), position);
3032 TRACE_STRIDED((dataLocations), blendWeights);
3033 TRACE_STRIDED((dataLocations), blendMatrixIndices);
3034 TRACE_STRIDED((dataLocations), normal);
3035 TRACE_STRIDED((dataLocations), pSize);
3036 TRACE_STRIDED((dataLocations), diffuse);
3037 TRACE_STRIDED((dataLocations), specular);
3038 TRACE_STRIDED((dataLocations), texCoords[0]);
3039 TRACE_STRIDED((dataLocations), texCoords[1]);
3040 TRACE_STRIDED((dataLocations), texCoords[2]);
3041 TRACE_STRIDED((dataLocations), texCoords[3]);
3042 TRACE_STRIDED((dataLocations), texCoords[4]);
3043 TRACE_STRIDED((dataLocations), texCoords[5]);
3044 TRACE_STRIDED((dataLocations), texCoords[6]);
3045 TRACE_STRIDED((dataLocations), texCoords[7]);
3046 TRACE_STRIDED((dataLocations), position2);
3047 TRACE_STRIDED((dataLocations), normal2);
3048 TRACE_STRIDED((dataLocations), tangent);
3049 TRACE_STRIDED((dataLocations), binormal);
3050 TRACE_STRIDED((dataLocations), tessFactor);
3051 TRACE_STRIDED((dataLocations), fog);
3052 TRACE_STRIDED((dataLocations), depth);
3053 TRACE_STRIDED((dataLocations), sample);
3058 /* Helper for vertexdeclaration() */
3059 static inline void handleStreams(IWineD3DStateBlockImpl *stateblock, BOOL useVertexShaderFunction, WineD3DContext *context) {
3060 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3062 WineDirect3DVertexStridedData *dataLocations = &device->strided_streams;
3064 if(device->up_strided) {
3065 /* Note: this is a ddraw fixed-function code path */
3066 TRACE("================ Strided Input ===================\n");
3067 memcpy(dataLocations, device->up_strided, sizeof(*dataLocations));
3070 drawPrimitiveTraceDataLocations(dataLocations);
3072 } else if (stateblock->vertexDecl) {
3073 /* Note: This is a fixed function or shader codepath.
3074 * This means it must handle both types of strided data.
3075 * Shaders must go through here to zero the strided data, even if they
3076 * don't set any declaration at all
3078 TRACE("================ Vertex Declaration ===================\n");
3079 memset(dataLocations, 0, sizeof(*dataLocations));
3080 primitiveDeclarationConvertToStridedData((IWineD3DDevice *) device,
3081 useVertexShaderFunction, dataLocations, &fixup);
3083 /* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
3084 * It is reachable through d3d8, but only for fixed-function.
3085 * It will not work properly for shaders.
3087 TRACE("================ FVF ===================\n");
3088 memset(dataLocations, 0, sizeof(*dataLocations));
3089 primitiveConvertToStridedData((IWineD3DDevice *) device, dataLocations, &fixup);
3091 drawPrimitiveTraceDataLocations(dataLocations);
3095 if (dataLocations->u.s.position_transformed) {
3096 useVertexShaderFunction = FALSE;
3099 /* Unload the old arrays before loading the new ones to get old junk out */
3100 if(context->numberedArraysLoaded) {
3101 unloadNumberedArrays(stateblock);
3102 context->numberedArraysLoaded = FALSE;
3104 if(context->namedArraysLoaded) {
3105 unloadVertexData(stateblock);
3106 context->namedArraysLoaded = FALSE;
3109 if(useVertexShaderFunction) {
3110 TRACE("Loading numbered arrays\n");
3111 loadNumberedArrays(stateblock, dataLocations);
3112 device->useDrawStridedSlow = FALSE;
3113 context->numberedArraysLoaded = TRUE;
3115 (dataLocations->u.s.pSize.lpData == NULL &&
3116 dataLocations->u.s.diffuse.lpData == NULL &&
3117 dataLocations->u.s.specular.lpData == NULL)) {
3118 /* Load the vertex data using named arrays */
3119 TRACE("Loading vertex data\n");
3120 loadVertexData(stateblock, dataLocations);
3121 device->useDrawStridedSlow = FALSE;
3122 context->namedArraysLoaded = TRUE;
3124 TRACE("Not loading vertex data\n");
3125 device->useDrawStridedSlow = TRUE;
3128 /* Generate some fixme's if unsupported functionality is being used */
3129 #define BUFFER_OR_DATA(_attribute) dataLocations->u.s._attribute.lpData
3130 /* TODO: Either support missing functionality in fixupVertices or by creating a shader to replace the pipeline. */
3131 if (!useVertexShaderFunction && (BUFFER_OR_DATA(position2) || BUFFER_OR_DATA(normal2))) {
3132 FIXME("Tweening is only valid with vertex shaders\n");
3134 if (!useVertexShaderFunction && (BUFFER_OR_DATA(tangent) || BUFFER_OR_DATA(binormal))) {
3135 FIXME("Tangent and binormal bump mapping is only valid with vertex shaders\n");
3137 if (!useVertexShaderFunction && (BUFFER_OR_DATA(tessFactor) || BUFFER_OR_DATA(fog) || BUFFER_OR_DATA(depth) || BUFFER_OR_DATA(sample))) {
3138 FIXME("Extended attributes are only valid with vertex shaders\n");
3140 #undef BUFFER_OR_DATA
3143 static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3144 BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
3145 BOOL usePixelShaderFunction = stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE && stateblock->pixelShader
3146 && ((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.function;
3148 /* Some stuff is in the device until we have per context tracking */
3149 IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
3150 BOOL wasrhw = context->last_was_rhw;
3152 /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
3153 * here simply check whether a shader was set, or the user disabled shaders
3155 if (device->vs_selected_mode != SHADER_NONE && stateblock->vertexShader &&
3156 ((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.function != NULL) {
3157 useVertexShaderFunction = TRUE;
3159 if(((IWineD3DVertexShaderImpl *)stateblock->vertexShader)->baseShader.reg_maps.fog != context->last_was_foggy_shader) {
3162 } else if(context->last_was_foggy_shader) {
3166 handleStreams(stateblock, useVertexShaderFunction, context);
3168 transformed = device->strided_streams.u.s.position_transformed;
3169 if (transformed) useVertexShaderFunction = FALSE;
3171 if(transformed != context->last_was_rhw && !useVertexShaderFunction) {
3175 /* Reapply lighting if it is not scheduled for reapplication already */
3176 if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
3177 state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
3181 context->last_was_rhw = TRUE;
3184 /* Untransformed, so relies on the view and projection matrices */
3185 context->last_was_rhw = FALSE;
3186 /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
3187 device->untransformed = TRUE;
3189 /* Todo for sw shaders: Vertex Shader output is already transformed, so set up identity matrices
3190 * Not needed as long as only hw shaders are supported
3193 /* This sets the shader output position correction constants.
3194 * TODO: Move to the viewport state
3196 if (useVertexShaderFunction) {
3197 device->posFixup[1] = device->render_offscreen ? -1.0 : 1.0;
3201 /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
3202 * off this function will be called again anyway to make sure they're properly set
3204 if(!useVertexShaderFunction) {
3205 /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
3206 * or transformed / untransformed was switched
3208 if(wasrhw != context->last_was_rhw &&
3209 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
3210 !isStateDirty(context, STATE_VIEWPORT)) {
3211 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
3213 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
3216 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
3217 * this check will fail and the matrix not applied again. This is OK because a simple
3218 * world matrix change reapplies the matrix - These checks here are only to satisfy the
3219 * needs of the vertex declaration.
3221 * World and view matrix go into the same gl matrix, so only apply them when neither is
3224 if(transformed != wasrhw &&
3225 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
3226 !isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
3227 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
3230 if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
3231 state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
3234 if(context->last_was_vshader && !isStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE))) {
3235 state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), stateblock, context);
3238 /* We compile the shader here because we need the vertex declaration
3239 * in order to determine if we need to do any swizzling for D3DCOLOR
3240 * registers. If the shader is already compiled this call will do nothing. */
3241 IWineD3DVertexShader_CompileShader(stateblock->vertexShader);
3243 if(!context->last_was_vshader) {
3245 static BOOL warned = FALSE;
3246 /* Disable all clip planes to get defined results on all drivers. See comment in the
3247 * state_clipping state handler
3249 for(i = 0; i < GL_LIMITS(clipplanes); i++) {
3250 glDisable(GL_CLIP_PLANE0 + i);
3251 checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
3254 if(!warned && stateblock->renderState[WINED3DRS_CLIPPLANEENABLE]) {
3255 FIXME("Clipping not supported with vertex shaders\n");
3261 /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
3264 if (!isStateDirty(context, STATE_PIXELSHADER)) {
3265 device->shader_backend->shader_select((IWineD3DDevice *)device, usePixelShaderFunction, useVertexShaderFunction);
3267 if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
3268 shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
3272 context->last_was_vshader = useVertexShaderFunction;
3275 state_fog(STATE_RENDER(WINED3DRS_FOGENABLE), stateblock, context);
3279 static void viewport(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3280 glDepthRange(stateblock->viewport.MinZ, stateblock->viewport.MaxZ);
3281 checkGLcall("glDepthRange");
3282 /* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
3284 if(stateblock->wineD3DDevice->render_offscreen) {
3285 glViewport(stateblock->viewport.X,
3286 stateblock->viewport.Y,
3287 stateblock->viewport.Width, stateblock->viewport.Height);
3289 glViewport(stateblock->viewport.X,
3290 (((IWineD3DSurfaceImpl *)stateblock->wineD3DDevice->render_targets[0])->currentDesc.Height - (stateblock->viewport.Y + stateblock->viewport.Height)),
3291 stateblock->viewport.Width, stateblock->viewport.Height);
3294 checkGLcall("glViewport");
3296 stateblock->wineD3DDevice->posFixup[2] = 0.9 / stateblock->viewport.Width;
3297 stateblock->wineD3DDevice->posFixup[3] = -0.9 / stateblock->viewport.Height;
3298 if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
3299 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
3304 static void light(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3305 UINT Index = state - STATE_ACTIVELIGHT(0);
3306 PLIGHTINFOEL *lightInfo = stateblock->activeLights[Index];
3309 glDisable(GL_LIGHT0 + Index);
3310 checkGLcall("glDisable(GL_LIGHT0 + Index)");
3313 float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
3315 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
3316 glMatrixMode(GL_MODELVIEW);
3318 glLoadMatrixf((float *)&stateblock->transforms[WINED3DTS_VIEW].u.m[0][0]);
3321 colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
3322 colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
3323 colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
3324 colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
3325 glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
3326 checkGLcall("glLightfv");
3329 colRGBA[0] = lightInfo->OriginalParms.Specular.r;
3330 colRGBA[1] = lightInfo->OriginalParms.Specular.g;
3331 colRGBA[2] = lightInfo->OriginalParms.Specular.b;
3332 colRGBA[3] = lightInfo->OriginalParms.Specular.a;
3333 glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
3334 checkGLcall("glLightfv");
3337 colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
3338 colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
3339 colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
3340 colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
3341 glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
3342 checkGLcall("glLightfv");
3344 if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
3345 quad_att = 1.4/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
3347 quad_att = 0; /* 0 or MAX? (0 seems to be ok) */
3350 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
3351 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
3352 * Attenuation0 to NaN and crashes in the gl lib
3355 switch (lightInfo->OriginalParms.Type) {
3356 case WINED3DLIGHT_POINT:
3358 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3359 checkGLcall("glLightfv");
3360 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3361 checkGLcall("glLightf");
3362 /* Attenuation - Are these right? guessing... */
3363 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
3364 checkGLcall("glLightf");
3365 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
3366 checkGLcall("glLightf");
3367 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3368 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3369 checkGLcall("glLightf");
3373 case WINED3DLIGHT_SPOT:
3375 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
3376 checkGLcall("glLightfv");
3378 glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
3379 checkGLcall("glLightfv");
3380 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
3381 checkGLcall("glLightf");
3382 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3383 checkGLcall("glLightf");
3384 /* Attenuation - Are these right? guessing... */
3385 glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
3386 checkGLcall("glLightf");
3387 glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
3388 checkGLcall("glLightf");
3389 if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
3390 glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
3391 checkGLcall("glLightf");
3395 case WINED3DLIGHT_DIRECTIONAL:
3397 glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
3398 checkGLcall("glLightfv");
3399 glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
3400 checkGLcall("glLightf");
3401 glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
3402 checkGLcall("glLightf");
3406 FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
3409 /* Restore the modelview matrix */
3412 glEnable(GL_LIGHT0 + Index);
3413 checkGLcall("glEnable(GL_LIGHT0 + Index)");
3419 static void scissorrect(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3420 IWineD3DSwapChainImpl *swapchain = (IWineD3DSwapChainImpl *) stateblock->wineD3DDevice->swapchains[0];
3421 RECT *pRect = &stateblock->scissorRect;
3425 GetClientRect(swapchain->win_handle, &windowRect);
3426 /* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
3427 * Warning2: Even in windowed mode the coords are relative to the window, not the screen
3429 winHeight = windowRect.bottom - windowRect.top;
3430 TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock->wineD3DDevice, pRect->left, pRect->bottom - winHeight,
3431 pRect->right - pRect->left, pRect->bottom - pRect->top);
3432 glScissor(pRect->left, winHeight - pRect->bottom, pRect->right - pRect->left, pRect->bottom - pRect->top);
3433 checkGLcall("glScissor");
3436 static void indexbuffer(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context) {
3437 if(GL_SUPPORT(ARB_VERTEX_BUFFER_OBJECT)) {
3438 if(stateblock->streamIsUP || stateblock->pIndexData == NULL ) {
3439 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
3441 IWineD3DIndexBufferImpl *ib = (IWineD3DIndexBufferImpl *) stateblock->pIndexData;
3442 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->vbo));
3447 const struct StateEntry StateTable[] =
3449 /* State name representative, apply function */
3450 { /* 0, Undefined */ 0, state_undefined },
3451 { /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined },
3452 { /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias },
3453 { /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined },
3454 { /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective },
3455 { /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), state_wrapu },
3456 { /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), state_wrapv },
3457 { /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), state_zenable },
3458 { /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode },
3459 { /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode },
3460 { /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern },
3461 { /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable },
3462 { /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), state_rop2 },
3463 { /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask },
3464 { /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable },
3465 { /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
3466 { /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel },
3467 { /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined },
3468 { /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined },
3469 { /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3470 { /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3471 { /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined },
3472 { /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode },
3473 { /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc },
3474 { /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
3475 { /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
3476 { /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable },
3477 { /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3478 { /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3479 { /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable},
3480 { /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl },
3481 { /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel },
3482 { /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx },
3483 { /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha },
3484 { /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor },
3485 { /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3486 { /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3487 { /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3488 { /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity },
3489 { /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable },
3490 { /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3491 { /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha },
3492 { /* 42, undefined */ 0, state_undefined },
3493 { /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), state_bordercolor },
3494 { /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined },
3495 { /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined },
3496 { /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias },
3497 { /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), state_zbias },
3498 { /* 48, WINED3DRS_RANGEFOGENABLE */ 0, state_nogl },
3499 { /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy },
3500 { /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch },
3501 { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi },
3502 { /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3503 { /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3504 { /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3505 { /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3506 { /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3507 { /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3508 { /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3509 { /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite },
3510 { /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor },
3511 { /* 61, Undefined */ 0, state_undefined },
3512 { /* 62, Undefined */ 0, state_undefined },
3513 { /* 63, Undefined */ 0, state_undefined },
3514 { /* 64, WINED3DRS_STIPPLEPATTERN00 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3515 { /* 65, WINED3DRS_STIPPLEPATTERN01 */ 0 /* Obsolete, should he handled by ddraw */, state_undefined },
3516 { /* 66, WINED3DRS_STIPPLEPATTERN02 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3517 { /* 67, WINED3DRS_STIPPLEPATTERN03 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3518 { /* 68, WINED3DRS_STIPPLEPATTERN04 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3519 { /* 69, WINED3DRS_STIPPLEPATTERN05 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3520 { /* 70, WINED3DRS_STIPPLEPATTERN06 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3521 { /* 71, WINED3DRS_STIPPLEPATTERN07 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3522 { /* 72, WINED3DRS_STIPPLEPATTERN08 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3523 { /* 73, WINED3DRS_STIPPLEPATTERN09 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3524 { /* 74, WINED3DRS_STIPPLEPATTERN10 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3525 { /* 75, WINED3DRS_STIPPLEPATTERN11 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3526 { /* 76, WINED3DRS_STIPPLEPATTERN12 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3527 { /* 77, WINED3DRS_STIPPLEPATTERN13 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3528 { /* 78, WINED3DRS_STIPPLEPATTERN14 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3529 { /* 79, WINED3DRS_STIPPLEPATTERN15 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3530 { /* 80, WINED3DRS_STIPPLEPATTERN16 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3531 { /* 81, WINED3DRS_STIPPLEPATTERN17 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3532 { /* 82, WINED3DRS_STIPPLEPATTERN18 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3533 { /* 83, WINED3DRS_STIPPLEPATTERN19 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3534 { /* 84, WINED3DRS_STIPPLEPATTERN20 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3535 { /* 85, WINED3DRS_STIPPLEPATTERN21 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3536 { /* 86, WINED3DRS_STIPPLEPATTERN22 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3537 { /* 87, WINED3DRS_STIPPLEPATTERN23 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3538 { /* 88, WINED3DRS_STIPPLEPATTERN24 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3539 { /* 89, WINED3DRS_STIPPLEPATTERN25 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3540 { /* 90, WINED3DRS_STIPPLEPATTERN26 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3541 { /* 91, WINED3DRS_STIPPLEPATTERN27 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3542 { /* 92, WINED3DRS_STIPPLEPATTERN28 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3543 { /* 93, WINED3DRS_STIPPLEPATTERN29 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3544 { /* 94, WINED3DRS_STIPPLEPATTERN30 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3545 { /* 95, WINED3DRS_STIPPLEPATTERN31 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined },
3546 { /* 96, Undefined */ 0, state_undefined },
3547 { /* 97, Undefined */ 0, state_undefined },
3548 { /* 98, Undefined */ 0, state_undefined },
3549 { /* 99, Undefined */ 0, state_undefined },
3550 { /*100, Undefined */ 0, state_undefined },
3551 { /*101, Undefined */ 0, state_undefined },
3552 { /*102, Undefined */ 0, state_undefined },
3553 { /*103, Undefined */ 0, state_undefined },
3554 { /*104, Undefined */ 0, state_undefined },
3555 { /*105, Undefined */ 0, state_undefined },
3556 { /*106, Undefined */ 0, state_undefined },
3557 { /*107, Undefined */ 0, state_undefined },
3558 { /*108, Undefined */ 0, state_undefined },
3559 { /*109, Undefined */ 0, state_undefined },
3560 { /*110, Undefined */ 0, state_undefined },
3561 { /*111, Undefined */ 0, state_undefined },
3562 { /*112, Undefined */ 0, state_undefined },
3563 { /*113, Undefined */ 0, state_undefined },
3564 { /*114, Undefined */ 0, state_undefined },
3565 { /*115, Undefined */ 0, state_undefined },
3566 { /*116, Undefined */ 0, state_undefined },
3567 { /*117, Undefined */ 0, state_undefined },
3568 { /*118, Undefined */ 0, state_undefined },
3569 { /*119, Undefined */ 0, state_undefined },
3570 { /*120, Undefined */ 0, state_undefined },
3571 { /*121, Undefined */ 0, state_undefined },
3572 { /*122, Undefined */ 0, state_undefined },
3573 { /*123, Undefined */ 0, state_undefined },
3574 { /*124, Undefined */ 0, state_undefined },
3575 { /*125, Undefined */ 0, state_undefined },
3576 { /*126, Undefined */ 0, state_undefined },
3577 { /*127, Undefined */ 0, state_undefined },
3579 { /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3580 { /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3581 { /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3582 { /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3583 { /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3584 { /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3585 { /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3586 { /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3587 { /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
3588 { /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING), state_lighting },
3589 { /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), state_extents },
3590 { /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), state_ambient },
3591 { /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), state_fog },
3592 { /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3593 { /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer },
3594 { /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize },
3595 { /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend },
3596 { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3597 { /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3598 { /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3599 { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat },
3600 { /*149, Undefined */ 0, state_undefined },
3601 { /*150, Undefined */ 0, state_undefined },
3602 { /*151, WINED3DRS_VERTEXBLEND */ STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend },
3603 { /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING), state_clipping },
3604 { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl },
3605 { /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), state_psize },
3606 { /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin },
3607 { /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite },
3608 { /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3609 { /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3610 { /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3611 { /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale },
3612 { /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_multisampleaa },
3613 { /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask },
3614 { /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle},
3615 { /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments },
3616 { /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_nogl },
3617 { /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), state_psizemax },
3618 { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ 0, state_nogl },
3619 { /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3620 { /*169, Undefined */ 0, state_undefined },
3621 { /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl },
3622 { /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), state_blendop },
3623 { /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree},
3624 { /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree },
3625 /*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
3626 /*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
3627 { /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor },
3628 { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
3629 { /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend },
3630 { /*177, undefined */ 0, state_undefined },
3631 { /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3632 { /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3633 { /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3634 { /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3635 { /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3636 { /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3637 { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation },
3638 { /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3639 { /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3640 { /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3641 { /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3642 { /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil },
3643 { /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3644 { /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3645 { /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite },
3646 { /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor },
3647 { /*194, WINED3DRS_SRGBWRITEENABLE */ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), state_srgbwrite },
3648 { /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias },
3649 { /*196, undefined */ 0, state_undefined },
3650 { /*197, undefined */ 0, state_undefined },
3651 { /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3652 { /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3653 { /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3654 { /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3655 { /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3656 { /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3657 { /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3658 { /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0), state_wrap },
3659 { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3660 { /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3661 { /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3662 { /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), state_seperateblend },
3663 /* Texture stage states */
3664 { /*0, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3665 { /*0, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3666 { /*0, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3667 { /*0, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3668 { /*0, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3669 { /*0, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3670 { /*0, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3671 { /*0, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3672 { /*0, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3673 { /*0, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3674 { /*0, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3675 { /*0, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3676 { /*0, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3677 { /*0, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3678 { /*0, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3679 { /*0, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3680 { /*0, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3681 { /*0, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3682 { /*0, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3683 { /*0, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3684 { /*0, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3685 { /*0, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3686 { /*0, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3687 { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
3688 { /*0, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3689 { /*0, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop },
3690 { /*0, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop },
3691 { /*0, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), tex_resultarg },
3692 { /*0, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3693 { /*0, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3694 { /*0, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3695 { /*0, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3697 { /*1, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3698 { /*1, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3699 { /*1, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3700 { /*1, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3701 { /*1, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3702 { /*1, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3703 { /*1, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3704 { /*1, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3705 { /*1, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3706 { /*1, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3707 { /*1, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3708 { /*1, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3709 { /*1, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3710 { /*1, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3711 { /*1, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3712 { /*1, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3713 { /*1, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3714 { /*1, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3715 { /*1, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3716 { /*1, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3717 { /*1, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3718 { /*1, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3719 { /*1, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3720 { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
3721 { /*1, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3722 { /*1, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop },
3723 { /*1, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop },
3724 { /*1, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), tex_resultarg },
3725 { /*1, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3726 { /*1, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3727 { /*1, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3728 { /*1, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3730 { /*2, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3731 { /*2, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3732 { /*2, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3733 { /*2, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3734 { /*2, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3735 { /*2, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3736 { /*2, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3737 { /*2, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3738 { /*2, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3739 { /*2, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3740 { /*2, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3741 { /*2, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3742 { /*2, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3743 { /*2, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3744 { /*2, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3745 { /*2, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3746 { /*2, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3747 { /*2, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3748 { /*2, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3749 { /*2, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3750 { /*2, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3751 { /*2, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3752 { /*2, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3753 { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
3754 { /*2, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3755 { /*2, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop },
3756 { /*2, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop },
3757 { /*2, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), tex_resultarg },
3758 { /*2, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3759 { /*2, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3760 { /*2, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3761 { /*2, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3763 { /*3, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3764 { /*3, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3765 { /*3, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3766 { /*3, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3767 { /*3, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3768 { /*3, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3769 { /*3, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3770 { /*3, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3771 { /*3, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3772 { /*3, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3773 { /*3, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3774 { /*3, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3775 { /*3, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3776 { /*3, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3777 { /*3, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3778 { /*3, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3779 { /*3, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3780 { /*3, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3781 { /*3, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3782 { /*3, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3783 { /*3, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3784 { /*3, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3785 { /*3, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3786 { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
3787 { /*3, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3788 { /*3, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop },
3789 { /*3, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop },
3790 { /*3, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), tex_resultarg },
3791 { /*3, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3792 { /*3, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3793 { /*3, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3794 { /*3, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3796 { /*4, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3797 { /*4, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3798 { /*4, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3799 { /*4, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3800 { /*4, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3801 { /*4, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3802 { /*4, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3803 { /*4, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3804 { /*4, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3805 { /*4, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3806 { /*4, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3807 { /*4, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3808 { /*4, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3809 { /*4, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3810 { /*4, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3811 { /*4, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3812 { /*4, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3813 { /*4, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3814 { /*4, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3815 { /*4, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3816 { /*4, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3817 { /*4, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3818 { /*4, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3819 { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
3820 { /*4, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3821 { /*4, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop },
3822 { /*4, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop },
3823 { /*4, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), tex_resultarg },
3824 { /*4, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3825 { /*4, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3826 { /*4, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3827 { /*4, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3829 { /*5, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3830 { /*5, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3831 { /*5, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3832 { /*5, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3833 { /*5, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3834 { /*5, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3835 { /*5, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3836 { /*5, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3837 { /*5, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3838 { /*5, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3839 { /*5, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3840 { /*5, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3841 { /*5, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3842 { /*5, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3843 { /*5, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3844 { /*5, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3845 { /*5, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3846 { /*5, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3847 { /*5, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3848 { /*5, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3849 { /*5, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3850 { /*5, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3851 { /*5, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3852 { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
3853 { /*5, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3854 { /*5, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop },
3855 { /*5, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop },
3856 { /*5, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), tex_resultarg },
3857 { /*5, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3858 { /*5, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3859 { /*5, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3860 { /*5, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3862 { /*6, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3863 { /*6, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3864 { /*6, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3865 { /*6, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3866 { /*6, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3867 { /*6, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3868 { /*6, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3869 { /*6, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3870 { /*6, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3871 { /*6, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3872 { /*6, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3873 { /*6, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3874 { /*6, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3875 { /*6, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3876 { /*6, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3877 { /*6, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3878 { /*6, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3879 { /*6, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3880 { /*6, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3881 { /*6, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3882 { /*6, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3883 { /*6, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3884 { /*6, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3885 { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
3886 { /*6, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3887 { /*6, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop },
3888 { /*6, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop },
3889 { /*6, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), tex_resultarg },
3890 { /*6, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3891 { /*6, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3892 { /*6, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3893 { /*6, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3895 { /*7, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3896 { /*7, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3897 { /*7, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3898 { /*7, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3899 { /*7, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3900 { /*7, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3901 { /*7, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3902 { /*7, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3903 { /*7, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3904 { /*7, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), tex_bumpenvmat },
3905 { /*7, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex },
3906 { /*7, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3907 { /*7, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3908 { /*7, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3909 { /*7, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3910 { /*7, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3911 { /*7, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3912 { /*7, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3913 { /*7, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3914 { /*7, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3915 { /*7, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3916 { /*7, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale },
3917 { /*7, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), tex_bumpenvloffset },
3918 { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
3919 { /*7, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3920 { /*7, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop },
3921 { /*7, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop },
3922 { /*7, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), tex_resultarg },
3923 { /*7, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3924 { /*7, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3925 { /*7, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined },
3926 { /*7, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl },
3927 /* Sampler states */
3928 { /* 0, Sampler 0 */ STATE_SAMPLER(0), sampler },
3929 { /* 1, Sampler 1 */ STATE_SAMPLER(1), sampler },
3930 { /* 2, Sampler 2 */ STATE_SAMPLER(2), sampler },
3931 { /* 3, Sampler 3 */ STATE_SAMPLER(3), sampler },
3932 { /* 4, Sampler 3 */ STATE_SAMPLER(4), sampler },
3933 { /* 5, Sampler 5 */ STATE_SAMPLER(5), sampler },
3934 { /* 6, Sampler 6 */ STATE_SAMPLER(6), sampler },
3935 { /* 7, Sampler 7 */ STATE_SAMPLER(7), sampler },
3936 { /* 8, Sampler 8 */ STATE_SAMPLER(8), sampler },
3937 { /* 9, Sampler 9 */ STATE_SAMPLER(9), sampler },
3938 { /*10, Sampler 10 */ STATE_SAMPLER(10), sampler },
3939 { /*11, Sampler 11 */ STATE_SAMPLER(11), sampler },
3940 { /*12, Sampler 12 */ STATE_SAMPLER(12), sampler },
3941 { /*13, Sampler 13 */ STATE_SAMPLER(13), sampler },
3942 { /*14, Sampler 14 */ STATE_SAMPLER(14), sampler },
3943 { /*15, Sampler 15 */ STATE_SAMPLER(15), sampler },
3945 { /* , Pixel Shader */ STATE_PIXELSHADER, pixelshader },
3946 /* Transform states follow */
3947 { /* 1, undefined */ 0, state_undefined },
3948 { /* 2, WINED3DTS_VIEW */ STATE_TRANSFORM(WINED3DTS_VIEW), transform_view },
3949 { /* 3, WINED3DTS_PROJECTION */ STATE_TRANSFORM(WINED3DTS_PROJECTION), transform_projection},
3950 { /* 4, undefined */ 0, state_undefined },
3951 { /* 5, undefined */ 0, state_undefined },
3952 { /* 6, undefined */ 0, state_undefined },
3953 { /* 7, undefined */ 0, state_undefined },
3954 { /* 8, undefined */ 0, state_undefined },
3955 { /* 9, undefined */ 0, state_undefined },
3956 { /* 10, undefined */ 0, state_undefined },
3957 { /* 11, undefined */ 0, state_undefined },
3958 { /* 12, undefined */ 0, state_undefined },
3959 { /* 13, undefined */ 0, state_undefined },
3960 { /* 14, undefined */ 0, state_undefined },
3961 { /* 15, undefined */ 0, state_undefined },
3962 { /* 16, WINED3DTS_TEXTURE0 */ STATE_TRANSFORM(WINED3DTS_TEXTURE0), transform_texture },
3963 { /* 17, WINED3DTS_TEXTURE1 */ STATE_TRANSFORM(WINED3DTS_TEXTURE1), transform_texture },
3964 { /* 18, WINED3DTS_TEXTURE2 */ STATE_TRANSFORM(WINED3DTS_TEXTURE2), transform_texture },
3965 { /* 19, WINED3DTS_TEXTURE3 */ STATE_TRANSFORM(WINED3DTS_TEXTURE3), transform_texture },
3966 { /* 20, WINED3DTS_TEXTURE4 */ STATE_TRANSFORM(WINED3DTS_TEXTURE4), transform_texture },
3967 { /* 21, WINED3DTS_TEXTURE5 */ STATE_TRANSFORM(WINED3DTS_TEXTURE5), transform_texture },
3968 { /* 22, WINED3DTS_TEXTURE6 */ STATE_TRANSFORM(WINED3DTS_TEXTURE6), transform_texture },
3969 { /* 23, WINED3DTS_TEXTURE7 */ STATE_TRANSFORM(WINED3DTS_TEXTURE7), transform_texture },
3970 /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
3971 { /* 24, undefined */ 0, state_undefined },
3972 { /* 25, undefined */ 0, state_undefined },
3973 { /* 26, undefined */ 0, state_undefined },
3974 { /* 27, undefined */ 0, state_undefined },
3975 { /* 28, undefined */ 0, state_undefined },
3976 { /* 29, undefined */ 0, state_undefined },
3977 { /* 30, undefined */ 0, state_undefined },
3978 { /* 31, undefined */ 0, state_undefined },
3979 { /* 32, undefined */ 0, state_undefined },
3980 { /* 33, undefined */ 0, state_undefined },
3981 { /* 34, undefined */ 0, state_undefined },
3982 { /* 35, undefined */ 0, state_undefined },
3983 { /* 36, undefined */ 0, state_undefined },
3984 { /* 37, undefined */ 0, state_undefined },
3985 { /* 38, undefined */ 0, state_undefined },
3986 { /* 39, undefined */ 0, state_undefined },
3987 { /* 40, undefined */ 0, state_undefined },
3988 { /* 41, undefined */ 0, state_undefined },
3989 { /* 42, undefined */ 0, state_undefined },
3990 { /* 43, undefined */ 0, state_undefined },
3991 { /* 44, undefined */ 0, state_undefined },
3992 { /* 45, undefined */ 0, state_undefined },
3993 { /* 46, undefined */ 0, state_undefined },
3994 { /* 47, undefined */ 0, state_undefined },
3995 { /* 48, undefined */ 0, state_undefined },
3996 { /* 49, undefined */ 0, state_undefined },
3997 { /* 50, undefined */ 0, state_undefined },
3998 { /* 51, undefined */ 0, state_undefined },
3999 { /* 52, undefined */ 0, state_undefined },
4000 { /* 53, undefined */ 0, state_undefined },
4001 { /* 54, undefined */ 0, state_undefined },
4002 { /* 55, undefined */ 0, state_undefined },
4003 { /* 56, undefined */ 0, state_undefined },
4004 { /* 57, undefined */ 0, state_undefined },
4005 { /* 58, undefined */ 0, state_undefined },
4006 { /* 59, undefined */ 0, state_undefined },
4007 { /* 60, undefined */ 0, state_undefined },
4008 { /* 61, undefined */ 0, state_undefined },
4009 { /* 62, undefined */ 0, state_undefined },
4010 { /* 63, undefined */ 0, state_undefined },
4011 { /* 64, undefined */ 0, state_undefined },
4012 { /* 65, undefined */ 0, state_undefined },
4013 { /* 66, undefined */ 0, state_undefined },
4014 { /* 67, undefined */ 0, state_undefined },
4015 { /* 68, undefined */ 0, state_undefined },
4016 { /* 69, undefined */ 0, state_undefined },
4017 { /* 70, undefined */ 0, state_undefined },
4018 { /* 71, undefined */ 0, state_undefined },
4019 { /* 72, undefined */ 0, state_undefined },
4020 { /* 73, undefined */ 0, state_undefined },
4021 { /* 74, undefined */ 0, state_undefined },
4022 { /* 75, undefined */ 0, state_undefined },
4023 { /* 76, undefined */ 0, state_undefined },
4024 { /* 77, undefined */ 0, state_undefined },
4025 { /* 78, undefined */ 0, state_undefined },
4026 { /* 79, undefined */ 0, state_undefined },
4027 { /* 80, undefined */ 0, state_undefined },
4028 { /* 81, undefined */ 0, state_undefined },
4029 { /* 82, undefined */ 0, state_undefined },
4030 { /* 83, undefined */ 0, state_undefined },
4031 { /* 84, undefined */ 0, state_undefined },
4032 { /* 85, undefined */ 0, state_undefined },
4033 { /* 86, undefined */ 0, state_undefined },
4034 { /* 87, undefined */ 0, state_undefined },
4035 { /* 88, undefined */ 0, state_undefined },
4036 { /* 89, undefined */ 0, state_undefined },
4037 { /* 90, undefined */ 0, state_undefined },
4038 { /* 91, undefined */ 0, state_undefined },
4039 { /* 92, undefined */ 0, state_undefined },
4040 { /* 93, undefined */ 0, state_undefined },
4041 { /* 94, undefined */ 0, state_undefined },
4042 { /* 95, undefined */ 0, state_undefined },
4043 { /* 96, undefined */ 0, state_undefined },
4044 { /* 97, undefined */ 0, state_undefined },
4045 { /* 98, undefined */ 0, state_undefined },
4046 { /* 99, undefined */ 0, state_undefined },
4047 { /*100, undefined */ 0, state_undefined },
4048 { /*101, undefined */ 0, state_undefined },
4049 { /*102, undefined */ 0, state_undefined },
4050 { /*103, undefined */ 0, state_undefined },
4051 { /*104, undefined */ 0, state_undefined },
4052 { /*105, undefined */ 0, state_undefined },
4053 { /*106, undefined */ 0, state_undefined },
4054 { /*107, undefined */ 0, state_undefined },
4055 { /*108, undefined */ 0, state_undefined },
4056 { /*109, undefined */ 0, state_undefined },
4057 { /*110, undefined */ 0, state_undefined },
4058 { /*111, undefined */ 0, state_undefined },
4059 { /*112, undefined */ 0, state_undefined },
4060 { /*113, undefined */ 0, state_undefined },
4061 { /*114, undefined */ 0, state_undefined },
4062 { /*115, undefined */ 0, state_undefined },
4063 { /*116, undefined */ 0, state_undefined },
4064 { /*117, undefined */ 0, state_undefined },
4065 { /*118, undefined */ 0, state_undefined },
4066 { /*119, undefined */ 0, state_undefined },
4067 { /*120, undefined */ 0, state_undefined },
4068 { /*121, undefined */ 0, state_undefined },
4069 { /*122, undefined */ 0, state_undefined },
4070 { /*123, undefined */ 0, state_undefined },
4071 { /*124, undefined */ 0, state_undefined },
4072 { /*125, undefined */ 0, state_undefined },
4073 { /*126, undefined */ 0, state_undefined },
4074 { /*127, undefined */ 0, state_undefined },
4075 { /*128, undefined */ 0, state_undefined },
4076 { /*129, undefined */ 0, state_undefined },
4077 { /*130, undefined */ 0, state_undefined },
4078 { /*131, undefined */ 0, state_undefined },
4079 { /*132, undefined */ 0, state_undefined },
4080 { /*133, undefined */ 0, state_undefined },
4081 { /*134, undefined */ 0, state_undefined },
4082 { /*135, undefined */ 0, state_undefined },
4083 { /*136, undefined */ 0, state_undefined },
4084 { /*137, undefined */ 0, state_undefined },
4085 { /*138, undefined */ 0, state_undefined },
4086 { /*139, undefined */ 0, state_undefined },
4087 { /*140, undefined */ 0, state_undefined },
4088 { /*141, undefined */ 0, state_undefined },
4089 { /*142, undefined */ 0, state_undefined },
4090 { /*143, undefined */ 0, state_undefined },
4091 { /*144, undefined */ 0, state_undefined },
4092 { /*145, undefined */ 0, state_undefined },
4093 { /*146, undefined */ 0, state_undefined },
4094 { /*147, undefined */ 0, state_undefined },
4095 { /*148, undefined */ 0, state_undefined },
4096 { /*149, undefined */ 0, state_undefined },
4097 { /*150, undefined */ 0, state_undefined },
4098 { /*151, undefined */ 0, state_undefined },
4099 { /*152, undefined */ 0, state_undefined },
4100 { /*153, undefined */ 0, state_undefined },
4101 { /*154, undefined */ 0, state_undefined },
4102 { /*155, undefined */ 0, state_undefined },
4103 { /*156, undefined */ 0, state_undefined },
4104 { /*157, undefined */ 0, state_undefined },
4105 { /*158, undefined */ 0, state_undefined },
4106 { /*159, undefined */ 0, state_undefined },
4107 { /*160, undefined */ 0, state_undefined },
4108 { /*161, undefined */ 0, state_undefined },
4109 { /*162, undefined */ 0, state_undefined },
4110 { /*163, undefined */ 0, state_undefined },
4111 { /*164, undefined */ 0, state_undefined },
4112 { /*165, undefined */ 0, state_undefined },
4113 { /*166, undefined */ 0, state_undefined },
4114 { /*167, undefined */ 0, state_undefined },
4115 { /*168, undefined */ 0, state_undefined },
4116 { /*169, undefined */ 0, state_undefined },
4117 { /*170, undefined */ 0, state_undefined },
4118 { /*171, undefined */ 0, state_undefined },
4119 { /*172, undefined */ 0, state_undefined },
4120 { /*173, undefined */ 0, state_undefined },
4121 { /*174, undefined */ 0, state_undefined },
4122 { /*175, undefined */ 0, state_undefined },
4123 { /*176, undefined */ 0, state_undefined },
4124 { /*177, undefined */ 0, state_undefined },
4125 { /*178, undefined */ 0, state_undefined },
4126 { /*179, undefined */ 0, state_undefined },
4127 { /*180, undefined */ 0, state_undefined },
4128 { /*181, undefined */ 0, state_undefined },
4129 { /*182, undefined */ 0, state_undefined },
4130 { /*183, undefined */ 0, state_undefined },
4131 { /*184, undefined */ 0, state_undefined },
4132 { /*185, undefined */ 0, state_undefined },
4133 { /*186, undefined */ 0, state_undefined },
4134 { /*187, undefined */ 0, state_undefined },
4135 { /*188, undefined */ 0, state_undefined },
4136 { /*189, undefined */ 0, state_undefined },
4137 { /*190, undefined */ 0, state_undefined },
4138 { /*191, undefined */ 0, state_undefined },
4139 { /*192, undefined */ 0, state_undefined },
4140 { /*193, undefined */ 0, state_undefined },
4141 { /*194, undefined */ 0, state_undefined },
4142 { /*195, undefined */ 0, state_undefined },
4143 { /*196, undefined */ 0, state_undefined },
4144 { /*197, undefined */ 0, state_undefined },
4145 { /*198, undefined */ 0, state_undefined },
4146 { /*199, undefined */ 0, state_undefined },
4147 { /*200, undefined */ 0, state_undefined },
4148 { /*201, undefined */ 0, state_undefined },
4149 { /*202, undefined */ 0, state_undefined },
4150 { /*203, undefined */ 0, state_undefined },
4151 { /*204, undefined */ 0, state_undefined },
4152 { /*205, undefined */ 0, state_undefined },
4153 { /*206, undefined */ 0, state_undefined },
4154 { /*207, undefined */ 0, state_undefined },
4155 { /*208, undefined */ 0, state_undefined },
4156 { /*209, undefined */ 0, state_undefined },
4157 { /*210, undefined */ 0, state_undefined },
4158 { /*211, undefined */ 0, state_undefined },
4159 { /*212, undefined */ 0, state_undefined },
4160 { /*213, undefined */ 0, state_undefined },
4161 { /*214, undefined */ 0, state_undefined },
4162 { /*215, undefined */ 0, state_undefined },
4163 { /*216, undefined */ 0, state_undefined },
4164 { /*217, undefined */ 0, state_undefined },
4165 { /*218, undefined */ 0, state_undefined },
4166 { /*219, undefined */ 0, state_undefined },
4167 { /*220, undefined */ 0, state_undefined },
4168 { /*221, undefined */ 0, state_undefined },
4169 { /*222, undefined */ 0, state_undefined },
4170 { /*223, undefined */ 0, state_undefined },
4171 { /*224, undefined */ 0, state_undefined },
4172 { /*225, undefined */ 0, state_undefined },
4173 { /*226, undefined */ 0, state_undefined },
4174 { /*227, undefined */ 0, state_undefined },
4175 { /*228, undefined */ 0, state_undefined },
4176 { /*229, undefined */ 0, state_undefined },
4177 { /*230, undefined */ 0, state_undefined },
4178 { /*231, undefined */ 0, state_undefined },
4179 { /*232, undefined */ 0, state_undefined },
4180 { /*233, undefined */ 0, state_undefined },
4181 { /*234, undefined */ 0, state_undefined },
4182 { /*235, undefined */ 0, state_undefined },
4183 { /*236, undefined */ 0, state_undefined },
4184 { /*237, undefined */ 0, state_undefined },
4185 { /*238, undefined */ 0, state_undefined },
4186 { /*239, undefined */ 0, state_undefined },
4187 { /*240, undefined */ 0, state_undefined },
4188 { /*241, undefined */ 0, state_undefined },
4189 { /*242, undefined */ 0, state_undefined },
4190 { /*243, undefined */ 0, state_undefined },
4191 { /*244, undefined */ 0, state_undefined },
4192 { /*245, undefined */ 0, state_undefined },
4193 { /*246, undefined */ 0, state_undefined },
4194 { /*247, undefined */ 0, state_undefined },
4195 { /*248, undefined */ 0, state_undefined },
4196 { /*249, undefined */ 0, state_undefined },
4197 { /*250, undefined */ 0, state_undefined },
4198 { /*251, undefined */ 0, state_undefined },
4199 { /*252, undefined */ 0, state_undefined },
4200 { /*253, undefined */ 0, state_undefined },
4201 { /*254, undefined */ 0, state_undefined },
4202 { /*255, undefined */ 0, state_undefined },
4204 { /*256, WINED3DTS_WORLDMATRIX(0) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), transform_world },
4205 { /*257, WINED3DTS_WORLDMATRIX(1) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)), transform_worldex },
4206 { /*258, WINED3DTS_WORLDMATRIX(2) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)), transform_worldex },
4207 { /*259, WINED3DTS_WORLDMATRIX(3) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)), transform_worldex },
4208 { /*260, WINED3DTS_WORLDMATRIX(4) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)), transform_worldex },
4209 { /*261, WINED3DTS_WORLDMATRIX(5) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)), transform_worldex },
4210 { /*262, WINED3DTS_WORLDMATRIX(6) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)), transform_worldex },
4211 { /*263, WINED3DTS_WORLDMATRIX(7) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)), transform_worldex },
4212 { /*264, WINED3DTS_WORLDMATRIX(8) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)), transform_worldex },
4213 { /*265, WINED3DTS_WORLDMATRIX(9) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)), transform_worldex },
4214 { /*266, WINED3DTS_WORLDMATRIX(10) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)), transform_worldex },
4215 { /*267, WINED3DTS_WORLDMATRIX(11) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)), transform_worldex },
4216 { /*268, WINED3DTS_WORLDMATRIX(12) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)), transform_worldex },
4217 { /*269, WINED3DTS_WORLDMATRIX(13) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)), transform_worldex },
4218 { /*270, WINED3DTS_WORLDMATRIX(14) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)), transform_worldex },
4219 { /*271, WINED3DTS_WORLDMATRIX(15) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)), transform_worldex },
4220 { /*272, WINED3DTS_WORLDMATRIX(16) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)), transform_worldex },
4221 { /*273, WINED3DTS_WORLDMATRIX(17) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)), transform_worldex },
4222 { /*274, WINED3DTS_WORLDMATRIX(18) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)), transform_worldex },
4223 { /*275, WINED3DTS_WORLDMATRIX(19) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)), transform_worldex },
4224 { /*276, WINED3DTS_WORLDMATRIX(20) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)), transform_worldex },
4225 { /*277, WINED3DTS_WORLDMATRIX(21) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)), transform_worldex },
4226 { /*278, WINED3DTS_WORLDMATRIX(22) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)), transform_worldex },
4227 { /*279, WINED3DTS_WORLDMATRIX(23) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)), transform_worldex },
4228 { /*280, WINED3DTS_WORLDMATRIX(24) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)), transform_worldex },
4229 { /*281, WINED3DTS_WORLDMATRIX(25) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)), transform_worldex },
4230 { /*282, WINED3DTS_WORLDMATRIX(26) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)), transform_worldex },
4231 { /*283, WINED3DTS_WORLDMATRIX(27) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)), transform_worldex },
4232 { /*284, WINED3DTS_WORLDMATRIX(28) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)), transform_worldex },
4233 { /*285, WINED3DTS_WORLDMATRIX(29) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)), transform_worldex },
4234 { /*286, WINED3DTS_WORLDMATRIX(30) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)), transform_worldex },
4235 { /*287, WINED3DTS_WORLDMATRIX(31) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)), transform_worldex },
4236 { /*288, WINED3DTS_WORLDMATRIX(32) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)), transform_worldex },
4237 { /*289, WINED3DTS_WORLDMATRIX(33) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)), transform_worldex },
4238 { /*290, WINED3DTS_WORLDMATRIX(34) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)), transform_worldex },
4239 { /*291, WINED3DTS_WORLDMATRIX(35) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)), transform_worldex },
4240 { /*292, WINED3DTS_WORLDMATRIX(36) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)), transform_worldex },
4241 { /*293, WINED3DTS_WORLDMATRIX(37) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)), transform_worldex },
4242 { /*294, WINED3DTS_WORLDMATRIX(38) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)), transform_worldex },
4243 { /*295, WINED3DTS_WORLDMATRIX(39) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)), transform_worldex },
4244 { /*296, WINED3DTS_WORLDMATRIX(40) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)), transform_worldex },
4245 { /*297, WINED3DTS_WORLDMATRIX(41) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)), transform_worldex },
4246 { /*298, WINED3DTS_WORLDMATRIX(42) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)), transform_worldex },
4247 { /*299, WINED3DTS_WORLDMATRIX(43) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)), transform_worldex },
4248 { /*300, WINED3DTS_WORLDMATRIX(44) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)), transform_worldex },
4249 { /*301, WINED3DTS_WORLDMATRIX(45) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)), transform_worldex },
4250 { /*302, WINED3DTS_WORLDMATRIX(46) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)), transform_worldex },
4251 { /*303, WINED3DTS_WORLDMATRIX(47) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)), transform_worldex },
4252 { /*304, WINED3DTS_WORLDMATRIX(48) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)), transform_worldex },
4253 { /*305, WINED3DTS_WORLDMATRIX(49) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)), transform_worldex },
4254 { /*306, WINED3DTS_WORLDMATRIX(50) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)), transform_worldex },
4255 { /*307, WINED3DTS_WORLDMATRIX(51) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)), transform_worldex },
4256 { /*308, WINED3DTS_WORLDMATRIX(52) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)), transform_worldex },
4257 { /*309, WINED3DTS_WORLDMATRIX(53) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)), transform_worldex },
4258 { /*310, WINED3DTS_WORLDMATRIX(54) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)), transform_worldex },
4259 { /*311, WINED3DTS_WORLDMATRIX(55) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)), transform_worldex },
4260 { /*312, WINED3DTS_WORLDMATRIX(56) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)), transform_worldex },
4261 { /*313, WINED3DTS_WORLDMATRIX(57) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)), transform_worldex },
4262 { /*314, WINED3DTS_WORLDMATRIX(58) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)), transform_worldex },
4263 { /*315, WINED3DTS_WORLDMATRIX(59) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)), transform_worldex },
4264 { /*316, WINED3DTS_WORLDMATRIX(60) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)), transform_worldex },
4265 { /*317, WINED3DTS_WORLDMATRIX(61) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)), transform_worldex },
4266 { /*318, WINED3DTS_WORLDMATRIX(62) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)), transform_worldex },
4267 { /*319, WINED3DTS_WORLDMATRIX(63) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)), transform_worldex },
4268 { /*320, WINED3DTS_WORLDMATRIX(64) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)), transform_worldex },
4269 { /*321, WINED3DTS_WORLDMATRIX(65) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)), transform_worldex },
4270 { /*322, WINED3DTS_WORLDMATRIX(66) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)), transform_worldex },
4271 { /*323, WINED3DTS_WORLDMATRIX(67) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)), transform_worldex },
4272 { /*324, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)), transform_worldex },
4273 { /*325, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)), transform_worldex },
4274 { /*326, WINED3DTS_WORLDMATRIX(70) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)), transform_worldex },
4275 { /*327, WINED3DTS_WORLDMATRIX(71) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)), transform_worldex },
4276 { /*328, WINED3DTS_WORLDMATRIX(72) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)), transform_worldex },
4277 { /*329, WINED3DTS_WORLDMATRIX(73) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)), transform_worldex },
4278 { /*330, WINED3DTS_WORLDMATRIX(74) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)), transform_worldex },
4279 { /*331, WINED3DTS_WORLDMATRIX(75) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)), transform_worldex },
4280 { /*332, WINED3DTS_WORLDMATRIX(76) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)), transform_worldex },
4281 { /*333, WINED3DTS_WORLDMATRIX(77) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)), transform_worldex },
4282 { /*334, WINED3DTS_WORLDMATRIX(78) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)), transform_worldex },
4283 { /*335, WINED3DTS_WORLDMATRIX(79) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)), transform_worldex },
4284 { /*336, WINED3DTS_WORLDMATRIX(80) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)), transform_worldex },
4285 { /*337, WINED3DTS_WORLDMATRIX(81) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)), transform_worldex },
4286 { /*338, WINED3DTS_WORLDMATRIX(82) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)), transform_worldex },
4287 { /*339, WINED3DTS_WORLDMATRIX(83) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)), transform_worldex },
4288 { /*340, WINED3DTS_WORLDMATRIX(84) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)), transform_worldex },
4289 { /*341, WINED3DTS_WORLDMATRIX(85) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)), transform_worldex },
4290 { /*341, WINED3DTS_WORLDMATRIX(86) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)), transform_worldex },
4291 { /*343, WINED3DTS_WORLDMATRIX(87) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)), transform_worldex },
4292 { /*344, WINED3DTS_WORLDMATRIX(88) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)), transform_worldex },
4293 { /*345, WINED3DTS_WORLDMATRIX(89) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)), transform_worldex },
4294 { /*346, WINED3DTS_WORLDMATRIX(90) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)), transform_worldex },
4295 { /*347, WINED3DTS_WORLDMATRIX(91) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)), transform_worldex },
4296 { /*348, WINED3DTS_WORLDMATRIX(92) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)), transform_worldex },
4297 { /*349, WINED3DTS_WORLDMATRIX(93) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)), transform_worldex },
4298 { /*350, WINED3DTS_WORLDMATRIX(94) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)), transform_worldex },
4299 { /*351, WINED3DTS_WORLDMATRIX(95) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)), transform_worldex },
4300 { /*352, WINED3DTS_WORLDMATRIX(96) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)), transform_worldex },
4301 { /*353, WINED3DTS_WORLDMATRIX(97) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)), transform_worldex },
4302 { /*354, WINED3DTS_WORLDMATRIX(98) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)), transform_worldex },
4303 { /*355, WINED3DTS_WORLDMATRIX(99) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)), transform_worldex },
4304 { /*356, WINED3DTS_WORLDMATRIX(100) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex },
4305 { /*357, WINED3DTS_WORLDMATRIX(101) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex },
4306 { /*358, WINED3DTS_WORLDMATRIX(102) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex },
4307 { /*359, WINED3DTS_WORLDMATRIX(103) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex },
4308 { /*360, WINED3DTS_WORLDMATRIX(104) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex },
4309 { /*361, WINED3DTS_WORLDMATRIX(105) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex },
4310 { /*362, WINED3DTS_WORLDMATRIX(106) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex },
4311 { /*363, WINED3DTS_WORLDMATRIX(107) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex },
4312 { /*364, WINED3DTS_WORLDMATRIX(108) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex },
4313 { /*365, WINED3DTS_WORLDMATRIX(109) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex },
4314 { /*366, WINED3DTS_WORLDMATRIX(110) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex },
4315 { /*367, WINED3DTS_WORLDMATRIX(111) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex },
4316 { /*368, WINED3DTS_WORLDMATRIX(112) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex },
4317 { /*369, WINED3DTS_WORLDMATRIX(113) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex },
4318 { /*370, WINED3DTS_WORLDMATRIX(114) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex },
4319 { /*371, WINED3DTS_WORLDMATRIX(115) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex },
4320 { /*372, WINED3DTS_WORLDMATRIX(116) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex },
4321 { /*373, WINED3DTS_WORLDMATRIX(117) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex },
4322 { /*374, WINED3DTS_WORLDMATRIX(118) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex },
4323 { /*375, WINED3DTS_WORLDMATRIX(119) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex },
4324 { /*376, WINED3DTS_WORLDMATRIX(120) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex },
4325 { /*377, WINED3DTS_WORLDMATRIX(121) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex },
4326 { /*378, WINED3DTS_WORLDMATRIX(122) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex },
4327 { /*379, WINED3DTS_WORLDMATRIX(123) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex },
4328 { /*380, WINED3DTS_WORLDMATRIX(124) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex },
4329 { /*381, WINED3DTS_WORLDMATRIX(125) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex },
4330 { /*382, WINED3DTS_WORLDMATRIX(126) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex },
4331 { /*383, WINED3DTS_WORLDMATRIX(127) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex },
4332 { /*384, WINED3DTS_WORLDMATRIX(128) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex },
4333 { /*385, WINED3DTS_WORLDMATRIX(129) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex },
4334 { /*386, WINED3DTS_WORLDMATRIX(130) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex },
4335 { /*387, WINED3DTS_WORLDMATRIX(131) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex },
4336 { /*388, WINED3DTS_WORLDMATRIX(132) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex },
4337 { /*389, WINED3DTS_WORLDMATRIX(133) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex },
4338 { /*390, WINED3DTS_WORLDMATRIX(134) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex },
4339 { /*391, WINED3DTS_WORLDMATRIX(135) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex },
4340 { /*392, WINED3DTS_WORLDMATRIX(136) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex },
4341 { /*393, WINED3DTS_WORLDMATRIX(137) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex },
4342 { /*394, WINED3DTS_WORLDMATRIX(138) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex },
4343 { /*395, WINED3DTS_WORLDMATRIX(139) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex },
4344 { /*396, WINED3DTS_WORLDMATRIX(140) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex },
4345 { /*397, WINED3DTS_WORLDMATRIX(141) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex },
4346 { /*398, WINED3DTS_WORLDMATRIX(142) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex },
4347 { /*399, WINED3DTS_WORLDMATRIX(143) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex },
4348 { /*400, WINED3DTS_WORLDMATRIX(144) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex },
4349 { /*401, WINED3DTS_WORLDMATRIX(145) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex },
4350 { /*402, WINED3DTS_WORLDMATRIX(146) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex },
4351 { /*403, WINED3DTS_WORLDMATRIX(147) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex },
4352 { /*404, WINED3DTS_WORLDMATRIX(148) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex },
4353 { /*405, WINED3DTS_WORLDMATRIX(149) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex },
4354 { /*406, WINED3DTS_WORLDMATRIX(150) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex },
4355 { /*407, WINED3DTS_WORLDMATRIX(151) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex },
4356 { /*408, WINED3DTS_WORLDMATRIX(152) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex },
4357 { /*409, WINED3DTS_WORLDMATRIX(153) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex },
4358 { /*410, WINED3DTS_WORLDMATRIX(154) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex },
4359 { /*411, WINED3DTS_WORLDMATRIX(155) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex },
4360 { /*412, WINED3DTS_WORLDMATRIX(156) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex },
4361 { /*413, WINED3DTS_WORLDMATRIX(157) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex },
4362 { /*414, WINED3DTS_WORLDMATRIX(158) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex },
4363 { /*415, WINED3DTS_WORLDMATRIX(159) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex },
4364 { /*416, WINED3DTS_WORLDMATRIX(160) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex },
4365 { /*417, WINED3DTS_WORLDMATRIX(161) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex },
4366 { /*418, WINED3DTS_WORLDMATRIX(162) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex },
4367 { /*419, WINED3DTS_WORLDMATRIX(163) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex },
4368 { /*420, WINED3DTS_WORLDMATRIX(164) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex },
4369 { /*421, WINED3DTS_WORLDMATRIX(165) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex },
4370 { /*422, WINED3DTS_WORLDMATRIX(166) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex },
4371 { /*423, WINED3DTS_WORLDMATRIX(167) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex },
4372 { /*424, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex },
4373 { /*425, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex },
4374 { /*426, WINED3DTS_WORLDMATRIX(170) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex },
4375 { /*427, WINED3DTS_WORLDMATRIX(171) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex },
4376 { /*428, WINED3DTS_WORLDMATRIX(172) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex },
4377 { /*429, WINED3DTS_WORLDMATRIX(173) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex },
4378 { /*430, WINED3DTS_WORLDMATRIX(174) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex },
4379 { /*431, WINED3DTS_WORLDMATRIX(175) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex },
4380 { /*432, WINED3DTS_WORLDMATRIX(176) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex },
4381 { /*433, WINED3DTS_WORLDMATRIX(177) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex },
4382 { /*434, WINED3DTS_WORLDMATRIX(178) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex },
4383 { /*435, WINED3DTS_WORLDMATRIX(179) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex },
4384 { /*436, WINED3DTS_WORLDMATRIX(180) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex },
4385 { /*437, WINED3DTS_WORLDMATRIX(181) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex },
4386 { /*438, WINED3DTS_WORLDMATRIX(182) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex },
4387 { /*439, WINED3DTS_WORLDMATRIX(183) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex },
4388 { /*440, WINED3DTS_WORLDMATRIX(184) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex },
4389 { /*441, WINED3DTS_WORLDMATRIX(185) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex },
4390 { /*441, WINED3DTS_WORLDMATRIX(186) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex },
4391 { /*443, WINED3DTS_WORLDMATRIX(187) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex },
4392 { /*444, WINED3DTS_WORLDMATRIX(188) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex },
4393 { /*445, WINED3DTS_WORLDMATRIX(189) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex },
4394 { /*446, WINED3DTS_WORLDMATRIX(190) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex },
4395 { /*447, WINED3DTS_WORLDMATRIX(191) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex },
4396 { /*448, WINED3DTS_WORLDMATRIX(192) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex },
4397 { /*449, WINED3DTS_WORLDMATRIX(193) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex },
4398 { /*450, WINED3DTS_WORLDMATRIX(194) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex },
4399 { /*451, WINED3DTS_WORLDMATRIX(195) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex },
4400 { /*452, WINED3DTS_WORLDMATRIX(196) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex },
4401 { /*453, WINED3DTS_WORLDMATRIX(197) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex },
4402 { /*454, WINED3DTS_WORLDMATRIX(198) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex },
4403 { /*455, WINED3DTS_WORLDMATRIX(199) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex },
4404 { /*356, WINED3DTS_WORLDMATRIX(200) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex },
4405 { /*457, WINED3DTS_WORLDMATRIX(201) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex },
4406 { /*458, WINED3DTS_WORLDMATRIX(202) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex },
4407 { /*459, WINED3DTS_WORLDMATRIX(203) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex },
4408 { /*460, WINED3DTS_WORLDMATRIX(204) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex },
4409 { /*461, WINED3DTS_WORLDMATRIX(205) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex },
4410 { /*462, WINED3DTS_WORLDMATRIX(206) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex },
4411 { /*463, WINED3DTS_WORLDMATRIX(207) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex },
4412 { /*464, WINED3DTS_WORLDMATRIX(208) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex },
4413 { /*465, WINED3DTS_WORLDMATRIX(209) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex },
4414 { /*466, WINED3DTS_WORLDMATRIX(210) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex },
4415 { /*467, WINED3DTS_WORLDMATRIX(211) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex },
4416 { /*468, WINED3DTS_WORLDMATRIX(212) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex },
4417 { /*469, WINED3DTS_WORLDMATRIX(213) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex },
4418 { /*470, WINED3DTS_WORLDMATRIX(214) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex },
4419 { /*471, WINED3DTS_WORLDMATRIX(215) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex },
4420 { /*472, WINED3DTS_WORLDMATRIX(216) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex },
4421 { /*473, WINED3DTS_WORLDMATRIX(217) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex },
4422 { /*474, WINED3DTS_WORLDMATRIX(218) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex },
4423 { /*475, WINED3DTS_WORLDMATRIX(219) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex },
4424 { /*476, WINED3DTS_WORLDMATRIX(220) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex },
4425 { /*477, WINED3DTS_WORLDMATRIX(221) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex },
4426 { /*478, WINED3DTS_WORLDMATRIX(222) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex },
4427 { /*479, WINED3DTS_WORLDMATRIX(223) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex },
4428 { /*480, WINED3DTS_WORLDMATRIX(224) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex },
4429 { /*481, WINED3DTS_WORLDMATRIX(225) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex },
4430 { /*482, WINED3DTS_WORLDMATRIX(226) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex },
4431 { /*483, WINED3DTS_WORLDMATRIX(227) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex },
4432 { /*484, WINED3DTS_WORLDMATRIX(228) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex },
4433 { /*485, WINED3DTS_WORLDMATRIX(229) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex },
4434 { /*486, WINED3DTS_WORLDMATRIX(230) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex },
4435 { /*487, WINED3DTS_WORLDMATRIX(231) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex },
4436 { /*488, WINED3DTS_WORLDMATRIX(232) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex },
4437 { /*489, WINED3DTS_WORLDMATRIX(233) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex },
4438 { /*490, WINED3DTS_WORLDMATRIX(234) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex },
4439 { /*491, WINED3DTS_WORLDMATRIX(235) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex },
4440 { /*492, WINED3DTS_WORLDMATRIX(236) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex },
4441 { /*493, WINED3DTS_WORLDMATRIX(237) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex },
4442 { /*494, WINED3DTS_WORLDMATRIX(238) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex },
4443 { /*495, WINED3DTS_WORLDMATRIX(239) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex },
4444 { /*496, WINED3DTS_WORLDMATRIX(240) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex },
4445 { /*497, WINED3DTS_WORLDMATRIX(241) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex },
4446 { /*498, WINED3DTS_WORLDMATRIX(242) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex },
4447 { /*499, WINED3DTS_WORLDMATRIX(243) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex },
4448 { /*500, WINED3DTS_WORLDMATRIX(244) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex },
4449 { /*501, WINED3DTS_WORLDMATRIX(245) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex },
4450 { /*502, WINED3DTS_WORLDMATRIX(246) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex },
4451 { /*503, WINED3DTS_WORLDMATRIX(247) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex },
4452 { /*504, WINED3DTS_WORLDMATRIX(248) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex },
4453 { /*505, WINED3DTS_WORLDMATRIX(249) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex },
4454 { /*506, WINED3DTS_WORLDMATRIX(250) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex },
4455 { /*507, WINED3DTS_WORLDMATRIX(251) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex },
4456 { /*508, WINED3DTS_WORLDMATRIX(252) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex },
4457 { /*509, WINED3DTS_WORLDMATRIX(253) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex },
4458 { /*510, WINED3DTS_WORLDMATRIX(254) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex },
4459 { /*511, WINED3DTS_WORLDMATRIX(255) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex },
4460 /* Various Vertex states follow */
4461 { /* , STATE_STREAMSRC */ STATE_VDECL, vertexdeclaration },
4462 { /* , STATE_INDEXBUFFER */ STATE_INDEXBUFFER, indexbuffer },
4463 { /* , STATE_VDECL */ STATE_VDECL, vertexdeclaration },
4464 { /* , STATE_VSHADER */ STATE_VDECL, vertexdeclaration },
4465 { /* , STATE_VIEWPORT */ STATE_VIEWPORT, viewport },
4466 { /* , STATE_VERTEXSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
4467 { /* , STATE_PIXELSHADERCONSTANT */ STATE_VERTEXSHADERCONSTANT, shaderconstant },
4469 { /* , STATE_ACTIVELIGHT(0) */ STATE_ACTIVELIGHT(0), light },
4470 { /* , STATE_ACTIVELIGHT(1) */ STATE_ACTIVELIGHT(1), light },
4471 { /* , STATE_ACTIVELIGHT(2) */ STATE_ACTIVELIGHT(2), light },
4472 { /* , STATE_ACTIVELIGHT(3) */ STATE_ACTIVELIGHT(3), light },
4473 { /* , STATE_ACTIVELIGHT(4) */ STATE_ACTIVELIGHT(4), light },
4474 { /* , STATE_ACTIVELIGHT(5) */ STATE_ACTIVELIGHT(5), light },
4475 { /* , STATE_ACTIVELIGHT(6) */ STATE_ACTIVELIGHT(6), light },
4476 { /* , STATE_ACTIVELIGHT(7) */ STATE_ACTIVELIGHT(7), light },
4478 { /* Scissor rect */ STATE_SCISSORRECT, scissorrect },
4480 { /* STATE_CLIPPLANE(0) */ STATE_CLIPPLANE(0), clipplane },
4481 { /* STATE_CLIPPLANE(1) */ STATE_CLIPPLANE(1), clipplane },
4482 { /* STATE_CLIPPLANE(2) */ STATE_CLIPPLANE(2), clipplane },
4483 { /* STATE_CLIPPLANE(3) */ STATE_CLIPPLANE(3), clipplane },
4484 { /* STATE_CLIPPLANE(4) */ STATE_CLIPPLANE(4), clipplane },
4485 { /* STATE_CLIPPLANE(5) */ STATE_CLIPPLANE(5), clipplane },
4486 { /* STATE_CLIPPLANE(6) */ STATE_CLIPPLANE(6), clipplane },
4487 { /* STATE_CLIPPLANE(7) */ STATE_CLIPPLANE(7), clipplane },
4488 { /* STATE_CLIPPLANE(8) */ STATE_CLIPPLANE(8), clipplane },
4489 { /* STATE_CLIPPLANE(9) */ STATE_CLIPPLANE(9), clipplane },
4490 { /* STATE_CLIPPLANE(10) */ STATE_CLIPPLANE(10), clipplane },
4491 { /* STATE_CLIPPLANE(11) */ STATE_CLIPPLANE(11), clipplane },
4492 { /* STATE_CLIPPLANE(12) */ STATE_CLIPPLANE(12), clipplane },
4493 { /* STATE_CLIPPLANE(13) */ STATE_CLIPPLANE(13), clipplane },
4494 { /* STATE_CLIPPLANE(14) */ STATE_CLIPPLANE(14), clipplane },
4495 { /* STATE_CLIPPLANE(15) */ STATE_CLIPPLANE(15), clipplane },
4496 { /* STATE_CLIPPLANE(16) */ STATE_CLIPPLANE(16), clipplane },
4497 { /* STATE_CLIPPLANE(17) */ STATE_CLIPPLANE(17), clipplane },
4498 { /* STATE_CLIPPLANE(18) */ STATE_CLIPPLANE(18), clipplane },
4499 { /* STATE_CLIPPLANE(19) */ STATE_CLIPPLANE(19), clipplane },
4500 { /* STATE_CLIPPLANE(20) */ STATE_CLIPPLANE(20), clipplane },
4501 { /* STATE_CLIPPLANE(21) */ STATE_CLIPPLANE(21), clipplane },
4502 { /* STATE_CLIPPLANE(22) */ STATE_CLIPPLANE(22), clipplane },
4503 { /* STATE_CLIPPLANE(23) */ STATE_CLIPPLANE(23), clipplane },
4504 { /* STATE_CLIPPLANE(24) */ STATE_CLIPPLANE(24), clipplane },
4505 { /* STATE_CLIPPLANE(25) */ STATE_CLIPPLANE(25), clipplane },
4506 { /* STATE_CLIPPLANE(26) */ STATE_CLIPPLANE(26), clipplane },
4507 { /* STATE_CLIPPLANE(27) */ STATE_CLIPPLANE(27), clipplane },
4508 { /* STATE_CLIPPLANE(28) */ STATE_CLIPPLANE(28), clipplane },
4509 { /* STATE_CLIPPLANE(29) */ STATE_CLIPPLANE(29), clipplane },
4510 { /* STATE_CLIPPLANE(30) */ STATE_CLIPPLANE(30), clipplane },
4511 { /* STATE_CLIPPLANE(31) */ STATE_CLIPPLANE(31), clipplane },