VirtualBox

Changeset 99535 in vbox


Ignore:
Timestamp:
Apr 26, 2023 4:52:49 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
157044
Message:

Devices/Graphics: SVGA_REG_CAP2; SET_*_CONSTANT_BUFFER_OFFSET; fixes for shader parser. bugref:9830

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

Legend:

Unmodified
Added
Removed

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

    r98103 r99535  
    34373437{
    34383438#ifdef VMSVGA3D_DX
    3439     DEBUG_BREAKPOINT_TEST();
    3440     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3441     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3442     return vmsvga3dDXSetVSConstantBufferOffset(pThisCC, idDXContext);
     3439    //DEBUG_BREAKPOINT_TEST();
     3440    RT_NOREF(cbCmd);
     3441    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_VS);
    34433442#else
    34443443    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    34523451{
    34533452#ifdef VMSVGA3D_DX
    3454     DEBUG_BREAKPOINT_TEST();
    3455     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3456     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3457     return vmsvga3dDXSetPSConstantBufferOffset(pThisCC, idDXContext);
     3453    //DEBUG_BREAKPOINT_TEST();
     3454    RT_NOREF(cbCmd);
     3455    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_PS);
    34583456#else
    34593457    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    34673465{
    34683466#ifdef VMSVGA3D_DX
    3469     DEBUG_BREAKPOINT_TEST();
    3470     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3471     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3472     return vmsvga3dDXSetGSConstantBufferOffset(pThisCC, idDXContext);
     3467    //DEBUG_BREAKPOINT_TEST();
     3468    RT_NOREF(cbCmd);
     3469    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_GS);
    34733470#else
    34743471    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    34823479{
    34833480#ifdef VMSVGA3D_DX
    3484     DEBUG_BREAKPOINT_TEST();
    3485     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3486     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3487     return vmsvga3dDXSetHSConstantBufferOffset(pThisCC, idDXContext);
     3481    //DEBUG_BREAKPOINT_TEST();
     3482    RT_NOREF(cbCmd);
     3483    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_HS);
    34883484#else
    34893485    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    34973493{
    34983494#ifdef VMSVGA3D_DX
    3499     DEBUG_BREAKPOINT_TEST();
    3500     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3501     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3502     return vmsvga3dDXSetDSConstantBufferOffset(pThisCC, idDXContext);
     3495    //DEBUG_BREAKPOINT_TEST();
     3496    RT_NOREF(cbCmd);
     3497    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_DS);
    35033498#else
    35043499    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    35123507{
    35133508#ifdef VMSVGA3D_DX
    3514     DEBUG_BREAKPOINT_TEST();
    3515     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    3516     RT_NOREF(pSvgaR3State, pCmd, cbCmd);
    3517     return vmsvga3dDXSetCSConstantBufferOffset(pThisCC, idDXContext);
     3509    //DEBUG_BREAKPOINT_TEST();
     3510    RT_NOREF(cbCmd);
     3511    return vmsvga3dDXSetConstantBufferOffset(pThisCC, idDXContext, pCmd, SVGA3D_SHADERTYPE_CS);
    35183512#else
    35193513    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
    … …  
    36023596{
    36033597#ifdef VMSVGA3D_DX
    3604     DEBUG_BREAKPOINT_TEST();
     3598    //DEBUG_BREAKPOINT_TEST();
    36053599    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    36063600

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

    r99521 r99535  
    398398    SSMFIELD_ENTRY(                 VMSVGAState, u32CurrentGMRId),
    399399    SSMFIELD_ENTRY(                 VMSVGAState, u32DeviceCaps),
     400    SSMFIELD_ENTRY_VER(             VMSVGAState, u32DeviceCaps2, VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2),
     401    SSMFIELD_ENTRY_VER(             VMSVGAState, u32GuestDriverId, VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2),
     402    SSMFIELD_ENTRY_VER(             VMSVGAState, u32GuestDriverVer1, VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2),
     403    SSMFIELD_ENTRY_VER(             VMSVGAState, u32GuestDriverVer2, VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2),
     404    SSMFIELD_ENTRY_VER(             VMSVGAState, u32GuestDriverVer3, VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2),
    400405    SSMFIELD_ENTRY(                 VMSVGAState, u32IndexReg),
    401406    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, hFIFORequestSem),
    … …  
    15201525            break;
    15211526
     1527        case SVGA_REG_BLANK_SCREEN_TARGETS:
     1528            /// @todo STAM_REL_COUNTER_INC(&pThis->svga.aStatRegRd[idxReg]);
     1529            *pu32 = 0; /* Not supported. */
     1530            break;
     1531
     1532        case SVGA_REG_CAP2:
     1533            *pu32 = pThis->svga.u32DeviceCaps2;
     1534            break;
     1535
     1536        case SVGA_REG_DEVEL_CAP:
     1537            *pu32 = 0; /* Not supported. */
     1538            break;
     1539
     1540        /*
     1541         * SVGA_REG_GUEST_DRIVER_* registers require SVGA_CAP2_DX2.
     1542         */
     1543        case SVGA_REG_GUEST_DRIVER_ID:
     1544            *pu32 = pThis->svga.u32GuestDriverId;
     1545            break;
     1546
     1547        case SVGA_REG_GUEST_DRIVER_VERSION1:
     1548            *pu32 = pThis->svga.u32GuestDriverVer1;
     1549            break;
     1550
     1551        case SVGA_REG_GUEST_DRIVER_VERSION2:
     1552            *pu32 = pThis->svga.u32GuestDriverVer2;
     1553            break;
     1554
     1555        case SVGA_REG_GUEST_DRIVER_VERSION3:
     1556            *pu32 = pThis->svga.u32GuestDriverVer3;
     1557            break;
     1558
     1559        /*
     1560         * SVGA_REG_CURSOR_ registers require SVGA_CAP2_CURSOR_MOB which the device does not support currently.
     1561         */
     1562        case SVGA_REG_CURSOR_MOBID:
     1563            *pu32 = SVGA_ID_INVALID;
     1564            break;
     1565
     1566        case SVGA_REG_CURSOR_MAX_BYTE_SIZE:
     1567            *pu32 = 0;
     1568            break;
     1569
     1570        case SVGA_REG_CURSOR_MAX_DIMENSION:
     1571            *pu32 = 0;
     1572            break;
     1573
     1574        case SVGA_REG_FIFO_CAPS:
     1575        case SVGA_REG_FENCE: /* Same as SVGA_FIFO_FENCE for PCI_ID_SVGA3. Our device is PCI_ID_SVGA2 so not supported. */
     1576        case SVGA_REG_RESERVED1: /* SVGA_REG_RESERVED* correspond to SVGA_REG_CURSOR4_*. Require SVGA_CAP2_EXTRA_REGS. */
     1577        case SVGA_REG_RESERVED2:
     1578        case SVGA_REG_RESERVED3:
     1579        case SVGA_REG_RESERVED4:
     1580        case SVGA_REG_RESERVED5:
     1581        case SVGA_REG_SCREENDMA:
     1582            *pu32 = 0; /* Not supported. */
     1583            break;
     1584
     1585        case SVGA_REG_GBOBJECT_MEM_SIZE_KB:
     1586            /** @todo "The maximum amount of guest-backed objects that the device can have resident at a time" */
     1587            *pu32 = _1G / _1K;
     1588            break;
     1589
    15221590        default:
    15231591        {
    … …  
    22592327            STAM_REL_COUNTER_INC(&pThis->svga.StatRegCmdPrependHighWr);
    22602328            /* Not supported. */
     2329            break;
     2330
     2331        case SVGA_REG_GUEST_DRIVER_ID:
     2332            if (u32 != SVGA_REG_GUEST_DRIVER_ID_SUBMIT)
     2333                pThis->svga.u32GuestDriverId = u32;
     2334            break;
     2335
     2336        case SVGA_REG_GUEST_DRIVER_VERSION1:
     2337            pThis->svga.u32GuestDriverVer1 = u32;
     2338            break;
     2339
     2340        case SVGA_REG_GUEST_DRIVER_VERSION2:
     2341            pThis->svga.u32GuestDriverVer2 = u32;
     2342            break;
     2343
     2344        case SVGA_REG_GUEST_DRIVER_VERSION3:
     2345            pThis->svga.u32GuestDriverVer3 = u32;
     2346            break;
     2347
     2348        case SVGA_REG_CURSOR_MOBID:
     2349            /* Not supported, ignore. See correspondent comments in vmsvgaReadPort. */
    22612350            break;
    22622351
    … …  
    22862375        case SVGA_REG_SCREENTARGET_MAX_HEIGHT:
    22872376        case SVGA_REG_MOB_MAX_SIZE:
     2377        case SVGA_REG_BLANK_SCREEN_TARGETS:
     2378        case SVGA_REG_CAP2:
     2379        case SVGA_REG_DEVEL_CAP:
     2380        case SVGA_REG_CURSOR_MAX_BYTE_SIZE:
     2381        case SVGA_REG_CURSOR_MAX_DIMENSION:
     2382        case SVGA_REG_FIFO_CAPS:
     2383        case SVGA_REG_FENCE:
     2384        case SVGA_REG_RESERVED1:
     2385        case SVGA_REG_RESERVED2:
     2386        case SVGA_REG_RESERVED3:
     2387        case SVGA_REG_RESERVED4:
     2388        case SVGA_REG_RESERVED5:
     2389        case SVGA_REG_SCREENDMA:
     2390        case SVGA_REG_GBOBJECT_MEM_SIZE_KB:
    22882391            /* Read only - ignore. */
    22892392            Log(("Write to R/O register %x - val %x ignored\n", idxReg, u32));
    … …  
    54115514    pHlp->pfnPrintf(pHlp, "Current GMR ID:     %#x\n", pThis->svga.u32CurrentGMRId);
    54125515    pHlp->pfnPrintf(pHlp, "Device Capabilites: %#x\n", pThis->svga.u32DeviceCaps);
     5516    pHlp->pfnPrintf(pHlp, "Device Cap2:        %#x\n", pThis->svga.u32DeviceCaps2);
     5517    pHlp->pfnPrintf(pHlp, "Guest driver id:    %#x\n", pThis->svga.u32GuestDriverId);
     5518    pHlp->pfnPrintf(pHlp, "Guest driver ver1:  %#x\n", pThis->svga.u32GuestDriverVer1);
     5519    pHlp->pfnPrintf(pHlp, "Guest driver ver2:  %#x\n", pThis->svga.u32GuestDriverVer2);
     5520    pHlp->pfnPrintf(pHlp, "Guest driver ver3:  %#x\n", pThis->svga.u32GuestDriverVer3);
    54135521    pHlp->pfnPrintf(pHlp, "Index reg:          %#x\n", pThis->svga.u32IndexReg);
    54145522    pHlp->pfnPrintf(pHlp, "Action flags:       %#x\n", pThis->svga.u32ActionFlags);
    … …  
    63066414 * @param   pThisCC   The VGA/VMSVGA state for ring-3.
    63076415 * @param   pu32DeviceCaps Device capabilities (SVGA_CAP_*).
     6416 * @param   pu32DeviceCaps2 Device capabilities (SVGA_CAP2_*).
    63086417 * @param   pu32FIFOCaps FIFO capabilities (SVGA_FIFO_CAPS_*).
    63096418 */
    6310 static void vmsvgaR3GetCaps(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t *pu32DeviceCaps, uint32_t *pu32FIFOCaps)
     6419static void vmsvgaR3GetCaps(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t *pu32DeviceCaps, uint32_t *pu32DeviceCaps2, uint32_t *pu32FIFOCaps)
    63116420{
    63126421#ifndef VBOX_WITH_VMSVGA3D
    … …  
    63296438
    63306439    *pu32DeviceCaps |= SVGA_CAP_COMMAND_BUFFERS   /* Enable register based command buffer submission. */
    6331 //                  |  SVGA_CAP_CMD_BUFFERS_2     /* Support for SVGA_REG_CMD_PREPEND_LOW/HIGH */
    63326440                    ;
     6441
     6442    *pu32DeviceCaps2 = SVGA_CAP2_NONE;
    63336443
    63346444    /* VGPU10 capabilities. */
    … …  
    63396449           *pu32DeviceCaps |= SVGA_CAP_GBOBJECTS; /* Enable guest-backed objects and surfaces. */
    63406450        if (pThisCC->svga.pSvgaR3State->pFuncsDX)
    6341            *pu32DeviceCaps |= SVGA_CAP_DX;        /* Enable support for DX commands, and command buffers in a mob. */
     6451        {
     6452           *pu32DeviceCaps |= SVGA_CAP_DX                 /* DX commands, and command buffers in a mob. */
     6453                           |  SVGA_CAP_CAP2_REGISTER      /* Extended capabilities. */
     6454                           ;
     6455
     6456           if (*pu32DeviceCaps & SVGA_CAP_CAP2_REGISTER)
     6457               *pu32DeviceCaps2 |= SVGA_CAP2_GROW_OTABLE  /* "Allow the GrowOTable/DXGrowCOTable commands" */
     6458                                |  SVGA_CAP2_DX2          /* Shader Model 4.1.
     6459                                                           * "Allow the DefineGBSurface_v3, WholeSurfaceCopy, WriteZeroSurface, and
     6460                                                           * HintZeroSurface commands, and the SVGA_REG_GUEST_DRIVER_ID register."
     6461                                                           */
     6462                                |  SVGA_CAP2_GB_MEMSIZE_2 /* "Allow the SVGA_REG_GBOBJECT_MEM_SIZE_KB register" */
     6463                                |  SVGA_CAP2_OTABLE_PTDEPTH_2
     6464                                |  SVGA_CAP2_DX3          /* Shader Model 5.
     6465                                                           * DefineGBSurface_v4, etc
     6466                                                           */
     6467                                ;
     6468        }
    63426469# endif
    63436470    }
    … …  
    64856612
    64866613    /* Initialize FIFO and register capabilities. */
    6487     vmsvgaR3GetCaps(pThis, pThisCC, &pThis->svga.u32DeviceCaps, &pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES]);
     6614    vmsvgaR3GetCaps(pThis, pThisCC, &pThis->svga.u32DeviceCaps, &pThis->svga.u32DeviceCaps2, &pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES]);
    64886615
    64896616# ifdef VBOX_WITH_VMSVGA3D
    … …  
    69277054    {
    69287055        vmsvgaR3InitFIFO(pThis, pThisCC);
    6929         vmsvgaR3GetCaps(pThis, pThisCC, &pThis->svga.u32DeviceCaps, &pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES]);
     7056        vmsvgaR3GetCaps(pThis, pThisCC, &pThis->svga.u32DeviceCaps, &pThis->svga.u32DeviceCaps2, &pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES]);
    69307057    }
    69317058# ifdef DEBUG
    … …  
    69347061        /* If saved state is being loaded then FIFO and caps are already restored. */
    69357062        uint32_t u32DeviceCaps = 0;
     7063        uint32_t u32DeviceCaps2 = 0;
    69367064        uint32_t u32FIFOCaps = 0;
    6937         vmsvgaR3GetCaps(pThis, pThisCC, &u32DeviceCaps, &u32FIFOCaps);
     7065        vmsvgaR3GetCaps(pThis, pThisCC, &u32DeviceCaps, &u32DeviceCaps2, &u32FIFOCaps);
    69387066
    69397067        /* Capabilities should not change normally. */
    69407068        Assert(   pThis->svga.u32DeviceCaps == u32DeviceCaps
     7069               && pThis->svga.u32DeviceCaps2 == u32DeviceCaps2
    69417070               && pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES] == u32FIFOCaps);
    69427071    }

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

    r98103 r99535  
    331331    /** SVGA device capabilities. */
    332332    uint32_t                    u32DeviceCaps;
    333     uint32_t                    Padding0; /* Used to be I/O port base address. */
     333    uint32_t                    u32DeviceCaps2; /* Used to be I/O port base address and Padding0. */
     334    /** Guest driver information (SVGA_REG_GUEST_DRIVER_*). */
     335    uint32_t                    u32GuestDriverId;
     336    uint32_t                    u32GuestDriverVer1;
     337    uint32_t                    u32GuestDriverVer2;
     338    uint32_t                    u32GuestDriverVer3;
    334339    /** Port io index register. */
    335340    uint32_t                    u32IndexReg;

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

    r99521 r99535  
    46414641
    46424642    case SVGA3D_DEVCAP_SM41:
    4643         *pu32Val = 0; /* boolean */
     4643        *pu32Val = 1; /* boolean */
    46444644        break;
    46454645
    … …  
    46724672
    46734673    case SVGA3D_DEVCAP_SM5:
    4674         *pu32Val = 0; /* boolean */
     4674        *pu32Val = 1; /* boolean */
    46754675        break;
    46764676
    … …  
    94489448
    94499449static DECLCALLBACK(int) vmsvga3dBackDXBufferUpdate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9450 {
    9451     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9452 
    9453     RT_NOREF(pBackend, pDXContext);
    9454     AssertFailed(); /** @todo Implement */
    9455     return VERR_NOT_IMPLEMENTED;
    9456 }
    9457 
    9458 
    9459 static DECLCALLBACK(int) vmsvga3dBackDXSetVSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9460 {
    9461     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9462 
    9463     RT_NOREF(pBackend, pDXContext);
    9464     AssertFailed(); /** @todo Implement */
    9465     return VERR_NOT_IMPLEMENTED;
    9466 }
    9467 
    9468 
    9469 static DECLCALLBACK(int) vmsvga3dBackDXSetPSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9470 {
    9471     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9472 
    9473     RT_NOREF(pBackend, pDXContext);
    9474     AssertFailed(); /** @todo Implement */
    9475     return VERR_NOT_IMPLEMENTED;
    9476 }
    9477 
    9478 
    9479 static DECLCALLBACK(int) vmsvga3dBackDXSetGSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9480 {
    9481     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9482 
    9483     RT_NOREF(pBackend, pDXContext);
    9484     AssertFailed(); /** @todo Implement */
    9485     return VERR_NOT_IMPLEMENTED;
    9486 }
    9487 
    9488 
    9489 static DECLCALLBACK(int) vmsvga3dBackDXSetHSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9490 {
    9491     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9492 
    9493     RT_NOREF(pBackend, pDXContext);
    9494     AssertFailed(); /** @todo Implement */
    9495     return VERR_NOT_IMPLEMENTED;
    9496 }
    9497 
    9498 
    9499 static DECLCALLBACK(int) vmsvga3dBackDXSetDSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    9500 {
    9501     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    9502 
    9503     RT_NOREF(pBackend, pDXContext);
    9504     AssertFailed(); /** @todo Implement */
    9505     return VERR_NOT_IMPLEMENTED;
    9506 }
    9507 
    9508 
    9509 static DECLCALLBACK(int) vmsvga3dBackDXSetCSConstantBufferOffset(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
    95109450{
    95119451    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
    … …  
    1024410184                p->pfnDXHint                      = vmsvga3dBackDXHint;
    1024510185                p->pfnDXBufferUpdate              = vmsvga3dBackDXBufferUpdate;
    10246                 p->pfnDXSetVSConstantBufferOffset = vmsvga3dBackDXSetVSConstantBufferOffset;
    10247                 p->pfnDXSetPSConstantBufferOffset = vmsvga3dBackDXSetPSConstantBufferOffset;
    10248                 p->pfnDXSetGSConstantBufferOffset = vmsvga3dBackDXSetGSConstantBufferOffset;
    10249                 p->pfnDXSetHSConstantBufferOffset = vmsvga3dBackDXSetHSConstantBufferOffset;
    10250                 p->pfnDXSetDSConstantBufferOffset = vmsvga3dBackDXSetDSConstantBufferOffset;
    10251                 p->pfnDXSetCSConstantBufferOffset = vmsvga3dBackDXSetCSConstantBufferOffset;
    1025210186                p->pfnDXCondBindAllShader         = vmsvga3dBackDXCondBindAllShader;
    1025310187                p->pfnScreenCopy                  = vmsvga3dBackScreenCopy;

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

    r98103 r99535  
    17831783                /* Integer divide. */
    17841784                pOpcode->cOperand = 4; /* dstQuit, dstRem, src0, src1. */
    1785 
    1786                 /* Operands. */
    1787                 uint32_t cOperandRemain = RT_ELEMENTS(pOpcode->aValOperand);
    1788                 for (uint32_t i = 0; i < pOpcode->cOperand; ++i)
    1789                 {
    1790                     Log6(("  [operand %d]\n", i));
    1791                     uint32_t const idxOperand = RT_ELEMENTS(pOpcode->aValOperand) - cOperandRemain;
    1792                     pOpcode->aIdxOperand[i] = idxOperand;
    1793                     int rc = dxbcParseOperand(r, &pOpcode->aValOperand[idxOperand], &cOperandRemain);
    1794                     ASSERT_GUEST_RETURN(RT_SUCCESS(rc), VERR_INVALID_PARAMETER);
    1795                 }
    1796             }
    1797             //else if (opcode.vmwareOpcodeType == VGPU10_VMWARE_OPCODE_DFRC)
    1798             //else if (opcode.vmwareOpcodeType == VGPU10_VMWARE_OPCODE_DRSQ)
     1785            }
     1786            else if (opcode.vmwareOpcodeType == VGPU10_VMWARE_OPCODE_DFRC)
     1787            {
     1788                /* Double precision fraction. */
     1789                pOpcode->cOperand = 2; /* dst, src. */
     1790            }
     1791            else if (opcode.vmwareOpcodeType == VGPU10_VMWARE_OPCODE_DRSQ)
     1792            {
     1793                /* Double precision reciprocal square root. */
     1794                pOpcode->cOperand = 2; /* dst, src. */
     1795            }
    17991796            else
    18001797            {
    1801                 /** @todo implement */
    18021798                ASSERT_GUEST_FAILED_RETURN(VERR_INVALID_PARAMETER);
     1799            }
     1800
     1801            /* Operands. */
     1802            uint32_t cOperandRemain = RT_ELEMENTS(pOpcode->aValOperand);
     1803            for (uint32_t i = 0; i < pOpcode->cOperand; ++i)
     1804            {
     1805                Log6(("  [operand %d]\n", i));
     1806                uint32_t const idxOperand = RT_ELEMENTS(pOpcode->aValOperand) - cOperandRemain;
     1807                pOpcode->aIdxOperand[i] = idxOperand;
     1808                int rc = dxbcParseOperand(r, &pOpcode->aValOperand[idxOperand], &cOperandRemain);
     1809                ASSERT_GUEST_RETURN(RT_SUCCESS(rc), VERR_INVALID_PARAMETER);
    18031810            }
    18041811        }
    … …  
    18321839
    18331840
    1834 static int dxbcEmitVmwareIDIV(DXBCOUTPUTCTX *pOutctx, DXBCByteWriter *w, VGPUOpcode *pOpcode)
    1835 {
    1836     /* Insert a call and append a subroutne. */
     1841static void dxbcEmitCall(DXBCByteWriter *w, VGPUOpcode const *pOpcode, uint32_t label)
     1842{
    18371843    VGPU10OpcodeToken0 opcode;
    18381844    VGPU10OperandToken0 operand;
    18391845
    1840     uint32_t const label = (pOutctx->offSubroutine - dxbcByteWriterSize(w)) / 4;
    1841 
    1842     /*
    1843      * Call
    1844      */
    18451846    opcode.value = 0;
    18461847    opcode.opcodeType = VGPU10_OPCODE_CALL;
    … …  
    18621863    for (unsigned i = 0; i < pOpcode->cOpcodeToken - 3; ++i)
    18631864        dxbcByteWriterAddTokens(w, &opcode.value, 1);
    1864 
    1865     /*
    1866      * Subroutine.
    1867      */
    1868     DXBCByteWriterState savedWriterState;
    1869     if (!dxbcByteWriterSetOffset(w, pOutctx->offSubroutine, &savedWriterState))
    1870         return w->rc;
    1871 
    1872     /* label */
     1865}
     1866
     1867
     1868static void dxbcEmitLabel(DXBCByteWriter *w, uint32_t label)
     1869{
     1870    VGPU10OpcodeToken0 opcode;
     1871    VGPU10OperandToken0 operand;
     1872
    18731873    opcode.value = 0;
    18741874    opcode.opcodeType = VGPU10_OPCODE_LABEL;
    … …  
    18831883    dxbcByteWriterAddTokens(w, &operand.value, 1);
    18841884    dxbcByteWriterAddTokens(w, &label, 1);
     1885}
     1886
     1887
     1888static void dxbcEmitRet(DXBCByteWriter *w)
     1889{
     1890    VGPU10OpcodeToken0 opcode;
     1891
     1892    opcode.value = 0;
     1893    opcode.opcodeType = VGPU10_OPCODE_RET;
     1894    opcode.instructionLength = 1;
     1895    dxbcByteWriterAddTokens(w, &opcode.value, 1);
     1896}
     1897
     1898
     1899static int dxbcEmitVmwareIDIV(DXBCOUTPUTCTX *pOutctx, DXBCByteWriter *w, VGPUOpcode *pOpcode)
     1900{
     1901    /* Insert a call and append a subroutne. */
     1902    VGPU10OpcodeToken0 opcode;
     1903
     1904    uint32_t const label = (pOutctx->offSubroutine - dxbcByteWriterSize(w)) / 4;
     1905
     1906    dxbcEmitCall(w, pOpcode, label);
     1907
     1908    /*
     1909     * Subroutine.
     1910     */
     1911    DXBCByteWriterState savedWriterState;
     1912    if (!dxbcByteWriterSetOffset(w, pOutctx->offSubroutine, &savedWriterState))
     1913        return w->rc;
     1914
     1915    dxbcEmitLabel(w, label);
    18851916
    18861917    /* Just output UDIV for now. */
    … …  
    18911922    dxbcByteWriterAddTokens(w, &pOpcode->paOpcodeToken[1], pOpcode->cOpcodeToken - 1);
    18921923
    1893     /* ret */
     1924    dxbcEmitRet(w);
     1925
     1926    pOutctx->offSubroutine = dxbcByteWriterSize(w);
     1927    dxbcByteWriterRestore(w, &savedWriterState);
     1928
     1929    return w->rc;
     1930}
     1931
     1932
     1933static int dxbcEmitVmwareDFRC(DXBCOUTPUTCTX *pOutctx, DXBCByteWriter *w, VGPUOpcode *pOpcode)
     1934{
     1935    /* Insert a call and append a subroutine. */
     1936    VGPU10OpcodeToken0 opcode;
     1937
     1938    uint32_t const label = (pOutctx->offSubroutine - dxbcByteWriterSize(w)) / 4;
     1939
     1940    dxbcEmitCall(w, pOpcode, label);
     1941
     1942    /*
     1943     * Subroutine.
     1944     */
     1945    DXBCByteWriterState savedWriterState;
     1946    if (!dxbcByteWriterSetOffset(w, pOutctx->offSubroutine, &savedWriterState))
     1947        return w->rc;
     1948
     1949    dxbcEmitLabel(w, label);
     1950
     1951    /* Just output a MOV for now. */
    18941952    opcode.value = 0;
    1895     opcode.opcodeType = VGPU10_OPCODE_RET;
    1896     opcode.instructionLength = 1;
     1953    opcode.opcodeType = VGPU10_OPCODE_MOV;
     1954    opcode.instructionLength = pOpcode->cOpcodeToken;
    18971955    dxbcByteWriterAddTokens(w, &opcode.value, 1);
     1956    dxbcByteWriterAddTokens(w, &pOpcode->paOpcodeToken[1], pOpcode->cOpcodeToken - 1);
     1957
     1958    dxbcEmitRet(w);
     1959
     1960    pOutctx->offSubroutine = dxbcByteWriterSize(w);
     1961    dxbcByteWriterRestore(w, &savedWriterState);
     1962
     1963    return w->rc;
     1964}
     1965
     1966
     1967static int dxbcEmitVmwareDRSQ(DXBCOUTPUTCTX *pOutctx, DXBCByteWriter *w, VGPUOpcode *pOpcode)
     1968{
     1969    /* Insert a call and append a subroutine. */
     1970    VGPU10OpcodeToken0 opcode;
     1971
     1972    uint32_t const label = (pOutctx->offSubroutine - dxbcByteWriterSize(w)) / 4;
     1973
     1974    dxbcEmitCall(w, pOpcode, label);
     1975
     1976    /*
     1977     * Subroutine.
     1978     */
     1979    DXBCByteWriterState savedWriterState;
     1980    if (!dxbcByteWriterSetOffset(w, pOutctx->offSubroutine, &savedWriterState))
     1981        return w->rc;
     1982
     1983    dxbcEmitLabel(w, label);
     1984
     1985    /* Just output a MOV for now. */
     1986    opcode.value = 0;
     1987    opcode.opcodeType = VGPU10_OPCODE_MOV;
     1988    opcode.instructionLength = pOpcode->cOpcodeToken;
     1989    dxbcByteWriterAddTokens(w, &opcode.value, 1);
     1990    dxbcByteWriterAddTokens(w, &pOpcode->paOpcodeToken[1], pOpcode->cOpcodeToken - 1);
     1991
     1992    dxbcEmitRet(w);
    18981993
    18991994    pOutctx->offSubroutine = dxbcByteWriterSize(w);
    … …  
    19342029    {
    19352030        if (pOpcode->opcodeSubtype == VGPU10_VMWARE_OPCODE_IDIV)
    1936         {
    19372031            return dxbcEmitVmwareIDIV(pOutctx, w, pOpcode);
    1938         }
     2032        if (pOpcode->opcodeSubtype == VGPU10_VMWARE_OPCODE_DFRC)
     2033            return dxbcEmitVmwareDFRC(pOutctx, w, pOpcode);
     2034        if (pOpcode->opcodeSubtype == VGPU10_VMWARE_OPCODE_DRSQ)
     2035            return dxbcEmitVmwareDRSQ(pOutctx, w, pOpcode);
    19392036
    19402037        ASSERT_GUEST_FAILED_RETURN(VERR_NOT_SUPPORTED);
    … …  
    22062303}
    22072304
     2305
    22082306void DXShaderGenerateSemantics(DXShaderInfo *pInfo)
    22092307{
    … …  
    22212319                              pInfo->aPatchConstantSemantic, DXBC_BLOB_TYPE_PCSG);
    22222320}
     2321
     2322
     2323void DXShaderSortSignatures(DXShaderInfo *pInfo)
     2324{
     2325    /* Sort signatures by register index and mask because the host API need them to be sorted. */
     2326    if (pInfo->cInputSignature)
     2327    {
     2328        RTSortShell(pInfo->aInputSignature, pInfo->cInputSignature, sizeof(pInfo->aInputSignature[0]),
     2329                    signatureEntryCmp, NULL);
     2330    }
     2331    if (pInfo->cOutputSignature)
     2332    {
     2333        RTSortShell(pInfo->aOutputSignature, pInfo->cOutputSignature, sizeof(pInfo->aOutputSignature[0]),
     2334                    signatureEntryCmp, NULL);
     2335    }
     2336    if (pInfo->cPatchConstantSignature)
     2337    {
     2338        RTSortShell(pInfo->aPatchConstantSignature, pInfo->cPatchConstantSignature, sizeof(pInfo->aPatchConstantSignature[0]),
     2339                    signatureEntryCmp, NULL);
     2340    }
     2341}
     2342
    22232343
    22242344void DXShaderFree(DXShaderInfo *pInfo)
    … …  
    23722492    pHdrISGN->offElement = RT_UOFFSETOF(DXBCBlobIOSGN, aElement[0]);
    23732493
     2494#ifdef DEBUG
     2495    /* Check that signatures are sorted by register index because the host API need them to be sorted. */
     2496    uint32_t idxRegisterLast = 0;
     2497#endif
     2498
    23742499    for (uint32_t iSignatureEntry = 0; iSignatureEntry < cSignature; ++iSignatureEntry)
    23752500    {
    … …  
    23982523              iSignatureEntry, srcSemantic->pcszSemanticName, dst->idxSemantic,
    23992524              dst->enmSystemValue, dst->enmComponentType, dst->idxRegister, dst->u.mask));
     2525
     2526#ifdef DEBUG
     2527        Assert(idxRegisterLast <= dst->idxRegister);
     2528        idxRegisterLast = dst->idxRegister;
     2529#endif
    24002530
    24012531        if (dst->offElementName == 0)

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

    r98103 r99535  
    7777int DXShaderParse(void const *pvCode, uint32_t cbCode, DXShaderInfo *pInfo);
    7878void DXShaderGenerateSemantics(DXShaderInfo *pInfo);
     79void DXShaderSortSignatures(DXShaderInfo *pInfo);
    7980void DXShaderFree(DXShaderInfo *pInfo);
    8081int DXShaderUpdateResources(DXShaderInfo const *pInfo, VGPU10_RESOURCE_DIMENSION *paResourceDimension,

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

    r98908 r99535  
    19901990                memcpy(pShaderInfo->aPatchConstantSignature, pu8Signatures, pSignatureHeader->numPatchConstantSignatures * sizeof(SVGA3dDXSignatureEntry));
    19911991
     1992                /* Sort must be called before GenerateSemantics which assigns attribute indices
     1993                 * based on the order of attributes.
     1994                 */
     1995                DXShaderSortSignatures(pShaderInfo);
    19921996                DXShaderGenerateSemantics(pShaderInfo);
    19931997            }
    … …  
    24812485
    24822486
    2483 int vmsvga3dDXSetVSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2484 {
    2485     int rc;
    2486     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2487     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetVSConstantBufferOffset, VERR_INVALID_STATE);
    2488     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2489     AssertReturn(p3dState, VERR_INVALID_STATE);
    2490 
    2491     PVMSVGA3DDXCONTEXT pDXContext;
    2492     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2493     AssertRCReturn(rc, rc);
    2494 
    2495     rc = pSvgaR3State->pFuncsDX->pfnDXSetVSConstantBufferOffset(pThisCC, pDXContext);
    2496     return rc;
    2497 }
    2498 
    2499 
    2500 int vmsvga3dDXSetPSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2501 {
    2502     int rc;
    2503     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2504     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetPSConstantBufferOffset, VERR_INVALID_STATE);
    2505     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2506     AssertReturn(p3dState, VERR_INVALID_STATE);
    2507 
    2508     PVMSVGA3DDXCONTEXT pDXContext;
    2509     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2510     AssertRCReturn(rc, rc);
    2511 
    2512     rc = pSvgaR3State->pFuncsDX->pfnDXSetPSConstantBufferOffset(pThisCC, pDXContext);
    2513     return rc;
    2514 }
    2515 
    2516 
    2517 int vmsvga3dDXSetGSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2518 {
    2519     int rc;
    2520     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2521     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetGSConstantBufferOffset, VERR_INVALID_STATE);
    2522     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2523     AssertReturn(p3dState, VERR_INVALID_STATE);
    2524 
    2525     PVMSVGA3DDXCONTEXT pDXContext;
    2526     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2527     AssertRCReturn(rc, rc);
    2528 
    2529     rc = pSvgaR3State->pFuncsDX->pfnDXSetGSConstantBufferOffset(pThisCC, pDXContext);
    2530     return rc;
    2531 }
    2532 
    2533 
    2534 int vmsvga3dDXSetHSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2535 {
    2536     int rc;
    2537     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2538     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetHSConstantBufferOffset, VERR_INVALID_STATE);
    2539     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2540     AssertReturn(p3dState, VERR_INVALID_STATE);
    2541 
    2542     PVMSVGA3DDXCONTEXT pDXContext;
    2543     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2544     AssertRCReturn(rc, rc);
    2545 
    2546     rc = pSvgaR3State->pFuncsDX->pfnDXSetHSConstantBufferOffset(pThisCC, pDXContext);
    2547     return rc;
    2548 }
    2549 
    2550 
    2551 int vmsvga3dDXSetDSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2552 {
    2553     int rc;
    2554     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2555     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetDSConstantBufferOffset, VERR_INVALID_STATE);
    2556     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2557     AssertReturn(p3dState, VERR_INVALID_STATE);
    2558 
    2559     PVMSVGA3DDXCONTEXT pDXContext;
    2560     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2561     AssertRCReturn(rc, rc);
    2562 
    2563     rc = pSvgaR3State->pFuncsDX->pfnDXSetDSConstantBufferOffset(pThisCC, pDXContext);
    2564     return rc;
    2565 }
    2566 
    2567 
    2568 int vmsvga3dDXSetCSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext)
    2569 {
    2570     int rc;
    2571     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
    2572     AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetCSConstantBufferOffset, VERR_INVALID_STATE);
    2573     PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
    2574     AssertReturn(p3dState, VERR_INVALID_STATE);
    2575 
    2576     PVMSVGA3DDXCONTEXT pDXContext;
    2577     rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
    2578     AssertRCReturn(rc, rc);
    2579 
    2580     rc = pSvgaR3State->pFuncsDX->pfnDXSetCSConstantBufferOffset(pThisCC, pDXContext);
     2487int vmsvga3dDXSetConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetConstantBufferOffset const *pCmd, SVGA3dShaderType type)
     2488{
     2489    int rc;
     2490    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
     2491    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXSetSingleConstantBuffer, VERR_INVALID_STATE);
     2492    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
     2493    AssertReturn(p3dState, VERR_INVALID_STATE);
     2494
     2495    PVMSVGA3DDXCONTEXT pDXContext;
     2496    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
     2497    AssertRCReturn(rc, rc);
     2498
     2499    ASSERT_GUEST_RETURN(pCmd->slot < SVGA3D_DX_MAX_CONSTBUFFERS, VERR_INVALID_PARAMETER);
     2500    RT_UNTRUSTED_VALIDATED_FENCE();
     2501
     2502    uint32_t const idxShaderState = type - SVGA3D_SHADERTYPE_MIN;
     2503    SVGA3dConstantBufferBinding *pCBB = &pDXContext->svgaDXContext.shaderState[idxShaderState].constantBuffers[pCmd->slot];
     2504
     2505    /* Only 'offsetInBytes' is updated. */
     2506    // pCBB->sid;
     2507    pCBB->offsetInBytes = pCmd->offsetInBytes;
     2508    // pCBB->sizeInBytes;
     2509
     2510    rc = pSvgaR3State->pFuncsDX->pfnDXSetSingleConstantBuffer(pThisCC, pDXContext, pCmd->slot, type, pCBB->sid, pCBB->offsetInBytes, pCBB->sizeInBytes);
    25812511    return rc;
    25822512}

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

    r99521 r99535  
    513513    DECLCALLBACKMEMBER(int, pfnDXHint,                      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    514514    DECLCALLBACKMEMBER(int, pfnDXBufferUpdate,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    515     DECLCALLBACKMEMBER(int, pfnDXSetVSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    516     DECLCALLBACKMEMBER(int, pfnDXSetPSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    517     DECLCALLBACKMEMBER(int, pfnDXSetGSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    518     DECLCALLBACKMEMBER(int, pfnDXSetHSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    519     DECLCALLBACKMEMBER(int, pfnDXSetDSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    520     DECLCALLBACKMEMBER(int, pfnDXSetCSConstantBufferOffset, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    521515    DECLCALLBACKMEMBER(int, pfnDXCondBindAllShader,         (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    522516    DECLCALLBACKMEMBER(int, pfnScreenCopy,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
    … …  
    637631int vmsvga3dDXHint(PVGASTATECC pThisCC, uint32_t idDXContext);
    638632int vmsvga3dDXBufferUpdate(PVGASTATECC pThisCC, uint32_t idDXContext);
    639 int vmsvga3dDXSetVSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
    640 int vmsvga3dDXSetPSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
    641 int vmsvga3dDXSetGSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
    642 int vmsvga3dDXSetHSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
    643 int vmsvga3dDXSetDSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
    644 int vmsvga3dDXSetCSConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext);
     633int vmsvga3dDXSetConstantBufferOffset(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetConstantBufferOffset const *pCmd, SVGA3dShaderType type);
    645634int vmsvga3dDXCondBindAllShader(PVGASTATECC pThisCC, uint32_t idDXContext);
    646635int vmsvga3dScreenCopy(PVGASTATECC pThisCC, uint32_t idDXContext);

  • trunk/src/VBox/Devices/Graphics/DevVGASavedState.h

    r98103 r99535  
    5757    } while (0)
    5858
    59 #define VGA_SAVEDSTATE_VERSION                   26
     59#define VGA_SAVEDSTATE_VERSION                   27
     60#define VGA_SAVEDSTATE_VERSION_VMSVGA_REG_CAP2   27 /* SVGA_REG_CAP2. */
    6061#define VGA_SAVEDSTATE_VERSION_VMSVGA_DX_SFLAGS  26 /* SVGA3dSurfaceAllFlags. */
    6162#define VGA_SAVEDSTATE_VERSION_VMSVGA_DX_CMDBUF  25 /* Command buffers capability is not tied to VGPU10 setting. */
Note: See TracChangeset for help on using the changeset viewer.

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