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
30 #include "wined3d_private.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
34 ULONG CDECL
wined3d_blend_state_incref(struct wined3d_blend_state
*state
)
36 ULONG refcount
= InterlockedIncrement(&state
->refcount
);
38 TRACE("%p increasing refcount to %u.\n", state
, refcount
);
43 static void wined3d_blend_state_destroy_object(void *object
)
45 TRACE("object %p.\n", object
);
50 ULONG CDECL
wined3d_blend_state_decref(struct wined3d_blend_state
*state
)
52 ULONG refcount
= wined3d_atomic_decrement_mutex_lock(&state
->refcount
);
53 struct wined3d_device
*device
= state
->device
;
55 TRACE("%p decreasing refcount to %u.\n", state
, refcount
);
59 state
->parent_ops
->wined3d_object_destroyed(state
->parent
);
60 wined3d_cs_destroy_object(device
->cs
, wined3d_blend_state_destroy_object
, state
);
61 wined3d_mutex_unlock();
67 void * CDECL
wined3d_blend_state_get_parent(const struct wined3d_blend_state
*state
)
69 TRACE("state %p.\n", state
);
74 static BOOL
is_dual_source(enum wined3d_blend state
)
76 return state
>= WINED3D_BLEND_SRC1COLOR
&& state
<= WINED3D_BLEND_INVSRC1ALPHA
;
79 HRESULT CDECL
wined3d_blend_state_create(struct wined3d_device
*device
,
80 const struct wined3d_blend_state_desc
*desc
, void *parent
,
81 const struct wined3d_parent_ops
*parent_ops
, struct wined3d_blend_state
**state
)
83 struct wined3d_blend_state
*object
;
85 TRACE("device %p, desc %p, parent %p, parent_ops %p, state %p.\n",
86 device
, desc
, parent
, parent_ops
, state
);
88 if (!(object
= heap_alloc_zero(sizeof(*object
))))
93 object
->parent
= parent
;
94 object
->parent_ops
= parent_ops
;
95 object
->device
= device
;
97 object
->dual_source
= desc
->rt
[0].enable
98 && (is_dual_source(desc
->rt
[0].src
)
99 || is_dual_source(desc
->rt
[0].dst
)
100 || is_dual_source(desc
->rt
[0].src_alpha
)
101 || is_dual_source(desc
->rt
[0].dst_alpha
));
103 TRACE("Created blend state %p.\n", object
);
109 ULONG CDECL
wined3d_depth_stencil_state_incref(struct wined3d_depth_stencil_state
*state
)
111 ULONG refcount
= InterlockedIncrement(&state
->refcount
);
113 TRACE("%p increasing refcount to %u.\n", state
, refcount
);
118 static void wined3d_depth_stencil_state_destroy_object(void *object
)
120 TRACE("object %p.\n", object
);
125 ULONG CDECL
wined3d_depth_stencil_state_decref(struct wined3d_depth_stencil_state
*state
)
127 ULONG refcount
= wined3d_atomic_decrement_mutex_lock(&state
->refcount
);
128 struct wined3d_device
*device
= state
->device
;
130 TRACE("%p decreasing refcount to %u.\n", state
, refcount
);
134 state
->parent_ops
->wined3d_object_destroyed(state
->parent
);
135 wined3d_cs_destroy_object(device
->cs
, wined3d_depth_stencil_state_destroy_object
, state
);
136 wined3d_mutex_unlock();
142 void * CDECL
wined3d_depth_stencil_state_get_parent(const struct wined3d_depth_stencil_state
*state
)
144 TRACE("state %p.\n", state
);
146 return state
->parent
;
149 static bool stencil_op_writes_ds(const struct wined3d_stencil_op_desc
*desc
)
151 return desc
->fail_op
!= WINED3D_STENCIL_OP_KEEP
152 || desc
->depth_fail_op
!= WINED3D_STENCIL_OP_KEEP
153 || desc
->pass_op
!= WINED3D_STENCIL_OP_KEEP
;
156 static bool depth_stencil_state_desc_writes_ds(const struct wined3d_depth_stencil_state_desc
*desc
)
158 if (desc
->depth
&& desc
->depth_write
)
161 if (desc
->stencil
&& desc
->stencil_write_mask
)
163 if (stencil_op_writes_ds(&desc
->front
) || stencil_op_writes_ds(&desc
->back
))
170 HRESULT CDECL
wined3d_depth_stencil_state_create(struct wined3d_device
*device
,
171 const struct wined3d_depth_stencil_state_desc
*desc
, void *parent
,
172 const struct wined3d_parent_ops
*parent_ops
, struct wined3d_depth_stencil_state
**state
)
174 struct wined3d_depth_stencil_state
*object
;
176 TRACE("device %p, desc %p, parent %p, parent_ops %p, state %p.\n",
177 device
, desc
, parent
, parent_ops
, state
);
179 if (!(object
= heap_alloc_zero(sizeof(*object
))))
180 return E_OUTOFMEMORY
;
182 object
->refcount
= 1;
183 object
->desc
= *desc
;
184 object
->parent
= parent
;
185 object
->parent_ops
= parent_ops
;
186 object
->device
= device
;
188 object
->writes_ds
= depth_stencil_state_desc_writes_ds(desc
);
190 TRACE("Created depth/stencil state %p.\n", object
);
196 ULONG CDECL
wined3d_rasterizer_state_incref(struct wined3d_rasterizer_state
*state
)
198 ULONG refcount
= InterlockedIncrement(&state
->refcount
);
200 TRACE("%p increasing refcount to %u.\n", state
, refcount
);
205 static void wined3d_rasterizer_state_destroy_object(void *object
)
207 TRACE("object %p.\n", object
);
212 ULONG CDECL
wined3d_rasterizer_state_decref(struct wined3d_rasterizer_state
*state
)
214 ULONG refcount
= wined3d_atomic_decrement_mutex_lock(&state
->refcount
);
215 struct wined3d_device
*device
= state
->device
;
217 TRACE("%p decreasing refcount to %u.\n", state
, refcount
);
221 state
->parent_ops
->wined3d_object_destroyed(state
->parent
);
222 wined3d_cs_destroy_object(device
->cs
, wined3d_rasterizer_state_destroy_object
, state
);
223 wined3d_mutex_unlock();
229 void * CDECL
wined3d_rasterizer_state_get_parent(const struct wined3d_rasterizer_state
*state
)
231 TRACE("rasterizer_state %p.\n", state
);
233 return state
->parent
;
236 HRESULT CDECL
wined3d_rasterizer_state_create(struct wined3d_device
*device
,
237 const struct wined3d_rasterizer_state_desc
*desc
, void *parent
,
238 const struct wined3d_parent_ops
*parent_ops
, struct wined3d_rasterizer_state
**state
)
240 struct wined3d_rasterizer_state
*object
;
242 TRACE("device %p, desc %p, parent %p, parent_ops %p, state %p.\n",
243 device
, desc
, parent
, parent_ops
, state
);
245 if (!(object
= heap_alloc_zero(sizeof(*object
))))
246 return E_OUTOFMEMORY
;
248 object
->refcount
= 1;
249 object
->desc
= *desc
;
250 object
->parent
= parent
;
251 object
->parent_ops
= parent_ops
;
252 object
->device
= device
;
254 TRACE("Created rasterizer state %p.\n", object
);
260 /* Context activation for state handler is done by the caller. */
262 static void state_undefined(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
264 ERR("Undefined state %s (%#x).\n", debug_d3dstate(state_id
), state_id
);
267 void state_nop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
269 TRACE("%s: nop in current pipe config.\n", debug_d3dstate(state_id
));
272 static void fillmode(const struct wined3d_rasterizer_state
*r
, const struct wined3d_gl_info
*gl_info
)
274 enum wined3d_fill_mode mode
= r
? r
->desc
.fill_mode
: WINED3D_FILL_SOLID
;
278 case WINED3D_FILL_POINT
:
279 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_POINT
);
280 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
282 case WINED3D_FILL_WIREFRAME
:
283 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_LINE
);
284 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
286 case WINED3D_FILL_SOLID
:
287 gl_info
->gl_ops
.gl
.p_glPolygonMode(GL_FRONT_AND_BACK
, GL_FILL
);
288 checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
291 FIXME("Unrecognized fill mode %#x.\n", mode
);
295 static void state_lighting(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
297 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
299 /* Lighting is not enabled if transformed vertices are drawn, but lighting
300 * does not affect the stream sources, so it is not grouped for
301 * performance reasons. */
303 if (state
->render_states
[WINED3D_RS_LIGHTING
]
304 && !context
->stream_info
.position_transformed
)
306 gl_info
->gl_ops
.gl
.p_glEnable(GL_LIGHTING
);
307 checkGLcall("glEnable GL_LIGHTING");
311 gl_info
->gl_ops
.gl
.p_glDisable(GL_LIGHTING
);
312 checkGLcall("glDisable GL_LIGHTING");
316 static void cullmode(const struct wined3d_rasterizer_state
*r
, const struct wined3d_gl_info
*gl_info
)
318 enum wined3d_cull mode
= r
? r
->desc
.cull_mode
: WINED3D_CULL_BACK
;
320 /* glFrontFace() is set in context.c at context init and on an
321 * offscreen / onscreen rendering switch. */
324 case WINED3D_CULL_NONE
:
325 gl_info
->gl_ops
.gl
.p_glDisable(GL_CULL_FACE
);
326 checkGLcall("glDisable GL_CULL_FACE");
328 case WINED3D_CULL_FRONT
:
329 gl_info
->gl_ops
.gl
.p_glEnable(GL_CULL_FACE
);
330 checkGLcall("glEnable GL_CULL_FACE");
331 gl_info
->gl_ops
.gl
.p_glCullFace(GL_FRONT
);
332 checkGLcall("glCullFace(GL_FRONT)");
334 case WINED3D_CULL_BACK
:
335 gl_info
->gl_ops
.gl
.p_glEnable(GL_CULL_FACE
);
336 checkGLcall("glEnable GL_CULL_FACE");
337 gl_info
->gl_ops
.gl
.p_glCullFace(GL_BACK
);
338 checkGLcall("glCullFace(GL_BACK)");
341 FIXME("Unrecognized cull mode %#x.\n", mode
);
345 void state_shademode(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
347 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
349 switch (state
->render_states
[WINED3D_RS_SHADEMODE
])
351 case WINED3D_SHADE_FLAT
:
352 gl_info
->gl_ops
.gl
.p_glShadeModel(GL_FLAT
);
353 checkGLcall("glShadeModel(GL_FLAT)");
355 case WINED3D_SHADE_GOURAUD
:
356 /* WINED3D_SHADE_PHONG in practice is the same as WINED3D_SHADE_GOURAUD
358 case WINED3D_SHADE_PHONG
:
359 gl_info
->gl_ops
.gl
.p_glShadeModel(GL_SMOOTH
);
360 checkGLcall("glShadeModel(GL_SMOOTH)");
363 FIXME("Unrecognized shade mode %#x.\n",
364 state
->render_states
[WINED3D_RS_SHADEMODE
]);
368 static void state_ditherenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
370 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
372 if (state
->render_states
[WINED3D_RS_DITHERENABLE
])
374 gl_info
->gl_ops
.gl
.p_glEnable(GL_DITHER
);
375 checkGLcall("glEnable GL_DITHER");
379 gl_info
->gl_ops
.gl
.p_glDisable(GL_DITHER
);
380 checkGLcall("glDisable GL_DITHER");
384 GLenum
wined3d_gl_compare_func(enum wined3d_cmp_func f
)
388 case WINED3D_CMP_NEVER
:
390 case WINED3D_CMP_LESS
:
392 case WINED3D_CMP_EQUAL
:
394 case WINED3D_CMP_LESSEQUAL
:
396 case WINED3D_CMP_GREATER
:
398 case WINED3D_CMP_NOTEQUAL
:
400 case WINED3D_CMP_GREATEREQUAL
:
402 case WINED3D_CMP_ALWAYS
:
406 WARN("Unrecognized compare function %#x.\n", f
);
408 FIXME("Unrecognized compare function %#x.\n", f
);
413 static void state_ambient(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
415 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
416 struct wined3d_color color
;
418 wined3d_color_from_d3dcolor(&color
, state
->render_states
[WINED3D_RS_AMBIENT
]);
419 TRACE("Setting ambient to %s.\n", debug_color(&color
));
420 gl_info
->gl_ops
.gl
.p_glLightModelfv(GL_LIGHT_MODEL_AMBIENT
, &color
.r
);
421 checkGLcall("glLightModel for MODEL_AMBIENT");
424 static GLenum
gl_blend_op(const struct wined3d_gl_info
*gl_info
, enum wined3d_blend_op op
)
428 case WINED3D_BLEND_OP_ADD
:
430 case WINED3D_BLEND_OP_SUBTRACT
:
431 return gl_info
->supported
[EXT_BLEND_SUBTRACT
] ? GL_FUNC_SUBTRACT
: GL_FUNC_ADD
;
432 case WINED3D_BLEND_OP_REVSUBTRACT
:
433 return gl_info
->supported
[EXT_BLEND_SUBTRACT
] ? GL_FUNC_REVERSE_SUBTRACT
: GL_FUNC_ADD
;
434 case WINED3D_BLEND_OP_MIN
:
435 return gl_info
->supported
[EXT_BLEND_MINMAX
] ? GL_MIN
: GL_FUNC_ADD
;
436 case WINED3D_BLEND_OP_MAX
:
437 return gl_info
->supported
[EXT_BLEND_MINMAX
] ? GL_MAX
: GL_FUNC_ADD
;
440 WARN("Unhandled blend op %#x.\n", op
);
442 FIXME("Unhandled blend op %#x.\n", op
);
447 static void blendop(const struct wined3d_state
*state
, const struct wined3d_gl_info
*gl_info
)
449 const struct wined3d_blend_state
*b
= state
->blend_state
;
450 GLenum blend_equation_alpha
= GL_FUNC_ADD_EXT
;
451 GLenum blend_equation
= GL_FUNC_ADD_EXT
;
453 if (!gl_info
->supported
[WINED3D_GL_BLEND_EQUATION
])
455 WARN("Unsupported in local OpenGL implementation: glBlendEquation.\n");
459 /* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
460 if (b
->desc
.rt
[0].op_alpha
&& !gl_info
->supported
[EXT_BLEND_EQUATION_SEPARATE
])
462 WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparate.\n");
466 blend_equation
= gl_blend_op(gl_info
, b
->desc
.rt
[0].op
);
467 blend_equation_alpha
= gl_blend_op(gl_info
, b
->desc
.rt
[0].op_alpha
);
468 TRACE("blend_equation %#x, blend_equation_alpha %#x.\n", blend_equation
, blend_equation_alpha
);
470 if (b
->desc
.rt
[0].op
!= b
->desc
.rt
[0].op_alpha
)
472 GL_EXTCALL(glBlendEquationSeparate(blend_equation
, blend_equation_alpha
));
473 checkGLcall("glBlendEquationSeparate");
477 GL_EXTCALL(glBlendEquation(blend_equation
));
478 checkGLcall("glBlendEquation");
482 static GLenum
gl_blend_factor(enum wined3d_blend factor
, const struct wined3d_format
*dst_format
)
486 case WINED3D_BLEND_ZERO
:
488 case WINED3D_BLEND_ONE
:
490 case WINED3D_BLEND_SRCCOLOR
:
492 case WINED3D_BLEND_INVSRCCOLOR
:
493 return GL_ONE_MINUS_SRC_COLOR
;
494 case WINED3D_BLEND_SRCALPHA
:
496 case WINED3D_BLEND_INVSRCALPHA
:
497 return GL_ONE_MINUS_SRC_ALPHA
;
498 case WINED3D_BLEND_DESTCOLOR
:
500 case WINED3D_BLEND_INVDESTCOLOR
:
501 return GL_ONE_MINUS_DST_COLOR
;
502 /* To compensate for the lack of format switching with backbuffer
503 * offscreen rendering, and with onscreen rendering, we modify the
504 * alpha test parameters for (INV)DESTALPHA if the render target
505 * doesn't support alpha blending. A nonexistent alpha channel
506 * returns 1.0, so WINED3D_BLEND_DESTALPHA becomes GL_ONE, and
507 * WINED3D_BLEND_INVDESTALPHA becomes GL_ZERO. */
508 case WINED3D_BLEND_DESTALPHA
:
509 return dst_format
->alpha_size
? GL_DST_ALPHA
: GL_ONE
;
510 case WINED3D_BLEND_INVDESTALPHA
:
511 return dst_format
->alpha_size
? GL_ONE_MINUS_DST_ALPHA
: GL_ZERO
;
512 case WINED3D_BLEND_SRCALPHASAT
:
513 return GL_SRC_ALPHA_SATURATE
;
514 case WINED3D_BLEND_BLENDFACTOR
:
515 return GL_CONSTANT_COLOR_EXT
;
516 case WINED3D_BLEND_INVBLENDFACTOR
:
517 return GL_ONE_MINUS_CONSTANT_COLOR_EXT
;
518 case WINED3D_BLEND_SRC1COLOR
:
519 return GL_SRC1_COLOR
;
520 case WINED3D_BLEND_INVSRC1COLOR
:
521 return GL_ONE_MINUS_SRC1_COLOR
;
522 case WINED3D_BLEND_SRC1ALPHA
:
523 return GL_SRC1_ALPHA
;
524 case WINED3D_BLEND_INVSRC1ALPHA
:
525 return GL_ONE_MINUS_SRC1_ALPHA
;
528 WARN("Unhandled blend factor %#x.\n", factor
);
530 FIXME("Unhandled blend factor %#x.\n", factor
);
535 static void gl_blend_from_d3d(GLenum
*src_blend
, GLenum
*dst_blend
,
536 enum wined3d_blend d3d_src_blend
, enum wined3d_blend d3d_dst_blend
,
537 const struct wined3d_format
*rt_format
)
539 /* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
540 * source blending values which are still valid up to d3d9. They should
541 * not occur as dest blend values. */
542 if (d3d_src_blend
== WINED3D_BLEND_BOTHSRCALPHA
)
544 *src_blend
= GL_SRC_ALPHA
;
545 *dst_blend
= GL_ONE_MINUS_SRC_ALPHA
;
547 else if (d3d_src_blend
== WINED3D_BLEND_BOTHINVSRCALPHA
)
549 *src_blend
= GL_ONE_MINUS_SRC_ALPHA
;
550 *dst_blend
= GL_SRC_ALPHA
;
554 *src_blend
= gl_blend_factor(d3d_src_blend
, rt_format
);
555 *dst_blend
= gl_blend_factor(d3d_dst_blend
, rt_format
);
559 static void state_blend_factor_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
561 WARN("Unsupported in local OpenGL implementation: glBlendColor.\n");
564 static void state_blend_factor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
566 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
567 const struct wined3d_color
*factor
= &state
->blend_factor
;
569 TRACE("Setting blend factor to %s.\n", debug_color(factor
));
571 GL_EXTCALL(glBlendColor(factor
->r
, factor
->g
, factor
->b
, factor
->a
));
572 checkGLcall("glBlendColor");
575 static BOOL
is_blend_enabled(struct wined3d_context
*context
, const struct wined3d_state
*state
, UINT index
)
577 const struct wined3d_blend_state
*b
= state
->blend_state
;
579 if (!state
->fb
.render_targets
[index
])
582 if (!b
->desc
.rt
[index
].enable
)
585 /* Disable blending in all cases even without pixel shaders.
586 * With blending on we could face a big performance penalty.
587 * The d3d9 visual test confirms the behavior. */
588 if (context
->render_offscreen
589 && !(state
->fb
.render_targets
[index
]->format_caps
& WINED3D_FORMAT_CAP_POSTPIXELSHADER_BLENDING
))
595 static void blend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
597 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
598 const struct wined3d_blend_state
*b
= state
->blend_state
;
599 const struct wined3d_format
*rt_format
;
600 GLenum src_blend
, dst_blend
;
603 if (gl_info
->supported
[ARB_MULTISAMPLE
])
605 if (b
&& b
->desc
.alpha_to_coverage
)
606 gl_info
->gl_ops
.gl
.p_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
608 gl_info
->gl_ops
.gl
.p_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
609 checkGLcall("glEnable GL_SAMPLE_ALPHA_TO_COVERAGE");
612 if (b
&& b
->desc
.independent
)
613 WARN("Independent blend is not supported by this GL implementation.\n");
615 mask
= b
? b
->desc
.rt
[0].writemask
: 0xf;
617 gl_info
->gl_ops
.gl
.p_glColorMask(mask
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
618 mask
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
619 mask
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
620 mask
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
);
621 checkGLcall("glColorMask");
623 if (!b
|| !is_blend_enabled(context
, state
, 0))
625 gl_info
->gl_ops
.gl
.p_glDisable(GL_BLEND
);
626 checkGLcall("glDisable GL_BLEND");
630 gl_info
->gl_ops
.gl
.p_glEnable(GL_BLEND
);
631 checkGLcall("glEnable GL_BLEND");
633 rt_format
= state
->fb
.render_targets
[0]->format
;
635 gl_blend_from_d3d(&src_blend
, &dst_blend
, b
->desc
.rt
[0].src
, b
->desc
.rt
[0].dst
, rt_format
);
637 blendop(state
, gl_info
);
639 if (b
->desc
.rt
[0].src
!= b
->desc
.rt
[0].src_alpha
|| b
->desc
.rt
[0].dst
!= b
->desc
.rt
[0].dst_alpha
)
641 GLenum src_blend_alpha
, dst_blend_alpha
;
643 /* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
644 if (!gl_info
->supported
[EXT_BLEND_FUNC_SEPARATE
])
646 WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparate.\n");
650 gl_blend_from_d3d(&src_blend_alpha
, &dst_blend_alpha
, b
->desc
.rt
[0].src_alpha
, b
->desc
.rt
[0].dst_alpha
, rt_format
);
652 GL_EXTCALL(glBlendFuncSeparate(src_blend
, dst_blend
, src_blend_alpha
, dst_blend_alpha
));
653 checkGLcall("glBlendFuncSeparate");
657 TRACE("glBlendFunc src=%x, dst=%x.\n", src_blend
, dst_blend
);
658 gl_info
->gl_ops
.gl
.p_glBlendFunc(src_blend
, dst_blend
);
659 checkGLcall("glBlendFunc");
662 /* Colorkey fixup for stage 0 alphaop depends on blend state, so it may need
664 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
])
665 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
668 static void set_color_mask(const struct wined3d_gl_info
*gl_info
, UINT index
, DWORD mask
)
670 GL_EXTCALL(glColorMaski(index
,
671 mask
& WINED3DCOLORWRITEENABLE_RED
? GL_TRUE
: GL_FALSE
,
672 mask
& WINED3DCOLORWRITEENABLE_GREEN
? GL_TRUE
: GL_FALSE
,
673 mask
& WINED3DCOLORWRITEENABLE_BLUE
? GL_TRUE
: GL_FALSE
,
674 mask
& WINED3DCOLORWRITEENABLE_ALPHA
? GL_TRUE
: GL_FALSE
));
675 checkGLcall("glColorMaski");
678 static void blend_db2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
680 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
681 GLenum src_blend
, dst_blend
, src_blend_alpha
, dst_blend_alpha
;
682 const struct wined3d_blend_state
*b
= state
->blend_state
;
683 const struct wined3d_format
*rt_format
;
684 BOOL dual_source
= b
&& b
->dual_source
;
687 if (b
&& b
->desc
.alpha_to_coverage
)
688 gl_info
->gl_ops
.gl
.p_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
690 gl_info
->gl_ops
.gl
.p_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
691 checkGLcall("glEnable GL_SAMPLE_ALPHA_TO_COVERAGE");
693 if (context
->last_was_dual_source_blend
!= dual_source
)
695 /* Dual source blending changes the location of the output varyings. */
696 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_PIXEL
;
697 context
->last_was_dual_source_blend
= dual_source
;
700 if (!b
|| !b
->desc
.independent
)
702 blend(context
, state
, state_id
);
706 rt_format
= state
->fb
.render_targets
[0]->format
;
707 gl_blend_from_d3d(&src_blend
, &dst_blend
, b
->desc
.rt
[0].src
, b
->desc
.rt
[0].dst
, rt_format
);
708 gl_blend_from_d3d(&src_blend_alpha
, &dst_blend_alpha
, b
->desc
.rt
[0].src_alpha
, b
->desc
.rt
[0].dst_alpha
, rt_format
);
710 GL_EXTCALL(glBlendFuncSeparate(src_blend
, dst_blend
, src_blend_alpha
, dst_blend_alpha
));
711 checkGLcall("glBlendFuncSeparate");
713 GL_EXTCALL(glBlendEquationSeparate(gl_blend_op(gl_info
, b
->desc
.rt
[0].op
),
714 gl_blend_op(gl_info
, b
->desc
.rt
[0].op_alpha
)));
715 checkGLcall("glBlendEquationSeparate");
717 for (i
= 0; i
< WINED3D_MAX_RENDER_TARGETS
; ++i
)
719 set_color_mask(gl_info
, i
, b
->desc
.rt
[i
].writemask
);
721 if (!is_blend_enabled(context
, state
, i
))
723 GL_EXTCALL(glDisablei(GL_BLEND
, i
));
724 checkGLcall("glDisablei GL_BLEND");
728 GL_EXTCALL(glEnablei(GL_BLEND
, i
));
729 checkGLcall("glEnablei GL_BLEND");
731 if (b
->desc
.rt
[i
].src
!= b
->desc
.rt
[0].src
732 || b
->desc
.rt
[i
].dst
!= b
->desc
.rt
[0].dst
733 || b
->desc
.rt
[i
].op
!= b
->desc
.rt
[0].op
734 || b
->desc
.rt
[i
].src_alpha
!= b
->desc
.rt
[0].src_alpha
735 || b
->desc
.rt
[i
].dst_alpha
!= b
->desc
.rt
[0].dst_alpha
736 || b
->desc
.rt
[i
].op_alpha
!= b
->desc
.rt
[0].op_alpha
)
737 WARN("Independent blend equations and blend functions are not supported by this GL implementation.\n");
740 /* Colorkey fixup for stage 0 alphaop depends on blend state, so it may need
742 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
])
743 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
746 static void blend_dbb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
748 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
749 const struct wined3d_blend_state
*b
= state
->blend_state
;
750 BOOL dual_source
= b
&& b
->dual_source
;
753 if (b
&& b
->desc
.alpha_to_coverage
)
754 gl_info
->gl_ops
.gl
.p_glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
756 gl_info
->gl_ops
.gl
.p_glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE
);
757 checkGLcall("glEnable GL_SAMPLE_ALPHA_TO_COVERAGE");
759 if (context
->last_was_dual_source_blend
!= dual_source
)
761 /* Dual source blending changes the location of the output varyings. */
762 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_PIXEL
;
763 context
->last_was_dual_source_blend
= dual_source
;
766 if (!b
|| !b
->desc
.independent
)
768 blend(context
, state
, state_id
);
772 for (i
= 0; i
< WINED3D_MAX_RENDER_TARGETS
; ++i
)
774 GLenum src_blend
, dst_blend
, src_blend_alpha
, dst_blend_alpha
;
775 const struct wined3d_format
*rt_format
;
777 set_color_mask(gl_info
, i
, b
->desc
.rt
[i
].writemask
);
779 if (!is_blend_enabled(context
, state
, i
))
781 GL_EXTCALL(glDisablei(GL_BLEND
, i
));
782 checkGLcall("glDisablei GL_BLEND");
786 GL_EXTCALL(glEnablei(GL_BLEND
, i
));
787 checkGLcall("glEnablei GL_BLEND");
789 rt_format
= state
->fb
.render_targets
[i
]->format
;
790 gl_blend_from_d3d(&src_blend
, &dst_blend
, b
->desc
.rt
[i
].src
, b
->desc
.rt
[i
].dst
, rt_format
);
791 gl_blend_from_d3d(&src_blend_alpha
, &dst_blend_alpha
,
792 b
->desc
.rt
[i
].src_alpha
, b
->desc
.rt
[i
].dst_alpha
, rt_format
);
794 GL_EXTCALL(glBlendFuncSeparatei(i
, src_blend
, dst_blend
, src_blend_alpha
, dst_blend_alpha
));
795 checkGLcall("glBlendFuncSeparatei");
797 GL_EXTCALL(glBlendEquationSeparatei(i
, gl_blend_op(gl_info
, b
->desc
.rt
[i
].op
),
798 gl_blend_op(gl_info
, b
->desc
.rt
[i
].op_alpha
)));
799 checkGLcall("glBlendEquationSeparatei");
802 /* Colorkey fixup for stage 0 alphaop depends on blend state, so it may need
804 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
])
805 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
808 void state_alpha_test(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
810 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
813 BOOL enable_ckey
= FALSE
;
815 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
817 /* Find out if the texture on the first stage has a ckey set. The alpha
818 * state func reads the texture settings, even though alpha and texture
819 * are not grouped together. This is to avoid making a huge alpha +
820 * texture + texture stage + ckey block due to the hardly used
821 * WINED3D_RS_COLORKEYENABLE state(which is d3d <= 3 only). The texture
822 * function will call alpha in case it finds some texture + colorkeyenable
823 * combination which needs extra care. */
824 if (state
->textures
[0] && (state
->textures
[0]->async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
))
827 if (enable_ckey
|| context
->last_was_ckey
)
828 context_apply_state(context
, state
, STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
));
829 context
->last_was_ckey
= enable_ckey
;
831 if (state
->render_states
[WINED3D_RS_ALPHATESTENABLE
]
832 || (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && enable_ckey
))
834 gl_info
->gl_ops
.gl
.p_glEnable(GL_ALPHA_TEST
);
835 checkGLcall("glEnable GL_ALPHA_TEST");
839 gl_info
->gl_ops
.gl
.p_glDisable(GL_ALPHA_TEST
);
840 checkGLcall("glDisable GL_ALPHA_TEST");
841 /* Alpha test is disabled, don't bother setting the params - it will happen on the next
847 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && enable_ckey
)
849 glParm
= GL_NOTEQUAL
;
854 ref
= wined3d_alpha_ref(state
);
855 glParm
= wined3d_gl_compare_func(state
->render_states
[WINED3D_RS_ALPHAFUNC
]);
859 gl_info
->gl_ops
.gl
.p_glAlphaFunc(glParm
, ref
);
860 checkGLcall("glAlphaFunc");
864 void state_clipping(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
866 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
867 uint32_t enable_mask
;
869 if (use_vs(state
) && !context
->d3d_info
->vs_clipping
)
873 /* The OpenGL spec says that clipping planes are disabled when using
874 * shaders. Direct3D planes aren't, so that is an issue. The MacOS ATI
875 * driver keeps clipping planes activated with shaders in some
876 * conditions I got sick of tracking down. The shader state handler
877 * disables all clip planes because of that - don't do anything here
878 * and keep them disabled. */
879 if (state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
] && !warned
++)
880 FIXME("Clipping not supported with vertex shaders.\n");
884 /* glEnable(GL_CLIP_PLANEx) doesn't apply to (ARB backend) vertex shaders.
885 * The enabled / disabled planes are hardcoded into the shader. Update the
886 * shader to update the enabled clipplanes. In case of fixed function, we
887 * need to update the clipping field from ffp_vertex_settings. */
888 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_VERTEX
;
890 /* If enabling / disabling all
891 * TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
893 enable_mask
= state
->render_states
[WINED3D_RS_CLIPPING
] ?
894 state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
] : 0;
895 wined3d_context_gl_enable_clip_distances(context_gl
, enable_mask
);
898 static void state_specularenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
900 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
902 /* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
903 * and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
904 * specular color. This is wrong:
905 * Separate specular color means the specular colour is maintained separately, whereas
906 * single color means it is merged in. However in both cases they are being used to
908 * To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
909 * NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
913 * If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
914 * Instead, we need to setup the FinalCombiner properly.
916 * The default setup for the FinalCombiner is:
918 * <variable> <input> <mapping> <usage>
919 * GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
920 * GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
921 * GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
922 * GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
923 * GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
924 * GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
925 * GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
927 * That's pretty much fine as it is, except for variable B, which needs to take
928 * either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
929 * whether WINED3D_RS_SPECULARENABLE is enabled or not.
932 TRACE("Setting specular enable state and materials\n");
933 if (state
->render_states
[WINED3D_RS_SPECULARENABLE
])
935 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&state
->material
.specular
);
936 checkGLcall("glMaterialfv");
938 if (state
->material
.power
> gl_info
->limits
.shininess
)
940 /* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
941 * and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
942 * allows bigger values. If the extension is supported, gl_info->limits.shininess contains the
943 * value reported by the extension, otherwise 128. For values > gl_info->limits.shininess clamp
944 * them, it should be safe to do so without major visual distortions.
946 WARN("Material power = %.8e, limit %.8e\n", state
->material
.power
, gl_info
->limits
.shininess
);
947 gl_info
->gl_ops
.gl
.p_glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, gl_info
->limits
.shininess
);
951 gl_info
->gl_ops
.gl
.p_glMaterialf(GL_FRONT_AND_BACK
, GL_SHININESS
, state
->material
.power
);
953 checkGLcall("glMaterialf(GL_SHININESS)");
955 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
956 gl_info
->gl_ops
.gl
.p_glEnable(GL_COLOR_SUM_EXT
);
958 TRACE("Specular colors cannot be enabled in this version of opengl\n");
959 checkGLcall("glEnable(GL_COLOR_SUM)");
961 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
963 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_PLUS_SECONDARY_COLOR_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
964 checkGLcall("glFinalCombinerInputNV()");
967 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
969 /* for the case of enabled lighting: */
970 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
971 checkGLcall("glMaterialfv");
973 /* for the case of disabled lighting: */
974 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
975 gl_info
->gl_ops
.gl
.p_glDisable(GL_COLOR_SUM_EXT
);
977 TRACE("Specular colors cannot be disabled in this version of opengl\n");
978 checkGLcall("glDisable(GL_COLOR_SUM)");
980 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
982 GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV
, GL_SPARE0_NV
, GL_UNSIGNED_IDENTITY_NV
, GL_RGB
));
983 checkGLcall("glFinalCombinerInputNV()");
987 TRACE("diffuse %s\n", debug_color(&state
->material
.diffuse
));
988 TRACE("ambient %s\n", debug_color(&state
->material
.ambient
));
989 TRACE("specular %s\n", debug_color(&state
->material
.specular
));
990 TRACE("emissive %s\n", debug_color(&state
->material
.emissive
));
992 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
993 checkGLcall("glMaterialfv(GL_AMBIENT)");
994 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
995 checkGLcall("glMaterialfv(GL_DIFFUSE)");
996 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&state
->material
.emissive
);
997 checkGLcall("glMaterialfv(GL_EMISSION)");
1000 static void state_texfactor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1002 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
1003 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
1004 struct wined3d_color color
;
1007 /* Note the texture color applies to all textures whereas
1008 * GL_TEXTURE_ENV_COLOR applies to active only. */
1009 wined3d_color_from_d3dcolor(&color
, state
->render_states
[WINED3D_RS_TEXTUREFACTOR
]);
1011 /* And now the default texture color as well */
1012 for (i
= 0; i
< context
->d3d_info
->limits
.ffp_blend_stages
; ++i
)
1014 /* Note the WINED3D_RS value applies to all textures, but GL has one
1015 * per texture, so apply it now ready to be used! */
1016 wined3d_context_gl_active_texture(context_gl
, gl_info
, i
);
1018 gl_info
->gl_ops
.gl
.p_glTexEnvfv(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_COLOR
, &color
.r
);
1019 checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
1023 static void renderstate_stencil_twosided(struct wined3d_context
*context
, GLint face
,
1024 GLint func
, GLint ref
, GLuint mask
, GLint stencilFail
, GLint depthFail
, GLint stencilPass
)
1026 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1028 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
1029 checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
1030 GL_EXTCALL(glActiveStencilFaceEXT(face
));
1031 checkGLcall("glActiveStencilFaceEXT(...)");
1032 gl_info
->gl_ops
.gl
.p_glStencilFunc(func
, ref
, mask
);
1033 checkGLcall("glStencilFunc(...)");
1034 gl_info
->gl_ops
.gl
.p_glStencilOp(stencilFail
, depthFail
, stencilPass
);
1035 checkGLcall("glStencilOp(...)");
1038 static GLenum
gl_stencil_op(enum wined3d_stencil_op op
)
1042 case WINED3D_STENCIL_OP_KEEP
:
1044 case WINED3D_STENCIL_OP_ZERO
:
1046 case WINED3D_STENCIL_OP_REPLACE
:
1048 case WINED3D_STENCIL_OP_INCR_SAT
:
1050 case WINED3D_STENCIL_OP_DECR_SAT
:
1052 case WINED3D_STENCIL_OP_INVERT
:
1054 case WINED3D_STENCIL_OP_INCR
:
1055 return GL_INCR_WRAP
;
1056 case WINED3D_STENCIL_OP_DECR
:
1057 return GL_DECR_WRAP
;
1060 WARN("Unrecognized stencil op %#x.\n", op
);
1062 FIXME("Unrecognized stencil op %#x.\n", op
);
1067 static void state_stencil(struct wined3d_context
*context
, const struct wined3d_state
*state
)
1069 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1070 const struct wined3d_depth_stencil_state
*d
= state
->depth_stencil_state
;
1076 GLint stencilFail_back
;
1078 GLint stencilPass_back
;
1080 GLint depthFail_back
;
1082 /* No stencil test without a stencil buffer. */
1083 if (!state
->fb
.depth_stencil
|| !d
|| !d
->desc
.stencil
)
1085 gl_info
->gl_ops
.gl
.p_glDisable(GL_STENCIL_TEST
);
1086 checkGLcall("glDisable GL_STENCIL_TEST");
1090 if (!(func
= wined3d_gl_compare_func(d
->desc
.front
.func
)))
1092 if (!(func_back
= wined3d_gl_compare_func(d
->desc
.back
.func
)))
1093 func_back
= GL_ALWAYS
;
1094 mask
= d
->desc
.stencil_read_mask
;
1095 ref
= state
->stencil_ref
& wined3d_mask_from_size(state
->fb
.depth_stencil
->format
->stencil_size
);
1096 stencilFail
= gl_stencil_op(d
->desc
.front
.fail_op
);
1097 depthFail
= gl_stencil_op(d
->desc
.front
.depth_fail_op
);
1098 stencilPass
= gl_stencil_op(d
->desc
.front
.pass_op
);
1099 stencilFail_back
= gl_stencil_op(d
->desc
.back
.fail_op
);
1100 depthFail_back
= gl_stencil_op(d
->desc
.back
.depth_fail_op
);
1101 stencilPass_back
= gl_stencil_op(d
->desc
.back
.pass_op
);
1103 TRACE("(ref %x, mask %x, "
1104 "GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
1105 "GL_BACK: func: %x, fail %x, zfail %x, zpass %x)\n",
1107 func
, stencilFail
, depthFail
, stencilPass
,
1108 func_back
, stencilFail_back
, depthFail_back
, stencilPass_back
);
1110 if (memcmp(&d
->desc
.front
, &d
->desc
.back
, sizeof(d
->desc
.front
)))
1112 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST
);
1113 checkGLcall("glEnable GL_STENCIL_TEST");
1115 if (gl_info
->supported
[WINED3D_GL_VERSION_2_0
])
1117 GL_EXTCALL(glStencilFuncSeparate(GL_FRONT
, func
, ref
, mask
));
1118 GL_EXTCALL(glStencilOpSeparate(GL_FRONT
, stencilFail
, depthFail
, stencilPass
));
1119 GL_EXTCALL(glStencilFuncSeparate(GL_BACK
, func_back
, ref
, mask
));
1120 GL_EXTCALL(glStencilOpSeparate(GL_BACK
, stencilFail_back
, depthFail_back
, stencilPass_back
));
1121 checkGLcall("setting two sided stencil state");
1123 else if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
1125 /* Apply back first, then front. This function calls glActiveStencilFaceEXT,
1126 * which has an effect on the code below too. If we apply the front face
1127 * afterwards, we are sure that the active stencil face is set to front,
1128 * and other stencil functions which do not use two sided stencil do not have
1131 renderstate_stencil_twosided(context
, GL_BACK
,
1132 func_back
, ref
, mask
, stencilFail_back
, depthFail_back
, stencilPass_back
);
1133 renderstate_stencil_twosided(context
, GL_FRONT
,
1134 func
, ref
, mask
, stencilFail
, depthFail
, stencilPass
);
1136 else if (gl_info
->supported
[ATI_SEPARATE_STENCIL
])
1138 GL_EXTCALL(glStencilFuncSeparateATI(func
, func_back
, ref
, mask
));
1139 checkGLcall("glStencilFuncSeparateATI(...)");
1140 GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT
, stencilFail
, depthFail
, stencilPass
));
1141 checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
1142 GL_EXTCALL(glStencilOpSeparateATI(GL_BACK
, stencilFail_back
, depthFail_back
, stencilPass_back
));
1143 checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
1147 FIXME("Separate (two sided) stencil not supported on this version of OpenGL. Caps weren't honored?\n");
1152 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
])
1154 gl_info
->gl_ops
.gl
.p_glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT
);
1155 checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
1158 /* This code disables the ATI extension as well, since the standard stencil functions are equal
1159 * to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
1161 gl_info
->gl_ops
.gl
.p_glEnable(GL_STENCIL_TEST
);
1162 checkGLcall("glEnable GL_STENCIL_TEST");
1163 gl_info
->gl_ops
.gl
.p_glStencilFunc(func
, ref
, mask
);
1164 checkGLcall("glStencilFunc(...)");
1165 gl_info
->gl_ops
.gl
.p_glStencilOp(stencilFail
, depthFail
, stencilPass
);
1166 checkGLcall("glStencilOp(...)");
1170 static void depth(struct wined3d_context
*context
, const struct wined3d_state
*state
)
1172 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1173 const struct wined3d_depth_stencil_state
*d
= state
->depth_stencil_state
;
1174 BOOL enable_depth
= d
? d
->desc
.depth
: TRUE
;
1175 GLenum depth_func
= GL_LESS
;
1177 if (!state
->fb
.depth_stencil
)
1179 TRACE("No depth/stencil buffer is attached; disabling depth test.\n");
1180 enable_depth
= FALSE
;
1185 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_TEST
);
1186 checkGLcall("glEnable GL_DEPTH_TEST");
1190 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_TEST
);
1191 checkGLcall("glDisable GL_DEPTH_TEST");
1194 if (!d
|| d
->desc
.depth_write
)
1196 gl_info
->gl_ops
.gl
.p_glDepthMask(GL_TRUE
);
1197 checkGLcall("glDepthMask(GL_TRUE)");
1201 gl_info
->gl_ops
.gl
.p_glDepthMask(GL_FALSE
);
1202 checkGLcall("glDepthMask(GL_FALSE)");
1206 depth_func
= wined3d_gl_compare_func(d
->desc
.depth_func
);
1209 gl_info
->gl_ops
.gl
.p_glDepthFunc(depth_func
);
1210 checkGLcall("glDepthFunc");
1213 if (context
->last_was_rhw
&& !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
)))
1214 context_apply_state(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
1217 static void depth_stencil(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1219 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1220 const struct wined3d_depth_stencil_state
*d
= state
->depth_stencil_state
;
1221 GLuint stencil_write_mask
= 0;
1223 depth(context
, state
);
1224 state_stencil(context
, state
);
1226 if (state
->fb
.depth_stencil
)
1227 stencil_write_mask
= d
? d
->desc
.stencil_write_mask
: ~0u;
1229 gl_info
->gl_ops
.gl
.p_glStencilMask(stencil_write_mask
);
1230 checkGLcall("glStencilMask");
1233 static void depth_stencil_2s(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1235 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1236 const struct wined3d_depth_stencil_state
*d
= state
->depth_stencil_state
;
1237 GLuint stencil_write_mask
= 0;
1239 depth(context
, state
);
1240 state_stencil(context
, state
);
1242 if (state
->fb
.depth_stencil
)
1243 stencil_write_mask
= d
? d
->desc
.stencil_write_mask
: ~0u;
1245 GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK
));
1246 checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
1247 gl_info
->gl_ops
.gl
.p_glStencilMask(stencil_write_mask
);
1248 checkGLcall("glStencilMask");
1249 GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT
));
1250 checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
1251 gl_info
->gl_ops
.gl
.p_glStencilMask(stencil_write_mask
);
1254 static void state_fog_vertexpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1256 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1258 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
1260 if (!state
->render_states
[WINED3D_RS_FOGENABLE
])
1263 /* Table fog on: Never use fog coords, and use per-fragment fog */
1264 if (state
->render_states
[WINED3D_RS_FOGTABLEMODE
] != WINED3D_FOG_NONE
)
1266 gl_info
->gl_ops
.gl
.p_glHint(GL_FOG_HINT
, GL_NICEST
);
1267 if (context
->fog_coord
)
1269 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
1270 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1271 context
->fog_coord
= FALSE
;
1274 /* Range fog is only used with per-vertex fog in d3d */
1275 if (gl_info
->supported
[NV_FOG_DISTANCE
])
1277 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
1278 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1283 /* Otherwise use per-vertex fog in any case */
1284 gl_info
->gl_ops
.gl
.p_glHint(GL_FOG_HINT
, GL_FASTEST
);
1286 if (state
->render_states
[WINED3D_RS_FOGVERTEXMODE
] == WINED3D_FOG_NONE
|| context
->last_was_rhw
)
1288 /* No fog at all, or transformed vertices: Use fog coord */
1289 if (!context
->fog_coord
)
1291 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FOG_COORDINATE_EXT
);
1292 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
1293 context
->fog_coord
= TRUE
;
1298 /* Otherwise, use the fragment depth */
1299 if (context
->fog_coord
)
1301 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_COORDINATE_SOURCE_EXT
, GL_FRAGMENT_DEPTH_EXT
);
1302 checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
1303 context
->fog_coord
= FALSE
;
1306 if (state
->render_states
[WINED3D_RS_RANGEFOGENABLE
])
1308 if (gl_info
->supported
[NV_FOG_DISTANCE
])
1310 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_RADIAL_NV
);
1311 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
1315 WARN("Range fog enabled, but not supported by this GL implementation.\n");
1318 else if (gl_info
->supported
[NV_FOG_DISTANCE
])
1320 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_DISTANCE_MODE_NV
, GL_EYE_PLANE_ABSOLUTE_NV
);
1321 checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
1326 void state_fogstartend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1328 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1329 float fogstart
, fogend
;
1331 get_fog_start_end(context
, state
, &fogstart
, &fogend
);
1333 gl_info
->gl_ops
.gl
.p_glFogf(GL_FOG_START
, fogstart
);
1334 checkGLcall("glFogf(GL_FOG_START, fogstart)");
1335 TRACE("Fog Start == %f\n", fogstart
);
1337 gl_info
->gl_ops
.gl
.p_glFogf(GL_FOG_END
, fogend
);
1338 checkGLcall("glFogf(GL_FOG_END, fogend)");
1339 TRACE("Fog End == %f\n", fogend
);
1342 void state_fog_fragpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1344 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1345 enum fogsource new_source
;
1346 DWORD fogstart
= state
->render_states
[WINED3D_RS_FOGSTART
];
1347 DWORD fogend
= state
->render_states
[WINED3D_RS_FOGEND
];
1349 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
1351 if (!state
->render_states
[WINED3D_RS_FOGENABLE
])
1353 /* No fog? Disable it, and we're done :-) */
1354 gl_info
->p_glDisableWINE(GL_FOG
);
1355 checkGLcall("glDisable GL_FOG");
1361 * With fixed function vertex processing, Direct3D knows 2 different fog input sources.
1362 * It can use the Z value of the vertex, or the alpha component of the specular color.
1363 * This depends on the fog vertex, fog table and the vertex declaration. If the Z value
1364 * is used, fogstart, fogend and the equation type are used, otherwise linear fog with
1365 * start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
1367 * FOGTABLEMODE != NONE:
1368 * The Z value is used, with the equation specified, no matter what vertex type.
1370 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
1371 * Per vertex fog is calculated using the specified fog equation and the parameters
1373 * FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
1374 * FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
1375 * Linear fog with start = 255.0, end = 0.0, input comes from the specular color
1378 * Rules for vertex fog with shaders:
1380 * When mixing fixed function functionality with the programmable pipeline, D3D expects
1381 * the fog computation to happen during transformation while openGL expects it to happen
1382 * during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
1383 * the pixel shader while openGL always expects the pixel shader to handle the blending.
1384 * To solve this problem, WineD3D does:
1385 * 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
1387 * and 2) disables the fog computation (in either the fixed function or programmable
1388 * rasterizer) if using a vertex program.
1390 * D3D shaders can provide an explicit fog coordinate. This fog coordinate is used with
1391 * D3DRS_FOGTABLEMODE==D3DFOG_NONE. The FOGVERTEXMODE is ignored, d3d always uses linear
1392 * fog with start=1.0 and end=0.0 in this case. This is similar to fog coordinates in
1393 * the specular color, a vertex shader counts as pretransformed geometry in this case.
1394 * There are some GL differences between specular fog coords and vertex shaders though.
1396 * With table fog the vertex shader fog coordinate is ignored.
1398 * If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
1402 /* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
1403 * the system will apply only pixel(=table) fog effects."
1405 if (state
->render_states
[WINED3D_RS_FOGTABLEMODE
] == WINED3D_FOG_NONE
)
1409 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1410 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1411 new_source
= FOGSOURCE_VS
;
1415 switch (state
->render_states
[WINED3D_RS_FOGVERTEXMODE
])
1417 /* If processed vertices are used, fall through to the NONE case */
1418 case WINED3D_FOG_EXP
:
1419 if (!context
->last_was_rhw
)
1421 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP
);
1422 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1423 new_source
= FOGSOURCE_FFP
;
1428 case WINED3D_FOG_EXP2
:
1429 if (!context
->last_was_rhw
)
1431 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP2
);
1432 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1433 new_source
= FOGSOURCE_FFP
;
1438 case WINED3D_FOG_LINEAR
:
1439 if (!context
->last_was_rhw
)
1441 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1442 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1443 new_source
= FOGSOURCE_FFP
;
1448 case WINED3D_FOG_NONE
:
1449 /* Both are none? According to msdn the alpha channel of
1450 * the specular colour contains a fog factor. Set it in
1451 * draw_primitive_immediate_mode(). Same happens with
1452 * vertex fog on transformed vertices. */
1453 new_source
= FOGSOURCE_COORD
;
1454 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1455 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1459 FIXME("Unexpected WINED3D_RS_FOGVERTEXMODE %#x.\n",
1460 state
->render_states
[WINED3D_RS_FOGVERTEXMODE
]);
1461 new_source
= FOGSOURCE_FFP
; /* Make the compiler happy */
1465 new_source
= FOGSOURCE_FFP
;
1467 switch (state
->render_states
[WINED3D_RS_FOGTABLEMODE
])
1469 case WINED3D_FOG_EXP
:
1470 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP
);
1471 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
1474 case WINED3D_FOG_EXP2
:
1475 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_EXP2
);
1476 checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
1479 case WINED3D_FOG_LINEAR
:
1480 gl_info
->gl_ops
.gl
.p_glFogi(GL_FOG_MODE
, GL_LINEAR
);
1481 checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
1484 case WINED3D_FOG_NONE
: /* Won't happen */
1486 FIXME("Unexpected WINED3D_RS_FOGTABLEMODE %#x.\n",
1487 state
->render_states
[WINED3D_RS_FOGTABLEMODE
]);
1491 gl_info
->p_glEnableWINE(GL_FOG
);
1492 checkGLcall("glEnable GL_FOG");
1493 if (new_source
!= context
->fog_source
|| fogstart
== fogend
)
1495 context
->fog_source
= new_source
;
1496 state_fogstartend(context
, state
, STATE_RENDER(WINED3D_RS_FOGSTART
));
1500 void state_fogcolor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1502 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1503 struct wined3d_color color
;
1505 wined3d_color_from_d3dcolor(&color
, state
->render_states
[WINED3D_RS_FOGCOLOR
]);
1506 gl_info
->gl_ops
.gl
.p_glFogfv(GL_FOG_COLOR
, &color
.r
);
1507 checkGLcall("glFog GL_FOG_COLOR");
1510 void state_fogdensity(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1512 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1518 tmpvalue
.d
= state
->render_states
[WINED3D_RS_FOGDENSITY
];
1519 gl_info
->gl_ops
.gl
.p_glFogfv(GL_FOG_DENSITY
, &tmpvalue
.f
);
1520 checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
1523 static void state_colormat(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1525 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
1526 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
1529 context_gl
->untracked_material_count
= 0;
1530 if ((context_gl
->c
.stream_info
.use_map
& (1u << WINED3D_FFP_DIFFUSE
))
1531 && state
->render_states
[WINED3D_RS_COLORVERTEX
])
1533 TRACE("diff %d, amb %d, emis %d, spec %d\n",
1534 state
->render_states
[WINED3D_RS_DIFFUSEMATERIALSOURCE
],
1535 state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
],
1536 state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
],
1537 state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
]);
1539 if (state
->render_states
[WINED3D_RS_DIFFUSEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1541 if (state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1542 Parm
= GL_AMBIENT_AND_DIFFUSE
;
1545 if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1546 context_gl
->untracked_materials
[context_gl
->untracked_material_count
++] = GL_EMISSION
;
1547 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1548 context_gl
->untracked_materials
[context_gl
->untracked_material_count
++] = GL_SPECULAR
;
1550 else if (state
->render_states
[WINED3D_RS_AMBIENTMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1553 if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1554 context_gl
->untracked_materials
[context_gl
->untracked_material_count
++] = GL_EMISSION
;
1555 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1556 context_gl
->untracked_materials
[context_gl
->untracked_material_count
++] = GL_SPECULAR
;
1558 else if (state
->render_states
[WINED3D_RS_EMISSIVEMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1561 if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1562 context_gl
->untracked_materials
[context_gl
->untracked_material_count
++] = GL_SPECULAR
;
1564 else if (state
->render_states
[WINED3D_RS_SPECULARMATERIALSOURCE
] == WINED3D_MCS_COLOR1
)
1570 /* Nothing changed, return. */
1571 if (Parm
== context_gl
->tracking_parm
)
1576 gl_info
->gl_ops
.gl
.p_glDisable(GL_COLOR_MATERIAL
);
1577 checkGLcall("glDisable GL_COLOR_MATERIAL");
1581 gl_info
->gl_ops
.gl
.p_glColorMaterial(GL_FRONT_AND_BACK
, Parm
);
1582 checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
1583 gl_info
->gl_ops
.gl
.p_glEnable(GL_COLOR_MATERIAL
);
1584 checkGLcall("glEnable(GL_COLOR_MATERIAL)");
1587 /* Apparently calls to glMaterialfv are ignored for properties we're
1588 * tracking with glColorMaterial, so apply those here. */
1589 switch (context_gl
->tracking_parm
)
1591 case GL_AMBIENT_AND_DIFFUSE
:
1592 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
1593 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
1594 checkGLcall("glMaterialfv");
1598 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_DIFFUSE
, (float *)&state
->material
.diffuse
);
1599 checkGLcall("glMaterialfv");
1603 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_AMBIENT
, (float *)&state
->material
.ambient
);
1604 checkGLcall("glMaterialfv");
1608 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_EMISSION
, (float *)&state
->material
.emissive
);
1609 checkGLcall("glMaterialfv");
1613 /* Only change material color if specular is enabled, otherwise it is set to black */
1614 if (state
->render_states
[WINED3D_RS_SPECULARENABLE
])
1616 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, (float *)&state
->material
.specular
);
1617 checkGLcall("glMaterialfv");
1621 static const GLfloat black
[] = {0.0f
, 0.0f
, 0.0f
, 0.0f
};
1622 gl_info
->gl_ops
.gl
.p_glMaterialfv(GL_FRONT_AND_BACK
, GL_SPECULAR
, &black
[0]);
1623 checkGLcall("glMaterialfv");
1628 context_gl
->tracking_parm
= Parm
;
1631 static void state_linepattern(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1633 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1637 struct wined3d_line_pattern lp
;
1639 tmppattern
.d
= state
->render_states
[WINED3D_RS_LINEPATTERN
];
1641 TRACE("Line pattern: repeat %d bits %x.\n", tmppattern
.lp
.repeat_factor
, tmppattern
.lp
.line_pattern
);
1643 if (tmppattern
.lp
.repeat_factor
)
1645 gl_info
->gl_ops
.gl
.p_glLineStipple(tmppattern
.lp
.repeat_factor
, tmppattern
.lp
.line_pattern
);
1646 checkGLcall("glLineStipple(repeat, linepattern)");
1647 gl_info
->gl_ops
.gl
.p_glEnable(GL_LINE_STIPPLE
);
1648 checkGLcall("glEnable(GL_LINE_STIPPLE);");
1652 gl_info
->gl_ops
.gl
.p_glDisable(GL_LINE_STIPPLE
);
1653 checkGLcall("glDisable(GL_LINE_STIPPLE);");
1657 static void state_linepattern_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1659 static unsigned int once
;
1662 FIXME("Setting line patterns is not supported in OpenGL core contexts.\n");
1665 static void state_normalize(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1667 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1669 /* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
1670 * from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
1671 * by zero and is not properly defined in opengl, so avoid it
1673 if (state
->render_states
[WINED3D_RS_NORMALIZENORMALS
]
1674 && (context
->stream_info
.use_map
& (1u << WINED3D_FFP_NORMAL
)))
1676 gl_info
->gl_ops
.gl
.p_glEnable(GL_NORMALIZE
);
1677 checkGLcall("glEnable(GL_NORMALIZE);");
1681 gl_info
->gl_ops
.gl
.p_glDisable(GL_NORMALIZE
);
1682 checkGLcall("glDisable(GL_NORMALIZE);");
1686 static void state_psizemin_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1690 get_pointsize_minmax(context
, state
, &min
, &max
);
1693 FIXME("WINED3D_RS_POINTSIZE_MIN value %.8e not supported on this OpenGL implementation.\n", min
);
1695 FIXME("WINED3D_RS_POINTSIZE_MAX value %.8e not supported on this OpenGL implementation.\n", max
);
1698 static void state_psizemin_ext(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1700 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1703 get_pointsize_minmax(context
, state
, &min
, &max
);
1705 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MIN_EXT
, min
);
1706 checkGLcall("glPointParameterfEXT(...)");
1707 GL_EXTCALL(glPointParameterfEXT
)(GL_POINT_SIZE_MAX_EXT
, max
);
1708 checkGLcall("glPointParameterfEXT(...)");
1711 static void state_psizemin_arb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1713 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1716 get_pointsize_minmax(context
, state
, &min
, &max
);
1718 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MIN_ARB
, min
);
1719 checkGLcall("glPointParameterfARB(...)");
1720 GL_EXTCALL(glPointParameterfARB
)(GL_POINT_SIZE_MAX_ARB
, max
);
1721 checkGLcall("glPointParameterfARB(...)");
1724 static void state_pscale(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1726 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1730 get_pointsize(context
, state
, &pointsize
, att
);
1732 if (gl_info
->supported
[ARB_POINT_PARAMETERS
])
1734 GL_EXTCALL(glPointParameterfvARB
)(GL_POINT_DISTANCE_ATTENUATION_ARB
, att
);
1735 checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
1737 else if (gl_info
->supported
[EXT_POINT_PARAMETERS
])
1739 GL_EXTCALL(glPointParameterfvEXT
)(GL_DISTANCE_ATTENUATION_EXT
, att
);
1740 checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
1742 else if (state
->render_states
[WINED3D_RS_POINTSCALEENABLE
])
1744 WARN("POINT_PARAMETERS not supported in this version of opengl\n");
1747 gl_info
->gl_ops
.gl
.p_glPointSize(max(pointsize
, FLT_MIN
));
1748 checkGLcall("glPointSize(...);");
1751 static void state_debug_monitor(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1753 WARN("token: %#x.\n", state
->render_states
[WINED3D_RS_DEBUGMONITORTOKEN
]);
1756 static void state_localviewer(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1758 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1760 if (state
->render_states
[WINED3D_RS_LOCALVIEWER
])
1762 gl_info
->gl_ops
.gl
.p_glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 1);
1763 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
1767 gl_info
->gl_ops
.gl
.p_glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER
, 0);
1768 checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
1772 static void state_lastpixel(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1774 if (state
->render_states
[WINED3D_RS_LASTPIXEL
])
1776 TRACE("Last Pixel Drawing Enabled\n");
1782 FIXME("Last Pixel Drawing Disabled, not handled yet\n");
1785 TRACE("Last Pixel Drawing Disabled, not handled yet\n");
1790 void state_pointsprite_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1794 /* TODO: NV_POINT_SPRITE */
1795 if (!warned
&& state
->render_states
[WINED3D_RS_POINTSPRITEENABLE
])
1797 /* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
1798 FIXME("Point sprites not supported\n");
1803 void state_pointsprite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1805 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1807 if (state
->render_states
[WINED3D_RS_POINTSPRITEENABLE
])
1809 gl_info
->gl_ops
.gl
.p_glEnable(GL_POINT_SPRITE_ARB
);
1810 checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
1814 gl_info
->gl_ops
.gl
.p_glDisable(GL_POINT_SPRITE_ARB
);
1815 checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
1819 static void state_wrap(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1821 static unsigned int once
;
1823 if ((state
->render_states
[WINED3D_RS_WRAP0
]
1824 || state
->render_states
[WINED3D_RS_WRAP1
]
1825 || state
->render_states
[WINED3D_RS_WRAP2
]
1826 || state
->render_states
[WINED3D_RS_WRAP3
]
1827 || state
->render_states
[WINED3D_RS_WRAP4
]
1828 || state
->render_states
[WINED3D_RS_WRAP5
]
1829 || state
->render_states
[WINED3D_RS_WRAP6
]
1830 || state
->render_states
[WINED3D_RS_WRAP7
]
1831 || state
->render_states
[WINED3D_RS_WRAP8
]
1832 || state
->render_states
[WINED3D_RS_WRAP9
]
1833 || state
->render_states
[WINED3D_RS_WRAP10
]
1834 || state
->render_states
[WINED3D_RS_WRAP11
]
1835 || state
->render_states
[WINED3D_RS_WRAP12
]
1836 || state
->render_states
[WINED3D_RS_WRAP13
]
1837 || state
->render_states
[WINED3D_RS_WRAP14
]
1838 || state
->render_states
[WINED3D_RS_WRAP15
])
1840 FIXME("(WINED3D_RS_WRAP0) Texture wrapping not yet supported.\n");
1843 static void state_msaa_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1845 if (state
->render_states
[WINED3D_RS_MULTISAMPLEANTIALIAS
])
1846 WARN("Multisample antialiasing not supported by GL.\n");
1849 static void state_msaa(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1851 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1853 if (state
->render_states
[WINED3D_RS_MULTISAMPLEANTIALIAS
])
1855 gl_info
->gl_ops
.gl
.p_glEnable(GL_MULTISAMPLE_ARB
);
1856 checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
1860 gl_info
->gl_ops
.gl
.p_glDisable(GL_MULTISAMPLE_ARB
);
1861 checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
1865 static void line_antialias(const struct wined3d_rasterizer_state
*r
, const struct wined3d_gl_info
*gl_info
)
1867 if (r
&& r
->desc
.line_antialias
)
1869 gl_info
->gl_ops
.gl
.p_glEnable(GL_LINE_SMOOTH
);
1870 checkGLcall("glEnable(GL_LINE_SMOOTH)");
1874 gl_info
->gl_ops
.gl
.p_glDisable(GL_LINE_SMOOTH
);
1875 checkGLcall("glDisable(GL_LINE_SMOOTH)");
1879 static void scissor(const struct wined3d_rasterizer_state
*r
, const struct wined3d_gl_info
*gl_info
)
1881 if (r
&& r
->desc
.scissor
)
1883 gl_info
->gl_ops
.gl
.p_glEnable(GL_SCISSOR_TEST
);
1884 checkGLcall("glEnable(GL_SCISSOR_TEST)");
1888 gl_info
->gl_ops
.gl
.p_glDisable(GL_SCISSOR_TEST
);
1889 checkGLcall("glDisable(GL_SCISSOR_TEST)");
1893 /* The Direct3D depth bias is specified in normalized depth coordinates. In
1894 * OpenGL the bias is specified in units of "the smallest value that is
1895 * guaranteed to produce a resolvable offset for a given implementation". To
1896 * convert from D3D to GL we need to divide the D3D depth bias by that value.
1897 * We try to detect the value from GL with test draws. On most drivers (r300g,
1898 * 600g, Nvidia, i965 on Mesa) the value is 2^23 for fixed point depth buffers,
1899 * for r200 and i965 on OSX it is 2^24, for r500 on OSX it is 2^22. For floating
1900 * point buffers it is 2^22, 2^23 or 2^24 depending on the GPU. The value does
1901 * not depend on the depth buffer precision on any driver.
1903 * Two games that are picky regarding depth bias are Mass Effect 2 (flickering
1904 * decals) and F.E.A.R and F.E.A.R. 2 (semi-transparent guns).
1906 * Note that SLOPESCALEDEPTHBIAS is a scaling factor for the depth slope, and
1907 * doesn't need to be scaled to account for GL vs D3D differences. */
1908 static void depthbias(struct wined3d_context
*context
, const struct wined3d_state
*state
)
1910 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1911 const struct wined3d_rasterizer_state
*r
= state
->rasterizer_state
;
1912 float scale_bias
= r
? r
->desc
.scale_bias
: 0.0f
;
1919 const_bias
.f
= r
? r
->desc
.depth_bias
: 0.0f
;
1921 if (scale_bias
|| const_bias
.f
)
1923 const struct wined3d_rendertarget_view
*depth
= state
->fb
.depth_stencil
;
1924 float factor
, units
, scale
, clamp
;
1926 clamp
= r
? r
->desc
.depth_bias_clamp
: 0.0f
;
1928 if (context
->d3d_info
->wined3d_creation_flags
& WINED3D_LEGACY_DEPTH_BIAS
)
1930 factor
= units
= -(float)const_bias
.d
;
1936 scale
= depth
->format
->depth_bias_scale
;
1938 TRACE("Depth format %s, using depthbias scale of %.8e.\n",
1939 debug_d3dformat(depth
->format
->id
), scale
);
1943 /* The context manager will reapply this state on a depth stencil change */
1944 TRACE("No depth stencil, using depth bias scale of 0.0.\n");
1948 factor
= scale_bias
;
1949 units
= const_bias
.f
* scale
;
1952 gl_info
->gl_ops
.gl
.p_glEnable(GL_POLYGON_OFFSET_FILL
);
1953 if (gl_info
->supported
[ARB_POLYGON_OFFSET_CLAMP
])
1955 gl_info
->gl_ops
.ext
.p_glPolygonOffsetClamp(factor
, units
, clamp
);
1960 WARN("Ignoring depth bias clamp %.8e.\n", clamp
);
1961 gl_info
->gl_ops
.gl
.p_glPolygonOffset(factor
, units
);
1966 gl_info
->gl_ops
.gl
.p_glDisable(GL_POLYGON_OFFSET_FILL
);
1969 checkGLcall("depth bias");
1972 static void state_zvisible(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1974 if (state
->render_states
[WINED3D_RS_ZVISIBLE
])
1975 FIXME("WINED3D_RS_ZVISIBLE not implemented.\n");
1978 static void state_stippledalpha(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1980 if (state
->render_states
[WINED3D_RS_STIPPLEDALPHA
])
1981 FIXME("Stippled Alpha not supported yet.\n");
1984 static void state_antialias(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1986 if (state
->render_states
[WINED3D_RS_ANTIALIAS
])
1987 FIXME("Antialias not supported yet.\n");
1990 static void state_sample_mask(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
1992 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
1993 unsigned int sample_mask
= state
->sample_mask
;
1995 TRACE("Setting sample mask to %#x.\n", sample_mask
);
1996 if (sample_mask
!= 0xffffffff)
1998 gl_info
->gl_ops
.gl
.p_glEnable(GL_SAMPLE_MASK
);
1999 checkGLcall("glEnable GL_SAMPLE_MASK");
2000 GL_EXTCALL(glSampleMaski(0, sample_mask
));
2001 checkGLcall("glSampleMaski");
2005 gl_info
->gl_ops
.gl
.p_glDisable(GL_SAMPLE_MASK
);
2006 checkGLcall("glDisable GL_SAMPLE_MASK");
2010 static void state_sample_mask_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2012 WARN("Unsupported in local OpenGL implementation: glSampleMaski.\n");
2015 static void state_patchedgestyle(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2017 if (state
->render_states
[WINED3D_RS_PATCHEDGESTYLE
] != WINED3D_PATCH_EDGE_DISCRETE
)
2018 FIXME("WINED3D_RS_PATCHEDGESTYLE %#x not yet implemented.\n",
2019 state
->render_states
[WINED3D_RS_PATCHEDGESTYLE
]);
2022 static void state_patchsegments(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2030 if (state
->render_states
[WINED3D_RS_PATCHSEGMENTS
] != tmpvalue
.d
)
2032 static BOOL displayed
= FALSE
;
2034 tmpvalue
.d
= state
->render_states
[WINED3D_RS_PATCHSEGMENTS
];
2036 FIXME("(WINED3D_RS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue
.f
);
2042 static void state_positiondegree(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2044 if (state
->render_states
[WINED3D_RS_POSITIONDEGREE
] != WINED3D_DEGREE_CUBIC
)
2045 FIXME("WINED3D_RS_POSITIONDEGREE %#x not yet implemented.\n",
2046 state
->render_states
[WINED3D_RS_POSITIONDEGREE
]);
2049 static void state_normaldegree(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2051 if (state
->render_states
[WINED3D_RS_NORMALDEGREE
] != WINED3D_DEGREE_LINEAR
)
2052 FIXME("WINED3D_RS_NORMALDEGREE %#x not yet implemented.\n",
2053 state
->render_states
[WINED3D_RS_NORMALDEGREE
]);
2056 static void state_tessellation(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2058 if (state
->render_states
[WINED3D_RS_ENABLEADAPTIVETESSELLATION
])
2059 FIXME("WINED3D_RS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
2060 state
->render_states
[WINED3D_RS_ENABLEADAPTIVETESSELLATION
]);
2063 static void state_nvdb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2065 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
2072 if (state
->render_states
[WINED3D_RS_ADAPTIVETESS_X
] == WINED3DFMT_NVDB
)
2074 zmin
.d
= state
->render_states
[WINED3D_RS_ADAPTIVETESS_Z
];
2075 zmax
.d
= state
->render_states
[WINED3D_RS_ADAPTIVETESS_W
];
2077 /* If zmin is larger than zmax INVALID_VALUE error is generated.
2078 * In d3d9 test is not performed in this case*/
2079 if (zmin
.f
<= zmax
.f
)
2081 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_BOUNDS_TEST_EXT
);
2082 checkGLcall("glEnable(GL_DEPTH_BOUNDS_TEST_EXT)");
2083 GL_EXTCALL(glDepthBoundsEXT(zmin
.f
, zmax
.f
));
2084 checkGLcall("glDepthBoundsEXT(...)");
2088 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
2089 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
2094 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_BOUNDS_TEST_EXT
);
2095 checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
2098 state_tessellation(context
, state
, STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
));
2101 static void state_wrapu(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2103 if (state
->render_states
[WINED3D_RS_WRAPU
])
2104 FIXME("Render state WINED3D_RS_WRAPU not implemented yet.\n");
2107 static void state_wrapv(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2109 if (state
->render_states
[WINED3D_RS_WRAPV
])
2110 FIXME("Render state WINED3D_RS_WRAPV not implemented yet.\n");
2113 static void state_monoenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2115 if (state
->render_states
[WINED3D_RS_MONOENABLE
])
2116 FIXME("Render state WINED3D_RS_MONOENABLE not implemented yet.\n");
2119 static void state_rop2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2121 if (state
->render_states
[WINED3D_RS_ROP2
])
2122 FIXME("Render state WINED3D_RS_ROP2 not implemented yet.\n");
2125 static void state_planemask(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2127 if (state
->render_states
[WINED3D_RS_PLANEMASK
])
2128 FIXME("Render state WINED3D_RS_PLANEMASK not implemented yet.\n");
2131 static void state_subpixel(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2133 if (state
->render_states
[WINED3D_RS_SUBPIXEL
])
2134 FIXME("Render state WINED3D_RS_SUBPIXEL not implemented yet.\n");
2137 static void state_subpixelx(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2139 if (state
->render_states
[WINED3D_RS_SUBPIXELX
])
2140 FIXME("Render state WINED3D_RS_SUBPIXELX not implemented yet.\n");
2143 static void state_stippleenable(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2145 if (state
->render_states
[WINED3D_RS_STIPPLEENABLE
])
2146 FIXME("Render state WINED3D_RS_STIPPLEENABLE not implemented yet.\n");
2149 static void state_mipmaplodbias(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2151 if (state
->render_states
[WINED3D_RS_MIPMAPLODBIAS
])
2152 FIXME("Render state WINED3D_RS_MIPMAPLODBIAS not implemented yet.\n");
2155 static void state_anisotropy(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2157 if (state
->render_states
[WINED3D_RS_ANISOTROPY
])
2158 FIXME("Render state WINED3D_RS_ANISOTROPY not implemented yet.\n");
2161 static void state_flushbatch(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2163 if (state
->render_states
[WINED3D_RS_FLUSHBATCH
])
2164 FIXME("Render state WINED3D_RS_FLUSHBATCH not implemented yet.\n");
2167 static void state_translucentsi(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2169 if (state
->render_states
[WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
])
2170 FIXME("Render state WINED3D_RS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
2173 static void state_extents(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2175 if (state
->render_states
[WINED3D_RS_EXTENTS
])
2176 FIXME("Render state WINED3D_RS_EXTENTS not implemented yet.\n");
2179 static void state_ckeyblend(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2181 if (state
->render_states
[WINED3D_RS_COLORKEYBLENDENABLE
])
2182 FIXME("Render state WINED3D_RS_COLORKEYBLENDENABLE not implemented yet.\n");
2185 static void state_swvp(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
2188 if (state
->render_states
[WINED3D_RS_SOFTWAREVERTEXPROCESSING
])
2191 FIXME("Software vertex processing not implemented.\n");
2195 static void get_src_and_opr(DWORD arg
, BOOL is_alpha
, GLenum
* source
, GLenum
* operand
) {
2196 /* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
2197 * input should be used for all input components. The WINED3DTA_COMPLEMENT
2198 * flag specifies the complement of the input should be used. */
2199 BOOL from_alpha
= is_alpha
|| arg
& WINED3DTA_ALPHAREPLICATE
;
2200 BOOL complement
= arg
& WINED3DTA_COMPLEMENT
;
2202 /* Calculate the operand */
2204 if (from_alpha
) *operand
= GL_ONE_MINUS_SRC_ALPHA
;
2205 else *operand
= GL_ONE_MINUS_SRC_COLOR
;
2207 if (from_alpha
) *operand
= GL_SRC_ALPHA
;
2208 else *operand
= GL_SRC_COLOR
;
2211 /* Calculate the source */
2212 switch (arg
& WINED3DTA_SELECTMASK
) {
2213 case WINED3DTA_CURRENT
: *source
= GL_PREVIOUS_EXT
; break;
2214 case WINED3DTA_DIFFUSE
: *source
= GL_PRIMARY_COLOR_EXT
; break;
2215 case WINED3DTA_TEXTURE
: *source
= GL_TEXTURE
; break;
2216 case WINED3DTA_TFACTOR
: *source
= GL_CONSTANT_EXT
; break;
2217 case WINED3DTA_SPECULAR
:
2219 * According to the GL_ARB_texture_env_combine specs, SPECULAR is
2220 * 'Secondary color' and isn't supported until base GL supports it
2221 * There is no concept of temp registers as far as I can tell
2223 FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
2224 *source
= GL_TEXTURE
;
2227 FIXME("Unrecognized texture arg %#x\n", arg
);
2228 *source
= GL_TEXTURE
;
2233 /* Setup the texture operations texture stage states */
2234 static void set_tex_op(const struct wined3d_gl_info
*gl_info
, const struct wined3d_state
*state
,
2235 BOOL isAlpha
, int Stage
, enum wined3d_texture_op op
, DWORD arg1
, DWORD arg2
, DWORD arg3
)
2237 GLenum src1
, src2
, src3
;
2238 GLenum opr1
, opr2
, opr3
;
2240 GLenum src0_target
, src1_target
, src2_target
;
2241 GLenum opr0_target
, opr1_target
, opr2_target
;
2243 GLenum opr
=0, invopr
, src3_target
, opr3_target
;
2244 BOOL Handled
= FALSE
;
2246 TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha
, Stage
, debug_d3dtop(op
), arg1
, arg2
, arg3
);
2248 /* Operations usually involve two args, src0 and src1 and are operations
2249 * of the form (a1 <operation> a2). However, some of the more complex
2250 * operations take 3 parameters. Instead of the (sensible) addition of a3,
2251 * Microsoft added in a third parameter called a0. Therefore these are
2252 * operations of the form a0 <operation> a1 <operation> a2. I.e., the new
2253 * parameter goes to the front.
2255 * However, below we treat the new (a0) parameter as src2/opr2, so in the
2256 * actual functions below, expect their syntax to differ slightly to those
2257 * listed in the manuals. I.e., replace arg1 with arg3, arg2 with arg1 and
2258 * arg3 with arg2. This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP. */
2262 comb_target
= GL_COMBINE_ALPHA
;
2263 src0_target
= GL_SOURCE0_ALPHA
;
2264 src1_target
= GL_SOURCE1_ALPHA
;
2265 src2_target
= GL_SOURCE2_ALPHA
;
2266 opr0_target
= GL_OPERAND0_ALPHA
;
2267 opr1_target
= GL_OPERAND1_ALPHA
;
2268 opr2_target
= GL_OPERAND2_ALPHA
;
2269 scal_target
= GL_ALPHA_SCALE
;
2273 comb_target
= GL_COMBINE_RGB
;
2274 src0_target
= GL_SOURCE0_RGB
;
2275 src1_target
= GL_SOURCE1_RGB
;
2276 src2_target
= GL_SOURCE2_RGB
;
2277 opr0_target
= GL_OPERAND0_RGB
;
2278 opr1_target
= GL_OPERAND1_RGB
;
2279 opr2_target
= GL_OPERAND2_RGB
;
2280 scal_target
= GL_RGB_SCALE
;
2283 /* If a texture stage references an invalid texture unit the stage just
2284 * passes through the result from the previous stage */
2285 if (is_invalid_op(state
, Stage
, op
, arg1
, arg2
, arg3
))
2287 arg1
= WINED3DTA_CURRENT
;
2288 op
= WINED3D_TOP_SELECT_ARG1
;
2291 if (isAlpha
&& !state
->textures
[Stage
] && arg1
== WINED3DTA_TEXTURE
)
2293 get_src_and_opr(WINED3DTA_DIFFUSE
, isAlpha
, &src1
, &opr1
);
2295 get_src_and_opr(arg1
, isAlpha
, &src1
, &opr1
);
2297 get_src_and_opr(arg2
, isAlpha
, &src2
, &opr2
);
2298 get_src_and_opr(arg3
, isAlpha
, &src3
, &opr3
);
2300 TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target
, src1
, opr1
, src2
, opr2
, src3
, opr3
);
2302 Handled
= TRUE
; /* Assume will be handled */
2304 /* Other texture operations require special extensions: */
2305 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
2309 invopr
= GL_ONE_MINUS_SRC_ALPHA
;
2310 src3_target
= GL_SOURCE3_ALPHA_NV
;
2311 opr3_target
= GL_OPERAND3_ALPHA_NV
;
2314 invopr
= GL_ONE_MINUS_SRC_COLOR
;
2315 src3_target
= GL_SOURCE3_RGB_NV
;
2316 opr3_target
= GL_OPERAND3_RGB_NV
;
2320 case WINED3D_TOP_DISABLE
: /* Only for alpha */
2321 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2322 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2323 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2324 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2325 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2326 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2327 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2328 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2329 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2330 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2331 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2332 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2333 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2334 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2335 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2336 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2337 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2338 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2341 case WINED3D_TOP_SELECT_ARG1
: /* = a1 * 1 + 0 * 0 */
2342 case WINED3D_TOP_SELECT_ARG2
: /* = a2 * 1 + 0 * 0 */
2343 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2344 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2345 if (op
== WINED3D_TOP_SELECT_ARG1
)
2347 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2348 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2349 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2350 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2354 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2355 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2356 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2357 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2359 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2360 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2361 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2362 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2363 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2364 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
2365 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2366 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2367 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2368 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2369 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2370 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2373 case WINED3D_TOP_MODULATE
:
2374 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2375 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2376 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2377 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2378 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2379 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2380 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2381 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2382 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2383 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2384 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2385 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2386 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2387 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2388 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2389 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2390 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2391 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2392 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2393 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2395 case WINED3D_TOP_MODULATE_2X
:
2396 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2397 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2398 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2399 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2400 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2401 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2402 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2403 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2404 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2405 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2406 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2407 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2408 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2409 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2410 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2411 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2412 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2413 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2414 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2415 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2417 case WINED3D_TOP_MODULATE_4X
:
2418 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2419 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2420 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2421 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2422 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2423 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2424 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2425 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2426 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2427 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2428 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_ZERO
);
2429 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2430 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2431 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2432 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2433 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2434 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2435 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
2436 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2437 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2440 case WINED3D_TOP_ADD
:
2441 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2442 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2443 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2444 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2445 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2446 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2447 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2448 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2449 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2450 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2451 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2452 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2453 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2454 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2455 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2456 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2457 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2458 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2459 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2460 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2463 case WINED3D_TOP_ADD_SIGNED
:
2464 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2465 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2466 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2467 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2468 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2469 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2470 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2471 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2472 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2473 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2474 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2475 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2476 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2477 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2478 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2479 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2480 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2481 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2482 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2483 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2486 case WINED3D_TOP_ADD_SIGNED_2X
:
2487 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2488 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2489 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2490 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2491 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2492 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2493 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2494 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2495 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2496 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2497 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2498 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2499 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2500 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2501 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2502 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2503 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2504 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2505 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2506 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2509 case WINED3D_TOP_ADD_SMOOTH
:
2510 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2511 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2512 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2513 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2514 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2515 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2516 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2517 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2518 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2519 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2520 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2521 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2522 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2523 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2524 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2525 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2527 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2528 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2529 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2530 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2532 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2533 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2534 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2535 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2538 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
2539 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2540 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2541 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2542 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2543 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2544 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2545 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_PRIMARY_COLOR
);
2546 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_PRIMARY_COLOR");
2547 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2548 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2549 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2550 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2551 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2552 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2553 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_PRIMARY_COLOR
);
2554 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_PRIMARY_COLOR");
2555 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2556 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2557 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2558 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2560 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
2561 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2562 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2563 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2564 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2565 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2566 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2567 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_TEXTURE
);
2568 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
2569 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2570 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2571 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2572 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2573 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2574 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2575 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2576 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2577 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2578 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2579 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2580 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2582 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
2583 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2584 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2585 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2586 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2587 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2588 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2589 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_CONSTANT
);
2590 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_CONSTANT");
2591 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2592 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2593 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2594 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2595 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2596 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2597 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_CONSTANT
);
2598 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_CONSTANT");
2599 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2600 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2601 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2602 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2604 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
2605 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2606 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2607 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2608 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2609 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2610 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2611 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2612 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2613 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2614 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2615 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2616 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2617 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2618 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2619 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_TEXTURE
);
2620 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
2621 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, GL_ONE_MINUS_SRC_ALPHA
);
2622 checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
2623 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2624 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2626 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
2627 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2628 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
2629 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
); /* a0 = src1/opr1 */
2630 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2631 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2632 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
2633 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2634 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2635 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2636 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2637 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
); /* a2 = arg2 */
2638 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2639 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2640 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
2641 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2642 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2644 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2645 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2647 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2648 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2649 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2650 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2652 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
2653 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2654 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2655 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2656 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2657 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2658 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2659 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2660 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2661 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2662 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2663 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2664 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2666 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2667 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2669 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2670 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2671 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2672 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2673 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2674 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2675 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2676 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2678 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
2679 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2680 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2681 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2682 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2683 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2684 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2685 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2686 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2687 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2688 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2689 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
2690 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2691 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
2692 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2693 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src1
);
2694 checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
2696 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2697 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2698 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2699 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2701 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr
);
2702 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
2703 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2704 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2706 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
2707 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2708 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2709 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2710 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2712 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
2713 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
2714 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2715 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
2717 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
2718 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
2719 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2720 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2721 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2722 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2723 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2724 checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
2726 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
2727 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
2729 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr
);
2730 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
2731 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, GL_ZERO
);
2732 checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
2733 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, invopr
);
2734 checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
2735 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2736 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2738 case WINED3D_TOP_MULTIPLY_ADD
:
2739 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2740 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2741 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src3
);
2742 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2743 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr3
);
2744 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2745 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, GL_ZERO
);
2746 checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
2747 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, invopr
);
2748 checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
2749 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src1
);
2750 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
2751 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr1
);
2752 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
2753 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src3_target
, src2
);
2754 checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
2755 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr3_target
, opr2
);
2756 checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
2757 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2758 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2761 case WINED3D_TOP_BUMPENVMAP
:
2762 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
2763 FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
2772 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE4_NV
);
2773 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
2777 } /* GL_NV_texture_env_combine4 */
2779 Handled
= TRUE
; /* Again, assume handled */
2781 case WINED3D_TOP_DISABLE
: /* Only for alpha */
2782 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2783 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2784 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_PREVIOUS_EXT
);
2785 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
2786 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_SRC_ALPHA
);
2787 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
2788 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2789 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2791 case WINED3D_TOP_SELECT_ARG1
:
2792 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2793 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2794 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2795 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2796 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2797 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2798 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2799 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2801 case WINED3D_TOP_SELECT_ARG2
:
2802 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_REPLACE
);
2803 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
2804 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src2
);
2805 checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
2806 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr2
);
2807 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
2808 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2809 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2811 case WINED3D_TOP_MODULATE
:
2812 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2813 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2814 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2815 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2816 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2817 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2818 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2819 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2820 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2821 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2822 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2823 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2825 case WINED3D_TOP_MODULATE_2X
:
2826 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2827 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2828 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2829 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2830 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2831 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2832 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2833 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2834 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2835 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2836 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2837 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2839 case WINED3D_TOP_MODULATE_4X
:
2840 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE
);
2841 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
2842 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2843 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2844 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2845 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2846 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2847 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2848 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2849 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2850 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 4);
2851 checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
2853 case WINED3D_TOP_ADD
:
2854 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD
);
2855 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
2856 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2857 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2858 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2859 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2860 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2861 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2862 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2863 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2864 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2865 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2867 case WINED3D_TOP_ADD_SIGNED
:
2868 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2869 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2870 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2871 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2872 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2873 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2874 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2875 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2876 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2877 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2878 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2879 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2881 case WINED3D_TOP_ADD_SIGNED_2X
:
2882 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_ADD_SIGNED
);
2883 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
2884 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2885 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2886 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2887 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2888 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2889 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2890 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2891 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2892 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 2);
2893 checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
2895 case WINED3D_TOP_SUBTRACT
:
2896 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
])
2898 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_SUBTRACT
);
2899 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_SUBTRACT");
2900 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2901 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2902 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2903 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2904 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2905 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2906 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2907 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2908 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2909 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2911 FIXME("This version of opengl does not support GL_SUBTRACT\n");
2915 case WINED3D_TOP_BLEND_DIFFUSE_ALPHA
:
2916 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2917 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2918 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2919 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2920 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2921 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2922 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2923 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2924 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2925 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2926 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_PRIMARY_COLOR
);
2927 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
2928 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2929 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2930 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2931 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2933 case WINED3D_TOP_BLEND_TEXTURE_ALPHA
:
2934 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2935 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2936 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2937 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2938 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2939 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2940 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2941 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2942 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2943 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2944 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_TEXTURE
);
2945 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
2946 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2947 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2948 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2949 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2951 case WINED3D_TOP_BLEND_FACTOR_ALPHA
:
2952 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2953 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2954 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2955 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2956 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2957 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2958 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2959 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2960 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2961 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2962 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_CONSTANT
);
2963 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
2964 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2965 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2966 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2967 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2969 case WINED3D_TOP_BLEND_CURRENT_ALPHA
:
2970 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
2971 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
2972 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
2973 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
2974 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
2975 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
2976 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
2977 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
2978 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
2979 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
2980 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, GL_PREVIOUS
);
2981 checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
2982 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, GL_SRC_ALPHA
);
2983 checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
2984 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
2985 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
2987 case WINED3D_TOP_DOTPRODUCT3
:
2988 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
2990 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_ARB
);
2991 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
2993 else if (gl_info
->supported
[EXT_TEXTURE_ENV_DOT3
])
2995 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_DOT3_RGBA_EXT
);
2996 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
2998 FIXME("This version of opengl does not support GL_DOT3\n");
3000 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3001 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3002 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3003 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3004 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
3005 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
3006 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
3007 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
3008 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3009 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3011 case WINED3D_TOP_LERP
:
3012 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_INTERPOLATE
);
3013 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
3014 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3015 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3016 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3017 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3018 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src2
);
3019 checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
3020 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr2
);
3021 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
3022 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src3
);
3023 checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
3024 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr3
);
3025 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
3026 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3027 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3029 case WINED3D_TOP_ADD_SMOOTH
:
3030 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3032 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3033 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3034 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3035 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3037 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
3038 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
3039 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3040 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3042 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3043 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3044 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3045 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3046 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
3047 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
3048 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3049 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3050 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3051 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3052 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3053 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3057 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
3058 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3060 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3061 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3062 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, GL_TEXTURE
);
3063 checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
3064 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, GL_ONE_MINUS_SRC_ALPHA
);
3065 checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
3066 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3067 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3068 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
3069 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
3070 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3071 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3072 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3073 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3074 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3075 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3079 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
3080 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3082 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3083 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3084 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3085 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3087 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3088 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3089 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3090 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3092 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3093 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3094 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3095 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3096 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
3097 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
3098 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3099 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3100 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3101 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3102 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3103 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3107 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
3108 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3110 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3111 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3112 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3113 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3114 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3115 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3116 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3117 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3119 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3120 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3121 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3122 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3124 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
3125 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
3126 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3127 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3128 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3129 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3130 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3131 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3135 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
3136 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3138 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3139 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3140 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3141 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3143 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3144 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3145 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3146 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3148 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3149 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3150 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3151 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3152 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr1
);
3153 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
3154 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3155 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3156 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3157 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3158 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3159 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3163 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
3164 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3166 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3167 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3168 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3169 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3171 case GL_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_COLOR
; break;
3172 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_SRC_COLOR
; break;
3173 case GL_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3174 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3176 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr
);
3177 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
3178 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src1
);
3179 checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
3181 case GL_SRC_COLOR
: opr
= GL_SRC_ALPHA
; break;
3182 case GL_ONE_MINUS_SRC_COLOR
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3183 case GL_SRC_ALPHA
: opr
= GL_SRC_ALPHA
; break;
3184 case GL_ONE_MINUS_SRC_ALPHA
: opr
= GL_ONE_MINUS_SRC_ALPHA
; break;
3186 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr
);
3187 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
3188 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3189 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3190 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3191 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3192 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3193 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3197 case WINED3D_TOP_MULTIPLY_ADD
:
3198 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
])
3200 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, comb_target
, GL_MODULATE_ADD_ATI
);
3201 checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
3202 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src0_target
, src1
);
3203 checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
3204 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr0_target
, opr1
);
3205 checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
3206 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src1_target
, src3
);
3207 checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
3208 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr1_target
, opr3
);
3209 checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
3210 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, src2_target
, src2
);
3211 checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
3212 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, opr2_target
, opr2
);
3213 checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
3214 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, scal_target
, 1);
3215 checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
3219 case WINED3D_TOP_BUMPENVMAP_LUMINANCE
:
3220 case WINED3D_TOP_BUMPENVMAP
:
3221 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
3223 /* Technically texture shader support without register combiners is possible, but not expected to occur
3224 * on real world cards, so for now a fixme should be enough
3226 FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
3236 BOOL combineOK
= TRUE
;
3237 if (gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
3242 op2
= state
->texture_states
[Stage
][WINED3D_TSS_COLOR_OP
];
3244 op2
= state
->texture_states
[Stage
][WINED3D_TSS_ALPHA_OP
];
3246 /* Note: If COMBINE4 in effect can't go back to combine! */
3249 case WINED3D_TOP_ADD_SMOOTH
:
3250 case WINED3D_TOP_BLEND_TEXTURE_ALPHA_PM
:
3251 case WINED3D_TOP_MODULATE_ALPHA_ADD_COLOR
:
3252 case WINED3D_TOP_MODULATE_COLOR_ADD_ALPHA
:
3253 case WINED3D_TOP_MODULATE_INVALPHA_ADD_COLOR
:
3254 case WINED3D_TOP_MODULATE_INVCOLOR_ADD_ALPHA
:
3255 case WINED3D_TOP_MULTIPLY_ADD
:
3256 /* Ignore those implemented in both cases */
3259 case WINED3D_TOP_SELECT_ARG1
:
3260 case WINED3D_TOP_SELECT_ARG2
:
3265 FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op
), debug_d3dtop(op2
), isAlpha
);
3273 gl_info
->gl_ops
.gl
.p_glTexEnvi(GL_TEXTURE_ENV
, GL_TEXTURE_ENV_MODE
, GL_COMBINE
);
3274 checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE");
3280 /* After all the extensions, if still unhandled, report fixme */
3281 FIXME("Unhandled texture operation %s\n", debug_d3dtop(op
));
3285 static void tex_colorop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3287 unsigned int stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3288 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
3289 BOOL tex_used
= context
->fixed_function_usage_map
& (1u << stage
);
3290 unsigned int mapped_stage
= context_gl
->tex_unit_map
[stage
];
3291 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
3293 TRACE("Setting color op for stage %d\n", stage
);
3295 /* Using a pixel shader? Don't care for anything here, the shader applying does it */
3296 if (use_ps(state
)) return;
3298 if (stage
!= mapped_stage
) WARN("Using non 1:1 mapping: %d -> %d!\n", stage
, mapped_stage
);
3300 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3302 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3304 FIXME("Attempt to enable unsupported stage!\n");
3307 wined3d_context_gl_active_texture(context_gl
, gl_info
, mapped_stage
);
3310 if (stage
>= context
->lowest_disabled_stage
)
3312 TRACE("Stage disabled\n");
3313 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3315 /* Disable everything here */
3316 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_2D
);
3317 checkGLcall("glDisable(GL_TEXTURE_2D)");
3318 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_3D
);
3319 checkGLcall("glDisable(GL_TEXTURE_3D)");
3320 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
3322 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_CUBE_MAP_ARB
);
3323 checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
3325 if (gl_info
->supported
[ARB_TEXTURE_RECTANGLE
])
3327 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_RECTANGLE_ARB
);
3328 checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
3335 /* The sampler will also activate the correct texture dimensions, so no
3336 * need to do it here if the sampler for this stage is dirty. */
3337 if (!isStateDirty(context
, STATE_SAMPLER(stage
)) && tex_used
)
3338 texture_activate_dimensions(state
->textures
[stage
], gl_info
);
3340 set_tex_op(gl_info
, state
, FALSE
, stage
,
3341 state
->texture_states
[stage
][WINED3D_TSS_COLOR_OP
],
3342 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG1
],
3343 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG2
],
3344 state
->texture_states
[stage
][WINED3D_TSS_COLOR_ARG0
]);
3347 void tex_alphaop(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3349 unsigned int stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3350 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
3351 BOOL tex_used
= context
->fixed_function_usage_map
& (1u << stage
);
3352 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
3353 unsigned int mapped_stage
= context_gl
->tex_unit_map
[stage
];
3354 DWORD op
, arg1
, arg2
, arg0
;
3356 TRACE("Setting alpha op for stage %d\n", stage
);
3357 /* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
3358 if (mapped_stage
!= WINED3D_UNMAPPED_STAGE
)
3360 if (tex_used
&& mapped_stage
>= gl_info
->limits
.textures
)
3362 FIXME("Attempt to enable unsupported stage!\n");
3365 wined3d_context_gl_active_texture(context_gl
, gl_info
, mapped_stage
);
3368 op
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_OP
];
3369 arg1
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG1
];
3370 arg2
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG2
];
3371 arg0
= state
->texture_states
[stage
][WINED3D_TSS_ALPHA_ARG0
];
3373 if (state
->render_states
[WINED3D_RS_COLORKEYENABLE
] && !stage
&& state
->textures
[0])
3375 struct wined3d_texture_gl
*texture_gl
= wined3d_texture_gl(state
->textures
[0]);
3376 GLenum texture_dimensions
= texture_gl
->target
;
3378 if (texture_dimensions
== GL_TEXTURE_2D
|| texture_dimensions
== GL_TEXTURE_RECTANGLE_ARB
)
3380 if (texture_gl
->t
.async
.color_key_flags
& WINED3D_CKEY_SRC_BLT
3381 && !texture_gl
->t
.resource
.format
->alpha_size
)
3383 /* Color keying needs to pass alpha values from the texture through to have the alpha test work
3384 * properly. On the other hand applications can still use texture combiners apparently. This code
3385 * takes care that apps cannot remove the texture's alpha channel entirely.
3387 * The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires
3388 * D3DTOP_MODULATE to work on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures
3389 * and alpha component of diffuse color to draw things like translucent text and perform other
3392 * Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To
3393 * provide the behavior expected by the game, while emulating the colorkey, diffuse alpha must be
3394 * modulated with texture alpha. OTOH, Moto racer 2 at some points sets alphaop/alphaarg to
3395 * SELECTARG/CURRENT, yet puts garbage in diffuse alpha (zeroes). This works on native, because the
3396 * game disables alpha test and alpha blending. Alpha test is overwritten by wine's for purposes of
3397 * color-keying though, so this will lead to missing geometry if texture alpha is modulated (pixels
3398 * fail alpha test). To get around this, blend state is checked: if the app enables alpha blending,
3399 * it can be expected to provide meaningful values in diffuse alpha, so it should be modulated with
3400 * texture alpha; otherwise, selecting diffuse alpha is ignored in favour of texture alpha.
3402 * What to do with multitexturing? So far no app has been found that uses color keying with
3404 if (op
== WINED3D_TOP_DISABLE
)
3406 arg1
= WINED3DTA_TEXTURE
;
3407 op
= WINED3D_TOP_SELECT_ARG1
;
3409 else if (op
== WINED3D_TOP_SELECT_ARG1
&& arg1
!= WINED3DTA_TEXTURE
)
3411 if (state
->blend_state
&& state
->blend_state
->desc
.rt
[0].enable
)
3413 arg2
= WINED3DTA_TEXTURE
;
3414 op
= WINED3D_TOP_MODULATE
;
3416 else arg1
= WINED3DTA_TEXTURE
;
3418 else if (op
== WINED3D_TOP_SELECT_ARG2
&& arg2
!= WINED3DTA_TEXTURE
)
3420 if (state
->blend_state
&& state
->blend_state
->desc
.rt
[0].enable
)
3422 arg1
= WINED3DTA_TEXTURE
;
3423 op
= WINED3D_TOP_MODULATE
;
3425 else arg2
= WINED3DTA_TEXTURE
;
3431 /* tex_alphaop is shared between the ffp and nvrc because the difference only comes down to
3432 * this if block here, and the other code(color keying, texture unit selection) are the same
3434 TRACE("Setting alpha op for stage %d\n", stage
);
3435 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
3437 set_tex_op_nvrc(gl_info
, state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
,
3438 mapped_stage
, state
->texture_states
[stage
][WINED3D_TSS_RESULT_ARG
]);
3442 set_tex_op(gl_info
, state
, TRUE
, stage
, op
, arg1
, arg2
, arg0
);
3446 static void transform_texture(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3448 unsigned int tex
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3449 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
3450 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
3451 unsigned int mapped_stage
= context_gl
->tex_unit_map
[tex
];
3452 struct wined3d_matrix mat
;
3456 TRACE("Using a vertex shader, skipping.\n");
3460 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
) return;
3461 if (mapped_stage
>= gl_info
->limits
.textures
) return;
3463 wined3d_context_gl_active_texture(context_gl
, gl_info
, mapped_stage
);
3464 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_TEXTURE
);
3465 checkGLcall("glMatrixMode(GL_TEXTURE)");
3467 get_texture_matrix(context
, state
, mapped_stage
, &mat
);
3469 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&mat
._11
);
3470 checkGLcall("glLoadMatrixf");
3473 static void tex_coordindex(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3475 unsigned int stage
= (state_id
- STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE
+ 1);
3476 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
3477 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
3478 unsigned int mapped_stage
= context_gl
->tex_unit_map
[stage
];
3480 static const GLfloat s_plane
[] = { 1.0f
, 0.0f
, 0.0f
, 0.0f
};
3481 static const GLfloat t_plane
[] = { 0.0f
, 1.0f
, 0.0f
, 0.0f
};
3482 static const GLfloat r_plane
[] = { 0.0f
, 0.0f
, 1.0f
, 0.0f
};
3483 static const GLfloat q_plane
[] = { 0.0f
, 0.0f
, 0.0f
, 1.0f
};
3485 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3487 TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage
);
3491 if (mapped_stage
>= min(gl_info
->limits
.samplers
[WINED3D_SHADER_TYPE_PIXEL
], WINED3D_MAX_FRAGMENT_SAMPLERS
))
3493 WARN("stage %u not mapped to a valid texture unit (%u)\n", stage
, mapped_stage
);
3496 wined3d_context_gl_active_texture(context_gl
, gl_info
, mapped_stage
);
3498 /* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
3500 * FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
3501 * eg. SetTextureStageState( 0, WINED3D_TSS_TEXCOORDINDEX, WINED3D_TSS_TCI_CAMERASPACEPOSITION | 1 );
3502 * means use the vertex position (camera-space) as the input texture coordinates
3503 * for this texture stage, and the wrap mode set in the WINED3D_RS_WRAP1 render
3504 * state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
3505 * to the TEXCOORDINDEX value
3507 switch (state
->texture_states
[stage
][WINED3D_TSS_TEXCOORD_INDEX
] & 0xffff0000)
3509 case WINED3DTSS_TCI_PASSTHRU
:
3510 /* Use the specified texture coordinates contained within the
3511 * vertex format. This value resolves to zero. */
3512 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_S
);
3513 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_T
);
3514 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3515 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_Q
);
3516 checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
3519 case WINED3DTSS_TCI_CAMERASPACEPOSITION
:
3520 /* CameraSpacePosition means use the vertex position, transformed to camera space,
3521 * as the input texture coordinates for this stage's texture transformation. This
3522 * equates roughly to EYE_LINEAR */
3524 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3525 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3526 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3527 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3528 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3529 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3530 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3531 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3532 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
3534 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3535 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3536 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_EYE_LINEAR
);
3537 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
3539 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3540 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3541 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3542 checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
3546 case WINED3DTSS_TCI_CAMERASPACENORMAL
:
3547 /* Note that NV_TEXGEN_REFLECTION support is implied when
3548 * ARB_TEXTURE_CUBE_MAP is supported */
3549 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3551 FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
3555 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3556 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3557 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3558 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3559 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3560 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3561 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3562 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3563 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
3565 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3566 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3567 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_NORMAL_MAP_NV
);
3568 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
3570 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3571 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3572 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3573 checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
3577 case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR
:
3578 /* Note that NV_TEXGEN_REFLECTION support is implied when
3579 * ARB_TEXTURE_CUBE_MAP is supported */
3580 if (!gl_info
->supported
[NV_TEXGEN_REFLECTION
])
3582 FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
3586 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3587 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3588 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3589 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_S
, GL_EYE_PLANE
, s_plane
);
3590 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_T
, GL_EYE_PLANE
, t_plane
);
3591 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_R
, GL_EYE_PLANE
, r_plane
);
3592 gl_info
->gl_ops
.gl
.p_glTexGenfv(GL_Q
, GL_EYE_PLANE
, q_plane
);
3593 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3594 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
3596 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3597 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3598 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_R
, GL_TEXTURE_GEN_MODE
, GL_REFLECTION_MAP_NV
);
3599 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
3601 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3602 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3603 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_R
);
3604 checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
3608 case WINED3DTSS_TCI_SPHEREMAP
:
3609 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_S
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3610 gl_info
->gl_ops
.gl
.p_glTexGeni(GL_T
, GL_TEXTURE_GEN_MODE
, GL_SPHERE_MAP
);
3611 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
3613 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_S
);
3614 gl_info
->gl_ops
.gl
.p_glEnable(GL_TEXTURE_GEN_T
);
3615 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3616 checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
3621 FIXME("Unhandled WINED3D_TSS_TEXCOORD_INDEX %#x.\n",
3622 state
->texture_states
[stage
][WINED3D_TSS_TEXCOORD_INDEX
]);
3623 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_S
);
3624 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_T
);
3625 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_R
);
3626 gl_info
->gl_ops
.gl
.p_glDisable(GL_TEXTURE_GEN_Q
);
3627 checkGLcall("Disable texgen.");
3632 /* Update the texture matrix. */
3633 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ stage
)))
3634 transform_texture(context
, state
, STATE_TEXTURESTAGE(stage
, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
3636 if (!isStateDirty(context
, STATE_VDECL
) && context
->namedArraysLoaded
)
3638 /* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
3639 * source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
3640 * and do all the things linked to it
3641 * TODO: Tidy that up to reload only the arrays of the changed unit
3643 GLuint curVBO
= gl_info
->supported
[ARB_VERTEX_BUFFER_OBJECT
] ? ~0U : 0;
3645 wined3d_context_gl_unload_tex_coords(context_gl
);
3646 wined3d_context_gl_load_tex_coords(context_gl
, &context
->stream_info
, &curVBO
, state
);
3650 static void sampler_texmatrix(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3652 const DWORD sampler
= state_id
- STATE_SAMPLER(0);
3653 const struct wined3d_texture
*texture
= state
->textures
[sampler
];
3655 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
3660 /* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
3661 * wined3d_texture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
3662 * scaling is reapplied or removed, the texture matrix has to be reapplied.
3664 if (sampler
< WINED3D_MAX_TEXTURES
)
3666 const BOOL tex_is_pow2
= !(texture
->flags
& WINED3D_TEXTURE_POW2_MAT_IDENT
);
3668 if (tex_is_pow2
|| (context
->lastWasPow2Texture
& (1u << sampler
)))
3671 context
->lastWasPow2Texture
|= 1u << sampler
;
3673 context
->lastWasPow2Texture
&= ~(1u << sampler
);
3675 transform_texture(context
, state
, STATE_TEXTURESTAGE(sampler
, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
3680 static enum wined3d_texture_address
wined3d_texture_gl_address_mode(const struct wined3d_texture_gl
*texture_gl
,
3681 enum wined3d_texture_address t
)
3683 if (t
< WINED3D_TADDRESS_WRAP
|| t
> WINED3D_TADDRESS_MIRROR_ONCE
)
3685 FIXME("Unrecognized or unsupported texture address mode %#x.\n", t
);
3686 return WINED3D_TADDRESS_WRAP
;
3689 /* Cubemaps are always set to clamp, regardless of the sampler state. */
3690 if (texture_gl
->target
== GL_TEXTURE_CUBE_MAP_ARB
|| ((texture_gl
->t
.flags
& WINED3D_TEXTURE_COND_NP2
)
3691 && t
== WINED3D_TADDRESS_WRAP
))
3692 return WINED3D_TADDRESS_CLAMP
;
3697 static void wined3d_sampler_desc_from_sampler_states(struct wined3d_sampler_desc
*desc
,
3698 const struct wined3d_context_gl
*context_gl
, const DWORD
*sampler_states
,
3699 const struct wined3d_texture_gl
*texture_gl
)
3707 desc
->address_u
= wined3d_texture_gl_address_mode(texture_gl
, sampler_states
[WINED3D_SAMP_ADDRESS_U
]);
3708 desc
->address_v
= wined3d_texture_gl_address_mode(texture_gl
, sampler_states
[WINED3D_SAMP_ADDRESS_V
]);
3709 desc
->address_w
= wined3d_texture_gl_address_mode(texture_gl
, sampler_states
[WINED3D_SAMP_ADDRESS_W
]);
3710 wined3d_color_from_d3dcolor((struct wined3d_color
*)desc
->border_color
,
3711 sampler_states
[WINED3D_SAMP_BORDER_COLOR
]);
3712 if (sampler_states
[WINED3D_SAMP_MAG_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3713 FIXME("Unrecognized or unsupported WINED3D_SAMP_MAG_FILTER %#x.\n",
3714 sampler_states
[WINED3D_SAMP_MAG_FILTER
]);
3715 desc
->mag_filter
= min(max(sampler_states
[WINED3D_SAMP_MAG_FILTER
], WINED3D_TEXF_POINT
), WINED3D_TEXF_LINEAR
);
3716 if (sampler_states
[WINED3D_SAMP_MIN_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3717 FIXME("Unrecognized or unsupported WINED3D_SAMP_MIN_FILTER %#x.\n",
3718 sampler_states
[WINED3D_SAMP_MIN_FILTER
]);
3719 desc
->min_filter
= min(max(sampler_states
[WINED3D_SAMP_MIN_FILTER
], WINED3D_TEXF_POINT
), WINED3D_TEXF_LINEAR
);
3720 if (sampler_states
[WINED3D_SAMP_MIP_FILTER
] > WINED3D_TEXF_ANISOTROPIC
)
3721 FIXME("Unrecognized or unsupported WINED3D_SAMP_MIP_FILTER %#x.\n",
3722 sampler_states
[WINED3D_SAMP_MIP_FILTER
]);
3723 desc
->mip_filter
= min(max(sampler_states
[WINED3D_SAMP_MIP_FILTER
], WINED3D_TEXF_NONE
), WINED3D_TEXF_LINEAR
);
3724 lod_bias
.d
= sampler_states
[WINED3D_SAMP_MIPMAP_LOD_BIAS
];
3725 desc
->lod_bias
= lod_bias
.f
;
3726 desc
->min_lod
= -1000.0f
;
3727 desc
->max_lod
= 1000.0f
;
3728 desc
->mip_base_level
= sampler_states
[WINED3D_SAMP_MAX_MIP_LEVEL
];
3729 desc
->max_anisotropy
= sampler_states
[WINED3D_SAMP_MAX_ANISOTROPY
];
3730 if ((sampler_states
[WINED3D_SAMP_MAG_FILTER
] != WINED3D_TEXF_ANISOTROPIC
3731 && sampler_states
[WINED3D_SAMP_MIN_FILTER
] != WINED3D_TEXF_ANISOTROPIC
3732 && sampler_states
[WINED3D_SAMP_MIP_FILTER
] != WINED3D_TEXF_ANISOTROPIC
)
3733 || (texture_gl
->t
.flags
& WINED3D_TEXTURE_COND_NP2
))
3734 desc
->max_anisotropy
= 1;
3735 desc
->compare
= texture_gl
->t
.resource
.format_caps
& WINED3D_FORMAT_CAP_SHADOW
;
3736 desc
->comparison_func
= WINED3D_CMP_LESSEQUAL
;
3737 desc
->srgb_decode
= is_srgb_enabled(sampler_states
);
3739 if (!(texture_gl
->t
.resource
.format_caps
& WINED3D_FORMAT_CAP_FILTERING
))
3741 desc
->mag_filter
= WINED3D_TEXF_POINT
;
3742 desc
->min_filter
= WINED3D_TEXF_POINT
;
3743 desc
->mip_filter
= WINED3D_TEXF_NONE
;
3746 if (texture_gl
->t
.flags
& WINED3D_TEXTURE_COND_NP2
)
3748 desc
->mip_filter
= WINED3D_TEXF_NONE
;
3749 if (context_gl
->gl_info
->supported
[WINED3D_GL_NORMALIZED_TEXRECT
])
3750 desc
->min_filter
= WINED3D_TEXF_POINT
;
3754 /* Enabling and disabling texture dimensions is done by texture stage state /
3755 * pixel shader setup, this function only has to bind textures and set the per
3756 * texture states. */
3757 static void sampler(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3759 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
3760 unsigned int sampler_idx
= state_id
- STATE_SAMPLER(0);
3761 unsigned int mapped_stage
= context_gl
->tex_unit_map
[sampler_idx
];
3762 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
3764 TRACE("Sampler %u.\n", sampler_idx
);
3766 if (mapped_stage
== WINED3D_UNMAPPED_STAGE
)
3768 TRACE("No sampler mapped to stage %u. Returning.\n", sampler_idx
);
3772 if (mapped_stage
>= gl_info
->limits
.graphics_samplers
)
3774 wined3d_context_gl_active_texture(context_gl
, gl_info
, mapped_stage
);
3776 if (state
->textures
[sampler_idx
])
3778 struct wined3d_texture_gl
*texture_gl
= wined3d_texture_gl(state
->textures
[sampler_idx
]);
3779 const DWORD
*sampler_states
= state
->sampler_states
[sampler_idx
];
3780 struct wined3d_device
*device
= context
->device
;
3781 BOOL srgb
= is_srgb_enabled(sampler_states
);
3782 struct wined3d_sampler_desc desc
;
3783 struct wined3d_sampler
*sampler
;
3784 struct wine_rb_entry
*entry
;
3786 wined3d_sampler_desc_from_sampler_states(&desc
, context_gl
, sampler_states
, texture_gl
);
3788 wined3d_texture_gl_bind(texture_gl
, context_gl
, srgb
);
3790 if ((entry
= wine_rb_get(&device
->samplers
, &desc
)))
3792 sampler
= WINE_RB_ENTRY_VALUE(entry
, struct wined3d_sampler
, entry
);
3796 if (FAILED(wined3d_sampler_create(device
, &desc
, NULL
, &wined3d_null_parent_ops
, &sampler
)))
3798 ERR("Failed to create sampler.\n");
3801 if (wine_rb_put(&device
->samplers
, &desc
, &sampler
->entry
) == -1)
3803 ERR("Failed to insert sampler.\n");
3804 wined3d_sampler_decref(sampler
);
3809 wined3d_sampler_gl_bind(wined3d_sampler_gl(sampler
), mapped_stage
, texture_gl
, context_gl
);
3811 /* Trigger shader constant reloading (for NP2 texcoord fixup) */
3812 if (!(texture_gl
->t
.flags
& WINED3D_TEXTURE_POW2_MAT_IDENT
))
3813 context
->constant_update_mask
|= WINED3D_SHADER_CONST_PS_NP2_FIXUP
;
3817 wined3d_context_gl_bind_texture(context_gl
, GL_NONE
, 0);
3818 if (gl_info
->supported
[ARB_SAMPLER_OBJECTS
])
3820 GL_EXTCALL(glBindSampler(mapped_stage
, 0));
3821 checkGLcall("glBindSampler");
3826 void apply_pixelshader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3832 if (!context
->last_was_pshader
)
3834 /* Former draw without a pixel shader, some samplers may be
3835 * disabled because of WINED3D_TSS_COLOR_OP = WINED3DTOP_DISABLE
3836 * make sure to enable them. */
3837 for (i
= 0; i
< WINED3D_MAX_FRAGMENT_SAMPLERS
; ++i
)
3839 if (!isStateDirty(context
, STATE_SAMPLER(i
)))
3840 sampler(context
, state
, STATE_SAMPLER(i
));
3842 context
->last_was_pshader
= TRUE
;
3846 /* Otherwise all samplers were activated by the code above in
3847 * earlier draws, or by sampler() if a different texture was
3848 * bound. I don't have to do anything. */
3853 /* Disabled the pixel shader - color ops weren't applied while it was
3854 * enabled, so re-apply them. */
3855 for (i
= 0; i
< context
->d3d_info
->limits
.ffp_blend_stages
; ++i
)
3857 if (!isStateDirty(context
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_COLOR_OP
)))
3858 context_apply_state(context
, state
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_COLOR_OP
));
3860 context
->last_was_pshader
= FALSE
;
3863 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_PIXEL
;
3866 static void state_compute_shader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3868 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_COMPUTE
;
3871 static void state_shader(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3873 enum wined3d_shader_type shader_type
= state_id
- STATE_SHADER(0);
3874 context
->shader_update_mask
|= 1u << shader_type
;
3877 static void shader_bumpenv(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3879 context
->constant_update_mask
|= WINED3D_SHADER_CONST_PS_BUMP_ENV
;
3882 static void transform_world(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3884 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
3885 struct wined3d_matrix mat
;
3887 /* This function is called by transform_view below if the view matrix was changed too
3889 * Deliberately no check if the vertex declaration is dirty because the vdecl state
3890 * does not always update the world matrix, only on a switch between transformed
3891 * and untransformed draws. It *may* happen that the world matrix is set 2 times during one
3892 * draw, but that should be rather rare and cheaper in total.
3894 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3895 checkGLcall("glMatrixMode");
3897 get_modelview_matrix(context
, state
, 0, &mat
);
3899 gl_info
->gl_ops
.gl
.p_glLoadMatrixf((GLfloat
*)&mat
);
3900 checkGLcall("glLoadMatrixf");
3903 void clipplane(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3905 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
3906 UINT index
= state_id
- STATE_CLIPPLANE(0);
3909 if (isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_VIEW
)) || index
>= gl_info
->limits
.user_clip_distances
)
3912 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3913 gl_info
->gl_ops
.gl
.p_glPushMatrix();
3915 /* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
3917 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
]._11
);
3919 /* With vertex shaders, clip planes are not transformed in Direct3D,
3920 * while in OpenGL they are still transformed by the model view matrix. */
3921 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3923 plane
[0] = state
->clip_planes
[index
].x
;
3924 plane
[1] = state
->clip_planes
[index
].y
;
3925 plane
[2] = state
->clip_planes
[index
].z
;
3926 plane
[3] = state
->clip_planes
[index
].w
;
3928 TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
3929 plane
[0], plane
[1], plane
[2], plane
[3]);
3930 gl_info
->gl_ops
.gl
.p_glClipPlane(GL_CLIP_PLANE0
+ index
, plane
);
3931 checkGLcall("glClipPlane");
3933 gl_info
->gl_ops
.gl
.p_glPopMatrix();
3936 static void transform_worldex(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3938 unsigned int matrix
= state_id
- STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0));
3940 WARN("Unsupported world matrix %u set.\n", matrix
);
3943 static void state_vertexblend_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3945 enum wined3d_vertex_blend_flags f
= state
->render_states
[WINED3D_RS_VERTEXBLEND
];
3946 static unsigned int once
;
3948 if (f
== WINED3D_VBF_DISABLE
)
3951 if (!once
++) FIXME("Vertex blend flags %#x not supported.\n", f
);
3952 else WARN("Vertex blend flags %#x not supported.\n", f
);
3955 static void transform_view(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
3957 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
3958 const struct wined3d_light_info
*light
= NULL
;
3961 /* If we are changing the View matrix, reset the light and clipping planes to the new view
3962 * NOTE: We have to reset the positions even if the light/plane is not currently
3963 * enabled, since the call to enable it will not reset the position.
3964 * NOTE2: Apparently texture transforms do NOT need reapplying
3967 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
3968 checkGLcall("glMatrixMode(GL_MODELVIEW)");
3969 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
]._11
);
3970 checkGLcall("glLoadMatrixf(...)");
3972 /* Reset lights. TODO: Call light apply func */
3973 for (k
= 0; k
< gl_info
->limits
.lights
; ++k
)
3975 if (!(light
= state
->light_state
.lights
[k
]))
3977 if (light
->OriginalParms
.type
== WINED3D_LIGHT_DIRECTIONAL
)
3978 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_POSITION
, &light
->direction
.x
);
3980 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_POSITION
, &light
->position
.x
);
3981 checkGLcall("glLightfv posn");
3982 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ light
->glIndex
, GL_SPOT_DIRECTION
, &light
->direction
.x
);
3983 checkGLcall("glLightfv dirn");
3986 /* Reset Clipping Planes */
3987 for (k
= 0; k
< gl_info
->limits
.user_clip_distances
; ++k
)
3989 if (!isStateDirty(context
, STATE_CLIPPLANE(k
)))
3990 clipplane(context
, state
, STATE_CLIPPLANE(k
));
3993 if (context
->last_was_rhw
)
3995 gl_info
->gl_ops
.gl
.p_glLoadIdentity();
3996 checkGLcall("glLoadIdentity()");
3997 /* No need to update the world matrix, the identity is fine */
4001 /* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
4002 * No need to do it here if the state is scheduled for update. */
4003 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0))))
4004 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4007 static void transform_projection(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4009 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4010 struct wined3d_matrix projection
;
4012 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_PROJECTION
);
4013 checkGLcall("glMatrixMode(GL_PROJECTION)");
4015 get_projection_matrix(context
, state
, &projection
);
4016 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&projection
._11
);
4017 checkGLcall("glLoadMatrixf");
4020 static void streamsrc(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4022 wined3d_context_gl_update_stream_sources(wined3d_context_gl(context
), state
);
4025 static void vdecl_miscpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4027 if (isStateDirty(context
, STATE_STREAMSRC
))
4029 wined3d_context_gl_update_stream_sources(wined3d_context_gl(context
), state
);
4032 static void vertexdeclaration(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4034 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
4035 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
4036 BOOL useVertexShaderFunction
= use_vs(state
);
4037 BOOL updateFog
= FALSE
;
4039 BOOL wasrhw
= context
->last_was_rhw
;
4042 transformed
= context
->stream_info
.position_transformed
;
4043 if (transformed
!= context
->last_was_rhw
&& !useVertexShaderFunction
)
4046 context
->last_was_rhw
= transformed
;
4048 if (context
->stream_info
.swizzle_map
!= context
->last_swizzle_map
)
4049 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_VERTEX
;
4051 context
->last_swizzle_map
= context
->stream_info
.swizzle_map
;
4053 /* Don't have to apply the matrices when vertex shaders are used. When
4054 * vshaders are turned off this function will be called again anyway to
4055 * make sure they're properly set. */
4056 if (!useVertexShaderFunction
)
4058 /* TODO: Move this mainly to the viewport state and only apply when
4059 * the vp has changed or transformed / untransformed was switched. */
4060 if (wasrhw
!= context
->last_was_rhw
4061 && !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
))
4062 && !isStateDirty(context
, STATE_VIEWPORT
))
4063 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4064 /* World matrix needs reapplication here only if we're switching between rhw and non-rhw
4067 * If a vertex shader is used, the world matrix changed and then vertex shader unbound
4068 * this check will fail and the matrix not applied again. This is OK because a simple
4069 * world matrix change reapplies the matrix - These checks here are only to satisfy the
4070 * needs of the vertex declaration.
4072 * World and view matrix go into the same gl matrix, so only apply them when neither is
4075 if (transformed
!= wasrhw
&& !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)))
4076 && !isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_VIEW
)))
4077 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4078 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_COLORVERTEX
)))
4079 context_apply_state(context
, state
, STATE_RENDER(WINED3D_RS_COLORVERTEX
));
4080 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_LIGHTING
)))
4081 state_lighting(context
, state
, STATE_RENDER(WINED3D_RS_LIGHTING
));
4083 if (context
->last_was_vshader
)
4087 if (!context
->d3d_info
->vs_clipping
4088 && !isStateDirty(context
, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
)))
4090 state_clipping(context
, state
, STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
));
4093 for (i
= 0; i
< gl_info
->limits
.user_clip_distances
; ++i
)
4095 clipplane(context
, state
, STATE_CLIPPLANE(i
));
4098 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
)))
4099 state_normalize(context
, state
, STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
));
4103 if (!context
->last_was_vshader
)
4105 static BOOL warned
= FALSE
;
4106 if (!context
->d3d_info
->vs_clipping
)
4108 /* Disable all clip planes to get defined results on all drivers. See comment in the
4109 * state_clipping state handler
4111 wined3d_context_gl_enable_clip_distances(context_gl
, 0);
4113 if (!warned
&& state
->render_states
[WINED3D_RS_CLIPPLANEENABLE
])
4115 FIXME("Clipping not supported with vertex shaders.\n");
4121 /* Apply the transform matrices when switching from rhw
4122 * drawing to vertex shaders. Vertex shaders themselves do
4123 * not need it, but the matrices are not reapplied
4124 * automatically when switching back from vertex shaders to
4125 * fixed function processing. So make sure we leave the fixed
4126 * function vertex processing states back in a sane state
4127 * before switching to shaders. */
4128 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
)))
4129 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4130 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0))))
4131 transform_world(context
, state
, STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(0)));
4135 /* Vertex shader clipping ignores the view matrix. Update all clipplanes
4136 * (Note: ARB shaders can read the clip planes for clipping emulation even if
4137 * device->vs_clipping is false.
4139 for (i
= 0; i
< gl_info
->limits
.user_clip_distances
; ++i
)
4141 clipplane(context
, state
, STATE_CLIPPLANE(i
));
4146 context
->last_was_vshader
= useVertexShaderFunction
;
4147 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_VERTEX
;
4150 context_apply_state(context
, state
, STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
));
4152 if (!useVertexShaderFunction
)
4156 for (i
= 0; i
< WINED3D_MAX_TEXTURES
; ++i
)
4158 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ i
)))
4159 transform_texture(context
, state
, STATE_TEXTURESTAGE(i
, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
));
4162 if (use_ps(state
) && state
->shader
[WINED3D_SHADER_TYPE_PIXEL
]->reg_maps
.shader_version
.major
== 1
4163 && state
->shader
[WINED3D_SHADER_TYPE_PIXEL
]->reg_maps
.shader_version
.minor
<= 3)
4164 context
->shader_update_mask
|= 1u << WINED3D_SHADER_TYPE_PIXEL
;
4168 static void get_viewports(struct wined3d_context
*context
, const struct wined3d_state
*state
,
4169 unsigned int viewport_count
, struct wined3d_viewport
*viewports
)
4171 const struct wined3d_rendertarget_view
*depth_stencil
= state
->fb
.depth_stencil
;
4172 const struct wined3d_rendertarget_view
*target
= state
->fb
.render_targets
[0];
4173 unsigned int width
, height
, i
;
4175 for (i
= 0; i
< viewport_count
; ++i
)
4176 viewports
[i
] = state
->viewports
[i
];
4178 /* Note: GL uses a lower left origin while DirectX uses upper left. This
4179 * is reversed when using offscreen rendering. */
4180 if (context
->render_offscreen
)
4185 wined3d_rendertarget_view_get_drawable_size(target
, context
, &width
, &height
);
4187 else if (depth_stencil
)
4189 height
= depth_stencil
->height
;
4193 FIXME("Could not get the height of render targets.\n");
4197 for (i
= 0; i
< viewport_count
; ++i
)
4198 viewports
[i
].y
= height
- (viewports
[i
].y
+ viewports
[i
].height
);
4201 static void viewport_miscpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4203 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4204 struct wined3d_viewport vp
[WINED3D_MAX_VIEWPORTS
];
4207 if (gl_info
->supported
[ARB_VIEWPORT_ARRAY
])
4209 GLdouble depth_ranges
[2 * WINED3D_MAX_VIEWPORTS
];
4210 GLfloat viewports
[4 * WINED3D_MAX_VIEWPORTS
];
4212 unsigned int i
, reset_count
= 0;
4214 get_viewports(context
, state
, state
->viewport_count
, vp
);
4215 for (i
= 0; i
< state
->viewport_count
; ++i
)
4217 wined3d_viewport_get_z_range(&vp
[i
], &min_z
, &max_z
);
4218 depth_ranges
[i
* 2] = min_z
;
4219 depth_ranges
[i
* 2 + 1] = max_z
;
4221 viewports
[i
* 4] = vp
[i
].x
;
4222 viewports
[i
* 4 + 1] = vp
[i
].y
;
4223 viewports
[i
* 4 + 2] = vp
[i
].width
;
4224 viewports
[i
* 4 + 3] = vp
[i
].height
;
4226 /* Don't pass fractionals to GL if we earlier decided not to use
4227 * this functionality for two reasons: First, GL might offer us
4228 * fewer than 8 bits, and still make use of the fractional, in
4229 * addition to the emulation we apply in shader_get_position_fixup.
4230 * Second, even if GL tells us it has no subpixel precision (Mac OS!)
4231 * it might still do something with the fractional amount, e.g.
4232 * round it upwards. I can't find any info on rounding in
4233 * GL_ARB_viewport_array. */
4234 if (!context
->d3d_info
->subpixel_viewport
)
4236 viewports
[i
* 4] = floor(viewports
[i
* 4]);
4237 viewports
[i
* 4 + 1] = floor(viewports
[i
* 4 + 1]);
4238 viewports
[i
* 4 + 2] = floor(viewports
[i
* 4 + 2]);
4239 viewports
[i
* 4 + 3] = floor(viewports
[i
* 4 + 3]);
4243 if (context
->viewport_count
> state
->viewport_count
)
4244 reset_count
= context
->viewport_count
- state
->viewport_count
;
4248 memset(&depth_ranges
[state
->viewport_count
* 2], 0, reset_count
* 2 * sizeof(*depth_ranges
));
4249 memset(&viewports
[state
->viewport_count
* 4], 0, reset_count
* 4 * sizeof(*viewports
));
4252 GL_EXTCALL(glDepthRangeArrayv(0, state
->viewport_count
+ reset_count
, depth_ranges
));
4253 GL_EXTCALL(glViewportArrayv(0, state
->viewport_count
+ reset_count
, viewports
));
4254 context
->viewport_count
= state
->viewport_count
;
4258 get_viewports(context
, state
, 1, vp
);
4259 wined3d_viewport_get_z_range(&vp
[0], &min_z
, &max_z
);
4260 gl_info
->gl_ops
.gl
.p_glDepthRange(min_z
, max_z
);
4261 gl_info
->gl_ops
.gl
.p_glViewport(vp
[0].x
, vp
[0].y
, vp
[0].width
, vp
[0].height
);
4263 checkGLcall("setting clip space and viewport");
4266 static void viewport_miscpart_cc(struct wined3d_context
*context
,
4267 const struct wined3d_state
*state
, DWORD state_id
)
4269 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4270 /* See get_projection_matrix() in utils.c for a discussion about those values. */
4271 float pixel_center_offset
= context
->d3d_info
->wined3d_creation_flags
4272 & WINED3D_PIXEL_CENTER_INTEGER
? 0.5f
: 0.0f
;
4273 struct wined3d_viewport vp
[WINED3D_MAX_VIEWPORTS
];
4274 GLdouble depth_ranges
[2 * WINED3D_MAX_VIEWPORTS
];
4275 GLfloat viewports
[4 * WINED3D_MAX_VIEWPORTS
];
4276 unsigned int i
, reset_count
= 0;
4279 pixel_center_offset
+= context
->d3d_info
->filling_convention_offset
/ 2.0f
;
4280 get_viewports(context
, state
, state
->viewport_count
, vp
);
4282 GL_EXTCALL(glClipControl(context
->render_offscreen
? GL_UPPER_LEFT
: GL_LOWER_LEFT
, GL_ZERO_TO_ONE
));
4284 for (i
= 0; i
< state
->viewport_count
; ++i
)
4286 wined3d_viewport_get_z_range(&vp
[i
], &min_z
, &max_z
);
4287 depth_ranges
[i
* 2] = min_z
;
4288 depth_ranges
[i
* 2 + 1] = max_z
;
4290 viewports
[i
* 4] = vp
[i
].x
+ pixel_center_offset
;
4291 viewports
[i
* 4 + 1] = vp
[i
].y
+ pixel_center_offset
;
4292 viewports
[i
* 4 + 2] = vp
[i
].width
;
4293 viewports
[i
* 4 + 3] = vp
[i
].height
;
4296 if (context
->viewport_count
> state
->viewport_count
)
4297 reset_count
= context
->viewport_count
- state
->viewport_count
;
4301 memset(&depth_ranges
[state
->viewport_count
* 2], 0, reset_count
* 2 * sizeof(*depth_ranges
));
4302 memset(&viewports
[state
->viewport_count
* 4], 0, reset_count
* 4 * sizeof(*viewports
));
4305 GL_EXTCALL(glDepthRangeArrayv(0, state
->viewport_count
+ reset_count
, depth_ranges
));
4306 GL_EXTCALL(glViewportArrayv(0, state
->viewport_count
+ reset_count
, viewports
));
4307 context
->viewport_count
= state
->viewport_count
;
4309 checkGLcall("setting clip space and viewport");
4312 static void viewport_vertexpart(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4314 if (!isStateDirty(context
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
)))
4315 transform_projection(context
, state
, STATE_TRANSFORM(WINED3D_TS_PROJECTION
));
4316 if (!isStateDirty(context
, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
))
4317 && state
->render_states
[WINED3D_RS_POINTSCALEENABLE
])
4318 state_pscale(context
, state
, STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
));
4319 /* Update the position fixup. */
4320 context
->constant_update_mask
|= WINED3D_SHADER_CONST_POS_FIXUP
;
4323 static void light(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4325 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4326 UINT Index
= state_id
- STATE_ACTIVELIGHT(0);
4327 const struct wined3d_light_info
*lightInfo
= state
->light_state
.lights
[Index
];
4331 gl_info
->gl_ops
.gl
.p_glDisable(GL_LIGHT0
+ Index
);
4332 checkGLcall("glDisable(GL_LIGHT0 + Index)");
4338 /* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
4339 gl_info
->gl_ops
.gl
.p_glMatrixMode(GL_MODELVIEW
);
4340 gl_info
->gl_ops
.gl
.p_glPushMatrix();
4341 gl_info
->gl_ops
.gl
.p_glLoadMatrixf(&state
->transforms
[WINED3D_TS_VIEW
]._11
);
4343 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_DIFFUSE
, &lightInfo
->OriginalParms
.diffuse
.r
);
4344 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_SPECULAR
, &lightInfo
->OriginalParms
.specular
.r
);
4345 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_AMBIENT
, &lightInfo
->OriginalParms
.ambient
.r
);
4346 checkGLcall("glLightfv");
4348 if ((lightInfo
->OriginalParms
.range
* lightInfo
->OriginalParms
.range
) >= FLT_MIN
)
4349 quad_att
= 1.4f
/ (lightInfo
->OriginalParms
.range
* lightInfo
->OriginalParms
.range
);
4351 quad_att
= 0.0f
; /* 0 or MAX? (0 seems to be ok) */
4353 /* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
4354 * but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
4355 * Attenuation0 to NaN and crashes in the gl lib
4358 switch (lightInfo
->OriginalParms
.type
)
4360 case WINED3D_LIGHT_POINT
:
4362 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->position
.x
);
4363 checkGLcall("glLightfv");
4364 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4365 checkGLcall("glLightf");
4366 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
,
4367 lightInfo
->OriginalParms
.attenuation0
);
4368 checkGLcall("glLightf");
4369 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
,
4370 lightInfo
->OriginalParms
.attenuation1
);
4371 checkGLcall("glLightf");
4372 if (quad_att
< lightInfo
->OriginalParms
.attenuation2
)
4373 quad_att
= lightInfo
->OriginalParms
.attenuation2
;
4374 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4375 checkGLcall("glLightf");
4379 case WINED3D_LIGHT_SPOT
:
4381 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->position
.x
);
4382 checkGLcall("glLightfv");
4384 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_SPOT_DIRECTION
, &lightInfo
->direction
.x
);
4385 checkGLcall("glLightfv");
4386 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, lightInfo
->exponent
);
4387 checkGLcall("glLightf");
4388 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4389 checkGLcall("glLightf");
4390 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_CONSTANT_ATTENUATION
,
4391 lightInfo
->OriginalParms
.attenuation0
);
4392 checkGLcall("glLightf");
4393 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_LINEAR_ATTENUATION
,
4394 lightInfo
->OriginalParms
.attenuation1
);
4395 checkGLcall("glLightf");
4396 if (quad_att
< lightInfo
->OriginalParms
.attenuation2
)
4397 quad_att
= lightInfo
->OriginalParms
.attenuation2
;
4398 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_QUADRATIC_ATTENUATION
, quad_att
);
4399 checkGLcall("glLightf");
4403 case WINED3D_LIGHT_DIRECTIONAL
:
4405 /* Note GL uses w position of 0 for direction! */
4406 gl_info
->gl_ops
.gl
.p_glLightfv(GL_LIGHT0
+ Index
, GL_POSITION
, &lightInfo
->direction
.x
);
4407 checkGLcall("glLightfv");
4408 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_CUTOFF
, lightInfo
->cutoff
);
4409 checkGLcall("glLightf");
4410 gl_info
->gl_ops
.gl
.p_glLightf(GL_LIGHT0
+ Index
, GL_SPOT_EXPONENT
, 0.0f
);
4411 checkGLcall("glLightf");
4415 FIXME("Unrecognized light type %#x.\n", lightInfo
->OriginalParms
.type
);
4418 /* Restore the modelview matrix */
4419 gl_info
->gl_ops
.gl
.p_glPopMatrix();
4421 gl_info
->gl_ops
.gl
.p_glEnable(GL_LIGHT0
+ Index
);
4422 checkGLcall("glEnable(GL_LIGHT0 + Index)");
4426 static void scissorrect(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4428 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4429 unsigned int height
= 0;
4432 /* Warning: glScissor uses window coordinates, not viewport coordinates,
4433 * so our viewport correction does not apply. Warning2: Even in windowed
4434 * mode the coords are relative to the window, not the screen. */
4436 if (!context
->render_offscreen
)
4438 const struct wined3d_rendertarget_view
*target
= state
->fb
.render_targets
[0];
4441 wined3d_rendertarget_view_get_drawable_size(target
, context
, &width
, &height
);
4444 if (gl_info
->supported
[ARB_VIEWPORT_ARRAY
])
4446 GLint sr
[4 * WINED3D_MAX_VIEWPORTS
];
4447 unsigned int i
, reset_count
= 0;
4449 for (i
= 0; i
< state
->scissor_rect_count
; ++i
)
4451 r
= &state
->scissor_rects
[i
];
4453 sr
[i
* 4] = r
->left
;
4454 sr
[i
* 4 + 1] = height
? height
- r
->top
: r
->top
;
4455 sr
[i
* 4 + 2] = r
->right
- r
->left
;
4456 sr
[i
* 4 + 3] = r
->bottom
- r
->top
;
4459 if (context
->scissor_rect_count
> state
->scissor_rect_count
)
4460 reset_count
= context
->scissor_rect_count
- state
->scissor_rect_count
;
4463 memset(&sr
[state
->scissor_rect_count
* 4], 0, reset_count
* 4 * sizeof(GLint
));
4465 GL_EXTCALL(glScissorArrayv(0, state
->scissor_rect_count
+ reset_count
, sr
));
4466 checkGLcall("glScissorArrayv");
4467 context
->scissor_rect_count
= state
->scissor_rect_count
;
4471 r
= &state
->scissor_rects
[0];
4472 gl_info
->gl_ops
.gl
.p_glScissor(r
->left
, height
? height
- r
->top
: r
->top
,
4473 r
->right
- r
->left
, r
->bottom
- r
->top
);
4474 checkGLcall("glScissor");
4478 static void indexbuffer(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4480 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4481 const struct wined3d_stream_info
*stream_info
= &context
->stream_info
;
4482 struct wined3d_buffer
*buffer
;
4484 if (!state
->index_buffer
|| !stream_info
->all_vbo
)
4486 GL_EXTCALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER
, 0));
4490 buffer
= state
->index_buffer
;
4491 if (buffer
->buffer_object
)
4493 GL_EXTCALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER
, wined3d_bo_gl(buffer
->buffer_object
)->id
));
4494 buffer
->bo_user
.valid
= true;
4498 GL_EXTCALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER
, 0));
4502 static void depth_clip(const struct wined3d_rasterizer_state
*r
, const struct wined3d_gl_info
*gl_info
)
4504 if (!gl_info
->supported
[ARB_DEPTH_CLAMP
])
4506 if (r
&& !r
->desc
.depth_clip
)
4507 FIXME("Depth clamp not supported by this GL implementation.\n");
4511 if (r
&& !r
->desc
.depth_clip
)
4512 gl_info
->gl_ops
.gl
.p_glEnable(GL_DEPTH_CLAMP
);
4514 gl_info
->gl_ops
.gl
.p_glDisable(GL_DEPTH_CLAMP
);
4515 checkGLcall("depth clip");
4518 static void rasterizer(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4520 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4521 const struct wined3d_rasterizer_state
*r
= state
->rasterizer_state
;
4524 mode
= r
&& r
->desc
.front_ccw
? GL_CCW
: GL_CW
;
4525 if (context
->render_offscreen
)
4526 mode
= (mode
== GL_CW
) ? GL_CCW
: GL_CW
;
4528 gl_info
->gl_ops
.gl
.p_glFrontFace(mode
);
4529 checkGLcall("glFrontFace");
4530 depthbias(context
, state
);
4531 fillmode(r
, gl_info
);
4532 cullmode(r
, gl_info
);
4533 depth_clip(r
, gl_info
);
4534 scissor(r
, gl_info
);
4535 line_antialias(r
, gl_info
);
4538 static void rasterizer_cc(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4540 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4541 const struct wined3d_rasterizer_state
*r
= state
->rasterizer_state
;
4544 mode
= r
&& r
->desc
.front_ccw
? GL_CCW
: GL_CW
;
4546 gl_info
->gl_ops
.gl
.p_glFrontFace(mode
);
4547 checkGLcall("glFrontFace");
4548 depthbias(context
, state
);
4549 fillmode(r
, gl_info
);
4550 cullmode(r
, gl_info
);
4551 depth_clip(r
, gl_info
);
4552 scissor(r
, gl_info
);
4553 line_antialias(r
, gl_info
);
4556 static void psorigin_w(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4562 WARN("Point sprite coordinate origin switching not supported.\n");
4567 static void psorigin(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4569 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4570 GLint origin
= context
->render_offscreen
? GL_LOWER_LEFT
: GL_UPPER_LEFT
;
4572 GL_EXTCALL(glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN
, origin
));
4573 checkGLcall("glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
4576 void state_srgbwrite(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4578 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4580 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4582 if (needs_srgb_write(context
->d3d_info
, state
, &state
->fb
))
4583 gl_info
->gl_ops
.gl
.p_glEnable(GL_FRAMEBUFFER_SRGB
);
4585 gl_info
->gl_ops
.gl
.p_glDisable(GL_FRAMEBUFFER_SRGB
);
4588 static void state_cb(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4590 const struct wined3d_gl_info
*gl_info
= wined3d_context_gl(context
)->gl_info
;
4591 enum wined3d_shader_type shader_type
;
4592 struct wined3d_buffer
*buffer
;
4593 unsigned int i
, base
, count
;
4594 struct wined3d_bo_gl
*bo_gl
;
4596 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4598 if (STATE_IS_GRAPHICS_CONSTANT_BUFFER(state_id
))
4599 shader_type
= state_id
- STATE_GRAPHICS_CONSTANT_BUFFER(0);
4601 shader_type
= WINED3D_SHADER_TYPE_COMPUTE
;
4603 /* If a shader has not been set, buffer objects are not yet initialised. */
4604 if (!state
->shader
[shader_type
])
4607 wined3d_gl_limits_get_uniform_block_range(&gl_info
->limits
, shader_type
, &base
, &count
);
4608 for (i
= 0; i
< count
; ++i
)
4610 const struct wined3d_constant_buffer_state
*buffer_state
= &state
->cb
[shader_type
][i
];
4612 if (!buffer_state
->buffer
)
4614 GL_EXTCALL(glBindBufferBase(GL_UNIFORM_BUFFER
, base
+ i
, 0));
4618 buffer
= buffer_state
->buffer
;
4619 bo_gl
= wined3d_bo_gl(buffer
->buffer_object
);
4620 GL_EXTCALL(glBindBufferRange(GL_UNIFORM_BUFFER
, base
+ i
,
4621 bo_gl
->id
, bo_gl
->b
.buffer_offset
+ buffer_state
->offset
, buffer_state
->size
));
4622 buffer
->bo_user
.valid
= true;
4624 checkGLcall("bind constant buffers");
4627 static void state_cb_warn(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4629 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4631 WARN("Constant buffers (%s) no supported.\n", debug_d3dstate(state_id
));
4634 static void state_shader_resource_binding(struct wined3d_context
*context
,
4635 const struct wined3d_state
*state
, DWORD state_id
)
4637 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4639 context
->update_shader_resource_bindings
= 1;
4642 static void state_cs_resource_binding(struct wined3d_context
*context
,
4643 const struct wined3d_state
*state
, DWORD state_id
)
4645 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4646 context
->update_compute_shader_resource_bindings
= 1;
4649 static void state_uav_binding(struct wined3d_context
*context
,
4650 const struct wined3d_state
*state
, DWORD state_id
)
4652 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4653 context
->update_unordered_access_view_bindings
= 1;
4656 static void state_cs_uav_binding(struct wined3d_context
*context
,
4657 const struct wined3d_state
*state
, DWORD state_id
)
4659 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4660 context
->update_compute_unordered_access_view_bindings
= 1;
4663 static void state_uav_warn(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4665 WARN("ARB_shader_image_load_store is not supported by this OpenGL implementation.\n");
4668 static void state_so(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4670 struct wined3d_context_gl
*context_gl
= wined3d_context_gl(context
);
4671 const struct wined3d_gl_info
*gl_info
= context_gl
->gl_info
;
4672 struct wined3d_buffer
*buffer
;
4673 unsigned int offset
, size
, i
;
4674 struct wined3d_bo_gl
*bo_gl
;
4676 TRACE("context %p, state %p, state_id %#x.\n", context
, state
, state_id
);
4678 wined3d_context_gl_end_transform_feedback(context_gl
);
4680 for (i
= 0; i
< ARRAY_SIZE(state
->stream_output
); ++i
)
4682 if (!state
->stream_output
[i
].buffer
)
4684 GL_EXTCALL(glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER
, i
, 0));
4688 buffer
= state
->stream_output
[i
].buffer
;
4689 offset
= state
->stream_output
[i
].offset
;
4690 bo_gl
= wined3d_bo_gl(buffer
->buffer_object
);
4693 FIXME("Appending to stream output buffers not implemented.\n");
4696 size
= buffer
->resource
.size
- offset
;
4697 GL_EXTCALL(glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER
, i
,
4698 bo_gl
->id
, bo_gl
->b
.buffer_offset
+ offset
, size
));
4699 buffer
->bo_user
.valid
= true;
4701 checkGLcall("bind transform feedback buffers");
4704 static void state_so_warn(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
4706 WARN("Transform feedback not supported.\n");
4709 const struct wined3d_state_entry_template misc_state_template_gl
[] =
4711 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4712 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4713 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL
), state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4714 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4715 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN
), state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4716 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4717 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),{ STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4718 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),{ STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4719 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4720 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4721 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE
), state_cb
, }, ARB_UNIFORM_BUFFER_OBJECT
},
4722 { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE
), { STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE
), state_cb_warn
, }, WINED3D_GL_EXT_NONE
},
4723 { STATE_GRAPHICS_SHADER_RESOURCE_BINDING
, { STATE_GRAPHICS_SHADER_RESOURCE_BINDING
, state_shader_resource_binding
}, WINED3D_GL_EXT_NONE
},
4724 { STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
, { STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
, state_uav_binding
}, ARB_SHADER_IMAGE_LOAD_STORE
},
4725 { STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
, { STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
, state_uav_warn
}, WINED3D_GL_EXT_NONE
},
4726 { STATE_COMPUTE_SHADER_RESOURCE_BINDING
, { STATE_COMPUTE_SHADER_RESOURCE_BINDING
, state_cs_resource_binding
}, WINED3D_GL_EXT_NONE
},
4727 { STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
, { STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
, state_cs_uav_binding
}, ARB_SHADER_IMAGE_LOAD_STORE
},
4728 { STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
, { STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
, state_uav_warn
}, WINED3D_GL_EXT_NONE
},
4729 { STATE_STREAM_OUTPUT
, { STATE_STREAM_OUTPUT
, state_so
, }, WINED3D_GL_VERSION_3_2
},
4730 { STATE_STREAM_OUTPUT
, { STATE_STREAM_OUTPUT
, state_so_warn
, }, WINED3D_GL_EXT_NONE
},
4731 { STATE_BLEND
, { STATE_BLEND
, blend_dbb
}, ARB_DRAW_BUFFERS_BLEND
},
4732 { STATE_BLEND
, { STATE_BLEND
, blend_db2
}, EXT_DRAW_BUFFERS2
},
4733 { STATE_BLEND
, { STATE_BLEND
, blend
}, WINED3D_GL_EXT_NONE
},
4734 { STATE_BLEND_FACTOR
, { STATE_BLEND_FACTOR
, state_blend_factor
}, EXT_BLEND_COLOR
},
4735 { STATE_BLEND_FACTOR
, { STATE_BLEND_FACTOR
, state_blend_factor_w
}, WINED3D_GL_EXT_NONE
},
4736 { STATE_SAMPLE_MASK
, { STATE_SAMPLE_MASK
, state_sample_mask
}, ARB_TEXTURE_MULTISAMPLE
},
4737 { STATE_SAMPLE_MASK
, { STATE_SAMPLE_MASK
, state_sample_mask_w
}, WINED3D_GL_EXT_NONE
},
4738 { STATE_DEPTH_STENCIL
, { STATE_DEPTH_STENCIL
, depth_stencil_2s
}, EXT_STENCIL_TWO_SIDE
},
4739 { STATE_DEPTH_STENCIL
, { STATE_DEPTH_STENCIL
, depth_stencil
}, WINED3D_GL_EXT_NONE
},
4740 { STATE_STENCIL_REF
, { STATE_DEPTH_STENCIL
, NULL
}, WINED3D_GL_EXT_NONE
},
4741 { STATE_STREAMSRC
, { STATE_STREAMSRC
, streamsrc
}, WINED3D_GL_EXT_NONE
},
4742 { STATE_VDECL
, { STATE_VDECL
, vdecl_miscpart
}, WINED3D_GL_EXT_NONE
},
4743 { STATE_RASTERIZER
, { STATE_RASTERIZER
, rasterizer_cc
}, ARB_CLIP_CONTROL
},
4744 { STATE_RASTERIZER
, { STATE_RASTERIZER
, rasterizer
}, WINED3D_GL_EXT_NONE
},
4745 { STATE_SCISSORRECT
, { STATE_SCISSORRECT
, scissorrect
}, WINED3D_GL_EXT_NONE
},
4746 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, state_nop
}, ARB_CLIP_CONTROL
},
4747 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin
}, WINED3D_GL_VERSION_2_0
},
4748 { STATE_POINTSPRITECOORDORIGIN
, { STATE_POINTSPRITECOORDORIGIN
, psorigin_w
}, WINED3D_GL_EXT_NONE
},
4750 /* TODO: Move shader constant loading to vertex and fragment pipeline respectively, as soon as the pshader and
4751 * vshader loadings are untied from each other
4753 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4754 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4755 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4756 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4757 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4758 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4759 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4760 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4761 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4762 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4763 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4764 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4765 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4766 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4767 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4768 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4769 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4770 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4771 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4772 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4773 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4774 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4775 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4776 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4777 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4778 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4779 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4780 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4781 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4782 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4783 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4784 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00
), NULL
}, WINED3D_GL_EXT_NONE
},
4785 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4786 { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4787 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4788 { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4789 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4790 { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4791 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4792 { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4793 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4794 { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4795 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4796 { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4797 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4798 { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4799 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), shader_bumpenv
}, WINED3D_GL_EXT_NONE
},
4800 { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LOFFSET
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE
), NULL
}, WINED3D_GL_EXT_NONE
},
4802 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_miscpart_cc
}, ARB_CLIP_CONTROL
},
4803 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_miscpart
}, WINED3D_GL_EXT_NONE
},
4804 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, indexbuffer
}, ARB_VERTEX_BUFFER_OBJECT
},
4805 { STATE_INDEXBUFFER
, { STATE_INDEXBUFFER
, state_nop
}, WINED3D_GL_EXT_NONE
},
4806 { STATE_RENDER(WINED3D_RS_ANTIALIAS
), { STATE_RENDER(WINED3D_RS_ANTIALIAS
), state_antialias
}, WINED3D_GL_EXT_NONE
},
4807 { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE
), { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE
), state_nop
}, WINED3D_GL_EXT_NONE
},
4808 { STATE_RENDER(WINED3D_RS_WRAPU
), { STATE_RENDER(WINED3D_RS_WRAPU
), state_wrapu
}, WINED3D_GL_EXT_NONE
},
4809 { STATE_RENDER(WINED3D_RS_WRAPV
), { STATE_RENDER(WINED3D_RS_WRAPV
), state_wrapv
}, WINED3D_GL_EXT_NONE
},
4810 { STATE_RENDER(WINED3D_RS_LINEPATTERN
), { STATE_RENDER(WINED3D_RS_LINEPATTERN
), state_linepattern
}, WINED3D_GL_LEGACY_CONTEXT
},
4811 { STATE_RENDER(WINED3D_RS_LINEPATTERN
), { STATE_RENDER(WINED3D_RS_LINEPATTERN
), state_linepattern_w
}, WINED3D_GL_EXT_NONE
},
4812 { STATE_RENDER(WINED3D_RS_MONOENABLE
), { STATE_RENDER(WINED3D_RS_MONOENABLE
), state_monoenable
}, WINED3D_GL_EXT_NONE
},
4813 { STATE_RENDER(WINED3D_RS_ROP2
), { STATE_RENDER(WINED3D_RS_ROP2
), state_rop2
}, WINED3D_GL_EXT_NONE
},
4814 { STATE_RENDER(WINED3D_RS_PLANEMASK
), { STATE_RENDER(WINED3D_RS_PLANEMASK
), state_planemask
}, WINED3D_GL_EXT_NONE
},
4815 { STATE_RENDER(WINED3D_RS_LASTPIXEL
), { STATE_RENDER(WINED3D_RS_LASTPIXEL
), state_lastpixel
}, WINED3D_GL_EXT_NONE
},
4816 { STATE_RENDER(WINED3D_RS_DITHERENABLE
), { STATE_RENDER(WINED3D_RS_DITHERENABLE
), state_ditherenable
}, WINED3D_GL_EXT_NONE
},
4817 { STATE_RENDER(WINED3D_RS_SUBPIXEL
), { STATE_RENDER(WINED3D_RS_SUBPIXEL
), state_subpixel
}, WINED3D_GL_EXT_NONE
},
4818 { STATE_RENDER(WINED3D_RS_SUBPIXELX
), { STATE_RENDER(WINED3D_RS_SUBPIXELX
), state_subpixelx
}, WINED3D_GL_EXT_NONE
},
4819 { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA
), { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA
), state_stippledalpha
}, WINED3D_GL_EXT_NONE
},
4820 { STATE_RENDER(WINED3D_RS_STIPPLEENABLE
), { STATE_RENDER(WINED3D_RS_STIPPLEENABLE
), state_stippleenable
}, WINED3D_GL_EXT_NONE
},
4821 { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS
), { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS
), state_mipmaplodbias
}, WINED3D_GL_EXT_NONE
},
4822 { STATE_RENDER(WINED3D_RS_ANISOTROPY
), { STATE_RENDER(WINED3D_RS_ANISOTROPY
), state_anisotropy
}, WINED3D_GL_EXT_NONE
},
4823 { STATE_RENDER(WINED3D_RS_FLUSHBATCH
), { STATE_RENDER(WINED3D_RS_FLUSHBATCH
), state_flushbatch
}, WINED3D_GL_EXT_NONE
},
4824 { STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
),{ STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT
),state_translucentsi
}, WINED3D_GL_EXT_NONE
},
4825 { STATE_RENDER(WINED3D_RS_WRAP0
), { STATE_RENDER(WINED3D_RS_WRAP0
), state_wrap
}, WINED3D_GL_EXT_NONE
},
4826 { STATE_RENDER(WINED3D_RS_WRAP1
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4827 { STATE_RENDER(WINED3D_RS_WRAP2
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4828 { STATE_RENDER(WINED3D_RS_WRAP3
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4829 { STATE_RENDER(WINED3D_RS_WRAP4
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4830 { STATE_RENDER(WINED3D_RS_WRAP5
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4831 { STATE_RENDER(WINED3D_RS_WRAP6
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4832 { STATE_RENDER(WINED3D_RS_WRAP7
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4833 { STATE_RENDER(WINED3D_RS_WRAP8
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4834 { STATE_RENDER(WINED3D_RS_WRAP9
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4835 { STATE_RENDER(WINED3D_RS_WRAP10
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4836 { STATE_RENDER(WINED3D_RS_WRAP11
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4837 { STATE_RENDER(WINED3D_RS_WRAP12
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4838 { STATE_RENDER(WINED3D_RS_WRAP13
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4839 { STATE_RENDER(WINED3D_RS_WRAP14
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4840 { STATE_RENDER(WINED3D_RS_WRAP15
), { STATE_RENDER(WINED3D_RS_WRAP0
), NULL
}, WINED3D_GL_EXT_NONE
},
4841 { STATE_RENDER(WINED3D_RS_EXTENTS
), { STATE_RENDER(WINED3D_RS_EXTENTS
), state_extents
}, WINED3D_GL_EXT_NONE
},
4842 { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE
), { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE
), state_ckeyblend
}, WINED3D_GL_EXT_NONE
},
4843 { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING
), { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING
), state_swvp
}, WINED3D_GL_EXT_NONE
},
4844 { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE
), { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE
), state_patchedgestyle
}, WINED3D_GL_EXT_NONE
},
4845 { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS
), { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS
), state_patchsegments
}, WINED3D_GL_EXT_NONE
},
4846 { STATE_RENDER(WINED3D_RS_POSITIONDEGREE
), { STATE_RENDER(WINED3D_RS_POSITIONDEGREE
), state_positiondegree
}, WINED3D_GL_EXT_NONE
},
4847 { STATE_RENDER(WINED3D_RS_NORMALDEGREE
), { STATE_RENDER(WINED3D_RS_NORMALDEGREE
), state_normaldegree
}, WINED3D_GL_EXT_NONE
},
4848 { STATE_RENDER(WINED3D_RS_MINTESSELLATIONLEVEL
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4849 { STATE_RENDER(WINED3D_RS_MAXTESSELLATIONLEVEL
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4850 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_X
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4851 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Y
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4852 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Z
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4853 { STATE_RENDER(WINED3D_RS_ADAPTIVETESS_W
), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),NULL
}, WINED3D_GL_EXT_NONE
},
4854 { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),state_nvdb
}, EXT_DEPTH_BOUNDS_TEST
},
4855 { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION
),state_tessellation
}, WINED3D_GL_EXT_NONE
},
4856 { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), state_msaa
}, ARB_MULTISAMPLE
},
4857 { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS
), state_msaa_w
}, WINED3D_GL_EXT_NONE
},
4858 { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN
), { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN
), state_debug_monitor
}, WINED3D_GL_EXT_NONE
},
4859 { STATE_RENDER(WINED3D_RS_ZVISIBLE
), { STATE_RENDER(WINED3D_RS_ZVISIBLE
), state_zvisible
}, WINED3D_GL_EXT_NONE
},
4861 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler
}, WINED3D_GL_EXT_NONE
},
4862 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler
}, WINED3D_GL_EXT_NONE
},
4863 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler
}, WINED3D_GL_EXT_NONE
},
4864 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler
}, WINED3D_GL_EXT_NONE
},
4865 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler
}, WINED3D_GL_EXT_NONE
},
4866 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler
}, WINED3D_GL_EXT_NONE
},
4867 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler
}, WINED3D_GL_EXT_NONE
},
4868 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler
}, WINED3D_GL_EXT_NONE
},
4869 { STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler
}, WINED3D_GL_EXT_NONE
},
4870 { STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler
}, WINED3D_GL_EXT_NONE
},
4871 { STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler
}, WINED3D_GL_EXT_NONE
},
4872 { STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler
}, WINED3D_GL_EXT_NONE
},
4873 { STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler
}, WINED3D_GL_EXT_NONE
},
4874 { STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler
}, WINED3D_GL_EXT_NONE
},
4875 { STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler
}, WINED3D_GL_EXT_NONE
},
4876 { STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler
}, WINED3D_GL_EXT_NONE
},
4877 { STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler
}, WINED3D_GL_EXT_NONE
},
4878 { STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler
}, WINED3D_GL_EXT_NONE
},
4879 { STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler
}, WINED3D_GL_EXT_NONE
},
4880 { STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler
}, WINED3D_GL_EXT_NONE
},
4881 { STATE_BASEVERTEXINDEX
, { STATE_BASEVERTEXINDEX
, state_nop
, }, ARB_DRAW_ELEMENTS_BASE_VERTEX
},
4882 { STATE_BASEVERTEXINDEX
, { STATE_STREAMSRC
, NULL
, }, WINED3D_GL_EXT_NONE
},
4883 { STATE_FRAMEBUFFER
, { STATE_FRAMEBUFFER
, context_state_fb
}, WINED3D_GL_EXT_NONE
},
4884 { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), context_state_drawbuf
},WINED3D_GL_EXT_NONE
},
4885 { STATE_SHADER(WINED3D_SHADER_TYPE_HULL
), { STATE_SHADER(WINED3D_SHADER_TYPE_HULL
), state_shader
}, WINED3D_GL_EXT_NONE
},
4886 { STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN
), { STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN
), state_shader
}, WINED3D_GL_EXT_NONE
},
4887 { STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
), { STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
), state_shader
}, WINED3D_GL_EXT_NONE
},
4888 { STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE
), { STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE
), state_compute_shader
}, WINED3D_GL_EXT_NONE
},
4889 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
4892 static const struct wined3d_state_entry_template vp_ffp_states
[] =
4894 { STATE_VDECL
, { STATE_VDECL
, vertexdeclaration
}, WINED3D_GL_EXT_NONE
},
4895 { STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
), { STATE_VDECL
, NULL
}, WINED3D_GL_EXT_NONE
},
4896 { STATE_MATERIAL
, { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
4897 { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), { STATE_RENDER(WINED3D_RS_SPECULARENABLE
), state_specularenable
}, WINED3D_GL_EXT_NONE
},
4899 { STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane
}, WINED3D_GL_EXT_NONE
},
4900 { STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane
}, WINED3D_GL_EXT_NONE
},
4901 { STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane
}, WINED3D_GL_EXT_NONE
},
4902 { STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane
}, WINED3D_GL_EXT_NONE
},
4903 { STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane
}, WINED3D_GL_EXT_NONE
},
4904 { STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane
}, WINED3D_GL_EXT_NONE
},
4905 { STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane
}, WINED3D_GL_EXT_NONE
},
4906 { STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane
}, WINED3D_GL_EXT_NONE
},
4908 { STATE_LIGHT_TYPE
, { STATE_LIGHT_TYPE
, state_nop
}, WINED3D_GL_EXT_NONE
},
4909 { STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light
}, WINED3D_GL_EXT_NONE
},
4910 { STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light
}, WINED3D_GL_EXT_NONE
},
4911 { STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light
}, WINED3D_GL_EXT_NONE
},
4912 { STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light
}, WINED3D_GL_EXT_NONE
},
4913 { STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light
}, WINED3D_GL_EXT_NONE
},
4914 { STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light
}, WINED3D_GL_EXT_NONE
},
4915 { STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light
}, WINED3D_GL_EXT_NONE
},
4916 { STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light
}, WINED3D_GL_EXT_NONE
},
4918 { STATE_VIEWPORT
, { STATE_VIEWPORT
, viewport_vertexpart
}, WINED3D_GL_EXT_NONE
},
4919 /* Transform states follow */
4920 { STATE_TRANSFORM(WINED3D_TS_VIEW
), { STATE_TRANSFORM(WINED3D_TS_VIEW
), transform_view
}, WINED3D_GL_EXT_NONE
},
4921 { STATE_TRANSFORM(WINED3D_TS_PROJECTION
), { STATE_TRANSFORM(WINED3D_TS_PROJECTION
), transform_projection
}, WINED3D_GL_EXT_NONE
},
4922 { STATE_TRANSFORM(WINED3D_TS_TEXTURE0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4923 { STATE_TRANSFORM(WINED3D_TS_TEXTURE1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4924 { STATE_TRANSFORM(WINED3D_TS_TEXTURE2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4925 { STATE_TRANSFORM(WINED3D_TS_TEXTURE3
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4926 { STATE_TRANSFORM(WINED3D_TS_TEXTURE4
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4927 { STATE_TRANSFORM(WINED3D_TS_TEXTURE5
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4928 { STATE_TRANSFORM(WINED3D_TS_TEXTURE6
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4929 { STATE_TRANSFORM(WINED3D_TS_TEXTURE7
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), NULL
}, WINED3D_GL_EXT_NONE
},
4930 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), transform_world
}, WINED3D_GL_EXT_NONE
},
4931 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4932 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4933 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4934 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4935 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4936 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4937 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4938 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4939 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4940 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4941 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4942 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4943 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4944 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4945 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4946 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4947 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4948 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4949 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4950 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4951 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4952 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4953 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4954 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4955 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4956 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4957 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4958 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4959 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4960 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4961 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4962 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4963 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4964 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4965 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4966 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4967 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4968 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4969 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4970 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4971 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4972 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4973 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4974 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4975 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4976 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4977 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4978 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4979 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4980 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4981 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4982 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4983 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4984 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4985 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4986 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4987 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4988 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4989 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4990 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4991 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4992 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4993 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4994 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4995 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4996 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4997 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4998 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
4999 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5000 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5001 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5002 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5003 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5004 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5005 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5006 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5007 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5008 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5009 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5010 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5011 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5012 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5013 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5014 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5015 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5016 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5017 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5018 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5019 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5020 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5021 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5022 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5023 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5024 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5025 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5026 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5027 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5028 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5029 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5030 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5031 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5032 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5033 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5034 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5035 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5036 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5037 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5038 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5039 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5040 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5041 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5042 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5043 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5044 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5045 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5046 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5047 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5048 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5049 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5050 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5051 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5052 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5053 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5054 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5055 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5056 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5057 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5058 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5059 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5060 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5061 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5062 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5063 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5064 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5065 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5066 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5067 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5068 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5069 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5070 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5071 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5072 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5073 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5074 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5075 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5076 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5077 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5078 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5079 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5080 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5081 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5082 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5083 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5084 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5085 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5086 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5087 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5088 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5089 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5090 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5091 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5092 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5093 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5094 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5095 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5096 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5097 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5098 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5099 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5100 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5101 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5102 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5103 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5104 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5105 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5106 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5107 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5108 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5109 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5110 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5111 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5112 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5113 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5114 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5115 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5116 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5117 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5118 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5119 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5120 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5121 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5122 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5123 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5124 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5125 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5126 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5127 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5128 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5129 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5130 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5131 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5132 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5133 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5134 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5135 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5136 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5137 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5138 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5139 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5140 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5141 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5142 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5143 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5144 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5145 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5146 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5147 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5148 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5149 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5150 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5151 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5152 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5153 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5154 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5155 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5156 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5157 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5158 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5159 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5160 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5161 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5162 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5163 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5164 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5165 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5166 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5167 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5168 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5169 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5170 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5171 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5172 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5173 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5174 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5175 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5176 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5177 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5178 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5179 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5180 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5181 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5182 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5183 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5184 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5185 { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), transform_worldex
}, WINED3D_GL_EXT_NONE
},
5186 { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5187 { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5188 { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5189 { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5190 { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5191 { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5192 { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5193 { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), {STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS
), transform_texture
}, WINED3D_GL_EXT_NONE
},
5194 { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5195 { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5196 { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5197 { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5198 { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5199 { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5200 { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5201 { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX
), tex_coordindex
}, WINED3D_GL_EXT_NONE
},
5203 { STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_vertexpart
}, WINED3D_GL_EXT_NONE
},
5204 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5205 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5206 { STATE_RENDER(WINED3D_RS_RANGEFOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5207 { STATE_RENDER(WINED3D_RS_CLIPPING
), { STATE_RENDER(WINED3D_RS_CLIPPING
), state_clipping
}, WINED3D_GL_EXT_NONE
},
5208 { STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE
), { STATE_RENDER(WINED3D_RS_CLIPPING
), NULL
}, WINED3D_GL_EXT_NONE
},
5209 { STATE_RENDER(WINED3D_RS_LIGHTING
), { STATE_RENDER(WINED3D_RS_LIGHTING
), state_lighting
}, WINED3D_GL_EXT_NONE
},
5210 { STATE_RENDER(WINED3D_RS_AMBIENT
), { STATE_RENDER(WINED3D_RS_AMBIENT
), state_ambient
}, WINED3D_GL_EXT_NONE
},
5211 { STATE_RENDER(WINED3D_RS_COLORVERTEX
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), state_colormat
}, WINED3D_GL_EXT_NONE
},
5212 { STATE_RENDER(WINED3D_RS_LOCALVIEWER
), { STATE_RENDER(WINED3D_RS_LOCALVIEWER
), state_localviewer
}, WINED3D_GL_EXT_NONE
},
5213 { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS
), state_normalize
}, WINED3D_GL_EXT_NONE
},
5214 { STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5215 { STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5216 { STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5217 { STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE
), { STATE_RENDER(WINED3D_RS_COLORVERTEX
), NULL
}, WINED3D_GL_EXT_NONE
},
5218 { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), state_vertexblend_w
}, WINED3D_GL_EXT_NONE
},
5219 { STATE_RENDER(WINED3D_RS_POINTSIZE
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5220 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_arb
}, ARB_POINT_PARAMETERS
},
5221 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_ext
}, EXT_POINT_PARAMETERS
},
5222 { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), state_psizemin_w
}, WINED3D_GL_EXT_NONE
},
5223 { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), state_pointsprite
}, ARB_POINT_SPRITE
},
5224 { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE
), state_pointsprite_w
}, WINED3D_GL_EXT_NONE
},
5225 { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), state_pscale
}, WINED3D_GL_EXT_NONE
},
5226 { STATE_RENDER(WINED3D_RS_POINTSCALE_A
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5227 { STATE_RENDER(WINED3D_RS_POINTSCALE_B
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5228 { STATE_RENDER(WINED3D_RS_POINTSCALE_C
), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5229 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, ARB_POINT_PARAMETERS
},
5230 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, EXT_POINT_PARAMETERS
},
5231 { STATE_RENDER(WINED3D_RS_POINTSIZE_MAX
), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN
), NULL
}, WINED3D_GL_EXT_NONE
},
5232 { STATE_RENDER(WINED3D_RS_TWEENFACTOR
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5233 { STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE
), { STATE_RENDER(WINED3D_RS_VERTEXBLEND
), NULL
}, WINED3D_GL_EXT_NONE
},
5235 /* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
5236 * so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
5237 * otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
5239 { STATE_SAMPLER(0), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5240 { STATE_SAMPLER(0), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5241 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5242 { STATE_SAMPLER(1), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5243 { STATE_SAMPLER(1), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5244 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5245 { STATE_SAMPLER(2), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5246 { STATE_SAMPLER(2), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5247 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5248 { STATE_SAMPLER(3), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5249 { STATE_SAMPLER(3), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5250 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5251 { STATE_SAMPLER(4), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5252 { STATE_SAMPLER(4), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5253 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5254 { STATE_SAMPLER(5), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5255 { STATE_SAMPLER(5), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5256 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5257 { STATE_SAMPLER(6), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5258 { STATE_SAMPLER(6), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5259 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5260 { STATE_SAMPLER(7), { 0, NULL
}, ARB_TEXTURE_NON_POWER_OF_TWO
},
5261 { STATE_SAMPLER(7), { 0, NULL
}, WINED3D_GL_NORMALIZED_TEXRECT
},
5262 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix
}, WINED3D_GL_EXT_NONE
},
5263 { STATE_POINT_ENABLE
, { STATE_POINT_ENABLE
, state_nop
}, WINED3D_GL_EXT_NONE
},
5264 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5267 static const struct wined3d_state_entry_template ffp_fragmentstate_template
[] = {
5268 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5269 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5270 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5271 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5272 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5273 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5274 { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5275 { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5276 { STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5277 { STATE_TEXTURESTAGE(0, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5278 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5279 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5280 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5281 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5282 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5283 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5284 { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5285 { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5286 { STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5287 { STATE_TEXTURESTAGE(1, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5288 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5289 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5290 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5291 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5292 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5293 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5294 { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5295 { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5296 { STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5297 { STATE_TEXTURESTAGE(2, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5298 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5299 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5300 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5301 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5302 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5303 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5304 { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5305 { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5306 { STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5307 { STATE_TEXTURESTAGE(3, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5308 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5309 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5310 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5311 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5312 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5313 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5314 { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5315 { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5316 { STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5317 { STATE_TEXTURESTAGE(4, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5318 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5319 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5320 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5321 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5322 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5323 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5324 { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5325 { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5326 { STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5327 { STATE_TEXTURESTAGE(5, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5328 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5329 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5330 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5331 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5332 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5333 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5334 { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5335 { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5336 { STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5337 { STATE_TEXTURESTAGE(6, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5338 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), tex_colorop
}, WINED3D_GL_EXT_NONE
},
5339 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5340 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5341 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), tex_alphaop
}, WINED3D_GL_EXT_NONE
},
5342 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5343 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5344 { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5345 { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5346 { STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG
), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP
), NULL
}, WINED3D_GL_EXT_NONE
},
5347 { STATE_TEXTURESTAGE(7, WINED3D_TSS_CONSTANT
), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL
}, WINED3D_GL_EXT_NONE
},
5348 { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), apply_pixelshader
}, WINED3D_GL_EXT_NONE
},
5349 { STATE_RENDER(WINED3D_RS_ALPHAFUNC
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5350 { STATE_RENDER(WINED3D_RS_ALPHAREF
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5351 { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), state_alpha_test
}, WINED3D_GL_EXT_NONE
},
5352 { STATE_RENDER(WINED3D_RS_COLORKEYENABLE
), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5353 { STATE_COLOR_KEY
, { STATE_COLOR_KEY
, state_nop
}, WINED3D_GL_EXT_NONE
},
5354 { STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE
), { STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
), NULL
}, WINED3D_GL_EXT_NONE
},
5355 { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR
), state_texfactor
}, WINED3D_GL_EXT_NONE
},
5356 { STATE_RENDER(WINED3D_RS_FOGCOLOR
), { STATE_RENDER(WINED3D_RS_FOGCOLOR
), state_fogcolor
}, WINED3D_GL_EXT_NONE
},
5357 { STATE_RENDER(WINED3D_RS_FOGDENSITY
), { STATE_RENDER(WINED3D_RS_FOGDENSITY
), state_fogdensity
}, WINED3D_GL_EXT_NONE
},
5358 { STATE_RENDER(WINED3D_RS_FOGENABLE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), state_fog_fragpart
}, WINED3D_GL_EXT_NONE
},
5359 { STATE_RENDER(WINED3D_RS_FOGTABLEMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5360 { STATE_RENDER(WINED3D_RS_FOGVERTEXMODE
), { STATE_RENDER(WINED3D_RS_FOGENABLE
), NULL
}, WINED3D_GL_EXT_NONE
},
5361 { STATE_RENDER(WINED3D_RS_FOGSTART
), { STATE_RENDER(WINED3D_RS_FOGSTART
), state_fogstartend
}, WINED3D_GL_EXT_NONE
},
5362 { STATE_RENDER(WINED3D_RS_FOGEND
), { STATE_RENDER(WINED3D_RS_FOGSTART
), NULL
}, WINED3D_GL_EXT_NONE
},
5363 { STATE_RENDER(WINED3D_RS_SHADEMODE
), { STATE_RENDER(WINED3D_RS_SHADEMODE
), state_shademode
}, WINED3D_GL_EXT_NONE
},
5364 { STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5365 { STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5366 { STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5367 { STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5368 { STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5369 { STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5370 { STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5371 { STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim
}, WINED3D_GL_EXT_NONE
},
5372 {0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE
},
5375 /* Context activation is done by the caller. */
5376 static void ffp_pipe_enable(const struct wined3d_context
*context
, BOOL enable
) {}
5378 static void *ffp_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
5383 static void ffp_free(struct wined3d_device
*device
, struct wined3d_context
*context
) {}
5385 static void vp_ffp_get_caps(const struct wined3d_adapter
*adapter
, struct wined3d_vertex_caps
*caps
)
5387 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
5389 caps
->xyzrhw
= FALSE
;
5390 caps
->ffp_generic_attributes
= FALSE
;
5391 caps
->max_active_lights
= gl_info
->limits
.lights
;
5392 caps
->max_vertex_blend_matrices
= 1;
5393 caps
->max_vertex_blend_matrix_index
= 0;
5394 caps
->vertex_processing_caps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
5395 | WINED3DVTXPCAPS_MATERIALSOURCE7
5396 | WINED3DVTXPCAPS_POSITIONALLIGHTS
5397 | WINED3DVTXPCAPS_LOCALVIEWER
5398 | WINED3DVTXPCAPS_VERTEXFOG
5399 | WINED3DVTXPCAPS_TEXGEN
5400 | WINED3DVTXPCAPS_TEXGEN_SPHEREMAP
;
5401 caps
->fvf_caps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
5402 caps
->max_user_clip_planes
= gl_info
->limits
.user_clip_distances
;
5403 caps
->raster_caps
= 0;
5404 if (gl_info
->supported
[NV_FOG_DISTANCE
])
5405 caps
->raster_caps
|= WINED3DPRASTERCAPS_FOGRANGE
;
5408 static DWORD
vp_ffp_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
5410 return GL_EXT_EMUL_ARB_MULTITEXTURE
| GL_EXT_EMUL_EXT_FOG_COORD
;
5413 const struct wined3d_vertex_pipe_ops ffp_vertex_pipe
=
5417 vp_ffp_get_emul_mask
,
5423 static void ffp_fragment_get_caps(const struct wined3d_adapter
*adapter
, struct fragment_caps
*caps
)
5425 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
5427 caps
->wined3d_caps
= 0;
5428 caps
->PrimitiveMiscCaps
= 0;
5429 caps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
5430 | WINED3DTEXOPCAPS_ADDSIGNED
5431 | WINED3DTEXOPCAPS_ADDSIGNED2X
5432 | WINED3DTEXOPCAPS_MODULATE
5433 | WINED3DTEXOPCAPS_MODULATE2X
5434 | WINED3DTEXOPCAPS_MODULATE4X
5435 | WINED3DTEXOPCAPS_SELECTARG1
5436 | WINED3DTEXOPCAPS_SELECTARG2
5437 | WINED3DTEXOPCAPS_DISABLE
;
5439 if (gl_info
->supported
[ARB_TEXTURE_ENV_COMBINE
]
5440 || gl_info
->supported
[EXT_TEXTURE_ENV_COMBINE
]
5441 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5443 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
5444 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
5445 | WINED3DTEXOPCAPS_BLENDFACTORALPHA
5446 | WINED3DTEXOPCAPS_BLENDCURRENTALPHA
5447 | WINED3DTEXOPCAPS_LERP
5448 | WINED3DTEXOPCAPS_SUBTRACT
;
5450 if (gl_info
->supported
[ATI_TEXTURE_ENV_COMBINE3
]
5451 || gl_info
->supported
[NV_TEXTURE_ENV_COMBINE4
])
5453 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_ADDSMOOTH
5454 | WINED3DTEXOPCAPS_MULTIPLYADD
5455 | WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
5456 | WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
5457 | WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
;
5459 if (gl_info
->supported
[ARB_TEXTURE_ENV_DOT3
])
5460 caps
->TextureOpCaps
|= WINED3DTEXOPCAPS_DOTPRODUCT3
;
5462 caps
->MaxTextureBlendStages
= gl_info
->limits
.textures
;
5463 caps
->MaxSimultaneousTextures
= gl_info
->limits
.textures
;
5466 static DWORD
ffp_fragment_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
5468 return GL_EXT_EMUL_ARB_MULTITEXTURE
| GL_EXT_EMUL_EXT_FOG_COORD
;
5471 static BOOL
ffp_color_fixup_supported(struct color_fixup_desc fixup
)
5473 /* We only support identity conversions. */
5474 return is_identity_fixup(fixup
);
5477 static BOOL
ffp_none_context_alloc(struct wined3d_context
*context
)
5482 static void ffp_none_context_free(struct wined3d_context
*context
)
5486 const struct wined3d_fragment_pipe_ops ffp_fragment_pipeline
=
5489 ffp_fragment_get_caps
,
5490 ffp_fragment_get_emul_mask
,
5493 ffp_none_context_alloc
,
5494 ffp_none_context_free
,
5495 ffp_color_fixup_supported
,
5496 ffp_fragmentstate_template
,
5499 static void none_pipe_enable(const struct wined3d_context
*context
, BOOL enable
) {}
5501 static void *none_alloc(const struct wined3d_shader_backend_ops
*shader_backend
, void *shader_priv
)
5506 static void none_free(struct wined3d_device
*device
, struct wined3d_context
*context
) {}
5508 static void vp_none_get_caps(const struct wined3d_adapter
*adapter
, struct wined3d_vertex_caps
*caps
)
5510 memset(caps
, 0, sizeof(*caps
));
5513 static DWORD
vp_none_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
5518 const struct wined3d_vertex_pipe_ops none_vertex_pipe
=
5522 vp_none_get_emul_mask
,
5528 static void fp_none_get_caps(const struct wined3d_adapter
*adapter
, struct fragment_caps
*caps
)
5530 memset(caps
, 0, sizeof(*caps
));
5533 static DWORD
fp_none_get_emul_mask(const struct wined3d_gl_info
*gl_info
)
5538 static BOOL
fp_none_color_fixup_supported(struct color_fixup_desc fixup
)
5540 return is_identity_fixup(fixup
);
5543 const struct wined3d_fragment_pipe_ops none_fragment_pipe
=
5547 fp_none_get_emul_mask
,
5550 ffp_none_context_alloc
,
5551 ffp_none_context_free
,
5552 fp_none_color_fixup_supported
,
5556 static unsigned int num_handlers(const APPLYSTATEFUNC
*funcs
)
5559 for(i
= 0; funcs
[i
]; i
++);
5563 static void multistate_apply_2(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5565 context
->device
->multistate_funcs
[state_id
][0](context
, state
, state_id
);
5566 context
->device
->multistate_funcs
[state_id
][1](context
, state
, state_id
);
5569 static void multistate_apply_3(struct wined3d_context
*context
, const struct wined3d_state
*state
, DWORD state_id
)
5571 context
->device
->multistate_funcs
[state_id
][0](context
, state
, state_id
);
5572 context
->device
->multistate_funcs
[state_id
][1](context
, state
, state_id
);
5573 context
->device
->multistate_funcs
[state_id
][2](context
, state
, state_id
);
5576 static void prune_invalid_states(struct wined3d_state_entry
*state_table
, const struct wined3d_d3d_info
*d3d_info
)
5578 unsigned int start
, last
, i
;
5580 start
= STATE_TEXTURESTAGE(d3d_info
->limits
.ffp_blend_stages
, 0);
5581 last
= STATE_TEXTURESTAGE(WINED3D_MAX_TEXTURES
- 1, WINED3D_HIGHEST_TEXTURE_STATE
);
5582 for (i
= start
; i
<= last
; ++i
)
5584 state_table
[i
].representative
= 0;
5585 state_table
[i
].apply
= state_undefined
;
5588 start
= STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ d3d_info
->limits
.ffp_blend_stages
);
5589 last
= STATE_TRANSFORM(WINED3D_TS_TEXTURE0
+ WINED3D_MAX_TEXTURES
- 1);
5590 for (i
= start
; i
<= last
; ++i
)
5592 state_table
[i
].representative
= 0;
5593 state_table
[i
].apply
= state_undefined
;
5596 start
= STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(d3d_info
->limits
.ffp_vertex_blend_matrices
));
5597 last
= STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255));
5598 for (i
= start
; i
<= last
; ++i
)
5600 state_table
[i
].representative
= 0;
5601 state_table
[i
].apply
= state_undefined
;
5605 static void validate_state_table(struct wined3d_state_entry
*state_table
)
5635 static const DWORD simple_states
[] =
5641 STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX
),
5642 STATE_SHADER(WINED3D_SHADER_TYPE_HULL
),
5643 STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN
),
5644 STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY
),
5645 STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL
),
5646 STATE_SHADER(WINED3D_SHADER_TYPE_COMPUTE
),
5647 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX
),
5648 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL
),
5649 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN
),
5650 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY
),
5651 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL
),
5652 STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_COMPUTE
),
5653 STATE_COMPUTE_SHADER_RESOURCE_BINDING
,
5654 STATE_GRAPHICS_SHADER_RESOURCE_BINDING
,
5655 STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING
,
5656 STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING
,
5661 STATE_POINTSPRITECOORDORIGIN
,
5662 STATE_BASEVERTEXINDEX
,
5668 STATE_DEPTH_STENCIL
,
5671 unsigned int i
, current
;
5673 for (i
= STATE_RENDER(1), current
= 0; i
<= STATE_RENDER(WINEHIGHEST_RENDER_STATE
); ++i
)
5675 if (!rs_holes
[current
].first
|| i
< STATE_RENDER(rs_holes
[current
].first
))
5677 if (!state_table
[i
].representative
)
5678 ERR("State %s (%#x) should have a representative.\n", debug_d3dstate(i
), i
);
5680 else if (state_table
[i
].representative
)
5681 ERR("State %s (%#x) shouldn't have a representative.\n", debug_d3dstate(i
), i
);
5683 if (i
== STATE_RENDER(rs_holes
[current
].last
)) ++current
;
5686 for (i
= 0; i
< ARRAY_SIZE(simple_states
); ++i
)
5688 if (!state_table
[simple_states
[i
]].representative
)
5689 ERR("State %s (%#x) should have a representative.\n",
5690 debug_d3dstate(simple_states
[i
]), simple_states
[i
]);
5693 for (i
= 0; i
< STATE_HIGHEST
+ 1; ++i
)
5695 DWORD rep
= state_table
[i
].representative
;
5698 if (state_table
[rep
].representative
!= rep
)
5700 ERR("State %s (%#x) has invalid representative %s (%#x).\n",
5701 debug_d3dstate(i
), i
, debug_d3dstate(rep
), rep
);
5702 state_table
[i
].representative
= 0;
5707 if (state_table
[i
].apply
)
5708 ERR("State %s (%#x) has both a handler and representative.\n", debug_d3dstate(i
), i
);
5710 else if (!state_table
[i
].apply
)
5712 ERR("Self representing state %s (%#x) has no handler.\n", debug_d3dstate(i
), i
);
5718 HRESULT
compile_state_table(struct wined3d_state_entry
*state_table
, APPLYSTATEFUNC
**dev_multistate_funcs
,
5719 const struct wined3d_d3d_info
*d3d_info
, const BOOL
*supported_extensions
,
5720 const struct wined3d_vertex_pipe_ops
*vertex
, const struct wined3d_fragment_pipe_ops
*fragment
,
5721 const struct wined3d_state_entry_template
*misc
)
5723 APPLYSTATEFUNC multistate_funcs
[STATE_HIGHEST
+ 1][3];
5724 const struct wined3d_state_entry_template
*cur
;
5725 unsigned int i
, type
, handlers
;
5726 BOOL set
[STATE_HIGHEST
+ 1];
5728 memset(multistate_funcs
, 0, sizeof(multistate_funcs
));
5730 for (i
= 0; i
< STATE_HIGHEST
+ 1; ++i
)
5732 state_table
[i
].representative
= 0;
5733 state_table
[i
].apply
= state_undefined
;
5736 for (type
= 0; type
< 3; ++type
)
5738 /* This switch decides the order in which the states are applied */
5741 case 0: cur
= misc
; break;
5742 case 1: cur
= fragment
->states
; break;
5743 case 2: cur
= vertex
->vp_states
; break;
5744 default: cur
= NULL
; /* Stupid compiler */
5748 /* GL extension filtering should not prevent multiple handlers being applied from different
5751 memset(set
, 0, sizeof(set
));
5753 for (i
= 0; cur
[i
].state
; ++i
)
5755 APPLYSTATEFUNC
*funcs_array
;
5757 /* Only use the first matching state with the available extension from one template.
5759 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
5760 * {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
5762 * if GL_XYZ_fancy is supported, ignore the 2nd line
5764 if (set
[cur
[i
].state
]) continue;
5765 /* Skip state lines depending on unsupported extensions */
5766 if (!supported_extensions
[cur
[i
].extension
]) continue;
5767 set
[cur
[i
].state
] = TRUE
;
5768 /* In some cases having an extension means that nothing has to be
5769 * done for a state, e.g. if GL_ARB_texture_non_power_of_two is
5770 * supported, the texture coordinate fixup can be ignored. If the
5771 * apply function is used, mark the state set(done above) to prevent
5772 * applying later lines, but do not record anything in the state
5775 if (!cur
[i
].content
.representative
) continue;
5777 handlers
= num_handlers(multistate_funcs
[cur
[i
].state
]);
5778 multistate_funcs
[cur
[i
].state
][handlers
] = cur
[i
].content
.apply
;
5782 state_table
[cur
[i
].state
].apply
= cur
[i
].content
.apply
;
5785 state_table
[cur
[i
].state
].apply
= multistate_apply_2
;
5786 if (!(dev_multistate_funcs
[cur
[i
].state
] = heap_calloc(2, sizeof(**dev_multistate_funcs
))))
5789 dev_multistate_funcs
[cur
[i
].state
][0] = multistate_funcs
[cur
[i
].state
][0];
5790 dev_multistate_funcs
[cur
[i
].state
][1] = multistate_funcs
[cur
[i
].state
][1];
5793 state_table
[cur
[i
].state
].apply
= multistate_apply_3
;
5794 if (!(funcs_array
= heap_realloc(dev_multistate_funcs
[cur
[i
].state
],
5795 sizeof(**dev_multistate_funcs
) * 3)))
5798 dev_multistate_funcs
[cur
[i
].state
] = funcs_array
;
5799 dev_multistate_funcs
[cur
[i
].state
][2] = multistate_funcs
[cur
[i
].state
][2];
5802 ERR("Unexpected amount of state handlers for state %u: %u.\n",
5803 cur
[i
].state
, handlers
+ 1);
5806 if (state_table
[cur
[i
].state
].representative
5807 && state_table
[cur
[i
].state
].representative
!= cur
[i
].content
.representative
)
5809 FIXME("State %s (%#x) has different representatives in different pipeline parts.\n",
5810 debug_d3dstate(cur
[i
].state
), cur
[i
].state
);
5812 state_table
[cur
[i
].state
].representative
= cur
[i
].content
.representative
;
5816 prune_invalid_states(state_table
, d3d_info
);
5817 validate_state_table(state_table
);
5822 for (i
= 0; i
<= STATE_HIGHEST
; ++i
)
5824 heap_free(dev_multistate_funcs
[i
]);
5827 memset(dev_multistate_funcs
, 0, (STATE_HIGHEST
+ 1) * sizeof(*dev_multistate_funcs
));
5829 return E_OUTOFMEMORY
;