Imported from /home/lorry/working-area/delta_VirtualBox/VirtualBox-4.3.10.tar.bz2.HEADVirtualBox-4.3.10master

1 files changed, 174 insertions, 26 deletions

diff --git a/src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c b/src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c
index 09831311..005f9462 100644
--- a/src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c
+++ b/src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c
@@ -30,7 +30,7 @@ void crStateListsInit(CRContext *ctx)
     RESET(lb->dirty, ctx->bitid);
 }
 
-/*#define CRSTATE_DEBUG_QUERY_HW_STATE*/
+//#define CRSTATE_DEBUG_QUERY_HW_STATE
 
 #ifndef CRSTATE_DEBUG_QUERY_HW_STATE
 # define CRSTATE_SET_CAP(state, value, format) g->state=value
@@ -168,7 +168,7 @@ void crStateListsInit(CRContext *ctx)
         }                                                   \
     }
 
-void STATE_APIENTRY crStateQueryHWState()
+void STATE_APIENTRY crStateQueryHWState(GLuint fbFbo, GLuint bbFbo)
 {
     CRContext *g = GetCurrentContext();
     CRStateBits *sb = GetCurrentBits();
@@ -217,12 +217,68 @@ void STATE_APIENTRY crStateQueryHWState()
 
         if (CHECKDIRTY(sb->buffer.drawBuffer, negbitID))
         {
-            CRSTATE_SET_ENUM(buffer.drawBuffer, GL_DRAW_BUFFER);
+            GLuint buf = 0;
+            diff_api.GetIntegerv(GL_DRAW_BUFFER, &buf);
+
+            if (buf == GL_COLOR_ATTACHMENT0_EXT && (bbFbo || fbFbo))
+            {
+                GLuint binding = 0;
+                diff_api.GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &binding);
+                if (!binding)
+                {
+                    crWarning("HW state synch: GL_DRAW_FRAMEBUFFER_BINDING is NULL");
+                }
+
+                if (bbFbo && binding == bbFbo)
+                {
+                    g->buffer.drawBuffer = GL_BACK;
+                }
+                else if (fbFbo && binding == fbFbo)
+                {
+                    g->buffer.drawBuffer = GL_FRONT;
+                }
+                else
+                {
+                    g->buffer.drawBuffer = buf;
+                }
+            }
+            else
+            {
+                g->buffer.drawBuffer = buf;
+            }
         }
 
         if (CHECKDIRTY(sb->buffer.readBuffer, negbitID))
         {
-            CRSTATE_SET_ENUM(buffer.readBuffer, GL_READ_BUFFER);
+            GLuint buf = 0;
+            diff_api.GetIntegerv(GL_READ_BUFFER, &buf);
+
+            if (buf == GL_COLOR_ATTACHMENT0_EXT && (bbFbo || fbFbo))
+            {
+                GLuint binding = 0;
+                diff_api.GetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &binding);
+                if (!binding)
+                {
+                    crWarning("HW state synch: GL_READ_FRAMEBUFFER_BINDING is NULL");
+                }
+
+                if (bbFbo && binding == bbFbo)
+                {
+                    g->buffer.readBuffer = GL_BACK;
+                }
+                else if (fbFbo && binding == fbFbo)
+                {
+                    g->buffer.readBuffer = GL_FRONT;
+                }
+                else
+                {
+                    g->buffer.readBuffer = buf;
+                }
+            }
+            else
+            {
+                g->buffer.readBuffer = buf;
+            }
         }
 
         if (CHECKDIRTY(sb->buffer.indexMask, negbitID))
