Changeset 50041 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

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/HostServices/SharedOpenGL/LICENSE (modified) (1 prop)
• src/VBox/HostServices/SharedOpenGL/Makefile.kmk (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/get_components.py (deleted)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server.h (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_get.py (modified) (2 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_getshaders.c (modified) (5 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_glsl.c (modified) (2 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_lists.c (modified) (2 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (4 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c (modified) (8 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_special (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_texture.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/render/renderspu.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/render/renderspu.h (modified) (3 diffs)
• src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c (modified) (3 diffs)
• src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/render/renderspu_wgl.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c (modified) (4 diffs)

trunk/src/VBox/HostServices/SharedOpenGL/Makefile.kmk

@@ -175 +175 @@
         $(QUIET)$(call VBOX_CROGL_PYTHON_ENV,$(VBOX_PATH_CROGL_PYTHON_INCLUDE),$@) $(VBOX_BLD_PYTHON) $< $(VBOX_PATH_CROGL_GLAPI) $(<D)
 
-$(VBOX_PATH_CROGL_GENFILES)/server_get.c: $(addprefix $(PATH_SUB_CURRENT)/crserverlib/, server_get.py server_special get_components.py) $(VBOX_CROGL_API_FILES) | $$(dir $$@)
+$(VBOX_PATH_CROGL_GENFILES)/server_get.c: $(addprefix $(PATH_SUB_CURRENT)/crserverlib/, server_get.py server_special) $(VBOX_CROGL_API_FILES) | $$(dir $$@)
         $(call MSG_GENERATE,python,$@,$<)
         $(QUIET)$(call VBOX_CROGL_PYTHON_ENV,$(VBOX_PATH_CROGL_PYTHON_INCLUDE),$@) $(VBOX_BLD_PYTHON) $< $(VBOX_PATH_CROGL_GLAPI) $(<D)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

@@ -250 +250 @@
     *pu8Val2 = tmp;
 }
+
+#ifdef DEBUG
+# define CR_GLERR_CHECK(_op) do { \
+        GLenum status; \
+        while ((status = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR) {/*Assert(0);*/} \
+        _op \
+        while ((status = cr_server.head_spu->dispatch_table.GetError()) != GL_NO_ERROR) {Assert(0);} \
+    } while (0)
+#else
+# define CR_GLERR_CHECK(_op) do { \
+        _op \
+    } while (0)
+#endif
 
 #ifdef DEBUG_misha

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_get.py

@@ -109 +109 @@
 ];
 
-from get_components import *;
-
 keys = apiutil.GetDispatchedFunctions(sys.argv[1]+"/APIspec.txt")
 for func_name in keys:
@@ -143 +141 @@
             print '\tcrServerReturnValue( &(%s[0]), %d*sizeof(%s) );' % (local_argname, max_components[func_name], local_argtype );
         else:
-            print '\tcrServerReturnValue( &(%s[0]), lookupComponents(pname)*sizeof(%s) );' % (local_argname, local_argtype );
+            print '\tcrServerReturnValue( &(%s[0]), crStateHlpComponentsCount(pname)*sizeof(%s) );' % (local_argname, local_argtype );
         print '}\n'

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getshaders.c

@@ -98 +98 @@
 }
 
-void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)
-{
-    GLsizei *pLocal;
-
-    pLocal = (GLsizei*) crAlloc(maxCount*sizeof(GLhandleARB)+sizeof(GLsizei));
-    if (!pLocal)
-    {
-        GLsizei zero=0;
-        crServerReturnValue(&zero, sizeof(zero));
-    }
-    /* initial (fallback )value */
-    *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(containerObj), maxCount, pLocal, (GLhandleARB*)&pLocal[1]);
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetAttachedObjectsARB(VBoxGLhandleARB containerObj, GLsizei maxCount, GLsizei * count, VBoxGLhandleARB * obj)
+{
+    GLsizei *pLocal;
+
+    pLocal = (GLsizei*) crAlloc(maxCount*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
+    if (!pLocal)
+    {
+        GLsizei zero=0;
+        crServerReturnValue(&zero, sizeof(zero));
+    }
+    /* initial (fallback )value */
+    *pLocal = 0;
+    cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(containerObj), maxCount, pLocal, (VBoxGLhandleARB*)&pLocal[1]);
 
     {
@@ -120 +120 @@
     }
 
-    crServerReturnValue(pLocal, (*pLocal)*sizeof(GLhandleARB)+sizeof(GLsizei));
+    crServerReturnValue(pLocal, (*pLocal)*sizeof(VBoxGLhandleARB)+sizeof(GLsizei));
     crFree(pLocal);
 }
@@ -126 +126 @@
 AssertCompile(sizeof(GLsizei) == 4);
 
-void SERVER_DISPATCH_APIENTRY crServerDispatchGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetInfoLogARB(VBoxGLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
 {
     GLsizei *pLocal;
@@ -305 +305 @@
 }
 
-void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat * params )
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterfvARB( VBoxGLhandleARB obj, GLenum pname, GLfloat * params )
 {
     GLfloat local_params[1];
@@ -324 +324 @@
 }
 
-void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint * params )
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetObjectParameterivARB( VBoxGLhandleARB obj, GLenum pname, GLint * params )
 {
     GLint local_params[1];

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_glsl.c

@@ -112 +112 @@
 }
 
-void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteObjectARB(GLhandleARB obj)
+void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteObjectARB(VBoxGLhandleARB obj)
 {
     GLuint hwid =  crStateDeleteObjectARB(obj);
@@ -130 +130 @@
 }
 
-GLhandleARB SERVER_DISPATCH_APIENTRY crServerDispatchGetHandleARB( GLenum pname )
+VBoxGLhandleARB SERVER_DISPATCH_APIENTRY crServerDispatchGetHandleARB( GLenum pname )
 {
-    GLhandleARB retval;
+    VBoxGLhandleARB retval;
     retval = cr_server.head_spu->dispatch_table.GetHandleARB(pname);
     if (pname==GL_PROGRAM_OBJECT_ARB)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_lists.c

@@ -308 +308 @@
     }
 
+    crStatePrioritizeTextures(n, textures, priorities);
+
     for (i = 0; i < n; i++)
     {
@@ -313 +315 @@
     }
 
-    crStatePrioritizeTextures(n, textures, priorities);
     cr_server.head_spu->dispatch_table.PrioritizeTextures(n, newTextures, priorities);
     crFree(newTextures);

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c

@@ -332 +332 @@
 #endif
 
-//    cr_server.bUseMultipleContexts = (crGetenv( "CR_SERVER_ENABLE_MULTIPLE_CONTEXTS" ) != NULL);
+    cr_server.bUseMultipleContexts = (crGetenv( "CR_SERVER_ENABLE_MULTIPLE_CONTEXTS" ) != NULL);
 
     if (cr_server.bUseMultipleContexts)
@@ -396 +396 @@
     crStateDiffAPI( &(cr_server.head_spu->dispatch_table) );
 
+#ifdef VBOX_WITH_CRSERVER_DUMPER
+    crMemset(&cr_server.Recorder, 0, sizeof (cr_server.Recorder));
+    crMemset(&cr_server.RecorderBlitter, 0, sizeof (cr_server.RecorderBlitter));
+    crMemset(&cr_server.DbgPrintDumper, 0, sizeof (cr_server.DbgPrintDumper));
+    crMemset(&cr_server.HtmlDumper, 0, sizeof (cr_server.HtmlDumper));
+    cr_server.pDumper = NULL;
+#endif
+
     crUnpackSetReturnPointer( &(cr_server.return_ptr) );
     crUnpackSetWritebackPointer( &(cr_server.writeback_ptr) );
@@ -432 +440 @@
 #endif
 
-//    cr_server.bUseMultipleContexts = (crGetenv( "CR_SERVER_ENABLE_MULTIPLE_CONTEXTS" ) != NULL);
+    cr_server.bUseMultipleContexts = (crGetenv( "CR_SERVER_ENABLE_MULTIPLE_CONTEXTS" ) != NULL);
 
     if (cr_server.bUseMultipleContexts)
@@ -509 +517 @@
     crServerInitTmpCtxDispatch();
     crStateDiffAPI( &(cr_server.head_spu->dispatch_table) );
+
+#ifdef VBOX_WITH_CRSERVER_DUMPER
+    crMemset(&cr_server.Recorder, 0, sizeof (cr_server.Recorder));
+    crMemset(&cr_server.RecorderBlitter, 0, sizeof (cr_server.RecorderBlitter));
+    crMemset(&cr_server.DbgPrintDumper, 0, sizeof (cr_server.DbgPrintDumper));
+    crMemset(&cr_server.HtmlDumper, 0, sizeof (cr_server.HtmlDumper));
+    cr_server.pDumper = NULL;
+#endif
 
     /*Check for PBO support*/

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c

@@ -1398 +1398 @@
 int64_t g_CrDbgDumpPid = 0;
 unsigned long g_CrDbgDumpEnabled = 0;
-unsigned long g_CrDbgDumpDraw = CR_SERVER_DUMP_F_COMPILE_SHADER
+unsigned long g_CrDbgDumpDraw = 0
+#if 0
+        | CR_SERVER_DUMP_F_COMPILE_SHADER
         | CR_SERVER_DUMP_F_LINK_PROGRAM
+#endif
+        ;
+#if 0
         | CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
         | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
@@ -1410 +1415 @@
         | CR_SERVER_DUMP_F_DRAWEL
         | CR_SERVER_DUMP_F_SHADER_SOURCE
-        ; //CR_SERVER_DUMP_F_DRAW_BUFF_ENTER | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE;
+        ;
+#endif
 unsigned long g_CrDbgDumpDrawFramesSettings = CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
         | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
@@ -1422 +1428 @@
 unsigned long g_CrDbgDumpDrawFramesCount = 0;
 
+uint32_t g_CrDbgDumpDrawCount = 0;
+uint32_t g_CrDbgDumpDumpOnCount = 10;
+uint32_t g_CrDbgDumpDumpOnCountEnabled = 0;
+uint32_t g_CrDbgDumpDumpOnCountPerform = 0;
+uint32_t g_CrDbgDumpDrawFlags = CR_SERVER_DUMP_F_COMPILE_SHADER
+        | CR_SERVER_DUMP_F_SHADER_SOURCE
+        | CR_SERVER_DUMP_F_COMPILE_SHADER
+        | CR_SERVER_DUMP_F_LINK_PROGRAM
+        | CR_SERVER_DUMP_F_DRAW_BUFF_ENTER
+        | CR_SERVER_DUMP_F_DRAW_BUFF_LEAVE
+        | CR_SERVER_DUMP_F_DRAW_TEX_ENTER
+        | CR_SERVER_DUMP_F_DRAW_PROGRAM_UNIFORMS_ENTER
+        | CR_SERVER_DUMP_F_DRAW_PROGRAM_ATTRIBS_ENTER
+        | CR_SERVER_DUMP_F_DRAW_PROGRAM_ENTER
+        | CR_SERVER_DUMP_F_DRAW_STATE_ENTER
+        | CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER
+        | CR_SERVER_DUMP_F_DRAWEL
+        | CR_SERVER_DUMP_F_TEXPRESENT;
+
 void crServerDumpCheckTerm()
 {
@@ -1437 +1462 @@
     CRMuralInfo *pBlitterMural;
 
-    if (CrBltIsInitialized(&cr_server.RecorderBlitter))
-        return VINF_SUCCESS;
-
-    pBlitterMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.visualBits);
-    if (!pBlitterMural)
-    {
-        crWarning("crServerGetDummyMural failed");
-        return VERR_GENERAL_FAILURE;
-    }
-
-    crServerVBoxBlitterWinInit(&BltWin, pBlitterMural);
-    crServerVBoxBlitterCtxInit(&BltCtx, &cr_server.MainContextInfo);
-
-    rc = CrBltInit(&cr_server.RecorderBlitter, &BltCtx, true, true, NULL, &cr_server.TmpCtxDispatch);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrBltInit failed rc %d", rc);
-        return rc;
-    }
-
-    rc = CrBltMuralSetCurrent(&cr_server.RecorderBlitter, &BltWin);
-    if (!RT_SUCCESS(rc))
-    {
-        crWarning("CrBltMuralSetCurrent failed rc %d", rc);
-        return rc;
+    if (!CrBltIsInitialized(&cr_server.RecorderBlitter))
+    {
+        pBlitterMural = crServerGetDummyMural(cr_server.MainContextInfo.CreateInfo.visualBits);
+        if (!pBlitterMural)
+        {
+            crWarning("crServerGetDummyMural failed");
+            return VERR_GENERAL_FAILURE;
+        }
+
+        crServerVBoxBlitterWinInit(&BltWin, pBlitterMural);
+        crServerVBoxBlitterCtxInit(&BltCtx, &cr_server.MainContextInfo);
+
+        rc = CrBltInit(&cr_server.RecorderBlitter, &BltCtx, true, true, NULL, &cr_server.TmpCtxDispatch);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrBltInit failed rc %d", rc);
+            return rc;
+        }
+
+        rc = CrBltMuralSetCurrent(&cr_server.RecorderBlitter, &BltWin);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrBltMuralSetCurrent failed rc %d", rc);
+            return rc;
+        }
     }
 
@@ -1468 +1493 @@
     cr_server.pDumper = &cr_server.DbgPrintDumper.Base;
 #else
-    crDmpHtmlInit(&cr_server.HtmlDumper, "S:\\projects\\virtualbox\\3d\\dumps\\1", "index.html");
-    cr_server.pDumper = &cr_server.HtmlDumper.Base;
+    if (!crDmpHtmlIsInited(&cr_server.HtmlDumper))
+    {
+        static int cCounter = 0;
+//    crDmpHtmlInit(&cr_server.HtmlDumper, "S:\\projects\\virtualbox\\3d\\dumps\\1", "index.html");
+        crDmpHtmlInitF(&cr_server.HtmlDumper, "/Users/oracle-mac/vbox/dump/1", "index%d.html", cCounter);
+        cr_server.pDumper = &cr_server.HtmlDumper.Base;
+        ++cCounter;
+    }
 #endif
 
@@ -1630 +1661 @@
 void crServerDumpFilterOpLeave(unsigned long event, CR_DUMPER *pDumper)
 {
+    if (CR_SERVER_DUMP_F_DRAW_LEAVE_ALL & event)
+    {
+        g_CrDbgDumpDumpOnCountPerform = 0;
+    }
 }
 
 bool crServerDumpFilterOpEnter(unsigned long event, CR_DUMPER *pDumper)
 {
+    if ((CR_SERVER_DUMP_F_SWAPBUFFERS_ENTER & event)
+            || (CR_SERVER_DUMP_F_TEXPRESENT & event))
+    {
+        if (g_CrDbgDumpDumpOnCountEnabled == 1)
+            g_CrDbgDumpDumpOnCountEnabled = 2;
+        else if (g_CrDbgDumpDumpOnCountEnabled)
+        {
+            g_CrDbgDumpDumpOnCountEnabled = 0;
+            if (cr_server.pDumper == &cr_server.HtmlDumper.Base)
+            {
+                crDmpHtmlTerm(&cr_server.HtmlDumper);
+                cr_server.pDumper = NULL;
+            }
+        }
+
+        g_CrDbgDumpDrawCount = 0;
+    }
+    else if (CR_SERVER_DUMP_F_DRAW_ENTER_ALL & event)
+    {
+        if (g_CrDbgDumpDumpOnCountEnabled == 2)
+        {
+            if (g_CrDbgDumpDumpOnCount == g_CrDbgDumpDrawCount)
+            {
+                g_CrDbgDumpDumpOnCountPerform = 1;
+            }
+            ++g_CrDbgDumpDrawCount;
+        }
+    }
+    if (g_CrDbgDumpDumpOnCountPerform)
+    {
+        if (g_CrDbgDumpDrawFlags & event)
+            return true;
+    }
     return CR_SERVER_DUMP_DEFAULT_FILTER_OP(event);
 }
@@ -1639 +1707 @@
 bool crServerDumpFilterDmp(unsigned long event, CR_DUMPER *pDumper)
 {
+    if (g_CrDbgDumpDumpOnCountPerform)
+    {
+        if (g_CrDbgDumpDrawFlags & event)
+            return true;
+    }
     return CR_SERVER_DUMP_DEFAULT_FILTER_DMP(event);
 }
@@ -1673 +1746 @@
 }
 #endif
-/* */
+
+GLvoid crServerSpriteCoordReplEnable(GLboolean fEnable)
+{
+    CRContext *g = crStateGetCurrent();
+    CRTextureState *t = &(g->texture);
+    GLuint curTextureUnit = t->curTextureUnit;
+    GLuint curTextureUnitRestore = curTextureUnit;
+    GLuint i;
+
+    for (i = 0; i < g->limits.maxTextureUnits; ++i)
+    {
+        if (g->point.coordReplacement[i])
+        {
+            if (i != curTextureUnit)
+            {
+                curTextureUnit = i;
+                cr_server.head_spu->dispatch_table.ActiveTextureARB( i + GL_TEXTURE0_ARB );
+            }
+
+            cr_server.head_spu->dispatch_table.TexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, (GLint)fEnable);
+        }
+    }
+
+    if (curTextureUnit != curTextureUnitRestore)
+    {
+        cr_server.head_spu->dispatch_table.ActiveTextureARB( curTextureUnitRestore + GL_TEXTURE0_ARB );
+    }
+}
+
+GLvoid SERVER_DISPATCH_APIENTRY crServerDispatchDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+#ifdef DEBUG
+    GLenum status = cr_server.head_spu->dispatch_table.CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
+    Assert(GL_FRAMEBUFFER_COMPLETE == status);
+#endif
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_TRUE);
+    CR_SERVER_DUMP_DRAW_ENTER();
+    CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.DrawArrays(mode, first, count););
+    CR_SERVER_DUMP_DRAW_LEAVE();
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_FALSE);
+}
+
+GLvoid SERVER_DISPATCH_APIENTRY crServerDispatchDrawElements(GLenum mode,  GLsizei count,  GLenum type,  const GLvoid * indices)
+{
+#ifdef DEBUG
+    GLenum status = cr_server.head_spu->dispatch_table.CheckFramebufferStatusEXT(GL_DRAW_FRAMEBUFFER_EXT);
+    Assert(GL_FRAMEBUFFER_COMPLETE == status);
+#endif
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_TRUE);
+    CR_SERVER_DUMP_DRAW_ENTER();
+    CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.DrawElements(mode, count, type, indices););
+    CR_SERVER_DUMP_DRAW_LEAVE();
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_FALSE);
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchEnd( void )
+{
+    CRContext *g = crStateGetCurrent();
+    GLenum mode = g->current.mode;
+
+    crStateEnd();
+    cr_server.head_spu->dispatch_table.End();
+
+    CR_SERVER_DUMP_DRAW_LEAVE();
+
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_FALSE);
+}
+
+#ifdef DEBUG
+extern GLuint g_VBoxTstNumVa;
+#endif
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchBegin(GLenum mode)
+{
+#ifdef DEBUG
+    CRContext *ctx = crStateGetCurrent();
+    SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
+
+    g_VBoxTstNumVa = 0;
+
+    if (ctx->program.vpProgramBinding)
+    {
+        AssertRelease(ctx->program.currentVertexProgram);
+
+        if (ctx->program.currentVertexProgram->isARBprogram)
+        {
+            GLint pid=-1;
+            gl->GetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_BINDING_ARB, &pid);
+
+            if (pid != ctx->program.currentVertexProgram->id)
+            {
+                crWarning("pid(%d) != ctx->program.currentVertexProgram->id(%d)", pid, ctx->program.currentVertexProgram->id);
+            }
+            AssertRelease(pid == ctx->program.currentVertexProgram->id);
+        }
+        else
+        {
+            GLint pid=-1;
+
+            gl->GetIntegerv(GL_VERTEX_PROGRAM_BINDING_NV, &pid);
+            if (pid != ctx->program.currentVertexProgram->id)
+            {
+                crWarning("pid(%d) != ctx->program.currentVertexProgram->id(%d)", pid, ctx->program.currentVertexProgram->id);
+            }
+            AssertRelease(pid == ctx->program.currentVertexProgram->id);
+        }
+    }
+    else if (ctx->glsl.activeProgram)
+    {
+        GLint pid=-1;
+
+        gl->GetIntegerv(GL_CURRENT_PROGRAM, &pid);
+        crDebug("pid %i, state: id %i, hwid %i", pid, ctx->glsl.activeProgram->id, ctx->glsl.activeProgram->hwid);
+        if (pid != ctx->glsl.activeProgram->hwid)
+        {
+            crWarning("pid(%d) != ctx->glsl.activeProgram->hwid(%d)", pid, ctx->glsl.activeProgram->hwid);
+        }
+        AssertRelease(pid == ctx->glsl.activeProgram->hwid);
+    }
+#endif
+
+    if (mode == GL_POINTS)
+        crServerSpriteCoordReplEnable(GL_TRUE);
+
+    CR_SERVER_DUMP_DRAW_ENTER();
+
+    crStateBegin(mode);
+    cr_server.head_spu->dispatch_table.Begin(mode);
+}
+

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_special

@@ -254 +254 @@
 GetProgramiv
 GetShaderiv
+Begin
+DrawArrays
+DrawElements
+End
+TexEnvf
+TexEnvfv
+TexEnvi
+TexEnviv
+GetTexEnvfv
+GetTexEnviv

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_texture.c

@@ -137 +137 @@
     (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels),
     (target, level, internalFormat, width, height, depth, border, format, type, realptr), pixels)
+
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvf( GLenum target, GLenum pname, GLfloat param )
+{
+    crStateTexEnvf( target, pname, param );
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvf( target, pname, param ););
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvfv( GLenum target, GLenum pname, const GLfloat * params )
+{
+    crStateTexEnvfv( target, pname, params );
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvfv( target, pname, params ););
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvi( GLenum target, GLenum pname, GLint param )
+{
+    crStateTexEnvi( target, pname, param );
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvi( target, pname, param ););
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnviv( GLenum target, GLenum pname, const GLint * params )
+{
+    crStateTexEnviv( target, pname, params );
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnviv( target, pname, params ););
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetTexEnvfv( GLenum target, GLenum pname, GLfloat * params )
+{
+    GLfloat local_params[4];
+    (void) params;
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        cr_server.head_spu->dispatch_table.GetTexEnvfv( target, pname, local_params );
+    else
+        crStateGetTexEnvfv( target, pname, local_params );
+
+    crServerReturnValue( &(local_params[0]), crStateHlpComponentsCount(pname)*sizeof (GLfloat) );
+}
+
+void SERVER_DISPATCH_APIENTRY crServerDispatchGetTexEnviv( GLenum target, GLenum pname, GLint * params )
+{
+    GLint local_params[4];
+    (void) params;
+    if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
+        cr_server.head_spu->dispatch_table.GetTexEnviv( target, pname, local_params );
+    else
+        crStateGetTexEnviv( target, pname, local_params );
+
+    crServerReturnValue( &(local_params[0]), crStateHlpComponentsCount(pname)*sizeof (GLint) );
+}

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

@@ -1816 +1816 @@
     FILLIN( "GetString", renderspuGetString );
     FILLIN( "VBoxPresentComposition", renderspuVBoxPresentComposition );
-
     return i;
 }

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.h

@@ -210 +210 @@
 #endif
 
+#ifdef RT_OS_DARWIN
+typedef void (*PFNDELETE_OBJECT)(GLhandleARB obj);
+typedef void (*PFNGET_ATTACHED_OBJECTS)( GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj );
+typedef GLhandleARB (*PFNGET_HANDLE)(GLenum pname);
+typedef void (*PFNGET_INFO_LOG)( GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog );
+typedef void (*PFNGET_OBJECT_PARAMETERFV)( GLhandleARB obj, GLenum pname, GLfloat * params );
+typedef void (*PFNGET_OBJECT_PARAMETERIV)( GLhandleARB obj, GLenum pname, GLint * params );
+#endif
+
 /**
  * Renderspu state info
@@ -311 +320 @@
 #ifdef RT_OS_DARWIN
 # ifdef VBOX_WITH_COCOA_QT
+    PFNDELETE_OBJECT pfnDeleteObject;
+    PFNGET_ATTACHED_OBJECTS pfnGetAttachedObjects;
+    PFNGET_HANDLE pfnGetHandle;
+    PFNGET_INFO_LOG pfnGetInfoLog;
+    PFNGET_OBJECT_PARAMETERFV pfnGetObjectParameterfv;
+    PFNGET_OBJECT_PARAMETERIV pfnGetObjectParameteriv;
+
     CR_GLSL_CACHE GlobalShaders;
 # else
@@ -391 +407 @@
 extern void renderspu_SystemReparentWindow(WindowInfo *window);
 extern void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry );
+uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable);
 extern void renderspu_GCWindow(void);
 extern int renderspuCreateFunctions( SPUNamedFunctionTable table[] );

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c

@@ -22 +22 @@
 #include <iprt/path.h>
 
+#include <cr_string.h>
+#include <cr_mem.h>
+
 GLboolean renderspu_SystemInitVisual(VisualInfo *pVisInfo)
 {
@@ -197 +200 @@
     CrGlslTerm(&render_spu.GlobalShaders);
     return VINF_SUCCESS;
+}
+
+static SPUNamedFunctionTable * renderspuFindEntry(SPUNamedFunctionTable *aFunctions, const char *pcszName)
+{
+    SPUNamedFunctionTable *pCur;
+
+    for (pCur = aFunctions ; pCur->name != NULL ; pCur++)
+    {
+        if (!crStrcmp( pcszName, pCur->name ) )
+        {
+            return pCur;
+        }
+    }
+
+    AssertFailed();
+
+    return NULL;
 }
 
@@ -290 +310 @@
     }
 }
+
+AssertCompile(sizeof (GLhandleARB) == sizeof (void*));
+
+static VBoxGLhandleARB crHndlSearchVBox(GLhandleARB hNative)
+{
+    CRASSERT(!(((uintptr_t)hNative) >> 32));
+    return (VBoxGLhandleARB)((uintptr_t)hNative);
+}
+
+static GLhandleARB crHndlSearchNative(VBoxGLhandleARB hVBox)
+{
+    return (GLhandleARB)((uintptr_t)hVBox);
+}
+
+static VBoxGLhandleARB crHndlAcquireVBox(GLhandleARB hNative)
+{
+    CRASSERT(!(((uintptr_t)hNative) >> 32));
+    return (VBoxGLhandleARB)((uintptr_t)hNative);
+}
+
+static GLhandleARB crHndlReleaseVBox(VBoxGLhandleARB hVBox)
+{
+    return (GLhandleARB)((uintptr_t)hVBox);
+}
+
+static void SPU_APIENTRY renderspu_SystemDeleteObjectARB(VBoxGLhandleARB obj)
+{
+    GLhandleARB hNative = crHndlReleaseVBox(obj);
+    if (!hNative)
+    {
+        crWarning("no native for %d", obj);
+        return;
+    }
+
+    render_spu.pfnDeleteObject(hNative);
+}
+
+static void SPU_APIENTRY renderspu_SystemGetAttachedObjectsARB( VBoxGLhandleARB containerObj, GLsizei maxCount, GLsizei * pCount, VBoxGLhandleARB * obj )
+{
+    GLhandleARB *paAttachments;
+    GLhandleARB hNative = crHndlSearchNative(containerObj);
+    GLsizei count, i;
+
+    if (pCount)
+        *pCount = 0;
+
+    if (!hNative)
+    {
+        crWarning("no native for %d", obj);
+        return;
+    }
+
+    paAttachments = crCalloc(maxCount * sizeof (*paAttachments));
+    if (!paAttachments)
+    {
+        crWarning("crCalloc failed");
+        return;
+    }
+
+    render_spu.pfnGetAttachedObjects(hNative, maxCount, &count, paAttachments);
+    if (pCount)
+        *pCount = count;
+    if (count > maxCount)
+    {
+        crWarning("count too big");
+        count = maxCount;
+    }
+
+    for (i = 0; i < count; ++i)
+    {
+        obj[i] = crHndlSearchVBox(paAttachments[i]);
+        CRASSERT(obj[i]);
+    }
+
+    crFree(paAttachments);
+}
+
+static VBoxGLhandleARB SPU_APIENTRY renderspu_SystemGetHandleARB(GLenum pname)
+{
+    GLhandleARB hNative = render_spu.pfnGetHandle(pname);
+    VBoxGLhandleARB hVBox;
+    if (!hNative)
+    {
+        crWarning("pfnGetHandle failed");
+        return 0;
+    }
+    hVBox = crHndlAcquireVBox(hNative);
+    CRASSERT(hVBox);
+    return hVBox;
+}
+
+static void SPU_APIENTRY renderspu_SystemGetInfoLogARB( VBoxGLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog )
+{
+    GLhandleARB hNative = crHndlSearchNative(obj);
+    if (!hNative)
+    {
+        crWarning("invalid handle!");
+        return;
+    }
+
+    render_spu.pfnGetInfoLog(hNative, maxLength, length, infoLog);
+}
+
+static void SPU_APIENTRY renderspu_SystemGetObjectParameterfvARB( VBoxGLhandleARB obj, GLenum pname, GLfloat * params )
+{
+    GLhandleARB hNative = crHndlSearchNative(obj);
+    if (!hNative)
+    {
+        crWarning("invalid handle!");
+        return;
+    }
+
+    render_spu.pfnGetObjectParameterfv(hNative, pname, params);
+}
+
+static void SPU_APIENTRY renderspu_SystemGetObjectParameterivARB( VBoxGLhandleARB obj, GLenum pname, GLint * params )
+{
+    GLhandleARB hNative = crHndlSearchNative(obj);
+    if (!hNative)
+    {
+        crWarning("invalid handle!");
+        return;
+    }
+
+    render_spu.pfnGetObjectParameteriv(hNative, pname, params);
+}
+
+uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable)
+{
+    SPUNamedFunctionTable * pEntry;
+
+    pEntry = renderspuFindEntry(aFunctions, "DeleteObjectARB");
+    if (pEntry)
+    {
+        render_spu.pfnDeleteObject = (PFNDELETE_OBJECT)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemDeleteObjectARB;
+    }
+
+    pEntry = renderspuFindEntry(aFunctions, "GetAttachedObjectsARB");
+    if (pEntry)
+    {
+        render_spu.pfnGetAttachedObjects = (PFNGET_ATTACHED_OBJECTS)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemGetAttachedObjectsARB;
+    }
+
+    pEntry = renderspuFindEntry(aFunctions, "GetHandleARB");
+    if (pEntry)
+    {
+        render_spu.pfnGetHandle = (PFNGET_HANDLE)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemGetHandleARB;
+    }
+
+    pEntry = renderspuFindEntry(aFunctions, "GetInfoLogARB");
+    if (pEntry)
+    {
+        render_spu.pfnGetInfoLog = (PFNGET_INFO_LOG)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemGetInfoLogARB;
+    }
+
+    pEntry = renderspuFindEntry(aFunctions, "GetObjectParameterfvARB");
+    if (pEntry)
+    {
+        render_spu.pfnGetObjectParameterfv = (PFNGET_OBJECT_PARAMETERFV)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemGetObjectParameterfvARB;
+    }
+
+    pEntry = renderspuFindEntry(aFunctions, "GetObjectParameterivARB");
+    if (pEntry)
+    {
+        render_spu.pfnGetObjectParameteriv = (PFNGET_OBJECT_PARAMETERIV)pEntry->fn;
+        pEntry->fn = (SPUGenericFunction)renderspu_SystemGetObjectParameterivARB;
+    }
+
+    return cFunctions;
+}

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c

@@ -2080 +2080 @@
 
 }
+
+uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable)
+{
+    return cFunctions;
+}

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c

@@ -374 +374 @@
     render_spu.gather_conns = NULL;
 
+    numFuncs = renderspu_SystemPostprocessFunctions(_cr_render_table, numFuncs, RT_ELEMENTS(_cr_render_table));
+
     crDebug("Render SPU: ---------- End of Init -------------");
 

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_wgl.c

@@ -1688 +1688 @@
 
 }
+
+uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable)
+{
+    return cFunctions;
+}

trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c

@@ -40 +40 @@
     GLint hasNonLocalLen = READ_DATA(16, GLsizei);
     GLint *pLocalLength = DATA_POINTER(20, GLint);
-    const char **ppStrings = NULL;
-    GLsizei i;
+    char **ppStrings = NULL;
+    GLsizei i, j, jUpTo;
     int pos=20+count*sizeof(*pLocalLength);
 
@@ -61 +61 @@
             pLocalLength[i] -= 1;
         }
+
+        Assert(pLocalLength[i] > 0);
+        jUpTo = i == count -1 ? pLocalLength[i] - 1 : pLocalLength[i];
+        for (j = 0; j < jUpTo; ++j)
+        {
+            char *pString = ppStrings[i];
+
+            if (pString[j] == '\0')
+            {
+                Assert(j == jUpTo - 1);
+                pString[j] = '\n';
+            }
+        }
     }
 
-    cr_unpackDispatch.ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
+//    cr_unpackDispatch.ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
+    cr_unpackDispatch.ShaderSource(shader, 1, ppStrings, 0);
+
     crFree(ppStrings);
 }
@@ -250 +265 @@
 void crUnpackExtendGetAttachedObjectsARB(void)
 {
-        GLhandleARB containerObj = READ_DATA(8, GLhandleARB);
+        VBoxGLhandleARB containerObj = READ_DATA(8, VBoxGLhandleARB);
         GLsizei maxCount = READ_DATA(12, GLsizei);
         SET_RETURN_PTR(16);
@@ -259 +274 @@
 void crUnpackExtendGetInfoLogARB(void)
 {
-        GLhandleARB obj = READ_DATA(8, GLhandleARB);
+        VBoxGLhandleARB obj = READ_DATA(8, VBoxGLhandleARB);
         GLsizei maxLength = READ_DATA(12, GLsizei);
         SET_RETURN_PTR(16);