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 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
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
);
42 static void state_undefined(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
44 ERR("Undefined state.\n");
47 static void state_nop(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
49 TRACE("%s: nop in current pipe config.\n", debug_d3dstate(state
));
52 static void state_fillmode(DWORD state
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
471 WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
474 static void state_blendfactor(DWORD state
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
= (IWineD3DSurfaceImpl
*)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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
634 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
637 static void state_blendop(DWORD state
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
1584 WARN("token: %#x\n", stateblock
->state
.render_states
[WINED3DRS_DEBUGMONITORTOKEN
]);
1587 static void state_colorwrite(DWORD state
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
= (IWineD3DSurfaceImpl
*)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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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
, IWineD3DStateBlockImpl
*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 IWineD3DBaseTexture
*texture
= (IWineD3DBaseTexture
*)state
->textures
[sampler
];
3647 BOOL srgb
= state
->sampler_states
[sampler
][WINED3DSAMP_SRGBTEXTURE
];
3649 IWineD3DBaseTexture_BindTexture(texture
, srgb
);
3650 basetexture_apply_state_changes(texture
,
3651 state
->texture_states
[sampler
],
3652 state
->sampler_states
[sampler
], gl_info
);
3654 if (gl_info
->supported
[EXT_TEXTURE_LOD_BIAS
])
3656 tmpvalue
.d
= state
->sampler_states
[sampler
][WINED3DSAMP_MIPMAPLODBIAS
];
3657 glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT
,
3658 GL_TEXTURE_LOD_BIAS_EXT
,
3660 checkGLcall("glTexEnvi(GL_TEXTURE_LOD_BIAS_EXT, ...)");
3663 if (!use_ps(state
) && sampler
< state
->lowest_disabled_stage
)
3665 if (state
->render_states
[WINED3DRS_COLORKEYENABLE
] && !sampler
)
3667 /* If color keying is enabled update the alpha test, it depends on the existence
3668 * of a color key in stage 0
3670 state_alpha(WINED3DRS_COLORKEYENABLE
, stateblock
, context
);
3674 /* Trigger shader constant reloading (for NP2 texcoord fixup) */
3675 if (!state
->textures
[sampler
]->baseTexture
.pow2Matrix_identity
)
3677 device
->shader_backend
->shader_load_np2fixup_constants(device
->shader_priv
, gl_info
, state
);
3680 else if (mapped_stage
< gl_info
->limits
.textures
)
3682 if (sampler
< state
->lowest_disabled_stage
)
3684 /* TODO: What should I do with pixel shaders here ??? */
3685 if (state
->render_states
[WINED3DRS_COLORKEYENABLE
] && !sampler
)
3687 /* If color keying is enabled update the alpha test, it depends on the existence
3688 * of a color key in stage 0
3690 state_alpha(WINED3DRS_COLORKEYENABLE
, stateblock
, context
);
3692 } /* Otherwise tex_colorop disables the stage */
3693 glBindTexture(GL_TEXTURE_2D
, device
->dummyTextureName
[sampler
]);
3694 checkGLcall("glBindTexture(GL_TEXTURE_2D, device->dummyTextureName[sampler])");
3698 void apply_pixelshader(DWORD state_id
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3700 const struct wined3d_state
*state
= &stateblock
->state
;
3701 IWineD3DDeviceImpl
*device
= stateblock
->device
;
3702 BOOL use_vshader
= use_vs(state
);
3703 BOOL use_pshader
= use_ps(state
);
3707 if(!context
->last_was_pshader
) {
3708 /* Former draw without a pixel shader, some samplers
3709 * may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
3710 * make sure to enable them
3712 for(i
=0; i
< MAX_FRAGMENT_SAMPLERS
; i
++) {
3713 if(!isStateDirty(context
, STATE_SAMPLER(i
))) {
3714 sampler(STATE_SAMPLER(i
), stateblock
, context
);
3717 context
->last_was_pshader
= TRUE
;
3719 /* Otherwise all samplers were activated by the code above in earlier draws, or by sampler()
3720 * if a different texture was bound. I don't have to do anything.
3724 /* Disabled the pixel shader - color ops weren't applied
3725 * while it was enabled, so re-apply them. */
3726 for (i
= 0; i
< context
->gl_info
->limits
.texture_stages
; ++i
)
3728 if (!isStateDirty(context
, STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
)))
3729 stateblock_apply_state(STATE_TEXTURESTAGE(i
, WINED3DTSS_COLOROP
), stateblock
, context
);
3731 context
->last_was_pshader
= FALSE
;
3734 if(!isStateDirty(context
, device
->StateTable
[STATE_VSHADER
].representative
)) {
3735 device
->shader_backend
->shader_select(context
, use_pshader
, use_vshader
);
3737 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
) && (use_vshader
|| use_pshader
)) {
3738 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
3743 static void shader_bumpenvmat(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3745 DWORD stage
= (state
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3746 IWineD3DPixelShaderImpl
*ps
= stateblock
->state
.pixel_shader
;
3748 if (ps
&& stage
&& (ps
->baseShader
.reg_maps
.bumpmat
& (1 << stage
)))
3750 /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
3753 if(!isStateDirty(context
, STATE_PIXELSHADERCONSTANT
) &&
3754 !isStateDirty(context
, STATE_PIXELSHADER
)) {
3755 shaderconstant(STATE_PIXELSHADERCONSTANT
, stateblock
, context
);
3760 static void transform_world(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3762 /* This function is called by transform_view below if the view matrix was changed too
3764 * Deliberately no check if the vertex declaration is dirty because the vdecl state
3765 * does not always update the world matrix, only on a switch between transformed
3766 * and untransformed draws. It *may* happen that the world matrix is set 2 times during one
3767 * draw, but that should be rather rare and cheaper in total.
3769 glMatrixMode(GL_MODELVIEW
);
3770 checkGLcall("glMatrixMode");
3772 if(context
->last_was_rhw
) {
3774 checkGLcall("glLoadIdentity()");
3776 /* In the general case, the view matrix is the identity matrix */
3777 if (stateblock
->device
->view_ident
)
3779 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
3780 checkGLcall("glLoadMatrixf");
3784 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3785 checkGLcall("glLoadMatrixf");
3786 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(0)].u
.m
[0][0]);
3787 checkGLcall("glMultMatrixf");
3792 static void clipplane(DWORD state_id
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3794 const struct wined3d_state
*state
= &stateblock
->state
;
3795 UINT index
= state_id
- STATE_CLIPPLANE(0);
3797 if (isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
)) || index
>= context
->gl_info
->limits
.clipplanes
)
3802 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
3805 glMatrixMode(GL_MODELVIEW
);
3807 glLoadMatrixf(&state
->transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3811 /* with vertex shaders, clip planes are not transformed in direct3d,
3812 * in OpenGL they are still transformed by the model view.
3813 * Use this to swap the y coordinate if necessary
3815 glMatrixMode(GL_MODELVIEW
);
3818 if (context
->render_offscreen
) glScalef(1.0f
, -1.0f
, 1.0f
);
3821 TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
3822 state
->clip_planes
[index
][0],
3823 state
->clip_planes
[index
][1],
3824 state
->clip_planes
[index
][2],
3825 state
->clip_planes
[index
][3]);
3826 glClipPlane(GL_CLIP_PLANE0
+ index
, state
->clip_planes
[index
]);
3827 checkGLcall("glClipPlane");
3832 static void transform_worldex(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3834 UINT matrix
= state
- STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
3836 TRACE("Setting world matrix %d\n", matrix
);
3838 if (matrix
>= context
->gl_info
->limits
.blends
)
3840 WARN("Unsupported blend matrix set\n");
3842 } else if(isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
))) {
3846 /* GL_MODELVIEW0_ARB: 0x1700
3847 * GL_MODELVIEW1_ARB: 0x850a
3848 * GL_MODELVIEW2_ARB: 0x8722
3849 * GL_MODELVIEW3_ARB: 0x8723
3851 * GL_MODELVIEW31_ARB: 0x873F
3853 if(matrix
== 1) glMat
= GL_MODELVIEW1_ARB
;
3854 else glMat
= GL_MODELVIEW2_ARB
- 2 + matrix
;
3856 glMatrixMode(glMat
);
3857 checkGLcall("glMatrixMode(glMat)");
3859 /* World matrix 0 is multiplied with the view matrix because d3d uses 3 matrices while gl uses only 2. To avoid
3860 * weighting the view matrix incorrectly it has to be multiplied into every gl modelview matrix
3862 if (stateblock
->device
->view_ident
)
3864 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(matrix
)].u
.m
[0][0]);
3865 checkGLcall("glLoadMatrixf");
3869 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3870 checkGLcall("glLoadMatrixf");
3871 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_WORLDMATRIX(matrix
)].u
.m
[0][0]);
3872 checkGLcall("glMultMatrixf");
3876 static void state_vertexblend_w(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3878 WINED3DVERTEXBLENDFLAGS f
= stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
];
3879 static unsigned int once
;
3881 if (f
== WINED3DVBF_DISABLE
) return;
3883 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", f
);
3884 else WARN("Vertex blend flags %#x not supported.\n", f
);
3887 static void state_vertexblend(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3889 WINED3DVERTEXBLENDFLAGS val
= stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
];
3890 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3891 static unsigned int once
;
3894 case WINED3DVBF_1WEIGHTS
:
3895 case WINED3DVBF_2WEIGHTS
:
3896 case WINED3DVBF_3WEIGHTS
:
3897 glEnable(GL_VERTEX_BLEND_ARB
);
3898 checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
3900 /* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
3901 * creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
3903 GL_EXTCALL(glVertexBlendARB(stateblock
->state
.render_states
[WINED3DRS_VERTEXBLEND
] + 1));
3905 if (!stateblock
->device
->vertexBlendUsed
)
3908 for (i
= 1; i
< gl_info
->limits
.blends
; ++i
)
3910 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i
))))
3912 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i
)), stateblock
, context
);
3915 stateblock
->device
->vertexBlendUsed
= TRUE
;
3919 case WINED3DVBF_TWEENING
:
3920 case WINED3DVBF_0WEIGHTS
: /* Indexed vertex blending, not supported. */
3921 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", val
);
3922 else WARN("Vertex blend flags %#x not supported.\n", val
);
3924 case WINED3DVBF_DISABLE
:
3925 glDisable(GL_VERTEX_BLEND_ARB
);
3926 checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
3931 static void transform_view(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3933 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3934 const struct wined3d_light_info
*light
= NULL
;
3937 /* If we are changing the View matrix, reset the light and clipping planes to the new view
3938 * NOTE: We have to reset the positions even if the light/plane is not currently
3939 * enabled, since the call to enable it will not reset the position.
3940 * NOTE2: Apparently texture transforms do NOT need reapplying
3943 glMatrixMode(GL_MODELVIEW
);
3944 checkGLcall("glMatrixMode(GL_MODELVIEW)");
3945 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
3946 checkGLcall("glLoadMatrixf(...)");
3948 /* Reset lights. TODO: Call light apply func */
3949 for (k
= 0; k
< stateblock
->device
->maxConcurrentLights
; ++k
)
3951 light
= stateblock
->state
.lights
[k
];
3952 if(!light
) continue;
3953 glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_POSITION
, light
->lightPosn
);
3954 checkGLcall("glLightfv posn");
3955 glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_SPOT_DIRECTION
, light
->lightDirn
);
3956 checkGLcall("glLightfv dirn");
3959 /* Reset Clipping Planes */
3960 for (k
= 0; k
< gl_info
->limits
.clipplanes
; ++k
)
3962 if(!isStateDirty(context
, STATE_CLIPPLANE(k
))) {
3963 clipplane(STATE_CLIPPLANE(k
), stateblock
, context
);
3967 if(context
->last_was_rhw
) {
3969 checkGLcall("glLoadIdentity()");
3970 /* No need to update the world matrix, the identity is fine */
3974 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
3975 * No need to do it here if the state is scheduled for update.
3977 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
3978 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
3981 /* Avoid looping over a number of matrices if the app never used the functionality */
3982 if (stateblock
->device
->vertexBlendUsed
)
3984 for (k
= 1; k
< gl_info
->limits
.blends
; ++k
)
3986 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k
)))) {
3987 transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k
)), stateblock
, context
);
3993 static void transform_projection(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
3995 glMatrixMode(GL_PROJECTION
);
3996 checkGLcall("glMatrixMode(GL_PROJECTION)");
3998 checkGLcall("glLoadIdentity");
4000 if (context
->last_was_rhw
)
4002 double x
= stateblock
->state
.viewport
.X
;
4003 double y
= stateblock
->state
.viewport
.Y
;
4004 double w
= stateblock
->state
.viewport
.Width
;
4005 double h
= stateblock
->state
.viewport
.Height
;
4007 TRACE("Calling glOrtho with x %.8e, y %.8e, w %.8e, h %.8e.\n", x
, y
, w
, h
);
4008 if (context
->render_offscreen
)
4009 glOrtho(x
, x
+ w
, -y
, -y
- h
, 0.0, -1.0);
4011 glOrtho(x
, x
+ w
, y
+ h
, y
, 0.0, -1.0);
4012 checkGLcall("glOrtho");
4014 /* D3D texture coordinates are flipped compared to OpenGL ones, so
4015 * render everything upside down when rendering offscreen. */
4016 if (context
->render_offscreen
)
4018 glScalef(1.0f
, -1.0f
, 1.0f
);
4019 checkGLcall("glScalef");
4022 /* Window Coord 0 is the middle of the first pixel, so translate by 1/2 pixels */
4023 glTranslatef(63.0f
/ 128.0f
, 63.0f
/ 128.0f
, 0.0f
);
4024 checkGLcall("glTranslatef(63.0f / 128.0f, 63.0f / 128.0f, 0.0f)");
4028 /* The rule is that the window coordinate 0 does not correspond to the
4029 beginning of the first pixel, but the center of the first pixel.
4030 As a consequence if you want to correctly draw one line exactly from
4031 the left to the right end of the viewport (with all matrices set to
4032 be identity), the x coords of both ends of the line would be not
4033 -1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
4036 1.0 / Width is used because the coord range goes from -1.0 to 1.0, then we
4037 divide by the Width/Height, so we need the half range(1.0) to translate by
4040 The other fun is that d3d's output z range after the transformation is [0;1],
4041 but opengl's is [-1;1]. Since the z buffer is in range [0;1] for both, gl
4042 scales [-1;1] to [0;1]. This would mean that we end up in [0.5;1] and loose a lot
4043 of Z buffer precision and the clear values do not match in the z test. Thus scale
4044 [0;1] to [-1;1], so when gl undoes that we utilize the full z range
4048 * Careful with the order of operations here, we're essentially working backwards:
4050 * y = (y - 1/h) * flip;
4054 * glTranslatef(0.0, 0.0, -1.0);
4055 * glScalef(1.0, 1.0, 2.0);
4057 * glScalef(1.0, flip, 1.0);
4058 * glTranslatef(1/w, -1/h, 0.0);
4060 * This is equivalent to:
4061 * glTranslatef(1/w, -flip/h, -1.0)
4062 * glScalef(1.0, flip, 2.0);
4065 /* Translate by slightly less than a half pixel to force a top-left
4066 * filling convention. We want the difference to be large enough that
4067 * it doesn't get lost due to rounding inside the driver, but small
4068 * enough to prevent it from interfering with any anti-aliasing. */
4069 GLfloat xoffset
= (63.0f
/ 64.0f
) / stateblock
->state
.viewport
.Width
;
4070 GLfloat yoffset
= -(63.0f
/ 64.0f
) / stateblock
->state
.viewport
.Height
;
4072 if (context
->render_offscreen
)
4074 /* D3D texture coordinates are flipped compared to OpenGL ones, so
4075 * render everything upside down when rendering offscreen. */
4076 glTranslatef(xoffset
, -yoffset
, -1.0f
);
4077 checkGLcall("glTranslatef(xoffset, -yoffset, -1.0f)");
4078 glScalef(1.0f
, -1.0f
, 2.0f
);
4080 glTranslatef(xoffset
, yoffset
, -1.0f
);
4081 checkGLcall("glTranslatef(xoffset, yoffset, -1.0f)");
4082 glScalef(1.0f
, 1.0f
, 2.0f
);
4084 checkGLcall("glScalef");
4086 glMultMatrixf(&stateblock
->state
.transforms
[WINED3DTS_PROJECTION
].u
.m
[0][0]);
4087 checkGLcall("glLoadMatrixf");
4091 /* This should match any arrays loaded in loadVertexData.
4092 * TODO: Only load / unload arrays if we have to.
4094 static inline void unloadVertexData(const struct wined3d_gl_info
*gl_info
)
4096 glDisableClientState(GL_VERTEX_ARRAY
);
4097 glDisableClientState(GL_NORMAL_ARRAY
);
4098 glDisableClientState(GL_COLOR_ARRAY
);
4099 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4101 glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4103 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4105 glDisableClientState(GL_WEIGHT_ARRAY_ARB
);
4107 unloadTexCoords(gl_info
);
4110 static inline void unload_numbered_array(struct wined3d_context
*context
, int i
)
4112 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4114 GL_EXTCALL(glDisableVertexAttribArrayARB(i
));
4115 checkGLcall("glDisableVertexAttribArrayARB(reg)");
4117 context
->numbered_array_mask
&= ~(1 << i
);
4120 /* This should match any arrays loaded in loadNumberedArrays
4121 * TODO: Only load / unload arrays if we have to.
4123 static inline void unloadNumberedArrays(struct wined3d_context
*context
)
4125 /* disable any attribs (this is the same for both GLSL and ARB modes) */
4126 GLint maxAttribs
= 16;
4129 /* Leave all the attribs disabled */
4130 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB
, &maxAttribs
);
4131 /* MESA does not support it right not */
4132 if (glGetError() != GL_NO_ERROR
)
4134 for (i
= 0; i
< maxAttribs
; ++i
) {
4135 unload_numbered_array(context
, i
);
4139 static inline void loadNumberedArrays(IWineD3DStateBlockImpl
*stateblock
,
4140 const struct wined3d_stream_info
*stream_info
, struct wined3d_context
*context
)
4142 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4143 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4145 struct wined3d_buffer
*vb
;
4146 DWORD_PTR shift_index
;
4148 /* Default to no instancing */
4149 stateblock
->device
->instancedDraw
= FALSE
;
4151 for (i
= 0; i
< MAX_ATTRIBS
; i
++)
4153 const struct wined3d_stream_state
*stream
;
4155 if (!(stream_info
->use_map
& (1 << i
)))
4157 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4161 stream
= &stateblock
->state
.streams
[stream_info
->elements
[i
].stream_idx
];
4163 /* Do not load instance data. It will be specified using glTexCoord by drawprim */
4164 if (stream
->flags
& WINED3DSTREAMSOURCE_INSTANCEDATA
)
4166 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4167 stateblock
->device
->instancedDraw
= TRUE
;
4171 TRACE_(d3d_shader
)("Loading array %u [VBO=%u]\n", i
, stream_info
->elements
[i
].buffer_object
);
4173 if (stream_info
->elements
[i
].stride
)
4175 if (curVBO
!= stream_info
->elements
[i
].buffer_object
)
4177 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, stream_info
->elements
[i
].buffer_object
));
4178 checkGLcall("glBindBufferARB");
4179 curVBO
= stream_info
->elements
[i
].buffer_object
;
4181 /* Use the VBO to find out if a vertex buffer exists, not the vb
4182 * pointer. vb can point to a user pointer data blob. In that case
4183 * curVBO will be 0. If there is a vertex buffer but no vbo we
4184 * won't be load converted attributes anyway. */
4185 vb
= stream
->buffer
;
4186 if (curVBO
&& vb
->conversion_shift
)
4188 TRACE("Loading attribute from shifted buffer\n");
4189 TRACE("Attrib %d has original stride %d, new stride %d\n",
4190 i
, stream_info
->elements
[i
].stride
, vb
->conversion_stride
);
4191 TRACE("Original offset %p, additional offset 0x%08x\n",
4192 stream_info
->elements
[i
].data
, vb
->conversion_shift
[(DWORD_PTR
)stream_info
->elements
[i
].data
]);
4193 TRACE("Opengl type %#x\n", stream_info
->elements
[i
].format
->gl_vtx_type
);
4194 shift_index
= ((DWORD_PTR
)stream_info
->elements
[i
].data
+ stream
->offset
);
4195 shift_index
= shift_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 vb
->conversion_stride
, stream_info
->elements
[i
].data
+ vb
->conversion_shift
[shift_index
]
4200 + stateblock
->state
.load_base_vertex_index
* stream_info
->elements
[i
].stride
4204 GL_EXTCALL(glVertexAttribPointerARB(i
, stream_info
->elements
[i
].format
->gl_vtx_format
,
4205 stream_info
->elements
[i
].format
->gl_vtx_type
,
4206 stream_info
->elements
[i
].format
->gl_normalized
,
4207 stream_info
->elements
[i
].stride
, stream_info
->elements
[i
].data
4208 + stateblock
->state
.load_base_vertex_index
* stream_info
->elements
[i
].stride
4212 if (!(context
->numbered_array_mask
& (1 << i
)))
4214 GL_EXTCALL(glEnableVertexAttribArrayARB(i
));
4215 context
->numbered_array_mask
|= (1 << i
);
4220 /* Stride = 0 means always the same values.
4221 * glVertexAttribPointerARB doesn't do that. Instead disable the
4222 * pointer and set up the attribute statically. But we have to
4223 * figure out the system memory address. */
4224 const BYTE
*ptr
= stream_info
->elements
[i
].data
+ stream
->offset
;
4225 if (stream_info
->elements
[i
].buffer_object
)
4227 vb
= stream
->buffer
;
4228 ptr
+= (ULONG_PTR
)buffer_get_sysmem(vb
, gl_info
);
4231 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4233 switch (stream_info
->elements
[i
].format
->id
)
4235 case WINED3DFMT_R32_FLOAT
:
4236 GL_EXTCALL(glVertexAttrib1fvARB(i
, (const GLfloat
*)ptr
));
4238 case WINED3DFMT_R32G32_FLOAT
:
4239 GL_EXTCALL(glVertexAttrib2fvARB(i
, (const GLfloat
*)ptr
));
4241 case WINED3DFMT_R32G32B32_FLOAT
:
4242 GL_EXTCALL(glVertexAttrib3fvARB(i
, (const GLfloat
*)ptr
));
4244 case WINED3DFMT_R32G32B32A32_FLOAT
:
4245 GL_EXTCALL(glVertexAttrib4fvARB(i
, (const GLfloat
*)ptr
));
4248 case WINED3DFMT_R8G8B8A8_UINT
:
4249 GL_EXTCALL(glVertexAttrib4NubvARB(i
, ptr
));
4251 case WINED3DFMT_B8G8R8A8_UNORM
:
4252 if (gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
])
4254 const DWORD
*src
= (const DWORD
*)ptr
;
4255 DWORD c
= *src
& 0xff00ff00;
4256 c
|= (*src
& 0xff0000) >> 16;
4257 c
|= (*src
& 0xff) << 16;
4258 GL_EXTCALL(glVertexAttrib4NubvARB(i
, (GLubyte
*)&c
));
4261 /* else fallthrough */
4262 case WINED3DFMT_R8G8B8A8_UNORM
:
4263 GL_EXTCALL(glVertexAttrib4NubvARB(i
, ptr
));
4266 case WINED3DFMT_R16G16_SINT
:
4267 GL_EXTCALL(glVertexAttrib4svARB(i
, (const GLshort
*)ptr
));
4269 case WINED3DFMT_R16G16B16A16_SINT
:
4270 GL_EXTCALL(glVertexAttrib4svARB(i
, (const GLshort
*)ptr
));
4273 case WINED3DFMT_R16G16_SNORM
:
4275 const GLshort s
[4] = {((const GLshort
*)ptr
)[0], ((const GLshort
*)ptr
)[1], 0, 1};
4276 GL_EXTCALL(glVertexAttrib4NsvARB(i
, s
));
4279 case WINED3DFMT_R16G16_UNORM
:
4281 const GLushort s
[4] = {((const GLushort
*)ptr
)[0], ((const GLushort
*)ptr
)[1], 0, 1};
4282 GL_EXTCALL(glVertexAttrib4NusvARB(i
, s
));
4285 case WINED3DFMT_R16G16B16A16_SNORM
:
4286 GL_EXTCALL(glVertexAttrib4NsvARB(i
, (const GLshort
*)ptr
));
4288 case WINED3DFMT_R16G16B16A16_UNORM
:
4289 GL_EXTCALL(glVertexAttrib4NusvARB(i
, (const GLushort
*)ptr
));
4292 case WINED3DFMT_R10G10B10A2_UINT
:
4293 FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
4294 /*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
4296 case WINED3DFMT_R10G10B10A2_SNORM
:
4297 FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
4298 /*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
4301 case WINED3DFMT_R16G16_FLOAT
:
4302 /* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
4303 * byte float according to the IEEE standard
4305 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
4307 case WINED3DFMT_R16G16B16A16_FLOAT
:
4308 FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
4312 ERR("Unexpected declaration in stride 0 attributes\n");
4318 checkGLcall("Loading numbered arrays");
4321 /* Used from 2 different functions, and too big to justify making it inlined */
4322 static void loadVertexData(const struct wined3d_context
*context
, IWineD3DStateBlockImpl
*stateblock
,
4323 const struct wined3d_stream_info
*si
)
4325 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4326 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4327 const struct wined3d_stream_info_element
*e
;
4328 const struct wined3d_stream_state
*stream
;
4330 TRACE("Using fast vertex array code\n");
4332 /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
4333 stateblock
->device
->instancedDraw
= FALSE
;
4335 /* Blend Data ---------------------------------------------- */
4336 if ((si
->use_map
& (1 << WINED3D_FFP_BLENDWEIGHT
))
4337 || si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4339 e
= &si
->elements
[WINED3D_FFP_BLENDWEIGHT
];
4340 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4342 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4344 TRACE("Blend %u %p %u\n", e
->format
->component_count
,
4345 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
, e
->stride
+ stream
->offset
);
4347 glEnableClientState(GL_WEIGHT_ARRAY_ARB
);
4348 checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
4350 GL_EXTCALL(glVertexBlendARB(e
->format
->component_count
+ 1));
4352 if (curVBO
!= e
->buffer_object
)
4354 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4355 checkGLcall("glBindBufferARB");
4356 curVBO
= e
->buffer_object
;
4359 TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
4360 e
->format
->gl_vtx_format
,
4361 e
->format
->gl_vtx_type
,
4363 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4364 GL_EXTCALL(glWeightPointerARB(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4365 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4367 checkGLcall("glWeightPointerARB");
4369 if (si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4374 FIXME("blendMatrixIndices support\n");
4379 /* TODO: support blends in drawStridedSlow
4380 * No need to write a FIXME here, this is done after the general vertex decl decoding
4382 WARN("unsupported blending in openGl\n");
4387 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4389 static const GLbyte one
= 1;
4390 GL_EXTCALL(glWeightbvARB(1, &one
));
4391 checkGLcall("glWeightivARB(gl_info->max_blends, weights)");
4395 /* Point Size ----------------------------------------------*/
4396 if (si
->use_map
& (1 << WINED3D_FFP_PSIZE
))
4398 /* no such functionality in the fixed function GL pipeline */
4399 TRACE("Cannot change ptSize here in openGl\n");
4400 /* TODO: Implement this function in using shaders if they are available */
4403 /* Vertex Pointers -----------------------------------------*/
4404 if (si
->use_map
& (1 << WINED3D_FFP_POSITION
))
4406 e
= &si
->elements
[WINED3D_FFP_POSITION
];
4407 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4409 if (curVBO
!= e
->buffer_object
)
4411 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4412 checkGLcall("glBindBufferARB");
4413 curVBO
= e
->buffer_object
;
4416 /* min(WINED3D_ATR_FORMAT(position),3) to Disable RHW mode as 'w' coord
4417 handling for rhw mode should not impact screen position whereas in GL it does.
4418 This may result in very slightly distorted textures in rhw mode.
4419 There's always the other option of fixing the view matrix to
4420 prevent w from having any effect.
4422 This only applies to user pointer sources, in VBOs the vertices are fixed up
4424 if (!e
->buffer_object
)
4426 TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e
->format
->gl_vtx_type
, e
->stride
,
4427 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4428 glVertexPointer(3 /* min(e->format->gl_vtx_format, 3) */, e
->format
->gl_vtx_type
, e
->stride
,
4429 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4433 TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
4434 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4435 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4436 glVertexPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4437 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4439 checkGLcall("glVertexPointer(...)");
4440 glEnableClientState(GL_VERTEX_ARRAY
);
4441 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
4444 /* Normals -------------------------------------------------*/
4445 if (si
->use_map
& (1 << WINED3D_FFP_NORMAL
))
4447 e
= &si
->elements
[WINED3D_FFP_NORMAL
];
4448 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4450 if (curVBO
!= e
->buffer_object
)
4452 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4453 checkGLcall("glBindBufferARB");
4454 curVBO
= e
->buffer_object
;
4457 TRACE("glNormalPointer(%#x, %#x, %p);\n", e
->format
->gl_vtx_type
, e
->stride
,
4458 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4459 glNormalPointer(e
->format
->gl_vtx_type
, e
->stride
,
4460 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4461 checkGLcall("glNormalPointer(...)");
4462 glEnableClientState(GL_NORMAL_ARRAY
);
4463 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
4466 glNormal3f(0, 0, 0);
4467 checkGLcall("glNormal3f(0, 0, 0)");
4470 /* Diffuse Colour --------------------------------------------*/
4471 /* WARNING: Data here MUST be in RGBA format, so cannot */
4472 /* go directly into fast mode from app pgm, because */
4473 /* directx requires data in BGRA format. */
4474 /* currently fixupVertices swizzles the format, but this isn't*/
4475 /* very practical when using VBOs */
4476 /* NOTE: Unless we write a vertex shader to swizzle the colour*/
4477 /* , or the user doesn't care and wants the speed advantage */
4479 if (si
->use_map
& (1 << WINED3D_FFP_DIFFUSE
))
4481 e
= &si
->elements
[WINED3D_FFP_DIFFUSE
];
4482 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4484 if (curVBO
!= e
->buffer_object
)
4486 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4487 checkGLcall("glBindBufferARB");
4488 curVBO
= e
->buffer_object
;
4491 TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
4492 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4493 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4494 glColorPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4495 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4496 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
4497 glEnableClientState(GL_COLOR_ARRAY
);
4498 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
4501 glColor4f(1.0f
, 1.0f
, 1.0f
, 1.0f
);
4502 checkGLcall("glColor4f(1, 1, 1, 1)");
4505 /* Specular Colour ------------------------------------------*/
4506 if (si
->use_map
& (1 << WINED3D_FFP_SPECULAR
))
4508 TRACE("setting specular colour\n");
4510 e
= &si
->elements
[WINED3D_FFP_SPECULAR
];
4511 stream
= &stateblock
->state
.streams
[e
->stream_idx
];
4513 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4515 GLenum type
= e
->format
->gl_vtx_type
;
4516 GLint format
= e
->format
->gl_vtx_format
;
4518 if (curVBO
!= e
->buffer_object
)
4520 GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB
, e
->buffer_object
));
4521 checkGLcall("glBindBufferARB");
4522 curVBO
= e
->buffer_object
;
4525 if (format
!= 4 || (gl_info
->quirks
& WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA
))
4527 /* Usually specular colors only allow 3 components, since they have no alpha. In D3D, the specular alpha
4528 * contains the fog coordinate, which is passed to GL with GL_EXT_fog_coord. However, the fixed function
4529 * vertex pipeline can pass the specular alpha through, and pixel shaders can read it. So it GL accepts
4530 * 4 component secondary colors use it
4532 TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format
, type
, e
->stride
,
4533 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4534 GL_EXTCALL(glSecondaryColorPointerEXT(format
, type
, e
->stride
,
4535 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4536 checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
4542 case GL_UNSIGNED_BYTE
:
4543 TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e
->stride
,
4544 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4545 GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE
, e
->stride
,
4546 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4547 checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
4551 FIXME("Add 4 component specular color pointers for type %x\n", type
);
4552 /* Make sure that the right color component is dropped */
4553 TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type
, e
->stride
,
4554 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
);
4555 GL_EXTCALL(glSecondaryColorPointerEXT(3, type
, e
->stride
,
4556 e
->data
+ stateblock
->state
.load_base_vertex_index
* e
->stride
+ stream
->offset
));
4557 checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
4560 glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4561 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
4565 WARN("Specular colour is not supported in this GL implementation.\n");
4570 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4572 GL_EXTCALL(glSecondaryColor3fEXT
)(0, 0, 0);
4573 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
4577 WARN("Specular colour is not supported in this GL implementation.\n");
4581 /* Texture coords -------------------------------------------*/
4582 loadTexCoords(gl_info
, stateblock
, si
, &curVBO
);
4585 static void streamsrc(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4587 IWineD3DDeviceImpl
*device
= stateblock
->device
;
4588 BOOL load_numbered
= use_vs(&stateblock
->state
) && !device
->useDrawStridedSlow
;
4589 BOOL load_named
= !use_vs(&stateblock
->state
) && !device
->useDrawStridedSlow
;
4591 if (context
->numberedArraysLoaded
&& !load_numbered
)
4593 unloadNumberedArrays(context
);
4594 context
->numberedArraysLoaded
= FALSE
;
4595 context
->numbered_array_mask
= 0;
4597 else if (context
->namedArraysLoaded
)
4599 unloadVertexData(context
->gl_info
);
4600 context
->namedArraysLoaded
= FALSE
;
4605 TRACE("Loading numbered arrays\n");
4606 loadNumberedArrays(stateblock
, &device
->strided_streams
, context
);
4607 context
->numberedArraysLoaded
= TRUE
;
4609 else if (load_named
)
4611 TRACE("Loading vertex data\n");
4612 loadVertexData(context
, stateblock
, &device
->strided_streams
);
4613 context
->namedArraysLoaded
= TRUE
;
4617 static void vertexdeclaration(DWORD state_id
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4619 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4620 const struct wined3d_state
*state
= &stateblock
->state
;
4621 BOOL useVertexShaderFunction
= use_vs(state
);
4622 BOOL usePixelShaderFunction
= use_ps(state
);
4623 BOOL updateFog
= FALSE
;
4624 IWineD3DDeviceImpl
*device
= stateblock
->device
;
4626 BOOL wasrhw
= context
->last_was_rhw
;
4629 transformed
= device
->strided_streams
.position_transformed
;
4630 if(transformed
!= context
->last_was_rhw
&& !useVertexShaderFunction
) {
4634 /* Reapply lighting if it is not scheduled for reapplication already */
4635 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_LIGHTING
))) {
4636 state_lighting(STATE_RENDER(WINED3DRS_LIGHTING
), stateblock
, context
);
4640 context
->last_was_rhw
= TRUE
;
4643 /* Untransformed, so relies on the view and projection matrices */
4644 context
->last_was_rhw
= FALSE
;
4645 /* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
4646 device
->untransformed
= TRUE
;
4649 /* Don't have to apply the matrices when vertex shaders are used. When vshaders are turned
4650 * off this function will be called again anyway to make sure they're properly set
4652 if(!useVertexShaderFunction
) {
4653 /* TODO: Move this mainly to the viewport state and only apply when the vp has changed
4654 * or transformed / untransformed was switched
4656 if(wasrhw
!= context
->last_was_rhw
&&
4657 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
)) &&
4658 !isStateDirty(context
, STATE_VIEWPORT
)) {
4659 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4661 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
4664 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
4665 * this check will fail and the matrix not applied again. This is OK because a simple
4666 * world matrix change reapplies the matrix - These checks here are only to satisfy the
4667 * needs of the vertex declaration.
4669 * World and view matrix go into the same gl matrix, so only apply them when neither is
4672 if(transformed
!= wasrhw
&&
4673 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
4674 !isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_VIEW
))) {
4675 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
4678 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_COLORVERTEX
))) {
4679 state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX
), stateblock
, context
);
4682 if(context
->last_was_vshader
) {
4684 if(!device
->vs_clipping
&& !isStateDirty(context
, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
))) {
4685 state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
), stateblock
, context
);
4687 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4689 clipplane(STATE_CLIPPLANE(i
), stateblock
, context
);
4692 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_NORMALIZENORMALS
))) {
4693 state_normalize(STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), stateblock
, context
);
4696 if(!context
->last_was_vshader
) {
4697 static BOOL warned
= FALSE
;
4698 if(!device
->vs_clipping
) {
4699 /* Disable all clip planes to get defined results on all drivers. See comment in the
4700 * state_clipping state handler
4702 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4704 glDisable(GL_CLIP_PLANE0
+ i
);
4705 checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
4708 if (!warned
&& stateblock
->state
.render_states
[WINED3DRS_CLIPPLANEENABLE
])
4710 FIXME("Clipping not supported with vertex shaders\n");
4715 /* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
4716 * shaders themselves do not need it, but the matrices are not reapplied automatically when
4717 * switching back from vertex shaders to fixed function processing. So make sure we leave the
4718 * fixed function vertex processing states back in a sane state before switching to shaders
4720 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
))) {
4721 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4723 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
4724 transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock
, context
);
4729 /* Vertex shader clipping ignores the view matrix. Update all clipplanes
4730 * (Note: ARB shaders can read the clip planes for clipping emulation even if
4731 * device->vs_clipping is false.
4733 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4735 clipplane(STATE_CLIPPLANE(i
), stateblock
, context
);
4740 /* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
4743 if (!isStateDirty(context
, STATE_PIXELSHADER
)) {
4744 device
->shader_backend
->shader_select(context
, usePixelShaderFunction
, useVertexShaderFunction
);
4746 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
) && (useVertexShaderFunction
|| usePixelShaderFunction
)) {
4747 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
4751 context
->last_was_vshader
= useVertexShaderFunction
;
4753 if (updateFog
) stateblock_apply_state(STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), stateblock
, context
);
4755 if(!useVertexShaderFunction
) {
4757 for(i
= 0; i
< MAX_TEXTURES
; i
++) {
4758 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ i
))) {
4759 transform_texture(STATE_TEXTURESTAGE(i
, WINED3DTSS_TEXTURETRANSFORMFLAGS
), stateblock
, context
);
4765 static void viewport_miscpart(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4767 IWineD3DSurfaceImpl
*target
= stateblock
->device
->render_targets
[0];
4769 WINED3DVIEWPORT vp
= stateblock
->state
.viewport
;
4771 if(vp
.Width
> target
->currentDesc
.Width
) vp
.Width
= target
->currentDesc
.Width
;
4772 if(vp
.Height
> target
->currentDesc
.Height
) vp
.Height
= target
->currentDesc
.Height
;
4774 glDepthRange(vp
.MinZ
, vp
.MaxZ
);
4775 checkGLcall("glDepthRange");
4776 /* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
4778 if (context
->render_offscreen
)
4780 glViewport(vp
.X
, vp
.Y
, vp
.Width
, vp
.Height
);
4782 target
->get_drawable_size(context
, &width
, &height
);
4785 (height
- (vp
.Y
+ vp
.Height
)),
4786 vp
.Width
, vp
.Height
);
4789 checkGLcall("glViewport");
4792 static void viewport_vertexpart(DWORD state_id
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4794 if(!isStateDirty(context
, STATE_TRANSFORM(WINED3DTS_PROJECTION
))) {
4795 transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION
), stateblock
, context
);
4797 if(!isStateDirty(context
, STATE_RENDER(WINED3DRS_POINTSCALEENABLE
))) {
4798 state_pscale(STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), stateblock
, context
);
4800 /* Update the position fixup. */
4801 if (!isStateDirty(context
, STATE_VERTEXSHADERCONSTANT
))
4802 shaderconstant(STATE_VERTEXSHADERCONSTANT
, stateblock
, context
);
4805 static void light(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4807 UINT Index
= state
- STATE_ACTIVELIGHT(0);
4808 const struct wined3d_light_info
*lightInfo
= stateblock
->state
.lights
[Index
];
4811 glDisable(GL_LIGHT0
+ Index
);
4812 checkGLcall("glDisable(GL_LIGHT0 + Index)");
4815 float colRGBA
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
4817 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
4818 glMatrixMode(GL_MODELVIEW
);
4820 glLoadMatrixf(&stateblock
->state
.transforms
[WINED3DTS_VIEW
].u
.m
[0][0]);
4823 colRGBA
[0] = lightInfo
->OriginalParms
.Diffuse
.r
;
4824 colRGBA
[1] = lightInfo
->OriginalParms
.Diffuse
.g
;
4825 colRGBA
[2] = lightInfo
->OriginalParms
.Diffuse
.b
;
4826 colRGBA
[3] = lightInfo
->OriginalParms
.Diffuse
.a
;
4827 glLightfv(GL_LIGHT0
+ Index
, GL_DIFFUSE
, colRGBA
);
4828 checkGLcall("glLightfv");
4831 colRGBA
[0] = lightInfo
->OriginalParms
.Specular
.r
;
4832 colRGBA
[1] = lightInfo
->OriginalParms
.Specular
.g
;
4833 colRGBA
[2] = lightInfo
->OriginalParms
.Specular
.b
;
4834 colRGBA
[3] = lightInfo
->OriginalParms
.Specular
.a
;
4835 glLightfv(GL_LIGHT0
+ Index
, GL_SPECULAR
, colRGBA
);
4836 checkGLcall("glLightfv");
4839 colRGBA
[0] = lightInfo
->OriginalParms
.Ambient
.r
;
4840 colRGBA
[1] = lightInfo
->OriginalParms
.Ambient
.g
;
4841 colRGBA
[2] = lightInfo
->OriginalParms
.Ambient
.b
;
4842 colRGBA
[3] = lightInfo
->OriginalParms
.Ambient
.a
;
4843 glLightfv(GL_LIGHT0
+ Index
, GL_AMBIENT
, colRGBA
);
4844 checkGLcall("glLightfv");
4846 if ((lightInfo
->OriginalParms
.Range
*lightInfo
->OriginalParms
.Range
) >= FLT_MIN
) {
4847 quad_att
= 1.4f
/(lightInfo
->OriginalParms
.Range
*lightInfo
->OriginalParms
.Range
);
4849 quad_att
= 0.0f
; /* 0 or MAX? (0 seems to be ok) */
4852 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
4853 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
4854 * Attenuation0 to NaN and crashes in the gl lib
4857 switch (lightInfo
->OriginalParms
.Type
) {
4858 case WINED3DLIGHT_POINT
:
4860 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4861 checkGLcall("glLightfv");
4862 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4863 checkGLcall("glLightf");
4864 /* Attenuation - Are these right? guessing... */
4865 glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation0
);
4866 checkGLcall("glLightf");
4867 glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation1
);
4868 checkGLcall("glLightf");
4869 if (quad_att
< lightInfo
->OriginalParms
.Attenuation2
) quad_att
= lightInfo
->OriginalParms
.Attenuation2
;
4870 glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4871 checkGLcall("glLightf");
4875 case WINED3DLIGHT_SPOT
:
4877 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4878 checkGLcall("glLightfv");
4880 glLightfv(GL_LIGHT0
+ Index
, GL_SPOT_DIRECTION
, &lightInfo
->lightDirn
[0]);
4881 checkGLcall("glLightfv");
4882 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, lightInfo
->exponent
);
4883 checkGLcall("glLightf");
4884 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4885 checkGLcall("glLightf");
4886 /* Attenuation - Are these right? guessing... */
4887 glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation0
);
4888 checkGLcall("glLightf");
4889 glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
, lightInfo
->OriginalParms
.Attenuation1
);
4890 checkGLcall("glLightf");
4891 if (quad_att
< lightInfo
->OriginalParms
.Attenuation2
) quad_att
= lightInfo
->OriginalParms
.Attenuation2
;
4892 glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4893 checkGLcall("glLightf");
4897 case WINED3DLIGHT_DIRECTIONAL
:
4899 glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]); /* Note gl uses w position of 0 for direction! */
4900 checkGLcall("glLightfv");
4901 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4902 checkGLcall("glLightf");
4903 glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, 0.0f
);
4904 checkGLcall("glLightf");
4908 FIXME("Unrecognized light type %d\n", lightInfo
->OriginalParms
.Type
);
4911 /* Restore the modelview matrix */
4914 glEnable(GL_LIGHT0
+ Index
);
4915 checkGLcall("glEnable(GL_LIGHT0 + Index)");
4919 static void scissorrect(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4921 IWineD3DSurfaceImpl
*target
= stateblock
->device
->render_targets
[0];
4922 RECT
*pRect
= &stateblock
->state
.scissor_rect
;
4926 target
->get_drawable_size(context
, &width
, &height
);
4927 /* Warning: glScissor uses window coordinates, not viewport coordinates, so our viewport correction does not apply
4928 * Warning2: Even in windowed mode the coords are relative to the window, not the screen
4930 TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock
->device
, pRect
->left
, pRect
->bottom
- height
,
4931 pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4933 if (context
->render_offscreen
)
4935 glScissor(pRect
->left
, pRect
->top
, pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4937 glScissor(pRect
->left
, height
- pRect
->bottom
, pRect
->right
- pRect
->left
, pRect
->bottom
- pRect
->top
);
4939 checkGLcall("glScissor");
4942 static void indexbuffer(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4944 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4946 if (stateblock
->state
.user_stream
|| !stateblock
->state
.index_buffer
)
4948 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB
, 0));
4952 struct wined3d_buffer
*ib
= stateblock
->state
.index_buffer
;
4953 GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB
, ib
->buffer_object
));
4957 static void frontface(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
4959 if (context
->render_offscreen
)
4961 glFrontFace(GL_CCW
);
4962 checkGLcall("glFrontFace(GL_CCW)");
4965 checkGLcall("glFrontFace(GL_CW)");
4969 const struct StateEntryTemplate misc_state_template
[] = {
4970 { STATE_RENDER(WINED3DRS_SRCBLEND
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4971 { STATE_RENDER(WINED3DRS_DESTBLEND
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4972 { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), state_blend
}, WINED3D_GL_EXT_NONE
},
4973 { STATE_RENDER(WINED3DRS_EDGEANTIALIAS
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4974 { STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4975 { STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4976 { STATE_RENDER(WINED3DRS_SRCBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4977 { STATE_RENDER(WINED3DRS_DESTBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4978 { STATE_RENDER(WINED3DRS_DESTBLENDALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4979 { STATE_RENDER(WINED3DRS_BLENDOPALPHA
), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4980 { STATE_STREAMSRC
, { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
4981 { STATE_VDECL
, { STATE_VDECL
, streamsrc
}, WINED3D_GL_EXT_NONE
},
4982 { STATE_FRONTFACE
, { STATE_FRONTFACE
, frontface
}, WINED3D_GL_EXT_NONE
},
4983 { STATE_SCISSORRECT
, { STATE_SCISSORRECT
, scissorrect
}, WINED3D_GL_EXT_NONE
},
4984 /* TODO: Move shader constant loading to vertex and fragment pipeline repectively, as soon as the pshader and
4985 * vshader loadings are untied from each other
4987 { STATE_VERTEXSHADERCONSTANT
, { STATE_VERTEXSHADERCONSTANT
, shaderconstant
}, WINED3D_GL_EXT_NONE
},
4988 { STATE_PIXELSHADERCONSTANT
, { STATE_VERTEXSHADERCONSTANT
, NULL
}, WINED3D_GL_EXT_NONE
},
4989 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
4990 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4991 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4992 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4993 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
4994 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4995 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4996 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4997 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
4998 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4999 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5000 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5001 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5002 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5003 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5004 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5005 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5006 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5007 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5008 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5009 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5010 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5011 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5012 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5013 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5014 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5015 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5016 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5017 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), shader_bumpenvmat
}, WINED3D_GL_EXT_NONE
},
5018 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5019 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5020 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5021 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5022 { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5023 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5024 { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5025 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5026 { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5027 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5028 { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5029 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5030 { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5031 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5032 { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5033 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5034 { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5035 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), tex_bumpenvlscale
}, WINED3D_GL_EXT_NONE
},
5036 { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET
), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5038 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_miscpart
}, WINED3D_GL_EXT_NONE
},
5039 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, indexbuffer
}, ARB_VERTEX_BUFFER_OBJECT
},
5040 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, state_nop
}, WINED3D_GL_EXT_NONE
},
5041 { STATE_RENDER(WINED3DRS_ANTIALIAS
), { STATE_RENDER(WINED3DRS_ANTIALIAS
), state_antialias
}, WINED3D_GL_EXT_NONE
},
5042 { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE
), { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE
), state_perspective
}, WINED3D_GL_EXT_NONE
},
5043 { STATE_RENDER(WINED3DRS_ZENABLE
), { STATE_RENDER(WINED3DRS_ZENABLE
), state_zenable
}, WINED3D_GL_EXT_NONE
},
5044 { STATE_RENDER(WINED3DRS_WRAPU
), { STATE_RENDER(WINED3DRS_WRAPU
), state_wrapu
}, WINED3D_GL_EXT_NONE
},
5045 { STATE_RENDER(WINED3DRS_WRAPV
), { STATE_RENDER(WINED3DRS_WRAPV
), state_wrapv
}, WINED3D_GL_EXT_NONE
},
5046 { STATE_RENDER(WINED3DRS_FILLMODE
), { STATE_RENDER(WINED3DRS_FILLMODE
), state_fillmode
}, WINED3D_GL_EXT_NONE
},
5047 { STATE_RENDER(WINED3DRS_SHADEMODE
), { STATE_RENDER(WINED3DRS_SHADEMODE
), state_shademode
}, WINED3D_GL_EXT_NONE
},
5048 { STATE_RENDER(WINED3DRS_LINEPATTERN
), { STATE_RENDER(WINED3DRS_LINEPATTERN
), state_linepattern
}, WINED3D_GL_EXT_NONE
},
5049 { STATE_RENDER(WINED3DRS_MONOENABLE
), { STATE_RENDER(WINED3DRS_MONOENABLE
), state_monoenable
}, WINED3D_GL_EXT_NONE
},
5050 { STATE_RENDER(WINED3DRS_ROP2
), { STATE_RENDER(WINED3DRS_ROP2
), state_rop2
}, WINED3D_GL_EXT_NONE
},
5051 { STATE_RENDER(WINED3DRS_PLANEMASK
), { STATE_RENDER(WINED3DRS_PLANEMASK
), state_planemask
}, WINED3D_GL_EXT_NONE
},
5052 { STATE_RENDER(WINED3DRS_ZWRITEENABLE
), { STATE_RENDER(WINED3DRS_ZWRITEENABLE
), state_zwritenable
}, WINED3D_GL_EXT_NONE
},
5053 { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), state_alpha
}, WINED3D_GL_EXT_NONE
},
5054 { STATE_RENDER(WINED3DRS_ALPHAREF
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5055 { STATE_RENDER(WINED3DRS_ALPHAFUNC
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5056 { STATE_RENDER(WINED3DRS_COLORKEYENABLE
), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5057 { STATE_RENDER(WINED3DRS_LASTPIXEL
), { STATE_RENDER(WINED3DRS_LASTPIXEL
), state_lastpixel
}, WINED3D_GL_EXT_NONE
},
5058 { STATE_RENDER(WINED3DRS_CULLMODE
), { STATE_RENDER(WINED3DRS_CULLMODE
), state_cullmode
}, WINED3D_GL_EXT_NONE
},
5059 { STATE_RENDER(WINED3DRS_ZFUNC
), { STATE_RENDER(WINED3DRS_ZFUNC
), state_zfunc
}, WINED3D_GL_EXT_NONE
},
5060 { STATE_RENDER(WINED3DRS_DITHERENABLE
), { STATE_RENDER(WINED3DRS_DITHERENABLE
), state_ditherenable
}, WINED3D_GL_EXT_NONE
},
5061 { STATE_RENDER(WINED3DRS_SUBPIXEL
), { STATE_RENDER(WINED3DRS_SUBPIXEL
), state_subpixel
}, WINED3D_GL_EXT_NONE
},
5062 { STATE_RENDER(WINED3DRS_SUBPIXELX
), { STATE_RENDER(WINED3DRS_SUBPIXELX
), state_subpixelx
}, WINED3D_GL_EXT_NONE
},
5063 { STATE_RENDER(WINED3DRS_STIPPLEDALPHA
), { STATE_RENDER(WINED3DRS_STIPPLEDALPHA
), state_stippledalpha
}, WINED3D_GL_EXT_NONE
},
5064 { STATE_RENDER(WINED3DRS_ZBIAS
), { STATE_RENDER(WINED3DRS_ZBIAS
), state_zbias
}, WINED3D_GL_EXT_NONE
},
5065 { STATE_RENDER(WINED3DRS_STIPPLEENABLE
), { STATE_RENDER(WINED3DRS_STIPPLEENABLE
), state_stippleenable
}, WINED3D_GL_EXT_NONE
},
5066 { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS
), { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS
), state_mipmaplodbias
}, WINED3D_GL_EXT_NONE
},
5067 { STATE_RENDER(WINED3DRS_ANISOTROPY
), { STATE_RENDER(WINED3DRS_ANISOTROPY
), state_anisotropy
}, WINED3D_GL_EXT_NONE
},
5068 { STATE_RENDER(WINED3DRS_FLUSHBATCH
), { STATE_RENDER(WINED3DRS_FLUSHBATCH
), state_flushbatch
}, WINED3D_GL_EXT_NONE
},
5069 { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT
), state_translucentsi
}, WINED3D_GL_EXT_NONE
},
5070 { STATE_RENDER(WINED3DRS_STENCILENABLE
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), state_stencil
}, WINED3D_GL_EXT_NONE
},
5071 { STATE_RENDER(WINED3DRS_STENCILFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5072 { STATE_RENDER(WINED3DRS_STENCILZFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5073 { STATE_RENDER(WINED3DRS_STENCILPASS
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5074 { STATE_RENDER(WINED3DRS_STENCILFUNC
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5075 { STATE_RENDER(WINED3DRS_STENCILREF
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5076 { STATE_RENDER(WINED3DRS_STENCILMASK
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5077 { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), state_stencilwrite2s
}, EXT_STENCIL_TWO_SIDE
},
5078 { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK
), state_stencilwrite
}, WINED3D_GL_EXT_NONE
},
5079 { STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5080 { STATE_RENDER(WINED3DRS_CCW_STENCILFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5081 { STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5082 { STATE_RENDER(WINED3DRS_CCW_STENCILPASS
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5083 { STATE_RENDER(WINED3DRS_CCW_STENCILFUNC
), { STATE_RENDER(WINED3DRS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5084 { STATE_RENDER(WINED3DRS_WRAP0
), { STATE_RENDER(WINED3DRS_WRAP0
), state_wrap
}, WINED3D_GL_EXT_NONE
},
5085 { STATE_RENDER(WINED3DRS_WRAP1
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5086 { STATE_RENDER(WINED3DRS_WRAP2
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5087 { STATE_RENDER(WINED3DRS_WRAP3
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5088 { STATE_RENDER(WINED3DRS_WRAP4
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5089 { STATE_RENDER(WINED3DRS_WRAP5
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5090 { STATE_RENDER(WINED3DRS_WRAP6
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5091 { STATE_RENDER(WINED3DRS_WRAP7
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5092 { STATE_RENDER(WINED3DRS_WRAP8
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5093 { STATE_RENDER(WINED3DRS_WRAP9
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5094 { STATE_RENDER(WINED3DRS_WRAP10
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5095 { STATE_RENDER(WINED3DRS_WRAP11
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5096 { STATE_RENDER(WINED3DRS_WRAP12
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5097 { STATE_RENDER(WINED3DRS_WRAP13
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5098 { STATE_RENDER(WINED3DRS_WRAP14
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5099 { STATE_RENDER(WINED3DRS_WRAP15
), { STATE_RENDER(WINED3DRS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5100 { STATE_RENDER(WINED3DRS_EXTENTS
), { STATE_RENDER(WINED3DRS_EXTENTS
), state_extents
}, WINED3D_GL_EXT_NONE
},
5101 { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE
), { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE
), state_ckeyblend
}, WINED3D_GL_EXT_NONE
},
5102 { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING
), { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING
), state_swvp
}, WINED3D_GL_EXT_NONE
},
5103 { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE
), { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE
), state_patchedgestyle
}, WINED3D_GL_EXT_NONE
},
5104 { STATE_RENDER(WINED3DRS_PATCHSEGMENTS
), { STATE_RENDER(WINED3DRS_PATCHSEGMENTS
), state_patchsegments
}, WINED3D_GL_EXT_NONE
},
5105 { STATE_RENDER(WINED3DRS_POSITIONDEGREE
), { STATE_RENDER(WINED3DRS_POSITIONDEGREE
), state_positiondegree
}, WINED3D_GL_EXT_NONE
},
5106 { STATE_RENDER(WINED3DRS_NORMALDEGREE
), { STATE_RENDER(WINED3DRS_NORMALDEGREE
), state_normaldegree
}, WINED3D_GL_EXT_NONE
},
5107 { STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5108 { STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5109 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_X
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5110 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5111 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5112 { STATE_RENDER(WINED3DRS_ADAPTIVETESS_W
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), NULL
}, WINED3D_GL_EXT_NONE
},
5113 { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_nvdb
}, EXT_DEPTH_BOUNDS_TEST
},
5114 { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION
), state_tessellation
}, WINED3D_GL_EXT_NONE
},
5115 { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), state_msaa
}, ARB_MULTISAMPLE
},
5116 { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS
), state_msaa_w
}, WINED3D_GL_EXT_NONE
},
5117 { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK
), { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK
), state_multisampmask
}, WINED3D_GL_EXT_NONE
},
5118 { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN
), { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN
), state_debug_monitor
}, WINED3D_GL_EXT_NONE
},
5119 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite0
}, EXT_DRAW_BUFFERS2
},
5120 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), state_colorwrite
}, WINED3D_GL_EXT_NONE
},
5121 { STATE_RENDER(WINED3DRS_BLENDOP
), { STATE_RENDER(WINED3DRS_BLENDOP
), state_blendop
}, EXT_BLEND_MINMAX
},
5122 { STATE_RENDER(WINED3DRS_BLENDOP
), { STATE_RENDER(WINED3DRS_BLENDOP
), state_blendop_w
}, WINED3D_GL_EXT_NONE
},
5123 { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE
), state_scissor
}, WINED3D_GL_EXT_NONE
},
5124 { STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS
), { STATE_RENDER(WINED3DRS_DEPTHBIAS
), NULL
}, WINED3D_GL_EXT_NONE
},
5125 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), state_colorwrite1
}, EXT_DRAW_BUFFERS2
},
5126 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5127 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), state_colorwrite2
}, EXT_DRAW_BUFFERS2
},
5128 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5129 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), state_colorwrite3
}, EXT_DRAW_BUFFERS2
},
5130 { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5131 { STATE_RENDER(WINED3DRS_BLENDFACTOR
), { STATE_RENDER(WINED3DRS_BLENDFACTOR
), state_blendfactor
}, EXT_BLEND_COLOR
},
5132 { STATE_RENDER(WINED3DRS_BLENDFACTOR
), { STATE_RENDER(WINED3DRS_BLENDFACTOR
), state_blendfactor_w
}, WINED3D_GL_EXT_NONE
},
5133 { STATE_RENDER(WINED3DRS_DEPTHBIAS
), { STATE_RENDER(WINED3DRS_DEPTHBIAS
), state_depthbias
}, WINED3D_GL_EXT_NONE
},
5134 { STATE_RENDER(WINED3DRS_ZVISIBLE
), { STATE_RENDER(WINED3DRS_ZVISIBLE
), state_zvisible
}, WINED3D_GL_EXT_NONE
},
5136 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler
}, WINED3D_GL_EXT_NONE
},
5137 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler
}, WINED3D_GL_EXT_NONE
},
5138 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler
}, WINED3D_GL_EXT_NONE
},
5139 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler
}, WINED3D_GL_EXT_NONE
},
5140 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler
}, WINED3D_GL_EXT_NONE
},
5141 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler
}, WINED3D_GL_EXT_NONE
},
5142 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler
}, WINED3D_GL_EXT_NONE
},
5143 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler
}, WINED3D_GL_EXT_NONE
},
5144 { STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler
}, WINED3D_GL_EXT_NONE
},
5145 { STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler
}, WINED3D_GL_EXT_NONE
},
5146 { STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler
}, WINED3D_GL_EXT_NONE
},
5147 { STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler
}, WINED3D_GL_EXT_NONE
},
5148 { STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler
}, WINED3D_GL_EXT_NONE
},
5149 { STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler
}, WINED3D_GL_EXT_NONE
},
5150 { STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler
}, WINED3D_GL_EXT_NONE
},
5151 { STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler
}, WINED3D_GL_EXT_NONE
},
5152 { STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler
}, WINED3D_GL_EXT_NONE
},
5153 { STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler
}, WINED3D_GL_EXT_NONE
},
5154 { STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler
}, WINED3D_GL_EXT_NONE
},
5155 { STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler
}, WINED3D_GL_EXT_NONE
},
5156 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5159 const struct StateEntryTemplate ffp_vertexstate_template
[] = {
5160 { STATE_VDECL
, { STATE_VDECL
, vertexdeclaration
}, WINED3D_GL_EXT_NONE
},
5161 { STATE_VSHADER
, { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
5162 { STATE_MATERIAL
, { STATE_RENDER(WINED3DRS_SPECULARENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5163 { STATE_RENDER(WINED3DRS_SPECULARENABLE
), { STATE_RENDER(WINED3DRS_SPECULARENABLE
), state_specularenable
}, WINED3D_GL_EXT_NONE
},
5165 { STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane
}, WINED3D_GL_EXT_NONE
},
5166 { STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane
}, WINED3D_GL_EXT_NONE
},
5167 { STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane
}, WINED3D_GL_EXT_NONE
},
5168 { STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane
}, WINED3D_GL_EXT_NONE
},
5169 { STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane
}, WINED3D_GL_EXT_NONE
},
5170 { STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane
}, WINED3D_GL_EXT_NONE
},
5171 { STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane
}, WINED3D_GL_EXT_NONE
},
5172 { STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane
}, WINED3D_GL_EXT_NONE
},
5173 { STATE_CLIPPLANE(8), { STATE_CLIPPLANE(8), clipplane
}, WINED3D_GL_EXT_NONE
},
5174 { STATE_CLIPPLANE(9), { STATE_CLIPPLANE(9), clipplane
}, WINED3D_GL_EXT_NONE
},
5175 { STATE_CLIPPLANE(10), { STATE_CLIPPLANE(10), clipplane
}, WINED3D_GL_EXT_NONE
},
5176 { STATE_CLIPPLANE(11), { STATE_CLIPPLANE(11), clipplane
}, WINED3D_GL_EXT_NONE
},
5177 { STATE_CLIPPLANE(12), { STATE_CLIPPLANE(12), clipplane
}, WINED3D_GL_EXT_NONE
},
5178 { STATE_CLIPPLANE(13), { STATE_CLIPPLANE(13), clipplane
}, WINED3D_GL_EXT_NONE
},
5179 { STATE_CLIPPLANE(14), { STATE_CLIPPLANE(14), clipplane
}, WINED3D_GL_EXT_NONE
},
5180 { STATE_CLIPPLANE(15), { STATE_CLIPPLANE(15), clipplane
}, WINED3D_GL_EXT_NONE
},
5181 { STATE_CLIPPLANE(16), { STATE_CLIPPLANE(16), clipplane
}, WINED3D_GL_EXT_NONE
},
5182 { STATE_CLIPPLANE(17), { STATE_CLIPPLANE(17), clipplane
}, WINED3D_GL_EXT_NONE
},
5183 { STATE_CLIPPLANE(18), { STATE_CLIPPLANE(18), clipplane
}, WINED3D_GL_EXT_NONE
},
5184 { STATE_CLIPPLANE(19), { STATE_CLIPPLANE(19), clipplane
}, WINED3D_GL_EXT_NONE
},
5185 { STATE_CLIPPLANE(20), { STATE_CLIPPLANE(20), clipplane
}, WINED3D_GL_EXT_NONE
},
5186 { STATE_CLIPPLANE(21), { STATE_CLIPPLANE(21), clipplane
}, WINED3D_GL_EXT_NONE
},
5187 { STATE_CLIPPLANE(22), { STATE_CLIPPLANE(22), clipplane
}, WINED3D_GL_EXT_NONE
},
5188 { STATE_CLIPPLANE(23), { STATE_CLIPPLANE(23), clipplane
}, WINED3D_GL_EXT_NONE
},
5189 { STATE_CLIPPLANE(24), { STATE_CLIPPLANE(24), clipplane
}, WINED3D_GL_EXT_NONE
},
5190 { STATE_CLIPPLANE(25), { STATE_CLIPPLANE(25), clipplane
}, WINED3D_GL_EXT_NONE
},
5191 { STATE_CLIPPLANE(26), { STATE_CLIPPLANE(26), clipplane
}, WINED3D_GL_EXT_NONE
},
5192 { STATE_CLIPPLANE(27), { STATE_CLIPPLANE(27), clipplane
}, WINED3D_GL_EXT_NONE
},
5193 { STATE_CLIPPLANE(28), { STATE_CLIPPLANE(28), clipplane
}, WINED3D_GL_EXT_NONE
},
5194 { STATE_CLIPPLANE(29), { STATE_CLIPPLANE(29), clipplane
}, WINED3D_GL_EXT_NONE
},
5195 { STATE_CLIPPLANE(30), { STATE_CLIPPLANE(30), clipplane
}, WINED3D_GL_EXT_NONE
},
5196 { STATE_CLIPPLANE(31), { STATE_CLIPPLANE(31), clipplane
}, WINED3D_GL_EXT_NONE
},
5198 { STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light
}, WINED3D_GL_EXT_NONE
},
5199 { STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light
}, WINED3D_GL_EXT_NONE
},
5200 { STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light
}, WINED3D_GL_EXT_NONE
},
5201 { STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light
}, WINED3D_GL_EXT_NONE
},
5202 { STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light
}, WINED3D_GL_EXT_NONE
},
5203 { STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light
}, WINED3D_GL_EXT_NONE
},
5204 { STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light
}, WINED3D_GL_EXT_NONE
},
5205 { STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light
}, WINED3D_GL_EXT_NONE
},
5207 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_vertexpart
}, WINED3D_GL_EXT_NONE
},
5208 /* Transform states follow */
5209 { STATE_TRANSFORM(WINED3DTS_VIEW
), { STATE_TRANSFORM(WINED3DTS_VIEW
), transform_view
}, WINED3D_GL_EXT_NONE
},
5210 { STATE_TRANSFORM(WINED3DTS_PROJECTION
), { STATE_TRANSFORM(WINED3DTS_PROJECTION
), transform_projection
}, WINED3D_GL_EXT_NONE
},
5211 { STATE_TRANSFORM(WINED3DTS_TEXTURE0
), { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5212 { STATE_TRANSFORM(WINED3DTS_TEXTURE1
), { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5213 { STATE_TRANSFORM(WINED3DTS_TEXTURE2
), { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5214 { STATE_TRANSFORM(WINED3DTS_TEXTURE3
), { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5215 { STATE_TRANSFORM(WINED3DTS_TEXTURE4
), { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5216 { STATE_TRANSFORM(WINED3DTS_TEXTURE5
), { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5217 { STATE_TRANSFORM(WINED3DTS_TEXTURE6
), { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5218 { STATE_TRANSFORM(WINED3DTS_TEXTURE7
), { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5219 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), transform_world
}, WINED3D_GL_EXT_NONE
},
5220 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5221 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5222 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5223 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5224 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5225 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5226 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5227 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5228 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5229 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5230 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5231 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5232 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5233 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5234 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5235 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5236 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5237 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5238 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5239 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5240 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5241 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5242 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5243 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5244 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5245 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5246 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5247 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5248 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5249 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5250 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5251 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5252 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5253 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5254 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5255 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5256 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5257 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5258 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5259 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5260 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5261 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5262 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5263 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5264 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5265 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5266 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5267 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5268 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5269 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5270 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5271 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5272 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5273 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5274 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5275 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5276 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5277 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5278 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5279 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5280 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5281 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5282 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5283 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5284 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5285 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5286 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5287 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5288 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5289 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5290 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5291 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5292 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5293 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5294 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5295 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5296 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5297 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5298 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5299 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5300 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5301 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5302 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5303 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5304 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5305 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5306 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5307 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5308 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5309 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5310 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5311 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5312 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5313 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5314 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5315 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5316 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5317 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5318 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5319 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5320 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5321 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5322 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5323 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5324 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5325 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5326 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5327 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5328 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5329 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5330 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5331 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5332 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5333 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5334 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5335 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5336 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5337 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5338 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5339 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5340 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5341 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5342 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5343 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5344 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5345 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5346 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5347 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5348 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5349 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5350 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5351 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5352 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5353 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5354 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5355 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5356 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5357 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5358 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5359 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5360 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5361 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5362 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5363 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5364 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5365 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5366 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5367 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5368 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5369 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5370 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5371 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5372 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5373 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5374 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5375 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5376 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5377 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5378 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5379 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5380 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5381 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5382 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5383 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5384 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5385 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5386 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5387 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5388 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5389 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5390 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5391 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5392 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5393 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5394 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5395 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5396 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5397 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5398 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5399 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5400 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5401 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5402 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5403 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5404 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5405 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5406 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5407 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5408 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5409 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5410 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5411 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5412 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5413 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5414 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5415 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5416 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5417 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5418 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5419 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5420 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5421 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5422 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5423 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5424 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5425 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5426 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5427 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5428 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5429 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5430 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5431 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5432 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5433 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5434 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5435 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5436 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5437 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5438 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5439 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5440 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5441 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5442 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5443 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5444 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5445 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5446 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5447 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5448 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5449 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5450 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5451 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5452 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5453 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5454 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5455 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5456 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5457 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5458 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5459 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5460 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5461 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5462 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5463 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5464 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5465 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5466 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5467 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5468 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5469 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5470 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5471 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5472 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5473 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5474 { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5475 { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5476 { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5477 { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5478 { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5479 { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5480 { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5481 { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5482 { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
),{STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS
),transform_texture
}, WINED3D_GL_EXT_NONE
},
5483 { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5484 { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5485 { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5486 { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5487 { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5488 { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5489 { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5490 { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX
), { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5492 { STATE_RENDER(WINED3DRS_FOGENABLE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog_vertexpart
}, WINED3D_GL_EXT_NONE
},
5493 { STATE_RENDER(WINED3DRS_FOGTABLEMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5494 { STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5495 { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), state_rangefog
}, NV_FOG_DISTANCE
},
5496 { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE
), state_rangefog_w
}, WINED3D_GL_EXT_NONE
},
5497 { STATE_RENDER(WINED3DRS_CLIPPING
), { STATE_RENDER(WINED3DRS_CLIPPING
), state_clipping
}, WINED3D_GL_EXT_NONE
},
5498 { STATE_RENDER(WINED3DRS_CLIPPLANEENABLE
), { STATE_RENDER(WINED3DRS_CLIPPING
), NULL
}, WINED3D_GL_EXT_NONE
},
5499 { STATE_RENDER(WINED3DRS_LIGHTING
), { STATE_RENDER(WINED3DRS_LIGHTING
), state_lighting
}, WINED3D_GL_EXT_NONE
},
5500 { STATE_RENDER(WINED3DRS_AMBIENT
), { STATE_RENDER(WINED3DRS_AMBIENT
), state_ambient
}, WINED3D_GL_EXT_NONE
},
5501 { STATE_RENDER(WINED3DRS_COLORVERTEX
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), state_colormat
}, WINED3D_GL_EXT_NONE
},
5502 { STATE_RENDER(WINED3DRS_LOCALVIEWER
), { STATE_RENDER(WINED3DRS_LOCALVIEWER
), state_localviewer
}, WINED3D_GL_EXT_NONE
},
5503 { STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), { STATE_RENDER(WINED3DRS_NORMALIZENORMALS
), state_normalize
}, WINED3D_GL_EXT_NONE
},
5504 { STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5505 { STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5506 { STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5507 { STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE
), { STATE_RENDER(WINED3DRS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5508 { STATE_RENDER(WINED3DRS_VERTEXBLEND
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), state_vertexblend
}, ARB_VERTEX_BLEND
},
5509 { STATE_RENDER(WINED3DRS_VERTEXBLEND
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), state_vertexblend_w
}, WINED3D_GL_EXT_NONE
},
5510 { STATE_RENDER(WINED3DRS_POINTSIZE
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5511 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_arb
}, ARB_POINT_PARAMETERS
},
5512 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_ext
}, EXT_POINT_PARAMETERS
},
5513 { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), state_psizemin_w
}, WINED3D_GL_EXT_NONE
},
5514 { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), state_pointsprite
}, ARB_POINT_SPRITE
},
5515 { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE
), state_pointsprite_w
}, WINED3D_GL_EXT_NONE
},
5516 { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), state_pscale
}, WINED3D_GL_EXT_NONE
},
5517 { STATE_RENDER(WINED3DRS_POINTSCALE_A
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5518 { STATE_RENDER(WINED3DRS_POINTSCALE_B
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5519 { STATE_RENDER(WINED3DRS_POINTSCALE_C
), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5520 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, ARB_POINT_PARAMETERS
},
5521 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, EXT_POINT_PARAMETERS
},
5522 { STATE_RENDER(WINED3DRS_POINTSIZE_MAX
), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN
), NULL
}, WINED3D_GL_EXT_NONE
},
5523 { STATE_RENDER(WINED3DRS_TWEENFACTOR
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5524 { STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE
), { STATE_RENDER(WINED3DRS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5526 /* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
5527 * so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
5528 * otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
5530 { STATE_SAMPLER(0), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5531 { STATE_SAMPLER(0), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5532 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5533 { STATE_SAMPLER(1), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5534 { STATE_SAMPLER(1), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5535 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5536 { STATE_SAMPLER(2), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5537 { STATE_SAMPLER(2), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5538 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5539 { STATE_SAMPLER(3), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5540 { STATE_SAMPLER(3), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5541 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5542 { STATE_SAMPLER(4), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5543 { STATE_SAMPLER(4), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5544 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5545 { STATE_SAMPLER(5), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5546 { STATE_SAMPLER(5), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5547 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5548 { STATE_SAMPLER(6), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5549 { STATE_SAMPLER(6), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5550 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5551 { STATE_SAMPLER(7), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5552 { STATE_SAMPLER(7), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5553 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5554 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5557 static const struct StateEntryTemplate ffp_fragmentstate_template
[] = {
5558 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5559 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5560 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5561 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5562 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5563 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5564 { STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5565 { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5566 { STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5567 { STATE_TEXTURESTAGE(0, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5568 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5569 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5570 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5571 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5572 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5573 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5574 { STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5575 { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5576 { STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5577 { STATE_TEXTURESTAGE(1, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5578 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5579 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5580 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5581 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5582 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5583 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5584 { STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5585 { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5586 { STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5587 { STATE_TEXTURESTAGE(2, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5588 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5589 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5590 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5591 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5592 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5593 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5594 { STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5595 { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5596 { STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5597 { STATE_TEXTURESTAGE(3, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5598 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5599 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5600 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5601 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5602 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5603 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5604 { STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5605 { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5606 { STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5607 { STATE_TEXTURESTAGE(4, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5608 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5609 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5610 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5611 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5612 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5613 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5614 { STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5615 { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5616 { STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5617 { STATE_TEXTURESTAGE(5, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5618 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5619 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5620 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5621 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5622 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5623 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5624 { STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5625 { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5626 { STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5627 { STATE_TEXTURESTAGE(6, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5628 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5629 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5630 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5631 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5632 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5633 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5634 { STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5635 { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0
), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP
), NULL
}, WINED3D_GL_EXT_NONE
},
5636 { STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG
), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP
), NULL
}, WINED3D_GL_EXT_NONE
},
5637 { STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5638 { STATE_PIXELSHADER
, { STATE_PIXELSHADER
, apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
5639 { STATE_RENDER(WINED3DRS_SRGBWRITEENABLE
), { STATE_PIXELSHADER
, NULL
}, WINED3D_GL_EXT_NONE
},
5640 { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR
), state_texfactor
}, WINED3D_GL_EXT_NONE
},
5641 { STATE_RENDER(WINED3DRS_FOGCOLOR
), { STATE_RENDER(WINED3DRS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
5642 { STATE_RENDER(WINED3DRS_FOGDENSITY
), { STATE_RENDER(WINED3DRS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
5643 { STATE_RENDER(WINED3DRS_FOGENABLE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
5644 { STATE_RENDER(WINED3DRS_FOGTABLEMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5645 { STATE_RENDER(WINED3DRS_FOGVERTEXMODE
), { STATE_RENDER(WINED3DRS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5646 { STATE_RENDER(WINED3DRS_FOGSTART
), { STATE_RENDER(WINED3DRS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
5647 { STATE_RENDER(WINED3DRS_FOGEND
), { STATE_RENDER(WINED3DRS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
5648 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5649 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5650 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5651 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5652 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5653 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5654 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5655 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5656 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5659 /* Context activation is done by the caller. */
5660 static void ffp_enable(IWineD3DDevice
*iface
, BOOL enable
) { }
5662 static void ffp_fragment_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*pCaps
)
5664 pCaps
->PrimitiveMiscCaps
= 0;
5665 pCaps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
|
5666 WINED3DTEXOPCAPS_ADDSIGNED
|
5667 WINED3DTEXOPCAPS_ADDSIGNED2X
|
5668 WINED3DTEXOPCAPS_MODULATE
|
5669 WINED3DTEXOPCAPS_MODULATE2X
|
5670 WINED3DTEXOPCAPS_MODULATE4X
|
5671 WINED3DTEXOPCAPS_SELECTARG1
|
5672 WINED3DTEXOPCAPS_SELECTARG2
|
5673 WINED3DTEXOPCAPS_DISABLE
;
5675 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
]
5676 || gl_info
->supported
[EXT_TEXTURE_ENV_COMBINE
]
5677 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5679 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
5680 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
5681 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
5682 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
5683 WINED3DTEXOPCAPS_LERP
|
5684 WINED3DTEXOPCAPS_SUBTRACT
;
5686 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
]
5687 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5689 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_ADDSMOOTH
|
5690 WINED3DTEXOPCAPS_MULTIPLYADD
|
5691 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
5692 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
5693 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
;
5695 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
5696 pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_DOTPRODUCT3
;
5698 pCaps
->MaxTextureBlendStages
= gl_info
->limits
.textures
;
5699 pCaps
->MaxSimultaneousTextures
= gl_info
->limits
.textures
;
5702 static HRESULT
ffp_fragment_alloc(IWineD3DDevice
*iface
) { return WINED3D_OK
; }
5703 static void ffp_fragment_free(IWineD3DDevice
*iface
) {}
5704 static BOOL
ffp_color_fixup_supported(struct color_fixup_desc fixup
)
5708 TRACE("Checking support for fixup:\n");
5709 dump_color_fixup_desc(fixup
);
5712 /* We only support identity conversions. */
5713 if (is_identity_fixup(fixup
))
5719 TRACE("[FAILED]\n");
5723 const struct fragment_pipeline ffp_fragment_pipeline
= {
5725 ffp_fragment_get_caps
,
5728 ffp_color_fixup_supported
,
5729 ffp_fragmentstate_template
,
5730 FALSE
/* we cannot disable projected textures. The vertex pipe has to do it */
5733 static unsigned int num_handlers(const APPLYSTATEFUNC
*funcs
)
5736 for(i
= 0; funcs
[i
]; i
++);
5740 static void multistate_apply_2(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
5742 stateblock
->device
->multistate_funcs
[state
][0](state
, stateblock
, context
);
5743 stateblock
->device
->multistate_funcs
[state
][1](state
, stateblock
, context
);
5746 static void multistate_apply_3(DWORD state
, IWineD3DStateBlockImpl
*stateblock
, struct wined3d_context
*context
)
5748 stateblock
->device
->multistate_funcs
[state
][0](state
, stateblock
, context
);
5749 stateblock
->device
->multistate_funcs
[state
][1](state
, stateblock
, context
);
5750 stateblock
->device
->multistate_funcs
[state
][2](state
, stateblock
, context
);
5753 static void prune_invalid_states(struct StateEntry
*state_table
, const struct wined3d_gl_info
*gl_info
)
5755 unsigned int start
, last
, i
;
5757 start
= STATE_TEXTURESTAGE(gl_info
->limits
.texture_stages
, 0);
5758 last
= STATE_TEXTURESTAGE(MAX_TEXTURES
- 1, WINED3D_HIGHEST_TEXTURE_STATE
);
5759 for (i
= start
; i
<= last
; ++i
)
5761 state_table
[i
].representative
= 0;
5762 state_table
[i
].apply
= state_undefined
;
5765 start
= STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ gl_info
->limits
.texture_stages
);
5766 last
= STATE_TRANSFORM(WINED3DTS_TEXTURE0
+ MAX_TEXTURES
- 1);
5767 for (i
= start
; i
<= last
; ++i
)
5769 state_table
[i
].representative
= 0;
5770 state_table
[i
].apply
= state_undefined
;
5773 start
= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(gl_info
->limits
.blends
));
5774 last
= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255));
5775 for (i
= start
; i
<= last
; ++i
)
5777 state_table
[i
].representative
= 0;
5778 state_table
[i
].apply
= state_undefined
;
5782 static void validate_state_table(struct StateEntry
*state_table
)
5803 static const DWORD simple_states
[] =
5809 STATE_VERTEXSHADERCONSTANT
,
5810 STATE_PIXELSHADERCONSTANT
,
5817 unsigned int i
, current
;
5819 for (i
= STATE_RENDER(1), current
= 0; i
<= STATE_RENDER(WINEHIGHEST_RENDER_STATE
); ++i
)
5821 if (!rs_holes
[current
].first
|| i
< STATE_RENDER(rs_holes
[current
].first
))
5823 if (!state_table
[i
].representative
)
5824 ERR("State %s (%#x) should have a representative.\n", debug_d3dstate(i
), i
);
5826 else if (state_table
[i
].representative
)
5827 ERR("State %s (%#x) shouldn't have a representative.\n", debug_d3dstate(i
), i
);
5829 if (i
== STATE_RENDER(rs_holes
[current
].last
)) ++current
;
5832 for (i
= 0; i
< sizeof(simple_states
) / sizeof(*simple_states
); ++i
)
5834 if (!state_table
[simple_states
[i
]].representative
)
5835 ERR("State %s (%#x) should have a representative.\n",
5836 debug_d3dstate(simple_states
[i
]), simple_states
[i
]);
5839 for (i
= 0; i
< STATE_HIGHEST
+ 1; ++i
)
5841 DWORD rep
= state_table
[i
].representative
;
5844 if (state_table
[rep
].representative
!= rep
)
5846 ERR("State %s (%#x) has invalid representative %s (%#x).\n",
5847 debug_d3dstate(i
), i
, debug_d3dstate(rep
), rep
);
5848 state_table
[i
].representative
= 0;
5853 if (state_table
[i
].apply
)
5854 ERR("State %s (%#x) has both a handler and representative.\n", debug_d3dstate(i
), i
);
5856 else if (!state_table
[i
].apply
)
5858 ERR("Self representing state %s (%#x) has no handler.\n", debug_d3dstate(i
), i
);
5864 HRESULT
compile_state_table(struct StateEntry
*StateTable
, APPLYSTATEFUNC
**dev_multistate_funcs
,
5865 const struct wined3d_gl_info
*gl_info
, const struct StateEntryTemplate
*vertex
,
5866 const struct fragment_pipeline
*fragment
, const struct StateEntryTemplate
*misc
)
5868 unsigned int i
, type
, handlers
;
5869 APPLYSTATEFUNC multistate_funcs
[STATE_HIGHEST
+ 1][3];
5870 const struct StateEntryTemplate
*cur
;
5871 BOOL set
[STATE_HIGHEST
+ 1];
5873 memset(multistate_funcs
, 0, sizeof(multistate_funcs
));
5875 for(i
= 0; i
< STATE_HIGHEST
+ 1; i
++) {
5876 StateTable
[i
].representative
= 0;
5877 StateTable
[i
].apply
= state_undefined
;
5880 for(type
= 0; type
< 3; type
++) {
5881 /* This switch decides the order in which the states are applied */
5883 case 0: cur
= misc
; break;
5884 case 1: cur
= fragment
->states
; break;
5885 case 2: cur
= vertex
; break;
5886 default: cur
= NULL
; /* Stupid compiler */
5890 /* GL extension filtering should not prevent multiple handlers being applied from different
5893 memset(set
, 0, sizeof(set
));
5895 for(i
= 0; cur
[i
].state
; i
++) {
5896 APPLYSTATEFUNC
*funcs_array
;
5898 /* Only use the first matching state with the available extension from one template.
5900 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
5901 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
5903 * if GL_XYZ_fancy is supported, ignore the 2nd line
5905 if(set
[cur
[i
].state
]) continue;
5906 /* Skip state lines depending on unsupported extensions */
5907 if (!gl_info
->supported
[cur
[i
].extension
]) continue;
5908 set
[cur
[i
].state
] = TRUE
;
5909 /* In some cases having an extension means that nothing has to be
5910 * done for a state, e.g. if GL_ARB_texture_non_power_of_two is
5911 * supported, the texture coordinate fixup can be ignored. If the
5912 * apply function is used, mark the state set(done above) to prevent
5913 * applying later lines, but do not record anything in the state
5916 if (!cur
[i
].content
.representative
) continue;
5918 handlers
= num_handlers(multistate_funcs
[cur
[i
].state
]);
5919 multistate_funcs
[cur
[i
].state
][handlers
] = cur
[i
].content
.apply
;
5922 StateTable
[cur
[i
].state
].apply
= cur
[i
].content
.apply
;
5925 StateTable
[cur
[i
].state
].apply
= multistate_apply_2
;
5926 dev_multistate_funcs
[cur
[i
].state
] = HeapAlloc(GetProcessHeap(),
5928 sizeof(**dev_multistate_funcs
) * 2);
5929 if (!dev_multistate_funcs
[cur
[i
].state
]) {
5933 dev_multistate_funcs
[cur
[i
].state
][0] = multistate_funcs
[cur
[i
].state
][0];
5934 dev_multistate_funcs
[cur
[i
].state
][1] = multistate_funcs
[cur
[i
].state
][1];
5937 StateTable
[cur
[i
].state
].apply
= multistate_apply_3
;
5938 funcs_array
= HeapReAlloc(GetProcessHeap(),
5940 dev_multistate_funcs
[cur
[i
].state
],
5941 sizeof(**dev_multistate_funcs
) * 3);
5946 dev_multistate_funcs
[cur
[i
].state
] = funcs_array
;
5947 dev_multistate_funcs
[cur
[i
].state
][2] = multistate_funcs
[cur
[i
].state
][2];
5950 ERR("Unexpected amount of state handlers for state %u: %u\n",
5951 cur
[i
].state
, handlers
+ 1);
5954 if(StateTable
[cur
[i
].state
].representative
&&
5955 StateTable
[cur
[i
].state
].representative
!= cur
[i
].content
.representative
) {
5956 FIXME("State %u has different representatives in different pipeline parts\n",
5959 StateTable
[cur
[i
].state
].representative
= cur
[i
].content
.representative
;
5963 prune_invalid_states(StateTable
, gl_info
);
5964 validate_state_table(StateTable
);
5969 for (i
= 0; i
<= STATE_HIGHEST
; ++i
) {
5970 HeapFree(GetProcessHeap(), 0, dev_multistate_funcs
[i
]);
5973 memset(dev_multistate_funcs
, 0, (STATE_HIGHEST
+ 1)*sizeof(*dev_multistate_funcs
));
5975 return E_OUTOFMEMORY
;