state.c revision 058c0c53c37f5cb271aeb3c385c10766f84f4aef
/*
* Direct3D state management
*
* Copyright 2002 Lionel Ulmer
* Copyright 2002-2005 Jason Edmeades
* Copyright 2003-2004 Raphael Junqueira
* Copyright 2004 Christian Costa
* Copyright 2005 Oliver Stieber
* Copyright 2006 Henri Verbeet
* Copyright 2006-2008 Stefan Dösinger for CodeWeavers
* Copyright 2009-2011 Henri Verbeet for CodeWeavers
*
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include <stdio.h>
#ifdef HAVE_FLOAT_H
# include <float.h>
#endif
#include "wined3d_private.h"
/* Context activation for state handler is done by the caller. */
static void state_undefined(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
#ifndef VBOX
ERR("Undefined state.\n");
#else
WARN("Undefined state.\n");
#endif
}
static void state_nop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_fillmode(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
switch (mode)
{
case WINED3D_FILL_POINT:
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
break;
case WINED3D_FILL_WIREFRAME:
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
break;
case WINED3D_FILL_SOLID:
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
break;
default:
}
}
static void state_lighting(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Lighting is not enabled if transformed vertices are drawn, but lighting
* does not affect the stream sources, so it is not grouped for
* performance reasons. This state reads the decoded vertex declaration,
* so if it is dirty don't do anything. The vertex declaration applying
* function calls this function for updating. */
return;
{
checkGLcall("glEnable GL_LIGHTING");
}
else
{
checkGLcall("glDisable GL_LIGHTING");
}
}
static void state_zenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* No z test without depth stencil buffers */
{
TRACE("No Z buffer - disabling depth test\n");
}
switch (zenable)
{
case WINED3D_ZB_FALSE:
checkGLcall("glDisable GL_DEPTH_TEST");
break;
case WINED3D_ZB_TRUE:
checkGLcall("glEnable GL_DEPTH_TEST");
break;
case WINED3D_ZB_USEW:
checkGLcall("glEnable GL_DEPTH_TEST");
FIXME("W buffer is not well handled\n");
break;
default:
break;
}
{
{
checkGLcall("glEnable(GL_DEPTH_CLAMP)");
}
else
{
checkGLcall("glDisable(GL_DEPTH_CLAMP)");
}
}
FIXME("Z buffer disabled, but ARB_depth_clamp isn't supported.\n");
}
static void state_cullmode(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* glFrontFace() is set in context.c at context init and on an
* offscreen / onscreen rendering switch. */
{
case WINED3D_CULL_NONE:
checkGLcall("glDisable GL_CULL_FACE");
break;
case WINED3D_CULL_CW:
checkGLcall("glEnable GL_CULL_FACE");
checkGLcall("glCullFace(GL_FRONT)");
break;
case WINED3D_CULL_CCW:
checkGLcall("glEnable GL_CULL_FACE");
checkGLcall("glCullFace(GL_BACK)");
break;
default:
FIXME("Unrecognized cull mode %#x.\n",
}
}
static void state_shademode(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
case WINED3D_SHADE_FLAT:
checkGLcall("glShadeModel(GL_FLAT)");
break;
case WINED3D_SHADE_GOURAUD:
checkGLcall("glShadeModel(GL_SMOOTH)");
break;
case WINED3D_SHADE_PHONG:
FIXME("WINED3D_SHADE_PHONG isn't supported.\n");
break;
default:
FIXME("Unrecognized shade mode %#x.\n",
}
}
static void state_ditherenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glEnable GL_DITHER");
}
else
{
checkGLcall("glDisable GL_DITHER");
}
}
static void state_zwritenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glDepthMask(1)");
}
else
{
checkGLcall("glDepthMask(0)");
}
}
{
switch (f)
{
case WINED3D_CMP_NEVER:
return GL_NEVER;
case WINED3D_CMP_LESS:
return GL_LESS;
case WINED3D_CMP_EQUAL:
return GL_EQUAL;
case WINED3D_CMP_LESSEQUAL:
return GL_LEQUAL;
case WINED3D_CMP_GREATER:
return GL_GREATER;
case WINED3D_CMP_NOTEQUAL:
return GL_NOTEQUAL;
case WINED3D_CMP_GREATEREQUAL:
return GL_GEQUAL;
case WINED3D_CMP_ALWAYS:
return GL_ALWAYS;
default:
FIXME("Unrecognized compare function %#x.\n", f);
return GL_NONE;
}
}
static void state_zfunc(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
if (!depth_func) return;
checkGLcall("glDepthFunc");
}
void state_ambient(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
float col[4];
checkGLcall("glLightModel for MODEL_AMBIENT");
}
static void state_blendop_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
}
{
switch (op)
{
case WINED3D_BLEND_OP_ADD:
return GL_FUNC_ADD_EXT;
return GL_FUNC_SUBTRACT_EXT;
return GL_FUNC_REVERSE_SUBTRACT_EXT;
case WINED3D_BLEND_OP_MIN:
return GL_MIN_EXT;
case WINED3D_BLEND_OP_MAX:
return GL_MAX_EXT;
default:
return GL_NONE;
}
}
static void state_blendop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
{
WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
return;
}
{
checkGLcall("glBlendEquationSeparateEXT");
}
else
{
checkGLcall("glBlendEquation");
}
}
{
switch (factor)
{
case WINED3D_BLEND_ZERO:
return GL_ZERO;
case WINED3D_BLEND_ONE:
return GL_ONE;
case WINED3D_BLEND_SRCCOLOR:
return GL_SRC_COLOR;
return GL_ONE_MINUS_SRC_COLOR;
case WINED3D_BLEND_SRCALPHA:
return GL_SRC_ALPHA;
return GL_ONE_MINUS_SRC_ALPHA;
case WINED3D_BLEND_DESTCOLOR:
return GL_DST_COLOR;
return GL_ONE_MINUS_DST_COLOR;
/* To compensate for the lack of format switching with backbuffer
* offscreen rendering, and with onscreen rendering, we modify the
* alpha test parameters for (INV)DESTALPHA if the render target
* doesn't support alpha blending. A nonexistent alpha channel
* returns 1.0, so WINED3D_BLEND_DESTALPHA becomes GL_ONE, and
* WINED3D_BLEND_INVDESTALPHA becomes GL_ZERO. */
case WINED3D_BLEND_DESTALPHA:
return GL_SRC_ALPHA_SATURATE;
return GL_CONSTANT_COLOR_EXT;
return GL_ONE_MINUS_CONSTANT_COLOR_EXT;
default:
return GL_NONE;
}
}
static void state_blend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
enum wined3d_blend d3d_blend;
/* According to the red book, GL_LINE_SMOOTH needs GL_BLEND with specific
* blending parameters to work. */
{
/* Disable blending in all cases even without pixelshaders.
* With blending on we could face a big performance penalty.
* The d3d9 visual test confirms the behavior. */
if (context->render_offscreen
{
checkGLcall("glDisable GL_BLEND");
return;
}
else
{
checkGLcall("glEnable GL_BLEND");
}
}
else
{
checkGLcall("glDisable GL_BLEND");
/* Nothing more to do - get out */
return;
};
/* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
if (d3d_blend == WINED3D_BLEND_BOTHSRCALPHA)
{
}
else if (d3d_blend == WINED3D_BLEND_BOTHINVSRCALPHA)
{
}
else
{
}
{
checkGLcall("glEnable(GL_LINE_SMOOTH)");
if (srcBlend != GL_SRC_ALPHA)
WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected src blending param.\n");
WARN("WINED3D_RS_EDGEANTIALIAS enabled, but unexpected dst blending param.\n");
}
else
{
checkGLcall("glDisable(GL_LINE_SMOOTH)");
}
/* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
{
/* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
{
WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparateEXT\n");
return;
}
/* WINED3D_BLEND_BOTHSRCALPHA and WINED3D_BLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
if (d3d_blend == WINED3D_BLEND_BOTHSRCALPHA)
{
}
else if (d3d_blend == WINED3D_BLEND_BOTHINVSRCALPHA)
{
}
else
{
}
checkGLcall("glBlendFuncSeparateEXT");
}
else
{
checkGLcall("glBlendFunc");
}
/* Colorkey fixup for stage 0 alphaop depends on
* WINED3D_RS_ALPHABLENDENABLE state, so it may need updating. */
}
static void state_blendfactor_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
}
static void state_blendfactor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
float col[4];
checkGLcall("glBlendColor");
}
static void state_alpha(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
int glParm = 0;
float ref;
/* Find out if the texture on the first stage has a ckey set
* The alpha state func reads the texture settings, even though alpha and texture are not grouped
* together. This is to avoid making a huge alpha+texture+texture stage+ckey block due to the hardly
* used WINED3D_RS_COLORKEYENABLE state(which is d3d <= 3 only). The texture function will call alpha
* in case it finds some texture+colorkeyenable combination which needs extra care.
*/
{
enable_ckey = TRUE;
}
{
checkGLcall("glEnable GL_ALPHA_TEST");
}
else
{
checkGLcall("glDisable GL_ALPHA_TEST");
/* Alpha test is disabled, don't bother setting the params - it will happen on the next
* enable call
*/
return;
}
{
ref = 0.0f;
}
else
{
}
if (glParm)
{
checkGLcall("glAlphaFunc");
}
}
static void shaderconstant(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
void state_clipping(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
/* The OpenGL spec says that clipping planes are disabled when using
* shaders. Direct3D planes aren't, so that is an issue. The MacOS ATI
* driver keeps clipping planes activated with shaders in some
* conditions I got sick of tracking down. The shader state handler
* disables all clip planes because of that - don't do anything here
* and keep them disabled. */
FIXME("Clipping not supported with vertex shaders\n");
return;
}
/* glEnable(GL_CLIP_PLANEx) doesn't apply to (ARB backend) vertex shaders.
* The enabled / disabled planes are hardcoded into the shader. Update the
* shader to update the enabled clipplanes. In case of fixed function, we
* need to update the clipping field from ffp_vertex_settings. */
/* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
* of already set values
*/
/* If enabling / disabling all
* TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
*/
{
}
else
{
disable = 0xffffffff;
enable = 0x00;
}
checkGLcall("clip plane enable");
checkGLcall("clip plane disable");
}
void state_specularenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
* specular color. This is wrong:
* Separate specular color means the specular colour is maintained separately, whereas
* single color means it is merged in. However in both cases they are being used to
* some extent.
* To disable specular color, set it explicitly to black and turn off GL_COLOR_SUM_EXT
* NOTE: If not supported don't give FIXMEs the impact is really minimal and very few people are
* running 1.4 yet!
*
*
* If register combiners are enabled, enabling / disabling GL_COLOR_SUM has no effect.
* Instead, we need to setup the FinalCombiner properly.
*
* The default setup for the FinalCombiner is:
*
* <variable> <input> <mapping> <usage>
* GL_VARIABLE_A_NV GL_FOG, GL_UNSIGNED_IDENTITY_NV GL_ALPHA
* GL_VARIABLE_B_NV GL_SPARE0_PLUS_SECONDARY_COLOR_NV GL_UNSIGNED_IDENTITY_NV GL_RGB
* GL_VARIABLE_C_NV GL_FOG GL_UNSIGNED_IDENTITY_NV GL_RGB
* GL_VARIABLE_D_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
* GL_VARIABLE_E_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
* GL_VARIABLE_F_NV GL_ZERO GL_UNSIGNED_IDENTITY_NV GL_RGB
* GL_VARIABLE_G_NV GL_SPARE0_NV GL_UNSIGNED_IDENTITY_NV GL_ALPHA
*
* That's pretty much fine as it is, except for variable B, which needs to take
* either GL_SPARE0_PLUS_SECONDARY_COLOR_NV or GL_SPARE0_NV, depending on
* whether WINED3D_RS_SPECULARENABLE is enabled or not.
*/
TRACE("Setting specular enable state and materials\n");
{
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&state->material.specular);
checkGLcall("glMaterialfv");
{
/* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
* and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
* allows bigger values. If the extension is supported, gl_info->limits.shininess contains the
* value reported by the extension, otherwise 128. For values > gl_info->limits.shininess clamp
* them, it should be safe to do so without major visual distortions.
*/
}
else
{
}
checkGLcall("glMaterialf(GL_SHININESS)");
else
TRACE("Specular colors cannot be enabled in this version of opengl\n");
checkGLcall("glEnable(GL_COLOR_SUM)");
{
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
checkGLcall("glFinalCombinerInputNV()");
}
} else {
/* for the case of enabled lighting: */
checkGLcall("glMaterialfv");
/* for the case of disabled lighting: */
else
TRACE("Specular colors cannot be disabled in this version of opengl\n");
checkGLcall("glDisable(GL_COLOR_SUM)");
{
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
checkGLcall("glFinalCombinerInputNV()");
}
}
TRACE("diffuse {%.8e, %.8e, %.8e, %.8e}\n",
TRACE("ambient {%.8e, %.8e, %.8e, %.8e}\n",
TRACE("specular {%.8e, %.8e, %.8e, %.8e}\n",
TRACE("emissive {%.8e, %.8e, %.8e, %.8e}\n",
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&state->material.ambient);
checkGLcall("glMaterialfv(GL_AMBIENT)");
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&state->material.diffuse);
checkGLcall("glMaterialfv(GL_DIFFUSE)");
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&state->material.emissive);
checkGLcall("glMaterialfv(GL_EMISSION)");
}
static void state_texfactor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
unsigned int i;
/* Note the texture color applies to all textures whereas
* GL_TEXTURE_ENV_COLOR applies to active only. */
float col[4];
/* And now the default texture color as well */
{
/* Note the WINED3D_RS value applies to all textures, but GL has one
* per texture, so apply it now ready to be used! */
checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
}
}
{
checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
checkGLcall("glActiveStencilFaceEXT(...)");
checkGLcall("glStencilFunc(...)");
checkGLcall("glStencilOp(...)");
}
{
switch (op)
{
case WINED3D_STENCIL_OP_KEEP:
return GL_KEEP;
case WINED3D_STENCIL_OP_ZERO:
return GL_ZERO;
return GL_REPLACE;
return GL_INCR;
return GL_DECR;
return GL_INVERT;
case WINED3D_STENCIL_OP_INCR:
return GL_INCR_WRAP_EXT;
case WINED3D_STENCIL_OP_DECR:
return GL_DECR_WRAP_EXT;
default:
return GL_KEEP;
}
}
static void state_stencil(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* No stencil test without a stencil buffer. */
{
checkGLcall("glDisable GL_STENCIL_TEST");
return;
}
TRACE("(onesided %d, twosided %d, ref %x, mask %x, "
"GL_FRONT: func: %x, fail %x, zfail %x, zpass %x "
"GL_BACK: func: %x, fail %x, zfail %x, zpass %x )\n",
if (twosided_enable && onesided_enable)
{
checkGLcall("glEnable GL_STENCIL_TEST");
{
/* Apply back first, then front. This function calls glActiveStencilFaceEXT,
* which has an effect on the code below too. If we apply the front face
* afterwards, we are sure that the active stencil face is set to front,
* and other stencil functions which do not use two sided stencil do not have
* to set it back
*/
}
{
checkGLcall("glStencilFuncSeparateATI(...)");
checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
} else {
ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
}
}
else if(onesided_enable)
{
{
checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
}
/* This code disables the ATI extension as well, since the standard stencil functions are equal
* to calling the ATI functions with GL_FRONT_AND_BACK as face parameter
*/
checkGLcall("glEnable GL_STENCIL_TEST");
checkGLcall("glStencilFunc(...)");
checkGLcall("glStencilOp(...)");
}
else
{
checkGLcall("glDisable GL_STENCIL_TEST");
}
}
static void state_stencilwrite2s(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
checkGLcall("glStencilMask");
checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
}
static void state_stencilwrite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
checkGLcall("glStencilMask");
}
static void state_fog_vertexpart(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
return;
/* Table fog on: Never use fog coords, and use per-fragment fog */
{
{
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
}
/* Range fog is only used with per-vertex fog in d3d */
{
checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
}
return;
}
/* Otherwise use per-vertex fog in any case */
{
/* No fog at all, or transformed vertices: Use fog coord */
{
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
}
}
else
{
/* Otherwise, use the fragment depth */
{
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
}
{
{
checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
}
else
{
WARN("Range fog enabled, but not supported by this GL implementation.\n");
}
}
{
checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
}
}
}
void state_fogstartend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
DWORD d;
float f;
} tmpvalue;
switch(context->fog_source) {
case FOGSOURCE_VS:
fogstart = 1.0f;
fogend = 0.0f;
break;
case FOGSOURCE_COORD:
fogstart = 255.0f;
fogend = 0.0f;
break;
case FOGSOURCE_FFP:
/* In GL, fogstart == fogend disables fog, in D3D everything's fogged.*/
fogend = 0.0f;
}
break;
default:
/* This should not happen.context->fog_source is set in wined3d, not the app.
* Still this is needed to make the compiler happy
*/
ERR("Unexpected fog coordinate source\n");
fogstart = 0.0f;
fogend = 0.0f;
}
checkGLcall("glFogf(GL_FOG_START, fogstart)");
checkGLcall("glFogf(GL_FOG_END, fogend)");
}
void state_fog_fragpart(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
enum fogsource new_source;
{
/* No fog? Disable it, and we're done :-) */
checkGLcall("glDisable GL_FOG");
return;
}
/* Fog Rules:
*
* With fixed function vertex processing, Direct3D knows 2 different fog input sources.
* It can use the Z value of the vertex, or the alpha component of the specular color.
* This depends on the fog vertex, fog table and the vertex declaration. If the Z value
* is used, fogstart, fogend and the equation type are used, otherwise linear fog with
* start = 255, end = 0 is used. Obviously the msdn is not very clear on that.
*
* FOGTABLEMODE != NONE:
* The Z value is used, with the equation specified, no matter what vertex type.
*
* FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, untransformed:
* Per vertex fog is calculated using the specified fog equation and the parameters
*
* FOGTABLEMODE == NONE, FOGVERTEXMODE != NONE, transformed, OR
* FOGTABLEMODE == NONE, FOGVERTEXMODE == NONE, untransformed:
* Linear fog with start = 255.0, end = 0.0, input comes from the specular color
*
*
* Rules for vertex fog with shaders:
*
* When mixing fixed function functionality with the programmable pipeline, D3D expects
* the fog computation to happen during transformation while openGL expects it to happen
* during rasterization. Also, prior to pixel shader 3.0 D3D handles fog blending after
* the pixel shader while openGL always expects the pixel shader to handle the blending.
* To solve this problem, WineD3D does:
* 1) implement a linear fog equation and fog blending at the end of every pre 3.0 pixel
* shader,
* and 2) disables the fog computation (in either the fixed function or programmable
* rasterizer) if using a vertex program.
*
* D3D shaders can provide an explicit fog coordinate. This fog coordinate is used with
* D3DRS_FOGTABLEMODE==D3DFOG_NONE. The FOGVERTEXMODE is ignored, d3d always uses linear
* fog with start=1.0 and end=0.0 in this case. This is similar to fog coordinates in
* the specular color, a vertex shader counts as pretransformed geometry in this case.
* There are some GL differences between specular fog coords and vertex shaders though.
*
* With table fog the vertex shader fog coordinate is ignored.
*
* If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
* without shaders).
*/
/* DX 7 sdk: "If both render states(vertex and table fog) are set to valid modes,
* the system will apply only pixel(=table) fog effects."
*/
{
{
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
}
else
{
{
/* If processed vertices are used, fall through to the NONE case */
case WINED3D_FOG_EXP:
if (!context->last_was_rhw)
{
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
break;
}
/* drop through */
case WINED3D_FOG_EXP2:
if (!context->last_was_rhw)
{
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
break;
}
/* drop through */
case WINED3D_FOG_LINEAR:
if (!context->last_was_rhw)
{
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
break;
}
/* drop through */
case WINED3D_FOG_NONE:
/* Both are none? According to msdn the alpha channel of the specular
* color contains a fog factor. Set it in drawStridedSlow.
* Same happens with Vertexfog on transformed vertices
*/
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
break;
default:
FIXME("Unexpected WINED3D_RS_FOGVERTEXMODE %#x.\n",
}
}
} else {
{
case WINED3D_FOG_EXP:
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
break;
case WINED3D_FOG_EXP2:
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
break;
case WINED3D_FOG_LINEAR:
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
break;
case WINED3D_FOG_NONE: /* Won't happen */
default:
FIXME("Unexpected WINED3D_RS_FOGTABLEMODE %#x.\n",
}
}
checkGLcall("glEnable GL_FOG");
{
}
}
void state_fogcolor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
float col[4];
checkGLcall("glFog GL_FOG_COLOR");
}
void state_fogdensity(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
DWORD d;
float f;
} tmpvalue;
checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
}
static void state_colormat(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Depends on the decoded vertex declaration to read the existence of diffuse data.
* The vertex declaration will call this function if the fixed function pipeline is used.
*/
return;
}
{
TRACE("diff %d, amb %d, emis %d, spec %d\n",
{
else
Parm = GL_DIFFUSE;
{
}
{
}
}
{
Parm = GL_AMBIENT;
{
}
{
}
}
{
Parm = GL_EMISSION;
{
}
}
{
Parm = GL_SPECULAR;
}
}
/* Nothing changed, return. */
if (!Parm)
{
checkGLcall("glDisable GL_COLOR_MATERIAL");
}
else
{
checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
checkGLcall("glEnable(GL_COLOR_MATERIAL)");
}
/* Apparently calls to glMaterialfv are ignored for properties we're
* tracking with glColorMaterial, so apply those here. */
switch (context->tracking_parm)
{
case GL_AMBIENT_AND_DIFFUSE:
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&state->material.ambient);
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&state->material.diffuse);
checkGLcall("glMaterialfv");
break;
case GL_DIFFUSE:
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&state->material.diffuse);
checkGLcall("glMaterialfv");
break;
case GL_AMBIENT:
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&state->material.ambient);
checkGLcall("glMaterialfv");
break;
case GL_EMISSION:
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&state->material.emissive);
checkGLcall("glMaterialfv");
break;
case GL_SPECULAR:
/* Only change material color if specular is enabled, otherwise it is set to black */
{
gl_info->gl_ops.gl.p_glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&state->material.specular);
checkGLcall("glMaterialfv");
}
else
{
checkGLcall("glMaterialfv");
}
break;
}
}
static void state_linepattern(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union
{
DWORD d;
struct wined3d_line_pattern lp;
} tmppattern;
TRACE("Line pattern: repeat %d bits %x.\n", tmppattern.lp.repeat_factor, tmppattern.lp.line_pattern);
{
checkGLcall("glLineStipple(repeat, linepattern)");
checkGLcall("glEnable(GL_LINE_STIPPLE);");
}
else
{
checkGLcall("glDisable(GL_LINE_STIPPLE);");
}
}
static void state_normalize(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
return;
/* Without vertex normals, we set the current normal to 0/0/0 to remove the diffuse factor
* from the opengl lighting equation, as d3d does. Normalization of 0/0/0 can lead to a division
* by zero and is not properly defined in opengl, so avoid it
*/
{
checkGLcall("glEnable(GL_NORMALIZE);");
}
else
{
checkGLcall("glDisable(GL_NORMALIZE);");
}
}
void state_psizemin_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
DWORD d;
float f;
} tmpvalue;
if (tmpvalue.f != 1.0f)
{
}
if (tmpvalue.f != 64.0f)
{
}
}
void state_psizemin_ext(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union
{
DWORD d;
float f;
/* Max point size trumps min point size */
}
checkGLcall("glPointParameterfEXT(...)");
checkGLcall("glPointParameterfEXT(...)");
}
void state_psizemin_arb(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union
{
DWORD d;
float f;
/* Max point size trumps min point size */
}
checkGLcall("glPointParameterfARB(...)");
checkGLcall("glPointParameterfARB(...)");
}
void state_pscale(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* TODO: Group this with the viewport */
/*
* POINTSCALEENABLE controls how point size value is treated. If set to
* true, the point size is scaled with respect to height of viewport.
* When set to false point size is in pixels.
*/
/* Default values */
union {
DWORD d;
float f;
} pointSize, A, B, C;
{
{
/* Minimum valid point size for OpenGL is driver specific. For Direct3D it is
* 0.0f. This means that OpenGL will clamp really small point sizes to the
* driver minimum. To correct for this we need to multiply by the scale factor when sizes
* are less than 1.0f. scale_factor = 1.0f / point_size.
*/
/* Clamp the point size, don't rely on the driver to do it. MacOS says min point size
* is 1.0, but then accepts points below that and draws too small points
*/
}
{
/* gl already scales the input to glPointSize,
* d3d scales the result after the point size scale.
* If the point size is bigger than the max size, use the
* scaling to scale it bigger, and set the gl point size to max
*/
} else {
scaleFactor = 1.0f;
}
att[0] = A.f / scaleFactor;
}
{
checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
}
{
checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
}
{
WARN("POINT_PARAMETERS not supported in this version of opengl\n");
}
checkGLcall("glPointSize(...);");
}
static void state_debug_monitor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_colorwrite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
checkGLcall("glColorMask(...)");
{
FIXME("WINED3D_RS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
FIXME("Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n");
}
}
{
}
static void state_colorwrite0(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_colorwrite1(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_colorwrite2(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_colorwrite3(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void state_localviewer(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
}
else
{
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
}
}
static void state_lastpixel(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
TRACE("Last Pixel Drawing Enabled\n");
}
else
{
if (!warned) {
FIXME("Last Pixel Drawing Disabled, not handled yet\n");
} else {
TRACE("Last Pixel Drawing Disabled, not handled yet\n");
}
}
}
void state_pointsprite_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* TODO: NV_POINT_SPRITE */
{
/* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
FIXME("Point sprites not supported\n");
}
}
void state_pointsprite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
}
else
{
checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
}
}
static void state_wrap(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("(WINED3D_RS_WRAP0) Texture wrapping not yet supported.\n");
}
static void state_msaa_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
WARN("Multisample antialiasing not supported by GL.\n");
}
static void state_msaa(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
}
else
{
checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
}
}
static void state_scissor(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glEnable(GL_SCISSOR_TEST)");
}
else
{
checkGLcall("glDisable(GL_SCISSOR_TEST)");
}
}
/* The Direct3D depth bias is specified in normalized depth coordinates. In
* OpenGL the bias is specified in units of "the smallest value that is
* guaranteed to produce a resolvable offset for a given implementation". To
* convert from D3D to GL we need to divide the D3D depth bias by that value.
* There's no practical way to retrieve that value from a given GL
* implementation, but the D3D application has essentially the same problem,
* which makes a guess of the depth buffer format's highest possible value a
* reasonable guess. Note that SLOPESCALEDEPTHBIAS is a scaling factor for the
* depth slope, and doesn't need to be scaled. */
static void state_depthbias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
float scale;
union
{
DWORD d;
float f;
} scale_bias, const_bias;
checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
{
float bias = -(float)const_bias.d;
checkGLcall("glPolygonOffset");
}
else
{
if (depth)
{
TRACE("Depth format %s, using depthbias scale of %.8e.\n",
}
else
{
/* The context manager will reapply this state on a depth stencil change */
TRACE("No depth stencil, using depthbias scale of 0.0.\n");
scale = 0.0f;
}
checkGLcall("glPolygonOffset(...)");
}
}
else
{
checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
}
}
static void state_zvisible(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_ZVISIBLE not implemented.\n");
}
static void state_perspective(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
}
else
{
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
}
}
static void state_stippledalpha(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Stippled Alpha not supported yet.\n");
}
static void state_antialias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Antialias not supported yet.\n");
}
static void state_multisampmask(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_MULTISAMPLEMASK %#x not yet implemented.\n",
}
static void state_patchedgestyle(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_PATCHEDGESTYLE %#x not yet implemented.\n",
}
static void state_patchsegments(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
DWORD d;
float f;
} tmpvalue;
tmpvalue.f = 1.0f;
{
if(!displayed)
}
}
static void state_positiondegree(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_POSITIONDEGREE %#x not yet implemented.\n",
}
static void state_normaldegree(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_NORMALDEGREE %#x not yet implemented.\n",
}
static void state_tessellation(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("WINED3D_RS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
}
static void state_nvdb(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
DWORD d;
float f;
{
/* If zmin is larger than zmax INVALID_VALUE error is generated.
* In d3d9 test is not performed in this case*/
{
checkGLcall("glEnable(GL_DEPTH_BOUNDS_TEST_EXT)");
checkGLcall("glDepthBoundsEXT(...)");
}
else
{
checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
}
}
else
{
checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
}
}
static void state_wrapu(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_WRAPU not implemented yet.\n");
}
static void state_wrapv(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_WRAPV not implemented yet.\n");
}
static void state_monoenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_MONOENABLE not implemented yet.\n");
}
static void state_rop2(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_ROP2 not implemented yet.\n");
}
static void state_planemask(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_PLANEMASK not implemented yet.\n");
}
static void state_subpixel(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_SUBPIXEL not implemented yet.\n");
}
static void state_subpixelx(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_SUBPIXELX not implemented yet.\n");
}
static void state_stippleenable(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_STIPPLEENABLE not implemented yet.\n");
}
static void state_mipmaplodbias(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_MIPMAPLODBIAS not implemented yet.\n");
}
static void state_anisotropy(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_ANISOTROPY not implemented yet.\n");
}
static void state_flushbatch(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_FLUSHBATCH not implemented yet.\n");
}
static void state_translucentsi(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
}
static void state_extents(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_EXTENTS not implemented yet.\n");
}
static void state_ckeyblend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Render state WINED3D_RS_COLORKEYBLENDENABLE not implemented yet.\n");
}
static void state_swvp(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
FIXME("Software vertex processing not implemented.\n");
}
/* The WINED3DTA_ALPHAREPLICATE flag specifies the alpha component of the
* input should be used for all input components. The WINED3DTA_COMPLEMENT
* flag specifies the complement of the input should be used. */
/* Calculate the operand */
if (complement) {
else *operand = GL_ONE_MINUS_SRC_COLOR;
} else {
else *operand = GL_SRC_COLOR;
}
/* Calculate the source */
switch (arg & WINED3DTA_SELECTMASK) {
case WINED3DTA_SPECULAR:
/*
* According to the GL_ARB_texture_env_combine specs, SPECULAR is
* 'Secondary color' and isn't supported until base GL supports it
* There is no concept of temp registers as far as I can tell
*/
FIXME("Unhandled texture arg WINED3DTA_SPECULAR\n");
*source = GL_TEXTURE;
break;
default:
*source = GL_TEXTURE;
break;
}
}
/* Setup the texture operations texture stage states */
{
TRACE("Alpha?(%d), Stage:%d Op(%s), a1(%d), a2(%d), a3(%d)\n", isAlpha, Stage, debug_d3dtop(op), arg1, arg2, arg3);
/* This is called by a state handler which has the gl lock held and a context for the thread */
/* Note: Operations usually involve two ars, src0 and src1 and are operations of
the form (a1 <operation> a2). However, some of the more complex operations
take 3 parameters. Instead of the (sensible) addition of a3, Microsoft added
in a third parameter called a0. Therefore these are operations of the form
a0 <operation> a1 <operation> a2, i.e., the new parameter goes to the front.
functions below, expect their syntax to differ slightly to those listed in the
manuals, i.e., replace arg1 with arg3, arg2 with arg1 and arg3 with arg2
This affects WINED3DTOP_MULTIPLYADD and WINED3DTOP_LERP */
if (isAlpha)
{
}
else
{
}
/* If a texture stage references an invalid texture unit the stage just
* passes through the result from the previous stage */
{
}
{
} else {
}
TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
/* Other texture operations require special extensions: */
{
if (isAlpha) {
opr = GL_SRC_ALPHA;
} else {
opr = GL_SRC_COLOR;
}
switch (op)
{
case WINED3D_TOP_DISABLE: /* Only for alpha */
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
case WINED3D_TOP_SELECT_ARG1: /* = a1 * 1 + 0 * 0 */
case WINED3D_TOP_SELECT_ARG2: /* = a2 * 1 + 0 * 0 */
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
if (op == WINED3D_TOP_SELECT_ARG1)
{
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
}
else
{
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
}
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
case WINED3D_TOP_MODULATE:
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_MODULATE_2X:
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3D_TOP_MODULATE_4X:
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
case WINED3D_TOP_ADD:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_ADD_SIGNED:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3D_TOP_ADD_SMOOTH:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_PRIMARY_COLOR");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_PRIMARY_COLOR");
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_CONSTANT");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_CONSTANT");
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr) {
}
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_MULTIPLY_ADD:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_BUMPENVMAP:
FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
break;
default:
}
if (Handled)
{
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
return;
}
} /* GL_NV_texture_env_combine4 */
switch (op) {
case WINED3D_TOP_DISABLE: /* Only for alpha */
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_SELECT_ARG1:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_SELECT_ARG2:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_MODULATE:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_MODULATE_2X:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3D_TOP_MODULATE_4X:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
case WINED3D_TOP_ADD:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_ADD_SIGNED:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD_SIGNED");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3D_TOP_SUBTRACT:
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_SUBTRACT");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else {
FIXME("This version of opengl does not support GL_SUBTRACT\n");
}
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_DOTPRODUCT3:
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
}
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
} else {
FIXME("This version of opengl does not support GL_DOT3\n");
}
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_LERP:
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_INTERPOLATE");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3D_TOP_ADD_SMOOTH:
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
}
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
case WINED3D_TOP_MULTIPLY_ADD:
{
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
break;
case WINED3D_TOP_BUMPENVMAP:
{
/* Technically texture shader support without register combiners is possible, but not expected to occur
* on real world cards, so for now a fixme should be enough
*/
FIXME("Implement bump mapping with GL_NV_texture_shader in non register combiner path\n");
}
break;
default:
}
if (Handled) {
{
if (isAlpha)
else
/* Note: If COMBINE4 in effect can't go back to combine! */
switch (op2)
{
case WINED3D_TOP_ADD_SMOOTH:
case WINED3D_TOP_MULTIPLY_ADD:
/* Ignore those implemented in both cases */
switch (op)
{
case WINED3D_TOP_SELECT_ARG1:
case WINED3D_TOP_SELECT_ARG2:
break;
default:
FIXME("Can't use COMBINE4 and COMBINE together, thisop=%s, otherop=%s, isAlpha(%d)\n", debug_d3dtop(op), debug_d3dtop(op2), isAlpha);
return;
}
}
}
if (combineOK)
{
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE");
return;
}
}
/* After all the extensions, if still unhandled, report fixme */
}
static void tex_colorop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Using a pixel shader? Don't care for anything here, the shader applying does it */
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
{
FIXME("Attempt to enable unsupported stage!\n");
return;
}
}
{
TRACE("Stage disabled\n");
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
/* Disable everything here */
checkGLcall("glDisable(GL_TEXTURE_2D)");
checkGLcall("glDisable(GL_TEXTURE_3D)");
{
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
{
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
}
/* All done */
return;
}
/* The sampler will also activate the correct texture dimensions, so no
* need to do it here if the sampler for this stage is dirty. */
}
void tex_alphaop(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
{
FIXME("Attempt to enable unsupported stage!\n");
return;
}
}
{
{
{
/* Color keying needs to pass alpha values from the texture through to have the alpha test work
* properly. On the other hand applications can still use texture combiners apparently. This code
* takes care that apps cannot remove the texture's alpha channel entirely.
*
* The fixup is required for Prince of Persia 3D(prison bars), while Moto racer 2 requires
* D3DTOP_MODULATE to work on color keyed surfaces. Aliens vs Predator 1 uses color keyed textures
* and alpha component of diffuse color to draw things like translucent text and perform other
* blending effects.
*
* Aliens vs Predator 1 relies on diffuse alpha having an effect, so it cannot be ignored. To
* provide the behavior expected by the game, while emulating the colorkey, diffuse alpha must be
* game disables alpha test and alpha blending. Alpha test is overwritten by wine's for purposes of
* color-keying though, so this will lead to missing geometry if texture alpha is modulated (pixels
* fail alpha test). To get around this, ALPHABLENDENABLE state is checked: if the app enables alpha
* blending, it can be expected to provide meaningful values in diffuse alpha, so it should be
* modulated with texture alpha; otherwise, selecting diffuse alpha is ignored in favour of texture
* alpha.
*
* What to do with multitexturing? So far no app has been found that uses color keying with
* multitexturing */
if (op == WINED3D_TOP_DISABLE)
{
}
{
{
}
else arg1 = WINED3DTA_TEXTURE;
}
{
{
}
else arg2 = WINED3DTA_TEXTURE;
}
}
}
}
/* tex_alphaop is shared between the ffp and nvrc because the difference only comes down to
* this if block here, and the other code(color keying, texture unit selection) are the same
*/
{
}
else
{
}
}
void transform_texture(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
int coordIdx;
/* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
{
TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
return;
}
if (mapped_stage == WINED3D_UNMAPPED_STAGE) return;
generated = (state->texture_states[texUnit][WINED3D_TSS_TEXCOORD_INDEX] & 0xffff0000) != WINED3DTSS_TCI_PASSTHRU;
coordIdx = min(state->texture_states[texUnit][WINED3D_TSS_TEXCOORD_INDEX & 0x0000ffff], MAX_TEXTURES - 1);
/* The sampler applying function calls us if this changes */
{
if(generated) {
FIXME("Non-power2 texture being used with generated texture coords\n");
}
/* NP2 texcoord fixup is implemented for pixelshaders so only enable the
fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
{
TRACE("Non power two matrix multiply fixup\n");
}
}
}
{
unsigned int texture_idx;
{
}
}
static void load_tex_coords(const struct wined3d_context *context, const struct wined3d_stream_info *si,
{
unsigned int mapped_stage = 0;
unsigned int textureNo = 0;
{
if (mapped_stage == WINED3D_UNMAPPED_STAGE) continue;
{
continue;
}
{
TRACE("Setting up texture %u, idx %d, coordindx %u, data {%#x:%p}.\n",
{
checkGLcall("glBindBufferARB");
}
checkGLcall("glClientActiveTextureARB");
/* The coords to supply depend completely on the fvf / vertex shader */
}
else
{
}
}
{
/* The number of the mapped stages increases monotonically, so it's fine to use the last used one. */
{
}
}
checkGLcall("loadTexCoords");
}
static void tex_coordindex(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
if (mapped_stage == WINED3D_UNMAPPED_STAGE)
{
return;
}
{
return;
}
/* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
*
* FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
* eg. SetTextureStageState( 0, WINED3D_TSS_TEXCOORDINDEX, WINED3D_TSS_TCI_CAMERASPACEPOSITION | 1 );
* means use the vertex position (camera-space) as the input texture coordinates
* for this texture stage, and the wrap mode set in the WINED3D_RS_WRAP1 render
* state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
* to the TEXCOORDINDEX value
*/
{
case WINED3DTSS_TCI_PASSTHRU:
/* Use the specified texture coordinates contained within the
* vertex format. This value resolves to zero. */
checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
break;
/* CameraSpacePosition means use the vertex position, transformed to camera space,
* as the input texture coordinates for this stage's texture transformation. This
* equates roughly to EYE_LINEAR */
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
break;
/* Note that NV_TEXGEN_REFLECTION support is implied when
* ARB_TEXTURE_CUBE_MAP is supported */
{
FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
break;
}
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
break;
/* Note that NV_TEXGEN_REFLECTION support is implied when
* ARB_TEXTURE_CUBE_MAP is supported */
{
FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
break;
}
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
break;
case WINED3DTSS_TCI_SPHEREMAP:
checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
break;
default:
FIXME("Unhandled WINED3D_TSS_TEXCOORD_INDEX %#x.\n",
checkGLcall("Disable texgen.");
break;
}
/* Update the texture matrix. */
{
/* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
* source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
* and do all the things linked to it
* TODO: Tidy that up to reload only the arrays of the changed unit
*/
}
}
static void tex_bumpenvlscale(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* The pixel shader has to know the luminance scale. Do a constants update. */
}
void sampler_texmatrix(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
if(!texture) return;
/* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
* wined3d_texture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
* scaling is reapplied or removed, the texture matrix has to be reapplied
*
* The mapped stage is already active because the sampler() function below, which is part of the
* misc pipeline
*/
if (sampler < MAX_TEXTURES)
{
{
if (texIsPow2)
else
}
}
}
static void sampler(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
union {
float f;
DWORD d;
} tmpvalue;
/* Enabling and disabling texture dimensions is done by texture stage state / pixel shader setup, this function
* only has to bind textures and set the per texture states
*/
if (mapped_stage == WINED3D_UNMAPPED_STAGE)
{
return;
}
{
return;
}
{
{
checkGLcall("glTexEnvf(GL_TEXTURE_LOD_BIAS_EXT, ...)");
}
{
{
/* If color keying is enabled update the alpha test, it
* depends on the existence of a color key in stage 0. */
}
}
/* Trigger shader constant reloading (for NP2 texcoord fixup) */
}
else
{
{
/* TODO: What should I do with pixel shaders here ??? */
{
/* If color keying is enabled update the alpha test, it
* depends on the existence of a color key in stage 0. */
}
} /* Otherwise tex_colorop disables the stage */
}
}
void apply_pixelshader(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
unsigned int i;
{
if (!context->last_was_pshader)
{
/* Former draw without a pixel shader, some samplers may be
* disabled because of WINED3D_TSS_COLOR_OP = WINED3DTOP_DISABLE
* make sure to enable them. */
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
{
}
}
else
{
/* Otherwise all samplers were activated by the code above in
* earlier draws, or by sampler() if a different texture was
* bound. I don't have to do anything. */
}
}
else
{
/* Disabled the pixel shader - color ops weren't applied while it was
* enabled, so re-apply them. */
{
}
}
}
static void state_geometry_shader(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void shader_bumpenvmat(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* The pixel shader has to know the bump env matrix. Do a constants update. */
}
void transform_world(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* This function is called by transform_view below if the view matrix was changed too
*
* Deliberately no check if the vertex declaration is dirty because the vdecl state
* does not always update the world matrix, only on a switch between transformed
* and untransformed draws. It *may* happen that the world matrix is set 2 times during one
* draw, but that should be rather rare and cheaper in total.
*/
checkGLcall("glMatrixMode");
if (context->last_was_rhw)
{
checkGLcall("glLoadIdentity()");
}
else
{
checkGLcall("glLoadMatrixf");
checkGLcall("glMultMatrixf");
}
}
{
return;
/* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
else
/* With vertex shaders, clip planes are not transformed in Direct3D,
* while in OpenGL they are still transformed by the model view matix. */
TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
checkGLcall("glClipPlane");
}
static void transform_worldex(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
WARN("Unsupported blend matrix set\n");
return;
}
return;
/* GL_MODELVIEW0_ARB: 0x1700
* GL_MODELVIEW1_ARB: 0x850a
* GL_MODELVIEW2_ARB: 0x8722
* GL_MODELVIEW3_ARB: 0x8723
* etc
* GL_MODELVIEW31_ARB: 0x873f
*/
checkGLcall("glMatrixMode(glMat)");
/* World matrix 0 is multiplied with the view matrix because d3d uses 3
* matrices while gl uses only 2. To avoid weighting the view matrix
* incorrectly it has to be multiplied into every GL modelview matrix. */
checkGLcall("glLoadMatrixf");
checkGLcall("glMultMatrixf");
}
static void state_vertexblend_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
static unsigned int once;
if (f == WINED3D_VBF_DISABLE)
return;
else WARN("Vertex blend flags %#x not supported.\n", f);
}
static void state_vertexblend(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
static unsigned int once;
switch (val)
{
case WINED3D_VBF_1WEIGHTS:
case WINED3D_VBF_2WEIGHTS:
case WINED3D_VBF_3WEIGHTS:
checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
/* D3D adds one more matrix which has weight (1 - sum(weights)).
* This is enabled at context creation with enabling
* GL_WEIGHT_SUM_UNITY_ARB. */
if (!device->vertexBlendUsed)
{
unsigned int i;
{
}
}
break;
case WINED3D_VBF_TWEENING:
case WINED3D_VBF_0WEIGHTS: /* Indexed vertex blending, not supported. */
/* Fall through. */
case WINED3D_VBF_DISABLE:
checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
break;
}
}
void transform_view(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
unsigned int k;
/* If we are changing the View matrix, reset the light and clipping planes to the new view
* enabled, since the call to enable it will not reset the position.
* NOTE2: Apparently texture transforms do NOT need reapplying
*/
checkGLcall("glMatrixMode(GL_MODELVIEW)");
checkGLcall("glLoadMatrixf(...)");
/* Reset lights. TODO: Call light apply func */
{
continue;
checkGLcall("glLightfv posn");
checkGLcall("glLightfv dirn");
}
/* Reset Clipping Planes */
{
}
if (context->last_was_rhw)
{
checkGLcall("glLoadIdentity()");
/* No need to update the world matrix, the identity is fine */
return;
}
/* Call the world matrix state, this will apply the combined WORLD + VIEW matrix
* No need to do it here if the state is scheduled for update. */
/* Avoid looping over a number of matrices if the app never used the functionality */
{
{
}
}
}
void transform_projection(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
checkGLcall("glMatrixMode(GL_PROJECTION)");
/* There are a couple of additional things we have to take into account
* here besides the projection transformation itself:
* - We need to flip along the y-axis in case of offscreen rendering.
* - OpenGL Z range is {-Wc,...,Wc} while D3D Z range is {0,...,Wc}.
* - D3D coordinates refer to pixel centers while GL coordinates refer
* to pixel corners.
* - D3D has a top-left filling convention. We need to maintain this
* even after the y-flip mentioned above.
* In order to handle the last two points, we translate by
* (63.0 / 128.0) / VPw and (63.0 / 128.0) / VPh. This is equivalent to
* translating slightly less than half a pixel. We want the difference to
* be large enough that it doesn't get lost due to rounding inside the
* driver, but small enough to prevent it from interfering with any
* anti-aliasing. */
if (context->last_was_rhw)
{
/* Transform D3D RHW coordinates to OpenGL clip coordinates. */
double x_scale = 2.0 / w;
? ((63.0 / 64.0) - (2.0 * y) - h) / h
: ((63.0 / 64.0) - (2.0 * y) - h) / -h;
const GLdouble projection[] =
{
0.0, 0.0, 2.0, 0.0,
};
checkGLcall("glLoadMatrixd");
}
else
{
const GLdouble projection[] =
{
1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 2.0, 0.0,
};
checkGLcall("glLoadMatrixd");
checkGLcall("glLoadMatrixf");
}
}
/* This should match any arrays loaded in load_vertex_data.
* TODO: Only load / unload arrays if we have to. */
{
}
{
checkGLcall("glDisableVertexAttribArrayARB(reg)");
GL_EXTCALL(glVertexAttribDivisorARB(i, 0));
}
/* This should match any arrays loaded in loadNumberedArrays
* TODO: Only load / unload arrays if we have to. */
{
/* disable any attribs (this is the same for both GLSL and ARB modes) */
int i;
}
}
{
int i;
/* Default to no instancing */
device->instance_count = 0;
for (i = 0; i < MAX_ATTRIBS; i++)
{
const struct wined3d_stream_state *stream;
{
continue;
}
{
if (!device->instance_count)
{
/* Unload instanced arrays, they will be loaded using
* immediate mode instead. */
continue;
}
}
{
GL_EXTCALL(glVertexAttribDivisorARB(i, 0));
}
{
{
checkGLcall("glBindBufferARB");
}
/* Use the VBO to find out if a vertex buffer exists, not the vb
* pointer. vb can point to a user pointer data blob. In that case
* curVBO will be 0. If there is a vertex buffer but no vbo we
* won't be load converted attributes anyway. */
{
}
}
else
{
/* Stride = 0 means always the same values.
* glVertexAttribPointerARB doesn't do that. Instead disable the
* pointer and set up the attribute statically. But we have to
* figure out the system memory address. */
{
}
{
case WINED3DFMT_R32_FLOAT:
break;
case WINED3DFMT_R32G32_FLOAT:
break;
break;
break;
case WINED3DFMT_R8G8B8A8_UINT:
break;
{
break;
}
/* else fallthrough */
break;
case WINED3DFMT_R16G16_SINT:
break;
break;
case WINED3DFMT_R16G16_SNORM:
{
GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
break;
}
case WINED3DFMT_R16G16_UNORM:
{
GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
break;
}
break;
break;
FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
/*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
break;
FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
/*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
break;
case WINED3DFMT_R16G16_FLOAT:
/* Are those 16 bit floats. C doesn't have a 16 bit float type. I could read the single bits and calculate a 4
* byte float according to the IEEE standard
*/
FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_2\n");
break;
FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
break;
default:
ERR("Unexpected declaration in stride 0 attributes\n");
break;
}
}
}
checkGLcall("Loading numbered arrays");
}
{
const struct wined3d_stream_info_element *e;
TRACE("Using fast vertex array code\n");
/* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
device->instance_count = 0;
/* Blend Data ---------------------------------------------- */
{
{
checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
{
checkGLcall("glBindBufferARB");
}
TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
e->format->gl_vtx_format,
e->format->gl_vtx_type,
e->stride,
checkGLcall("glWeightPointerARB");
{
if (!warned)
{
FIXME("blendMatrixIndices support\n");
}
}
} else {
/* TODO: support blends in drawStridedSlow
* No need to write a FIXME here, this is done after the general vertex decl decoding
*/
WARN("unsupported blending in openGl\n");
}
}
else
{
{
checkGLcall("glWeightbvARB(gl_info->max_blends, weights)");
}
}
/* Point Size ----------------------------------------------*/
{
/* no such functionality in the fixed function GL pipeline */
TRACE("Cannot change ptSize here in openGl\n");
/* TODO: Implement this function in using shaders if they are available */
}
/* Vertex Pointers -----------------------------------------*/
{
{
checkGLcall("glBindBufferARB");
}
TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
checkGLcall("glVertexPointer(...)");
checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
}
/* Normals -------------------------------------------------*/
{
{
checkGLcall("glBindBufferARB");
}
checkGLcall("glNormalPointer(...)");
checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
}
else
{
checkGLcall("glNormal3f(0, 0, 0)");
}
/* Diffuse Colour --------------------------------------------*/
{
{
checkGLcall("glBindBufferARB");
}
TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
}
else
{
checkGLcall("glColor4f(1, 1, 1, 1)");
}
/* Specular Colour ------------------------------------------*/
{
TRACE("setting specular colour\n");
{
{
checkGLcall("glBindBufferARB");
}
{
/* Usually specular colors only allow 3 components, since they have no alpha. In D3D, the specular alpha
* contains the fog coordinate, which is passed to GL with GL_EXT_fog_coord. However, the fixed function
* vertex pipeline can pass the specular alpha through, and pixel shaders can read it. So it GL accepts
* 4 component secondary colors use it
*/
checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
}
else
{
switch(type)
{
case GL_UNSIGNED_BYTE:
checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
break;
default:
/* Make sure that the right color component is dropped */
checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
}
}
checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
}
else
{
WARN("Specular colour is not supported in this GL implementation.\n");
}
}
else
{
{
GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
}
else
{
WARN("Specular colour is not supported in this GL implementation.\n");
}
}
/* Texture coords -------------------------------------------*/
}
static void streamsrc(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
context->numbered_array_mask = 0;
}
else if (context->namedArraysLoaded)
{
}
if (load_numbered)
{
TRACE("Loading numbered arrays\n");
}
else if (load_named)
{
TRACE("Loading vertex data\n");
}
}
static void vdecl_miscpart(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
return;
}
void vertexdeclaration(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
unsigned int i;
/* Don't have to apply the matrices when vertex shaders are used. When
* vshaders are turned off this function will be called again anyway to
* make sure they're properly set. */
if (!useVertexShaderFunction)
{
/* TODO: Move this mainly to the viewport state and only apply when
* the vp has changed or transformed / untransformed was switched. */
/* World matrix needs reapplication here only if we're switching between rhw and non-rhw
* mode.
*
* If a vertex shader is used, the world matrix changed and then vertex shader unbound
* this check will fail and the matrix not applied again. This is OK because a simple
* world matrix change reapplies the matrix - These checks here are only to satisfy the
* needs of the vertex declaration.
*
* World and view matrix go into the same gl matrix, so only apply them when neither is
* dirty
*/
if (context->last_was_vshader)
{
{
}
{
}
}
}
else
{
if(!context->last_was_vshader) {
{
/* Disable all clip planes to get defined results on all drivers. See comment in the
* state_clipping state handler
*/
{
checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
}
{
FIXME("Clipping not supported with vertex shaders\n");
}
}
if (wasrhw)
{
/* Apply the transform matrices when switching from rhw
* drawing to vertex shaders. Vertex shaders themselves do
* not need it, but the matrices are not reapplied
* automatically when switching back from vertex shaders to
* fixed function processing. So make sure we leave the fixed
* function vertex processing states back in a sane state
* before switching to shaders. */
}
/* Vertex shader clipping ignores the view matrix. Update all clipplanes
* (Note: ARB shaders can read the clip planes for clipping emulation even if
* device->vs_clipping is false.
*/
{
}
}
}
if (updateFog)
if (!useVertexShaderFunction)
{
unsigned int i;
for (i = 0; i < MAX_TEXTURES; ++i)
{
}
}
}
static void viewport_miscpart(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
checkGLcall("glDepthRange");
/* Note: GL requires lower left, DirectX supplies upper left. This is
* reversed when using offscreen rendering. */
if (context->render_offscreen)
{
}
else
{
}
checkGLcall("glViewport");
}
void viewport_vertexpart(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Update the position fixup. */
}
{
if (!lightInfo)
{
checkGLcall("glDisable(GL_LIGHT0 + Index)");
}
else
{
float quad_att;
/* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
/* Diffuse: */
checkGLcall("glLightfv");
/* Specular */
checkGLcall("glLightfv");
/* Ambient */
checkGLcall("glLightfv");
else
/* Do not assign attenuation values for lights that do not use them. D3D apps are free to pass any junk,
* but gl drivers use them and may crash due to bad Attenuation values. Need for Speed most wanted sets
* Attenuation0 to NaN and crashes in the gl lib
*/
{
case WINED3D_LIGHT_POINT:
/* Position */
checkGLcall("glLightfv");
checkGLcall("glLightf");
/* Attenuation - Are these right? guessing... */
checkGLcall("glLightf");
checkGLcall("glLightf");
checkGLcall("glLightf");
/* FIXME: Range */
break;
case WINED3D_LIGHT_SPOT:
/* Position */
checkGLcall("glLightfv");
/* Direction */
checkGLcall("glLightfv");
checkGLcall("glLightf");
checkGLcall("glLightf");
/* Attenuation - Are these right? guessing... */
checkGLcall("glLightf");
checkGLcall("glLightf");
checkGLcall("glLightf");
/* FIXME: Range */
break;
/* Direction */
/* Note GL uses w position of 0 for direction! */
checkGLcall("glLightfv");
checkGLcall("glLightf");
checkGLcall("glLightf");
break;
default:
}
/* Restore the modelview matrix */
checkGLcall("glEnable(GL_LIGHT0 + Index)");
}
}
static void scissorrect(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
/* Warning: glScissor uses window coordinates, not viewport coordinates,
* so our viewport correction does not apply. Warning2: Even in windowed
* mode the coords are relative to the window, not the screen. */
if (context->render_offscreen)
{
}
else
{
gl_info->gl_ops.gl.p_glScissor(r->left, height - r->bottom, r->right - r->left, r->bottom - r->top);
}
checkGLcall("glScissor");
}
static void indexbuffer(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
}
else
{
}
}
static void frontface(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
if (context->render_offscreen)
{
checkGLcall("glFrontFace(GL_CCW)");
}
else
{
checkGLcall("glFrontFace(GL_CW)");
}
}
static void psorigin_w(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
if (!warned)
{
WARN("Point sprite coordinate origin switching not supported.\n");
}
}
static void psorigin(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
{
checkGLcall("glPointParameteriNV(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
}
}
void state_srgbwrite(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
else
}
const struct StateEntryTemplate misc_state_template[] = {
{ STATE_RENDER(WINED3D_RS_SRCBLEND), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DESTBLEND), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_EDGEANTIALIAS), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ANTIALIASEDLINEENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SEPARATEALPHABLENDENABLE), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SRCBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DESTBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DESTBLENDALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_BLENDOPALPHA), { STATE_RENDER(WINED3D_RS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_POINTSPRITECOORDORIGIN, { STATE_POINTSPRITECOORDORIGIN, psorigin }, WINED3D_GL_VERSION_2_0 },
{ STATE_POINTSPRITECOORDORIGIN, { STATE_POINTSPRITECOORDORIGIN, psorigin_w }, WINED3D_GL_EXT_NONE },
/* TODO: Move shader constant loading to vertex and fragment pipeline respectively, as soon as the pshader and
* vshader loadings are untied from each other
*/
{ STATE_VERTEXSHADERCONSTANT, { STATE_VERTEXSHADERCONSTANT, shaderconstant }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT01), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT10), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT11), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_MAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(0, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(1, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(2, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(3, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(4, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(5, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(6, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LOFFSET), { STATE_TEXTURESTAGE(7, WINED3D_TSS_BUMPENV_LSCALE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ANTIALIAS), { STATE_RENDER(WINED3D_RS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3D_RS_TEXTUREPERSPECTIVE), state_perspective }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ZENABLE), { STATE_RENDER(WINED3D_RS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_WRAPU), { STATE_RENDER(WINED3D_RS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_WRAPV), { STATE_RENDER(WINED3D_RS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FILLMODE), { STATE_RENDER(WINED3D_RS_FILLMODE), state_fillmode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SHADEMODE), { STATE_RENDER(WINED3D_RS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_LINEPATTERN), { STATE_RENDER(WINED3D_RS_LINEPATTERN), state_linepattern }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MONOENABLE), { STATE_RENDER(WINED3D_RS_MONOENABLE), state_monoenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ROP2), { STATE_RENDER(WINED3D_RS_ROP2), state_rop2 }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_PLANEMASK), { STATE_RENDER(WINED3D_RS_PLANEMASK), state_planemask }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ZWRITEENABLE), { STATE_RENDER(WINED3D_RS_ZWRITEENABLE), state_zwritenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ALPHAREF), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ALPHAFUNC), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORKEYENABLE), { STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_LASTPIXEL), { STATE_RENDER(WINED3D_RS_LASTPIXEL), state_lastpixel }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CULLMODE), { STATE_RENDER(WINED3D_RS_CULLMODE), state_cullmode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ZFUNC), { STATE_RENDER(WINED3D_RS_ZFUNC), state_zfunc }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DITHERENABLE), { STATE_RENDER(WINED3D_RS_DITHERENABLE), state_ditherenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SUBPIXEL), { STATE_RENDER(WINED3D_RS_SUBPIXEL), state_subpixel }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SUBPIXELX), { STATE_RENDER(WINED3D_RS_SUBPIXELX), state_subpixelx }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), { STATE_RENDER(WINED3D_RS_STIPPLEDALPHA), state_stippledalpha }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STIPPLEENABLE), { STATE_RENDER(WINED3D_RS_STIPPLEENABLE), state_stippleenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), { STATE_RENDER(WINED3D_RS_MIPMAPLODBIAS), state_mipmaplodbias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ANISOTROPY), { STATE_RENDER(WINED3D_RS_ANISOTROPY), state_anisotropy }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FLUSHBATCH), { STATE_RENDER(WINED3D_RS_FLUSHBATCH), state_flushbatch }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT),{ STATE_RENDER(WINED3D_RS_TRANSLUCENTSORTINDEPENDENT),state_translucentsi }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILENABLE), { STATE_RENDER(WINED3D_RS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILZFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILPASS), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILFUNC), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILREF), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILMASK), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), state_stencilwrite2s}, EXT_STENCIL_TWO_SIDE },
{ STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), { STATE_RENDER(WINED3D_RS_STENCILWRITEMASK), state_stencilwrite }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TWOSIDEDSTENCILMODE), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CCW_STENCILFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CCW_STENCILZFAIL), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CCW_STENCILPASS), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CCW_STENCILFUNC), { STATE_RENDER(WINED3D_RS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_WRAP0), { STATE_RENDER(WINED3D_RS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_EXTENTS), { STATE_RENDER(WINED3D_RS_EXTENTS), state_extents }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), { STATE_RENDER(WINED3D_RS_COLORKEYBLENDENABLE), state_ckeyblend }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), { STATE_RENDER(WINED3D_RS_SOFTWAREVERTEXPROCESSING), state_swvp }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), { STATE_RENDER(WINED3D_RS_PATCHEDGESTYLE), state_patchedgestyle}, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), { STATE_RENDER(WINED3D_RS_PATCHSEGMENTS), state_patchsegments }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POSITIONDEGREE), { STATE_RENDER(WINED3D_RS_POSITIONDEGREE), state_positiondegree}, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_NORMALDEGREE), { STATE_RENDER(WINED3D_RS_NORMALDEGREE), state_normaldegree }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MINTESSELLATIONLEVEL), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MAXTESSELLATIONLEVEL), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ADAPTIVETESS_X), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Y), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ADAPTIVETESS_Z), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ADAPTIVETESS_W), { STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),state_nvdb }, EXT_DEPTH_BOUNDS_TEST },
{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),{ STATE_RENDER(WINED3D_RS_ENABLEADAPTIVETESSELLATION),state_tessellation }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_msaa }, ARB_MULTISAMPLE },
{ STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3D_RS_MULTISAMPLEANTIALIAS), state_msaa_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK), { STATE_RENDER(WINED3D_RS_MULTISAMPLEMASK), state_multisampmask }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), { STATE_RENDER(WINED3D_RS_DEBUGMONITORTOKEN), state_debug_monitor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), state_colorwrite0 }, EXT_DRAW_BUFFERS2 },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_BLENDOP), { STATE_RENDER(WINED3D_RS_BLENDOP), state_blendop }, EXT_BLEND_MINMAX },
{ STATE_RENDER(WINED3D_RS_BLENDOP), { STATE_RENDER(WINED3D_RS_BLENDOP), state_blendop_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE), { STATE_RENDER(WINED3D_RS_SCISSORTESTENABLE), state_scissor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SLOPESCALEDEPTHBIAS), { STATE_RENDER(WINED3D_RS_DEPTHBIAS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), state_colorwrite1 }, EXT_DRAW_BUFFERS2 },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE1), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), state_colorwrite2 }, EXT_DRAW_BUFFERS2 },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE2), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), state_colorwrite3 }, EXT_DRAW_BUFFERS2 },
{ STATE_RENDER(WINED3D_RS_COLORWRITEENABLE3), { STATE_RENDER(WINED3D_RS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_BLENDFACTOR), { STATE_RENDER(WINED3D_RS_BLENDFACTOR), state_blendfactor }, EXT_BLEND_COLOR },
{ STATE_RENDER(WINED3D_RS_BLENDFACTOR), { STATE_RENDER(WINED3D_RS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DEPTHBIAS), { STATE_RENDER(WINED3D_RS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_ZVISIBLE), { STATE_RENDER(WINED3D_RS_ZVISIBLE), state_zvisible }, WINED3D_GL_EXT_NONE },
/* Samplers */
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
};
const struct StateEntryTemplate vp_ffp_states[] =
{
{ STATE_RENDER(WINED3D_RS_SPECULARENABLE), { STATE_RENDER(WINED3D_RS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
/* Clip planes */
/* Lights */
/* Viewport */
/* Transform states follow */
{ STATE_TRANSFORM(WINED3D_TS_VIEW), { STATE_TRANSFORM(WINED3D_TS_VIEW), transform_view }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_PROJECTION), { STATE_TRANSFORM(WINED3D_TS_PROJECTION), transform_projection}, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE3), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE4), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE5), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE6), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_TEXTURE7), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 0)), transform_world }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 1)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 2)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 3)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 4)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 5)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 6)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 7)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 8)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 9)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 10)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 11)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 12)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 13)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 14)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 15)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 16)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 17)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 18)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 19)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 20)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 21)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 22)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 23)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 24)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 25)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 26)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 27)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 28)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 29)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 30)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 31)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 32)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 33)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 34)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 35)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 36)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 37)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 38)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 39)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 40)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 41)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 42)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 43)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 44)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 45)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 46)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 47)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 48)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 49)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 50)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 51)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 52)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 53)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 54)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 55)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 56)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 57)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 58)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 59)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 60)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 61)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 62)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 63)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 64)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 65)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 66)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 67)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 68)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 69)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 70)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 71)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 72)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 73)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 74)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 75)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 76)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 77)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 78)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 79)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 80)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 81)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 82)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 83)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 84)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 85)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 86)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 87)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 88)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 89)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 90)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 91)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 92)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 93)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 94)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 95)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 96)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 97)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 98)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX( 99)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(100)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(101)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(102)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(103)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(104)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(105)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(106)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(107)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(108)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(109)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(110)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(111)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(112)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(113)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(114)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(115)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(116)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(117)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(118)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(119)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(120)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(121)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(122)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(123)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(124)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(125)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(126)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(127)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(128)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(129)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(130)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(131)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(132)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(133)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(134)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(135)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(136)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(137)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(138)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(139)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(140)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(141)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(142)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(143)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(144)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(145)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(146)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(147)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(148)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(149)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(150)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(151)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(152)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(153)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(154)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(155)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(156)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(157)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(158)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(159)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(160)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(161)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(162)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(163)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(164)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(165)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(166)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(167)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(168)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(169)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(170)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(171)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(172)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(173)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(174)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(175)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(176)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(177)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(178)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(179)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(180)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(181)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(182)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(183)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(184)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(185)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(186)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(187)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(188)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(189)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(190)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(191)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(192)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(193)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(194)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(195)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(196)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(197)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(198)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(199)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(200)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(201)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(202)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(203)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(204)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(205)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(206)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(207)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(208)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(209)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(210)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(211)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(212)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(213)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(214)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(215)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(216)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(217)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(218)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(219)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(220)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(221)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(222)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(223)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(224)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(225)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(226)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(227)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(228)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(229)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(230)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(231)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(232)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(233)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(234)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(235)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(236)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(237)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(238)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(239)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(240)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(241)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(242)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(243)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(244)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(245)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(246)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(247)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(248)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(249)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(250)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(251)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(252)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(253)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(254)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), { STATE_TRANSFORM(WINED3D_TS_WORLD_MATRIX(255)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), {STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS), transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(0, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(1, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(2, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(3, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(4, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(5, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(6, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX), { STATE_TEXTURESTAGE(7, WINED3D_TSS_TEXCOORD_INDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
/* Fog */
{ STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_RANGEFOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CLIPPING), { STATE_RENDER(WINED3D_RS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE), { STATE_RENDER(WINED3D_RS_CLIPPING), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_LIGHTING), { STATE_RENDER(WINED3D_RS_LIGHTING), state_lighting }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_AMBIENT), { STATE_RENDER(WINED3D_RS_AMBIENT), state_ambient }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_COLORVERTEX), { STATE_RENDER(WINED3D_RS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_LOCALVIEWER), { STATE_RENDER(WINED3D_RS_LOCALVIEWER), state_localviewer }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), { STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), state_normalize }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE), { STATE_RENDER(WINED3D_RS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_VERTEXBLEND), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), state_vertexblend }, ARB_VERTEX_BLEND },
{ STATE_RENDER(WINED3D_RS_VERTEXBLEND), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), state_vertexblend_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSIZE), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_pointsprite }, ARB_POINT_SPRITE },
{ STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), { STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_pointsprite_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSCALE_A), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSCALE_B), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSCALE_C), { STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, ARB_POINT_PARAMETERS },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, EXT_POINT_PARAMETERS },
{ STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), { STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TWEENFACTOR), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE), { STATE_RENDER(WINED3D_RS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
/* Samplers for NP2 texture matrix adjustions. They are not needed if GL_ARB_texture_non_power_of_two is supported,
* so register a NULL state handler in that case to get the vertex part of sampler() skipped(VTF is handled in the misc states.
* otherwise, register sampler_texmatrix, which takes care of updating the texture matrix
*/
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
};
static const struct StateEntryTemplate ffp_fragmentstate_template[] = {
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(0, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(0, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(1, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(1, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(2, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(2, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(3, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(3, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(4, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(4, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(5, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(5, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(6, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(6, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), tex_colorop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), tex_alphaop }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG1), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG2), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_ARG0), { STATE_TEXTURESTAGE(7, WINED3D_TSS_ALPHA_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_RESULT_ARG), { STATE_TEXTURESTAGE(7, WINED3D_TSS_COLOR_OP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3D_TSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), { STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), state_texfactor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGCOLOR), { STATE_RENDER(WINED3D_RS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGDENSITY), { STATE_RENDER(WINED3D_RS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGENABLE), { STATE_RENDER(WINED3D_RS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGTABLEMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), { STATE_RENDER(WINED3D_RS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGSTART), { STATE_RENDER(WINED3D_RS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3D_RS_FOGEND), { STATE_RENDER(WINED3D_RS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
};
/* Context activation is done by the caller. */
{
return shader_priv;
}
static void vp_ffp_get_caps(const struct wined3d_gl_info *gl_info, struct wined3d_vertex_caps *caps)
{
caps->raster_caps = 0;
}
const struct wined3d_vertex_pipe_ops ffp_vertex_pipe =
{
};
static void ffp_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
{
caps->wined3d_caps = 0;
caps->PrimitiveMiscCaps = 0;
{
}
{
}
}
{
{
TRACE("Checking support for fixup:\n");
}
/* We only support identity conversions. */
if (is_identity_fixup(fixup))
{
TRACE("[OK]\n");
return TRUE;
}
TRACE("[FAILED]\n");
return FALSE;
}
const struct fragment_pipeline ffp_fragment_pipeline = {
};
{
return shader_priv;
}
static void vp_none_get_caps(const struct wined3d_gl_info *gl_info, struct wined3d_vertex_caps *caps)
{
}
const struct wined3d_vertex_pipe_ops none_vertex_pipe =
{
NULL,
};
{
}
{
return is_identity_fixup(fixup);
}
const struct fragment_pipeline none_fragment_pipe =
{
NULL,
};
{
unsigned int i;
for(i = 0; funcs[i]; i++);
return i;
}
static void multistate_apply_2(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void multistate_apply_3(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id)
{
}
static void prune_invalid_states(struct StateEntry *state_table, const struct wined3d_gl_info *gl_info,
const struct wined3d_d3d_info *d3d_info)
{
{
state_table[i].representative = 0;
}
{
state_table[i].representative = 0;
}
{
state_table[i].representative = 0;
}
}
{
static const struct
{
}
rs_holes[] =
{
{ 1, 1},
{ 3, 3},
{ 17, 18},
{ 21, 21},
{ 42, 45},
{ 47, 47},
{ 61, 127},
{149, 150},
{169, 169},
{177, 177},
{196, 197},
{ 0, 0},
};
static const DWORD simple_states[] =
{
};
unsigned int i, current;
{
{
if (!state_table[i].representative)
}
else if (state_table[i].representative)
}
for (i = 0; i < sizeof(simple_states) / sizeof(*simple_states); ++i)
{
ERR("State %s (%#x) should have a representative.\n",
}
for (i = 0; i < STATE_HIGHEST + 1; ++i)
{
if (rep)
{
{
ERR("State %s (%#x) has invalid representative %s (%#x).\n",
state_table[i].representative = 0;
}
if (rep != i)
{
if (state_table[i].apply)
}
else if (!state_table[i].apply)
{
}
}
}
}
const struct StateEntryTemplate *misc)
{
const struct StateEntryTemplate *cur;
for(i = 0; i < STATE_HIGHEST + 1; i++) {
StateTable[i].representative = 0;
}
/* This switch decides the order in which the states are applied */
switch(type) {
}
if(!cur) continue;
/* GL extension filtering should not prevent multiple handlers being applied from different
* pipeline parts
*/
/* Only use the first matching state with the available extension from one template.
* e.g.
* {D3DRS_FOOBAR, {D3DRS_FOOBAR, func1}, XYZ_FANCY},
* {D3DRS_FOOBAR, {D3DRS_FOOBAR, func2}, 0 }
*
* if GL_XYZ_fancy is supported, ignore the 2nd line
*/
/* Skip state lines depending on unsupported extensions */
/* In some cases having an extension means that nothing has to be
* done for a state, e.g. if GL_ARB_texture_non_power_of_two is
* supported, the texture coordinate fixup can be ignored. If the
* apply function is used, mark the state set(done above) to prevent
* applying later lines, but do not record anything in the state
* table
*/
switch(handlers) {
case 0:
break;
case 1:
0,
sizeof(**dev_multistate_funcs) * 2);
goto out_of_mem;
}
break;
case 2:
0,
sizeof(**dev_multistate_funcs) * 3);
if (!funcs_array) {
goto out_of_mem;
}
break;
default:
ERR("Unexpected amount of state handlers for state %u: %u\n",
}
{
FIXME("State %s (%#x) has different representatives in different pipeline parts.\n",
}
}
}
return WINED3D_OK;
for (i = 0; i <= STATE_HIGHEST; ++i) {
}
return E_OUTOFMEMORY;
}