WineD3D: Add render states to the state table

Stefan Dösinger stefan at codeweavers.com
Tue Dec 5 16:33:34 CST 2006


A rather long mail follows to explain my design decicions. Alexandre, if you 
have objections tell me, I can change things. If anyone else puts a veto I'll 
change stuff too.

This patch adds d3d render state entries to the state table. So far the 
entries are sort of emtpy, they all have the state_unknown apply function. 
The representatives are already there because it safed the effort of 
modifying them back and fixing the whitespaces.

I want to put all states into one table, and create the correct indices with 
macros. So further states will work like this:

#define STATE_TRANSFORM(a) (STATE_RENDER(WINEHIGHEST_RENDER_STATE) + (a))

Why do I prefer that way?

* It allows us to build groups between different states, for example link 
lighting to the vertex declaration

* Only one function to dirtify states. If I use different tables and dirty 
lists I'd need a seperate dirtification function for each state type. 
Simmilarily when applying the states only one list has to be checked.

* The uglyness is in the macros, which are handled at compile time. It doesn't 
leave any inefficiency in the code, like having a bunch of almost simmilar 
functions in the code, or checking a bigger number of lists instead of just 
one.

The other slightly ugly stuff will be finding out which state is meant, like
DWORD sampler = state - STATE_SAMPLER(0); This will be only needed for texture 
stages and samplers, the other code knows with which states it works, and 
does not really use the state variable passed to it.

Another thing that is quite obvious is that if the WINEHIGHEST_RENDER_STATE 
value is changed the table indices will be wrong. There is no checking for 
that, and I want to be able to just use the index for performance reasons. 
This table will most likely only change every few years with new directx 
versions, I do not think we should check its validity a few hundred times per 
secound. Breakage due to wrong indices will be very obvious to those who 
change the table or the highest values. If it is prefered I can put 
a "termination" entry at the end of the list which is checked at dll loading 
time.

