2 * Direct3D state management
4 * Copyright 2002 Lionel Ulmer
5 * Copyright 2002-2005 Jason Edmeades
6 * Copyright 2003-2004 Raphael Junqueira
7 * Copyright 2004 Christian Costa
8 * Copyright 2005 Oliver Stieber
9 * Copyright 2006 Henri Verbeet
10 * Copyright 2006-2008 Stefan Dösinger for CodeWeavers
11 * Copyright 2009-2010 Henri Verbeet for CodeWeavers
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "wined3d_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
36 WINE_DECLARE_DEBUG_CHANNEL(d3d_shader
);
38 /* GL locking for state handlers is done by the caller. */
40 static void state_blendop(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
);
42 static void state_undefined(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
44 ERR("Undefined state.\n");
47 static void state_nop(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
49 TRACE("%s: nop in current pipe config.\n", debug_d3dstate(state
));
52 static void state_fillmode(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
54 WINED3DFILLMODE Value
= stateblock
->state
.render_states
[WINED3DRS_FILLMODE
];
57 case WINED3DFILL_POINT
:
58 glPolygonMode(GL_FRONT_AND_BACK
, GL_POINT
);
59 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
61 case WINED3DFILL_WIREFRAME
:
62 glPolygonMode(GL_FRONT_AND_BACK
, GL_LINE
);
63 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
65 case WINED3DFILL_SOLID
:
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
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
76 /* Lighting is not enabled if transformed vertices are drawn
77 * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
78 * This state reads the decoded vertex declaration, so if it is dirty don't do anything. The
79 * vertex declaration applying function calls this function for updating
82 if(isStateDirty(context
, STATE_VDECL
)) {
86 if (stateblock
->state
.render_states
[WINED3DRS_LIGHTING
]
87 && !stateblock
->device
->strided_streams
.position_transformed
)
89 glEnable(GL_LIGHTING
);
90 checkGLcall("glEnable GL_LIGHTING");
92 glDisable(GL_LIGHTING
);
93 checkGLcall("glDisable GL_LIGHTING");
97 static void state_zenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
99 /* No z test without depth stencil buffers */
100 if (!stateblock
->device
->depth_stencil
)
102 TRACE("No Z buffer - disabling depth test\n");
103 glDisable(GL_DEPTH_TEST
); /* This also disables z writing in gl */
104 checkGLcall("glDisable GL_DEPTH_TEST");
108 switch (stateblock
->state
.render_states
[WINED3DRS_ZENABLE
])
110 case WINED3DZB_FALSE
:
111 glDisable(GL_DEPTH_TEST
);
112 checkGLcall("glDisable GL_DEPTH_TEST");
115 glEnable(GL_DEPTH_TEST
);
116 checkGLcall("glEnable GL_DEPTH_TEST");
119 glEnable(GL_DEPTH_TEST
);
120 checkGLcall("glEnable GL_DEPTH_TEST");
121 FIXME("W buffer is not well handled\n");
124 FIXME("Unrecognized D3DZBUFFERTYPE value %#x.\n",
125 stateblock
->state
.render_states
[WINED3DRS_ZENABLE
]);
129 static void state_cullmode(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
131 /* glFrontFace() is set in context.c at context init and on an
132 * offscreen / onscreen rendering switch. */
133 switch (stateblock
->state
.render_states
[WINED3DRS_CULLMODE
])
135 case WINED3DCULL_NONE
:
136 glDisable(GL_CULL_FACE
);
137 checkGLcall("glDisable GL_CULL_FACE");
140 glEnable(GL_CULL_FACE
);
141 checkGLcall("glEnable GL_CULL_FACE");
142 glCullFace(GL_FRONT
);
143 checkGLcall("glCullFace(GL_FRONT)");
145 case WINED3DCULL_CCW
:
146 glEnable(GL_CULL_FACE
);
147 checkGLcall("glEnable GL_CULL_FACE");
149 checkGLcall("glCullFace(GL_BACK)");
152 FIXME("Unrecognized/Unhandled WINED3DCULL value %#x.\n",
153 stateblock
->state
.render_states
[WINED3DRS_CULLMODE
]);
157 static void state_shademode(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
159 switch (stateblock
->state
.render_states
[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 %#x.\n",
174 stateblock
->state
.render_states
[WINED3DRS_SHADEMODE
]);
178 static void state_ditherenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
180 if (stateblock
->state
.render_states
[WINED3DRS_DITHERENABLE
])
183 checkGLcall("glEnable GL_DITHER");
187 glDisable(GL_DITHER
);
188 checkGLcall("glDisable GL_DITHER");
192 static void state_zwritenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
194 /* TODO: Test if in d3d z writing is enabled even if ZENABLE is off.
195 * If yes, this has to be merged with ZENABLE and ZFUNC. */
196 if (stateblock
->state
.render_states
[WINED3DRS_ZWRITEENABLE
])
199 checkGLcall("glDepthMask(1)");
204 checkGLcall("glDepthMask(0)");
208 static void state_zfunc(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
210 GLenum depth_func
= CompareFunc(stateblock
->state
.render_states
[WINED3DRS_ZFUNC
]);
212 if (!depth_func
) return;
214 if (depth_func
== GL_EQUAL
|| depth_func
== GL_NOTEQUAL
)
217 /* There are a few issues with this: First, our inability to
218 * select a proper Z depth, most of the time we're stuck with
219 * D24S8, even if the app selects D32 or D16. There seem to be
220 * some other precision problems which have to be debugged to
221 * make NOTEQUAL and EQUAL work properly. */
225 FIXME("D3DCMP_NOTEQUAL and D3DCMP_EQUAL do not work correctly yet.\n");
229 glDepthFunc(depth_func
);
230 checkGLcall("glDepthFunc");
233 static void state_ambient(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
236 D3DCOLORTOGLFLOAT4(stateblock
->state
.render_states
[WINED3DRS_AMBIENT
], col
);
238 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col
[0], col
[1], col
[2], col
[3]);
239 glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, col
);
240 checkGLcall("glLightModel for MODEL_AMBIENT");
243 static void state_blend(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
245 IWineD3DSurfaceImpl
*target
= stateblock
->device
->render_targets
[0];
246 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
247 int srcBlend
= GL_ZERO
;
248 int dstBlend
= GL_ZERO
;
250 /* According to the red book, GL_LINE_SMOOTH needs GL_BLEND with specific
251 * blending parameters to work. */
252 if (stateblock
->state
.render_states
[WINED3DRS_ALPHABLENDENABLE
]
253 || stateblock
->state
.render_states
[WINED3DRS_EDGEANTIALIAS
]
254 || stateblock
->state
.render_states
[WINED3DRS_ANTIALIASEDLINEENABLE
])
256 /* Disable blending in all cases even without pixelshaders.
257 * With blending on we could face a big performance penalty.
258 * The d3d9 visual test confirms the behavior. */
259 if (context
->render_offscreen
260 && !(target
->resource
.format
->flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
))
263 checkGLcall("glDisable GL_BLEND");
267 checkGLcall("glEnable GL_BLEND");
271 checkGLcall("glDisable GL_BLEND");
272 /* Nothing more to do - get out */
276 switch (stateblock
->state
.render_states
[WINED3DRS_DESTBLEND
])
278 case WINED3DBLEND_ZERO
: dstBlend
= GL_ZERO
; break;
279 case WINED3DBLEND_ONE
: dstBlend
= GL_ONE
; break;
280 case WINED3DBLEND_SRCCOLOR
: dstBlend
= GL_SRC_COLOR
; break;
281 case WINED3DBLEND_INVSRCCOLOR
: dstBlend
= GL_ONE_MINUS_SRC_COLOR
; break;
282 case WINED3DBLEND_SRCALPHA
: dstBlend
= GL_SRC_ALPHA
; break;
283 case WINED3DBLEND_INVSRCALPHA
: dstBlend
= GL_ONE_MINUS_SRC_ALPHA
; break;
284 case WINED3DBLEND_DESTCOLOR
: dstBlend
= GL_DST_COLOR
; break;
285 case WINED3DBLEND_INVDESTCOLOR
: dstBlend
= GL_ONE_MINUS_DST_COLOR
; break;
287 /* To compensate the lack of format switching with backbuffer offscreen rendering,
288 * and with onscreen rendering, we modify the alpha test parameters for (INV)DESTALPHA
289 * if the render target doesn't support alpha blending. A nonexistent alpha channel
290 * returns 1.0, so D3DBLEND_DESTALPHA is GL_ONE, and D3DBLEND_INVDESTALPHA is GL_ZERO
292 case WINED3DBLEND_DESTALPHA
:
293 dstBlend
= target
->resource
.format
->alpha_mask
? GL_DST_ALPHA
: GL_ONE
;
295 case WINED3DBLEND_INVDESTALPHA
:
296 dstBlend
= target
->resource
.format
->alpha_mask
? GL_ONE_MINUS_DST_ALPHA
: GL_ZERO
;
299 case WINED3DBLEND_SRCALPHASAT
:
300 dstBlend
= GL_SRC_ALPHA_SATURATE
;
301 WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
304 /* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
305 * values which are still valid up to d3d9. They should not occur as dest blend values
307 case WINED3DBLEND_BOTHSRCALPHA
: dstBlend
= GL_SRC_ALPHA
;
308 srcBlend
= GL_SRC_ALPHA
;
309 FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
312 case WINED3DBLEND_BOTHINVSRCALPHA
: dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
313 srcBlend
= GL_ONE_MINUS_SRC_ALPHA
;
314 FIXME("WINED3DRS_DESTBLEND = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
317 case WINED3DBLEND_BLENDFACTOR
: dstBlend
= GL_CONSTANT_COLOR
; break;
318 case WINED3DBLEND_INVBLENDFACTOR
: dstBlend
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
320 FIXME("Unrecognized dst blend value %#x.\n",
321 stateblock
->state
.render_states
[WINED3DRS_DESTBLEND
]);
324 switch (stateblock
->state
.render_states
[WINED3DRS_SRCBLEND
])
326 case WINED3DBLEND_ZERO
: srcBlend
= GL_ZERO
; break;
327 case WINED3DBLEND_ONE
: srcBlend
= GL_ONE
; break;
328 case WINED3DBLEND_SRCCOLOR
: srcBlend
= GL_SRC_COLOR
; break;
329 case WINED3DBLEND_INVSRCCOLOR
: srcBlend
= GL_ONE_MINUS_SRC_COLOR
; break;
330 case WINED3DBLEND_SRCALPHA
: srcBlend
= GL_SRC_ALPHA
; break;
331 case WINED3DBLEND_INVSRCALPHA
: srcBlend
= GL_ONE_MINUS_SRC_ALPHA
; break;
332 case WINED3DBLEND_DESTCOLOR
: srcBlend
= GL_DST_COLOR
; break;
333 case WINED3DBLEND_INVDESTCOLOR
: srcBlend
= GL_ONE_MINUS_DST_COLOR
; break;
334 case WINED3DBLEND_SRCALPHASAT
: srcBlend
= GL_SRC_ALPHA_SATURATE
; break;
336 case WINED3DBLEND_DESTALPHA
:
337 srcBlend
= target
->resource
.format
->alpha_mask
? GL_DST_ALPHA
: GL_ONE
;
339 case WINED3DBLEND_INVDESTALPHA
:
340 srcBlend
= target
->resource
.format
->alpha_mask
? GL_ONE_MINUS_DST_ALPHA
: GL_ZERO
;
343 case WINED3DBLEND_BOTHSRCALPHA
: srcBlend
= GL_SRC_ALPHA
;
344 dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
347 case WINED3DBLEND_BOTHINVSRCALPHA
: srcBlend
= GL_ONE_MINUS_SRC_ALPHA
;
348 dstBlend
= GL_SRC_ALPHA
;
351 case WINED3DBLEND_BLENDFACTOR
: srcBlend
= GL_CONSTANT_COLOR
; break;
352 case WINED3DBLEND_INVBLENDFACTOR
: srcBlend
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
354 FIXME("Unrecognized src blend value %#x.\n",
355 stateblock
->state
.render_states
[WINED3DRS_SRCBLEND
]);
358 if (stateblock
->state
.render_states
[WINED3DRS_EDGEANTIALIAS
]
359 || stateblock
->state
.render_states
[WINED3DRS_ANTIALIASEDLINEENABLE
])
361 glEnable(GL_LINE_SMOOTH
);
362 checkGLcall("glEnable(GL_LINE_SMOOTH)");
363 if(srcBlend
!= GL_SRC_ALPHA
) {
364 WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
366 if(dstBlend
!= GL_ONE_MINUS_SRC_ALPHA
&& dstBlend
!= GL_ONE
) {
367 WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
370 glDisable(GL_LINE_SMOOTH
);
371 checkGLcall("glDisable(GL_LINE_SMOOTH)");
374 /* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
375 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_BLENDOP
))) {
376 state_blendop(STATE_RENDER(WINED3DRS_BLENDOPALPHA
), stateblock
, context
);
379 if (stateblock
->state
.render_states
[WINED3DRS_SEPARATEALPHABLENDENABLE
])
381 int srcBlendAlpha
= GL_ZERO
;
382 int dstBlendAlpha
= GL_ZERO
;
384 /* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
385 if (!context
->gl_info
->supported
[EXT_BLEND_FUNC_SEPARATE
])
387 WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparateEXT\n");
391 switch (stateblock
->state
.render_states
[WINED3DRS_DESTBLENDALPHA
])
393 case WINED3DBLEND_ZERO
: dstBlendAlpha
= GL_ZERO
; break;
394 case WINED3DBLEND_ONE
: dstBlendAlpha
= GL_ONE
; break;
395 case WINED3DBLEND_SRCCOLOR
: dstBlendAlpha
= GL_SRC_COLOR
; break;
396 case WINED3DBLEND_INVSRCCOLOR
: dstBlendAlpha
= GL_ONE_MINUS_SRC_COLOR
; break;
397 case WINED3DBLEND_SRCALPHA
: dstBlendAlpha
= GL_SRC_ALPHA
; break;
398 case WINED3DBLEND_INVSRCALPHA
: dstBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
; break;
399 case WINED3DBLEND_DESTCOLOR
: dstBlendAlpha
= GL_DST_COLOR
; break;
400 case WINED3DBLEND_INVDESTCOLOR
: dstBlendAlpha
= GL_ONE_MINUS_DST_COLOR
; break;
401 case WINED3DBLEND_DESTALPHA
: dstBlendAlpha
= GL_DST_ALPHA
; break;
402 case WINED3DBLEND_INVDESTALPHA
: dstBlendAlpha
= GL_DST_ALPHA
; break;
403 case WINED3DBLEND_SRCALPHASAT
:
404 dstBlend
= GL_SRC_ALPHA_SATURATE
;
405 WARN("Application uses SRCALPHASAT as dest blend factor, expect problems\n");
407 /* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy source blending
408 * values which are still valid up to d3d9. They should not occur as dest blend values
410 case WINED3DBLEND_BOTHSRCALPHA
:
411 dstBlendAlpha
= GL_SRC_ALPHA
;
412 srcBlendAlpha
= GL_SRC_ALPHA
;
413 FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHSRCALPHA, what to do?\n");
415 case WINED3DBLEND_BOTHINVSRCALPHA
:
416 dstBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
417 srcBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
418 FIXME("WINED3DRS_DESTBLENDALPHA = WINED3DBLEND_BOTHINVSRCALPHA, what to do?\n");
420 case WINED3DBLEND_BLENDFACTOR
: dstBlendAlpha
= GL_CONSTANT_COLOR
; break;
421 case WINED3DBLEND_INVBLENDFACTOR
: dstBlendAlpha
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
423 FIXME("Unrecognized dst blend alpha value %#x.\n",
424 stateblock
->state
.render_states
[WINED3DRS_DESTBLENDALPHA
]);
427 switch (stateblock
->state
.render_states
[WINED3DRS_SRCBLENDALPHA
])
429 case WINED3DBLEND_ZERO
: srcBlendAlpha
= GL_ZERO
; break;
430 case WINED3DBLEND_ONE
: srcBlendAlpha
= GL_ONE
; break;
431 case WINED3DBLEND_SRCCOLOR
: srcBlendAlpha
= GL_SRC_COLOR
; break;
432 case WINED3DBLEND_INVSRCCOLOR
: srcBlendAlpha
= GL_ONE_MINUS_SRC_COLOR
; break;
433 case WINED3DBLEND_SRCALPHA
: srcBlendAlpha
= GL_SRC_ALPHA
; break;
434 case WINED3DBLEND_INVSRCALPHA
: srcBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
; break;
435 case WINED3DBLEND_DESTCOLOR
: srcBlendAlpha
= GL_DST_COLOR
; break;
436 case WINED3DBLEND_INVDESTCOLOR
: srcBlendAlpha
= GL_ONE_MINUS_DST_COLOR
; break;
437 case WINED3DBLEND_SRCALPHASAT
: srcBlendAlpha
= GL_SRC_ALPHA_SATURATE
; break;
438 case WINED3DBLEND_DESTALPHA
: srcBlendAlpha
= GL_DST_ALPHA
; break;
439 case WINED3DBLEND_INVDESTALPHA
: srcBlendAlpha
= GL_DST_ALPHA
; break;
440 case WINED3DBLEND_BOTHSRCALPHA
:
441 srcBlendAlpha
= GL_SRC_ALPHA
;
442 dstBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
444 case WINED3DBLEND_BOTHINVSRCALPHA
:
445 srcBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
446 dstBlendAlpha
= GL_SRC_ALPHA
;
448 case WINED3DBLEND_BLENDFACTOR
: srcBlendAlpha
= GL_CONSTANT_COLOR
; break;
449 case WINED3DBLEND_INVBLENDFACTOR
: srcBlendAlpha
= GL_ONE_MINUS_CONSTANT_COLOR
; break;
451 FIXME("Unrecognized src blend alpha value %#x.\n",
452 stateblock
->state
.render_states
[WINED3DRS_SRCBLENDALPHA
]);
455 GL_EXTCALL(glBlendFuncSeparateEXT(srcBlend
, dstBlend
, srcBlendAlpha
, dstBlendAlpha
));
456 checkGLcall("glBlendFuncSeparateEXT");
458 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend
, dstBlend
);
459 glBlendFunc(srcBlend
, dstBlend
);
460 checkGLcall("glBlendFunc");
463 /* colorkey fixup for stage 0 alphaop depends on WINED3DRS_ALPHABLENDENABLE state,
464 so it may need updating */
465 if (stateblock
->state
.render_states
[WINED3DRS_COLORKEYENABLE
])
466 stateblock_apply_state(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), stateblock
, context
);
469 static void state_blendfactor_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
471 WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
474 static void state_blendfactor(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
476 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
479 TRACE("Setting blend factor to %#x.\n", stateblock
->state
.render_states
[WINED3DRS_BLENDFACTOR
]);
480 D3DCOLORTOGLFLOAT4(stateblock
->state
.render_states
[WINED3DRS_BLENDFACTOR
], col
);
481 GL_EXTCALL(glBlendColorEXT (col
[0],col
[1],col
[2],col
[3]));
482 checkGLcall("glBlendColor");
485 static void state_alpha(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
489 BOOL enable_ckey
= FALSE
;
491 TRACE("state %#x, stateblock %p, context %p\n", state
, stateblock
, context
);
493 /* Find out if the texture on the first stage has a ckey set
494 * The alpha state func reads the texture settings, even though alpha and texture are not grouped
495 * together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
496 * used WINED3DRS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
497 * in case it finds some texture+colorkeyenable combination which needs extra care.
499 if (stateblock
->state
.textures
[0])
501 IWineD3DBaseTextureImpl
*texture
= stateblock
->state
.textures
[0];
502 GLenum texture_dimensions
= texture
->baseTexture
.target
;
504 if (texture_dimensions
== GL_TEXTURE_2D
|| texture_dimensions
== GL_TEXTURE_RECTANGLE_ARB
)
506 IWineD3DSurfaceImpl
*surf
= surface_from_resource(texture
->baseTexture
.sub_resources
[0]);
508 if (surf
->CKeyFlags
& WINEDDSD_CKSRCBLT
)
510 /* The surface conversion does not do color keying conversion for surfaces that have an alpha
511 * channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
512 * surface has alpha bits */
513 if (!surf
->resource
.format
->alpha_mask
) enable_ckey
= TRUE
;
518 if (enable_ckey
|| context
->last_was_ckey
)
519 stateblock_apply_state(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), stateblock
, context
);
520 context
->last_was_ckey
= enable_ckey
;
522 if (stateblock
->state
.render_states
[WINED3DRS_ALPHATESTENABLE
]
523 || (stateblock
->state
.render_states
[WINED3DRS_COLORKEYENABLE
] && enable_ckey
))
525 glEnable(GL_ALPHA_TEST
);
526 checkGLcall("glEnable GL_ALPHA_TEST");
528 glDisable(GL_ALPHA_TEST
);
529 checkGLcall("glDisable GL_ALPHA_TEST");
530 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
536 if (stateblock
->state
.render_states
[WINED3DRS_COLORKEYENABLE
] && enable_ckey
)
538 glParm
= GL_NOTEQUAL
;
541 ref
= ((float)stateblock
->state
.render_states
[WINED3DRS_ALPHAREF
]) / 255.0f
;
542 glParm
= CompareFunc(stateblock
->state
.render_states
[WINED3DRS_ALPHAFUNC
]);
545 glAlphaFunc(glParm
, ref
);
546 checkGLcall("glAlphaFunc");
550 static void state_clipping(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
552 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
553 const struct wined3d_state
*state
= &stateblock
->state
;
554 DWORD enable
= 0xFFFFFFFF;
555 DWORD disable
= 0x00000000;
557 if (!stateblock
->device
->vs_clipping
&& use_vs(state
))
559 /* The spec says that opengl clipping planes are disabled when using shaders. Direct3D planes aren't,
560 * so that is an issue. The MacOS ATI driver keeps clipping planes activated with shaders in some
561 * conditions I got sick of tracking down. The shader state handler disables all clip planes because
562 * of that - don't do anything here and keep them disabled
564 if (state
->render_states
[WINED3DRS_CLIPPLANEENABLE
])
566 static BOOL warned
= FALSE
;
568 FIXME("Clipping not supported with vertex shaders\n");
575 /* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
576 * of already set values
579 /* If enabling / disabling all
580 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
582 if (state
->render_states
[WINED3DRS_CLIPPING
])
584 enable
= state
->render_states
[WINED3DRS_CLIPPLANEENABLE
];
585 disable
= ~state
->render_states
[WINED3DRS_CLIPPLANEENABLE
];
586 if (gl_info
->supported
[ARB_DEPTH_CLAMP
])
588 glDisable(GL_DEPTH_CLAMP
);
589 checkGLcall("glDisable(GL_DEPTH_CLAMP)");
592 disable
= 0xffffffff;
594 if (gl_info
->supported
[ARB_DEPTH_CLAMP
])
596 glEnable(GL_DEPTH_CLAMP
);
597 checkGLcall("glEnable(GL_DEPTH_CLAMP)");
601 FIXME("Clipping disabled, but ARB_depth_clamp isn't supported.\n");
605 if (enable
& WINED3DCLIPPLANE0
) { glEnable(GL_CLIP_PLANE0
); checkGLcall("glEnable(clip plane 0)"); }
606 if (enable
& WINED3DCLIPPLANE1
) { glEnable(GL_CLIP_PLANE1
); checkGLcall("glEnable(clip plane 1)"); }
607 if (enable
& WINED3DCLIPPLANE2
) { glEnable(GL_CLIP_PLANE2
); checkGLcall("glEnable(clip plane 2)"); }
608 if (enable
& WINED3DCLIPPLANE3
) { glEnable(GL_CLIP_PLANE3
); checkGLcall("glEnable(clip plane 3)"); }
609 if (enable
& WINED3DCLIPPLANE4
) { glEnable(GL_CLIP_PLANE4
); checkGLcall("glEnable(clip plane 4)"); }
610 if (enable
& WINED3DCLIPPLANE5
) { glEnable(GL_CLIP_PLANE5
); checkGLcall("glEnable(clip plane 5)"); }
612 if (disable
& WINED3DCLIPPLANE0
) { glDisable(GL_CLIP_PLANE0
); checkGLcall("glDisable(clip plane 0)"); }
613 if (disable
& WINED3DCLIPPLANE1
) { glDisable(GL_CLIP_PLANE1
); checkGLcall("glDisable(clip plane 1)"); }
614 if (disable
& WINED3DCLIPPLANE2
) { glDisable(GL_CLIP_PLANE2
); checkGLcall("glDisable(clip plane 2)"); }
615 if (disable
& WINED3DCLIPPLANE3
) { glDisable(GL_CLIP_PLANE3
); checkGLcall("glDisable(clip plane 3)"); }
616 if (disable
& WINED3DCLIPPLANE4
) { glDisable(GL_CLIP_PLANE4
); checkGLcall("glDisable(clip plane 4)"); }
617 if (disable
& WINED3DCLIPPLANE5
) { glDisable(GL_CLIP_PLANE5
); checkGLcall("glDisable(clip plane 5)"); }
619 /** update clipping status */
622 stateblock
->state
.clip_status
.ClipUnion
= 0;
623 stateblock
->state
.clip_status
.ClipIntersection
= 0xFFFFFFFF;
627 stateblock
->state
.clip_status
.ClipUnion
= 0;
628 stateblock
->state
.clip_status
.ClipIntersection
= 0;
632 static void state_blendop_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
634 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
637 static void state_blendop(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
639 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
640 int blendEquation
= GL_FUNC_ADD
;
641 int blendEquationAlpha
= GL_FUNC_ADD
;
643 /* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
644 if (stateblock
->state
.render_states
[WINED3DRS_BLENDOPALPHA
]
645 && !gl_info
->supported
[EXT_BLEND_EQUATION_SEPARATE
])
647 WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
651 switch (stateblock
->state
.render_states
[WINED3DRS_BLENDOP
])
653 case WINED3DBLENDOP_ADD
: blendEquation
= GL_FUNC_ADD
; break;
654 case WINED3DBLENDOP_SUBTRACT
: blendEquation
= GL_FUNC_SUBTRACT
; break;
655 case WINED3DBLENDOP_REVSUBTRACT
: blendEquation
= GL_FUNC_REVERSE_SUBTRACT
; break;
656 case WINED3DBLENDOP_MIN
: blendEquation
= GL_MIN
; break;
657 case WINED3DBLENDOP_MAX
: blendEquation
= GL_MAX
; break;
659 FIXME("Unrecognized/Unhandled D3DBLENDOP value %#x.\n",
660 stateblock
->state
.render_states
[WINED3DRS_BLENDOP
]);
663 switch (stateblock
->state
.render_states
[WINED3DRS_BLENDOPALPHA
])
665 case WINED3DBLENDOP_ADD
: blendEquationAlpha
= GL_FUNC_ADD
; break;
666 case WINED3DBLENDOP_SUBTRACT
: blendEquationAlpha
= GL_FUNC_SUBTRACT
; break;
667 case WINED3DBLENDOP_REVSUBTRACT
: blendEquationAlpha
= GL_FUNC_REVERSE_SUBTRACT
; break;
668 case WINED3DBLENDOP_MIN
: blendEquationAlpha
= GL_MIN
; break;
669 case WINED3DBLENDOP_MAX
: blendEquationAlpha
= GL_MAX
; break;
671 FIXME("Unrecognized/Unhandled D3DBLENDOP value %#x\n",
672 stateblock
->state
.render_states
[WINED3DRS_BLENDOPALPHA
]);
675 if (stateblock
->state
.render_states
[WINED3DRS_SEPARATEALPHABLENDENABLE
])
677 TRACE("glBlendEquationSeparateEXT(%x, %x)\n", blendEquation
, blendEquationAlpha
);
678 GL_EXTCALL(glBlendEquationSeparateEXT(blendEquation
, blendEquationAlpha
));
679 checkGLcall("glBlendEquationSeparateEXT");
681 TRACE("glBlendEquation(%x)\n", blendEquation
);
682 GL_EXTCALL(glBlendEquationEXT(blendEquation
));
683 checkGLcall("glBlendEquation");
687 static void state_specularenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
689 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
690 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
691 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
692 * specular color. This is wrong:
693 * Separate specular color means the specular colour is maintained separately, whereas
694 * single color means it is merged in. However in both cases they are being used to
696 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
697 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
701 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
702 * Instead, we need to setup the FinalCombiner properly.
704 * The default setup for the FinalCombiner is:
706 * <variable> <input> <mapping> <usage>
707 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
708 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
709 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
710 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
711 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
712 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
713 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
715 * That's pretty much fine as it is, except for variable B, which needs to take
716 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
717 * whether WINED3DRS_SPECULARENABLE is enabled or not.
720 TRACE("Setting specular enable state and materials\n");
721 if (stateblock
->state
.render_states
[WINED3DRS_SPECULARENABLE
])
723 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&stateblock
->state
.material
.Specular
);
724 checkGLcall("glMaterialfv");
726 if (stateblock
->state
.material
.Power
> gl_info
->limits
.shininess
)
728 /* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
729 * and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
730 * allows bigger values. If the extension is supported, gl_info->limits.shininess contains the
731 * value reported by the extension, otherwise 128. For values > gl_info->limits.shininess clamp
732 * them, it should be safe to do so without major visual distortions.
734 WARN("Material power = %f, limit %f\n", stateblock
->state
.material
.Power
, gl_info
->limits
.shininess
);
735 glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, gl_info
->limits
.shininess
);
739 glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, stateblock
->state
.material
.Power
);
741 checkGLcall("glMaterialf(GL_SHININESS)");
743 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
745 glEnable(GL_COLOR_SUM_EXT
);
749 TRACE("Specular colors cannot be enabled in this version of opengl\n");
751 checkGLcall("glEnable(GL_COLOR_SUM)");
753 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
755 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_PLUS_SECONDARY_COLOR_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
756 checkGLcall("glFinalCombinerInputNV()");
759 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
761 /* for the case of enabled lighting: */
762 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
763 checkGLcall("glMaterialfv");
765 /* for the case of disabled lighting: */
766 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
768 glDisable(GL_COLOR_SUM_EXT
);
772 TRACE("Specular colors cannot be disabled in this version of opengl\n");
774 checkGLcall("glDisable(GL_COLOR_SUM)");
776 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
778 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
779 checkGLcall("glFinalCombinerInputNV()");
783 TRACE("(%p) : Diffuse {%.8e, %.8e, %.8e, %.8e}\n", stateblock
->device
,
784 stateblock
->state
.material
.Diffuse
.r
, stateblock
->state
.material
.Diffuse
.g
,
785 stateblock
->state
.material
.Diffuse
.b
, stateblock
->state
.material
.Diffuse
.a
);
786 TRACE("(%p) : Ambient {%.8e, %.8e, %.8e, %.8e}\n", stateblock
->device
,
787 stateblock
->state
.material
.Ambient
.r
, stateblock
->state
.material
.Ambient
.g
,
788 stateblock
->state
.material
.Ambient
.b
, stateblock
->state
.material
.Ambient
.a
);
789 TRACE("(%p) : Specular {%.8e, %.8e, %.8e, %.8e}\n", stateblock
->device
,
790 stateblock
->state
.material
.Specular
.r
, stateblock
->state
.material
.Specular
.g
,
791 stateblock
->state
.material
.Specular
.b
, stateblock
->state
.material
.Specular
.a
);
792 TRACE("(%p) : Emissive {%.8e, %.8e, %.8e, %.8e}\n", stateblock
->device
,
793 stateblock
->state
.material
.Emissive
.r
, stateblock
->state
.material
.Emissive
.g
,
794 stateblock
->state
.material
.Emissive
.b
, stateblock
->state
.material
.Emissive
.a
);
796 glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&stateblock
->state
.material
.Ambient
);
797 checkGLcall("glMaterialfv(GL_AMBIENT)");
798 glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&stateblock
->state
.material
.Diffuse
);
799 checkGLcall("glMaterialfv(GL_DIFFUSE)");
800 glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&stateblock
->state
.material
.Emissive
);
801 checkGLcall("glMaterialfv(GL_EMISSION)");
804 static void state_texfactor(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
806 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
809 /* Note the texture color applies to all textures whereas
810 * GL_TEXTURE_ENV_COLOR applies to active only
813 D3DCOLORTOGLFLOAT4(stateblock
->state
.render_states
[WINED3DRS_TEXTUREFACTOR
], col
);
815 /* And now the default texture color as well */
816 for (i
= 0; i
< gl_info
->limits
.texture_stages
; ++i
)
818 /* Note the WINED3DRS value applies to all textures, but GL has one
819 * per texture, so apply it now ready to be used!
821 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ i
));
822 checkGLcall("glActiveTextureARB");
824 glTexEnvfv(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_COLOR
, &col
[0]);
825 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
829 static void renderstate_stencil_twosided(struct wined3d_context
*context
, GLint face
,
830 GLint func
, GLint ref
, GLuint mask
, GLint stencilFail
, GLint depthFail
, GLint stencilPass
)
832 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
834 glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
835 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
836 GL_EXTCALL(glActiveStencilFaceEXT(face
));
837 checkGLcall("glActiveStencilFaceEXT(...)");
838 glStencilFunc(func
, ref
, mask
);
839 checkGLcall("glStencilFunc(...)");
840 glStencilOp(stencilFail
, depthFail
, stencilPass
);
841 checkGLcall("glStencilOp(...)");
844 static void state_stencil(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
846 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
847 DWORD onesided_enable
= FALSE
;
848 DWORD twosided_enable
= FALSE
;
849 GLint func
= GL_ALWAYS
;
850 GLint func_ccw
= GL_ALWAYS
;
853 GLint stencilFail
= GL_KEEP
;
854 GLint depthFail
= GL_KEEP
;
855 GLint stencilPass
= GL_KEEP
;
856 GLint stencilFail_ccw
= GL_KEEP
;
857 GLint depthFail_ccw
= GL_KEEP
;
858 GLint stencilPass_ccw
= GL_KEEP
;
860 /* No stencil test without a stencil buffer. */
861 if (!stateblock
->device
->depth_stencil
)
863 glDisable(GL_STENCIL_TEST
);
864 checkGLcall("glDisable GL_STENCIL_TEST");
868 onesided_enable
= stateblock
->state
.render_states
[WINED3DRS_STENCILENABLE
];
869 twosided_enable
= stateblock
->state
.render_states
[WINED3DRS_TWOSIDEDSTENCILMODE
];
870 if (!(func
= CompareFunc(stateblock
->state
.render_states
[WINED3DRS_STENCILFUNC
])))
872 if (!(func_ccw
= CompareFunc(stateblock
->state
.render_states
[WINED3DRS_CCW_STENCILFUNC
])))
873 func_ccw
= GL_ALWAYS
;
874 ref
= stateblock
->state
.render_states
[WINED3DRS_STENCILREF
];
875 mask
= stateblock
->state
.render_states
[WINED3DRS_STENCILMASK
];
876 stencilFail
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_STENCILFAIL
]);
877 depthFail
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_STENCILZFAIL
]);
878 stencilPass
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_STENCILPASS
]);
879 stencilFail_ccw
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_CCW_STENCILFAIL
]);
880 depthFail_ccw
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_CCW_STENCILZFAIL
]);
881 stencilPass_ccw
= StencilOp(stateblock
->state
.render_states
[WINED3DRS_CCW_STENCILPASS
]);
883 TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
884 "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
885 "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
886 onesided_enable
, twosided_enable
, ref
, mask
,
887 func
, stencilFail
, depthFail
, stencilPass
,
888 func_ccw
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
890 if (twosided_enable
&& onesided_enable
) {
891 glEnable(GL_STENCIL_TEST
);
892 checkGLcall("glEnable GL_STENCIL_TEST");
894 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
896 /* Apply back first, then front. This function calls glActiveStencilFaceEXT,
897 * which has an effect on the code below too. If we apply the front face
898 * afterwards, we are sure that the active stencil face is set to front,
899 * and other stencil functions which do not use two sided stencil do not have
902 renderstate_stencil_twosided(context
, GL_BACK
,
903 func_ccw
, ref
, mask
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
904 renderstate_stencil_twosided(context
, GL_FRONT
,
905 func
, ref
, mask
, stencilFail
, depthFail
, stencilPass
);
907 else if (gl_info
->supported
[ATI_SEPARATE_STENCIL
])
909 GL_EXTCALL(glStencilFuncSeparateATI(func
, func_ccw
, ref
, mask
));
910 checkGLcall("glStencilFuncSeparateATI(...)");
911 GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT
, stencilFail
, depthFail
, stencilPass
));
912 checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
913 GL_EXTCALL(glStencilOpSeparateATI(GL_BACK
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
));
914 checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
916 ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
919 else if(onesided_enable
)
921 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
923 glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
924 checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
927 /* This code disables the ATI extension as well, since the standard stencil functions are equal
928 * to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
930 glEnable(GL_STENCIL_TEST
);
931 checkGLcall("glEnable GL_STENCIL_TEST");
932 glStencilFunc(func
, ref
, mask
);
933 checkGLcall("glStencilFunc(...)");
934 glStencilOp(stencilFail
, depthFail
, stencilPass
);
935 checkGLcall("glStencilOp(...)");
937 glDisable(GL_STENCIL_TEST
);
938 checkGLcall("glDisable GL_STENCIL_TEST");
942 static void state_stencilwrite2s(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
944 DWORD mask
= stateblock
->device
->depth_stencil
? stateblock
->state
.render_states
[WINED3DRS_STENCILWRITEMASK
] : 0;
945 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
947 GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK
));
948 checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
950 checkGLcall("glStencilMask");
951 GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT
));
952 checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
956 static void state_stencilwrite(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
958 DWORD mask
= stateblock
->device
->depth_stencil
? stateblock
->state
.render_states
[WINED3DRS_STENCILWRITEMASK
] : 0;
961 checkGLcall("glStencilMask");
964 static void state_fog_vertexpart(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
967 TRACE("state %#x, stateblock %p, context %p\n", state
, stateblock
, context
);
969 if (!stateblock
->state
.render_states
[WINED3DRS_FOGENABLE
]) return;
971 /* Table fog on: Never use fog coords, and use per-fragment fog */
972 if (stateblock
->state
.render_states
[WINED3DRS_FOGTABLEMODE
] != WINED3DFOG_NONE
)
974 glHint(GL_FOG_HINT
, GL_NICEST
);
975 if(context
->fog_coord
) {
976 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
977 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
978 context
->fog_coord
= FALSE
;
983 /* Otherwise use per-vertex fog in any case */
984 glHint(GL_FOG_HINT
, GL_FASTEST
);
986 if (stateblock
->state
.render_states
[WINED3DRS_FOGVERTEXMODE
] == WINED3DFOG_NONE
|| context
->last_was_rhw
)
988 /* No fog at all, or transformed vertices: Use fog coord */
989 if(!context
->fog_coord
) {
990 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FOG_COORDINATE_EXT
);
991 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
992 context
->fog_coord
= TRUE
;
995 /* Otherwise, use the fragment depth */
996 if(context
->fog_coord
) {
997 glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
998 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
999 context
->fog_coord
= FALSE
;
1004 void state_fogstartend(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1006 float fogstart
, fogend
;
1012 switch(context
->fog_source
) {
1018 case FOGSOURCE_COORD
:
1024 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_FOGSTART
];
1025 fogstart
= tmpvalue
.f
;
1026 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_FOGEND
];
1027 fogend
= tmpvalue
.f
;
1028 /* In GL, fogstart == fogend disables fog, in D3D everything's fogged.*/
1029 if(fogstart
== fogend
) {
1030 fogstart
= -1.0f
/ 0.0f
;
1036 /* This should not happen.context->fog_source is set in wined3d, not the app.
1037 * Still this is needed to make the compiler happy
1039 ERR("Unexpected fog coordinate source\n");
1044 glFogf(GL_FOG_START
, fogstart
);
1045 checkGLcall("glFogf(GL_FOG_START, fogstart)");
1046 TRACE("Fog Start == %f\n", fogstart
);
1048 glFogf(GL_FOG_END
, fogend
);
1049 checkGLcall("glFogf(GL_FOG_END, fogend)");
1050 TRACE("Fog End == %f\n", fogend
);
1053 void state_fog_fragpart(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1055 const struct wined3d_state
*state
= &stateblock
->state
;
1056 enum fogsource new_source
;
1058 TRACE("state_id %#x, stateblock %p, context %p\n", state_id
, stateblock
, context
);
1060 if (!state
->render_states
[WINED3DRS_FOGENABLE
])
1062 /* No fog? Disable it, and we're done :-) */
1063 glDisableWINE(GL_FOG
);
1064 checkGLcall("glDisable GL_FOG");
1070 * With fixed function vertex processing, Direct3D knows 2 different fog input sources.
1071 * It can use the Z value of the vertex, or the alpha component of the specular color.
1072 * This depends on the fog vertex, fog table and the vertex declaration. If the Z value
1073 * is used, fogstart, fogend and the equation type are used, otherwise linear fog with
1074 * start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
1076 * FOGTABLEMODE != NONE:
1077 * The Z value is used, with the equation specified, no matter what vertex type.
1079 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
1080 * Per vertex fog is calculated using the specified fog equation and the parameters
1082 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
1083 * FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
1084 * Linear fog with start = 255.0, end = 0.0, input comes from the specular color
1087 * Rules for vertex fog with shaders:
1089 * When mixing fixed function functionality with the programmable pipeline, D3D expects
1090 * the fog computation to happen during transformation while openGL expects it to happen
1091 * during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
1092 * the pixel shader while openGL always expects the pixel shader to handle the blending.
1093 * To solve this problem, WineD3D does:
1094 * 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
1096 * and 2) disables the fog computation (in either the fixed function or programmable
1097 * rasterizer) if using a vertex program.
1099 * D3D shaders can provide an explicit fog coordinate. This fog coordinate is used with
1100 * D3DRS_FOGTABLEMODE==D3DFOG_NONE. The FOGVERTEXMODE is ignored, d3d always uses linear
1101 * fog with start=1.0 and end=0.0 in this case. This is similar to fog coordinates in
1102 * the specular color, a vertex shader counts as pretransformed geometry in this case.
1103 * There are some GL differences between specular fog coords and vertex shaders though.
1105 * With table fog the vertex shader fog coordinate is ignored.
1107 * If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
1111 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
1112 * the system will apply only pixel(=table) fog effects."
1114 if (state
->render_states
[WINED3DRS_FOGTABLEMODE
] == WINED3DFOG_NONE
)
1118 glFogi(GL_FOG_MODE
, GL_LINEAR
);
1119 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1120 new_source
= FOGSOURCE_VS
;
1124 switch (state
->render_states
[WINED3DRS_FOGVERTEXMODE
])
1126 /* If processed vertices are used, fall through to the NONE case */
1127 case WINED3DFOG_EXP
:
1128 if(!context
->last_was_rhw
) {
1129 glFogi(GL_FOG_MODE
, GL_EXP
);
1130 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1131 new_source
= FOGSOURCE_FFP
;
1136 case WINED3DFOG_EXP2
:
1137 if(!context
->last_was_rhw
) {
1138 glFogi(GL_FOG_MODE
, GL_EXP2
);
1139 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1140 new_source
= FOGSOURCE_FFP
;
1145 case WINED3DFOG_LINEAR
:
1146 if(!context
->last_was_rhw
) {
1147 glFogi(GL_FOG_MODE
, GL_LINEAR
);
1148 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1149 new_source
= FOGSOURCE_FFP
;
1154 case WINED3DFOG_NONE
:
1155 /* Both are none? According to msdn the alpha channel of the specular
1156 * color contains a fog factor. Set it in drawStridedSlow.
1157 * Same happens with Vertexfog on transformed vertices
1159 new_source
= FOGSOURCE_COORD
;
1160 glFogi(GL_FOG_MODE
, GL_LINEAR
);
1161 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1165 FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %#x.\n",
1166 state
->render_states
[WINED3DRS_FOGVERTEXMODE
]);
1167 new_source
= FOGSOURCE_FFP
; /* Make the compiler happy */
1171 new_source
= FOGSOURCE_FFP
;
1173 switch (state
->render_states
[WINED3DRS_FOGTABLEMODE
])
1175 case WINED3DFOG_EXP
:
1176 glFogi(GL_FOG_MODE
, GL_EXP
);
1177 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1180 case WINED3DFOG_EXP2
:
1181 glFogi(GL_FOG_MODE
, GL_EXP2
);
1182 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1185 case WINED3DFOG_LINEAR
:
1186 glFogi(GL_FOG_MODE
, GL_LINEAR
);
1187 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1190 case WINED3DFOG_NONE
: /* Won't happen */
1192 FIXME("Unexpected WINED3DRS_FOGTABLEMODE %#x.\n",
1193 state
->render_states
[WINED3DRS_FOGTABLEMODE
]);
1197 glEnableWINE(GL_FOG
);
1198 checkGLcall("glEnable GL_FOG");
1199 if(new_source
!= context
->fog_source
) {
1200 context
->fog_source
= new_source
;
1201 state_fogstartend(STATE_RENDER(WINED3DRS_FOGSTART
), stateblock
, context
);
1205 static void state_rangefog_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1207 if (stateblock
->state
.render_states
[WINED3DRS_RANGEFOGENABLE
])
1208 WARN("Range fog enabled, but not supported by this opengl implementation\n");
1211 static void state_rangefog(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1213 if (stateblock
->state
.render_states
[WINED3DRS_RANGEFOGENABLE
])
1215 glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_RADIAL_NV
);
1216 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
1218 glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
1219 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1223 void state_fogcolor(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1226 D3DCOLORTOGLFLOAT4(stateblock
->state
.render_states
[WINED3DRS_FOGCOLOR
], col
);
1227 glFogfv(GL_FOG_COLOR
, &col
[0]);
1228 checkGLcall("glFog GL_FOG_COLOR");
1231 void state_fogdensity(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1237 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_FOGDENSITY
];
1238 glFogfv(GL_FOG_DENSITY
, &tmpvalue
.f
);
1239 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
1242 static void state_colormat(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1244 const struct wined3d_state
*state
= &stateblock
->state
;
1245 IWineD3DDeviceImpl
*device
= stateblock
->device
;
1248 /* Depends on the decoded vertex declaration to read the existence of diffuse data.
1249 * The vertex declaration will call this function if the fixed function pipeline is used.
1252 if(isStateDirty(context
, STATE_VDECL
)) {
1256 context
->num_untracked_materials
= 0;
1257 if ((device
->strided_streams
.use_map
& (1 << WINED3D_FFP_DIFFUSE
))
1258 && state
->render_states
[WINED3DRS_COLORVERTEX
])
1260 TRACE("diff %d, amb %d, emis %d, spec %d\n",
1261 state
->render_states
[WINED3DRS_DIFFUSEMATERIALSOURCE
],
1262 state
->render_states
[WINED3DRS_AMBIENTMATERIALSOURCE
],
1263 state
->render_states
[WINED3DRS_EMISSIVEMATERIALSOURCE
],
1264 state
->render_states
[WINED3DRS_SPECULARMATERIALSOURCE
]);
1266 if (state
->render_states
[WINED3DRS_DIFFUSEMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1268 if (state
->render_states
[WINED3DRS_AMBIENTMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1269 Parm
= GL_AMBIENT_AND_DIFFUSE
;
1272 if (state
->render_states
[WINED3DRS_EMISSIVEMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1274 context
->untracked_materials
[context
->num_untracked_materials
] = GL_EMISSION
;
1275 context
->num_untracked_materials
++;
1277 if (state
->render_states
[WINED3DRS_SPECULARMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1279 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1280 context
->num_untracked_materials
++;
1283 else if (state
->render_states
[WINED3DRS_AMBIENTMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1286 if (state
->render_states
[WINED3DRS_EMISSIVEMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1288 context
->untracked_materials
[context
->num_untracked_materials
] = GL_EMISSION
;
1289 context
->num_untracked_materials
++;
1291 if (state
->render_states
[WINED3DRS_SPECULARMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1293 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1294 context
->num_untracked_materials
++;
1297 else if (state
->render_states
[WINED3DRS_EMISSIVEMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1300 if (state
->render_states
[WINED3DRS_SPECULARMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1302 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1303 context
->num_untracked_materials
++;
1306 else if (state
->render_states
[WINED3DRS_SPECULARMATERIALSOURCE
] == WINED3DMCS_COLOR1
)
1312 /* Nothing changed, return. */
1313 if (Parm
== context
->tracking_parm
) return;
1316 glDisable(GL_COLOR_MATERIAL
);
1317 checkGLcall("glDisable GL_COLOR_MATERIAL");
1319 glColorMaterial(GL_FRONT_AND_BACK
, Parm
);
1320 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1321 glEnable(GL_COLOR_MATERIAL
);
1322 checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1325 /* Apparently calls to glMaterialfv are ignored for properties we're
1326 * tracking with glColorMaterial, so apply those here. */
1327 switch (context
->tracking_parm
) {
1328 case GL_AMBIENT_AND_DIFFUSE
:
1329 glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.Ambient
);
1330 glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.Diffuse
);
1331 checkGLcall("glMaterialfv");
1335 glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.Diffuse
);
1336 checkGLcall("glMaterialfv");
1340 glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.Ambient
);
1341 checkGLcall("glMaterialfv");
1345 glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&state
->material
.Emissive
);
1346 checkGLcall("glMaterialfv");
1350 /* Only change material color if specular is enabled, otherwise it is set to black */
1351 if (state
->render_states
[WINED3DRS_SPECULARENABLE
])
1353 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&state
->material
.Specular
);
1354 checkGLcall("glMaterialfv");
1356 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
1357 glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
1358 checkGLcall("glMaterialfv");
1363 context
->tracking_parm
= Parm
;
1366 static void state_linepattern(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1370 WINED3DLINEPATTERN lp
;
1372 tmppattern
.d
= stateblock
->state
.render_states
[WINED3DRS_LINEPATTERN
];
1374 TRACE("Line pattern: repeat %d bits %x\n", tmppattern
.lp
.wRepeatFactor
, tmppattern
.lp
.wLinePattern
);
1376 if (tmppattern
.lp
.wRepeatFactor
) {
1377 glLineStipple(tmppattern
.lp
.wRepeatFactor
, tmppattern
.lp
.wLinePattern
);
1378 checkGLcall("glLineStipple(repeat, linepattern)");
1379 glEnable(GL_LINE_STIPPLE
);
1380 checkGLcall("glEnable(GL_LINE_STIPPLE);");
1382 glDisable(GL_LINE_STIPPLE
);
1383 checkGLcall("glDisable(GL_LINE_STIPPLE);");
1387 static void state_zbias(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1394 if (stateblock
->state
.render_states
[WINED3DRS_ZBIAS
])
1396 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_ZBIAS
];
1397 TRACE("ZBias value %f\n", tmpvalue
.f
);
1398 glPolygonOffset(0, -tmpvalue
.f
);
1399 checkGLcall("glPolygonOffset(0, -Value)");
1400 glEnable(GL_POLYGON_OFFSET_FILL
);
1401 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL);");
1402 glEnable(GL_POLYGON_OFFSET_LINE
);
1403 checkGLcall("glEnable(GL_POLYGON_OFFSET_LINE);");
1404 glEnable(GL_POLYGON_OFFSET_POINT
);
1405 checkGLcall("glEnable(GL_POLYGON_OFFSET_POINT);");
1407 glDisable(GL_POLYGON_OFFSET_FILL
);
1408 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL);");
1409 glDisable(GL_POLYGON_OFFSET_LINE
);
1410 checkGLcall("glDisable(GL_POLYGON_OFFSET_LINE);");
1411 glDisable(GL_POLYGON_OFFSET_POINT
);
1412 checkGLcall("glDisable(GL_POLYGON_OFFSET_POINT);");
1417 static void state_normalize(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1419 if(isStateDirty(context
, STATE_VDECL
)) {
1422 /* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
1423 * from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
1424 * by zero and is not properly defined in opengl, so avoid it
1426 if (stateblock
->state
.render_states
[WINED3DRS_NORMALIZENORMALS
]
1427 && (stateblock
->device
->strided_streams
.use_map
& (1 << WINED3D_FFP_NORMAL
)))
1429 glEnable(GL_NORMALIZE
);
1430 checkGLcall("glEnable(GL_NORMALIZE);");
1432 glDisable(GL_NORMALIZE
);
1433 checkGLcall("glDisable(GL_NORMALIZE);");
1437 static void state_psizemin_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1444 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MIN
];
1445 if (tmpvalue
.f
!= 1.0f
)
1447 FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue
.f
);
1449 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MAX
];
1450 if (tmpvalue
.f
!= 64.0f
)
1452 FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue
.f
);
1457 static void state_psizemin_ext(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1459 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1466 min
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MIN
];
1467 max
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MAX
];
1469 /* Max point size trumps min point size */
1474 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MIN_EXT
, min
.f
);
1475 checkGLcall("glPointParameterfEXT(...)");
1476 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MAX_EXT
, max
.f
);
1477 checkGLcall("glPointParameterfEXT(...)");
1480 static void state_psizemin_arb(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1482 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1489 min
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MIN
];
1490 max
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE_MAX
];
1492 /* Max point size trumps min point size */
1497 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MIN_ARB
, min
.f
);
1498 checkGLcall("glPointParameterfARB(...)");
1499 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MAX_ARB
, max
.f
);
1500 checkGLcall("glPointParameterfARB(...)");
1503 static void state_pscale(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1505 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1506 /* TODO: Group this with the viewport */
1508 * POINTSCALEENABLE controls how point size value is treated. If set to
1509 * true, the point size is scaled with respect to height of viewport.
1510 * When set to false point size is in pixels.
1513 /* Default values */
1514 GLfloat att
[3] = {1.0f
, 0.0f
, 0.0f
};
1518 } pointSize
, A
, B
, C
;
1520 pointSize
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSIZE
];
1521 A
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSCALE_A
];
1522 B
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSCALE_B
];
1523 C
.d
= stateblock
->state
.render_states
[WINED3DRS_POINTSCALE_C
];
1525 if (stateblock
->state
.render_states
[WINED3DRS_POINTSCALEENABLE
])
1527 GLfloat scaleFactor
;
1528 DWORD h
= stateblock
->state
.viewport
.Height
;
1530 if (pointSize
.f
< gl_info
->limits
.pointsize_min
)
1532 /* Minimum valid point size for OpenGL is driver specific. For Direct3D it is
1533 * 0.0f. This means that OpenGL will clamp really small point sizes to the
1534 * driver minimum. To correct for this we need to multiply by the scale factor when sizes
1535 * are less than 1.0f. scale_factor = 1.0f / point_size.
1537 scaleFactor
= pointSize
.f
/ gl_info
->limits
.pointsize_min
;
1538 /* Clamp the point size, don't rely on the driver to do it. MacOS says min point size
1539 * is 1.0, but then accepts points below that and draws too small points
1541 pointSize
.f
= gl_info
->limits
.pointsize_min
;
1543 else if(pointSize
.f
> gl_info
->limits
.pointsize_max
)
1545 /* gl already scales the input to glPointSize,
1546 * d3d scales the result after the point size scale.
1547 * If the point size is bigger than the max size, use the
1548 * scaling to scale it bigger, and set the gl point size to max
1550 scaleFactor
= pointSize
.f
/ gl_info
->limits
.pointsize_max
;
1551 TRACE("scale: %f\n", scaleFactor
);
1552 pointSize
.f
= gl_info
->limits
.pointsize_max
;
1556 scaleFactor
= powf(h
* scaleFactor
, 2);
1558 att
[0] = A
.f
/ scaleFactor
;
1559 att
[1] = B
.f
/ scaleFactor
;
1560 att
[2] = C
.f
/ scaleFactor
;
1563 if (gl_info
->supported
[ARB_POINT_PARAMETERS
])
1565 GL_EXTCALL(glPointParameterfvARB
)(GL_POINT_DISTANCE_ATTENUATION_ARB
, att
);
1566 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
1568 else if (gl_info
->supported
[EXT_POINT_PARAMETERS
])
1570 GL_EXTCALL(glPointParameterfvEXT
)(GL_DISTANCE_ATTENUATION_EXT
, att
);
1571 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
1573 else if(stateblock
->state
.render_states
[WINED3DRS_POINTSCALEENABLE
])
1575 WARN("POINT_PARAMETERS not supported in this version of opengl\n");
1578 glPointSize(pointSize
.f
);
1579 checkGLcall("glPointSize(...);");
1582 static void state_debug_monitor(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1584 WARN("token: %#x\n", stateblock
->state
.render_states
[WINED3DRS_DEBUGMONITORTOKEN
]);
1587 static void state_colorwrite(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1589 DWORD mask0
= stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE
];
1590 DWORD mask1
= stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE1
];
1591 DWORD mask2
= stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE2
];
1592 DWORD mask3
= stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE3
];
1594 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1595 mask0
& WINED3DCOLORWRITEENABLE_RED
? 1 : 0,
1596 mask0
& WINED3DCOLORWRITEENABLE_GREEN
? 1 : 0,
1597 mask0
& WINED3DCOLORWRITEENABLE_BLUE
? 1 : 0,
1598 mask0
& WINED3DCOLORWRITEENABLE_ALPHA
? 1 : 0);
1599 glColorMask(mask0
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
1600 mask0
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
1601 mask0
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
1602 mask0
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
);
1603 checkGLcall("glColorMask(...)");
1605 if (!((mask1
== mask0
&& mask2
== mask0
&& mask3
== mask0
)
1606 || (mask1
== 0xf && mask2
== 0xf && mask3
== 0xf)))
1608 FIXME("WINED3DRS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
1609 mask0
, mask1
, mask2
, mask3
);
1610 FIXME("Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n");
1614 static void set_color_mask(const struct wined3d_gl_info
*gl_info
, UINT index
, DWORD mask
)
1616 GL_EXTCALL(glColorMaskIndexedEXT(index
,
1617 mask
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
1618 mask
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
1619 mask
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
1620 mask
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
));
1623 static void state_colorwrite0(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1625 set_color_mask(context
->gl_info
, 0, stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE
]);
1628 static void state_colorwrite1(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1630 set_color_mask(context
->gl_info
, 1, stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE1
]);
1633 static void state_colorwrite2(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1635 set_color_mask(context
->gl_info
, 2, stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE2
]);
1638 static void state_colorwrite3(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1640 set_color_mask(context
->gl_info
, 3, stateblock
->state
.render_states
[WINED3DRS_COLORWRITEENABLE3
]);
1643 static void state_localviewer(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1645 if (stateblock
->state
.render_states
[WINED3DRS_LOCALVIEWER
])
1647 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 1);
1648 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1650 glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 0);
1651 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1655 static void state_lastpixel(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1657 if (stateblock
->state
.render_states
[WINED3DRS_LASTPIXEL
])
1659 TRACE("Last Pixel Drawing Enabled\n");
1663 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1666 TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1671 static void state_pointsprite_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1675 /* TODO: NV_POINT_SPRITE */
1676 if (!warned
&& stateblock
->state
.render_states
[WINED3DRS_POINTSPRITEENABLE
])
1678 /* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
1679 FIXME("Point sprites not supported\n");
1684 static void state_pointsprite(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1686 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1687 const struct wined3d_state
*state
= &stateblock
->state
;
1689 if (state
->render_states
[WINED3DRS_POINTSPRITEENABLE
])
1693 if (gl_info
->limits
.point_sprite_units
< gl_info
->limits
.textures
&& !warned
)
1695 if (use_ps(state
) || state
->lowest_disabled_stage
> gl_info
->limits
.point_sprite_units
)
1697 FIXME("The app uses point sprite texture coordinates on more units than supported by the driver\n");
1702 glEnable(GL_POINT_SPRITE_ARB
);
1703 checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1705 glDisable(GL_POINT_SPRITE_ARB
);
1706 checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1710 static void state_wrap(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1713 http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
1714 http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
1715 Discussion on the ways to turn on WRAPing to solve an OpenGL conversion problem.
1716 http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
1718 so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
1720 if (stateblock
->state
.render_states
[WINED3DRS_WRAP0
]
1721 || stateblock
->state
.render_states
[WINED3DRS_WRAP1
]
1722 || stateblock
->state
.render_states
[WINED3DRS_WRAP2
]
1723 || stateblock
->state
.render_states
[WINED3DRS_WRAP3
]
1724 || stateblock
->state
.render_states
[WINED3DRS_WRAP4
]
1725 || stateblock
->state
.render_states
[WINED3DRS_WRAP5
]
1726 || stateblock
->state
.render_states
[WINED3DRS_WRAP6
]
1727 || stateblock
->state
.render_states
[WINED3DRS_WRAP7
]
1728 || stateblock
->state
.render_states
[WINED3DRS_WRAP8
]
1729 || stateblock
->state
.render_states
[WINED3DRS_WRAP9
]
1730 || stateblock
->state
.render_states
[WINED3DRS_WRAP10
]
1731 || stateblock
->state
.render_states
[WINED3DRS_WRAP11
]
1732 || stateblock
->state
.render_states
[WINED3DRS_WRAP12
]
1733 || stateblock
->state
.render_states
[WINED3DRS_WRAP13
]
1734 || stateblock
->state
.render_states
[WINED3DRS_WRAP14
]
1735 || stateblock
->state
.render_states
[WINED3DRS_WRAP15
])
1737 FIXME("(WINED3DRS_WRAP0) Texture wrapping not yet supported.\n");
1741 static void state_msaa_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1743 if (stateblock
->state
.render_states
[WINED3DRS_MULTISAMPLEANTIALIAS
])
1744 WARN("Multisample antialiasing not supported by gl\n");
1747 static void state_msaa(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1749 if (stateblock
->state
.render_states
[WINED3DRS_MULTISAMPLEANTIALIAS
])
1751 glEnable(GL_MULTISAMPLE_ARB
);
1752 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1754 glDisable(GL_MULTISAMPLE_ARB
);
1755 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1759 static void state_scissor(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1761 if (stateblock
->state
.render_states
[WINED3DRS_SCISSORTESTENABLE
])
1763 glEnable(GL_SCISSOR_TEST
);
1764 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1766 glDisable(GL_SCISSOR_TEST
);
1767 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1771 /* The Direct3D depth bias is specified in normalized depth coordinates. In
1772 * OpenGL the bias is specified in units of "the smallest value that is
1773 * guaranteed to produce a resolvable offset for a given implementation". To
1774 * convert from D3D to GL we need to divide the D3D depth bias by that value.
1775 * There's no practical way to retrieve that value from a given GL
1776 * implementation, but the D3D application has essentially the same problem,
1777 * which makes a guess of 1e-6f seem reasonable here. Note that
1778 * SLOPESCALEDEPTHBIAS is a scaling factor for the depth slope, and doesn't
1779 * need to be scaled. */
1780 static void state_depthbias(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1782 if (stateblock
->state
.render_states
[WINED3DRS_SLOPESCALEDEPTHBIAS
]
1783 || stateblock
->state
.render_states
[WINED3DRS_DEPTHBIAS
])
1789 } scale_bias
, const_bias
;
1791 scale_bias
.d
= stateblock
->state
.render_states
[WINED3DRS_SLOPESCALEDEPTHBIAS
];
1792 const_bias
.d
= stateblock
->state
.render_states
[WINED3DRS_DEPTHBIAS
];
1794 glEnable(GL_POLYGON_OFFSET_FILL
);
1795 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1797 glPolygonOffset(scale_bias
.f
, const_bias
.f
* 1e6f
);
1798 checkGLcall("glPolygonOffset(...)");
1800 glDisable(GL_POLYGON_OFFSET_FILL
);
1801 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1805 static void state_zvisible(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1807 if (stateblock
->state
.render_states
[WINED3DRS_ZVISIBLE
])
1808 FIXME("WINED3DRS_ZVISIBLE not implemented.\n");
1811 static void state_perspective(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1813 if (stateblock
->state
.render_states
[WINED3DRS_TEXTUREPERSPECTIVE
])
1815 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_NICEST
);
1816 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1818 glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_FASTEST
);
1819 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1823 static void state_stippledalpha(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1825 if (stateblock
->state
.render_states
[WINED3DRS_STIPPLEDALPHA
])
1826 FIXME(" Stippled Alpha not supported yet.\n");
1829 static void state_antialias(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1831 if (stateblock
->state
.render_states
[WINED3DRS_ANTIALIAS
])
1832 FIXME("Antialias not supported yet.\n");
1835 static void state_multisampmask(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1837 if (stateblock
->state
.render_states
[WINED3DRS_MULTISAMPLEMASK
] != 0xffffffff)
1838 FIXME("WINED3DRS_MULTISAMPLEMASK %#x not yet implemented.\n",
1839 stateblock
->state
.render_states
[WINED3DRS_MULTISAMPLEMASK
]);
1842 static void state_patchedgestyle(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1844 if (stateblock
->state
.render_states
[WINED3DRS_PATCHEDGESTYLE
] != WINED3DPATCHEDGE_DISCRETE
)
1845 FIXME("WINED3DRS_PATCHEDGESTYLE %#x not yet implemented.\n",
1846 stateblock
->state
.render_states
[WINED3DRS_PATCHEDGESTYLE
]);
1849 static void state_patchsegments(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1857 if (stateblock
->state
.render_states
[WINED3DRS_PATCHSEGMENTS
] != tmpvalue
.d
)
1859 static BOOL displayed
= FALSE
;
1861 tmpvalue
.d
= stateblock
->state
.render_states
[WINED3DRS_PATCHSEGMENTS
];
1863 FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue
.f
);
1869 static void state_positiondegree(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1871 if (stateblock
->state
.render_states
[WINED3DRS_POSITIONDEGREE
] != WINED3DDEGREE_CUBIC
)
1872 FIXME("WINED3DRS_POSITIONDEGREE %#x not yet implemented.\n",
1873 stateblock
->state
.render_states
[WINED3DRS_POSITIONDEGREE
]);
1876 static void state_normaldegree(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1878 if (stateblock
->state
.render_states
[WINED3DRS_NORMALDEGREE
] != WINED3DDEGREE_LINEAR
)
1879 FIXME("WINED3DRS_NORMALDEGREE %#x not yet implemented.\n",
1880 stateblock
->state
.render_states
[WINED3DRS_NORMALDEGREE
]);
1883 static void state_tessellation(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1885 if (stateblock
->state
.render_states
[WINED3DRS_ENABLEADAPTIVETESSELLATION
])
1886 FIXME("WINED3DRS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
1887 stateblock
->state
.render_states
[WINED3DRS_ENABLEADAPTIVETESSELLATION
]);
1890 static void state_nvdb(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1897 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1899 if (stateblock
->state
.render_states
[WINED3DRS_ADAPTIVETESS_X
] == WINED3DFMT_NVDB
)
1901 zmin
.d
= stateblock
->state
.render_states
[WINED3DRS_ADAPTIVETESS_Z
];
1902 zmax
.d
= stateblock
->state
.render_states
[WINED3DRS_ADAPTIVETESS_W
];
1904 /* If zmin is larger than zmax INVALID_VALUE error is generated.
1905 * In d3d9 test is not performed in this case*/
1906 if (zmin
.f
<= zmax
.f
)
1908 glEnable(GL_DEPTH_BOUNDS_TEST_EXT
);
1909 checkGLcall("glEnable(GL_DEPTH_BOUNDS_TEST_EXT)");
1910 GL_EXTCALL(glDepthBoundsEXT(zmin
.f
, zmax
.f
));
1911 checkGLcall("glDepthBoundsEXT(...)");
1914 glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
1915 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
1919 glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
1920 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
1923 state_tessellation(state
, stateblock
, context
);
1926 static void state_wrapu(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1928 if (stateblock
->state
.render_states
[WINED3DRS_WRAPU
])
1929 FIXME("Render state WINED3DRS_WRAPU not implemented yet.\n");
1932 static void state_wrapv(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1934 if (stateblock
->state
.render_states
[WINED3DRS_WRAPV
])
1935 FIXME("Render state WINED3DRS_WRAPV not implemented yet.\n");
1938 static void state_monoenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1940 if (stateblock
->state
.render_states
[WINED3DRS_MONOENABLE
])
1941 FIXME("Render state WINED3DRS_MONOENABLE not implemented yet.\n");
1944 static void state_rop2(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1946 if (stateblock
->state
.render_states
[WINED3DRS_ROP2
])
1947 FIXME("Render state WINED3DRS_ROP2 not implemented yet.\n");
1950 static void state_planemask(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1952 if (stateblock
->state
.render_states
[WINED3DRS_PLANEMASK
])
1953 FIXME("Render state WINED3DRS_PLANEMASK not implemented yet.\n");
1956 static void state_subpixel(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1958 if (stateblock
->state
.render_states
[WINED3DRS_SUBPIXEL
])
1959 FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet.\n");
1962 static void state_subpixelx(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1964 if (stateblock
->state
.render_states
[WINED3DRS_SUBPIXELX
])
1965 FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet.\n");
1968 static void state_stippleenable(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1970 if (stateblock
->state
.render_states
[WINED3DRS_STIPPLEENABLE
])
1971 FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet.\n");
1974 static void state_mipmaplodbias(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1976 if (stateblock
->state
.render_states
[WINED3DRS_MIPMAPLODBIAS
])
1977 FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet.\n");
1980 static void state_anisotropy(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1982 if (stateblock
->state
.render_states
[WINED3DRS_ANISOTROPY
])
1983 FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet.\n");
1986 static void state_flushbatch(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1988 if (stateblock
->state
.render_states
[WINED3DRS_FLUSHBATCH
])
1989 FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet.\n");
1992 static void state_translucentsi(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
1994 if (stateblock
->state
.render_states
[WINED3DRS_TRANSLUCENTSORTINDEPENDENT
])
1995 FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
1998 static void state_extents(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
2000 if (stateblock
->state
.render_states
[WINED3DRS_EXTENTS
])
2001 FIXME("Render state WINED3DRS_EXTENTS not implemented yet.\n");
2004 static void state_ckeyblend(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
2006 if (stateblock
->state
.render_states
[WINED3DRS_COLORKEYBLENDENABLE
])
2007 FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet.\n");
2010 static void state_swvp(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
2012 if (stateblock
->state
.render_states
[WINED3DRS_SOFTWAREVERTEXPROCESSING
])
2013 FIXME("Software vertex processing not implemented.\n");
2016 /* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
2017 #if defined (GL_VERSION_1_3)
2018 # define useext(A) A
2019 #elif defined (GL_EXT_texture_env_combine)
2020 # define useext(A) A##_EXT
2021 #elif defined (GL_ARB_texture_env_combine)
2022 # define useext(A) A##_ARB
2025 static void get_src_and_opr(DWORD arg
, BOOL is_alpha
, GLenum
* source
, GLenum
* operand
) {
2026 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
2027 * input should be used for all input components. The WINED3DTA_COMPLEMENT
2028 * flag specifies the complement of the input should be used. */
2029 BOOL from_alpha
= is_alpha
|| arg
& WINED3DTA_ALPHAREPLICATE
;
2030 BOOL complement
= arg
& WINED3DTA_COMPLEMENT
;
2032 /* Calculate the operand */
2034 if (from_alpha
) *operand
= GL_ONE_MINUS_SRC_ALPHA
;
2035 else *operand
= GL_ONE_MINUS_SRC_COLOR
;
2037 if (from_alpha
) *operand
= GL_SRC_ALPHA
;
2038 else *operand
= GL_SRC_COLOR
;
2041 /* Calculate the source */
2042 switch (arg
& WINED3DTA_SELECTMASK
) {
2043 case WINED3DTA_CURRENT
: *source
= GL_PREVIOUS_EXT
; break;
2044 case WINED3DTA_DIFFUSE
: *source
= GL_PRIMARY_COLOR_EXT
; break;
2045 case WINED3DTA_TEXTURE
: *source
= GL_TEXTURE
; break;
2046 case WINED3DTA_TFACTOR
: *source
= GL_CONSTANT_EXT
; break;
2047 case WINED3DTA_SPECULAR
:
2049 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
2050 * 'Secondary color' and isn't supported until base GL supports it
2051 * There is no concept of temp registers as far as I can tell
2053 FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
2054 *source
= GL_TEXTURE
;
2057 FIXME("Unrecognized texture arg %#x\n", arg
);
2058 *source
= GL_TEXTURE
;
2063 /* Setup the texture operations texture stage states */
2064 static void set_tex_op(const struct wined3d_gl_info
*gl_info
, const struct wined3d_state
*state
,
2065 BOOL isAlpha
, int Stage
, WINED3DTEXTUREOP op
, DWORD arg1
, DWORD arg2
, DWORD arg3
)
2067 GLenum src1
, src2
, src3
;
2068 GLenum opr1
, opr2
, opr3
;
2070 GLenum src0_target
, src1_target
, src2_target
;
2071 GLenum opr0_target
, opr1_target
, opr2_target
;
2073 GLenum opr
=0, invopr
, src3_target
, opr3_target
;
2074 BOOL Handled
= FALSE
;
2076 TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha
, Stage
, debug_d3dtop(op
), arg1
, arg2
, arg3
);
2078 /* This is called by a state handler which has the gl lock held and a context for the thread */
2080 /* Note: Operations usually involve two ars, src0 and src1 and are operations of
2081 the form (a1 <operation> a2). However, some of the more complex operations
2082 take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
2083 in a third parameter called a0. Therefore these are operations of the form
2084 a0 <operation> a1 <operation> a2, i.e., the new parameter goes to the front.
2086 However, below we treat the new (a0) parameter as src2/opr2, so in the actual
2087 functions below, expect their syntax to differ slightly to those listed in the
2088 manuals, i.e., replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
2089 This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
2092 comb_target
= useext(GL_COMBINE_ALPHA
);
2093 src0_target
= useext(GL_SOURCE0_ALPHA
);
2094 src1_target
= useext(GL_SOURCE1_ALPHA
);
2095 src2_target
= useext(GL_SOURCE2_ALPHA
);
2096 opr0_target
= useext(GL_OPERAND0_ALPHA
);
2097 opr1_target
= useext(GL_OPERAND1_ALPHA
);
2098 opr2_target
= useext(GL_OPERAND2_ALPHA
);
2099 scal_target
= GL_ALPHA_SCALE
;
2102 comb_target
= useext(GL_COMBINE_RGB
);
2103 src0_target
= useext(GL_SOURCE0_RGB
);
2104 src1_target
= useext(GL_SOURCE1_RGB
);
2105 src2_target
= useext(GL_SOURCE2_RGB
);
2106 opr0_target
= useext(GL_OPERAND0_RGB
);
2107 opr1_target
= useext(GL_OPERAND1_RGB
);
2108 opr2_target
= useext(GL_OPERAND2_RGB
);
2109 scal_target
= useext(GL_RGB_SCALE
);
2112 /* If a texture stage references an invalid texture unit the stage just
2113 * passes through the result from the previous stage */
2114 if (is_invalid_op(state
, Stage
, op
, arg1
, arg2
, arg3
))
2116 arg1
= WINED3DTA_CURRENT
;
2117 op
= WINED3DTOP_SELECTARG1
;
2120 if (isAlpha
&& !state
->textures
[Stage
] && arg1
== WINED3DTA_TEXTURE
)
2122 get_src_and_opr(WINED3DTA_DIFFUSE
, isAlpha
, &src1
, &opr1
);
2124 get_src_and_opr(arg1
, isAlpha
, &src1
, &opr1
);
2126 get_src_and_opr(arg2
, isAlpha
, &src2
, &opr2
);
2127 get_src_and_opr(arg3
, isAlpha
, &src3
, &opr3
);
2129 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target
, src1
, opr1
, src2
, opr2
, src3
, opr3
);
2131 Handled
= TRUE
; /* Assume will be handled */
2133 /* Other texture operations require special extensions: */
2134 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
2138 invopr
= GL_ONE_MINUS_SRC_ALPHA
;
2139 src3_target
= GL_SOURCE3_ALPHA_NV
;
2140 opr3_target
= GL_OPERAND3_ALPHA_NV
;
2143 invopr
= GL_ONE_MINUS_SRC_COLOR
;
2144 src3_target
= GL_SOURCE3_RGB_NV
;
2145 opr3_target
= GL_OPERAND3_RGB_NV
;
2148 case WINED3DTOP_DISABLE
: /* Only for alpha */
2149 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2150 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2151 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2152 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2153 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2154 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2155 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2156 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2157 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2158 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2159 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2160 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2161 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2162 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2163 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2164 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2165 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2166 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2168 case WINED3DTOP_SELECTARG1
: /* = a1 * 1 + 0 * 0 */
2169 case WINED3DTOP_SELECTARG2
: /* = a2 * 1 + 0 * 0 */
2170 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2171 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2172 if (op
== WINED3DTOP_SELECTARG1
) {
2173 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2174 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2175 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2176 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2178 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2179 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2180 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2181 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2183 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2184 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2185 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2186 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2187 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2188 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2189 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2190 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2191 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2192 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2193 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2194 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2197 case WINED3DTOP_MODULATE
:
2198 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2199 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2200 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2201 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2202 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2203 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2204 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2205 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2206 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2207 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2208 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2209 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2210 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2211 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2212 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2213 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2214 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2215 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2216 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2217 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2219 case WINED3DTOP_MODULATE2X
:
2220 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2221 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2222 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2223 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2224 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2225 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2226 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2227 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2228 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2229 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2230 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2231 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2232 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2233 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2234 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2235 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2236 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2237 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2238 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2239 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2241 case WINED3DTOP_MODULATE4X
:
2242 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2243 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2244 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2245 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2246 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2247 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2248 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2249 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2250 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2251 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2252 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2253 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2254 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2255 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2256 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2257 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2258 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2259 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2260 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2261 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2264 case WINED3DTOP_ADD
:
2265 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2266 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2267 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2268 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2269 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2270 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2271 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2272 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2273 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2274 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2275 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2276 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2277 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2278 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2279 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2280 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2281 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2282 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2283 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2284 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2287 case WINED3DTOP_ADDSIGNED
:
2288 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
2289 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2290 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2291 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2292 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2293 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2294 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2295 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2296 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2297 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2298 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2299 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2300 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2301 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2302 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2303 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2304 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2305 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2306 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2307 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2310 case WINED3DTOP_ADDSIGNED2X
:
2311 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
2312 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2313 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2314 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2315 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2316 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2317 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2318 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2319 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2320 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2321 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2322 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2323 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2324 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2325 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2326 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2327 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2328 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2329 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2330 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2333 case WINED3DTOP_ADDSMOOTH
:
2334 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2335 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2336 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2337 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2338 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2339 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2340 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2341 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2342 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2343 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2344 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2345 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2346 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2347 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2348 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2349 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2351 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2352 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2353 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2354 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2356 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2357 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2358 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2359 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2362 case WINED3DTOP_BLENDDIFFUSEALPHA
:
2363 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2364 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2365 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2366 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2367 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2368 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2369 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, useext(GL_PRIMARY_COLOR
));
2370 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
2371 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2372 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2373 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2374 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2375 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2376 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2377 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, useext(GL_PRIMARY_COLOR
));
2378 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
2379 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2380 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2381 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2382 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2384 case WINED3DTOP_BLENDTEXTUREALPHA
:
2385 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2386 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2387 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2388 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2389 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2390 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2391 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_TEXTURE
);
2392 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
2393 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2394 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2395 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2396 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2397 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2398 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2399 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2400 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2401 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2402 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2403 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2404 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2406 case WINED3DTOP_BLENDFACTORALPHA
:
2407 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2408 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2409 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2410 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2411 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2412 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2413 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, useext(GL_CONSTANT
));
2414 checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
2415 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2416 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2417 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2418 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2419 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2420 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2421 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, useext(GL_CONSTANT
));
2422 checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
2423 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2424 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2425 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2426 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2428 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
2429 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2430 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2431 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2432 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2433 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2434 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2435 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2436 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2437 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2438 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2439 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2440 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2441 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2442 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2443 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2444 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2445 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2446 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2447 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2448 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2450 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
2451 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2452 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2453 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
); /* a0 = src1/opr1 */
2454 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2455 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2456 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
2457 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2458 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2459 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2460 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2461 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
); /* a2 = arg2 */
2462 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2463 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2464 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
2465 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2466 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2468 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2469 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2471 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2472 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2473 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2474 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2476 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
2477 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2478 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2479 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2480 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2481 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2482 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2483 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2484 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2485 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2486 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2487 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2488 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2490 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2491 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2493 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2494 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2495 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2496 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2497 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2498 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2499 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2500 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2502 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
2503 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2504 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2505 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2506 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2507 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2508 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2509 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2510 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2511 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2512 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2513 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2514 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2515 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2516 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2517 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2518 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2520 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2521 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2522 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2523 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2525 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2526 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2527 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2528 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2530 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
2531 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2532 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2533 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2534 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2536 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2537 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2538 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2539 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2541 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2542 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2543 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2544 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2545 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2546 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2547 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2548 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2550 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2551 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2553 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2554 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2555 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2556 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2557 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2558 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2559 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2560 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2562 case WINED3DTOP_MULTIPLYADD
:
2563 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2564 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2565 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src3
);
2566 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2567 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr3
);
2568 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2569 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2570 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2571 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2572 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2573 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2574 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2575 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr1
);
2576 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2577 glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src2
);
2578 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
2579 glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr2
);
2580 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
2581 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2582 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2585 case WINED3DTOP_BUMPENVMAP
:
2589 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
2590 FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
2596 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE4_NV
);
2597 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
2601 } /* GL_NV_texture_env_combine4 */
2603 Handled
= TRUE
; /* Again, assume handled */
2605 case WINED3DTOP_DISABLE
: /* Only for alpha */
2606 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2607 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2608 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2609 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
2610 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2611 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
2612 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2613 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2615 case WINED3DTOP_SELECTARG1
:
2616 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2617 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2618 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2619 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2620 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2621 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2622 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2623 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2625 case WINED3DTOP_SELECTARG2
:
2626 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2627 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2628 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2629 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2630 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2631 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2632 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2633 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2635 case WINED3DTOP_MODULATE
:
2636 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2637 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2638 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2639 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2640 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2641 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2642 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2643 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2644 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2645 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2646 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2647 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2649 case WINED3DTOP_MODULATE2X
:
2650 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2651 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2652 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2653 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2654 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2655 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2656 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2657 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2658 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2659 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2660 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2661 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2663 case WINED3DTOP_MODULATE4X
:
2664 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2665 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2666 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2667 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2668 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2669 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2670 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2671 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2672 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2673 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2674 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2675 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2677 case WINED3DTOP_ADD
:
2678 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2679 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2680 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2681 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2682 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2683 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2684 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2685 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2686 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2687 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2688 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2689 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2691 case WINED3DTOP_ADDSIGNED
:
2692 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
2693 checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
2694 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2695 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2696 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2697 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2698 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2699 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2700 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2701 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2702 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2703 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2705 case WINED3DTOP_ADDSIGNED2X
:
2706 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_ADD_SIGNED
));
2707 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
2708 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2709 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2710 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2711 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2712 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2713 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2714 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2715 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2716 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2717 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2719 case WINED3DTOP_SUBTRACT
:
2720 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
])
2722 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_SUBTRACT
);
2723 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
2724 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2725 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2726 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2727 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2728 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2729 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2730 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2731 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2732 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2733 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2735 FIXME("This version of opengl does not support GL_SUBTRACT\n");
2739 case WINED3DTOP_BLENDDIFFUSEALPHA
:
2740 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
2741 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2742 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2743 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2744 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2745 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2746 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2747 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2748 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2749 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2750 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_PRIMARY_COLOR
));
2751 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
2752 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2753 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2754 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2755 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2757 case WINED3DTOP_BLENDTEXTUREALPHA
:
2758 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
2759 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2760 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2761 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2762 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2763 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2764 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2765 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2766 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2767 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2768 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_TEXTURE
);
2769 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
2770 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2771 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2772 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2773 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2775 case WINED3DTOP_BLENDFACTORALPHA
:
2776 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
2777 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2778 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2779 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2780 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2781 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2782 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2783 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2784 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2785 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2786 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_CONSTANT
));
2787 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
2788 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2789 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2790 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2791 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2793 case WINED3DTOP_BLENDCURRENTALPHA
:
2794 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
2795 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2796 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2797 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2798 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2799 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2800 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2801 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2802 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2803 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2804 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, useext(GL_PREVIOUS
));
2805 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
2806 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2807 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2808 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2809 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2811 case WINED3DTOP_DOTPRODUCT3
:
2812 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
2814 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_ARB
);
2815 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
2817 else if (gl_info
->supported
[EXT_TEXTURE_ENV_DOT3
])
2819 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_EXT
);
2820 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
2822 FIXME("This version of opengl does not support GL_DOT3\n");
2824 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2825 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2826 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2827 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2828 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2829 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2830 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2831 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2832 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2833 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2835 case WINED3DTOP_LERP
:
2836 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, useext(GL_INTERPOLATE
));
2837 checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
2838 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2839 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2840 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2841 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2842 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2843 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2844 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2845 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2846 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src3
);
2847 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
2848 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr3
);
2849 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
2850 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2851 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2853 case WINED3DTOP_ADDSMOOTH
:
2854 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2856 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2857 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2858 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2859 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2861 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2862 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2863 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2864 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2866 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2867 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2868 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2869 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2870 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2871 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2872 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2873 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2874 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2875 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2876 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2877 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2881 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
2882 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2884 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2885 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2886 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_TEXTURE
);
2887 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
2888 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_ONE_MINUS_SRC_ALPHA
);
2889 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
2890 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2891 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2892 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2893 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2894 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2895 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2896 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2897 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2898 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2899 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2903 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
2904 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2906 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2907 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2908 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2909 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2911 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2912 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2913 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2914 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2916 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2917 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2918 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2919 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2920 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2921 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2922 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2923 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2924 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2925 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2926 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2927 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2931 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
2932 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2934 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2935 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2936 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2937 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2938 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2939 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2940 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2941 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2943 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2944 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2945 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2946 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2948 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
2949 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2950 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2951 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2952 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2953 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2954 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2955 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2959 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
2960 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2962 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2963 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2964 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2965 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2967 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2968 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2969 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2970 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2972 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2973 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2974 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2975 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2976 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2977 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2978 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2979 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2980 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2981 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2982 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2983 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2987 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
2988 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2990 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2991 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2992 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2993 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2995 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2996 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2997 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2998 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3000 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3001 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3002 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3003 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3005 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3006 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3007 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3008 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3010 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
3011 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
3012 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3013 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3014 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3015 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3016 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3017 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3021 case WINED3DTOP_MULTIPLYADD
:
3022 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3024 glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3025 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3026 glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3027 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3028 glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3029 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3030 glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src3
);
3031 checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
3032 glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr3
);
3033 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
3034 glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3035 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3036 glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3037 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3038 glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3039 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3043 case WINED3DTOP_BUMPENVMAPLUMINANCE
:
3044 case WINED3DTOP_BUMPENVMAP
:
3045 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
3047 /* Technically texture shader support without register combiners is possible, but not expected to occur
3048 * on real world cards, so for now a fixme should be enough
3050 FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
3057 BOOL combineOK
= TRUE
;
3058 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
3063 op2
= state
->texture_states
[Stage
][WINED3DTSS_COLOROP
];
3065 op2
= state
->texture_states
[Stage
][WINED3DTSS_ALPHAOP
];
3067 /* Note: If COMBINE4 in effect can't go back to combine! */
3069 case WINED3DTOP_ADDSMOOTH
:
3070 case WINED3DTOP_BLENDTEXTUREALPHAPM
:
3071 case WINED3DTOP_MODULATEALPHA_ADDCOLOR
:
3072 case WINED3DTOP_MODULATECOLOR_ADDALPHA
:
3073 case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR
:
3074 case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA
:
3075 case WINED3DTOP_MULTIPLYADD
:
3076 /* Ignore those implemented in both cases */
3078 case WINED3DTOP_SELECTARG1
:
3079 case WINED3DTOP_SELECTARG2
:
3084 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op
), debug_d3dtop(op2
), isAlpha
);
3091 glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, useext(GL_COMBINE
));
3092 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
3098 /* After all the extensions, if still unhandled, report fixme */
3099 FIXME("Unhandled texture operation %s\n", debug_d3dtop(op
));
3103 static void tex_colorop(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3105 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3106 BOOL tex_used
= stateblock
->device
->fixed_function_usage_map
& (1 << stage
);
3107 DWORD mapped_stage
= stateblock
->device
->texUnitMap
[stage
];
3108 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3109 const struct wined3d_state
*state
= &stateblock
->state
;
3111 TRACE("Setting color op for stage %d\n", stage
);
3113 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
3114 if (use_ps(state
)) return;
3116 if (stage
!= mapped_stage
) WARN("Using non 1:1 mapping: %d -> %d!\n", stage
, mapped_stage
);
3118 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3120 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3122 FIXME("Attempt to enable unsupported stage!\n");
3125 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3126 checkGLcall("glActiveTextureARB");
3129 if (stage
>= state
->lowest_disabled_stage
)
3131 TRACE("Stage disabled\n");
3132 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3134 /* Disable everything here */
3135 glDisable(GL_TEXTURE_2D
);
3136 checkGLcall("glDisable(GL_TEXTURE_2D)");
3137 glDisable(GL_TEXTURE_3D
);
3138 checkGLcall("glDisable(GL_TEXTURE_3D)");
3139 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
3141 glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
3142 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3144 if (gl_info
->supported
[ARB_TEXTURE_RECTANGLE
])
3146 glDisable(GL_TEXTURE_RECTANGLE_ARB
);
3147 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3154 /* The sampler will also activate the correct texture dimensions, so no
3155 * need to do it here if the sampler for this stage is dirty. */
3156 if (!isStateDirty(context
, STATE_SAMPLER(stage
)) && tex_used
)
3157 texture_activate_dimensions(state
->textures
[stage
], gl_info
);
3159 set_tex_op(gl_info
, state
, FALSE
, stage
,
3160 state
->texture_states
[stage
][WINED3DTSS_COLOROP
],
3161 state
->texture_states
[stage
][WINED3DTSS_COLORARG1
],
3162 state
->texture_states
[stage
][WINED3DTSS_COLORARG2
],
3163 state
->texture_states
[stage
][WINED3DTSS_COLORARG0
]);
3166 void tex_alphaop(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3168 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3169 BOOL tex_used
= stateblock
->device
->fixed_function_usage_map
& (1 << stage
);
3170 DWORD mapped_stage
= stateblock
->device
->texUnitMap
[stage
];
3171 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3172 DWORD op
, arg1
, arg2
, arg0
;
3174 TRACE("Setting alpha op for stage %d\n", stage
);
3175 /* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
3176 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3178 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3180 FIXME("Attempt to enable unsupported stage!\n");
3183 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3184 checkGLcall("glActiveTextureARB");
3187 op
= stateblock
->state
.texture_states
[stage
][WINED3DTSS_ALPHAOP
];
3188 arg1
= stateblock
->state
.texture_states
[stage
][WINED3DTSS_ALPHAARG1
];
3189 arg2
= stateblock
->state
.texture_states
[stage
][WINED3DTSS_ALPHAARG2
];
3190 arg0
= stateblock
->state
.texture_states
[stage
][WINED3DTSS_ALPHAARG0
];
3192 if (stateblock
->state
.render_states
[WINED3DRS_COLORKEYENABLE
] && !stage
&& stateblock
->state
.textures
[0])
3194 IWineD3DBaseTextureImpl
*texture
= stateblock
->state
.textures
[0];
3195 GLenum texture_dimensions
= texture
->baseTexture
.target
;
3197 if (texture_dimensions
== GL_TEXTURE_2D
|| texture_dimensions
== GL_TEXTURE_RECTANGLE_ARB
)
3199 IWineD3DSurfaceImpl
*surf
= surface_from_resource(texture
->baseTexture
.sub_resources
[0]);
3201 if (surf
->CKeyFlags
& WINEDDSD_CKSRCBLT
&& !surf
->resource
.format
->alpha_mask
)
3203 /* Color keying needs to pass alpha values from the texture through to have the alpha test work
3204 * properly. On the other hand applications can still use texture combiners apparently. This code
3205 * takes care that apps cannot remove the texture's alpha channel entirely.
3207 * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires
3208 * D3DTOP_MODULATE to work on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures
3209 * and alpha component of diffuse color to draw things like translucent text and perform other
3212 * Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To
3213 * provide the behavior expected by the game, while emulating the colorkey, diffuse alpha must be
3214 * modulated with texture alpha. OTOH, Moto racer 2 at some points sets alphaop/alphaarg to
3215 * SELECTARG/CURRENT, yet puts garbage in diffuse alpha (zeroes). This works on native, because the
3216 * game disables alpha test and alpha blending. Alpha test is overwritten by wine's for purposes of
3217 * color-keying though, so this will lead to missing geometry if texture alpha is modulated (pixels
3218 * fail alpha test). To get around this, ALPHABLENDENABLE state is checked: if the app enables alpha
3219 * blending, it can be expected to provide meaningful values in diffuse alpha, so it should be
3220 * modulated with texture alpha; otherwise, selecting diffuse alpha is ignored in favour of texture
3223 * What to do with multitexturing? So far no app has been found that uses color keying with
3225 if (op
== WINED3DTOP_DISABLE
)
3227 arg1
= WINED3DTA_TEXTURE
;
3228 op
= WINED3DTOP_SELECTARG1
;
3230 else if(op
== WINED3DTOP_SELECTARG1
&& arg1
!= WINED3DTA_TEXTURE
)
3232 if (stateblock
->state
.render_states
[WINED3DRS_ALPHABLENDENABLE
])
3234 arg2
= WINED3DTA_TEXTURE
;
3235 op
= WINED3DTOP_MODULATE
;
3237 else arg1
= WINED3DTA_TEXTURE
;
3239 else if(op
== WINED3DTOP_SELECTARG2
&& arg2
!= WINED3DTA_TEXTURE
)
3241 if (stateblock
->state
.render_states
[WINED3DRS_ALPHABLENDENABLE
])
3243 arg1
= WINED3DTA_TEXTURE
;
3244 op
= WINED3DTOP_MODULATE
;
3246 else arg2
= WINED3DTA_TEXTURE
;
3252 /* tex_alphaop is shared between the ffp and nvrc because the difference only comes down to
3253 * this if block here, and the other code(color keying, texture unit selection) are the same
3255 TRACE("Setting alpha op for stage %d\n", stage
);
3256 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
3258 set_tex_op_nvrc(gl_info
, &stateblock
->state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
,
3259 mapped_stage
, stateblock
->state
.texture_states
[stage
][WINED3DTSS_RESULTARG
]);
3263 set_tex_op(gl_info
, &stateblock
->state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
);
3267 static void transform_texture(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3269 DWORD texUnit
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3270 DWORD mapped_stage
= stateblock
->device
->texUnitMap
[texUnit
];
3271 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3272 const struct wined3d_state
*state
= &stateblock
->state
;
3276 /* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
3277 if (use_vs(state
) || isStateDirty(context
, STATE_VDECL
))
3279 TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
3283 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
) return;
3284 if (mapped_stage
>= gl_info
->limits
.textures
) return;
3286 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3287 checkGLcall("glActiveTextureARB");
3288 generated
= (state
->texture_states
[texUnit
][WINED3DTSS_TEXCOORDINDEX
] & 0xffff0000) != WINED3DTSS_TCI_PASSTHRU
;
3289 coordIdx
= min(state
->texture_states
[texUnit
][WINED3DTSS_TEXCOORDINDEX
& 0x0000ffff], MAX_TEXTURES
- 1);
3291 set_texture_matrix(&state
->transforms
[WINED3DTS_TEXTURE0
+ texUnit
].u
.m
[0][0],
3292 state
->texture_states
[texUnit
][WINED3DTSS_TEXTURETRANSFORMFLAGS
],
3293 generated
, context
->last_was_rhw
,
3294 stateblock
->device
->strided_streams
.use_map
& (1 << (WINED3D_FFP_TEXCOORD0
+ coordIdx
))
3295 ? stateblock
->device
->strided_streams
.elements
[WINED3D_FFP_TEXCOORD0
+ coordIdx
].format
->id
3296 : WINED3DFMT_UNKNOWN
,
3297 stateblock
->device
->frag_pipe
->ffp_proj_control
);
3299 /* The sampler applying function calls us if this changes */
3300 if ((context
->lastWasPow2Texture
& (1 << texUnit
)) && state
->textures
[texUnit
])
3303 FIXME("Non-power2 texture being used with generated texture coords\n");
3305 /* NP2 texcoord fixup is implemented for pixelshaders so only enable the
3306 fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
3309 TRACE("Non power two matrix multiply fixup\n");
3310 glMultMatrixf(state
->textures
[texUnit
]->baseTexture
.pow2Matrix
);
3315 static void unloadTexCoords(const struct wined3d_gl_info
*gl_info
)
3317 unsigned int texture_idx
;
3319 for (texture_idx
= 0; texture_idx
< gl_info
->limits
.texture_stages
; ++texture_idx
)
3321 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB
+ texture_idx
));
3322 glDisableClientState(GL_TEXTURE_COORD_ARRAY
);
3326 static void loadTexCoords(const struct wined3d_gl_info
*gl_info
, struct wined3d_stateblock
*stateblock
,
3327 const struct wined3d_stream_info
*si
, GLuint
*curVBO
)
3329 unsigned int mapped_stage
= 0;
3330 unsigned int textureNo
= 0;
3332 for (textureNo
= 0; textureNo
< gl_info
->limits
.texture_stages
; ++textureNo
)
3334 int coordIdx
= stateblock
->state
.texture_states
[textureNo
][WINED3DTSS_TEXCOORDINDEX
];
3336 mapped_stage
= stateblock
->device
->texUnitMap
[textureNo
];
3337 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
) continue;
3339 if (coordIdx
< MAX_TEXTURES
&& (si
->use_map
& (1 << (WINED3D_FFP_TEXCOORD0
+ coordIdx
))))
3341 const struct wined3d_stream_info_element
*e
= &si
->elements
[WINED3D_FFP_TEXCOORD0
+ coordIdx
];
3342 const struct wined3d_stream_state
*stream
= &stateblock
->state
.streams
[e
->stream_idx
];
3344 TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
3345 textureNo
, mapped_stage
, coordIdx
, e
->data
);
3347 if (*curVBO
!= e
->buffer_object
)
3349 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
3350 checkGLcall("glBindBufferARB");
3351 *curVBO
= e
->buffer_object
;
3354 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3355 checkGLcall("glClientActiveTextureARB");
3357 /* The coords to supply depend completely on the fvf / vertex shader */
3358 glTexCoordPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
3359 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
3360 glEnableClientState(GL_TEXTURE_COORD_ARRAY
);
3362 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB
+ mapped_stage
, 0, 0, 0, 1));
3365 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
3367 /* The number of the mapped stages increases monotonically, so it's fine to use the last used one. */
3368 for (textureNo
= mapped_stage
+ 1; textureNo
< gl_info
->limits
.textures
; ++textureNo
)
3370 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB
+ textureNo
, 0, 0, 0, 1));
3374 checkGLcall("loadTexCoords");
3377 static void tex_coordindex(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3379 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3380 DWORD mapped_stage
= stateblock
->device
->texUnitMap
[stage
];
3381 static const GLfloat s_plane
[] = { 1.0f
, 0.0f
, 0.0f
, 0.0f
};
3382 static const GLfloat t_plane
[] = { 0.0f
, 1.0f
, 0.0f
, 0.0f
};
3383 static const GLfloat r_plane
[] = { 0.0f
, 0.0f
, 1.0f
, 0.0f
};
3384 static const GLfloat q_plane
[] = { 0.0f
, 0.0f
, 0.0f
, 1.0f
};
3385 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3387 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3389 TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage
);
3393 if (mapped_stage
>= gl_info
->limits
.fragment_samplers
)
3395 WARN("stage %u not mapped to a valid texture unit (%u)\n", stage
, mapped_stage
);
3398 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3399 checkGLcall("glActiveTextureARB");
3401 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
3403 * FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
3404 * eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_TCI_CAMERASPACEPOSITION | 1 );
3405 * means use the vertex position (camera-space) as the input texture coordinates
3406 * for this texture stage, and the wrap mode set in the WINED3DRS_WRAP1 render
3407 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
3408 * to the TEXCOORDINDEX value
3410 switch (stateblock
->state
.texture_states
[stage
][WINED3DTSS_TEXCOORDINDEX
] & 0xffff0000)
3412 case WINED3DTSS_TCI_PASSTHRU
:
3413 /* Use the specified texture coordinates contained within the
3414 * vertex format. This value resolves to zero. */
3415 glDisable(GL_TEXTURE_GEN_S
);
3416 glDisable(GL_TEXTURE_GEN_T
);
3417 glDisable(GL_TEXTURE_GEN_R
);
3418 glDisable(GL_TEXTURE_GEN_Q
);
3419 checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
3422 case WINED3DTSS_TCI_CAMERASPACEPOSITION
:
3423 /* CameraSpacePosition means use the vertex position, transformed to camera space,
3424 * as the input texture coordinates for this stage's texture transformation. This
3425 * equates roughly to EYE_LINEAR */
3427 glMatrixMode(GL_MODELVIEW
);
3430 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3431 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3432 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3433 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3435 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
3437 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3438 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3439 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3440 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
3442 glEnable(GL_TEXTURE_GEN_S
);
3443 glEnable(GL_TEXTURE_GEN_T
);
3444 glEnable(GL_TEXTURE_GEN_R
);
3445 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
3449 case WINED3DTSS_TCI_CAMERASPACENORMAL
:
3450 /* Note that NV_TEXGEN_REFLECTION support is implied when
3451 * ARB_TEXTURE_CUBE_MAP is supported */
3452 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3454 FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
3458 glMatrixMode(GL_MODELVIEW
);
3461 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3462 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3463 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3464 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3466 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
3468 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3469 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3470 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3471 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
3473 glEnable(GL_TEXTURE_GEN_S
);
3474 glEnable(GL_TEXTURE_GEN_T
);
3475 glEnable(GL_TEXTURE_GEN_R
);
3476 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
3480 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
:
3481 /* Note that NV_TEXGEN_REFLECTION support is implied when
3482 * ARB_TEXTURE_CUBE_MAP is supported */
3483 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3485 FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
3489 glMatrixMode(GL_MODELVIEW
);
3492 glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3493 glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3494 glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3495 glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3497 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
3499 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3500 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3501 glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3502 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
3504 glEnable(GL_TEXTURE_GEN_S
);
3505 glEnable(GL_TEXTURE_GEN_T
);
3506 glEnable(GL_TEXTURE_GEN_R
);
3507 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
3511 case WINED3DTSS_TCI_SPHEREMAP
:
3512 glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3513 glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3514 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
3516 glEnable(GL_TEXTURE_GEN_S
);
3517 glEnable(GL_TEXTURE_GEN_T
);
3518 glDisable(GL_TEXTURE_GEN_R
);
3519 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
3524 FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %#x.\n",
3525 stateblock
->state
.texture_states
[stage
][WINED3DTSS_TEXCOORDINDEX
]);
3526 glDisable(GL_TEXTURE_GEN_S
);
3527 glDisable(GL_TEXTURE_GEN_T
);
3528 glDisable(GL_TEXTURE_GEN_R
);
3529 glDisable(GL_TEXTURE_GEN_Q
);
3530 checkGLcall("Disable texgen.");
3535 /* Update the texture matrix */
3536 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ stage
))) {
3537 transform_texture(STATE_TEXTURESTAGE(stage
, WINED3DTSS_TEXTURETRANSFORMFLAGS
), stateblock
, context
);
3540 if(!isStateDirty(context
, STATE_VDECL
) && context
->namedArraysLoaded
) {
3541 /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
3542 * source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
3543 * and do all the things linked to it
3544 * TODO: Tidy that up to reload only the arrays of the changed unit
3546 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
3548 unloadTexCoords(gl_info
);
3549 loadTexCoords(gl_info
, stateblock
, &stateblock
->device
->strided_streams
, &curVBO
);
3553 static void shaderconstant(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3555 const struct wined3d_state
*state
= &stateblock
->state
;
3556 IWineD3DDeviceImpl
*device
= stateblock
->device
;
3558 /* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
3559 * has an update pending
3561 if(isStateDirty(context
, STATE_VDECL
) ||
3562 isStateDirty(context
, STATE_PIXELSHADER
)) {
3566 device
->shader_backend
->shader_load_constants(context
, use_ps(state
), use_vs(state
));
3569 static void tex_bumpenvlscale(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3571 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3572 IWineD3DPixelShaderImpl
*ps
= stateblock
->state
.pixel_shader
;
3574 if (ps
&& stage
&& (ps
->baseShader
.reg_maps
.luminanceparams
& (1 << stage
)))
3576 /* The pixel shader has to know the luminance scale. Do a constants update if it
3577 * isn't scheduled anyway
3579 if(!isStateDirty(context
, STATE_PIXELSHADERCONSTANT
) &&
3580 !isStateDirty(context
, STATE_PIXELSHADER
)) {
3581 shaderconstant(STATE_PIXELSHADERCONSTANT
, stateblock
, context
);
3586 static void sampler_texmatrix(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3588 const DWORD sampler
= state
- STATE_SAMPLER(0);
3589 IWineD3DBaseTextureImpl
*texture
= stateblock
->state
.textures
[sampler
];
3591 TRACE("state %#x, stateblock %p, context %p\n", state
, stateblock
, context
);
3593 if(!texture
) return;
3594 /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
3595 * basetexture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
3596 * scaling is reapplied or removed, the texture matrix has to be reapplied
3598 * The mapped stage is already active because the sampler() function below, which is part of the
3601 if(sampler
< MAX_TEXTURES
) {
3602 const BOOL texIsPow2
= !texture
->baseTexture
.pow2Matrix_identity
;
3604 if (texIsPow2
|| (context
->lastWasPow2Texture
& (1 << sampler
)))
3606 if (texIsPow2
) context
->lastWasPow2Texture
|= 1 << sampler
;
3607 else context
->lastWasPow2Texture
&= ~(1 << sampler
);
3608 transform_texture(STATE_TEXTURESTAGE(stateblock
->device
->texUnitMap
[sampler
],
3609 WINED3DTSS_TEXTURETRANSFORMFLAGS
), stateblock
, context
);
3614 static void sampler(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3616 DWORD sampler
= state_id
- STATE_SAMPLER(0);
3617 IWineD3DDeviceImpl
*device
= stateblock
->device
;
3618 DWORD mapped_stage
= device
->texUnitMap
[sampler
];
3619 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3620 const struct wined3d_state
*state
= &stateblock
->state
;
3626 TRACE("Sampler: %d\n", sampler
);
3627 /* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
3628 * only has to bind textures and set the per texture states
3631 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3633 TRACE("No sampler mapped to stage %d. Returning.\n", sampler
);
3637 if (mapped_stage
>= gl_info
->limits
.combined_samplers
)
3641 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3642 checkGLcall("glActiveTextureARB");
3644 if (state
->textures
[sampler
])
3646 IWineD3DBaseTextureImpl
*texture
= state
->textures
[sampler
];
3647 BOOL srgb
= state
->sampler_states
[sampler
][WINED3DSAMP_SRGBTEXTURE
];
3649 texture
->baseTexture
.texture_ops
->texture_bind(texture
, gl_info
, srgb
);
3650 basetexture_apply_state_changes(texture
,
3651 state
->sampler_states
[sampler
], gl_info
);
3653 if (gl_info
->supported
[EXT_TEXTURE_LOD_BIAS
])
3655 tmpvalue
.d
= state
->sampler_states
[sampler
][WINED3DSAMP_MIPMAPLODBIAS
];
3656 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT
,
3657 GL_TEXTURE_LOD_BIAS_EXT
,
3659 checkGLcall("glTexEnvf(GL_TEXTURE_LOD_BIAS_EXT, ...)");
3662 if (!use_ps(state
) && sampler
< state
->lowest_disabled_stage
)
3664 if (state
->render_states
[WINED3DRS_COLORKEYENABLE
] && !sampler
)
3666 /* If color keying is enabled update the alpha test, it depends on the existence
3667 * of a color key in stage 0
3669 state_alpha(WINED3DRS_COLORKEYENABLE
, stateblock
, context
);
3673 /* Trigger shader constant reloading (for NP2 texcoord fixup) */
3674 if (!texture
->baseTexture
.pow2Matrix_identity
)
3676 device
->shader_backend
->shader_load_np2fixup_constants(device
->shader_priv
, gl_info
, state
);
3679 else if (mapped_stage
< gl_info
->limits
.textures
)
3681 if (sampler
< state
->lowest_disabled_stage
)
3683 /* TODO: What should I do with pixel shaders here ??? */
3684 if (state
->render_states
[WINED3DRS_COLORKEYENABLE
] && !sampler
)
3686 /* If color keying is enabled update the alpha test, it depends on the existence
3687 * of a color key in stage 0
3689 state_alpha(WINED3DRS_COLORKEYENABLE
, stateblock
, context
);
3691 } /* Otherwise tex_colorop disables the stage */
3692 glBindTexture(GL_TEXTURE_2D
, device
->dummyTextureName
[sampler
]);
3693 checkGLcall("glBindTexture(GL_TEXTURE_2D, device->dummyTextureName[sampler])");
3697 void apply_pixelshader(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3699 const struct wined3d_state
*state
= &stateblock
->state
;
3700 IWineD3DDeviceImpl
*device
= stateblock
->device
;
3701 BOOL use_vshader
= use_vs(state
);
3702 BOOL use_pshader
= use_ps(state
);
3706 if(!context
->last_was_pshader
) {
3707 /* Former draw without a pixel shader, some samplers
3708 * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
3709 * make sure to enable them
3711 for(i
=0; i
< MAX_FRAGMENT_SAMPLERS
; i
++) {
3712 if(!isStateDirty(context
, STATE_SAMPLER(i
))) {
3713 sampler(STATE_SAMPLER(i
), stateblock
, context
);
3716 context
->last_was_pshader
= TRUE
;
3718 /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
3719 * if a different texture was bound. I don't have to do anything.
3723 /* Disabled the pixel shader - color ops weren't applied
3724 * while it was enabled, so re-apply them. */
3725 for (i
= 0; i
< context
->gl_info
->limits
.texture_stages
; ++i
)
3727 if (!isStateDirty(context
, STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
)))
3728 stateblock_apply_state(STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
), stateblock
, context
);
3730 context
->last_was_pshader
= FALSE
;
3733 if(!isStateDirty(context
, device
->StateTable
[STATE_VSHADER
].representative
)) {
3734 device
->shader_backend
->shader_select(context
, use_pshader
, use_vshader
);
3736 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
) && (use_vshader
|| use_pshader
)) {
3737 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
3742 static void shader_bumpenvmat(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3744 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3745 IWineD3DPixelShaderImpl
*ps
= stateblock
->state
.pixel_shader
;
3747 if (ps
&& stage
&& (ps
->baseShader
.reg_maps
.bumpmat
& (1 << stage
)))
3749 /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
3752 if(!isStateDirty(context
, STATE_PIXELSHADERCONSTANT
) &&
3753 !isStateDirty(context
, STATE_PIXELSHADER
)) {
3754 shaderconstant(STATE_PIXELSHADERCONSTANT
, stateblock
, context
);
3759 static void transform_world(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3761 /* This function is called by transform_view below if the view matrix was changed too
3763 * Deliberately no check if the vertex declaration is dirty because the vdecl state
3764 * does not always update the world matrix, only on a switch between transformed
3765 * and untransformed draws. It *may* happen that the world matrix is set 2 times during one
3766 * draw, but that should be rather rare and cheaper in total.
3768 glMatrixMode(GL_MODELVIEW
);
3769 checkGLcall("glMatrixMode");
3771 if(context
->last_was_rhw
) {
3773 checkGLcall("glLoadIdentity()");
3775 /* In the general case, the view matrix is the identity matrix */
3776 if (stateblock
->device
->view_ident
)
3778 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
3779 checkGLcall("glLoadMatrixf");
3783 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3784 checkGLcall("glLoadMatrixf");
3785 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
3786 checkGLcall("glMultMatrixf");
3791 static void clipplane(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3793 const struct wined3d_state
*state
= &stateblock
->state
;
3794 UINT index
= state_id
- STATE_CLIPPLANE(0);
3796 if (isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
)) || index
>= context
->gl_info
->limits
.clipplanes
)
3801 glMatrixMode(GL_MODELVIEW
);
3804 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
3806 glLoadMatrixf(&state
->transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3808 /* with vertex shaders, clip planes are not transformed in direct3d,
3809 * in OpenGL they are still transformed by the model view.
3813 TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
3814 state
->clip_planes
[index
][0],
3815 state
->clip_planes
[index
][1],
3816 state
->clip_planes
[index
][2],
3817 state
->clip_planes
[index
][3]);
3818 glClipPlane(GL_CLIP_PLANE0
+ index
, state
->clip_planes
[index
]);
3819 checkGLcall("glClipPlane");
3824 static void transform_worldex(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3826 UINT matrix
= state
- STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
3828 TRACE("Setting world matrix %d\n", matrix
);
3830 if (matrix
>= context
->gl_info
->limits
.blends
)
3832 WARN("Unsupported blend matrix set\n");
3834 } else if(isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
))) {
3838 /* GL_MODELVIEW0_ARB: 0x1700
3839 * GL_MODELVIEW1_ARB: 0x850a
3840 * GL_MODELVIEW2_ARB: 0x8722
3841 * GL_MODELVIEW3_ARB: 0x8723
3843 * GL_MODELVIEW31_ARB: 0x873F
3845 if(matrix
== 1) glMat
= GL_MODELVIEW1_ARB
;
3846 else glMat
= GL_MODELVIEW2_ARB
- 2 + matrix
;
3848 glMatrixMode(glMat
);
3849 checkGLcall("glMatrixMode(glMat)");
3851 /* World matrix 0 is multiplied with the view matrix because d3d uses 3 matrices while gl uses only 2. To avoid
3852 * weighting the view matrix incorrectly it has to be multiplied into every gl modelview matrix
3854 if (stateblock
->device
->view_ident
)
3856 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(matrix
)].u
.m
[0][0]);
3857 checkGLcall("glLoadMatrixf");
3861 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3862 checkGLcall("glLoadMatrixf");
3863 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(matrix
)].u
.m
[0][0]);
3864 checkGLcall("glMultMatrixf");
3868 static void state_vertexblend_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3870 WINED3DVERTEXBLENDFLAGS f
= stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
];
3871 static unsigned int once
;
3873 if (f
== WINED3DVBF_DISABLE
) return;
3875 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", f
);
3876 else WARN("Vertex blend flags %#x not supported.\n", f
);
3879 static void state_vertexblend(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3881 WINED3DVERTEXBLENDFLAGS val
= stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
];
3882 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3883 static unsigned int once
;
3886 case WINED3DVBF_1WEIGHTS
:
3887 case WINED3DVBF_2WEIGHTS
:
3888 case WINED3DVBF_3WEIGHTS
:
3889 glEnable(GL_VERTEX_BLEND_ARB
);
3890 checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
3892 /* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
3893 * creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
3895 GL_EXTCALL(glVertexBlendARB(stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
] + 1));
3897 if (!stateblock
->device
->vertexBlendUsed
)
3900 for (i
= 1; i
< gl_info
->limits
.blends
; ++i
)
3902 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i
))))
3904 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i
)), stateblock
, context
);
3907 stateblock
->device
->vertexBlendUsed
= TRUE
;
3911 case WINED3DVBF_TWEENING
:
3912 case WINED3DVBF_0WEIGHTS
: /* Indexed vertex blending, not supported. */
3913 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", val
);
3914 else WARN("Vertex blend flags %#x not supported.\n", val
);
3916 case WINED3DVBF_DISABLE
:
3917 glDisable(GL_VERTEX_BLEND_ARB
);
3918 checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
3923 static void transform_view(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3925 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3926 const struct wined3d_light_info
*light
= NULL
;
3929 /* If we are changing the View matrix, reset the light and clipping planes to the new view
3930 * NOTE: We have to reset the positions even if the light/plane is not currently
3931 * enabled, since the call to enable it will not reset the position.
3932 * NOTE2: Apparently texture transforms do NOT need reapplying
3935 glMatrixMode(GL_MODELVIEW
);
3936 checkGLcall("glMatrixMode(GL_MODELVIEW)");
3937 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3938 checkGLcall("glLoadMatrixf(...)");
3940 /* Reset lights. TODO: Call light apply func */
3941 for (k
= 0; k
< stateblock
->device
->maxConcurrentLights
; ++k
)
3943 light
= stateblock
->state
.lights
[k
];
3944 if(!light
) continue;
3945 glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_POSITION
, light
->lightPosn
);
3946 checkGLcall("glLightfv posn");
3947 glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_SPOT_DIRECTION
, light
->lightDirn
);
3948 checkGLcall("glLightfv dirn");
3951 /* Reset Clipping Planes */
3952 for (k
= 0; k
< gl_info
->limits
.clipplanes
; ++k
)
3954 if(!isStateDirty(context
, STATE_CLIPPLANE(k
))) {
3955 clipplane(STATE_CLIPPLANE(k
), stateblock
, context
);
3959 if(context
->last_was_rhw
) {
3961 checkGLcall("glLoadIdentity()");
3962 /* No need to update the world matrix, the identity is fine */
3966 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
3967 * No need to do it here if the state is scheduled for update.
3969 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
3970 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
3973 /* Avoid looping over a number of matrices if the app never used the functionality */
3974 if (stateblock
->device
->vertexBlendUsed
)
3976 for (k
= 1; k
< gl_info
->limits
.blends
; ++k
)
3978 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k
)))) {
3979 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k
)), stateblock
, context
);
3985 static void transform_projection(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
3987 glMatrixMode(GL_PROJECTION
);
3988 checkGLcall("glMatrixMode(GL_PROJECTION)");
3990 checkGLcall("glLoadIdentity");
3992 if (context
->last_was_rhw
)
3994 double x
= stateblock
->state
.viewport
.X
;
3995 double y
= stateblock
->state
.viewport
.Y
;
3996 double w
= stateblock
->state
.viewport
.Width
;
3997 double h
= stateblock
->state
.viewport
.Height
;
3999 TRACE("Calling glOrtho with x %.8e, y %.8e, w %.8e, h %.8e.\n", x
, y
, w
, h
);
4000 if (context
->render_offscreen
)
4001 glOrtho(x
, x
+ w
, -y
, -y
- h
, 0.0, -1.0);
4003 glOrtho(x
, x
+ w
, y
+ h
, y
, 0.0, -1.0);
4004 checkGLcall("glOrtho");
4006 /* D3D texture coordinates are flipped compared to OpenGL ones, so
4007 * render everything upside down when rendering offscreen. */
4008 if (context
->render_offscreen
)
4010 glScalef(1.0f
, -1.0f
, 1.0f
);
4011 checkGLcall("glScalef");
4014 /* Window Coord 0 is the middle of the first pixel, so translate by 1/2 pixels */
4015 glTranslatef(63.0f
/ 128.0f
, 63.0f
/ 128.0f
, 0.0f
);
4016 checkGLcall("glTranslatef(63.0f / 128.0f, 63.0f / 128.0f, 0.0f)");
4020 /* The rule is that the window coordinate 0 does not correspond to the
4021 beginning of the first pixel, but the center of the first pixel.
4022 As a consequence if you want to correctly draw one line exactly from
4023 the left to the right end of the viewport (with all matrices set to
4024 be identity), the x coords of both ends of the line would be not
4025 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
4028 1.0 / Width is used because the coord range goes from -1.0 to 1.0, then we
4029 divide by the Width/Height, so we need the half range(1.0) to translate by
4032 The other fun is that d3d's output z range after the transformation is [0;1],
4033 but opengl's is [-1;1]. Since the z buffer is in range [0;1] for both, gl
4034 scales [-1;1] to [0;1]. This would mean that we end up in [0.5;1] and loose a lot
4035 of Z buffer precision and the clear values do not match in the z test. Thus scale
4036 [0;1] to [-1;1], so when gl undoes that we utilize the full z range
4040 * Careful with the order of operations here, we're essentially working backwards:
4042 * y = (y - 1/h) * flip;
4046 * glTranslatef(0.0, 0.0, -1.0);
4047 * glScalef(1.0, 1.0, 2.0);
4049 * glScalef(1.0, flip, 1.0);
4050 * glTranslatef(1/w, -1/h, 0.0);
4052 * This is equivalent to:
4053 * glTranslatef(1/w, -flip/h, -1.0)
4054 * glScalef(1.0, flip, 2.0);
4057 /* Translate by slightly less than a half pixel to force a top-left
4058 * filling convention. We want the difference to be large enough that
4059 * it doesn't get lost due to rounding inside the driver, but small
4060 * enough to prevent it from interfering with any anti-aliasing. */
4061 GLfloat xoffset
= (63.0f
/ 64.0f
) / stateblock
->state
.viewport
.Width
;
4062 GLfloat yoffset
= -(63.0f
/ 64.0f
) / stateblock
->state
.viewport
.Height
;
4064 if (context
->render_offscreen
)
4066 /* D3D texture coordinates are flipped compared to OpenGL ones, so
4067 * render everything upside down when rendering offscreen. */
4068 glTranslatef(xoffset
, -yoffset
, -1.0f
);
4069 checkGLcall("glTranslatef(xoffset, -yoffset, -1.0f)");
4070 glScalef(1.0f
, -1.0f
, 2.0f
);
4072 glTranslatef(xoffset
, yoffset
, -1.0f
);
4073 checkGLcall("glTranslatef(xoffset, yoffset, -1.0f)");
4074 glScalef(1.0f
, 1.0f
, 2.0f
);
4076 checkGLcall("glScalef");
4078 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_PROJECTION
].u
.m
[0][0]);
4079 checkGLcall("glLoadMatrixf");
4083 /* This should match any arrays loaded in loadVertexData.
4084 * TODO: Only load / unload arrays if we have to.
4086 static inline void unloadVertexData(const struct wined3d_gl_info
*gl_info
)
4088 glDisableClientState(GL_VERTEX_ARRAY
);
4089 glDisableClientState(GL_NORMAL_ARRAY
);
4090 glDisableClientState(GL_COLOR_ARRAY
);
4091 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4093 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4095 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4097 glDisableClientState(GL_WEIGHT_ARRAY_ARB
);
4099 unloadTexCoords(gl_info
);
4102 static inline void unload_numbered_array(struct wined3d_context
*context
, int i
)
4104 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4106 GL_EXTCALL(glDisableVertexAttribArrayARB(i
));
4107 checkGLcall("glDisableVertexAttribArrayARB(reg)");
4109 context
->numbered_array_mask
&= ~(1 << i
);
4112 /* This should match any arrays loaded in loadNumberedArrays
4113 * TODO: Only load / unload arrays if we have to.
4115 static inline void unloadNumberedArrays(struct wined3d_context
*context
)
4117 /* disable any attribs (this is the same for both GLSL and ARB modes) */
4118 GLint maxAttribs
= 16;
4121 /* Leave all the attribs disabled */
4122 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB
, &maxAttribs
);
4123 /* MESA does not support it right not */
4124 if (glGetError() != GL_NO_ERROR
)
4126 for (i
= 0; i
< maxAttribs
; ++i
) {
4127 unload_numbered_array(context
, i
);
4131 static void loadNumberedArrays(struct wined3d_stateblock
*stateblock
,
4132 const struct wined3d_stream_info
*stream_info
, struct wined3d_context
*context
)
4134 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4135 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4137 struct wined3d_buffer
*vb
;
4138 DWORD_PTR shift_index
;
4140 /* Default to no instancing */
4141 stateblock
->device
->instancedDraw
= FALSE
;
4143 for (i
= 0; i
< MAX_ATTRIBS
; i
++)
4145 const struct wined3d_stream_state
*stream
;
4147 if (!(stream_info
->use_map
& (1 << i
)))
4149 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4153 stream
= &stateblock
->state
.streams
[stream_info
->elements
[i
].stream_idx
];
4155 /* Do not load instance data. It will be specified using glTexCoord by drawprim */
4156 if (stream
->flags
& WINED3DSTREAMSOURCE_INSTANCEDATA
)
4158 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4159 stateblock
->device
->instancedDraw
= TRUE
;
4163 TRACE_(d3d_shader
)("Loading array %u [VBO=%u]\n", i
, stream_info
->elements
[i
].buffer_object
);
4165 if (stream_info
->elements
[i
].stride
)
4167 if (curVBO
!= stream_info
->elements
[i
].buffer_object
)
4169 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, stream_info
->elements
[i
].buffer_object
));
4170 checkGLcall("glBindBufferARB");
4171 curVBO
= stream_info
->elements
[i
].buffer_object
;
4173 /* Use the VBO to find out if a vertex buffer exists, not the vb
4174 * pointer. vb can point to a user pointer data blob. In that case
4175 * curVBO will be 0. If there is a vertex buffer but no vbo we
4176 * won't be load converted attributes anyway. */
4177 vb
= stream
->buffer
;
4178 if (curVBO
&& vb
->conversion_shift
)
4180 TRACE("Loading attribute from shifted buffer\n");
4181 TRACE("Attrib %d has original stride %d, new stride %d\n",
4182 i
, stream_info
->elements
[i
].stride
, vb
->conversion_stride
);
4183 TRACE("Original offset %p, additional offset 0x%08x\n",
4184 stream_info
->elements
[i
].data
, vb
->conversion_shift
[(DWORD_PTR
)stream_info
->elements
[i
].data
]);
4185 TRACE("Opengl type %#x\n", stream_info
->elements
[i
].format
->gl_vtx_type
);
4186 shift_index
= ((DWORD_PTR
)stream_info
->elements
[i
].data
+ stream
->offset
);
4187 shift_index
= shift_index
% stream_info
->elements
[i
].stride
;
4188 GL_EXTCALL(glVertexAttribPointerARB(i
, stream_info
->elements
[i
].format
->gl_vtx_format
,
4189 stream_info
->elements
[i
].format
->gl_vtx_type
,
4190 stream_info
->elements
[i
].format
->gl_normalized
,
4191 vb
->conversion_stride
, stream_info
->elements
[i
].data
+ vb
->conversion_shift
[shift_index
]
4192 + stateblock
->state
.load_base_vertex_index
* stream_info
->elements
[i
].stride
4196 GL_EXTCALL(glVertexAttribPointerARB(i
, stream_info
->elements
[i
].format
->gl_vtx_format
,
4197 stream_info
->elements
[i
].format
->gl_vtx_type
,
4198 stream_info
->elements
[i
].format
->gl_normalized
,
4199 stream_info
->elements
[i
].stride
, stream_info
->elements
[i
].data
4200 + stateblock
->state
.load_base_vertex_index
* stream_info
->elements
[i
].stride
4204 if (!(context
->numbered_array_mask
& (1 << i
)))
4206 GL_EXTCALL(glEnableVertexAttribArrayARB(i
));
4207 context
->numbered_array_mask
|= (1 << i
);
4212 /* Stride = 0 means always the same values.
4213 * glVertexAttribPointerARB doesn't do that. Instead disable the
4214 * pointer and set up the attribute statically. But we have to
4215 * figure out the system memory address. */
4216 const BYTE
*ptr
= stream_info
->elements
[i
].data
+ stream
->offset
;
4217 if (stream_info
->elements
[i
].buffer_object
)
4219 vb
= stream
->buffer
;
4220 ptr
+= (ULONG_PTR
)buffer_get_sysmem(vb
, gl_info
);
4223 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4225 switch (stream_info
->elements
[i
].format
->id
)
4227 case WINED3DFMT_R32_FLOAT
:
4228 GL_EXTCALL(glVertexAttrib1fvARB(i
, (const GLfloat
*)ptr
));
4230 case WINED3DFMT_R32G32_FLOAT
:
4231 GL_EXTCALL(glVertexAttrib2fvARB(i
, (const GLfloat
*)ptr
));
4233 case WINED3DFMT_R32G32B32_FLOAT
:
4234 GL_EXTCALL(glVertexAttrib3fvARB(i
, (const GLfloat
*)ptr
));
4236 case WINED3DFMT_R32G32B32A32_FLOAT
:
4237 GL_EXTCALL(glVertexAttrib4fvARB(i
, (const GLfloat
*)ptr
));
4240 case WINED3DFMT_R8G8B8A8_UINT
:
4241 GL_EXTCALL(glVertexAttrib4NubvARB(i
, ptr
));
4243 case WINED3DFMT_B8G8R8A8_UNORM
:
4244 if (gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
])
4246 const DWORD
*src
= (const DWORD
*)ptr
;
4247 DWORD c
= *src
& 0xff00ff00;
4248 c
|= (*src
& 0xff0000) >> 16;
4249 c
|= (*src
& 0xff) << 16;
4250 GL_EXTCALL(glVertexAttrib4NubvARB(i
, (GLubyte
*)&c
));
4253 /* else fallthrough */
4254 case WINED3DFMT_R8G8B8A8_UNORM
:
4255 GL_EXTCALL(glVertexAttrib4NubvARB(i
, ptr
));
4258 case WINED3DFMT_R16G16_SINT
:
4259 GL_EXTCALL(glVertexAttrib4svARB(i
, (const GLshort
*)ptr
));
4261 case WINED3DFMT_R16G16B16A16_SINT
:
4262 GL_EXTCALL(glVertexAttrib4svARB(i
, (const GLshort
*)ptr
));
4265 case WINED3DFMT_R16G16_SNORM
:
4267 const GLshort s
[4] = {((const GLshort
*)ptr
)[0], ((const GLshort
*)ptr
)[1], 0, 1};
4268 GL_EXTCALL(glVertexAttrib4NsvARB(i
, s
));
4271 case WINED3DFMT_R16G16_UNORM
:
4273 const GLushort s
[4] = {((const GLushort
*)ptr
)[0], ((const GLushort
*)ptr
)[1], 0, 1};
4274 GL_EXTCALL(glVertexAttrib4NusvARB(i
, s
));
4277 case WINED3DFMT_R16G16B16A16_SNORM
:
4278 GL_EXTCALL(glVertexAttrib4NsvARB(i
, (const GLshort
*)ptr
));
4280 case WINED3DFMT_R16G16B16A16_UNORM
:
4281 GL_EXTCALL(glVertexAttrib4NusvARB(i
, (const GLushort
*)ptr
));
4284 case WINED3DFMT_R10G10B10A2_UINT
:
4285 FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
4286 /*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
4288 case WINED3DFMT_R10G10B10A2_SNORM
:
4289 FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
4290 /*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
4293 case WINED3DFMT_R16G16_FLOAT
:
4294 /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
4295 * byte float according to the IEEE standard
4297 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
4299 case WINED3DFMT_R16G16B16A16_FLOAT
:
4300 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
4304 ERR("Unexpected declaration in stride 0 attributes\n");
4310 checkGLcall("Loading numbered arrays");
4313 /* Used from 2 different functions, and too big to justify making it inlined */
4314 static void loadVertexData(const struct wined3d_context
*context
, struct wined3d_stateblock
*stateblock
,
4315 const struct wined3d_stream_info
*si
)
4317 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4318 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4319 const struct wined3d_stream_info_element
*e
;
4320 const struct wined3d_stream_state
*stream
;
4322 TRACE("Using fast vertex array code\n");
4324 /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
4325 stateblock
->device
->instancedDraw
= FALSE
;
4327 /* Blend Data ---------------------------------------------- */
4328 if ((si
->use_map
& (1 << WINED3D_FFP_BLENDWEIGHT
))
4329 || si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4331 e
= &si
->elements
[WINED3D_FFP_BLENDWEIGHT
];
4332 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4334 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4336 TRACE("Blend %u %p %u\n", e
->format
->component_count
,
4337 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
, e
->stride
+ stream
->offset
);
4339 glEnableClientState(GL_WEIGHT_ARRAY_ARB
);
4340 checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
4342 GL_EXTCALL(glVertexBlendARB(e
->format
->component_count
+ 1));
4344 if (curVBO
!= e
->buffer_object
)
4346 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4347 checkGLcall("glBindBufferARB");
4348 curVBO
= e
->buffer_object
;
4351 TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
4352 e
->format
->gl_vtx_format
,
4353 e
->format
->gl_vtx_type
,
4355 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4356 GL_EXTCALL(glWeightPointerARB(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4357 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4359 checkGLcall("glWeightPointerARB");
4361 if (si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4366 FIXME("blendMatrixIndices support\n");
4371 /* TODO: support blends in drawStridedSlow
4372 * No need to write a FIXME here, this is done after the general vertex decl decoding
4374 WARN("unsupported blending in openGl\n");
4379 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4381 static const GLbyte one
= 1;
4382 GL_EXTCALL(glWeightbvARB(1, &one
));
4383 checkGLcall("glWeightbvARB(gl_info->max_blends, weights)");
4387 /* Point Size ----------------------------------------------*/
4388 if (si
->use_map
& (1 << WINED3D_FFP_PSIZE
))
4390 /* no such functionality in the fixed function GL pipeline */
4391 TRACE("Cannot change ptSize here in openGl\n");
4392 /* TODO: Implement this function in using shaders if they are available */
4395 /* Vertex Pointers -----------------------------------------*/
4396 if (si
->use_map
& (1 << WINED3D_FFP_POSITION
))
4398 e
= &si
->elements
[WINED3D_FFP_POSITION
];
4399 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4401 if (curVBO
!= e
->buffer_object
)
4403 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4404 checkGLcall("glBindBufferARB");
4405 curVBO
= e
->buffer_object
;
4408 /* min(WINED3D_ATR_FORMAT(position),3) to Disable RHW mode as 'w' coord
4409 handling for rhw mode should not impact screen position whereas in GL it does.
4410 This may result in very slightly distorted textures in rhw mode.
4411 There's always the other option of fixing the view matrix to
4412 prevent w from having any effect.
4414 This only applies to user pointer sources, in VBOs the vertices are fixed up
4416 if (!e
->buffer_object
)
4418 TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e
->format
->gl_vtx_type
, e
->stride
,
4419 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4420 glVertexPointer(3 /* min(e->format->gl_vtx_format, 3) */, e
->format
->gl_vtx_type
, e
->stride
,
4421 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4425 TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
4426 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4427 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4428 glVertexPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4429 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4431 checkGLcall("glVertexPointer(...)");
4432 glEnableClientState(GL_VERTEX_ARRAY
);
4433 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
4436 /* Normals -------------------------------------------------*/
4437 if (si
->use_map
& (1 << WINED3D_FFP_NORMAL
))
4439 e
= &si
->elements
[WINED3D_FFP_NORMAL
];
4440 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4442 if (curVBO
!= e
->buffer_object
)
4444 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4445 checkGLcall("glBindBufferARB");
4446 curVBO
= e
->buffer_object
;
4449 TRACE("glNormalPointer(%#x, %#x, %p);\n", e
->format
->gl_vtx_type
, e
->stride
,
4450 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4451 glNormalPointer(e
->format
->gl_vtx_type
, e
->stride
,
4452 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4453 checkGLcall("glNormalPointer(...)");
4454 glEnableClientState(GL_NORMAL_ARRAY
);
4455 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
4458 glNormal3f(0, 0, 0);
4459 checkGLcall("glNormal3f(0, 0, 0)");
4462 /* Diffuse Colour --------------------------------------------*/
4463 /* WARNING: Data here MUST be in RGBA format, so cannot */
4464 /* go directly into fast mode from app pgm, because */
4465 /* directx requires data in BGRA format. */
4466 /* currently fixupVertices swizzles the format, but this isn't*/
4467 /* very practical when using VBOs */
4468 /* NOTE: Unless we write a vertex shader to swizzle the colour*/
4469 /* , or the user doesn't care and wants the speed advantage */
4471 if (si
->use_map
& (1 << WINED3D_FFP_DIFFUSE
))
4473 e
= &si
->elements
[WINED3D_FFP_DIFFUSE
];
4474 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4476 if (curVBO
!= e
->buffer_object
)
4478 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4479 checkGLcall("glBindBufferARB");
4480 curVBO
= e
->buffer_object
;
4483 TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
4484 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4485 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4486 glColorPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4487 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4488 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
4489 glEnableClientState(GL_COLOR_ARRAY
);
4490 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
4493 glColor4f(1.0f
, 1.0f
, 1.0f
, 1.0f
);
4494 checkGLcall("glColor4f(1, 1, 1, 1)");
4497 /* Specular Colour ------------------------------------------*/
4498 if (si
->use_map
& (1 << WINED3D_FFP_SPECULAR
))
4500 TRACE("setting specular colour\n");
4502 e
= &si
->elements
[WINED3D_FFP_SPECULAR
];
4503 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4505 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4507 GLenum type
= e
->format
->gl_vtx_type
;
4508 GLint format
= e
->format
->gl_vtx_format
;
4510 if (curVBO
!= e
->buffer_object
)
4512 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4513 checkGLcall("glBindBufferARB");
4514 curVBO
= e
->buffer_object
;
4517 if (format
!= 4 || (gl_info
->quirks
& WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA
))
4519 /* Usually specular colors only allow 3 components, since they have no alpha. In D3D, the specular alpha
4520 * contains the fog coordinate, which is passed to GL with GL_EXT_fog_coord. However, the fixed function
4521 * vertex pipeline can pass the specular alpha through, and pixel shaders can read it. So it GL accepts
4522 * 4 component secondary colors use it
4524 TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format
, type
, e
->stride
,
4525 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4526 GL_EXTCALL(glSecondaryColorPointerEXT(format
, type
, e
->stride
,
4527 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4528 checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
4534 case GL_UNSIGNED_BYTE
:
4535 TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e
->stride
,
4536 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4537 GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE
, e
->stride
,
4538 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4539 checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
4543 FIXME("Add 4 component specular color pointers for type %x\n", type
);
4544 /* Make sure that the right color component is dropped */
4545 TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type
, e
->stride
,
4546 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4547 GL_EXTCALL(glSecondaryColorPointerEXT(3, type
, e
->stride
,
4548 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4549 checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
4552 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4553 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
4557 WARN("Specular colour is not supported in this GL implementation.\n");
4562 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4564 GL_EXTCALL(glSecondaryColor3fEXT
)(0, 0, 0);
4565 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
4569 WARN("Specular colour is not supported in this GL implementation.\n");
4573 /* Texture coords -------------------------------------------*/
4574 loadTexCoords(gl_info
, stateblock
, si
, &curVBO
);
4577 static void streamsrc(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4579 IWineD3DDeviceImpl
*device
= stateblock
->device
;
4580 BOOL load_numbered
= use_vs(&stateblock
->state
) && !device
->useDrawStridedSlow
;
4581 BOOL load_named
= !use_vs(&stateblock
->state
) && !device
->useDrawStridedSlow
;
4583 if (context
->numberedArraysLoaded
&& !load_numbered
)
4585 unloadNumberedArrays(context
);
4586 context
->numberedArraysLoaded
= FALSE
;
4587 context
->numbered_array_mask
= 0;
4589 else if (context
->namedArraysLoaded
)
4591 unloadVertexData(context
->gl_info
);
4592 context
->namedArraysLoaded
= FALSE
;
4597 TRACE("Loading numbered arrays\n");
4598 loadNumberedArrays(stateblock
, &device
->strided_streams
, context
);
4599 context
->numberedArraysLoaded
= TRUE
;
4601 else if (load_named
)
4603 TRACE("Loading vertex data\n");
4604 loadVertexData(context
, stateblock
, &device
->strided_streams
);
4605 context
->namedArraysLoaded
= TRUE
;
4609 static void vertexdeclaration(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4611 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4612 const struct wined3d_state
*state
= &stateblock
->state
;
4613 BOOL useVertexShaderFunction
= use_vs(state
);
4614 BOOL usePixelShaderFunction
= use_ps(state
);
4615 BOOL updateFog
= FALSE
;
4616 IWineD3DDeviceImpl
*device
= stateblock
->device
;
4618 BOOL wasrhw
= context
->last_was_rhw
;
4621 transformed
= device
->strided_streams
.position_transformed
;
4622 if(transformed
!= context
->last_was_rhw
&& !useVertexShaderFunction
) {
4627 context
->last_was_rhw
= TRUE
;
4630 /* Untransformed, so relies on the view and projection matrices */
4631 context
->last_was_rhw
= FALSE
;
4632 /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
4633 device
->untransformed
= TRUE
;
4636 /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
4637 * off this function will be called again anyway to make sure they're properly set
4639 if(!useVertexShaderFunction
) {
4640 /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
4641 * or transformed / untransformed was switched
4643 if(wasrhw
!= context
->last_was_rhw
&&
4644 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
)) &&
4645 !isStateDirty(context
, STATE_VIEWPORT
)) {
4646 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4648 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
4651 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
4652 * this check will fail and the matrix not applied again. This is OK because a simple
4653 * world matrix change reapplies the matrix - These checks here are only to satisfy the
4654 * needs of the vertex declaration.
4656 * World and view matrix go into the same gl matrix, so only apply them when neither is
4659 if(transformed
!= wasrhw
&&
4660 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
4661 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
))) {
4662 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
4665 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_COLORVERTEX
))) {
4666 state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX
), stateblock
, context
);
4668 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_LIGHTING
))) {
4669 state_lighting(STATE_RENDER(WINED3DRS_LIGHTING
), stateblock
, context
);
4672 if(context
->last_was_vshader
) {
4674 if(!device
->vs_clipping
&& !isStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
))) {
4675 state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
), stateblock
, context
);
4677 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4679 clipplane(STATE_CLIPPLANE(i
), stateblock
, context
);
4682 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_NORMALIZENORMALS
))) {
4683 state_normalize(STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), stateblock
, context
);
4686 if(!context
->last_was_vshader
) {
4687 static BOOL warned
= FALSE
;
4688 if(!device
->vs_clipping
) {
4689 /* Disable all clip planes to get defined results on all drivers. See comment in the
4690 * state_clipping state handler
4692 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4694 glDisable(GL_CLIP_PLANE0
+ i
);
4695 checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
4698 if (!warned
&& stateblock
->state
.render_states
[WINED3DRS_CLIPPLANEENABLE
])
4700 FIXME("Clipping not supported with vertex shaders\n");
4705 /* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
4706 * shaders themselves do not need it, but the matrices are not reapplied automatically when
4707 * switching back from vertex shaders to fixed function processing. So make sure we leave the
4708 * fixed function vertex processing states back in a sane state before switching to shaders
4710 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
))) {
4711 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4713 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
4714 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
4719 /* Vertex shader clipping ignores the view matrix. Update all clipplanes
4720 * (Note: ARB shaders can read the clip planes for clipping emulation even if
4721 * device->vs_clipping is false.
4723 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4725 clipplane(STATE_CLIPPLANE(i
), stateblock
, context
);
4730 /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
4733 if (!isStateDirty(context
, STATE_PIXELSHADER
)) {
4734 device
->shader_backend
->shader_select(context
, usePixelShaderFunction
, useVertexShaderFunction
);
4736 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
) && (useVertexShaderFunction
|| usePixelShaderFunction
)) {
4737 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
4741 context
->last_was_vshader
= useVertexShaderFunction
;
4743 if (updateFog
) stateblock_apply_state(STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), stateblock
, context
);
4745 if(!useVertexShaderFunction
) {
4747 for(i
= 0; i
< MAX_TEXTURES
; i
++) {
4748 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ i
))) {
4749 transform_texture(STATE_TEXTURESTAGE(i
, WINED3DTSS_TEXTURETRANSFORMFLAGS
), stateblock
, context
);
4755 static void viewport_miscpart(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4757 IWineD3DSurfaceImpl
*target
= stateblock
->device
->render_targets
[0];
4759 WINED3DVIEWPORT vp
= stateblock
->state
.viewport
;
4761 if (vp
.Width
> target
->resource
.width
)
4762 vp
.Width
= target
->resource
.width
;
4763 if (vp
.Height
> target
->resource
.height
)
4764 vp
.Height
= target
->resource
.height
;
4766 glDepthRange(vp
.MinZ
, vp
.MaxZ
);
4767 checkGLcall("glDepthRange");
4768 /* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
4770 if (context
->render_offscreen
)
4772 glViewport(vp
.X
, vp
.Y
, vp
.Width
, vp
.Height
);
4774 target
->get_drawable_size(context
, &width
, &height
);
4777 (height
- (vp
.Y
+ vp
.Height
)),
4778 vp
.Width
, vp
.Height
);
4781 checkGLcall("glViewport");
4784 static void viewport_vertexpart(DWORD state_id
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4786 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
))) {
4787 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4789 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_POINTSCALEENABLE
))) {
4790 state_pscale(STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), stateblock
, context
);
4792 /* Update the position fixup. */
4793 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
))
4794 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
4797 static void light(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4799 UINT Index
= state
- STATE_ACTIVELIGHT(0);
4800 const struct wined3d_light_info
*lightInfo
= stateblock
->state
.lights
[Index
];
4803 glDisable(GL_LIGHT0
+ Index
);
4804 checkGLcall("glDisable(GL_LIGHT0 + Index)");
4807 float colRGBA
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
4809 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
4810 glMatrixMode(GL_MODELVIEW
);
4812 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
4815 colRGBA
[0] = lightInfo
->OriginalParms
.Diffuse
.r
;
4816 colRGBA
[1] = lightInfo
->OriginalParms
.Diffuse
.g
;
4817 colRGBA
[2] = lightInfo
->OriginalParms
.Diffuse
.b
;
4818 colRGBA
[3] = lightInfo
->OriginalParms
.Diffuse
.a
;
4819 glLightfv(GL_LIGHT0
+ Index
, GL_DIFFUSE
, colRGBA
);
4820 checkGLcall("glLightfv");
4823 colRGBA
[0] = lightInfo
->OriginalParms
.Specular
.r
;
4824 colRGBA
[1] = lightInfo
->OriginalParms
.Specular
.g
;
4825 colRGBA
[2] = lightInfo
->OriginalParms
.Specular
.b
;
4826 colRGBA
[3] = lightInfo
->OriginalParms
.Specular
.a
;
4827 glLightfv(GL_LIGHT0
+ Index
, GL_SPECULAR
, colRGBA
);
4828 checkGLcall("glLightfv");
4831 colRGBA
[0] = lightInfo
->OriginalParms
.Ambient
.r
;
4832 colRGBA
[1] = lightInfo
->OriginalParms
.Ambient
.g
;
4833 colRGBA
[2] = lightInfo
->OriginalParms
.Ambient
.b
;
4834 colRGBA
[3] = lightInfo
->OriginalParms
.Ambient
.a
;
4835 glLightfv(GL_LIGHT0
+ Index
, GL_AMBIENT
, colRGBA
);
4836 checkGLcall("glLightfv");
4838 if ((lightInfo
->OriginalParms
.Range
*lightInfo
->OriginalParms
.Range
) >= FLT_MIN
) {
4839 quad_att
= 1.4f
/(lightInfo
->OriginalParms
.Range
*lightInfo
->OriginalParms
.Range
);
4841 quad_att
= 0.0f
; /* 0 or MAX? (0 seems to be ok) */
4844 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
4845 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
4846 * Attenuation0 to NaN and crashes in the gl lib
4849 switch (lightInfo
->OriginalParms
.Type
) {
4850 case WINED3DLIGHT_POINT
:
4852 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4853 checkGLcall("glLightfv");
4854 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4855 checkGLcall("glLightf");
4856 /* Attenuation - Are these right? guessing... */
4857 glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation0
);
4858 checkGLcall("glLightf");
4859 glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation1
);
4860 checkGLcall("glLightf");
4861 if (quad_att
< lightInfo
->OriginalParms
.Attenuation2
) quad_att
= lightInfo
->OriginalParms
.Attenuation2
;
4862 glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4863 checkGLcall("glLightf");
4867 case WINED3DLIGHT_SPOT
:
4869 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4870 checkGLcall("glLightfv");
4872 glLightfv(GL_LIGHT0
+ Index
, GL_SPOT_DIRECTION
, &lightInfo
->lightDirn
[0]);
4873 checkGLcall("glLightfv");
4874 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, lightInfo
->exponent
);
4875 checkGLcall("glLightf");
4876 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4877 checkGLcall("glLightf");
4878 /* Attenuation - Are these right? guessing... */
4879 glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation0
);
4880 checkGLcall("glLightf");
4881 glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation1
);
4882 checkGLcall("glLightf");
4883 if (quad_att
< lightInfo
->OriginalParms
.Attenuation2
) quad_att
= lightInfo
->OriginalParms
.Attenuation2
;
4884 glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4885 checkGLcall("glLightf");
4889 case WINED3DLIGHT_DIRECTIONAL
:
4891 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]); /* Note gl uses w position of 0 for direction! */
4892 checkGLcall("glLightfv");
4893 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4894 checkGLcall("glLightf");
4895 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, 0.0f
);
4896 checkGLcall("glLightf");
4900 FIXME("Unrecognized light type %d\n", lightInfo
->OriginalParms
.Type
);
4903 /* Restore the modelview matrix */
4906 glEnable(GL_LIGHT0
+ Index
);
4907 checkGLcall("glEnable(GL_LIGHT0 + Index)");
4911 static void scissorrect(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4913 IWineD3DSurfaceImpl
*target
= stateblock
->device
->render_targets
[0];
4914 RECT
*pRect
= &stateblock
->state
.scissor_rect
;
4918 target
->get_drawable_size(context
, &width
, &height
);
4919 /* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
4920 * Warning2: Even in windowed mode the coords are relative to the window, not the screen
4922 TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock
->device
, pRect
->left
, pRect
->bottom
- height
,
4923 pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4925 if (context
->render_offscreen
)
4927 glScissor(pRect
->left
, pRect
->top
, pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4929 glScissor(pRect
->left
, height
- pRect
->bottom
, pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4931 checkGLcall("glScissor");
4934 static void indexbuffer(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4936 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4938 if (stateblock
->state
.user_stream
|| !stateblock
->state
.index_buffer
)
4940 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB
, 0));
4944 struct wined3d_buffer
*ib
= stateblock
->state
.index_buffer
;
4945 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB
, ib
->buffer_object
));
4949 static void frontface(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4951 if (context
->render_offscreen
)
4953 glFrontFace(GL_CCW
);
4954 checkGLcall("glFrontFace(GL_CCW)");
4957 checkGLcall("glFrontFace(GL_CW)");
4961 static void psorigin_w(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4967 WARN("Point sprite coordinate origin switching not supported.\n");
4972 static void psorigin(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
4974 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4975 GLint origin
= context
->render_offscreen
? GL_LOWER_LEFT
: GL_UPPER_LEFT
;
4977 if (glPointParameteri
)
4979 glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN
, origin
);
4980 checkGLcall("glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
4982 else if (gl_info
->supported
[NV_POINT_SPRITE
])
4984 GL_EXTCALL(glPointParameteriNV(GL_POINT_SPRITE_COORD_ORIGIN
, origin
));
4985 checkGLcall("glPointParameteriNV(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
4989 const struct StateEntryTemplate misc_state_template
[] = {
4990 { STATE_RENDER(WINED3DRS_SRCBLEND
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4991 { STATE_RENDER(WINED3DRS_DESTBLEND
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4992 { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
}, WINED3D_GL_EXT_NONE
},
4993 { STATE_RENDER(WINED3DRS_EDGEANTIALIAS
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4994 { STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4995 { STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4996 { STATE_RENDER(WINED3DRS_SRCBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4997 { STATE_RENDER(WINED3DRS_DESTBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4998 { STATE_RENDER(WINED3DRS_DESTBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4999 { STATE_RENDER(WINED3DRS_BLENDOPALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5000 { STATE_STREAMSRC
, { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
5001 { STATE_VDECL
, { STATE_VDECL
, streamsrc
}, WINED3D_GL_EXT_NONE
},
5002 { STATE_FRONTFACE
, { STATE_FRONTFACE
, frontface
}, WINED3D_GL_EXT_NONE
},
5003 { STATE_SCISSORRECT
, { STATE_SCISSORRECT
, scissorrect
}, WINED3D_GL_EXT_NONE
},
5004 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin
}, WINED3D_GL_VERSION_2_0
},
5005 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin_w
}, WINED3D_GL_EXT_NONE
},
5007 /* TODO: Move shader constant loading to vertex and fragment pipeline repectively, as soon as the pshader and
5008 * vshader loadings are untied from each other
5010 { STATE_VERTEXSHADERCONSTANT
, { STATE_VERTEXSHADERCONSTANT
, shaderconstant
}, WINED3D_GL_EXT_NONE
},
5011 { STATE_PIXELSHADERCONSTANT
, { STATE_VERTEXSHADERCONSTANT
, NULL
}, WINED3D_GL_EXT_NONE
},
5012 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5013 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5014 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5015 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5016 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5017 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5018 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5019 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5020 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5021 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5022 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5023 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5024 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5025 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5026 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5027 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5028 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5029 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5030 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5031 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5032 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5033 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5034 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5035 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5036 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5037 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5038 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5039 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5040 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5041 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5042 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5043 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5044 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5045 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5046 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5047 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5048 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5049 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5050 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5051 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5052 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5053 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5054 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5055 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5056 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5057 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5058 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5059 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5061 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_miscpart
}, WINED3D_GL_EXT_NONE
},
5062 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, indexbuffer
}, ARB_VERTEX_BUFFER_OBJECT
},
5063 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, state_nop
}, WINED3D_GL_EXT_NONE
},
5064 { STATE_RENDER(WINED3DRS_ANTIALIAS
), { STATE_RENDER(WINED3DRS_ANTIALIAS
), state_antialias
}, WINED3D_GL_EXT_NONE
},
5065 { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE
), { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE
), state_perspective
}, WINED3D_GL_EXT_NONE
},
5066 { STATE_RENDER(WINED3DRS_ZENABLE
), { STATE_RENDER(WINED3DRS_ZENABLE
), state_zenable
}, WINED3D_GL_EXT_NONE
},
5067 { STATE_RENDER(WINED3DRS_WRAPU
), { STATE_RENDER(WINED3DRS_WRAPU
), state_wrapu
}, WINED3D_GL_EXT_NONE
},
5068 { STATE_RENDER(WINED3DRS_WRAPV
), { STATE_RENDER(WINED3DRS_WRAPV
), state_wrapv
}, WINED3D_GL_EXT_NONE
},
5069 { STATE_RENDER(WINED3DRS_FILLMODE
), { STATE_RENDER(WINED3DRS_FILLMODE
), state_fillmode
}, WINED3D_GL_EXT_NONE
},
5070 { STATE_RENDER(WINED3DRS_SHADEMODE
), { STATE_RENDER(WINED3DRS_SHADEMODE
), state_shademode
}, WINED3D_GL_EXT_NONE
},
5071 { STATE_RENDER(WINED3DRS_LINEPATTERN
), { STATE_RENDER(WINED3DRS_LINEPATTERN
), state_linepattern
}, WINED3D_GL_EXT_NONE
},
5072 { STATE_RENDER(WINED3DRS_MONOENABLE
), { STATE_RENDER(WINED3DRS_MONOENABLE
), state_monoenable
}, WINED3D_GL_EXT_NONE
},
5073 { STATE_RENDER(WINED3DRS_ROP2
), { STATE_RENDER(WINED3DRS_ROP2
), state_rop2
}, WINED3D_GL_EXT_NONE
},
5074 { STATE_RENDER(WINED3DRS_PLANEMASK
), { STATE_RENDER(WINED3DRS_PLANEMASK
), state_planemask
}, WINED3D_GL_EXT_NONE
},
5075 { STATE_RENDER(WINED3DRS_ZWRITEENABLE
), { STATE_RENDER(WINED3DRS_ZWRITEENABLE
), state_zwritenable
}, WINED3D_GL_EXT_NONE
},
5076 { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
}, WINED3D_GL_EXT_NONE
},
5077 { STATE_RENDER(WINED3DRS_ALPHAREF
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5078 { STATE_RENDER(WINED3DRS_ALPHAFUNC
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5079 { STATE_RENDER(WINED3DRS_COLORKEYENABLE
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5080 { STATE_RENDER(WINED3DRS_LASTPIXEL
), { STATE_RENDER(WINED3DRS_LASTPIXEL
), state_lastpixel
}, WINED3D_GL_EXT_NONE
},
5081 { STATE_RENDER(WINED3DRS_CULLMODE
), { STATE_RENDER(WINED3DRS_CULLMODE
), state_cullmode
}, WINED3D_GL_EXT_NONE
},
5082 { STATE_RENDER(WINED3DRS_ZFUNC
), { STATE_RENDER(WINED3DRS_ZFUNC
), state_zfunc
}, WINED3D_GL_EXT_NONE
},
5083 { STATE_RENDER(WINED3DRS_DITHERENABLE
), { STATE_RENDER(WINED3DRS_DITHERENABLE
), state_ditherenable
}, WINED3D_GL_EXT_NONE
},
5084 { STATE_RENDER(WINED3DRS_SUBPIXEL
), { STATE_RENDER(WINED3DRS_SUBPIXEL
), state_subpixel
}, WINED3D_GL_EXT_NONE
},
5085 { STATE_RENDER(WINED3DRS_SUBPIXELX
), { STATE_RENDER(WINED3DRS_SUBPIXELX
), state_subpixelx
}, WINED3D_GL_EXT_NONE
},
5086 { STATE_RENDER(WINED3DRS_STIPPLEDALPHA
), { STATE_RENDER(WINED3DRS_STIPPLEDALPHA
), state_stippledalpha
}, WINED3D_GL_EXT_NONE
},
5087 { STATE_RENDER(WINED3DRS_ZBIAS
), { STATE_RENDER(WINED3DRS_ZBIAS
), state_zbias
}, WINED3D_GL_EXT_NONE
},
5088 { STATE_RENDER(WINED3DRS_STIPPLEENABLE
), { STATE_RENDER(WINED3DRS_STIPPLEENABLE
), state_stippleenable
}, WINED3D_GL_EXT_NONE
},
5089 { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS
), { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS
), state_mipmaplodbias
}, WINED3D_GL_EXT_NONE
},
5090 { STATE_RENDER(WINED3DRS_ANISOTROPY
), { STATE_RENDER(WINED3DRS_ANISOTROPY
), state_anisotropy
}, WINED3D_GL_EXT_NONE
},
5091 { STATE_RENDER(WINED3DRS_FLUSHBATCH
), { STATE_RENDER(WINED3DRS_FLUSHBATCH
), state_flushbatch
}, WINED3D_GL_EXT_NONE
},
5092 { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
), state_translucentsi
}, WINED3D_GL_EXT_NONE
},
5093 { STATE_RENDER(WINED3DRS_STENCILENABLE
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
}, WINED3D_GL_EXT_NONE
},
5094 { STATE_RENDER(WINED3DRS_STENCILFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5095 { STATE_RENDER(WINED3DRS_STENCILZFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5096 { STATE_RENDER(WINED3DRS_STENCILPASS
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5097 { STATE_RENDER(WINED3DRS_STENCILFUNC
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5098 { STATE_RENDER(WINED3DRS_STENCILREF
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5099 { STATE_RENDER(WINED3DRS_STENCILMASK
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5100 { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), state_stencilwrite2s
}, EXT_STENCIL_TWO_SIDE
},
5101 { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), state_stencilwrite
}, WINED3D_GL_EXT_NONE
},
5102 { STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5103 { STATE_RENDER(WINED3DRS_CCW_STENCILFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5104 { STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5105 { STATE_RENDER(WINED3DRS_CCW_STENCILPASS
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5106 { STATE_RENDER(WINED3DRS_CCW_STENCILFUNC
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5107 { STATE_RENDER(WINED3DRS_WRAP0
), { STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
}, WINED3D_GL_EXT_NONE
},
5108 { STATE_RENDER(WINED3DRS_WRAP1
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5109 { STATE_RENDER(WINED3DRS_WRAP2
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5110 { STATE_RENDER(WINED3DRS_WRAP3
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5111 { STATE_RENDER(WINED3DRS_WRAP4
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5112 { STATE_RENDER(WINED3DRS_WRAP5
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5113 { STATE_RENDER(WINED3DRS_WRAP6
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5114 { STATE_RENDER(WINED3DRS_WRAP7
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5115 { STATE_RENDER(WINED3DRS_WRAP8
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5116 { STATE_RENDER(WINED3DRS_WRAP9
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5117 { STATE_RENDER(WINED3DRS_WRAP10
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5118 { STATE_RENDER(WINED3DRS_WRAP11
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5119 { STATE_RENDER(WINED3DRS_WRAP12
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5120 { STATE_RENDER(WINED3DRS_WRAP13
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5121 { STATE_RENDER(WINED3DRS_WRAP14
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5122 { STATE_RENDER(WINED3DRS_WRAP15
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5123 { STATE_RENDER(WINED3DRS_EXTENTS
), { STATE_RENDER(WINED3DRS_EXTENTS
), state_extents
}, WINED3D_GL_EXT_NONE
},
5124 { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE
), { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE
), state_ckeyblend
}, WINED3D_GL_EXT_NONE
},
5125 { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING
), { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING
), state_swvp
}, WINED3D_GL_EXT_NONE
},
5126 { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE
), { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE
), state_patchedgestyle
}, WINED3D_GL_EXT_NONE
},
5127 { STATE_RENDER(WINED3DRS_PATCHSEGMENTS
), { STATE_RENDER(WINED3DRS_PATCHSEGMENTS
), state_patchsegments
}, WINED3D_GL_EXT_NONE
},
5128 { STATE_RENDER(WINED3DRS_POSITIONDEGREE
), { STATE_RENDER(WINED3DRS_POSITIONDEGREE
), state_positiondegree
}, WINED3D_GL_EXT_NONE
},
5129 { STATE_RENDER(WINED3DRS_NORMALDEGREE
), { STATE_RENDER(WINED3DRS_NORMALDEGREE
), state_normaldegree
}, WINED3D_GL_EXT_NONE
},
5130 { STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5131 { STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5132 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_X
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5133 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5134 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5135 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_W
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5136 { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_nvdb
}, EXT_DEPTH_BOUNDS_TEST
},
5137 { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
}, WINED3D_GL_EXT_NONE
},
5138 { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), state_msaa
}, ARB_MULTISAMPLE
},
5139 { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), state_msaa_w
}, WINED3D_GL_EXT_NONE
},
5140 { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK
), { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK
), state_multisampmask
}, WINED3D_GL_EXT_NONE
},
5141 { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN
), { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN
), state_debug_monitor
}, WINED3D_GL_EXT_NONE
},
5142 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite0
}, EXT_DRAW_BUFFERS2
},
5143 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
}, WINED3D_GL_EXT_NONE
},
5144 { STATE_RENDER(WINED3DRS_BLENDOP
), { STATE_RENDER(WINED3DRS_BLENDOP
), state_blendop
}, EXT_BLEND_MINMAX
},
5145 { STATE_RENDER(WINED3DRS_BLENDOP
), { STATE_RENDER(WINED3DRS_BLENDOP
), state_blendop_w
}, WINED3D_GL_EXT_NONE
},
5146 { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), state_scissor
}, WINED3D_GL_EXT_NONE
},
5147 { STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS
), { STATE_RENDER(WINED3DRS_DEPTHBIAS
), NULL
}, WINED3D_GL_EXT_NONE
},
5148 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), state_colorwrite1
}, EXT_DRAW_BUFFERS2
},
5149 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5150 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), state_colorwrite2
}, EXT_DRAW_BUFFERS2
},
5151 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5152 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), state_colorwrite3
}, EXT_DRAW_BUFFERS2
},
5153 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5154 { STATE_RENDER(WINED3DRS_BLENDFACTOR
), { STATE_RENDER(WINED3DRS_BLENDFACTOR
), state_blendfactor
}, EXT_BLEND_COLOR
},
5155 { STATE_RENDER(WINED3DRS_BLENDFACTOR
), { STATE_RENDER(WINED3DRS_BLENDFACTOR
), state_blendfactor_w
}, WINED3D_GL_EXT_NONE
},
5156 { STATE_RENDER(WINED3DRS_DEPTHBIAS
), { STATE_RENDER(WINED3DRS_DEPTHBIAS
), state_depthbias
}, WINED3D_GL_EXT_NONE
},
5157 { STATE_RENDER(WINED3DRS_ZVISIBLE
), { STATE_RENDER(WINED3DRS_ZVISIBLE
), state_zvisible
}, WINED3D_GL_EXT_NONE
},
5159 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler
}, WINED3D_GL_EXT_NONE
},
5160 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler
}, WINED3D_GL_EXT_NONE
},
5161 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler
}, WINED3D_GL_EXT_NONE
},
5162 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler
}, WINED3D_GL_EXT_NONE
},
5163 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler
}, WINED3D_GL_EXT_NONE
},
5164 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler
}, WINED3D_GL_EXT_NONE
},
5165 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler
}, WINED3D_GL_EXT_NONE
},
5166 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler
}, WINED3D_GL_EXT_NONE
},
5167 { STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler
}, WINED3D_GL_EXT_NONE
},
5168 { STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler
}, WINED3D_GL_EXT_NONE
},
5169 { STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler
}, WINED3D_GL_EXT_NONE
},
5170 { STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler
}, WINED3D_GL_EXT_NONE
},
5171 { STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler
}, WINED3D_GL_EXT_NONE
},
5172 { STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler
}, WINED3D_GL_EXT_NONE
},
5173 { STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler
}, WINED3D_GL_EXT_NONE
},
5174 { STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler
}, WINED3D_GL_EXT_NONE
},
5175 { STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler
}, WINED3D_GL_EXT_NONE
},
5176 { STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler
}, WINED3D_GL_EXT_NONE
},
5177 { STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler
}, WINED3D_GL_EXT_NONE
},
5178 { STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler
}, WINED3D_GL_EXT_NONE
},
5179 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5182 const struct StateEntryTemplate ffp_vertexstate_template
[] = {
5183 { STATE_VDECL
, { STATE_VDECL
, vertexdeclaration
}, WINED3D_GL_EXT_NONE
},
5184 { STATE_VSHADER
, { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
5185 { STATE_MATERIAL
, { STATE_RENDER(WINED3DRS_SPECULARENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5186 { STATE_RENDER(WINED3DRS_SPECULARENABLE
), { STATE_RENDER(WINED3DRS_SPECULARENABLE
), state_specularenable
}, WINED3D_GL_EXT_NONE
},
5188 { STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane
}, WINED3D_GL_EXT_NONE
},
5189 { STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane
}, WINED3D_GL_EXT_NONE
},
5190 { STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane
}, WINED3D_GL_EXT_NONE
},
5191 { STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane
}, WINED3D_GL_EXT_NONE
},
5192 { STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane
}, WINED3D_GL_EXT_NONE
},
5193 { STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane
}, WINED3D_GL_EXT_NONE
},
5194 { STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane
}, WINED3D_GL_EXT_NONE
},
5195 { STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane
}, WINED3D_GL_EXT_NONE
},
5196 { STATE_CLIPPLANE(8), { STATE_CLIPPLANE(8), clipplane
}, WINED3D_GL_EXT_NONE
},
5197 { STATE_CLIPPLANE(9), { STATE_CLIPPLANE(9), clipplane
}, WINED3D_GL_EXT_NONE
},
5198 { STATE_CLIPPLANE(10), { STATE_CLIPPLANE(10), clipplane
}, WINED3D_GL_EXT_NONE
},
5199 { STATE_CLIPPLANE(11), { STATE_CLIPPLANE(11), clipplane
}, WINED3D_GL_EXT_NONE
},
5200 { STATE_CLIPPLANE(12), { STATE_CLIPPLANE(12), clipplane
}, WINED3D_GL_EXT_NONE
},
5201 { STATE_CLIPPLANE(13), { STATE_CLIPPLANE(13), clipplane
}, WINED3D_GL_EXT_NONE
},
5202 { STATE_CLIPPLANE(14), { STATE_CLIPPLANE(14), clipplane
}, WINED3D_GL_EXT_NONE
},
5203 { STATE_CLIPPLANE(15), { STATE_CLIPPLANE(15), clipplane
}, WINED3D_GL_EXT_NONE
},
5204 { STATE_CLIPPLANE(16), { STATE_CLIPPLANE(16), clipplane
}, WINED3D_GL_EXT_NONE
},
5205 { STATE_CLIPPLANE(17), { STATE_CLIPPLANE(17), clipplane
}, WINED3D_GL_EXT_NONE
},
5206 { STATE_CLIPPLANE(18), { STATE_CLIPPLANE(18), clipplane
}, WINED3D_GL_EXT_NONE
},
5207 { STATE_CLIPPLANE(19), { STATE_CLIPPLANE(19), clipplane
}, WINED3D_GL_EXT_NONE
},
5208 { STATE_CLIPPLANE(20), { STATE_CLIPPLANE(20), clipplane
}, WINED3D_GL_EXT_NONE
},
5209 { STATE_CLIPPLANE(21), { STATE_CLIPPLANE(21), clipplane
}, WINED3D_GL_EXT_NONE
},
5210 { STATE_CLIPPLANE(22), { STATE_CLIPPLANE(22), clipplane
}, WINED3D_GL_EXT_NONE
},
5211 { STATE_CLIPPLANE(23), { STATE_CLIPPLANE(23), clipplane
}, WINED3D_GL_EXT_NONE
},
5212 { STATE_CLIPPLANE(24), { STATE_CLIPPLANE(24), clipplane
}, WINED3D_GL_EXT_NONE
},
5213 { STATE_CLIPPLANE(25), { STATE_CLIPPLANE(25), clipplane
}, WINED3D_GL_EXT_NONE
},
5214 { STATE_CLIPPLANE(26), { STATE_CLIPPLANE(26), clipplane
}, WINED3D_GL_EXT_NONE
},
5215 { STATE_CLIPPLANE(27), { STATE_CLIPPLANE(27), clipplane
}, WINED3D_GL_EXT_NONE
},
5216 { STATE_CLIPPLANE(28), { STATE_CLIPPLANE(28), clipplane
}, WINED3D_GL_EXT_NONE
},
5217 { STATE_CLIPPLANE(29), { STATE_CLIPPLANE(29), clipplane
}, WINED3D_GL_EXT_NONE
},
5218 { STATE_CLIPPLANE(30), { STATE_CLIPPLANE(30), clipplane
}, WINED3D_GL_EXT_NONE
},
5219 { STATE_CLIPPLANE(31), { STATE_CLIPPLANE(31), clipplane
}, WINED3D_GL_EXT_NONE
},
5221 { STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light
}, WINED3D_GL_EXT_NONE
},
5222 { STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light
}, WINED3D_GL_EXT_NONE
},
5223 { STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light
}, WINED3D_GL_EXT_NONE
},
5224 { STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light
}, WINED3D_GL_EXT_NONE
},
5225 { STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light
}, WINED3D_GL_EXT_NONE
},
5226 { STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light
}, WINED3D_GL_EXT_NONE
},
5227 { STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light
}, WINED3D_GL_EXT_NONE
},
5228 { STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light
}, WINED3D_GL_EXT_NONE
},
5230 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_vertexpart
}, WINED3D_GL_EXT_NONE
},
5231 /* Transform states follow */
5232 { STATE_TRANSFORM(WINED3DTS_VIEW
), { STATE_TRANSFORM(WINED3DTS_VIEW
), transform_view
}, WINED3D_GL_EXT_NONE
},
5233 { STATE_TRANSFORM(WINED3DTS_PROJECTION
), { STATE_TRANSFORM(WINED3DTS_PROJECTION
), transform_projection
}, WINED3D_GL_EXT_NONE
},
5234 { STATE_TRANSFORM(WINED3DTS_TEXTURE0
), { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5235 { STATE_TRANSFORM(WINED3DTS_TEXTURE1
), { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5236 { STATE_TRANSFORM(WINED3DTS_TEXTURE2
), { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5237 { STATE_TRANSFORM(WINED3DTS_TEXTURE3
), { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5238 { STATE_TRANSFORM(WINED3DTS_TEXTURE4
), { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5239 { STATE_TRANSFORM(WINED3DTS_TEXTURE5
), { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5240 { STATE_TRANSFORM(WINED3DTS_TEXTURE6
), { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5241 { STATE_TRANSFORM(WINED3DTS_TEXTURE7
), { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5242 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), transform_world
}, WINED3D_GL_EXT_NONE
},
5243 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5244 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5245 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5246 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5247 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5248 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5249 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5250 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5251 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5252 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5253 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5254 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5255 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5256 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5257 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5258 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5259 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5260 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5261 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5262 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5263 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5264 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5265 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5266 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5267 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5268 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5269 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5270 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5271 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5272 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5273 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5274 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5275 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5276 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5277 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5278 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5279 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5280 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5281 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5282 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5283 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5284 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5285 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5286 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5287 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5288 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5289 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5290 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5291 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5292 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5293 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5294 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5295 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5296 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5297 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5298 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5299 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5300 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5301 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5302 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5303 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5304 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5305 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5306 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5307 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5308 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5309 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5310 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5311 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5312 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5313 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5314 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5315 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5316 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5317 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5318 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5319 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5320 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5321 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5322 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5323 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5324 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5325 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5326 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5327 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5328 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5329 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5330 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5331 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5332 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5333 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5334 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5335 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5336 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5337 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5338 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5339 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5340 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5341 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5342 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5343 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5344 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5345 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5346 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5347 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5348 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5349 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5350 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5351 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5352 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5353 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5354 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5355 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5356 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5357 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5358 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5359 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5360 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5361 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5362 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5363 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5364 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5365 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5366 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5367 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5368 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5369 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5370 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5371 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5372 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5373 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5374 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5375 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5376 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5377 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5378 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5379 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5380 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5381 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5382 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5383 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5384 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5385 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5386 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5387 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5388 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5389 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5390 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5391 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5392 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5393 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5394 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5395 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5396 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5397 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5398 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5399 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5400 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5401 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5402 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5403 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5404 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5405 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5406 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5407 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5408 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5409 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5410 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5411 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5412 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5413 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5414 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5415 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5416 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5417 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5418 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5419 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5420 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5421 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5422 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5423 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5424 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5425 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5426 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5427 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5428 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5429 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5430 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5431 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5432 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5433 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5434 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5435 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5436 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5437 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5438 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5439 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5440 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5441 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5442 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5443 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5444 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5445 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5446 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5447 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5448 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5449 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5450 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5451 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5452 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5453 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5454 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5455 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5456 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5457 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5458 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5459 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5460 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5461 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5462 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5463 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5464 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5465 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5466 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5467 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5468 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5469 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5470 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5471 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5472 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5473 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5474 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5475 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5476 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5477 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5478 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5479 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5480 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5481 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5482 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5483 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5484 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5485 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5486 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5487 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5488 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5489 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5490 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5491 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5492 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5493 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5494 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5495 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5496 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5497 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5498 { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5499 { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5500 { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5501 { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5502 { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5503 { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5504 { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5505 { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5506 { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5507 { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5508 { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5509 { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5510 { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5511 { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5512 { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5513 { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5515 { STATE_RENDER(WINED3DRS_FOGENABLE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog_vertexpart
}, WINED3D_GL_EXT_NONE
},
5516 { STATE_RENDER(WINED3DRS_FOGTABLEMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5517 { STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5518 { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), state_rangefog
}, NV_FOG_DISTANCE
},
5519 { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), state_rangefog_w
}, WINED3D_GL_EXT_NONE
},
5520 { STATE_RENDER(WINED3DRS_CLIPPING
), { STATE_RENDER(WINED3DRS_CLIPPING
), state_clipping
}, WINED3D_GL_EXT_NONE
},
5521 { STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
), { STATE_RENDER(WINED3DRS_CLIPPING
), NULL
}, WINED3D_GL_EXT_NONE
},
5522 { STATE_RENDER(WINED3DRS_LIGHTING
), { STATE_RENDER(WINED3DRS_LIGHTING
), state_lighting
}, WINED3D_GL_EXT_NONE
},
5523 { STATE_RENDER(WINED3DRS_AMBIENT
), { STATE_RENDER(WINED3DRS_AMBIENT
), state_ambient
}, WINED3D_GL_EXT_NONE
},
5524 { STATE_RENDER(WINED3DRS_COLORVERTEX
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
}, WINED3D_GL_EXT_NONE
},
5525 { STATE_RENDER(WINED3DRS_LOCALVIEWER
), { STATE_RENDER(WINED3DRS_LOCALVIEWER
), state_localviewer
}, WINED3D_GL_EXT_NONE
},
5526 { STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), { STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), state_normalize
}, WINED3D_GL_EXT_NONE
},
5527 { STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5528 { STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5529 { STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5530 { STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5531 { STATE_RENDER(WINED3DRS_VERTEXBLEND
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), state_vertexblend
}, ARB_VERTEX_BLEND
},
5532 { STATE_RENDER(WINED3DRS_VERTEXBLEND
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), state_vertexblend_w
}, WINED3D_GL_EXT_NONE
},
5533 { STATE_RENDER(WINED3DRS_POINTSIZE
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5534 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_arb
}, ARB_POINT_PARAMETERS
},
5535 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_ext
}, EXT_POINT_PARAMETERS
},
5536 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_w
}, WINED3D_GL_EXT_NONE
},
5537 { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), state_pointsprite
}, ARB_POINT_SPRITE
},
5538 { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), state_pointsprite_w
}, WINED3D_GL_EXT_NONE
},
5539 { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
}, WINED3D_GL_EXT_NONE
},
5540 { STATE_RENDER(WINED3DRS_POINTSCALE_A
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5541 { STATE_RENDER(WINED3DRS_POINTSCALE_B
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5542 { STATE_RENDER(WINED3DRS_POINTSCALE_C
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5543 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, ARB_POINT_PARAMETERS
},
5544 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, EXT_POINT_PARAMETERS
},
5545 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, WINED3D_GL_EXT_NONE
},
5546 { STATE_RENDER(WINED3DRS_TWEENFACTOR
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5547 { STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5549 /* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
5550 * so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
5551 * otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
5553 { STATE_SAMPLER(0), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5554 { STATE_SAMPLER(0), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5555 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5556 { STATE_SAMPLER(1), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5557 { STATE_SAMPLER(1), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5558 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5559 { STATE_SAMPLER(2), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5560 { STATE_SAMPLER(2), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5561 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5562 { STATE_SAMPLER(3), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5563 { STATE_SAMPLER(3), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5564 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5565 { STATE_SAMPLER(4), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5566 { STATE_SAMPLER(4), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5567 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5568 { STATE_SAMPLER(5), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5569 { STATE_SAMPLER(5), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5570 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5571 { STATE_SAMPLER(6), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5572 { STATE_SAMPLER(6), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5573 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5574 { STATE_SAMPLER(7), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5575 { STATE_SAMPLER(7), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5576 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5577 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5580 static const struct StateEntryTemplate ffp_fragmentstate_template
[] = {
5581 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5582 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5583 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5584 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5585 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5586 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5587 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5588 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5589 { STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5590 { STATE_TEXTURESTAGE(0, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5591 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5592 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5593 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5594 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5595 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5596 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5597 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5598 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5599 { STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5600 { STATE_TEXTURESTAGE(1, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5601 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5602 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5603 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5604 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5605 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5606 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5607 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5608 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5609 { STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5610 { STATE_TEXTURESTAGE(2, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5611 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5612 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5613 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5614 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5615 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5616 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5617 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5618 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5619 { STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5620 { STATE_TEXTURESTAGE(3, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5621 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5622 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5623 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5624 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5625 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5626 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5627 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5628 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5629 { STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5630 { STATE_TEXTURESTAGE(4, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5631 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5632 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5633 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5634 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5635 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5636 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5637 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5638 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5639 { STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5640 { STATE_TEXTURESTAGE(5, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5641 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5642 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5643 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5644 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5645 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5646 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5647 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5648 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5649 { STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5650 { STATE_TEXTURESTAGE(6, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5651 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5652 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5653 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5654 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5655 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5656 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5657 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5658 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5659 { STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5660 { STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5661 { STATE_PIXELSHADER
, { STATE_PIXELSHADER
, apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
5662 { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE
), { STATE_PIXELSHADER
, NULL
}, WINED3D_GL_EXT_NONE
},
5663 { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), state_texfactor
}, WINED3D_GL_EXT_NONE
},
5664 { STATE_RENDER(WINED3DRS_FOGCOLOR
), { STATE_RENDER(WINED3DRS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
5665 { STATE_RENDER(WINED3DRS_FOGDENSITY
), { STATE_RENDER(WINED3DRS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
5666 { STATE_RENDER(WINED3DRS_FOGENABLE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
5667 { STATE_RENDER(WINED3DRS_FOGTABLEMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5668 { STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5669 { STATE_RENDER(WINED3DRS_FOGSTART
), { STATE_RENDER(WINED3DRS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
5670 { STATE_RENDER(WINED3DRS_FOGEND
), { STATE_RENDER(WINED3DRS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
5671 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5672 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5673 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5674 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5675 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5676 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5677 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5678 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5679 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5682 /* Context activation is done by the caller. */
5683 static void ffp_enable(BOOL enable
) {}
5685 static void ffp_fragment_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*pCaps
)
5687 pCaps
->PrimitiveMiscCaps
= 0;
5688 pCaps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
|
5689 WINED3DTEXOPCAPS_ADDSIGNED
|
5690 WINED3DTEXOPCAPS_ADDSIGNED2X
|
5691 WINED3DTEXOPCAPS_MODULATE
|
5692 WINED3DTEXOPCAPS_MODULATE2X
|
5693 WINED3DTEXOPCAPS_MODULATE4X
|
5694 WINED3DTEXOPCAPS_SELECTARG1
|
5695 WINED3DTEXOPCAPS_SELECTARG2
|
5696 WINED3DTEXOPCAPS_DISABLE
;
5698 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
]
5699 || gl_info
->supported
[EXT_TEXTURE_ENV_COMBINE
]
5700 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5702 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
5703 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
5704 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
5705 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
5706 WINED3DTEXOPCAPS_LERP
|
5707 WINED3DTEXOPCAPS_SUBTRACT
;
5709 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
]
5710 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5712 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_ADDSMOOTH
|
5713 WINED3DTEXOPCAPS_MULTIPLYADD
|
5714 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
5715 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
5716 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
;
5718 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
5719 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_DOTPRODUCT3
;
5721 pCaps
->MaxTextureBlendStages
= gl_info
->limits
.textures
;
5722 pCaps
->MaxSimultaneousTextures
= gl_info
->limits
.textures
;
5725 static HRESULT
ffp_fragment_alloc(IWineD3DDeviceImpl
*device
) { return WINED3D_OK
; }
5726 static void ffp_fragment_free(IWineD3DDeviceImpl
*device
) {}
5727 static BOOL
ffp_color_fixup_supported(struct color_fixup_desc fixup
)
5731 TRACE("Checking support for fixup:\n");
5732 dump_color_fixup_desc(fixup
);
5735 /* We only support identity conversions. */
5736 if (is_identity_fixup(fixup
))
5742 TRACE("[FAILED]\n");
5746 const struct fragment_pipeline ffp_fragment_pipeline
= {
5748 ffp_fragment_get_caps
,
5751 ffp_color_fixup_supported
,
5752 ffp_fragmentstate_template
,
5753 FALSE
/* we cannot disable projected textures. The vertex pipe has to do it */
5756 static unsigned int num_handlers(const APPLYSTATEFUNC
*funcs
)
5759 for(i
= 0; funcs
[i
]; i
++);
5763 static void multistate_apply_2(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
5765 stateblock
->device
->multistate_funcs
[state
][0](state
, stateblock
, context
);
5766 stateblock
->device
->multistate_funcs
[state
][1](state
, stateblock
, context
);
5769 static void multistate_apply_3(DWORD state
, struct wined3d_stateblock
*stateblock
, struct wined3d_context
*context
)
5771 stateblock
->device
->multistate_funcs
[state
][0](state
, stateblock
, context
);
5772 stateblock
->device
->multistate_funcs
[state
][1](state
, stateblock
, context
);
5773 stateblock
->device
->multistate_funcs
[state
][2](state
, stateblock
, context
);
5776 static void prune_invalid_states(struct StateEntry
*state_table
, const struct wined3d_gl_info
*gl_info
)
5778 unsigned int start
, last
, i
;
5780 start
= STATE_TEXTURESTAGE(gl_info
->limits
.texture_stages
, 0);
5781 last
= STATE_TEXTURESTAGE(MAX_TEXTURES
- 1, WINED3D_HIGHEST_TEXTURE_STATE
);
5782 for (i
= start
; i
<= last
; ++i
)
5784 state_table
[i
].representative
= 0;
5785 state_table
[i
].apply
= state_undefined
;
5788 start
= STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ gl_info
->limits
.texture_stages
);
5789 last
= STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ MAX_TEXTURES
- 1);
5790 for (i
= start
; i
<= last
; ++i
)
5792 state_table
[i
].representative
= 0;
5793 state_table
[i
].apply
= state_undefined
;
5796 start
= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(gl_info
->limits
.blends
));
5797 last
= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255));
5798 for (i
= start
; i
<= last
; ++i
)
5800 state_table
[i
].representative
= 0;
5801 state_table
[i
].apply
= state_undefined
;
5805 static void validate_state_table(struct StateEntry
*state_table
)
5826 static const DWORD simple_states
[] =
5832 STATE_VERTEXSHADERCONSTANT
,
5833 STATE_PIXELSHADERCONSTANT
,
5839 STATE_POINTSPRITECOORDORIGIN
,
5841 unsigned int i
, current
;
5843 for (i
= STATE_RENDER(1), current
= 0; i
<= STATE_RENDER(WINEHIGHEST_RENDER_STATE
); ++i
)
5845 if (!rs_holes
[current
].first
|| i
< STATE_RENDER(rs_holes
[current
].first
))
5847 if (!state_table
[i
].representative
)
5848 ERR("State %s (%#x) should have a representative.\n", debug_d3dstate(i
), i
);
5850 else if (state_table
[i
].representative
)
5851 ERR("State %s (%#x) shouldn't have a representative.\n", debug_d3dstate(i
), i
);
5853 if (i
== STATE_RENDER(rs_holes
[current
].last
)) ++current
;
5856 for (i
= 0; i
< sizeof(simple_states
) / sizeof(*simple_states
); ++i
)
5858 if (!state_table
[simple_states
[i
]].representative
)
5859 ERR("State %s (%#x) should have a representative.\n",
5860 debug_d3dstate(simple_states
[i
]), simple_states
[i
]);
5863 for (i
= 0; i
< STATE_HIGHEST
+ 1; ++i
)
5865 DWORD rep
= state_table
[i
].representative
;
5868 if (state_table
[rep
].representative
!= rep
)
5870 ERR("State %s (%#x) has invalid representative %s (%#x).\n",
5871 debug_d3dstate(i
), i
, debug_d3dstate(rep
), rep
);
5872 state_table
[i
].representative
= 0;
5877 if (state_table
[i
].apply
)
5878 ERR("State %s (%#x) has both a handler and representative.\n", debug_d3dstate(i
), i
);
5880 else if (!state_table
[i
].apply
)
5882 ERR("Self representing state %s (%#x) has no handler.\n", debug_d3dstate(i
), i
);
5888 HRESULT
compile_state_table(struct StateEntry
*StateTable
, APPLYSTATEFUNC
**dev_multistate_funcs
,
5889 const struct wined3d_gl_info
*gl_info
, const struct StateEntryTemplate
*vertex
,
5890 const struct fragment_pipeline
*fragment
, const struct StateEntryTemplate
*misc
)
5892 unsigned int i
, type
, handlers
;
5893 APPLYSTATEFUNC multistate_funcs
[STATE_HIGHEST
+ 1][3];
5894 const struct StateEntryTemplate
*cur
;
5895 BOOL set
[STATE_HIGHEST
+ 1];
5897 memset(multistate_funcs
, 0, sizeof(multistate_funcs
));
5899 for(i
= 0; i
< STATE_HIGHEST
+ 1; i
++) {
5900 StateTable
[i
].representative
= 0;
5901 StateTable
[i
].apply
= state_undefined
;
5904 for(type
= 0; type
< 3; type
++) {
5905 /* This switch decides the order in which the states are applied */
5907 case 0: cur
= misc
; break;
5908 case 1: cur
= fragment
->states
; break;
5909 case 2: cur
= vertex
; break;
5910 default: cur
= NULL
; /* Stupid compiler */
5914 /* GL extension filtering should not prevent multiple handlers being applied from different
5917 memset(set
, 0, sizeof(set
));
5919 for(i
= 0; cur
[i
].state
; i
++) {
5920 APPLYSTATEFUNC
*funcs_array
;
5922 /* Only use the first matching state with the available extension from one template.
5924 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
5925 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
5927 * if GL_XYZ_fancy is supported, ignore the 2nd line
5929 if(set
[cur
[i
].state
]) continue;
5930 /* Skip state lines depending on unsupported extensions */
5931 if (!gl_info
->supported
[cur
[i
].extension
]) continue;
5932 set
[cur
[i
].state
] = TRUE
;
5933 /* In some cases having an extension means that nothing has to be
5934 * done for a state, e.g. if GL_ARB_texture_non_power_of_two is
5935 * supported, the texture coordinate fixup can be ignored. If the
5936 * apply function is used, mark the state set(done above) to prevent
5937 * applying later lines, but do not record anything in the state
5940 if (!cur
[i
].content
.representative
) continue;
5942 handlers
= num_handlers(multistate_funcs
[cur
[i
].state
]);
5943 multistate_funcs
[cur
[i
].state
][handlers
] = cur
[i
].content
.apply
;
5946 StateTable
[cur
[i
].state
].apply
= cur
[i
].content
.apply
;
5949 StateTable
[cur
[i
].state
].apply
= multistate_apply_2
;
5950 dev_multistate_funcs
[cur
[i
].state
] = HeapAlloc(GetProcessHeap(),
5952 sizeof(**dev_multistate_funcs
) * 2);
5953 if (!dev_multistate_funcs
[cur
[i
].state
]) {
5957 dev_multistate_funcs
[cur
[i
].state
][0] = multistate_funcs
[cur
[i
].state
][0];
5958 dev_multistate_funcs
[cur
[i
].state
][1] = multistate_funcs
[cur
[i
].state
][1];
5961 StateTable
[cur
[i
].state
].apply
= multistate_apply_3
;
5962 funcs_array
= HeapReAlloc(GetProcessHeap(),
5964 dev_multistate_funcs
[cur
[i
].state
],
5965 sizeof(**dev_multistate_funcs
) * 3);
5970 dev_multistate_funcs
[cur
[i
].state
] = funcs_array
;
5971 dev_multistate_funcs
[cur
[i
].state
][2] = multistate_funcs
[cur
[i
].state
][2];
5974 ERR("Unexpected amount of state handlers for state %u: %u\n",
5975 cur
[i
].state
, handlers
+ 1);
5978 if(StateTable
[cur
[i
].state
].representative
&&
5979 StateTable
[cur
[i
].state
].representative
!= cur
[i
].content
.representative
) {
5980 FIXME("State %u has different representatives in different pipeline parts\n",
5983 StateTable
[cur
[i
].state
].representative
= cur
[i
].content
.representative
;
5987 prune_invalid_states(StateTable
, gl_info
);
5988 validate_state_table(StateTable
);
5993 for (i
= 0; i
<= STATE_HIGHEST
; ++i
) {
5994 HeapFree(GetProcessHeap(), 0, dev_multistate_funcs
[i
]);
5997 memset(dev_multistate_funcs
, 0, (STATE_HIGHEST
+ 1)*sizeof(*dev_multistate_funcs
));
5999 return E_OUTOFMEMORY
;