VirtualBox

Changeset 94146 in vbox


Ignore:
Timestamp:
Mar 9, 2022 12:07:30 PM (3 years ago)
Author:
vboxsync
Message:

Devices/Graphics: shader management: bugref:9830

Location:
trunk/src/VBox/Devices/Graphics
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA-cmd.cpp

    r93944 r94146  
    15061506                else
    15071507                    rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
    1508                 if (RT_FAILURE(rc))
    1509                     break;
     1508                AssertRCBreak(rc);
    15101509
    15111510                pu8Map += map.cbRowPitch;

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx-shader.cpp

    r93115 r94146  
    19371937    while (dxbcTokenReaderCanRead(r, 1))
    19381938    {
     1939        uint32_t const offOpcode = dxbcByteWriterSize(w);
     1940
    19391941        VGPUOpcode opcode;
    19401942        rc = dxbcParseOpcode(r, &opcode);
    … …  
    19461948        if (pInfo)
    19471949        {
     1950            /* Remember offsets of DCL_RESOURCE instructions. */
     1951            if (   outctx.programToken.programType == VGPU10_PIXEL_SHADER
     1952                && opcode.opcodeType == VGPU10_OPCODE_DCL_RESOURCE)
     1953            {
     1954                ASSERT_GUEST_STMT_BREAK(pInfo->cDclResource <= SVGA3D_DX_MAX_SRVIEWS,
     1955                                        rc = VERR_NOT_SUPPORTED);
     1956
     1957                pInfo->aOffDclResource[pInfo->cDclResource++] = offOpcode;
     1958            }
     1959
    19481960            /* Fetch signatures. */
    19491961            SVGA3dDXSignatureEntry *pSignatureEntry = NULL;
    … …  
    23532365}
    23542366
     2367int DXShaderUpdateResourceTypes(DXShaderInfo const *pInfo, SVGA3dResourceType *paResourceType, uint32_t cResourceType)
     2368{
     2369    for (uint32_t i = 0; i < pInfo->cDclResource; ++i)
     2370    {
     2371        SVGA3dResourceType const resourceType = i < cResourceType ? paResourceType[i] : SVGA3D_RESOURCE_TEXTURE2D;
     2372        AssertContinue(resourceType < SVGA3D_RESOURCE_TYPE_MAX);
     2373
     2374        uint32_t const offToken = pInfo->aOffDclResource[i];
     2375        AssertContinue(offToken < pInfo->cbBytecode);
     2376        uint32_t *paToken = (uint32_t *)((uintptr_t)pInfo->pvBytecode + offToken);
     2377
     2378        uint8_t resourceDimension;
     2379        uint32_t returnType;
     2380        switch (resourceType)
     2381        {
     2382            case SVGA3D_RESOURCE_BUFFER:
     2383                resourceDimension = VGPU10_RESOURCE_DIMENSION_BUFFER;
     2384                returnType = 0x5555; /* float */
     2385                break;
     2386            case SVGA3D_RESOURCE_TEXTURE1D:
     2387                resourceDimension = VGPU10_RESOURCE_DIMENSION_TEXTURE1D;
     2388                returnType = 0x5555; /* float */
     2389                break;
     2390            default:
     2391            case SVGA3D_RESOURCE_TEXTURE2D:
     2392                resourceDimension = VGPU10_RESOURCE_DIMENSION_TEXTURE2D;
     2393                returnType = 0x5555; /* float */
     2394                break;
     2395            case SVGA3D_RESOURCE_TEXTURE3D:
     2396                resourceDimension = VGPU10_RESOURCE_DIMENSION_TEXTURE3D;
     2397                returnType = 0x5555; /* float */
     2398                break;
     2399            case SVGA3D_RESOURCE_TEXTURECUBE:
     2400                resourceDimension = VGPU10_RESOURCE_DIMENSION_TEXTURECUBE;
     2401                returnType = 0x5555; /* float */
     2402                break;
     2403            case SVGA3D_RESOURCE_BUFFEREX:
     2404                resourceDimension = VGPU10_RESOURCE_DIMENSION_BUFFER;
     2405                returnType = 0x5555; /* float */
     2406                break;
     2407        }
     2408
     2409        VGPU10OpcodeToken0 *pOpcode = (VGPU10OpcodeToken0 *)&paToken[0];
     2410        pOpcode->resourceDimension = resourceDimension;
     2411        // paToken[1] unmodified
     2412        // paToken[2] unmodified
     2413        paToken[3] = returnType;
     2414    }
     2415
     2416    return VINF_SUCCESS;
     2417}
    23552418
    23562419#ifdef DXBC_STANDALONE_TEST

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx-shader.h

    r93115 r94146  
    4343    uint32_t cOutputSignature;
    4444    uint32_t cPatchConstantSignature;
     45    uint32_t cDclResource;
    4546    SVGA3dDXSignatureEntry aInputSignature[32];
    4647    SVGA3dDXSignatureEntry aOutputSignature[32];
    4748    SVGA3dDXSignatureEntry aPatchConstantSignature[32];
     49    uint32_t aOffDclResource[SVGA3D_DX_MAX_SRVIEWS];
    4850} DXShaderInfo;
    4951
    5052int DXShaderParse(void const *pvCode, uint32_t cbCode, DXShaderInfo *pInfo);
    5153void DXShaderFree(DXShaderInfo *pInfo);
     54int DXShaderUpdateResourceTypes(DXShaderInfo const *pInfo, SVGA3dResourceType *paResourceType, uint32_t cResourceType);
    5255int DXShaderCreateDXBC(DXShaderInfo const *pInfo, void **ppvDXBC, uint32_t *pcbDXBC);
    5356char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister);

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx.cpp

    r94113 r94146  
    3838#include "DevVGA-SVGA3d-internal.h"
    3939#include "DevVGA-SVGA-internal.h"
    40 
    41 
    42 /*
    43  *
    44  * 3D backend entry points. These functions are used from vmsvga3dDXSwitchContext and command handlers.
    45  *
    46  */
    47 
    48 static int dxSetShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
    49                        SVGA3dShaderType shaderType, SVGA3dShaderId shaderId)
    50 {
    51     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    52 
    53     PVMSVGA3DSHADER pShader;
    54     if (shaderId != SVGA_ID_INVALID)
    55     {
    56         SVGACOTableDXShaderEntry *pEntry = &pDXContext->cot.paShader[shaderId];
    57         ASSERT_GUEST_RETURN(pEntry->type == shaderType, VERR_INVALID_PARAMETER);
    58         RT_UNTRUSTED_VALIDATED_FENCE();
    59 
    60         pShader = &pDXContext->paShader[shaderId];
    61     }
    62     else
    63         pShader = NULL;
    64 
    65     return pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContext, shaderType, pShader);
    66 }
    6740
    6841
    … …  
    158131        SVGA3dShaderId shaderId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
    159132
    160         rc = dxSetShader(pThisCC, pDXContext, shaderType, shaderId);
     133        rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContext, shaderId, shaderType);
    161134        AssertRC(rc);
    162135    }
    … …  
    172145        SVGA3dShaderId shaderId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
    173146
    174         rc = dxSetShader(pThisCC, pDXContext, shaderType, shaderId);
     147        rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContext, shaderId, shaderType);
    175148        AssertRC(rc);
    176149    }
    … …  
    186159        SVGA3dShaderId shaderId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
    187160
    188         rc = dxSetShader(pThisCC, pDXContext, shaderType, shaderId);
     161        rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContext, shaderId, shaderType);
    189162        AssertRC(rc);
    190163    }
    … …  
    605578    pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId = pCmd->shaderId;
    606579
    607     rc = dxSetShader(pThisCC, pDXContext, pCmd->type, pCmd->shaderId);
     580    rc = pSvgaR3State->pFuncsDX->pfnDXSetShader(pThisCC, pDXContext, pCmd->shaderId, pCmd->type);
    608581    return rc;
    609582}
    … …  
    11721145    AssertRCReturn(rc, rc);
    11731146
    1174     ASSERT_GUEST_RETURN(cViewport < SVGA3D_DX_MAX_VIEWPORTS, VERR_INVALID_PARAMETER);
     1147    ASSERT_GUEST_RETURN(cViewport <= SVGA3D_DX_MAX_VIEWPORTS, VERR_INVALID_PARAMETER);
    11751148    RT_UNTRUSTED_VALIDATED_FENCE();
    11761149
    … …  
    11961169    AssertRCReturn(rc, rc);
    11971170
    1198     ASSERT_GUEST_RETURN(cRect < SVGA3D_DX_MAX_SCISSORRECTS, VERR_INVALID_PARAMETER);
     1171    ASSERT_GUEST_RETURN(cRect <= SVGA3D_DX_MAX_SCISSORRECTS, VERR_INVALID_PARAMETER);
    11991172    RT_UNTRUSTED_VALIDATED_FENCE();
    12001173
    … …  
    17911764    AssertRCReturn(rc, rc);
    17921765
    1793     AssertReturn(pDXContext->paShader, VERR_INVALID_STATE);
    1794 
    17951766    SVGA3dShaderId const shaderId = pCmd->shaderId;
    17961767
    … …  
    18001771    ASSERT_GUEST_RETURN(pCmd->sizeInBytes >= 8, VERR_INVALID_PARAMETER); /* Version Token + Length Token. */
    18011772    RT_UNTRUSTED_VALIDATED_FENCE();
     1773
     1774    /* Cleanup the current shader. */
     1775    pSvgaR3State->pFuncsDX->pfnDXDestroyShader(pThisCC, pDXContext, shaderId);
    18021776
    18031777    SVGACOTableDXShaderEntry *pEntry = &pDXContext->cot.paShader[shaderId];
    … …  
    18071781    pEntry->mobid         = SVGA_ID_INVALID;
    18081782
    1809     PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
    1810     if (pShader->id != SVGA_ID_INVALID)
    1811     {
    1812         /* Cleanup the current shader. */
    1813         pSvgaR3State->pFuncsDX->pfnDXDestroyShader(pThisCC, pDXContext, shaderId);
    1814         RTMemFree(pShader->pShaderProgram);
    1815     }
    1816 
    1817     pShader->id                = shaderId;
    1818     pShader->cid               = idDXContext;
    1819     pShader->type              = pEntry->type;
    1820     pShader->cbData            = pEntry->sizeInBytes;
    1821     pShader->pShaderProgram    = NULL;
    1822     pShader->u.pvBackendShader = NULL;
    1823 
    18241783    rc = pSvgaR3State->pFuncsDX->pfnDXDefineShader(pThisCC, pDXContext, shaderId, pEntry);
    18251784    return rc;
    … …  
    18381797    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    18391798    AssertRCReturn(rc, rc);
    1840 
    1841     AssertReturn(pDXContext->paShader, VERR_INVALID_STATE);
    18421799
    18431800    SVGA3dShaderId const shaderId = pCmd->shaderId;
    … …  
    18471804    RT_UNTRUSTED_VALIDATED_FENCE();
    18481805
    1849     rc = pSvgaR3State->pFuncsDX->pfnDXDestroyShader(pThisCC, pDXContext, shaderId);
     1806    pSvgaR3State->pFuncsDX->pfnDXDestroyShader(pThisCC, pDXContext, shaderId);
    18501807
    18511808    /* Cleanup COTable entries.*/
    … …  
    18571814
    18581815    /** @todo Destroy shaders on context and backend deletion. */
    1859     PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
    1860     DXShaderFree(&pShader->shaderInfo);
    1861     pShader->id                = SVGA_ID_INVALID;
    1862     pShader->cid               = SVGA_ID_INVALID;
    1863     pShader->type              = SVGA3D_SHADERTYPE_INVALID;
    1864     pShader->cbData            = 0;
    1865     RTMemFree(pShader->pShaderProgram);
    1866     pShader->pShaderProgram    = NULL;
    1867     pShader->u.pvBackendShader = NULL;
    1868 
    1869     return rc;
    1870 }
    1871 
    1872 
    1873 static int dxBindShader(PVMSVGA3DSHADER pShader, PVMSVGAMOB pMob, SVGACOTableDXShaderEntry const *pEntry, void const *pvShaderBytecode)
     1816    return rc;
     1817}
     1818
     1819
     1820static int dxBindShader(DXShaderInfo *pShaderInfo, PVMSVGAMOB pMob, SVGACOTableDXShaderEntry const *pEntry, void const *pvShaderBytecode)
    18741821{
    18751822    /* How many bytes the MOB can hold. */
    … …  
    18781825    AssertReturn(pEntry->sizeInBytes >= 8, VERR_INTERNAL_ERROR); /* Host ensures this in DefineShader. */
    18791826
    1880     int rc = DXShaderParse(pvShaderBytecode, pEntry->sizeInBytes, &pShader->shaderInfo);
     1827    int rc = DXShaderParse(pvShaderBytecode, pEntry->sizeInBytes, pShaderInfo);
    18811828    if (RT_SUCCESS(rc))
    18821829    {
    … …  
    18861833        ASSERT_GUEST_RETURN(cToken <= pEntry->sizeInBytes / 4, VERR_INVALID_PARAMETER);
    18871834
    1888         pShader->cbData = cToken * 4;
    1889 
    18901835        /* Check if the MOB contains SVGA3dDXSignatureHeader and signature entries.
    18911836         * If they are not there (Linux guest driver does not provide them), then it is fine
    18921837         * and the signatures generated by DXShaderParse will be used.
    18931838         */
    1894         uint32_t const cbSignaturesMax = cbMob - pShader->cbData; /* How many bytes for signatures are available. */
     1839        uint32_t const cbSignaturesMax = cbMob - cToken * 4; /* How many bytes for signatures are available. */
    18951840        if (cbSignaturesMax > sizeof(SVGA3dDXSignatureHeader))
    18961841        {
    1897             SVGA3dDXSignatureHeader const *pSignatureHeader = (SVGA3dDXSignatureHeader *)((uint8_t *)pvShaderBytecode + pShader->cbData);
     1842            SVGA3dDXSignatureHeader const *pSignatureHeader = (SVGA3dDXSignatureHeader *)((uint8_t *)pvShaderBytecode + cToken * 4);
    18981843            if (pSignatureHeader->headerVersion == SVGADX_SIGNATURE_HEADER_VERSION_0)
    18991844            {
    19001845                DEBUG_BREAKPOINT_TEST();
    1901                 ASSERT_GUEST_RETURN(   pSignatureHeader->numInputSignatures <= RT_ELEMENTS(pShader->shaderInfo.aInputSignature)
    1902                                     && pSignatureHeader->numOutputSignatures <= RT_ELEMENTS(pShader->shaderInfo.aOutputSignature)
    1903                                     && pSignatureHeader->numPatchConstantSignatures <= RT_ELEMENTS(pShader->shaderInfo.aPatchConstantSignature),
     1846                ASSERT_GUEST_RETURN(   pSignatureHeader->numInputSignatures <= RT_ELEMENTS(pShaderInfo->aInputSignature)
     1847                                    && pSignatureHeader->numOutputSignatures <= RT_ELEMENTS(pShaderInfo->aOutputSignature)
     1848                                    && pSignatureHeader->numPatchConstantSignatures <= RT_ELEMENTS(pShaderInfo->aPatchConstantSignature),
    19041849                                    VERR_INVALID_PARAMETER);
    19051850
    … …  
    19121857                /* Copy to DXShaderInfo. */
    19131858                uint8_t const *pu8Signatures = (uint8_t *)&pSignatureHeader[1];
    1914                 pShader->shaderInfo.cInputSignature = pSignatureHeader->numInputSignatures;
    1915                 memcpy(pShader->shaderInfo.aInputSignature, pu8Signatures, pSignatureHeader->numInputSignatures * sizeof(SVGA3dDXSignatureEntry));
     1859                pShaderInfo->cInputSignature = pSignatureHeader->numInputSignatures;
     1860                memcpy(pShaderInfo->aInputSignature, pu8Signatures, pSignatureHeader->numInputSignatures * sizeof(SVGA3dDXSignatureEntry));
    19161861
    19171862                pu8Signatures += pSignatureHeader->numInputSignatures * sizeof(SVGA3dDXSignatureEntry);
    1918                 pShader->shaderInfo.cOutputSignature = pSignatureHeader->numOutputSignatures;
    1919                 memcpy(pShader->shaderInfo.aOutputSignature, pu8Signatures, pSignatureHeader->numOutputSignatures * sizeof(SVGA3dDXSignatureEntry));
     1863                pShaderInfo->cOutputSignature = pSignatureHeader->numOutputSignatures;
     1864                memcpy(pShaderInfo->aOutputSignature, pu8Signatures, pSignatureHeader->numOutputSignatures * sizeof(SVGA3dDXSignatureEntry));
    19201865
    19211866                pu8Signatures += pSignatureHeader->numOutputSignatures * sizeof(SVGA3dDXSignatureEntry);
    1922                 pShader->shaderInfo.cPatchConstantSignature = pSignatureHeader->numPatchConstantSignatures;
    1923                 memcpy(pShader->shaderInfo.aPatchConstantSignature, pu8Signatures, pSignatureHeader->numPatchConstantSignatures * sizeof(SVGA3dDXSignatureEntry));
     1867                pShaderInfo->cPatchConstantSignature = pSignatureHeader->numPatchConstantSignatures;
     1868                memcpy(pShaderInfo->aPatchConstantSignature, pu8Signatures, pSignatureHeader->numPatchConstantSignatures * sizeof(SVGA3dDXSignatureEntry));
    19241869            }
    19251870        }
    … …  
    19451890    RT_UNTRUSTED_VALIDATED_FENCE();
    19461891
     1892    /* 'type' and 'sizeInBytes' has been already initialized by DefineShader. */
    19471893    SVGACOTableDXShaderEntry *pEntry = &pDXContext->cot.paShader[pCmd->shid];
    19481894    //pEntry->type;
    … …  
    19631909            ASSERT_GUEST_RETURN(pvShaderBytecode, VERR_INVALID_PARAMETER);
    19641910
    1965             PVMSVGA3DSHADER pShader = &pDXContext->paShader[pCmd->shid];
    1966             Assert(   pShader->id == pCmd->shid
    1967                    && pShader->type == pEntry->type); /* The host ensures this. */
    1968 
    19691911            /* Get the shader and optional signatures from the MOB. */
    1970             rc = dxBindShader(pShader, pMob, pEntry, pvShaderBytecode);
     1912            DXShaderInfo shaderInfo;
     1913            RT_ZERO(shaderInfo);
     1914            rc = dxBindShader(&shaderInfo, pMob, pEntry, pvShaderBytecode);
    19711915            if (RT_SUCCESS(rc))
    1972                 rc = pSvgaR3State->pFuncsDX->pfnDXBindShader(pThisCC, pDXContext, pShader, pvShaderBytecode);
    1973 
     1916            {
     1917                /* pfnDXBindShader makes a copy of shaderInfo on success. */
     1918                rc = pSvgaR3State->pFuncsDX->pfnDXBindShader(pThisCC, pDXContext, pCmd->shid, &shaderInfo);
     1919            }
     1920            AssertRC(rc);
     1921
     1922            /** @todo Backing store is not needed anymore in any case? */
    19741923            if (RT_FAILURE(rc))
    19751924            {
    1976                 /** @todo Any cleanup? */
     1925                DXShaderFree(&shaderInfo);
     1926
    19771927                vmsvgaR3MobBackingStoreDelete(pSvgaR3State, pMob);
    19781928            }
    … …  
    21932143                pDXContext->cot.paShader          = (SVGACOTableDXShaderEntry *)pvCOT;
    21942144                pDXContext->cot.cShader           = cEntries;
    2195 
    2196                 /* Create host array for information about shaders. */
    2197                 RTMemFree(pDXContext->paShader);
    2198                 pDXContext->paShader = NULL;
    2199 
    2200                 if (pDXContext->cot.cShader)
    2201                 {
    2202                     pDXContext->paShader = (PVMSVGA3DSHADER)RTMemAllocZ(pDXContext->cot.cShader * sizeof(VMSVGA3DSHADER));
    2203                     AssertReturn(pDXContext->paShader, VERR_NO_MEMORY);
    2204                     for (uint32_t i = 0; i < pDXContext->cot.cShader; ++i)
    2205                         pDXContext->paShader[i].id = SVGA_ID_INVALID;
    2206                 }
    22072145                break;
    22082146            case SVGA_COTABLE_UAVIEW:

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

    r93115 r94146  
    707707        void                       *pPixelShader;
    708708#endif
    709         void                       *pvBackendShader;
    710709    } u;
    711 #ifdef VMSVGA3D_DX
    712     DXShaderInfo                   shaderInfo;
    713 #endif
    714710} VMSVGA3DSHADER;
    715711typedef VMSVGA3DSHADER *PVMSVGA3DSHADER;
    … …  
    726722    SSMFIELD_ENTRY(                 VMSVGA3DSHADER, cbData),
    727723    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGA3DSHADER, pShaderProgram),
    728     SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGA3DSHADER, u.pvBackendShader),
    729724    SSMFIELD_ENTRY_TERM()
    730725};
    … …  
    994989        uint32_t                           cUAView;
    995990    } cot;
    996     /* Shader information. The array has cot.cShader elements. Some data is dublicated in cot.paShader. */
    997     PVMSVGA3DSHADER paShader;
    998991} VMSVGA3DDXCONTEXT;
    999992/** Pointer to a VMSVGA3D DX context. */

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win-dx.cpp

    r94113 r94146  
    214214
    215215    uint32_t                    soid;               /* Stream output declarations for geometry shaders. */
     216
     217    DXShaderInfo                shaderInfo;
    216218} DXSHADER;
    217219
    … …  
    280282static int dxSetRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext);
    281283static DECLCALLBACK(void) vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface);
     284static int dxDestroyShader(DXSHADER *pDXShader);
    282285
    283286
    … …  
    15851588
    15861589
    1587 static HRESULT dxShaderCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, DXSHADER *pDXShader)
     1590static HRESULT dxShaderCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, DXSHADER *pDXShader)
    15881591{
    15891592    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
    … …  
    15911594    HRESULT hr = S_OK;
    15921595
    1593     switch (pShader->type)
     1596    switch (pDXShader->enmShaderType)
    15941597    {
    15951598        case SVGA3D_SHADERTYPE_VS:
    … …  
    16181621                    D3D11_SO_DECLARATION_ENTRY *p = &pDXStreamOutput->aDeclarationEntry[i];
    16191622                    SVGA3dStreamOutputDeclarationEntry const *decl = &pEntry->decl[i];
    1620                     p->SemanticName = DXShaderGetOutputSemanticName(&pShader->shaderInfo, decl->registerIndex);
     1623                    p->SemanticName = DXShaderGetOutputSemanticName(&pDXShader->shaderInfo, decl->registerIndex);
    16211624                }
    16221625
    … …  
    28522855    LogRelMax(1, ("VMSVGA: Single DX device mode: %s\n", pBackend->fSingleDevice ? "enabled" : "disabled"));
    28532856
    2854 //DEBUG_BREAKPOINT_TEST();
     2857DEBUG_BREAKPOINT_TEST();
    28552858    return rc;
    28562859}
    … …  
    32333236        }
    32343237        else
    3235             rc = VERR_NOT_SUPPORTED;
     3238            AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
    32363239    }
    32373240    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
    … …  
    33063309        }
    33073310        else
    3308             rc = VERR_NOT_SUPPORTED;
     3311            AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
    33093312    }
    33103313    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
    … …  
    33513354            }
    33523355            else
    3353                 rc = VERR_NOT_SUPPORTED;
     3356                AssertFailedStmt(rc = VERR_NOT_SUPPORTED);
    33543357        }
    33553358    }
    … …  
    50715074        {
    50725075            for (uint32_t i = 0; i < pBackendDXContext->cShader; ++i)
    5073                 D3D_RELEASE(pBackendDXContext->paShader[i].pShader); /// @todo dxDestroyShader
     5076                dxDestroyShader(&pBackendDXContext->paShader[i]);
    50745077        }
    50755078        if (pBackendDXContext->paStreamOutput)
    … …  
    52725275
    52735276
    5274 static DECLCALLBACK(int) vmsvga3dBackDXSetShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, PVMSVGA3DSHADER pShader)
     5277static DECLCALLBACK(int) vmsvga3dBackDXSetShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGA3dShaderType type)
    52755278{
    52765279    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    … …  
    52805283    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
    52815284
    5282     DXSHADER *pDXShader;
    5283     if (pShader)
    5284     {
    5285         pDXShader = &pDXContext->pBackendDXContext->paShader[pShader->id];
    5286         Assert(pDXShader->pShader);
    5287         Assert(pDXShader->enmShaderType >= SVGA3D_SHADERTYPE_MIN && pDXShader->enmShaderType < SVGA3D_SHADERTYPE_MAX);
    5288     }
    5289     else
    5290         pDXShader = NULL;
    5291 
    5292     dxShaderSet(pThisCC, pDXContext, type, pDXShader);
     5285    RT_NOREF(shaderId, type);
     5286
    52935287    return VINF_SUCCESS;
    52945288}
    … …  
    53325326    DXDEVICE *pDXDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
    53335327    pDXDevice->pImmediateContext->OMSetRenderTargets(0, NULL, NULL);
     5328
     5329    /*
     5330     * Shader resources
     5331     */
    53345332
    53355333    /* Make sure that the shader resource views exist. */
    … …  
    53765374    }
    53775375
     5376    /*
     5377     * Render targets
     5378     */
    53785379
    53795380    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
    … …  
    54335434    rc = dxSetRenderTargets(pThisCC, pDXContext);
    54345435    AssertRC(rc);
     5436
     5437    /*
     5438     * Shaders
     5439     */
     5440
     5441    for (uint32_t idxShaderState = 0; idxShaderState < SVGA3D_NUM_SHADERTYPE_DX10 /** @todo SVGA3D_NUM_SHADERTYPE*/; ++idxShaderState)
     5442    {
     5443        DXSHADER *pDXShader;
     5444        SVGA3dShaderType const shaderType = (SVGA3dShaderType)(idxShaderState + SVGA3D_SHADERTYPE_MIN);
     5445        SVGA3dShaderId const shaderId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
     5446
     5447        if (shaderId != SVGA3D_INVALID_ID)
     5448        {
     5449            pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
     5450            if (pDXShader->pShader == NULL)
     5451            {
     5452                /* Create a new shader. */
     5453                Log(("Shader: cid=%u shid=%u type=%d\n", pDXContext->cid, shaderId, pDXShader->enmShaderType));
     5454
     5455                /* Apply resource types to a pixel shader. */
     5456                if (shaderType == SVGA3D_SHADERTYPE_PS)
     5457                {
     5458                    SVGA3dResourceType aResourceType[SVGA3D_DX_MAX_SRVIEWS];
     5459                    RT_ZERO(aResourceType);
     5460                    uint32_t cResourceType = 0;
     5461
     5462                    for (uint32_t idxSR = 0; idxSR < SVGA3D_DX_MAX_SRVIEWS; ++idxSR)
     5463                    {
     5464                        SVGA3dShaderResourceViewId const shaderResourceViewId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderResources[idxSR];
     5465                        if (shaderResourceViewId != SVGA3D_INVALID_ID)
     5466                        {
     5467                            SVGACOTableDXSRViewEntry const *pSRViewEntry = dxGetShaderResourceViewEntry(pDXContext, shaderResourceViewId);
     5468                            AssertContinue(pSRViewEntry != NULL);
     5469
     5470                            aResourceType[idxSR] = pSRViewEntry->resourceDimension;
     5471                            cResourceType = idxSR + 1;
     5472                        }
     5473                    }
     5474
     5475                    rc = DXShaderUpdateResourceTypes(&pDXShader->shaderInfo, aResourceType, cResourceType);
     5476                    AssertRC(rc); /* Ignore rc because the shader will most likely work anyway. */
     5477                }
     5478
     5479                rc = DXShaderCreateDXBC(&pDXShader->shaderInfo, &pDXShader->pvDXBC, &pDXShader->cbDXBC);
     5480                if (RT_SUCCESS(rc))
     5481                {
     5482#ifdef LOG_ENABLED
     5483                    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
     5484                    if (pBackend->pfnD3DDisassemble && LogIs6Enabled())
     5485                    {
     5486                        ID3D10Blob *pBlob = 0;
     5487                        HRESULT hr2 = pBackend->pfnD3DDisassemble(pDXShader->pvDXBC, pDXShader->cbDXBC, 0, NULL, &pBlob);
     5488                        if (SUCCEEDED(hr2) && pBlob && pBlob->GetBufferSize())
     5489                            Log6(("%s\n", pBlob->GetBufferPointer()));
     5490                        else
     5491                            AssertFailed();
     5492                        D3D_RELEASE(pBlob);
     5493                    }
     5494#endif
     5495
     5496                    HRESULT hr = dxShaderCreate(pThisCC, pDXContext, pDXShader);
     5497                    if (FAILED(hr))
     5498                        rc = VERR_INVALID_STATE;
     5499                }
     5500                else
     5501                    rc = VERR_NO_MEMORY;
     5502            }
     5503        }
     5504        else
     5505            pDXShader = NULL;
     5506
     5507        if (RT_SUCCESS(rc))
     5508            dxShaderSet(pThisCC, pDXContext, shaderType, pDXShader);
     5509
     5510        AssertRC(rc);
     5511    }
     5512
     5513    /*
     5514     * InputLayout
     5515     */
     5516    SVGA3dElementLayoutId const elementLayoutId = pDXContext->svgaDXContext.inputAssembly.layoutId;
     5517    ID3D11InputLayout *pInputLayout = NULL;
     5518    if (elementLayoutId != SVGA3D_INVALID_ID)
     5519    {
     5520        DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[elementLayoutId];
     5521        if (!pDXElementLayout->pElementLayout)
     5522        {
     5523            uint32_t const idxShaderState = SVGA3D_SHADERTYPE_VS - SVGA3D_SHADERTYPE_MIN;
     5524            uint32_t const shid = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
     5525            if (shid < pDXContext->pBackendDXContext->cShader)
     5526            {
     5527                DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shid];
     5528                if (pDXShader->pvDXBC)
     5529                {
     5530                    HRESULT hr = pDevice->pDevice->CreateInputLayout(pDXElementLayout->aElementDesc,
     5531                                                                     pDXElementLayout->cElementDesc,
     5532                                                                     pDXShader->pvDXBC,
     5533                                                                     pDXShader->cbDXBC,
     5534                                                                     &pDXElementLayout->pElementLayout);
     5535                    Assert(SUCCEEDED(hr));
     5536                }
     5537                else
     5538                    LogRelMax(16, ("VMSVGA: DX shader bytecode is not available in DXSetInputLayout: shid = %u\n", shid));
     5539            }
     5540            else
     5541                LogRelMax(16, ("VMSVGA: DX shader is not set in DXSetInputLayout: shid = 0x%x\n", shid));
     5542        }
     5543
     5544        pInputLayout = pDXElementLayout->pElementLayout;
     5545    }
     5546
     5547    pDevice->pImmediateContext->IASetInputLayout(pInputLayout);
    54355548}
    54365549
    … …  
    57755888    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
    57765889
    5777     ID3D11InputLayout *pInputLayout = NULL;
    5778     if (elementLayoutId != SVGA3D_INVALID_ID)
    5779     {
    5780         DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[elementLayoutId];
    5781         if (!pDXElementLayout->pElementLayout)
    5782         {
    5783             uint32_t const idxShaderState = SVGA3D_SHADERTYPE_VS - SVGA3D_SHADERTYPE_MIN;
    5784             uint32_t const shid = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId;
    5785             AssertReturnStmt(shid < pDXContext->pBackendDXContext->cShader,
    5786                              LogRelMax(16, ("VMSVGA: DX shader is not set in DXSetInputLayout: shid = 0x%x\n", shid)),
    5787                              VERR_INVALID_STATE);
    5788             DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shid];
    5789             AssertReturnStmt(pDXShader->pvDXBC,
    5790                              LogRelMax(16, ("VMSVGA: DX shader bytecode is not available in DXSetInputLayout: shid = %u\n", shid)),
    5791                              VERR_INVALID_STATE);
    5792             HRESULT hr = pDevice->pDevice->CreateInputLayout(pDXElementLayout->aElementDesc,
    5793                                                              pDXElementLayout->cElementDesc,
    5794                                                              pDXShader->pvDXBC,
    5795                                                              pDXShader->cbDXBC,
    5796                                                              &pDXElementLayout->pElementLayout);
    5797             AssertReturn(SUCCEEDED(hr), VERR_NO_MEMORY);
    5798         }
    5799 
    5800         pInputLayout = pDXElementLayout->pElementLayout;
    5801     }
    5802 
    5803     pDevice->pImmediateContext->IASetInputLayout(pInputLayout);
     5890    RT_NOREF(elementLayoutId);
     5891
    58045892    return VINF_SUCCESS;
    58055893}
    … …  
    64856573    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
    64866574
     6575    /** @todo Probably not necessary because SRVs are defined in setupPipeline. */
    64876576    return dxDefineShaderResourceView(pThisCC, pDXContext, shaderResourceViewId, pEntry);
    64886577}
    … …  
    67896878    /** @todo A common approach for creation of COTable backend objects: runtime, empty DX COTable, live DX COTable. */
    67906879    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
    6791     if (pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID)
    6792     {
    6793         /* Init the shader structure. */
    6794         pDXShader->enmShaderType = pEntry->type;
    6795         pDXShader->soid = SVGA_ID_INVALID;
    6796     }
    6797 
    6798     PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
    6799     pShader->u.pvBackendShader = pDXShader;
     6880    Assert(pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID);
     6881
     6882    /* Init the backend shader structure, if the shader has not been created yet. */
     6883    pDXShader->enmShaderType = pEntry->type;
     6884    pDXShader->pShader = NULL;
     6885    pDXShader->soid = SVGA_ID_INVALID;
    68006886
    68016887    return VINF_SUCCESS;
    … …  
    68206906    RT_NOREF(pBackend);
    68216907
     6908    return dxDefineShader(pDXContext, shaderId, pEntry);
     6909}
     6910
     6911
     6912static DECLCALLBACK(int) vmsvga3dBackDXDestroyShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId)
     6913{
     6914    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
     6915    RT_NOREF(pBackend);
     6916
    68226917    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
    68236918    dxDestroyShader(pDXShader);
    68246919
    6825     return dxDefineShader(pDXContext, shaderId, pEntry);
    6826 }
    6827 
    6828 
    6829 static DECLCALLBACK(int) vmsvga3dBackDXDestroyShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId)
    6830 {
    6831     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    6832     RT_NOREF(pBackend);
    6833 
    6834     DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
    6835     dxDestroyShader(pDXShader);
    6836 
    68376920    return VINF_SUCCESS;
    68386921}
    68396922
    68406923
    6841 static DECLCALLBACK(int) vmsvga3dBackDXBindShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, void const *pvShaderBytecode)
     6924static DECLCALLBACK(int) vmsvga3dBackDXBindShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, DXShaderInfo const *pShaderInfo)
    68426925{
    68436926    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    … …  
    68476930    RT_NOREF(pBackend);
    68486931
    6849     int rc = VINF_SUCCESS;
    6850 
    6851     DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[pShader->id];
    6852     Assert(pDXShader->enmShaderType == pShader->type);
    6853 
     6932    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
    68546933    if (pDXShader->pvDXBC)
    68556934    {
     6935        /* New DXBC code and new shader must be created. */
     6936        D3D_RELEASE(pDXShader->pShader);
    68566937        RTMemFree(pDXShader->pvDXBC);
    68576938        pDXShader->pvDXBC = NULL;
    … …  
    68596940    }
    68606941
    6861     if (pvShaderBytecode)
    6862     {
    6863         Log(("Shader: cid=%u shid=%u type=%d\n", pDXContext->cid, pShader->id, pDXShader->enmShaderType));
    6864 
    6865         rc = DXShaderCreateDXBC(&pShader->shaderInfo, &pDXShader->pvDXBC, &pDXShader->cbDXBC);
    6866         if (RT_SUCCESS(rc))
    6867         {
    6868 #ifdef LOG_ENABLED
    6869             if (pBackend->pfnD3DDisassemble && LogIs6Enabled())
    6870             {
    6871                 ID3D10Blob *pBlob = 0;
    6872                 HRESULT hr2 = pBackend->pfnD3DDisassemble(pDXShader->pvDXBC, pDXShader->cbDXBC, 0, NULL, &pBlob);
    6873                 if (SUCCEEDED(hr2) && pBlob && pBlob->GetBufferSize())
    6874                     Log6(("%s\n", pBlob->GetBufferPointer()));
    6875                 else
    6876                     AssertFailed();
    6877                 D3D_RELEASE(pBlob);
    6878             }
    6879 #endif
    6880 
    6881             HRESULT hr = dxShaderCreate(pThisCC, pDXContext, pShader, pDXShader);
    6882             if (SUCCEEDED(hr))
    6883             {
    6884             }
    6885             else
    6886                 rc = VERR_INVALID_STATE;
    6887         }
    6888         else
    6889             rc = VERR_NO_MEMORY;
    6890     }
    6891 
    6892     return rc;
     6942    pDXShader->shaderInfo = *pShaderInfo;
     6943
     6944    return VINF_SUCCESS;
    68936945}
    68946946
    … …  
    72227274                    continue; /* Skip uninitialized entry. */
    72237275
    7224                 /** @todo this should be in the common DX code (the caller). */
    7225                 PVMSVGA3DSHADER pShader = &pDXContext->paShader[i];
    7226                 pShader->id                = i;
    7227                 pShader->cid               = pDXContext->cid;
    7228                 pShader->type              = pEntry->type;
    7229                 pShader->cbData            = pEntry->sizeInBytes;
    7230                 pShader->pShaderProgram    = NULL;
    7231                 pShader->u.pvBackendShader = NULL;
    7232 
    7233                 dxDefineShader(pDXContext, i, pEntry);
     7276                /* Define shaders which were not defined yet in backend. */
     7277                DXSHADER *pDXShader = &pBackendDXContext->paShader[i];
     7278                if (   pEntry->type != SVGA3D_SHADERTYPE_INVALID
     7279                    && pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID)
     7280                    dxDefineShader(pDXContext, i, pEntry);
     7281                else
     7282                    Assert(pEntry->type == pDXShader->enmShaderType);
     7283
    72347284            }
    72357285            break;

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

    r94106 r94146  
    390390typedef struct VMSVGA3DSHADER *PVMSVGA3DSHADER;
    391391typedef struct VMSVGA3DDXCONTEXT *PVMSVGA3DDXCONTEXT;
     392struct DXShaderInfo;
    392393#define VMSVGA3D_BACKEND_INTERFACE_NAME_DX "DX"
    393394typedef struct
    … …  
    401402    DECLCALLBACKMEMBER(int, pfnDXSetSingleConstantBuffer,   (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t slot, SVGA3dShaderType type, SVGA3dSurfaceId sid, uint32_t offsetInBytes, uint32_t sizeInBytes));
    402403    DECLCALLBACKMEMBER(int, pfnDXSetShaderResources,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startView, SVGA3dShaderType type, uint32_t cShaderResourceViewId, SVGA3dShaderResourceViewId const *paShaderResourceViewId));
    403     DECLCALLBACKMEMBER(int, pfnDXSetShader,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, PVMSVGA3DSHADER pShader));
     404    DECLCALLBACKMEMBER(int, pfnDXSetShader,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGA3dShaderType type));
    404405    DECLCALLBACKMEMBER(int, pfnDXSetSamplers,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startSampler, SVGA3dShaderType type, uint32_t cSamplerId, SVGA3dSamplerId const *paSamplerId));
    405406    DECLCALLBACKMEMBER(int, pfnDXDraw,                      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t vertexCount, uint32_t startVertexLocation));
    … …  
    451452    DECLCALLBACKMEMBER(int, pfnDXDefineShader,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGACOTableDXShaderEntry const *pEntry));
    452453    DECLCALLBACKMEMBER(int, pfnDXDestroyShader,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId));
    453     DECLCALLBACKMEMBER(int, pfnDXBindShader,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, void const *pvShaderBytecode));
     454    DECLCALLBACKMEMBER(int, pfnDXBindShader,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, DXShaderInfo const *pShaderInfo));
    454455    DECLCALLBACKMEMBER(int, pfnDXDefineStreamOutput,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid, SVGACOTableDXStreamOutputEntry const *pEntry));
    455456    DECLCALLBACKMEMBER(int, pfnDXDestroyStreamOutput,       (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid));
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette