Am Donnerstag 19 Oktober 2006 12:08 schrieb Stefan Dösinger:
> Hi,
> I considererd that it would be finally time to get started with the state
> management rewrite :-) Just a mail with the final plan, if anyone has
> comments.
Well, I started with the thing, and I want to show the first results so others
can better see where we are headed :-)
I named the file state.c, no idea why. At the moment it only contains a state
management table which is basically empty. The state management table
contains a representative for each state(e.g. ALPHAFUNC is the representative
for ALPHAFUNC and ALPHAREF, because both states affect the same gl state.
Most states are their own representative for now, this will change when the
stuff is implemented. Those will be used to group render states depending on
each other
For each state there is a pointer to a function for applying the state. At the
moment those pointers are NULL, but later this file will contain static
functions for applying a specific state, referenced by the table. So a state
can be applied by calling
States[STATE_RENDER(RenderState)]->func(IWineD3DStateBlockImpl *);
STATE_RENDER is defined as
#define STATE_RENDER(a) (a)
for sampler states, ..., I will add a
#define STATE_SAMPLER(b, a) STATE_RENDER(WINEHIGHEST_RENDER_STATE +
WINEHIGHEST_SAMPLER_STATE * b + a)
and so on. Simmilar, if needed a STATE_IS_SAMPLER, but I don't think we'll
need that.
For the function that applies all the states in drawprim I was thinking about
2 ways: Using a pointer to the apply function in the table, or inline
functions, aka
LIST_FOR_EACH(dirty_states_list)
{
switch(current_state_number)
{
case STATE_RENDER(D3DRS_LIGHTING)
call_some_inline_function; break;
}
}
This would have avoided a full call+ret for each state that is applied, but
this switch block would grow terribly long, ~500 entries with all states in
one list, or the equivalent number in seperate switch blocks. I think a call
is faster than checking against 500 constants, and it allows us to apply a
single state with ease.
A
for(i = 0; i < HIGHEST_STATE_ENTRY; i++)
{
if(States[i]->func) States[i]->func(Stateblock);
}
will allow us to record a full stateblock into an opengl display list :-)
Concernes:
The state table will get pretty big, with some gaps. I want to allow finding a
state by just going into the array with the state number without having to
search for the state(yes, binary search is easilly possible, but still). We
can stuff the gaps with other states if we really, really want to, and code
for searching might take more memory than the gaps in the list.
The list can get hard to maintain, one missing entry and all pointers go
wrong... But we have to write it only once, d3d10 is unlikely to add more
stuff as the fixed function pipeline was kicked.
Grouping the states: Should work nice basically, but once concern about the
vertex type, lighting, fog, vertex shaders: Fog and Lighting depends on the
vertex type, and fog depends on wether a vertex shader is used. So
D3DRS_LIGHTING, D3DRS_FOGSTART, D3DRS_FOGEND, D3DRS_FOGENABLE,
D3DRS_FOGTABLEMODE, D3DRS_FOGVERTEXMODE, The vertex type, the bound vertex
shader will be linked together. Pretty huge block... Any suggestions about
breaking it up nicely?
More?
/*
* Direct3D state management
*
* Copyright 2006 Stefan Dösinger for CodeWeavers
*
* 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);
const struct StateEntry States[] =
{
/* State name representative, apply function */
{ /* 0, Undefined */ 0, NULL },
{ /* 1, WINED3DRS_TEXTUREHANDLE */ 0 /* Handled in ddraw */, NULL },
{ /* 2, WINED3DRS_ANTIALIAS */ STATE_RENDER(WINED3DRS_ANTIALIAS), NULL },
{ /* 3, WINED3DRS_TEXTUREADDRESS */ 0 /* Handled in ddraw */, NULL },
{ /* 4, WINED3DRS_TEXTUREPERSPECTIVE */ STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE), NULL },
{ /* 5, WINED3DRS_WRAPU */ STATE_RENDER(WINED3DRS_WRAPU), NULL },
{ /* 6, WINED3DRS_WRAPV */ STATE_RENDER(WINED3DRS_WRAPV), NULL },
{ /* 7, WINED3DRS_ZENABLE */ STATE_RENDER(WINED3DRS_ZENABLE), NULL },
{ /* 8, WINED3DRS_FILLMODE */ STATE_RENDER(WINED3DRS_FILLMODE), NULL },
{ /* 9, WINED3DRS_SHADEMODE */ STATE_RENDER(WINED3DRS_SHADEMODE), NULL },
{ /* 10, WINED3DRS_LINEPATTERN */ STATE_RENDER(WINED3DRS_LINEPATTERN), NULL },
{ /* 11, WINED3DRS_MONOENABLE */ STATE_RENDER(WINED3DRS_MONOENABLE), NULL },
{ /* 12, WINED3DRS_ROP2 */ STATE_RENDER(WINED3DRS_ROP2), NULL },
{ /* 13, WINED3DRS_PLANEMASK */ STATE_RENDER(WINED3DRS_PLANEMASK), NULL },
{ /* 14, WINED3DRS_ZWRITEENABLE */ STATE_RENDER(WINED3DRS_ZWRITEENABLE), NULL },
{ /* 15, WINED3DRS_ALPHATESTENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL },
{ /* 16, WINED3DRS_LASTPIXEL */ STATE_RENDER(WINED3DRS_LASTPIXEL), NULL },
{ /* 17, WINED3DRS_TEXTUREMAG */ 0 /* Handled in ddraw */, NULL },
{ /* 18, WINED3DRS_TEXTUREMIN */ 0 /* Handled in ddraw */, NULL },
{ /* 19, WINED3DRS_SRCBLEND */ STATE_RENDER(WINED3DRS_SRCBLEND), NULL },
{ /* 20, WINED3DRS_DESTBLEND */ STATE_RENDER(WINED3DRS_DESTBLEND), NULL },
{ /* 21, WINED3DRS_TEXTUREMAPBLEND */ 0 /* Handled in ddraw */, NULL },
{ /* 22, WINED3DRS_CULLMODE */ STATE_RENDER(WINED3DRS_CULLMODE), NULL },
{ /* 23, WINED3DRS_ZFUNC */ STATE_RENDER(WINED3DRS_ZFUNC), NULL },
{ /* 24, WINED3DRS_ALPHAREF */ STATE_RENDER(WINED3DRS_ALPHAFUNC), NULL },
{ /* 25, WINED3DRS_ALPHAFUNC */ STATE_RENDER(WINED3DRS_ALPHAFUNC), NULL },
{ /* 26, WINED3DRS_DITHERENABLE */ STATE_RENDER(WINED3DRS_DITHERENABLE), NULL },
{ /* 27, WINED3DRS_ALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_ALPHABLENDENABLE), NULL },
{ /* 28, WINED3DRS_FOGENABLE */ STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/, NULL },
{ /* 29, WINED3DRS_SPECULARENABLE */ STATE_RENDER(WINED3DRS_SPECULARENABLE), NULL },
{ /* 30, WINED3DRS_ZVISIBLE */ STATE_RENDER(WINED3DRS_ZVISIBLE), NULL },
{ /* 31, WINED3DRS_SUBPIXEL */ STATE_RENDER(WINED3DRS_SUBPIXEL), NULL },
{ /* 32, WINED3DRS_SUBPIXELX */ STATE_RENDER(WINED3DRS_SUBPIXELX), NULL },
{ /* 33, WINED3DRS_STIPPLEDALPHA */ STATE_RENDER(WINED3DRS_STIPPLEDALPHA), NULL },
{ /* 34, WINED3DRS_FOGCOLOR */ STATE_RENDER(WINED3DRS_FOGCOLOR), NULL },
{ /* 35, WINED3DRS_FOGTABLEMODE */ STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/, NULL },
{ /* 36, WINED3DRS_FOGSTART */ STATE_RENDER(WINED3DRS_FOGENABLE), NULL },
{ /* 37, WINED3DRS_FOGEND */ STATE_RENDER(WINED3DRS_FOGENABLE), NULL },
{ /* 38, WINED3DRS_FOGDENSITY */ STATE_RENDER(WINED3DRS_FOGDENSITY), NULL },
{ /* 39, WINED3DRS_STIPPLEENABLE */ STATE_RENDER(WINED3DRS_STIPPLEENABLE), NULL },
{ /* 40, WINED3DRS_EDGEANTIALIAS */ STATE_RENDER(WINED3DRS_EDGEANTIALIAS), NULL },
{ /* 41, WINED3DRS_COLORKEYENABLE */ STATE_RENDER(WINED3DRS_ALPHATESTENABLE), NULL },
{ /* 42, undefined */ 0, NULL },
{ /* 43, WINED3DRS_BORDERCOLOR */ STATE_RENDER(WINED3DRS_BORDERCOLOR), NULL },
{ /* 44, WINED3DRS_TEXTUREADDRESSU */ 0, /* Handled in ddraw */ NULL },
{ /* 45, WINED3DRS_TEXTUREADDRESSV */ 0, /* Handled in ddraw */ NULL },
{ /* 46, WINED3DRS_MIPMAPLODBIAS */ STATE_RENDER(WINED3DRS_MIPMAPLODBIAS), NULL },
{ /* 47, WINED3DRS_ZBIAS */ STATE_RENDER(WINED3DRS_ZBIAS), NULL },
{ /* 48, WINED3DRS_RANGEFOGENABLE */ STATE_RENDER(WINED3DRS_RANGEFOGENABLE), NULL },
{ /* 49, WINED3DRS_ANISOTROPY */ STATE_RENDER(WINED3DRS_ANISOTROPY), NULL },
{ /* 50, WINED3DRS_FLUSHBATCH */ STATE_RENDER(WINED3DRS_FLUSHBATCH), NULL },
{ /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT */ STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), NULL },
{ /* 52, WINED3DRS_STENCILENABLE */ STATE_RENDER(WINED3DRS_STENCILENABLE), NULL },
{ /* 53, WINED3DRS_STENCILFAIL */ STATE_RENDER(WINED3DRS_STENCILFAIL), NULL },
{ /* 54, WINED3DRS_STENCILZFAIL */ STATE_RENDER(WINED3DRS_STENCILZFAIL), NULL },
{ /* 55, WINED3DRS_STENCILPASS */ STATE_RENDER(WINED3DRS_STENCILPASS), NULL },
{ /* 56, WINED3DRS_STENCILFUNC */ STATE_RENDER(WINED3DRS_STENCILFUNC), NULL },
{ /* 57, WINED3DRS_STENCILREF */ STATE_RENDER(WINED3DRS_STENCILREF), NULL },
{ /* 58, WINED3DRS_STENCILMASK */ STATE_RENDER(WINED3DRS_STENCILMASK), NULL },
{ /* 59, WINED3DRS_STENCILWRITEMASK */ STATE_RENDER(WINED3DRS_STENCILWRITEMASK), NULL },
{ /* 60, WINED3DRS_TEXTUREFACTOR */ STATE_RENDER(WINED3DRS_TEXTUREFACTOR), NULL },
/* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
{ /* 61, Undefined */ 0, NULL },
{ /* 62, Undefined */ 0, NULL },
{ /* 63, Undefined */ 0, NULL },
{ /* 64, Undefined */ 0, NULL },
{ /* 65, Undefined */ 0, NULL },
{ /* 66, Undefined */ 0, NULL },
{ /* 67, Undefined */ 0, NULL },
{ /* 68, Undefined */ 0, NULL },
{ /* 69, Undefined */ 0, NULL },
{ /* 70, Undefined */ 0, NULL },
{ /* 71, Undefined */ 0, NULL },
{ /* 72, Undefined */ 0, NULL },
{ /* 73, Undefined */ 0, NULL },
{ /* 74, Undefined */ 0, NULL },
{ /* 75, Undefined */ 0, NULL },
{ /* 76, Undefined */ 0, NULL },
{ /* 77, Undefined */ 0, NULL },
{ /* 78, Undefined */ 0, NULL },
{ /* 79, Undefined */ 0, NULL },
{ /* 80, Undefined */ 0, NULL },
{ /* 81, Undefined */ 0, NULL },
{ /* 82, Undefined */ 0, NULL },
{ /* 83, Undefined */ 0, NULL },
{ /* 84, Undefined */ 0, NULL },
{ /* 85, Undefined */ 0, NULL },
{ /* 86, Undefined */ 0, NULL },
{ /* 87, Undefined */ 0, NULL },
{ /* 88, Undefined */ 0, NULL },
{ /* 89, Undefined */ 0, NULL },
{ /* 90, Undefined */ 0, NULL },
{ /* 91, Undefined */ 0, NULL },
{ /* 92, Undefined */ 0, NULL },
{ /* 93, Undefined */ 0, NULL },
{ /* 94, Undefined */ 0, NULL },
{ /* 95, Undefined */ 0, NULL },
{ /* 96, Undefined */ 0, NULL },
{ /* 97, Undefined */ 0, NULL },
{ /* 98, Undefined */ 0, NULL },
{ /* 99, Undefined */ 0, NULL },
{ /*100, Undefined */ 0, NULL },
{ /*101, Undefined */ 0, NULL },
{ /*102, Undefined */ 0, NULL },
{ /*103, Undefined */ 0, NULL },
{ /*104, Undefined */ 0, NULL },
{ /*105, Undefined */ 0, NULL },
{ /*106, Undefined */ 0, NULL },
{ /*107, Undefined */ 0, NULL },
{ /*108, Undefined */ 0, NULL },
{ /*109, Undefined */ 0, NULL },
{ /*110, Undefined */ 0, NULL },
{ /*111, Undefined */ 0, NULL },
{ /*112, Undefined */ 0, NULL },
{ /*113, Undefined */ 0, NULL },
{ /*114, Undefined */ 0, NULL },
{ /*115, Undefined */ 0, NULL },
{ /*116, Undefined */ 0, NULL },
{ /*117, Undefined */ 0, NULL },
{ /*118, Undefined */ 0, NULL },
{ /*119, Undefined */ 0, NULL },
{ /*120, Undefined */ 0, NULL },
{ /*121, Undefined */ 0, NULL },
{ /*122, Undefined */ 0, NULL },
{ /*123, Undefined */ 0, NULL },
{ /*124, Undefined */ 0, NULL },
{ /*125, Undefined */ 0, NULL },
{ /*126, Undefined */ 0, NULL },
{ /*127, Undefined */ 0, NULL },
/* Big hole ends */
{ /*128, WINED3DRS_WRAP0 */ STATE_RENDER(WINED3DRS_WRAP0), NULL },
{ /*129, WINED3DRS_WRAP1 */ STATE_RENDER(WINED3DRS_WRAP1), NULL },
{ /*130, WINED3DRS_WRAP2 */ STATE_RENDER(WINED3DRS_WRAP2), NULL },
{ /*131, WINED3DRS_WRAP3 */ STATE_RENDER(WINED3DRS_WRAP3), NULL },
{ /*132, WINED3DRS_WRAP4 */ STATE_RENDER(WINED3DRS_WRAP4), NULL },
{ /*133, WINED3DRS_WRAP5 */ STATE_RENDER(WINED3DRS_WRAP5), NULL },
{ /*134, WINED3DRS_WRAP6 */ STATE_RENDER(WINED3DRS_WRAP6), NULL },
{ /*135, WINED3DRS_WRAP7 */ STATE_RENDER(WINED3DRS_WRAP7), NULL },
{ /*136, WINED3DRS_CLIPPING */ STATE_RENDER(WINED3DRS_CLIPPING), NULL },
{ /*137, WINED3DRS_LIGHTING */ STATE_RENDER(WINED3DRS_LIGHTING), NULL },
{ /*138, WINED3DRS_EXTENTS */ STATE_RENDER(WINED3DRS_EXTENTS), NULL },
{ /*139, WINED3DRS_AMBIENT */ STATE_RENDER(WINED3DRS_AMBIENT), NULL },
{ /*140, WINED3DRS_FOGVERTEXMODE */ STATE_RENDER(WINED3DRS_FOGENABLE), NULL },
{ /*141, WINED3DRS_COLORVERTEX */ STATE_RENDER(WINED3DRS_COLORVERTEX), NULL },
{ /*142, WINED3DRS_LOCALVIEWER */ STATE_RENDER(WINED3DRS_LOCALVIEWER), NULL },
{ /*143, WINED3DRS_NORMALIZENORMALS */ STATE_RENDER(WINED3DRS_NORMALIZENORMALS), NULL },
{ /*144, WINED3DRS_COLORKEYBLENDENABLE */ STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE), NULL },
{ /*145, WINED3DRS_DIFFUSEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_DIFFUSEMATERIALSOURCE), NULL },
{ /*146, WINED3DRS_SPECULARMATERIALSOURCE */ STATE_RENDER(WINED3DRS_SPECULARMATERIALSOURCE), NULL },
{ /*147, WINED3DRS_AMBIENTMATERIALSOURCE */ STATE_RENDER(WINED3DRS_AMBIENTMATERIALSOURCE), NULL },
{ /*148, WINED3DRS_EMISSIVEMATERIALSOURCE */ STATE_RENDER(WINED3DRS_EMISSIVEMATERIALSOURCE), NULL },
{ /*149, WINED3DRS_VERTEXBLEND */ STATE_RENDER(WINED3DRS_VERTEXBLEND), NULL },
{ /*152, WINED3DRS_CLIPPLANEENABLE */ STATE_RENDER(WINED3DRS_CLIPPLANEENABLE), NULL },
{ /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING */ STATE_RENDER(WINED3DRS_SOFTWAREVERTEXPROCESSING), NULL },
{ /*154, WINED3DRS_POINTSIZE */ STATE_RENDER(WINED3DRS_POINTSIZE), NULL },
{ /*155, WINED3DRS_POINTSIZE_MIN */ STATE_RENDER(WINED3DRS_POINTSIZE_MIN), NULL },
{ /*156, WINED3DRS_POINTSPRITEENABLE */ STATE_RENDER(WINED3DRS_POINTSPRITEENABLE), NULL },
{ /*157, WINED3DRS_POINTSCALEENABLE */ STATE_RENDER(WINED3DRS_POINTSCALEENABLE), NULL },
{ /*158, WINED3DRS_POINTSCALE_A */ STATE_RENDER(WINED3DRS_POINTSCALE_A), NULL },
{ /*159, WINED3DRS_POINTSCALE_B */ STATE_RENDER(WINED3DRS_POINTSCALE_B), NULL },
{ /*160, WINED3DRS_POINTSCALE_C */ STATE_RENDER(WINED3DRS_POINTSCALE_C), NULL },
{ /*161, WINED3DRS_MULTISAMPLEANTIALIAS */ STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS), NULL },
{ /*162, WINED3DRS_MULTISAMPLEMASK */ STATE_RENDER(WINED3DRS_MULTISAMPLEMASK), NULL },
{ /*163, WINED3DRS_PATCHEDGESTYLE */ STATE_RENDER(WINED3DRS_PATCHEDGESTYLE), NULL },
{ /*164, WINED3DRS_PATCHSEGMENTS */ STATE_RENDER(WINED3DRS_PATCHSEGMENTS), NULL },
{ /*165, WINED3DRS_DEBUGMONITORTOKEN */ STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN), NULL },
{ /*166, WINED3DRS_POINTSIZE_MAX */ STATE_RENDER(WINED3DRS_POINTSIZE_MAX), NULL },
{ /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE */ STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE), NULL },
{ /*168, WINED3DRS_COLORWRITEENABLE */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE), NULL },
{ /*169, Undefined */ 0, NULL },
{ /*170, WINED3DRS_TWEENFACTOR */ STATE_RENDER(WINED3DRS_TWEENFACTOR), NULL },
{ /*171, WINED3DRS_BLENDOP */ STATE_RENDER(WINED3DRS_BLENDOP), NULL },
{ /*172, WINED3DRS_POSITIONORDER */ STATE_RENDER(WINED3DRS_POSITIONORDER), NULL },
{ /*173, WINED3DRS_NORMALORDER */ STATE_RENDER(WINED3DRS_NORMALORDER), NULL },
/*172, WINED3DRS_POSITIONDEGREE */
/*173, WINED3DRS_NORMALDEGREE */
{ /*174, WINED3DRS_SCISSORTESTENABLE */ STATE_RENDER(WINED3DRS_SCISSORTESTENABLE), NULL },
{ /*175, WINED3DRS_SLOPESCALEDEPTHBIAS */ STATE_RENDER(WINED3DRS_SLOPESCALEDEPTHBIAS), NULL },
{ /*176, WINED3DRS_ANTIALIASEDLINEENABLE */ STATE_RENDER(WINED3DRS_ANTIALIASEDLINEENABLE), NULL },
{ /*177, undefined */ 0, NULL },
{ /*178, WINED3DRS_MINTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_MINTESSELLATIONLEVEL), NULL },
{ /*179, WINED3DRS_MAXTESSELLATIONLEVEL */ STATE_RENDER(WINED3DRS_MAXTESSELLATIONLEVEL), NULL },
{ /*180, WINED3DRS_ADAPTIVETESS_X */ STATE_RENDER(WINED3DRS_ADAPTIVETESS_X), NULL },
{ /*181, WINED3DRS_ADAPTIVETESS_Y */ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Y), NULL },
{ /*182, WINED3DRS_ADAPTIVETESS_Z */ STATE_RENDER(WINED3DRS_ADAPTIVETESS_Z), NULL },
{ /*183, WINED3DRS_ADAPTIVETESS_W */ STATE_RENDER(WINED3DRS_ADAPTIVETESS_W), NULL },
{ /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION */ STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), NULL },
{ /*185, WINED3DRS_TWOSIDEDSTENCILMODE */ STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE), NULL },
{ /*186, WINED3DRS_CCW_STENCILFAIL */ STATE_RENDER(WINED3DRS_CCW_STENCILFAIL), NULL },
{ /*187, WINED3DRS_CCW_STENCILZFAIL */ STATE_RENDER(WINED3DRS_CCW_STENCILZFAIL), NULL },
{ /*188, WINED3DRS_CCW_STENCILPASS */ STATE_RENDER(WINED3DRS_CCW_STENCILPASS), NULL },
{ /*189, WINED3DRS_CCW_STENCILFUNC */ STATE_RENDER(WINED3DRS_CCW_STENCILFUNC), NULL },
{ /*190, WINED3DRS_COLORWRITEENABLE1 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE1), NULL },
{ /*191, WINED3DRS_COLORWRITEENABLE2 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE2), NULL },
{ /*192, WINED3DRS_COLORWRITEENABLE3 */ STATE_RENDER(WINED3DRS_COLORWRITEENABLE3), NULL },
{ /*193, WINED3DRS_BLENDFACTOR */ STATE_RENDER(WINED3DRS_BLENDFACTOR), NULL },
{ /*194, WINED3DRS_SRGBWRITEENABLE */ STATE_RENDER(WINED3DRS_SRGBWRITEENABLE), NULL },
{ /*195, WINED3DRS_DEPTHBIAS */ STATE_RENDER(WINED3DRS_DEPTHBIAS), NULL },
{ /*196, undefined */ 0, NULL },
{ /*197, undefined */ 0, NULL },
{ /*198, WINED3DRS_WRAP8 */ STATE_RENDER(WINED3DRS_WRAP8), NULL },
{ /*199, WINED3DRS_WRAP9 */ STATE_RENDER(WINED3DRS_WRAP9), NULL },
{ /*200, WINED3DRS_WRAP10 */ STATE_RENDER(WINED3DRS_WRAP10), NULL },
{ /*201, WINED3DRS_WRAP11 */ STATE_RENDER(WINED3DRS_WRAP11), NULL },
{ /*202, WINED3DRS_WRAP12 */ STATE_RENDER(WINED3DRS_WRAP12), NULL },
{ /*203, WINED3DRS_WRAP13 */ STATE_RENDER(WINED3DRS_WRAP13), NULL },
{ /*204, WINED3DRS_WRAP14 */ STATE_RENDER(WINED3DRS_WRAP14), NULL },
{ /*205, WINED3DRS_WRAP15 */ STATE_RENDER(WINED3DRS_WRAP15), NULL },
{ /*206, WINED3DRS_SEPARATEALPHABLENDENABLE */ STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE), NULL },
{ /*207, WINED3DRS_SRCBLENDALPHA */ STATE_RENDER(WINED3DRS_SRCBLENDALPHA), NULL },
{ /*208, WINED3DRS_DESTBLENDALPHA */ STATE_RENDER(WINED3DRS_DESTBLENDALPHA), NULL },
{ /*209, WINED3DRS_BLENDOPALPHA */ STATE_RENDER(WINED3DRS_BLENDOPALPHA), NULL }
};
