[7/10] WineD3D: Break the lighting state out of the vertex decl

[Stefan Dösinger]

The vertex declaration affects lighting, but it is pointless to  
reparse and apply the vdecl and stream sources when just the lighting  
is changed. The reenabled state_lighting function reads the decoded  
vertex declaration, and it does not perform anything if a vdecl  
update is sheduled. vertexdeclaration() will call lighting to update  
the lights, but only if the light state is not dirty yet.

Yes, states are marked clean before the apply func is called ;-)

-------------- next part --------------
From ca4e12b1de68dedca519107baf9bf4638d789401 Mon Sep 17 00:00:00 2001
From: =?utf-8?q?Stefan_D=C3=B6singer?= <stefan at imac.local>
Date: Tue, 2 Jan 2007 22:45:08 +0100
Subject: [PATCH] WineD3D: Break the lighting state out of the vertex decl state

---
 dlls/wined3d/state.c |   37 ++++++++++++++++++-------------------
 1 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c
index 334d430..9f690c5 100644
--- a/dlls/wined3d/state.c
+++ b/dlls/wined3d/state.c
@@ -71,15 +71,23 @@ static void state_fillmode(DWORD state, 
     }
 }
 
-#if 0
-/* if 0ed because it will be revived later */
 static void state_lighting(DWORD state, IWineD3DStateBlockImpl *stateblock) {
+    BOOL normals;
 
-    /* TODO: Lighting is only enabled if Vertex normals are passed by the application,
-     * so merge the lighting render state with the vertex declaration once it is available
+    /* Lighting is only enabled if Vertex normals are passed by the application,
+     * but lighting does not affect the stream sources, so it is not grouped for performance reasons.
+     * This state reads the decoded vertex decl, so if it is dirty don't do anything. The
+     * vertex declaration appplying function calls this function for updating
      */
 
-    if (stateblock->renderState[WINED3DRS_LIGHTING]) {
+	if(isStateDirty(stateblock->wineD3DDevice, STATE_VDECL)) {
+		return;
+	}
+
+    normals = stateblock->wineD3DDevice->strided_streams.u.s.normal.lpData != NULL ||
+              stateblock->wineD3DDevice->strided_streams.u.s.normal.VBO != 0;
+
+    if (stateblock->renderState[WINED3DRS_LIGHTING] && normals) {
         glEnable(GL_LIGHTING);
         checkGLcall("glEnable GL_LIGHTING");
     } else {
@@ -87,7 +95,6 @@ static void state_lighting(DWORD state, 
         checkGLcall("glDisable GL_LIGHTING");
     }
 }
-#endif
 
 static void state_zenable(DWORD state, IWineD3DStateBlockImpl *stateblock) {
     switch ((WINED3DZBUFFERTYPE) stateblock->renderState[WINED3DRS_ZENABLE]) {
@@ -1885,7 +1892,7 @@ static const GLfloat invymat[16] = {
 
 static void vertexdeclaration(DWORD state, IWineD3DStateBlockImpl *stateblock) {
     BOOL useVertexShaderFunction = FALSE, updateFog = FALSE;
-    BOOL transformed, lit;
+    BOOL transformed;
     /* Some stuff is in the device until we have per context tracking */
     IWineD3DDeviceImpl *device = stateblock->wineD3DDevice;
     BOOL wasrhw = device->last_was_rhw;
@@ -1941,22 +1948,14 @@ static void vertexdeclaration(DWORD stat
     transformed = ((device->strided_streams.u.s.position.lpData != NULL ||
                     device->strided_streams.u.s.position.VBO != 0) &&
                     device->strided_streams.u.s.position_transformed) ? TRUE : FALSE;
-    lit = device->strided_streams.u.s.normal.lpData == NULL &&
-          device->strided_streams.u.s.normal.VBO == 0;
 
     if(transformed != device->last_was_rhw && !useVertexShaderFunction) {
         updateFog = TRUE;
     }
 
-    /* TODO: The vertex declaration changes lighting, but lighting doesn't affect the vertex declaration and the
-     * stream sources. This can be handled nicer
-     */
-    if(stateblock->renderState[WINED3DRS_LIGHTING] && !lit) {
-        glEnable(GL_LIGHTING);
-        checkGLcall("glEnable(GL_LIGHTING)");
-    } else {
-        glDisable(GL_LIGHTING);
-        checkGLcall("glDisable(GL_LIGHTING");
+    /* Reapply lighting if it is not sheduled for reapplication already */ 
+    if(!isStateDirty(device, STATE_RENDER(WINED3DRS_LIGHTING))) {
+        state_lighting(STATE_RENDER(WINED3DRS_LIGHTING), stateblock);
     }
 
     if (!useVertexShaderFunction && transformed) {
@@ -2165,7 +2164,7 @@ const struct StateEntry StateTable[] =
     { /*134, WINED3DRS_WRAP6                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
     { /*135, WINED3DRS_WRAP7                        */      STATE_RENDER(WINED3DRS_WRAP0),                      state_wrap          },
     { /*136, WINED3DRS_CLIPPING                     */      STATE_RENDER(WINED3DRS_CLIPPING),                   state_clipping      },
-    { /*137, WINED3DRS_LIGHTING                     */      STATE_VDECL,                                        vertexdeclaration   },
+    { /*137, WINED3DRS_LIGHTING                     */      STATE_RENDER(WINED3DRS_LIGHTING),                   state_lighting      },
     { /*138, WINED3DRS_EXTENTS                      */      STATE_RENDER(WINED3DRS_EXTENTS),                    state_extents       },
     { /*139, WINED3DRS_AMBIENT                      */      STATE_RENDER(WINED3DRS_AMBIENT),                    state_ambient       },
     { /*140, WINED3DRS_FOGVERTEXMODE                */      STATE_RENDER(WINED3DRS_FOGENABLE),                  state_fog           },
-- 
1.4.2.4