Changeset 50041 in vbox for trunk/src/VBox/GuestHost/OpenGL/state_tracker

Timestamp:

Jan 9, 2014 4:13:28 PM (11 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

91522

Message:

crOpenGL: crOpenGL: 1. workaround point sprite driver bugs; 2. workaround multi-string shader source driver bug; 3. proper GLhandle for OSX; 4. extended dumping; 5. misc fixes

Location:

trunk

Files:

• . (modified) (1 prop)
• src/VBox (modified) (1 prop)
• src/VBox/GuestHost/OpenGL/state_tracker/dump.cpp (modified) (5 diffs)
• src/VBox/GuestHost/OpenGL/state_tracker/dump_gen.py (modified) (4 diffs)
• src/VBox/GuestHost/OpenGL/state_tracker/get_components.py (added)
• src/VBox/GuestHost/OpenGL/state_tracker/state_get.py (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_glsl.c (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_point.c (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_texture.c (modified) (1 diff)

trunk/src/VBox/GuestHost/OpenGL/state_tracker/dump.cpp

@@ -730 +730 @@
     crRecDumpLog(pRec, hwid);
 
-    GLhandleARB *pShaders = (GLhandleARB*)crCalloc(cShaders * sizeof (*pShaders));
+    VBoxGLhandleARB *pShaders = (VBoxGLhandleARB*)crCalloc(cShaders * sizeof (*pShaders));
     if (!pShaders)
     {
@@ -741 +741 @@
     for (GLint i = 0; i < cShaders; ++i)
     {
-        crRecDumpShader(pRec, ctx, 0, pShaders[i]);
+        if (pShaders[i])
+            crRecDumpShader(pRec, ctx, 0, pShaders[i]);
+        else
+            crDmpStrF(pRec->pDumper, "WARNING: Shader[%d] is null", i);
     }
 
@@ -848 +851 @@
     crDmpStrF(pRec->pDumper, "==RECOMPILE PROGRAM ctx(%d) id(%d) hwid(%d) status(%d) shaders(%d)==", ctx->id, id, hwid, linkStatus, cShaders);
 
-    GLhandleARB *pShaders = (GLhandleARB*)crCalloc(cShaders * sizeof (*pShaders));
+    VBoxGLhandleARB *pShaders = (VBoxGLhandleARB*)crCalloc(cShaders * sizeof (*pShaders));
     if (!pShaders)
     {
@@ -1665 +1668 @@
 }
 
+DECLEXPORT(bool) crDmpHtmlIsInited(struct CR_HTML_DUMPER * pDumper)
+{
+    return !!pDumper->pFile;
+}
+
+DECLEXPORT(void) crDmpHtmlTerm(struct CR_HTML_DUMPER * pDumper)
+{
+    crDmpHtmlPrintFooter(pDumper);
+    fclose (pDumper->pFile);
+    pDumper->pFile = NULL;
+}
+
 DECLEXPORT(int) crDmpHtmlInit(struct CR_HTML_DUMPER * pDumper, const char *pszDir, const char *pszFile)
 {
@@ -1707 +1722 @@
 }
 
+DECLEXPORT(int) crDmpHtmlInitV(struct CR_HTML_DUMPER * pDumper, const char *pszDir, const char *pszFile, va_list pArgList)
+{
+    char szBuffer[4096] = {0};
+    vsprintf_s(szBuffer, sizeof (szBuffer), pszFile, pArgList);
+    return crDmpHtmlInit(pDumper, pszDir, szBuffer);
+}
+
+DECLEXPORT(int) crDmpHtmlInitF(struct CR_HTML_DUMPER * pDumper, const char *pszDir, const char *pszFile, ...)
+{
+    int rc;
+    va_list pArgList;
+    va_start(pArgList, pszFile);
+    rc = crDmpHtmlInitV(pDumper, pszDir, pszFile, pArgList);
+    va_end(pArgList);
+    return rc;
+}
+
 #endif

trunk/src/VBox/GuestHost/OpenGL/state_tracker/dump_gen.py

@@ -128 +128 @@
 #endif
 """
-
-from get_components import *;
 
 texenv_mappings = {
@@ -195 +193 @@
 """
 for pname in texparam_names:
-    print "\tcComponents = lookupComponents(%s);" % pname
+    print "\tcComponents = crStateHlpComponentsCount(%s);" % pname
     print "\tAssert(cComponents <= RT_ELEMENTS(afBuf));"
     print "\tmemset(afBuf, 0, sizeof (afBuf));"
@@ -222 +220 @@
     values = texenv_mappings[target]
     for pname in values:
-        print "\tcComponents = lookupComponents(%s);" % pname
+        print "\tcComponents = crStateHlpComponentsCount(%s);" % pname
         print "\tAssert(cComponents <= RT_ELEMENTS(afBuf));"
         print "\tmemset(afBuf, 0, sizeof (afBuf));"
@@ -247 +245 @@
     print "\tcrDmpStrF(pRec->pDumper, \"===%s===\");" % coord
     for pname in texgen_names:
-        print "\tcComponents = lookupComponents(%s);" % pname
+        print "\tcComponents = crStateHlpComponentsCount(%s);" % pname
         print "\tAssert(cComponents <= RT_ELEMENTS(afBuf));"
         print "\tmemset(afBuf, 0, sizeof (afBuf));"

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_get.py

@@ -234 +234 @@
         print '\t}'
         print '}'
+
+from get_components import *

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_glsl.c

@@ -259 +259 @@
 }
 
-DECLEXPORT(GLuint) STATE_APIENTRY crStateDeleteObjectARB( GLhandleARB obj )
+DECLEXPORT(GLuint) STATE_APIENTRY crStateDeleteObjectARB( VBoxGLhandleARB obj )
 {
     GLuint hwId = crStateGetProgramHWID(obj);

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_point.c

@@ -201 +201 @@
         crStatePointParameterfvARB( pname, &f_param );
 }
+
+void crStatePointDiff(CRPointBits *b, CRbitvalue *bitID,
+        CRContext *fromCtx, CRContext *toCtx)
+{
+    CRPointState *from = &(fromCtx->point);
+    CRPointState *to = &(toCtx->point);
+    unsigned int j, i;
+    CRbitvalue nbitID[CR_MAX_BITARRAY];
+    Assert(0);
+    for (j=0;j<CR_MAX_BITARRAY;j++)
+        nbitID[j] = ~bitID[j];
+    i = 0; /* silence compiler */
+    if (CHECKDIRTY(b->enableSmooth, bitID))
+    {
+        glAble able[2];
+        able[0] = diff_api.Disable;
+        able[1] = diff_api.Enable;
+        if (from->pointSmooth != to->pointSmooth)
+        {
+            able[to->pointSmooth](GL_POINT_SMOOTH);
+            from->pointSmooth = to->pointSmooth;
+        }
+        CLEARDIRTY(b->enableSmooth, nbitID);
+    }
+    if (CHECKDIRTY(b->size, bitID))
+    {
+        if (from->pointSize != to->pointSize)
+        {
+            diff_api.PointSize (to->pointSize);
+            from->pointSize = to->pointSize;
+        }
+        CLEARDIRTY(b->size, nbitID);
+    }
+    if (CHECKDIRTY(b->minSize, bitID))
+    {
+        if (from->minSize != to->minSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SIZE_MIN_ARB, to->minSize);
+            from->minSize = to->minSize;
+        }
+        CLEARDIRTY(b->minSize, nbitID);
+    }
+    if (CHECKDIRTY(b->maxSize, bitID))
+    {
+        if (from->maxSize != to->maxSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SIZE_MAX_ARB, to->maxSize);
+            from->maxSize = to->maxSize;
+        }
+        CLEARDIRTY(b->maxSize, nbitID);
+    }
+    if (CHECKDIRTY(b->fadeThresholdSize, bitID))
+    {
+        if (from->fadeThresholdSize != to->fadeThresholdSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_FADE_THRESHOLD_SIZE_ARB, to->fadeThresholdSize);
+            from->fadeThresholdSize = to->fadeThresholdSize;
+        }
+        CLEARDIRTY(b->fadeThresholdSize, nbitID);
+    }
+    if (CHECKDIRTY(b->spriteCoordOrigin, bitID))
+    {
+        if (from->spriteCoordOrigin != to->spriteCoordOrigin)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SPRITE_COORD_ORIGIN, to->spriteCoordOrigin);
+            from->spriteCoordOrigin = to->spriteCoordOrigin;
+        }
+        CLEARDIRTY(b->spriteCoordOrigin, nbitID);
+    }
+    if (CHECKDIRTY(b->distanceAttenuation, bitID))
+    {
+        if (from->distanceAttenuation[0] != to->distanceAttenuation[0] || from->distanceAttenuation[1] != to->distanceAttenuation[1] || from->distanceAttenuation[2] != to->distanceAttenuation[2]) {
+            diff_api.PointParameterfvARB (GL_POINT_DISTANCE_ATTENUATION_ARB, to->distanceAttenuation);
+            from->distanceAttenuation[0] = to->distanceAttenuation[0];
+            from->distanceAttenuation[1] = to->distanceAttenuation[1];
+            from->distanceAttenuation[2] = to->distanceAttenuation[2];
+        }
+        CLEARDIRTY(b->distanceAttenuation, nbitID);
+    }
+    if (CHECKDIRTY(b->enableSprite, bitID))
+    {
+        glAble able[2];
+        able[0] = diff_api.Disable;
+        able[1] = diff_api.Enable;
+        if (from->pointSprite != to->pointSprite)
+        {
+            able[to->pointSprite](GL_POINT_SPRITE_ARB);
+            from->pointSprite = to->pointSprite;
+        }
+        CLEARDIRTY(b->enableSprite, nbitID);
+    }
+    {
+        unsigned int activeUnit = (unsigned int) -1;
+        for (i = 0; i < CR_MAX_TEXTURE_UNITS; i++) {
+            if (CHECKDIRTY(b->coordReplacement[i], bitID))
+            {
+                GLint replacement = to->coordReplacement[i];
+                if (activeUnit != i) {
+                     diff_api.ActiveTextureARB(i + GL_TEXTURE0_ARB );
+                     activeUnit = i;
+                }
+                diff_api.TexEnviv(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, &replacement);
+                from->coordReplacement[i] = to->coordReplacement[i];
+                CLEARDIRTY(b->coordReplacement[i], nbitID);
+            }
+        }
+        if (activeUnit != toCtx->texture.curTextureUnit)
+           diff_api.ActiveTextureARB(GL_TEXTURE0 + toCtx->texture.curTextureUnit);
+    }
+    CLEARDIRTY(b->dirty, nbitID);
+}
+
+void crStatePointSwitch(CRPointBits *b, CRbitvalue *bitID,
+        CRContext *fromCtx, CRContext *toCtx)
+{
+    CRPointState *from = &(fromCtx->point);
+    CRPointState *to = &(toCtx->point);
+    unsigned int j, i;
+    GLboolean fEnabled;
+    CRbitvalue nbitID[CR_MAX_BITARRAY];
+    for (j=0;j<CR_MAX_BITARRAY;j++)
+        nbitID[j] = ~bitID[j];
+    i = 0; /* silence compiler */
+    if (CHECKDIRTY(b->enableSmooth, bitID))
+    {
+        glAble able[2];
+        able[0] = diff_api.Disable;
+        able[1] = diff_api.Enable;
+        if (from->pointSmooth != to->pointSmooth)
+        {
+            able[to->pointSmooth](GL_POINT_SMOOTH);
+            FILLDIRTY(b->enableSmooth);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->enableSmooth, nbitID);
+    }
+    if (CHECKDIRTY(b->size, bitID))
+    {
+        if (from->pointSize != to->pointSize)
+        {
+            diff_api.PointSize (to->pointSize);
+            FILLDIRTY(b->size);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->size, nbitID);
+    }
+    if (CHECKDIRTY(b->minSize, bitID))
+    {
+        if (from->minSize != to->minSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SIZE_MIN_ARB, to->minSize);
+            FILLDIRTY(b->minSize);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->minSize, nbitID);
+    }
+    if (CHECKDIRTY(b->maxSize, bitID))
+    {
+        if (from->maxSize != to->maxSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SIZE_MAX_ARB, to->maxSize);
+            FILLDIRTY(b->maxSize);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->maxSize, nbitID);
+    }
+    if (CHECKDIRTY(b->fadeThresholdSize, bitID))
+    {
+        if (from->fadeThresholdSize != to->fadeThresholdSize)
+        {
+            diff_api.PointParameterfARB (GL_POINT_FADE_THRESHOLD_SIZE_ARB, to->fadeThresholdSize);
+            FILLDIRTY(b->fadeThresholdSize);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->fadeThresholdSize, nbitID);
+    }
+    if (CHECKDIRTY(b->spriteCoordOrigin, bitID))
+    {
+        if (from->spriteCoordOrigin != to->spriteCoordOrigin)
+        {
+            diff_api.PointParameterfARB (GL_POINT_SPRITE_COORD_ORIGIN, to->spriteCoordOrigin);
+            FILLDIRTY(b->spriteCoordOrigin);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->spriteCoordOrigin, nbitID);
+    }
+    if (CHECKDIRTY(b->distanceAttenuation, bitID))
+    {
+        if (from->distanceAttenuation[0] != to->distanceAttenuation[0] || from->distanceAttenuation[1] != to->distanceAttenuation[1] || from->distanceAttenuation[2] != to->distanceAttenuation[2]) {
+            diff_api.PointParameterfvARB (GL_POINT_DISTANCE_ATTENUATION_ARB, to->distanceAttenuation);
+            FILLDIRTY(b->distanceAttenuation);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->distanceAttenuation, nbitID);
+    }
+    fEnabled = from->pointSprite;
+    {
+        unsigned int activeUnit = (unsigned int) -1;
+        for (i = 0; i < CR_MAX_TEXTURE_UNITS; i++) {
+            if (CHECKDIRTY(b->coordReplacement[i], bitID))
+            {
+                if (!fEnabled)
+                {
+                    diff_api.Enable(GL_POINT_SPRITE_ARB);
+                    fEnabled = GL_TRUE;
+                }
+#if 0
+                /*don't set coord replacement, it will be set just before drawing points when necessary,
+                 * to work around gpu driver bugs
+                 * See crServerDispatch[Begin|End|Draw*] */
+                GLint replacement = to->coordReplacement[i];
+                if (activeUnit != i) {
+                     diff_api.ActiveTextureARB(i + GL_TEXTURE0_ARB );
+                     activeUnit = i;
+                }
+                diff_api.TexEnviv(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, &replacement);
+#endif
+                CLEARDIRTY(b->coordReplacement[i], nbitID);
+            }
+        }
+        if (activeUnit != toCtx->texture.curTextureUnit)
+           diff_api.ActiveTextureARB(GL_TEXTURE0 + toCtx->texture.curTextureUnit);
+    }
+    if (CHECKDIRTY(b->enableSprite, bitID))
+    {
+        glAble able[2];
+        able[0] = diff_api.Disable;
+        able[1] = diff_api.Enable;
+        if (fEnabled != to->pointSprite)
+        {
+            able[to->pointSprite](GL_POINT_SPRITE_ARB);
+            FILLDIRTY(b->enableSprite);
+            FILLDIRTY(b->dirty);
+        }
+        CLEARDIRTY(b->enableSprite, nbitID);
+    }
+    else if (fEnabled != to->pointSprite)
+    {
+        glAble able[2];
+        able[0] = diff_api.Disable;
+        able[1] = diff_api.Enable;
+        able[to->pointSprite](GL_POINT_SPRITE_ARB);
+    }
+    CLEARDIRTY(b->dirty, nbitID);
+}

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texture.c

@@ -3260 +3260 @@
                                                     const GLclampf *priorities) 
 {
-    UNUSED(n);
-    UNUSED(textures);
+    CRContext *g = GetCurrentContext();
+    CRTextureObj *tobj;
+    GLsizei i;
     UNUSED(priorities);
-    /* TODO: */
+
+    for (i = 0; i < n; ++i)
+    {
+        GLuint tex = textures[i];
+        GET_TOBJ(tobj, g, tex);
+        if (!tobj)
+        {
+            Assert(crHashtableIsKeyUsed(g->shared->textureTable, tex));
+            tobj = crStateTextureAllocate_t(g, tex);
+        }
+
+        /* so far the code just ensures the tex object is created to make
+         * the crserverlib code be able to pass it to host ogl */
+
+        /* TODO: store texture priorities in the state data to be able to restore it properly
+         * on save state load */
+    }
+
     return;
 }