Changeset 59741 in vbox

Timestamp:

Feb 19, 2016 3:11:35 PM (9 years ago)

Author:

vboxsync

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

105608

Message:

SVGA3d: Applied patch for supporting pretransformed vertices (SVGA3D_DECLUSAGE_POSITIONT) from trivirt.

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA3d-ogl.cpp (modified) (15 diffs)
• VBoxSVGA3D.def (modified) (1 diff)
• shaderlib/glsl_shader.c (modified) (2 diffs)
• shaderlib/shaderapi.c (modified) (4 diffs)
• shaderlib/shaderlib.h (modified) (1 diff)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

@@ -3662 +3662 @@
     case SVGA3D_TRANSFORM_PROJECTION:
     {
-        int rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix);
+        int rc = ShaderTransformProjection(pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, matrix, false /* fPretransformed */);
         AssertRCReturn(rc, rc);
         break;
@@ -5862 +5862 @@
 }
 
-int vmsvga3dDrawPrimitivesProcessVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
-{
+int vmsvga3dResetTransformMatrices(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
+{
+    int rc;
+
+    /* Reset the view matrix (also takes the world matrix into account). */
+    if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid == true)
+    {
+        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_VIEW, pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
+    }
+    else
+    {
+        float matrix[16];
+
+        /* identity matrix if no matrix set. */
+        memset(matrix, 0, sizeof(matrix));
+        matrix[0]  = 1.0;
+        matrix[5]  = 1.0;
+        matrix[10] = 1.0;
+        matrix[15] = 1.0;
+        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
+    }
+
+    /* Reset the projection matrix. */
+    if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
+    {
+        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
+    }
+    else
+    {
+        float matrix[16];
+
+        /* identity matrix if no matrix set. */
+        memset(matrix, 0, sizeof(matrix));
+        matrix[0]  = 1.0;
+        matrix[5]  = 1.0;
+        matrix[10] = 1.0;
+        matrix[15] = 1.0;
+        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
+    }
+    AssertRC(rc);
+    return rc;
+}
+
+int vmsvga3dDrawPrimitivesProcessVertexDecls(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
+{
+    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
     unsigned            sidVertex = pVertexDecl[0].array.surfaceId;
     PVMSVGA3DSURFACE    pVertexSurface;
@@ -5936 +5980 @@
             switch (pVertexDecl[iVertex].identity.usage)
             {
+            case SVGA3D_DECLUSAGE_POSITIONT:
             case SVGA3D_DECLUSAGE_POSITION:
+            {
                 glEnableClientState(GL_VERTEX_ARRAY);
                 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
@@ -5943 +5989 @@
                 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
                 break;
+            }
             case SVGA3D_DECLUSAGE_BLENDWEIGHT:
                 AssertFailed();
@@ -5981 +6028 @@
                 AssertFailed();
                 break;
-            case SVGA3D_DECLUSAGE_POSITIONT:
-                AssertFailed(); /* see position_transformed in Wine */
-                break;
             case SVGA3D_DECLUSAGE_COLOR:    /** @todo color component order not identical!! test GL_BGRA!! */
                 glEnableClientState(GL_COLOR_ARRAY);
@@ -6017 +6061 @@
 }
 
-int vmsvga3dDrawPrimitivesCleanupVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
-{
-    /* Setup the vertex declarations. */
+int vmsvga3dDrawPrimitivesCleanupVertexDecls(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
+{
+    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+
+    /* Clean up the vertex declarations. */
     for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
     {
+        if (pVertexDecl[iVertex].identity.usage == SVGA3D_DECLUSAGE_POSITIONT)
+        {
+            /* Reset the transformation matrices in case of a switch back from pretransformed mode. */
+            Log(("vmsvga3dDrawPrimitivesCleanupVertexDecls: reset world and projection matrices after transformation reset (pre-transformed -> transformed)\n"));
+            vmsvga3dResetTransformMatrices(pThis, pContext);
+        }
+
         if (pContext->state.shidVertex != SVGA_ID_INVALID)
         {
@@ -6034 +6087 @@
             {
             case SVGA3D_DECLUSAGE_POSITION:
+            case SVGA3D_DECLUSAGE_POSITIONT:
                 glDisableClientState(GL_VERTEX_ARRAY);
                 VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
@@ -6063 +6117 @@
             case SVGA3D_DECLUSAGE_TESSFACTOR:
                 break;
-            case SVGA3D_DECLUSAGE_POSITIONT:
-                break;
             case SVGA3D_DECLUSAGE_COLOR:    /** @todo color component order not identical!! */
                 glDisableClientState(GL_COLOR_ARRAY);
@@ -6089 +6141 @@
 int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
 {
+    PVMSVGA3DSTATE               pState = pThis->svga.p3dState;
     PVMSVGA3DCONTEXT             pContext;
-    PVMSVGA3DSTATE               pState = pThis->svga.p3dState;
     AssertReturn(pState, VERR_INTERNAL_ERROR);
     int                          rc = VERR_NOT_IMPLEMENTED;
@@ -6112 +6164 @@
     VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
 
-    /* Flush any shader changes. */
+    /* Check for pretransformed vertex declarations. */
+    for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
+    {
+        switch (pVertexDecl[iVertex].identity.usage)
+        {
+        case SVGA3D_DECLUSAGE_POSITIONT:
+            Log(("ShaderSetPositionTransformed: (%d,%d)\n", pContext->state.RectViewPort.w, pContext->state.RectViewPort.h));
+        case SVGA3D_DECLUSAGE_POSITION:
+            ShaderSetPositionTransformed(pContext->pShaderContext, pContext->state.RectViewPort.w, pContext->state.RectViewPort.h, 
+                                         pVertexDecl[iVertex].identity.usage == SVGA3D_DECLUSAGE_POSITIONT);
+            break;
+        }
+    }
+
+    /* Flush any shader changes; after (!) checking the vertex declarations to deal with pre-transformed vertices. */
     if (pContext->pShaderContext)
     {
@@ -6142 +6208 @@
         }
 
-        rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pState, pContext, iCurrentVertex, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
+        rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pThis, pContext, iCurrentVertex, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
         AssertRCReturn(rc, rc);
 
@@ -6223 +6289 @@
         else
         {
+            GLenum indexType;
+
             Assert(pRange[iPrimitive].indexBias >= 0);  /** @todo  indexBias */
             Assert(pRange[iPrimitive].indexWidth == pRange[iPrimitive].indexArray.stride);
+
+            if (pRange[iPrimitive].indexWidth == sizeof(uint8_t))
+            {
+                indexType = GL_UNSIGNED_BYTE;
+            }
+            else
+            if (pRange[iPrimitive].indexWidth == sizeof(uint16_t))
+            {
+                indexType = GL_UNSIGNED_SHORT;
+            }
+            else
+            {
+                Assert(pRange[iPrimitive].indexWidth == sizeof(uint32_t));
+                indexType = GL_UNSIGNED_INT;
+            }
 
             /* Render with an index buffer */
@@ -6231 +6314 @@
                 glDrawElements(modeDraw,
                                cVertices,
-                               (pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
+                               indexType,
                                (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset);   /* byte offset in indices buffer */
             else
                 pState->ext.glDrawElementsBaseVertex(modeDraw,
                                                      cVertices,
-                                                     (pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT,
+                                                     indexType,
                                                      (GLvoid *)(uintptr_t)pRange[iPrimitive].indexArray.offset, /* byte offset in indices buffer */
                                                      pRange[iPrimitive].indexBias);  /* basevertex */
@@ -6265 +6348 @@
         }
 
-        rc = vmsvga3dDrawPrimitivesCleanupVertexDecls(pState, pContext, iCurrentVertex, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
+        rc = vmsvga3dDrawPrimitivesCleanupVertexDecls(pThis, pContext, iCurrentVertex, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
         AssertRCReturn(rc, rc);
 
@@ -6308 +6391 @@
 
 #ifdef DEBUG_GFX_WINDOW
-    if (pContext->aSidActiveTexture[0])
+    if (pContext->sidRenderTarget)
     {
         SVGA3dCopyRect rect;
 
         rect.srcx = rect.srcy = rect.x = rect.y = 0;
-        rect.w = 800;
-        rect.h = 600;
+        rect.w = pContext->state.RectViewPort.w;
+        rect.h = pContext->state.RectViewPort.h;
         vmsvga3dCommandPresent(pThis, pContext->sidRenderTarget, 0, NULL);
     }
 #endif
+
     return rc;
 }

trunk/src/VBox/Devices/Graphics/VBoxSVGA3D.def

@@ -36 +36 @@
     ShaderUpdateState
     ShaderTransformProjection
+    ShaderSetPositionTransformed
 
+

trunk/src/VBox/Devices/Graphics/shaderlib/glsl_shader.c

@@ -4262 +4262 @@
 }
 
+#ifdef VBOX_WITH_VMSVGA
+static GLhandleARB generate_passthrough_vshader(const struct wined3d_gl_info *gl_info)
+{
+    GLhandleARB ret = 0;
+    static const char *passthrough_vshader[] =
+    {
+        "#version 120\n"
+        "vec4 R0;\n"
+        "void main(void)\n"
+        "{\n"
+        "    R0   = gl_Vertex;\n"
+        "    R0.w = 1.0;\n"
+        "    R0.z = 0.0;\n"
+        "    gl_Position   = gl_ModelViewProjectionMatrix * R0;\n"
+        "}\n"
+    };
+
+    ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
+    checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
+    GL_EXTCALL(glShaderSourceARB(ret, 1, passthrough_vshader, NULL));
+    checkGLcall("glShaderSourceARB(ret, 1, passthrough_vshader, NULL)");
+    GL_EXTCALL(glCompileShaderARB(ret));
+    checkGLcall("glCompileShaderARB(ret)");
+    shader_glsl_validate_compile_link(gl_info, ret, FALSE);
+
+    return ret;
+}
+
+#endif
+
 /* GL locking is done by the caller */
 static void hardcode_local_constants(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
@@ -4710 +4740 @@
         list_add_head(&((IWineD3DBaseShaderImpl *)vshader)->baseShader.linked_programs, &entry->vshader_entry);
     }
+#ifdef VBOX_WITH_VMSVGA
+    else
+    if (device->strided_streams.position_transformed)
+    {
+        GLhandleARB passthrough_vshader_id;
+
+        passthrough_vshader_id = generate_passthrough_vshader(gl_info);
+        TRACE("Attaching GLSL shader object %p to program %p\n", (void *)(uintptr_t)passthrough_vshader_id, (void *)(uintptr_t)programId);
+        GL_EXTCALL(glAttachObjectARB(programId, passthrough_vshader_id));
+        checkGLcall("glAttachObjectARB");
+        /* Flag the reorder function for deletion, then it will be freed automatically when the program
+         * is destroyed
+         */
+        GL_EXTCALL(glDeleteObjectARB(passthrough_vshader_id));
+    }
+#endif
+
 
     /* Attach GLSL pshader */

trunk/src/VBox/Devices/Graphics/shaderlib/shaderapi.c

@@ -15 +15 @@
  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  */
-
 #include <iprt/err.h>
 #include <iprt/mem.h>
@@ -626 +625 @@
 }
 
+SHADERDECL(int) ShaderSetPositionTransformed(void *pShaderContext, unsigned cxViewPort, unsigned cyViewPort, bool fPreTransformed)
+{
+    IWineD3DDeviceImpl *This;
+    int rc;
+
+    SHADER_SET_CURRENT_CONTEXT(pShaderContext);
+    This = g_pCurrentContext->pDeviceContext;
+
+    if (This->strided_streams.position_transformed == fPreTransformed)
+        return VINF_SUCCESS;    /* no changes; nothing to do. */
+
+    Log(("ShaderSetPositionTransformed viewport (%d,%d) fPreTransformed=%d\n", cxViewPort, cyViewPort, fPreTransformed));
+    
+    if (fPreTransformed)
+    {   /* In the pre-transformed vertex coordinate case we need to disable all transformations as we're already using screen coordinates. */
+        /* Load the identity matrix for the model view */
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+
+        /* Reset the projection matrix too */
+        rc = ShaderTransformProjection(cxViewPort, cyViewPort, NULL, fPreTransformed);
+        AssertRCReturn(rc, rc);
+    }
+
+    This->strided_streams.position_transformed = fPreTransformed;
+    ((IWineD3DVertexDeclarationImpl *)(This->stateBlock->vertexDecl))->position_transformed = fPreTransformed;
+    return VINF_SUCCESS;
+}
+
 SHADERDECL(int) ShaderUpdateState(void *pShaderContext, uint32_t rtHeight)
 {
@@ -668 +696 @@
 }
 
-SHADERDECL(int) ShaderTransformProjection(unsigned cxViewPort, unsigned cyViewPort, float matrix[16])
+SHADERDECL(int) ShaderTransformProjection(unsigned cxViewPort, unsigned cyViewPort, float matrix[16], bool fPretransformed)
 {
 #ifdef DEBUG
@@ -723 +751 @@
 
     glTranslatef(xoffset, -yoffset, -1.0f);
-    /* flip y coordinate origin too */
-    glScalef(1.0f, -1.0f, 2.0f);
-
-    glMultMatrixf(matrix);
-
+
+    if (fPretransformed) 
+    {
+        /* One world coordinate equals one screen pixel; y-inversion no longer an issue */
+        glOrtho(0, cxViewPort, 0, cyViewPort, -1, 1);
+    }
+    else
+    {
+        /* flip y coordinate origin too */
+        glScalef(1.0f, -1.0f, 2.0f);
+
+        /* Apply the supplied projection matrix */
+        glMultMatrixf(matrix);
+    }
 #ifdef DEBUG
     lastError = glGetError();                                     \

trunk/src/VBox/Devices/Graphics/shaderlib/shaderlib.h

@@ -87 +87 @@
 SHADERDECL(int) ShaderSetPixelShaderConstantF(void *pShaderContext, uint32_t reg, const float *pValues, uint32_t cRegisters);
 
+SHADERDECL(int) ShaderSetPositionTransformed(void *pShaderContext, unsigned cxViewPort, unsigned cyViewPort, bool fPreTransformed);
+
 SHADERDECL(int) ShaderUpdateState(void *pShaderContext, uint32_t rtHeight);
 
-SHADERDECL(int) ShaderTransformProjection(unsigned cxViewPort, unsigned cyViewPort, float matrix[16]);
+SHADERDECL(int) ShaderTransformProjection(unsigned cxViewPort, unsigned cyViewPort, float matrix[16], bool fPretransformed);
 
 RT_C_DECLS_END