ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/wined3d/state.c

5891 lines
336 KiB
C
Raw Normal View History

wined3d: Create the state table.
2006-12-05 23:36:10 +01:00
/*
* Direct3D state management
*
wined3d: Add copyright statements to state.c.
2007-01-10 11:38:00 +01:00
* 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
wined3d: Convert source files to utf-8.
2008-10-18 19:21:20 +02:00
* Copyright 2006-2008 Stefan Dösinger for CodeWeavers
wined3d: Introduce a helper function for translating blend operations.
2011-04-03 23:35:33 +02:00
* Copyright 2009-2011 Henri Verbeet for CodeWeavers
wined3d: Create the state table.
2006-12-05 23:36:10 +01:00
*
* This library is free software; you can redistribute it and/or
* 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"
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
wined3d: Create the state table.
2006-12-05 23:36:10 +01:00
wined3d: Document functions that depend on the caller to do GL locking.
2009-05-14 19:40:56 +02:00
/* GL locking for state handlers is done by the caller. */
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blendop(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context);
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_undefined(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Don't check for a "representative" in the MarkStateDirty() functions. States without representative should never be called. Arguably they shouldn't exist in the first place, but allowing them simplifies the state table.
2009-08-21 09:12:28 +02:00
ERR("Undefined state.\n");
wined3d: Create the state table.
2006-12-05 23:36:10 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_nop(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Add an extensionless STATE_INDEXBUFFER handler.
2010-04-07 21:04:45 +02:00
{
TRACE("%s: nop in current pipe config.\n", debug_d3dstate(state));
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_fillmode(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
WINED3DFILLMODE Value = stateblock->state.render_states[WINED3DRS_FILLMODE];
wined3d: Move WINED3DRS_FILLMODE to the state table.
2006-12-05 23:45:35 +01:00
switch(Value) {
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFILL_POINT:
wined3d: Move WINED3DRS_FILLMODE to the state table.
2006-12-05 23:45:35 +01:00
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_POINT)");
break;
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFILL_WIREFRAME:
wined3d: Move WINED3DRS_FILLMODE to the state table.
2006-12-05 23:45:35 +01:00
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)");
break;
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFILL_SOLID:
wined3d: Move WINED3DRS_FILLMODE to the state table.
2006-12-05 23:45:35 +01:00
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
break;
default:
FIXME("Unrecognized WINED3DRS_FILLMODE value %d\n", Value);
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_lighting(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Lighting is calculated for vertices without normals. It still should be disabled for transformed vertices though.
2007-02-16 19:08:34 +01:00
/* Lighting is not enabled if transformed vertices are drawn
wined3d: Break the lighting state out of the vertex decl.
2007-01-02 22:49:17 +01:00
* but lighting does not affect the stream sources, so it is not grouped for performance reasons.
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
* 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
wined3d: Move WINED3DRS_LIGHTNING to the state table.
2006-12-08 01:39:55 +01:00
*/
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(isStateDirty(context, STATE_VDECL)) {
wined3d: Attempt to remove some tabs smuggled in by xcode.
2007-01-10 11:37:03 +01:00
return;
}
wined3d: Break the lighting state out of the vertex decl.
2007-01-02 22:49:17 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_LIGHTING]
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
&& !stateblock->device->strided_streams.position_transformed)
wined3d: Simplify the "transformed" check in state_lighting(). It doesn't really matter if lighting is enabled or not if we don't have position data.
2009-03-26 10:43:40 +01:00
{
wined3d: Move WINED3DRS_LIGHTNING to the state table.
2006-12-08 01:39:55 +01:00
glEnable(GL_LIGHTING);
checkGLcall("glEnable GL_LIGHTING");
} else {
glDisable(GL_LIGHTING);
checkGLcall("glDisable GL_LIGHTING");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_zenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Disable depth stencil related states without a depth stencil buffer. Except with fbos, it is not possible to remove the depth stencil buffer from the opengl frame buffer, so when the d3d app sets a NULL depth stencil disable all states that work with the depth stencil buffer.
2007-03-06 13:54:05 +01:00
/* No z test without depth stencil buffers */
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
if (!stateblock->device->fb.depth_stencil)
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
{
wined3d: Depth stencil fixes.
2007-11-10 00:19:19 +01:00
TRACE("No Z buffer - disabling depth test\n");
wined3d: Disable depth stencil related states without a depth stencil buffer. Except with fbos, it is not possible to remove the depth stencil buffer from the opengl frame buffer, so when the d3d app sets a NULL depth stencil disable all states that work with the depth stencil buffer.
2007-03-06 13:54:05 +01:00
glDisable(GL_DEPTH_TEST); /* This also disables z writing in gl */
checkGLcall("glDisable GL_DEPTH_TEST");
return;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
switch (stateblock->state.render_states[WINED3DRS_ZENABLE])
{
wined3d: Move WINED3DRS_ZENABLE to the state table.
2006-12-08 01:40:51 +01:00
case WINED3DZB_FALSE:
glDisable(GL_DEPTH_TEST);
checkGLcall("glDisable GL_DEPTH_TEST");
break;
case WINED3DZB_TRUE:
glEnable(GL_DEPTH_TEST);
checkGLcall("glEnable GL_DEPTH_TEST");
break;
case WINED3DZB_USEW:
glEnable(GL_DEPTH_TEST);
checkGLcall("glEnable GL_DEPTH_TEST");
FIXME("W buffer is not well handled\n");
break;
default:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
FIXME("Unrecognized D3DZBUFFERTYPE value %#x.\n",
stateblock->state.render_states[WINED3DRS_ZENABLE]);
wined3d: Move WINED3DRS_ZENABLE to the state table.
2006-12-08 01:40:51 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_cullmode(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
/* glFrontFace() is set in context.c at context init and on an
* offscreen / onscreen rendering switch. */
switch (stateblock->state.render_states[WINED3DRS_CULLMODE])
{
wined3d: Move WINED3DRS_CULLMODE to the state table.
2006-12-08 01:41:43 +01:00
case WINED3DCULL_NONE:
glDisable(GL_CULL_FACE);
checkGLcall("glDisable GL_CULL_FACE");
break;
case WINED3DCULL_CW:
glEnable(GL_CULL_FACE);
checkGLcall("glEnable GL_CULL_FACE");
wined3d: Untie culling and offscreen rendering.
2007-09-18 11:43:09 +02:00
glCullFace(GL_FRONT);
checkGLcall("glCullFace(GL_FRONT)");
wined3d: Move WINED3DRS_CULLMODE to the state table.
2006-12-08 01:41:43 +01:00
break;
case WINED3DCULL_CCW:
glEnable(GL_CULL_FACE);
checkGLcall("glEnable GL_CULL_FACE");
glCullFace(GL_BACK);
wined3d: Untie culling and offscreen rendering.
2007-09-18 11:43:09 +02:00
checkGLcall("glCullFace(GL_BACK)");
wined3d: Move WINED3DRS_CULLMODE to the state table.
2006-12-08 01:41:43 +01:00
break;
default:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
FIXME("Unrecognized/Unhandled WINED3DCULL value %#x.\n",
stateblock->state.render_states[WINED3DRS_CULLMODE]);
wined3d: Move WINED3DRS_CULLMODE to the state table.
2006-12-08 01:41:43 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_shademode(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
switch (stateblock->state.render_states[WINED3DRS_SHADEMODE])
{
wined3d: Move WINED3DRS_SHADEMODE to the state table.
2006-12-08 01:42:16 +01:00
case WINED3DSHADE_FLAT:
glShadeModel(GL_FLAT);
checkGLcall("glShadeModel(GL_FLAT)");
break;
case WINED3DSHADE_GOURAUD:
glShadeModel(GL_SMOOTH);
checkGLcall("glShadeModel(GL_SMOOTH)");
break;
case WINED3DSHADE_PHONG:
FIXME("WINED3DSHADE_PHONG isn't supported\n");
break;
default:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
FIXME("Unrecognized/Unhandled WINED3DSHADEMODE value %#x.\n",
stateblock->state.render_states[WINED3DRS_SHADEMODE]);
wined3d: Move WINED3DRS_SHADEMODE to the state table.
2006-12-08 01:42:16 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_ditherenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_DITHERENABLE])
{
wined3d: Move WINED3DRS_DITHERENABLE to the state table.
2006-12-08 01:42:43 +01:00
glEnable(GL_DITHER);
checkGLcall("glEnable GL_DITHER");
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
else
{
wined3d: Move WINED3DRS_DITHERENABLE to the state table.
2006-12-08 01:42:43 +01:00
glDisable(GL_DITHER);
checkGLcall("glDisable GL_DITHER");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_zwritenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
/* TODO: Test if in d3d z writing is enabled even if ZENABLE is off.
* If yes, this has to be merged with ZENABLE and ZFUNC. */
if (stateblock->state.render_states[WINED3DRS_ZWRITEENABLE])
{
wined3d: Move WINED3DRS_ZWRITEENABLE to the state table.
2006-12-08 01:43:25 +01:00
glDepthMask(1);
checkGLcall("glDepthMask(1)");
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
else
{
wined3d: Move WINED3DRS_ZWRITEENABLE to the state table.
2006-12-08 01:43:25 +01:00
glDepthMask(0);
checkGLcall("glDepthMask(0)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_zfunc(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
GLenum depth_func = CompareFunc(stateblock->state.render_states[WINED3DRS_ZFUNC]);
wined3d: Move WINED3DRS_ZFUNCENABLE to the state table.
2006-12-08 01:44:55 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (!depth_func) return;
wined3d: Add a fixme for D3DCMP_NOTEQUAL and D3DCMP_EQUAL.
2007-09-11 15:33:14 +02:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (depth_func == GL_EQUAL || depth_func == GL_NOTEQUAL)
{
static BOOL once;
/* There are a few issues with this: First, our inability to
* select a proper Z depth, most of the time we're stuck with
* D24S8, even if the app selects D32 or D16. There seem to be
* some other precision problems which have to be debugged to
* make NOTEQUAL and EQUAL work properly. */
if (!once)
{
once = TRUE;
FIXME("D3DCMP_NOTEQUAL and D3DCMP_EQUAL do not work correctly yet.\n");
}
wined3d: Move WINED3DRS_ZFUNCENABLE to the state table.
2006-12-08 01:44:55 +01:00
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
glDepthFunc(depth_func);
checkGLcall("glDepthFunc");
wined3d: Move WINED3DRS_ZFUNCENABLE to the state table.
2006-12-08 01:44:55 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_ambient(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
Revert "wined3d: Where possible, avoid using D3DCOLORTOGLFLOAT4." This reverts commit 045975b1f439049da9405a8defbad82a39710f49.
2006-12-29 11:35:57 +01:00
float col[4];
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_AMBIENT], col);
wined3d: Move WINED3DRS_AMBIENT to the state table.
2006-12-08 01:45:26 +01:00
Revert "wined3d: Where possible, avoid using D3DCOLORTOGLFLOAT4." This reverts commit 045975b1f439049da9405a8defbad82a39710f49.
2006-12-29 11:35:57 +01:00
TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
wined3d: Move WINED3DRS_AMBIENT to the state table.
2006-12-08 01:45:26 +01:00
checkGLcall("glLightModel for MODEL_AMBIENT");
}
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
static GLenum gl_blend_factor(WINED3DBLEND factor, const struct wined3d_format *dst_format)
{
switch (factor)
{
case WINED3DBLEND_ZERO:
return GL_ZERO;
case WINED3DBLEND_ONE:
return GL_ONE;
case WINED3DBLEND_SRCCOLOR:
return GL_SRC_COLOR;
case WINED3DBLEND_INVSRCCOLOR:
return GL_ONE_MINUS_SRC_COLOR;
case WINED3DBLEND_SRCALPHA:
return GL_SRC_ALPHA;
case WINED3DBLEND_INVSRCALPHA:
return GL_ONE_MINUS_SRC_ALPHA;
case WINED3DBLEND_DESTCOLOR:
return GL_DST_COLOR;
case WINED3DBLEND_INVDESTCOLOR:
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
Assorted spelling and case fixes.
2011-05-09 09:03:40 +02:00
* doesn't support alpha blending. A nonexistent alpha channel
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
* returns 1.0, so WINED3DBLEND_DESTALPHA becomes GL_ONE, and
* WINED3DBLEND_INVDESTALPHA becomes GL_ZERO. */
case WINED3DBLEND_DESTALPHA:
return dst_format->alpha_mask ? GL_DST_ALPHA : GL_ONE;
case WINED3DBLEND_INVDESTALPHA:
return dst_format->alpha_mask ? GL_ONE_MINUS_DST_ALPHA : GL_ZERO;
case WINED3DBLEND_SRCALPHASAT:
return GL_SRC_ALPHA_SATURATE;
case WINED3DBLEND_BLENDFACTOR:
return GL_CONSTANT_COLOR_EXT;
case WINED3DBLEND_INVBLENDFACTOR:
return GL_ONE_MINUS_CONSTANT_COLOR_EXT;
default:
FIXME("Unhandled blend factor %#x.\n", factor);
return GL_NONE;
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blend(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
struct wined3d_surface *target = stateblock->device->fb.render_targets[0];
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
GLenum srcBlend, dstBlend;
WINED3DBLEND d3d_blend;
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
/* According to the red book, GL_LINE_SMOOTH needs GL_BLEND with specific
* blending parameters to work. */
if (stateblock->state.render_states[WINED3DRS_ALPHABLENDENABLE]
|| stateblock->state.render_states[WINED3DRS_EDGEANTIALIAS]
|| stateblock->state.render_states[WINED3DRS_ANTIALIASEDLINEENABLE])
{
/* Disable blending in all cases even without pixelshaders.
* With blending on we could face a big performance penalty.
wined3d: Fix a postpixelshader_blending bug.
2008-03-29 15:48:15 +01:00
* The d3d9 visual test confirms the behavior. */
wined3d: Only disable blending for offscreen targets.
2009-12-09 11:51:19 +01:00
if (context->render_offscreen
wined3d: Rename the wined3d_format "Flags" field to "flags".
2010-11-12 13:12:05 +01:00
&& !(target->resource.format->flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING))
wined3d: Get rid of some calls to getFormatDescEntry(). Use the format description stored in the resource instead.
2009-03-12 09:53:15 +01:00
{
wined3d: Initial post pixelshader blending support. [attempt 2]. For each pixel format we store a flag in the table whether it supports post pixelshader blending. Before applying blending or during a context switch we verify that blending is turned off for the format. In case of R32F this gave a 5-6x performance boost (without filtering and software conversion).
2008-03-28 10:02:39 +01:00
glDisable(GL_BLEND);
checkGLcall("glDisable GL_BLEND");
return;
} else {
glEnable(GL_BLEND);
checkGLcall("glEnable GL_BLEND");
}
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
} else {
glDisable(GL_BLEND);
checkGLcall("glDisable GL_BLEND");
/* Nothing more to do - get out */
return;
};
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
/* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
d3d_blend = stateblock->state.render_states[WINED3DRS_SRCBLEND];
if (d3d_blend == WINED3DBLEND_BOTHSRCALPHA)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
srcBlend = GL_SRC_ALPHA;
dstBlend = GL_ONE_MINUS_SRC_ALPHA;
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
}
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
else if (d3d_blend == WINED3DBLEND_BOTHINVSRCALPHA)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
srcBlend = GL_ONE_MINUS_SRC_ALPHA;
dstBlend = GL_SRC_ALPHA;
}
else
{
srcBlend = gl_blend_factor(d3d_blend, target->resource.format);
dstBlend = gl_blend_factor(stateblock->state.render_states[WINED3DRS_DESTBLEND],
target->resource.format);
wined3d: FIX D3DBLEND_BOTHSRCALPHA and BLEND_BOTHINVSRCALPHA.
2007-08-12 21:44:30 +02:00
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_EDGEANTIALIAS]
|| stateblock->state.render_states[WINED3DRS_ANTIALIASEDLINEENABLE])
{
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
glEnable(GL_LINE_SMOOTH);
checkGLcall("glEnable(GL_LINE_SMOOTH)");
if(srcBlend != GL_SRC_ALPHA) {
wined3d: Don't modify the blending parameters in state_blend().
2007-07-23 21:35:15 +02:00
WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected src blending param\n");
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
}
wined3d: Don't modify the blending parameters in state_blend().
2007-07-23 21:35:15 +02:00
if(dstBlend != GL_ONE_MINUS_SRC_ALPHA && dstBlend != GL_ONE) {
WARN("WINED3DRS_EDGEANTIALIAS enabled, but unexpected dst blending param\n");
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
}
} else {
glDisable(GL_LINE_SMOOTH);
checkGLcall("glDisable(GL_LINE_SMOOTH)");
}
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
/* Re-apply BLENDOP(ALPHA) because of a possible SEPARATEALPHABLENDENABLE change */
if(!isStateDirty(context, STATE_RENDER(WINED3DRS_BLENDOP))) {
state_blendop(STATE_RENDER(WINED3DRS_BLENDOPALPHA), stateblock, context);
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SEPARATEALPHABLENDENABLE])
{
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
GLenum srcBlendAlpha, dstBlendAlpha;
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
/* Separate alpha blending requires GL_EXT_blend_function_separate, so make sure it is around */
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (!context->gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
{
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
WARN("Unsupported in local OpenGL implementation: glBlendFuncSeparateEXT\n");
return;
}
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
/* WINED3DBLEND_BOTHSRCALPHA and WINED3DBLEND_BOTHINVSRCALPHA are legacy
* source blending values which are still valid up to d3d9. They should
* not occur as dest blend values. */
d3d_blend = stateblock->state.render_states[WINED3DRS_SRCBLENDALPHA];
if (d3d_blend == WINED3DBLEND_BOTHSRCALPHA)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
srcBlendAlpha = GL_SRC_ALPHA;
dstBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
}
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
else if (d3d_blend == WINED3DBLEND_BOTHINVSRCALPHA)
{
srcBlendAlpha = GL_ONE_MINUS_SRC_ALPHA;
dstBlendAlpha = GL_SRC_ALPHA;
}
else
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Introduce a helper function for translating blend factors.
2011-05-05 20:56:08 +02:00
srcBlendAlpha = gl_blend_factor(d3d_blend, target->resource.format);
dstBlendAlpha = gl_blend_factor(stateblock->state.render_states[WINED3DRS_DESTBLENDALPHA],
target->resource.format);
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
}
GL_EXTCALL(glBlendFuncSeparateEXT(srcBlend, dstBlend, srcBlendAlpha, dstBlendAlpha));
checkGLcall("glBlendFuncSeparateEXT");
} else {
TRACE("glBlendFunc src=%x, dst=%x\n", srcBlend, dstBlend);
glBlendFunc(srcBlend, dstBlend);
checkGLcall("glBlendFunc");
}
wined3d: Change colorkey fixup for stage 0 alphaop / alphaarg.
2008-01-21 05:17:49 +01:00
/* colorkey fixup for stage 0 alphaop depends on WINED3DRS_ALPHABLENDENABLE state,
so it may need updating */
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_COLORKEYENABLE])
wined3d: Don't call directly into the state table.
2010-04-01 11:34:44 +02:00
stateblock_apply_state(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
wined3d: D3DRS_BLENDFACTOR should not influence glBlend(TRUE/FALSE).
2006-12-25 18:46:59 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blendfactor_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
WARN("Unsupported in local OpenGL implementation: glBlendColorEXT\n");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blendfactor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: D3DRS_BLENDFACTOR should not influence glBlend(TRUE/FALSE).
2006-12-25 18:46:59 +01:00
float col[4];
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
TRACE("Setting blend factor to %#x.\n", stateblock->state.render_states[WINED3DRS_BLENDFACTOR]);
D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_BLENDFACTOR], col);
wined3d: Use EXT-versions of glBlend*.
2007-10-06 17:42:39 +02:00
GL_EXTCALL(glBlendColorEXT (col[0],col[1],col[2],col[3]));
wined3d: Move blending related states to the state table.
2006-12-08 01:51:11 +01:00
checkGLcall("glBlendColor");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_alpha(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
int glParm = 0;
float ref;
BOOL enable_ckey = FALSE;
wined3d: Add some traces to state handlers. Should make it a bit clearer what's happening in some cases.
2009-02-19 08:53:50 +01:00
TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
/* 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 WINED3DRS_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.
*/
wined3d: Move texture bindings to wined3d_state.
2010-09-17 11:59:40 +02:00
if (stateblock->state.textures[0])
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
{
wined3d: Get rid of the IWineD3DBaseTexture typedefs.
2011-03-18 19:11:00 +01:00
struct wined3d_texture *texture = stateblock->state.textures[0];
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
GLenum texture_dimensions = texture->target;
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
{
wined3d: Get rid of the IWineD3DSurface typedefs.
2011-04-29 13:03:42 +02:00
struct wined3d_surface *surf = surface_from_resource(texture->sub_resources[0]);
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
if (surf->CKeyFlags & WINEDDSD_CKSRCBLT)
{
/* The surface conversion does not do color keying conversion for surfaces that have an alpha
* channel on their own. Likewise, the alpha test shouldn't be set up for color keying if the
* surface has alpha bits */
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
if (!surf->resource.format->alpha_mask) enable_ckey = TRUE;
wined3d: Enable color keying only for surfaces without an alpha channel.
2007-02-15 03:05:54 +01:00
}
}
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
}
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
if (enable_ckey || context->last_was_ckey)
wined3d: Don't call directly into the state table.
2010-04-01 11:34:44 +02:00
stateblock_apply_state(STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), stateblock, context);
wined3d: alphaop fixes for color keying.
2007-02-15 03:04:18 +01:00
context->last_was_ckey = enable_ckey;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ALPHATESTENABLE]
|| (stateblock->state.render_states[WINED3DRS_COLORKEYENABLE] && enable_ckey))
{
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
glEnable(GL_ALPHA_TEST);
checkGLcall("glEnable GL_ALPHA_TEST");
} else {
glDisable(GL_ALPHA_TEST);
checkGLcall("glDisable GL_ALPHA_TEST");
/* Alpha test is disabled, don't bother setting the params - it will happen on the next
* enable call
*/
return;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_COLORKEYENABLE] && enable_ckey)
{
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
glParm = GL_NOTEQUAL;
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
ref = 0.0f;
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
} else {
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
ref = ((float)stateblock->state.render_states[WINED3DRS_ALPHAREF]) / 255.0f;
glParm = CompareFunc(stateblock->state.render_states[WINED3DRS_ALPHAFUNC]);
wined3d: Move alpha states to the state table.
2006-12-08 20:21:32 +01:00
}
if(glParm) {
glAlphaFunc(glParm, ref);
checkGLcall("glAlphaFunc");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_clipping(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Move clipping states to the state table.
2006-12-08 18:01:23 +01:00
DWORD enable = 0xFFFFFFFF;
DWORD disable = 0x00000000;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (!stateblock->device->vs_clipping && use_vs(state))
wined3d: Make use_vs() and use_ps() work on a stateblock instead of a device. Most callers work on a stateblock rather than a device, and the main fields we check (vertexShader and pixelShader) are part of the stateblock as well.
2008-12-30 14:56:49 +01:00
{
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
/* The spec says that opengl 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
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
* conditions I got sick of tracking down. The shader state handler disables all clip planes because
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
* of that - don't do anything here and keep them disabled
*/
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->render_states[WINED3DRS_CLIPPLANEENABLE])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
static BOOL warned = FALSE;
if(!warned) {
FIXME("Clipping not supported with vertex shaders\n");
warned = TRUE;
}
}
return;
}
Assorted spelling fixes.
2007-06-07 11:48:55 +02:00
/* TODO: Keep track of previously enabled clipplanes to avoid unnecessary resetting
wined3d: Move clipping states to the state table.
2006-12-08 18:01:23 +01:00
* of already set values
*/
/* If enabling / disabling all
* TODO: Is this correct? Doesn't D3DRS_CLIPPING disable clipping on the viewport frustrum?
*/
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->render_states[WINED3DRS_CLIPPING])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
enable = state->render_states[WINED3DRS_CLIPPLANEENABLE];
disable = ~state->render_states[WINED3DRS_CLIPPLANEENABLE];
wined3d: Don't clamp vertex depth values. Since we report D3DPMISCCAPS_CLIPTLVERTS.
2011-06-05 22:48:50 +02:00
}
else
{
wined3d: Move clipping states to the state table.
2006-12-08 18:01:23 +01:00
disable = 0xffffffff;
enable = 0x00;
}
if (enable & WINED3DCLIPPLANE0) { glEnable(GL_CLIP_PLANE0); checkGLcall("glEnable(clip plane 0)"); }
if (enable & WINED3DCLIPPLANE1) { glEnable(GL_CLIP_PLANE1); checkGLcall("glEnable(clip plane 1)"); }
if (enable & WINED3DCLIPPLANE2) { glEnable(GL_CLIP_PLANE2); checkGLcall("glEnable(clip plane 2)"); }
if (enable & WINED3DCLIPPLANE3) { glEnable(GL_CLIP_PLANE3); checkGLcall("glEnable(clip plane 3)"); }
if (enable & WINED3DCLIPPLANE4) { glEnable(GL_CLIP_PLANE4); checkGLcall("glEnable(clip plane 4)"); }
if (enable & WINED3DCLIPPLANE5) { glEnable(GL_CLIP_PLANE5); checkGLcall("glEnable(clip plane 5)"); }
if (disable & WINED3DCLIPPLANE0) { glDisable(GL_CLIP_PLANE0); checkGLcall("glDisable(clip plane 0)"); }
if (disable & WINED3DCLIPPLANE1) { glDisable(GL_CLIP_PLANE1); checkGLcall("glDisable(clip plane 1)"); }
if (disable & WINED3DCLIPPLANE2) { glDisable(GL_CLIP_PLANE2); checkGLcall("glDisable(clip plane 2)"); }
if (disable & WINED3DCLIPPLANE3) { glDisable(GL_CLIP_PLANE3); checkGLcall("glDisable(clip plane 3)"); }
if (disable & WINED3DCLIPPLANE4) { glDisable(GL_CLIP_PLANE4); checkGLcall("glDisable(clip plane 4)"); }
if (disable & WINED3DCLIPPLANE5) { glDisable(GL_CLIP_PLANE5); checkGLcall("glDisable(clip plane 5)"); }
/** update clipping status */
wined3d: Move clip status to wined3d_state.
2010-09-21 21:20:56 +02:00
if (enable)
{
stateblock->state.clip_status.ClipUnion = 0;
stateblock->state.clip_status.ClipIntersection = 0xFFFFFFFF;
}
else
{
stateblock->state.clip_status.ClipUnion = 0;
stateblock->state.clip_status.ClipIntersection = 0;
wined3d: Move clipping states to the state table.
2006-12-08 18:01:23 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blendop_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
WARN("Unsupported in local OpenGL implementation: glBlendEquation\n");
}
wined3d: Introduce a helper function for translating blend operations.
2011-04-03 23:35:33 +02:00
static GLenum gl_blend_op(WINED3DBLENDOP op)
{
switch (op)
{
case WINED3DBLENDOP_ADD:
return GL_FUNC_ADD_EXT;
case WINED3DBLENDOP_SUBTRACT:
return GL_FUNC_SUBTRACT_EXT;
case WINED3DBLENDOP_REVSUBTRACT:
return GL_FUNC_REVERSE_SUBTRACT_EXT;
case WINED3DBLENDOP_MIN:
return GL_MIN_EXT;
case WINED3DBLENDOP_MAX:
return GL_MAX_EXT;
default:
FIXME("Unhandled blend op %#x.\n", op);
return GL_NONE;
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_blendop(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Fix the EXT_blend_minmax extension definitions.
2011-03-31 20:04:43 +02:00
int blendEquation = GL_FUNC_ADD_EXT;
int blendEquationAlpha = GL_FUNC_ADD_EXT;
wined3d: Move WINED3DRS_BLENDOP to the state table.
2006-12-08 20:21:43 +01:00
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
/* BLENDOPALPHA requires GL_EXT_blend_equation_separate, so make sure it is around */
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_BLENDOPALPHA]
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
&& !gl_info->supported[EXT_BLEND_EQUATION_SEPARATE])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
WARN("Unsupported in local OpenGL implementation: glBlendEquationSeparateEXT\n");
return;
}
wined3d: Introduce a helper function for translating blend operations.
2011-04-03 23:35:33 +02:00
blendEquation = gl_blend_op(stateblock->state.render_states[WINED3DRS_BLENDOP]);
blendEquationAlpha = gl_blend_op(stateblock->state.render_states[WINED3DRS_BLENDOPALPHA]);
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SEPARATEALPHABLENDENABLE])
{
wined3d: Add separate alpha blend support.
2008-02-16 16:42:11 +01:00
TRACE("glBlendEquationSeparateEXT(%x, %x)\n", blendEquation, blendEquationAlpha);
GL_EXTCALL(glBlendEquationSeparateEXT(blendEquation, blendEquationAlpha));
checkGLcall("glBlendEquationSeparateEXT");
} else {
TRACE("glBlendEquation(%x)\n", blendEquation);
GL_EXTCALL(glBlendEquationEXT(blendEquation));
checkGLcall("glBlendEquation");
}
wined3d: Move WINED3DRS_BLENDOP to the state table.
2006-12-08 20:21:43 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_specularenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
/* Originally this used glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR)
* and (GL_LIGHT_MODEL_COLOR_CONTROL,GL_SINGLE_COLOR) to swap between enabled/disabled
* 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 WINED3DRS_SPECULARENABLE is enabled or not.
*/
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
TRACE("Setting specular enable state and materials\n");
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SPECULARENABLE])
{
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&stateblock->state.material.Specular);
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
checkGLcall("glMaterialfv");
wined3d: Clamp material power to 128.0.
2007-06-15 22:38:14 +02:00
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
if (stateblock->state.material.Power > gl_info->limits.shininess)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Clamp material power to 128.0.
2007-06-15 22:38:14 +02:00
/* glMaterialf man page says that the material says that GL_SHININESS must be between 0.0
wined3d: Support shininess > 128 if opengl does.
2008-03-02 00:02:18 +01:00
* and 128.0, although in d3d neither -1 nor 129 produce an error. GL_NV_max_light_exponent
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
* 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
Spelling fixes.
2008-04-22 08:18:14 +02:00
* them, it should be safe to do so without major visual distortions.
wined3d: Clamp material power to 128.0.
2007-06-15 22:38:14 +02:00
*/
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
WARN("Material power = %f, limit %f\n", stateblock->state.material.Power, gl_info->limits.shininess);
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, gl_info->limits.shininess);
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
}
else
{
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, stateblock->state.material.Power);
wined3d: Clamp material power to 128.0.
2007-06-15 22:38:14 +02:00
}
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glMaterialf(GL_SHININESS)");
wined3d: Clamp material power to 128.0.
2007-06-15 22:38:14 +02:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_SECONDARY_COLOR])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
glEnable(GL_COLOR_SUM_EXT);
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
TRACE("Specular colors cannot be enabled in this version of opengl\n");
}
checkGLcall("glEnable(GL_COLOR_SUM)");
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_REGISTER_COMBINERS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_PLUS_SECONDARY_COLOR_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
checkGLcall("glFinalCombinerInputNV()");
}
} else {
wined3d: Make some constant arrays also static. As pointed out by Dan Kegel.
2008-12-10 10:04:40 +01:00
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
/* for the case of enabled lighting: */
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
checkGLcall("glMaterialfv");
/* for the case of disabled lighting: */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_SECONDARY_COLOR])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
glDisable(GL_COLOR_SUM_EXT);
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
TRACE("Specular colors cannot be disabled in this version of opengl\n");
}
checkGLcall("glDisable(GL_COLOR_SUM)");
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_REGISTER_COMBINERS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
GL_EXTCALL(glFinalCombinerInputNV(GL_VARIABLE_B_NV, GL_SPARE0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB));
checkGLcall("glFinalCombinerInputNV()");
}
}
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
TRACE("(%p) : Diffuse {%.8e, %.8e, %.8e, %.8e}\n", stateblock->device,
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
stateblock->state.material.Diffuse.r, stateblock->state.material.Diffuse.g,
stateblock->state.material.Diffuse.b, stateblock->state.material.Diffuse.a);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
TRACE("(%p) : Ambient {%.8e, %.8e, %.8e, %.8e}\n", stateblock->device,
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
stateblock->state.material.Ambient.r, stateblock->state.material.Ambient.g,
stateblock->state.material.Ambient.b, stateblock->state.material.Ambient.a);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
TRACE("(%p) : Specular {%.8e, %.8e, %.8e, %.8e}\n", stateblock->device,
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
stateblock->state.material.Specular.r, stateblock->state.material.Specular.g,
stateblock->state.material.Specular.b, stateblock->state.material.Specular.a);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
TRACE("(%p) : Emissive {%.8e, %.8e, %.8e, %.8e}\n", stateblock->device,
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
stateblock->state.material.Emissive.r, stateblock->state.material.Emissive.g,
stateblock->state.material.Emissive.b, stateblock->state.material.Emissive.a);
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&stateblock->state.material.Ambient);
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
checkGLcall("glMaterialfv(GL_AMBIENT)");
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&stateblock->state.material.Diffuse);
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
checkGLcall("glMaterialfv(GL_DIFFUSE)");
wined3d: Move the material to wined3d_state.
2010-09-16 11:19:55 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&stateblock->state.material.Emissive);
wined3d: Move material applying to the state table.
2007-06-15 21:33:54 +02:00
checkGLcall("glMaterialfv(GL_EMISSION)");
wined3d: Move WINED3DRS_SPECULARENABLE to the state table.
2006-12-08 18:38:30 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_texfactor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Move WINED3DRS_TEXTUREFACTOR to the state table.
2006-12-08 18:37:17 +01:00
unsigned int i;
/* Note the texture color applies to all textures whereas
* GL_TEXTURE_ENV_COLOR applies to active only
*/
Revert "wined3d: Where possible, avoid using D3DCOLORTOGLFLOAT4." This reverts commit 045975b1f439049da9405a8defbad82a39710f49.
2006-12-29 11:35:57 +01:00
float col[4];
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_TEXTUREFACTOR], col);
wined3d: Move WINED3DRS_TEXTUREFACTOR to the state table.
2006-12-08 18:37:17 +01:00
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
/* And now the default texture color as well */
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
for (i = 0; i < gl_info->limits.texture_stages; ++i)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
/* Note the WINED3DRS value applies to all textures, but GL has one
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
* per texture, so apply it now ready to be used!
*/
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + i));
checkGLcall("glActiveTextureARB");
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
wined3d: Move WINED3DRS_TEXTUREFACTOR to the state table.
2006-12-08 18:37:17 +01:00
}
}
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
static void renderstate_stencil_twosided(struct wined3d_context *context, GLint face,
GLint func, GLint ref, GLuint mask, GLint stencilFail, GLint depthFail, GLint stencilPass)
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Fix the GL_ATI_separate_stencil codepath. glStencilFuncSeparateATI does not take a face argument, instead it sets the front and back facing functions at once. This means the renderstate_stencil_twosided helper function is somewhat pointless for this extension.
2008-04-23 21:53:59 +02:00
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
checkGLcall("glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
GL_EXTCALL(glActiveStencilFaceEXT(face));
checkGLcall("glActiveStencilFaceEXT(...)");
glStencilFunc(func, ref, mask);
checkGLcall("glStencilFunc(...)");
glStencilOp(stencilFail, depthFail, stencilPass);
checkGLcall("glStencilOp(...)");
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_stencil(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
DWORD onesided_enable = FALSE;
DWORD twosided_enable = FALSE;
GLint func = GL_ALWAYS;
GLint func_ccw = GL_ALWAYS;
GLint ref = 0;
GLuint mask = 0;
GLint stencilFail = GL_KEEP;
GLint depthFail = GL_KEEP;
GLint stencilPass = GL_KEEP;
GLint stencilFail_ccw = GL_KEEP;
GLint depthFail_ccw = GL_KEEP;
GLint stencilPass_ccw = GL_KEEP;
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
/* No stencil test without a stencil buffer. */
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
if (!stateblock->device->fb.depth_stencil)
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
{
wined3d: Disable depth stencil related states without a depth stencil buffer. Except with fbos, it is not possible to remove the depth stencil buffer from the opengl frame buffer, so when the d3d app sets a NULL depth stencil disable all states that work with the depth stencil buffer.
2007-03-06 13:54:05 +01:00
glDisable(GL_STENCIL_TEST);
checkGLcall("glDisable GL_STENCIL_TEST");
return;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
onesided_enable = stateblock->state.render_states[WINED3DRS_STENCILENABLE];
twosided_enable = stateblock->state.render_states[WINED3DRS_TWOSIDEDSTENCILMODE];
if (!(func = CompareFunc(stateblock->state.render_states[WINED3DRS_STENCILFUNC])))
wined3d: Remove stateblock::set.*.
2007-07-30 19:28:33 +02:00
func = GL_ALWAYS;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (!(func_ccw = CompareFunc(stateblock->state.render_states[WINED3DRS_CCW_STENCILFUNC])))
wined3d: Fix a copypaste error.
2007-09-14 11:57:42 +02:00
func_ccw = GL_ALWAYS;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
ref = stateblock->state.render_states[WINED3DRS_STENCILREF];
mask = stateblock->state.render_states[WINED3DRS_STENCILMASK];
stencilFail = StencilOp(stateblock->state.render_states[WINED3DRS_STENCILFAIL]);
depthFail = StencilOp(stateblock->state.render_states[WINED3DRS_STENCILZFAIL]);
stencilPass = StencilOp(stateblock->state.render_states[WINED3DRS_STENCILPASS]);
stencilFail_ccw = StencilOp(stateblock->state.render_states[WINED3DRS_CCW_STENCILFAIL]);
depthFail_ccw = StencilOp(stateblock->state.render_states[WINED3DRS_CCW_STENCILZFAIL]);
stencilPass_ccw = StencilOp(stateblock->state.render_states[WINED3DRS_CCW_STENCILPASS]);
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
janitorial: Use the C standard for multiline strings.
2007-01-09 23:42:26 +01:00
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",
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
onesided_enable, twosided_enable, ref, mask,
func, stencilFail, depthFail, stencilPass,
func_ccw, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
wined3d: Enable the stencil test if two sided stencil is used.
2007-09-14 12:00:46 +02:00
if (twosided_enable && onesided_enable) {
glEnable(GL_STENCIL_TEST);
checkGLcall("glEnable GL_STENCIL_TEST");
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_STENCIL_TWO_SIDE])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Fix the GL_ATI_separate_stencil codepath. glStencilFuncSeparateATI does not take a face argument, instead it sets the front and back facing functions at once. This means the renderstate_stencil_twosided helper function is somewhat pointless for this extension.
2008-04-23 21:53:59 +02:00
/* 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
*/
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
renderstate_stencil_twosided(context, GL_BACK,
func_ccw, ref, mask, stencilFail_ccw, depthFail_ccw, stencilPass_ccw);
renderstate_stencil_twosided(context, GL_FRONT,
func, ref, mask, stencilFail, depthFail, stencilPass);
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
else if (gl_info->supported[ATI_SEPARATE_STENCIL])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Fix the GL_ATI_separate_stencil codepath. glStencilFuncSeparateATI does not take a face argument, instead it sets the front and back facing functions at once. This means the renderstate_stencil_twosided helper function is somewhat pointless for this extension.
2008-04-23 21:53:59 +02:00
GL_EXTCALL(glStencilFuncSeparateATI(func, func_ccw, ref, mask));
checkGLcall("glStencilFuncSeparateATI(...)");
GL_EXTCALL(glStencilOpSeparateATI(GL_FRONT, stencilFail, depthFail, stencilPass));
checkGLcall("glStencilOpSeparateATI(GL_FRONT, ...)");
GL_EXTCALL(glStencilOpSeparateATI(GL_BACK, stencilFail_ccw, depthFail_ccw, stencilPass_ccw));
checkGLcall("glStencilOpSeparateATI(GL_BACK, ...)");
} else {
ERR("Separate (two sided) stencil not supported on this version of opengl. Caps weren't honored?\n");
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else if(onesided_enable)
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_STENCIL_TWO_SIDE])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Disable two sided stencil if it is supported, but not enabled.
2007-09-14 12:02:56 +02:00
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
checkGLcall("glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT)");
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
}
wined3d: Disable two sided stencil if it is supported, but not enabled.
2007-09-14 12:02:56 +02:00
wined3d: Fix the GL_ATI_separate_stencil codepath. glStencilFuncSeparateATI does not take a face argument, instead it sets the front and back facing functions at once. This means the renderstate_stencil_twosided helper function is somewhat pointless for this extension.
2008-04-23 21:53:59 +02:00
/* 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
*/
wined3d: Disable two sided stencil if it is supported, but not enabled.
2007-09-14 12:02:56 +02:00
glEnable(GL_STENCIL_TEST);
checkGLcall("glEnable GL_STENCIL_TEST");
glStencilFunc(func, ref, mask);
checkGLcall("glStencilFunc(...)");
glStencilOp(stencilFail, depthFail, stencilPass);
checkGLcall("glStencilOp(...)");
} else {
glDisable(GL_STENCIL_TEST);
checkGLcall("glDisable GL_STENCIL_TEST");
wined3d: Move stencil states to the state table.
2006-12-08 18:39:45 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_stencilwrite2s(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
DWORD mask = stateblock->device->fb.depth_stencil ? stateblock->state.render_states[WINED3DRS_STENCILWRITEMASK] : 0;
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Set the stencil mask for both faces.
2007-09-14 11:57:07 +02:00
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
GL_EXTCALL(glActiveStencilFaceEXT(GL_BACK));
checkGLcall("glActiveStencilFaceEXT(GL_BACK)");
glStencilMask(mask);
checkGLcall("glStencilMask");
GL_EXTCALL(glActiveStencilFaceEXT(GL_FRONT));
checkGLcall("glActiveStencilFaceEXT(GL_FRONT)");
glStencilMask(mask);
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_stencilwrite(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
DWORD mask = stateblock->device->fb.depth_stencil ? stateblock->state.render_states[WINED3DRS_STENCILWRITEMASK] : 0;
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
glStencilMask(mask);
wined3d: Move WINED3DRS_STENCILWRITEMASK to the state table.
2006-12-08 18:41:05 +01:00
checkGLcall("glStencilMask");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_fog_vertexpart(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Add some traces to state handlers. Should make it a bit clearer what's happening in some cases.
2009-02-19 08:53:50 +01:00
TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (!stateblock->state.render_states[WINED3DRS_FOGENABLE]) return;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
/* Table fog on: Never use fog coords, and use per-fragment fog */
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_FOGTABLEMODE] != WINED3DFOG_NONE)
{
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
glHint(GL_FOG_HINT, GL_NICEST);
if(context->fog_coord) {
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
context->fog_coord = FALSE;
}
return;
}
/* Otherwise use per-vertex fog in any case */
glHint(GL_FOG_HINT, GL_FASTEST);
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_FOGVERTEXMODE] == WINED3DFOG_NONE || context->last_was_rhw)
{
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
/* No fog at all, or transformed vertices: Use fog coord */
if(!context->fog_coord) {
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT)");
context->fog_coord = TRUE;
}
} else {
/* Otherwise, use the fragment depth */
if(context->fog_coord) {
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
checkGLcall("glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT)");
context->fog_coord = FALSE;
}
}
}
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void state_fogstartend(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
float fogstart, fogend;
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
union {
DWORD d;
float f;
} tmpvalue;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
switch(context->fog_source) {
case FOGSOURCE_VS:
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
fogstart = 1.0f;
fogend = 0.0f;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
break;
case FOGSOURCE_COORD:
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
fogstart = 255.0f;
fogend = 0.0f;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
break;
case FOGSOURCE_FFP:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_FOGSTART];
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
fogstart = tmpvalue.f;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_FOGEND];
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
fogend = tmpvalue.f;
/* In GL, fogstart == fogend disables fog, in D3D everything's fogged.*/
if(fogstart == fogend) {
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
fogstart = -1.0f / 0.0f;
fogend = 0.0f;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
}
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");
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
fogstart = 0.0f;
fogend = 0.0f;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
}
glFogf(GL_FOG_START, fogstart);
checkGLcall("glFogf(GL_FOG_START, fogstart)");
TRACE("Fog Start == %f\n", fogstart);
glFogf(GL_FOG_END, fogend);
checkGLcall("glFogf(GL_FOG_END, fogend)");
TRACE("Fog End == %f\n", fogend);
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void state_fog_fragpart(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
enum fogsource new_source;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
TRACE("state_id %#x, stateblock %p, context %p\n", state_id, stateblock, context);
wined3d: Add some traces to state handlers. Should make it a bit clearer what's happening in some cases.
2009-02-19 08:53:50 +01:00
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (!state->render_states[WINED3DRS_FOGENABLE])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
/* No fog? Disable it, and we're done :-) */
wined3d: Avoid hooking non-fog glEnable/glDisable calls. This prevents fallout from the GL_EXT_fog_coord emulation. glEnable and glDisable calls other than those that change GL_FOG are not hooked. The glEnableWINE and glDisableWINE functions can be used to add other hooks too if ever needed.
2008-12-15 19:38:48 +01:00
glDisableWINE(GL_FOG);
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
checkGLcall("glDisable GL_FOG");
wined3d: Leave the fog state handler after disabling fog.
2007-02-25 23:58:14 +01:00
return;
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
}
direct3d: Add a fixed function fog test.
2007-03-14 18:04:56 +01:00
/* 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
*
wined3d: Implement linear fog with pixel shader.
2007-03-22 17:32:48 +01:00
*
* 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.
*
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
* 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.
wined3d: Implement linear fog with pixel shader.
2007-03-22 17:32:48 +01:00
*
* If a fogtablemode and a fogvertexmode are specified, table fog is applied (with or
* without shaders).
direct3d: Add a fixed function fog test.
2007-03-14 18:04:56 +01:00
*/
wined3d: Implement linear fog with pixel shader.
2007-03-22 17:32:48 +01:00
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
/* 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."
*/
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->render_states[WINED3DRS_FOGTABLEMODE] == WINED3DFOG_NONE)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (use_vs(state))
{
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
glFogi(GL_FOG_MODE, GL_LINEAR);
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
new_source = FOGSOURCE_VS;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
}
else
{
switch (state->render_states[WINED3DRS_FOGVERTEXMODE])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
/* If processed vertices are used, fall through to the NONE case */
case WINED3DFOG_EXP:
if(!context->last_was_rhw) {
glFogi(GL_FOG_MODE, GL_EXP);
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
new_source = FOGSOURCE_FFP;
break;
}
/* drop through */
case WINED3DFOG_EXP2:
if(!context->last_was_rhw) {
glFogi(GL_FOG_MODE, GL_EXP2);
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
new_source = FOGSOURCE_FFP;
break;
}
/* drop through */
case WINED3DFOG_LINEAR:
if(!context->last_was_rhw) {
glFogi(GL_FOG_MODE, GL_LINEAR);
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
new_source = FOGSOURCE_FFP;
break;
}
/* drop through */
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
case WINED3DFOG_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
*/
new_source = FOGSOURCE_COORD;
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
glFogi(GL_FOG_MODE, GL_LINEAR);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
break;
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
default:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
FIXME("Unexpected WINED3DRS_FOGVERTEXMODE %#x.\n",
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
state->render_states[WINED3DRS_FOGVERTEXMODE]);
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
new_source = FOGSOURCE_FFP; /* Make the compiler happy */
}
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
}
} else {
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
new_source = FOGSOURCE_FFP;
wined3d: Move the functionality of primitiveInitState to the state table.
2007-01-02 22:47:10 +01:00
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
switch (state->render_states[WINED3DRS_FOGTABLEMODE])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFOG_EXP:
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
glFogi(GL_FOG_MODE, GL_EXP);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP)");
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
break;
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFOG_EXP2:
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
glFogi(GL_FOG_MODE, GL_EXP2);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2)");
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
break;
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFOG_LINEAR:
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
glFogi(GL_FOG_MODE, GL_LINEAR);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR)");
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
break;
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
case WINED3DFOG_NONE: /* Won't happen */
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
default:
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
FIXME("Unexpected WINED3DRS_FOGTABLEMODE %#x.\n",
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
state->render_states[WINED3DRS_FOGTABLEMODE]);
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
}
}
wined3d: Avoid hooking non-fog glEnable/glDisable calls. This prevents fallout from the GL_EXT_fog_coord emulation. glEnable and glDisable calls other than those that change GL_FOG are not hooked. The glEnableWINE and glDisableWINE functions can be used to add other hooks too if ever needed.
2008-12-15 19:38:48 +01:00
glEnableWINE(GL_FOG);
wined3d: Remove the pixelshader fogstart/fogend optimization.
2008-12-14 17:00:21 +01:00
checkGLcall("glEnable GL_FOG");
wined3d: Split the remains of state_fog.
2008-12-15 19:37:36 +01:00
if(new_source != context->fog_source) {
context->fog_source = new_source;
state_fogstartend(STATE_RENDER(WINED3DRS_FOGSTART), stateblock, context);
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
}
wined3d: Implement range based fog and advertize it correctly.
2007-08-21 12:30:22 +02:00
}
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_rangefog_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_RANGEFOGENABLE])
wined3d: Move the range fog support test to the template.
2008-07-05 22:38:43 +02:00
WARN("Range fog enabled, but not supported by this opengl implementation\n");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_rangefog(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_RANGEFOGENABLE])
{
wined3d: Move the range fog support test to the template.
2008-07-05 22:38:43 +02:00
glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV);
checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_RADIAL_NV)");
wined3d: Implement range based fog and advertize it correctly.
2007-08-21 12:30:22 +02:00
} else {
wined3d: Move the range fog support test to the template.
2008-07-05 22:38:43 +02:00
glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV);
checkGLcall("glFogi(GL_FOG_DISTANCE_MODE_NV, GL_EYE_PLANE_ABSOLUTE_NV)");
wined3d: Move fog states to the state table.
2006-12-08 18:42:43 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void state_fogcolor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
Revert "wined3d: Where possible, avoid using D3DCOLORTOGLFLOAT4." This reverts commit 045975b1f439049da9405a8defbad82a39710f49.
2006-12-29 11:35:57 +01:00
float col[4];
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
D3DCOLORTOGLFLOAT4(stateblock->state.render_states[WINED3DRS_FOGCOLOR], col);
Revert "wined3d: Where possible, avoid using D3DCOLORTOGLFLOAT4." This reverts commit 045975b1f439049da9405a8defbad82a39710f49.
2006-12-29 11:35:57 +01:00
glFogfv(GL_FOG_COLOR, &col[0]);
wined3d: Move WINED3DRS_FOGCOLOR to the state table.
2006-12-08 18:52:30 +01:00
checkGLcall("glFog GL_FOG_COLOR");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void state_fogdensity(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move wined3drs_fogdensity to the state table.
2006-12-10 16:34:45 +01:00
union {
DWORD d;
float f;
} tmpvalue;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_FOGDENSITY];
wined3d: Move wined3drs_fogdensity to the state table.
2006-12-10 16:34:45 +01:00
glFogfv(GL_FOG_DENSITY, &tmpvalue.f);
checkGLcall("glFogf(GL_FOG_DENSITY, (float) Value)");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colormat(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Don't set Parm when isDiffuseSupplied is FALSE in state_colormat(), it isn't used anyway.
2007-01-17 21:41:21 +01:00
GLenum Parm = 0;
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
Assorted spelling fixes.
2007-02-14 16:22:07 +01:00
/* Depends on the decoded vertex declaration to read the existence of diffuse data.
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
* The vertex declaration will call this function if the fixed function pipeline is used.
*/
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(isStateDirty(context, STATE_VDECL)) {
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
return;
}
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->num_untracked_materials = 0;
wined3d: Properly check if an attribute is used in state_colormat().
2009-08-24 09:27:55 +02:00
if ((device->strided_streams.use_map & (1 << WINED3D_FFP_DIFFUSE))
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
&& state->render_states[WINED3DRS_COLORVERTEX])
wined3d: Properly check if an attribute is used in state_colormat().
2009-08-24 09:27:55 +02:00
{
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
TRACE("diff %d, amb %d, emis %d, spec %d\n",
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE],
state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE],
state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE],
state->render_states[WINED3DRS_SPECULARMATERIALSOURCE]);
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_DIFFUSEMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
Parm = GL_AMBIENT_AND_DIFFUSE;
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
else
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
Parm = GL_DIFFUSE;
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
context->num_untracked_materials++;
}
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
else if (state->render_states[WINED3DRS_AMBIENTMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
Parm = GL_AMBIENT;
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->untracked_materials[context->num_untracked_materials] = GL_EMISSION;
context->num_untracked_materials++;
}
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
else if (state->render_states[WINED3DRS_EMISSIVEMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
Parm = GL_EMISSION;
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Emulate tracking of multiple material properties.
2007-06-20 14:36:32 +02:00
context->untracked_materials[context->num_untracked_materials] = GL_SPECULAR;
context->num_untracked_materials++;
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
else if (state->render_states[WINED3DRS_SPECULARMATERIALSOURCE] == WINED3DMCS_COLOR1)
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
Parm = GL_SPECULAR;
}
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
}
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
/* Nothing changed, return. */
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
if (Parm == context->tracking_parm) return;
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
wined3d: Don't set Parm when isDiffuseSupplied is FALSE in state_colormat(), it isn't used anyway.
2007-01-17 21:41:21 +01:00
if(!Parm) {
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
glDisable(GL_COLOR_MATERIAL);
checkGLcall("glDisable GL_COLOR_MATERIAL");
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
} else {
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
glColorMaterial(GL_FRONT_AND_BACK, Parm);
checkGLcall("glColorMaterial(GL_FRONT_AND_BACK, Parm)");
glEnable(GL_COLOR_MATERIAL);
checkGLcall("glEnable(GL_COLOR_MATERIAL)");
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
}
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
/* Apparently calls to glMaterialfv are ignored for properties we're
* tracking with glColorMaterial, so apply those here. */
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
switch (context->tracking_parm) {
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
case GL_AMBIENT_AND_DIFFUSE:
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&state->material.Ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&state->material.Diffuse);
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
checkGLcall("glMaterialfv");
break;
case GL_DIFFUSE:
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&state->material.Diffuse);
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
checkGLcall("glMaterialfv");
break;
case GL_AMBIENT:
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&state->material.Ambient);
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
checkGLcall("glMaterialfv");
break;
case GL_EMISSION:
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&state->material.Emissive);
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
checkGLcall("glMaterialfv");
break;
case GL_SPECULAR:
/* Only change material color if specular is enabled, otherwise it is set to black */
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
if (state->render_states[WINED3DRS_SPECULARENABLE])
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
{
wined3d: Consistently use the same stateblock in state_colormat(). These should refer to the same stateblock when we're drawing, but it's still ugly.
2010-09-23 21:33:29 +02:00
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&state->material.Specular);
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
checkGLcall("glMaterialfv");
} else {
wined3d: Make some constant arrays also static. As pointed out by Dan Kegel.
2008-12-10 10:04:40 +01:00
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
wined3d: When switching color material, apply the material we were previously tracking. This fixes a regression introduced by 329670c7f129343ef0086f76b08a40d0fd5e3242.
2007-01-17 21:41:35 +01:00
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &black[0]);
checkGLcall("glMaterialfv");
}
break;
}
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
context->tracking_parm = Parm;
wined3d: Move WINED3DRS_COLORVERTEX to the state table.
2006-12-10 22:44:18 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_linepattern(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move WINED3DRS_LINEPATTERN to the state table.
2006-12-10 23:20:01 +01:00
union {
DWORD d;
WINED3DLINEPATTERN lp;
} tmppattern;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmppattern.d = stateblock->state.render_states[WINED3DRS_LINEPATTERN];
wined3d: Move WINED3DRS_LINEPATTERN to the state table.
2006-12-10 23:20:01 +01:00
TRACE("Line pattern: repeat %d bits %x\n", tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
if (tmppattern.lp.wRepeatFactor) {
glLineStipple(tmppattern.lp.wRepeatFactor, tmppattern.lp.wLinePattern);
checkGLcall("glLineStipple(repeat, linepattern)");
glEnable(GL_LINE_STIPPLE);
checkGLcall("glEnable(GL_LINE_STIPPLE);");
} else {
glDisable(GL_LINE_STIPPLE);
checkGLcall("glDisable(GL_LINE_STIPPLE);");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_normalize(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Use 0/0/0 as normal if no normal is supplied.
2007-08-21 18:05:27 +02:00
if(isStateDirty(context, STATE_VDECL)) {
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
*/
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_NORMALIZENORMALS]
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
&& (stateblock->device->strided_streams.use_map & (1 << WINED3D_FFP_NORMAL)))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Move WINED3DRS_NORMALIZENORMALS to the state table.
2006-12-10 23:20:05 +01:00
glEnable(GL_NORMALIZE);
checkGLcall("glEnable(GL_NORMALIZE);");
} else {
glDisable(GL_NORMALIZE);
checkGLcall("glDisable(GL_NORMALIZE);");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_psizemin_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move WINED3DRS_POINTSIZE_MIN to the state table.
2006-12-10 23:20:12 +01:00
union {
DWORD d;
float f;
} tmpvalue;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MIN];
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
if (tmpvalue.f != 1.0f)
{
wined3d: Do not warn about unsupported point sizes if the default values are set.
2007-01-10 11:32:07 +01:00
FIXME("WINED3DRS_POINTSIZE_MIN not supported on this opengl, value is %f\n", tmpvalue.f);
wined3d: Move WINED3DRS_POINTSIZE_MIN to the state table.
2006-12-10 23:20:12 +01:00
}
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MAX];
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
if (tmpvalue.f != 64.0f)
{
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
FIXME("WINED3DRS_POINTSIZE_MAX not supported on this opengl, value is %f\n", tmpvalue.f);
}
wined3d: Move WINED3DRS_POINTSIZE_MIN to the state table.
2006-12-10 23:20:12 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_psizemin_ext(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
union
{
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
DWORD d;
float f;
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
} min, max;
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
min.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MIN];
max.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MAX];
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
/* Max point size trumps min point size */
if(min.f > max.f) {
min.f = max.f;
}
GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MIN_EXT, min.f);
checkGLcall("glPointParameterfEXT(...)");
GL_EXTCALL(glPointParameterfEXT)(GL_POINT_SIZE_MAX_EXT, max.f);
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
checkGLcall("glPointParameterfEXT(...)");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_psizemin_arb(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
union
{
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
DWORD d;
float f;
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
} min, max;
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
min.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MIN];
max.d = stateblock->state.render_states[WINED3DRS_POINTSIZE_MAX];
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
/* Max point size trumps min point size */
if(min.f > max.f) {
min.f = max.f;
}
wined3d: Move WINED3DRS_POINTSIZE_MAX to the state table.
2006-12-10 23:20:15 +01:00
d3d9: Test psize_min vs psize_max vs psize behavior. Add a test that checks what happens if D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN and POINTSIZE_MAX have conflicting values. D3DRS_POINTSIZE_MAX trumps D3DRS_POINTSIZE_MIN, and both MIN and MAX clamp the D3DRS_POINTSIZE value if it is outside of their range.
2008-11-07 17:02:54 +01:00
GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MIN_ARB, min.f);
checkGLcall("glPointParameterfARB(...)");
GL_EXTCALL(glPointParameterfARB)(GL_POINT_SIZE_MAX_ARB, max.f);
wined3d: Split the psizemax state handler.
2008-07-05 22:47:59 +02:00
checkGLcall("glPointParameterfARB(...)");
wined3d: Move WINED3DRS_POINTSIZE_MAX to the state table.
2006-12-10 23:20:15 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_pscale(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
/* 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 */
GLfloat att[3] = {1.0f, 0.0f, 0.0f};
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
union {
DWORD d;
float f;
} pointSize, A, B, C;
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
pointSize.d = stateblock->state.render_states[WINED3DRS_POINTSIZE];
A.d = stateblock->state.render_states[WINED3DRS_POINTSCALE_A];
B.d = stateblock->state.render_states[WINED3DRS_POINTSCALE_B];
C.d = stateblock->state.render_states[WINED3DRS_POINTSCALE_C];
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_POINTSCALEENABLE])
{
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
GLfloat scaleFactor;
wined3d: Move the viewport to wined3d_state.
2010-09-15 12:00:06 +02:00
DWORD h = stateblock->state.viewport.Height;
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (pointSize.f < gl_info->limits.pointsize_min)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
/* Minimum valid point size for OpenGL is driver specific. For Direct3D it is
wined3d: Honor the driver's min point size.
2007-11-03 15:39:22 +01:00
* 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
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
* are less than 1.0f. scale_factor = 1.0f / point_size.
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
scaleFactor = pointSize.f / gl_info->limits.pointsize_min;
wined3d: Honor the driver's min point size.
2007-11-03 15:39:22 +01:00
/* 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
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
pointSize.f = gl_info->limits.pointsize_min;
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
}
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
else if(pointSize.f > gl_info->limits.pointsize_max)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
/* 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
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
scaleFactor = pointSize.f / gl_info->limits.pointsize_max;
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
TRACE("scale: %f\n", scaleFactor);
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
pointSize.f = gl_info->limits.pointsize_max;
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
} else {
scaleFactor = 1.0f;
}
wined3d: MSVC fixes in state.c.
2010-07-28 19:07:19 +02:00
scaleFactor = powf(h * scaleFactor, 2);
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
att[0] = A.f / scaleFactor;
att[1] = B.f / scaleFactor;
att[2] = C.f / scaleFactor;
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_POINT_PARAMETERS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
GL_EXTCALL(glPointParameterfvARB)(GL_POINT_DISTANCE_ATTENUATION_ARB, att);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glPointParameterfvARB(GL_DISTANCE_ATTENUATION_ARB, ...)");
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
else if (gl_info->supported[EXT_POINT_PARAMETERS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
GL_EXTCALL(glPointParameterfvEXT)(GL_DISTANCE_ATTENUATION_EXT, att);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, ...)");
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
}
else if(stateblock->state.render_states[WINED3DRS_POINTSCALEENABLE])
{
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
WARN("POINT_PARAMETERS not supported in this version of opengl\n");
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
}
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
glPointSize(pointSize.f);
checkGLcall("glPointSize(...);");
wined3d: Move point scale render states to the state table.
2006-12-10 23:20:19 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_debug_monitor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Add a state handler for WINED3DRS_DEBUGMONITORTOKEN.
2009-08-21 09:12:27 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
WARN("token: %#x\n", stateblock->state.render_states[WINED3DRS_DEBUGMONITORTOKEN]);
wined3d: Add a state handler for WINED3DRS_DEBUGMONITORTOKEN.
2009-08-21 09:12:27 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colorwrite(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
DWORD mask0 = stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE];
DWORD mask1 = stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE1];
DWORD mask2 = stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE2];
DWORD mask3 = stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE3];
wined3d: Move WINED3DRS_COLORWRITEENABLEx to the state table.
2006-12-10 23:20:22 +01:00
TRACE("Color mask: r(%d) g(%d) b(%d) a(%d)\n",
wined3d: Don't warn about independent color write masks when the masks are all the same.
2010-03-25 22:51:25 +01:00
mask0 & WINED3DCOLORWRITEENABLE_RED ? 1 : 0,
mask0 & WINED3DCOLORWRITEENABLE_GREEN ? 1 : 0,
mask0 & WINED3DCOLORWRITEENABLE_BLUE ? 1 : 0,
mask0 & WINED3DCOLORWRITEENABLE_ALPHA ? 1 : 0);
glColorMask(mask0 & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
mask0 & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
mask0 & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
mask0 & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE);
wined3d: Move WINED3DRS_COLORWRITEENABLEx to the state table.
2006-12-10 23:20:22 +01:00
checkGLcall("glColorMask(...)");
wined3d: Don't warn about independent color write masks when the masks are all the same.
2010-03-25 22:51:25 +01:00
if (!((mask1 == mask0 && mask2 == mask0 && mask3 == mask0)
|| (mask1 == 0xf && mask2 == 0xf && mask3 == 0xf)))
{
FIXME("WINED3DRS_COLORWRITEENABLE/1/2/3, %#x/%#x/%#x/%#x not yet implemented.\n",
mask0, mask1, mask2, mask3);
FIXME("Missing of cap D3DPMISCCAPS_INDEPENDENTWRITEMASKS wasn't honored?\n");
wined3d: Move WINED3DRS_COLORWRITEENABLEx to the state table.
2006-12-10 23:20:22 +01:00
}
}
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
static void set_color_mask(const struct wined3d_gl_info *gl_info, UINT index, DWORD mask)
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{
GL_EXTCALL(glColorMaskIndexedEXT(index,
mask & WINED3DCOLORWRITEENABLE_RED ? GL_TRUE : GL_FALSE,
mask & WINED3DCOLORWRITEENABLE_GREEN ? GL_TRUE : GL_FALSE,
mask & WINED3DCOLORWRITEENABLE_BLUE ? GL_TRUE : GL_FALSE,
mask & WINED3DCOLORWRITEENABLE_ALPHA ? GL_TRUE : GL_FALSE));
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colorwrite0(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
set_color_mask(context->gl_info, 0, stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE]);
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colorwrite1(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
set_color_mask(context->gl_info, 1, stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE1]);
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colorwrite2(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
set_color_mask(context->gl_info, 2, stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE2]);
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_colorwrite3(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
set_color_mask(context->gl_info, 3, stateblock->state.render_states[WINED3DRS_COLORWRITEENABLE3]);
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_localviewer(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_LOCALVIEWER])
{
wined3d: Move WINED3DRS_LOCALVIEWER to the state table.
2006-12-10 23:20:26 +01:00
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)");
} else {
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
checkGLcall("glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_lastpixel(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_LASTPIXEL])
{
wined3d: Move WINED3DRS_LASTPIXEL to the state table.
2006-12-10 23:20:29 +01:00
TRACE("Last Pixel Drawing Enabled\n");
} else {
wined3d: Handle a few "silent" FIXMEs more consistent with the rest of the code. Also avoids needlessly initializing static variables.
2008-12-01 15:32:14 +01:00
static BOOL warned;
if (!warned) {
wined3d: Print lastpixel state fixme only once.
2007-03-27 09:27:52 +02:00
FIXME("Last Pixel Drawing Disabled, not handled yet\n");
wined3d: Handle a few "silent" FIXMEs more consistent with the rest of the code. Also avoids needlessly initializing static variables.
2008-12-01 15:32:14 +01:00
warned = TRUE;
wined3d: Print lastpixel state fixme only once.
2007-03-27 09:27:52 +02:00
} else {
TRACE("Last Pixel Drawing Disabled, not handled yet\n");
}
wined3d: Move WINED3DRS_LASTPIXEL to the state table.
2006-12-10 23:20:29 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_pointsprite_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Printing a FIXME once only works if the relevant BOOL is static (LLVM/Clang).
2009-10-16 10:38:43 +02:00
static BOOL warned;
wined3d: Move WINED3DRS_POINTSPRITEENABLE to the state table.
2006-12-10 23:20:36 +01:00
/* TODO: NV_POINT_SPRITE */
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (!warned && stateblock->state.render_states[WINED3DRS_POINTSPRITEENABLE])
{
wined3d: Work around a bad crash in fglrx.
2009-05-06 19:36:08 +02:00
/* A FIXME, not a WARN because point sprites should be software emulated if not supported by HW */
FIXME("Point sprites not supported\n");
warned = TRUE;
wined3d: Move WINED3DRS_POINTSPRITEENABLE to the state table.
2006-12-10 23:20:36 +01:00
}
wined3d: Move the point sprite support test into the template.
2008-07-05 22:49:50 +02:00
}
wined3d: Move WINED3DRS_POINTSPRITEENABLE to the state table.
2006-12-10 23:20:36 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_pointsprite(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (state->render_states[WINED3DRS_POINTSPRITEENABLE])
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Printing a FIXME once only works if the relevant BOOL is static (LLVM/Clang).
2009-10-16 10:38:43 +02:00
static BOOL warned;
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (gl_info->limits.point_sprite_units < gl_info->limits.textures && !warned)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (use_ps(state) || state->lowest_disabled_stage > gl_info->limits.point_sprite_units)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Work around a bad crash in fglrx.
2009-05-06 19:36:08 +02:00
FIXME("The app uses point sprite texture coordinates on more units than supported by the driver\n");
warned = TRUE;
}
}
wined3d: Some point sprite fixes.
2007-06-17 00:26:17 +02:00
glEnable(GL_POINT_SPRITE_ARB);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glEnable(GL_POINT_SPRITE_ARB)");
wined3d: Move WINED3DRS_POINTSPRITEENABLE to the state table.
2006-12-10 23:20:36 +01:00
} else {
wined3d: Some point sprite fixes.
2007-06-17 00:26:17 +02:00
glDisable(GL_POINT_SPRITE_ARB);
wined3d: Fix some typos.
2007-12-19 19:12:12 +01:00
checkGLcall("glDisable(GL_POINT_SPRITE_ARB)");
wined3d: Move WINED3DRS_POINTSPRITEENABLE to the state table.
2006-12-10 23:20:36 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_wrap(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move WINED3DRS_WRAPx to the state table.
2006-12-10 23:20:45 +01:00
/**
http://www.cosc.brocku.ca/Offerings/3P98/course/lectures/texture/
http://www.gamedev.net/reference/programming/features/rendererdll3/page2.asp
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
Discussion on the ways to turn on WRAPing to solve an OpenGL conversion problem.
wined3d: Move WINED3DRS_WRAPx to the state table.
2006-12-10 23:20:45 +01:00
http://www.flipcode.org/cgi-bin/fcmsg.cgi?thread_show=10248
so far as I can tell, wrapping and texture-coordinate generate go hand in hand,
*/
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_WRAP0]
|| stateblock->state.render_states[WINED3DRS_WRAP1]
|| stateblock->state.render_states[WINED3DRS_WRAP2]
|| stateblock->state.render_states[WINED3DRS_WRAP3]
|| stateblock->state.render_states[WINED3DRS_WRAP4]
|| stateblock->state.render_states[WINED3DRS_WRAP5]
|| stateblock->state.render_states[WINED3DRS_WRAP6]
|| stateblock->state.render_states[WINED3DRS_WRAP7]
|| stateblock->state.render_states[WINED3DRS_WRAP8]
|| stateblock->state.render_states[WINED3DRS_WRAP9]
|| stateblock->state.render_states[WINED3DRS_WRAP10]
|| stateblock->state.render_states[WINED3DRS_WRAP11]
|| stateblock->state.render_states[WINED3DRS_WRAP12]
|| stateblock->state.render_states[WINED3DRS_WRAP13]
|| stateblock->state.render_states[WINED3DRS_WRAP14]
|| stateblock->state.render_states[WINED3DRS_WRAP15])
{
FIXME("(WINED3DRS_WRAP0) Texture wrapping not yet supported.\n");
wined3d: Move WINED3DRS_WRAPx to the state table.
2006-12-10 23:20:45 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_msaa_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_MULTISAMPLEANTIALIAS])
wined3d: Test for multisampling in the template.
2008-07-05 22:59:21 +02:00
WARN("Multisample antialiasing not supported by gl\n");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_msaa(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_MULTISAMPLEANTIALIAS])
{
wined3d: Test for multisampling in the template.
2008-07-05 22:59:21 +02:00
glEnable(GL_MULTISAMPLE_ARB);
checkGLcall("glEnable(GL_MULTISAMPLE_ARB)");
wined3d: Move WINED3DRS_MULTISAMPLEANTIALIAS to the state table.
2006-12-10 23:20:40 +01:00
} else {
wined3d: Test for multisampling in the template.
2008-07-05 22:59:21 +02:00
glDisable(GL_MULTISAMPLE_ARB);
checkGLcall("glDisable(GL_MULTISAMPLE_ARB)");
wined3d: Move WINED3DRS_MULTISAMPLEANTIALIAS to the state table.
2006-12-10 23:20:40 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_scissor(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SCISSORTESTENABLE])
{
wined3d: Move WINED3DRS_SCISSORTESTENABLE to the state table.
2006-12-10 23:20:48 +01:00
glEnable(GL_SCISSOR_TEST);
checkGLcall("glEnable(GL_SCISSOR_TEST)");
} else {
glDisable(GL_SCISSOR_TEST);
checkGLcall("glDisable(GL_SCISSOR_TEST)");
}
}
wined3d: Fix WINED3DRS_DEPTHBIAS handling.
2009-12-30 19:33:43 +01:00
/* 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,
wined3d: Scale the depthbias factor by the depth buffer's depth.
2011-04-20 16:28:05 +02:00
* 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. */
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_depthbias(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SLOPESCALEDEPTHBIAS]
|| stateblock->state.render_states[WINED3DRS_DEPTHBIAS])
wined3d: Fix WINED3DRS_DEPTHBIAS handling.
2009-12-30 19:33:43 +01:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
struct wined3d_surface *depth = stateblock->device->fb.depth_stencil;
wined3d: Scale the depthbias factor by the depth buffer's depth.
2011-04-20 16:28:05 +02:00
float scale;
wined3d: Fix WINED3DRS_DEPTHBIAS handling.
2009-12-30 19:33:43 +01:00
union
{
DWORD d;
float f;
} scale_bias, const_bias;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
scale_bias.d = stateblock->state.render_states[WINED3DRS_SLOPESCALEDEPTHBIAS];
const_bias.d = stateblock->state.render_states[WINED3DRS_DEPTHBIAS];
wined3d: Move WINED3DRS_DEPTHBIAS to the state table.
2006-12-10 23:20:52 +01:00
glEnable(GL_POLYGON_OFFSET_FILL);
checkGLcall("glEnable(GL_POLYGON_OFFSET_FILL)");
wined3d: Fix WINED3DRS_DEPTHBIAS handling.
2009-12-30 19:33:43 +01:00
wined3d: Scale the depthbias factor by the depth buffer's depth.
2011-04-20 16:28:05 +02:00
if (depth)
{
const struct wined3d_format *fmt = depth->resource.format;
scale = powf(2, fmt->depth_size) - 1;
TRACE("Depth format %s, using depthbias scale of %f\n",
debug_d3dformat(fmt->id), scale);
}
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;
}
glPolygonOffset(scale_bias.f, const_bias.f * scale);
wined3d: Move WINED3DRS_DEPTHBIAS to the state table.
2006-12-10 23:20:52 +01:00
checkGLcall("glPolygonOffset(...)");
} else {
glDisable(GL_POLYGON_OFFSET_FILL);
checkGLcall("glDisable(GL_POLYGON_OFFSET_FILL)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_zvisible(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Add a state handler for WINED3DRS_ZVISIBLE.
2010-04-01 21:28:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ZVISIBLE])
wined3d: Add a state handler for WINED3DRS_ZVISIBLE.
2010-04-01 21:28:51 +02:00
FIXME("WINED3DRS_ZVISIBLE not implemented.\n");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_perspective(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_TEXTUREPERSPECTIVE])
{
wined3d: Move WINED3DRS_TEXTUREPERSPECTIVE to the state table.
2006-12-10 23:20:56 +01:00
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)");
} else {
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
checkGLcall("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_stippledalpha(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_STIPPLEDALPHA])
wined3d: Downgrade some ERRs to FIXMEs.
2007-04-03 23:38:21 +02:00
FIXME(" Stippled Alpha not supported yet.\n");
wined3d: Move WINED3DRS_STIPPLEDALPHA to the state table.
2006-12-10 23:20:59 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_antialias(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ANTIALIAS])
FIXME("Antialias not supported yet.\n");
wined3d: Move WINED3DRS_ANTIALIAS to the state table.
2006-12-10 23:21:03 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_multisampmask(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_MULTISAMPLEMASK] != 0xffffffff)
FIXME("WINED3DRS_MULTISAMPLEMASK %#x not yet implemented.\n",
stateblock->state.render_states[WINED3DRS_MULTISAMPLEMASK]);
wined3d: Move WINED3DRS_MULTISAMPLEMASK to the state table.
2006-12-10 23:21:07 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_patchedgestyle(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_PATCHEDGESTYLE] != WINED3DPATCHEDGE_DISCRETE)
FIXME("WINED3DRS_PATCHEDGESTYLE %#x not yet implemented.\n",
stateblock->state.render_states[WINED3DRS_PATCHEDGESTYLE]);
wined3d: Move WINED3DRS_PATCHEDGESTYLE to the state table.
2006-12-10 23:21:10 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_patchsegments(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move WINED3DRS_PATCHSEGMENTS to the state table.
2006-12-10 23:21:14 +01:00
union {
DWORD d;
float f;
} tmpvalue;
tmpvalue.f = 1.0f;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_PATCHSEGMENTS] != tmpvalue.d)
wined3d: Fix broken ERR() message.
2007-03-28 20:37:10 +02:00
{
wined3d: Only issue state_patchsegments FIXME once.
2007-04-03 23:39:22 +02:00
static BOOL displayed = FALSE;
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
tmpvalue.d = stateblock->state.render_states[WINED3DRS_PATCHSEGMENTS];
wined3d: Only issue state_patchsegments FIXME once.
2007-04-03 23:39:22 +02:00
if(!displayed)
FIXME("(WINED3DRS_PATCHSEGMENTS,%f) not yet implemented\n", tmpvalue.f);
displayed = TRUE;
wined3d: Fix broken ERR() message.
2007-03-28 20:37:10 +02:00
}
wined3d: Move WINED3DRS_PATCHSEGMENTS to the state table.
2006-12-10 23:21:14 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_positiondegree(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_POSITIONDEGREE] != WINED3DDEGREE_CUBIC)
FIXME("WINED3DRS_POSITIONDEGREE %#x not yet implemented.\n",
stateblock->state.render_states[WINED3DRS_POSITIONDEGREE]);
wined3d: Move WINED3DRS_POSITIONDEGREE to the state table.
2006-12-10 23:21:21 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_normaldegree(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_NORMALDEGREE] != WINED3DDEGREE_LINEAR)
FIXME("WINED3DRS_NORMALDEGREE %#x not yet implemented.\n",
stateblock->state.render_states[WINED3DRS_NORMALDEGREE]);
wined3d: Move WINED3DRS_NORMALDEGREE to the state table.
2006-12-10 23:21:25 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_tessellation(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION])
FIXME("WINED3DRS_ENABLEADAPTIVETESSELLATION %#x not yet implemented.\n",
stateblock->state.render_states[WINED3DRS_ENABLEADAPTIVETESSELLATION]);
wined3d: Move tesselation to the state table.
2006-12-10 23:21:27 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_nvdb(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Add NVDB support.
2010-09-16 08:58:26 +02:00
{
union {
DWORD d;
float f;
} zmin, zmax;
const struct wined3d_gl_info *gl_info = context->gl_info;
if (stateblock->state.render_states[WINED3DRS_ADAPTIVETESS_X] == WINED3DFMT_NVDB)
{
zmin.d = stateblock->state.render_states[WINED3DRS_ADAPTIVETESS_Z];
zmax.d = stateblock->state.render_states[WINED3DRS_ADAPTIVETESS_W];
/* If zmin is larger than zmax INVALID_VALUE error is generated.
* In d3d9 test is not performed in this case*/
if (zmin.f <= zmax.f)
{
glEnable(GL_DEPTH_BOUNDS_TEST_EXT);
checkGLcall("glEnable(GL_DEPTH_BOUNDS_TEST_EXT)");
GL_EXTCALL(glDepthBoundsEXT(zmin.f, zmax.f));
checkGLcall("glDepthBoundsEXT(...)");
}
else {
glDisable(GL_DEPTH_BOUNDS_TEST_EXT);
checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
}
}
else {
glDisable(GL_DEPTH_BOUNDS_TEST_EXT);
checkGLcall("glDisable(GL_DEPTH_BOUNDS_TEST_EXT)");
}
state_tessellation(state, stateblock, context);
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_wrapu(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_WRAPU])
FIXME("Render state WINED3DRS_WRAPU not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_wrapv(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_WRAPV])
FIXME("Render state WINED3DRS_WRAPV not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_monoenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_MONOENABLE])
FIXME("Render state WINED3DRS_MONOENABLE not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_rop2(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ROP2])
FIXME("Render state WINED3DRS_ROP2 not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_planemask(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_PLANEMASK])
FIXME("Render state WINED3DRS_PLANEMASK not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_subpixel(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SUBPIXEL])
FIXME("Render state WINED3DRS_SUBPIXEL not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_subpixelx(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SUBPIXELX])
FIXME("Render state WINED3DRS_SUBPIXELX not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_stippleenable(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_STIPPLEENABLE])
FIXME("Render state WINED3DRS_STIPPLEENABLE not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_mipmaplodbias(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_MIPMAPLODBIAS])
FIXME("Render state WINED3DRS_MIPMAPLODBIAS not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_anisotropy(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ANISOTROPY])
FIXME("Render state WINED3DRS_ANISOTROPY not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_flushbatch(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_FLUSHBATCH])
FIXME("Render state WINED3DRS_FLUSHBATCH not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_translucentsi(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_TRANSLUCENTSORTINDEPENDENT])
FIXME("Render state WINED3DRS_TRANSLUCENTSORTINDEPENDENT not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_extents(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_EXTENTS])
FIXME("Render state WINED3DRS_EXTENTS not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_ckeyblend(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_COLORKEYBLENDENABLE])
FIXME("Render state WINED3DRS_COLORKEYBLENDENABLE not implemented yet.\n");
wined3d: Add missing render state function.
2006-12-15 20:02:13 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_swvp(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Add a state handler for WINED3DRS_SOFTWAREVERTEXPROCESSING.
2009-09-25 13:31:48 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_SOFTWAREVERTEXPROCESSING])
wined3d: Add a state handler for WINED3DRS_SOFTWAREVERTEXPROCESSING.
2009-09-25 13:31:48 +02:00
FIXME("Software vertex processing not implemented.\n");
}
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
/* Set texture operations up - The following avoids lots of ifdefs in this routine!*/
#if defined (GL_VERSION_1_3)
# define useext(A) A
#elif defined (GL_EXT_texture_env_combine)
# define useext(A) A##_EXT
#elif defined (GL_ARB_texture_env_combine)
# define useext(A) A##_ARB
#endif
static void get_src_and_opr(DWORD arg, BOOL is_alpha, GLenum* source, GLenum* operand) {
/* 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. */
BOOL from_alpha = is_alpha || arg & WINED3DTA_ALPHAREPLICATE;
BOOL complement = arg & WINED3DTA_COMPLEMENT;
/* Calculate the operand */
if (complement) {
if (from_alpha) *operand = GL_ONE_MINUS_SRC_ALPHA;
else *operand = GL_ONE_MINUS_SRC_COLOR;
} else {
if (from_alpha) *operand = GL_SRC_ALPHA;
else *operand = GL_SRC_COLOR;
}
/* Calculate the source */
switch (arg & WINED3DTA_SELECTMASK) {
case WINED3DTA_CURRENT: *source = GL_PREVIOUS_EXT; break;
case WINED3DTA_DIFFUSE: *source = GL_PRIMARY_COLOR_EXT; break;
case WINED3DTA_TEXTURE: *source = GL_TEXTURE; break;
case WINED3DTA_TFACTOR: *source = GL_CONSTANT_EXT; break;
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:
FIXME("Unrecognized texture arg %#x\n", arg);
*source = GL_TEXTURE;
break;
}
}
/* Setup the texture operations texture stage states */
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
static void set_tex_op(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3)
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
{
GLenum src1, src2, src3;
GLenum opr1, opr2, opr3;
GLenum comb_target;
GLenum src0_target, src1_target, src2_target;
GLenum opr0_target, opr1_target, opr2_target;
GLenum scal_target;
GLenum opr=0, invopr, src3_target, opr3_target;
BOOL Handled = FALSE;
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.
However, below we treat the new (a0) parameter as src2/opr2, so in the actual
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) {
comb_target = useext(GL_COMBINE_ALPHA);
src0_target = useext(GL_SOURCE0_ALPHA);
src1_target = useext(GL_SOURCE1_ALPHA);
src2_target = useext(GL_SOURCE2_ALPHA);
opr0_target = useext(GL_OPERAND0_ALPHA);
opr1_target = useext(GL_OPERAND1_ALPHA);
opr2_target = useext(GL_OPERAND2_ALPHA);
scal_target = GL_ALPHA_SCALE;
}
else {
comb_target = useext(GL_COMBINE_RGB);
src0_target = useext(GL_SOURCE0_RGB);
src1_target = useext(GL_SOURCE1_RGB);
src2_target = useext(GL_SOURCE2_RGB);
opr0_target = useext(GL_OPERAND0_RGB);
opr1_target = useext(GL_OPERAND1_RGB);
opr2_target = useext(GL_OPERAND2_RGB);
scal_target = useext(GL_RGB_SCALE);
}
/* If a texture stage references an invalid texture unit the stage just
* passes through the result from the previous stage */
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
if (is_invalid_op(state, Stage, op, arg1, arg2, arg3))
wined3d: Pass a wined3d_state structure to is_invalid_op(). Instead of an entire device.
2010-09-23 11:48:02 +02:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
arg1 = WINED3DTA_CURRENT;
op = WINED3DTOP_SELECTARG1;
}
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
if (isAlpha && !state->textures[Stage] && arg1 == WINED3DTA_TEXTURE)
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
get_src_and_opr(WINED3DTA_DIFFUSE, isAlpha, &src1, &opr1);
} else {
get_src_and_opr(arg1, isAlpha, &src1, &opr1);
}
get_src_and_opr(arg2, isAlpha, &src2, &opr2);
get_src_and_opr(arg3, isAlpha, &src3, &opr3);
TRACE("ct(%x), 1:(%x,%x), 2:(%x,%x), 3:(%x,%x)\n", comb_target, src1, opr1, src2, opr2, src3, opr3);
Handled = TRUE; /* Assume will be handled */
/* Other texture operations require special extensions: */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_TEXTURE_ENV_COMBINE4])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
if (isAlpha) {
opr = GL_SRC_ALPHA;
invopr = GL_ONE_MINUS_SRC_ALPHA;
src3_target = GL_SOURCE3_ALPHA_NV;
opr3_target = GL_OPERAND3_ALPHA_NV;
} else {
opr = GL_SRC_COLOR;
invopr = GL_ONE_MINUS_SRC_COLOR;
src3_target = GL_SOURCE3_RGB_NV;
opr3_target = GL_OPERAND3_RGB_NV;
}
switch (op) {
case WINED3DTOP_DISABLE: /* Only for alpha */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
case WINED3DTOP_SELECTARG1: /* = a1 * 1 + 0 * 0 */
case WINED3DTOP_SELECTARG2: /* = a2 * 1 + 0 * 0 */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
if (op == WINED3DTOP_SELECTARG1) {
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
} else {
glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
}
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
break;
case WINED3DTOP_MODULATE:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATE2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3DTOP_MODULATE4X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
case WINED3DTOP_ADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_ADDSIGNED:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_ADDSIGNED2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3DTOP_ADDSMOOTH:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDDIFFUSEALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_PRIMARY_COLOR)");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_PRIMARY_COLOR)");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDTEXTUREALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDFACTORALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src1_target, useext(GL_CONSTANT)");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src3_target, useext(GL_CONSTANT)");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDTEXTUREALPHAPM:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr3_target, GL_ONE_MINUS_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD"); /* Add = a0*a1 + a2*a3 */
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1); /* a0 = src1/opr1 */
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1"); /* a1 = 1 (see docs) */
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2); /* a2 = arg2 */
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2"); /* a3 = src1 alpha */
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src1);
checkGLcall("GL_TEXTURE_ENV, src3_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src3_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src3_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr3_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MULTIPLYADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src3);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, GL_ZERO);
checkGLcall("GL_TEXTURE_ENV, src1_target, GL_ZERO");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, invopr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, invopr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src1);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src3_target, src2);
checkGLcall("GL_TEXTURE_ENV, src3_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr3_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr3_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BUMPENVMAP:
{
}
case WINED3DTOP_BUMPENVMAPLUMINANCE:
FIXME("Implement bump environment mapping in GL_NV_texture_env_combine4 path\n");
default:
Handled = FALSE;
}
if (Handled) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV);
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE4_NV");
return;
}
} /* GL_NV_texture_env_combine4 */
Handled = TRUE; /* Again, assume handled */
switch (op) {
case WINED3DTOP_DISABLE: /* Only for alpha */
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT);
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_PREVIOUS_EXT");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_SELECTARG1:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_SELECTARG2:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_REPLACE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_REPLACE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src2);
checkGLcall("GL_TEXTURE_ENV, src0_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATE:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_MODULATE2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3DTOP_MODULATE4X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 4);
checkGLcall("GL_TEXTURE_ENV, scal_target, 4");
break;
case WINED3DTOP_ADD:
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_ADD);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_ADD");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_ADDSIGNED:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext((GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_ADDSIGNED2X:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_ADD_SIGNED)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 2);
checkGLcall("GL_TEXTURE_ENV, scal_target, 2");
break;
case WINED3DTOP_SUBTRACT:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_TEXTURE_ENV_COMBINE])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_SUBTRACT);
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_SUBTRACT)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else {
FIXME("This version of opengl does not support GL_SUBTRACT\n");
}
break;
case WINED3DTOP_BLENDDIFFUSEALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PRIMARY_COLOR));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PRIMARY_COLOR");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDTEXTUREALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDFACTORALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_CONSTANT));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_CONSTANT");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_BLENDCURRENTALPHA:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, useext(GL_PREVIOUS));
checkGLcall("GL_TEXTURE_ENV, src2_target, GL_PREVIOUS");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr2_target, GL_SRC_ALPHA");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_DOTPRODUCT3:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_TEXTURE_ENV_DOT3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_ARB");
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
else if (gl_info->supported[EXT_TEXTURE_ENV_DOT3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_DOT3_RGBA_EXT");
} else {
FIXME("This version of opengl does not support GL_DOT3\n");
}
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_LERP:
glTexEnvi(GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE));
checkGLcall("GL_TEXTURE_ENV, comb_target, useext(GL_INTERPOLATE)");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src2);
checkGLcall("GL_TEXTURE_ENV, src1_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src3);
checkGLcall("GL_TEXTURE_ENV, src2_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
break;
case WINED3DTOP_ADDSMOOTH:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_BLENDTEXTUREALPHAPM:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, GL_TEXTURE);
checkGLcall("GL_TEXTURE_ENV, src0_target, GL_TEXTURE");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_ALPHA);
checkGLcall("GL_TEXTURE_ENV, opr0_target, GL_ONE_MINUS_SRC_APHA");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_ONE_MINUS_SRC_COLOR; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_SRC_COLOR; break;
case GL_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src1);
checkGLcall("GL_TEXTURE_ENV, src1_target, src1");
switch (opr1) {
case GL_SRC_COLOR: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_COLOR: opr = GL_ONE_MINUS_SRC_ALPHA; break;
case GL_SRC_ALPHA: opr = GL_SRC_ALPHA; break;
case GL_ONE_MINUS_SRC_ALPHA: opr = GL_ONE_MINUS_SRC_ALPHA; break;
}
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_MULTIPLYADD:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
glTexEnvi(GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI);
checkGLcall("GL_TEXTURE_ENV, comb_target, GL_MODULATE_ADD_ATI");
glTexEnvi(GL_TEXTURE_ENV, src0_target, src1);
checkGLcall("GL_TEXTURE_ENV, src0_target, src1");
glTexEnvi(GL_TEXTURE_ENV, opr0_target, opr1);
checkGLcall("GL_TEXTURE_ENV, opr0_target, opr1");
glTexEnvi(GL_TEXTURE_ENV, src1_target, src3);
checkGLcall("GL_TEXTURE_ENV, src1_target, src3");
glTexEnvi(GL_TEXTURE_ENV, opr1_target, opr3);
checkGLcall("GL_TEXTURE_ENV, opr1_target, opr3");
glTexEnvi(GL_TEXTURE_ENV, src2_target, src2);
checkGLcall("GL_TEXTURE_ENV, src2_target, src2");
glTexEnvi(GL_TEXTURE_ENV, opr2_target, opr2);
checkGLcall("GL_TEXTURE_ENV, opr2_target, opr2");
glTexEnvi(GL_TEXTURE_ENV, scal_target, 1);
checkGLcall("GL_TEXTURE_ENV, scal_target, 1");
} else
Handled = FALSE;
break;
case WINED3DTOP_BUMPENVMAPLUMINANCE:
case WINED3DTOP_BUMPENVMAP:
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_TEXTURE_SHADER2])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
/* 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");
}
default:
Handled = FALSE;
}
if (Handled) {
BOOL combineOK = TRUE;
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_TEXTURE_ENV_COMBINE4])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
DWORD op2;
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
if (isAlpha)
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
op2 = state->texture_states[Stage][WINED3DTSS_COLOROP];
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
else
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
op2 = state->texture_states[Stage][WINED3DTSS_ALPHAOP];
wined3d: Move set_tex_op(_nvrc) to their specific files.
2008-07-12 18:45:33 +02:00
/* Note: If COMBINE4 in effect can't go back to combine! */
switch (op2) {
case WINED3DTOP_ADDSMOOTH:
case WINED3DTOP_BLENDTEXTUREALPHAPM:
case WINED3DTOP_MODULATEALPHA_ADDCOLOR:
case WINED3DTOP_MODULATECOLOR_ADDALPHA:
case WINED3DTOP_MODULATEINVALPHA_ADDCOLOR:
case WINED3DTOP_MODULATEINVCOLOR_ADDALPHA:
case WINED3DTOP_MULTIPLYADD:
/* Ignore those implemented in both cases */
switch (op) {
case WINED3DTOP_SELECTARG1:
case WINED3DTOP_SELECTARG2:
combineOK = FALSE;
Handled = FALSE;
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) {
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE));
checkGLcall("GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, useext(GL_COMBINE)");
return;
}
}
/* After all the extensions, if still unhandled, report fixme */
FIXME("Unhandled texture operation %s\n", debug_d3dtop(op));
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void tex_colorop(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
DWORD stage = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
BOOL tex_used = stateblock->device->fixed_function_usage_map & (1 << stage);
DWORD mapped_stage = stateblock->device->texUnitMap[stage];
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
TRACE("Setting color op for stage %d\n", stage);
wined3d: Shaders will never have a NULL function.
2008-12-15 16:35:14 +01:00
/* Using a pixel shader? Don't care for anything here, the shader applying does it */
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (use_ps(state)) return;
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
wined3d: Don't do WINED3DTSS_COLOROP texture operations for stages that aren't mapped to a texture unit.
2007-01-03 19:18:38 +01:00
if (stage != mapped_stage) WARN("Using non 1:1 mapping: %d -> %d!\n", stage, mapped_stage);
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (tex_used && mapped_stage >= gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
FIXME("Attempt to enable unsupported stage!\n");
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
return;
}
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
}
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (stage >= state->lowest_disabled_stage)
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
{
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
TRACE("Stage disabled\n");
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
wined3d: Don't do WINED3DTSS_COLOROP texture operations for stages that aren't mapped to a texture unit.
2007-01-03 19:18:38 +01:00
/* Disable everything here */
glDisable(GL_TEXTURE_2D);
checkGLcall("glDisable(GL_TEXTURE_2D)");
glDisable(GL_TEXTURE_3D);
checkGLcall("glDisable(GL_TEXTURE_3D)");
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Only disable GL_TEXTURE_CUBE_MAP_ARB if supported.
2007-03-28 19:17:51 +02:00
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
glDisable(GL_TEXTURE_RECTANGLE_ARB);
checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
}
wined3d: Support bump environment mapping using GL_NV_texture_shader.
2007-05-07 21:08:14 +02:00
}
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
/* All done */
return;
}
wined3d: Directly pass the texture to texture_activate_dimensions().
2010-09-23 21:33:27 +02:00
/* The sampler will also activate the correct texture dimensions, so no
* need to do it here if the sampler for this stage is dirty. */
if (!isStateDirty(context, STATE_SAMPLER(stage)) && tex_used)
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
texture_activate_dimensions(state->textures[stage], gl_info);
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
set_tex_op(gl_info, state, FALSE, stage,
state->texture_states[stage][WINED3DTSS_COLOROP],
state->texture_states[stage][WINED3DTSS_COLORARG1],
state->texture_states[stage][WINED3DTSS_COLORARG2],
state->texture_states[stage][WINED3DTSS_COLORARG0]);
wined3d: Move WINED3DTSS_COLOROP to the state table.
2006-12-19 23:00:58 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void tex_alphaop(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Renumber WINED3DTEXTURESTAGESTATETYPE enum elements. Saves some space by not having unused entries is the arrays tracking these states.
2009-01-06 11:43:45 +01:00
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
BOOL tex_used = stateblock->device->fixed_function_usage_map & (1 << stage);
DWORD mapped_stage = stateblock->device->texUnitMap[stage];
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: alphaop fixes for color keying.
2007-02-15 03:04:18 +01:00
DWORD op, arg1, arg2, arg0;
wined3d: Move WINED3DTSS_ALPHAOP to the state table.
2006-12-19 23:03:37 +01:00
TRACE("Setting alpha op for stage %d\n", stage);
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
/* Do not care for enabled / disabled stages, just assign the settings. colorop disables / enables required stuff */
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage != WINED3D_UNMAPPED_STAGE)
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (tex_used && mapped_stage >= gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
FIXME("Attempt to enable unsupported stage!\n");
wined3d: Move WINED3DTSS_ALPHAOP to the state table.
2006-12-19 23:03:37 +01:00
return;
}
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Move WINED3DTSS_ALPHAOP to the state table.
2006-12-19 23:03:37 +01:00
}
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
op = stateblock->state.texture_states[stage][WINED3DTSS_ALPHAOP];
arg1 = stateblock->state.texture_states[stage][WINED3DTSS_ALPHAARG1];
arg2 = stateblock->state.texture_states[stage][WINED3DTSS_ALPHAARG2];
arg0 = stateblock->state.texture_states[stage][WINED3DTSS_ALPHAARG0];
wined3d: alphaop fixes for color keying.
2007-02-15 03:04:18 +01:00
wined3d: Move texture bindings to wined3d_state.
2010-09-17 11:59:40 +02:00
if (stateblock->state.render_states[WINED3DRS_COLORKEYENABLE] && !stage && stateblock->state.textures[0])
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
{
wined3d: Get rid of the IWineD3DBaseTexture typedefs.
2011-03-18 19:11:00 +01:00
struct wined3d_texture *texture = stateblock->state.textures[0];
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
GLenum texture_dimensions = texture->target;
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
if (texture_dimensions == GL_TEXTURE_2D || texture_dimensions == GL_TEXTURE_RECTANGLE_ARB)
{
wined3d: Get rid of the IWineD3DSurface typedefs.
2011-04-29 13:03:42 +02:00
struct wined3d_surface *surf = surface_from_resource(texture->sub_resources[0]);
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
if (surf->CKeyFlags & WINEDDSD_CKSRCBLT && !surf->resource.format->alpha_mask)
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
{
/* 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
* modulated with texture alpha. OTOH, Moto racer 2 at some points sets alphaop/alphaarg to
* SELECTARG/CURRENT, yet puts garbage in diffuse alpha (zeroes). This works on native, because the
* 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 == WINED3DTOP_DISABLE)
{
wined3d: Change colorkey fixup for stage 0 alphaop / alphaarg.
2008-01-21 05:17:49 +01:00
arg1 = WINED3DTA_TEXTURE;
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
op = WINED3DTOP_SELECTARG1;
}
else if(op == WINED3DTOP_SELECTARG1 && arg1 != WINED3DTA_TEXTURE)
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ALPHABLENDENABLE])
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
{
arg2 = WINED3DTA_TEXTURE;
op = WINED3DTOP_MODULATE;
}
else arg1 = WINED3DTA_TEXTURE;
}
else if(op == WINED3DTOP_SELECTARG2 && arg2 != WINED3DTA_TEXTURE)
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (stateblock->state.render_states[WINED3DRS_ALPHABLENDENABLE])
wined3d: Get rid of the textureDimensions field in the state block.
2008-12-12 09:33:51 +01:00
{
arg1 = WINED3DTA_TEXTURE;
op = WINED3DTOP_MODULATE;
}
else arg2 = WINED3DTA_TEXTURE;
wined3d: Change colorkey fixup for stage 0 alphaop / alphaarg.
2008-01-21 05:17:49 +01:00
}
}
wined3d: alphaop fixes for color keying.
2007-02-15 03:04:18 +01:00
}
}
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
/* 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
*/
wined3d: Move WINED3DTSS_ALPHAOP to the state table.
2006-12-19 23:03:37 +01:00
TRACE("Setting alpha op for stage %d\n", stage);
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_REGISTER_COMBINERS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Pass a wined3d_state structure to set_tex_op_nvrc().
2010-09-23 11:48:03 +02:00
set_tex_op_nvrc(gl_info, &stateblock->state, TRUE, stage, op, arg1, arg2, arg0,
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
mapped_stage, stateblock->state.texture_states[stage][WINED3DTSS_RESULTARG]);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
}
else
{
wined3d: Pass a wined3d_state structure to set_tex_op().
2010-09-23 21:33:26 +02:00
set_tex_op(gl_info, &stateblock->state, TRUE, stage, op, arg1, arg2, arg0);
wined3d: Move WINED3DTSS_ALPHAOP to the state table.
2006-12-19 23:03:37 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void transform_texture(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
DWORD texUnit = (state_id - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
DWORD mapped_stage = stateblock->device->texUnitMap[texUnit];
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Non power of two texture fixes.
2007-11-13 22:08:13 +01:00
BOOL generated;
wined3d: Honor the texcoordindex when setting the texture matrix.
2008-07-22 20:56:07 +02:00
int coordIdx;
wined3d: Correct various texture limits checks.
2007-03-12 23:21:44 +01:00
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
/* Ignore this when a vertex shader is used, or if the streams aren't sorted out yet */
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (use_vs(state) || isStateDirty(context, STATE_VDECL))
wined3d: Make use_vs() and use_ps() work on a stateblock instead of a device. Most callers work on a stateblock rather than a device, and the main fields we check (vertexShader and pixelShader) are part of the stateblock as well.
2008-12-30 14:56:49 +01:00
{
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
TRACE("Using a vertex shader, or stream sources not sorted out yet, skipping\n");
return;
}
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage == WINED3D_UNMAPPED_STAGE) return;
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
if (mapped_stage >= gl_info->limits.textures) return;
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
generated = (state->texture_states[texUnit][WINED3DTSS_TEXCOORDINDEX] & 0xffff0000) != WINED3DTSS_TCI_PASSTHRU;
coordIdx = min(state->texture_states[texUnit][WINED3DTSS_TEXCOORDINDEX & 0x0000ffff], MAX_TEXTURES - 1);
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
set_texture_matrix(&state->transforms[WINED3DTS_TEXTURE0 + texUnit].u.m[0][0],
state->texture_states[texUnit][WINED3DTSS_TEXTURETRANSFORMFLAGS],
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
generated, context->last_was_rhw,
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->strided_streams.use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx))
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
? stateblock->device->strided_streams.elements[WINED3D_FFP_TEXCOORD0 + coordIdx].format->id
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
: WINED3DFMT_UNKNOWN,
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->frag_pipe->ffp_proj_control);
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
wined3d: Non power of two texture fixes.
2007-11-13 22:08:13 +01:00
/* The sampler applying function calls us if this changes */
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if ((context->lastWasPow2Texture & (1 << texUnit)) && state->textures[texUnit])
wined3d: Convert some BOOLs to bitfields in struct WineD3DContext. Also happens to fill two 3 byte holes.
2008-12-30 14:56:49 +01:00
{
wined3d: Non power of two texture fixes.
2007-11-13 22:08:13 +01:00
if(generated) {
FIXME("Non-power2 texture being used with generated texture coords\n");
}
wined3d: Fix comments about NP2 fixup.
2009-07-01 18:36:51 +02:00
/* NP2 texcoord fixup is implemented for pixelshaders so only enable the
fixed-function-pipeline fixup via pow2Matrix when no PS is used. */
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (!use_ps(state))
{
wined3d: GLSL: Implement texrect coord fixup.
2009-03-26 03:19:41 +01:00
TRACE("Non power two matrix multiply fixup\n");
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
glMultMatrixf(state->textures[texUnit]->pow2_matrix);
wined3d: GLSL: Implement texrect coord fixup.
2009-03-26 03:19:41 +01:00
}
wined3d: Non power of two texture fixes.
2007-11-13 22:08:13 +01:00
}
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
}
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
static void unloadTexCoords(const struct wined3d_gl_info *gl_info)
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
{
wined3d: Fix a few sign compare warnings.
2009-03-25 10:12:27 +01:00
unsigned int texture_idx;
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
for (texture_idx = 0; texture_idx < gl_info->limits.texture_stages; ++texture_idx)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + texture_idx));
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void loadTexCoords(const struct wined3d_gl_info *gl_info, struct wined3d_stateblock *stateblock,
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
const struct wined3d_stream_info *si, GLuint *curVBO)
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
{
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
unsigned int mapped_stage = 0;
unsigned int textureNo = 0;
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
for (textureNo = 0; textureNo < gl_info->limits.texture_stages; ++textureNo)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
int coordIdx = stateblock->state.texture_states[textureNo][WINED3DTSS_TEXCOORDINDEX];
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
mapped_stage = stateblock->device->texUnitMap[textureNo];
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage == WINED3D_UNMAPPED_STAGE) continue;
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
wined3d: Properly check if an attribute is used in loadTexCoords().
2009-08-24 09:27:52 +02:00
if (coordIdx < MAX_TEXTURES && (si->use_map & (1 << (WINED3D_FFP_TEXCOORD0 + coordIdx))))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Properly check if an attribute is used in loadTexCoords().
2009-08-24 09:27:52 +02:00
const struct wined3d_stream_info_element *e = &si->elements[WINED3D_FFP_TEXCOORD0 + coordIdx];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
const struct wined3d_stream_state *stream = &stateblock->state.streams[e->stream_idx];
wined3d: Properly check if an attribute is used in loadTexCoords().
2009-08-24 09:27:52 +02:00
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
TRACE("Setting up texture %u, idx %d, cordindx %u, data %p\n",
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
textureNo, mapped_stage, coordIdx, e->data);
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (*curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
*curVBO = e->buffer_object;
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
}
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
GL_EXTCALL(glClientActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glClientActiveTextureARB");
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
/* The coords to supply depend completely on the fvf / vertex shader */
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
glTexCoordPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Load texture coordinates even if no texture is bound to that stage at this time.
2007-05-09 19:08:27 +02:00
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
} else {
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + mapped_stage, 0, 0, 0, 1));
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
}
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[NV_REGISTER_COMBINERS])
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
{
/* The number of the mapped stages increases monotonically, so it's fine to use the last used one. */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
for (textureNo = mapped_stage + 1; textureNo < gl_info->limits.textures; ++textureNo)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
GL_EXTCALL(glMultiTexCoord4fARB(GL_TEXTURE0_ARB + textureNo, 0, 0, 0, 1));
}
}
wined3d: Add a checkGLcall() at the end of loadTexCoords(). To prevent GL errors in loadTexCoords from showing up in different state handlers
2008-09-17 17:51:49 +02:00
checkGLcall("loadTexCoords");
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void tex_coordindex(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Renumber WINED3DTEXTURESTAGESTATETYPE enum elements. Saves some space by not having unused entries is the arrays tracking these states.
2009-01-06 11:43:45 +01:00
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
DWORD mapped_stage = stateblock->device->texUnitMap[stage];
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
static const GLfloat s_plane[] = { 1.0f, 0.0f, 0.0f, 0.0f };
static const GLfloat t_plane[] = { 0.0f, 1.0f, 0.0f, 0.0f };
static const GLfloat r_plane[] = { 0.0f, 0.0f, 1.0f, 0.0f };
static const GLfloat q_plane[] = { 0.0f, 0.0f, 0.0f, 1.0f };
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Skip WINED3DTSS_TEXCOORDINDEX state application for stages that aren't mapped to a texture unit.
2007-01-03 19:18:51 +01:00
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage == WINED3D_UNMAPPED_STAGE)
{
wined3d: Skip WINED3DTSS_TEXCOORDINDEX state application for stages that aren't mapped to a texture unit.
2007-01-03 19:18:51 +01:00
TRACE("No texture unit mapped to stage %d. Skipping texture coordinates.\n", stage);
return;
}
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (mapped_stage >= gl_info->limits.fragment_samplers)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Print a warning when the stage isn't mapped to a valid texture unit in tex_coordindex().
2009-03-25 10:12:26 +01:00
WARN("stage %u not mapped to a valid texture unit (%u)\n", stage, mapped_stage);
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
return;
}
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
/* Values 0-7 are indexes into the FVF tex coords - See comments in DrawPrimitive
*
wined3d: Remove some comments.
2009-01-15 09:58:45 +01:00
* FIXME: When using generated texture coordinates, the index value is used to specify the wrapping mode.
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
* eg. SetTextureStageState( 0, WINED3DTSS_TEXCOORDINDEX, WINED3DTSS_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 WINED3DRS_WRAP1 render
* state. We do not (yet) support the WINED3DRENDERSTATE_WRAPx values, nor tie them up
* to the TEXCOORDINDEX value
*/
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
switch (stateblock->state.texture_states[stage][WINED3DTSS_TEXCOORDINDEX] & 0xffff0000)
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
{
case WINED3DTSS_TCI_PASSTHRU:
/* Use the specified texture coordinates contained within the
* vertex format. This value resolves to zero. */
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_PASSTHRU - Disable texgen.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
case WINED3DTSS_TCI_CAMERASPACEPOSITION:
/* 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 */
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
glPopMatrix();
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set eye plane.");
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Set texgen mode.");
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
checkGLcall("WINED3DTSS_TCI_CAMERASPACEPOSITION - Enable texgen.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
case WINED3DTSS_TCI_CAMERASPACENORMAL:
wined3d: Print a FIXME in tex_coordindex() when NV_TEXGEN_REFLECTION isn't supported.
2009-03-25 10:12:26 +01:00
/* Note that NV_TEXGEN_REFLECTION support is implied when
* ARB_TEXTURE_CUBE_MAP is supported */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (!gl_info->supported[NV_TEXGEN_REFLECTION])
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
{
wined3d: Print a FIXME in tex_coordindex() when NV_TEXGEN_REFLECTION isn't supported.
2009-03-25 10:12:26 +01:00
FIXME("WINED3DTSS_TCI_CAMERASPACENORMAL not supported.\n");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
glPopMatrix();
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set eye plane.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_NV);
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Set texgen mode.");
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
checkGLcall("WINED3DTSS_TCI_CAMERASPACENORMAL - Enable texgen.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
case WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
wined3d: Print a FIXME in tex_coordindex() when NV_TEXGEN_REFLECTION isn't supported.
2009-03-25 10:12:26 +01:00
/* Note that NV_TEXGEN_REFLECTION support is implied when
* ARB_TEXTURE_CUBE_MAP is supported */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (!gl_info->supported[NV_TEXGEN_REFLECTION])
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
{
wined3d: Print a FIXME in tex_coordindex() when NV_TEXGEN_REFLECTION isn't supported.
2009-03-25 10:12:26 +01:00
FIXME("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR not supported.\n");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
}
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
glTexGenfv(GL_R, GL_EYE_PLANE, r_plane);
glTexGenfv(GL_Q, GL_EYE_PLANE, q_plane);
glPopMatrix();
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set eye plane.");
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV);
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Set texgen mode.");
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
checkGLcall("WINED3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR - Enable texgen.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
wined3d: Implement WINED3DTSS_TCI_SPHEREMAP.
2009-03-25 10:12:26 +01:00
case WINED3DTSS_TCI_SPHEREMAP:
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Set texgen mode.");
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
checkGLcall("WINED3DTSS_TCI_SPHEREMAP - Enable texgen.");
break;
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
default:
wined3d: Move texture states to wined3d_state.
2010-09-16 11:19:57 +02:00
FIXME("Unhandled WINED3DTSS_TEXCOORDINDEX %#x.\n",
stateblock->state.texture_states[stage][WINED3DTSS_TEXCOORDINDEX]);
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
wined3d: Reduce the number of checkGLcall's in tex_coordindex() a bit.
2009-03-25 10:12:26 +01:00
checkGLcall("Disable texgen.");
wined3d: Fix the indentation in tex_coordindex(). The indentation here is pretty horrible. Also removes a couple of fairly useless comments.
2009-03-25 10:12:26 +01:00
break;
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
}
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
/* Update the texture matrix */
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + stage))) {
wined3d: Handle texture transforms in the TEXTURETRANSFORMFLAGS state. This is a nop by itself, but it makes it easier for fragment pipelines to read WINED3DTSS_TEXTURETRANSFORMFLAGS.
2008-08-26 21:25:56 +02:00
transform_texture(STATE_TEXTURESTAGE(stage, WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
wined3d: Move WINED3DTS_TEXTURETRANSFORMFLAGS to the state table.
2007-01-01 23:53:59 +01:00
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(!isStateDirty(context, STATE_VDECL) && context->namedArraysLoaded) {
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* Reload the arrays if we are using fixed function arrays to reflect the selected coord input
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
* source. Call loadTexCoords directly because there is no need to reparse the vertex declaration
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
* and do all the things linked to it
* TODO: Tidy that up to reload only the arrays of the changed unit
*/
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0;
wined3d: Split texture coordinate loading from loadVertexData().
2007-05-09 19:08:10 +02:00
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
unloadTexCoords(gl_info);
loadTexCoords(gl_info, stateblock, &stateblock->device->strided_streams, &curVBO);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Move WINED3DTSS_TEXCOORDINDEX to the state table.
2006-12-19 23:04:16 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void shaderconstant(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
/* Vertex and pixel shader states will call a shader upload, don't do anything as long one of them
* has an update pending
*/
if(isStateDirty(context, STATE_VDECL) ||
isStateDirty(context, STATE_PIXELSHADER)) {
return;
}
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
device->shader_backend->shader_load_constants(context, use_ps(state), use_vs(state));
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void tex_bumpenvlscale(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Renumber WINED3DTEXTURESTAGESTATETYPE enum elements. Saves some space by not having unused entries is the arrays tracking these states.
2009-01-06 11:43:45 +01:00
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Get rid of the IWineD3DBaseShader typedefs.
2011-03-30 20:49:26 +02:00
const struct wined3d_shader *ps = stateblock->state.pixel_shader;
wined3d: Add a WINED3DTSS_BUMPENVSCALE stub.
2006-12-19 23:05:08 +01:00
wined3d: Get rid of IWineD3DBaseShaderClass.
2011-03-30 20:49:24 +02:00
if (ps && stage && (ps->reg_maps.luminanceparams & (1 << stage)))
wined3d: Make the "luminanceparams" shader_reg_maps member a bitmap.
2009-08-12 09:44:26 +02:00
{
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
/* The pixel shader has to know the luminance scale. Do a constants update if it
* isn't scheduled anyway
*/
if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
!isStateDirty(context, STATE_PIXELSHADER)) {
shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
}
}
wined3d: Add a WINED3DTSS_BUMPENVLOFFSET stub.
2006-12-19 23:34:17 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void sampler_texmatrix(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Simplify sampler_texmatrix using pow2Matrix_identity.
2009-03-26 03:47:58 +01:00
const DWORD sampler = state - STATE_SAMPLER(0);
wined3d: Get rid of the IWineD3DBaseTexture typedefs.
2011-03-18 19:11:00 +01:00
struct wined3d_texture *texture = stateblock->state.textures[sampler];
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
wined3d: Add some traces to state handlers. Should make it a bit clearer what's happening in some cases.
2009-02-19 08:53:50 +01:00
TRACE("state %#x, stateblock %p, context %p\n", state, stateblock, context);
wined3d: Store the texture in a local variable in sampler_texmatrix(). Slightly improves readability.
2008-07-16 22:45:45 +02:00
if(!texture) return;
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
/* The fixed function np2 texture emulation uses the texture matrix to fix up the coordinates
wined3d: Remove COM from the texture implementation.
2011-03-18 19:10:59 +01:00
* wined3d_texture_apply_state_changes() multiplies the set matrix with a fixup matrix. Before the
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
* scaling is reapplied or removed, the texture matrix has to be reapplied
*
wined3d: Fix some typos.
2008-10-20 17:56:58 +02:00
* The mapped stage is already active because the sampler() function below, which is part of the
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
* misc pipeline
*/
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
if (sampler < MAX_TEXTURES)
{
wined3d: Replace "pow2_matrix_identity" in wined3d_texture with a flag.
2011-03-28 21:58:44 +02:00
const BOOL texIsPow2 = !(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT);
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
wined3d: Convert some BOOLs to bitfields in struct WineD3DContext. Also happens to fill two 3 byte holes.
2008-12-30 14:56:49 +01:00
if (texIsPow2 || (context->lastWasPow2Texture & (1 << sampler)))
{
if (texIsPow2) context->lastWasPow2Texture |= 1 << sampler;
else context->lastWasPow2Texture &= ~(1 << sampler);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
transform_texture(STATE_TEXTURESTAGE(stateblock->device->texUnitMap[sampler],
WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
wined3d: NP2 coordinate adjustment is a vertex operation. When a sampler is changed and unconditional NP2 textures are not supported, the texture matrix may need adjustment. The sampler state function checks for that, and calls the texture transform setting function in that case. However, samplers are a misc state, and the texture transform flags a vertex state. Thus split up the code and move the matrix changes to the vertex side.
2008-07-03 20:26:06 +02:00
}
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void sampler(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
DWORD sampler = state_id - STATE_SAMPLER(0);
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Explicitly pass parameters to shader_load_np2fixup_constants().
2010-10-25 12:33:40 +02:00
DWORD mapped_stage = device->texUnitMap[sampler];
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Remove IWineD3DDevice_ApplyStateChanges.
2007-01-02 00:07:55 +01:00
union {
float f;
DWORD d;
} tmpvalue;
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
TRACE("Sampler: %d\n", sampler);
/* 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
*/
wined3d: Skip sampler state application for stages that aren't mapped to a texture unit.
2007-01-03 19:18:59 +01:00
wined3d: Don't compare texUnitMap entries to -1.
2009-03-09 14:31:28 +01:00
if (mapped_stage == WINED3D_UNMAPPED_STAGE)
{
wined3d: Skip sampler state application for stages that aren't mapped to a texture unit.
2007-01-03 19:18:59 +01:00
TRACE("No sampler mapped to stage %d. Returning.\n", sampler);
return;
}
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (mapped_stage >= gl_info->limits.combined_samplers)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
return;
}
wined3d: Fake GL_ARB_multitexture.
2008-12-16 13:18:49 +01:00
GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB + mapped_stage));
checkGLcall("glActiveTextureARB");
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->textures[sampler])
wined3d: Move sampler states to wined3d_state.
2010-09-16 11:19:58 +02:00
{
wined3d: Get rid of the IWineD3DBaseTexture typedefs.
2011-03-18 19:11:00 +01:00
struct wined3d_texture *texture = state->textures[sampler];
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
BOOL srgb = state->sampler_states[sampler][WINED3DSAMP_SRGBTEXTURE];
wined3d: Move texture bindings to wined3d_state.
2010-09-17 11:59:40 +02:00
wined3d: Get rid of IWineD3DBaseTextureClass.
2011-03-28 21:58:42 +02:00
texture->texture_ops->texture_bind(texture, gl_info, srgb);
wined3d: Remove COM from the texture implementation.
2011-03-18 19:10:59 +01:00
wined3d_texture_apply_state_changes(texture, state->sampler_states[sampler], gl_info);
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_TEXTURE_LOD_BIAS])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
tmpvalue.d = state->sampler_states[sampler][WINED3DSAMP_MIPMAPLODBIAS];
wined3d: Remove IWineD3DDevice_ApplyStateChanges.
2007-01-02 00:07:55 +01:00
glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
GL_TEXTURE_LOD_BIAS_EXT,
tmpvalue.f);
wined3d: Fix some checkGLcall() messages.
2010-11-05 11:17:51 +01:00
checkGLcall("glTexEnvf(GL_TEXTURE_LOD_BIAS_EXT, ...)");
wined3d: Remove IWineD3DDevice_ApplyStateChanges.
2007-01-02 00:07:55 +01:00
}
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
if (!use_ps(state) && sampler < state->lowest_disabled_stage)
wined3d: Make use_vs() and use_ps() work on a stateblock instead of a device. Most callers work on a stateblock rather than a device, and the main fields we check (vertexShader and pixelShader) are part of the stateblock as well.
2008-12-30 14:56:49 +01:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->render_states[WINED3DRS_COLORKEYENABLE] && !sampler)
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
{
Assorted spelling fixes.
2007-01-04 10:47:11 +01:00
/* If color keying is enabled update the alpha test, it depends on the existence
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
* of a color key in stage 0
*/
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
}
}
wined3d: GLSL: Implement texrect coord fixup.
2009-03-26 03:19:41 +01:00
wined3d: Fix comments about NP2 fixup.
2009-07-01 18:36:51 +02:00
/* Trigger shader constant reloading (for NP2 texcoord fixup) */
wined3d: Replace "pow2_matrix_identity" in wined3d_texture with a flag.
2011-03-28 21:58:44 +02:00
if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
wined3d: Explicitly pass parameters to shader_load_np2fixup_constants().
2010-10-25 12:33:40 +02:00
device->shader_backend->shader_load_np2fixup_constants(device->shader_priv, gl_info, state);
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
}
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
else if (mapped_stage < gl_info->limits.textures)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (sampler < state->lowest_disabled_stage)
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
{
wined3d: Do not activate / deactivate texture dimensions twice.
2007-01-10 11:44:55 +01:00
/* TODO: What should I do with pixel shaders here ??? */
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (state->render_states[WINED3DRS_COLORKEYENABLE] && !sampler)
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
{
wined3d: Also update alpha test when stage texture is NULL.
2007-12-27 09:23:59 +01:00
/* If color keying is enabled update the alpha test, it depends on the existence
* of a color key in stage 0
*/
state_alpha(WINED3DRS_COLORKEYENABLE, stateblock, context);
}
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
} /* Otherwise tex_colorop disables the stage */
wined3d: Explicitly pass parameters to shader_load_np2fixup_constants().
2010-10-25 12:33:40 +02:00
glBindTexture(GL_TEXTURE_2D, device->dummyTextureName[sampler]);
checkGLcall("glBindTexture(GL_TEXTURE_2D, device->dummyTextureName[sampler])");
wined3d: Move samplers to the state table.
2006-12-19 23:26:39 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
void apply_pixelshader(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
BOOL use_vshader = use_vs(state);
BOOL use_pshader = use_ps(state);
wined3d: MSVC fixes in state.c.
2010-07-28 19:07:19 +02:00
unsigned int i;
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
if (use_pshader) {
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
if(!context->last_was_pshader) {
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
/* Former draw without a pixel shader, some samplers
* may be disabled because of WINED3DTSS_COLOROP = WINED3DTOP_DISABLE
* make sure to enable them
*/
wined3d: Increase the sizes of texturing related arrays, in order to support vertex textures.
2007-06-25 22:45:40 +02:00
for(i=0; i < MAX_FRAGMENT_SAMPLERS; i++) {
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(!isStateDirty(context, STATE_SAMPLER(i))) {
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
sampler(STATE_SAMPLER(i), stateblock, context);
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
}
}
wined3d: Properly update last_was_pshader.
2009-01-19 12:29:49 +01:00
context->last_was_pshader = TRUE;
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
} 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
wined3d: Use correct texture stage limits in a couple of places.
2010-01-27 20:19:42 +01:00
* while it was enabled, so re-apply them. */
for (i = 0; i < context->gl_info->limits.texture_stages; ++i)
{
wined3d: Don't call directly into the state table.
2010-04-01 11:34:44 +02:00
if (!isStateDirty(context, STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP)))
stateblock_apply_state(STATE_TEXTURESTAGE(i, WINED3DTSS_COLOROP), stateblock, context);
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
}
wined3d: Properly update last_was_pshader.
2009-01-19 12:29:49 +01:00
context->last_was_pshader = FALSE;
wined3d: Cleanup the pixelshader() state handler a little bit.
2007-02-13 19:53:20 +01:00
}
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
wined3d: Remove the state table from the shader backend.
2008-07-02 21:56:38 +02:00
if(!isStateDirty(context, device->StateTable[STATE_VSHADER].representative)) {
wined3d: Explicitly pass the context to the shader_select() handler.
2009-08-07 08:51:18 +02:00
device->shader_backend->shader_select(context, use_pshader, use_vshader);
wined3d: Move applying shader constants to the state table.
2007-01-06 18:17:27 +01:00
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (use_vshader || use_pshader)) {
wined3d: Cleanup the pixelshader() state handler a little bit.
2007-02-13 19:53:20 +01:00
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
wined3d: Apply shaders in their state handlers.
2007-01-06 18:14:12 +01:00
}
wined3d: Add pixel shaders to the state table.
2006-12-19 23:22:19 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void shader_bumpenvmat(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Renumber WINED3DTEXTURESTAGESTATETYPE enum elements. Saves some space by not having unused entries is the arrays tracking these states.
2009-01-06 11:43:45 +01:00
DWORD stage = (state - STATE_TEXTURESTAGE(0, 0)) / (WINED3D_HIGHEST_TEXTURE_STATE + 1);
wined3d: Get rid of the IWineD3DBaseShader typedefs.
2011-03-30 20:49:26 +02:00
const struct wined3d_shader *ps = stateblock->state.pixel_shader;
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
wined3d: Get rid of IWineD3DBaseShaderClass.
2011-03-30 20:49:24 +02:00
if (ps && stage && (ps->reg_maps.bumpmat & (1 << stage)))
wined3d: Make the "bumpmat" shader_reg_maps member a bitmap.
2009-08-12 09:44:25 +02:00
{
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
/* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
* anyway
*/
if(!isStateDirty(context, STATE_PIXELSHADERCONSTANT) &&
wined3d: Move shader constant affecting states to the misc pipeline. As long as we have the shader constants in misc, it is best to keep all the code that affects shader constants, like bumpenvmat setting, in there as well.
2008-07-04 23:54:06 +02:00
!isStateDirty(context, STATE_PIXELSHADER)) {
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
shaderconstant(STATE_PIXELSHADERCONSTANT, stateblock, context);
wined3d: Whitespace fix.
2008-07-12 04:16:28 +02:00
}
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
}
wined3d: Move shader constant affecting states to the misc pipeline. As long as we have the shader constants in misc, it is best to keep all the code that affects shader constants, like bumpenvmat setting, in there as well.
2008-07-04 23:54:06 +02:00
}
wined3d: Implement environment bump mapping with GL_ATI_envmap_bumpmap.
2007-05-04 14:28:09 +02:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void transform_world(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
/* 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
wined3d: Spelling fixes.
2008-01-09 20:37:05 +01:00
* and untransformed draws. It *may* happen that the world matrix is set 2 times during one
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
* draw, but that should be rather rare and cheaper in total.
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
*/
glMatrixMode(GL_MODELVIEW);
checkGLcall("glMatrixMode");
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
if(context->last_was_rhw) {
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
glLoadIdentity();
checkGLcall("glLoadIdentity()");
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
} else {
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
/* In the general case, the view matrix is the identity matrix */
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
if (stateblock->device->view_ident)
{
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
checkGLcall("glLoadMatrixf");
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
}
else
{
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_VIEW].u.m[0][0]);
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
checkGLcall("glLoadMatrixf");
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glMultMatrixf(&stateblock->state.transforms[WINED3DTS_WORLDMATRIX(0)].u.m[0][0]);
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
checkGLcall("glMultMatrixf");
}
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void clipplane(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
const struct wined3d_state *state = &stateblock->state;
UINT index = state_id - STATE_CLIPPLANE(0);
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW)) || index >= context->gl_info->limits.clipplanes)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
return;
}
wined3d: Make clip planes independent from offscreen/onscreen drawing.
2011-02-01 02:42:22 +01:00
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
/* Clip Plane settings are affected by the model view in OpenGL, the View transform in direct3d */
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
if (!use_vs(state))
glLoadMatrixf(&state->transforms[WINED3DTS_VIEW].u.m[0][0]);
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
else
wined3d: Support clipplanes with GLSL. This is the Nth attemt to make clipping work with GLSL shaders. The patch now uses the GLSL quirk table to handle cards that need a custom varying for gl_ClipPos, and the code is adapted to the changed state table and shader backend system.
2009-05-08 17:24:01 +02:00
/* with vertex shaders, clip planes are not transformed in direct3d,
* in OpenGL they are still transformed by the model view.
*/
glLoadIdentity();
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
TRACE("Clipplane [%.8e, %.8e, %.8e, %.8e]\n",
state->clip_planes[index][0],
state->clip_planes[index][1],
state->clip_planes[index][2],
state->clip_planes[index][3]);
glClipPlane(GL_CLIP_PLANE0 + index, state->clip_planes[index]);
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
checkGLcall("glClipPlane");
glPopMatrix();
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void transform_worldex(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
UINT matrix = state - STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0));
GLenum glMat;
TRACE("Setting world matrix %d\n", matrix);
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
if (matrix >= context->gl_info->limits.blends)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
WARN("Unsupported blend matrix set\n");
return;
} else if(isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
return;
}
/* GL_MODELVIEW0_ARB: 0x1700
wined3d: Fix some typos.
2008-10-20 17:56:58 +02:00
* GL_MODELVIEW1_ARB: 0x850a
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
* GL_MODELVIEW2_ARB: 0x8722
* GL_MODELVIEW3_ARB: 0x8723
* etc
* GL_MODELVIEW31_ARB: 0x873F
*/
if(matrix == 1) glMat = GL_MODELVIEW1_ARB;
else glMat = GL_MODELVIEW2_ARB - 2 + matrix;
glMatrixMode(glMat);
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
*/
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
if (stateblock->device->view_ident)
{
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
wined3d: Fix some macros definitions to make them proper C statements.
2008-12-03 10:03:26 +01:00
checkGLcall("glLoadMatrixf");
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
}
else
{
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_VIEW].u.m[0][0]);
wined3d: Fix some macros definitions to make them proper C statements.
2008-12-03 10:03:26 +01:00
checkGLcall("glLoadMatrixf");
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glMultMatrixf(&stateblock->state.transforms[WINED3DTS_WORLDMATRIX(matrix)].u.m[0][0]);
wined3d: Fix some macros definitions to make them proper C statements.
2008-12-03 10:03:26 +01:00
checkGLcall("glMultMatrixf");
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_vertexblend_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
WINED3DVERTEXBLENDFLAGS f = stateblock->state.render_states[WINED3DRS_VERTEXBLEND];
wined3d: Print a FIXME/WARN for all unsupported vertex blend flags.
2010-03-31 11:29:00 +02:00
static unsigned int once;
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
wined3d: Print a FIXME/WARN for all unsupported vertex blend flags.
2010-03-31 11:29:00 +02:00
if (f == WINED3DVBF_DISABLE) return;
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
wined3d: Print a FIXME/WARN for all unsupported vertex blend flags.
2010-03-31 11:29:00 +02:00
if (!once++) FIXME("Vertex blend flags %#x not supported.\n", f);
else WARN("Vertex blend flags %#x not supported.\n", f);
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void state_vertexblend(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
WINED3DVERTEXBLENDFLAGS val = stateblock->state.render_states[WINED3DRS_VERTEXBLEND];
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Print a FIXME/WARN for all unsupported vertex blend flags.
2010-03-31 11:29:00 +02:00
static unsigned int once;
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
switch(val) {
case WINED3DVBF_1WEIGHTS:
case WINED3DVBF_2WEIGHTS:
case WINED3DVBF_3WEIGHTS:
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
glEnable(GL_VERTEX_BLEND_ARB);
checkGLcall("glEnable(GL_VERTEX_BLEND_ARB)");
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
/* D3D adds one more matrix which has weight (1 - sum(weights)). This is enabled at context
* creation with enabling GL_WEIGHT_SUM_UNITY_ARB.
*/
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
GL_EXTCALL(glVertexBlendARB(stateblock->state.render_states[WINED3DRS_VERTEXBLEND] + 1));
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
if (!stateblock->device->vertexBlendUsed)
{
wined3d: Fix a few sign compare warnings.
2009-03-25 10:12:27 +01:00
unsigned int i;
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
for (i = 1; i < gl_info->limits.blends; ++i)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
if (!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i))))
{
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(i)), stateblock, context);
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
}
wined3d: Prevent some console spamming.
2007-10-07 10:57:46 +02:00
}
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->vertexBlendUsed = TRUE;
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
}
break;
wined3d: Print a FIXME/WARN for all unsupported vertex blend flags.
2010-03-31 11:29:00 +02:00
case WINED3DVBF_TWEENING:
case WINED3DVBF_0WEIGHTS: /* Indexed vertex blending, not supported. */
if (!once++) FIXME("Vertex blend flags %#x not supported.\n", val);
else WARN("Vertex blend flags %#x not supported.\n", val);
/* Fall through. */
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
case WINED3DVBF_DISABLE:
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
glDisable(GL_VERTEX_BLEND_ARB);
checkGLcall("glDisable(GL_VERTEX_BLEND_ARB)");
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
break;
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void transform_view(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Rename PLIGHTINFOEL to something less awful.
2009-10-14 10:55:16 +02:00
const struct wined3d_light_info *light = NULL;
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
unsigned int k;
/* If we are changing the View matrix, reset the light and clipping planes to the new view
* NOTE: We have to reset the positions even if the light/plane is not currently
* enabled, since the call to enable it will not reset the position.
* NOTE2: Apparently texture transforms do NOT need reapplying
*/
glMatrixMode(GL_MODELVIEW);
checkGLcall("glMatrixMode(GL_MODELVIEW)");
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_VIEW].u.m[0][0]);
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
checkGLcall("glLoadMatrixf(...)");
/* Reset lights. TODO: Call light apply func */
wined3d: Remove maxConcurrentLights from the device.
2011-05-18 09:12:40 +02:00
for (k = 0; k < gl_info->limits.lights; ++k)
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
{
wined3d: Move light state to wined3d_state.
2010-09-21 21:20:54 +02:00
light = stateblock->state.lights[k];
wined3d: Replace the light chain with a hashmap.
2007-02-14 17:46:54 +01:00
if(!light) continue;
glLightfv(GL_LIGHT0 + light->glIndex, GL_POSITION, light->lightPosn);
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
checkGLcall("glLightfv posn");
wined3d: Replace the light chain with a hashmap.
2007-02-14 17:46:54 +01:00
glLightfv(GL_LIGHT0 + light->glIndex, GL_SPOT_DIRECTION, light->lightDirn);
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
checkGLcall("glLightfv dirn");
}
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
/* Reset Clipping Planes */
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
for (k = 0; k < gl_info->limits.clipplanes; ++k)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Move clip planes to the state table.
2007-02-28 14:36:36 +01:00
if(!isStateDirty(context, STATE_CLIPPLANE(k))) {
clipplane(STATE_CLIPPLANE(k), stateblock, context);
}
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
}
wined3d: Move the functionality of primitiveInitState to the state table.
2007-01-02 22:47:10 +01:00
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
if(context->last_was_rhw) {
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
glLoadIdentity();
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.
*/
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
}
wined3d: Move WINED3DTS_MODELVIEW to the state table.
2007-01-02 00:48:58 +01:00
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
/* Avoid looping over a number of matrices if the app never used the functionality */
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
if (stateblock->device->vertexBlendUsed)
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
for (k = 1; k < gl_info->limits.blends; ++k)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)))) {
transform_worldex(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(k)), stateblock, context);
}
}
}
wined3d: Add stub handlers for world matrices 1-255.
2007-01-02 00:25:51 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void transform_projection(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
glMatrixMode(GL_PROJECTION);
checkGLcall("glMatrixMode(GL_PROJECTION)");
glLoadIdentity();
checkGLcall("glLoadIdentity");
wined3d: Get rid of the depth range hack.
2010-01-26 18:31:38 +01:00
if (context->last_was_rhw)
{
wined3d: Move the viewport to wined3d_state.
2010-09-15 12:00:06 +02:00
double x = stateblock->state.viewport.X;
double y = stateblock->state.viewport.Y;
double w = stateblock->state.viewport.Width;
double h = stateblock->state.viewport.Height;
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
wined3d: Get rid of the depth range hack.
2010-01-26 18:31:38 +01:00
TRACE("Calling glOrtho with x %.8e, y %.8e, w %.8e, h %.8e.\n", x, y, w, h);
if (context->render_offscreen)
glOrtho(x, x + w, -y, -y - h, 0.0, -1.0);
else
glOrtho(x, x + w, y + h, y, 0.0, -1.0);
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
checkGLcall("glOrtho");
/* D3D texture coordinates are flipped compared to OpenGL ones, so
* render everything upside down when rendering offscreen. */
wined3d: Track render_offscreen in the context. This makes sure the relevant states in FindContext() are actually marked dirty when needed.
2009-08-06 08:12:19 +02:00
if (context->render_offscreen)
{
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
glScalef(1.0f, -1.0f, 1.0f);
wined3d: Get rid of the invymat. glScalef(1.0, -1.0, 1.0) does the same as the glMultMatrix with the invymat matrix, and it is more optimal.
2007-12-25 23:14:05 +01:00
checkGLcall("glScalef");
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
}
wined3d: Translate before scaling for rhw as well in transform_projection().
2010-09-05 23:38:49 +02:00
/* Window Coord 0 is the middle of the first pixel, so translate by 1/2 pixels */
glTranslatef(63.0f / 128.0f, 63.0f / 128.0f, 0.0f);
wined3d: Fix typo in checkGLcall.
2010-09-08 21:50:02 +02:00
checkGLcall("glTranslatef(63.0f / 128.0f, 63.0f / 128.0f, 0.0f)");
wined3d: Translate before scaling for rhw as well in transform_projection().
2010-09-05 23:38:49 +02:00
}
else
{
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
/* The rule is that the window coordinate 0 does not correspond to the
beginning of the first pixel, but the center of the first pixel.
As a consequence if you want to correctly draw one line exactly from
the left to the right end of the viewport (with all matrices set to
be identity), the x coords of both ends of the line would be not
-1 and 1 respectively but (-1-1/viewport_widh) and (1-1/viewport_width)
wined3d: Fix the half pixel correction.
2007-08-19 19:43:44 +02:00
instead.
1.0 / Width is used because the coord range goes from -1.0 to 1.0, then we
divide by the Width/Height, so we need the half range(1.0) to translate by
half a pixel.
wined3d: Fix the z range.
2007-08-31 20:32:52 +02:00
The other fun is that d3d's output z range after the transformation is [0;1],
but opengl's is [-1;1]. Since the z buffer is in range [0;1] for both, gl
scales [-1;1] to [0;1]. This would mean that we end up in [0.5;1] and loose a lot
of Z buffer precision and the clear values do not match in the z test. Thus scale
[0;1] to [-1;1], so when gl undoes that we utilize the full z range
wined3d: Fix the half pixel correction.
2007-08-19 19:43:44 +02:00
*/
wined3d: Translate one pixel down after flipping for offscreen rendering.
2008-09-08 10:15:51 +02:00
wined3d: Fix the half pixel offset. Turns out the original fix was correct for fixed function, but for the wrong reason. The shader path was already correct. This fixes a regresssion introduced by 932e95c111118b643650d6643e47be0ddb5528a1.
2008-09-10 11:08:10 +02:00
/*
* Careful with the order of operations here, we're essentially working backwards:
* x = x + 1/w;
* y = (y - 1/h) * flip;
* z = z * 2 - 1;
*
* Becomes:
* glTranslatef(0.0, 0.0, -1.0);
* glScalef(1.0, 1.0, 2.0);
*
* glScalef(1.0, flip, 1.0);
* glTranslatef(1/w, -1/h, 0.0);
*
* This is equivalent to:
* glTranslatef(1/w, -flip/h, -1.0)
* glScalef(1.0, flip, 2.0);
*/
wined3d: Try to force a top-left filling convention.
2009-08-19 10:55:36 +02:00
/* Translate by slightly less than a half pixel to force a top-left
* filling convention. 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. */
wined3d: Move the viewport to wined3d_state.
2010-09-15 12:00:06 +02:00
GLfloat xoffset = (63.0f / 64.0f) / stateblock->state.viewport.Width;
GLfloat yoffset = -(63.0f / 64.0f) / stateblock->state.viewport.Height;
wined3d: Try to force a top-left filling convention.
2009-08-19 10:55:36 +02:00
wined3d: Track render_offscreen in the context. This makes sure the relevant states in FindContext() are actually marked dirty when needed.
2009-08-06 08:12:19 +02:00
if (context->render_offscreen)
{
wined3d: Combine two glScalef calls into one.
2007-12-26 22:12:05 +01:00
/* D3D texture coordinates are flipped compared to OpenGL ones, so
* render everything upside down when rendering offscreen. */
wined3d: Try to force a top-left filling convention.
2009-08-19 10:55:36 +02:00
glTranslatef(xoffset, -yoffset, -1.0f);
checkGLcall("glTranslatef(xoffset, -yoffset, -1.0f)");
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
glScalef(1.0f, -1.0f, 2.0f);
wined3d: Combine two glScalef calls into one.
2007-12-26 22:12:05 +01:00
} else {
wined3d: Try to force a top-left filling convention.
2009-08-19 10:55:36 +02:00
glTranslatef(xoffset, yoffset, -1.0f);
checkGLcall("glTranslatef(xoffset, yoffset, -1.0f)");
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
glScalef(1.0f, 1.0f, 2.0f);
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
}
wined3d: Combine two glScalef calls into one.
2007-12-26 22:12:05 +01:00
checkGLcall("glScalef");
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glMultMatrixf(&stateblock->state.transforms[WINED3DTS_PROJECTION].u.m[0][0]);
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
checkGLcall("glLoadMatrixf");
}
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* This should match any arrays loaded in loadVertexData.
* TODO: Only load / unload arrays if we have to.
*/
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
static inline void unloadVertexData(const struct wined3d_gl_info *gl_info)
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_SECONDARY_COLOR])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
glDisableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
}
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_VERTEX_BLEND])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Unload vertex weight data in unloadVertexData.
2007-05-06 23:47:20 +02:00
glDisableClientState(GL_WEIGHT_ARRAY_ARB);
}
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
unloadTexCoords(gl_info);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
static inline void unload_numbered_array(struct wined3d_context *context, int i)
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
GL_EXTCALL(glDisableVertexAttribArrayARB(i));
checkGLcall("glDisableVertexAttribArrayARB(reg)");
context->numbered_array_mask &= ~(1 << i);
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* This should match any arrays loaded in loadNumberedArrays
* TODO: Only load / unload arrays if we have to.
*/
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
static inline void unloadNumberedArrays(struct wined3d_context *context)
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* disable any attribs (this is the same for both GLSL and ARB modes) */
wined3d: Initialize maxAttribs in case it isn't changed by glGetIntegerv.
2008-03-22 18:28:52 +01:00
GLint maxAttribs = 16;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
int i;
/* Leave all the attribs disabled */
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &maxAttribs);
/* MESA does not support it right not */
if (glGetError() != GL_NO_ERROR)
maxAttribs = 16;
for (i = 0; i < maxAttribs; ++i) {
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
unload_numbered_array(context, i);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void loadNumberedArrays(struct wined3d_stateblock *stateblock,
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
const struct wined3d_stream_info *stream_info, struct wined3d_context *context)
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
int i;
wined3d: Merge IWineD3DVertexBuffer with IWineD3DBuffer. That still leaves IWineD3DIndexBuffer, but that code is also mostly similar, except for the conversion code (which will be unused there).
2009-03-06 14:56:23 +01:00
struct wined3d_buffer *vb;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
/* Default to no instancing */
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->instancedDraw = FALSE;
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
for (i = 0; i < MAX_ATTRIBS; i++)
{
const struct wined3d_stream_state *stream;
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (!(stream_info->use_map & (1 << i)))
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
continue;
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[stream_info->elements[i].stream_idx];
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
/* Do not load instance data. It will be specified using glTexCoord by drawprim */
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
if (stream->flags & WINED3DSTREAMSOURCE_INSTANCEDATA)
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->instancedDraw = TRUE;
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
continue;
}
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
TRACE_(d3d_shader)("Loading array %u [VBO=%u]\n", i, stream_info->elements[i].buffer_object);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (stream_info->elements[i].stride)
{
if (curVBO != stream_info->elements[i].buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, stream_info->elements[i].buffer_object));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = stream_info->elements[i].buffer_object;
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
}
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
/* 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. */
vb = stream->buffer;
wined3d: Remove FLOAT16 vertex attribute conversion support. All mayor drivers support GL_ARB_half_float_vertex now and the half float conversion doesn't work well in practise. The only game that was ever playable with it was Eve online.
2011-02-06 23:47:49 +01:00
GL_EXTCALL(glVertexAttribPointerARB(i, stream_info->elements[i].format->gl_vtx_format,
stream_info->elements[i].format->gl_vtx_type,
stream_info->elements[i].format->gl_normalized,
stream_info->elements[i].stride, stream_info->elements[i].data
+ stateblock->state.load_base_vertex_index * stream_info->elements[i].stride
+ stream->offset));
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
if (!(context->numbered_array_mask & (1 << i)))
{
GL_EXTCALL(glEnableVertexAttribArrayARB(i));
context->numbered_array_mask |= (1 << i);
}
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
}
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. */
const BYTE *ptr = stream_info->elements[i].data + stream->offset;
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (stream_info->elements[i].buffer_object)
{
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
vb = stream->buffer;
wined3d: Avoid using the long type.
2010-05-21 12:45:40 +02:00
ptr += (ULONG_PTR)buffer_get_sysmem(vb, gl_info);
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
}
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
switch (stream_info->elements[i].format->id)
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R32_FLOAT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib1fvARB(i, (const GLfloat *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R32G32_FLOAT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib2fvARB(i, (const GLfloat *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R32G32B32_FLOAT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib3fvARB(i, (const GLfloat *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R32G32B32A32_FLOAT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib4fvARB(i, (const GLfloat *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R8G8B8A8_UINT:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
break;
wined3d: Use the DXGI naming convention for all formats.
2009-09-25 13:31:49 +02:00
case WINED3DFMT_B8G8R8A8_UNORM:
wined3d: Add support for ARB_vertex_array_bgra.
2010-01-25 19:51:31 +01:00
if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
wined3d: Take EXT_vertex_array_bgra into account in send_attribute() and loadNumberedArrays().
2009-01-23 10:22:33 +01:00
{
const DWORD *src = (const DWORD *)ptr;
DWORD c = *src & 0xff00ff00;
c |= (*src & 0xff0000) >> 16;
c |= (*src & 0xff) << 16;
GL_EXTCALL(glVertexAttrib4NubvARB(i, (GLubyte *)&c));
break;
}
/* else fallthrough */
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R8G8B8A8_UNORM:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
GL_EXTCALL(glVertexAttrib4NubvARB(i, ptr));
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16_SINT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib4svARB(i, (const GLshort *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16B16A16_SINT:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib4svARB(i, (const GLshort *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16_SNORM:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
{
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
const GLshort s[4] = {((const GLshort *)ptr)[0], ((const GLshort *)ptr)[1], 0, 1};
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
GL_EXTCALL(glVertexAttrib4NsvARB(i, s));
break;
}
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16_UNORM:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
{
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
const GLushort s[4] = {((const GLushort *)ptr)[0], ((const GLushort *)ptr)[1], 0, 1};
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
GL_EXTCALL(glVertexAttrib4NusvARB(i, s));
break;
}
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16B16A16_SNORM:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib4NsvARB(i, (const GLshort *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16B16A16_UNORM:
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
GL_EXTCALL(glVertexAttrib4NusvARB(i, (const GLushort *)ptr));
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R10G10B10A2_UINT:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
FIXME("Unsure about WINED3DDECLTYPE_UDEC3\n");
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
/*glVertexAttrib3usvARB(i, (const GLushort *)ptr); Does not exist */
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R10G10B10A2_SNORM:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
FIXME("Unsure about WINED3DDECLTYPE_DEC3N\n");
wined3d: Make the lpData member of WineDirect3DStridedData const.
2008-11-28 15:30:12 +01:00
/*glVertexAttrib3NusvARB(i, (const GLushort *)ptr); Does not exist */
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
break;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16_FLOAT:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
/* 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;
wined3d: Unify vertex and texture formats. Some fields should be redundant now, eg. gl_vtx_type and glType. I'll leave that for a different patch to fix though.
2009-03-27 10:25:56 +01:00
case WINED3DFMT_R16G16B16A16_FLOAT:
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
FIXME("Unsupported WINED3DDECLTYPE_FLOAT16_4\n");
break;
default:
ERR("Unexpected declaration in stride 0 attributes\n");
break;
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Correctly load vertex attributes with a stride of 0.
2007-02-14 17:55:56 +01:00
}
wined3d: Emulate half float vertices if GL_NV_half_float is not there.
2007-12-17 18:18:19 +01:00
checkGLcall("Loading numbered arrays");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
/* Used from 2 different functions, and too big to justify making it inlined */
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void loadVertexData(const struct wined3d_context *context, struct wined3d_stateblock *stateblock,
wined3d: Pass the context's gl_info to state handlers.
2009-08-19 10:55:38 +02:00
const struct wined3d_stream_info *si)
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
const struct wined3d_gl_info *gl_info = context->gl_info;
GLuint curVBO = gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] ? ~0U : 0;
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
const struct wined3d_stream_info_element *e;
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
const struct wined3d_stream_state *stream;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
TRACE("Using fast vertex array code\n");
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
/* This is fixed function pipeline only, and the fixed function pipeline doesn't do instancing */
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->instancedDraw = FALSE;
wined3d: Instancing emulation.
2007-02-14 17:56:29 +01:00
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* Blend Data ---------------------------------------------- */
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if ((si->use_map & (1 << WINED3D_FFP_BLENDWEIGHT))
|| si->use_map & (1 << WINED3D_FFP_BLENDINDICES))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
e = &si->elements[WINED3D_FFP_BLENDWEIGHT];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[e->stream_idx];
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_VERTEX_BLEND])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
TRACE("Blend %u %p %u\n", e->format->component_count,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride, e->stride + stream->offset);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
glEnableClientState(GL_WEIGHT_ARRAY_ARB);
checkGLcall("glEnableClientState(GL_WEIGHT_ARRAY_ARB)");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
GL_EXTCALL(glVertexBlendARB(e->format->component_count + 1));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = e->buffer_object;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
TRACE("glWeightPointerARB(%#x, %#x, %#x, %p);\n",
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
e->format->gl_vtx_format,
e->format->gl_vtx_type,
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
GL_EXTCALL(glWeightPointerARB(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glWeightPointerARB");
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_BLENDINDICES))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Handle a few "silent" FIXMEs more consistent with the rest of the code. Also avoids needlessly initializing static variables.
2008-12-01 15:32:14 +01:00
static BOOL warned;
if (!warned)
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
FIXME("blendMatrixIndices support\n");
wined3d: Handle a few "silent" FIXMEs more consistent with the rest of the code. Also avoids needlessly initializing static variables.
2008-12-01 15:32:14 +01:00
warned = TRUE;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
}
} else {
wined3d: Only scream about unsupported vertex blending when it is used.
2007-02-16 19:15:15 +01:00
/* 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");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[ARB_VERTEX_BLEND])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Implement vertex blending using GL_ARB_vertex_blend.
2007-04-27 00:43:15 +02:00
static const GLbyte one = 1;
GL_EXTCALL(glWeightbvARB(1, &one));
wined3d: Fix some checkGLcall() messages.
2010-11-05 11:17:51 +01:00
checkGLcall("glWeightbvARB(gl_info->max_blends, weights)");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
}
/* Point Size ----------------------------------------------*/
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_PSIZE))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* 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 -----------------------------------------*/
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_POSITION))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
e = &si->elements[WINED3D_FFP_POSITION];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[e->stream_idx];
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = e->buffer_object;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Add support for EXT_vertex_array_bgra. This allows us to skip BGRA->RGBA color conversion for vertex attributes if this extension is present.
2009-01-08 10:19:17 +01:00
/* min(WINED3D_ATR_FORMAT(position),3) to Disable RHW mode as 'w' coord
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
handling for rhw mode should not impact screen position whereas in GL it does.
Assorted spelling fixes.
2008-01-23 15:16:30 +01:00
This may result in very slightly distorted textures in rhw mode.
There's always the other option of fixing the view matrix to
prevent w from having any effect.
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
This only applies to user pointer sources, in VBOs the vertices are fixed up
*/
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (!e->buffer_object)
{
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
TRACE("glVertexPointer(3, %#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
glVertexPointer(3 /* min(e->format->gl_vtx_format, 3) */, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
}
else
{
TRACE("glVertexPointer(%#x, %#x, %#x, %p);\n",
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
glVertexPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
checkGLcall("glVertexPointer(...)");
glEnableClientState(GL_VERTEX_ARRAY);
checkGLcall("glEnableClientState(GL_VERTEX_ARRAY)");
}
/* Normals -------------------------------------------------*/
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_NORMAL))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
e = &si->elements[WINED3D_FFP_NORMAL];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[e->stream_idx];
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = e->buffer_object;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
TRACE("glNormalPointer(%#x, %#x, %p);\n", e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
glNormalPointer(e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glNormalPointer(...)");
glEnableClientState(GL_NORMAL_ARRAY);
checkGLcall("glEnableClientState(GL_NORMAL_ARRAY)");
} else {
wined3d: Use 0/0/0 as normal if no normal is supplied.
2007-08-21 18:05:27 +02:00
glNormal3f(0, 0, 0);
checkGLcall("glNormal3f(0, 0, 0)");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
/* Diffuse Colour --------------------------------------------*/
/* WARNING: Data here MUST be in RGBA format, so cannot */
/* go directly into fast mode from app pgm, because */
/* directx requires data in BGRA format. */
Assorted spelling fixes.
2008-01-23 15:16:30 +01:00
/* currently fixupVertices swizzles the format, but this isn't*/
Spelling fixes.
2008-04-22 08:18:14 +02:00
/* very practical when using VBOs */
Assorted spelling fixes.
2008-01-23 15:16:30 +01:00
/* NOTE: Unless we write a vertex shader to swizzle the colour*/
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
/* , or the user doesn't care and wants the speed advantage */
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_DIFFUSE))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
e = &si->elements[WINED3D_FFP_DIFFUSE];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[e->stream_idx];
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = e->buffer_object;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Fixed function vertex attribute types are flexible.
2007-12-19 17:10:02 +01:00
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
TRACE("glColorPointer(%#x, %#x %#x, %p);\n",
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
glColorPointer(e->format->gl_vtx_format, e->format->gl_vtx_type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glColorPointer(4, GL_UNSIGNED_BYTE, ...)");
glEnableClientState(GL_COLOR_ARRAY);
checkGLcall("glEnableClientState(GL_COLOR_ARRAY)");
} else {
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
checkGLcall("glColor4f(1, 1, 1, 1)");
}
/* Specular Colour ------------------------------------------*/
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
if (si->use_map & (1 << WINED3D_FFP_SPECULAR))
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
TRACE("setting specular colour\n");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
wined3d: Properly check if an attribute is used in loadVertexData().
2009-08-24 09:27:51 +02:00
e = &si->elements[WINED3D_FFP_SPECULAR];
wined3d: Move stream state to wined3d_state.
2010-09-20 19:41:22 +02:00
stream = &stateblock->state.streams[e->stream_idx];
wined3d: Introduce a structure for stream state.
2010-09-14 13:38:41 +02:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_SECONDARY_COLOR])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Rename wined3d_format_desc to wined3d_format.
2010-08-30 20:29:49 +02:00
GLenum type = e->format->gl_vtx_type;
GLint format = e->format->gl_vtx_format;
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
if (curVBO != e->buffer_object)
{
GL_EXTCALL(glBindBufferARB(GL_ARRAY_BUFFER_ARB, e->buffer_object));
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
checkGLcall("glBindBufferARB");
wined3d: Use separate structures for ddraw style strided data and wined3d's internal stream info.
2009-03-27 10:25:55 +01:00
curVBO = e->buffer_object;
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (format != 4 || (gl_info->quirks & WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA))
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
{
/* 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
*/
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
TRACE("glSecondaryColorPointer(%#x, %#x, %#x, %p);\n", format, type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
GL_EXTCALL(glSecondaryColorPointerEXT(format, type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset));
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
checkGLcall("glSecondaryColorPointerEXT(format, type, ...)");
}
else
{
switch(type)
{
case GL_UNSIGNED_BYTE:
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
TRACE("glSecondaryColorPointer(3, GL_UNSIGNED_BYTE, %#x, %p);\n", e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
GL_EXTCALL(glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset));
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
checkGLcall("glSecondaryColorPointerEXT(3, GL_UNSIGNED_BYTE, ...)");
break;
default:
FIXME("Add 4 component specular color pointers for type %x\n", type);
/* Make sure that the right color component is dropped */
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
TRACE("glSecondaryColorPointer(3, %#x, %#x, %p);\n", type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset);
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
GL_EXTCALL(glSecondaryColorPointerEXT(3, type, e->stride,
wined3d: Move base vertex state to wined3d_state.
2010-09-20 19:41:24 +02:00
e->data + stateblock->state.load_base_vertex_index * e->stride + stream->offset));
wined3d: Only use 4 component specular colors if GL allows it.
2009-07-10 11:28:49 +02:00
checkGLcall("glSecondaryColorPointerEXT(3, type, ...)");
}
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT);
wined3d: Get rid of vcheckGLcall. Everywhere it's used a regular checkGLcall will do just as well.
2008-12-03 14:53:44 +01:00
checkGLcall("glEnableClientState(GL_SECONDARY_COLOR_ARRAY_EXT)");
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
}
else
{
WARN("Specular colour is not supported in this GL implementation.\n");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
}
else
{
wined3d: Remove a few redundant context dereferences.
2010-01-04 21:33:10 +01:00
if (gl_info->supported[EXT_SECONDARY_COLOR])
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
{
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
GL_EXTCALL(glSecondaryColor3fEXT)(0, 0, 0);
checkGLcall("glSecondaryColor3fEXT(0, 0, 0)");
wined3d: Replace some VTRACEs with proper TRACEs.
2010-03-17 21:59:52 +01:00
}
else
{
WARN("Specular colour is not supported in this GL implementation.\n");
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
}
/* Texture coords -------------------------------------------*/
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
loadTexCoords(gl_info, stateblock, si, &curVBO);
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void streamsrc(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Pass a wined3d_state structure to use_vs().
2010-09-28 12:00:23 +02:00
BOOL load_numbered = use_vs(&stateblock->state) && !device->useDrawStridedSlow;
BOOL load_named = !use_vs(&stateblock->state) && !device->useDrawStridedSlow;
wined3d: Move debugging fixmes from drawprim to the stream source handler.
2007-01-06 18:13:21 +01:00
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
if (context->numberedArraysLoaded && !load_numbered)
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
unloadNumberedArrays(context);
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
context->numberedArraysLoaded = FALSE;
context->numbered_array_mask = 0;
}
else if (context->namedArraysLoaded)
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
unloadVertexData(context->gl_info);
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
context->namedArraysLoaded = FALSE;
}
if (load_numbered)
{
TRACE("Loading numbered arrays\n");
wined3d: Update the stream info before applying states.
2010-02-03 11:02:22 +01:00
loadNumberedArrays(stateblock, &device->strided_streams, context);
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
context->numberedArraysLoaded = TRUE;
}
else if (load_named)
{
TRACE("Loading vertex data\n");
wined3d: Update the stream info before applying states.
2010-02-03 11:02:22 +01:00
loadVertexData(context, stateblock, &device->strided_streams);
wined3d: Avoid disabling numbered arrays if we're going to enable them afterwards anyway.
2008-12-08 10:30:02 +01:00
context->namedArraysLoaded = TRUE;
}
wined3d: Move decoding the streams to their own inline function.
2007-01-04 00:13:15 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void vertexdeclaration(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
const struct wined3d_state *state = &stateblock->state;
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
struct wined3d_device *device = stateblock->device;
wined3d: Pass a wined3d_state structure to use_ps().
2010-09-28 12:00:24 +02:00
BOOL useVertexShaderFunction = use_vs(state);
BOOL usePixelShaderFunction = use_ps(state);
wined3d: Fix use_vs() usage in vertexdeclaration().
2008-12-15 16:35:15 +01:00
BOOL updateFog = FALSE;
wined3d: Move decoding the streams to their own inline function.
2007-01-04 00:13:15 +01:00
BOOL transformed;
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
BOOL wasrhw = context->last_was_rhw;
wined3d: Update clipplanes on a shader-fixed function switch. The view matrix that was set at the time the clipplane was applied is hardcoded into the clipplane. With vertex shaders clip planes ignore the view matrix in d3d. We implement that, but this also means that the clip planes potentially change when we switch between vs and fixed func.
2009-05-29 01:09:22 +02:00
unsigned int i;
wined3d: Move decoding the streams to their own inline function.
2007-01-04 00:13:15 +01:00
wined3d: Move position_transformed out of u.s in struct WineDirect3DVertexStridedData.
2009-01-08 10:19:16 +01:00
transformed = device->strided_streams.position_transformed;
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
if (transformed != context->last_was_rhw && !useVertexShaderFunction)
wined3d: Move the functionality of primitiveInitState to the state table.
2007-01-02 22:47:10 +01:00
updateFog = TRUE;
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
if (transformed) {
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
context->last_was_rhw = TRUE;
wined3d: Move the functionality of primitiveInitState to the state table.
2007-01-02 22:47:10 +01:00
} else {
/* Untransformed, so relies on the view and projection matrices */
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
context->last_was_rhw = FALSE;
wined3d: Move the world matrix to the state table.
2007-01-02 22:47:39 +01:00
/* This turns off the Z scale trick to 'disable' viewport frustum clipping in rhw mode*/
wined3d: Move the functionality of primitiveInitState to the state table.
2007-01-02 22:47:10 +01:00
device->untransformed = TRUE;
}
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
/* 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
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
*/
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
if(!useVertexShaderFunction) {
/* TODO: Move this mainly to the viewport state and only apply when the vp has changed
* or transformed / untransformed was switched
*/
wined3d: Store state optmization members in the context.
2007-02-12 19:18:27 +01:00
if(wasrhw != context->last_was_rhw &&
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION)) &&
!isStateDirty(context, STATE_VIEWPORT)) {
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
}
/* 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(transformed != wasrhw &&
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0))) &&
!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_VIEW))) {
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
wined3d: Remove d3ddevice_set_ortho.
2007-01-02 22:52:11 +01:00
}
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
wined3d: Store dirty states per context.
2007-02-12 19:18:31 +01:00
if(!isStateDirty(context, STATE_RENDER(WINED3DRS_COLORVERTEX))) {
wined3d: Add a per context structure for context management.
2007-02-12 19:18:22 +01:00
state_colormat(STATE_RENDER(WINED3DRS_COLORVERTEX), stateblock, context);
wined3d: Move material applying to the state table.
2007-01-10 11:26:12 +01:00
}
wined3d: Don't reapply lighting when vertex shaders are used. If a vertex shader is used the GL_LIGHTING state is ignored. If the shader is turned off state_vdecl is called anyway, so it will adjust the lighting state to match the available fixed function vertex attributes.
2010-10-29 18:15:23 +02:00
if(!isStateDirty(context, STATE_RENDER(WINED3DRS_LIGHTING))) {
state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock, context);
}
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
if(context->last_was_vshader) {
updateFog = TRUE;
wined3d: Support clipplanes with GLSL. This is the Nth attemt to make clipping work with GLSL shaders. The patch now uses the GLSL quirk table to handle cards that need a custom varying for gl_ClipPos, and the code is adapted to the changed state table and shader backend system.
2009-05-08 17:24:01 +02:00
if(!device->vs_clipping && !isStateDirty(context, STATE_RENDER(WINED3DRS_CLIPPLANEENABLE))) {
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
state_clipping(STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), stateblock, context);
}
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
for (i = 0; i < gl_info->limits.clipplanes; ++i)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Update clipplanes on a shader-fixed function switch. The view matrix that was set at the time the clipplane was applied is hardcoded into the clipplane. With vertex shaders clip planes ignore the view matrix in d3d. We implement that, but this also means that the clip planes potentially change when we switch between vs and fixed func.
2009-05-29 01:09:22 +02:00
clipplane(STATE_CLIPPLANE(i), stateblock, context);
}
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
}
wined3d: Use 0/0/0 as normal if no normal is supplied.
2007-08-21 18:05:27 +02:00
if(!isStateDirty(context, STATE_RENDER(WINED3DRS_NORMALIZENORMALS))) {
state_normalize(STATE_RENDER(WINED3DRS_NORMALIZENORMALS), stateblock, context);
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
} else {
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
if(!context->last_was_vshader) {
static BOOL warned = FALSE;
wined3d: Support clipplanes with GLSL. This is the Nth attemt to make clipping work with GLSL shaders. The patch now uses the GLSL quirk table to handle cards that need a custom varying for gl_ClipPos, and the code is adapted to the changed state table and shader backend system.
2009-05-08 17:24:01 +02:00
if(!device->vs_clipping) {
/* Disable all clip planes to get defined results on all drivers. See comment in the
* state_clipping state handler
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
for (i = 0; i < gl_info->limits.clipplanes; ++i)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Support clipplanes with GLSL. This is the Nth attemt to make clipping work with GLSL shaders. The patch now uses the GLSL quirk table to handle cards that need a custom varying for gl_ClipPos, and the code is adapted to the changed state table and shader backend system.
2009-05-08 17:24:01 +02:00
glDisable(GL_CLIP_PLANE0 + i);
checkGLcall("glDisable(GL_CLIP_PLANE0 + i)");
}
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
wined3d: Introduce a separate structure for stateblock states. We'd like to not pass an entire stateblock to things like state handlers and the shader backend, because those then use the stateblock to get to the device and through there to all the rest of wined3d. This would also be required for serialization of wined3d draw and state change commands into a single GL context. Resource updates would be explicitly excluded from serialization.
2010-09-15 12:00:04 +02:00
if (!warned && stateblock->state.render_states[WINED3DRS_CLIPPLANEENABLE])
{
wined3d: Support clipplanes with GLSL. This is the Nth attemt to make clipping work with GLSL shaders. The patch now uses the GLSL quirk table to handle cards that need a custom varying for gl_ClipPos, and the code is adapted to the changed state table and shader backend system.
2009-05-08 17:24:01 +02:00
FIXME("Clipping not supported with vertex shaders\n");
warned = TRUE;
}
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
}
wined3d: Apply matrices when switching from transformed vertices to shaders.
2007-11-11 21:46:17 +01:00
if(wasrhw) {
/* Apply the transform matrices when switching from rhw drawing to vertex shaders. Vertex
Assorted spelling fixes.
2007-12-07 01:03:54 +01:00
* shaders themselves do not need it, but the matrices are not reapplied automatically when
wined3d: Apply matrices when switching from transformed vertices to shaders.
2007-11-11 21:46:17 +01:00
* 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
*/
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
}
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)))) {
transform_world(STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(0)), stateblock, context);
}
}
wined3d: Get rid of last_was_foggy_shader & friends. The fog settings do not depend on wether the shader writes to oFog or not, instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a vertex shader is bound at all. It works the same way as with the fixed function, and having a vertex shader is the same as using pretransformed vertices, just that the fog coord comes from the shader instead of the specular color: FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored FOGTABLEMODE == NONE, with VS: oFog is used FOGTABLEMODE == NONE, no VS, XYZ: Z is used FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
updateFog = TRUE;
wined3d: Update clipplanes on a shader-fixed function switch. The view matrix that was set at the time the clipplane was applied is hardcoded into the clipplane. With vertex shaders clip planes ignore the view matrix in d3d. We implement that, but this also means that the clip planes potentially change when we switch between vs and fixed func.
2009-05-29 01:09:22 +02:00
/* 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.
*/
wined3d: Introduce a separate structure for various OpenGL implementation limits.
2009-10-29 10:37:10 +01:00
for (i = 0; i < gl_info->limits.clipplanes; ++i)
wined3d: Get rid of GL_LIMITS.
2009-10-22 10:09:54 +02:00
{
wined3d: Update clipplanes on a shader-fixed function switch. The view matrix that was set at the time the clipplane was applied is hardcoded into the clipplane. With vertex shaders clip planes ignore the view matrix in d3d. We implement that, but this also means that the clip planes potentially change when we switch between vs and fixed func.
2009-05-29 01:09:22 +02:00
clipplane(STATE_CLIPPLANE(i), stateblock, context);
}
wined3d: Clip planes with vertex shaders.
2007-02-27 23:11:15 +01:00
}
wined3d: Move applying shader constants to the state table.
2007-01-06 18:17:27 +01:00
}
wined3d: Apply shaders in their state handlers.
2007-01-06 18:14:12 +01:00
wined3d: Always select the correct shader pair in the vertexdeclaration() state handler.
2007-02-13 19:53:11 +01:00
/* Vertex and pixel shaders are applied together for now, so let the last dirty state do the
* application
*/
if (!isStateDirty(context, STATE_PIXELSHADER)) {
wined3d: Explicitly pass the context to the shader_select() handler.
2009-08-07 08:51:18 +02:00
device->shader_backend->shader_select(context, usePixelShaderFunction, useVertexShaderFunction);
wined3d: Apply shaders in their state handlers.
2007-01-06 18:14:12 +01:00
wined3d: Always select the correct shader pair in the vertexdeclaration() state handler.
2007-02-13 19:53:11 +01:00
if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT) && (useVertexShaderFunction || usePixelShaderFunction)) {
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
wined3d: Apply shaders in their state handlers.
2007-01-06 18:14:12 +01:00
}
wined3d: Move applying the gl stream sources to the state table.
2007-01-06 18:11:21 +01:00
}
wined3d: Move the projection matrix into its own state.
2007-01-02 22:50:38 +01:00
wined3d: Always select the correct shader pair in the vertexdeclaration() state handler.
2007-02-13 19:53:11 +01:00
context->last_was_vshader = useVertexShaderFunction;
wined3d: Don't call directly into the state table.
2010-04-01 11:34:44 +02:00
if (updateFog) stateblock_apply_state(STATE_RENDER(WINED3DRS_FOGVERTEXMODE), stateblock, context);
wined3d: Some texture transform fixes.
2007-08-27 14:33:46 +02:00
if(!useVertexShaderFunction) {
wined3d: Texture transforms are disabled when drawing rhw vertices.
2007-08-19 12:50:14 +02:00
int i;
for(i = 0; i < MAX_TEXTURES; i++) {
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_TEXTURE0 + i))) {
wined3d: Handle texture transforms in the TEXTURETRANSFORMFLAGS state. This is a nop by itself, but it makes it easier for fragment pipelines to read WINED3DTSS_TEXTURETRANSFORMFLAGS.
2008-08-26 21:25:56 +02:00
transform_texture(STATE_TEXTURESTAGE(i, WINED3DTSS_TEXTURETRANSFORMFLAGS), stateblock, context);
wined3d: Texture transforms are disabled when drawing rhw vertices.
2007-08-19 12:50:14 +02:00
}
}
}
wined3d: Add emtpy vertex declaration and related states to the state table.
2007-01-02 00:35:07 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void viewport_miscpart(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
struct wined3d_surface *target = stateblock->device->fb.render_targets[0];
wined3d: Retrieve the height properly when setting the viewport.
2007-11-30 21:01:29 +01:00
UINT width, height;
wined3d: Move the viewport to wined3d_state.
2010-09-15 12:00:06 +02:00
WINED3DVIEWPORT vp = stateblock->state.viewport;
d3d9: Test viewports that are bigger than the surface.
2009-10-01 15:48:52 +02:00
wined3d: Store all the resource desc information in struct wined3d_resource.
2011-03-08 19:41:07 +01:00
if (vp.Width > target->resource.width)
vp.Width = target->resource.width;
if (vp.Height > target->resource.height)
vp.Height = target->resource.height;
wined3d: Retrieve the height properly when setting the viewport.
2007-11-30 21:01:29 +01:00
d3d9: Test viewports that are bigger than the surface.
2009-10-01 15:48:52 +02:00
glDepthRange(vp.MinZ, vp.MaxZ);
wined3d: Break the viewport out of the vertex declaration state.
2007-01-04 00:05:05 +01:00
checkGLcall("glDepthRange");
wined3d: Do not specify the viewport origin upside down when doing offscreen rendering. The gl viewport origin is the lower left corner of the window, in d3d it is the upper right corner. This is corrected when setting the viewport. However, when we are doing offscreen rendering, this is reversed. So do not flip the viewport origin when rendering offscreen.
2007-03-06 14:56:58 +01:00
/* Note: GL requires lower left, DirectX supplies upper left. This is reversed when using offscreen rendering
*/
wined3d: Track render_offscreen in the context. This makes sure the relevant states in FindContext() are actually marked dirty when needed.
2009-08-06 08:12:19 +02:00
if (context->render_offscreen)
{
d3d9: Test viewports that are bigger than the surface.
2009-10-01 15:48:52 +02:00
glViewport(vp.X, vp.Y, vp.Width, vp.Height);
wined3d: Do not specify the viewport origin upside down when doing offscreen rendering. The gl viewport origin is the lower left corner of the window, in d3d it is the upper right corner. This is corrected when setting the viewport. However, when we are doing offscreen rendering, this is reversed. So do not flip the viewport origin when rendering offscreen.
2007-03-06 14:56:58 +01:00
} else {
wined3d: Explicitly pass the context to get_drawable_size().
2009-07-24 10:44:15 +02:00
target->get_drawable_size(context, &width, &height);
wined3d: Retrieve the height properly when setting the viewport.
2007-11-30 21:01:29 +01:00
d3d9: Test viewports that are bigger than the surface.
2009-10-01 15:48:52 +02:00
glViewport(vp.X,
(height - (vp.Y + vp.Height)),
vp.Width, vp.Height);
wined3d: Do not specify the viewport origin upside down when doing offscreen rendering. The gl viewport origin is the lower left corner of the window, in d3d it is the upper right corner. This is corrected when setting the viewport. However, when we are doing offscreen rendering, this is reversed. So do not flip the viewport origin when rendering offscreen.
2007-03-06 14:56:58 +01:00
}
wined3d: Break the viewport out of the vertex declaration state.
2007-01-04 00:05:05 +01:00
checkGLcall("glViewport");
wined3d: Move the viewport to the vertex and misc pipeline states.
2008-07-02 20:16:23 +02:00
}
wined3d: Break the viewport out of the vertex declaration state.
2007-01-04 00:05:05 +01:00
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void viewport_vertexpart(DWORD state_id, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Get rid of any remaining d3d9 stuff in state.c.
2007-02-15 13:32:13 +01:00
if(!isStateDirty(context, STATE_TRANSFORM(WINED3DTS_PROJECTION))) {
transform_projection(STATE_TRANSFORM(WINED3DTS_PROJECTION), stateblock, context);
wined3d: Break the viewport out of the vertex declaration state.
2007-01-04 00:05:05 +01:00
}
wined3d: A point size fix.
2007-10-22 12:15:03 +02:00
if(!isStateDirty(context, STATE_RENDER(WINED3DRS_POINTSCALEENABLE))) {
state_pscale(STATE_RENDER(WINED3DRS_POINTSCALEENABLE), stateblock, context);
}
wined3d: Get rid of the posFixup field from the device.
2010-10-26 09:11:05 +02:00
/* Update the position fixup. */
wined3d: Update shader constants on viewport changes. Otherwise the vertex shader will see stale posFixup values.
2010-04-07 21:04:47 +02:00
if (!isStateDirty(context, STATE_VERTEXSHADERCONSTANT))
shaderconstant(STATE_VERTEXSHADERCONSTANT, stateblock, context);
wined3d: Break the viewport out of the vertex declaration state.
2007-01-04 00:05:05 +01:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void light(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
UINT Index = state - STATE_ACTIVELIGHT(0);
wined3d: Move light state to wined3d_state.
2010-09-21 21:20:54 +02:00
const struct wined3d_light_info *lightInfo = stateblock->state.lights[Index];
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
if(!lightInfo) {
glDisable(GL_LIGHT0 + Index);
checkGLcall("glDisable(GL_LIGHT0 + Index)");
} else {
float quad_att;
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
float colRGBA[] = {0.0f, 0.0f, 0.0f, 0.0f};
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
/* Light settings are affected by the model view in OpenGL, the View transform in direct3d*/
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
wined3d: Move transforms to wined3d_state.
2010-09-16 11:19:56 +02:00
glLoadMatrixf(&stateblock->state.transforms[WINED3DTS_VIEW].u.m[0][0]);
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
/* Diffuse: */
colRGBA[0] = lightInfo->OriginalParms.Diffuse.r;
colRGBA[1] = lightInfo->OriginalParms.Diffuse.g;
colRGBA[2] = lightInfo->OriginalParms.Diffuse.b;
colRGBA[3] = lightInfo->OriginalParms.Diffuse.a;
glLightfv(GL_LIGHT0 + Index, GL_DIFFUSE, colRGBA);
checkGLcall("glLightfv");
/* Specular */
colRGBA[0] = lightInfo->OriginalParms.Specular.r;
colRGBA[1] = lightInfo->OriginalParms.Specular.g;
colRGBA[2] = lightInfo->OriginalParms.Specular.b;
colRGBA[3] = lightInfo->OriginalParms.Specular.a;
glLightfv(GL_LIGHT0 + Index, GL_SPECULAR, colRGBA);
checkGLcall("glLightfv");
/* Ambient */
colRGBA[0] = lightInfo->OriginalParms.Ambient.r;
colRGBA[1] = lightInfo->OriginalParms.Ambient.g;
colRGBA[2] = lightInfo->OriginalParms.Ambient.b;
colRGBA[3] = lightInfo->OriginalParms.Ambient.a;
glLightfv(GL_LIGHT0 + Index, GL_AMBIENT, colRGBA);
checkGLcall("glLightfv");
if ((lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range) >= FLT_MIN) {
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
quad_att = 1.4f/(lightInfo->OriginalParms.Range *lightInfo->OriginalParms.Range);
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
} else {
wined3d: Add some missing float suffixes. The compiler should be smart enough to fix most of these, but it looks sloppy.
2009-07-07 11:08:01 +02:00
quad_att = 0.0f; /* 0 or MAX? (0 seems to be ok) */
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
}
wined3d: Light parameter fixes.
2007-02-20 22:43:13 +01:00
/* 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
*/
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
switch (lightInfo->OriginalParms.Type) {
case WINED3DLIGHT_POINT:
/* Position */
glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
checkGLcall("glLightfv");
glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
checkGLcall("glLightf");
wined3d: Light parameter fixes.
2007-02-20 22:43:13 +01:00
/* Attenuation - Are these right? guessing... */
glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
checkGLcall("glLightf");
glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
checkGLcall("glLightf");
if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
checkGLcall("glLightf");
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
/* FIXME: Range */
break;
case WINED3DLIGHT_SPOT:
/* Position */
glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]);
checkGLcall("glLightfv");
/* Direction */
glLightfv(GL_LIGHT0 + Index, GL_SPOT_DIRECTION, &lightInfo->lightDirn[0]);
checkGLcall("glLightfv");
glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, lightInfo->exponent);
checkGLcall("glLightf");
glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
checkGLcall("glLightf");
wined3d: Light parameter fixes.
2007-02-20 22:43:13 +01:00
/* Attenuation - Are these right? guessing... */
glLightf(GL_LIGHT0 + Index, GL_CONSTANT_ATTENUATION, lightInfo->OriginalParms.Attenuation0);
checkGLcall("glLightf");
glLightf(GL_LIGHT0 + Index, GL_LINEAR_ATTENUATION, lightInfo->OriginalParms.Attenuation1);
checkGLcall("glLightf");
if (quad_att < lightInfo->OriginalParms.Attenuation2) quad_att = lightInfo->OriginalParms.Attenuation2;
glLightf(GL_LIGHT0 + Index, GL_QUADRATIC_ATTENUATION, quad_att);
checkGLcall("glLightf");
wined3d: Move lights to the state table.
2007-02-14 17:48:52 +01:00
/* FIXME: Range */
break;
case WINED3DLIGHT_DIRECTIONAL:
/* Direction */
glLightfv(GL_LIGHT0 + Index, GL_POSITION, &lightInfo->lightPosn[0]); /* Note gl uses w position of 0 for direction! */
checkGLcall("glLightfv");
glLightf(GL_LIGHT0 + Index, GL_SPOT_CUTOFF, lightInfo->cutoff);
checkGLcall("glLightf");
glLightf(GL_LIGHT0 + Index, GL_SPOT_EXPONENT, 0.0f);
checkGLcall("glLightf");
break;
default:
FIXME("Unrecognized light type %d\n", lightInfo->OriginalParms.Type);
}
/* Restore the modelview matrix */
glPopMatrix();
glEnable(GL_LIGHT0 + Index);
checkGLcall("glEnable(GL_LIGHT0 + Index)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void scissorrect(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Introduce a separate structure for framebuffer state.
2011-05-18 22:30:15 +02:00
struct wined3d_surface *target = stateblock->device->fb.render_targets[0];
wined3d: Move the scissor rect to wined3d_state.
2010-09-15 12:00:05 +02:00
RECT *pRect = &stateblock->state.scissor_rect;
wined3d: Use the proper drawable size when setting the scissor rect.
2007-11-30 20:28:13 +01:00
UINT height;
UINT width;
wined3d: Read the framebuffer size from the surface, not the window.
2007-11-10 22:36:28 +01:00
wined3d: Explicitly pass the context to get_drawable_size().
2009-07-24 10:44:15 +02:00
target->get_drawable_size(context, &width, &height);
wined3d: Move the scissor rectangle to the state table.
2007-02-19 15:25:16 +01:00
/* 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
*/
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
TRACE("(%p) Setting new Scissor Rect to %d:%d-%d:%d\n", stateblock->device, pRect->left, pRect->bottom - height,
wined3d: Move the scissor rectangle to the state table.
2007-02-19 15:25:16 +01:00
pRect->right - pRect->left, pRect->bottom - pRect->top);
wined3d: Flip the scissor rect when rendering offscreen.
2007-07-26 00:38:50 +02:00
wined3d: Track render_offscreen in the context. This makes sure the relevant states in FindContext() are actually marked dirty when needed.
2009-08-06 08:12:19 +02:00
if (context->render_offscreen)
{
wined3d: Flip the scissor rect when rendering offscreen.
2007-07-26 00:38:50 +02:00
glScissor(pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top);
} else {
wined3d: Use the proper drawable size when setting the scissor rect.
2007-11-30 20:28:13 +01:00
glScissor(pRect->left, height - pRect->bottom, pRect->right - pRect->left, pRect->bottom - pRect->top);
wined3d: Flip the scissor rect when rendering offscreen.
2007-07-26 00:38:50 +02:00
}
wined3d: Move the scissor rectangle to the state table.
2007-02-19 15:25:16 +01:00
checkGLcall("glScissor");
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void indexbuffer(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Set the state.c GLINFO_LOCATION to *gl_info.
2010-05-25 12:02:03 +02:00
const struct wined3d_gl_info *gl_info = context->gl_info;
wined3d: Move index buffer state to wined3d_state.
2010-09-20 19:41:23 +02:00
if (stateblock->state.user_stream || !stateblock->state.index_buffer)
wined3d: Get rid of redundant comparisons against NULL / 0.
2010-09-14 13:38:39 +02:00
{
wined3d: Move an VBO support check to the state template.
2008-07-05 23:46:21 +02:00
GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0));
wined3d: Move index buffer state to wined3d_state.
2010-09-20 19:41:23 +02:00
}
else
{
struct wined3d_buffer *ib = stateblock->state.index_buffer;
wined3d: Merge indexbuffer and buffer implementations.
2009-04-06 13:38:56 +02:00
GL_EXTCALL(glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib->buffer_object));
wined3d: Use VBOs for index buffers.
2007-02-19 15:25:32 +01:00
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void frontface(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Track render_offscreen in the context. This makes sure the relevant states in FindContext() are actually marked dirty when needed.
2009-08-06 08:12:19 +02:00
if (context->render_offscreen)
{
wined3d: Untie culling and offscreen rendering.
2007-09-18 11:43:09 +02:00
glFrontFace(GL_CCW);
checkGLcall("glFrontFace(GL_CCW)");
} else {
glFrontFace(GL_CW);
checkGLcall("glFrontFace(GL_CW)");
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void psorigin_w(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Don't call glPointParameter with a random context.
2011-01-07 01:16:18 +01:00
{
static BOOL warned;
if (!warned)
{
WARN("Point sprite coordinate origin switching not supported.\n");
warned = TRUE;
}
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void psorigin(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Don't call glPointParameter with a random context.
2011-01-07 01:16:18 +01:00
{
const struct wined3d_gl_info *gl_info = context->gl_info;
GLint origin = context->render_offscreen ? GL_LOWER_LEFT : GL_UPPER_LEFT;
if (glPointParameteri)
{
glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, origin);
checkGLcall("glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
}
else if (gl_info->supported[NV_POINT_SPRITE])
{
GL_EXTCALL(glPointParameteriNV(GL_POINT_SPRITE_COORD_ORIGIN, origin));
checkGLcall("glPointParameteriNV(GL_POINT_SPRITE_COORD_ORIGIN, ...)");
}
}
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
const struct StateEntryTemplate misc_state_template[] = {
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_SRCBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_DESTBLEND), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), state_blend }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_EDGEANTIALIAS), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SRCBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_DESTBLENDALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_BLENDOPALPHA), { STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_STREAMSRC, { STATE_VDECL, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_VDECL, { STATE_VDECL, streamsrc }, WINED3D_GL_EXT_NONE },
{ STATE_FRONTFACE, { STATE_FRONTFACE, frontface }, WINED3D_GL_EXT_NONE },
{ STATE_SCISSORRECT, { STATE_SCISSORRECT, scissorrect }, WINED3D_GL_EXT_NONE },
wined3d: Don't call glPointParameter with a random context.
2011-01-07 01:16:18 +01:00
{ STATE_POINTSPRITECOORDORIGIN, { STATE_POINTSPRITECOORDORIGIN, psorigin }, WINED3D_GL_VERSION_2_0 },
{ STATE_POINTSPRITECOORDORIGIN, { STATE_POINTSPRITECOORDORIGIN, psorigin_w }, WINED3D_GL_EXT_NONE },
wined3d: Move shader constants to the misc states.
2008-07-02 20:07:41 +02:00
/* TODO: Move shader constant loading to vertex and fragment pipeline repectively, as soon as the pshader and
* vshader loadings are untied from each other
*/
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_VERTEXSHADERCONSTANT, { STATE_VERTEXSHADERCONSTANT, shaderconstant }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_PIXELSHADERCONSTANT, { STATE_VERTEXSHADERCONSTANT, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), shader_bumpenvmat }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT01), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT10), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT11), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVMAT00), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(0, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(1, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(2, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(3, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(4, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(5, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(6, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), tex_bumpenvlscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLOFFSET), { STATE_TEXTURESTAGE(7, WINED3DTSS_BUMPENVLSCALE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_VIEWPORT, { STATE_VIEWPORT, viewport_miscpart }, WINED3D_GL_EXT_NONE },
wined3d: Move an VBO support check to the state template.
2008-07-05 23:46:21 +02:00
{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, indexbuffer }, ARB_VERTEX_BUFFER_OBJECT },
wined3d: Add an extensionless STATE_INDEXBUFFER handler.
2010-04-07 21:04:45 +02:00
{ STATE_INDEXBUFFER, { STATE_INDEXBUFFER, state_nop }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_ANTIALIAS), { STATE_RENDER(WINED3DRS_ANTIALIAS), state_antialias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), { STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), state_perspective }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ZENABLE), { STATE_RENDER(WINED3DRS_ZENABLE), state_zenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAPU), { STATE_RENDER(WINED3DRS_WRAPU), state_wrapu }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAPV), { STATE_RENDER(WINED3DRS_WRAPV), state_wrapv }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FILLMODE), { STATE_RENDER(WINED3DRS_FILLMODE), state_fillmode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SHADEMODE), { STATE_RENDER(WINED3DRS_SHADEMODE), state_shademode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_LINEPATTERN), { STATE_RENDER(WINED3DRS_LINEPATTERN), state_linepattern }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_MONOENABLE), { STATE_RENDER(WINED3DRS_MONOENABLE), state_monoenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ROP2), { STATE_RENDER(WINED3DRS_ROP2), state_rop2 }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_PLANEMASK), { STATE_RENDER(WINED3DRS_PLANEMASK), state_planemask }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ZWRITEENABLE), { STATE_RENDER(WINED3DRS_ZWRITEENABLE), state_zwritenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), state_alpha }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_ALPHAREF), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ALPHAFUNC), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_COLORKEYENABLE), { STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_LASTPIXEL), { STATE_RENDER(WINED3DRS_LASTPIXEL), state_lastpixel }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CULLMODE), { STATE_RENDER(WINED3DRS_CULLMODE), state_cullmode }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ZFUNC), { STATE_RENDER(WINED3DRS_ZFUNC), state_zfunc }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_DITHERENABLE), { STATE_RENDER(WINED3DRS_DITHERENABLE), state_ditherenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SUBPIXEL), { STATE_RENDER(WINED3DRS_SUBPIXEL), state_subpixel }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SUBPIXELX), { STATE_RENDER(WINED3DRS_SUBPIXELX), state_subpixelx }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), { STATE_RENDER(WINED3DRS_STIPPLEDALPHA), state_stippledalpha }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STIPPLEENABLE), { STATE_RENDER(WINED3DRS_STIPPLEENABLE), state_stippleenable }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), { STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), state_mipmaplodbias }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ANISOTROPY), { STATE_RENDER(WINED3DRS_ANISOTROPY), state_anisotropy }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FLUSHBATCH), { STATE_RENDER(WINED3DRS_FLUSHBATCH), state_flushbatch }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), { STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_translucentsi }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILENABLE), { STATE_RENDER(WINED3DRS_STENCILENABLE), state_stencil }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILREF), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_STENCILMASK), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
{ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite2s}, EXT_STENCIL_TWO_SIDE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), { STATE_RENDER(WINED3DRS_STENCILWRITEMASK), state_stencilwrite }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CCW_STENCILFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CCW_STENCILPASS), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CCW_STENCILFUNC), { STATE_RENDER(WINED3DRS_STENCILENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_WRAP0), { STATE_RENDER(WINED3DRS_WRAP0), state_wrap }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_WRAP1), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP2), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP3), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP4), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP5), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP6), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP7), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP8), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP9), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP10), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP11), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP12), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP13), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP14), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_WRAP15), { STATE_RENDER(WINED3DRS_WRAP0), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_EXTENTS), { STATE_RENDER(WINED3DRS_EXTENTS), state_extents }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), { STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), state_ckeyblend }, WINED3D_GL_EXT_NONE },
wined3d: Add a state handler for WINED3DRS_SOFTWAREVERTEXPROCESSING.
2009-09-25 13:31:48 +02:00
{ STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING), { STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING), state_swvp }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), { STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), state_patchedgestyle}, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), { STATE_RENDER(WINED3DRS_PATCHSEGMENTS), state_patchsegments }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_POSITIONDEGREE), { STATE_RENDER(WINED3DRS_POSITIONDEGREE), state_positiondegree}, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_NORMALDEGREE), { STATE_RENDER(WINED3DRS_NORMALDEGREE), state_normaldegree }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_X), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_ADAPTIVETESS_W), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add NVDB support.
2010-09-16 08:58:26 +02:00
{ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_nvdb }, EXT_DEPTH_BOUNDS_TEST },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), { STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_tessellation }, WINED3D_GL_EXT_NONE },
wined3d: Test for multisampling in the template.
2008-07-05 22:59:21 +02:00
{ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa }, ARB_MULTISAMPLE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), { STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), state_msaa_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), { STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), state_multisampmask }, WINED3D_GL_EXT_NONE },
wined3d: Add a state handler for WINED3DRS_DEBUGMONITORTOKEN.
2009-08-21 09:12:27 +02:00
{ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), { STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), state_debug_monitor }, WINED3D_GL_EXT_NONE },
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite0 }, EXT_DRAW_BUFFERS2 },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), state_colorwrite }, WINED3D_GL_EXT_NONE },
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
{ STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop }, EXT_BLEND_MINMAX },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_BLENDOP), { STATE_RENDER(WINED3DRS_BLENDOP), state_blendop_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), { STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), state_scissor }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), state_colorwrite1 }, EXT_DRAW_BUFFERS2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), state_colorwrite2 }, EXT_DRAW_BUFFERS2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Implement independent color write masks.
2010-03-25 22:51:24 +01:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), state_colorwrite3 }, EXT_DRAW_BUFFERS2 },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), { STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move a few extension checks into the state template.
2008-07-05 22:35:53 +02:00
{ STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor }, EXT_BLEND_COLOR },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_BLENDFACTOR), { STATE_RENDER(WINED3DRS_BLENDFACTOR), state_blendfactor_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_DEPTHBIAS), { STATE_RENDER(WINED3DRS_DEPTHBIAS), state_depthbias }, WINED3D_GL_EXT_NONE },
wined3d: Add a state handler for WINED3DRS_ZVISIBLE.
2010-04-01 21:28:51 +02:00
{ STATE_RENDER(WINED3DRS_ZVISIBLE), { STATE_RENDER(WINED3DRS_ZVISIBLE), state_zvisible }, WINED3D_GL_EXT_NONE },
wined3d: Samplers -> misc states.
2008-07-03 14:04:59 +02:00
/* Samplers */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(8), { STATE_SAMPLER(8), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(9), { STATE_SAMPLER(9), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(10), { STATE_SAMPLER(10), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(11), { STATE_SAMPLER(11), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(12), { STATE_SAMPLER(12), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(13), { STATE_SAMPLER(13), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(14), { STATE_SAMPLER(14), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(15), { STATE_SAMPLER(15), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(16), /* Vertex sampler 0 */ { STATE_SAMPLER(16), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(17), /* Vertex sampler 1 */ { STATE_SAMPLER(17), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(18), /* Vertex sampler 2 */ { STATE_SAMPLER(18), sampler }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(19), /* Vertex sampler 3 */ { STATE_SAMPLER(19), sampler }, WINED3D_GL_EXT_NONE },
wined3d: Fix the STATE_BASEVERTEXINDEX state entry.
2011-06-20 23:21:12 +02:00
{ STATE_BASEVERTEXINDEX, { STATE_BASEVERTEXINDEX, state_nop, }, ARB_DRAW_ELEMENTS_BASE_VERTEX },
wined3d: Link STATE_BASEVERTEXINDEX to STATE_VDECL.
2011-06-18 13:47:34 +02:00
{ STATE_BASEVERTEXINDEX, { STATE_VDECL, NULL, }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
wined3d: Move stream source and vshader to misc and vertex pipeline tables.
2008-07-02 17:02:19 +02:00
};
const struct StateEntryTemplate ffp_vertexstate_template[] = {
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_VDECL, { STATE_VDECL, vertexdeclaration }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_VSHADER, { STATE_VDECL, NULL }, WINED3D_GL_EXT_NONE },
{ STATE_MATERIAL, { STATE_RENDER(WINED3DRS_SPECULARENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_SPECULARENABLE), { STATE_RENDER(WINED3DRS_SPECULARENABLE), state_specularenable}, WINED3D_GL_EXT_NONE },
wined3d: Move clipplanes to vertex states.
2008-07-02 19:10:42 +02:00
/* Clip planes */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_CLIPPLANE(0), { STATE_CLIPPLANE(0), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(1), { STATE_CLIPPLANE(1), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(2), { STATE_CLIPPLANE(2), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(3), { STATE_CLIPPLANE(3), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(4), { STATE_CLIPPLANE(4), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(5), { STATE_CLIPPLANE(5), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(6), { STATE_CLIPPLANE(6), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(7), { STATE_CLIPPLANE(7), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(8), { STATE_CLIPPLANE(8), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(9), { STATE_CLIPPLANE(9), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(10), { STATE_CLIPPLANE(10), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(11), { STATE_CLIPPLANE(11), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(12), { STATE_CLIPPLANE(12), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(13), { STATE_CLIPPLANE(13), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(14), { STATE_CLIPPLANE(14), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(15), { STATE_CLIPPLANE(15), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(16), { STATE_CLIPPLANE(16), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(17), { STATE_CLIPPLANE(17), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(18), { STATE_CLIPPLANE(18), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(19), { STATE_CLIPPLANE(19), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(20), { STATE_CLIPPLANE(20), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(21), { STATE_CLIPPLANE(21), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(22), { STATE_CLIPPLANE(22), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(23), { STATE_CLIPPLANE(23), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(24), { STATE_CLIPPLANE(24), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(25), { STATE_CLIPPLANE(25), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(26), { STATE_CLIPPLANE(26), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(27), { STATE_CLIPPLANE(27), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(28), { STATE_CLIPPLANE(28), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(29), { STATE_CLIPPLANE(29), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(30), { STATE_CLIPPLANE(30), clipplane }, WINED3D_GL_EXT_NONE },
{ STATE_CLIPPLANE(31), { STATE_CLIPPLANE(31), clipplane }, WINED3D_GL_EXT_NONE },
wined3d: Move lights to the vertex pipeline states.
2008-07-02 19:15:34 +02:00
/* Lights */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_ACTIVELIGHT(0), { STATE_ACTIVELIGHT(0), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(1), { STATE_ACTIVELIGHT(1), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(2), { STATE_ACTIVELIGHT(2), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(3), { STATE_ACTIVELIGHT(3), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(4), { STATE_ACTIVELIGHT(4), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(5), { STATE_ACTIVELIGHT(5), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(6), { STATE_ACTIVELIGHT(6), light }, WINED3D_GL_EXT_NONE },
{ STATE_ACTIVELIGHT(7), { STATE_ACTIVELIGHT(7), light }, WINED3D_GL_EXT_NONE },
wined3d: Move the viewport to the vertex and misc pipeline states.
2008-07-02 20:16:23 +02:00
/* Viewport */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_VIEWPORT, { STATE_VIEWPORT, viewport_vertexpart }, WINED3D_GL_EXT_NONE },
wined3d: Move transforms to the vertex code. Some fragment pipeline implementations may want to register their own texture transform handlers.
2008-07-02 20:40:23 +02:00
/* Transform states follow */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TRANSFORM(WINED3DTS_VIEW), { STATE_TRANSFORM(WINED3DTS_VIEW), transform_view }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_PROJECTION), { STATE_TRANSFORM(WINED3DTS_PROJECTION), transform_projection}, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TRANSFORM(WINED3DTS_TEXTURE0), { STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE1), { STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE2), { STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE3), { STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE4), { STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE5), { STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE6), { STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_TEXTURE7), { STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 0)), transform_world }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 1)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 2)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 3)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 4)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 5)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 6)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 7)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 8)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 9)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 10)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 11)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 12)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 13)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 14)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 15)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 16)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 17)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 18)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 19)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 20)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 21)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 22)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 23)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 24)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 25)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 26)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 27)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 28)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 29)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 30)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 31)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 32)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 33)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 34)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 35)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 36)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 37)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 38)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 39)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 40)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 41)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 42)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 43)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 44)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 45)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 46)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 47)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 48)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 49)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 50)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 51)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 52)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 53)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 54)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 55)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 56)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 57)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 58)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 59)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 60)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 61)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 62)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 63)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 64)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 65)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 66)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 67)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 68)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 69)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 70)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 71)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 72)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 73)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 74)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 75)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 76)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 77)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 78)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 79)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 80)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 81)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 82)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 83)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 84)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 85)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 86)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 87)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 88)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 89)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 90)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 91)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 92)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 93)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 94)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 95)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 96)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 97)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 98)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX( 99)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(100)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(101)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(102)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(103)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(104)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(105)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(106)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(107)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(108)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(109)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(110)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(111)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(112)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(113)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(114)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(115)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(116)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(117)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(118)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(119)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(120)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(121)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(122)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(123)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(124)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(125)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(126)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(127)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(128)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(129)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(130)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(131)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(132)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(133)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(134)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(135)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(136)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(137)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(138)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(139)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(140)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(141)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(142)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(143)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(144)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(145)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(146)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(147)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(148)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(149)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(150)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(151)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(152)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(153)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(154)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(155)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(156)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(157)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(158)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(159)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(160)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(161)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(162)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(163)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(164)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(165)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(166)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(167)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(168)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(169)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(170)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(171)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(172)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(173)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(174)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(175)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(176)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(177)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(178)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(179)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(180)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(181)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(182)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(183)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(184)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(185)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(186)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(187)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(188)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(189)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(190)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(191)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(192)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(193)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(194)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(195)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(196)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(197)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(198)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(199)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(200)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(201)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(202)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(203)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(204)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(205)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(206)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(207)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(208)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(209)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(210)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(211)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(212)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(213)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(214)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(215)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(216)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(217)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(218)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(219)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(220)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(221)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(222)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(223)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(224)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(225)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(226)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(227)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(228)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(229)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(230)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(231)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(232)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(233)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(234)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(235)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(236)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(237)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(238)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(239)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(240)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(241)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(242)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(243)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(244)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(245)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(246)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(247)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(248)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(249)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(250)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(251)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(252)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(253)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(254)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), { STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)), transform_worldex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(0,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(1,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(2,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(3,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(4,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(5,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(6,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),{STATE_TEXTURESTAGE(7,WINED3DTSS_TEXTURETRANSFORMFLAGS),transform_texture }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(0, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(1, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(2, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(3, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(4, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(5, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(6, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), { STATE_TEXTURESTAGE(7, WINED3DTSS_TEXCOORDINDEX), tex_coordindex }, WINED3D_GL_EXT_NONE },
wined3d: Move fog to the vertex states.
2008-07-03 03:49:43 +02:00
/* Fog */
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_vertexpart}, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move the range fog support test to the template.
2008-07-05 22:38:43 +02:00
{ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_rangefog }, NV_FOG_DISTANCE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), { STATE_RENDER(WINED3DRS_RANGEFOGENABLE), state_rangefog_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_CLIPPING), { STATE_RENDER(WINED3DRS_CLIPPING), state_clipping }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), { STATE_RENDER(WINED3DRS_CLIPPING), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_LIGHTING), { STATE_RENDER(WINED3DRS_LIGHTING), state_lighting }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_AMBIENT), { STATE_RENDER(WINED3DRS_AMBIENT), state_ambient }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_COLORVERTEX), { STATE_RENDER(WINED3DRS_COLORVERTEX), state_colormat }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_LOCALVIEWER), { STATE_RENDER(WINED3DRS_LOCALVIEWER), state_localviewer }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), { STATE_RENDER(WINED3DRS_NORMALIZENORMALS), state_normalize }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE), { STATE_RENDER(WINED3DRS_COLORVERTEX), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Move the vertexblend support check to the template.
2008-07-05 23:21:26 +02:00
{ STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend }, ARB_VERTEX_BLEND },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_VERTEXBLEND), { STATE_RENDER(WINED3DRS_VERTEXBLEND), state_vertexblend_w }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_POINTSIZE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Split the psizemin handler.
2008-07-05 22:45:39 +02:00
{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_arb }, ARB_POINT_PARAMETERS },
{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_ext }, EXT_POINT_PARAMETERS },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), state_psizemin_w }, WINED3D_GL_EXT_NONE },
wined3d: Move the point sprite support test into the template.
2008-07-05 22:49:50 +02:00
{ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite }, ARB_POINT_SPRITE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), { STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), state_pointsprite_w }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), state_pscale }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_POINTSCALE_A), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_POINTSCALE_B), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_POINTSCALE_C), { STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, ARB_POINT_PARAMETERS },
{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, EXT_POINT_PARAMETERS },
{ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), { STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_TWEENFACTOR), { STATE_RENDER(WINED3DRS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a state table entry for WINED3DRS_INDEXEDVERTEXBLENDENABLE.
2010-04-01 11:34:48 +02:00
{ STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE), { STATE_RENDER(WINED3DRS_VERTEXBLEND), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a state table entry for WINED3DRS_TWEENFACTOR.
2010-03-31 11:29:01 +02:00
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
/* 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
*/
{ STATE_SAMPLER(0), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(0), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(1), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(1), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(2), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(2), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(3), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(3), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(4), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(4), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(5), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(5), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(6), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(6), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
wined3d: Only register the np2 texture fixup if needed.
2008-07-05 23:07:00 +02:00
{ STATE_SAMPLER(7), { 0, NULL }, ARB_TEXTURE_NON_POWER_OF_TWO },
wined3d: Use a more consistent name for the normalized texrect "extension".
2010-07-20 18:51:54 +02:00
{ STATE_SAMPLER(7), { 0, NULL }, WINED3D_GL_NORMALIZED_TEXRECT },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texmatrix }, WINED3D_GL_EXT_NONE },
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
};
wined3d: Give nv* fixed function stuff its own state template.
2008-07-06 01:31:34 +02:00
static const struct StateEntryTemplate ffp_fragmentstate_template[] = {
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(0, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(0, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(0, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(0, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(1, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(1, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(1, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(1, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(2, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(2, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(2, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(2, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(3, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(3, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(3, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(3, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(4, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(4, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(4, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(4, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(5, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(5, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(5, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(5, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(6, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(6, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(6, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(6, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), tex_colorop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), tex_alphaop }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG1), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG2), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_COLORARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAARG0), { STATE_TEXTURESTAGE(7, WINED3DTSS_ALPHAOP), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_TEXTURESTAGE(7, WINED3DTSS_RESULTARG), { STATE_TEXTURESTAGE(7, WINED3DTSS_COLOROP), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Get rid of state_nogl(). It's unused, all states that have this as handler have a 0 representative.
2010-04-07 21:04:46 +02:00
{ STATE_TEXTURESTAGE(7, WINED3DTSS_CONSTANT), { 0 /* As long as we don't support D3DTA_CONSTANT */, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_PIXELSHADER, { STATE_PIXELSHADER, apply_pixelshader }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), { STATE_PIXELSHADER, NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), { STATE_RENDER(WINED3DRS_TEXTUREFACTOR), state_texfactor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGCOLOR), { STATE_RENDER(WINED3DRS_FOGCOLOR), state_fogcolor }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGDENSITY), { STATE_RENDER(WINED3DRS_FOGDENSITY), state_fogdensity }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGENABLE), { STATE_RENDER(WINED3DRS_FOGENABLE), state_fog_fragpart }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_FOGTABLEMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
{ STATE_RENDER(WINED3DRS_FOGVERTEXMODE), { STATE_RENDER(WINED3DRS_FOGENABLE), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_RENDER(WINED3DRS_FOGSTART), { STATE_RENDER(WINED3DRS_FOGSTART), state_fogstartend }, WINED3D_GL_EXT_NONE },
wined3d: Explicitly set the state handler to NULL for states with a representative. We should never call the handler for states that have a rep.
2010-04-01 11:34:46 +02:00
{ STATE_RENDER(WINED3DRS_FOGEND), { STATE_RENDER(WINED3DRS_FOGSTART), NULL }, WINED3D_GL_EXT_NONE },
wined3d: Add a proper enum value for "no extension". This would allow an extension check for ARB_COLOR_BUFFER_FLOAT to work.
2009-06-04 10:16:21 +02:00
{ STATE_SAMPLER(0), { STATE_SAMPLER(0), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(1), { STATE_SAMPLER(1), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(2), { STATE_SAMPLER(2), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(3), { STATE_SAMPLER(3), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(4), { STATE_SAMPLER(4), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(5), { STATE_SAMPLER(5), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(6), { STATE_SAMPLER(6), sampler_texdim }, WINED3D_GL_EXT_NONE },
{ STATE_SAMPLER(7), { STATE_SAMPLER(7), sampler_texdim }, WINED3D_GL_EXT_NONE },
{0 /* Terminate */, { 0, 0 }, WINED3D_GL_EXT_NONE },
wined3d: Create fragment processing state templates and select one. For now the atifs selection sticks to the old rules, thus it is bound to the available and selected shader capabilities. We may want to change that in the future.
2008-07-04 22:01:26 +02:00
};
wined3d: Move shader_fragment_enable to the fragment pipeline implementation. It isn't related to the shader backend any longer. The nvts_enable in the ffp code isn't quite right as well, it should be moved away once there is a dedicated nvts fragment pipeline replacement
2008-07-04 22:09:49 +02:00
wined3d: Call frag_pipe->enable_extension under the GL lock.
2011-05-24 23:36:16 +02:00
/* Context activation and GL locking are done by the caller. */
wined3d: Remove a redundant parameter to enable_extension().
2010-12-01 20:50:45 +01:00
static void ffp_enable(BOOL enable) {}
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
static void ffp_fragment_get_caps(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps)
wined3d: Const correctness fixes for arb_program_shader.c.
2008-11-25 14:36:09 +01:00
{
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->PrimitiveMiscCaps = 0;
caps->TextureOpCaps = WINED3DTEXOPCAPS_ADD
| WINED3DTEXOPCAPS_ADDSIGNED
| WINED3DTEXOPCAPS_ADDSIGNED2X
| WINED3DTEXOPCAPS_MODULATE
| WINED3DTEXOPCAPS_MODULATE2X
| WINED3DTEXOPCAPS_MODULATE4X
| WINED3DTEXOPCAPS_SELECTARG1
| WINED3DTEXOPCAPS_SELECTARG2
| WINED3DTEXOPCAPS_DISABLE;
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[ARB_TEXTURE_ENV_COMBINE]
|| gl_info->supported[EXT_TEXTURE_ENV_COMBINE]
|| gl_info->supported[NV_TEXTURE_ENV_COMBINE4])
{
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->TextureOpCaps |= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
| WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
| WINED3DTEXOPCAPS_BLENDFACTORALPHA
| WINED3DTEXOPCAPS_BLENDCURRENTALPHA
| WINED3DTEXOPCAPS_LERP
| WINED3DTEXOPCAPS_SUBTRACT;
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[ATI_TEXTURE_ENV_COMBINE3]
|| gl_info->supported[NV_TEXTURE_ENV_COMBINE4])
{
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->TextureOpCaps |= WINED3DTEXOPCAPS_ADDSMOOTH
| WINED3DTEXOPCAPS_MULTIPLYADD
| WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
| WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
| WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
}
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (gl_info->supported[ARB_TEXTURE_ENV_DOT3])
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->TextureOpCaps |= WINED3DTEXOPCAPS_DOTPRODUCT3;
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
wined3d: Rename "pCaps" to "caps".
2011-04-26 19:24:15 +02:00
caps->MaxTextureBlendStages = gl_info->limits.textures;
caps->MaxSimultaneousTextures = gl_info->limits.textures;
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
}
wined3d: Get rid of the IWineD3DDevice typedefs.
2011-05-16 23:01:23 +02:00
static HRESULT ffp_fragment_alloc(struct wined3d_device *device) { return WINED3D_OK; }
static void ffp_fragment_free(struct wined3d_device *device) {}
wined3d: Make shader texture format fixups more generic. Based on a patch by Stefan Dösinger. This is more flexible, and allows the shader backend implementation to be simpler, since it doesn't have to know about specific formats. The next patch makes use of this.
2008-12-03 14:53:43 +01:00
static BOOL ffp_color_fixup_supported(struct color_fixup_desc fixup)
{
if (TRACE_ON(d3d))
{
TRACE("Checking support for fixup:\n");
dump_color_fixup_desc(fixup);
}
/* We only support identity conversions. */
if (is_identity_fixup(fixup))
{
TRACE("[OK]\n");
return TRUE;
}
TRACE("[FAILED]\n");
wined3d: Ask the ffp/shader/blit implementation about format support. If a format is not supported natively by opengl, a shader may be able to convert it. Up to now, CheckDeviceFormat had magic knowldge which GL extensions lead to which supported format. This patch adds functions that allow CheckDeviceFormat to ask the actual implementation for its capabilities.
2008-08-07 21:51:35 +02:00
return FALSE;
}
wined3d: Remove the atifs shader backend. Since atifs is only doing the fragment pipeline replacement right now there is no need for the shader backend structure any longer. The ffp private data is stored in new fragment pipeline private data(which could potentially be set to equal the shader private data if needed).
2008-07-11 16:41:28 +02:00
wined3d: Move shader_fragment_enable to the fragment pipeline implementation. It isn't related to the shader backend any longer. The nvts_enable in the ffp code isn't quite right as well, it should be moved away once there is a dedicated nvts fragment pipeline replacement
2008-07-04 22:09:49 +02:00
const struct fragment_pipeline ffp_fragment_pipeline = {
wined3d: Give the nvts/nvrc code its own pipeline implementation. This code creates the structures and the pipeline selection, as well as the caps filling. It does not yet move the actual code around, since this will be a bigger task.
2008-07-04 23:15:18 +02:00
ffp_enable,
wined3d: Set ffp caps in the ffp backend, not the shader backend.
2008-07-03 21:36:18 +02:00
ffp_fragment_get_caps,
wined3d: Remove the atifs shader backend. Since atifs is only doing the fragment pipeline replacement right now there is no need for the shader backend structure any longer. The ffp private data is stored in new fragment pipeline private data(which could potentially be set to equal the shader private data if needed).
2008-07-11 16:41:28 +02:00
ffp_fragment_alloc,
ffp_fragment_free,
wined3d: Make shader texture format fixups more generic. Based on a patch by Stefan Dösinger. This is more flexible, and allows the shader backend implementation to be simpler, since it doesn't have to know about specific formats. The next patch makes use of this.
2008-12-03 14:53:43 +01:00
ffp_color_fixup_supported,
wined3d: Handle projected textures properly in arbfp and atifs. GL_ARB_fragment_program and GL_ATI_fragment_shader can disable projected textures properly, and they can also handle D3DTTFF_PROJECTED | D3DTTFF_COUNT3 properly.
2008-08-23 22:41:51 +02:00
ffp_fragmentstate_template,
FALSE /* we cannot disable projected textures. The vertex pipe has to do it */
wined3d: Move shader_fragment_enable to the fragment pipeline implementation. It isn't related to the shader backend any longer. The nvts_enable in the ffp code isn't quite right as well, it should be moved away once there is a dedicated nvts fragment pipeline replacement
2008-07-04 22:09:49 +02:00
};
wined3d: Create fragment processing state templates and select one. For now the atifs selection sticks to the old rules, thus it is bound to the available and selected shader capabilities. We may want to change that in the future.
2008-07-04 22:01:26 +02:00
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
static unsigned int num_handlers(const APPLYSTATEFUNC *funcs)
{
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
unsigned int i;
for(i = 0; funcs[i]; i++);
return i;
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void multistate_apply_2(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->multistate_funcs[state][0](state, stateblock, context);
stateblock->device->multistate_funcs[state][1](state, stateblock, context);
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
}
wined3d: Get rid of the IWineD3DStateBlockImpl typedef.
2011-01-28 20:05:43 +01:00
static void multistate_apply_3(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *context)
wined3d: Rename WineD3DContext to struct wined3d_context.
2009-08-03 08:06:51 +02:00
{
wined3d: Rename "wineD3DDevice" to "device".
2009-12-09 20:32:08 +01:00
stateblock->device->multistate_funcs[state][0](state, stateblock, context);
stateblock->device->multistate_funcs[state][1](state, stateblock, context);
stateblock->device->multistate_funcs[state][2](state, stateblock, context);
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
}
wined3d: Prune invalid states from the state table.
2010-01-28 23:40:25 +01:00
static void prune_invalid_states(struct StateEntry *state_table, const struct wined3d_gl_info *gl_info)
{
unsigned int start, last, i;
start = STATE_TEXTURESTAGE(gl_info->limits.texture_stages, 0);
last = STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE);
for (i = start; i <= last; ++i)
{
state_table[i].representative = 0;
state_table[i].apply = state_undefined;
}
start = STATE_TRANSFORM(WINED3DTS_TEXTURE0 + gl_info->limits.texture_stages);
last = STATE_TRANSFORM(WINED3DTS_TEXTURE0 + MAX_TEXTURES - 1);
for (i = start; i <= last; ++i)
{
state_table[i].representative = 0;
state_table[i].apply = state_undefined;
}
wined3d: Prune unsupported world matrix transform states.
2010-04-13 20:46:28 +02:00
start = STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(gl_info->limits.blends));
last = STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255));
for (i = start; i <= last; ++i)
{
state_table[i].representative = 0;
state_table[i].apply = state_undefined;
}
wined3d: Prune invalid states from the state table.
2010-01-28 23:40:25 +01:00
}
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
static void validate_state_table(struct StateEntry *state_table)
{
wined3d: Verify all render states have a handler.
2010-04-01 21:28:55 +02:00
static const struct
{
DWORD first;
DWORD last;
}
rs_holes[] =
{
{ 1, 1},
{ 3, 3},
{ 17, 18},
{ 21, 21},
{ 42, 45},
d3d: Map D3DRS_ZBIAS to WINED3DRS_DEPTHBIAS. ZBIAS was removed in d3d9 and replaced with DEPTHBIAS. Currently wined3d implements both independently which will cause trouble if we want to set the depthbias value depending on the depth stencil format.
2011-04-21 22:36:11 +02:00
{ 47, 47},
wined3d: Verify all render states have a handler.
2010-04-01 21:28:55 +02:00
{ 61, 127},
{149, 150},
{169, 169},
{177, 177},
{196, 197},
{ 0, 0},
};
wined3d: Validate some more states.
2010-04-07 21:04:48 +02:00
static const DWORD simple_states[] =
{
STATE_MATERIAL,
STATE_VDECL,
STATE_STREAMSRC,
STATE_INDEXBUFFER,
STATE_VERTEXSHADERCONSTANT,
STATE_PIXELSHADERCONSTANT,
STATE_VSHADER,
STATE_PIXELSHADER,
STATE_VIEWPORT,
STATE_SCISSORRECT,
STATE_FRONTFACE,
wined3d: Don't call glPointParameter with a random context.
2011-01-07 01:16:18 +01:00
STATE_POINTSPRITECOORDORIGIN,
wined3d: Validate STATE_BASEVERTEXINDEX in validate_state_table().
2011-06-20 23:21:11 +02:00
STATE_BASEVERTEXINDEX,
wined3d: Validate some more states.
2010-04-07 21:04:48 +02:00
};
wined3d: Verify all render states have a handler.
2010-04-01 21:28:55 +02:00
unsigned int i, current;
for (i = STATE_RENDER(1), current = 0; i <= STATE_RENDER(WINEHIGHEST_RENDER_STATE); ++i)
{
if (!rs_holes[current].first || i < STATE_RENDER(rs_holes[current].first))
{
if (!state_table[i].representative)
ERR("State %s (%#x) should have a representative.\n", debug_d3dstate(i), i);
}
else if (state_table[i].representative)
ERR("State %s (%#x) shouldn't have a representative.\n", debug_d3dstate(i), i);
if (i == STATE_RENDER(rs_holes[current].last)) ++current;
}
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
wined3d: Validate some more states.
2010-04-07 21:04:48 +02:00
for (i = 0; i < sizeof(simple_states) / sizeof(*simple_states); ++i)
{
if (!state_table[simple_states[i]].representative)
ERR("State %s (%#x) should have a representative.\n",
debug_d3dstate(simple_states[i]), simple_states[i]);
}
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
for (i = 0; i < STATE_HIGHEST + 1; ++i)
{
DWORD rep = state_table[i].representative;
wined3d: Verify each state table entry has either a handler or a representative.
2010-04-01 11:34:47 +02:00
if (rep)
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
{
wined3d: Verify state representatives represent themselves. This ensures there's no multilevel indirection in the state table.
2010-04-01 21:28:50 +02:00
if (state_table[rep].representative != rep)
wined3d: Verify each state table entry has either a handler or a representative.
2010-04-01 11:34:47 +02:00
{
ERR("State %s (%#x) has invalid representative %s (%#x).\n",
debug_d3dstate(i), i, debug_d3dstate(rep), rep);
state_table[i].representative = 0;
}
if (rep != i)
{
if (state_table[i].apply)
ERR("State %s (%#x) has both a handler and representative.\n", debug_d3dstate(i), i);
}
else if (!state_table[i].apply)
{
ERR("Self representing state %s (%#x) has no handler.\n", debug_d3dstate(i), i);
}
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
}
}
}
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs,
wined3d: Rename _WineD3D_GL_Info to struct wined3d_gl_info.
2009-07-17 10:34:01 +02:00
const struct wined3d_gl_info *gl_info, const struct StateEntryTemplate *vertex,
wined3d: Const correctness fixes for state.c.
2008-12-01 15:32:14 +01:00
const struct fragment_pipeline *fragment, const struct StateEntryTemplate *misc)
{
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
unsigned int i, type, handlers;
APPLYSTATEFUNC multistate_funcs[STATE_HIGHEST + 1][3];
const struct StateEntryTemplate *cur;
wined3d: Add extension information to the states. This patch adds a new field to the state templates. If this extension field is != 0, then the line is only applied to the final state table if the extension is supported. Once a line is applied to the final table, all further templates for this state from the same pipeline part are ignored. This allows removing some extension checks from the state handlers, which cleans them up and saves a few CPU cycles when applying the states.
2008-07-05 22:04:16 +02:00
BOOL set[STATE_HIGHEST + 1];
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
memset(multistate_funcs, 0, sizeof(multistate_funcs));
wined3d: Initialize the state table before filling it.
2008-07-02 22:27:46 +02:00
for(i = 0; i < STATE_HIGHEST + 1; i++) {
StateTable[i].representative = 0;
StateTable[i].apply = state_undefined;
}
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
for(type = 0; type < 3; type++) {
/* This switch decides the order in which the states are applied */
switch(type) {
case 0: cur = misc; break;
wined3d: Move shader_fragment_enable to the fragment pipeline implementation. It isn't related to the shader backend any longer. The nvts_enable in the ffp code isn't quite right as well, it should be moved away once there is a dedicated nvts fragment pipeline replacement
2008-07-04 22:09:49 +02:00
case 1: cur = fragment->states; break;
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
case 2: cur = vertex; break;
default: cur = NULL; /* Stupid compiler */
}
if(!cur) continue;
wined3d: Add extension information to the states. This patch adds a new field to the state templates. If this extension field is != 0, then the line is only applied to the final state table if the extension is supported. Once a line is applied to the final table, all further templates for this state from the same pipeline part are ignored. This allows removing some extension checks from the state handlers, which cleans them up and saves a few CPU cycles when applying the states.
2008-07-05 22:04:16 +02:00
/* GL extension filtering should not prevent multiple handlers being applied from different
* pipeline parts
*/
memset(set, 0, sizeof(set));
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
for(i = 0; cur[i].state; i++) {
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
APPLYSTATEFUNC *funcs_array;
wined3d: Add extension information to the states. This patch adds a new field to the state templates. If this extension field is != 0, then the line is only applied to the final state table if the extension is supported. Once a line is applied to the final table, all further templates for this state from the same pipeline part are ignored. This allows removing some extension checks from the state handlers, which cleans them up and saves a few CPU cycles when applying the states.
2008-07-05 22:04:16 +02:00
/* 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
*/
if(set[cur[i].state]) continue;
/* Skip state lines depending on unsupported extensions */
wined3d: Get rid of the GL_SUPPORT macro.
2009-10-29 10:37:11 +01:00
if (!gl_info->supported[cur[i].extension]) continue;
wined3d: Add extension information to the states. This patch adds a new field to the state templates. If this extension field is != 0, then the line is only applied to the final state table if the extension is supported. Once a line is applied to the final table, all further templates for this state from the same pipeline part are ignored. This allows removing some extension checks from the state handlers, which cleans them up and saves a few CPU cycles when applying the states.
2008-07-05 22:04:16 +02:00
set[cur[i].state] = TRUE;
/* 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
*/
wined3d: Use the rep instead of the apply function to determine if a state is used.
2010-04-01 11:34:45 +02:00
if (!cur[i].content.representative) continue;
wined3d: Add extension information to the states. This patch adds a new field to the state templates. If this extension field is != 0, then the line is only applied to the final state table if the extension is supported. Once a line is applied to the final table, all further templates for this state from the same pipeline part are ignored. This allows removing some extension checks from the state handlers, which cleans them up and saves a few CPU cycles when applying the states.
2008-07-05 22:04:16 +02:00
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
handlers = num_handlers(multistate_funcs[cur[i].state]);
multistate_funcs[cur[i].state][handlers] = cur[i].content.apply;
switch(handlers) {
case 0:
StateTable[cur[i].state].apply = cur[i].content.apply;
break;
case 1:
StateTable[cur[i].state].apply = multistate_apply_2;
dev_multistate_funcs[cur[i].state] = HeapAlloc(GetProcessHeap(),
0,
sizeof(**dev_multistate_funcs) * 2);
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
if (!dev_multistate_funcs[cur[i].state]) {
goto out_of_mem;
}
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
dev_multistate_funcs[cur[i].state][0] = multistate_funcs[cur[i].state][0];
dev_multistate_funcs[cur[i].state][1] = multistate_funcs[cur[i].state][1];
break;
case 2:
StateTable[cur[i].state].apply = multistate_apply_3;
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
funcs_array = HeapReAlloc(GetProcessHeap(),
0,
dev_multistate_funcs[cur[i].state],
sizeof(**dev_multistate_funcs) * 3);
if (!funcs_array) {
goto out_of_mem;
}
dev_multistate_funcs[cur[i].state] = funcs_array;
wined3d: Implement the state merger and start to use it.
2008-07-02 02:43:52 +02:00
dev_multistate_funcs[cur[i].state][2] = multistate_funcs[cur[i].state][2];
break;
default:
ERR("Unexpected amount of state handlers for state %u: %u\n",
cur[i].state, handlers + 1);
}
if(StateTable[cur[i].state].representative &&
StateTable[cur[i].state].representative != cur[i].content.representative) {
FIXME("State %u has different representatives in different pipeline parts\n",
cur[i].state);
}
StateTable[cur[i].state].representative = cur[i].content.representative;
}
}
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
wined3d: Prune invalid states from the state table.
2010-01-28 23:40:25 +01:00
prune_invalid_states(StateTable, gl_info);
wined3d: Add some basic state table validation.
2010-01-28 23:40:24 +01:00
validate_state_table(StateTable);
wined3d: Add code to cleanup device multistate_funcs.
2009-01-07 02:20:08 +01:00
return WINED3D_OK;
out_of_mem:
for (i = 0; i <= STATE_HIGHEST; ++i) {
HeapFree(GetProcessHeap(), 0, dev_multistate_funcs[i]);
}
memset(dev_multistate_funcs, 0, (STATE_HIGHEST + 1)*sizeof(*dev_multistate_funcs));
return E_OUTOFMEMORY;
wined3d: Start the state splitup. The idea of this patchset is to split the monolithic state set into 3 parts, vertex processing, fragment processing and other states(depth, stencil, scissor, ...). The states will be provided in templates which can be (mostly) independently combined, and are merged into a single state table at device creation time. This way we retain the advantages of the single state table and having the advantage of separated pipeline implementations which can be combined without any manually written glue code.
2008-07-02 01:23:44 +02:00
}