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-2011 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
29 #include "wine/port.h"
36 #include "wined3d_private.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
39 WINE_DECLARE_DEBUG_CHANNEL(d3d_shader
);
41 /* Context activation for state handler is done by the caller. */
43 static void state_undefined(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
45 ERR("Undefined state.\n");
48 static void state_nop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
50 TRACE("%s: nop in current pipe config.\n", debug_d3dstate(state_id
));
53 static void state_fillmode(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
55 enum wined3d_fill_mode mode
= state
->render_states
[WINED3D_RS_FILLMODE
];
56 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
60 case WINED3D_FILL_POINT
:
61 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_POINT
);
62 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
64 case WINED3D_FILL_WIREFRAME
:
65 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_LINE
);
66 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
68 case WINED3D_FILL_SOLID
:
69 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_FILL
);
70 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
73 FIXME("Unrecognized fill mode %#x.\n", mode
);
77 static void state_lighting(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
79 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
81 /* Lighting is not enabled if transformed vertices are drawn, but lighting
82 * does not affect the stream sources, so it is not grouped for
83 * performance reasons. This state reads the decoded vertex declaration,
84 * so if it is dirty don't do anything. The vertex declaration applying
85 * function calls this function for updating. */
86 if (isStateDirty(context
, STATE_VDECL
))
89 if (state
->render_states
[WINED3D_RS_LIGHTING
]
90 && !context
->stream_info
.position_transformed
)
92 gl_info
->gl_ops
.gl
.p_glEnable(GL_LIGHTING
);
93 checkGLcall("glEnable GL_LIGHTING");
97 gl_info
->gl_ops
.gl
.p_glDisable(GL_LIGHTING
);
98 checkGLcall("glDisable GL_LIGHTING");
102 static void state_zenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
104 enum wined3d_depth_buffer_type zenable
= state
->render_states
[WINED3D_RS_ZENABLE
];
105 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
108 /* No z test without depth stencil buffers */
109 if (!state
->fb
->depth_stencil
)
111 TRACE("No Z buffer - disabling depth test\n");
112 zenable
= WINED3D_ZB_FALSE
;
117 case WINED3D_ZB_FALSE
:
118 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_TEST
);
119 checkGLcall("glDisable GL_DEPTH_TEST");
121 case WINED3D_ZB_TRUE
:
122 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_TEST
);
123 checkGLcall("glEnable GL_DEPTH_TEST");
125 case WINED3D_ZB_USEW
:
126 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_TEST
);
127 checkGLcall("glEnable GL_DEPTH_TEST");
128 FIXME("W buffer is not well handled\n");
131 FIXME("Unrecognized depth buffer type %#x.\n", zenable
);
135 if (context
->gl_info
->supported
[ARB_DEPTH_CLAMP
])
137 if (!zenable
&& context
->stream_info
.position_transformed
)
139 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_CLAMP
);
140 checkGLcall("glEnable(GL_DEPTH_CLAMP)");
144 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_CLAMP
);
145 checkGLcall("glDisable(GL_DEPTH_CLAMP)");
148 else if (!zenable
&& !once
++)
149 FIXME("Z buffer disabled, but ARB_depth_clamp isn't supported.\n");
152 static void state_cullmode(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
154 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
156 /* glFrontFace() is set in context.c at context init and on an
157 * offscreen / onscreen rendering switch. */
158 switch (state
->render_states
[WINED3D_RS_CULLMODE
])
160 case WINED3D_CULL_NONE
:
161 gl_info
->gl_ops
.gl
.p_glDisable(GL_CULL_FACE
);
162 checkGLcall("glDisable GL_CULL_FACE");
164 case WINED3D_CULL_CW
:
165 gl_info
->gl_ops
.gl
.p_glEnable(GL_CULL_FACE
);
166 checkGLcall("glEnable GL_CULL_FACE");
167 gl_info
->gl_ops
.gl
.p_glCullFace(GL_FRONT
);
168 checkGLcall("glCullFace(GL_FRONT)");
170 case WINED3D_CULL_CCW
:
171 gl_info
->gl_ops
.gl
.p_glEnable(GL_CULL_FACE
);
172 checkGLcall("glEnable GL_CULL_FACE");
173 gl_info
->gl_ops
.gl
.p_glCullFace(GL_BACK
);
174 checkGLcall("glCullFace(GL_BACK)");
177 FIXME("Unrecognized cull mode %#x.\n",
178 state
->render_states
[WINED3D_RS_CULLMODE
]);
182 static void state_shademode(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
184 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
186 switch (state
->render_states
[WINED3D_RS_SHADEMODE
])
188 case WINED3D_SHADE_FLAT
:
189 gl_info
->gl_ops
.gl
.p_glShadeModel(GL_FLAT
);
190 checkGLcall("glShadeModel(GL_FLAT)");
192 case WINED3D_SHADE_GOURAUD
:
193 gl_info
->gl_ops
.gl
.p_glShadeModel(GL_SMOOTH
);
194 checkGLcall("glShadeModel(GL_SMOOTH)");
196 case WINED3D_SHADE_PHONG
:
197 FIXME("WINED3D_SHADE_PHONG isn't supported.\n");
200 FIXME("Unrecognized shade mode %#x.\n",
201 state
->render_states
[WINED3D_RS_SHADEMODE
]);
205 static void state_ditherenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
207 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
209 if (state
->render_states
[WINED3D_RS_DITHERENABLE
])
211 gl_info
->gl_ops
.gl
.p_glEnable(GL_DITHER
);
212 checkGLcall("glEnable GL_DITHER");
216 gl_info
->gl_ops
.gl
.p_glDisable(GL_DITHER
);
217 checkGLcall("glDisable GL_DITHER");
221 static void state_zwritenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
223 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
225 if (state
->render_states
[WINED3D_RS_ZWRITEENABLE
])
227 gl_info
->gl_ops
.gl
.p_glDepthMask(1);
228 checkGLcall("glDepthMask(1)");
232 gl_info
->gl_ops
.gl
.p_glDepthMask(0);
233 checkGLcall("glDepthMask(0)");
237 GLenum
wined3d_gl_compare_func(enum wined3d_cmp_func f
)
241 case WINED3D_CMP_NEVER
:
243 case WINED3D_CMP_LESS
:
245 case WINED3D_CMP_EQUAL
:
247 case WINED3D_CMP_LESSEQUAL
:
249 case WINED3D_CMP_GREATER
:
251 case WINED3D_CMP_NOTEQUAL
:
253 case WINED3D_CMP_GREATEREQUAL
:
255 case WINED3D_CMP_ALWAYS
:
258 FIXME("Unrecognized compare function %#x.\n", f
);
263 static void state_zfunc(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
265 GLenum depth_func
= wined3d_gl_compare_func(state
->render_states
[WINED3D_RS_ZFUNC
]);
266 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
268 if (!depth_func
) return;
270 gl_info
->gl_ops
.gl
.p_glDepthFunc(depth_func
);
271 checkGLcall("glDepthFunc");
274 void state_ambient(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
276 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
279 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_AMBIENT
], col
);
280 TRACE("Setting ambient to (%f,%f,%f,%f)\n", col
[0], col
[1], col
[2], col
[3]);
281 gl_info
->gl_ops
.gl
.p_glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, col
);
282 checkGLcall("glLightModel for MODEL_AMBIENT");
285 static void state_blendop_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
287 WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
290 static GLenum
gl_blend_op(enum wined3d_blend_op op
)
294 case WINED3D_BLEND_OP_ADD
:
295 return GL_FUNC_ADD_EXT
;
296 case WINED3D_BLEND_OP_SUBTRACT
:
297 return GL_FUNC_SUBTRACT_EXT
;
298 case WINED3D_BLEND_OP_REVSUBTRACT
:
299 return GL_FUNC_REVERSE_SUBTRACT_EXT
;
300 case WINED3D_BLEND_OP_MIN
:
302 case WINED3D_BLEND_OP_MAX
:
305 FIXME("Unhandled blend op %#x.\n", op
);
310 static void state_blendop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
312 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
313 GLenum blend_equation_alpha
= GL_FUNC_ADD_EXT
;
314 GLenum blend_equation
= GL_FUNC_ADD_EXT
;
316 /* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
317 if (state
->render_states
[WINED3D_RS_BLENDOPALPHA
]
318 && !gl_info
->supported
[EXT_BLEND_EQUATION_SEPARATE
])
320 WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparate.\n");
324 blend_equation
= gl_blend_op(state
->render_states
[WINED3D_RS_BLENDOP
]);
325 blend_equation_alpha
= gl_blend_op(state
->render_states
[WINED3D_RS_BLENDOPALPHA
]);
326 TRACE("blend_equation %#x, blend_equation_alpha %#x.\n", blend_equation
, blend_equation_alpha
);
328 if (state
->render_states
[WINED3D_RS_SEPARATEALPHABLENDENABLE
])
330 GL_EXTCALL(glBlendEquationSeparate(blend_equation
, blend_equation_alpha
));
331 checkGLcall("glBlendEquationSeparate");
335 GL_EXTCALL(glBlendEquation(blend_equation
));
336 checkGLcall("glBlendEquation");
340 static GLenum
gl_blend_factor(enum wined3d_blend factor
, const struct wined3d_format
*dst_format
)
344 case WINED3D_BLEND_ZERO
:
346 case WINED3D_BLEND_ONE
:
348 case WINED3D_BLEND_SRCCOLOR
:
350 case WINED3D_BLEND_INVSRCCOLOR
:
351 return GL_ONE_MINUS_SRC_COLOR
;
352 case WINED3D_BLEND_SRCALPHA
:
354 case WINED3D_BLEND_INVSRCALPHA
:
355 return GL_ONE_MINUS_SRC_ALPHA
;
356 case WINED3D_BLEND_DESTCOLOR
:
358 case WINED3D_BLEND_INVDESTCOLOR
:
359 return GL_ONE_MINUS_DST_COLOR
;
360 /* To compensate for the lack of format switching with backbuffer
361 * offscreen rendering, and with onscreen rendering, we modify the
362 * alpha test parameters for (INV)DESTALPHA if the render target
363 * doesn't support alpha blending. A nonexistent alpha channel
364 * returns 1.0, so WINED3D_BLEND_DESTALPHA becomes GL_ONE, and
365 * WINED3D_BLEND_INVDESTALPHA becomes GL_ZERO. */
366 case WINED3D_BLEND_DESTALPHA
:
367 return dst_format
->alpha_size
? GL_DST_ALPHA
: GL_ONE
;
368 case WINED3D_BLEND_INVDESTALPHA
:
369 return dst_format
->alpha_size
? GL_ONE_MINUS_DST_ALPHA
: GL_ZERO
;
370 case WINED3D_BLEND_SRCALPHASAT
:
371 return GL_SRC_ALPHA_SATURATE
;
372 case WINED3D_BLEND_BLENDFACTOR
:
373 return GL_CONSTANT_COLOR_EXT
;
374 case WINED3D_BLEND_INVBLENDFACTOR
:
375 return GL_ONE_MINUS_CONSTANT_COLOR_EXT
;
377 FIXME("Unhandled blend factor %#x.\n", factor
);
382 static void state_blend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
384 const struct wined3d_format
*rt_format
= state
->fb
->render_targets
[0]->format
;
385 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
386 GLenum srcBlend
, dstBlend
;
387 enum wined3d_blend d3d_blend
;
389 /* According to the red book, GL_LINE_SMOOTH needs GL_BLEND with specific
390 * blending parameters to work. */
391 if (state
->render_states
[WINED3D_RS_ALPHABLENDENABLE
]
392 || state
->render_states
[WINED3D_RS_EDGEANTIALIAS
]
393 || state
->render_states
[WINED3D_RS_ANTIALIASEDLINEENABLE
])
395 /* Disable blending in all cases even without pixelshaders.
396 * With blending on we could face a big performance penalty.
397 * The d3d9 visual test confirms the behavior. */
398 if (context
->render_offscreen
&& !(rt_format
->flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
))
400 gl_info
->gl_ops
.gl
.p_glDisable(GL_BLEND
);
401 checkGLcall("glDisable GL_BLEND");
406 gl_info
->gl_ops
.gl
.p_glEnable(GL_BLEND
);
407 checkGLcall("glEnable GL_BLEND");
412 gl_info
->gl_ops
.gl
.p_glDisable(GL_BLEND
);
413 checkGLcall("glDisable GL_BLEND");
414 /* Nothing more to do - get out */
418 /* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
419 * source blending values which are still valid up to d3d9. They should
420 * not occur as dest blend values. */
421 d3d_blend
= state
->render_states
[WINED3D_RS_SRCBLEND
];
422 if (d3d_blend
== WINED3D_BLEND_BOTHSRCALPHA
)
424 srcBlend
= GL_SRC_ALPHA
;
425 dstBlend
= GL_ONE_MINUS_SRC_ALPHA
;
427 else if (d3d_blend
== WINED3D_BLEND_BOTHINVSRCALPHA
)
429 srcBlend
= GL_ONE_MINUS_SRC_ALPHA
;
430 dstBlend
= GL_SRC_ALPHA
;
434 srcBlend
= gl_blend_factor(d3d_blend
, rt_format
);
435 dstBlend
= gl_blend_factor(state
->render_states
[WINED3D_RS_DESTBLEND
], rt_format
);
438 if (state
->render_states
[WINED3D_RS_EDGEANTIALIAS
]
439 || state
->render_states
[WINED3D_RS_ANTIALIASEDLINEENABLE
])
441 gl_info
->gl_ops
.gl
.p_glEnable(GL_LINE_SMOOTH
);
442 checkGLcall("glEnable(GL_LINE_SMOOTH)");
443 if (srcBlend
!= GL_SRC_ALPHA
)
444 WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected src blending param.\n");
445 if (dstBlend
!= GL_ONE_MINUS_SRC_ALPHA
&& dstBlend
!= GL_ONE
)
446 WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected dst blending param.\n");
450 gl_info
->gl_ops
.gl
.p_glDisable(GL_LINE_SMOOTH
);
451 checkGLcall("glDisable(GL_LINE_SMOOTH)");
454 /* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
455 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_BLENDOP
)))
456 state_blendop(context
, state
, STATE_RENDER(WINED3D_RS_BLENDOPALPHA
));
458 if (state
->render_states
[WINED3D_RS_SEPARATEALPHABLENDENABLE
])
460 GLenum srcBlendAlpha
, dstBlendAlpha
;
462 /* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
463 if (!context
->gl_info
->supported
[EXT_BLEND_FUNC_SEPARATE
])
465 WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparate.\n");
469 /* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
470 * source blending values which are still valid up to d3d9. They should
471 * not occur as dest blend values. */
472 d3d_blend
= state
->render_states
[WINED3D_RS_SRCBLENDALPHA
];
473 if (d3d_blend
== WINED3D_BLEND_BOTHSRCALPHA
)
475 srcBlendAlpha
= GL_SRC_ALPHA
;
476 dstBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
478 else if (d3d_blend
== WINED3D_BLEND_BOTHINVSRCALPHA
)
480 srcBlendAlpha
= GL_ONE_MINUS_SRC_ALPHA
;
481 dstBlendAlpha
= GL_SRC_ALPHA
;
485 srcBlendAlpha
= gl_blend_factor(d3d_blend
, rt_format
);
486 dstBlendAlpha
= gl_blend_factor(state
->render_states
[WINED3D_RS_DESTBLENDALPHA
], rt_format
);
489 GL_EXTCALL(glBlendFuncSeparate(srcBlend
, dstBlend
, srcBlendAlpha
, dstBlendAlpha
));
490 checkGLcall("glBlendFuncSeparate");
494 TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend
, dstBlend
);
495 gl_info
->gl_ops
.gl
.p_glBlendFunc(srcBlend
, dstBlend
);
496 checkGLcall("glBlendFunc");
499 /* Colorkey fixup for stage 0 alphaop depends on
500 * WINED3D_RS_ALPHABLENDENABLE state, so it may need updating. */
501 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
])
502 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
505 static void state_blendfactor_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
507 WARN("Unsupported in local OpenGL implementation: glBlendColor.\n");
510 static void state_blendfactor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
512 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
515 TRACE("Setting blend factor to %#x.\n", state
->render_states
[WINED3D_RS_BLENDFACTOR
]);
517 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_BLENDFACTOR
], col
);
518 GL_EXTCALL(glBlendColor(col
[0], col
[1], col
[2], col
[3]));
519 checkGLcall("glBlendColor");
522 static void state_alpha(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
524 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
527 BOOL enable_ckey
= FALSE
;
529 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
531 /* Find out if the texture on the first stage has a ckey set. The alpha
532 * state func reads the texture settings, even though alpha and texture
533 * are not grouped together. This is to avoid making a huge alpha +
534 * texture + texture stage + ckey block due to the hardly used
535 * WINED3D_RS_COLORKEYENABLE state(which is d3d <= 3 only). The texture
536 * function will call alpha in case it finds some texture + colorkeyenable
537 * combination which needs extra care. */
538 if (state
->textures
[0] && (state
->textures
[0]->color_key_flags
& WINED3D_CKEY_SRC_BLT
))
541 if (enable_ckey
|| context
->last_was_ckey
)
542 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
543 context
->last_was_ckey
= enable_ckey
;
545 if (state
->render_states
[WINED3D_RS_ALPHATESTENABLE
]
546 || (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && enable_ckey
))
548 gl_info
->gl_ops
.gl
.p_glEnable(GL_ALPHA_TEST
);
549 checkGLcall("glEnable GL_ALPHA_TEST");
553 gl_info
->gl_ops
.gl
.p_glDisable(GL_ALPHA_TEST
);
554 checkGLcall("glDisable GL_ALPHA_TEST");
555 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
561 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && enable_ckey
)
563 glParm
= GL_NOTEQUAL
;
568 ref
= ((float)state
->render_states
[WINED3D_RS_ALPHAREF
]) / 255.0f
;
569 glParm
= wined3d_gl_compare_func(state
->render_states
[WINED3D_RS_ALPHAFUNC
]);
573 gl_info
->gl_ops
.gl
.p_glAlphaFunc(glParm
, ref
);
574 checkGLcall("glAlphaFunc");
578 void state_clipping(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
580 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
581 DWORD enable
= 0xffffffff;
582 DWORD disable
= 0x00000000;
584 if (use_vs(state
) && !context
->d3d_info
->vs_clipping
)
588 /* The OpenGL spec says that clipping planes are disabled when using
589 * shaders. Direct3D planes aren't, so that is an issue. The MacOS ATI
590 * driver keeps clipping planes activated with shaders in some
591 * conditions I got sick of tracking down. The shader state handler
592 * disables all clip planes because of that - don't do anything here
593 * and keep them disabled. */
594 if (state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
] && !warned
++)
595 FIXME("Clipping not supported with vertex shaders\n");
599 /* glEnable(GL_CLIP_PLANEx) doesn't apply to (ARB backend) vertex shaders.
600 * The enabled / disabled planes are hardcoded into the shader. Update the
601 * shader to update the enabled clipplanes. In case of fixed function, we
602 * need to update the clipping field from ffp_vertex_settings. */
603 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_VERTEX
;
605 /* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
606 * of already set values
609 /* If enabling / disabling all
610 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
612 if (state
->render_states
[WINED3D_RS_CLIPPING
])
614 enable
= state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
];
615 disable
= ~state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
];
619 disable
= 0xffffffff;
623 if (enable
& WINED3DCLIPPLANE0
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE0
);
624 if (enable
& WINED3DCLIPPLANE1
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE1
);
625 if (enable
& WINED3DCLIPPLANE2
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE2
);
626 if (enable
& WINED3DCLIPPLANE3
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE3
);
627 if (enable
& WINED3DCLIPPLANE4
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE4
);
628 if (enable
& WINED3DCLIPPLANE5
) gl_info
->gl_ops
.gl
.p_glEnable(GL_CLIP_PLANE5
);
629 checkGLcall("clip plane enable");
631 if (disable
& WINED3DCLIPPLANE0
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE0
);
632 if (disable
& WINED3DCLIPPLANE1
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE1
);
633 if (disable
& WINED3DCLIPPLANE2
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE2
);
634 if (disable
& WINED3DCLIPPLANE3
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE3
);
635 if (disable
& WINED3DCLIPPLANE4
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE4
);
636 if (disable
& WINED3DCLIPPLANE5
) gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE5
);
637 checkGLcall("clip plane disable");
640 void state_specularenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
642 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
643 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
644 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
645 * specular color. This is wrong:
646 * Separate specular color means the specular colour is maintained separately, whereas
647 * single color means it is merged in. However in both cases they are being used to
649 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
650 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
654 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
655 * Instead, we need to setup the FinalCombiner properly.
657 * The default setup for the FinalCombiner is:
659 * <variable> <input> <mapping> <usage>
660 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
661 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
662 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
663 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
664 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
665 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
666 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
668 * That's pretty much fine as it is, except for variable B, which needs to take
669 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
670 * whether WINED3D_RS_SPECULARENABLE is enabled or not.
673 TRACE("Setting specular enable state and materials\n");
674 if (state
->render_states
[WINED3D_RS_SPECULARENABLE
])
676 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&state
->material
.specular
);
677 checkGLcall("glMaterialfv");
679 if (state
->material
.power
> gl_info
->limits
.shininess
)
681 /* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
682 * and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
683 * allows bigger values. If the extension is supported, gl_info->limits.shininess contains the
684 * value reported by the extension, otherwise 128. For values > gl_info->limits.shininess clamp
685 * them, it should be safe to do so without major visual distortions.
687 WARN("Material power = %.8e, limit %.8e\n", state
->material
.power
, gl_info
->limits
.shininess
);
688 gl_info
->gl_ops
.gl
.p_glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, gl_info
->limits
.shininess
);
692 gl_info
->gl_ops
.gl
.p_glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, state
->material
.power
);
694 checkGLcall("glMaterialf(GL_SHININESS)");
696 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
697 gl_info
->gl_ops
.gl
.p_glEnable(GL_COLOR_SUM_EXT
);
699 TRACE("Specular colors cannot be enabled in this version of opengl\n");
700 checkGLcall("glEnable(GL_COLOR_SUM)");
702 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
704 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_PLUS_SECONDARY_COLOR_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
705 checkGLcall("glFinalCombinerInputNV()");
708 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
710 /* for the case of enabled lighting: */
711 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
712 checkGLcall("glMaterialfv");
714 /* for the case of disabled lighting: */
715 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
716 gl_info
->gl_ops
.gl
.p_glDisable(GL_COLOR_SUM_EXT
);
718 TRACE("Specular colors cannot be disabled in this version of opengl\n");
719 checkGLcall("glDisable(GL_COLOR_SUM)");
721 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
723 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
724 checkGLcall("glFinalCombinerInputNV()");
728 TRACE("diffuse {%.8e, %.8e, %.8e, %.8e}\n",
729 state
->material
.diffuse
.r
, state
->material
.diffuse
.g
,
730 state
->material
.diffuse
.b
, state
->material
.diffuse
.a
);
731 TRACE("ambient {%.8e, %.8e, %.8e, %.8e}\n",
732 state
->material
.ambient
.r
, state
->material
.ambient
.g
,
733 state
->material
.ambient
.b
, state
->material
.ambient
.a
);
734 TRACE("specular {%.8e, %.8e, %.8e, %.8e}\n",
735 state
->material
.specular
.r
, state
->material
.specular
.g
,
736 state
->material
.specular
.b
, state
->material
.specular
.a
);
737 TRACE("emissive {%.8e, %.8e, %.8e, %.8e}\n",
738 state
->material
.emissive
.r
, state
->material
.emissive
.g
,
739 state
->material
.emissive
.b
, state
->material
.emissive
.a
);
741 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
742 checkGLcall("glMaterialfv(GL_AMBIENT)");
743 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
744 checkGLcall("glMaterialfv(GL_DIFFUSE)");
745 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&state
->material
.emissive
);
746 checkGLcall("glMaterialfv(GL_EMISSION)");
749 static void state_texfactor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
751 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
754 /* Note the texture color applies to all textures whereas
755 * GL_TEXTURE_ENV_COLOR applies to active only. */
757 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_TEXTUREFACTOR
], col
);
759 /* And now the default texture color as well */
760 for (i
= 0; i
< context
->d3d_info
->limits
.ffp_blend_stages
; ++i
)
762 /* Note the WINED3D_RS value applies to all textures, but GL has one
763 * per texture, so apply it now ready to be used! */
764 context_active_texture(context
, gl_info
, i
);
766 gl_info
->gl_ops
.gl
.p_glTexEnvfv(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_COLOR
, &col
[0]);
767 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
771 static void renderstate_stencil_twosided(struct wined3d_context
*context
, GLint face
,
772 GLint func
, GLint ref
, GLuint mask
, GLint stencilFail
, GLint depthFail
, GLint stencilPass
)
774 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
776 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
777 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
778 GL_EXTCALL(glActiveStencilFaceEXT(face
));
779 checkGLcall("glActiveStencilFaceEXT(...)");
780 gl_info
->gl_ops
.gl
.p_glStencilFunc(func
, ref
, mask
);
781 checkGLcall("glStencilFunc(...)");
782 gl_info
->gl_ops
.gl
.p_glStencilOp(stencilFail
, depthFail
, stencilPass
);
783 checkGLcall("glStencilOp(...)");
786 static GLenum
gl_stencil_op(enum wined3d_stencil_op op
)
790 case WINED3D_STENCIL_OP_KEEP
:
792 case WINED3D_STENCIL_OP_ZERO
:
794 case WINED3D_STENCIL_OP_REPLACE
:
796 case WINED3D_STENCIL_OP_INCR_SAT
:
798 case WINED3D_STENCIL_OP_DECR_SAT
:
800 case WINED3D_STENCIL_OP_INVERT
:
802 case WINED3D_STENCIL_OP_INCR
:
803 return GL_INCR_WRAP_EXT
;
804 case WINED3D_STENCIL_OP_DECR
:
805 return GL_DECR_WRAP_EXT
;
807 FIXME("Unrecognized stencil op %#x.\n", op
);
812 static void state_stencil(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
814 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
815 DWORD onesided_enable
;
816 DWORD twosided_enable
;
822 GLint stencilFail_ccw
;
824 GLint stencilPass_ccw
;
828 /* No stencil test without a stencil buffer. */
829 if (!state
->fb
->depth_stencil
)
831 gl_info
->gl_ops
.gl
.p_glDisable(GL_STENCIL_TEST
);
832 checkGLcall("glDisable GL_STENCIL_TEST");
836 onesided_enable
= state
->render_states
[WINED3D_RS_STENCILENABLE
];
837 twosided_enable
= state
->render_states
[WINED3D_RS_TWOSIDEDSTENCILMODE
];
838 if (!(func
= wined3d_gl_compare_func(state
->render_states
[WINED3D_RS_STENCILFUNC
])))
840 if (!(func_ccw
= wined3d_gl_compare_func(state
->render_states
[WINED3D_RS_CCW_STENCILFUNC
])))
841 func_ccw
= GL_ALWAYS
;
842 ref
= state
->render_states
[WINED3D_RS_STENCILREF
];
843 mask
= state
->render_states
[WINED3D_RS_STENCILMASK
];
844 stencilFail
= gl_stencil_op(state
->render_states
[WINED3D_RS_STENCILFAIL
]);
845 depthFail
= gl_stencil_op(state
->render_states
[WINED3D_RS_STENCILZFAIL
]);
846 stencilPass
= gl_stencil_op(state
->render_states
[WINED3D_RS_STENCILPASS
]);
847 stencilFail_ccw
= gl_stencil_op(state
->render_states
[WINED3D_RS_CCW_STENCILFAIL
]);
848 depthFail_ccw
= gl_stencil_op(state
->render_states
[WINED3D_RS_CCW_STENCILZFAIL
]);
849 stencilPass_ccw
= gl_stencil_op(state
->render_states
[WINED3D_RS_CCW_STENCILPASS
]);
851 TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
852 "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
853 "GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
854 onesided_enable
, twosided_enable
, ref
, mask
,
855 func
, stencilFail
, depthFail
, stencilPass
,
856 func_ccw
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
858 if (twosided_enable
&& onesided_enable
)
860 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST
);
861 checkGLcall("glEnable GL_STENCIL_TEST");
863 if (gl_info
->supported
[WINED3D_GL_VERSION_2_0
])
865 GL_EXTCALL(glStencilFuncSeparate(GL_FRONT
, func
, ref
, mask
));
866 GL_EXTCALL(glStencilOpSeparate(GL_FRONT
, stencilFail
, depthFail
, stencilPass
));
867 GL_EXTCALL(glStencilFuncSeparate(GL_BACK
, func_ccw
, ref
, mask
));
868 GL_EXTCALL(glStencilOpSeparate(GL_BACK
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
));
869 checkGLcall("setting two sided stencil state");
871 else if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
873 /* Apply back first, then front. This function calls glActiveStencilFaceEXT,
874 * which has an effect on the code below too. If we apply the front face
875 * afterwards, we are sure that the active stencil face is set to front,
876 * and other stencil functions which do not use two sided stencil do not have
879 renderstate_stencil_twosided(context
, GL_BACK
,
880 func_ccw
, ref
, mask
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
);
881 renderstate_stencil_twosided(context
, GL_FRONT
,
882 func
, ref
, mask
, stencilFail
, depthFail
, stencilPass
);
884 else if (gl_info
->supported
[ATI_SEPARATE_STENCIL
])
886 GL_EXTCALL(glStencilFuncSeparateATI(func
, func_ccw
, ref
, mask
));
887 checkGLcall("glStencilFuncSeparateATI(...)");
888 GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT
, stencilFail
, depthFail
, stencilPass
));
889 checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
890 GL_EXTCALL(glStencilOpSeparateATI(GL_BACK
, stencilFail_ccw
, depthFail_ccw
, stencilPass_ccw
));
891 checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
895 ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
898 else if(onesided_enable
)
900 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
902 gl_info
->gl_ops
.gl
.p_glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
903 checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
906 /* This code disables the ATI extension as well, since the standard stencil functions are equal
907 * to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
909 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST
);
910 checkGLcall("glEnable GL_STENCIL_TEST");
911 gl_info
->gl_ops
.gl
.p_glStencilFunc(func
, ref
, mask
);
912 checkGLcall("glStencilFunc(...)");
913 gl_info
->gl_ops
.gl
.p_glStencilOp(stencilFail
, depthFail
, stencilPass
);
914 checkGLcall("glStencilOp(...)");
918 gl_info
->gl_ops
.gl
.p_glDisable(GL_STENCIL_TEST
);
919 checkGLcall("glDisable GL_STENCIL_TEST");
923 static void state_stencilwrite2s(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
925 DWORD mask
= state
->fb
->depth_stencil
? state
->render_states
[WINED3D_RS_STENCILWRITEMASK
] : 0;
926 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
928 GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK
));
929 checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
930 gl_info
->gl_ops
.gl
.p_glStencilMask(mask
);
931 checkGLcall("glStencilMask");
932 GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT
));
933 checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
934 gl_info
->gl_ops
.gl
.p_glStencilMask(mask
);
937 static void state_stencilwrite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
939 DWORD mask
= state
->fb
->depth_stencil
? state
->render_states
[WINED3D_RS_STENCILWRITEMASK
] : 0;
940 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
942 gl_info
->gl_ops
.gl
.p_glStencilMask(mask
);
943 checkGLcall("glStencilMask");
946 static void state_fog_vertexpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
948 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
950 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
952 if (!state
->render_states
[WINED3D_RS_FOGENABLE
])
955 /* Table fog on: Never use fog coords, and use per-fragment fog */
956 if (state
->render_states
[WINED3D_RS_FOGTABLEMODE
] != WINED3D_FOG_NONE
)
958 gl_info
->gl_ops
.gl
.p_glHint(GL_FOG_HINT
, GL_NICEST
);
959 if (context
->fog_coord
)
961 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
962 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
963 context
->fog_coord
= FALSE
;
966 /* Range fog is only used with per-vertex fog in d3d */
967 if (gl_info
->supported
[NV_FOG_DISTANCE
])
969 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
970 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
975 /* Otherwise use per-vertex fog in any case */
976 gl_info
->gl_ops
.gl
.p_glHint(GL_FOG_HINT
, GL_FASTEST
);
978 if (state
->render_states
[WINED3D_RS_FOGVERTEXMODE
] == WINED3D_FOG_NONE
|| context
->last_was_rhw
)
980 /* No fog at all, or transformed vertices: Use fog coord */
981 if (!context
->fog_coord
)
983 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FOG_COORDINATE_EXT
);
984 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
985 context
->fog_coord
= TRUE
;
990 /* Otherwise, use the fragment depth */
991 if (context
->fog_coord
)
993 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
994 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
995 context
->fog_coord
= FALSE
;
998 if (state
->render_states
[WINED3D_RS_RANGEFOGENABLE
])
1000 if (gl_info
->supported
[NV_FOG_DISTANCE
])
1002 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_RADIAL_NV
);
1003 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
1007 WARN("Range fog enabled, but not supported by this GL implementation.\n");
1010 else if (gl_info
->supported
[NV_FOG_DISTANCE
])
1012 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
1013 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1018 void state_fogstartend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1020 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1021 float fogstart
, fogend
;
1027 switch(context
->fog_source
) {
1033 case FOGSOURCE_COORD
:
1039 tmpvalue
.d
= state
->render_states
[WINED3D_RS_FOGSTART
];
1040 fogstart
= tmpvalue
.f
;
1041 tmpvalue
.d
= state
->render_states
[WINED3D_RS_FOGEND
];
1042 fogend
= tmpvalue
.f
;
1043 /* Special handling for fogstart == fogend. In d3d with vertex
1044 * fog, everything is fogged. With table fog, everything with
1045 * fog_coord < fog_start is unfogged, and fog_coord > fog_start
1046 * is fogged. Windows drivers disagree when fog_coord == fog_start. */
1047 if (state
->render_states
[WINED3D_RS_FOGTABLEMODE
] == WINED3D_FOG_NONE
1048 && fogstart
== fogend
)
1050 fogstart
= -INFINITY
;
1056 /* This should not happen.context->fog_source is set in wined3d, not the app.
1057 * Still this is needed to make the compiler happy
1059 ERR("Unexpected fog coordinate source\n");
1064 gl_info
->gl_ops
.gl
.p_glFogf(GL_FOG_START
, fogstart
);
1065 checkGLcall("glFogf(GL_FOG_START, fogstart)");
1066 TRACE("Fog Start == %f\n", fogstart
);
1068 gl_info
->gl_ops
.gl
.p_glFogf(GL_FOG_END
, fogend
);
1069 checkGLcall("glFogf(GL_FOG_END, fogend)");
1070 TRACE("Fog End == %f\n", fogend
);
1073 void state_fog_fragpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1075 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1076 enum fogsource new_source
;
1077 DWORD fogstart
= state
->render_states
[WINED3D_RS_FOGSTART
];
1078 DWORD fogend
= state
->render_states
[WINED3D_RS_FOGEND
];
1080 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
1082 if (!state
->render_states
[WINED3D_RS_FOGENABLE
])
1084 /* No fog? Disable it, and we're done :-) */
1085 glDisableWINE(GL_FOG
);
1086 checkGLcall("glDisable GL_FOG");
1092 * With fixed function vertex processing, Direct3D knows 2 different fog input sources.
1093 * It can use the Z value of the vertex, or the alpha component of the specular color.
1094 * This depends on the fog vertex, fog table and the vertex declaration. If the Z value
1095 * is used, fogstart, fogend and the equation type are used, otherwise linear fog with
1096 * start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
1098 * FOGTABLEMODE != NONE:
1099 * The Z value is used, with the equation specified, no matter what vertex type.
1101 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
1102 * Per vertex fog is calculated using the specified fog equation and the parameters
1104 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
1105 * FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
1106 * Linear fog with start = 255.0, end = 0.0, input comes from the specular color
1109 * Rules for vertex fog with shaders:
1111 * When mixing fixed function functionality with the programmable pipeline, D3D expects
1112 * the fog computation to happen during transformation while openGL expects it to happen
1113 * during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
1114 * the pixel shader while openGL always expects the pixel shader to handle the blending.
1115 * To solve this problem, WineD3D does:
1116 * 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
1118 * and 2) disables the fog computation (in either the fixed function or programmable
1119 * rasterizer) if using a vertex program.
1121 * D3D shaders can provide an explicit fog coordinate. This fog coordinate is used with
1122 * D3DRS_FOGTABLEMODE==D3DFOG_NONE. The FOGVERTEXMODE is ignored, d3d always uses linear
1123 * fog with start=1.0 and end=0.0 in this case. This is similar to fog coordinates in
1124 * the specular color, a vertex shader counts as pretransformed geometry in this case.
1125 * There are some GL differences between specular fog coords and vertex shaders though.
1127 * With table fog the vertex shader fog coordinate is ignored.
1129 * If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
1133 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
1134 * the system will apply only pixel(=table) fog effects."
1136 if (state
->render_states
[WINED3D_RS_FOGTABLEMODE
] == WINED3D_FOG_NONE
)
1140 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1141 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1142 new_source
= FOGSOURCE_VS
;
1146 switch (state
->render_states
[WINED3D_RS_FOGVERTEXMODE
])
1148 /* If processed vertices are used, fall through to the NONE case */
1149 case WINED3D_FOG_EXP
:
1150 if (!context
->last_was_rhw
)
1152 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP
);
1153 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1154 new_source
= FOGSOURCE_FFP
;
1159 case WINED3D_FOG_EXP2
:
1160 if (!context
->last_was_rhw
)
1162 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP2
);
1163 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1164 new_source
= FOGSOURCE_FFP
;
1169 case WINED3D_FOG_LINEAR
:
1170 if (!context
->last_was_rhw
)
1172 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1173 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1174 new_source
= FOGSOURCE_FFP
;
1179 case WINED3D_FOG_NONE
:
1180 /* Both are none? According to msdn the alpha channel of the specular
1181 * color contains a fog factor. Set it in drawStridedSlow.
1182 * Same happens with Vertexfog on transformed vertices
1184 new_source
= FOGSOURCE_COORD
;
1185 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1186 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1190 FIXME("Unexpected WINED3D_RS_FOGVERTEXMODE %#x.\n",
1191 state
->render_states
[WINED3D_RS_FOGVERTEXMODE
]);
1192 new_source
= FOGSOURCE_FFP
; /* Make the compiler happy */
1196 new_source
= FOGSOURCE_FFP
;
1198 switch (state
->render_states
[WINED3D_RS_FOGTABLEMODE
])
1200 case WINED3D_FOG_EXP
:
1201 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP
);
1202 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1205 case WINED3D_FOG_EXP2
:
1206 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP2
);
1207 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1210 case WINED3D_FOG_LINEAR
:
1211 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1212 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1215 case WINED3D_FOG_NONE
: /* Won't happen */
1217 FIXME("Unexpected WINED3D_RS_FOGTABLEMODE %#x.\n",
1218 state
->render_states
[WINED3D_RS_FOGTABLEMODE
]);
1222 glEnableWINE(GL_FOG
);
1223 checkGLcall("glEnable GL_FOG");
1224 if (new_source
!= context
->fog_source
|| fogstart
== fogend
)
1226 context
->fog_source
= new_source
;
1227 state_fogstartend(context
, state
, STATE_RENDER(WINED3D_RS_FOGSTART
));
1231 void state_fogcolor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1233 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1236 D3DCOLORTOGLFLOAT4(state
->render_states
[WINED3D_RS_FOGCOLOR
], col
);
1237 gl_info
->gl_ops
.gl
.p_glFogfv(GL_FOG_COLOR
, &col
[0]);
1238 checkGLcall("glFog GL_FOG_COLOR");
1241 void state_fogdensity(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1243 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1249 tmpvalue
.d
= state
->render_states
[WINED3D_RS_FOGDENSITY
];
1250 gl_info
->gl_ops
.gl
.p_glFogfv(GL_FOG_DENSITY
, &tmpvalue
.f
);
1251 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
1254 static void state_colormat(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1256 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1259 /* Depends on the decoded vertex declaration to read the existence of diffuse data.
1260 * The vertex declaration will call this function if the fixed function pipeline is used.
1263 if(isStateDirty(context
, STATE_VDECL
)) {
1267 context
->num_untracked_materials
= 0;
1268 if ((context
->stream_info
.use_map
& (1 << WINED3D_FFP_DIFFUSE
))
1269 && state
->render_states
[WINED3D_RS_COLORVERTEX
])
1271 TRACE("diff %d, amb %d, emis %d, spec %d\n",
1272 state
->render_states
[WINED3D_RS_DIFFUSEMATERIALSOURCE
],
1273 state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
],
1274 state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
],
1275 state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
]);
1277 if (state
->render_states
[WINED3D_RS_DIFFUSEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1279 if (state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1280 Parm
= GL_AMBIENT_AND_DIFFUSE
;
1283 if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1285 context
->untracked_materials
[context
->num_untracked_materials
] = GL_EMISSION
;
1286 context
->num_untracked_materials
++;
1288 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1290 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1291 context
->num_untracked_materials
++;
1294 else if (state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1297 if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1299 context
->untracked_materials
[context
->num_untracked_materials
] = GL_EMISSION
;
1300 context
->num_untracked_materials
++;
1302 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1304 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1305 context
->num_untracked_materials
++;
1308 else if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1311 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1313 context
->untracked_materials
[context
->num_untracked_materials
] = GL_SPECULAR
;
1314 context
->num_untracked_materials
++;
1317 else if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1323 /* Nothing changed, return. */
1324 if (Parm
== context
->tracking_parm
) return;
1328 gl_info
->gl_ops
.gl
.p_glDisable(GL_COLOR_MATERIAL
);
1329 checkGLcall("glDisable GL_COLOR_MATERIAL");
1333 gl_info
->gl_ops
.gl
.p_glColorMaterial(GL_FRONT_AND_BACK
, Parm
);
1334 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1335 gl_info
->gl_ops
.gl
.p_glEnable(GL_COLOR_MATERIAL
);
1336 checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1339 /* Apparently calls to glMaterialfv are ignored for properties we're
1340 * tracking with glColorMaterial, so apply those here. */
1341 switch (context
->tracking_parm
)
1343 case GL_AMBIENT_AND_DIFFUSE
:
1344 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
1345 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
1346 checkGLcall("glMaterialfv");
1350 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
1351 checkGLcall("glMaterialfv");
1355 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
1356 checkGLcall("glMaterialfv");
1360 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&state
->material
.emissive
);
1361 checkGLcall("glMaterialfv");
1365 /* Only change material color if specular is enabled, otherwise it is set to black */
1366 if (state
->render_states
[WINED3D_RS_SPECULARENABLE
])
1368 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&state
->material
.specular
);
1369 checkGLcall("glMaterialfv");
1373 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
1374 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
1375 checkGLcall("glMaterialfv");
1380 context
->tracking_parm
= Parm
;
1383 static void state_linepattern(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1385 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1389 struct wined3d_line_pattern lp
;
1391 tmppattern
.d
= state
->render_states
[WINED3D_RS_LINEPATTERN
];
1393 TRACE("Line pattern: repeat %d bits %x.\n", tmppattern
.lp
.repeat_factor
, tmppattern
.lp
.line_pattern
);
1395 if (tmppattern
.lp
.repeat_factor
)
1397 gl_info
->gl_ops
.gl
.p_glLineStipple(tmppattern
.lp
.repeat_factor
, tmppattern
.lp
.line_pattern
);
1398 checkGLcall("glLineStipple(repeat, linepattern)");
1399 gl_info
->gl_ops
.gl
.p_glEnable(GL_LINE_STIPPLE
);
1400 checkGLcall("glEnable(GL_LINE_STIPPLE);");
1404 gl_info
->gl_ops
.gl
.p_glDisable(GL_LINE_STIPPLE
);
1405 checkGLcall("glDisable(GL_LINE_STIPPLE);");
1409 static void state_normalize(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1411 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1413 if (isStateDirty(context
, STATE_VDECL
))
1416 /* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
1417 * from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
1418 * by zero and is not properly defined in opengl, so avoid it
1420 if (state
->render_states
[WINED3D_RS_NORMALIZENORMALS
]
1421 && (context
->stream_info
.use_map
& (1 << WINED3D_FFP_NORMAL
)))
1423 gl_info
->gl_ops
.gl
.p_glEnable(GL_NORMALIZE
);
1424 checkGLcall("glEnable(GL_NORMALIZE);");
1428 gl_info
->gl_ops
.gl
.p_glDisable(GL_NORMALIZE
);
1429 checkGLcall("glDisable(GL_NORMALIZE);");
1433 void state_psizemin_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1440 tmpvalue
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MIN
];
1441 if (tmpvalue
.f
!= 1.0f
)
1443 FIXME("WINED3D_RS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue
.f
);
1445 tmpvalue
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MAX
];
1446 if (tmpvalue
.f
!= 64.0f
)
1448 FIXME("WINED3D_RS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue
.f
);
1453 void state_psizemin_ext(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1455 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1462 min
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MIN
];
1463 max
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MAX
];
1465 /* Max point size trumps min point size */
1470 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MIN_EXT
, min
.f
);
1471 checkGLcall("glPointParameterfEXT(...)");
1472 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MAX_EXT
, max
.f
);
1473 checkGLcall("glPointParameterfEXT(...)");
1476 void state_psizemin_arb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1478 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1485 min
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MIN
];
1486 max
.d
= state
->render_states
[WINED3D_RS_POINTSIZE_MAX
];
1488 /* Max point size trumps min point size */
1493 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MIN_ARB
, min
.f
);
1494 checkGLcall("glPointParameterfARB(...)");
1495 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MAX_ARB
, max
.f
);
1496 checkGLcall("glPointParameterfARB(...)");
1499 void state_pscale(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1501 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1502 /* TODO: Group this with the viewport */
1504 * POINTSCALEENABLE controls how point size value is treated. If set to
1505 * true, the point size is scaled with respect to height of viewport.
1506 * When set to false point size is in pixels.
1509 /* Default values */
1510 GLfloat att
[3] = {1.0f
, 0.0f
, 0.0f
};
1514 } pointSize
, A
, B
, C
;
1516 pointSize
.d
= state
->render_states
[WINED3D_RS_POINTSIZE
];
1517 A
.d
= state
->render_states
[WINED3D_RS_POINTSCALE_A
];
1518 B
.d
= state
->render_states
[WINED3D_RS_POINTSCALE_B
];
1519 C
.d
= state
->render_states
[WINED3D_RS_POINTSCALE_C
];
1521 if (state
->render_states
[WINED3D_RS_POINTSCALEENABLE
])
1523 DWORD h
= state
->viewport
.height
;
1524 GLfloat scaleFactor
;
1526 if (pointSize
.f
< gl_info
->limits
.pointsize_min
)
1528 /* Minimum valid point size for OpenGL is driver specific. For Direct3D it is
1529 * 0.0f. This means that OpenGL will clamp really small point sizes to the
1530 * driver minimum. To correct for this we need to multiply by the scale factor when sizes
1531 * are less than 1.0f. scale_factor = 1.0f / point_size.
1533 scaleFactor
= pointSize
.f
/ gl_info
->limits
.pointsize_min
;
1534 /* Clamp the point size, don't rely on the driver to do it. MacOS says min point size
1535 * is 1.0, but then accepts points below that and draws too small points
1537 pointSize
.f
= gl_info
->limits
.pointsize_min
;
1539 else if(pointSize
.f
> gl_info
->limits
.pointsize_max
)
1541 /* gl already scales the input to glPointSize,
1542 * d3d scales the result after the point size scale.
1543 * If the point size is bigger than the max size, use the
1544 * scaling to scale it bigger, and set the gl point size to max
1546 scaleFactor
= pointSize
.f
/ gl_info
->limits
.pointsize_max
;
1547 TRACE("scale: %f\n", scaleFactor
);
1548 pointSize
.f
= gl_info
->limits
.pointsize_max
;
1552 scaleFactor
= powf(h
* scaleFactor
, 2);
1554 att
[0] = A
.f
/ scaleFactor
;
1555 att
[1] = B
.f
/ scaleFactor
;
1556 att
[2] = C
.f
/ scaleFactor
;
1559 if (gl_info
->supported
[ARB_POINT_PARAMETERS
])
1561 GL_EXTCALL(glPointParameterfvARB
)(GL_POINT_DISTANCE_ATTENUATION_ARB
, att
);
1562 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
1564 else if (gl_info
->supported
[EXT_POINT_PARAMETERS
])
1566 GL_EXTCALL(glPointParameterfvEXT
)(GL_DISTANCE_ATTENUATION_EXT
, att
);
1567 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
1569 else if (state
->render_states
[WINED3D_RS_POINTSCALEENABLE
])
1571 WARN("POINT_PARAMETERS not supported in this version of opengl\n");
1574 gl_info
->gl_ops
.gl
.p_glPointSize(pointSize
.f
);
1575 checkGLcall("glPointSize(...);");
1578 static void state_debug_monitor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1580 WARN("token: %#x.\n", state
->render_states
[WINED3D_RS_DEBUGMONITORTOKEN
]);
1583 static void state_colorwrite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1585 DWORD mask0
= state
->render_states
[WINED3D_RS_COLORWRITEENABLE
];
1586 DWORD mask1
= state
->render_states
[WINED3D_RS_COLORWRITEENABLE1
];
1587 DWORD mask2
= state
->render_states
[WINED3D_RS_COLORWRITEENABLE2
];
1588 DWORD mask3
= state
->render_states
[WINED3D_RS_COLORWRITEENABLE3
];
1589 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1591 TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
1592 mask0
& WINED3DCOLORWRITEENABLE_RED
? 1 : 0,
1593 mask0
& WINED3DCOLORWRITEENABLE_GREEN
? 1 : 0,
1594 mask0
& WINED3DCOLORWRITEENABLE_BLUE
? 1 : 0,
1595 mask0
& WINED3DCOLORWRITEENABLE_ALPHA
? 1 : 0);
1596 gl_info
->gl_ops
.gl
.p_glColorMask(mask0
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
1597 mask0
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
1598 mask0
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
1599 mask0
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
);
1600 checkGLcall("glColorMask(...)");
1602 if (!((mask1
== mask0
&& mask2
== mask0
&& mask3
== mask0
)
1603 || (mask1
== 0xf && mask2
== 0xf && mask3
== 0xf)))
1605 FIXME("WINED3D_RS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
1606 mask0
, mask1
, mask2
, mask3
);
1607 FIXME("Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n");
1611 static void set_color_mask(const struct wined3d_gl_info
*gl_info
, UINT index
, DWORD mask
)
1613 GL_EXTCALL(glColorMaski(index
,
1614 mask
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
1615 mask
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
1616 mask
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
1617 mask
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
));
1618 checkGLcall("glColorMaski");
1621 static void state_colorwrite0(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1623 set_color_mask(context
->gl_info
, 0, state
->render_states
[WINED3D_RS_COLORWRITEENABLE
]);
1626 static void state_colorwrite1(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1628 set_color_mask(context
->gl_info
, 1, state
->render_states
[WINED3D_RS_COLORWRITEENABLE1
]);
1631 static void state_colorwrite2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1633 set_color_mask(context
->gl_info
, 2, state
->render_states
[WINED3D_RS_COLORWRITEENABLE2
]);
1636 static void state_colorwrite3(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1638 set_color_mask(context
->gl_info
, 3, state
->render_states
[WINED3D_RS_COLORWRITEENABLE3
]);
1641 static void state_localviewer(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1643 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1645 if (state
->render_states
[WINED3D_RS_LOCALVIEWER
])
1647 gl_info
->gl_ops
.gl
.p_glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 1);
1648 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1652 gl_info
->gl_ops
.gl
.p_glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 0);
1653 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1657 static void state_lastpixel(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1659 if (state
->render_states
[WINED3D_RS_LASTPIXEL
])
1661 TRACE("Last Pixel Drawing Enabled\n");
1667 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1670 TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1675 void state_pointsprite_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1679 /* TODO: NV_POINT_SPRITE */
1680 if (!warned
&& state
->render_states
[WINED3D_RS_POINTSPRITEENABLE
])
1682 /* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
1683 FIXME("Point sprites not supported\n");
1688 void state_pointsprite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1690 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1692 if (state
->render_states
[WINED3D_RS_POINTSPRITEENABLE
])
1694 gl_info
->gl_ops
.gl
.p_glEnable(GL_POINT_SPRITE_ARB
);
1695 checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1699 gl_info
->gl_ops
.gl
.p_glDisable(GL_POINT_SPRITE_ARB
);
1700 checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1704 static void state_wrap(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1706 if (state
->render_states
[WINED3D_RS_WRAP0
]
1707 || state
->render_states
[WINED3D_RS_WRAP1
]
1708 || state
->render_states
[WINED3D_RS_WRAP2
]
1709 || state
->render_states
[WINED3D_RS_WRAP3
]
1710 || state
->render_states
[WINED3D_RS_WRAP4
]
1711 || state
->render_states
[WINED3D_RS_WRAP5
]
1712 || state
->render_states
[WINED3D_RS_WRAP6
]
1713 || state
->render_states
[WINED3D_RS_WRAP7
]
1714 || state
->render_states
[WINED3D_RS_WRAP8
]
1715 || state
->render_states
[WINED3D_RS_WRAP9
]
1716 || state
->render_states
[WINED3D_RS_WRAP10
]
1717 || state
->render_states
[WINED3D_RS_WRAP11
]
1718 || state
->render_states
[WINED3D_RS_WRAP12
]
1719 || state
->render_states
[WINED3D_RS_WRAP13
]
1720 || state
->render_states
[WINED3D_RS_WRAP14
]
1721 || state
->render_states
[WINED3D_RS_WRAP15
])
1722 FIXME("(WINED3D_RS_WRAP0) Texture wrapping not yet supported.\n");
1725 static void state_msaa_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1727 if (state
->render_states
[WINED3D_RS_MULTISAMPLEANTIALIAS
])
1728 WARN("Multisample antialiasing not supported by GL.\n");
1731 static void state_msaa(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1733 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1735 if (state
->render_states
[WINED3D_RS_MULTISAMPLEANTIALIAS
])
1737 gl_info
->gl_ops
.gl
.p_glEnable(GL_MULTISAMPLE_ARB
);
1738 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1742 gl_info
->gl_ops
.gl
.p_glDisable(GL_MULTISAMPLE_ARB
);
1743 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1747 static void state_scissor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1749 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1751 if (state
->render_states
[WINED3D_RS_SCISSORTESTENABLE
])
1753 gl_info
->gl_ops
.gl
.p_glEnable(GL_SCISSOR_TEST
);
1754 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1758 gl_info
->gl_ops
.gl
.p_glDisable(GL_SCISSOR_TEST
);
1759 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1763 /* The Direct3D depth bias is specified in normalized depth coordinates. In
1764 * OpenGL the bias is specified in units of "the smallest value that is
1765 * guaranteed to produce a resolvable offset for a given implementation". To
1766 * convert from D3D to GL we need to divide the D3D depth bias by that value.
1767 * There's no practical way to retrieve that value from a given GL
1768 * implementation, but the D3D application has essentially the same problem,
1769 * which makes a guess of the depth buffer format's highest possible value a
1770 * reasonable guess. Note that SLOPESCALEDEPTHBIAS is a scaling factor for the
1771 * depth slope, and doesn't need to be scaled. */
1772 static void state_depthbias(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1774 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1776 if (state
->render_states
[WINED3D_RS_SLOPESCALEDEPTHBIAS
]
1777 || state
->render_states
[WINED3D_RS_DEPTHBIAS
])
1779 const struct wined3d_rendertarget_view
*depth
= state
->fb
->depth_stencil
;
1786 } scale_bias
, const_bias
;
1788 scale_bias
.d
= state
->render_states
[WINED3D_RS_SLOPESCALEDEPTHBIAS
];
1789 const_bias
.d
= state
->render_states
[WINED3D_RS_DEPTHBIAS
];
1791 gl_info
->gl_ops
.gl
.p_glEnable(GL_POLYGON_OFFSET_FILL
);
1792 checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
1794 if (context
->swapchain
->device
->wined3d
->flags
& WINED3D_LEGACY_DEPTH_BIAS
)
1796 float bias
= -(float)const_bias
.d
;
1797 gl_info
->gl_ops
.gl
.p_glPolygonOffset(bias
, bias
);
1798 checkGLcall("glPolygonOffset");
1804 const struct wined3d_format
*fmt
= depth
->format
;
1805 scale
= powf(2, fmt
->depth_size
) - 1;
1806 TRACE("Depth format %s, using depthbias scale of %.8e.\n",
1807 debug_d3dformat(fmt
->id
), scale
);
1811 /* The context manager will reapply this state on a depth stencil change */
1812 TRACE("No depth stencil, using depthbias scale of 0.0.\n");
1816 gl_info
->gl_ops
.gl
.p_glPolygonOffset(scale_bias
.f
, const_bias
.f
* scale
);
1817 checkGLcall("glPolygonOffset(...)");
1822 gl_info
->gl_ops
.gl
.p_glDisable(GL_POLYGON_OFFSET_FILL
);
1823 checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
1827 static void state_zvisible(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1829 if (state
->render_states
[WINED3D_RS_ZVISIBLE
])
1830 FIXME("WINED3D_RS_ZVISIBLE not implemented.\n");
1833 static void state_perspective(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1835 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1837 if (state
->render_states
[WINED3D_RS_TEXTUREPERSPECTIVE
])
1839 gl_info
->gl_ops
.gl
.p_glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_NICEST
);
1840 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
1844 gl_info
->gl_ops
.gl
.p_glHint(GL_PERSPECTIVE_CORRECTION_HINT
, GL_FASTEST
);
1845 checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
1849 static void state_stippledalpha(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1851 if (state
->render_states
[WINED3D_RS_STIPPLEDALPHA
])
1852 FIXME("Stippled Alpha not supported yet.\n");
1855 static void state_antialias(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1857 if (state
->render_states
[WINED3D_RS_ANTIALIAS
])
1858 FIXME("Antialias not supported yet.\n");
1861 static void state_multisampmask(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1863 if (state
->render_states
[WINED3D_RS_MULTISAMPLEMASK
] != 0xffffffff)
1864 FIXME("WINED3D_RS_MULTISAMPLEMASK %#x not yet implemented.\n",
1865 state
->render_states
[WINED3D_RS_MULTISAMPLEMASK
]);
1868 static void state_patchedgestyle(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1870 if (state
->render_states
[WINED3D_RS_PATCHEDGESTYLE
] != WINED3D_PATCH_EDGE_DISCRETE
)
1871 FIXME("WINED3D_RS_PATCHEDGESTYLE %#x not yet implemented.\n",
1872 state
->render_states
[WINED3D_RS_PATCHEDGESTYLE
]);
1875 static void state_patchsegments(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1883 if (state
->render_states
[WINED3D_RS_PATCHSEGMENTS
] != tmpvalue
.d
)
1885 static BOOL displayed
= FALSE
;
1887 tmpvalue
.d
= state
->render_states
[WINED3D_RS_PATCHSEGMENTS
];
1889 FIXME("(WINED3D_RS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue
.f
);
1895 static void state_positiondegree(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1897 if (state
->render_states
[WINED3D_RS_POSITIONDEGREE
] != WINED3D_DEGREE_CUBIC
)
1898 FIXME("WINED3D_RS_POSITIONDEGREE %#x not yet implemented.\n",
1899 state
->render_states
[WINED3D_RS_POSITIONDEGREE
]);
1902 static void state_normaldegree(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1904 if (state
->render_states
[WINED3D_RS_NORMALDEGREE
] != WINED3D_DEGREE_LINEAR
)
1905 FIXME("WINED3D_RS_NORMALDEGREE %#x not yet implemented.\n",
1906 state
->render_states
[WINED3D_RS_NORMALDEGREE
]);
1909 static void state_tessellation(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1911 if (state
->render_states
[WINED3D_RS_ENABLEADAPTIVETESSELLATION
])
1912 FIXME("WINED3D_RS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
1913 state
->render_states
[WINED3D_RS_ENABLEADAPTIVETESSELLATION
]);
1916 static void state_nvdb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1923 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
1925 if (state
->render_states
[WINED3D_RS_ADAPTIVETESS_X
] == WINED3DFMT_NVDB
)
1927 zmin
.d
= state
->render_states
[WINED3D_RS_ADAPTIVETESS_Z
];
1928 zmax
.d
= state
->render_states
[WINED3D_RS_ADAPTIVETESS_W
];
1930 /* If zmin is larger than zmax INVALID_VALUE error is generated.
1931 * In d3d9 test is not performed in this case*/
1932 if (zmin
.f
<= zmax
.f
)
1934 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_BOUNDS_TEST_EXT
);
1935 checkGLcall("glEnable(GL_DEPTH_BOUNDS_TEST_EXT)");
1936 GL_EXTCALL(glDepthBoundsEXT(zmin
.f
, zmax
.f
));
1937 checkGLcall("glDepthBoundsEXT(...)");
1941 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
1942 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
1947 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
1948 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
1951 state_tessellation(context
, state
, STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
));
1954 static void state_wrapu(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1956 if (state
->render_states
[WINED3D_RS_WRAPU
])
1957 FIXME("Render state WINED3D_RS_WRAPU not implemented yet.\n");
1960 static void state_wrapv(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1962 if (state
->render_states
[WINED3D_RS_WRAPV
])
1963 FIXME("Render state WINED3D_RS_WRAPV not implemented yet.\n");
1966 static void state_monoenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1968 if (state
->render_states
[WINED3D_RS_MONOENABLE
])
1969 FIXME("Render state WINED3D_RS_MONOENABLE not implemented yet.\n");
1972 static void state_rop2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1974 if (state
->render_states
[WINED3D_RS_ROP2
])
1975 FIXME("Render state WINED3D_RS_ROP2 not implemented yet.\n");
1978 static void state_planemask(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1980 if (state
->render_states
[WINED3D_RS_PLANEMASK
])
1981 FIXME("Render state WINED3D_RS_PLANEMASK not implemented yet.\n");
1984 static void state_subpixel(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1986 if (state
->render_states
[WINED3D_RS_SUBPIXEL
])
1987 FIXME("Render state WINED3D_RS_SUBPIXEL not implemented yet.\n");
1990 static void state_subpixelx(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1992 if (state
->render_states
[WINED3D_RS_SUBPIXELX
])
1993 FIXME("Render state WINED3D_RS_SUBPIXELX not implemented yet.\n");
1996 static void state_stippleenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1998 if (state
->render_states
[WINED3D_RS_STIPPLEENABLE
])
1999 FIXME("Render state WINED3D_RS_STIPPLEENABLE not implemented yet.\n");
2002 static void state_mipmaplodbias(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2004 if (state
->render_states
[WINED3D_RS_MIPMAPLODBIAS
])
2005 FIXME("Render state WINED3D_RS_MIPMAPLODBIAS not implemented yet.\n");
2008 static void state_anisotropy(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2010 if (state
->render_states
[WINED3D_RS_ANISOTROPY
])
2011 FIXME("Render state WINED3D_RS_ANISOTROPY not implemented yet.\n");
2014 static void state_flushbatch(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2016 if (state
->render_states
[WINED3D_RS_FLUSHBATCH
])
2017 FIXME("Render state WINED3D_RS_FLUSHBATCH not implemented yet.\n");
2020 static void state_translucentsi(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2022 if (state
->render_states
[WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
])
2023 FIXME("Render state WINED3D_RS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
2026 static void state_extents(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2028 if (state
->render_states
[WINED3D_RS_EXTENTS
])
2029 FIXME("Render state WINED3D_RS_EXTENTS not implemented yet.\n");
2032 static void state_ckeyblend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2034 if (state
->render_states
[WINED3D_RS_COLORKEYBLENDENABLE
])
2035 FIXME("Render state WINED3D_RS_COLORKEYBLENDENABLE not implemented yet.\n");
2038 static void state_swvp(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2040 if (state
->render_states
[WINED3D_RS_SOFTWAREVERTEXPROCESSING
])
2041 FIXME("Software vertex processing not implemented.\n");
2044 static void get_src_and_opr(DWORD arg
, BOOL is_alpha
, GLenum
* source
, GLenum
* operand
) {
2045 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
2046 * input should be used for all input components. The WINED3DTA_COMPLEMENT
2047 * flag specifies the complement of the input should be used. */
2048 BOOL from_alpha
= is_alpha
|| arg
& WINED3DTA_ALPHAREPLICATE
;
2049 BOOL complement
= arg
& WINED3DTA_COMPLEMENT
;
2051 /* Calculate the operand */
2053 if (from_alpha
) *operand
= GL_ONE_MINUS_SRC_ALPHA
;
2054 else *operand
= GL_ONE_MINUS_SRC_COLOR
;
2056 if (from_alpha
) *operand
= GL_SRC_ALPHA
;
2057 else *operand
= GL_SRC_COLOR
;
2060 /* Calculate the source */
2061 switch (arg
& WINED3DTA_SELECTMASK
) {
2062 case WINED3DTA_CURRENT
: *source
= GL_PREVIOUS_EXT
; break;
2063 case WINED3DTA_DIFFUSE
: *source
= GL_PRIMARY_COLOR_EXT
; break;
2064 case WINED3DTA_TEXTURE
: *source
= GL_TEXTURE
; break;
2065 case WINED3DTA_TFACTOR
: *source
= GL_CONSTANT_EXT
; break;
2066 case WINED3DTA_SPECULAR
:
2068 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
2069 * 'Secondary color' and isn't supported until base GL supports it
2070 * There is no concept of temp registers as far as I can tell
2072 FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
2073 *source
= GL_TEXTURE
;
2076 FIXME("Unrecognized texture arg %#x\n", arg
);
2077 *source
= GL_TEXTURE
;
2082 /* Setup the texture operations texture stage states */
2083 static void set_tex_op(const struct wined3d_gl_info
*gl_info
, const struct wined3d_state
*state
,
2084 BOOL isAlpha
, int Stage
, enum wined3d_texture_op op
, DWORD arg1
, DWORD arg2
, DWORD arg3
)
2086 GLenum src1
, src2
, src3
;
2087 GLenum opr1
, opr2
, opr3
;
2089 GLenum src0_target
, src1_target
, src2_target
;
2090 GLenum opr0_target
, opr1_target
, opr2_target
;
2092 GLenum opr
=0, invopr
, src3_target
, opr3_target
;
2093 BOOL Handled
= FALSE
;
2095 TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha
, Stage
, debug_d3dtop(op
), arg1
, arg2
, arg3
);
2097 /* Operations usually involve two args, src0 and src1 and are operations
2098 * of the form (a1 <operation> a2). However, some of the more complex
2099 * operations take 3 parameters. Instead of the (sensible) addition of a3,
2100 * Microsoft added in a third parameter called a0. Therefore these are
2101 * operations of the form a0 <operation> a1 <operation> a2. I.e., the new
2102 * parameter goes to the front.
2104 * However, below we treat the new (a0) parameter as src2/opr2, so in the
2105 * actual functions below, expect their syntax to differ slightly to those
2106 * listed in the manuals. I.e., replace arg1 with arg3, arg2 with arg1 and
2107 * arg3 with arg2. This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP. */
2111 comb_target
= GL_COMBINE_ALPHA
;
2112 src0_target
= GL_SOURCE0_ALPHA
;
2113 src1_target
= GL_SOURCE1_ALPHA
;
2114 src2_target
= GL_SOURCE2_ALPHA
;
2115 opr0_target
= GL_OPERAND0_ALPHA
;
2116 opr1_target
= GL_OPERAND1_ALPHA
;
2117 opr2_target
= GL_OPERAND2_ALPHA
;
2118 scal_target
= GL_ALPHA_SCALE
;
2122 comb_target
= GL_COMBINE_RGB
;
2123 src0_target
= GL_SOURCE0_RGB
;
2124 src1_target
= GL_SOURCE1_RGB
;
2125 src2_target
= GL_SOURCE2_RGB
;
2126 opr0_target
= GL_OPERAND0_RGB
;
2127 opr1_target
= GL_OPERAND1_RGB
;
2128 opr2_target
= GL_OPERAND2_RGB
;
2129 scal_target
= GL_RGB_SCALE
;
2132 /* If a texture stage references an invalid texture unit the stage just
2133 * passes through the result from the previous stage */
2134 if (is_invalid_op(state
, Stage
, op
, arg1
, arg2
, arg3
))
2136 arg1
= WINED3DTA_CURRENT
;
2137 op
= WINED3D_TOP_SELECT_ARG1
;
2140 if (isAlpha
&& !state
->textures
[Stage
] && arg1
== WINED3DTA_TEXTURE
)
2142 get_src_and_opr(WINED3DTA_DIFFUSE
, isAlpha
, &src1
, &opr1
);
2144 get_src_and_opr(arg1
, isAlpha
, &src1
, &opr1
);
2146 get_src_and_opr(arg2
, isAlpha
, &src2
, &opr2
);
2147 get_src_and_opr(arg3
, isAlpha
, &src3
, &opr3
);
2149 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target
, src1
, opr1
, src2
, opr2
, src3
, opr3
);
2151 Handled
= TRUE
; /* Assume will be handled */
2153 /* Other texture operations require special extensions: */
2154 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
2158 invopr
= GL_ONE_MINUS_SRC_ALPHA
;
2159 src3_target
= GL_SOURCE3_ALPHA_NV
;
2160 opr3_target
= GL_OPERAND3_ALPHA_NV
;
2163 invopr
= GL_ONE_MINUS_SRC_COLOR
;
2164 src3_target
= GL_SOURCE3_RGB_NV
;
2165 opr3_target
= GL_OPERAND3_RGB_NV
;
2169 case WINED3D_TOP_DISABLE
: /* Only for alpha */
2170 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2171 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2172 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2173 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2174 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2175 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2176 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2177 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2178 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2179 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2180 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2181 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2182 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2183 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2184 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2185 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2186 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2187 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2190 case WINED3D_TOP_SELECT_ARG1
: /* = a1 * 1 + 0 * 0 */
2191 case WINED3D_TOP_SELECT_ARG2
: /* = a2 * 1 + 0 * 0 */
2192 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2193 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2194 if (op
== WINED3D_TOP_SELECT_ARG1
)
2196 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2197 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2198 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2199 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2203 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2204 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2205 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2206 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2208 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2209 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2210 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2211 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2212 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2213 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2214 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2215 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2216 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2217 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2218 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2219 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2222 case WINED3D_TOP_MODULATE
:
2223 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2224 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2225 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2226 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2227 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2228 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2229 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2230 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2231 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2232 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2233 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2234 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2235 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2236 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2237 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2238 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2239 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2240 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2241 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2242 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2244 case WINED3D_TOP_MODULATE_2X
:
2245 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2246 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2247 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2248 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2249 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2250 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2251 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2252 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2253 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2254 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2255 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2256 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2257 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2258 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2259 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2260 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2261 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2262 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2263 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2264 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2266 case WINED3D_TOP_MODULATE_4X
:
2267 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2268 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2269 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2270 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2271 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2272 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2273 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2274 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2275 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2276 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2277 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2278 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2279 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2280 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2281 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2282 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2283 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2284 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2285 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2286 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2289 case WINED3D_TOP_ADD
:
2290 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2291 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2292 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2293 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2294 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2295 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2296 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2297 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2298 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2299 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2300 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2301 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2302 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2303 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2304 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2305 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2306 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2307 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2308 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2309 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2312 case WINED3D_TOP_ADD_SIGNED
:
2313 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2314 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2315 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2316 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2317 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2318 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2319 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2320 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2321 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2322 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2323 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2324 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2325 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2326 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2327 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2328 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2329 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2330 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2331 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2332 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2335 case WINED3D_TOP_ADD_SIGNED_2X
:
2336 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2337 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2338 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2339 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2340 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2341 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2342 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2343 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2344 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2345 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2346 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2347 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2348 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2349 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2350 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2351 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2352 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2353 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2354 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2355 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2358 case WINED3D_TOP_ADD_SMOOTH
:
2359 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2360 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2361 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2362 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2363 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2364 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2365 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2366 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2367 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2368 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2369 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2370 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2371 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2372 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2373 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2374 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2376 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2377 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2378 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2379 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2381 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2382 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2383 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2384 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2387 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
2388 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2389 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2390 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2391 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2392 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2393 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2394 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_PRIMARY_COLOR
);
2395 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_PRIMARY_COLOR");
2396 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2397 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2398 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2399 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2400 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2401 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2402 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_PRIMARY_COLOR
);
2403 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_PRIMARY_COLOR");
2404 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2405 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2406 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2407 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2409 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
2410 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2411 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2412 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2413 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2414 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2415 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2416 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_TEXTURE
);
2417 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
2418 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2419 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2420 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2421 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2422 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2423 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2424 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2425 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2426 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2427 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2428 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2429 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2431 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
2432 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2433 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2434 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2435 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2436 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2437 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2438 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_CONSTANT
);
2439 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_CONSTANT");
2440 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2441 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2442 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2443 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2444 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2445 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2446 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_CONSTANT
);
2447 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_CONSTANT");
2448 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2449 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2450 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2451 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2453 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
2454 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2455 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2456 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2457 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2458 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2459 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2460 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2461 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2462 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2463 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2464 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2465 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2466 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2467 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2468 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2469 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2470 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2471 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2472 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2473 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2475 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
2476 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2477 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2478 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
); /* a0 = src1/opr1 */
2479 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2480 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2481 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
2482 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2483 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2484 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2485 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2486 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
); /* a2 = arg2 */
2487 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2488 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2489 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
2490 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2491 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2493 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2494 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2496 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2497 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2498 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2499 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2501 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
2502 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2503 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2504 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2505 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2506 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2507 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2508 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2509 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2510 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2511 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2512 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2513 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2515 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2516 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2518 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2519 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2520 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2521 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2522 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2523 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2524 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2525 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2527 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
2528 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2529 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2530 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2531 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2532 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2533 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2534 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2535 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2536 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2537 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2538 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2539 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2540 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2541 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2542 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2543 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2545 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2546 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2547 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2548 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2550 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2551 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2552 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2553 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2555 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
2556 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2557 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2558 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2559 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2561 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2562 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2563 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2564 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2566 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2567 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2568 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2569 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2570 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2571 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2572 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2573 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2575 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2576 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2578 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2579 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2580 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2581 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2582 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2583 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2584 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2585 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2587 case WINED3D_TOP_MULTIPLY_ADD
:
2588 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2589 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2590 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src3
);
2591 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2592 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr3
);
2593 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2594 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2595 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2596 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2597 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2598 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2599 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2600 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr1
);
2601 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2602 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src2
);
2603 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
2604 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr2
);
2605 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
2606 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2607 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2610 case WINED3D_TOP_BUMPENVMAP
:
2611 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
2612 FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
2621 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE4_NV
);
2622 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
2626 } /* GL_NV_texture_env_combine4 */
2628 Handled
= TRUE
; /* Again, assume handled */
2630 case WINED3D_TOP_DISABLE
: /* Only for alpha */
2631 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2632 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2633 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2634 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
2635 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2636 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
2637 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2638 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2640 case WINED3D_TOP_SELECT_ARG1
:
2641 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2642 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2643 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2644 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2645 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2646 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2647 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2648 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2650 case WINED3D_TOP_SELECT_ARG2
:
2651 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2652 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2653 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2654 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2655 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2656 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2657 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2658 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2660 case WINED3D_TOP_MODULATE
:
2661 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2662 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2663 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2664 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2665 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2666 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2667 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2668 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2669 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2670 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2671 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2672 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2674 case WINED3D_TOP_MODULATE_2X
:
2675 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2676 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2677 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2678 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2679 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2680 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2681 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2682 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2683 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2684 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2685 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2686 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2688 case WINED3D_TOP_MODULATE_4X
:
2689 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2690 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2691 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2692 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2693 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2694 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2695 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2696 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2697 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2698 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2699 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2700 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2702 case WINED3D_TOP_ADD
:
2703 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2704 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2705 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2706 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2707 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2708 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2709 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2710 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2711 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2712 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2713 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2714 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2716 case WINED3D_TOP_ADD_SIGNED
:
2717 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2718 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2719 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2720 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2721 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2722 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2723 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2724 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2725 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2726 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2727 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2728 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2730 case WINED3D_TOP_ADD_SIGNED_2X
:
2731 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2732 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2733 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2734 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2735 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2736 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2737 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2738 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2739 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2740 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2741 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2742 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2744 case WINED3D_TOP_SUBTRACT
:
2745 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
])
2747 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_SUBTRACT
);
2748 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_SUBTRACT");
2749 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2750 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2751 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2752 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2753 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2754 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2755 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2756 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2757 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2758 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2760 FIXME("This version of opengl does not support GL_SUBTRACT\n");
2764 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
2765 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2766 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2767 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2768 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2769 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2770 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2771 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2772 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2773 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2774 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2775 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_PRIMARY_COLOR
);
2776 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
2777 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2778 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2779 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2780 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2782 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
2783 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2784 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2785 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2786 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2787 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2788 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2789 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2790 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2791 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2792 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2793 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_TEXTURE
);
2794 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
2795 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2796 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2797 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2798 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2800 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
2801 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2802 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2803 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2804 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2805 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2806 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2807 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2808 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2809 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2810 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2811 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_CONSTANT
);
2812 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
2813 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2814 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2815 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2816 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2818 case WINED3D_TOP_BLEND_CURRENT_ALPHA
:
2819 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2820 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2821 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2822 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2823 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2824 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2825 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2826 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2827 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2828 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2829 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_PREVIOUS
);
2830 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
2831 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2832 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2833 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2834 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2836 case WINED3D_TOP_DOTPRODUCT3
:
2837 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
2839 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_ARB
);
2840 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
2842 else if (gl_info
->supported
[EXT_TEXTURE_ENV_DOT3
])
2844 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_EXT
);
2845 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
2847 FIXME("This version of opengl does not support GL_DOT3\n");
2849 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2850 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2851 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2852 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2853 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2854 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2855 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2856 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2857 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2858 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2860 case WINED3D_TOP_LERP
:
2861 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2862 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2863 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2864 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2865 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2866 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2867 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2868 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2869 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2870 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2871 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src3
);
2872 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
2873 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr3
);
2874 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
2875 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2876 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2878 case WINED3D_TOP_ADD_SMOOTH
:
2879 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2881 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2882 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2883 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2884 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2886 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2887 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2888 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2889 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2891 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2892 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2893 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2894 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2895 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2896 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2897 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2898 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2899 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2900 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2901 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2902 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2906 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
2907 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2909 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2910 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2911 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_TEXTURE
);
2912 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
2913 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_ONE_MINUS_SRC_ALPHA
);
2914 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
2915 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2916 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2917 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2918 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2919 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2920 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2921 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2922 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2923 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2924 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2928 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
2929 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2931 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2932 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2933 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2934 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2936 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2937 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2938 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2939 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2941 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2942 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2943 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2944 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2945 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
2946 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
2947 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2948 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2949 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2950 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2951 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2952 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2956 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
2957 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2959 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2960 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2961 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2962 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2963 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2964 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2965 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
2966 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
2968 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2969 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2970 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2971 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2973 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
2974 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
2975 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2976 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2977 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2978 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2979 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2980 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2984 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
2985 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
2987 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
2988 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
2989 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2990 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2992 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2993 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2994 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2995 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2997 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2998 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2999 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3000 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3001 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
3002 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
3003 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3004 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3005 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3006 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3007 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3008 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3012 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
3013 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3015 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3016 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3017 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3018 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3020 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
3021 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
3022 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3023 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3025 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3026 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3027 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3028 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3030 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3031 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3032 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3033 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3035 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
3036 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
3037 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3038 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3039 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3040 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3041 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3042 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3046 case WINED3D_TOP_MULTIPLY_ADD
:
3047 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3049 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3050 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3051 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3052 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3053 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3054 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3055 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src3
);
3056 checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
3057 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr3
);
3058 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
3059 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3060 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3061 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3062 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3063 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3064 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3068 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
3069 case WINED3D_TOP_BUMPENVMAP
:
3070 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
3072 /* Technically texture shader support without register combiners is possible, but not expected to occur
3073 * on real world cards, so for now a fixme should be enough
3075 FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
3085 BOOL combineOK
= TRUE
;
3086 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
3091 op2
= state
->texture_states
[Stage
][WINED3D_TSS_COLOR_OP
];
3093 op2
= state
->texture_states
[Stage
][WINED3D_TSS_ALPHA_OP
];
3095 /* Note: If COMBINE4 in effect can't go back to combine! */
3098 case WINED3D_TOP_ADD_SMOOTH
:
3099 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
3100 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
3101 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
3102 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
3103 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
3104 case WINED3D_TOP_MULTIPLY_ADD
:
3105 /* Ignore those implemented in both cases */
3108 case WINED3D_TOP_SELECT_ARG1
:
3109 case WINED3D_TOP_SELECT_ARG2
:
3114 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op
), debug_d3dtop(op2
), isAlpha
);
3122 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE
);
3123 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE");
3129 /* After all the extensions, if still unhandled, report fixme */
3130 FIXME("Unhandled texture operation %s\n", debug_d3dtop(op
));
3134 static void tex_colorop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3136 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3137 BOOL tex_used
= context
->fixed_function_usage_map
& (1 << stage
);
3138 DWORD mapped_stage
= context
->tex_unit_map
[stage
];
3139 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3141 TRACE("Setting color op for stage %d\n", stage
);
3143 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
3144 if (use_ps(state
)) return;
3146 if (stage
!= mapped_stage
) WARN("Using non 1:1 mapping: %d -> %d!\n", stage
, mapped_stage
);
3148 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3150 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3152 FIXME("Attempt to enable unsupported stage!\n");
3155 context_active_texture(context
, gl_info
, mapped_stage
);
3158 if (stage
>= context
->lowest_disabled_stage
)
3160 TRACE("Stage disabled\n");
3161 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3163 /* Disable everything here */
3164 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_2D
);
3165 checkGLcall("glDisable(GL_TEXTURE_2D)");
3166 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_3D
);
3167 checkGLcall("glDisable(GL_TEXTURE_3D)");
3168 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
3170 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
3171 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3173 if (gl_info
->supported
[ARB_TEXTURE_RECTANGLE
])
3175 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_RECTANGLE_ARB
);
3176 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3183 /* The sampler will also activate the correct texture dimensions, so no
3184 * need to do it here if the sampler for this stage is dirty. */
3185 if (!isStateDirty(context
, STATE_SAMPLER(stage
)) && tex_used
)
3186 texture_activate_dimensions(state
->textures
[stage
], gl_info
);
3188 set_tex_op(gl_info
, state
, FALSE
, stage
,
3189 state
->texture_states
[stage
][WINED3D_TSS_COLOR_OP
],
3190 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG1
],
3191 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG2
],
3192 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG0
]);
3195 void tex_alphaop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3197 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3198 BOOL tex_used
= context
->fixed_function_usage_map
& (1 << stage
);
3199 DWORD mapped_stage
= context
->tex_unit_map
[stage
];
3200 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3201 DWORD op
, arg1
, arg2
, arg0
;
3203 TRACE("Setting alpha op for stage %d\n", stage
);
3204 /* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
3205 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3207 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3209 FIXME("Attempt to enable unsupported stage!\n");
3212 context_active_texture(context
, gl_info
, mapped_stage
);
3215 op
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_OP
];
3216 arg1
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG1
];
3217 arg2
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG2
];
3218 arg0
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG0
];
3220 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && !stage
&& state
->textures
[0])
3222 struct wined3d_texture
*texture
= state
->textures
[0];
3223 GLenum texture_dimensions
= texture
->target
;
3225 if (texture_dimensions
== GL_TEXTURE_2D
|| texture_dimensions
== GL_TEXTURE_RECTANGLE_ARB
)
3227 if (texture
->color_key_flags
& WINED3D_CKEY_SRC_BLT
&& !texture
->resource
.format
->alpha_size
)
3229 /* Color keying needs to pass alpha values from the texture through to have the alpha test work
3230 * properly. On the other hand applications can still use texture combiners apparently. This code
3231 * takes care that apps cannot remove the texture's alpha channel entirely.
3233 * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires
3234 * D3DTOP_MODULATE to work on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures
3235 * and alpha component of diffuse color to draw things like translucent text and perform other
3238 * Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To
3239 * provide the behavior expected by the game, while emulating the colorkey, diffuse alpha must be
3240 * modulated with texture alpha. OTOH, Moto racer 2 at some points sets alphaop/alphaarg to
3241 * SELECTARG/CURRENT, yet puts garbage in diffuse alpha (zeroes). This works on native, because the
3242 * game disables alpha test and alpha blending. Alpha test is overwritten by wine's for purposes of
3243 * color-keying though, so this will lead to missing geometry if texture alpha is modulated (pixels
3244 * fail alpha test). To get around this, ALPHABLENDENABLE state is checked: if the app enables alpha
3245 * blending, it can be expected to provide meaningful values in diffuse alpha, so it should be
3246 * modulated with texture alpha; otherwise, selecting diffuse alpha is ignored in favour of texture
3249 * What to do with multitexturing? So far no app has been found that uses color keying with
3251 if (op
== WINED3D_TOP_DISABLE
)
3253 arg1
= WINED3DTA_TEXTURE
;
3254 op
= WINED3D_TOP_SELECT_ARG1
;
3256 else if (op
== WINED3D_TOP_SELECT_ARG1
&& arg1
!= WINED3DTA_TEXTURE
)
3258 if (state
->render_states
[WINED3D_RS_ALPHABLENDENABLE
])
3260 arg2
= WINED3DTA_TEXTURE
;
3261 op
= WINED3D_TOP_MODULATE
;
3263 else arg1
= WINED3DTA_TEXTURE
;
3265 else if (op
== WINED3D_TOP_SELECT_ARG2
&& arg2
!= WINED3DTA_TEXTURE
)
3267 if (state
->render_states
[WINED3D_RS_ALPHABLENDENABLE
])
3269 arg1
= WINED3DTA_TEXTURE
;
3270 op
= WINED3D_TOP_MODULATE
;
3272 else arg2
= WINED3DTA_TEXTURE
;
3278 /* tex_alphaop is shared between the ffp and nvrc because the difference only comes down to
3279 * this if block here, and the other code(color keying, texture unit selection) are the same
3281 TRACE("Setting alpha op for stage %d\n", stage
);
3282 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
3284 set_tex_op_nvrc(gl_info
, state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
,
3285 mapped_stage
, state
->texture_states
[stage
][WINED3D_TSS_RESULT_ARG
]);
3289 set_tex_op(gl_info
, state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
);
3293 void transform_texture(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3295 DWORD texUnit
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3296 const struct wined3d_device
*device
= context
->swapchain
->device
;
3297 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3298 DWORD mapped_stage
= context
->tex_unit_map
[texUnit
];
3302 /* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
3303 if (use_vs(state
) || isStateDirty(context
, STATE_VDECL
))
3305 TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
3309 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
) return;
3310 if (mapped_stage
>= gl_info
->limits
.textures
) return;
3312 context_active_texture(context
, gl_info
, mapped_stage
);
3313 generated
= (state
->texture_states
[texUnit
][WINED3D_TSS_TEXCOORD_INDEX
] & 0xffff0000) != WINED3DTSS_TCI_PASSTHRU
;
3314 coordIdx
= min(state
->texture_states
[texUnit
][WINED3D_TSS_TEXCOORD_INDEX
& 0x0000ffff], MAX_TEXTURES
- 1);
3316 set_texture_matrix(gl_info
, &state
->transforms
[WINED3D_TS_TEXTURE0
+ texUnit
].u
.m
[0][0],
3317 state
->texture_states
[texUnit
][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
],
3318 generated
, context
->last_was_rhw
,
3319 context
->stream_info
.use_map
& (1 << (WINED3D_FFP_TEXCOORD0
+ coordIdx
))
3320 ? context
->stream_info
.elements
[WINED3D_FFP_TEXCOORD0
+ coordIdx
].format
->id
3321 : WINED3DFMT_UNKNOWN
,
3322 device
->shader_backend
->shader_has_ffp_proj_control(device
->shader_priv
));
3324 /* The sampler applying function calls us if this changes */
3325 if ((context
->lastWasPow2Texture
& (1 << texUnit
)) && state
->textures
[texUnit
])
3328 FIXME("Non-power2 texture being used with generated texture coords\n");
3330 /* NP2 texcoord fixup is implemented for pixelshaders so only enable the
3331 fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
3334 TRACE("Non power two matrix multiply fixup\n");
3335 gl_info
->gl_ops
.gl
.p_glMultMatrixf(state
->textures
[texUnit
]->pow2_matrix
);
3340 static void unload_tex_coords(const struct wined3d_gl_info
*gl_info
)
3342 unsigned int texture_idx
;
3344 for (texture_idx
= 0; texture_idx
< gl_info
->limits
.texture_coords
; ++texture_idx
)
3346 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB
+ texture_idx
));
3347 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_TEXTURE_COORD_ARRAY
);
3351 static void load_tex_coords(const struct wined3d_context
*context
, const struct wined3d_stream_info
*si
,
3352 GLuint
*curVBO
, const struct wined3d_state
*state
)
3354 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3355 unsigned int mapped_stage
= 0;
3356 unsigned int textureNo
= 0;
3358 for (textureNo
= 0; textureNo
< context
->d3d_info
->limits
.ffp_blend_stages
; ++textureNo
)
3360 int coordIdx
= state
->texture_states
[textureNo
][WINED3D_TSS_TEXCOORD_INDEX
];
3362 mapped_stage
= context
->tex_unit_map
[textureNo
];
3363 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
) continue;
3365 if (mapped_stage
>= gl_info
->limits
.texture_coords
)
3367 FIXME("Attempted to load unsupported texture coordinate %u\n", mapped_stage
);
3371 if (coordIdx
< MAX_TEXTURES
&& (si
->use_map
& (1 << (WINED3D_FFP_TEXCOORD0
+ coordIdx
))))
3373 const struct wined3d_stream_info_element
*e
= &si
->elements
[WINED3D_FFP_TEXCOORD0
+ coordIdx
];
3375 TRACE("Setting up texture %u, idx %d, coordindx %u, data {%#x:%p}.\n",
3376 textureNo
, mapped_stage
, coordIdx
, e
->data
.buffer_object
, e
->data
.addr
);
3378 if (*curVBO
!= e
->data
.buffer_object
)
3380 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
3381 checkGLcall("glBindBuffer");
3382 *curVBO
= e
->data
.buffer_object
;
3385 GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB
+ mapped_stage
));
3386 checkGLcall("glClientActiveTextureARB");
3388 /* The coords to supply depend completely on the fvf / vertex shader */
3389 gl_info
->gl_ops
.gl
.p_glTexCoordPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
3390 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
3391 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_TEXTURE_COORD_ARRAY
);
3395 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB
+ mapped_stage
, 0, 0, 0, 1));
3398 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
3400 /* The number of the mapped stages increases monotonically, so it's fine to use the last used one. */
3401 for (textureNo
= mapped_stage
+ 1; textureNo
< gl_info
->limits
.textures
; ++textureNo
)
3403 GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB
+ textureNo
, 0, 0, 0, 1));
3407 checkGLcall("loadTexCoords");
3410 static void tex_coordindex(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3412 DWORD stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3413 static const GLfloat s_plane
[] = { 1.0f
, 0.0f
, 0.0f
, 0.0f
};
3414 static const GLfloat t_plane
[] = { 0.0f
, 1.0f
, 0.0f
, 0.0f
};
3415 static const GLfloat r_plane
[] = { 0.0f
, 0.0f
, 1.0f
, 0.0f
};
3416 static const GLfloat q_plane
[] = { 0.0f
, 0.0f
, 0.0f
, 1.0f
};
3417 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3418 DWORD mapped_stage
= context
->tex_unit_map
[stage
];
3420 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3422 TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage
);
3426 if (mapped_stage
>= gl_info
->limits
.fragment_samplers
)
3428 WARN("stage %u not mapped to a valid texture unit (%u)\n", stage
, mapped_stage
);
3431 context_active_texture(context
, gl_info
, mapped_stage
);
3433 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
3435 * FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
3436 * eg. SetTextureStageState( 0, WINED3D_TSS_TEXCOORDINDEX, WINED3D_TSS_TCI_CAMERASPACEPOSITION | 1 );
3437 * means use the vertex position (camera-space) as the input texture coordinates
3438 * for this texture stage, and the wrap mode set in the WINED3D_RS_WRAP1 render
3439 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
3440 * to the TEXCOORDINDEX value
3442 switch (state
->texture_states
[stage
][WINED3D_TSS_TEXCOORD_INDEX
] & 0xffff0000)
3444 case WINED3DTSS_TCI_PASSTHRU
:
3445 /* Use the specified texture coordinates contained within the
3446 * vertex format. This value resolves to zero. */
3447 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_S
);
3448 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_T
);
3449 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3450 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_Q
);
3451 checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
3454 case WINED3DTSS_TCI_CAMERASPACEPOSITION
:
3455 /* CameraSpacePosition means use the vertex position, transformed to camera space,
3456 * as the input texture coordinates for this stage's texture transformation. This
3457 * equates roughly to EYE_LINEAR */
3459 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3460 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3461 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3462 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3463 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3464 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3465 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3466 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3467 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
3469 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3470 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3471 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3472 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
3474 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3475 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3476 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3477 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
3481 case WINED3DTSS_TCI_CAMERASPACENORMAL
:
3482 /* Note that NV_TEXGEN_REFLECTION support is implied when
3483 * ARB_TEXTURE_CUBE_MAP is supported */
3484 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3486 FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
3490 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3491 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3492 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3493 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3494 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3495 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3496 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3497 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3498 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
3500 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3501 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3502 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3503 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
3505 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3506 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3507 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3508 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
3512 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
:
3513 /* Note that NV_TEXGEN_REFLECTION support is implied when
3514 * ARB_TEXTURE_CUBE_MAP is supported */
3515 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3517 FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
3521 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3522 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3523 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3524 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3525 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3526 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3527 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3528 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3529 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
3531 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3532 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3533 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3534 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
3536 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3537 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3538 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3539 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
3543 case WINED3DTSS_TCI_SPHEREMAP
:
3544 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3545 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3546 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
3548 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3549 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3550 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3551 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
3556 FIXME("Unhandled WINED3D_TSS_TEXCOORD_INDEX %#x.\n",
3557 state
->texture_states
[stage
][WINED3D_TSS_TEXCOORD_INDEX
]);
3558 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_S
);
3559 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_T
);
3560 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3561 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_Q
);
3562 checkGLcall("Disable texgen.");
3567 /* Update the texture matrix. */
3568 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ stage
)))
3569 transform_texture(context
, state
, STATE_TEXTURESTAGE(stage
, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
3571 if (!isStateDirty(context
, STATE_VDECL
) && context
->namedArraysLoaded
)
3573 /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
3574 * source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
3575 * and do all the things linked to it
3576 * TODO: Tidy that up to reload only the arrays of the changed unit
3578 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
3580 unload_tex_coords(gl_info
);
3581 load_tex_coords(context
, &context
->stream_info
, &curVBO
, state
);
3585 void sampler_texmatrix(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3587 const DWORD sampler
= state_id
- STATE_SAMPLER(0);
3588 const struct wined3d_texture
*texture
= state
->textures
[sampler
];
3590 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
3592 if(!texture
) return;
3593 /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
3594 * wined3d_texture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
3595 * scaling is reapplied or removed, the texture matrix has to be reapplied
3597 * The mapped stage is already active because the sampler() function below, which is part of the
3600 if (sampler
< MAX_TEXTURES
)
3602 const BOOL texIsPow2
= !(texture
->flags
& WINED3D_TEXTURE_POW2_MAT_IDENT
);
3604 if (texIsPow2
|| (context
->lastWasPow2Texture
& (1 << sampler
)))
3607 context
->lastWasPow2Texture
|= 1 << sampler
;
3609 context
->lastWasPow2Texture
&= ~(1 << sampler
);
3611 transform_texture(context
, state
,
3612 STATE_TEXTURESTAGE(context
->tex_unit_map
[sampler
], WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
3617 static enum wined3d_texture_address
wined3d_texture_address_mode(const struct wined3d_texture
*texture
,
3618 enum wined3d_texture_address t
)
3620 if (t
< WINED3D_TADDRESS_WRAP
|| t
> WINED3D_TADDRESS_MIRROR_ONCE
)
3622 FIXME("Unrecognized or unsupported texture address mode %#x.\n", t
);
3623 return WINED3D_TADDRESS_WRAP
;
3626 /* Cubemaps are always set to clamp, regardless of the sampler state. */
3627 if (texture
->target
== GL_TEXTURE_CUBE_MAP_ARB
|| ((texture
->flags
& WINED3D_TEXTURE_COND_NP2
)
3628 && t
== WINED3D_TADDRESS_WRAP
))
3629 return WINED3D_TADDRESS_CLAMP
;
3634 static void wined3d_sampler_desc_from_sampler_states(struct wined3d_sampler_desc
*desc
,
3635 const struct wined3d_gl_info
*gl_info
, const DWORD
*sampler_states
, const struct wined3d_texture
*texture
)
3643 desc
->address_u
= wined3d_texture_address_mode(texture
, sampler_states
[WINED3D_SAMP_ADDRESS_U
]);
3644 desc
->address_v
= wined3d_texture_address_mode(texture
, sampler_states
[WINED3D_SAMP_ADDRESS_V
]);
3645 desc
->address_w
= wined3d_texture_address_mode(texture
, sampler_states
[WINED3D_SAMP_ADDRESS_W
]);
3646 D3DCOLORTOGLFLOAT4(sampler_states
[WINED3D_SAMP_BORDER_COLOR
], desc
->border_color
);
3647 if (sampler_states
[WINED3D_SAMP_MAG_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3648 FIXME("Unrecognized or unsupported WINED3D_SAMP_MAG_FILTER %#x.\n",
3649 sampler_states
[WINED3D_SAMP_MAG_FILTER
]);
3650 desc
->mag_filter
= min(max(sampler_states
[WINED3D_SAMP_MAG_FILTER
], WINED3D_TEXF_POINT
), WINED3D_TEXF_LINEAR
);
3651 if (sampler_states
[WINED3D_SAMP_MIN_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3652 FIXME("Unrecognized or unsupported WINED3D_SAMP_MIN_FILTER %#x.\n",
3653 sampler_states
[WINED3D_SAMP_MIN_FILTER
]);
3654 desc
->min_filter
= min(max(sampler_states
[WINED3D_SAMP_MIN_FILTER
], WINED3D_TEXF_POINT
), WINED3D_TEXF_LINEAR
);
3655 if (sampler_states
[WINED3D_SAMP_MIP_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3656 FIXME("Unrecognized or unsupported WINED3D_SAMP_MIP_FILTER %#x.\n",
3657 sampler_states
[WINED3D_SAMP_MIP_FILTER
]);
3658 desc
->mip_filter
= min(max(sampler_states
[WINED3D_SAMP_MIP_FILTER
], WINED3D_TEXF_NONE
), WINED3D_TEXF_LINEAR
);
3659 lod_bias
.d
= sampler_states
[WINED3D_SAMP_MIPMAP_LOD_BIAS
];
3660 desc
->lod_bias
= lod_bias
.f
;
3661 desc
->min_lod
= -1000.0f
;
3662 desc
->max_lod
= 1000.0f
;
3663 desc
->max_anisotropy
= sampler_states
[WINED3D_SAMP_MAX_ANISOTROPY
];
3664 if ((sampler_states
[WINED3D_SAMP_MAG_FILTER
] != WINED3D_TEXF_ANISOTROPIC
3665 && sampler_states
[WINED3D_SAMP_MIN_FILTER
] != WINED3D_TEXF_ANISOTROPIC
3666 && sampler_states
[WINED3D_SAMP_MIP_FILTER
] != WINED3D_TEXF_ANISOTROPIC
)
3667 || (texture
->flags
& WINED3D_TEXTURE_COND_NP2
))
3668 desc
->max_anisotropy
= 1;
3669 desc
->compare
= texture
->resource
.format
->flags
& WINED3DFMT_FLAG_SHADOW
;
3670 desc
->comparison_func
= WINED3D_CMP_LESSEQUAL
;
3671 desc
->srgb_decode
= sampler_states
[WINED3D_SAMP_SRGB_TEXTURE
];
3673 if (!(texture
->resource
.format
->flags
& WINED3DFMT_FLAG_FILTERING
))
3675 desc
->mag_filter
= WINED3D_TEXF_POINT
;
3676 desc
->min_filter
= WINED3D_TEXF_POINT
;
3677 desc
->mip_filter
= WINED3D_TEXF_NONE
;
3680 if (texture
->flags
& WINED3D_TEXTURE_COND_NP2
)
3682 desc
->mip_filter
= WINED3D_TEXF_NONE
;
3683 if (gl_info
->supported
[WINED3D_GL_NORMALIZED_TEXRECT
])
3684 desc
->min_filter
= WINED3D_TEXF_POINT
;
3688 /* Enabling and disabling texture dimensions is done by texture stage state /
3689 * pixel shader setup, this function only has to bind textures and set the per
3690 * texture states. */
3691 static void sampler(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3693 DWORD sampler_idx
= state_id
- STATE_SAMPLER(0);
3694 DWORD mapped_stage
= context
->tex_unit_map
[sampler_idx
];
3695 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3697 TRACE("Sampler %u.\n", sampler_idx
);
3700 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3702 TRACE("No sampler mapped to stage %u. Returning.\n", sampler_idx
);
3706 if (mapped_stage
>= gl_info
->limits
.combined_samplers
)
3710 context_active_texture(context
, gl_info
, mapped_stage
);
3712 if (state
->textures
[sampler_idx
])
3714 struct wined3d_texture
*texture
= state
->textures
[sampler_idx
];
3715 BOOL srgb
= state
->sampler_states
[sampler_idx
][WINED3D_SAMP_SRGB_TEXTURE
];
3716 const DWORD
*sampler_states
= state
->sampler_states
[sampler_idx
];
3717 struct wined3d_sampler_desc desc
;
3718 struct gl_texture
*gl_tex
;
3719 unsigned int base_level
;
3721 wined3d_sampler_desc_from_sampler_states(&desc
, gl_info
, sampler_states
, texture
);
3723 wined3d_texture_bind(texture
, context
, srgb
);
3724 if (!gl_info
->supported
[ARB_SAMPLER_OBJECTS
])
3726 wined3d_texture_apply_sampler_desc(texture
, &desc
, gl_info
);
3730 struct wined3d_device
*device
= context
->swapchain
->device
;
3731 struct wined3d_sampler
*sampler
;
3732 struct wine_rb_entry
*entry
;
3734 if ((entry
= wine_rb_get(&device
->samplers
, &desc
)))
3736 sampler
= WINE_RB_ENTRY_VALUE(entry
, struct wined3d_sampler
, entry
);
3740 if (FAILED(wined3d_sampler_create(device
, &desc
, NULL
, &sampler
)))
3742 ERR("Failed to create sampler.\n");
3747 if (wine_rb_put(&device
->samplers
, &desc
, &sampler
->entry
) == -1)
3748 ERR("Failed to insert sampler.\n");
3754 GL_EXTCALL(glBindSampler(sampler_idx
, sampler
->name
));
3755 checkGLcall("glBindSampler");
3759 if (texture
->flags
& WINED3D_TEXTURE_COND_NP2
)
3761 else if (desc
.mip_filter
== WINED3D_TEXF_NONE
)
3762 base_level
= texture
->lod
;
3764 base_level
= min(max(sampler_states
[WINED3D_SAMP_MAX_MIP_LEVEL
],
3765 texture
->lod
), texture
->level_count
- 1);
3767 gl_tex
= wined3d_texture_get_gl_texture(texture
, texture
->flags
& WINED3D_TEXTURE_IS_SRGB
);
3768 if (base_level
!= gl_tex
->base_level
)
3770 /* Note that WINED3D_SAMP_MAX_MIP_LEVEL specifies the largest mipmap
3771 * (default 0), while GL_TEXTURE_MAX_LEVEL specifies the smallest
3772 * mimap used (default 1000). So WINED3D_SAMP_MAX_MIP_LEVEL
3773 * corresponds to GL_TEXTURE_BASE_LEVEL. */
3774 gl_info
->gl_ops
.gl
.p_glTexParameteri(texture
->target
, GL_TEXTURE_BASE_LEVEL
, base_level
);
3775 gl_tex
->base_level
= base_level
;
3778 if (!use_ps(state
) && sampler_idx
< context
->lowest_disabled_stage
)
3780 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && !sampler_idx
)
3782 /* If color keying is enabled update the alpha test, it
3783 * depends on the existence of a color key in stage 0. */
3784 state_alpha(context
, state
, WINED3D_RS_COLORKEYENABLE
);
3788 /* Trigger shader constant reloading (for NP2 texcoord fixup) */
3789 if (!(texture
->flags
& WINED3D_TEXTURE_POW2_MAT_IDENT
))
3790 context
->constant_update_mask
|= WINED3D_SHADER_CONST_PS_NP2_FIXUP
;
3794 if (sampler_idx
< context
->lowest_disabled_stage
)
3796 /* TODO: What should I do with pixel shaders here ??? */
3797 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && !sampler_idx
)
3799 /* If color keying is enabled update the alpha test, it
3800 * depends on the existence of a color key in stage 0. */
3801 state_alpha(context
, state
, WINED3D_RS_COLORKEYENABLE
);
3803 } /* Otherwise tex_colorop disables the stage */
3804 context_bind_texture(context
, GL_NONE
, 0);
3808 void apply_pixelshader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3814 if (!context
->last_was_pshader
)
3816 /* Former draw without a pixel shader, some samplers may be
3817 * disabled because of WINED3D_TSS_COLOR_OP = WINED3DTOP_DISABLE
3818 * make sure to enable them. */
3819 for (i
= 0; i
< MAX_FRAGMENT_SAMPLERS
; ++i
)
3821 if (!isStateDirty(context
, STATE_SAMPLER(i
)))
3822 sampler(context
, state
, STATE_SAMPLER(i
));
3824 context
->last_was_pshader
= TRUE
;
3828 /* Otherwise all samplers were activated by the code above in
3829 * earlier draws, or by sampler() if a different texture was
3830 * bound. I don't have to do anything. */
3835 /* Disabled the pixel shader - color ops weren't applied while it was
3836 * enabled, so re-apply them. */
3837 for (i
= 0; i
< context
->d3d_info
->limits
.ffp_blend_stages
; ++i
)
3839 if (!isStateDirty(context
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_COLOR_OP
)))
3840 context_apply_state(context
, state
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_COLOR_OP
));
3842 context
->last_was_pshader
= FALSE
;
3845 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_PIXEL
;
3848 static void state_geometry_shader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3850 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_GEOMETRY
;
3853 static void shader_bumpenv(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3855 context
->constant_update_mask
|= WINED3D_SHADER_CONST_PS_BUMP_ENV
;
3858 void transform_world(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3860 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3862 /* This function is called by transform_view below if the view matrix was changed too
3864 * Deliberately no check if the vertex declaration is dirty because the vdecl state
3865 * does not always update the world matrix, only on a switch between transformed
3866 * and untransformed draws. It *may* happen that the world matrix is set 2 times during one
3867 * draw, but that should be rather rare and cheaper in total.
3869 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3870 checkGLcall("glMatrixMode");
3872 if (context
->last_was_rhw
)
3874 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3875 checkGLcall("glLoadIdentity()");
3879 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
].u
.m
[0][0]);
3880 checkGLcall("glLoadMatrixf");
3881 gl_info
->gl_ops
.gl
.p_glMultMatrixf(&state
->transforms
[WINED3D_TS_WORLD_MATRIX(0)].u
.m
[0][0]);
3882 checkGLcall("glMultMatrixf");
3886 void clipplane(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3888 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3889 UINT index
= state_id
- STATE_CLIPPLANE(0);
3892 if (isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_VIEW
)) || index
>= gl_info
->limits
.clipplanes
)
3895 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3896 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3898 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
3900 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
].u
.m
[0][0]);
3902 /* With vertex shaders, clip planes are not transformed in Direct3D,
3903 * while in OpenGL they are still transformed by the model view matix. */
3904 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3906 plane
[0] = state
->clip_planes
[index
].x
;
3907 plane
[1] = state
->clip_planes
[index
].y
;
3908 plane
[2] = state
->clip_planes
[index
].z
;
3909 plane
[3] = state
->clip_planes
[index
].w
;
3911 TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
3912 plane
[0], plane
[1], plane
[2], plane
[3]);
3913 gl_info
->gl_ops
.gl
.p_glClipPlane(GL_CLIP_PLANE0
+ index
, plane
);
3914 checkGLcall("glClipPlane");
3916 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3919 static void transform_worldex(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3921 UINT matrix
= state_id
- STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0));
3922 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3925 TRACE("Setting world matrix %d\n", matrix
);
3927 if (matrix
>= gl_info
->limits
.blends
)
3929 WARN("Unsupported blend matrix set\n");
3933 if (isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_VIEW
)))
3936 /* GL_MODELVIEW0_ARB: 0x1700
3937 * GL_MODELVIEW1_ARB: 0x850a
3938 * GL_MODELVIEW2_ARB: 0x8722
3939 * GL_MODELVIEW3_ARB: 0x8723
3941 * GL_MODELVIEW31_ARB: 0x873f
3943 if(matrix
== 1) glMat
= GL_MODELVIEW1_ARB
;
3944 else glMat
= GL_MODELVIEW2_ARB
- 2 + matrix
;
3946 gl_info
->gl_ops
.gl
.p_glMatrixMode(glMat
);
3947 checkGLcall("glMatrixMode(glMat)");
3949 /* World matrix 0 is multiplied with the view matrix because d3d uses 3
3950 * matrices while gl uses only 2. To avoid weighting the view matrix
3951 * incorrectly it has to be multiplied into every GL modelview matrix. */
3952 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
].u
.m
[0][0]);
3953 checkGLcall("glLoadMatrixf");
3954 gl_info
->gl_ops
.gl
.p_glMultMatrixf(&state
->transforms
[WINED3D_TS_WORLD_MATRIX(matrix
)].u
.m
[0][0]);
3955 checkGLcall("glMultMatrixf");
3958 static void state_vertexblend_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3960 enum wined3d_vertex_blend_flags f
= state
->render_states
[WINED3D_RS_VERTEXBLEND
];
3961 static unsigned int once
;
3963 if (f
== WINED3D_VBF_DISABLE
)
3966 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", f
);
3967 else WARN("Vertex blend flags %#x not supported.\n", f
);
3970 static void state_vertexblend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3972 enum wined3d_vertex_blend_flags val
= state
->render_states
[WINED3D_RS_VERTEXBLEND
];
3973 struct wined3d_device
*device
= context
->swapchain
->device
;
3974 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
3975 static unsigned int once
;
3979 case WINED3D_VBF_1WEIGHTS
:
3980 case WINED3D_VBF_2WEIGHTS
:
3981 case WINED3D_VBF_3WEIGHTS
:
3982 gl_info
->gl_ops
.gl
.p_glEnable(GL_VERTEX_BLEND_ARB
);
3983 checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
3985 /* D3D adds one more matrix which has weight (1 - sum(weights)).
3986 * This is enabled at context creation with enabling
3987 * GL_WEIGHT_SUM_UNITY_ARB. */
3988 GL_EXTCALL(glVertexBlendARB(state
->render_states
[WINED3D_RS_VERTEXBLEND
] + 1));
3990 if (!device
->vertexBlendUsed
)
3993 for (i
= 1; i
< gl_info
->limits
.blends
; ++i
)
3995 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(i
))))
3996 transform_worldex(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(i
)));
3998 device
->vertexBlendUsed
= TRUE
;
4002 case WINED3D_VBF_TWEENING
:
4003 case WINED3D_VBF_0WEIGHTS
: /* Indexed vertex blending, not supported. */
4004 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", val
);
4005 else WARN("Vertex blend flags %#x not supported.\n", val
);
4007 case WINED3D_VBF_DISABLE
:
4008 gl_info
->gl_ops
.gl
.p_glDisable(GL_VERTEX_BLEND_ARB
);
4009 checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
4014 void transform_view(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4016 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4017 const struct wined3d_light_info
*light
= NULL
;
4020 /* If we are changing the View matrix, reset the light and clipping planes to the new view
4021 * NOTE: We have to reset the positions even if the light/plane is not currently
4022 * enabled, since the call to enable it will not reset the position.
4023 * NOTE2: Apparently texture transforms do NOT need reapplying
4026 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
4027 checkGLcall("glMatrixMode(GL_MODELVIEW)");
4028 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
].u
.m
[0][0]);
4029 checkGLcall("glLoadMatrixf(...)");
4031 /* Reset lights. TODO: Call light apply func */
4032 for (k
= 0; k
< gl_info
->limits
.lights
; ++k
)
4034 if (!(light
= state
->lights
[k
]))
4036 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_POSITION
, light
->lightPosn
);
4037 checkGLcall("glLightfv posn");
4038 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_SPOT_DIRECTION
, light
->lightDirn
);
4039 checkGLcall("glLightfv dirn");
4042 /* Reset Clipping Planes */
4043 for (k
= 0; k
< gl_info
->limits
.clipplanes
; ++k
)
4045 if (!isStateDirty(context
, STATE_CLIPPLANE(k
)))
4046 clipplane(context
, state
, STATE_CLIPPLANE(k
));
4049 if (context
->last_was_rhw
)
4051 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
4052 checkGLcall("glLoadIdentity()");
4053 /* No need to update the world matrix, the identity is fine */
4057 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
4058 * No need to do it here if the state is scheduled for update. */
4059 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0))))
4060 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4062 /* Avoid looping over a number of matrices if the app never used the functionality */
4063 if (context
->swapchain
->device
->vertexBlendUsed
)
4065 for (k
= 1; k
< gl_info
->limits
.blends
; ++k
)
4067 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(k
))))
4068 transform_worldex(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(k
)));
4073 void transform_projection(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4075 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4077 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_PROJECTION
);
4078 checkGLcall("glMatrixMode(GL_PROJECTION)");
4080 /* There are a couple of additional things we have to take into account
4081 * here besides the projection transformation itself:
4082 * - We need to flip along the y-axis in case of offscreen rendering.
4083 * - OpenGL Z range is {-Wc,...,Wc} while D3D Z range is {0,...,Wc}.
4084 * - D3D coordinates refer to pixel centers while GL coordinates refer
4086 * - D3D has a top-left filling convention. We need to maintain this
4087 * even after the y-flip mentioned above.
4088 * In order to handle the last two points, we translate by
4089 * (63.0 / 128.0) / VPw and (63.0 / 128.0) / VPh. This is equivalent to
4090 * translating slightly less than half a pixel. We want the difference to
4091 * be large enough that it doesn't get lost due to rounding inside the
4092 * driver, but small enough to prevent it from interfering with any
4095 if (context
->last_was_rhw
)
4097 /* Transform D3D RHW coordinates to OpenGL clip coordinates. */
4098 double x
= state
->viewport
.x
;
4099 double y
= state
->viewport
.y
;
4100 double w
= state
->viewport
.width
;
4101 double h
= state
->viewport
.height
;
4102 double x_scale
= 2.0 / w
;
4103 double x_offset
= ((63.0 / 64.0) - (2.0 * x
) - w
) / w
;
4104 double y_scale
= context
->render_offscreen
? 2.0 / h
: 2.0 / -h
;
4105 double y_offset
= context
->render_offscreen
4106 ? ((63.0 / 64.0) - (2.0 * y
) - h
) / h
4107 : ((63.0 / 64.0) - (2.0 * y
) - h
) / -h
;
4108 const GLdouble projection
[] =
4110 x_scale
, 0.0, 0.0, 0.0,
4111 0.0, y_scale
, 0.0, 0.0,
4113 x_offset
, y_offset
, -1.0, 1.0,
4116 gl_info
->gl_ops
.gl
.p_glLoadMatrixd(projection
);
4117 checkGLcall("glLoadMatrixd");
4121 double y_scale
= context
->render_offscreen
? -1.0 : 1.0;
4122 double x_offset
= (63.0 / 64.0) / state
->viewport
.width
;
4123 double y_offset
= context
->render_offscreen
4124 ? (63.0 / 64.0) / state
->viewport
.height
4125 : -(63.0 / 64.0) / state
->viewport
.height
;
4126 const GLdouble projection
[] =
4129 0.0, y_scale
, 0.0, 0.0,
4131 x_offset
, y_offset
, -1.0, 1.0,
4134 gl_info
->gl_ops
.gl
.p_glLoadMatrixd(projection
);
4135 checkGLcall("glLoadMatrixd");
4137 gl_info
->gl_ops
.gl
.p_glMultMatrixf(&state
->transforms
[WINED3D_TS_PROJECTION
].u
.m
[0][0]);
4138 checkGLcall("glLoadMatrixf");
4142 /* This should match any arrays loaded in load_vertex_data.
4143 * TODO: Only load / unload arrays if we have to. */
4144 static void unload_vertex_data(const struct wined3d_gl_info
*gl_info
)
4146 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_VERTEX_ARRAY
);
4147 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_NORMAL_ARRAY
);
4148 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_COLOR_ARRAY
);
4149 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4150 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4151 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4152 gl_info
->gl_ops
.gl
.p_glDisableClientState(GL_WEIGHT_ARRAY_ARB
);
4153 unload_tex_coords(gl_info
);
4156 static inline void unload_numbered_array(struct wined3d_context
*context
, int i
)
4158 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4160 GL_EXTCALL(glDisableVertexAttribArray(i
));
4161 checkGLcall("glDisableVertexAttribArray");
4162 if (gl_info
->supported
[ARB_INSTANCED_ARRAYS
])
4163 GL_EXTCALL(glVertexAttribDivisor(i
, 0));
4165 context
->numbered_array_mask
&= ~(1 << i
);
4168 /* This should match any arrays loaded in loadNumberedArrays
4169 * TODO: Only load / unload arrays if we have to. */
4170 static void unload_numbered_arrays(struct wined3d_context
*context
)
4172 /* disable any attribs (this is the same for both GLSL and ARB modes) */
4175 for (i
= 0; i
< context
->gl_info
->limits
.vertex_attribs
; ++i
) {
4176 unload_numbered_array(context
, i
);
4180 static void load_numbered_arrays(struct wined3d_context
*context
,
4181 const struct wined3d_stream_info
*stream_info
, const struct wined3d_state
*state
)
4183 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4184 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4187 /* Default to no instancing */
4188 context
->instance_count
= 0;
4190 for (i
= 0; i
< MAX_ATTRIBS
; i
++)
4192 const struct wined3d_stream_state
*stream
;
4194 if (!(stream_info
->use_map
& (1 << i
)))
4196 if (context
->numbered_array_mask
& (1 << i
))
4197 unload_numbered_array(context
, i
);
4198 if (state
->shader
[WINED3D_SHADER_TYPE_VERTEX
]->reg_maps
.input_registers
& (1 << i
))
4199 GL_EXTCALL(glVertexAttrib4f(i
, 0.0f
, 0.0f
, 0.0f
, 0.0f
));
4203 stream
= &state
->streams
[stream_info
->elements
[i
].stream_idx
];
4205 if (stream
->flags
& WINED3DSTREAMSOURCE_INSTANCEDATA
)
4207 if (!context
->instance_count
)
4208 context
->instance_count
= state
->streams
[0].frequency
? state
->streams
[0].frequency
: 1;
4210 if (!gl_info
->supported
[ARB_INSTANCED_ARRAYS
])
4212 /* Unload instanced arrays, they will be loaded using
4213 * immediate mode instead. */
4214 if (context
->numbered_array_mask
& (1 << i
))
4215 unload_numbered_array(context
, i
);
4219 GL_EXTCALL(glVertexAttribDivisor(i
, 1));
4221 else if (gl_info
->supported
[ARB_INSTANCED_ARRAYS
])
4223 GL_EXTCALL(glVertexAttribDivisor(i
, 0));
4226 TRACE_(d3d_shader
)("Loading array %u [VBO=%u]\n", i
, stream_info
->elements
[i
].data
.buffer_object
);
4228 if (stream_info
->elements
[i
].stride
)
4230 if (curVBO
!= stream_info
->elements
[i
].data
.buffer_object
)
4232 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, stream_info
->elements
[i
].data
.buffer_object
));
4233 checkGLcall("glBindBuffer");
4234 curVBO
= stream_info
->elements
[i
].data
.buffer_object
;
4236 /* Use the VBO to find out if a vertex buffer exists, not the vb
4237 * pointer. vb can point to a user pointer data blob. In that case
4238 * curVBO will be 0. If there is a vertex buffer but no vbo we
4239 * won't be load converted attributes anyway. */
4240 GL_EXTCALL(glVertexAttribPointer(i
, stream_info
->elements
[i
].format
->gl_vtx_format
,
4241 stream_info
->elements
[i
].format
->gl_vtx_type
,
4242 stream_info
->elements
[i
].format
->gl_normalized
,
4243 stream_info
->elements
[i
].stride
, stream_info
->elements
[i
].data
.addr
4244 + state
->load_base_vertex_index
* stream_info
->elements
[i
].stride
));
4246 if (!(context
->numbered_array_mask
& (1 << i
)))
4248 GL_EXTCALL(glEnableVertexAttribArray(i
));
4249 context
->numbered_array_mask
|= (1 << i
);
4254 /* Stride = 0 means always the same values.
4255 * glVertexAttribPointer doesn't do that. Instead disable the
4256 * pointer and set up the attribute statically. But we have to
4257 * figure out the system memory address. */
4258 const BYTE
*ptr
= stream_info
->elements
[i
].data
.addr
;
4259 if (stream_info
->elements
[i
].data
.buffer_object
)
4261 ptr
+= (ULONG_PTR
)buffer_get_sysmem(stream
->buffer
, context
);
4264 if (context
->numbered_array_mask
& (1 << i
)) unload_numbered_array(context
, i
);
4266 switch (stream_info
->elements
[i
].format
->id
)
4268 case WINED3DFMT_R32_FLOAT
:
4269 GL_EXTCALL(glVertexAttrib1fv(i
, (const GLfloat
*)ptr
));
4271 case WINED3DFMT_R32G32_FLOAT
:
4272 GL_EXTCALL(glVertexAttrib2fv(i
, (const GLfloat
*)ptr
));
4274 case WINED3DFMT_R32G32B32_FLOAT
:
4275 GL_EXTCALL(glVertexAttrib3fv(i
, (const GLfloat
*)ptr
));
4277 case WINED3DFMT_R32G32B32A32_FLOAT
:
4278 GL_EXTCALL(glVertexAttrib4fv(i
, (const GLfloat
*)ptr
));
4281 case WINED3DFMT_R8G8B8A8_UINT
:
4282 GL_EXTCALL(glVertexAttrib4ubv(i
, ptr
));
4284 case WINED3DFMT_B8G8R8A8_UNORM
:
4285 if (gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
])
4287 const DWORD
*src
= (const DWORD
*)ptr
;
4288 DWORD c
= *src
& 0xff00ff00;
4289 c
|= (*src
& 0xff0000) >> 16;
4290 c
|= (*src
& 0xff) << 16;
4291 GL_EXTCALL(glVertexAttrib4Nubv(i
, (GLubyte
*)&c
));
4294 /* else fallthrough */
4295 case WINED3DFMT_R8G8B8A8_UNORM
:
4296 GL_EXTCALL(glVertexAttrib4Nubv(i
, ptr
));
4299 case WINED3DFMT_R16G16_SINT
:
4300 GL_EXTCALL(glVertexAttrib2sv(i
, (const GLshort
*)ptr
));
4302 case WINED3DFMT_R16G16B16A16_SINT
:
4303 GL_EXTCALL(glVertexAttrib4sv(i
, (const GLshort
*)ptr
));
4306 case WINED3DFMT_R16G16_SNORM
:
4308 const GLshort s
[4] = {((const GLshort
*)ptr
)[0], ((const GLshort
*)ptr
)[1], 0, 1};
4309 GL_EXTCALL(glVertexAttrib4Nsv(i
, s
));
4312 case WINED3DFMT_R16G16_UNORM
:
4314 const GLushort s
[4] = {((const GLushort
*)ptr
)[0], ((const GLushort
*)ptr
)[1], 0, 1};
4315 GL_EXTCALL(glVertexAttrib4Nusv(i
, s
));
4318 case WINED3DFMT_R16G16B16A16_SNORM
:
4319 GL_EXTCALL(glVertexAttrib4Nsv(i
, (const GLshort
*)ptr
));
4321 case WINED3DFMT_R16G16B16A16_UNORM
:
4322 GL_EXTCALL(glVertexAttrib4Nusv(i
, (const GLushort
*)ptr
));
4325 case WINED3DFMT_R10G10B10A2_UINT
:
4326 FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
4327 /*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
4329 case WINED3DFMT_R10G10B10A2_SNORM
:
4330 FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
4331 /*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
4334 case WINED3DFMT_R16G16_FLOAT
:
4335 if (gl_info
->supported
[NV_HALF_FLOAT
] && gl_info
->supported
[NV_VERTEX_PROGRAM
])
4337 /* Not supported by GL_ARB_half_float_vertex. */
4338 GL_EXTCALL(glVertexAttrib2hvNV(i
, (const GLhalfNV
*)ptr
));
4342 float x
= float_16_to_32(((const unsigned short *)ptr
) + 0);
4343 float y
= float_16_to_32(((const unsigned short *)ptr
) + 1);
4344 GL_EXTCALL(glVertexAttrib2f(i
, x
, y
));
4347 case WINED3DFMT_R16G16B16A16_FLOAT
:
4348 if (gl_info
->supported
[NV_HALF_FLOAT
] && gl_info
->supported
[NV_VERTEX_PROGRAM
])
4350 /* Not supported by GL_ARB_half_float_vertex. */
4351 GL_EXTCALL(glVertexAttrib4hvNV(i
, (const GLhalfNV
*)ptr
));
4355 float x
= float_16_to_32(((const unsigned short *)ptr
) + 0);
4356 float y
= float_16_to_32(((const unsigned short *)ptr
) + 1);
4357 float z
= float_16_to_32(((const unsigned short *)ptr
) + 2);
4358 float w
= float_16_to_32(((const unsigned short *)ptr
) + 3);
4359 GL_EXTCALL(glVertexAttrib4f(i
, x
, y
, z
, w
));
4364 ERR("Unexpected declaration in stride 0 attributes\n");
4370 checkGLcall("Loading numbered arrays");
4373 static void load_vertex_data(struct wined3d_context
*context
,
4374 const struct wined3d_stream_info
*si
, const struct wined3d_state
*state
)
4376 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4377 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
4378 const struct wined3d_stream_info_element
*e
;
4380 TRACE("Using fast vertex array code\n");
4382 /* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
4383 context
->instance_count
= 0;
4385 /* Blend Data ---------------------------------------------- */
4386 if ((si
->use_map
& (1 << WINED3D_FFP_BLENDWEIGHT
))
4387 || si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4389 e
= &si
->elements
[WINED3D_FFP_BLENDWEIGHT
];
4391 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4393 TRACE("Blend %u %p %u\n", e
->format
->component_count
,
4394 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
, e
->stride
);
4396 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_WEIGHT_ARRAY_ARB
);
4397 checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
4399 GL_EXTCALL(glVertexBlendARB(e
->format
->component_count
+ 1));
4401 if (curVBO
!= e
->data
.buffer_object
)
4403 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
4404 checkGLcall("glBindBuffer");
4405 curVBO
= e
->data
.buffer_object
;
4408 TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
4409 e
->format
->gl_vtx_format
,
4410 e
->format
->gl_vtx_type
,
4412 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4413 GL_EXTCALL(glWeightPointerARB(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4414 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
));
4416 checkGLcall("glWeightPointerARB");
4418 if (si
->use_map
& (1 << WINED3D_FFP_BLENDINDICES
))
4423 FIXME("blendMatrixIndices support\n");
4428 /* TODO: support blends in drawStridedSlow
4429 * No need to write a FIXME here, this is done after the general vertex decl decoding
4431 WARN("unsupported blending in openGl\n");
4436 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
4438 static const GLbyte one
= 1;
4439 GL_EXTCALL(glWeightbvARB(1, &one
));
4440 checkGLcall("glWeightbvARB(gl_info->max_blends, weights)");
4444 /* Point Size ----------------------------------------------*/
4445 if (si
->use_map
& (1 << WINED3D_FFP_PSIZE
))
4447 /* no such functionality in the fixed function GL pipeline */
4448 TRACE("Cannot change ptSize here in openGl\n");
4449 /* TODO: Implement this function in using shaders if they are available */
4452 /* Vertex Pointers -----------------------------------------*/
4453 if (si
->use_map
& (1 << WINED3D_FFP_POSITION
))
4455 e
= &si
->elements
[WINED3D_FFP_POSITION
];
4457 if (curVBO
!= e
->data
.buffer_object
)
4459 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
4460 checkGLcall("glBindBuffer");
4461 curVBO
= e
->data
.buffer_object
;
4464 TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
4465 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4466 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4467 gl_info
->gl_ops
.gl
.p_glVertexPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4468 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4469 checkGLcall("glVertexPointer(...)");
4470 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_VERTEX_ARRAY
);
4471 checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
4474 /* Normals -------------------------------------------------*/
4475 if (si
->use_map
& (1 << WINED3D_FFP_NORMAL
))
4477 e
= &si
->elements
[WINED3D_FFP_NORMAL
];
4479 if (curVBO
!= e
->data
.buffer_object
)
4481 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
4482 checkGLcall("glBindBuffer");
4483 curVBO
= e
->data
.buffer_object
;
4486 TRACE("glNormalPointer(%#x, %#x, %p);\n", e
->format
->gl_vtx_type
, e
->stride
,
4487 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4488 gl_info
->gl_ops
.gl
.p_glNormalPointer(e
->format
->gl_vtx_type
, e
->stride
,
4489 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4490 checkGLcall("glNormalPointer(...)");
4491 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_NORMAL_ARRAY
);
4492 checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
4497 gl_info
->gl_ops
.gl
.p_glNormal3f(0, 0, 0);
4498 checkGLcall("glNormal3f(0, 0, 0)");
4501 /* Diffuse Colour --------------------------------------------*/
4502 if (si
->use_map
& (1 << WINED3D_FFP_DIFFUSE
))
4504 e
= &si
->elements
[WINED3D_FFP_DIFFUSE
];
4506 if (curVBO
!= e
->data
.buffer_object
)
4508 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
4509 checkGLcall("glBindBuffer");
4510 curVBO
= e
->data
.buffer_object
;
4513 TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
4514 e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4515 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4516 gl_info
->gl_ops
.gl
.p_glColorPointer(e
->format
->gl_vtx_format
, e
->format
->gl_vtx_type
, e
->stride
,
4517 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4518 checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
4519 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_COLOR_ARRAY
);
4520 checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
4525 gl_info
->gl_ops
.gl
.p_glColor4f(1.0f
, 1.0f
, 1.0f
, 1.0f
);
4526 checkGLcall("glColor4f(1, 1, 1, 1)");
4529 /* Specular Colour ------------------------------------------*/
4530 if (si
->use_map
& (1 << WINED3D_FFP_SPECULAR
))
4532 TRACE("setting specular colour\n");
4534 e
= &si
->elements
[WINED3D_FFP_SPECULAR
];
4536 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4538 GLenum type
= e
->format
->gl_vtx_type
;
4539 GLint format
= e
->format
->gl_vtx_format
;
4541 if (curVBO
!= e
->data
.buffer_object
)
4543 GL_EXTCALL(glBindBuffer(GL_ARRAY_BUFFER
, e
->data
.buffer_object
));
4544 checkGLcall("glBindBuffer");
4545 curVBO
= e
->data
.buffer_object
;
4548 if (format
!= 4 || (gl_info
->quirks
& WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA
))
4550 /* Usually specular colors only allow 3 components, since they have no alpha. In D3D, the specular alpha
4551 * contains the fog coordinate, which is passed to GL with GL_EXT_fog_coord. However, the fixed function
4552 * vertex pipeline can pass the specular alpha through, and pixel shaders can read it. So it GL accepts
4553 * 4 component secondary colors use it
4555 TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format
, type
, e
->stride
,
4556 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4557 GL_EXTCALL(glSecondaryColorPointerEXT(format
, type
, e
->stride
,
4558 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
));
4559 checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
4565 case GL_UNSIGNED_BYTE
:
4566 TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e
->stride
,
4567 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4568 GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE
, e
->stride
,
4569 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
));
4570 checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
4574 FIXME("Add 4 component specular color pointers for type %x\n", type
);
4575 /* Make sure that the right color component is dropped */
4576 TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type
, e
->stride
,
4577 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
);
4578 GL_EXTCALL(glSecondaryColorPointerEXT(3, type
, e
->stride
,
4579 e
->data
.addr
+ state
->load_base_vertex_index
* e
->stride
));
4580 checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
4583 gl_info
->gl_ops
.gl
.p_glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT
);
4584 checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
4588 WARN("Specular colour is not supported in this GL implementation.\n");
4593 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4595 GL_EXTCALL(glSecondaryColor3fEXT
)(0, 0, 0);
4596 checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
4600 WARN("Specular colour is not supported in this GL implementation.\n");
4604 /* Texture coords -------------------------------------------*/
4605 load_tex_coords(context
, si
, &curVBO
, state
);
4608 static void streamsrc(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4610 BOOL load_numbered
= use_vs(state
) && !context
->use_immediate_mode_draw
;
4611 BOOL load_named
= !use_vs(state
) && !context
->use_immediate_mode_draw
;
4613 if (isStateDirty(context
, STATE_VDECL
)) return;
4614 if (context
->numberedArraysLoaded
&& !load_numbered
)
4616 unload_numbered_arrays(context
);
4617 context
->numberedArraysLoaded
= FALSE
;
4618 context
->numbered_array_mask
= 0;
4620 else if (context
->namedArraysLoaded
)
4622 unload_vertex_data(context
->gl_info
);
4623 context
->namedArraysLoaded
= FALSE
;
4628 TRACE("Loading numbered arrays\n");
4629 load_numbered_arrays(context
, &context
->stream_info
, state
);
4630 context
->numberedArraysLoaded
= TRUE
;
4632 else if (load_named
)
4634 TRACE("Loading vertex data\n");
4635 load_vertex_data(context
, &context
->stream_info
, state
);
4636 context
->namedArraysLoaded
= TRUE
;
4640 static void vdecl_miscpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4642 if (isStateDirty(context
, STATE_STREAMSRC
))
4644 streamsrc(context
, state
, STATE_STREAMSRC
);
4647 void vertexdeclaration(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4649 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4650 BOOL useVertexShaderFunction
= use_vs(state
);
4651 BOOL updateFog
= FALSE
;
4653 BOOL wasrhw
= context
->last_was_rhw
;
4656 transformed
= context
->stream_info
.position_transformed
;
4657 if (transformed
!= context
->last_was_rhw
&& !useVertexShaderFunction
)
4660 context
->last_was_rhw
= transformed
;
4662 /* Don't have to apply the matrices when vertex shaders are used. When
4663 * vshaders are turned off this function will be called again anyway to
4664 * make sure they're properly set. */
4665 if (!useVertexShaderFunction
)
4667 /* TODO: Move this mainly to the viewport state and only apply when
4668 * the vp has changed or transformed / untransformed was switched. */
4669 if (wasrhw
!= context
->last_was_rhw
4670 && !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
))
4671 && !isStateDirty(context
, STATE_VIEWPORT
))
4672 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4673 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
4676 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
4677 * this check will fail and the matrix not applied again. This is OK because a simple
4678 * world matrix change reapplies the matrix - These checks here are only to satisfy the
4679 * needs of the vertex declaration.
4681 * World and view matrix go into the same gl matrix, so only apply them when neither is
4684 if (transformed
!= wasrhw
&& !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)))
4685 && !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_VIEW
)))
4686 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4687 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_COLORVERTEX
)))
4688 context_apply_state(context
, state
, STATE_RENDER(WINED3D_RS_COLORVERTEX
));
4689 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_LIGHTING
)))
4690 state_lighting(context
, state
, STATE_RENDER(WINED3D_RS_LIGHTING
));
4692 if (context
->last_was_vshader
)
4696 if (!context
->d3d_info
->vs_clipping
4697 && !isStateDirty(context
, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
)))
4699 state_clipping(context
, state
, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
));
4702 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4704 clipplane(context
, state
, STATE_CLIPPLANE(i
));
4707 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
)))
4708 state_normalize(context
, state
, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
));
4712 if(!context
->last_was_vshader
) {
4713 static BOOL warned
= FALSE
;
4714 if (!context
->d3d_info
->vs_clipping
)
4716 /* Disable all clip planes to get defined results on all drivers. See comment in the
4717 * state_clipping state handler
4719 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4721 gl_info
->gl_ops
.gl
.p_glDisable(GL_CLIP_PLANE0
+ i
);
4722 checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
4725 if (!warned
&& state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
])
4727 FIXME("Clipping not supported with vertex shaders\n");
4733 /* Apply the transform matrices when switching from rhw
4734 * drawing to vertex shaders. Vertex shaders themselves do
4735 * not need it, but the matrices are not reapplied
4736 * automatically when switching back from vertex shaders to
4737 * fixed function processing. So make sure we leave the fixed
4738 * function vertex processing states back in a sane state
4739 * before switching to shaders. */
4740 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
)))
4741 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4742 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0))))
4743 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4747 /* Vertex shader clipping ignores the view matrix. Update all clipplanes
4748 * (Note: ARB shaders can read the clip planes for clipping emulation even if
4749 * device->vs_clipping is false.
4751 for (i
= 0; i
< gl_info
->limits
.clipplanes
; ++i
)
4753 clipplane(context
, state
, STATE_CLIPPLANE(i
));
4758 context
->last_was_vshader
= useVertexShaderFunction
;
4759 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_VERTEX
;
4762 context_apply_state(context
, state
, STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
));
4764 if (!useVertexShaderFunction
)
4768 for (i
= 0; i
< MAX_TEXTURES
; ++i
)
4770 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ i
)))
4771 transform_texture(context
, state
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
4774 if (use_ps(state
) && state
->shader
[WINED3D_SHADER_TYPE_PIXEL
]->reg_maps
.shader_version
.major
== 1
4775 && state
->shader
[WINED3D_SHADER_TYPE_PIXEL
]->reg_maps
.shader_version
.minor
<= 3)
4776 context
->shader_update_mask
|= 1 << WINED3D_SHADER_TYPE_PIXEL
;
4779 if (transformed
!= wasrhw
&& !isStateDirty(context
, STATE_RENDER(WINED3D_RS_ZENABLE
)))
4780 state_zenable(context
, state
, STATE_RENDER(WINED3D_RS_ZENABLE
));
4783 static void viewport_miscpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4785 const struct wined3d_rendertarget_view
*target
= state
->fb
->render_targets
[0];
4786 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4787 struct wined3d_viewport vp
= state
->viewport
;
4789 if (vp
.width
> target
->width
)
4790 vp
.width
= target
->width
;
4791 if (vp
.height
> target
->height
)
4792 vp
.height
= target
->height
;
4794 gl_info
->gl_ops
.gl
.p_glDepthRange(vp
.min_z
, vp
.max_z
);
4795 checkGLcall("glDepthRange");
4796 /* Note: GL requires lower left, DirectX supplies upper left. This is
4797 * reversed when using offscreen rendering. */
4798 if (context
->render_offscreen
)
4800 gl_info
->gl_ops
.gl
.p_glViewport(vp
.x
, vp
.y
, vp
.width
, vp
.height
);
4806 surface_get_drawable_size(wined3d_rendertarget_view_get_surface(target
), context
, &width
, &height
);
4807 gl_info
->gl_ops
.gl
.p_glViewport(vp
.x
, (height
- (vp
.y
+ vp
.height
)),
4808 vp
.width
, vp
.height
);
4810 checkGLcall("glViewport");
4813 void viewport_vertexpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4815 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
)))
4816 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4817 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
))
4818 && state
->render_states
[WINED3D_RS_POINTSCALEENABLE
])
4819 state_pscale(context
, state
, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
));
4820 /* Update the position fixup. */
4821 context
->constant_update_mask
|= WINED3D_SHADER_CONST_VS_POS_FIXUP
;
4824 void light(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4826 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4827 UINT Index
= state_id
- STATE_ACTIVELIGHT(0);
4828 const struct wined3d_light_info
*lightInfo
= state
->lights
[Index
];
4832 gl_info
->gl_ops
.gl
.p_glDisable(GL_LIGHT0
+ Index
);
4833 checkGLcall("glDisable(GL_LIGHT0 + Index)");
4838 float colRGBA
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
4840 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
4841 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
4842 gl_info
->gl_ops
.gl
.p_glPushMatrix();
4843 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
].u
.m
[0][0]);
4846 colRGBA
[0] = lightInfo
->OriginalParms
.diffuse
.r
;
4847 colRGBA
[1] = lightInfo
->OriginalParms
.diffuse
.g
;
4848 colRGBA
[2] = lightInfo
->OriginalParms
.diffuse
.b
;
4849 colRGBA
[3] = lightInfo
->OriginalParms
.diffuse
.a
;
4850 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_DIFFUSE
, colRGBA
);
4851 checkGLcall("glLightfv");
4854 colRGBA
[0] = lightInfo
->OriginalParms
.specular
.r
;
4855 colRGBA
[1] = lightInfo
->OriginalParms
.specular
.g
;
4856 colRGBA
[2] = lightInfo
->OriginalParms
.specular
.b
;
4857 colRGBA
[3] = lightInfo
->OriginalParms
.specular
.a
;
4858 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_SPECULAR
, colRGBA
);
4859 checkGLcall("glLightfv");
4862 colRGBA
[0] = lightInfo
->OriginalParms
.ambient
.r
;
4863 colRGBA
[1] = lightInfo
->OriginalParms
.ambient
.g
;
4864 colRGBA
[2] = lightInfo
->OriginalParms
.ambient
.b
;
4865 colRGBA
[3] = lightInfo
->OriginalParms
.ambient
.a
;
4866 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_AMBIENT
, colRGBA
);
4867 checkGLcall("glLightfv");
4869 if ((lightInfo
->OriginalParms
.range
* lightInfo
->OriginalParms
.range
) >= FLT_MIN
)
4870 quad_att
= 1.4f
/ (lightInfo
->OriginalParms
.range
* lightInfo
->OriginalParms
.range
);
4872 quad_att
= 0.0f
; /* 0 or MAX? (0 seems to be ok) */
4874 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
4875 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
4876 * Attenuation0 to NaN and crashes in the gl lib
4879 switch (lightInfo
->OriginalParms
.type
)
4881 case WINED3D_LIGHT_POINT
:
4883 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4884 checkGLcall("glLightfv");
4885 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4886 checkGLcall("glLightf");
4887 /* Attenuation - Are these right? guessing... */
4888 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
,
4889 lightInfo
->OriginalParms
.attenuation0
);
4890 checkGLcall("glLightf");
4891 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
,
4892 lightInfo
->OriginalParms
.attenuation1
);
4893 checkGLcall("glLightf");
4894 if (quad_att
< lightInfo
->OriginalParms
.attenuation2
)
4895 quad_att
= lightInfo
->OriginalParms
.attenuation2
;
4896 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4897 checkGLcall("glLightf");
4901 case WINED3D_LIGHT_SPOT
:
4903 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4904 checkGLcall("glLightfv");
4906 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_SPOT_DIRECTION
, &lightInfo
->lightDirn
[0]);
4907 checkGLcall("glLightfv");
4908 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, lightInfo
->exponent
);
4909 checkGLcall("glLightf");
4910 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4911 checkGLcall("glLightf");
4912 /* Attenuation - Are these right? guessing... */
4913 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
,
4914 lightInfo
->OriginalParms
.attenuation0
);
4915 checkGLcall("glLightf");
4916 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
,
4917 lightInfo
->OriginalParms
.attenuation1
);
4918 checkGLcall("glLightf");
4919 if (quad_att
< lightInfo
->OriginalParms
.attenuation2
)
4920 quad_att
= lightInfo
->OriginalParms
.attenuation2
;
4921 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4922 checkGLcall("glLightf");
4926 case WINED3D_LIGHT_DIRECTIONAL
:
4928 /* Note GL uses w position of 0 for direction! */
4929 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->lightPosn
[0]);
4930 checkGLcall("glLightfv");
4931 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4932 checkGLcall("glLightf");
4933 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, 0.0f
);
4934 checkGLcall("glLightf");
4938 FIXME("Unrecognized light type %#x.\n", lightInfo
->OriginalParms
.type
);
4941 /* Restore the modelview matrix */
4942 gl_info
->gl_ops
.gl
.p_glPopMatrix();
4944 gl_info
->gl_ops
.gl
.p_glEnable(GL_LIGHT0
+ Index
);
4945 checkGLcall("glEnable(GL_LIGHT0 + Index)");
4949 static void scissorrect(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4951 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4952 const RECT
*r
= &state
->scissor_rect
;
4954 /* Warning: glScissor uses window coordinates, not viewport coordinates,
4955 * so our viewport correction does not apply. Warning2: Even in windowed
4956 * mode the coords are relative to the window, not the screen. */
4957 TRACE("Setting new scissor rect to %s.\n", wine_dbgstr_rect(r
));
4959 if (context
->render_offscreen
)
4961 gl_info
->gl_ops
.gl
.p_glScissor(r
->left
, r
->top
, r
->right
- r
->left
, r
->bottom
- r
->top
);
4965 const struct wined3d_rendertarget_view
*target
= state
->fb
->render_targets
[0];
4969 surface_get_drawable_size(wined3d_rendertarget_view_get_surface(target
), context
, &width
, &height
);
4970 gl_info
->gl_ops
.gl
.p_glScissor(r
->left
, height
- r
->bottom
, r
->right
- r
->left
, r
->bottom
- r
->top
);
4972 checkGLcall("glScissor");
4975 static void indexbuffer(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4977 const struct wined3d_stream_info
*stream_info
= &context
->stream_info
;
4978 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4980 if (!state
->index_buffer
|| !stream_info
->all_vbo
)
4982 GL_EXTCALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER
, 0));
4986 struct wined3d_buffer
*ib
= state
->index_buffer
;
4987 GL_EXTCALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER
, ib
->buffer_object
));
4991 static void frontface(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4993 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
4995 if (context
->render_offscreen
)
4997 gl_info
->gl_ops
.gl
.p_glFrontFace(GL_CCW
);
4998 checkGLcall("glFrontFace(GL_CCW)");
5002 gl_info
->gl_ops
.gl
.p_glFrontFace(GL_CW
);
5003 checkGLcall("glFrontFace(GL_CW)");
5007 static void psorigin_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5013 WARN("Point sprite coordinate origin switching not supported.\n");
5018 static void psorigin(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5020 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
5021 GLint origin
= context
->render_offscreen
? GL_LOWER_LEFT
: GL_UPPER_LEFT
;
5023 GL_EXTCALL(glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN
, origin
));
5024 checkGLcall("glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
5027 void state_srgbwrite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5029 const struct wined3d_format
*rt_format
= state
->fb
->render_targets
[0]->format
;
5030 const struct wined3d_gl_info
*gl_info
= context
->gl_info
;
5032 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5034 if (state
->render_states
[WINED3D_RS_SRGBWRITEENABLE
]
5035 && rt_format
->flags
& WINED3DFMT_FLAG_SRGB_WRITE
)
5036 gl_info
->gl_ops
.gl
.p_glEnable(GL_FRAMEBUFFER_SRGB
);
5038 gl_info
->gl_ops
.gl
.p_glDisable(GL_FRAMEBUFFER_SRGB
);
5041 static void state_cb(const struct wined3d_gl_info
*gl_info
, const struct wined3d_state
*state
,
5042 enum wined3d_shader_type type
, unsigned int base
, unsigned int count
)
5044 struct wined3d_buffer
*buffer
;
5047 for (i
= 0; i
< count
; ++i
)
5049 buffer
= state
->cb
[type
][i
];
5050 GL_EXTCALL(glBindBufferBase(GL_UNIFORM_BUFFER
, base
+ i
, buffer
? buffer
->buffer_object
: 0));
5052 checkGLcall("glBindBufferBase");
5055 static void state_cb_vs(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5057 const struct wined3d_gl_limits
*limits
= &context
->gl_info
->limits
;
5059 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5061 state_cb(context
->gl_info
, state
, WINED3D_SHADER_TYPE_VERTEX
, 0, limits
->vertex_uniform_blocks
);
5064 static void state_cb_gs(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5066 const struct wined3d_gl_limits
*limits
= &context
->gl_info
->limits
;
5068 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5070 state_cb(context
->gl_info
, state
, WINED3D_SHADER_TYPE_GEOMETRY
,
5071 limits
->vertex_uniform_blocks
, limits
->geometry_uniform_blocks
);
5074 static void state_cb_ps(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5076 const struct wined3d_gl_limits
*limits
= &context
->gl_info
->limits
;
5078 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5080 state_cb(context
->gl_info
, state
, WINED3D_SHADER_TYPE_PIXEL
,
5081 limits
->vertex_uniform_blocks
+ limits
->geometry_uniform_blocks
, limits
->fragment_uniform_blocks
);
5084 static void state_cb_warn(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5086 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5088 WARN("Constant buffers (%s) no supported.\n", debug_d3dstate(state_id
));
5091 static void state_shader_resource_binding(struct wined3d_context
*context
,
5092 const struct wined3d_state
*state
, DWORD state_id
)
5094 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
5096 context
->update_shader_resource_bindings
= 1;
5099 const struct StateEntryTemplate misc_state_template
[] =
5101 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), state_cb_vs
, }, ARB_UNIFORM_BUFFER_OBJECT
},
5102 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
5103 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),{ STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),state_cb_gs
, }, ARB_UNIFORM_BUFFER_OBJECT
},
5104 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),{ STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
5105 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), state_cb_ps
, }, ARB_UNIFORM_BUFFER_OBJECT
},
5106 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
5107 { STATE_SHADER_RESOURCE_BINDING
, { STATE_SHADER_RESOURCE_BINDING
, state_shader_resource_binding
}, WINED3D_GL_EXT_NONE
},
5108 { STATE_RENDER(WINED3D_RS_SRCBLEND
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5109 { STATE_RENDER(WINED3D_RS_DESTBLEND
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5110 { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), state_blend
}, WINED3D_GL_EXT_NONE
},
5111 { STATE_RENDER(WINED3D_RS_EDGEANTIALIAS
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5112 { STATE_RENDER(WINED3D_RS_ANTIALIASEDLINEENABLE
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5113 { STATE_RENDER(WINED3D_RS_SEPARATEALPHABLENDENABLE
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5114 { STATE_RENDER(WINED3D_RS_SRCBLENDALPHA
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5115 { STATE_RENDER(WINED3D_RS_DESTBLENDALPHA
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5116 { STATE_RENDER(WINED3D_RS_DESTBLENDALPHA
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5117 { STATE_RENDER(WINED3D_RS_BLENDOPALPHA
), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5118 { STATE_STREAMSRC
, { STATE_STREAMSRC
, streamsrc
}, WINED3D_GL_EXT_NONE
},
5119 { STATE_VDECL
, { STATE_VDECL
, vdecl_miscpart
}, WINED3D_GL_EXT_NONE
},
5120 { STATE_FRONTFACE
, { STATE_FRONTFACE
, frontface
}, WINED3D_GL_EXT_NONE
},
5121 { STATE_SCISSORRECT
, { STATE_SCISSORRECT
, scissorrect
}, WINED3D_GL_EXT_NONE
},
5122 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin
}, WINED3D_GL_VERSION_2_0
},
5123 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin_w
}, WINED3D_GL_EXT_NONE
},
5125 /* TODO: Move shader constant loading to vertex and fragment pipeline respectively, as soon as the pshader and
5126 * vshader loadings are untied from each other
5128 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5129 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5130 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5131 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5132 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5133 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5134 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5135 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5136 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5137 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5138 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5139 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5140 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5141 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5142 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5143 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5144 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5145 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5146 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5147 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5148 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5149 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5150 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5151 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5152 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5153 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5154 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5155 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5156 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5157 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5158 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5159 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
5160 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5161 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5162 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5163 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5164 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5165 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5166 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5167 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5168 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5169 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5170 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5171 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5172 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5173 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5174 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
5175 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
5177 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_miscpart
}, WINED3D_GL_EXT_NONE
},
5178 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, indexbuffer
}, ARB_VERTEX_BUFFER_OBJECT
},
5179 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, state_nop
}, WINED3D_GL_EXT_NONE
},
5180 { STATE_RENDER(WINED3D_RS_ANTIALIAS
), { STATE_RENDER(WINED3D_RS_ANTIALIAS
), state_antialias
}, WINED3D_GL_EXT_NONE
},
5181 { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE
), { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE
), state_perspective
}, WINED3D_GL_EXT_NONE
},
5182 { STATE_RENDER(WINED3D_RS_ZENABLE
), { STATE_RENDER(WINED3D_RS_ZENABLE
), state_zenable
}, WINED3D_GL_EXT_NONE
},
5183 { STATE_RENDER(WINED3D_RS_WRAPU
), { STATE_RENDER(WINED3D_RS_WRAPU
), state_wrapu
}, WINED3D_GL_EXT_NONE
},
5184 { STATE_RENDER(WINED3D_RS_WRAPV
), { STATE_RENDER(WINED3D_RS_WRAPV
), state_wrapv
}, WINED3D_GL_EXT_NONE
},
5185 { STATE_RENDER(WINED3D_RS_FILLMODE
), { STATE_RENDER(WINED3D_RS_FILLMODE
), state_fillmode
}, WINED3D_GL_EXT_NONE
},
5186 { STATE_RENDER(WINED3D_RS_SHADEMODE
), { STATE_RENDER(WINED3D_RS_SHADEMODE
), state_shademode
}, WINED3D_GL_EXT_NONE
},
5187 { STATE_RENDER(WINED3D_RS_LINEPATTERN
), { STATE_RENDER(WINED3D_RS_LINEPATTERN
), state_linepattern
}, WINED3D_GL_EXT_NONE
},
5188 { STATE_RENDER(WINED3D_RS_MONOENABLE
), { STATE_RENDER(WINED3D_RS_MONOENABLE
), state_monoenable
}, WINED3D_GL_EXT_NONE
},
5189 { STATE_RENDER(WINED3D_RS_ROP2
), { STATE_RENDER(WINED3D_RS_ROP2
), state_rop2
}, WINED3D_GL_EXT_NONE
},
5190 { STATE_RENDER(WINED3D_RS_PLANEMASK
), { STATE_RENDER(WINED3D_RS_PLANEMASK
), state_planemask
}, WINED3D_GL_EXT_NONE
},
5191 { STATE_RENDER(WINED3D_RS_ZWRITEENABLE
), { STATE_RENDER(WINED3D_RS_ZWRITEENABLE
), state_zwritenable
}, WINED3D_GL_EXT_NONE
},
5192 { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), state_alpha
}, WINED3D_GL_EXT_NONE
},
5193 { STATE_RENDER(WINED3D_RS_ALPHAREF
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5194 { STATE_RENDER(WINED3D_RS_ALPHAFUNC
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5195 { STATE_RENDER(WINED3D_RS_COLORKEYENABLE
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5196 { STATE_RENDER(WINED3D_RS_LASTPIXEL
), { STATE_RENDER(WINED3D_RS_LASTPIXEL
), state_lastpixel
}, WINED3D_GL_EXT_NONE
},
5197 { STATE_RENDER(WINED3D_RS_CULLMODE
), { STATE_RENDER(WINED3D_RS_CULLMODE
), state_cullmode
}, WINED3D_GL_EXT_NONE
},
5198 { STATE_RENDER(WINED3D_RS_ZFUNC
), { STATE_RENDER(WINED3D_RS_ZFUNC
), state_zfunc
}, WINED3D_GL_EXT_NONE
},
5199 { STATE_RENDER(WINED3D_RS_DITHERENABLE
), { STATE_RENDER(WINED3D_RS_DITHERENABLE
), state_ditherenable
}, WINED3D_GL_EXT_NONE
},
5200 { STATE_RENDER(WINED3D_RS_SUBPIXEL
), { STATE_RENDER(WINED3D_RS_SUBPIXEL
), state_subpixel
}, WINED3D_GL_EXT_NONE
},
5201 { STATE_RENDER(WINED3D_RS_SUBPIXELX
), { STATE_RENDER(WINED3D_RS_SUBPIXELX
), state_subpixelx
}, WINED3D_GL_EXT_NONE
},
5202 { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA
), { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA
), state_stippledalpha
}, WINED3D_GL_EXT_NONE
},
5203 { STATE_RENDER(WINED3D_RS_STIPPLEENABLE
), { STATE_RENDER(WINED3D_RS_STIPPLEENABLE
), state_stippleenable
}, WINED3D_GL_EXT_NONE
},
5204 { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS
), { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS
), state_mipmaplodbias
}, WINED3D_GL_EXT_NONE
},
5205 { STATE_RENDER(WINED3D_RS_ANISOTROPY
), { STATE_RENDER(WINED3D_RS_ANISOTROPY
), state_anisotropy
}, WINED3D_GL_EXT_NONE
},
5206 { STATE_RENDER(WINED3D_RS_FLUSHBATCH
), { STATE_RENDER(WINED3D_RS_FLUSHBATCH
), state_flushbatch
}, WINED3D_GL_EXT_NONE
},
5207 { STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
),{ STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
),state_translucentsi
}, WINED3D_GL_EXT_NONE
},
5208 { STATE_RENDER(WINED3D_RS_STENCILENABLE
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), state_stencil
}, WINED3D_GL_EXT_NONE
},
5209 { STATE_RENDER(WINED3D_RS_STENCILFAIL
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5210 { STATE_RENDER(WINED3D_RS_STENCILZFAIL
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5211 { STATE_RENDER(WINED3D_RS_STENCILPASS
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5212 { STATE_RENDER(WINED3D_RS_STENCILFUNC
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5213 { STATE_RENDER(WINED3D_RS_STENCILREF
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5214 { STATE_RENDER(WINED3D_RS_STENCILMASK
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5215 { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK
), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK
), state_stencilwrite2s
}, EXT_STENCIL_TWO_SIDE
},
5216 { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK
), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK
), state_stencilwrite
}, WINED3D_GL_EXT_NONE
},
5217 { STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5218 { STATE_RENDER(WINED3D_RS_CCW_STENCILFAIL
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5219 { STATE_RENDER(WINED3D_RS_CCW_STENCILZFAIL
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5220 { STATE_RENDER(WINED3D_RS_CCW_STENCILPASS
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5221 { STATE_RENDER(WINED3D_RS_CCW_STENCILFUNC
), { STATE_RENDER(WINED3D_RS_STENCILENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5222 { STATE_RENDER(WINED3D_RS_WRAP0
), { STATE_RENDER(WINED3D_RS_WRAP0
), state_wrap
}, WINED3D_GL_EXT_NONE
},
5223 { STATE_RENDER(WINED3D_RS_WRAP1
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5224 { STATE_RENDER(WINED3D_RS_WRAP2
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5225 { STATE_RENDER(WINED3D_RS_WRAP3
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5226 { STATE_RENDER(WINED3D_RS_WRAP4
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5227 { STATE_RENDER(WINED3D_RS_WRAP5
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5228 { STATE_RENDER(WINED3D_RS_WRAP6
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5229 { STATE_RENDER(WINED3D_RS_WRAP7
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5230 { STATE_RENDER(WINED3D_RS_WRAP8
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5231 { STATE_RENDER(WINED3D_RS_WRAP9
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5232 { STATE_RENDER(WINED3D_RS_WRAP10
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5233 { STATE_RENDER(WINED3D_RS_WRAP11
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5234 { STATE_RENDER(WINED3D_RS_WRAP12
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5235 { STATE_RENDER(WINED3D_RS_WRAP13
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5236 { STATE_RENDER(WINED3D_RS_WRAP14
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5237 { STATE_RENDER(WINED3D_RS_WRAP15
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
5238 { STATE_RENDER(WINED3D_RS_EXTENTS
), { STATE_RENDER(WINED3D_RS_EXTENTS
), state_extents
}, WINED3D_GL_EXT_NONE
},
5239 { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE
), { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE
), state_ckeyblend
}, WINED3D_GL_EXT_NONE
},
5240 { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING
), { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING
), state_swvp
}, WINED3D_GL_EXT_NONE
},
5241 { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE
), { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE
), state_patchedgestyle
}, WINED3D_GL_EXT_NONE
},
5242 { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS
), { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS
), state_patchsegments
}, WINED3D_GL_EXT_NONE
},
5243 { STATE_RENDER(WINED3D_RS_POSITIONDEGREE
), { STATE_RENDER(WINED3D_RS_POSITIONDEGREE
), state_positiondegree
}, WINED3D_GL_EXT_NONE
},
5244 { STATE_RENDER(WINED3D_RS_NORMALDEGREE
), { STATE_RENDER(WINED3D_RS_NORMALDEGREE
), state_normaldegree
}, WINED3D_GL_EXT_NONE
},
5245 { STATE_RENDER(WINED3D_RS_MINTESSELLATIONLEVEL
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5246 { STATE_RENDER(WINED3D_RS_MAXTESSELLATIONLEVEL
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5247 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_X
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5248 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Y
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5249 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Z
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5250 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_W
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
5251 { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),state_nvdb
}, EXT_DEPTH_BOUNDS_TEST
},
5252 { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),state_tessellation
}, WINED3D_GL_EXT_NONE
},
5253 { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), state_msaa
}, ARB_MULTISAMPLE
},
5254 { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), state_msaa_w
}, WINED3D_GL_EXT_NONE
},
5255 { STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK
), { STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK
), state_multisampmask
}, WINED3D_GL_EXT_NONE
},
5256 { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN
), { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN
), state_debug_monitor
}, WINED3D_GL_EXT_NONE
},
5257 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), state_colorwrite0
}, EXT_DRAW_BUFFERS2
},
5258 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), state_colorwrite
}, WINED3D_GL_EXT_NONE
},
5259 { STATE_RENDER(WINED3D_RS_BLENDOP
), { STATE_RENDER(WINED3D_RS_BLENDOP
), state_blendop
}, EXT_BLEND_MINMAX
},
5260 { STATE_RENDER(WINED3D_RS_BLENDOP
), { STATE_RENDER(WINED3D_RS_BLENDOP
), state_blendop_w
}, WINED3D_GL_EXT_NONE
},
5261 { STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE
), { STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE
), state_scissor
}, WINED3D_GL_EXT_NONE
},
5262 { STATE_RENDER(WINED3D_RS_SLOPESCALEDEPTHBIAS
), { STATE_RENDER(WINED3D_RS_DEPTHBIAS
), NULL
}, WINED3D_GL_EXT_NONE
},
5263 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1
), state_colorwrite1
}, EXT_DRAW_BUFFERS2
},
5264 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5265 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2
), state_colorwrite2
}, EXT_DRAW_BUFFERS2
},
5266 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5267 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3
), state_colorwrite3
}, EXT_DRAW_BUFFERS2
},
5268 { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3
), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5269 { STATE_RENDER(WINED3D_RS_BLENDFACTOR
), { STATE_RENDER(WINED3D_RS_BLENDFACTOR
), state_blendfactor
}, EXT_BLEND_COLOR
},
5270 { STATE_RENDER(WINED3D_RS_BLENDFACTOR
), { STATE_RENDER(WINED3D_RS_BLENDFACTOR
), state_blendfactor_w
}, WINED3D_GL_EXT_NONE
},
5271 { STATE_RENDER(WINED3D_RS_DEPTHBIAS
), { STATE_RENDER(WINED3D_RS_DEPTHBIAS
), state_depthbias
}, WINED3D_GL_EXT_NONE
},
5272 { STATE_RENDER(WINED3D_RS_ZVISIBLE
), { STATE_RENDER(WINED3D_RS_ZVISIBLE
), state_zvisible
}, WINED3D_GL_EXT_NONE
},
5274 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler
}, WINED3D_GL_EXT_NONE
},
5275 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler
}, WINED3D_GL_EXT_NONE
},
5276 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler
}, WINED3D_GL_EXT_NONE
},
5277 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler
}, WINED3D_GL_EXT_NONE
},
5278 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler
}, WINED3D_GL_EXT_NONE
},
5279 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler
}, WINED3D_GL_EXT_NONE
},
5280 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler
}, WINED3D_GL_EXT_NONE
},
5281 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler
}, WINED3D_GL_EXT_NONE
},
5282 { STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler
}, WINED3D_GL_EXT_NONE
},
5283 { STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler
}, WINED3D_GL_EXT_NONE
},
5284 { STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler
}, WINED3D_GL_EXT_NONE
},
5285 { STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler
}, WINED3D_GL_EXT_NONE
},
5286 { STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler
}, WINED3D_GL_EXT_NONE
},
5287 { STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler
}, WINED3D_GL_EXT_NONE
},
5288 { STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler
}, WINED3D_GL_EXT_NONE
},
5289 { STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler
}, WINED3D_GL_EXT_NONE
},
5290 { STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler
}, WINED3D_GL_EXT_NONE
},
5291 { STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler
}, WINED3D_GL_EXT_NONE
},
5292 { STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler
}, WINED3D_GL_EXT_NONE
},
5293 { STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler
}, WINED3D_GL_EXT_NONE
},
5294 { STATE_BASEVERTEXINDEX
, { STATE_BASEVERTEXINDEX
, state_nop
, }, ARB_DRAW_ELEMENTS_BASE_VERTEX
},
5295 { STATE_BASEVERTEXINDEX
, { STATE_STREAMSRC
, NULL
, }, WINED3D_GL_EXT_NONE
},
5296 { STATE_FRAMEBUFFER
, { STATE_FRAMEBUFFER
, context_state_fb
}, WINED3D_GL_EXT_NONE
},
5297 { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), context_state_drawbuf
},WINED3D_GL_EXT_NONE
},
5298 { STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
), { STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
), state_geometry_shader
}, WINED3D_GL_EXT_NONE
},
5299 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5302 static const struct StateEntryTemplate vp_ffp_states
[] =
5304 { STATE_VDECL
, { STATE_VDECL
, vertexdeclaration
}, WINED3D_GL_EXT_NONE
},
5305 { STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
5306 { STATE_MATERIAL
, { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5307 { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), state_specularenable
}, WINED3D_GL_EXT_NONE
},
5309 { STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane
}, WINED3D_GL_EXT_NONE
},
5310 { STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane
}, WINED3D_GL_EXT_NONE
},
5311 { STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane
}, WINED3D_GL_EXT_NONE
},
5312 { STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane
}, WINED3D_GL_EXT_NONE
},
5313 { STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane
}, WINED3D_GL_EXT_NONE
},
5314 { STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane
}, WINED3D_GL_EXT_NONE
},
5315 { STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane
}, WINED3D_GL_EXT_NONE
},
5316 { STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane
}, WINED3D_GL_EXT_NONE
},
5317 { STATE_CLIPPLANE(8), { STATE_CLIPPLANE(8), clipplane
}, WINED3D_GL_EXT_NONE
},
5318 { STATE_CLIPPLANE(9), { STATE_CLIPPLANE(9), clipplane
}, WINED3D_GL_EXT_NONE
},
5319 { STATE_CLIPPLANE(10), { STATE_CLIPPLANE(10), clipplane
}, WINED3D_GL_EXT_NONE
},
5320 { STATE_CLIPPLANE(11), { STATE_CLIPPLANE(11), clipplane
}, WINED3D_GL_EXT_NONE
},
5321 { STATE_CLIPPLANE(12), { STATE_CLIPPLANE(12), clipplane
}, WINED3D_GL_EXT_NONE
},
5322 { STATE_CLIPPLANE(13), { STATE_CLIPPLANE(13), clipplane
}, WINED3D_GL_EXT_NONE
},
5323 { STATE_CLIPPLANE(14), { STATE_CLIPPLANE(14), clipplane
}, WINED3D_GL_EXT_NONE
},
5324 { STATE_CLIPPLANE(15), { STATE_CLIPPLANE(15), clipplane
}, WINED3D_GL_EXT_NONE
},
5325 { STATE_CLIPPLANE(16), { STATE_CLIPPLANE(16), clipplane
}, WINED3D_GL_EXT_NONE
},
5326 { STATE_CLIPPLANE(17), { STATE_CLIPPLANE(17), clipplane
}, WINED3D_GL_EXT_NONE
},
5327 { STATE_CLIPPLANE(18), { STATE_CLIPPLANE(18), clipplane
}, WINED3D_GL_EXT_NONE
},
5328 { STATE_CLIPPLANE(19), { STATE_CLIPPLANE(19), clipplane
}, WINED3D_GL_EXT_NONE
},
5329 { STATE_CLIPPLANE(20), { STATE_CLIPPLANE(20), clipplane
}, WINED3D_GL_EXT_NONE
},
5330 { STATE_CLIPPLANE(21), { STATE_CLIPPLANE(21), clipplane
}, WINED3D_GL_EXT_NONE
},
5331 { STATE_CLIPPLANE(22), { STATE_CLIPPLANE(22), clipplane
}, WINED3D_GL_EXT_NONE
},
5332 { STATE_CLIPPLANE(23), { STATE_CLIPPLANE(23), clipplane
}, WINED3D_GL_EXT_NONE
},
5333 { STATE_CLIPPLANE(24), { STATE_CLIPPLANE(24), clipplane
}, WINED3D_GL_EXT_NONE
},
5334 { STATE_CLIPPLANE(25), { STATE_CLIPPLANE(25), clipplane
}, WINED3D_GL_EXT_NONE
},
5335 { STATE_CLIPPLANE(26), { STATE_CLIPPLANE(26), clipplane
}, WINED3D_GL_EXT_NONE
},
5336 { STATE_CLIPPLANE(27), { STATE_CLIPPLANE(27), clipplane
}, WINED3D_GL_EXT_NONE
},
5337 { STATE_CLIPPLANE(28), { STATE_CLIPPLANE(28), clipplane
}, WINED3D_GL_EXT_NONE
},
5338 { STATE_CLIPPLANE(29), { STATE_CLIPPLANE(29), clipplane
}, WINED3D_GL_EXT_NONE
},
5339 { STATE_CLIPPLANE(30), { STATE_CLIPPLANE(30), clipplane
}, WINED3D_GL_EXT_NONE
},
5340 { STATE_CLIPPLANE(31), { STATE_CLIPPLANE(31), clipplane
}, WINED3D_GL_EXT_NONE
},
5342 { STATE_LIGHT_TYPE
, { STATE_LIGHT_TYPE
, state_nop
}, WINED3D_GL_EXT_NONE
},
5343 { STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light
}, WINED3D_GL_EXT_NONE
},
5344 { STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light
}, WINED3D_GL_EXT_NONE
},
5345 { STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light
}, WINED3D_GL_EXT_NONE
},
5346 { STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light
}, WINED3D_GL_EXT_NONE
},
5347 { STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light
}, WINED3D_GL_EXT_NONE
},
5348 { STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light
}, WINED3D_GL_EXT_NONE
},
5349 { STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light
}, WINED3D_GL_EXT_NONE
},
5350 { STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light
}, WINED3D_GL_EXT_NONE
},
5352 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_vertexpart
}, WINED3D_GL_EXT_NONE
},
5353 /* Transform states follow */
5354 { STATE_TRANSFORM(WINED3D_TS_VIEW
), { STATE_TRANSFORM(WINED3D_TS_VIEW
), transform_view
}, WINED3D_GL_EXT_NONE
},
5355 { STATE_TRANSFORM(WINED3D_TS_PROJECTION
), { STATE_TRANSFORM(WINED3D_TS_PROJECTION
), transform_projection
}, WINED3D_GL_EXT_NONE
},
5356 { STATE_TRANSFORM(WINED3D_TS_TEXTURE0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5357 { STATE_TRANSFORM(WINED3D_TS_TEXTURE1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5358 { STATE_TRANSFORM(WINED3D_TS_TEXTURE2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5359 { STATE_TRANSFORM(WINED3D_TS_TEXTURE3
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5360 { STATE_TRANSFORM(WINED3D_TS_TEXTURE4
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5361 { STATE_TRANSFORM(WINED3D_TS_TEXTURE5
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5362 { STATE_TRANSFORM(WINED3D_TS_TEXTURE6
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5363 { STATE_TRANSFORM(WINED3D_TS_TEXTURE7
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
5364 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), transform_world
}, WINED3D_GL_EXT_NONE
},
5365 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5366 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5367 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5368 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5369 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5370 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5371 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5372 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5373 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5374 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5375 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5376 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5377 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5378 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5379 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5380 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5381 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5382 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5383 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5384 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5385 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5386 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5387 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5388 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5389 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5390 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5391 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5392 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5393 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5394 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5395 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5396 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5397 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5398 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5399 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5400 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5401 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5402 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5403 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5404 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5405 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5406 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5407 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5408 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5409 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5410 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5411 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5412 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5413 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5414 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5415 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5416 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5417 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5418 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5419 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5420 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5421 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5422 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5423 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5424 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5425 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5426 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5427 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5428 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5429 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5430 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5431 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5432 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5433 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5434 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5435 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5436 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5437 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5438 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5439 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5440 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5441 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5442 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5443 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5444 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5445 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5446 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5447 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5448 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5449 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5450 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5451 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5452 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5453 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5454 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5455 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5456 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5457 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5458 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5459 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5460 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5461 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5462 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5463 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5464 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5465 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5466 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5467 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5468 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5469 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5470 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5471 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5472 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5473 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5474 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5475 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5476 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5477 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5478 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5479 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5480 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5481 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5482 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5483 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5484 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5485 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5486 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5487 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5488 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5489 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5490 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5491 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5492 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5493 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5494 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5495 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5496 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5497 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5498 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5499 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5500 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5501 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5502 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5503 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5504 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5505 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5506 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5507 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5508 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5509 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5510 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5511 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5512 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5513 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5514 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5515 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5516 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5517 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5518 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5519 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5520 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5521 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5522 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5523 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5524 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5525 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5526 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5527 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5528 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5529 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5530 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5531 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5532 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5533 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5534 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5535 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5536 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5537 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5538 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5539 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5540 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5541 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5542 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5543 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5544 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5545 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5546 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5547 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5548 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5549 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5550 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5551 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5552 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5553 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5554 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5555 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5556 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5557 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5558 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5559 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5560 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5561 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5562 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5563 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5564 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5565 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5566 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5567 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5568 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5569 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5570 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5571 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5572 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5573 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5574 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5575 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5576 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5577 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5578 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5579 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5580 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5581 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5582 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5583 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5584 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5585 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5586 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5587 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5588 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5589 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5590 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5591 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5592 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5593 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5594 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5595 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5596 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5597 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5598 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5599 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5600 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5601 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5602 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5603 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5604 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5605 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5606 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5607 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5608 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5609 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5610 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5611 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5612 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5613 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5614 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5615 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5616 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5617 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5618 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5619 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5620 { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5621 { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5622 { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5623 { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5624 { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5625 { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5626 { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5627 { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5628 { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5629 { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5630 { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5631 { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5632 { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5633 { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5634 { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5635 { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5637 { STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_vertexpart
}, WINED3D_GL_EXT_NONE
},
5638 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5639 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5640 { STATE_RENDER(WINED3D_RS_RANGEFOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5641 { STATE_RENDER(WINED3D_RS_CLIPPING
), { STATE_RENDER(WINED3D_RS_CLIPPING
), state_clipping
}, WINED3D_GL_EXT_NONE
},
5642 { STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
), { STATE_RENDER(WINED3D_RS_CLIPPING
), NULL
}, WINED3D_GL_EXT_NONE
},
5643 { STATE_RENDER(WINED3D_RS_LIGHTING
), { STATE_RENDER(WINED3D_RS_LIGHTING
), state_lighting
}, WINED3D_GL_EXT_NONE
},
5644 { STATE_RENDER(WINED3D_RS_AMBIENT
), { STATE_RENDER(WINED3D_RS_AMBIENT
), state_ambient
}, WINED3D_GL_EXT_NONE
},
5645 { STATE_RENDER(WINED3D_RS_COLORVERTEX
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), state_colormat
}, WINED3D_GL_EXT_NONE
},
5646 { STATE_RENDER(WINED3D_RS_LOCALVIEWER
), { STATE_RENDER(WINED3D_RS_LOCALVIEWER
), state_localviewer
}, WINED3D_GL_EXT_NONE
},
5647 { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), state_normalize
}, WINED3D_GL_EXT_NONE
},
5648 { STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5649 { STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5650 { STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5651 { STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5652 { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), state_vertexblend
}, ARB_VERTEX_BLEND
},
5653 { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), state_vertexblend_w
}, WINED3D_GL_EXT_NONE
},
5654 { STATE_RENDER(WINED3D_RS_POINTSIZE
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5655 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_arb
}, ARB_POINT_PARAMETERS
},
5656 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_ext
}, EXT_POINT_PARAMETERS
},
5657 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_w
}, WINED3D_GL_EXT_NONE
},
5658 { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), state_pointsprite
}, ARB_POINT_SPRITE
},
5659 { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), state_pointsprite_w
}, WINED3D_GL_EXT_NONE
},
5660 { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), state_pscale
}, WINED3D_GL_EXT_NONE
},
5661 { STATE_RENDER(WINED3D_RS_POINTSCALE_A
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5662 { STATE_RENDER(WINED3D_RS_POINTSCALE_B
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5663 { STATE_RENDER(WINED3D_RS_POINTSCALE_C
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5664 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, ARB_POINT_PARAMETERS
},
5665 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, EXT_POINT_PARAMETERS
},
5666 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, WINED3D_GL_EXT_NONE
},
5667 { STATE_RENDER(WINED3D_RS_TWEENFACTOR
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5668 { STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5670 /* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
5671 * so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
5672 * otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
5674 { STATE_SAMPLER(0), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5675 { STATE_SAMPLER(0), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5676 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5677 { STATE_SAMPLER(1), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5678 { STATE_SAMPLER(1), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5679 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5680 { STATE_SAMPLER(2), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5681 { STATE_SAMPLER(2), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5682 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5683 { STATE_SAMPLER(3), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5684 { STATE_SAMPLER(3), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5685 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5686 { STATE_SAMPLER(4), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5687 { STATE_SAMPLER(4), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5688 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5689 { STATE_SAMPLER(5), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5690 { STATE_SAMPLER(5), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5691 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5692 { STATE_SAMPLER(6), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5693 { STATE_SAMPLER(6), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5694 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5695 { STATE_SAMPLER(7), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5696 { STATE_SAMPLER(7), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5697 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5698 { STATE_POINT_SIZE_ENABLE
, { STATE_POINT_SIZE_ENABLE
, state_nop
}, WINED3D_GL_EXT_NONE
},
5699 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5702 static const struct StateEntryTemplate ffp_fragmentstate_template
[] = {
5703 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5704 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5705 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5706 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5707 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5708 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5709 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5710 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5711 { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5712 { STATE_TEXTURESTAGE(0, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5713 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5714 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5715 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5716 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5717 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5718 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5719 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5720 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5721 { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5722 { STATE_TEXTURESTAGE(1, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5723 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5724 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5725 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5726 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5727 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5728 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5729 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5730 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5731 { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5732 { STATE_TEXTURESTAGE(2, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5733 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5734 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5735 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5736 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5737 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5738 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5739 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5740 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5741 { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5742 { STATE_TEXTURESTAGE(3, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5743 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5744 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5745 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5746 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5747 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5748 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5749 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5750 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5751 { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5752 { STATE_TEXTURESTAGE(4, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5753 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5754 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5755 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5756 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5757 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5758 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5759 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5760 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5761 { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5762 { STATE_TEXTURESTAGE(5, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5763 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5764 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5765 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5766 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5767 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5768 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5769 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5770 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5771 { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5772 { STATE_TEXTURESTAGE(6, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5773 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5774 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5775 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5776 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5777 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5778 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5779 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5780 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5781 { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5782 { STATE_TEXTURESTAGE(7, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5783 { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
5784 { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), NULL
}, WINED3D_GL_EXT_NONE
},
5785 { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), state_texfactor
}, WINED3D_GL_EXT_NONE
},
5786 { STATE_RENDER(WINED3D_RS_FOGCOLOR
), { STATE_RENDER(WINED3D_RS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
5787 { STATE_RENDER(WINED3D_RS_FOGDENSITY
), { STATE_RENDER(WINED3D_RS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
5788 { STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
5789 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5790 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5791 { STATE_RENDER(WINED3D_RS_FOGSTART
), { STATE_RENDER(WINED3D_RS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
5792 { STATE_RENDER(WINED3D_RS_FOGEND
), { STATE_RENDER(WINED3D_RS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
5793 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5794 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5795 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5796 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5797 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5798 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5799 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5800 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5801 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5804 /* Context activation is done by the caller. */
5805 static void ffp_enable(const struct wined3d_gl_info
*gl_info
, BOOL enable
) {}
5807 static void *ffp_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
5812 static void ffp_free(struct wined3d_device
*device
) {}
5814 static void vp_ffp_get_caps(const struct wined3d_gl_info
*gl_info
, struct wined3d_vertex_caps
*caps
)
5816 caps
->xyzrhw
= FALSE
;
5817 caps
->max_active_lights
= gl_info
->limits
.lights
;
5818 caps
->max_vertex_blend_matrices
= gl_info
->limits
.blends
;
5819 caps
->max_vertex_blend_matrix_index
= 0;
5820 caps
->vertex_processing_caps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
5821 | WINED3DVTXPCAPS_MATERIALSOURCE7
5822 | WINED3DVTXPCAPS_POSITIONALLIGHTS
5823 | WINED3DVTXPCAPS_LOCALVIEWER
5824 | WINED3DVTXPCAPS_VERTEXFOG
5825 | WINED3DVTXPCAPS_TEXGEN
5826 | WINED3DVTXPCAPS_TEXGEN_SPHEREMAP
;
5827 caps
->fvf_caps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
5828 caps
->max_user_clip_planes
= gl_info
->limits
.clipplanes
;
5829 caps
->raster_caps
= 0;
5830 if (gl_info
->supported
[NV_FOG_DISTANCE
])
5831 caps
->raster_caps
|= WINED3DPRASTERCAPS_FOGRANGE
;
5834 const struct wined3d_vertex_pipe_ops ffp_vertex_pipe
=
5843 static void ffp_fragment_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*caps
)
5845 caps
->wined3d_caps
= 0;
5846 caps
->PrimitiveMiscCaps
= 0;
5847 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
5848 | WINED3DTEXOPCAPS_ADDSIGNED
5849 | WINED3DTEXOPCAPS_ADDSIGNED2X
5850 | WINED3DTEXOPCAPS_MODULATE
5851 | WINED3DTEXOPCAPS_MODULATE2X
5852 | WINED3DTEXOPCAPS_MODULATE4X
5853 | WINED3DTEXOPCAPS_SELECTARG1
5854 | WINED3DTEXOPCAPS_SELECTARG2
5855 | WINED3DTEXOPCAPS_DISABLE
;
5857 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
]
5858 || gl_info
->supported
[EXT_TEXTURE_ENV_COMBINE
]
5859 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5861 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
5862 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
5863 | WINED3DTEXOPCAPS_BLENDFACTORALPHA
5864 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
5865 | WINED3DTEXOPCAPS_LERP
5866 | WINED3DTEXOPCAPS_SUBTRACT
;
5868 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
]
5869 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5871 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_ADDSMOOTH
5872 | WINED3DTEXOPCAPS_MULTIPLYADD
5873 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
5874 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
5875 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
;
5877 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
5878 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_DOTPRODUCT3
;
5880 caps
->MaxTextureBlendStages
= gl_info
->limits
.textures
;
5881 caps
->MaxSimultaneousTextures
= gl_info
->limits
.textures
;
5884 static BOOL
ffp_color_fixup_supported(struct color_fixup_desc fixup
)
5888 TRACE("Checking support for fixup:\n");
5889 dump_color_fixup_desc(fixup
);
5892 /* We only support identity conversions. */
5893 if (is_identity_fixup(fixup
))
5899 TRACE("[FAILED]\n");
5903 const struct fragment_pipeline ffp_fragment_pipeline
= {
5905 ffp_fragment_get_caps
,
5908 ffp_color_fixup_supported
,
5909 ffp_fragmentstate_template
,
5912 static void none_enable(const struct wined3d_gl_info
*gl_info
, BOOL enable
) {}
5914 static void *none_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
5919 static void none_free(struct wined3d_device
*device
) {}
5921 static void vp_none_get_caps(const struct wined3d_gl_info
*gl_info
, struct wined3d_vertex_caps
*caps
)
5923 memset(caps
, 0, sizeof(*caps
));
5926 const struct wined3d_vertex_pipe_ops none_vertex_pipe
=
5935 static void fp_none_get_caps(const struct wined3d_gl_info
*gl_info
, struct fragment_caps
*caps
)
5937 memset(caps
, 0, sizeof(*caps
));
5940 static BOOL
fp_none_color_fixup_supported(struct color_fixup_desc fixup
)
5942 return is_identity_fixup(fixup
);
5945 const struct fragment_pipeline none_fragment_pipe
=
5951 fp_none_color_fixup_supported
,
5955 static unsigned int num_handlers(const APPLYSTATEFUNC
*funcs
)
5958 for(i
= 0; funcs
[i
]; i
++);
5962 static void multistate_apply_2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5964 context
->swapchain
->device
->multistate_funcs
[state_id
][0](context
, state
, state_id
);
5965 context
->swapchain
->device
->multistate_funcs
[state_id
][1](context
, state
, state_id
);
5968 static void multistate_apply_3(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5970 context
->swapchain
->device
->multistate_funcs
[state_id
][0](context
, state
, state_id
);
5971 context
->swapchain
->device
->multistate_funcs
[state_id
][1](context
, state
, state_id
);
5972 context
->swapchain
->device
->multistate_funcs
[state_id
][2](context
, state
, state_id
);
5975 static void prune_invalid_states(struct StateEntry
*state_table
, const struct wined3d_gl_info
*gl_info
,
5976 const struct wined3d_d3d_info
*d3d_info
)
5978 unsigned int start
, last
, i
;
5980 start
= STATE_TEXTURESTAGE(d3d_info
->limits
.ffp_blend_stages
, 0);
5981 last
= STATE_TEXTURESTAGE(MAX_TEXTURES
- 1, WINED3D_HIGHEST_TEXTURE_STATE
);
5982 for (i
= start
; i
<= last
; ++i
)
5984 state_table
[i
].representative
= 0;
5985 state_table
[i
].apply
= state_undefined
;
5988 start
= STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ d3d_info
->limits
.ffp_blend_stages
);
5989 last
= STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ MAX_TEXTURES
- 1);
5990 for (i
= start
; i
<= last
; ++i
)
5992 state_table
[i
].representative
= 0;
5993 state_table
[i
].apply
= state_undefined
;
5996 start
= STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(gl_info
->limits
.blends
));
5997 last
= STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255));
5998 for (i
= start
; i
<= last
; ++i
)
6000 state_table
[i
].representative
= 0;
6001 state_table
[i
].apply
= state_undefined
;
6005 static void validate_state_table(struct StateEntry
*state_table
)
6027 static const DWORD simple_states
[] =
6033 STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
),
6034 STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
),
6035 STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
),
6036 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
),
6037 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),
6038 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
),
6039 STATE_SHADER_RESOURCE_BINDING
,
6044 STATE_POINTSPRITECOORDORIGIN
,
6045 STATE_BASEVERTEXINDEX
,
6047 STATE_POINT_SIZE_ENABLE
,
6049 unsigned int i
, current
;
6051 for (i
= STATE_RENDER(1), current
= 0; i
<= STATE_RENDER(WINEHIGHEST_RENDER_STATE
); ++i
)
6053 if (!rs_holes
[current
].first
|| i
< STATE_RENDER(rs_holes
[current
].first
))
6055 if (!state_table
[i
].representative
)
6056 ERR("State %s (%#x) should have a representative.\n", debug_d3dstate(i
), i
);
6058 else if (state_table
[i
].representative
)
6059 ERR("State %s (%#x) shouldn't have a representative.\n", debug_d3dstate(i
), i
);
6061 if (i
== STATE_RENDER(rs_holes
[current
].last
)) ++current
;
6064 for (i
= 0; i
< sizeof(simple_states
) / sizeof(*simple_states
); ++i
)
6066 if (!state_table
[simple_states
[i
]].representative
)
6067 ERR("State %s (%#x) should have a representative.\n",
6068 debug_d3dstate(simple_states
[i
]), simple_states
[i
]);
6071 for (i
= 0; i
< STATE_HIGHEST
+ 1; ++i
)
6073 DWORD rep
= state_table
[i
].representative
;
6076 if (state_table
[rep
].representative
!= rep
)
6078 ERR("State %s (%#x) has invalid representative %s (%#x).\n",
6079 debug_d3dstate(i
), i
, debug_d3dstate(rep
), rep
);
6080 state_table
[i
].representative
= 0;
6085 if (state_table
[i
].apply
)
6086 ERR("State %s (%#x) has both a handler and representative.\n", debug_d3dstate(i
), i
);
6088 else if (!state_table
[i
].apply
)
6090 ERR("Self representing state %s (%#x) has no handler.\n", debug_d3dstate(i
), i
);
6096 HRESULT
compile_state_table(struct StateEntry
*StateTable
, APPLYSTATEFUNC
**dev_multistate_funcs
,
6097 const struct wined3d_gl_info
*gl_info
, const struct wined3d_d3d_info
*d3d_info
,
6098 const struct wined3d_vertex_pipe_ops
*vertex
, const struct fragment_pipeline
*fragment
,
6099 const struct StateEntryTemplate
*misc
)
6101 unsigned int i
, type
, handlers
;
6102 APPLYSTATEFUNC multistate_funcs
[STATE_HIGHEST
+ 1][3];
6103 const struct StateEntryTemplate
*cur
;
6104 BOOL set
[STATE_HIGHEST
+ 1];
6106 memset(multistate_funcs
, 0, sizeof(multistate_funcs
));
6108 for(i
= 0; i
< STATE_HIGHEST
+ 1; i
++) {
6109 StateTable
[i
].representative
= 0;
6110 StateTable
[i
].apply
= state_undefined
;
6113 for(type
= 0; type
< 3; type
++) {
6114 /* This switch decides the order in which the states are applied */
6116 case 0: cur
= misc
; break;
6117 case 1: cur
= fragment
->states
; break;
6118 case 2: cur
= vertex
->vp_states
; break;
6119 default: cur
= NULL
; /* Stupid compiler */
6123 /* GL extension filtering should not prevent multiple handlers being applied from different
6126 memset(set
, 0, sizeof(set
));
6128 for(i
= 0; cur
[i
].state
; i
++) {
6129 APPLYSTATEFUNC
*funcs_array
;
6131 /* Only use the first matching state with the available extension from one template.
6133 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
6134 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
6136 * if GL_XYZ_fancy is supported, ignore the 2nd line
6138 if(set
[cur
[i
].state
]) continue;
6139 /* Skip state lines depending on unsupported extensions */
6140 if (!gl_info
->supported
[cur
[i
].extension
]) continue;
6141 set
[cur
[i
].state
] = TRUE
;
6142 /* In some cases having an extension means that nothing has to be
6143 * done for a state, e.g. if GL_ARB_texture_non_power_of_two is
6144 * supported, the texture coordinate fixup can be ignored. If the
6145 * apply function is used, mark the state set(done above) to prevent
6146 * applying later lines, but do not record anything in the state
6149 if (!cur
[i
].content
.representative
) continue;
6151 handlers
= num_handlers(multistate_funcs
[cur
[i
].state
]);
6152 multistate_funcs
[cur
[i
].state
][handlers
] = cur
[i
].content
.apply
;
6155 StateTable
[cur
[i
].state
].apply
= cur
[i
].content
.apply
;
6158 StateTable
[cur
[i
].state
].apply
= multistate_apply_2
;
6159 dev_multistate_funcs
[cur
[i
].state
] = HeapAlloc(GetProcessHeap(),
6161 sizeof(**dev_multistate_funcs
) * 2);
6162 if (!dev_multistate_funcs
[cur
[i
].state
]) {
6166 dev_multistate_funcs
[cur
[i
].state
][0] = multistate_funcs
[cur
[i
].state
][0];
6167 dev_multistate_funcs
[cur
[i
].state
][1] = multistate_funcs
[cur
[i
].state
][1];
6170 StateTable
[cur
[i
].state
].apply
= multistate_apply_3
;
6171 funcs_array
= HeapReAlloc(GetProcessHeap(),
6173 dev_multistate_funcs
[cur
[i
].state
],
6174 sizeof(**dev_multistate_funcs
) * 3);
6179 dev_multistate_funcs
[cur
[i
].state
] = funcs_array
;
6180 dev_multistate_funcs
[cur
[i
].state
][2] = multistate_funcs
[cur
[i
].state
][2];
6183 ERR("Unexpected amount of state handlers for state %u: %u\n",
6184 cur
[i
].state
, handlers
+ 1);
6187 if (StateTable
[cur
[i
].state
].representative
6188 && StateTable
[cur
[i
].state
].representative
!= cur
[i
].content
.representative
)
6190 FIXME("State %s (%#x) has different representatives in different pipeline parts.\n",
6191 debug_d3dstate(cur
[i
].state
), cur
[i
].state
);
6193 StateTable
[cur
[i
].state
].representative
= cur
[i
].content
.representative
;
6197 prune_invalid_states(StateTable
, gl_info
, d3d_info
);
6198 validate_state_table(StateTable
);
6203 for (i
= 0; i
<= STATE_HIGHEST
; ++i
) {
6204 HeapFree(GetProcessHeap(), 0, dev_multistate_funcs
[i
]);
6207 memset(dev_multistate_funcs
, 0, (STATE_HIGHEST
+ 1)*sizeof(*dev_multistate_funcs
));
6209 return E_OUTOFMEMORY
;