VirtualBox

Changeset 89121 in vbox for trunk/src/VBox/Devices/Graphics


Ignore:
Timestamp:
May 17, 2021 7:30:44 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
144462
Message:

Devices/Graphics: Function tables for 3D backends. bugref:9830

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

Legend:

Unmodified
Added
Removed

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

    r88904 r89121  
    418418
    419419
     420#ifdef VBOX_WITH_VMSVGA3D
    420421static int vmsvgaR3GboCreate(PVMSVGAR3STATE pSvgaR3State, SVGAMobFormat ptDepth, PPN64 baseAddress, uint32_t sizeInBytes, bool fGCPhys64, bool fWriteProtected, PVMSVGAGBO pGbo)
    421422{
    … …  
    941942
    942943
    943 #ifdef VBOX_WITH_VMSVGA3D
    944944int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox)
    945945{
    … …  
    41714171        STAM_REL_COUNTER_INC(&pSvgaR3State->StatR3Cmd3dEndQuery);
    41724172
    4173         vmsvga3dQueryEnd(pThisCC, pCmd->cid, pCmd->type, pCmd->guestResult);
     4173        vmsvga3dQueryEnd(pThisCC, pCmd->cid, pCmd->type);
    41744174        break;
    41754175    }
    … …  
    41814181        STAM_REL_COUNTER_INC(&pSvgaR3State->StatR3Cmd3dWaitForQuery);
    41824182
    4183         vmsvga3dQueryWait(pThis, pThisCC, pCmd->cid, pCmd->type, pCmd->guestResult);
     4183        vmsvga3dQueryWait(pThisCC, pCmd->cid, pCmd->type, pThis, &pCmd->guestResult);
    41844184        break;
    41854185    }

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

    r88787 r89121  
    143143
    144144# ifdef VBOX_WITH_VMSVGA3D
     145    VMSVGA3DBACKENDFUNCS3D  *pFuncs3D;
     146    VMSVGA3DBACKENDFUNCSVGPU9 *pFuncsVGPU9;
    145147    VMSVGA3DBACKENDFUNCSMAP *pFuncsMap;
    146148    VMSVGA3DBACKENDFUNCSGBO *pFuncsGBO;

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

    r88835 r89121  
    423423static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATECC pThisCC, PSSMHANDLE pSSM);
    424424static void vmsvgaR3CmdBufSubmit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, RTGCPHYS GCPhysCB, SVGACBContext CBCtx);
     425# ifdef VBOX_WITH_VMSVGA3D
     426static void vmsvga3dR3Free3dInterfaces(PVGASTATECC pThisCC);
     427# endif
    425428#endif /* IN_RING3 */
    426429
    … …  
    38883891            {
    38893892                /* The 3d subsystem must be reset from the fifo thread. */
    3890                 vmsvga3dReset(pThisCC);
     3893                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     3894                pSVGAState->pFuncs3D->pfnReset(pThisCC);
    38913895            }
    38923896# endif
    … …  
    39083912            {
    39093913                /* The 3d subsystem must be shut down from the fifo thread. */
    3910                 vmsvga3dTerminate(pThisCC);
     3914                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     3915                pSVGAState->pFuncs3D->pfnTerminate(pThisCC);
    39113916            }
    39123917# endif
    … …  
    39343939# ifdef VBOX_WITH_VMSVGA3D
    39353940            if (pThis->svga.f3DEnabled)
     3941            {
     3942                /* The following RT_OS_DARWIN code was in vmsvga3dLoadExec and therefore must be executed before each vmsvga3dLoadExec invocation. */
     3943#  ifndef RT_OS_DARWIN /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA.cpp */
     3944                /* Must initialize now as the recreation calls below rely on an initialized 3d subsystem. */
     3945                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     3946                pSVGAState->pFuncs3D->pfnPowerOn(pDevIns, pThis, pThisCC);
     3947#  endif
     3948
    39363949                vmsvga3dLoadExec(pDevIns, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
     3950            }
    39373951# endif
    39383952            break;
    … …  
    55535567
    55545568#  ifdef RT_OS_DARWIN  /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA3d-shared.h. */
    5555     vmsvga3dPowerOn(pDevIns, pThis, PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC));
     5569    pSVGAState->pFuncs3D->pfnPowerOn(pDevIns, pThis, pThisCC);
    55565570#  endif
    55575571
    … …  
    57045718 * @param   pSVGAState     Pointer to the structure. It is not deallocated.
    57055719 */
    5706 static void vmsvgaR3StateTerm(PVGASTATE pThis, PVMSVGAR3STATE pSVGAState)
    5707 {
     5720static void vmsvgaR3StateTerm(PVGASTATE pThis, PVGASTATECC pThisCC)
     5721{
     5722    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     5723
    57085724# ifndef VMSVGA_USE_EMT_HALT_CODE
    57095725    if (pSVGAState->hBusyDelayedEmts != NIL_RTSEMEVENTMULTI)
    … …  
    57455761
    57465762# ifdef VBOX_WITH_VMSVGA3D
     5763    vmsvga3dR3Free3dInterfaces(pThisCC);
     5764# endif
     5765}
     5766
     5767/**
     5768 * Constructor for PVMSVGAR3STATE structure.
     5769 *
     5770 * @returns VBox status code.
     5771 * @param   pDevIns        The PDM device instance.
     5772 * @param   pThis          The shared VGA/VMSVGA instance data.
     5773 * @param   pSVGAState     Pointer to the structure. It is already allocated.
     5774 */
     5775static int vmsvgaR3StateInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVMSVGAR3STATE pSVGAState)
     5776{
     5777    int rc = VINF_SUCCESS;
     5778
     5779    pSVGAState->pDevIns = pDevIns;
     5780
     5781    pSVGAState->paGMR = (PGMR)RTMemAllocZ(pThis->svga.cGMR * sizeof(GMR));
     5782    AssertReturn(pSVGAState->paGMR, VERR_NO_MEMORY);
     5783
     5784# ifndef VMSVGA_USE_EMT_HALT_CODE
     5785    /* Create semaphore for delaying EMTs wait for the FIFO to stop being busy. */
     5786    rc = RTSemEventMultiCreate(&pSVGAState->hBusyDelayedEmts);
     5787    AssertRCReturn(rc, rc);
     5788# endif
     5789
     5790    rc = RTCritSectInit(&pSVGAState->CritSectCmdBuf);
     5791    AssertRCReturn(rc, rc);
     5792
     5793    vmsvgaR3CmdBufCtxInit(&pSVGAState->CmdBufCtxDC);
     5794
     5795    RTListInit(&pSVGAState->MOBLRUList);
     5796    return rc;
     5797}
     5798
     5799# ifdef VBOX_WITH_VMSVGA3D
     5800static void vmsvga3dR3Free3dInterfaces(PVGASTATECC pThisCC)
     5801{
     5802    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     5803
    57475804    RTMemFree(pSVGAState->pFuncsMap);
    57485805    pSVGAState->pFuncsMap = NULL;
    … …  
    57515808    RTMemFree(pSVGAState->pFuncsDX);
    57525809    pSVGAState->pFuncsDX = NULL;
    5753 # endif
    5754 }
    5755 
    5756 /**
    5757  * Constructor for PVMSVGAR3STATE structure.
    5758  *
    5759  * @returns VBox status code.
    5760  * @param   pDevIns        The PDM device instance.
    5761  * @param   pThis          The shared VGA/VMSVGA instance data.
    5762  * @param   pSVGAState     Pointer to the structure. It is already allocated.
    5763  */
    5764 static int vmsvgaR3StateInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVMSVGAR3STATE pSVGAState)
    5765 {
    5766     int rc = VINF_SUCCESS;
    5767 
    5768     pSVGAState->pDevIns = pDevIns;
    5769 
    5770     pSVGAState->paGMR = (PGMR)RTMemAllocZ(pThis->svga.cGMR * sizeof(GMR));
    5771     AssertReturn(pSVGAState->paGMR, VERR_NO_MEMORY);
    5772 
    5773 # ifndef VMSVGA_USE_EMT_HALT_CODE
    5774     /* Create semaphore for delaying EMTs wait for the FIFO to stop being busy. */
    5775     rc = RTSemEventMultiCreate(&pSVGAState->hBusyDelayedEmts);
    5776     AssertRCReturn(rc, rc);
    5777 # endif
    5778 
    5779     rc = RTCritSectInit(&pSVGAState->CritSectCmdBuf);
    5780     AssertRCReturn(rc, rc);
    5781 
    5782     vmsvgaR3CmdBufCtxInit(&pSVGAState->CmdBufCtxDC);
    5783 
    5784     RTListInit(&pSVGAState->MOBLRUList);
    5785     return rc;
    5786 }
    5787 
    5788 # ifdef VBOX_WITH_VMSVGA3D
     5810    RTMemFree(pSVGAState->pFuncsVGPU9);
     5811    pSVGAState->pFuncsVGPU9 = NULL;
     5812    RTMemFree(pSVGAState->pFuncs3D);
     5813    pSVGAState->pFuncs3D = NULL;
     5814}
     5815
     5816/* This structure is used only by vmsvgaR3Init3dInterfaces */
     5817typedef struct VMSVGA3DINTERFACE
     5818{
     5819    char const *pcszName;
     5820    uint32_t cbFuncs;
     5821    void **ppvFuncs;
     5822} VMSVGA3DINTERFACE;
     5823
    57895824/**
    57905825 * Initializes the optional host 3D backend interfaces.
    … …  
    57975832    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
    57985833
    5799     int rc = vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_DX, NULL, sizeof(VMSVGA3DBACKENDFUNCSDX));
     5834#define ENTRY_3D_INTERFACE(a_Name, a_Field) { VMSVGA3D_BACKEND_INTERFACE_NAME_##a_Name, sizeof(VMSVGA3DBACKENDFUNCS##a_Name), (void **)&pSVGAState->a_Field }
     5835    VMSVGA3DINTERFACE a3dInterface[] =
     5836    {
     5837        ENTRY_3D_INTERFACE(3D,    pFuncs3D),
     5838        ENTRY_3D_INTERFACE(VGPU9, pFuncsVGPU9),
     5839        ENTRY_3D_INTERFACE(DX,    pFuncsDX),
     5840        ENTRY_3D_INTERFACE(MAP,   pFuncsMap),
     5841        ENTRY_3D_INTERFACE(GBO,   pFuncsGBO),
     5842    };
     5843#undef ENTRY_3D_INTERFACE
     5844
     5845    int rc = VINF_SUCCESS;
     5846    for (uint32_t i = 0; i < RT_ELEMENTS(a3dInterface); ++i)
     5847    {
     5848        VMSVGA3DINTERFACE *p = &a3dInterface[i];
     5849
     5850        int rc2 = vmsvga3dQueryInterface(pThisCC, p->pcszName, NULL, p->cbFuncs);
     5851        if (RT_SUCCESS(rc2))
     5852        {
     5853            *p->ppvFuncs = RTMemAllocZ(p->cbFuncs);
     5854            AssertBreakStmt(*p->ppvFuncs, rc = VERR_NO_MEMORY);
     5855
     5856            vmsvga3dQueryInterface(pThisCC, p->pcszName, *p->ppvFuncs, p->cbFuncs);
     5857        }
     5858    }
     5859
    58005860    if (RT_SUCCESS(rc))
    58015861    {
    5802         pSVGAState->pFuncsDX = (VMSVGA3DBACKENDFUNCSDX *)RTMemAllocZ(sizeof(VMSVGA3DBACKENDFUNCSDX));
    5803         AssertReturn(pSVGAState->pFuncsDX, VERR_NO_MEMORY);
    5804 
    5805         vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_DX, pSVGAState->pFuncsDX, sizeof(VMSVGA3DBACKENDFUNCSDX));
    5806     }
    5807 
    5808     rc = vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_MAP, NULL, sizeof(VMSVGA3DBACKENDFUNCSMAP));
    5809     if (RT_SUCCESS(rc))
    5810     {
    5811         pSVGAState->pFuncsMap = (VMSVGA3DBACKENDFUNCSMAP *)RTMemAllocZ(sizeof(VMSVGA3DBACKENDFUNCSMAP));
    5812         AssertReturn(pSVGAState->pFuncsMap, VERR_NO_MEMORY);
    5813 
    5814         vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_MAP, pSVGAState->pFuncsMap, sizeof(VMSVGA3DBACKENDFUNCSMAP));
    5815     }
    5816 
    5817     rc = vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_GBO, NULL, sizeof(VMSVGA3DBACKENDFUNCSGBO));
    5818     if (RT_SUCCESS(rc))
    5819     {
    5820         pSVGAState->pFuncsGBO = (VMSVGA3DBACKENDFUNCSGBO *)RTMemAllocZ(sizeof(VMSVGA3DBACKENDFUNCSGBO));
    5821         AssertReturn(pSVGAState->pFuncsGBO, VERR_NO_MEMORY);
    5822 
    5823         vmsvga3dQueryInterface(pThisCC, VMSVGA3D_BACKEND_INTERFACE_NAME_GBO, pSVGAState->pFuncsGBO, sizeof(VMSVGA3DBACKENDFUNCSGBO));
    5824     }
    5825 
    5826     return VINF_SUCCESS;
    5827 }
    5828 # endif
     5862        /* 3D interface is required. */
     5863        if (pSVGAState->pFuncs3D)
     5864            return VINF_SUCCESS;
     5865
     5866        rc = VERR_NOT_SUPPORTED;
     5867    }
     5868
     5869    vmsvga3dR3Free3dInterfaces(pThisCC);
     5870    return rc;
     5871}
     5872# endif /* VBOX_WITH_VMSVGA3D */
    58295873
    58305874/**
    … …  
    58375881static void vmsvgaR3InitCaps(PVGASTATE pThis, PVGASTATECC pThisCC)
    58385882{
     5883# ifdef VBOX_WITH_VMSVGA3D
     5884    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     5885# endif
     5886
    58395887    /* Device caps. */
    58405888    pThis->svga.u32DeviceCaps = SVGA_CAP_GMR
    … …  
    58595907
    58605908# ifdef VBOX_WITH_VMSVGA3D
    5861         PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
    58625909        if (pSVGAState->pFuncsGBO)
    58635910           pThis->svga.u32DeviceCaps |= SVGA_CAP_GBOBJECTS;     /* Enable guest-backed objects and surfaces. */
    … …  
    58685915
    58695916# ifdef VBOX_WITH_VMSVGA3D
    5870     pThis->svga.u32DeviceCaps |= SVGA_CAP_3D;
     5917    if (pSVGAState->pFuncs3D)
     5918        pThis->svga.u32DeviceCaps |= SVGA_CAP_3D;
    58715919# endif
    58725920
    … …  
    59936041    ASMAtomicWriteBool(&pThis->svga.fBadGuest, false);
    59946042
    5995     vmsvgaR3StateTerm(pThis, pThisCC->svga.pSvgaR3State);
     6043    vmsvgaR3StateTerm(pThis, pThisCC);
    59966044    vmsvgaR3StateInit(pDevIns, pThis, pThisCC->svga.pSvgaR3State);
    59976045
    59986046    RT_BZERO(pThisCC->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
    5999 
    6000 # ifdef VBOX_WITH_VMSVGA3D
    6001     /* Device capabilities depend on this. */
    6002     if (pThis->svga.f3DEnabled)
    6003         vmsvgaR3Init3dInterfaces(pThisCC);
    6004 # endif
    60056047
    60066048    /* Initialize FIFO and register capabilities. */
    … …  
    60566098    if (pThisCC->svga.pSvgaR3State)
    60576099    {
    6058         vmsvgaR3StateTerm(pThis, pThisCC->svga.pSvgaR3State);
     6100        vmsvgaR3StateTerm(pThis, pThisCC);
    60596101
    60606102        RTMemFree(pThisCC->svga.pSvgaR3State);
    … …  
    61456187    if (pThis->svga.f3DEnabled)
    61466188    {
    6147         rc = vmsvga3dInit(pDevIns, pThis, pThisCC);
     6189        /* Load a 3D backend. */
     6190        rc = vmsvgaR3Init3dInterfaces(pThisCC);
    61486191        if (RT_SUCCESS(rc))
    6149         {
    6150             /* Device capabilities depend on this. */
    6151             vmsvgaR3Init3dInterfaces(pThisCC);
    6152         }
    6153         else
     6192            rc = pSVGAState->pFuncs3D->pfnInit(pDevIns, pThis, pThisCC);
     6193
     6194        if (RT_FAILURE(rc))
    61546195        {
    61556196            LogRel(("VMSVGA3d: 3D support disabled! (vmsvga3dInit -> %Rrc)\n", rc));
    … …  
    64566497    if (pThis->svga.f3DEnabled)
    64576498    {
    6458         int rc = vmsvga3dPowerOn(pDevIns, pThis, pThisCC);
     6499        PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     6500        int rc = pSVGAState->pFuncs3D->pfnPowerOn(pDevIns, pThis, pThisCC);
    64596501        if (RT_SUCCESS(rc))
    64606502        {

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

    r88787 r89121  
    805805#elif defined(VMSVGA3D_D3D11)
    806806    /** @todo */
    807 #define VMSVGA3DQUERY_EXISTS(p) (false)
     807#define VMSVGA3DQUERY_EXISTS(p) ((p)->enmQueryState != VMSVGA3DQUERYSTATE_NULL)
    808808#else
    809809#define VMSVGA3DQUERY_EXISTS(p) ((p)->idQuery && (p)->enmQueryState != VMSVGA3DQUERYSTATE_NULL)
    … …  
    12521252#endif /* VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS */
    12531253
    1254 int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    1255 int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen);
    1256 
    1257 int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
    1258                                     SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
    1259                                     SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects);
    12601254
    12611255#ifdef VMSVGA3D_DIRECT3D
    … …  
    13361330
    13371331
    1338 
    1339 /* Command implementation workers. */
    1340 void vmsvga3dBackSurfaceDestroy(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface);
    1341 int  vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
    1342                                    PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
    1343                                    PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
    1344                                    SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext);
    1345 int  vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
    1346                                    PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
    1347                                    SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
    1348                                    SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox);
    1349 
    1350 int  vmsvga3dBackCreateTexture(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
    1351                                PVMSVGA3DSURFACE pSurface);
    1352 
    13531332DECLINLINE(int) vmsvga3dContextFromCid(PVMSVGA3DSTATE pState, uint32_t cid, PVMSVGA3DCONTEXT *ppContext)
    13541333{
    … …  
    14581437}
    14591438#endif
    1460 
    1461 int vmsvga3dOcclusionQueryCreate(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext);
    1462 int vmsvga3dOcclusionQueryDelete(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext);
    1463 int vmsvga3dOcclusionQueryBegin(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext);
    1464 int vmsvga3dOcclusionQueryEnd(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext);
    1465 int vmsvga3dOcclusionQueryGetData(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels);
    14661439
    14671440void vmsvga3dInfoSurfaceToBitmap(PCDBGFINFOHLP pHlp, PVMSVGA3DSURFACE pSurface,

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

    r88787 r89121  
    170170*********************************************************************************************************************************/
    171171static int  vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid);
     172static int  vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid);
    172173static void vmsvgaColor2GLFloatArray(uint32_t color, GLfloat *pRed, GLfloat *pGreen, GLfloat *pBlue, GLfloat *pAlpha);
     174static int  vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData);
     175static int  vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4]);
     176static int  vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
     177static int  vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext);
     178static int  vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface);
    173179
    174180/* Generated by VBoxDef2LazyLoad from the VBoxSVGA3D.def and VBoxSVGA3DObjC.def files. */
    … …  
    589595 * @param   pThisCC     The VGA/VMSVGA state for ring-3.
    590596 */
    591 int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     597static int vmsvga3dBackInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    592598{
    593599    int rc;
    … …  
    822828
    823829/* We must delay window creation until the PowerOn phase. Init is too early and will cause failures. */
    824 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     830static int vmsvga3dBackPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    825831{
    826832    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    11271133
    11281134    /* Cleanup */
    1129     rc = vmsvga3dContextDestroy(pThisCC, 1);
     1135    rc = vmsvga3dBackContextDestroy(pThisCC, 1);
    11301136    AssertRC(rc);
    11311137#ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
    1132     rc = vmsvga3dContextDestroy(pThisCC, 2);
     1138    rc = vmsvga3dBackContextDestroy(pThisCC, 2);
    11331139    AssertRC(rc);
    11341140#endif
    … …  
    11441150}
    11451151
    1146 int vmsvga3dReset(PVGASTATECC pThisCC)
     1152static int vmsvga3dBackReset(PVGASTATECC pThisCC)
    11471153{
    11481154    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    11601166    {
    11611167        if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
    1162             vmsvga3dContextDestroy(pThisCC, pState->papContexts[i]->id);
     1168            vmsvga3dBackContextDestroy(pThisCC, pState->papContexts[i]->id);
    11631169    }
    11641170
    … …  
    11691175}
    11701176
    1171 int vmsvga3dTerminate(PVGASTATECC pThisCC)
     1177static int vmsvga3dBackTerminate(PVGASTATECC pThisCC)
    11721178{
    11731179    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    11751181    int            rc;
    11761182
    1177     rc = vmsvga3dReset(pThisCC);
     1183    rc = vmsvga3dBackReset(pThisCC);
    11781184    AssertRCReturn(rc, rc);
    11791185
    … …  
    12101216
    12111217
    1212 void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
     1218static void vmsvga3dBackUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
    12131219{
    12141220    /** @todo Move the visible framebuffer content here, don't wait for the guest to
    … …  
    12311237
    12321238/**
    1233  * Worker for vmsvga3dQueryCaps that figures out supported operations for a
     1239 * Worker for vmsvga3dBackQueryCaps that figures out supported operations for a
    12341240 * given surface format capability.
    12351241 *
    … …  
    13751381
    13761382
    1377 int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
     1383static int vmsvga3dBackQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
    13781384{
    13791385    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    19952001 * Destroy backend specific surface bits (part of SVGA_3D_CMD_SURFACE_DESTROY).
    19962002 *
    1997  * @param   pState              The VMSVGA3d state.
     2003 * @param   pThisCC             The device state.
    19982004 * @param   pSurface            The surface being destroyed.
    19992005 */
    2000 void vmsvga3dBackSurfaceDestroy(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface)
    2001 {
     2006static void vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
     2007{
     2008    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     2009    AssertReturnVoid(pState);
     2010
    20022011    PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;
    20032012    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    20442053
    20452054
    2046 int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
    2047                         uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
     2055static int vmsvga3dBackSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
     2056                                   uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
    20482057{
    20492058    int rc;
    … …  
    20842093        {
    20852094            LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->surfaceFlags, pSurfaceDst->format));
    2086             rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSurfaceDst);
     2095            rc = vmsvga3dBackCreateTexture(pThisCC, pContext, pContext->id, pSurfaceDst);
    20872096            AssertRCReturn(rc, rc);
    20882097        }
    … …  
    23532362 * Surfaces are created when needed.
    23542363 *
    2355  * @param   pState              The VMSVGA3d state.
     2364 * @param   pThisCC             The device context.
    23562365 * @param   pContext            The context.
    23572366 * @param   idAssociatedContext Probably the same as pContext->id.
    23582367 * @param   pSurface            The surface to create the texture for.
    23592368 */
    2360 int vmsvga3dBackCreateTexture(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
     2369static int vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
    23612370                              PVMSVGA3DSURFACE pSurface)
    23622371{
     2372    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     2373
    23632374    RT_NOREF(idAssociatedContext);
    23642375
    … …  
    26492660 * @param   pContext            The VMSVGA3d context (already current for OGL).
    26502661 */
    2651 int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
     2662static int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
    26522663                                  PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
    26532664                                  PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
    … …  
    28522863 * @param   iBox                The current box number (for Direct 3D).
    28532864 */
    2854 int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
     2865static int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
    28552866                                  PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
    28562867                                  SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
    … …  
    31383149}
    31393150
    3140 int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
     3151static int vmsvga3dBackGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
    31413152{
    31423153    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
    … …  
    31663177        /* Unknown surface type; turn it into a texture. */
    31673178        LogFunc(("unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
    3168         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
     3179        rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
    31693180        AssertRCReturn(rc, rc);
    31703181    }
    … …  
    32713282        /* If one already exists with this id, then destroy it now. */
    32723283        if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
    3273             vmsvga3dContextDestroy(pThisCC, cid);
     3284            vmsvga3dBackContextDestroy(pThisCC, cid);
    32743285
    32753286        pContext = pState->papContexts[cid];
    … …  
    37303741    } while(0)
    37313742
    3732 int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3743static int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    37333744{
    37343745    LogRel4(("VMSVGA: vmsvga3dBackDefineScreen: screen %u\n", pScreen->idScreen));
    … …  
    38363847}
    38373848
    3838 int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3849static int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    38393850{
    38403851    LogRel4(("VMSVGA: vmsvga3dBackDestroyScreen: screen %u\n", pScreen->idScreen));
    … …  
    38623873
    38633874/* Blit a surface to the GLX pixmap. */
    3864 int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
     3875static int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
    38653876                                    SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
    38663877                                    SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
    … …  
    38793890    {
    38803891        LogFunc(("src sid=%u flags=0x%x format=%d -> create texture\n", srcImage.sid, pSurface->surfaceFlags, pSurface->format));
    3881         rc = vmsvga3dBackCreateTexture(pState, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID, pSurface);
     3892        rc = vmsvga3dBackCreateTexture(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID, pSurface);
    38823893        AssertRCReturn(rc, rc);
    38833894    }
    … …  
    39553966#else /* !RT_OS_LINUX */
    39563967
    3957 int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3968static int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    39583969{
    39593970    RT_NOREF(pThis, pThisCC, pScreen);
    … …  
    39613972}
    39623973
    3963 int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     3974static int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    39643975{
    39653976    RT_NOREF(pThisCC, pScreen);
    … …  
    39673978}
    39683979
    3969 int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
     3980static int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
    39703981                                    SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
    39713982                                    SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
    … …  
    39833994 * @param   cid             Context id
    39843995 */
    3985 int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
     3996static int vmsvga3dBackContextDefine(PVGASTATECC pThisCC, uint32_t cid)
    39863997{
    39873998    return vmsvga3dContextDefineOgl(pThisCC, cid, 0/*fFlags*/);
    … …  
    40164027    {
    40174028        if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
    4018             vmsvga3dShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
     4029            vmsvga3dBackShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
    40194030    }
    40204031    if (pContext->paPixelShader)
    … …  
    40254036    {
    40264037        if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
    4027             vmsvga3dShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
     4038            vmsvga3dBackShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
    40284039    }
    40294040    if (pContext->paVertexShader)
    … …  
    40614072    }
    40624073
    4063     vmsvga3dOcclusionQueryDelete(pState, pContext);
     4074    vmsvga3dBackOcclusionQueryDelete(pThisCC, pContext);
    40644075
    40654076#ifdef RT_OS_WINDOWS
    … …  
    40934104 * @param   cid             Context id
    40944105 */
    4095 int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
     4106static int vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
    40964107{
    40974108    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    41104121
    41114122/**
    4112  * Worker for vmsvga3dChangeMode that resizes a context.
     4123 * Worker for vmsvga3dBackChangeMode that resizes a context.
    41134124 *
    41144125 * @param   pState              The VMSVGA3d state.
    … …  
    41224133
    41234134/* Handle resize */
    4124 int vmsvga3dChangeMode(PVGASTATECC pThisCC)
     4135static int vmsvga3dBackChangeMode(PVGASTATECC pThisCC)
    41254136{
    41264137    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    41434154
    41444155
    4145 int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
     4156static int vmsvga3dBackSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
    41464157{
    41474158    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    42354246        {
    42364247            if (pContext->state.aClipPlane[j].fValid == true)
    4237                 vmsvga3dSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
     4248                vmsvga3dBackSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
    42384249        }
    42394250
    … …  
    42424253        {
    42434254            if (pContext->state.aLightData[j].fValidData == true)
    4244                 vmsvga3dSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
     4255                vmsvga3dBackSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
    42454256        }
    42464257    }
    … …  
    42494260}
    42504261
    4251 int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
     4262static int vmsvga3dBackSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
    42524263{
    42534264    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    43874398}
    43884399
    4389 int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
     4400static int vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
    43904401{
    43914402    uint32_t                    val = UINT32_MAX; /* Shut up MSC. */
    … …  
    46854696            }
    46864697
    4687             rc = vmsvga3dSetRenderState(pThisCC, cid, 2, renderstate);
     4698            rc = vmsvga3dBackSetRenderState(pThisCC, cid, 2, renderstate);
    46884699            AssertRCReturn(rc, rc);
    46894700
    … …  
    48564867            }
    48574868
    4858             rc = vmsvga3dSetRenderState(pThisCC, cid, RT_ELEMENTS(renderstate), renderstate);
     4869            rc = vmsvga3dBackSetRenderState(pThisCC, cid, RT_ELEMENTS(renderstate), renderstate);
    48594870            AssertRCReturn(rc, rc);
    48604871
    … …  
    52505261}
    52515262
    5252 int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
     5263static int vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
    52535264{
    52545265    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    53115322            LogFunc(("create depth texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n",
    53125323                     target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
    5313             rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
     5324            rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
    53145325            AssertRCReturn(rc, rc);
    53155326        }
    … …  
    53805391        {
    53815392            Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
    5382             rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
     5393            rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
    53835394            AssertRCReturn(rc, rc);
    53845395        }
    … …  
    55825593}
    55835594
    5584 int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
     5595static int vmsvga3dBackSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
    55855596{
    55865597    GLenum                      val = ~(GLenum)0; /* Shut up MSC. */
    … …  
    57225733                        Log(("CreateTexture (%d,%d) levels=%d\n",
    57235734                              pSurface->paMipmapLevels[0].mipmapSize.width, pSurface->paMipmapLevels[0].mipmapSize.height, pSurface->cLevels));
    5724                         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
     5735                        rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
    57255736                        AssertRCReturn(rc, rc);
    57265737                    }
    … …  
    57485759                            if (    pTextureStateIter->name != SVGA3D_TS_INVALID
    57495760                                &&  pTextureStateIter->name != SVGA3D_TS_BIND_TEXTURE)
    5750                                 vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureStateIter);
     5761                                vmsvga3dBackSetTextureState(pThisCC, pContext->id, 1, pTextureStateIter);
    57515762                        }
    57525763                    }
    … …  
    59165927}
    59175928
    5918 int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
     5929static int vmsvga3dBackSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
    59195930{
    59205931    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    59655976
    59665977/** @todo Move into separate library as we are using logic from Wine here. */
    5967 int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
     5978static int vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
    59685979{
    59695980    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    61386149}
    61396150
    6140 int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
     6151static int vmsvga3dBackSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
    61416152{
    61426153    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    61636174           /* Load the default settings if none have been set yet. */
    61646175           if (!pContext->state.aLightData[index].fValidData)
    6165                vmsvga3dSetLightData(pThisCC, cid, index, (SVGA3dLightData *)&vmsvga3d_default_light);
     6176               vmsvga3dBackSetLightData(pThisCC, cid, index, (SVGA3dLightData *)&vmsvga3d_default_light);
    61666177        }
    61676178        glEnable(GL_LIGHT0 + index);
    … …  
    61746185}
    61756186
    6176 int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     6187static int vmsvga3dBackSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    61776188{
    61786189    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    61976208    /* Reset the projection matrix as that relies on the viewport setting. */
    61986209    if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
    6199         vmsvga3dSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION,
     6210        vmsvga3dBackSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION,
    62006211                             pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
    62016212    else
    … …  
    62096220        matrix[10] = 1.0;
    62106221        matrix[15] = 1.0;
    6211         vmsvga3dSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION, matrix);
     6222        vmsvga3dBackSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION, matrix);
    62126223    }
    62136224
    … …  
    62156226}
    62166227
    6217 int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4])
     6228static int vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4])
    62186229{
    62196230    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    62466257}
    62476258
    6248 int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     6259static int vmsvga3dBackSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    62496260{
    62506261    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    62786289}
    62796290
    6280 int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil,
    6281                          uint32_t cRects, SVGA3dRect *pRect)
     6291static int vmsvga3dBackCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil,
     6292                                    uint32_t cRects, SVGA3dRect *pRect)
    62826293{
    62836294    GLbitfield            mask = 0;
    … …  
    67086719    /* Reset the view matrix (also takes the world matrix into account). */
    67096720    if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid == true)
    6710         rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW,
     6721        rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW,
    67116722                                  pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
    67126723    else
    … …  
    67206731        matrix[10] = 1.0;
    67216732        matrix[15] = 1.0;
    6722         rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
     6733        rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
    67236734    }
    67246735
    … …  
    67266737    if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
    67276738    {
    6728         rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
     6739        rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
    67296740    }
    67306741    else
    … …  
    67386749        matrix[10] = 1.0;
    67396750        matrix[15] = 1.0;
    6740         rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
     6751        rc = vmsvga3dBackSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
    67416752    }
    67426753    AssertRC(rc);
    … …  
    70247035}
    70257036
    7026 int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
     7037static int vmsvga3dBackDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
    70277038                           uint32_t numRanges, SVGA3dPrimitiveRange *pRange, uint32_t cVertexDivisor,
    70287039                           SVGA3dVertexDivisor *pVertexDivisor)
    … …  
    73407351
    73417352
    7342 int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
     7353static int vmsvga3dBackShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
    73437354{
    73447355    PVMSVGA3DSHADER       pShader;
    … …  
    73787389        /* If one already exists with this id, then destroy it now. */
    73797390        if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
    7380             vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
     7391            vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
    73817392
    73827393        pShader = &pContext->paVertexShader[shid];
    … …  
    73977408        /* If one already exists with this id, then destroy it now. */
    73987409        if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
    7399             vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
     7410            vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
    74007411
    74017412        pShader = &pContext->paPixelShader[shid];
    … …  
    74487459}
    74497460
    7450 int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
     7461static int vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
    74517462{
    74527463    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    74977508}
    74987509
    7499 int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
     7510static int vmsvga3dBackShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
    75007511{
    75017512    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
    … …  
    75687579}
    75697580
    7570 int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
     7581static int vmsvga3dBackShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
    75717582{
    75727583    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    76607671}
    76617672
    7662 int vmsvga3dOcclusionQueryCreate(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    7663 {
     7673static int vmsvga3dBackOcclusionQueryCreate(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     7674{
     7675    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    76647676    AssertReturn(pState->ext.glGenQueries, VERR_NOT_SUPPORTED);
    76657677    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    76737685}
    76747686
    7675 int vmsvga3dOcclusionQueryDelete(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    7676 {
     7687static int vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     7688{
     7689    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    76777690    AssertReturn(pState->ext.glDeleteQueries, VERR_NOT_SUPPORTED);
    76787691    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    76857698}
    76867699
    7687 int vmsvga3dOcclusionQueryBegin(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    7688 {
     7700static int vmsvga3dBackOcclusionQueryBegin(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     7701{
     7702    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    76897703    AssertReturn(pState->ext.glBeginQuery, VERR_NOT_SUPPORTED);
    76907704    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    76957709}
    76967710
    7697 int vmsvga3dOcclusionQueryEnd(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    7698 {
     7711static int vmsvga3dBackOcclusionQueryEnd(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     7712{
     7713    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    76997714    AssertReturn(pState->ext.glEndQuery, VERR_NOT_SUPPORTED);
    77007715    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    77057720}
    77067721
    7707 int vmsvga3dOcclusionQueryGetData(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
    7708 {
     7722static int vmsvga3dBackOcclusionQueryGetData(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
     7723{
     7724    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    77097725    AssertReturn(pState->ext.glGetQueryObjectuiv, VERR_NOT_SUPPORTED);
    77107726    VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
    … …  
    77207736int vmsvga3dQueryInterface(PVGASTATECC pThisCC, char const *pszInterfaceName, void *pvInterfaceFuncs, size_t cbInterfaceFuncs)
    77217737{
    7722     RT_NOREF(pThisCC, pszInterfaceName, pvInterfaceFuncs, cbInterfaceFuncs);
    7723     return VERR_NOT_IMPLEMENTED;
    7724 }
     7738    RT_NOREF(pThisCC);
     7739
     7740    int rc = VINF_SUCCESS;
     7741    if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_3D) == 0)
     7742    {
     7743        if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCS3D))
     7744        {
     7745            if (pvInterfaceFuncs)
     7746            {
     7747                VMSVGA3DBACKENDFUNCS3D *p = (VMSVGA3DBACKENDFUNCS3D *)pvInterfaceFuncs;
     7748                p->pfnInit                     = vmsvga3dBackInit;
     7749                p->pfnPowerOn                  = vmsvga3dBackPowerOn;
     7750                p->pfnTerminate                = vmsvga3dBackTerminate;
     7751                p->pfnReset                    = vmsvga3dBackReset;
     7752                p->pfnQueryCaps                = vmsvga3dBackQueryCaps;
     7753                p->pfnChangeMode               = vmsvga3dBackChangeMode;
     7754                p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
     7755                p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
     7756                p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
     7757                p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;
     7758                p->pfnSurfaceStretchBlt        = vmsvga3dBackSurfaceStretchBlt;
     7759                p->pfnUpdateHostScreenViewport = vmsvga3dBackUpdateHostScreenViewport;
     7760                p->pfnDefineScreen             = vmsvga3dBackDefineScreen;
     7761                p->pfnDestroyScreen            = vmsvga3dBackDestroyScreen;
     7762                p->pfnSurfaceBlitToScreen      = vmsvga3dBackSurfaceBlitToScreen;
     7763            }
     7764        }
     7765        else
     7766        {
     7767            AssertFailed();
     7768            rc = VERR_INVALID_PARAMETER;
     7769        }
     7770    }
     7771    else if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_VGPU9) == 0)
     7772    {
     7773        if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCSVGPU9))
     7774        {
     7775            if (pvInterfaceFuncs)
     7776            {
     7777                VMSVGA3DBACKENDFUNCSVGPU9 *p = (VMSVGA3DBACKENDFUNCSVGPU9 *)pvInterfaceFuncs;
     7778                p->pfnContextDefine            = vmsvga3dBackContextDefine;
     7779                p->pfnContextDestroy           = vmsvga3dBackContextDestroy;
     7780                p->pfnSetTransform             = vmsvga3dBackSetTransform;
     7781                p->pfnSetZRange                = vmsvga3dBackSetZRange;
     7782                p->pfnSetRenderState           = vmsvga3dBackSetRenderState;
     7783                p->pfnSetRenderTarget          = vmsvga3dBackSetRenderTarget;
     7784                p->pfnSetTextureState          = vmsvga3dBackSetTextureState;
     7785                p->pfnSetMaterial              = vmsvga3dBackSetMaterial;
     7786                p->pfnSetLightData             = vmsvga3dBackSetLightData;
     7787                p->pfnSetLightEnabled          = vmsvga3dBackSetLightEnabled;
     7788                p->pfnSetViewPort              = vmsvga3dBackSetViewPort;
     7789                p->pfnSetClipPlane             = vmsvga3dBackSetClipPlane;
     7790                p->pfnCommandClear             = vmsvga3dBackCommandClear;
     7791                p->pfnDrawPrimitives           = vmsvga3dBackDrawPrimitives;
     7792                p->pfnSetScissorRect           = vmsvga3dBackSetScissorRect;
     7793                p->pfnGenerateMipmaps          = vmsvga3dBackGenerateMipmaps;
     7794                p->pfnShaderDefine             = vmsvga3dBackShaderDefine;
     7795                p->pfnShaderDestroy            = vmsvga3dBackShaderDestroy;
     7796                p->pfnShaderSet                = vmsvga3dBackShaderSet;
     7797                p->pfnShaderSetConst           = vmsvga3dBackShaderSetConst;
     7798                p->pfnOcclusionQueryCreate     = vmsvga3dBackOcclusionQueryCreate;
     7799                p->pfnOcclusionQueryDelete     = vmsvga3dBackOcclusionQueryDelete;
     7800                p->pfnOcclusionQueryBegin      = vmsvga3dBackOcclusionQueryBegin;
     7801                p->pfnOcclusionQueryEnd        = vmsvga3dBackOcclusionQueryEnd;
     7802                p->pfnOcclusionQueryGetData    = vmsvga3dBackOcclusionQueryGetData;
     7803            }
     7804        }
     7805        else
     7806        {
     7807            AssertFailed();
     7808            rc = VERR_INVALID_PARAMETER;
     7809        }
     7810    }
     7811    else
     7812        rc = VERR_NOT_IMPLEMENTED;
     7813    return rc;
     7814}

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

    r88787 r89121  
    233233    LogFlow(("vmsvga3dLoadExec:\n"));
    234234
    235 #ifndef RT_OS_DARWIN /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA.cpp */
    236     /* Must initialize now as the recreation calls below rely on an initialized 3d subsystem. */
    237     vmsvga3dPowerOn(pDevIns, pThis, pThisCC);
    238 #endif
    239 
    240235    /* Get the generic 3d state first. */
    241236    rc = pHlp->pfnSSMGetStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);
    … …  
    269264                if (pContext->id != VMSVGA3D_SHARED_CTX_ID)
    270265                {
     266                    /** @todo Separate backend */
    271267                    rc = vmsvga3dContextDefineOgl(pThisCC, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
    272268                    AssertRCReturn(rc, rc);
    … …  
    445441                    case VMSVGA3DQUERYSTATE_SIGNALED:
    446442                        /* Create the query object. */
    447                         vmsvga3dOcclusionQueryCreate(pState, pContext);
     443                        vmsvga3dQueryCreate(pThisCC, cid, SVGA3D_QUERYTYPE_OCCLUSION);
    448444
    449445                        /* Update result and state. */
    … …  
    584580static int vmsvga3dSaveContext(PCPDMDEVHLPR3 pHlp, PVGASTATECC pThisCC, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
    585581{
    586     PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    587582    uint32_t cid = pContext->id;
    588583
    … …  
    687682        }
    688683
    689         switch (pContext->occlusion.enmQueryState)
     684        /* Save the current query state, because code below can change it. */
     685        VMSVGA3DQUERYSTATE const enmQueryState = pContext->occlusion.enmQueryState;
     686        switch (enmQueryState)
    690687        {
    691688            case VMSVGA3DQUERYSTATE_BUILDING:
    692689                /* Stop collecting data. Fetch partial result. Save result. */
    693                 vmsvga3dOcclusionQueryEnd(pState, pContext);
     690                vmsvga3dQueryEnd(pThisCC, cid, SVGA3D_QUERYTYPE_OCCLUSION);
    694691                RT_FALL_THRU();
    695692            case VMSVGA3DQUERYSTATE_ISSUED:
    696693                /* Fetch result. Save result. */
    697694                pContext->occlusion.u32QueryResult = 0;
    698                 vmsvga3dOcclusionQueryGetData(pState, pContext, &pContext->occlusion.u32QueryResult);
     695                vmsvga3dQueryWait(pThisCC, cid, SVGA3D_QUERYTYPE_OCCLUSION, NULL, NULL);
    699696                RT_FALL_THRU();
    700697            case VMSVGA3DQUERYSTATE_SIGNALED:
    … …  
    710707                break;
    711708        }
     709
     710        /* Restore the current actual state. */
     711        pContext->occlusion.enmQueryState = enmQueryState;
    712712
    713713        rc = pHlp->pfnSSMPutStructEx(pSSM, &pContext->occlusion, sizeof(pContext->occlusion), 0, g_aVMSVGA3DQUERYFields, NULL);

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

    r88904 r89121  
    185185    DXDEVICE                   device;                 /* Device for the VMSVGA3D context independent operation. */
    186186} VMSVGA3DBACKEND;
     187
     188
     189static void vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface);
    187190
    188191
    … …  
    11631166
    11641167
    1165 static int vmsvga3dBackSurfaceCreateScreenTarget(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface)
    1166 {
    1167     PVMSVGA3DBACKEND pBackend = pState->pBackend;
     1168static int vmsvga3dBackSurfaceCreateScreenTarget(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
     1169{
     1170    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     1171    AssertReturn(p3dState, VERR_INVALID_STATE);
     1172
     1173    PVMSVGA3DBACKEND pBackend = p3dState->pBackend;
    11681174    AssertReturn(pBackend, VERR_INVALID_STATE);
    11691175
    … …  
    11771183    {
    11781184        AssertFailed(); /* Should the function not be used like that? */
    1179         vmsvga3dBackSurfaceDestroy(pState, pSurface);
     1185        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    11801186    }
    11811187
    … …  
    12771283
    12781284
    1279 static int vmsvga3dBackSurfaceCreateTexture(PVMSVGA3DSTATE p3dState, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
    1280 {
     1285static int vmsvga3dBackSurfaceCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
     1286{
     1287    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     1288    AssertReturn(p3dState, VERR_INVALID_STATE);
     1289
    12811290    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
    12821291    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
    … …  
    12851294    {
    12861295        AssertFailed(); /** @todo Should the function not be used like that? */
    1287         vmsvga3dBackSurfaceDestroy(p3dState, pSurface);
     1296        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    12881297    }
    12891298
    … …  
    14981507
    14991508
    1500 static int vmsvga3dBackSurfaceCreateDepthStencilTexture(PVMSVGA3DSTATE p3dState, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
     1509static int vmsvga3dBackSurfaceCreateDepthStencilTexture(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
    15011510{
    15021511    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
    … …  
    15061515    {
    15071516        AssertFailed(); /** @todo Should the function not be used like that? */
    1508         vmsvga3dBackSurfaceDestroy(p3dState, pSurface);
     1517        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    15091518    }
    15101519
    … …  
    15521561
    15531562
    1554 static int vmsvga3dBackSurfaceCreateBuffer(PVMSVGA3DSTATE p3dState, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
     1563static int vmsvga3dBackSurfaceCreateBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
    15551564{
    15561565    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
    … …  
    15691578    {
    15701579        AssertFailed(); /** @todo Should the function not be used like that? */
    1571         vmsvga3dBackSurfaceDestroy(p3dState, pSurface);
     1580        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    15721581    }
    15731582
    … …  
    16091618
    16101619
    1611 static int vmsvga3dBackSurfaceCreateConstantBuffer(PVMSVGA3DSTATE p3dState, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
     1620static int vmsvga3dBackSurfaceCreateConstantBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
    16121621{
    16131622    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
    … …  
    16201629    {
    16211630        AssertFailed(); /** @todo Should the function not be used like that? */
    1622         vmsvga3dBackSurfaceDestroy(p3dState, pSurface);
     1631        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    16231632    }
    16241633
    … …  
    16891698
    16901699
    1691 static int vmsvga3dBackSurfaceCreate(PVMSVGA3DSTATE p3dState, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
     1700static int vmsvga3dBackSurfaceCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
    16921701{
    16931702    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
    … …  
    16971706    {
    16981707        AssertFailed(); /** @todo Should the function not be used like that? */
    1699         vmsvga3dBackSurfaceDestroy(p3dState, pSurface);
     1708        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
    17001709    }
    17011710
    … …  
    17551764
    17561765
    1757 int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     1766static int vmsvga3dBackInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    17581767{
    17591768    RT_NOREF(pDevIns, pThis);
    … …  
    17871796
    17881797
    1789 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     1798static int vmsvga3dBackPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    17901799{
    17911800    RT_NOREF(pDevIns, pThis);
    … …  
    18021811
    18031812
    1804 int vmsvga3dTerminate(PVGASTATECC pThisCC)
     1813static int vmsvga3dBackTerminate(PVGASTATECC pThisCC)
    18051814{
    18061815    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    18191828
    18201829
    1821 int vmsvga3dReset(PVGASTATECC pThisCC)
     1830static int vmsvga3dBackReset(PVGASTATECC pThisCC)
    18221831{
    18231832    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    19661975
    19671976
    1968 int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     1977static int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    19691978{
    19701979    RT_NOREF(pThis, pThisCC, pScreen);
    … …  
    20102019
    20112020
    2012 int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     2021static int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    20132022{
    20142023    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    20282037
    20292038
    2030 int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
     2039static int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
    20312040                                    SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
    20322041                                    SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
    … …  
    21142123        AssertRCReturn(rc, rc);
    21152124
    2116         rc = vmsvga3dBackSurfaceCreate(pState, pDXContext, pSurface);
     2125        rc = vmsvga3dBackSurfaceCreate(pThisCC, pDXContext, pSurface);
    21172126        AssertRCReturn(rc, rc);
    21182127
    … …  
    23972406        {
    23982407            /* Create the actual texture. */
    2399             rc = vmsvga3dBackSurfaceCreateScreenTarget(pState, pSurface);
     2408            rc = vmsvga3dBackSurfaceCreateScreenTarget(pThisCC, pSurface);
    24002409            AssertRCReturn(rc, rc);
    24012410        }
    … …  
    24952504
    24962505
    2497 void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
    2498 {
    2499     RT_NOREF(pThisCC, idScreen, pOldViewport);
    2500     /** @todo Scroll the screen content without requiring the guest to redraw. */
    2501 }
    2502 
    2503 
    2504 int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
     2506/*
     2507 *
     2508 * 3D interface.
     2509 *
     2510 */
     2511
     2512static int vmsvga3dBackQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
    25052513{
    25062514    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    30603068
    30613069
    3062 /* Handle resize */
    3063 int vmsvga3dChangeMode(PVGASTATECC pThisCC)
     3070static int vmsvga3dBackChangeMode(PVGASTATECC pThisCC)
    30643071{
    30653072    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    30703077
    30713078
    3072 int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
    3073                         uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
     3079static int vmsvga3dBackSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
     3080                               uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
    30743081{
    30753082    RT_NOREF(dest, src, cCopyBoxes, pBox);
    … …  
    30823089}
    30833090
     3091
     3092static void vmsvga3dBackUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
     3093{
     3094    RT_NOREF(pThisCC, idScreen, pOldViewport);
     3095    /** @todo Scroll the screen content without requiring the guest to redraw. */
     3096}
    30843097
    30853098/**
    … …  
    30903103 * @param   cid             Context id
    30913104 */
    3092 int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
     3105static int vmsvga3dBackContextDefine(PVGASTATECC pThisCC, uint32_t cid)
    30933106{
    30943107    RT_NOREF(cid);
    … …  
    31093122 * @param   cid             Context id
    31103123 */
    3111 int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
     3124static int vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
    31123125{
    31133126    RT_NOREF(cid);
    … …  
    31213134
    31223135
    3123 int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
     3136static int vmsvga3dBackSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
    31243137{
    31253138    RT_NOREF(cid, type, matrix);
    … …  
    31333146
    31343147
    3135 int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
     3148static int vmsvga3dBackSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
    31363149{
    31373150    RT_NOREF(cid, zRange);
    … …  
    31453158
    31463159
    3147 int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
     3160static int vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
    31483161{
    31493162    RT_NOREF(cid, cRenderStates, pRenderState);
    … …  
    31573170
    31583171
    3159 int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
     3172static int vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
    31603173{
    31613174    RT_NOREF(cid, type, target);
    … …  
    31693182
    31703183
    3171 int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
     3184static int vmsvga3dBackSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
    31723185{
    31733186    RT_NOREF(cid, cTextureStates, pTextureState);
    … …  
    31813194
    31823195
    3183 int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
     3196static int vmsvga3dBackSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
    31843197{
    31853198    RT_NOREF(cid, face, pMaterial);
    … …  
    31933206
    31943207
    3195 int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
     3208static int vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
    31963209{
    31973210    RT_NOREF(cid, index, pData);
    … …  
    32053218
    32063219
    3207 int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
     3220static int vmsvga3dBackSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
    32083221{
    32093222    RT_NOREF(cid, index, enabled);
    … …  
    32173230
    32183231
    3219 int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     3232static int vmsvga3dBackSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    32203233{
    32213234    RT_NOREF(cid, pRect);
    … …  
    32293242
    32303243
    3231 int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
     3244static int vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
    32323245{
    32333246    RT_NOREF(cid, index, plane);
    … …  
    32413254
    32423255
    3243 int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
    3244                          uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
     3256static int vmsvga3dBackCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
     3257                                    uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
    32453258{
    32463259    /* From SVGA3D_BeginClear comments:
    … …  
    32623275
    32633276
    3264 int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
    3265                            uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
    3266                            uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
     3277static int vmsvga3dBackDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
     3278                                  uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
     3279                                  uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
    32673280{
    32683281    RT_NOREF(cid, numVertexDecls, pVertexDecl, numRanges, pRange, cVertexDivisor, pVertexDivisor);
    … …  
    32763289
    32773290
    3278 int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     3291static int vmsvga3dBackSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    32793292{
    32803293    RT_NOREF(cid, pRect);
    … …  
    32883301
    32893302
    3290 int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
     3303static int vmsvga3dBackGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
    32913304{
    32923305    RT_NOREF(sid, filter);
    … …  
    33003313
    33013314
    3302 int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
    3303                          uint32_t cbData, uint32_t *pShaderData)
     3315static int vmsvga3dBackShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
     3316                                uint32_t cbData, uint32_t *pShaderData)
    33043317{
    33053318    RT_NOREF(cid, shid, type, cbData, pShaderData);
    … …  
    33133326
    33143327
    3315 int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
     3328static int vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
    33163329{
    33173330    RT_NOREF(cid, shid, type);
    … …  
    33253338
    33263339
    3327 int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
     3340static int vmsvga3dBackShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
    33283341{
    33293342    RT_NOREF(pContext, cid, type, shid);
    … …  
    33373350
    33383351
    3339 int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
    3340                            SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
     3352static int vmsvga3dBackShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
     3353                                  SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
    33413354{
    33423355    RT_NOREF(cid, reg, type, ctype, cRegisters, pValues);
    … …  
    33563369 * @param   pSurface            The surface being destroyed.
    33573370 */
    3358 void vmsvga3dBackSurfaceDestroy(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface)
    3359 {
    3360     PVMSVGA3DBACKEND pBackend = pState->pBackend;
    3361     AssertReturnVoid(pBackend);
     3371static void vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
     3372{
     3373    RT_NOREF(pThisCC);
    33623374
    33633375    /* The caller should not use the function for system memory surfaces. */
    … …  
    34093421 * @param   pContext            The VMSVGA3d context (already current for OGL).
    34103422 */
    3411 int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
     3423static int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
    34123424                                  PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
    34133425                                  PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
    … …  
    34413453 * @param   iBox                The current box number (for Direct 3D).
    34423454 */
    3443 int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
     3455static int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
    34443456                                  PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
    34453457                                  SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
    … …  
    36143626 * @param   pSurface            The surface to create the texture for.
    36153627 */
    3616 int vmsvga3dBackCreateTexture(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
    3617                               PVMSVGA3DSURFACE pSurface)
    3618 
    3619 {
    3620     RT_NOREF(pState, pContext, idAssociatedContext, pSurface);
     3628static int vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
     3629                                     PVMSVGA3DSURFACE pSurface)
     3630
     3631{
     3632    RT_NOREF(pThisCC, pContext, idAssociatedContext, pSurface);
    36213633
    36223634    AssertFailed();
    … …  
    36253637
    36263638
    3627 int vmsvga3dOcclusionQueryCreate(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    3628 {
    3629     RT_NOREF(pState, pContext);
     3639static int vmsvga3dBackOcclusionQueryCreate(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     3640{
     3641    RT_NOREF(pThisCC, pContext);
    36303642    AssertFailed();
    36313643    return VINF_SUCCESS;
    … …  
    36333645
    36343646
    3635 int vmsvga3dOcclusionQueryBegin(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    3636 {
    3637     RT_NOREF(pState, pContext);
     3647static int vmsvga3dBackOcclusionQueryBegin(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     3648{
     3649    RT_NOREF(pThisCC, pContext);
    36383650    AssertFailed();
    36393651    return VINF_SUCCESS;
    … …  
    36413653
    36423654
    3643 int vmsvga3dOcclusionQueryEnd(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    3644 {
    3645     RT_NOREF(pState, pContext);
     3655static int vmsvga3dBackOcclusionQueryEnd(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     3656{
     3657    RT_NOREF(pThisCC, pContext);
    36463658    AssertFailed();
    36473659    return VINF_SUCCESS;
    … …  
    36493661
    36503662
    3651 int vmsvga3dOcclusionQueryGetData(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
    3652 {
    3653     RT_NOREF(pState, pContext);
     3663static int vmsvga3dBackOcclusionQueryGetData(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
     3664{
     3665    RT_NOREF(pThisCC, pContext);
    36543666    *pu32Pixels = 0;
    36553667    AssertFailed();
    … …  
    36583670
    36593671
    3660 int vmsvga3dOcclusionQueryDelete(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    3661 {
    3662     RT_NOREF(pState, pContext);
     3672static int vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     3673{
     3674    RT_NOREF(pThisCC, pContext);
    36633675    AssertFailed();
    36643676    return VINF_SUCCESS;
    … …  
    37523764    {
    37533765        /* Create the resource. */
    3754         rc = vmsvga3dBackSurfaceCreateConstantBuffer(pThisCC->svga.p3dState, pDXContext, pSurface);
     3766        rc = vmsvga3dBackSurfaceCreateConstantBuffer(pThisCC, pDXContext, pSurface);
    37553767        AssertRCReturn(rc, rc);
    37563768    }
    … …  
    40614073            {
    40624074                /* Create the resource. */
    4063                 rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC->svga.p3dState, pDXContext, pSurface);
     4075                rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC, pDXContext, pSurface);
    40644076                AssertRCReturn(rc, rc);
    40654077            }
    … …  
    41284140        {
    41294141            /* Create the resource. */
    4130             rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC->svga.p3dState, pDXContext, pSurface);
     4142            rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC, pDXContext, pSurface);
    41314143            AssertRCReturn(rc, rc);
    41324144        }
    … …  
    44844496    {
    44854497        /* Create the resource. */
    4486         rc = vmsvga3dBackSurfaceCreateTexture(pThisCC->svga.p3dState, pDXContext, pSrcSurface);
     4498        rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, pDXContext, pSrcSurface);
    44874499        AssertRCReturn(rc, rc);
    44884500    }
    … …  
    44914503    {
    44924504        /* Create the resource. */
    4493         rc = vmsvga3dBackSurfaceCreateTexture(pThisCC->svga.p3dState, pDXContext, pDstSurface);
     4505        rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, pDXContext, pDstSurface);
    44944506        AssertRCReturn(rc, rc);
    44954507    }
    … …  
    46824694    {
    46834695        /* Create the actual texture. */
    4684         rc = vmsvga3dBackSurfaceCreateTexture(pThisCC->svga.p3dState, pDXContext, pSurface);
     4696        rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, pDXContext, pSurface);
    46854697        AssertRCReturn(rc, rc);
    46864698    }
    … …  
    47194731    {
    47204732        /* Create the actual texture. */
    4721         rc = vmsvga3dBackSurfaceCreateTexture(pThisCC->svga.p3dState, pDXContext, pSurface);
     4733        rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, pDXContext, pSurface);
    47224734        AssertRCReturn(rc, rc);
    47234735    }
    … …  
    47564768    {
    47574769        /* Create the actual texture. */
    4758         rc = vmsvga3dBackSurfaceCreateDepthStencilTexture(pThisCC->svga.p3dState, pDXContext, pSurface);
     4770        rc = vmsvga3dBackSurfaceCreateDepthStencilTexture(pThisCC, pDXContext, pSurface);
    47594771        AssertRCReturn(rc, rc);
    47604772    }
    … …  
    57715783int vmsvga3dQueryInterface(PVGASTATECC pThisCC, char const *pszInterfaceName, void *pvInterfaceFuncs, size_t cbInterfaceFuncs)
    57725784{
    5773     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    5774     AssertReturn(p3dState, VERR_NOT_SUPPORTED);
    5775 
    5776     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    5777     AssertReturn(pBackend, VERR_NOT_SUPPORTED);
    5778 
    5779     if (pvInterfaceFuncs)
    5780         RT_BZERO(pvInterfaceFuncs, cbInterfaceFuncs);
     5785    RT_NOREF(pThisCC);
    57815786
    57825787    int rc = VINF_SUCCESS;
    … …  
    59515956        }
    59525957    }
     5958    else if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_3D) == 0)
     5959    {
     5960        if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCS3D))
     5961        {
     5962            if (pvInterfaceFuncs)
     5963            {
     5964                VMSVGA3DBACKENDFUNCS3D *p = (VMSVGA3DBACKENDFUNCS3D *)pvInterfaceFuncs;
     5965                p->pfnInit                     = vmsvga3dBackInit;
     5966                p->pfnPowerOn                  = vmsvga3dBackPowerOn;
     5967                p->pfnTerminate                = vmsvga3dBackTerminate;
     5968                p->pfnReset                    = vmsvga3dBackReset;
     5969                p->pfnQueryCaps                = vmsvga3dBackQueryCaps;
     5970                p->pfnChangeMode               = vmsvga3dBackChangeMode;
     5971                p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
     5972                p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
     5973                p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
     5974                p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;
     5975                p->pfnSurfaceStretchBlt        = vmsvga3dBackSurfaceStretchBlt;
     5976                p->pfnUpdateHostScreenViewport = vmsvga3dBackUpdateHostScreenViewport;
     5977                p->pfnDefineScreen             = vmsvga3dBackDefineScreen;
     5978                p->pfnDestroyScreen            = vmsvga3dBackDestroyScreen;
     5979                p->pfnSurfaceBlitToScreen      = vmsvga3dBackSurfaceBlitToScreen;
     5980            }
     5981        }
     5982        else
     5983        {
     5984            AssertFailed();
     5985            rc = VERR_INVALID_PARAMETER;
     5986        }
     5987    }
    59535988    else
    59545989        rc = VERR_NOT_IMPLEMENTED;

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

    r88787 r89121  
    159159*********************************************************************************************************************************/
    160160static void vmsvgaDumpD3DCaps(D3DCAPS9 *pCaps, D3DADAPTER_IDENTIFIER9 const *pai9);
    161 
    162 
    163 int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     161static int vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid);
     162static int vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState);
     163static int vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target);
     164static int vmsvga3dBackSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState);
     165static int vmsvga3dBackSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect);
     166static int vmsvga3dBackSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect);
     167static int vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
     168static int vmsvga3dBackShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid);
     169static int vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext);
     170static int vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface);
     171
     172
     173static int vmsvga3dBackInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    164174{
    165175    RT_NOREF(pDevIns, pThis);
    … …  
    188198}
    189199
    190 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
     200static int vmsvga3dBackPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
    191201{
    192202    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    277287}
    278288
    279 int vmsvga3dReset(PVGASTATECC pThisCC)
     289static int vmsvga3dBackReset(PVGASTATECC pThisCC)
    280290{
    281291    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    293303    {
    294304        if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
    295             vmsvga3dContextDestroy(pThisCC, pState->papContexts[i]->id);
     305            vmsvga3dBackContextDestroy(pThisCC, pState->papContexts[i]->id);
    296306    }
    297307    return VINF_SUCCESS;
    298308}
    299309
    300 int vmsvga3dTerminate(PVGASTATECC pThisCC)
     310static int vmsvga3dBackTerminate(PVGASTATECC pThisCC)
    301311{
    302312    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    303313    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
    304314
    305     int rc = vmsvga3dReset(pThisCC);
     315    int rc = vmsvga3dBackReset(pThisCC);
    306316    AssertRCReturn(rc, rc);
    307317
    … …  
    317327}
    318328
    319 void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
     329static void vmsvga3dBackUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
    320330{
    321331    /** @todo Scroll the screen content without requiring the guest to redraw. */
    … …  
    424434
    425435
    426 int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
     436static int vmsvga3dBackQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
    427437{
    428438    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    10971107 * Destroy backend specific surface bits (part of SVGA_3D_CMD_SURFACE_DESTROY).
    10981108 *
    1099  * @param   pState              The VMSVGA3d state.
     1109 * @param   pThisCC             The device state.
    11001110 * @param   pSurface            The surface being destroyed.
    11011111 */
    1102 void vmsvga3dBackSurfaceDestroy(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface)
    1103 {
    1104     RT_NOREF(pState);
     1112static void vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
     1113{
     1114    RT_NOREF(pThisCC);
    11051115
    11061116    RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
    … …  
    14781488}
    14791489
    1480 int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
    1481                         uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
     1490static int vmsvga3dBackSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
     1491                                   uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
    14821492{
    14831493    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    15181528
    15191529        LogFunc(("sid=%u type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
    1520         rc = vmsvga3dBackCreateTexture(pState, pContextSrc, cidSrc, pSurfaceDest);
     1530        rc = vmsvga3dBackCreateTexture(pThisCC, pContextSrc, cidSrc, pSurfaceDest);
    15211531        AssertRCReturn(rc, rc);
    15221532    }
    … …  
    18311841 * Surfaces are created when needed.
    18321842 *
    1833  * @param   pState              The VMSVGA3d state.
     1843 * @param   pThisCC             The device context.
    18341844 * @param   pContext            The context.
    18351845 * @param   idAssociatedContext Probably the same as pContext->id.
    18361846 * @param   pSurface            The surface to create the texture for.
    18371847 */
    1838 int vmsvga3dBackCreateTexture(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
     1848static int vmsvga3dBackCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
    18391849                              PVMSVGA3DSURFACE pSurface)
    18401850
    18411851{
    1842     RT_NOREF(pState);
     1852    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     1853    AssertReturn(pState, VERR_NO_MEMORY);
     1854
    18431855    HRESULT hr;
    18441856
    … …  
    22592271 * @param   pContext            The VMSVGA3d context (already current for OGL).
    22602272 */
    2261 int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
     2273static int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
    22622274                                  PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
    22632275                                  PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
    … …  
    23492361 * @param   iBox                The current box number (for Direct 3D).
    23502362 */
    2351 int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
     2363static int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
    23522364                                  PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
    23532365                                  SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
    … …  
    25132525}
    25142526
    2515 int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
     2527static int vmsvga3dBackGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
    25162528{
    25172529    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
    … …  
    25412553        /* Unknown surface type; turn it into a texture. */
    25422554        LogFunc(("unknown src surface sid=%u type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
    2543         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
     2555        rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
    25442556        AssertRCReturn(rc, rc);
    25452557    }
    … …  
    25672579 * @param   cid             Context id
    25682580 */
    2569 int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
     2581static int vmsvga3dBackContextDefine(PVGASTATECC pThisCC, uint32_t cid)
    25702582{
    25712583    int                     rc;
    … …  
    25962608    /* If one already exists with this id, then destroy it now. */
    25972609    if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
    2598         vmsvga3dContextDestroy(pThisCC, cid);
     2610        vmsvga3dBackContextDestroy(pThisCC, cid);
    25992611
    26002612    pContext = pState->papContexts[cid];
    … …  
    26742686 * @param   cid             Context id
    26752687 */
    2676 int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
     2688static int vmsvga3dBackContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
    26772689{
    26782690    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    27772789        {
    27782790            if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
    2779                 vmsvga3dShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
     2791                vmsvga3dBackShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
    27802792        }
    27812793        if (pContext->paPixelShader)
    … …  
    27862798        {
    27872799            if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
    2788                 vmsvga3dShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
     2800                vmsvga3dBackShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
    27892801        }
    27902802        if (pContext->paVertexShader)
    … …  
    27962808            RTMemFree(pContext->state.paPixelShaderConst);
    27972809
    2798         vmsvga3dOcclusionQueryDelete(pState, pContext);
     2810        vmsvga3dBackOcclusionQueryDelete(pThisCC, pContext);
    27992811
    28002812        /* Release the D3D device object */
    … …  
    28142826}
    28152827
    2816 int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     2828static int vmsvga3dBackDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    28172829{
    28182830    RT_NOREF(pThis, pThisCC, pScreen);
    … …  
    28202832}
    28212833
    2822 int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
     2834static int vmsvga3dBackDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    28232835{
    28242836    RT_NOREF(pThisCC, pScreen);
    … …  
    28262838}
    28272839
    2828 int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
     2840static int vmsvga3dBackSurfaceBlitToScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
    28292841                                    SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
    28302842                                    SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects)
    … …  
    28542866
    28552867/* Handle resize */
    2856 int vmsvga3dChangeMode(PVGASTATECC pThisCC)
     2868static int vmsvga3dBackChangeMode(PVGASTATECC pThisCC)
    28572869{
    28582870    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    … …  
    30503062                    target.face     = 0;
    30513063                    target.mipmap   = 0;
    3052                     int rc = vmsvga3dSetRenderTarget(pThisCC, cid, (SVGA3dRenderTargetType)j, target);
     3064                    int rc = vmsvga3dBackSetRenderTarget(pThisCC, cid, (SVGA3dRenderTargetType)j, target);
    30533065                    AssertRCReturn(rc, rc);
    30543066                }
    … …  
    30633075
    30643076                if (pRenderState->state != SVGA3D_RS_INVALID)
    3065                     vmsvga3dSetRenderState(pThisCC, pContext->id, 1, pRenderState);
     3077                    vmsvga3dBackSetRenderState(pThisCC, pContext->id, 1, pRenderState);
    30663078            }
    30673079            Log(("vmsvga3dChangeMode: Recreate render state END\n"));
    … …  
    30763088
    30773089                    if (pTextureState->name != SVGA3D_RS_INVALID)
    3078                         vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureState);
     3090                        vmsvga3dBackSetTextureState(pThisCC, pContext->id, 1, pTextureState);
    30793091                }
    30803092            }
    … …  
    30823094
    30833095            if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
    3084                 vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
     3096                vmsvga3dBackSetScissorRect(pThis, cid, &pContext->state.RectScissor);
    30853097            if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
    3086                 vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
     3098                vmsvga3dBackSetZRange(pThisCC, cid, pContext->state.zRange);
    30873099            if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
    3088                 vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
     3100                vmsvga3dBackSetViewPort(pThis, cid, &pContext->state.RectViewPort);
    30893101            if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)
    3090                 vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
     3102                vmsvga3dBackShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
    30913103            if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)
    3092                 vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
     3104                vmsvga3dBackShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
    30933105            /** @todo restore more state data */
    30943106#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
    … …  
    30993111
    31003112
    3101 int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
     3113static int vmsvga3dBackSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
    31023114{
    31033115    D3DTRANSFORMSTATETYPE d3dState;
    … …  
    31793191}
    31803192
    3181 int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
     3193static int vmsvga3dBackSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
    31823194{
    31833195    D3DVIEWPORT9          viewport;
    … …  
    32523264}
    32533265
    3254 int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
     3266static int vmsvga3dBackSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
    32553267{
    32563268    DWORD                       val = 0; /* Shut up MSC */
    … …  
    39193931}
    39203932
    3921 int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
     3933static int vmsvga3dBackSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
    39223934{
    39233935    HRESULT        hr;
    … …  
    40274039            {
    40284040                LogFunc(("Creating stencil surface as texture!\n"));
    4029                 int rc2 = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
     4041                int rc2 = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
    40304042                AssertRC(rc2);   /* non-fatal, will use CreateDepthStencilSurface */
    40314043            }
    … …  
    41414153            {
    41424154                LogFunc(("Create texture to be used as render target; sid=%u type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
    4143                 rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
     4155                rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
    41444156                AssertRCReturn(rc, rc);
    41454157            }
    … …  
    42074219        /* Changing the render target resets the viewport; restore it here. */
    42084220        if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
    4209             vmsvga3dSetViewPort(pThisCC, cid, &pContext->state.RectViewPort);
     4221            vmsvga3dBackSetViewPort(pThisCC, cid, &pContext->state.RectViewPort);
    42104222        if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
    4211             vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
     4223            vmsvga3dBackSetZRange(pThisCC, cid, pContext->state.zRange);
    42124224        /* Changing the render target also resets the scissor rectangle; restore it as well. */
    42134225        if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
    4214             vmsvga3dSetScissorRect(pThisCC, cid, &pContext->state.RectScissor);
     4226            vmsvga3dBackSetScissorRect(pThisCC, cid, &pContext->state.RectScissor);
    42154227
    42164228        break;
    … …  
    43454357}
    43464358
    4347 int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
     4359static int vmsvga3dBackSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
    43484360{
    43494361    DWORD                       val = 0; /* Shut up MSC */
    … …  
    43984410                    Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
    43994411                    LogFunc(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->paMipmapLevels[0].mipmapSize.width, pSurface->paMipmapLevels[0].mipmapSize.height, pSurface->cLevels, pSurface->fUsageD3D, pSurface->formatD3D));
    4400                     rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
     4412                    rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
    44014413                    AssertRCReturn(rc, rc);
    44024414                }
    … …  
    46384650}
    46394651
    4640 int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
     4652static int vmsvga3dBackSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
    46414653{
    46424654    HRESULT               hr;
    … …  
    46894701}
    46904702
    4691 int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
     4703static int vmsvga3dBackSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
    46924704{
    46934705    HRESULT               hr;
    … …  
    47604772}
    47614773
    4762 int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
     4774static int vmsvga3dBackSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
    47634775{
    47644776    HRESULT               hr;
    … …  
    47834795}
    47844796
    4785 int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     4797static int vmsvga3dBackSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    47864798{
    47874799    HRESULT               hr;
    … …  
    48164828}
    48174829
    4818 int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
     4830static int vmsvga3dBackSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
    48194831{
    48204832    HRESULT               hr;
    … …  
    48394851}
    48404852
    4841 int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
    4842                          uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
     4853static int vmsvga3dBackCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
     4854                                uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
    48434855{
    48444856    /* From SVGA3D_BeginClear comments:
    … …  
    51175129}
    51185130
    5119 int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
    5120                            uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
    5121                            uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
     5131static int vmsvga3dBackDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
     5132                                  uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
     5133                                  uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
    51225134{
    51235135    static const D3DVERTEXELEMENT9 sVertexEnd = D3DDECL_END();
    … …  
    54695481
    54705482
    5471 int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     5483static int vmsvga3dBackSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
    54725484{
    54735485    HRESULT               hr;
    … …  
    54995511
    55005512
    5501 int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
     5513static int vmsvga3dBackShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
    55025514                         uint32_t cbData, uint32_t *pShaderData)
    55035515{
    … …  
    55385550        /* If one already exists with this id, then destroy it now. */
    55395551        if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
    5540             vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
     5552            vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
    55415553
    55425554        pShader = &pContext->paVertexShader[shid];
    … …  
    55575569        /* If one already exists with this id, then destroy it now. */
    55585570        if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
    5559             vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
     5571            vmsvga3dBackShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
    55605572
    55615573        pShader = &pContext->paPixelShader[shid];
    … …  
    56085620}
    56095621
    5610 int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
     5622static int vmsvga3dBackShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
    56115623{
    56125624    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
    … …  
    56545666}
    56555667
    5656 int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
     5668static int vmsvga3dBackShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
    56575669{
    56585670    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
    … …  
    57225734}
    57235735
    5724 int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
    5725                            SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
     5736static int vmsvga3dBackShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
     5737                                  SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
    57265738{
    57275739    HRESULT               hr;
    … …  
    58165828}
    58175829
    5818 int vmsvga3dOcclusionQueryCreate(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    5819 {
    5820     RT_NOREF(pState);
     5830static int vmsvga3dBackOcclusionQueryCreate(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     5831{
     5832    RT_NOREF(pThisCC);
    58215833    HRESULT hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &pContext->occlusion.pQuery);
    58225834    AssertMsgReturn(hr == D3D_OK, ("CreateQuery(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr), VERR_INTERNAL_ERROR);
    … …  
    58245836}
    58255837
    5826 int vmsvga3dOcclusionQueryDelete(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    5827 {
    5828     RT_NOREF(pState);
     5838static int vmsvga3dBackOcclusionQueryDelete(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     5839{
     5840    RT_NOREF(pThisCC);
    58295841    D3D_RELEASE(pContext->occlusion.pQuery);
    58305842    return VINF_SUCCESS;
    58315843}
    58325844
    5833 int vmsvga3dOcclusionQueryBegin(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    5834 {
    5835     RT_NOREF(pState);
     5845static int vmsvga3dBackOcclusionQueryBegin(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     5846{
     5847    RT_NOREF(pThisCC);
    58365848    HRESULT hr = pContext->occlusion.pQuery->Issue(D3DISSUE_BEGIN);
    58375849    AssertMsgReturnStmt(hr == D3D_OK, ("D3DISSUE_BEGIN(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr),
    … …  
    58405852}
    58415853
    5842 int vmsvga3dOcclusionQueryEnd(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
    5843 {
    5844     RT_NOREF(pState);
     5854static int vmsvga3dBackOcclusionQueryEnd(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
     5855{
     5856    RT_NOREF(pThisCC);
    58455857    HRESULT hr = pContext->occlusion.pQuery->Issue(D3DISSUE_END);
    58465858    AssertMsgReturnStmt(hr == D3D_OK, ("D3DISSUE_END(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr),
    … …  
    58495861}
    58505862
    5851 int vmsvga3dOcclusionQueryGetData(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
    5852 {
    5853     RT_NOREF(pState);
     5863static int vmsvga3dBackOcclusionQueryGetData(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
     5864{
     5865    RT_NOREF(pThisCC);
    58545866    HRESULT hr = D3D_OK;
    58555867    /* Wait until the data becomes available. */
    … …  
    61746186int vmsvga3dQueryInterface(PVGASTATECC pThisCC, char const *pszInterfaceName, void *pvInterfaceFuncs, size_t cbInterfaceFuncs)
    61756187{
    6176     RT_NOREF(pThisCC, pszInterfaceName, pvInterfaceFuncs, cbInterfaceFuncs);
    6177     return VERR_NOT_IMPLEMENTED;
     6188    RT_NOREF(pThisCC);
     6189
     6190    int rc = VINF_SUCCESS;
     6191    if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_3D) == 0)
     6192    {
     6193        if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCS3D))
     6194        {
     6195            if (pvInterfaceFuncs)
     6196            {
     6197                VMSVGA3DBACKENDFUNCS3D *p = (VMSVGA3DBACKENDFUNCS3D *)pvInterfaceFuncs;
     6198                p->pfnInit                     = vmsvga3dBackInit;
     6199                p->pfnPowerOn                  = vmsvga3dBackPowerOn;
     6200                p->pfnTerminate                = vmsvga3dBackTerminate;
     6201                p->pfnReset                    = vmsvga3dBackReset;
     6202                p->pfnQueryCaps                = vmsvga3dBackQueryCaps;
     6203                p->pfnChangeMode               = vmsvga3dBackChangeMode;
     6204                p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
     6205                p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
     6206                p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
     6207                p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;
     6208                p->pfnSurfaceStretchBlt        = vmsvga3dBackSurfaceStretchBlt;
     6209                p->pfnUpdateHostScreenViewport = vmsvga3dBackUpdateHostScreenViewport;
     6210                p->pfnDefineScreen             = vmsvga3dBackDefineScreen;
     6211                p->pfnDestroyScreen            = vmsvga3dBackDestroyScreen;
     6212                p->pfnSurfaceBlitToScreen      = vmsvga3dBackSurfaceBlitToScreen;
     6213            }
     6214        }
     6215        else
     6216        {
     6217            AssertFailed();
     6218            rc = VERR_INVALID_PARAMETER;
     6219        }
     6220    }
     6221    else if (RTStrCmp(pszInterfaceName, VMSVGA3D_BACKEND_INTERFACE_NAME_VGPU9) == 0)
     6222    {
     6223        if (cbInterfaceFuncs == sizeof(VMSVGA3DBACKENDFUNCSVGPU9))
     6224        {
     6225            if (pvInterfaceFuncs)
     6226            {
     6227                VMSVGA3DBACKENDFUNCSVGPU9 *p = (VMSVGA3DBACKENDFUNCSVGPU9 *)pvInterfaceFuncs;
     6228                p->pfnContextDefine            = vmsvga3dBackContextDefine;
     6229                p->pfnContextDestroy           = vmsvga3dBackContextDestroy;
     6230                p->pfnSetTransform             = vmsvga3dBackSetTransform;
     6231                p->pfnSetZRange                = vmsvga3dBackSetZRange;
     6232                p->pfnSetRenderState           = vmsvga3dBackSetRenderState;
     6233                p->pfnSetRenderTarget          = vmsvga3dBackSetRenderTarget;
     6234                p->pfnSetTextureState          = vmsvga3dBackSetTextureState;
     6235                p->pfnSetMaterial              = vmsvga3dBackSetMaterial;
     6236                p->pfnSetLightData             = vmsvga3dBackSetLightData;
     6237                p->pfnSetLightEnabled          = vmsvga3dBackSetLightEnabled;
     6238                p->pfnSetViewPort              = vmsvga3dBackSetViewPort;
     6239                p->pfnSetClipPlane             = vmsvga3dBackSetClipPlane;
     6240                p->pfnCommandClear             = vmsvga3dBackCommandClear;
     6241                p->pfnDrawPrimitives           = vmsvga3dBackDrawPrimitives;
     6242                p->pfnSetScissorRect           = vmsvga3dBackSetScissorRect;
     6243                p->pfnGenerateMipmaps          = vmsvga3dBackGenerateMipmaps;
     6244                p->pfnShaderDefine             = vmsvga3dBackShaderDefine;
     6245                p->pfnShaderDestroy            = vmsvga3dBackShaderDestroy;
     6246                p->pfnShaderSet                = vmsvga3dBackShaderSet;
     6247                p->pfnShaderSetConst           = vmsvga3dBackShaderSetConst;
     6248                p->pfnOcclusionQueryCreate     = vmsvga3dBackOcclusionQueryCreate;
     6249                p->pfnOcclusionQueryDelete     = vmsvga3dBackOcclusionQueryDelete;
     6250                p->pfnOcclusionQueryBegin      = vmsvga3dBackOcclusionQueryBegin;
     6251                p->pfnOcclusionQueryEnd        = vmsvga3dBackOcclusionQueryEnd;
     6252                p->pfnOcclusionQueryGetData    = vmsvga3dBackOcclusionQueryGetData;
     6253            }
     6254        }
     6255        else
     6256        {
     6257            AssertFailed();
     6258            rc = VERR_INVALID_PARAMETER;
     6259        }
     6260    }
     6261    else
     6262        rc = VERR_NOT_IMPLEMENTED;
     6263    return rc;
    61786264}

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

    r88831 r89121  
    3939#define VMSVGA3D_INCL_STRUCTURE_DESCRIPTORS
    4040#include "DevVGA-SVGA3d-internal.h"
     41#include "DevVGA-SVGA-internal.h"
    4142
    4243
    … …  
    401402    }
    402403
    403     vmsvga3dBackSurfaceDestroy(pState, pSurface);
     404    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     405    if (pSvgaR3State->pFuncs3D)
     406        pSvgaR3State->pFuncs3D->pfnSurfaceDestroy(pThisCC, pSurface);
    404407
    405408    if (pSurface->paMipmapLevels)
    … …  
    452455    AssertReturn(pDstSfcImg->mipmap < pDstSurface->cLevels, VERR_INVALID_PARAMETER);
    453456
     457    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     458    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     459
    454460    PVMSVGA3DCONTEXT pContext;
    455461#ifdef VMSVGA3D_OPENGL
    … …  
    479485        /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
    480486        LogFunc(("unknown src sid=%u type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->surfaceFlags, pSrcSurface->format));
    481         rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSrcSurface);
     487        rc = pSvgaR3State->pFuncs3D->pfnCreateTexture(pThisCC, pContext, pContext->id, pSrcSurface);
    482488        AssertRCReturn(rc, rc);
    483489    }
    … …  
    487493        /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
    488494        LogFunc(("unknown dest sid=%u type=%d format=%d -> create texture\n", sidDst, pDstSurface->surfaceFlags, pDstSurface->format));
    489         rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pDstSurface);
     495        rc = pSvgaR3State->pFuncs3D->pfnCreateTexture(pThisCC, pContext, pContext->id, pDstSurface);
    490496        AssertRCReturn(rc, rc);
    491497    }
    … …  
    504510    vmsvgaR3ClipBox(&pDstMipmapLevel->mipmapSize, &clipDstBox);
    505511
    506     return vmsvga3dBackSurfaceStretchBlt(pThis, pState,
     512    return pSvgaR3State->pFuncs3D->pfnSurfaceStretchBlt(pThis, pState,
    507513                                         pDstSurface, pDstSfcImg->face, pDstSfcImg->mipmap, &clipDstBox,
    508514                                         pSrcSurface, pSrcSfcImg->face, pSrcSfcImg->mipmap, &clipSrcBox,
    … …  
    540546    rc = vmsvga3dMipmapLevel(pSurface, host.face, host.mipmap, &pMipLevel);
    541547    AssertRCReturn(rc, rc);
     548
     549    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     550    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
    542551
    543552    PVMSVGA3DCONTEXT pContext = NULL;
    … …  
    708717            clipBox.srcy = srcy;
    709718            clipBox.srcz = srcz;
    710             rc = vmsvga3dBackSurfaceDMACopyBox(pThis, pThisCC, pState, pSurface, pMipLevel, host.face, host.mipmap,
     719            rc = pSvgaR3State->pFuncs3D->pfnSurfaceDMACopyBox(pThis, pThisCC, pState, pSurface, pMipLevel, host.face, host.mipmap,
    711720                                               guest.ptr, cbGuestPitch, transfer,
    712721                                               &clipBox, pContext, rc, i);
    … …  
    724733}
    725734
    726 static int vmsvga3dQueryWriteResult(PVGASTATE pThis, PVGASTATECC pThisCC, SVGAGuestPtr guestResult,
     735static int vmsvga3dQueryWriteResult(PVGASTATE pThis, PVGASTATECC pThisCC, SVGAGuestPtr const *pGuestResult,
    727736                                    SVGA3dQueryState enmState, uint32_t u32Result)
    728737{
    … …  
    734743    int rc = vmsvgaR3GmrTransfer(pThis, pThisCC, SVGA3D_READ_HOST_VRAM,
    735744                                 (uint8_t *)&queryResult, sizeof(queryResult), 0, sizeof(queryResult),
    736                                  guestResult, 0, sizeof(queryResult), sizeof(queryResult), 1);
     745                                 *pGuestResult, 0, sizeof(queryResult), sizeof(queryResult), 1);
    737746    AssertRC(rc);
    738747    return rc;
    739748}
    740749
    741 int vmsvga3dQueryBegin(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type)
    742 {
     750/* Used with saved state. */
     751int vmsvga3dQueryCreate(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type)
     752{
     753    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     754    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     755
    743756    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    744757    AssertReturn(pState, VERR_NO_MEMORY);
    … …  
    755768        if (!VMSVGA3DQUERY_EXISTS(p))
    756769        {
    757             /* Lazy creation of the query object. */
    758             rc = vmsvga3dOcclusionQueryCreate(pState, pContext);
     770            rc = pSvgaR3State->pFuncsVGPU9->pfnOcclusionQueryCreate(pThisCC, pContext);
    759771            AssertRCReturn(rc, rc);
    760772        }
    761 
    762         rc = vmsvga3dOcclusionQueryBegin(pState, pContext);
    763         AssertRCReturn(rc, rc);
    764 
    765         p->enmQueryState = VMSVGA3DQUERYSTATE_BUILDING;
    766         p->u32QueryResult = 0;
    767773
    768774        return VINF_SUCCESS;
    … …  
    773779}
    774780
    775 int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
    776 {
    777     RT_NOREF(guestResult);
     781int vmsvga3dQueryBegin(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type)
     782{
     783    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     784    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     785
    778786    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    779787    AssertReturn(pState, VERR_NO_MEMORY);
    780788
    781     LogFunc(("cid=%u type=%d guestResult %d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
     789    LogFunc(("cid=%u type=%d\n", cid, type));
    782790
    783791    PVMSVGA3DCONTEXT pContext;
    … …  
    788796    {
    789797        VMSVGA3DQUERY *p = &pContext->occlusion;
     798        if (!VMSVGA3DQUERY_EXISTS(p))
     799        {
     800            /* Lazy creation of the query object. */
     801            rc = pSvgaR3State->pFuncsVGPU9->pfnOcclusionQueryCreate(pThisCC, pContext);
     802            AssertRCReturn(rc, rc);
     803        }
     804
     805        rc = pSvgaR3State->pFuncsVGPU9->pfnOcclusionQueryBegin(pThisCC, pContext);
     806        AssertRCReturn(rc, rc);
     807
     808        p->enmQueryState = VMSVGA3DQUERYSTATE_BUILDING;
     809        p->u32QueryResult = 0;
     810
     811        return VINF_SUCCESS;
     812    }
     813
     814    /* Nothing else for VGPU9. */
     815    AssertFailedReturn(VERR_NOT_IMPLEMENTED);
     816}
     817
     818int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type)
     819{
     820    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     821    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     822
     823    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     824    AssertReturn(pState, VERR_NO_MEMORY);
     825
     826    LogFunc(("cid=%u type=%d\n", cid, type));
     827
     828    PVMSVGA3DCONTEXT pContext;
     829    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
     830    AssertRCReturn(rc, rc);
     831
     832    if (type == SVGA3D_QUERYTYPE_OCCLUSION)
     833    {
     834        VMSVGA3DQUERY *p = &pContext->occlusion;
    790835        Assert(p->enmQueryState == VMSVGA3DQUERYSTATE_BUILDING);
    791836        AssertMsgReturn(VMSVGA3DQUERY_EXISTS(p), ("Query is NULL\n"), VERR_INTERNAL_ERROR);
    792837
    793         rc = vmsvga3dOcclusionQueryEnd(pState, pContext);
     838        rc = pSvgaR3State->pFuncsVGPU9->pfnOcclusionQueryEnd(pThisCC, pContext);
    794839        AssertRCReturn(rc, rc);
    795840
    796841        p->enmQueryState = VMSVGA3DQUERYSTATE_ISSUED;
    797 
    798         /* Do not touch guestResult, because the guest will call WaitForQuery. */
    799842        return VINF_SUCCESS;
    800843    }
    … …  
    804847}
    805848
    806 int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
    807 {
     849int vmsvga3dQueryWait(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, PVGASTATE pThis, SVGAGuestPtr const *pGuestResult)
     850{
     851    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     852    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     853
    808854    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
    809855    AssertReturn(pState, VERR_NO_MEMORY);
    810856
    811     LogFunc(("cid=%u type=%d guestResult GMR%d:0x%x\n", cid, type, guestResult.gmrId, guestResult.offset));
     857    LogFunc(("cid=%u type=%d guestResult GMR%d:0x%x\n", cid, type, pGuestResult->gmrId, pGuestResult->offset));
    812858
    813859    PVMSVGA3DCONTEXT pContext;
    … …  
    826872                 */
    827873                uint32_t u32Pixels = 0;
    828                 rc = vmsvga3dOcclusionQueryGetData(pState, pContext, &u32Pixels);
     874                rc = pSvgaR3State->pFuncsVGPU9->pfnOcclusionQueryGetData(pThisCC, pContext, &u32Pixels);
    829875                if (RT_SUCCESS(rc))
    830876                {
    … …  
    836882            if (RT_SUCCESS(rc))
    837883            {
    838                 /* Return data to the guest. */
    839                 vmsvga3dQueryWriteResult(pThis, pThisCC, guestResult, SVGA3D_QUERYSTATE_SUCCEEDED, p->u32QueryResult);
     884                /* pGuestResult can be NULL when saving the state. */
     885                if (pGuestResult)
     886                {
     887                    /* Return data to the guest. */
     888                    vmsvga3dQueryWriteResult(pThis, pThisCC, pGuestResult, SVGA3D_QUERYSTATE_SUCCEEDED, p->u32QueryResult);
     889                }
    840890                return VINF_SUCCESS;
    841891            }
    … …  
    853903    }
    854904
    855     vmsvga3dQueryWriteResult(pThis, pThisCC, guestResult, SVGA3D_QUERYSTATE_FAILED, 0);
     905    if (pGuestResult)
     906        vmsvga3dQueryWriteResult(pThis, pThisCC, pGuestResult, SVGA3D_QUERYSTATE_FAILED, 0);
    856907    AssertFailedReturn(rc);
    857908}
    … …  
    881932    {
    882933        /* Use the backend accelerated method, if available. */
    883         int rc = vmsvga3dBackSurfaceBlitToScreen(pThisCC, pScreen,
    884                                                  destRect, src, srcRect, cRects, pRect);
    885         if (rc == VINF_SUCCESS)
    886         {
    887             return VINF_SUCCESS;
     934        PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     935        if (pSvgaR3State->pFuncs3D)
     936        {
     937            int rc = pSvgaR3State->pFuncs3D->pfnSurfaceBlitToScreen(pThisCC, pScreen, destRect, src, srcRect, cRects, pRect);
     938            if (rc == VINF_SUCCESS)
     939            {
     940                return VINF_SUCCESS;
     941            }
    888942        }
    889943    }
    … …  
    10231077int vmsvga3dDefineScreen(PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    10241078{
     1079    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1080    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     1081
    10251082    if (pScreen->pHwScreen)
    10261083    {
    1027         vmsvga3dBackDestroyScreen(pThisCC, pScreen);
    1028     }
    1029 
    1030     int rc = vmsvga3dBackDefineScreen(pThis, pThisCC, pScreen);
     1084        pSvgaR3State->pFuncs3D->pfnDestroyScreen(pThisCC, pScreen);
     1085    }
     1086
     1087    int rc = pSvgaR3State->pFuncs3D->pfnDefineScreen(pThis, pThisCC, pScreen);
    10311088    if (RT_SUCCESS(rc))
    10321089    {
    … …  
    10381095int vmsvga3dDestroyScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen)
    10391096{
    1040     return vmsvga3dBackDestroyScreen(pThisCC, pScreen);
     1097    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1098    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     1099
     1100    return pSvgaR3State->pFuncs3D->pfnDestroyScreen(pThisCC, pScreen);
    10411101}
    10421102
    … …  
    10701130    return rc;
    10711131}
     1132
     1133
     1134/*
     1135 *
     1136 * 3D
     1137 *
     1138 */
     1139
     1140int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val)
     1141{
     1142    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1143    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     1144    return pSvgaR3State->pFuncs3D->pfnQueryCaps(pThisCC, idx3dCaps, pu32Val);
     1145}
     1146
     1147int vmsvga3dChangeMode(PVGASTATECC pThisCC)
     1148{
     1149    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1150    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     1151    return pSvgaR3State->pFuncs3D->pfnChangeMode(pThisCC);
     1152}
     1153
     1154int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
     1155{
     1156    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1157    AssertReturn(pSvgaR3State->pFuncs3D, VERR_NOT_IMPLEMENTED);
     1158    return pSvgaR3State->pFuncs3D->pfnSurfaceCopy(pThisCC, dest, src, cCopyBoxes, pBox);
     1159}
     1160
     1161void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
     1162{
     1163    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1164    AssertReturnVoid(pSvgaR3State->pFuncs3D);
     1165    pSvgaR3State->pFuncs3D->pfnUpdateHostScreenViewport(pThisCC, idScreen, pOldViewport);
     1166}
     1167
     1168
     1169/*
     1170 *
     1171 * VGPU9
     1172 *
     1173 */
     1174
     1175int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
     1176{
     1177    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1178    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1179    return pSvgaR3State->pFuncsVGPU9->pfnContextDefine(pThisCC, cid);
     1180}
     1181
     1182int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
     1183{
     1184    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1185    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1186    return pSvgaR3State->pFuncsVGPU9->pfnContextDestroy(pThisCC, cid);
     1187}
     1188
     1189int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
     1190{
     1191    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1192    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1193    return pSvgaR3State->pFuncsVGPU9->pfnSetTransform(pThisCC, cid, type, matrix);
     1194}
     1195
     1196int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
     1197{
     1198    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1199    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1200    return pSvgaR3State->pFuncsVGPU9->pfnSetZRange(pThisCC, cid, zRange);
     1201}
     1202
     1203int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
     1204{
     1205    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1206    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1207    return pSvgaR3State->pFuncsVGPU9->pfnSetRenderState(pThisCC, cid, cRenderStates, pRenderState);
     1208}
     1209
     1210int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
     1211{
     1212    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1213    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1214    return pSvgaR3State->pFuncsVGPU9->pfnSetRenderTarget(pThisCC, cid, type, target);
     1215}
     1216
     1217int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
     1218{
     1219    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1220    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1221    return pSvgaR3State->pFuncsVGPU9->pfnSetTextureState(pThisCC, cid, cTextureStates, pTextureState);
     1222}
     1223
     1224int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
     1225{
     1226    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1227    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1228    return pSvgaR3State->pFuncsVGPU9->pfnSetMaterial(pThisCC, cid, face, pMaterial);
     1229}
     1230
     1231int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
     1232{
     1233    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1234    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1235    return pSvgaR3State->pFuncsVGPU9->pfnSetLightData(pThisCC, cid, index, pData);
     1236}
     1237
     1238int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
     1239{
     1240    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1241    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1242    return pSvgaR3State->pFuncsVGPU9->pfnSetLightEnabled(pThisCC, cid, index, enabled);
     1243}
     1244
     1245int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     1246{
     1247    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1248    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1249    return pSvgaR3State->pFuncsVGPU9->pfnSetViewPort(pThisCC, cid, pRect);
     1250}
     1251
     1252int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4])
     1253{
     1254    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1255    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1256    return pSvgaR3State->pFuncsVGPU9->pfnSetClipPlane(pThisCC, cid, index, plane);
     1257}
     1258
     1259int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
     1260{
     1261    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1262    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1263    return pSvgaR3State->pFuncsVGPU9->pfnCommandClear(pThisCC, cid, clearFlag, color, depth, stencil, cRects, pRect);
     1264}
     1265
     1266int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pNumRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
     1267{
     1268    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1269    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1270    return pSvgaR3State->pFuncsVGPU9->pfnDrawPrimitives(pThisCC, cid, numVertexDecls, pVertexDecl, numRanges, pNumRange, cVertexDivisor, pVertexDivisor);
     1271}
     1272
     1273int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
     1274{
     1275    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1276    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1277    return pSvgaR3State->pFuncsVGPU9->pfnSetScissorRect(pThisCC, cid, pRect);
     1278}
     1279
     1280int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
     1281{
     1282    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1283    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1284    return pSvgaR3State->pFuncsVGPU9->pfnGenerateMipmaps(pThisCC, sid, filter);
     1285}
     1286
     1287int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
     1288{
     1289    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1290    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1291    return pSvgaR3State->pFuncsVGPU9->pfnShaderDefine(pThisCC, cid, shid, type, cbData, pShaderData);
     1292}
     1293
     1294int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
     1295{
     1296    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1297    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1298    return pSvgaR3State->pFuncsVGPU9->pfnShaderDestroy(pThisCC, cid, shid, type);
     1299}
     1300
     1301int vmsvga3dShaderSet(PVGASTATECC pThisCC, struct VMSVGA3DCONTEXT *pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
     1302{
     1303    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1304    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1305    return pSvgaR3State->pFuncsVGPU9->pfnShaderSet(pThisCC, pContext, cid, type, shid);
     1306}
     1307
     1308int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
     1309{
     1310    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     1311    AssertReturn(pSvgaR3State->pFuncsVGPU9, VERR_NOT_IMPLEMENTED);
     1312    return pSvgaR3State->pFuncsVGPU9->pfnShaderSetConst(pThisCC, cid, reg, type, ctype, cRegisters, pValues);
     1313}
     1314

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

    r88904 r89121  
    7171
    7272/* DevVGA-SVGA3d-ogl.cpp & DevVGA-SVGA3d-win.cpp: */
    73 int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
    74 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
    7573int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    7674int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATECC pThisCC, PSSMHANDLE pSSM);
    77 int vmsvga3dTerminate(PVGASTATECC pThisCC);
    78 int vmsvga3dReset(PVGASTATECC pThisCC);
    7975void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport);
    8076int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val);
    … …  
    121117int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues);
    122118
     119int vmsvga3dQueryCreate(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type);
    123120int vmsvga3dQueryBegin(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type);
    124 int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
    125 int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
     121int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type);
     122int vmsvga3dQueryWait(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, PVGASTATE pThis, SVGAGuestPtr const *pGuestResult);
    126123
    127124int vmsvga3dSurfaceInvalidate(PVGASTATECC pThisCC, uint32_t sid, uint32_t face, uint32_t mipmap);
    … …  
    264261
    265262
     263/*
     264 * Backend interfaces.
     265 */
     266typedef struct VMSVGA3DSURFACE *PVMSVGA3DSURFACE;
     267typedef struct VMSVGA3DMIPMAPLEVEL *PVMSVGA3DMIPMAPLEVEL;
     268typedef struct VMSVGA3DCONTEXT *PVMSVGA3DCONTEXT;
     269
     270/* Essential 3D backend function. */
     271#define VMSVGA3D_BACKEND_INTERFACE_NAME_3D "3D"
     272typedef struct
     273{
     274    DECLCALLBACKMEMBER(int,  pfnInit,                     (PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC));
     275    DECLCALLBACKMEMBER(int,  pfnPowerOn,                  (PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC));
     276    DECLCALLBACKMEMBER(int,  pfnTerminate,                (PVGASTATECC pThisCC));
     277    DECLCALLBACKMEMBER(int,  pfnReset,                    (PVGASTATECC pThisCC));
     278    DECLCALLBACKMEMBER(int,  pfnQueryCaps,                (PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val));
     279    DECLCALLBACKMEMBER(int,  pfnChangeMode,               (PVGASTATECC pThisCC));
     280    DECLCALLBACKMEMBER(int,  pfnCreateTexture,            (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface));
     281    DECLCALLBACKMEMBER(void, pfnSurfaceDestroy,           (PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface));
     282    DECLCALLBACKMEMBER(int,  pfnSurfaceCopy,              (PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox));
     283    DECLCALLBACKMEMBER(int,  pfnSurfaceDMACopyBox,        (PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
     284                                                           PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
     285                                                           SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
     286                                                           SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox));
     287    DECLCALLBACKMEMBER(int,  pfnSurfaceStretchBlt,        (PVGASTATE pThis, PVMSVGA3DSTATE pState,
     288                                                           PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
     289                                                           PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
     290                                                           SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext));
     291    DECLCALLBACKMEMBER(void, pfnUpdateHostScreenViewport, (PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport));
     292    /** @todo HW accelerated screen output probably needs a separate interface. */
     293    DECLCALLBACKMEMBER(int,  pfnDefineScreen,             (PVGASTATE pThis, PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen));
     294    DECLCALLBACKMEMBER(int,  pfnDestroyScreen,            (PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen));
     295    DECLCALLBACKMEMBER(int,  pfnSurfaceBlitToScreen,      (PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen,
     296                                                           SVGASignedRect destRect, SVGA3dSurfaceImageId srcImage,
     297                                                           SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *paRects));
     298} VMSVGA3DBACKENDFUNCS3D;
     299
     300/* VGPU9 3D */
     301#define VMSVGA3D_BACKEND_INTERFACE_NAME_VGPU9 "VGPU9"
     302typedef struct
     303{
     304    DECLCALLBACKMEMBER(int,  pfnContextDefine,            (PVGASTATECC pThisCC, uint32_t cid));
     305    DECLCALLBACKMEMBER(int,  pfnContextDestroy,           (PVGASTATECC pThisCC, uint32_t cid));
     306    DECLCALLBACKMEMBER(int,  pfnSetTransform,             (PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16]));
     307    DECLCALLBACKMEMBER(int,  pfnSetZRange,                (PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange));
     308    DECLCALLBACKMEMBER(int,  pfnSetRenderState,           (PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState));
     309    DECLCALLBACKMEMBER(int,  pfnSetRenderTarget,          (PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target));
     310    DECLCALLBACKMEMBER(int,  pfnSetTextureState,          (PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState));
     311    DECLCALLBACKMEMBER(int,  pfnSetMaterial,              (PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial));
     312    DECLCALLBACKMEMBER(int,  pfnSetLightData,             (PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData));
     313    DECLCALLBACKMEMBER(int,  pfnSetLightEnabled,          (PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled));
     314    DECLCALLBACKMEMBER(int,  pfnSetViewPort,              (PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect));
     315    DECLCALLBACKMEMBER(int,  pfnSetClipPlane,             (PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4]));
     316    DECLCALLBACKMEMBER(int,  pfnCommandClear,             (PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect));
     317    DECLCALLBACKMEMBER(int,  pfnDrawPrimitives,           (PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pNumRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor));
     318    DECLCALLBACKMEMBER(int,  pfnSetScissorRect,           (PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect));
     319    DECLCALLBACKMEMBER(int,  pfnGenerateMipmaps,          (PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter));
     320    DECLCALLBACKMEMBER(int,  pfnShaderDefine,             (PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData));
     321    DECLCALLBACKMEMBER(int,  pfnShaderDestroy,            (PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type));
     322    DECLCALLBACKMEMBER(int,  pfnShaderSet,                (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid));
     323    DECLCALLBACKMEMBER(int,  pfnShaderSetConst,           (PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues));
     324    DECLCALLBACKMEMBER(int,  pfnOcclusionQueryCreate,     (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext));
     325    DECLCALLBACKMEMBER(int,  pfnOcclusionQueryDelete,     (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext));
     326    DECLCALLBACKMEMBER(int,  pfnOcclusionQueryBegin,      (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext));
     327    DECLCALLBACKMEMBER(int,  pfnOcclusionQueryEnd,        (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext));
     328    DECLCALLBACKMEMBER(int,  pfnOcclusionQueryGetData,    (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels));
     329} VMSVGA3DBACKENDFUNCSVGPU9;
     330
     331/* Support for Guest-Backed Objects. */
    266332#define VMSVGA3D_BACKEND_INTERFACE_NAME_GBO "GBO"
    267333typedef struct
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