@@ -295,23 +351,122 @@ void STATE_APIENTRY crStateQueryHWState()
 
     if (CHECKDIRTY(sb->stencil.dirty, negbitID))
     {
+        GLenum activeFace;
+        GLboolean backIsSet = GL_FALSE, frontIsSet = GL_FALSE;
+
         if (CHECKDIRTY(sb->stencil.enable, negbitID))
         {
             CRSTATE_SET_ENABLED(stencil.stencilTest, GL_STENCIL_TEST);
         }
 
-        if (CHECKDIRTY(sb->stencil.func, negbitID))
+        if (CHECKDIRTY(sb->stencil.enableTwoSideEXT, negbitID))
         {
-            CRSTATE_SET_ENUM(stencil.func, GL_STENCIL_FUNC);
-			CRSTATE_SET_INT(stencil.ref, GL_STENCIL_REF);
-			CRSTATE_SET_INT(stencil.mask, GL_STENCIL_VALUE_MASK);
+            CRSTATE_SET_ENABLED(stencil.stencilTwoSideEXT, GL_STENCIL_TEST_TWO_SIDE_EXT);
         }
 
-        if (CHECKDIRTY(sb->stencil.op, negbitID))
+        if (CHECKDIRTY(sb->stencil.activeStencilFace, negbitID))
         {
-            CRSTATE_SET_ENUM(stencil.fail, GL_STENCIL_FAIL);
-			CRSTATE_SET_ENUM(stencil.passDepthFail, GL_STENCIL_PASS_DEPTH_FAIL);
-			CRSTATE_SET_ENUM(stencil.passDepthPass, GL_STENCIL_PASS_DEPTH_PASS);
+            CRSTATE_SET_ENUM(stencil.activeStencilFace, GL_ACTIVE_STENCIL_FACE_EXT);
+        }
+
+        activeFace = g->stencil.activeStencilFace;
+
+
+#define CRSTATE_SET_STENCIL_FUNC(_idx, _suff) do { \
+        CRSTATE_SET_ENUM(stencil.buffers[(_idx)].func, GL_STENCIL##_suff##FUNC); \
+        CRSTATE_SET_INT(stencil.buffers[(_idx)].ref, GL_STENCIL##_suff##REF); \
+        CRSTATE_SET_INT(stencil.buffers[(_idx)].mask, GL_STENCIL##_suff##VALUE_MASK); \
+    } while (0)
+
+#define CRSTATE_SET_STENCIL_OP(_idx, _suff) do { \
+        CRSTATE_SET_ENUM(stencil.buffers[(_idx)].fail, GL_STENCIL##_suff##FAIL); \
+        CRSTATE_SET_ENUM(stencil.buffers[(_idx)].passDepthFail, GL_STENCIL##_suff##PASS_DEPTH_FAIL); \
+        CRSTATE_SET_ENUM(stencil.buffers[(_idx)].passDepthPass, GL_STENCIL##_suff##PASS_DEPTH_PASS); \
+    } while (0)
+
+        /* func */
+
+        if (CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_BACK].func, negbitID))
+        {
+            /* this if branch is not needed here actually, just in case ogl drivers misbehave */
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+
+            CRSTATE_SET_STENCIL_FUNC(CRSTATE_STENCIL_BUFFER_ID_BACK, _BACK_);
+            backIsSet = GL_TRUE;
+        }
+
+        if (CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT].func, negbitID))
+        {
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+            CRSTATE_SET_STENCIL_FUNC(CRSTATE_STENCIL_BUFFER_ID_FRONT, _);
+            frontIsSet = GL_TRUE;
+        }
+
+        if ((!frontIsSet || !backIsSet) && CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT_AND_BACK].func, negbitID))
+        {
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+            CRSTATE_SET_STENCIL_FUNC(CRSTATE_STENCIL_BUFFER_ID_FRONT, _);
+            if (!backIsSet)
+            {
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].func = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].func;
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].ref = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].ref;
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].mask = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].mask;
+            }
+        }
+
+        /* op */
+        backIsSet = GL_FALSE, frontIsSet = GL_FALSE;
+
+        if (CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_BACK].op, negbitID))
+        {
+            /* this if branch is not needed here actually, just in case ogl drivers misbehave */
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+
+            CRSTATE_SET_STENCIL_OP(CRSTATE_STENCIL_BUFFER_ID_BACK, _BACK_);
+            backIsSet = GL_TRUE;
+        }
+
+        if (CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT].op, negbitID))
+        {
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+            CRSTATE_SET_STENCIL_OP(CRSTATE_STENCIL_BUFFER_ID_FRONT, _);
+            frontIsSet = GL_TRUE;
+        }
+
+        if ((!frontIsSet || !backIsSet) && CHECKDIRTY(sb->stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT_AND_BACK].op, negbitID))
+        {
+            if (activeFace == GL_BACK)
+            {
+                diff_api.ActiveStencilFaceEXT(GL_FRONT);
+                activeFace = GL_FRONT;
+            }
+            CRSTATE_SET_STENCIL_OP(CRSTATE_STENCIL_BUFFER_ID_FRONT, _);
+            if (!backIsSet)
+            {
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].fail = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].fail;
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].passDepthFail = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].passDepthFail;
+                g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_BACK].passDepthPass = g->stencil.buffers[CRSTATE_STENCIL_BUFFER_ID_FRONT].passDepthPass;
+            }
         }
 
         if (CHECKDIRTY(sb->stencil.clearValue, negbitID))
@@ -499,12 +654,12 @@ void STATE_APIENTRY crStateQueryHWState()
         {
             CRSTATE_SET_MATERIAL_COLOR(lighting.ambient[0], GL_FRONT, GL_AMBIENT);
             CRSTATE_SET_MATERIAL_COLOR(lighting.ambient[1], GL_BACK, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.diffuse[0], GL_FRONT, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.diffuse[1], GL_BACK, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.specular[0], GL_FRONT, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.specular[1], GL_BACK, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.emission[0], GL_FRONT, GL_AMBIENT);
-            CRSTATE_SET_MATERIAL_COLOR(lighting.emission[1], GL_BACK, GL_AMBIENT);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.diffuse[0], GL_FRONT, GL_DIFFUSE);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.diffuse[1], GL_BACK, GL_DIFFUSE);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.specular[0], GL_FRONT, GL_SPECULAR);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.specular[1], GL_BACK, GL_SPECULAR);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.emission[0], GL_FRONT, GL_EMISSION);
+            CRSTATE_SET_MATERIAL_COLOR(lighting.emission[1], GL_BACK, GL_EMISSION);
             CRSTATE_SET_MATERIAL_F(lighting.shininess[0], GL_FRONT,  GL_SHININESS);
             CRSTATE_SET_MATERIAL_F(lighting.shininess[1], GL_BACK,  GL_SHININESS);
         }
@@ -1093,7 +1248,7 @@ void STATE_APIENTRY crStateNewList (GLuint list, GLenum mode)
     l->mode = mode;
 }
 
-void STATE_APIENTRY crStateEndList (void) 
+void STATE_APIENTRY crStateEndList (void)
 {
     CRContext *g = GetCurrentContext();
     CRListsState *l = &(g->lists);
@@ -1110,13 +1265,6 @@ void STATE_APIENTRY crStateEndList (void)
         return;
     }
 
-#ifndef IN_GUEST
-    if (l->mode==GL_COMPILE)
-    {
-        crStateQueryHWState();
-    }
-#endif
-
     l->currentIndex = 0;
     l->mode = 0;
 }