2 * Direct3D state management
4 * Copyright 2006 Stefan Dösinger for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wined3d_private.h"
28 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
30 #define GLINFO_LOCATION ((IWineD3DImpl *)(stateblock->wineD3DDevice->wineD3D))->gl_info
32 static void state_nogl(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
33 /* Used for states which are not mapped to a gl state as-is, but used somehow different,
34 * e.g as a parameter for drawing, or which are unimplemented in windows d3d
36 if(STATE_IS_RENDER(state
)) {
37 WINED3DRENDERSTATETYPE RenderState
= state
- STATE_RENDER(0);
38 TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState
), stateblock
->renderState
[RenderState
]);
40 /* Shouldn't have an unknown type here */
41 FIXME("%d no direct mapping to gl of state with unknown type\n", state
);
45 static void state_undefined(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
46 /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
47 * list without causing confusing terminal output. Deliberately no special debug name here
48 * because its undefined.
50 WARN("undefined state %d\n", state
);
53 static void state_fillmode(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
54 D3DFILLMODE Value
= stateblock
->renderState
[WINED3DRS_FILLMODE
];
58 glPolygonMode(GL_FRONT_AND_BACK
, GL_POINT
);
59 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
61 case D3DFILL_WIREFRAME
:
62 glPolygonMode(GL_FRONT_AND_BACK
, GL_LINE
);
63 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
66 glPolygonMode(GL_FRONT_AND_BACK
, GL_FILL
);
67 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
70 FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value
);
74 static void state_lighting(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
77 /* Lighting is only enabled if Vertex normals are passed by the application,
78 * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
79 * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
80 * vertex declaration appplying function calls this function for updating
83 if(isStateDirty(stateblock
->wineD3DDevice
, STATE_VDECL
)) {
87 normals
= stateblock
->wineD3DDevice
->strided_streams
.u
.s
.normal
.lpData
!= NULL
||
88 stateblock
->wineD3DDevice
->strided_streams
.u
.s
.normal
.VBO
!= 0;
90 if (stateblock
->renderState
[WINED3DRS_LIGHTING
] && normals
) {
91 glEnable(GL_LIGHTING
);
92 checkGLcall("glEnable GL_LIGHTING");
94 glDisable(GL_LIGHTING
);
95 checkGLcall("glDisable GL_LIGHTING");
99 static void state_zenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
100 switch ((WINED3DZBUFFERTYPE
) stateblock
->renderState
[WINED3DRS_ZENABLE
]) {
101 case WINED3DZB_FALSE
:
102 glDisable(GL_DEPTH_TEST
);
103 checkGLcall("glDisable GL_DEPTH_TEST");
106 glEnable(GL_DEPTH_TEST
);
107 checkGLcall("glEnable GL_DEPTH_TEST");
110 glEnable(GL_DEPTH_TEST
);
111 checkGLcall("glEnable GL_DEPTH_TEST");
112 FIXME("W buffer is not well handled\n");
115 FIXME("Unrecognized D3DZBUFFERTYPE value %d\n", stateblock
->renderState
[WINED3DRS_ZENABLE
]);
119 static void state_cullmode(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
120 /* TODO: Put this into the offscreen / onscreen rendering block due to device->render_offscreen */
122 /* If we are culling "back faces with clockwise vertices" then
123 set front faces to be counter clockwise and enable culling
125 switch ((WINED3DCULL
) stateblock
->renderState
[WINED3DRS_CULLMODE
]) {
126 case WINED3DCULL_NONE
:
127 glDisable(GL_CULL_FACE
);
128 checkGLcall("glDisable GL_CULL_FACE");
131 glEnable(GL_CULL_FACE
);
132 checkGLcall("glEnable GL_CULL_FACE");
133 if (stateblock
->wineD3DDevice
->render_offscreen
) {
135 checkGLcall("glFrontFace GL_CW");
138 checkGLcall("glFrontFace GL_CCW");
142 case WINED3DCULL_CCW
:
143 glEnable(GL_CULL_FACE
);
144 checkGLcall("glEnable GL_CULL_FACE");
145 if (stateblock
->wineD3DDevice
->render_offscreen
) {
147 checkGLcall("glFrontFace GL_CCW");
150 checkGLcall("glFrontFace GL_CW");
155 FIXME("Unrecognized/Unhandled WINED3DCULL value %d\n", stateblock
->renderState
[WINED3DRS_CULLMODE
]);
159 static void state_shademode(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
160 switch ((WINED3DSHADEMODE
) stateblock
->renderState
[WINED3DRS_SHADEMODE
]) {
161 case WINED3DSHADE_FLAT
:
162 glShadeModel(GL_FLAT
);
163 checkGLcall("glShadeModel(GL_FLAT)");
165 case WINED3DSHADE_GOURAUD
:
166 glShadeModel(GL_SMOOTH
);
167 checkGLcall("glShadeModel(GL_SMOOTH)");
169 case WINED3DSHADE_PHONG
:
170 FIXME("WINED3DSHADE_PHONG isn't supported\n");
173 FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %d\n", stateblock
->renderState
[WINED3DRS_SHADEMODE
]);
177 static void state_ditherenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
178 if (stateblock
->renderState
[WINED3DRS_DITHERENABLE
]) {
180 checkGLcall("glEnable GL_DITHER");
182 glDisable(GL_DITHER
);
183 checkGLcall("glDisable GL_DITHER");
187 static void state_zwritenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
188 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off. If yes,
189 * this has to be merged with ZENABLE and ZFUNC
191 if (stateblock
->renderState
[WINED3DRS_ZWRITEENABLE
]) {
193 checkGLcall("glDepthMask(1)");
196 checkGLcall("glDepthMask(0)");
200 static void state_zfunc(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
201 int glParm
= CompareFunc(stateblock
->renderState
[WINED3DRS_ZFUNC
]);
205 checkGLcall("glDepthFunc");
209 static void state_ambient(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
211 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_AMBIENT
], col
);
213 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col
[0], col
[1], col
[2], col
[3]);
214 glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, col
);
215 checkGLcall("glLightModel for MODEL_AMBIENT");
218 static void state_blend(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
219 int srcBlend
= GL_ZERO
;
220 int dstBlend
= GL_ZERO
;
222 /* GL_LINE_SMOOTH needs GL_BLEND to work, according to the red book, and special blending params */
223 if (stateblock
->renderState
[WINED3DRS_ALPHABLENDENABLE
] ||
224 stateblock
->renderState
[WINED3DRS_EDGEANTIALIAS
] ||
225 stateblock
->renderState
[WINED3DRS_ANTIALIASEDLINEENABLE
]) {
227 checkGLcall("glEnable GL_BLEND");
230 checkGLcall("glDisable GL_BLEND");
231 /* Nothing more to do - get out */
235 switch (stateblock
->renderState
[WINED3DRS_SRCBLEND
]) {
236 case WINED3DBLEND_ZERO
: srcBlend
= GL_ZERO
; break;
237 case WINED3DBLEND_ONE
: srcBlend
= GL_ONE
; break;
238 case WINED3DBLEND_SRCCOLOR
: srcBlend
= GL_SRC_COLOR
; break;
239 case WINED3DBLEND_INVSRCCOLOR
: srcBlend
= GL_ONE_MINUS_SRC_COLOR
; break;
240 case WINED3DBLEND_SRCALPHA
: srcBlend
= GL_SRC_ALPHA
; break;
241 case WINED3DBLEND_INVSRCALPHA
: srcBlend
= GL_ONE_MINUS_SRC_ALPHA
; break;
242 case WINED3DBLEND_DESTALPHA
: srcBlend
= GL_DST_ALPHA
; break;
243 case WINED3DBLEND_INVDESTALPHA
: srcBlend
= GL_ONE_MINUS_DST_ALPHA
; break;
244 case WINED3DBLEND_DESTCOLOR
: srcBlend
= GL_DST_COLOR
; break;
245 case WINED3DBLEND_INVDESTCOLOR
: srcBlend
= GL_ONE_MINUS_DST_COLOR
; break;
246 case WINED3DBLEND_SRCALPHASAT
: srcBlend
= GL_SRC_ALPHA_SATURATE
; break;
248 case WINED3DBLEND_BOTHSRCALPHA
: srcBlend
= GL_SRC_ALPHA
;
249 dstBlend
= GL_SRC_ALPHA
;
252 case WINED3DBLEND_BOTHINVSRCALPHA
: srcBlend
= GL_ONE_MINUS_SRC_ALPHA
;
253 dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
256 case WINED3DBLEND_BLENDFACTOR
: srcBlend
= GL_CONSTANT_COLOR
; break;
257 case WINED3DBLEND_INVBLENDFACTOR
: srcBlend
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
259 FIXME("Unrecognized src blend value %d\n", stateblock
->renderState
[WINED3DRS_SRCBLEND
]);
262 switch (stateblock
->renderState
[WINED3DRS_DESTBLEND
]) {
263 case WINED3DBLEND_ZERO
: dstBlend
= GL_ZERO
; break;
264 case WINED3DBLEND_ONE
: dstBlend
= GL_ONE
; break;
265 case WINED3DBLEND_SRCCOLOR
: dstBlend
= GL_SRC_COLOR
; break;
266 case WINED3DBLEND_INVSRCCOLOR
: dstBlend
= GL_ONE_MINUS_SRC_COLOR
; break;
267 case WINED3DBLEND_SRCALPHA
: dstBlend
= GL_SRC_ALPHA
; break;
268 case WINED3DBLEND_INVSRCALPHA
: dstBlend
= GL_ONE_MINUS_SRC_ALPHA
; break;
269 case WINED3DBLEND_DESTALPHA
: dstBlend
= GL_DST_ALPHA
; break;
270 case WINED3DBLEND_INVDESTALPHA
: dstBlend
= GL_ONE_MINUS_DST_ALPHA
; break;
271 case WINED3DBLEND_DESTCOLOR
: dstBlend
= GL_DST_COLOR
; break;
272 case WINED3DBLEND_INVDESTCOLOR
: dstBlend
= GL_ONE_MINUS_DST_COLOR
; break;
273 case WINED3DBLEND_SRCALPHASAT
: dstBlend
= GL_SRC_ALPHA_SATURATE
; break;
275 case WINED3DBLEND_BOTHSRCALPHA
: dstBlend
= GL_SRC_ALPHA
;
276 srcBlend
= GL_SRC_ALPHA
;
279 case WINED3DBLEND_BOTHINVSRCALPHA
: dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
280 srcBlend
= GL_ONE_MINUS_SRC_ALPHA
;
283 case D3DBLEND_BLENDFACTOR
: dstBlend
= GL_CONSTANT_COLOR
; break;
284 case D3DBLEND_INVBLENDFACTOR
: dstBlend
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
286 FIXME("Unrecognized dst blend value %d\n", stateblock
->renderState
[WINED3DRS_DESTBLEND
]);
289 if(stateblock
->renderState
[WINED3DRS_EDGEANTIALIAS
] ||
290 stateblock
->renderState
[WINED3DRS_ANTIALIASEDLINEENABLE
]) {
291 glEnable(GL_LINE_SMOOTH
);
292 checkGLcall("glEnable(GL_LINE_SMOOTH)");
293 if(srcBlend
!= GL_SRC_ALPHA
) {
294 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible src blending param - what to do?\n");
295 srcBlend
= GL_SRC_ALPHA
;
297 if(dstBlend
!= GL_ONE_MINUS_SRC_ALPHA
) {
298 FIXME("WINED3DRS_EDGEANTIALIAS enabled, but incompatible dst blending param - what to do?\n");
299 dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
302 glDisable(GL_LINE_SMOOTH
);
303 checkGLcall("glDisable(GL_LINE_SMOOTH)");
306 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend
, dstBlend
);
307 glBlendFunc(srcBlend
, dstBlend
);
308 checkGLcall("glBlendFunc");
310 /* TODO: Remove when state management done */
311 stateblock
->wineD3DDevice
->dstBlend
= dstBlend
;
312 stateblock
->wineD3DDevice
->srcBlend
= srcBlend
;
315 static void state_blendfactor(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
318 TRACE("Setting BlendFactor to %d\n", stateblock
->renderState
[WINED3DRS_BLENDFACTOR
]);
319 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_BLENDFACTOR
], col
);
320 glBlendColor (col
[0],col
[1],col
[2],col
[3]);
321 checkGLcall("glBlendColor");
324 static void state_alpha(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
327 BOOL enable_ckey
= FALSE
;
329 IWineD3DSurfaceImpl
*surf
;
331 /* Find out if the texture on the first stage has a ckey set
332 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
333 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
334 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
335 * in case it finds some texture+colorkeyenable combination which needs extra care.
337 if(stateblock
->textures
[0]) {
338 surf
= (IWineD3DSurfaceImpl
*) ((IWineD3DTextureImpl
*)stateblock
->textures
[0])->surfaces
[0];
339 if(surf
->CKeyFlags
& DDSD_CKSRCBLT
) enable_ckey
= TRUE
;
342 if (stateblock
->renderState
[WINED3DRS_ALPHATESTENABLE
] ||
343 (stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] && enable_ckey
)) {
344 glEnable(GL_ALPHA_TEST
);
345 checkGLcall("glEnable GL_ALPHA_TEST");
347 glDisable(GL_ALPHA_TEST
);
348 checkGLcall("glDisable GL_ALPHA_TEST");
349 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
355 if(stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] && enable_ckey
) {
356 glParm
= GL_NOTEQUAL
;
359 ref
= ((float) stateblock
->renderState
[WINED3DRS_ALPHAREF
]) / 255.0f
;
360 glParm
= CompareFunc(stateblock
->renderState
[WINED3DRS_ALPHAFUNC
]);
363 stateblock
->wineD3DDevice
->alphafunc
= glParm
; /* Remove when state management done */
364 glAlphaFunc(glParm
, ref
);
365 checkGLcall("glAlphaFunc");
367 /* TODO: Some texture blending operations seem to affect the alpha test */
370 static void state_clipping(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
371 DWORD enable
= 0xFFFFFFFF;
372 DWORD disable
= 0x00000000;
374 /* TODO: Keep track of previously enabled clipplanes to avoid unneccessary resetting
375 * of already set values
378 /* If enabling / disabling all
379 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
381 if (stateblock
->renderState
[WINED3DRS_CLIPPING
]) {
382 enable
= stateblock
->renderState
[WINED3DRS_CLIPPLANEENABLE
];
383 disable
= ~stateblock
->renderState
[WINED3DRS_CLIPPLANEENABLE
];
385 disable
= 0xffffffff;
389 if (enable
& WINED3DCLIPPLANE0
) { glEnable(GL_CLIP_PLANE0
); checkGLcall("glEnable(clip plane 0)"); }
390 if (enable
& WINED3DCLIPPLANE1
) { glEnable(GL_CLIP_PLANE1
); checkGLcall("glEnable(clip plane 1)"); }
391 if (enable
& WINED3DCLIPPLANE2
) { glEnable(GL_CLIP_PLANE2
); checkGLcall("glEnable(clip plane 2)"); }
392 if (enable
& WINED3DCLIPPLANE3
) { glEnable(GL_CLIP_PLANE3
); checkGLcall("glEnable(clip plane 3)"); }
393 if (enable
& WINED3DCLIPPLANE4
) { glEnable(GL_CLIP_PLANE4
); checkGLcall("glEnable(clip plane 4)"); }
394 if (enable
& WINED3DCLIPPLANE5
) { glEnable(GL_CLIP_PLANE5
); checkGLcall("glEnable(clip plane 5)"); }
396 if (disable
& WINED3DCLIPPLANE0
) { glDisable(GL_CLIP_PLANE0
); checkGLcall("glDisable(clip plane 0)"); }
397 if (disable
& WINED3DCLIPPLANE1
) { glDisable(GL_CLIP_PLANE1
); checkGLcall("glDisable(clip plane 1)"); }
398 if (disable
& WINED3DCLIPPLANE2
) { glDisable(GL_CLIP_PLANE2
); checkGLcall("glDisable(clip plane 2)"); }
399 if (disable
& WINED3DCLIPPLANE3
) { glDisable(GL_CLIP_PLANE3
); checkGLcall("glDisable(clip plane 3)"); }
400 if (disable
& WINED3DCLIPPLANE4
) { glDisable(GL_CLIP_PLANE4
); checkGLcall("glDisable(clip plane 4)"); }
401 if (disable
& WINED3DCLIPPLANE5
) { glDisable(GL_CLIP_PLANE5
); checkGLcall("glDisable(clip plane 5)"); }
403 /** update clipping status */
405 stateblock
->clip_status
.ClipUnion
= 0;
406 stateblock
->clip_status
.ClipIntersection
= 0xFFFFFFFF;
408 stateblock
->clip_status
.ClipUnion
= 0;
409 stateblock
->clip_status
.ClipIntersection
= 0;
413 static void state_blendop(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
414 int glParm
= GL_FUNC_ADD
;
416 if(!GL_SUPPORT(EXT_BLEND_MINMAX
)) {
417 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
421 switch ((WINED3DBLENDOP
) stateblock
->renderState
[WINED3DRS_BLENDOP
]) {
422 case WINED3DBLENDOP_ADD
: glParm
= GL_FUNC_ADD
; break;
423 case WINED3DBLENDOP_SUBTRACT
: glParm
= GL_FUNC_SUBTRACT
; break;
424 case WINED3DBLENDOP_REVSUBTRACT
: glParm
= GL_FUNC_REVERSE_SUBTRACT
; break;
425 case WINED3DBLENDOP_MIN
: glParm
= GL_MIN
; break;
426 case WINED3DBLENDOP_MAX
: glParm
= GL_MAX
; break;
428 FIXME("Unrecognized/Unhandled D3DBLENDOP value %d\n", stateblock
->renderState
[WINED3DRS_BLENDOP
]);
431 TRACE("glBlendEquation(%x)\n", glParm
);
432 GL_EXTCALL(glBlendEquation(glParm
));
433 checkGLcall("glBlendEquation");
437 state_specularenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
438 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
439 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
440 * specular color. This is wrong:
441 * Separate specular color means the specular colour is maintained separately, whereas
442 * single color means it is merged in. However in both cases they are being used to
444 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
445 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
449 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
450 * Instead, we need to setup the FinalCombiner properly.
452 * The default setup for the FinalCombiner is:
454 * <variable> <input> <mapping> <usage>
455 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
456 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
457 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
458 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
459 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
460 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
461 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
463 * That's pretty much fine as it is, except for variable B, which needs to take
464 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
465 * whether WINED3DRS_SPECULARENABLE is enabled or not.
468 TRACE("Setting specular enable state\n");
469 /* TODO: Add to the material setting functions */
470 if (stateblock
->renderState
[WINED3DRS_SPECULARENABLE
]) {
471 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float*) &stateblock
->material
.Specular
);
472 checkGLcall("glMaterialfv");
473 if (GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
474 glEnable(GL_COLOR_SUM_EXT
);
476 TRACE("Specular colors cannot be enabled in this version of opengl\n");
478 checkGLcall("glEnable(GL_COLOR_SUM)");
480 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
481 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_PLUS_SECONDARY_COLOR_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
482 checkGLcall("glFinalCombinerInputNV()");
485 float black
[4] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
487 /* for the case of enabled lighting: */
488 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
489 checkGLcall("glMaterialfv");
491 /* for the case of disabled lighting: */
492 if (GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
493 glDisable(GL_COLOR_SUM_EXT
);
495 TRACE("Specular colors cannot be disabled in this version of opengl\n");
497 checkGLcall("glDisable(GL_COLOR_SUM)");
499 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
500 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
501 checkGLcall("glFinalCombinerInputNV()");
506 static void state_texfactor(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
509 /* Note the texture color applies to all textures whereas
510 * GL_TEXTURE_ENV_COLOR applies to active only
513 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_TEXTUREFACTOR
], col
);
515 if (!GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
516 /* And now the default texture color as well */
517 for (i
= 0; i
< GL_LIMITS(texture_stages
); i
++) {
518 /* Note the WINED3DRS value applies to all textures, but GL has one
519 * per texture, so apply it now ready to be used!
521 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
522 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ i
));
523 checkGLcall("glActiveTextureARB");
525 FIXME("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
528 glTexEnvfv(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_COLOR
, &col
[0]);
529 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
532 GL_EXTCALL(glCombinerParameterfvNV(GL_CONSTANT_COLOR0_NV
, &col
[0]));
537 renderstate_stencil_twosided(IWineD3DStateBlockImpl
*stateblock
, GLint face
, GLint func
, GLint ref
, GLuint mask
, GLint stencilFail
, GLint depthFail
, GLint stencilPass
) {
538 #if 0 /* Don't use OpenGL 2.0 calls for now */
539 if(GL_EXTCALL(glStencilFuncSeparate
) && GL_EXTCALL(glStencilOpSeparate
)) {
540 GL_EXTCALL(glStencilFuncSeparate(face
, func
, ref
, mask
));
541 checkGLcall("glStencilFuncSeparate(...)");
542 GL_EXTCALL(glStencilOpSeparate(face
, stencilFail
, depthFail
, stencilPass
));
543 checkGLcall("glStencilOpSeparate(...)");
547 if(GL_SUPPORT(EXT_STENCIL_TWO_SIDE
)) {
548 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
549 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
550 GL_EXTCALL(glActiveStencilFaceEXT(face
));
551 checkGLcall("glActiveStencilFaceEXT(...)");
552 glStencilFunc(func
, ref
, mask
);
553 checkGLcall("glStencilFunc(...)");
554 glStencilOp(stencilFail
, depthFail
, stencilPass
);
555 checkGLcall("glStencilOp(...)");
556 } else if(GL_SUPPORT(ATI_SEPARATE_STENCIL
)) {
557 GL_EXTCALL(glStencilFuncSeparateATI(face
, func
, ref
, mask
));
558 checkGLcall("glStencilFuncSeparateATI(...)");
559 GL_EXTCALL(glStencilOpSeparateATI(face
, stencilFail
, depthFail
, stencilPass
));
560 checkGLcall("glStencilOpSeparateATI(...)");
562 ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
567 state_stencil(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
568 DWORD onesided_enable
= FALSE
;
569 DWORD twosided_enable
= FALSE
;
570 GLint func
= GL_ALWAYS
;
571 GLint func_ccw
= GL_ALWAYS
;
574 GLint stencilFail
= GL_KEEP
;
575 GLint depthFail
= GL_KEEP
;
576 GLint stencilPass
= GL_KEEP
;
577 GLint stencilFail_ccw
= GL_KEEP
;
578 GLint depthFail_ccw
= GL_KEEP
;
579 GLint stencilPass_ccw
= GL_KEEP
;
581 if( stateblock
->set
.renderState
[WINED3DRS_STENCILENABLE
] )
582 onesided_enable
= stateblock
->renderState
[WINED3DRS_STENCILENABLE
];
583 if( stateblock
->set
.renderState
[WINED3DRS_TWOSIDEDSTENCILMODE
] )
584 twosided_enable
= stateblock
->renderState
[WINED3DRS_TWOSIDEDSTENCILMODE
];
585 if( stateblock
->set
.renderState
[WINED3DRS_STENCILFUNC
] )
586 if( !( func
= CompareFunc(stateblock
->renderState
[WINED3DRS_STENCILFUNC
]) ) )
588 if( stateblock
->set
.renderState
[WINED3DRS_CCW_STENCILFUNC
] )
589 if( !( func_ccw
= CompareFunc(stateblock
->renderState
[WINED3DRS_CCW_STENCILFUNC
]) ) )
591 if( stateblock
->set
.renderState
[WINED3DRS_STENCILREF
] )
592 ref
= stateblock
->renderState
[WINED3DRS_STENCILREF
];
593 if( stateblock
->set
.renderState
[WINED3DRS_STENCILMASK
] )
594 mask
= stateblock
->renderState
[WINED3DRS_STENCILMASK
];
595 if( stateblock
->set
.renderState
[WINED3DRS_STENCILFAIL
] )
596 stencilFail
= StencilOp(stateblock
->renderState
[WINED3DRS_STENCILFAIL
]);
597 if( stateblock
->set
.renderState
[WINED3DRS_STENCILZFAIL
] )
598 depthFail
= StencilOp(stateblock
->renderState
[WINED3DRS_STENCILZFAIL
]);
599 if( stateblock
->set
.renderState
[WINED3DRS_STENCILPASS
] )
600 stencilPass
= StencilOp(stateblock
->renderState
[WINED3DRS_STENCILPASS
]);
601 if( stateblock
->set
.renderState
[WINED3DRS_CCW_STENCILFAIL
] )
602 stencilFail_ccw
= StencilOp(stateblock
->renderState
[WINED3DRS_CCW_STENCILFAIL
]);
603 if( stateblock
->set
.renderState
[WINED3DRS_CCW_STENCILZFAIL
] )
604 depthFail_ccw
= StencilOp(stateblock
->renderState
[WINED3DRS_CCW_STENCILZFAIL
]);
605 if( stateblock
->set
.renderState
[WINED3DRS_CCW_STENCILPASS
] )
606 stencilPass_ccw
= StencilOp(stateblock
->renderState
[WINED3DRS_CCW_STENCILPASS
]);
608 TRACE("(onesided %d, twosided %d, ref %x, mask %x, \
609 GL_FRONT: func: %x, fail %x, zfail %x, zpass %x \
610 GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
611 onesided_enable
, twosided_enable
, ref
, mask
,
612 func
, stencilFail
, depthFail
, stencilPass
,
613 func_ccw
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
615 if (twosided_enable
) {
616 renderstate_stencil_twosided(stateblock
, GL_FRONT
, func
, ref
, mask
, stencilFail
, depthFail
, stencilPass
);
617 renderstate_stencil_twosided(stateblock
, GL_BACK
, func_ccw
, ref
, mask
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
619 if (onesided_enable
) {
620 glEnable(GL_STENCIL_TEST
);
621 checkGLcall("glEnable GL_STENCIL_TEST");
622 glStencilFunc(func
, ref
, mask
);
623 checkGLcall("glStencilFunc(...)");
624 glStencilOp(stencilFail
, depthFail
, stencilPass
);
625 checkGLcall("glStencilOp(...)");
627 glDisable(GL_STENCIL_TEST
);
628 checkGLcall("glDisable GL_STENCIL_TEST");
633 static void state_stencilwrite(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
634 glStencilMask(stateblock
->renderState
[WINED3DRS_STENCILWRITEMASK
]);
635 checkGLcall("glStencilMask");
638 static void state_fog(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
639 /* TODO: Put this into the vertex type block once that is in the state table */
640 BOOL fogenable
= stateblock
->renderState
[WINED3DRS_FOGENABLE
];
641 float fogstart
, fogend
;
649 /* No fog? Disable it, and we're done :-) */
651 checkGLcall("glDisable GL_FOG");
654 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_FOGSTART
];
655 fogstart
= tmpvalue
.f
;
656 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_FOGEND
];
659 /* Activate when vertex shaders are in the state table */
660 if(stateblock
->vertexShader
&& ((IWineD3DVertexShaderImpl
*)stateblock
->vertexShader
)->baseShader
.function
&&
661 ((IWineD3DVertexShaderImpl
*)stateblock
->vertexShader
)->usesFog
) {
662 glFogi(GL_FOG_MODE
, GL_LINEAR
);
663 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
666 stateblock
->wineD3DDevice
->last_was_foggy_shader
= TRUE
;
668 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
669 * the system will apply only pixel(=table) fog effects."
671 else if(stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
] == D3DFOG_NONE
) {
672 glHint(GL_FOG_HINT
, GL_FASTEST
);
673 checkGLcall("glHint(GL_FOG_HINT, GL_FASTEST)");
674 stateblock
->wineD3DDevice
->last_was_foggy_shader
= FALSE
;
676 switch (stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]) {
677 /* Processed vertices have their fog factor stored in the specular value. Fall too the none case.
678 * If we are drawing untransformed vertices atm, d3ddevice_set_ortho will update the fog
681 if(!stateblock
->wineD3DDevice
->last_was_rhw
) {
682 glFogi(GL_FOG_MODE
, GL_EXP
);
683 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
684 if(GL_SUPPORT(EXT_FOG_COORD
)) {
685 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
686 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
692 if(!stateblock
->wineD3DDevice
->last_was_rhw
) {
693 glFogi(GL_FOG_MODE
, GL_EXP2
);
694 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
695 if(GL_SUPPORT(EXT_FOG_COORD
)) {
696 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
697 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
702 case D3DFOG_LINEAR
: {
703 if(!stateblock
->wineD3DDevice
->last_was_rhw
) {
704 glFogi(GL_FOG_MODE
, GL_LINEAR
);
705 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
706 if(GL_SUPPORT(EXT_FOG_COORD
)) {
707 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
708 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
714 /* Both are none? According to msdn the alpha channel of the specular
715 * color contains a fog factor. Set it in drawStridedSlow.
716 * Same happens with Vertexfog on transformed vertices
718 if(GL_SUPPORT(EXT_FOG_COORD
)) {
719 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FOG_COORDINATE_EXT
);
720 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)\n");
721 glFogi(GL_FOG_MODE
, GL_LINEAR
);
722 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
726 /* Disable GL fog, handle this in software in drawStridedSlow */
731 default: FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %d\n", stateblock
->renderState
[WINED3DRS_FOGVERTEXMODE
]);
734 glHint(GL_FOG_HINT
, GL_NICEST
);
735 checkGLcall("glHint(GL_FOG_HINT, GL_NICEST)");
736 stateblock
->wineD3DDevice
->last_was_foggy_shader
= FALSE
;
738 switch (stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]) {
740 glFogi(GL_FOG_MODE
, GL_EXP
);
741 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP");
742 if(GL_SUPPORT(EXT_FOG_COORD
)) {
743 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
744 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
749 glFogi(GL_FOG_MODE
, GL_EXP2
);
750 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2");
751 if(GL_SUPPORT(EXT_FOG_COORD
)) {
752 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
753 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
758 glFogi(GL_FOG_MODE
, GL_LINEAR
);
759 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR");
760 if(GL_SUPPORT(EXT_FOG_COORD
)) {
761 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
762 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT");
766 case D3DFOG_NONE
: /* Won't happen */
768 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %d\n", stateblock
->renderState
[WINED3DRS_FOGTABLEMODE
]);
774 checkGLcall("glEnable GL_FOG");
776 glFogfv(GL_FOG_START
, &fogstart
);
777 checkGLcall("glFogf(GL_FOG_START, fogstart");
778 TRACE("Fog Start == %f\n", fogstart
);
780 glFogfv(GL_FOG_END
, &fogend
);
781 checkGLcall("glFogf(GL_FOG_END, fogend");
782 TRACE("Fog End == %f\n", fogend
);
785 checkGLcall("glDisable GL_FOG");
788 if (GL_SUPPORT(NV_FOG_DISTANCE
)) {
789 glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
793 static void state_fogcolor(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
795 D3DCOLORTOGLFLOAT4(stateblock
->renderState
[WINED3DRS_FOGCOLOR
], col
);
796 /* Set the default alpha blend color */
797 glFogfv(GL_FOG_COLOR
, &col
[0]);
798 checkGLcall("glFog GL_FOG_COLOR");
801 static void state_fogdensity(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
806 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_FOGDENSITY
];
807 glFogfv(GL_FOG_DENSITY
, &tmpvalue
.f
);
808 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
811 /* TODO: Merge with primitive type + init_materials()!! */
812 static void state_colormat(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
813 GLenum Parm
= GL_AMBIENT_AND_DIFFUSE
;
815 if (stateblock
->renderState
[WINED3DRS_COLORVERTEX
]) {
816 TRACE("diff %d, amb %d, emis %d, spec %d\n",
817 stateblock
->renderState
[WINED3DRS_DIFFUSEMATERIALSOURCE
],
818 stateblock
->renderState
[WINED3DRS_AMBIENTMATERIALSOURCE
],
819 stateblock
->renderState
[WINED3DRS_EMISSIVEMATERIALSOURCE
],
820 stateblock
->renderState
[WINED3DRS_SPECULARMATERIALSOURCE
]);
822 if (stateblock
->renderState
[WINED3DRS_DIFFUSEMATERIALSOURCE
] == D3DMCS_COLOR1
) {
823 if (stateblock
->renderState
[WINED3DRS_AMBIENTMATERIALSOURCE
] == D3DMCS_COLOR1
) {
824 Parm
= GL_AMBIENT_AND_DIFFUSE
;
828 } else if (stateblock
->renderState
[WINED3DRS_AMBIENTMATERIALSOURCE
] == D3DMCS_COLOR1
) {
830 } else if (stateblock
->renderState
[WINED3DRS_EMISSIVEMATERIALSOURCE
] == D3DMCS_COLOR1
) {
832 } else if (stateblock
->renderState
[WINED3DRS_SPECULARMATERIALSOURCE
] == D3DMCS_COLOR1
) {
839 if (stateblock
->wineD3DDevice
->tracking_color
!= DISABLED_TRACKING
) stateblock
->wineD3DDevice
->tracking_color
= NEEDS_DISABLE
;
841 stateblock
->wineD3DDevice
->tracking_color
= NEEDS_TRACKING
;
842 stateblock
->wineD3DDevice
->tracking_parm
= Parm
;
846 if (stateblock
->wineD3DDevice
->tracking_color
!= DISABLED_TRACKING
) stateblock
->wineD3DDevice
->tracking_color
= NEEDS_DISABLE
;
850 static void state_linepattern(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
853 WINED3DLINEPATTERN lp
;
855 tmppattern
.d
= stateblock
->renderState
[WINED3DRS_LINEPATTERN
];
857 TRACE("Line pattern: repeat %d bits %x\n", tmppattern
.lp
.wRepeatFactor
, tmppattern
.lp
.wLinePattern
);
859 if (tmppattern
.lp
.wRepeatFactor
) {
860 glLineStipple(tmppattern
.lp
.wRepeatFactor
, tmppattern
.lp
.wLinePattern
);
861 checkGLcall("glLineStipple(repeat, linepattern)");
862 glEnable(GL_LINE_STIPPLE
);
863 checkGLcall("glEnable(GL_LINE_STIPPLE);");
865 glDisable(GL_LINE_STIPPLE
);
866 checkGLcall("glDisable(GL_LINE_STIPPLE);");
870 static void state_zbias(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
876 if (stateblock
->renderState
[WINED3DRS_ZBIAS
]) {
877 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_ZBIAS
];
878 TRACE("ZBias value %f\n", tmpvalue
.f
);
879 glPolygonOffset(0, -tmpvalue
.f
);
880 checkGLcall("glPolygonOffset(0, -Value)");
881 glEnable(GL_POLYGON_OFFSET_FILL
);
882 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
883 glEnable(GL_POLYGON_OFFSET_LINE
);
884 checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
885 glEnable(GL_POLYGON_OFFSET_POINT
);
886 checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
888 glDisable(GL_POLYGON_OFFSET_FILL
);
889 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
890 glDisable(GL_POLYGON_OFFSET_LINE
);
891 checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
892 glDisable(GL_POLYGON_OFFSET_POINT
);
893 checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
898 static void state_normalize(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
899 if (stateblock
->renderState
[WINED3DRS_NORMALIZENORMALS
]) {
900 glEnable(GL_NORMALIZE
);
901 checkGLcall("glEnable(GL_NORMALIZE);");
903 glDisable(GL_NORMALIZE
);
904 checkGLcall("glDisable(GL_NORMALIZE);");
908 static void state_psize(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
914 /* FIXME: check that pointSize isn't outside glGetFloatv( GL_POINT_SIZE_MAX_ARB, &maxSize ); or -ve */
915 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_POINTSIZE
];
916 TRACE("Set point size to %f\n", tmpvalue
.f
);
917 glPointSize(tmpvalue
.f
);
918 checkGLcall("glPointSize(...);");
921 static void state_psizemin(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
927 if(GL_SUPPORT(ARB_POINT_PARAMETERS
)) {
928 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_POINTSIZE_MIN
];
929 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MIN_ARB
, tmpvalue
.f
);
930 checkGLcall("glPointParameterfARB(...");
932 else if(GL_SUPPORT(EXT_POINT_PARAMETERS
)) {
933 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_POINTSIZE_MIN
];
934 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MIN_EXT
, tmpvalue
.f
);
935 checkGLcall("glPointParameterfEXT(...);");
937 FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl\n");
941 static void state_psizemax(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
947 if(GL_SUPPORT(ARB_POINT_PARAMETERS
)) {
948 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_POINTSIZE_MAX
];
949 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MAX_ARB
, tmpvalue
.f
);
950 checkGLcall("glPointParameterfARB(...");
952 else if(GL_SUPPORT(EXT_POINT_PARAMETERS
)) {
953 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_POINTSIZE_MAX
];
954 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MAX_EXT
, tmpvalue
.f
);
955 checkGLcall("glPointParameterfEXT(...);");
957 FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl\n");
961 static void state_pscale(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
962 /* TODO: Group this with the viewport */
964 * POINTSCALEENABLE controls how point size value is treated. If set to
965 * true, the point size is scaled with respect to height of viewport.
966 * When set to false point size is in pixels.
968 * http://msdn.microsoft.com/library/en-us/directx9_c/point_sprites.asp
972 GLfloat att
[3] = {1.0f
, 0.0f
, 0.0f
};
975 * Minimum valid point size for OpenGL is 1.0f. For Direct3D it is 0.0f.
976 * This means that OpenGL will clamp really small point sizes to 1.0f.
977 * To correct for this we need to multiply by the scale factor when sizes
978 * are less than 1.0f. scale_factor = 1.0f / point_size.
980 GLfloat pointSize
= *((float*)&stateblock
->renderState
[WINED3DRS_POINTSIZE
]);
981 if(pointSize
> 0.0f
) {
984 if(pointSize
< 1.0f
) {
985 scaleFactor
= pointSize
* pointSize
;
990 if(stateblock
->renderState
[WINED3DRS_POINTSCALEENABLE
]) {
991 att
[0] = *((float*)&stateblock
->renderState
[WINED3DRS_POINTSCALE_A
]) /
992 (stateblock
->viewport
.Height
* stateblock
->viewport
.Height
* scaleFactor
);
993 att
[1] = *((float*)&stateblock
->renderState
[WINED3DRS_POINTSCALE_B
]) /
994 (stateblock
->viewport
.Height
* stateblock
->viewport
.Height
* scaleFactor
);
995 att
[2] = *((float*)&stateblock
->renderState
[WINED3DRS_POINTSCALE_C
]) /
996 (stateblock
->viewport
.Height
* stateblock
->viewport
.Height
* scaleFactor
);
1000 if(GL_SUPPORT(ARB_POINT_PARAMETERS
)) {
1001 GL_EXTCALL(glPointParameterfvARB
)(GL_POINT_DISTANCE_ATTENUATION_ARB
, att
);
1002 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...");
1004 else if(GL_SUPPORT(EXT_POINT_PARAMETERS
)) {
1005 GL_EXTCALL(glPointParameterfvEXT
)(GL_DISTANCE_ATTENUATION_EXT
, att
);
1006 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...");
1008 TRACE("POINT_PARAMETERS not supported in this version of opengl\n");
1012 static void state_colorwrite(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1013 DWORD Value
= stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE
];
1015 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1016 Value
& D3DCOLORWRITEENABLE_RED
? 1 : 0,
1017 Value
& D3DCOLORWRITEENABLE_GREEN
? 1 : 0,
1018 Value
& D3DCOLORWRITEENABLE_BLUE
? 1 : 0,
1019 Value
& D3DCOLORWRITEENABLE_ALPHA
? 1 : 0);
1020 glColorMask(Value
& D3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
1021 Value
& D3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
1022 Value
& D3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
1023 Value
& D3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
);
1024 checkGLcall("glColorMask(...)");
1026 /* depends on WINED3DRS_COLORWRITEENABLE. */
1027 if(stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE1
] != 0x0000000F ||
1028 stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE2
] != 0x0000000F ||
1029 stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE3
] != 0x0000000F ) {
1030 ERR("(WINED3DRS_COLORWRITEENABLE1/2/3,%d,%d,%d) not yet implemented. Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n",
1031 stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE1
],
1032 stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE2
],
1033 stateblock
->renderState
[WINED3DRS_COLORWRITEENABLE3
]);
1037 static void state_localviewer(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1038 if(stateblock
->renderState
[WINED3DRS_LOCALVIEWER
]) {
1039 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 1);
1040 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1042 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 0);
1043 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1047 static void state_lastpixel(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1048 if(stateblock
->renderState
[WINED3DRS_LASTPIXEL
]) {
1049 TRACE("Last Pixel Drawing Enabled\n");
1051 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1055 static void state_pointsprite(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1056 /* TODO: NV_POINT_SPRITE */
1057 if (!GL_SUPPORT(ARB_POINT_SPRITE
)) {
1058 TRACE("Point sprites not supported\n");
1062 if (stateblock
->renderState
[WINED3DRS_POINTSPRITEENABLE
]) {
1063 glEnable(GL_POINT_SPRITE_ARB
);
1064 checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1065 glTexEnvf(GL_POINT_SPRITE_ARB
, GL_COORD_REPLACE_ARB
, TRUE
);
1066 checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, TRUE)");
1068 glDisable(GL_POINT_SPRITE_ARB
);
1069 checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1070 glTexEnvf(GL_POINT_SPRITE_ARB
, GL_COORD_REPLACE_ARB
, FALSE
);
1071 checkGLcall("glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, FALSE)");
1075 static void state_wrap(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1077 http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1078 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c/directx/graphics/programmingguide/FixedFunction/Textures/texturewrapping.asp
1079 http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1080 Descussion that ways to turn on WRAPing to solve an opengl conversion problem.
1081 http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1083 so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1086 if(stateblock
->renderState
[WINED3DRS_WRAP0
] ||
1087 stateblock
->renderState
[WINED3DRS_WRAP1
] ||
1088 stateblock
->renderState
[WINED3DRS_WRAP2
] ||
1089 stateblock
->renderState
[WINED3DRS_WRAP3
] ||
1090 stateblock
->renderState
[WINED3DRS_WRAP4
] ||
1091 stateblock
->renderState
[WINED3DRS_WRAP5
] ||
1092 stateblock
->renderState
[WINED3DRS_WRAP6
] ||
1093 stateblock
->renderState
[WINED3DRS_WRAP7
] ||
1094 stateblock
->renderState
[WINED3DRS_WRAP8
] ||
1095 stateblock
->renderState
[WINED3DRS_WRAP9
] ||
1096 stateblock
->renderState
[WINED3DRS_WRAP10
] ||
1097 stateblock
->renderState
[WINED3DRS_WRAP11
] ||
1098 stateblock
->renderState
[WINED3DRS_WRAP12
] ||
1099 stateblock
->renderState
[WINED3DRS_WRAP13
] ||
1100 stateblock
->renderState
[WINED3DRS_WRAP14
] ||
1101 stateblock
->renderState
[WINED3DRS_WRAP15
] ) {
1102 ERR("(WINED3DRS_WRAP0) Texture wraping not yet supported\n");
1106 static void state_multisampleaa(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1107 if( GL_SUPPORT(ARB_MULTISAMPLE
) ) {
1108 if(stateblock
->renderState
[WINED3DRS_MULTISAMPLEANTIALIAS
]) {
1109 glEnable(GL_MULTISAMPLE_ARB
);
1110 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1112 glDisable(GL_MULTISAMPLE_ARB
);
1113 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1116 if(stateblock
->renderState
[WINED3DRS_MULTISAMPLEANTIALIAS
]) {
1117 ERR("Multisample antialiasing not supported by gl\n");
1122 static void state_scissor(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1123 if(stateblock
->renderState
[WINED3DRS_SCISSORTESTENABLE
]) {
1124 glEnable(GL_SCISSOR_TEST
);
1125 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1127 glDisable(GL_SCISSOR_TEST
);
1128 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1132 static void state_depthbias(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1138 if(stateblock
->renderState
[WINED3DRS_SLOPESCALEDEPTHBIAS
] ||
1139 stateblock
->renderState
[WINED3DRS_DEPTHBIAS
]) {
1140 tmpvalue
.d
= stateblock
->renderState
[WINED3DRS_SLOPESCALEDEPTHBIAS
];
1141 glEnable(GL_POLYGON_OFFSET_FILL
);
1142 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1143 glPolygonOffset(tmpvalue
.f
, *((float*)&stateblock
->renderState
[WINED3DRS_DEPTHBIAS
]));
1144 checkGLcall("glPolygonOffset(...)");
1146 glDisable(GL_POLYGON_OFFSET_FILL
);
1147 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1151 static void state_perspective(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1152 if (stateblock
->renderState
[WINED3DRS_TEXTUREPERSPECTIVE
]) {
1153 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_NICEST
);
1154 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1156 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_FASTEST
);
1157 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1161 static void state_stippledalpha(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1163 if (stateblock
->renderState
[WINED3DRS_STIPPLEDALPHA
])
1164 ERR(" Stippled Alpha not supported yet.\n");
1167 static void state_antialias(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1169 if (stateblock
->renderState
[WINED3DRS_ANTIALIAS
])
1170 ERR(" Antialias not supported yet.\n");
1173 static void state_multisampmask(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1175 if (stateblock
->renderState
[WINED3DRS_MULTISAMPLEMASK
] != 0xFFFFFFFF)
1176 ERR("(WINED3DRS_MULTISAMPLEMASK,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_MULTISAMPLEMASK
]);
1179 static void state_patchedgestyle(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1181 if (stateblock
->renderState
[WINED3DRS_PATCHEDGESTYLE
] != D3DPATCHEDGE_DISCRETE
)
1182 ERR("(WINED3DRS_PATCHEDGESTYLE,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_PATCHEDGESTYLE
]);
1185 static void state_patchsegments(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1193 if (stateblock
->renderState
[WINED3DRS_PATCHSEGMENTS
] != tmpvalue
.d
)
1194 ERR("(WINED3DRS_PATCHSEGMENTS,%d) not yet implemented\n", tmpvalue
.d
);
1197 static void state_positiondegree(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1199 if (stateblock
->renderState
[WINED3DRS_POSITIONDEGREE
] != D3DDEGREE_CUBIC
)
1200 ERR("(WINED3DRS_POSITIONDEGREE,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_POSITIONDEGREE
]);
1203 static void state_normaldegree(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1205 if (stateblock
->renderState
[WINED3DRS_NORMALDEGREE
] != D3DDEGREE_LINEAR
)
1206 ERR("(WINED3DRS_NORMALDEGREE,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_NORMALDEGREE
]);
1209 static void state_tessellation(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1211 if(stateblock
->renderState
[WINED3DRS_ENABLEADAPTIVETESSELLATION
])
1212 FIXME("(WINED3DRS_ENABLEADAPTIVETESSELLATION,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_ENABLEADAPTIVETESSELLATION
]);
1216 static void state_srgbwrite(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1217 if(stateblock
->renderState
[WINED3DRS_SRGBWRITEENABLE
])
1218 ERR("Render state WINED3DRS_SRGBWRITEENABLE not yet implemented\n");
1221 static void state_seperateblend(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1223 if(stateblock
->renderState
[WINED3DRS_SEPARATEALPHABLENDENABLE
])
1224 FIXME("(WINED3DRS_SEPARATEALPHABLENDENABLE,%d) not yet implemented\n", stateblock
->renderState
[WINED3DRS_SEPARATEALPHABLENDENABLE
]);
1227 static void state_wrapu(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1228 if(stateblock
->renderState
[WINED3DRS_WRAPU
]) {
1229 FIXME("Render state WINED3DRS_WRAPU not implemented yet\n");
1233 static void state_wrapv(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1234 if(stateblock
->renderState
[WINED3DRS_WRAPV
]) {
1235 FIXME("Render state WINED3DRS_WRAPV not implemented yet\n");
1239 static void state_monoenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1240 if(stateblock
->renderState
[WINED3DRS_MONOENABLE
]) {
1241 FIXME("Render state WINED3DRS_MONOENABLE not implemented yet\n");
1245 static void state_rop2(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1246 if(stateblock
->renderState
[WINED3DRS_ROP2
]) {
1247 FIXME("Render state WINED3DRS_ROP2 not implemented yet\n");
1251 static void state_planemask(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1252 if(stateblock
->renderState
[WINED3DRS_PLANEMASK
]) {
1253 FIXME("Render state WINED3DRS_PLANEMASK not implemented yet\n");
1257 static void state_subpixel(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1258 if(stateblock
->renderState
[WINED3DRS_SUBPIXEL
]) {
1259 FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet\n");
1263 static void state_subpixelx(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1264 if(stateblock
->renderState
[WINED3DRS_SUBPIXELX
]) {
1265 FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet\n");
1269 static void state_stippleenable(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1270 if(stateblock
->renderState
[WINED3DRS_STIPPLEENABLE
]) {
1271 FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet\n");
1275 static void state_bordercolor(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1276 if(stateblock
->renderState
[WINED3DRS_BORDERCOLOR
]) {
1277 FIXME("Render state WINED3DRS_BORDERCOLOR not implemented yet\n");
1281 static void state_mipmaplodbias(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1282 if(stateblock
->renderState
[WINED3DRS_MIPMAPLODBIAS
]) {
1283 FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet\n");
1287 static void state_anisotropy(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1288 if(stateblock
->renderState
[WINED3DRS_ANISOTROPY
]) {
1289 FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet\n");
1293 static void state_flushbatch(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1294 if(stateblock
->renderState
[WINED3DRS_FLUSHBATCH
]) {
1295 FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet\n");
1299 static void state_translucentsi(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1300 if(stateblock
->renderState
[WINED3DRS_TRANSLUCENTSORTINDEPENDENT
]) {
1301 FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet\n");
1305 static void state_extents(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1306 if(stateblock
->renderState
[WINED3DRS_EXTENTS
]) {
1307 FIXME("Render state WINED3DRS_EXTENTS not implemented yet\n");
1311 static void state_ckeyblend(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1312 if(stateblock
->renderState
[WINED3DRS_COLORKEYBLENDENABLE
]) {
1313 FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet\n");
1317 /* Activates the texture dimension according to the bound D3D texture.
1318 * Does not care for the colorop or correct gl texture unit(when using nvrc)
1319 * Requires the caller to activate the correct unit before
1321 static void activate_dimensions(DWORD stage
, IWineD3DStateBlockImpl
*stateblock
) {
1322 if(stateblock
->textures
[stage
]) {
1323 glDisable(GL_TEXTURE_1D
);
1324 checkGLcall("glDisable(GL_TEXTURE_1D)");
1325 switch(stateblock
->textureDimensions
[stage
]) {
1327 glDisable(GL_TEXTURE_3D
);
1328 checkGLcall("glDisable(GL_TEXTURE_3D)");
1329 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1330 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1331 glEnable(GL_TEXTURE_2D
);
1332 checkGLcall("glEnable(GL_TEXTURE_2D)");
1335 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1336 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1337 glDisable(GL_TEXTURE_2D
);
1338 checkGLcall("glDisable(GL_TEXTURE_2D)");
1339 glEnable(GL_TEXTURE_3D
);
1340 checkGLcall("glEnable(GL_TEXTURE_3D)");
1342 case GL_TEXTURE_CUBE_MAP_ARB
:
1343 glDisable(GL_TEXTURE_2D
);
1344 checkGLcall("glDisable(GL_TEXTURE_2D)");
1345 glDisable(GL_TEXTURE_3D
);
1346 checkGLcall("glDisable(GL_TEXTURE_3D)");
1347 glEnable(GL_TEXTURE_CUBE_MAP_ARB
);
1348 checkGLcall("glEnable(GL_TEXTURE_CUBE_MAP_ARB)");
1352 glDisable(GL_TEXTURE_2D
);
1353 checkGLcall("glDisable(GL_TEXTURE_2D)");
1354 glDisable(GL_TEXTURE_3D
);
1355 checkGLcall("glDisable(GL_TEXTURE_3D)");
1356 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1357 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1358 glEnable(GL_TEXTURE_1D
);
1359 checkGLcall("glEnable(GL_TEXTURE_1D)");
1360 /* Binding textures is done by samplers. A dummy texture will be bound */
1364 static void tex_colorop(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1365 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1367 TRACE("Setting color op for stage %d\n", stage
);
1369 if (stateblock
->pixelShader
&& stateblock
->wineD3DDevice
->ps_selected_mode
!= SHADER_NONE
&&
1370 ((IWineD3DPixelShaderImpl
*)stateblock
->pixelShader
)->baseShader
.function
) {
1371 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
1375 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1376 /* TODO: register combiners! */
1377 if(stage
!= stateblock
->wineD3DDevice
->texUnitMap
[stage
]) ERR("Foo: %d is %d!\n", stage
, stateblock
->wineD3DDevice
->texUnitMap
[stage
]);
1378 if(stateblock
->wineD3DDevice
->texUnitMap
[stage
] >= GL_LIMITS(sampler_stages
)) {
1379 if(stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
] != WINED3DTOP_DISABLE
&&
1380 stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
] != 0) {
1381 FIXME("Attempt to enable unsupported stage!\n");
1385 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ stateblock
->wineD3DDevice
->texUnitMap
[stage
]));
1386 checkGLcall("glActiveTextureARB");
1387 } else if (stage
> 0) {
1388 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1392 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
1393 if(stateblock
->lowest_disabled_stage
> 0) {
1394 glEnable(GL_REGISTER_COMBINERS_NV
);
1395 GL_EXTCALL(glCombinerParameteriNV(GL_NUM_GENERAL_COMBINERS_NV
, stateblock
->lowest_disabled_stage
));
1397 glDisable(GL_REGISTER_COMBINERS_NV
);
1400 if(stage
>= stateblock
->lowest_disabled_stage
) {
1401 TRACE("Stage disabled\n");
1402 /* Disable everything here */
1403 glDisable(GL_TEXTURE_1D
);
1404 checkGLcall("glDisable(GL_TEXTURE_1D)");
1405 glDisable(GL_TEXTURE_2D
);
1406 checkGLcall("glDisable(GL_TEXTURE_2D)");
1407 glDisable(GL_TEXTURE_3D
);
1408 checkGLcall("glDisable(GL_TEXTURE_3D)");
1409 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
1410 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
1415 activate_dimensions(stage
, stateblock
);
1417 /* Set the texture combiners */
1418 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
1419 set_tex_op_nvrc((IWineD3DDevice
*)stateblock
->wineD3DDevice
, FALSE
, stage
,
1420 stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
],
1421 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG1
],
1422 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG2
],
1423 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG0
],
1424 stateblock
->wineD3DDevice
->texUnitMap
[stage
]);
1426 set_tex_op((IWineD3DDevice
*)stateblock
->wineD3DDevice
, FALSE
, stage
,
1427 stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
],
1428 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG1
],
1429 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG2
],
1430 stateblock
->textureState
[stage
][WINED3DTSS_COLORARG0
]);
1434 static void tex_alphaop(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1435 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1437 TRACE("Setting alpha op for stage %d\n", stage
);
1438 /* Do not care for enabled / disabled stages, just assign the settigns. colorop disables / enables required stuff */
1439 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1440 /* TODO: register combiners! */
1441 if(stage
>= GL_LIMITS(sampler_stages
)) {
1442 if(stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
] != WINED3DTOP_DISABLE
&&
1443 stateblock
->textureState
[stage
][WINED3DTSS_COLOROP
] != 0) {
1444 FIXME("Attempt to enable unsupported stage!\n");
1448 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ stateblock
->wineD3DDevice
->texUnitMap
[stage
]));
1449 checkGLcall("glActiveTextureARB");
1450 } else if (stage
> 0) {
1451 /* We can't do anything here */
1452 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1456 TRACE("Setting alpha op for stage %d\n", stage
);
1457 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
1458 set_tex_op_nvrc((IWineD3DDevice
*)stateblock
->wineD3DDevice
, TRUE
, stage
,
1459 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAOP
],
1460 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG1
],
1461 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG2
],
1462 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG0
],
1463 stateblock
->wineD3DDevice
->texUnitMap
[stage
]);
1465 set_tex_op((IWineD3DDevice
*)stateblock
->wineD3DDevice
, TRUE
, stage
, stateblock
->textureState
[stage
][WINED3DTSS_ALPHAOP
],
1466 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG1
],
1467 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG2
],
1468 stateblock
->textureState
[stage
][WINED3DTSS_ALPHAARG0
]);
1472 static void transform_texture(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1473 DWORD texUnit
= state
- STATE_TRANSFORM(WINED3DTS_TEXTURE0
);
1475 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1476 if(texUnit
>= GL_LIMITS(sampler_stages
)) {
1479 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ stateblock
->wineD3DDevice
->texUnitMap
[texUnit
]));
1480 checkGLcall("glActiveTextureARB");
1481 } else if (texUnit
> 0) {
1482 /* We can't do anything here */
1483 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1487 set_texture_matrix((float *)&stateblock
->transforms
[WINED3DTS_TEXTURE0
+ texUnit
].u
.m
[0][0],
1488 stateblock
->textureState
[texUnit
][WINED3DTSS_TEXTURETRANSFORMFLAGS
],
1489 (stateblock
->textureState
[texUnit
][WINED3DTSS_TEXCOORDINDEX
] & 0xFFFF0000) != WINED3DTSS_TCI_PASSTHRU
);
1493 static void tex_coordindex(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1494 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1496 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1497 /* TODO: register combiners! */
1498 if(stage
>= GL_LIMITS(sampler_stages
)) {
1501 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ stateblock
->wineD3DDevice
->texUnitMap
[stage
]));
1502 checkGLcall("glActiveTextureARB");
1503 } else if (stage
> 0) {
1504 /* We can't do anything here */
1505 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1509 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
1511 * FIXME: From MSDN: The WINED3DTSS_TCI_* flags are mutually exclusive. If you include
1512 * one flag, you can still specify an index value, which the system uses to
1513 * determine the texture wrapping mode.
1514 * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
1515 * means use the vertex position (camera-space) as the input texture coordinates
1516 * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
1517 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
1518 * to the TEXCOORDINDEX value
1522 * Be careful the value of the mask 0xF0000 come from d3d8types.h infos
1524 switch (stateblock
->textureState
[stage
][WINED3DTSS_TEXCOORDINDEX
] & 0xFFFF0000) {
1525 case WINED3DTSS_TCI_PASSTHRU
:
1526 /*Use the specified texture coordinates contained within the vertex format. This value resolves to zero.*/
1527 glDisable(GL_TEXTURE_GEN_S
);
1528 glDisable(GL_TEXTURE_GEN_T
);
1529 glDisable(GL_TEXTURE_GEN_R
);
1530 glDisable(GL_TEXTURE_GEN_Q
);
1531 checkGLcall("glDisable(GL_TEXTURE_GEN_S,T,R,Q)");
1534 case WINED3DTSS_TCI_CAMERASPACEPOSITION
:
1535 /* CameraSpacePosition means use the vertex position, transformed to camera space,
1536 * as the input texture coordinates for this stage's texture transformation. This
1537 * equates roughly to EYE_LINEAR
1540 float s_plane
[] = { 1.0, 0.0, 0.0, 0.0 };
1541 float t_plane
[] = { 0.0, 1.0, 0.0, 0.0 };
1542 float r_plane
[] = { 0.0, 0.0, 1.0, 0.0 };
1543 float q_plane
[] = { 0.0, 0.0, 0.0, 1.0 };
1544 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane\n");
1546 glMatrixMode(GL_MODELVIEW
);
1549 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
1550 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
1551 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
1552 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
1555 TRACE("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set GL_TEXTURE_GEN_x and GL_x, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR\n");
1556 glEnable(GL_TEXTURE_GEN_S
);
1557 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1558 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
1559 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1560 glEnable(GL_TEXTURE_GEN_T
);
1561 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1562 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
1563 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1564 glEnable(GL_TEXTURE_GEN_R
);
1565 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1566 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
1567 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)");
1571 case WINED3DTSS_TCI_CAMERASPACENORMAL
:
1573 if (GL_SUPPORT(NV_TEXGEN_REFLECTION
)) {
1574 float s_plane
[] = { 1.0, 0.0, 0.0, 0.0 };
1575 float t_plane
[] = { 0.0, 1.0, 0.0, 0.0 };
1576 float r_plane
[] = { 0.0, 0.0, 1.0, 0.0 };
1577 float q_plane
[] = { 0.0, 0.0, 0.0, 1.0 };
1578 TRACE("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane\n");
1580 glMatrixMode(GL_MODELVIEW
);
1583 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
1584 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
1585 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
1586 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
1589 glEnable(GL_TEXTURE_GEN_S
);
1590 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1591 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
1592 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1593 glEnable(GL_TEXTURE_GEN_T
);
1594 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1595 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
1596 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1597 glEnable(GL_TEXTURE_GEN_R
);
1598 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1599 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
1600 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV)");
1605 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
:
1607 if (GL_SUPPORT(NV_TEXGEN_REFLECTION
)) {
1608 float s_plane
[] = { 1.0, 0.0, 0.0, 0.0 };
1609 float t_plane
[] = { 0.0, 1.0, 0.0, 0.0 };
1610 float r_plane
[] = { 0.0, 0.0, 1.0, 0.0 };
1611 float q_plane
[] = { 0.0, 0.0, 0.0, 1.0 };
1612 TRACE("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane\n");
1614 glMatrixMode(GL_MODELVIEW
);
1617 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
1618 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
1619 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
1620 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
1623 glEnable(GL_TEXTURE_GEN_S
);
1624 checkGLcall("glEnable(GL_TEXTURE_GEN_S);");
1625 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
1626 checkGLcall("glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1627 glEnable(GL_TEXTURE_GEN_T
);
1628 checkGLcall("glEnable(GL_TEXTURE_GEN_T);");
1629 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
1630 checkGLcall("glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1631 glEnable(GL_TEXTURE_GEN_R
);
1632 checkGLcall("glEnable(GL_TEXTURE_GEN_R);");
1633 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
1634 checkGLcall("glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV)");
1639 /* Unhandled types: */
1642 /* ? disable GL_TEXTURE_GEN_n ? */
1643 glDisable(GL_TEXTURE_GEN_S
);
1644 glDisable(GL_TEXTURE_GEN_T
);
1645 glDisable(GL_TEXTURE_GEN_R
);
1646 glDisable(GL_TEXTURE_GEN_Q
);
1647 FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %x\n", stateblock
->textureState
[stage
][WINED3DTSS_TEXCOORDINDEX
]);
1651 /* Update the texture matrix */
1652 if(!isStateDirty(stateblock
->wineD3DDevice
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ stage
))) {
1653 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ stage
), stateblock
);
1657 static void tex_bumpenvlscale(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1658 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1664 tmpvalue
.d
= stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVLSCALE
];
1665 if(tmpvalue
.f
!= 0.0) {
1666 ERR("WINED3DTSS_BUMPENVLSCALE not supported yet\n");
1670 static void tex_bumpenvloffset(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1671 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1677 tmpvalue
.d
= stateblock
->textureState
[stage
][WINED3DTSS_BUMPENVLOFFSET
];
1678 if(tmpvalue
.f
!= 0.0) {
1679 ERR("WINED3DTSS_BUMPENVLOFFSET not supported yet\n");
1683 static void tex_resultarg(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1684 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / WINED3D_HIGHEST_TEXTURE_STATE
;
1686 if(stateblock
->textureState
[stage
][WINED3DTSS_RESULTARG
] != D3DTA_CURRENT
) {
1687 ERR("WINED3DTSS_RESULTARG not supported yet\n");
1691 static void sampler(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1692 DWORD sampler
= state
- STATE_SAMPLER(0);
1698 TRACE("Sampler: %d\n", sampler
);
1699 /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
1700 * only has to bind textures and set the per texture states
1702 if (GL_SUPPORT(ARB_MULTITEXTURE
)) {
1703 /* TODO: register combiners! */
1704 if(sampler
>= GL_LIMITS(sampler_stages
)) {
1707 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ stateblock
->wineD3DDevice
->texUnitMap
[sampler
]));
1708 checkGLcall("glActiveTextureARB");
1709 } else if (sampler
> 0) {
1710 /* We can't do anything here */
1711 WARN("Program using multiple concurrent textures which this opengl implementation doesn't support\n");
1715 if(stateblock
->textures
[sampler
]) {
1717 /* NP2 textures need the texture matrix set properly for the stage */
1718 if(wined3d_settings
.nonpower2_mode
== NP2_NATIVE
&& sampler
< MAX_TEXTURES
- 1 &&
1719 stateblock
->textureDimensions
[sampler
] == GL_TEXTURE_2D
&&
1720 (((IWineD3DTextureImpl
*) stateblock
->textures
[sampler
])->pow2scalingFactorX
!= 1.0 ||
1721 ((IWineD3DTextureImpl
*) stateblock
->textures
[sampler
])->pow2scalingFactorY
!= 1.0 ) ) {
1722 transform_texture(STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ stateblock
->wineD3DDevice
->texUnitMap
[sampler
]), stateblock
);
1725 IWineD3DBaseTexture_PreLoad((IWineD3DBaseTexture
*) stateblock
->textures
[sampler
]);
1726 IWineD3DBaseTexture_ApplyStateChanges(stateblock
->textures
[sampler
], stateblock
->textureState
[sampler
], stateblock
->samplerState
[sampler
]);
1728 if (GL_SUPPORT(EXT_TEXTURE_LOD_BIAS
)) {
1729 tmpvalue
.d
= stateblock
->samplerState
[sampler
][WINED3DSAMP_MIPMAPLODBIAS
];
1730 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT
,
1731 GL_TEXTURE_LOD_BIAS_EXT
,
1733 checkGLcall("glTexEnvi GL_TEXTURE_LOD_BIAS_EXT ...");
1736 if (stateblock
->wineD3DDevice
->ps_selected_mode
!= SHADER_NONE
&& stateblock
->pixelShader
&&
1737 ((IWineD3DPixelShaderImpl
*)stateblock
->pixelShader
)->baseShader
.function
) {
1738 /* Using a pixel shader? Verify the sampler types */
1740 /* Make sure that the texture dimensions are enabled. I don't have to disable the other
1741 * dimensions because the shader knows from which texture type to sample from. For the sake of
1742 * debugging all dimensions could be enabled and a texture with some ugly pink bound to the unused
1743 * dimensions. This should make wrong sampling sources visible :-)
1745 glEnable(stateblock
->textureDimensions
[sampler
]);
1746 checkGLcall("glEnable(stateblock->textureDimensions[sampler])");
1747 } else if(sampler
< stateblock
->lowest_disabled_stage
) {
1748 activate_dimensions(sampler
, stateblock
);
1750 if(stateblock
->renderState
[WINED3DRS_COLORKEYENABLE
] && sampler
== 0) {
1751 /* If color keying is enabled update the alpha test, it depends on the existance
1752 * of a color key in stage 0
1754 state_alpha(WINED3DRS_COLORKEYENABLE
, stateblock
);
1757 } else if(sampler
< GL_LIMITS(texture_stages
)) {
1758 if(sampler
< stateblock
->lowest_disabled_stage
) {
1759 /* TODO: Check if the colorop is dirty to do that job
1760 * TODO: What should I do with pixel shaders here ???
1762 activate_dimensions(sampler
, stateblock
);
1763 } /* Otherwise tex_colorop disables the stage */
1764 glBindTexture(GL_TEXTURE_1D
, stateblock
->wineD3DDevice
->dummyTextureName
[sampler
]);
1765 checkGLcall("glBindTexture(GL_TEXTURE_1D, stateblock->wineD3DDevice->dummyTextureName[sampler])");
1769 static void pixelshader(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1772 if(stateblock
->pixelShader
&& ((IWineD3DPixelShaderImpl
*) stateblock
->pixelShader
)->baseShader
.function
!= NULL
) {
1773 if(!stateblock
->wineD3DDevice
->last_was_pshader
) {
1774 /* Former draw without a pixel shader, some samplers
1775 * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
1776 * make sure to enable them
1778 for(i
=0; i
< MAX_SAMPLERS
; i
++) {
1779 if(!isStateDirty(stateblock
->wineD3DDevice
, STATE_SAMPLER(i
))) {
1780 sampler(STATE_SAMPLER(i
), stateblock
);
1784 /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
1785 * if a different texture was bound. I don't have to do anything.
1789 /* Compile and bind the shader */
1790 IWineD3DPixelShader_CompileShader(stateblock
->pixelShader
);
1793 /* Can't do that here right now, because glsl shaders depend on having both pixel and vertex shader
1794 * setup at the same time. The shader_select call will be done by drawprim until vertex shaders are
1795 * moved to the state table too
1797 stateblock
->wineD3DDevice
->shader_backend
->shader_select(
1798 (IWineD3DDevice
*) stateblock
->wineD3DDevice
,
1800 !stateblock
->vertexShader
? FALSE
: ((IWineD3DVertexShaderImpl
*) stateblock
->vertexShader
)->baseShader
.function
!= NULL
);
1802 stateblock
->wineD3DDevice
->last_was_pshader
= TRUE
;
1804 /* Disabled the pixel shader - color ops weren't applied
1805 * while it was enabled, so re-apply them.
1807 for(i
=0; i
< MAX_TEXTURES
; i
++) {
1808 if(!isStateDirty(stateblock
->wineD3DDevice
, STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
))) {
1809 tex_colorop(STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
), stateblock
);
1812 stateblock
->wineD3DDevice
->last_was_pshader
= FALSE
;
1815 stateblock
->wineD3DDevice
->shader_backend
->shader_select(
1816 (IWineD3DDevice
*) stateblock
->wineD3DDevice
,
1818 !stateblock
->vertexShader
? FALSE
: ((IWineD3DVertexShaderImpl
*) stateblock
->vertexShader
)->baseShader
.function
!= NULL
);
1823 static void transform_world(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1824 /* Do not bother applying when we're in rhw mode. vertexdeclaration() will call
1825 * transform_world if it switches out of rhw mode. This function is also called
1826 * by transform_view below if the view matrix was changed
1828 if(stateblock
->wineD3DDevice
->last_was_rhw
) {
1831 glMatrixMode(GL_MODELVIEW
);
1832 checkGLcall("glMatrixMode");
1834 /* In the general case, the view matrix is the identity matrix */
1835 if (stateblock
->wineD3DDevice
->view_ident
) {
1836 glLoadMatrixf((float *) &stateblock
->transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
1837 checkGLcall("glLoadMatrixf");
1839 glLoadMatrixf((float *) &stateblock
->transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
1840 checkGLcall("glLoadMatrixf");
1841 glMultMatrixf((float *) &stateblock
->transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
1842 checkGLcall("glMultMatrixf");
1846 static void transform_view(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1849 /* If we are changing the View matrix, reset the light and clipping planes to the new view
1850 * NOTE: We have to reset the positions even if the light/plane is not currently
1851 * enabled, since the call to enable it will not reset the position.
1852 * NOTE2: Apparently texture transforms do NOT need reapplying
1855 PLIGHTINFOEL
*lightChain
= NULL
;
1857 glMatrixMode(GL_MODELVIEW
);
1858 checkGLcall("glMatrixMode(GL_MODELVIEW)");
1859 glLoadMatrixf((float *)(float *) &stateblock
->transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
1860 checkGLcall("glLoadMatrixf(...)");
1862 /* Reset lights. TODO: Call light apply func */
1863 lightChain
= stateblock
->lights
;
1864 while (lightChain
&& lightChain
->glIndex
!= -1) {
1865 glLightfv(GL_LIGHT0
+ lightChain
->glIndex
, GL_POSITION
, lightChain
->lightPosn
);
1866 checkGLcall("glLightfv posn");
1867 glLightfv(GL_LIGHT0
+ lightChain
->glIndex
, GL_SPOT_DIRECTION
, lightChain
->lightDirn
);
1868 checkGLcall("glLightfv dirn");
1869 lightChain
= lightChain
->next
;
1872 /* Reset Clipping Planes if clipping is enabled. TODO: Call clipplane apply func */
1873 for (k
= 0; k
< GL_LIMITS(clipplanes
); k
++) {
1874 glClipPlane(GL_CLIP_PLANE0
+ k
, stateblock
->clipplane
[k
]);
1875 checkGLcall("glClipPlane");
1878 if(stateblock
->wineD3DDevice
->last_was_rhw
) {
1880 checkGLcall("glLoadIdentity()");
1881 /* No need to update the world matrix, the identity is fine */
1885 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
1886 * No need to do it here if the state is scheduled for update.
1888 if(!isStateDirty(stateblock
->wineD3DDevice
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
1889 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
);
1893 static void transform_worldex(DWORD state
, IWineD3DStateBlockImpl
*stateBlock
) {
1894 WARN("World matrix 1 - 255 not supported yet\n");
1897 static const GLfloat invymat
[16] = {
1898 1.0f
, 0.0f
, 0.0f
, 0.0f
,
1899 0.0f
, -1.0f
, 0.0f
, 0.0f
,
1900 0.0f
, 0.0f
, 1.0f
, 0.0f
,
1901 0.0f
, 0.0f
, 0.0f
, 1.0f
};
1903 static void vertexdeclaration(DWORD state
, IWineD3DStateBlockImpl
*stateblock
) {
1904 BOOL useVertexShaderFunction
= FALSE
, updateFog
= FALSE
;
1906 /* Some stuff is in the device until we have per context tracking */
1907 IWineD3DDeviceImpl
*device
= stateblock
->wineD3DDevice
;
1908 BOOL wasrhw
= device
->last_was_rhw
;
1910 device
->streamFixedUp
= FALSE
;
1912 /* Shaders can be implemented using ARB_PROGRAM, GLSL, or software -
1913 * here simply check whether a shader was set, or the user disabled shaders
1915 if (device
->vs_selected_mode
!= SHADER_NONE
&& stateblock
->vertexShader
&&
1916 ((IWineD3DVertexShaderImpl
*)stateblock
->vertexShader
)->baseShader
.function
!= NULL
) {
1917 useVertexShaderFunction
= TRUE
;
1919 if(((IWineD3DVertexShaderImpl
*)stateblock
->vertexShader
)->usesFog
!= device
->last_was_foggy_shader
) {
1922 } else if(device
->last_was_foggy_shader
) {
1926 if(device
->up_strided
) {
1928 /* Note: this is a ddraw fixed-function code path */
1929 TRACE("================ Strided Input ===================\n");
1930 memcpy(&device
->strided_streams
, device
->up_strided
, sizeof(device
->strided_streams
));
1932 else if (stateblock
->vertexDecl
|| stateblock
->vertexShader
) {
1933 /* Note: This is a fixed function or shader codepath.
1934 * This means it must handle both types of strided data.
1935 * Shaders must go through here to zero the strided data, even if they
1936 * don't set any declaration at all
1938 TRACE("================ Vertex Declaration ===================\n");
1939 memset(&device
->strided_streams
, 0, sizeof(device
->strided_streams
));
1941 if (stateblock
->vertexDecl
!= NULL
||
1942 ((IWineD3DVertexShaderImpl
*)stateblock
->vertexShader
)->vertexDeclaration
!= NULL
) {
1944 primitiveDeclarationConvertToStridedData((IWineD3DDevice
*) device
, useVertexShaderFunction
,
1945 &device
->strided_streams
, &device
->streamFixedUp
);
1948 /* Note: This codepath is not reachable from d3d9 (see fvf->decl9 conversion)
1949 * It is reachable through d3d8, but only for fixed-function.
1950 * It will not work properly for shaders.
1952 TRACE("================ FVF ===================\n");
1953 memset(&device
->strided_streams
, 0, sizeof(device
->strided_streams
));
1954 primitiveConvertToStridedData((IWineD3DDevice
*) device
, &device
->strided_streams
,
1955 &device
->streamFixedUp
);
1957 /* Do I have to use ? TRUE : FALSE ? Or can I rely on 15==15 beeing equal to TRUE(=1)? */
1958 transformed
= ((device
->strided_streams
.u
.s
.position
.lpData
!= NULL
||
1959 device
->strided_streams
.u
.s
.position
.VBO
!= 0) &&
1960 device
->strided_streams
.u
.s
.position_transformed
) ? TRUE
: FALSE
;
1962 if(transformed
!= device
->last_was_rhw
&& !useVertexShaderFunction
) {
1966 /* Reapply lighting if it is not sheduled for reapplication already */
1967 if(!isStateDirty(device
, STATE_RENDER(WINED3DRS_LIGHTING
))) {
1968 state_lighting(STATE_RENDER(WINED3DRS_LIGHTING
), stateblock
);
1971 if (!useVertexShaderFunction
&& transformed
) {
1972 d3ddevice_set_ortho(device
);
1976 /* Untransformed, so relies on the view and projection matrices */
1977 device
->last_was_rhw
= FALSE
;
1978 /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
1979 device
->untransformed
= TRUE
;
1981 /* Don't bother checking for !useVertexShaderFunction here. If shaders are always on wasrhw will never
1982 * be true. If they are switched on and off then knowing that the fixed function matrices are ok makes
1983 * those switches cheaper
1986 /* switching out of orthogonal mode? have to reapply the modelview matrix.
1987 * Only do that when it is not dirty though
1989 if(!isStateDirty(device
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
1990 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
);
1994 if (!useVertexShaderFunction
) {
1995 device
->proj_valid
= TRUE
;
1996 glMatrixMode(GL_PROJECTION
);
1997 checkGLcall("glMatrixMode");
1999 /* The rule is that the window coordinate 0 does not correspond to the
2000 beginning of the first pixel, but the center of the first pixel.
2001 As a consequence if you want to correctly draw one line exactly from
2002 the left to the right end of the viewport (with all matrices set to
2003 be identity), the x coords of both ends of the line would be not
2004 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
2008 glTranslatef(0.9 / stateblock
->viewport
.Width
, -0.9 / stateblock
->viewport
.Height
, 0);
2009 checkGLcall("glTranslatef (0.9 / width, -0.9 / height, 0)");
2011 /* D3D texture coordinates are flipped compared to OpenGL ones, so
2012 * render everything upside down when rendering offscreen. */
2013 if (device
->render_offscreen
) {
2014 glMultMatrixf(invymat
);
2015 checkGLcall("glMultMatrixf(invymat)");
2017 glMultMatrixf((float *) &stateblock
->transforms
[WINED3DTS_PROJECTION
].u
.m
[0][0]);
2018 checkGLcall("glLoadMatrixf");
2021 /* Vertex Shader output is already transformed, so set up identity matrices */
2022 if (useVertexShaderFunction
) {
2023 device
->posFixup
[1] = device
->render_offscreen
? -1.0 : 1.0;
2024 device
->posFixup
[2] = 0.9 / stateblock
->viewport
.Width
;
2025 device
->posFixup
[3] = -0.9 / stateblock
->viewport
.Height
;
2027 device
->last_was_rhw
= FALSE
;
2032 state_fog(STATE_RENDER(WINED3DRS_FOGENABLE
), stateblock
);
2036 const struct StateEntry StateTable
[] =
2038 /* State name representative, apply function */
2039 { /* 0, Undefined */ 0, state_undefined
},
2040 { /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, state_undefined
},
2041 { /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS
), state_antialias
},
2042 { /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, state_undefined
},
2043 { /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE
), state_perspective
},
2044 { /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU
), state_wrapu
},
2045 { /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV
), state_wrapv
},
2046 { /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE
), state_zenable
},
2047 { /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE
), state_fillmode
},
2048 { /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE
), state_shademode
},
2049 { /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN
), state_linepattern
},
2050 { /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE
), state_monoenable
},
2051 { /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2
), state_rop2
},
2052 { /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK
), state_planemask
},
2053 { /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE
), state_zwritenable
},
2054 { /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
},
2055 { /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL
), state_lastpixel
},
2056 { /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, state_undefined
},
2057 { /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, state_undefined
},
2058 { /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
},
2059 { /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
},
2060 { /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, state_undefined
},
2061 { /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE
), state_cullmode
},
2062 { /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC
), state_zfunc
},
2063 { /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
},
2064 { /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
},
2065 { /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE
), state_ditherenable
},
2066 { /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
},
2067 { /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog
},
2068 { /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE
), state_specularenable
},
2069 { /* 30, WINED3DRS_ZVISIBLE */ 0 /* Not supported according to the msdn */, state_nogl
},
2070 { /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL
), state_subpixel
},
2071 { /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX
), state_subpixelx
},
2072 { /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA
), state_stippledalpha
},
2073 { /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR
), state_fogcolor
},
2074 { /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog
},
2075 { /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog
},
2076 { /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog
},
2077 { /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY
), state_fogdensity
},
2078 { /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE
), state_stippleenable
},
2079 { /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
},
2080 { /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
},
2081 { /* 42, undefined */ 0, state_undefined
},
2082 { /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR
), state_bordercolor
},
2083 { /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ state_undefined
},
2084 { /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ state_undefined
},
2085 { /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS
), state_mipmaplodbias
},
2086 { /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS
), state_zbias
},
2087 { /* 48, WINED3DRS_RANGEFOGENABLE */ 0, state_nogl
},
2088 { /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY
), state_anisotropy
},
2089 { /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH
), state_flushbatch
},
2090 { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
), state_translucentsi
},
2091 { /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2092 { /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2093 { /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2094 { /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2095 { /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2096 { /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2097 { /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2098 { /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), state_stencilwrite
},
2099 { /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), state_texfactor
},
2100 { /* 61, Undefined */ 0, state_undefined
},
2101 { /* 62, Undefined */ 0, state_undefined
},
2102 { /* 63, Undefined */ 0, state_undefined
},
2103 { /* 64, WINED3DRS_STIPPLEPATTERN00 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2104 { /* 65, WINED3DRS_STIPPLEPATTERN01 */ 0 /* Obsolete, should he handled by ddraw */, state_undefined
},
2105 { /* 66, WINED3DRS_STIPPLEPATTERN02 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2106 { /* 67, WINED3DRS_STIPPLEPATTERN03 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2107 { /* 68, WINED3DRS_STIPPLEPATTERN04 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2108 { /* 69, WINED3DRS_STIPPLEPATTERN05 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2109 { /* 70, WINED3DRS_STIPPLEPATTERN06 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2110 { /* 71, WINED3DRS_STIPPLEPATTERN07 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2111 { /* 72, WINED3DRS_STIPPLEPATTERN08 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2112 { /* 73, WINED3DRS_STIPPLEPATTERN09 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2113 { /* 74, WINED3DRS_STIPPLEPATTERN10 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2114 { /* 75, WINED3DRS_STIPPLEPATTERN11 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2115 { /* 76, WINED3DRS_STIPPLEPATTERN12 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2116 { /* 77, WINED3DRS_STIPPLEPATTERN13 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2117 { /* 78, WINED3DRS_STIPPLEPATTERN14 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2118 { /* 79, WINED3DRS_STIPPLEPATTERN15 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2119 { /* 80, WINED3DRS_STIPPLEPATTERN16 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2120 { /* 81, WINED3DRS_STIPPLEPATTERN17 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2121 { /* 82, WINED3DRS_STIPPLEPATTERN18 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2122 { /* 83, WINED3DRS_STIPPLEPATTERN19 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2123 { /* 84, WINED3DRS_STIPPLEPATTERN20 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2124 { /* 85, WINED3DRS_STIPPLEPATTERN21 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2125 { /* 86, WINED3DRS_STIPPLEPATTERN22 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2126 { /* 87, WINED3DRS_STIPPLEPATTERN23 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2127 { /* 88, WINED3DRS_STIPPLEPATTERN24 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2128 { /* 89, WINED3DRS_STIPPLEPATTERN25 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2129 { /* 90, WINED3DRS_STIPPLEPATTERN26 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2130 { /* 91, WINED3DRS_STIPPLEPATTERN27 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2131 { /* 92, WINED3DRS_STIPPLEPATTERN28 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2132 { /* 93, WINED3DRS_STIPPLEPATTERN29 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2133 { /* 94, WINED3DRS_STIPPLEPATTERN30 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2134 { /* 95, WINED3DRS_STIPPLEPATTERN31 */ 0 /* Obsolete, should be handled by ddraw */, state_undefined
},
2135 { /* 96, Undefined */ 0, state_undefined
},
2136 { /* 97, Undefined */ 0, state_undefined
},
2137 { /* 98, Undefined */ 0, state_undefined
},
2138 { /* 99, Undefined */ 0, state_undefined
},
2139 { /*100, Undefined */ 0, state_undefined
},
2140 { /*101, Undefined */ 0, state_undefined
},
2141 { /*102, Undefined */ 0, state_undefined
},
2142 { /*103, Undefined */ 0, state_undefined
},
2143 { /*104, Undefined */ 0, state_undefined
},
2144 { /*105, Undefined */ 0, state_undefined
},
2145 { /*106, Undefined */ 0, state_undefined
},
2146 { /*107, Undefined */ 0, state_undefined
},
2147 { /*108, Undefined */ 0, state_undefined
},
2148 { /*109, Undefined */ 0, state_undefined
},
2149 { /*110, Undefined */ 0, state_undefined
},
2150 { /*111, Undefined */ 0, state_undefined
},
2151 { /*112, Undefined */ 0, state_undefined
},
2152 { /*113, Undefined */ 0, state_undefined
},
2153 { /*114, Undefined */ 0, state_undefined
},
2154 { /*115, Undefined */ 0, state_undefined
},
2155 { /*116, Undefined */ 0, state_undefined
},
2156 { /*117, Undefined */ 0, state_undefined
},
2157 { /*118, Undefined */ 0, state_undefined
},
2158 { /*119, Undefined */ 0, state_undefined
},
2159 { /*120, Undefined */ 0, state_undefined
},
2160 { /*121, Undefined */ 0, state_undefined
},
2161 { /*122, Undefined */ 0, state_undefined
},
2162 { /*123, Undefined */ 0, state_undefined
},
2163 { /*124, Undefined */ 0, state_undefined
},
2164 { /*125, Undefined */ 0, state_undefined
},
2165 { /*126, Undefined */ 0, state_undefined
},
2166 { /*127, Undefined */ 0, state_undefined
},
2168 { /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2169 { /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2170 { /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2171 { /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2172 { /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2173 { /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2174 { /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2175 { /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2176 { /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING
), state_clipping
},
2177 { /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING
), state_lighting
},
2178 { /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS
), state_extents
},
2179 { /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT
), state_ambient
},
2180 { /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog
},
2181 { /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
},
2182 { /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER
), state_localviewer
},
2183 { /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), state_normalize
},
2184 { /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE
), state_ckeyblend
},
2185 { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
},
2186 { /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
},
2187 { /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
},
2188 { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
},
2189 { /*149, Undefined */ 0, state_undefined
},
2190 { /*150, Undefined */ 0, state_undefined
},
2191 { /*151, WINED3DRS_VERTEXBLEND */ 0, state_nogl
},
2192 { /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPING
), state_clipping
},
2193 { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ 0, state_nogl
},
2194 { /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE
), state_psize
},
2195 { /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin
},
2196 { /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), state_pointsprite
},
2197 { /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
},
2198 { /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
},
2199 { /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
},
2200 { /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
},
2201 { /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), state_multisampleaa
},
2202 { /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK
), state_multisampmask
},
2203 { /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE
), state_patchedgestyle
},
2204 { /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS
), state_patchsegments
},
2205 { /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN
), state_nogl
},
2206 { /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), state_psizemax
},
2207 { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ 0, state_nogl
},
2208 { /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
},
2209 { /*169, Undefined */ 0, state_undefined
},
2210 { /*170, WINED3DRS_TWEENFACTOR */ 0, state_nogl
},
2211 { /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP
), state_blendop
},
2212 { /*172, WINED3DRS_POSITIONDEGREE */ STATE_RENDER(WINED3DRS_POSITIONDEGREE
), state_positiondegree
},
2213 { /*173, WINED3DRS_NORMALDEGREE */ STATE_RENDER(WINED3DRS_NORMALDEGREE
), state_normaldegree
},
2214 /*172, WINED3DRS_POSITIONORDER */ /* Value assigned to 2 state names */
2215 /*173, WINED3DRS_NORMALORDER */ /* Value assigned to 2 state names */
2216 { /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), state_scissor
},
2217 { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS
), state_depthbias
},
2218 { /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
},
2219 { /*177, undefined */ 0, state_undefined
},
2220 { /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2221 { /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2222 { /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2223 { /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2224 { /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2225 { /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2226 { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
},
2227 { /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2228 { /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2229 { /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2230 { /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2231 { /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
},
2232 { /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
},
2233 { /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
},
2234 { /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
},
2235 { /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_BLENDFACTOR
), state_blendfactor
},
2236 { /*194, WINED3DRS_SRGBWRITEENABLE */ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE
), state_srgbwrite
},
2237 { /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS
), state_depthbias
},
2238 { /*196, undefined */ 0, state_undefined
},
2239 { /*197, undefined */ 0, state_undefined
},
2240 { /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2241 { /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2242 { /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2243 { /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2244 { /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2245 { /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2246 { /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2247 { /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
},
2248 { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), state_seperateblend
},
2249 { /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), state_seperateblend
},
2250 { /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), state_seperateblend
},
2251 { /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), state_seperateblend
},
2252 /* Texture stage states */
2253 { /*0, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2254 { /*0, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2255 { /*0, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2256 { /*0, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2257 { /*0, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2258 { /*0, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2259 { /*0, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2260 { /*0, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2261 { /*0, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2262 { /*0, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2263 { /*0, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2264 { /*0, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2265 { /*0, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2266 { /*0, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2267 { /*0, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2268 { /*0, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2269 { /*0, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2270 { /*0, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2271 { /*0, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2272 { /*0, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2273 { /*0, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2274 { /*0, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2275 { /*0, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2276 { /*0, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE0
), transform_texture
},
2277 { /*0, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2278 { /*0, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
},
2279 { /*0, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2280 { /*0, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG
), tex_resultarg
},
2281 { /*0, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2282 { /*0, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2283 { /*0, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2284 { /*0, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2286 { /*1, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2287 { /*1, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2288 { /*1, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2289 { /*1, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2290 { /*1, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2291 { /*1, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2292 { /*1, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2293 { /*1, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2294 { /*1, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2295 { /*1, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2296 { /*1, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2297 { /*1, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2298 { /*1, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2299 { /*1, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2300 { /*1, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2301 { /*1, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2302 { /*1, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2303 { /*1, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2304 { /*1, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2305 { /*1, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2306 { /*1, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2307 { /*1, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2308 { /*1, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2309 { /*1, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE1
), transform_texture
},
2310 { /*1, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2311 { /*1, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
},
2312 { /*1, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2313 { /*1, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG
), tex_resultarg
},
2314 { /*1, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2315 { /*1, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2316 { /*1, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2317 { /*1, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2319 { /*2, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2320 { /*2, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2321 { /*2, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2322 { /*2, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2323 { /*2, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2324 { /*2, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2325 { /*2, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2326 { /*2, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2327 { /*2, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2328 { /*2, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2329 { /*2, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2330 { /*2, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2331 { /*2, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2332 { /*2, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2333 { /*2, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2334 { /*2, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2335 { /*2, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2336 { /*2, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2337 { /*2, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2338 { /*2, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2339 { /*2, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2340 { /*2, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2341 { /*2, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2342 { /*2, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE2
), transform_texture
},
2343 { /*2, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2344 { /*2, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
},
2345 { /*2, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2346 { /*2, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG
), tex_resultarg
},
2347 { /*2, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2348 { /*2, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2349 { /*2, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2350 { /*2, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2352 { /*3, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2353 { /*3, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2354 { /*3, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2355 { /*3, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2356 { /*3, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2357 { /*3, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2358 { /*3, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2359 { /*3, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2360 { /*3, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2361 { /*3, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2362 { /*3, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2363 { /*3, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2364 { /*3, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2365 { /*3, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2366 { /*3, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2367 { /*3, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2368 { /*3, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2369 { /*3, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2370 { /*3, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2371 { /*3, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2372 { /*3, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2373 { /*3, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2374 { /*3, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2375 { /*3, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE3
), transform_texture
},
2376 { /*3, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2377 { /*3, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
},
2378 { /*3, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2379 { /*3, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG
), tex_resultarg
},
2380 { /*3, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2381 { /*3, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2382 { /*3, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2383 { /*3, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2385 { /*4, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
},
2386 { /*4, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
},
2387 { /*4, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
},
2388 { /*4, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2389 { /*4, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2390 { /*4, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2391 { /*4, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), state_undefined
},
2392 { /*4, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), state_undefined
},
2393 { /*4, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), state_undefined
},
2394 { /*4, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), state_undefined
},
2395 { /*4, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2396 { /*4, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2397 { /*4, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2398 { /*4, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2399 { /*4, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2400 { /*4, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2401 { /*4, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2402 { /*4, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2403 { /*4, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2404 { /*4, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2405 { /*4, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2406 { /*4, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2407 { /*4, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2408 { /*4, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE4
), transform_texture
},
2409 { /*4, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2410 { /*4, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
},
2411 { /*4, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2412 { /*4, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG
), tex_resultarg
},
2413 { /*4, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2414 { /*4, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2415 { /*4, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2416 { /*4, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2418 { /*5, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2419 { /*5, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2420 { /*5, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2421 { /*5, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2422 { /*5, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2423 { /*5, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2424 { /*5, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2425 { /*5, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2426 { /*5, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2427 { /*5, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2428 { /*5, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2429 { /*5, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2430 { /*5, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2431 { /*5, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2432 { /*5, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2433 { /*5, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2434 { /*5, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2435 { /*5, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2436 { /*5, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2437 { /*5, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2438 { /*5, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2439 { /*5, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2440 { /*5, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2441 { /*5, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE5
), transform_texture
},
2442 { /*5, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2443 { /*5, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
},
2444 { /*5, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2445 { /*5, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG
), tex_resultarg
},
2446 { /*5, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2447 { /*5, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2448 { /*5, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2449 { /*5, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2451 { /*6, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2452 { /*6, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2453 { /*6, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2454 { /*6, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2455 { /*6, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2456 { /*6, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2457 { /*6, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2458 { /*6, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2459 { /*6, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2460 { /*6, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2461 { /*6, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2462 { /*6, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2463 { /*6, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2464 { /*6, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2465 { /*6, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2466 { /*6, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2467 { /*6, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2468 { /*6, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2469 { /*6, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2470 { /*6, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2471 { /*6, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2472 { /*6, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2473 { /*6, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2474 { /*6, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE6
), transform_texture
},
2475 { /*6, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2476 { /*6, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
},
2477 { /*6, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2478 { /*6, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG
), tex_resultarg
},
2479 { /*6, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2480 { /*6, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2481 { /*6, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2482 { /*6, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2484 { /*7, 01, WINED3DTSS_COLOROP */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2485 { /*7, 02, WINED3DTSS_COLORARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2486 { /*7, 03, WINED3DTSS_COLORARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2487 { /*7, 04, WINED3DTSS_ALPHAOP */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2488 { /*7, 05, WINED3DTSS_ALPHAARG1 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2489 { /*7, 06, WINED3DTSS_ALPHAARG2 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2490 { /*7, 07, WINED3DTSS_BUMPENVMAT00 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2491 { /*7, 08, WINED3DTSS_BUMPENVMAT01 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2492 { /*7, 09, WINED3DTSS_BUMPENVMAT10 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2493 { /*7, 10, WINED3DTSS_BUMPENVMAT11 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2494 { /*7, 11, WINED3DTSS_TEXCOORDINDEX */ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
},
2495 { /*7, 12, WINED3DTSS_ADDRESS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2496 { /*7, 13, WINED3DTSS_ADDRESSU */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2497 { /*7, 14, WINED3DTSS_ADDRESSV */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2498 { /*7, 15, WINED3DTSS_BORDERCOLOR */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2499 { /*7, 16, WINED3DTSS_MAGFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2500 { /*7, 17, WINED3DTSS_MINFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2501 { /*7, 18, WINED3DTSS_MIPFILTER */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2502 { /*7, 19, WINED3DTSS_MIPMAPLODBIAS */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2503 { /*7, 20, WINED3DTSS_MAXMIPLEVEL */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2504 { /*7, 21, WINED3DTSS_MAXANISOTROPY */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2505 { /*7, 22, WINED3DTSS_BUMPENVLSCALE */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
},
2506 { /*7, 23, WINED3DTSS_BUMPENVLOFFSET */ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET
), tex_bumpenvloffset
},
2507 { /*7, 24, WINED3DTSS_TEXTURETRANSFORMFLAGS */ STATE_TRANSFORM(WINED3DTS_TEXTURE7
), transform_texture
},
2508 { /*7, 25, WINED3DTSS_ADDRESSW */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2509 { /*7, 26, WINED3DTSS_COLORARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
},
2510 { /*7, 27, WINED3DTSS_ALPHAARG0 */ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
},
2511 { /*7, 28, WINED3DTSS_RESULTARG */ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG
), tex_resultarg
},
2512 { /*7, 29, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2513 { /*7, 30, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2514 { /*7, 31, undefined */ 0 /* -> sampler state in ddraw / d3d8 */, state_undefined
},
2515 { /*7, 32, WINED3DTSS_CONSTANT */ 0 /* As long as we don't support D3DTA_CONSTANT */, state_nogl
},
2516 /* Sampler states */
2517 { /* 0, Sampler 0 */ STATE_SAMPLER(0), sampler
},
2518 { /* 1, Sampler 1 */ STATE_SAMPLER(1), sampler
},
2519 { /* 2, Sampler 2 */ STATE_SAMPLER(2), sampler
},
2520 { /* 3, Sampler 3 */ STATE_SAMPLER(3), sampler
},
2521 { /* 4, Sampler 3 */ STATE_SAMPLER(4), sampler
},
2522 { /* 5, Sampler 5 */ STATE_SAMPLER(5), sampler
},
2523 { /* 6, Sampler 6 */ STATE_SAMPLER(6), sampler
},
2524 { /* 7, Sampler 7 */ STATE_SAMPLER(7), sampler
},
2525 { /* 8, Sampler 8 */ STATE_SAMPLER(8), sampler
},
2526 { /* 9, Sampler 9 */ STATE_SAMPLER(9), sampler
},
2527 { /*10, Sampler 10 */ STATE_SAMPLER(10), sampler
},
2528 { /*11, Sampler 11 */ STATE_SAMPLER(11), sampler
},
2529 { /*12, Sampler 12 */ STATE_SAMPLER(12), sampler
},
2530 { /*13, Sampler 13 */ STATE_SAMPLER(13), sampler
},
2531 { /*14, Sampler 14 */ STATE_SAMPLER(14), sampler
},
2532 { /*15, Sampler 15 */ STATE_SAMPLER(15), sampler
},
2534 { /* , Pixel Shader */ STATE_PIXELSHADER
, pixelshader
},
2535 /* Transform states follow */
2536 { /* 1, undefined */ 0, state_undefined
},
2537 { /* 2, WINED3DTS_VIEW */ STATE_TRANSFORM(WINED3DTS_VIEW
), transform_view
},
2538 { /* 3, WINED3DTS_PROJECTION */ STATE_VDECL
, vertexdeclaration
},
2539 { /* 4, undefined */ 0, state_undefined
},
2540 { /* 5, undefined */ 0, state_undefined
},
2541 { /* 6, undefined */ 0, state_undefined
},
2542 { /* 7, undefined */ 0, state_undefined
},
2543 { /* 8, undefined */ 0, state_undefined
},
2544 { /* 9, undefined */ 0, state_undefined
},
2545 { /* 10, undefined */ 0, state_undefined
},
2546 { /* 11, undefined */ 0, state_undefined
},
2547 { /* 12, undefined */ 0, state_undefined
},
2548 { /* 13, undefined */ 0, state_undefined
},
2549 { /* 14, undefined */ 0, state_undefined
},
2550 { /* 15, undefined */ 0, state_undefined
},
2551 { /* 16, WINED3DTS_TEXTURE0 */ STATE_TRANSFORM(WINED3DTS_TEXTURE0
), transform_texture
},
2552 { /* 17, WINED3DTS_TEXTURE1 */ STATE_TRANSFORM(WINED3DTS_TEXTURE1
), transform_texture
},
2553 { /* 18, WINED3DTS_TEXTURE2 */ STATE_TRANSFORM(WINED3DTS_TEXTURE2
), transform_texture
},
2554 { /* 19, WINED3DTS_TEXTURE3 */ STATE_TRANSFORM(WINED3DTS_TEXTURE3
), transform_texture
},
2555 { /* 20, WINED3DTS_TEXTURE4 */ STATE_TRANSFORM(WINED3DTS_TEXTURE4
), transform_texture
},
2556 { /* 21, WINED3DTS_TEXTURE5 */ STATE_TRANSFORM(WINED3DTS_TEXTURE5
), transform_texture
},
2557 { /* 22, WINED3DTS_TEXTURE6 */ STATE_TRANSFORM(WINED3DTS_TEXTURE6
), transform_texture
},
2558 { /* 23, WINED3DTS_TEXTURE7 */ STATE_TRANSFORM(WINED3DTS_TEXTURE7
), transform_texture
},
2559 /* A huge gap between TEXTURE7 and WORLDMATRIX(0) :-( But entries are needed to catch then if a broken app sets them */
2560 { /* 24, undefined */ 0, state_undefined
},
2561 { /* 25, undefined */ 0, state_undefined
},
2562 { /* 26, undefined */ 0, state_undefined
},
2563 { /* 27, undefined */ 0, state_undefined
},
2564 { /* 28, undefined */ 0, state_undefined
},
2565 { /* 29, undefined */ 0, state_undefined
},
2566 { /* 30, undefined */ 0, state_undefined
},
2567 { /* 31, undefined */ 0, state_undefined
},
2568 { /* 32, undefined */ 0, state_undefined
},
2569 { /* 33, undefined */ 0, state_undefined
},
2570 { /* 34, undefined */ 0, state_undefined
},
2571 { /* 35, undefined */ 0, state_undefined
},
2572 { /* 36, undefined */ 0, state_undefined
},
2573 { /* 37, undefined */ 0, state_undefined
},
2574 { /* 38, undefined */ 0, state_undefined
},
2575 { /* 39, undefined */ 0, state_undefined
},
2576 { /* 40, undefined */ 0, state_undefined
},
2577 { /* 41, undefined */ 0, state_undefined
},
2578 { /* 42, undefined */ 0, state_undefined
},
2579 { /* 43, undefined */ 0, state_undefined
},
2580 { /* 44, undefined */ 0, state_undefined
},
2581 { /* 45, undefined */ 0, state_undefined
},
2582 { /* 46, undefined */ 0, state_undefined
},
2583 { /* 47, undefined */ 0, state_undefined
},
2584 { /* 48, undefined */ 0, state_undefined
},
2585 { /* 49, undefined */ 0, state_undefined
},
2586 { /* 50, undefined */ 0, state_undefined
},
2587 { /* 51, undefined */ 0, state_undefined
},
2588 { /* 52, undefined */ 0, state_undefined
},
2589 { /* 53, undefined */ 0, state_undefined
},
2590 { /* 54, undefined */ 0, state_undefined
},
2591 { /* 55, undefined */ 0, state_undefined
},
2592 { /* 56, undefined */ 0, state_undefined
},
2593 { /* 57, undefined */ 0, state_undefined
},
2594 { /* 58, undefined */ 0, state_undefined
},
2595 { /* 59, undefined */ 0, state_undefined
},
2596 { /* 60, undefined */ 0, state_undefined
},
2597 { /* 61, undefined */ 0, state_undefined
},
2598 { /* 62, undefined */ 0, state_undefined
},
2599 { /* 63, undefined */ 0, state_undefined
},
2600 { /* 64, undefined */ 0, state_undefined
},
2601 { /* 65, undefined */ 0, state_undefined
},
2602 { /* 66, undefined */ 0, state_undefined
},
2603 { /* 67, undefined */ 0, state_undefined
},
2604 { /* 68, undefined */ 0, state_undefined
},
2605 { /* 69, undefined */ 0, state_undefined
},
2606 { /* 70, undefined */ 0, state_undefined
},
2607 { /* 71, undefined */ 0, state_undefined
},
2608 { /* 72, undefined */ 0, state_undefined
},
2609 { /* 73, undefined */ 0, state_undefined
},
2610 { /* 74, undefined */ 0, state_undefined
},
2611 { /* 75, undefined */ 0, state_undefined
},
2612 { /* 76, undefined */ 0, state_undefined
},
2613 { /* 77, undefined */ 0, state_undefined
},
2614 { /* 78, undefined */ 0, state_undefined
},
2615 { /* 79, undefined */ 0, state_undefined
},
2616 { /* 80, undefined */ 0, state_undefined
},
2617 { /* 81, undefined */ 0, state_undefined
},
2618 { /* 82, undefined */ 0, state_undefined
},
2619 { /* 83, undefined */ 0, state_undefined
},
2620 { /* 84, undefined */ 0, state_undefined
},
2621 { /* 85, undefined */ 0, state_undefined
},
2622 { /* 86, undefined */ 0, state_undefined
},
2623 { /* 87, undefined */ 0, state_undefined
},
2624 { /* 88, undefined */ 0, state_undefined
},
2625 { /* 89, undefined */ 0, state_undefined
},
2626 { /* 90, undefined */ 0, state_undefined
},
2627 { /* 91, undefined */ 0, state_undefined
},
2628 { /* 92, undefined */ 0, state_undefined
},
2629 { /* 93, undefined */ 0, state_undefined
},
2630 { /* 94, undefined */ 0, state_undefined
},
2631 { /* 95, undefined */ 0, state_undefined
},
2632 { /* 96, undefined */ 0, state_undefined
},
2633 { /* 97, undefined */ 0, state_undefined
},
2634 { /* 98, undefined */ 0, state_undefined
},
2635 { /* 99, undefined */ 0, state_undefined
},
2636 { /*100, undefined */ 0, state_undefined
},
2637 { /*101, undefined */ 0, state_undefined
},
2638 { /*102, undefined */ 0, state_undefined
},
2639 { /*103, undefined */ 0, state_undefined
},
2640 { /*104, undefined */ 0, state_undefined
},
2641 { /*105, undefined */ 0, state_undefined
},
2642 { /*106, undefined */ 0, state_undefined
},
2643 { /*107, undefined */ 0, state_undefined
},
2644 { /*108, undefined */ 0, state_undefined
},
2645 { /*109, undefined */ 0, state_undefined
},
2646 { /*110, undefined */ 0, state_undefined
},
2647 { /*111, undefined */ 0, state_undefined
},
2648 { /*112, undefined */ 0, state_undefined
},
2649 { /*113, undefined */ 0, state_undefined
},
2650 { /*114, undefined */ 0, state_undefined
},
2651 { /*115, undefined */ 0, state_undefined
},
2652 { /*116, undefined */ 0, state_undefined
},
2653 { /*117, undefined */ 0, state_undefined
},
2654 { /*118, undefined */ 0, state_undefined
},
2655 { /*119, undefined */ 0, state_undefined
},
2656 { /*120, undefined */ 0, state_undefined
},
2657 { /*121, undefined */ 0, state_undefined
},
2658 { /*122, undefined */ 0, state_undefined
},
2659 { /*123, undefined */ 0, state_undefined
},
2660 { /*124, undefined */ 0, state_undefined
},
2661 { /*125, undefined */ 0, state_undefined
},
2662 { /*126, undefined */ 0, state_undefined
},
2663 { /*127, undefined */ 0, state_undefined
},
2664 { /*128, undefined */ 0, state_undefined
},
2665 { /*129, undefined */ 0, state_undefined
},
2666 { /*130, undefined */ 0, state_undefined
},
2667 { /*131, undefined */ 0, state_undefined
},
2668 { /*132, undefined */ 0, state_undefined
},
2669 { /*133, undefined */ 0, state_undefined
},
2670 { /*134, undefined */ 0, state_undefined
},
2671 { /*135, undefined */ 0, state_undefined
},
2672 { /*136, undefined */ 0, state_undefined
},
2673 { /*137, undefined */ 0, state_undefined
},
2674 { /*138, undefined */ 0, state_undefined
},
2675 { /*139, undefined */ 0, state_undefined
},
2676 { /*140, undefined */ 0, state_undefined
},
2677 { /*141, undefined */ 0, state_undefined
},
2678 { /*142, undefined */ 0, state_undefined
},
2679 { /*143, undefined */ 0, state_undefined
},
2680 { /*144, undefined */ 0, state_undefined
},
2681 { /*145, undefined */ 0, state_undefined
},
2682 { /*146, undefined */ 0, state_undefined
},
2683 { /*147, undefined */ 0, state_undefined
},
2684 { /*148, undefined */ 0, state_undefined
},
2685 { /*149, undefined */ 0, state_undefined
},
2686 { /*150, undefined */ 0, state_undefined
},
2687 { /*151, undefined */ 0, state_undefined
},
2688 { /*152, undefined */ 0, state_undefined
},
2689 { /*153, undefined */ 0, state_undefined
},
2690 { /*154, undefined */ 0, state_undefined
},
2691 { /*155, undefined */ 0, state_undefined
},
2692 { /*156, undefined */ 0, state_undefined
},
2693 { /*157, undefined */ 0, state_undefined
},
2694 { /*158, undefined */ 0, state_undefined
},
2695 { /*159, undefined */ 0, state_undefined
},
2696 { /*160, undefined */ 0, state_undefined
},
2697 { /*161, undefined */ 0, state_undefined
},
2698 { /*162, undefined */ 0, state_undefined
},
2699 { /*163, undefined */ 0, state_undefined
},
2700 { /*164, undefined */ 0, state_undefined
},
2701 { /*165, undefined */ 0, state_undefined
},
2702 { /*166, undefined */ 0, state_undefined
},
2703 { /*167, undefined */ 0, state_undefined
},
2704 { /*168, undefined */ 0, state_undefined
},
2705 { /*169, undefined */ 0, state_undefined
},
2706 { /*170, undefined */ 0, state_undefined
},
2707 { /*171, undefined */ 0, state_undefined
},
2708 { /*172, undefined */ 0, state_undefined
},
2709 { /*173, undefined */ 0, state_undefined
},
2710 { /*174, undefined */ 0, state_undefined
},
2711 { /*175, undefined */ 0, state_undefined
},
2712 { /*176, undefined */ 0, state_undefined
},
2713 { /*177, undefined */ 0, state_undefined
},
2714 { /*178, undefined */ 0, state_undefined
},
2715 { /*179, undefined */ 0, state_undefined
},
2716 { /*180, undefined */ 0, state_undefined
},
2717 { /*181, undefined */ 0, state_undefined
},
2718 { /*182, undefined */ 0, state_undefined
},
2719 { /*183, undefined */ 0, state_undefined
},
2720 { /*184, undefined */ 0, state_undefined
},
2721 { /*185, undefined */ 0, state_undefined
},
2722 { /*186, undefined */ 0, state_undefined
},
2723 { /*187, undefined */ 0, state_undefined
},
2724 { /*188, undefined */ 0, state_undefined
},
2725 { /*189, undefined */ 0, state_undefined
},
2726 { /*190, undefined */ 0, state_undefined
},
2727 { /*191, undefined */ 0, state_undefined
},
2728 { /*192, undefined */ 0, state_undefined
},
2729 { /*193, undefined */ 0, state_undefined
},
2730 { /*194, undefined */ 0, state_undefined
},
2731 { /*195, undefined */ 0, state_undefined
},
2732 { /*196, undefined */ 0, state_undefined
},
2733 { /*197, undefined */ 0, state_undefined
},
2734 { /*198, undefined */ 0, state_undefined
},
2735 { /*199, undefined */ 0, state_undefined
},
2736 { /*200, undefined */ 0, state_undefined
},
2737 { /*201, undefined */ 0, state_undefined
},
2738 { /*202, undefined */ 0, state_undefined
},
2739 { /*203, undefined */ 0, state_undefined
},
2740 { /*204, undefined */ 0, state_undefined
},
2741 { /*205, undefined */ 0, state_undefined
},
2742 { /*206, undefined */ 0, state_undefined
},
2743 { /*207, undefined */ 0, state_undefined
},
2744 { /*208, undefined */ 0, state_undefined
},
2745 { /*209, undefined */ 0, state_undefined
},
2746 { /*210, undefined */ 0, state_undefined
},
2747 { /*211, undefined */ 0, state_undefined
},
2748 { /*212, undefined */ 0, state_undefined
},
2749 { /*213, undefined */ 0, state_undefined
},
2750 { /*214, undefined */ 0, state_undefined
},
2751 { /*215, undefined */ 0, state_undefined
},
2752 { /*216, undefined */ 0, state_undefined
},
2753 { /*217, undefined */ 0, state_undefined
},
2754 { /*218, undefined */ 0, state_undefined
},
2755 { /*219, undefined */ 0, state_undefined
},
2756 { /*220, undefined */ 0, state_undefined
},
2757 { /*221, undefined */ 0, state_undefined
},
2758 { /*222, undefined */ 0, state_undefined
},
2759 { /*223, undefined */ 0, state_undefined
},
2760 { /*224, undefined */ 0, state_undefined
},
2761 { /*225, undefined */ 0, state_undefined
},
2762 { /*226, undefined */ 0, state_undefined
},
2763 { /*227, undefined */ 0, state_undefined
},
2764 { /*228, undefined */ 0, state_undefined
},
2765 { /*229, undefined */ 0, state_undefined
},
2766 { /*230, undefined */ 0, state_undefined
},
2767 { /*231, undefined */ 0, state_undefined
},
2768 { /*232, undefined */ 0, state_undefined
},
2769 { /*233, undefined */ 0, state_undefined
},
2770 { /*234, undefined */ 0, state_undefined
},
2771 { /*235, undefined */ 0, state_undefined
},
2772 { /*236, undefined */ 0, state_undefined
},
2773 { /*237, undefined */ 0, state_undefined
},
2774 { /*238, undefined */ 0, state_undefined
},
2775 { /*239, undefined */ 0, state_undefined
},
2776 { /*240, undefined */ 0, state_undefined
},
2777 { /*241, undefined */ 0, state_undefined
},
2778 { /*242, undefined */ 0, state_undefined
},
2779 { /*243, undefined */ 0, state_undefined
},
2780 { /*244, undefined */ 0, state_undefined
},
2781 { /*245, undefined */ 0, state_undefined
},
2782 { /*246, undefined */ 0, state_undefined
},
2783 { /*247, undefined */ 0, state_undefined
},
2784 { /*248, undefined */ 0, state_undefined
},
2785 { /*249, undefined */ 0, state_undefined
},
2786 { /*250, undefined */ 0, state_undefined
},
2787 { /*251, undefined */ 0, state_undefined
},
2788 { /*252, undefined */ 0, state_undefined
},
2789 { /*253, undefined */ 0, state_undefined
},
2790 { /*254, undefined */ 0, state_undefined
},
2791 { /*255, undefined */ 0, state_undefined
},
2793 { /*256, WINED3DTS_WORLDMATRIX(0) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), transform_world
},
2794 { /*257, WINED3DTS_WORLDMATRIX(1) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(1)), transform_worldex
},
2795 { /*258, WINED3DTS_WORLDMATRIX(2) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(2)), transform_worldex
},
2796 { /*259, WINED3DTS_WORLDMATRIX(3) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(3)), transform_worldex
},
2797 { /*260, WINED3DTS_WORLDMATRIX(4) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(4)), transform_worldex
},
2798 { /*261, WINED3DTS_WORLDMATRIX(5) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(5)), transform_worldex
},
2799 { /*262, WINED3DTS_WORLDMATRIX(6) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(6)), transform_worldex
},
2800 { /*263, WINED3DTS_WORLDMATRIX(7) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(7)), transform_worldex
},
2801 { /*264, WINED3DTS_WORLDMATRIX(8) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(8)), transform_worldex
},
2802 { /*265, WINED3DTS_WORLDMATRIX(9) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(9)), transform_worldex
},
2803 { /*266, WINED3DTS_WORLDMATRIX(10) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(10)), transform_worldex
},
2804 { /*267, WINED3DTS_WORLDMATRIX(11) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(11)), transform_worldex
},
2805 { /*268, WINED3DTS_WORLDMATRIX(12) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(12)), transform_worldex
},
2806 { /*269, WINED3DTS_WORLDMATRIX(13) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(13)), transform_worldex
},
2807 { /*270, WINED3DTS_WORLDMATRIX(14) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(14)), transform_worldex
},
2808 { /*271, WINED3DTS_WORLDMATRIX(15) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(15)), transform_worldex
},
2809 { /*272, WINED3DTS_WORLDMATRIX(16) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(16)), transform_worldex
},
2810 { /*273, WINED3DTS_WORLDMATRIX(17) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(17)), transform_worldex
},
2811 { /*274, WINED3DTS_WORLDMATRIX(18) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(18)), transform_worldex
},
2812 { /*275, WINED3DTS_WORLDMATRIX(19) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(19)), transform_worldex
},
2813 { /*276, WINED3DTS_WORLDMATRIX(20) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(20)), transform_worldex
},
2814 { /*277, WINED3DTS_WORLDMATRIX(21) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(21)), transform_worldex
},
2815 { /*278, WINED3DTS_WORLDMATRIX(22) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(22)), transform_worldex
},
2816 { /*279, WINED3DTS_WORLDMATRIX(23) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(23)), transform_worldex
},
2817 { /*280, WINED3DTS_WORLDMATRIX(24) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(24)), transform_worldex
},
2818 { /*281, WINED3DTS_WORLDMATRIX(25) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(25)), transform_worldex
},
2819 { /*282, WINED3DTS_WORLDMATRIX(26) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(26)), transform_worldex
},
2820 { /*283, WINED3DTS_WORLDMATRIX(27) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(27)), transform_worldex
},
2821 { /*284, WINED3DTS_WORLDMATRIX(28) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(28)), transform_worldex
},
2822 { /*285, WINED3DTS_WORLDMATRIX(29) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(29)), transform_worldex
},
2823 { /*286, WINED3DTS_WORLDMATRIX(30) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(30)), transform_worldex
},
2824 { /*287, WINED3DTS_WORLDMATRIX(31) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(31)), transform_worldex
},
2825 { /*288, WINED3DTS_WORLDMATRIX(32) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(32)), transform_worldex
},
2826 { /*289, WINED3DTS_WORLDMATRIX(33) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(33)), transform_worldex
},
2827 { /*290, WINED3DTS_WORLDMATRIX(34) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(34)), transform_worldex
},
2828 { /*291, WINED3DTS_WORLDMATRIX(35) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(35)), transform_worldex
},
2829 { /*292, WINED3DTS_WORLDMATRIX(36) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(36)), transform_worldex
},
2830 { /*293, WINED3DTS_WORLDMATRIX(37) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(37)), transform_worldex
},
2831 { /*294, WINED3DTS_WORLDMATRIX(38) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(38)), transform_worldex
},
2832 { /*295, WINED3DTS_WORLDMATRIX(39) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(39)), transform_worldex
},
2833 { /*296, WINED3DTS_WORLDMATRIX(40) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(40)), transform_worldex
},
2834 { /*297, WINED3DTS_WORLDMATRIX(41) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(41)), transform_worldex
},
2835 { /*298, WINED3DTS_WORLDMATRIX(42) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(42)), transform_worldex
},
2836 { /*299, WINED3DTS_WORLDMATRIX(43) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(43)), transform_worldex
},
2837 { /*300, WINED3DTS_WORLDMATRIX(44) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(44)), transform_worldex
},
2838 { /*301, WINED3DTS_WORLDMATRIX(45) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(45)), transform_worldex
},
2839 { /*302, WINED3DTS_WORLDMATRIX(46) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(46)), transform_worldex
},
2840 { /*303, WINED3DTS_WORLDMATRIX(47) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(47)), transform_worldex
},
2841 { /*304, WINED3DTS_WORLDMATRIX(48) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(48)), transform_worldex
},
2842 { /*305, WINED3DTS_WORLDMATRIX(49) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(49)), transform_worldex
},
2843 { /*306, WINED3DTS_WORLDMATRIX(50) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(50)), transform_worldex
},
2844 { /*307, WINED3DTS_WORLDMATRIX(51) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(51)), transform_worldex
},
2845 { /*308, WINED3DTS_WORLDMATRIX(52) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(52)), transform_worldex
},
2846 { /*309, WINED3DTS_WORLDMATRIX(53) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(53)), transform_worldex
},
2847 { /*310, WINED3DTS_WORLDMATRIX(54) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(54)), transform_worldex
},
2848 { /*311, WINED3DTS_WORLDMATRIX(55) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(55)), transform_worldex
},
2849 { /*312, WINED3DTS_WORLDMATRIX(56) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(56)), transform_worldex
},
2850 { /*313, WINED3DTS_WORLDMATRIX(57) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(57)), transform_worldex
},
2851 { /*314, WINED3DTS_WORLDMATRIX(58) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(58)), transform_worldex
},
2852 { /*315, WINED3DTS_WORLDMATRIX(59) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(59)), transform_worldex
},
2853 { /*316, WINED3DTS_WORLDMATRIX(60) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(60)), transform_worldex
},
2854 { /*317, WINED3DTS_WORLDMATRIX(61) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(61)), transform_worldex
},
2855 { /*318, WINED3DTS_WORLDMATRIX(62) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(62)), transform_worldex
},
2856 { /*319, WINED3DTS_WORLDMATRIX(63) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(63)), transform_worldex
},
2857 { /*320, WINED3DTS_WORLDMATRIX(64) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(64)), transform_worldex
},
2858 { /*321, WINED3DTS_WORLDMATRIX(65) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(65)), transform_worldex
},
2859 { /*322, WINED3DTS_WORLDMATRIX(66) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(66)), transform_worldex
},
2860 { /*323, WINED3DTS_WORLDMATRIX(67) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(67)), transform_worldex
},
2861 { /*324, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(68)), transform_worldex
},
2862 { /*325, WINED3DTS_WORLDMATRIX(68) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(69)), transform_worldex
},
2863 { /*326, WINED3DTS_WORLDMATRIX(70) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(70)), transform_worldex
},
2864 { /*327, WINED3DTS_WORLDMATRIX(71) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(71)), transform_worldex
},
2865 { /*328, WINED3DTS_WORLDMATRIX(72) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(72)), transform_worldex
},
2866 { /*329, WINED3DTS_WORLDMATRIX(73) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(73)), transform_worldex
},
2867 { /*330, WINED3DTS_WORLDMATRIX(74) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(74)), transform_worldex
},
2868 { /*331, WINED3DTS_WORLDMATRIX(75) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(75)), transform_worldex
},
2869 { /*332, WINED3DTS_WORLDMATRIX(76) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(76)), transform_worldex
},
2870 { /*333, WINED3DTS_WORLDMATRIX(77) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(77)), transform_worldex
},
2871 { /*334, WINED3DTS_WORLDMATRIX(78) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(78)), transform_worldex
},
2872 { /*335, WINED3DTS_WORLDMATRIX(79) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(79)), transform_worldex
},
2873 { /*336, WINED3DTS_WORLDMATRIX(80) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(80)), transform_worldex
},
2874 { /*337, WINED3DTS_WORLDMATRIX(81) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(81)), transform_worldex
},
2875 { /*338, WINED3DTS_WORLDMATRIX(82) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(82)), transform_worldex
},
2876 { /*339, WINED3DTS_WORLDMATRIX(83) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(83)), transform_worldex
},
2877 { /*340, WINED3DTS_WORLDMATRIX(84) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(84)), transform_worldex
},
2878 { /*341, WINED3DTS_WORLDMATRIX(85) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(85)), transform_worldex
},
2879 { /*341, WINED3DTS_WORLDMATRIX(86) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(86)), transform_worldex
},
2880 { /*343, WINED3DTS_WORLDMATRIX(87) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(87)), transform_worldex
},
2881 { /*344, WINED3DTS_WORLDMATRIX(88) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(88)), transform_worldex
},
2882 { /*345, WINED3DTS_WORLDMATRIX(89) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(89)), transform_worldex
},
2883 { /*346, WINED3DTS_WORLDMATRIX(90) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(90)), transform_worldex
},
2884 { /*347, WINED3DTS_WORLDMATRIX(91) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(91)), transform_worldex
},
2885 { /*348, WINED3DTS_WORLDMATRIX(92) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(92)), transform_worldex
},
2886 { /*349, WINED3DTS_WORLDMATRIX(93) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(93)), transform_worldex
},
2887 { /*350, WINED3DTS_WORLDMATRIX(94) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(94)), transform_worldex
},
2888 { /*351, WINED3DTS_WORLDMATRIX(95) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(95)), transform_worldex
},
2889 { /*352, WINED3DTS_WORLDMATRIX(96) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(96)), transform_worldex
},
2890 { /*353, WINED3DTS_WORLDMATRIX(97) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(97)), transform_worldex
},
2891 { /*354, WINED3DTS_WORLDMATRIX(98) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(98)), transform_worldex
},
2892 { /*355, WINED3DTS_WORLDMATRIX(99) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(99)), transform_worldex
},
2893 { /*356, WINED3DTS_WORLDMATRIX(100) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex
},
2894 { /*357, WINED3DTS_WORLDMATRIX(101) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex
},
2895 { /*358, WINED3DTS_WORLDMATRIX(102) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex
},
2896 { /*359, WINED3DTS_WORLDMATRIX(103) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex
},
2897 { /*360, WINED3DTS_WORLDMATRIX(104) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex
},
2898 { /*361, WINED3DTS_WORLDMATRIX(105) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex
},
2899 { /*362, WINED3DTS_WORLDMATRIX(106) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex
},
2900 { /*363, WINED3DTS_WORLDMATRIX(107) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex
},
2901 { /*364, WINED3DTS_WORLDMATRIX(108) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex
},
2902 { /*365, WINED3DTS_WORLDMATRIX(109) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex
},
2903 { /*366, WINED3DTS_WORLDMATRIX(110) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex
},
2904 { /*367, WINED3DTS_WORLDMATRIX(111) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex
},
2905 { /*368, WINED3DTS_WORLDMATRIX(112) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex
},
2906 { /*369, WINED3DTS_WORLDMATRIX(113) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex
},
2907 { /*370, WINED3DTS_WORLDMATRIX(114) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex
},
2908 { /*371, WINED3DTS_WORLDMATRIX(115) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex
},
2909 { /*372, WINED3DTS_WORLDMATRIX(116) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex
},
2910 { /*373, WINED3DTS_WORLDMATRIX(117) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex
},
2911 { /*374, WINED3DTS_WORLDMATRIX(118) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex
},
2912 { /*375, WINED3DTS_WORLDMATRIX(119) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex
},
2913 { /*376, WINED3DTS_WORLDMATRIX(120) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex
},
2914 { /*377, WINED3DTS_WORLDMATRIX(121) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex
},
2915 { /*378, WINED3DTS_WORLDMATRIX(122) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex
},
2916 { /*379, WINED3DTS_WORLDMATRIX(123) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex
},
2917 { /*380, WINED3DTS_WORLDMATRIX(124) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex
},
2918 { /*381, WINED3DTS_WORLDMATRIX(125) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex
},
2919 { /*382, WINED3DTS_WORLDMATRIX(126) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex
},
2920 { /*383, WINED3DTS_WORLDMATRIX(127) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex
},
2921 { /*384, WINED3DTS_WORLDMATRIX(128) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex
},
2922 { /*385, WINED3DTS_WORLDMATRIX(129) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex
},
2923 { /*386, WINED3DTS_WORLDMATRIX(130) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex
},
2924 { /*387, WINED3DTS_WORLDMATRIX(131) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex
},
2925 { /*388, WINED3DTS_WORLDMATRIX(132) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex
},
2926 { /*389, WINED3DTS_WORLDMATRIX(133) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex
},
2927 { /*390, WINED3DTS_WORLDMATRIX(134) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex
},
2928 { /*391, WINED3DTS_WORLDMATRIX(135) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex
},
2929 { /*392, WINED3DTS_WORLDMATRIX(136) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex
},
2930 { /*393, WINED3DTS_WORLDMATRIX(137) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex
},
2931 { /*394, WINED3DTS_WORLDMATRIX(138) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex
},
2932 { /*395, WINED3DTS_WORLDMATRIX(139) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex
},
2933 { /*396, WINED3DTS_WORLDMATRIX(140) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex
},
2934 { /*397, WINED3DTS_WORLDMATRIX(141) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex
},
2935 { /*398, WINED3DTS_WORLDMATRIX(142) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex
},
2936 { /*399, WINED3DTS_WORLDMATRIX(143) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex
},
2937 { /*400, WINED3DTS_WORLDMATRIX(144) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex
},
2938 { /*401, WINED3DTS_WORLDMATRIX(145) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex
},
2939 { /*402, WINED3DTS_WORLDMATRIX(146) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex
},
2940 { /*403, WINED3DTS_WORLDMATRIX(147) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex
},
2941 { /*404, WINED3DTS_WORLDMATRIX(148) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex
},
2942 { /*405, WINED3DTS_WORLDMATRIX(149) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex
},
2943 { /*406, WINED3DTS_WORLDMATRIX(150) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex
},
2944 { /*407, WINED3DTS_WORLDMATRIX(151) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex
},
2945 { /*408, WINED3DTS_WORLDMATRIX(152) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex
},
2946 { /*409, WINED3DTS_WORLDMATRIX(153) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex
},
2947 { /*410, WINED3DTS_WORLDMATRIX(154) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex
},
2948 { /*411, WINED3DTS_WORLDMATRIX(155) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex
},
2949 { /*412, WINED3DTS_WORLDMATRIX(156) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex
},
2950 { /*413, WINED3DTS_WORLDMATRIX(157) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex
},
2951 { /*414, WINED3DTS_WORLDMATRIX(158) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex
},
2952 { /*415, WINED3DTS_WORLDMATRIX(159) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex
},
2953 { /*416, WINED3DTS_WORLDMATRIX(160) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex
},
2954 { /*417, WINED3DTS_WORLDMATRIX(161) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex
},
2955 { /*418, WINED3DTS_WORLDMATRIX(162) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex
},
2956 { /*419, WINED3DTS_WORLDMATRIX(163) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex
},
2957 { /*420, WINED3DTS_WORLDMATRIX(164) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex
},
2958 { /*421, WINED3DTS_WORLDMATRIX(165) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex
},
2959 { /*422, WINED3DTS_WORLDMATRIX(166) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex
},
2960 { /*423, WINED3DTS_WORLDMATRIX(167) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex
},
2961 { /*424, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex
},
2962 { /*425, WINED3DTS_WORLDMATRIX(168) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex
},
2963 { /*426, WINED3DTS_WORLDMATRIX(170) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex
},
2964 { /*427, WINED3DTS_WORLDMATRIX(171) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex
},
2965 { /*428, WINED3DTS_WORLDMATRIX(172) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex
},
2966 { /*429, WINED3DTS_WORLDMATRIX(173) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex
},
2967 { /*430, WINED3DTS_WORLDMATRIX(174) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex
},
2968 { /*431, WINED3DTS_WORLDMATRIX(175) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex
},
2969 { /*432, WINED3DTS_WORLDMATRIX(176) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex
},
2970 { /*433, WINED3DTS_WORLDMATRIX(177) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex
},
2971 { /*434, WINED3DTS_WORLDMATRIX(178) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex
},
2972 { /*435, WINED3DTS_WORLDMATRIX(179) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex
},
2973 { /*436, WINED3DTS_WORLDMATRIX(180) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex
},
2974 { /*437, WINED3DTS_WORLDMATRIX(181) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex
},
2975 { /*438, WINED3DTS_WORLDMATRIX(182) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex
},
2976 { /*439, WINED3DTS_WORLDMATRIX(183) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex
},
2977 { /*440, WINED3DTS_WORLDMATRIX(184) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex
},
2978 { /*441, WINED3DTS_WORLDMATRIX(185) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex
},
2979 { /*441, WINED3DTS_WORLDMATRIX(186) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex
},
2980 { /*443, WINED3DTS_WORLDMATRIX(187) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex
},
2981 { /*444, WINED3DTS_WORLDMATRIX(188) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex
},
2982 { /*445, WINED3DTS_WORLDMATRIX(189) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex
},
2983 { /*446, WINED3DTS_WORLDMATRIX(190) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex
},
2984 { /*447, WINED3DTS_WORLDMATRIX(191) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex
},
2985 { /*448, WINED3DTS_WORLDMATRIX(192) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex
},
2986 { /*449, WINED3DTS_WORLDMATRIX(193) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex
},
2987 { /*450, WINED3DTS_WORLDMATRIX(194) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex
},
2988 { /*451, WINED3DTS_WORLDMATRIX(195) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex
},
2989 { /*452, WINED3DTS_WORLDMATRIX(196) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex
},
2990 { /*453, WINED3DTS_WORLDMATRIX(197) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex
},
2991 { /*454, WINED3DTS_WORLDMATRIX(198) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex
},
2992 { /*455, WINED3DTS_WORLDMATRIX(199) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex
},
2993 { /*356, WINED3DTS_WORLDMATRIX(200) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex
},
2994 { /*457, WINED3DTS_WORLDMATRIX(201) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex
},
2995 { /*458, WINED3DTS_WORLDMATRIX(202) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex
},
2996 { /*459, WINED3DTS_WORLDMATRIX(203) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex
},
2997 { /*460, WINED3DTS_WORLDMATRIX(204) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex
},
2998 { /*461, WINED3DTS_WORLDMATRIX(205) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex
},
2999 { /*462, WINED3DTS_WORLDMATRIX(206) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex
},
3000 { /*463, WINED3DTS_WORLDMATRIX(207) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex
},
3001 { /*464, WINED3DTS_WORLDMATRIX(208) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex
},
3002 { /*465, WINED3DTS_WORLDMATRIX(209) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex
},
3003 { /*466, WINED3DTS_WORLDMATRIX(210) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex
},
3004 { /*467, WINED3DTS_WORLDMATRIX(211) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex
},
3005 { /*468, WINED3DTS_WORLDMATRIX(212) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex
},
3006 { /*469, WINED3DTS_WORLDMATRIX(213) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex
},
3007 { /*470, WINED3DTS_WORLDMATRIX(214) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex
},
3008 { /*471, WINED3DTS_WORLDMATRIX(215) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex
},
3009 { /*472, WINED3DTS_WORLDMATRIX(216) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex
},
3010 { /*473, WINED3DTS_WORLDMATRIX(217) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex
},
3011 { /*474, WINED3DTS_WORLDMATRIX(218) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex
},
3012 { /*475, WINED3DTS_WORLDMATRIX(219) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex
},
3013 { /*476, WINED3DTS_WORLDMATRIX(220) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex
},
3014 { /*477, WINED3DTS_WORLDMATRIX(221) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex
},
3015 { /*478, WINED3DTS_WORLDMATRIX(222) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex
},
3016 { /*479, WINED3DTS_WORLDMATRIX(223) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex
},
3017 { /*480, WINED3DTS_WORLDMATRIX(224) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex
},
3018 { /*481, WINED3DTS_WORLDMATRIX(225) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex
},
3019 { /*482, WINED3DTS_WORLDMATRIX(226) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex
},
3020 { /*483, WINED3DTS_WORLDMATRIX(227) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex
},
3021 { /*484, WINED3DTS_WORLDMATRIX(228) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex
},
3022 { /*485, WINED3DTS_WORLDMATRIX(229) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex
},
3023 { /*486, WINED3DTS_WORLDMATRIX(230) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex
},
3024 { /*487, WINED3DTS_WORLDMATRIX(231) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex
},
3025 { /*488, WINED3DTS_WORLDMATRIX(232) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex
},
3026 { /*489, WINED3DTS_WORLDMATRIX(233) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex
},
3027 { /*490, WINED3DTS_WORLDMATRIX(234) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex
},
3028 { /*491, WINED3DTS_WORLDMATRIX(235) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex
},
3029 { /*492, WINED3DTS_WORLDMATRIX(236) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex
},
3030 { /*493, WINED3DTS_WORLDMATRIX(237) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex
},
3031 { /*494, WINED3DTS_WORLDMATRIX(238) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex
},
3032 { /*495, WINED3DTS_WORLDMATRIX(239) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex
},
3033 { /*496, WINED3DTS_WORLDMATRIX(240) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex
},
3034 { /*497, WINED3DTS_WORLDMATRIX(241) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex
},
3035 { /*498, WINED3DTS_WORLDMATRIX(242) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex
},
3036 { /*499, WINED3DTS_WORLDMATRIX(243) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex
},
3037 { /*500, WINED3DTS_WORLDMATRIX(244) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex
},
3038 { /*501, WINED3DTS_WORLDMATRIX(245) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex
},
3039 { /*502, WINED3DTS_WORLDMATRIX(246) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex
},
3040 { /*503, WINED3DTS_WORLDMATRIX(247) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex
},
3041 { /*504, WINED3DTS_WORLDMATRIX(248) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex
},
3042 { /*505, WINED3DTS_WORLDMATRIX(249) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex
},
3043 { /*506, WINED3DTS_WORLDMATRIX(250) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex
},
3044 { /*507, WINED3DTS_WORLDMATRIX(251) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex
},
3045 { /*508, WINED3DTS_WORLDMATRIX(252) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex
},
3046 { /*509, WINED3DTS_WORLDMATRIX(253) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex
},
3047 { /*510, WINED3DTS_WORLDMATRIX(254) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex
},
3048 { /*511, WINED3DTS_WORLDMATRIX(255) */ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex
},
3049 /* Various Vertex states follow */
3050 { /* , STATE_STREAMSRC */ STATE_VDECL
, vertexdeclaration
},
3051 { /* , STATE_VDECL */ STATE_VDECL
, vertexdeclaration
},
3052 { /* , STATE_VSHADER */ STATE_VDECL
, vertexdeclaration
},
3053 { /* , STATE_VIEWPORT */ STATE_VDECL
, vertexdeclaration
},