As a sidenote, the STATE_IS_RENDER(a) macro is only used for nicer debugging 
output, the rest of the code inherently knows with which state it deals(a 
sampler function will never get a render state passed.
-------------- next part --------------
From 874f8407b7da2363e5f29c44d1ff5d72f760b851 Mon Sep 17 00:00:00 2001
From: Stefan Doesinger <stefan at codeweavers.com>
Date: Tue, 5 Dec 2006 21:54:16 +0100
Subject: [PATCH] WineD3D: Add render states to the state table

---
 dlls/wined3d/state.c           |  241 ++++++++++++++++++++++++++++++++++++++++
 dlls/wined3d/wined3d_private.h |    3 
 2 files changed, 242 insertions(+), 2 deletions(-)

diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 2b929b6..f70cbd6 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -28,11 +28,248 @@ #include "wined3d_private.h"
 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
 
 static void state_unknown(DWORD state, IWineD3DStateBlockImpl *stateblock) {
-    FIXME("Unknown state %d\n", state);
+    /* State which does exist, but wined3d doesn't know about */
+    if(STATE_IS_RENDER(state)) {
+        WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
+        FIXME("(%s, %d) Unknown state\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
+    } else {
+        FIXME("Unknown state %d with unknown type\n", state);
+    }
+}
+
+static void state_nogl(DWORD state, IWineD3DStateBlockImpl *stateblock) {
+    /* Used for states which are not mapped to a gl state as-is, but used somehow different,
+     * e.g as a parameter for drawing, or which are unimplemented in windows d3d
+     */
+    if(STATE_IS_RENDER(state)) {
+        WINED3DRENDERSTATETYPE RenderState = state - STATE_RENDER(0);
+        TRACE("(%s,%d) no direct mapping to gl\n", debug_d3drenderstate(RenderState), stateblock->renderState[RenderState]);
+    }
+}
+
+static void state_undefined(DWORD state, IWineD3DStateBlockImpl *stateblock) {
+    /* Print a WARN, this allows the stateblock code to loop over all states to generate a display
+     * list without causing confusing terminal output. Deliberately no special debug name here
+     * because its undefined.
+     */
+    WARN("undefined state %d\n", state);
 }
 
 const struct StateEntry StateTable[] =
 {
       /* State name                                         representative,                                     apply function */
-    { /* 0,  Undefined                              */      0,                                                  state_unknown     },
+    { /* 0,  Undefined                              */      0,                                                  state_undefined     },
+    { /* 1,  WINED3DRS_TEXTUREHANDLE                */      0 /* Handled in ddraw */,                           state_undefined     },
+    { /* 2,  WINED3DRS_ANTIALIAS                    */      STATE_RENDER(WINED3DRS_ANTIALIAS),                  state_unknown       },
+    { /* 3,  WINED3DRS_TEXTUREADDRESS               */      0 /* Handled in ddraw */,                           state_undefined     },
+    { /* 4,  WINED3DRS_TEXTUREPERSPECTIVE           */      STATE_RENDER(WINED3DRS_TEXTUREPERSPECTIVE),         state_unknown       },
+    { /* 5,  WINED3DRS_WRAPU                        */      STATE_RENDER(WINED3DRS_WRAPU),                      state_unknown       },
+    { /* 6,  WINED3DRS_WRAPV                        */      STATE_RENDER(WINED3DRS_WRAPV),                      state_unknown       },
+    { /* 7,  WINED3DRS_ZENABLE                      */      STATE_RENDER(WINED3DRS_ZENABLE),                    state_unknown       },
+    { /* 8,  WINED3DRS_FILLMODE                     */      STATE_RENDER(WINED3DRS_FILLMODE),                   state_unknown       },
+    { /* 9,  WINED3DRS_SHADEMODE                    */      STATE_RENDER(WINED3DRS_SHADEMODE),                  state_unknown       },
+    { /* 10, WINED3DRS_LINEPATTERN                  */      STATE_RENDER(WINED3DRS_LINEPATTERN),                state_unknown       },
+    { /* 11, WINED3DRS_MONOENABLE                   */      STATE_RENDER(WINED3DRS_MONOENABLE),                 state_unknown       },
+    { /* 12, WINED3DRS_ROP2                         */      STATE_RENDER(WINED3DRS_ROP2),                       state_unknown       },
+    { /* 13, WINED3DRS_PLANEMASK                    */      STATE_RENDER(WINED3DRS_PLANEMASK),                  state_unknown       },
+    { /* 14, WINED3DRS_ZWRITEENABLE                 */      STATE_RENDER(WINED3DRS_ZWRITEENABLE),               state_unknown       },
+    { /* 15, WINED3DRS_ALPHATESTENABLE              */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
+    { /* 16, WINED3DRS_LASTPIXEL                    */      STATE_RENDER(WINED3DRS_LASTPIXEL),                  state_unknown       },
+    { /* 17, WINED3DRS_TEXTUREMAG                   */      0 /* Handled in ddraw */,                           state_undefined     },
+    { /* 18, WINED3DRS_TEXTUREMIN                   */      0 /* Handled in ddraw */,                           state_undefined     },
+    { /* 19, WINED3DRS_SRCBLEND                     */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /* 20, WINED3DRS_DESTBLEND                    */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /* 21, WINED3DRS_TEXTUREMAPBLEND              */      0 /* Handled in ddraw */,                           state_undefined     },
+    { /* 22, WINED3DRS_CULLMODE                     */      STATE_RENDER(WINED3DRS_CULLMODE),                   state_unknown       },
+    { /* 23, WINED3DRS_ZFUNC                        */      STATE_RENDER(WINED3DRS_ZFUNC),                      state_unknown       },
+    { /* 24, WINED3DRS_ALPHAREF                     */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
+    { /* 25, WINED3DRS_ALPHAFUNC                    */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
+    { /* 26, WINED3DRS_DITHERENABLE                 */      STATE_RENDER(WINED3DRS_DITHERENABLE),               state_unknown       },
+    { /* 27, WINED3DRS_ALPHABLENDENABLE             */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /* 28, WINED3DRS_FOGENABLE                    */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
+    { /* 29, WINED3DRS_SPECULARENABLE               */      STATE_RENDER(WINED3DRS_SPECULARENABLE),             state_unknown       },
+    { /* 30, WINED3DRS_ZVISIBLE                     */      0 /* Not supported according to the msdn */,        state_nogl          },
+    { /* 31, WINED3DRS_SUBPIXEL                     */      STATE_RENDER(WINED3DRS_SUBPIXEL),                   state_unknown       },
+    { /* 32, WINED3DRS_SUBPIXELX                    */      STATE_RENDER(WINED3DRS_SUBPIXELX),                  state_unknown       },
+    { /* 33, WINED3DRS_STIPPLEDALPHA                */      STATE_RENDER(WINED3DRS_STIPPLEDALPHA),              state_unknown       },
+    { /* 34, WINED3DRS_FOGCOLOR                     */      STATE_RENDER(WINED3DRS_FOGCOLOR),                   state_unknown       },
+    { /* 35, WINED3DRS_FOGTABLEMODE                 */      STATE_RENDER(WINED3DRS_FOGENABLE)/*vertex type*/,   state_unknown       },
+    { /* 36, WINED3DRS_FOGSTART                     */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
+    { /* 37, WINED3DRS_FOGEND                       */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
+    { /* 38, WINED3DRS_FOGDENSITY                   */      STATE_RENDER(WINED3DRS_FOGDENSITY),                 state_unknown       },
+    { /* 39, WINED3DRS_STIPPLEENABLE                */      STATE_RENDER(WINED3DRS_STIPPLEENABLE),              state_unknown       },
+    { /* 40, WINED3DRS_EDGEANTIALIAS                */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /* 41, WINED3DRS_COLORKEYENABLE               */      STATE_RENDER(WINED3DRS_ALPHATESTENABLE),            state_unknown       },
+    { /* 42, undefined                              */      0,                                                  state_undefined     },
+    { /* 43, WINED3DRS_BORDERCOLOR                  */      STATE_RENDER(WINED3DRS_BORDERCOLOR),                state_unknown       },
+    { /* 44, WINED3DRS_TEXTUREADDRESSU              */      0, /* Handled in ddraw */                           state_undefined     },
+    { /* 45, WINED3DRS_TEXTUREADDRESSV              */      0, /* Handled in ddraw */                           state_undefined     },
+    { /* 46, WINED3DRS_MIPMAPLODBIAS                */      STATE_RENDER(WINED3DRS_MIPMAPLODBIAS),              state_unknown       },
+    { /* 47, WINED3DRS_ZBIAS                        */      STATE_RENDER(WINED3DRS_ZBIAS),                      state_unknown       },
+    { /* 48, WINED3DRS_RANGEFOGENABLE               */      STATE_RENDER(WINED3DRS_RANGEFOGENABLE),             state_unknown       },
+    { /* 49, WINED3DRS_ANISOTROPY                   */      STATE_RENDER(WINED3DRS_ANISOTROPY),                 state_unknown       },
+    { /* 50, WINED3DRS_FLUSHBATCH                   */      STATE_RENDER(WINED3DRS_FLUSHBATCH),                 state_unknown       },
+    { /* 51, WINED3DRS_TRANSLUCENTSORTINDEPENDENT   */      STATE_RENDER(WINED3DRS_TRANSLUCENTSORTINDEPENDENT), state_unknown       },
+    { /* 52, WINED3DRS_STENCILENABLE                */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 53, WINED3DRS_STENCILFAIL                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 54, WINED3DRS_STENCILZFAIL                 */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 55, WINED3DRS_STENCILPASS                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 56, WINED3DRS_STENCILFUNC                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 57, WINED3DRS_STENCILREF                   */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 58, WINED3DRS_STENCILMASK                  */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /* 59, WINED3DRS_STENCILWRITEMASK             */      STATE_RENDER(WINED3DRS_STENCILWRITEMASK),           state_unknown       },
+    { /* 60, WINED3DRS_TEXTUREFACTOR                */      STATE_RENDER(WINED3DRS_TEXTUREFACTOR),              state_unknown       },
+    /* A BIG hole. If wanted, 'fixed' states like the vertex type or the bound shaders can be put here */
+    { /* 61, Undefined                              */      0,                                                  state_undefined     },
+    { /* 62, Undefined                              */      0,                                                  state_undefined     },
+    { /* 63, Undefined                              */      0,                                                  state_undefined     },
+    { /* 64, Undefined                              */      0,                                                  state_undefined     },
+    { /* 65, Undefined                              */      0,                                                  state_undefined     },
+    { /* 66, Undefined                              */      0,                                                  state_undefined     },
+    { /* 67, Undefined                              */      0,                                                  state_undefined     },
+    { /* 68, Undefined                              */      0,                                                  state_undefined     },
+    { /* 69, Undefined                              */      0,                                                  state_undefined     },
+    { /* 70, Undefined                              */      0,                                                  state_undefined     },
+    { /* 71, Undefined                              */      0,                                                  state_undefined     },
+    { /* 72, Undefined                              */      0,                                                  state_undefined     },
+    { /* 73, Undefined                              */      0,                                                  state_undefined     },
+    { /* 74, Undefined                              */      0,                                                  state_undefined     },
+    { /* 75, Undefined                              */      0,                                                  state_undefined     },
+    { /* 76, Undefined                              */      0,                                                  state_undefined     },
+    { /* 77, Undefined                              */      0,                                                  state_undefined     },
+    { /* 78, Undefined                              */      0,                                                  state_undefined     },
+    { /* 79, Undefined                              */      0,                                                  state_undefined     },
+    { /* 80, Undefined                              */      0,                                                  state_undefined     },
+    { /* 81, Undefined                              */      0,                                                  state_undefined     },
+    { /* 82, Undefined                              */      0,                                                  state_undefined     },
+    { /* 83, Undefined                              */      0,                                                  state_undefined     },
+    { /* 84, Undefined                              */      0,                                                  state_undefined     },
+    { /* 85, Undefined                              */      0,                                                  state_undefined     },
+    { /* 86, Undefined                              */      0,                                                  state_undefined     },
+    { /* 87, Undefined                              */      0,                                                  state_undefined     },
+    { /* 88, Undefined                              */      0,                                                  state_undefined     },
+    { /* 89, Undefined                              */      0,                                                  state_undefined     },
+    { /* 90, Undefined                              */      0,                                                  state_undefined     },
+    { /* 91, Undefined                              */      0,                                                  state_undefined     },
+    { /* 92, Undefined                              */      0,                                                  state_undefined     },
+    { /* 93, Undefined                              */      0,                                                  state_undefined     },
+    { /* 94, Undefined                              */      0,                                                  state_undefined     },
+    { /* 95, Undefined                              */      0,                                                  state_undefined     },
+    { /* 96, Undefined                              */      0,                                                  state_undefined     },
+    { /* 97, Undefined                              */      0,                                                  state_undefined     },
+    { /* 98, Undefined                              */      0,                                                  state_undefined     },
+    { /* 99, Undefined                              */      0,                                                  state_undefined     },
+    { /*100, Undefined                              */      0,                                                  state_undefined     },
+    { /*101, Undefined                              */      0,                                                  state_undefined     },
+    { /*102, Undefined                              */      0,                                                  state_undefined     },
+    { /*103, Undefined                              */      0,                                                  state_undefined     },
+    { /*104, Undefined                              */      0,                                                  state_undefined     },
+    { /*105, Undefined                              */      0,                                                  state_undefined     },
+    { /*106, Undefined                              */      0,                                                  state_undefined     },
+    { /*107, Undefined                              */      0,                                                  state_undefined     },
+    { /*108, Undefined                              */      0,                                                  state_undefined     },
+    { /*109, Undefined                              */      0,                                                  state_undefined     },
+    { /*110, Undefined                              */      0,                                                  state_undefined     },
+    { /*111, Undefined                              */      0,                                                  state_undefined     },
+    { /*112, Undefined                              */      0,                                                  state_undefined     },
+    { /*113, Undefined                              */      0,                                                  state_undefined     },
+    { /*114, Undefined                              */      0,                                                  state_undefined     },
+    { /*115, Undefined                              */      0,                                                  state_undefined     },
+    { /*116, Undefined                              */      0,                                                  state_undefined     },
+    { /*117, Undefined                              */      0,                                                  state_undefined     },
+    { /*118, Undefined                              */      0,                                                  state_undefined     },
+    { /*119, Undefined                              */      0,                                                  state_undefined     },
+    { /*120, Undefined                              */      0,                                                  state_undefined     },
+    { /*121, Undefined                              */      0,                                                  state_undefined     },
+    { /*122, Undefined                              */      0,                                                  state_undefined     },
+    { /*123, Undefined                              */      0,                                                  state_undefined     },
+    { /*124, Undefined                              */      0,                                                  state_undefined     },
+    { /*125, Undefined                              */      0,                                                  state_undefined     },
+    { /*126, Undefined                              */      0,                                                  state_undefined     },
+    { /*127, Undefined                              */      0,                                                  state_undefined     },
+    /* Big hole ends */
+    { /*128, WINED3DRS_WRAP0                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*129, WINED3DRS_WRAP1                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*130, WINED3DRS_WRAP2                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*131, WINED3DRS_WRAP3                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*132, WINED3DRS_WRAP4                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*133, WINED3DRS_WRAP5                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_unknown       },
+    { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING) /* Vertex decl! */,state_unknown       },
+    { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_unknown       },
+    { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_unknown       },
+    { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_unknown       },
+    { /*141, WINED3DRS_COLORVERTEX                  */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
+    { /*142, WINED3DRS_LOCALVIEWER                  */      STATE_RENDER(WINED3DRS_LOCALVIEWER),                state_unknown       },
+    { /*143, WINED3DRS_NORMALIZENORMALS             */      STATE_RENDER(WINED3DRS_NORMALIZENORMALS),           state_unknown       },
+    { /*144, WINED3DRS_COLORKEYBLENDENABLE          */      STATE_RENDER(WINED3DRS_COLORKEYBLENDENABLE),        state_unknown       },
+    { /*145, WINED3DRS_DIFFUSEMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
+    { /*146, WINED3DRS_SPECULARMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
+    { /*147, WINED3DRS_AMBIENTMATERIALSOURCE        */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
+    { /*148, WINED3DRS_EMISSIVEMATERIALSOURCE       */      STATE_RENDER(WINED3DRS_COLORVERTEX),                state_unknown       },
+    { /*149, Undefined                              */      0,                                                  state_undefined     },
+    { /*150, Undefined                              */      0,                                                  state_undefined     },
+    { /*151, WINED3DRS_VERTEXBLEND                  */      0,                                                  state_nogl          },
+    { /*152, WINED3DRS_CLIPPLANEENABLE              */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_unknown       },
+    { /*153, WINED3DRS_SOFTWAREVERTEXPROCESSING     */      0,                                                  state_nogl          },
+    { /*154, WINED3DRS_POINTSIZE                    */      STATE_RENDER(WINED3DRS_POINTSIZE),                  state_unknown       },
+    { /*155, WINED3DRS_POINTSIZE_MIN                */      STATE_RENDER(WINED3DRS_POINTSIZE_MIN),              state_unknown       },
+    { /*156, WINED3DRS_POINTSPRITEENABLE            */      STATE_RENDER(WINED3DRS_POINTSPRITEENABLE),          state_unknown       },
+    { /*157, WINED3DRS_POINTSCALEENABLE             */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
+    { /*158, WINED3DRS_POINTSCALE_A                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
+    { /*159, WINED3DRS_POINTSCALE_B                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
+    { /*160, WINED3DRS_POINTSCALE_C                 */      STATE_RENDER(WINED3DRS_POINTSCALEENABLE),           state_unknown       },
+    { /*161, WINED3DRS_MULTISAMPLEANTIALIAS         */      STATE_RENDER(WINED3DRS_MULTISAMPLEANTIALIAS),       state_unknown       },
+    { /*162, WINED3DRS_MULTISAMPLEMASK              */      STATE_RENDER(WINED3DRS_MULTISAMPLEMASK),            state_unknown       },
+    { /*163, WINED3DRS_PATCHEDGESTYLE               */      STATE_RENDER(WINED3DRS_PATCHEDGESTYLE),             state_unknown       },
+    { /*164, WINED3DRS_PATCHSEGMENTS                */      STATE_RENDER(WINED3DRS_PATCHSEGMENTS),              state_unknown       },
+    { /*165, WINED3DRS_DEBUGMONITORTOKEN            */      STATE_RENDER(WINED3DRS_DEBUGMONITORTOKEN),          state_unknown       },
+    { /*166, WINED3DRS_POINTSIZE_MAX                */      STATE_RENDER(WINED3DRS_POINTSIZE_MAX),              state_unknown       },
+    { /*167, WINED3DRS_INDEXEDVERTEXBLENDENABLE     */      STATE_RENDER(WINED3DRS_INDEXEDVERTEXBLENDENABLE),   state_unknown       },
+    { /*168, WINED3DRS_COLORWRITEENABLE             */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
+    { /*169, Undefined                              */      0,                                                  state_undefined     },
+    { /*170, WINED3DRS_TWEENFACTOR                  */      0,                                                  state_nogl          },
+    { /*171, WINED3DRS_BLENDOP                      */      STATE_RENDER(WINED3DRS_BLENDOP),                    state_unknown       },
+    { /*172, WINED3DRS_POSITIONDEGREE               */      STATE_RENDER(WINED3DRS_POSITIONDEGREE),             state_unknown       },
+    { /*173, WINED3DRS_NORMALDEGREE                 */      STATE_RENDER(WINED3DRS_NORMALDEGREE),               state_unknown       },
+      /*172, WINED3DRS_POSITIONORDER                */      /* Value assigned to 2 state names */
+      /*173, WINED3DRS_NORMALORDER                  */      /* Value assigned to 2 state names */
+    { /*174, WINED3DRS_SCISSORTESTENABLE            */      STATE_RENDER(WINED3DRS_SCISSORTESTENABLE),          state_unknown       },
+    { /*175, WINED3DRS_SLOPESCALEDEPTHBIAS          */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
+    { /*176, WINED3DRS_ANTIALIASEDLINEENABLE        */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /*177, undefined                              */      0,                                                  state_undefined     },
+    { /*178, WINED3DRS_MINTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*179, WINED3DRS_MAXTESSELLATIONLEVEL         */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*180, WINED3DRS_ADAPTIVETESS_X               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*181, WINED3DRS_ADAPTIVETESS_Y               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*182, WINED3DRS_ADAPTIVETESS_Z               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*183, WINED3DRS_ADAPTIVETESS_W               */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*184, WINED3DRS_ENABLEADAPTIVETESSELLATION   */      STATE_RENDER(WINED3DRS_ENABLEADAPTIVETESSELLATION), state_unknown       },
+    { /*185, WINED3DRS_TWOSIDEDSTENCILMODE          */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /*186, WINED3DRS_CCW_STENCILFAIL              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /*187, WINED3DRS_CCW_STENCILZFAIL             */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /*188, WINED3DRS_CCW_STENCILPASS              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /*189, WINED3DRS_CCW_STENCILFUNC              */      STATE_RENDER(WINED3DRS_STENCILENABLE),              state_unknown       },
+    { /*190, WINED3DRS_COLORWRITEENABLE1            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
+    { /*191, WINED3DRS_COLORWRITEENABLE2            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
+    { /*192, WINED3DRS_COLORWRITEENABLE3            */      STATE_RENDER(WINED3DRS_COLORWRITEENABLE),           state_unknown       },
+    { /*193, WINED3DRS_BLENDFACTOR                  */      STATE_RENDER(WINED3DRS_ALPHABLENDENABLE),           state_unknown       },
+    { /*194, WINED3DRS_SRGBWRITEENABLE              */      0,                                                  state_nogl          },
+    { /*195, WINED3DRS_DEPTHBIAS                    */      STATE_RENDER(WINED3DRS_DEPTHBIAS),                  state_unknown       },
+    { /*196, undefined                              */      0,                                                  state_undefined     },
+    { /*197, undefined                              */      0,                                                  state_undefined     },
+    { /*198, WINED3DRS_WRAP8                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*199, WINED3DRS_WRAP9                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*200, WINED3DRS_WRAP10                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*201, WINED3DRS_WRAP11                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*202, WINED3DRS_WRAP12                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*203, WINED3DRS_WRAP13                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*204, WINED3DRS_WRAP14                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*205, WINED3DRS_WRAP15                       */      STATE_RENDER(WINED3DRS_WRAP0),                      state_unknown       },
+    { /*206, WINED3DRS_SEPARATEALPHABLENDENABLE     */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
+    { /*207, WINED3DRS_SRCBLENDALPHA                */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
+    { /*208, WINED3DRS_DESTBLENDALPHA               */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
+    { /*209, WINED3DRS_BLENDOPALPHA                 */      STATE_RENDER(WINED3DRS_SEPARATEALPHABLENDENABLE),   state_unknown       },
 };
diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h
index fac02b1..b7463ee 100644
--- a/dlls/wined3d/wined3d_private.h
+++ b/dlls/wined3d/wined3d_private.h
@@ -410,6 +410,9 @@ #define GET_TEXCOORD_SIZE_FROM_FVF(d3dvt
 /* Routines and structures related to state management */
 typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock);
 
+#define STATE_RENDER(a) (a)
+#define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))
+
 struct StateEntry
 {
     DWORD           representative;
-- 
1.4.2.4



More information about the wine-patches mailing list