930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * DevVMWare - VMWare SVGA device
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Copyright (C) 2013 Oracle Corporation
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * available from http://www.virtualbox.org. This file is free software;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * you can redistribute it and/or modify it under the terms of the GNU
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * General Public License (GPL) as published by the Free Software
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/*******************************************************************************
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync* Header Files *
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync*******************************************************************************/
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Enable to disassemble defined shaders. */
2624f7a939f765d1975a82f3072c272f7fa3548dvboxsync#if defined(DEBUG) && 0 /* Disabled as we don't have the DirectX SDK avaible atm. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Enable to render the result of DrawPrimitive in a seperate window. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync//#define DEBUG_GFX_WINDOW
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Enable to use Wine to convert D3D to opengl */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync//#define VBOX_VMSVGA3D_WITH_OPENGL
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#define FOURCC_INTZ (D3DFORMAT)MAKEFOURCC('I', 'N', 'T', 'Z')
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#define FOURCC_NULL (D3DFORMAT)MAKEFOURCC('N', 'U', 'L', 'L')
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/*******************************************************************************
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync* Structures and Typedefs *
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync*******************************************************************************/
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGA3DMIPMAPLEVEL structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic SSMFIELD const g_aVMSVGA3DMIPMAPLEVELFields[] =
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DMIPMAPLEVEL, cbSurfacePitch),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DMIPMAPLEVEL, pSurfaceData),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DMIPMAPLEVEL, fDirty),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Key is context id. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Dirty state; surface was manually updated. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Handle for shared objects (currently only textures & render targets). */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /** Event query inserted after each GPU operation that updates or uses this surface. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGA3DSURFACE structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DSURFACE, idAssociatedContext),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSURFACE, pMipmapLevels),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DSURFACE, multiSampleCount),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSURFACE, formatD3D),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSURFACE, fUsageD3D),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSURFACE, multiSampleTypeD3D),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSURFACE, hSharedObject),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSURFACE, pQuery),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSURFACE, u.pSurface),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSURFACE, bounce.pTexture),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSURFACE, pSharedObjectTree),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSURFACE, fStencilAsTexture),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGA3DSHADER structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSHADER, pShaderProgram),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSHADER, u.pVertexShader),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGASHADERCONST structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic SSMFIELD const g_aVMSVGASHADERCONSTFields[] =
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Current active render target (if any) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Current selected texture surfaces (if any) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t aSidActiveTexture[SVGA3D_MAX_TEXTURE_STAGE];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Per context pixel and vertex shaders. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Keep track of the internal state to be able to recreate the context properly (save/restore, window resize). */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SVGA3dTextureState aTextureState[SVGA3D_MAX_TEXTURE_STAGE][SVGA3D_TS_MAX];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync VMSVGATRANSFORMSTATE aTransformState[SVGA3D_TRANSFORM_MAX];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync VMSVGACLIPPLANESTATE aClipPlane[SVGA3D_CLIPPLANE_MAX];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGA3DCONTEXT structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, pDevice),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, sidRenderTarget),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DCONTEXT, aSidActiveTexture),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, paPixelShader),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, paVertexShader),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.u32UpdateFlags),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aRenderState),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aTextureState),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aTransformState),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aClipPlane),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aLightData),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.aRenderTargets),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.RectScissor),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.RectViewPort),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.shidVertex),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.cPixelShaderConst),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, state.paPixelShaderConst),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY( VMSVGA3DCONTEXT, state.cVertexShaderConst),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DCONTEXT, state.paVertexShaderConst),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /** Window Thread. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /** Window request semaphore. */
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync /** The size of papContexts. */
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync /** The size of papSurfaces. */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync /** Contexts indexed by ID. Grown as needed. */
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync /** Surfaces indexed by ID. Grown as needed. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SSM descriptor table for the VMSVGA3DSTATE structure.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSTATE, pWindowThread),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSTATE, WndRequestSem),
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSTATE, papContexts),
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync SSMFIELD_ENTRY_IGN_HCPTR( VMSVGA3DSTATE, papSurfaces),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSTATE, fSupportedSurfaceINTZ),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SSMFIELD_ENTRY_IGNORE( VMSVGA3DSTATE, fSupportedSurfaceNULL),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsynctypedef struct
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync (SVGA3dFormatOp) (SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET | SVGA3DFORMAT_OP_SAME_FORMAT_RENDERTARGET),
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dCreateTexture(PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pThis->svga.p3dState = RTMemAllocZ(sizeof(VMSVGA3DSTATE));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create event semaphore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("%s: Failed to create event semaphore for window handling.\n", __FUNCTION__));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create the async IO thread. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dWindowThread, pState->WndRequestSem, 0, RTTHREADTYPE_GUI, 0, "VMSVGA3DWND");
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailed(("%s: Async IO Thread creation for 3d window handling failed rc=%d\n", __FUNCTION__, rc));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync return VINF_SUCCESS; /* already initialized (load state) */
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync /* Direct3DCreate9Ex was introduced in Vista, so resolve it dynamically. */
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync typedef HRESULT (WINAPI *PFNDIRECT3DCREATE9EX)(UINT, IDirect3D9Ex **);
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync PFNDIRECT3DCREATE9EX pfnDirect3dCreate9Ex = (PFNDIRECT3DCREATE9EX)RTLdrGetSystemSymbol("d3d9.dll", "Direct3DCreate9Ex");
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync return PDMDevHlpVMSetError(pThis->CTX_SUFF(pDevIns), VERR_SYMBOL_NOT_FOUND, RT_SRC_POS,
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync "vmsvga3d: Unable to locate Direct3DCreate9Ex. This feature requires Vista and later.");
3a5d071dab624524dda1e35720f1383ddf416d61vboxsync hr = pfnDirect3dCreate9Ex(D3D_SDK_VERSION, &pState->pD3D9);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pState->pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &pState->caps);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check if INTZ is supported. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* INTZ support is essential to support depth surfaces used as textures. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: texture format INTZ not supported!!!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check if NULL is supported. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* NULL is a dummy surface which can be used as a render target to save memory. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: surface format NULL not supported!!!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check if DX9 depth stencil textures are supported */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: texture format D3DFMT_D16 not supported\n"));
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: texture format D3DFMT_D24X8 not supported\n"));
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: texture format D3DFMT_D24S8 not supported\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Destroy all leftover surfaces. */
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync vmsvga3dSurfaceDestroy(pThis, pState->papSurfaces[i]->id);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Destroy all leftover contexts. */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync vmsvga3dContextDestroy(pThis, pState->papContexts[i]->id);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Terminate the window creation thread. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_EXIT, 0, 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Shared functions that depend on private structure definitions. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic uint32_t vmsvga3dGetSurfaceFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps, D3DFORMAT format)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Try if the format can be used for the primary display. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < RT_ELEMENTS(aFormatSupport); i++)
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check for features only if the format is supported in any form. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < RT_ELEMENTS(aFeatureReject); i++)
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo missing:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * SVGA3DFORMAT_OP_PIXELSIZE
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync | SVGA3DFORMAT_OP_DISPLAYMODE /* Should not be set for alpha formats. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync | SVGA3DFORMAT_OP_3DACCELERATION; /* implies OP_DISPLAYMODE */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync | SVGA3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic uint32_t vmsvga3dGetDepthFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps, D3DFORMAT format)
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync | SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync | SVGA3DFORMAT_OP_TEXTURE /* Necessary for Ubuntu Unity */;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dQueryCaps(PVGASTATE pThis, uint32_t idx3dCaps, uint32_t *pu32Val)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: Unsupported vertex shader version %x\n", pCaps->VertexShaderVersion));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* boolean? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel(("VMSVGA: Unsupported pixel shader version %x\n", pCaps->PixelShaderVersion));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* boolean? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must be obsolete by now; surface format caps specify the same thing. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * 2. The BUFFER_FORMAT capabilities are deprecated, and they always
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * return TRUE. Even on physical hardware that does not support
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * these formats natively, the SVGA3D device will provide an emulation
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * which should be invisible to the guest OS.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo ?? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = pCaps->MaxVertexShader30InstructionSlots;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = pCaps->MaxPixelShader30InstructionSlots;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = !!(pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_DEVCAP_MAX_RENDER_TARGETS: /* @todo same thing? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * This is the maximum number of SVGA context IDs that the guest
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * can define using SVGA_3D_CMD_CONTEXT_DEFINE.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * This is the maximum number of SVGA surface IDs that the guest
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * can define using SVGA_3D_CMD_SURFACE_DEFINE*.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Supported surface formats. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X8R8G8B8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8R8G8B8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A2R10G10B10);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X1R5G5B5);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A1R5G5B5);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A4R4G4B4);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A4R4G4B4);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_L16);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8L8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_L8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D16);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT: /* @todo not correct */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24S8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24X8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo supposed to be floating-point, but unable to find a match for D3D9... */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24FS8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT1);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT2);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT3);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT4);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT5);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X8L8V8U8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A2W10V10U10);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_V8U8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_Q8W8V8U8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_CxV8U8);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_R16F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_R32F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G16R16F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G32R32F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A16B16G16R16F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A32B32G32R32F);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_V16U16);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G16R16);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A16B16G16R16);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_UYVY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_YUY2);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2'));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync *pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, (D3DFORMAT)MAKEFOURCC('A', 'Y', 'U', 'V'));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown; only in DX10 & 11 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("CAPS: Unknown CAP %s\n", vmsvga3dGetCapString(idx3dCaps)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Dump of VMWare Player caps (from their log); for debugging purposes */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync// Log(("CAPS: Unexpected CAP %d\n", idx3dCaps));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync// rc = VERR_INVALID_PARAMETER;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("CAPS: %d=%s - %x\n", idx3dCaps, vmsvga3dGetCapString(idx3dCaps), *pu32Val));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA format value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic D3DFORMAT vmsvga3dSurfaceFormat2D3D(SVGA3dSurfaceFormat format)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Advanced D3D9 depth formats. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo supposed to be floating-point, but unable to find a match for D3D9... */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Bump-map formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* No corresponding D3D9 equivalent. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* signed bump-map formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* mixed bump-map formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Single- and dual-component floating point formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Any surface can be used as a buffer object, but SVGA3D_BUFFER is
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * the most efficient format to use when creating new surfaces
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * expressly for index or vertex data.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Packed Video formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Planar video formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Video format with alpha */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown; only in DX10 & 11 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA multi sample count value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncD3DMULTISAMPLE_TYPE vmsvga3dMultipeSampleCount2D3D(uint32_t multisampleCount)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo exact same mapping as d3d? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSurfaceDefine(PVGASTATE pThis, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format, SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES],
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter, uint32_t cMipLevels, SVGA3dSize *pMipLevelSize)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync Log(("vmsvga3dSurfaceDefine: sid=%x surfaceFlags=%x format=%s (%x) multiSampleCount=%d autogenFilter=%d, cMipLevels=%d size=(%d,%d,%d)\n",
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync sid, surfaceFlags, vmsvgaSurfaceType2String(format), format, multisampleCount, autogenFilter, cMipLevels, pMipLevelSize->width, pMipLevelSize->height, pMipLevelSize->depth));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(cMipLevels >= 1, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Assuming all faces have the same nr of mipmaps. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(!(surfaceFlags & SVGA3D_SURFACE_CUBEMAP) || cMipLevels == face[0].numMipLevels * 6, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn((surfaceFlags & SVGA3D_SURFACE_CUBEMAP) || cMipLevels == face[0].numMipLevels, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync /* Grow the array. */
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync void *pvNew = RTMemRealloc(pState->papSurfaces, sizeof(pState->papSurfaces[0]) * cNew);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync pSurface = (PVMSVGA3DSURFACE)RTMemAllocZ(sizeof(*pSurface));
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync pState->papSurfaces[pState->cSurfaces++] = pSurface;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* If one already exists with this id, then destroy it now. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync /* The surface type is sort of undefined now, even though the hints and format can help to clear that up.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * In some case we'll have to wait until the surface is used to create the D3D object.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Texture compression formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Bump-map formats */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Typical render target formats; we should allow render target buffers to be used as textures. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Any surface can be used as a buffer object, but SVGA3D_BUFFER is
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * the most efficient format to use when creating new surfaces
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * expressly for index or vertex data.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->cFaces = 1; /* check for cube maps later */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(autogenFilter != SVGA3D_TEX_FILTER_FLATCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(autogenFilter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels = (PVMSVGA3DMIPMAPLEVEL)RTMemAllocZ(cMipLevels * sizeof(VMSVGA3DMIPMAPLEVEL));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->pMipmapLevels, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[i].size = pMipLevelSize[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Translate the format and usage flags to D3D. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->formatD3D = vmsvga3dSurfaceFormat2D3D(format);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->cbBlock = vmsvga3dSurfaceFormatSize(format);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->multiSampleTypeD3D= vmsvga3dMultipeSampleCount2D3D(multisampleCount);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync switch (surfaceFlags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* else type unknown at this time; postpone buffer creation */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Type unknown at this time; postpone buffer creation */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown; decide later. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Allocate buffer to hold the surface data until we can move it into a D3D object */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t iFace=0; iFace < pSurface->cFaces; iFace++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i=0; i < pSurface->faces[iFace].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t idx = i + iFace * pSurface->faces[0].numMipLevels;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceDefine: face %d mip level %d (%d,%d,%d)\n", iFace, i, pSurface->pMipmapLevels[idx].size.width, pSurface->pMipmapLevels[idx].size.height, pSurface->pMipmapLevels[idx].size.depth));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceDefine: cbPitch=%x cbBlock=%x \n", pSurface->cbBlock * pSurface->pMipmapLevels[idx].size.width, pSurface->cbBlock));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[idx].cbSurfacePitch = pSurface->cbBlock * pSurface->pMipmapLevels[idx].size.width;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[idx].cbSurface = pSurface->pMipmapLevels[idx].cbSurfacePitch * pSurface->pMipmapLevels[idx].size.height * pSurface->pMipmapLevels[idx].size.depth;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[idx].pSurfaceData = RTMemAllocZ(pSurface->pMipmapLevels[idx].cbSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->pMipmapLevels[idx].pSurfaceData, VERR_NO_MEMORY);
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync * Release all shared surface objects.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dSharedSurfaceDestroyTree(PAVLU32NODECORE pNode, void *pParam)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)pNode;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSURFACE pSurface = (PVMSVGA3DSURFACE)pParam;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSharedSurfaceDestroyTree: release shared object for context %d\n", pNode->Key));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSurfaceDestroy(PVGASTATE pThis, uint32_t sid)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check all contexts if this surface is used as a render target or active texture. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t cid = 0; cid < pState->cContexts; cid++)
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTexture); i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->aSidActiveTexture[i] = SVGA3D_INVALID_ID;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
9b37cfa6efe394762d21f3710df8fa46b2758880vboxsync switch (pSurface->flags & ( SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER
9b37cfa6efe394762d21f3710df8fa46b2758880vboxsync | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET
9b37cfa6efe394762d21f3710df8fa46b2758880vboxsync | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE: /* @todo actual texture surface not supported */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(!pSurface->u.pSurface, ("type=%x\n", (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t face=0; face < pSurface->cFaces; face++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i=0; i < pSurface->faces[face].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RTMemFree(pSurface->pMipmapLevels[idx].pSurfaceData);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Get the shared surface copy or create a new one. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic PVMSVGA3DSHAREDSURFACE vmsvga3dSurfaceGetSharedCopy(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTAvlU32Get(&pSurface->pSharedObjectTree, pContext->id);
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync Log(("vmsvga3dSurfaceGetSharedCopy: Create shared texture copy d3d (%d,%d) cMip=%d usage %x format %x.\n",
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTMemAllocZ(sizeof(*pSharedSurface));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync ret = RTAvlU32Insert(&pSurface->pSharedObjectTree, &pSharedSurface->Core);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create shadow copy of the original shared texture. Shared d3d resources require Vista+ and have some restrictions. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceGetSharedCopy: CreateTexture failed with %x\n", hr), NULL);
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync/* Inject a query event into the D3D pipeline so we can check when usage of this surface has finished.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * (D3D does not synchronize shared surface usage)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dSurfaceTrackUsage(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t sid)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Nothing to do if this surface hasn't been shared. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceTrackUsage: track usage of surface id=%x (cid=%x)\n", sid, pContext->id));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Release the previous query object. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceTrackUsage: release old query object\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pSurface->pQuery);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: CreateQuery failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: Issue failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Wait for all drawing, that uses this surface, to finish. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dSurfaceFlush(PVGASTATE pThis, PVMSVGA3DSURFACE pSurface)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogFlow(("vmsvga3dSurfaceFlush: no query object\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceFlush: wait for draw to finish (sid=%x)\n", pSurface->id));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync while (true)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->pQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#endif /* VBOX_VMSVGA3D_WITH_OPENGL */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSurfaceCopy(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sidSrc < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sidSrc < pState->cSurfaces && pState->papSurfaces[sidSrc]->id == sidSrc, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sidDest < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sidDest < pState->cSurfaces && pState->papSurfaces[sidDest]->id == sidDest, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurfaceSrc->faces[0].numMipLevels > src.mipmap, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurfaceDest->faces[0].numMipLevels > dest.mipmap, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync // AssertMsgReturn(pSurfaceSrc->format == pSurfaceDest->format, ("Format mismatch (%d vs %d)!!\n", pSurfaceSrc->format, pSurfaceDest->format), VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync bool fSrcTexture = !!(pSurfaceSrc->flags & SVGA3D_SURFACE_HINT_TEXTURE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync bool fDestTexture = !!(pSurfaceDest->flags & SVGA3D_SURFACE_HINT_TEXTURE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy: create texture surface id=%x type=%d format=%d -> create texture\n", sidDest, pSurfaceDest->flags, pSurfaceDest->format));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dCreateTexture(pContext, cid, pSurfaceDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync IDirect3DTexture9 *pSrcTexture = pSurfaceSrc->u.pTexture;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy; using texture %x created for another context (%d vs %d)\n", sidSrc, pSurfaceSrc->idAssociatedContext, cid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pSurfaceSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectSrc.right = pBox[i].srcx + pBox[i].w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectSrc.bottom = pBox[i].srcy + pBox[i].h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectDest.right = pBox[i].x + pBox[i].w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectDest.bottom = pBox[i].y + pBox[i].h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy: (StretchRect) copy src sid=%x face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%x face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy: redundant copy to the same surface at the same coordinates. Ignore. \n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSrcTexture->GetSurfaceLevel(src.mipmap /* Texture level */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceDest->u.pTexture->GetSurfaceLevel(dest.mipmap /* Texture level */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* UpdateSurface is too picky; use StretchRect instead */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->StretchRect(pSrc, &RectSrc, pDest, &RectDest, D3DTEXF_NONE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* GetSurfaceLevel increases the reference count; release the objects again. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Track the StretchRect operation. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, sidSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, sidDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: UpdateSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Rect.right = pBox[i].srcx + pBox[i].w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Rect.bottom = pBox[i].srcy + pBox[i].h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceCopy: (manual) copy src=%x src=%x face=%d (%d,%d)(%d,%d) to dest=%x src=%x face=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, Rect.left, Rect.top, Rect.right, Rect.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LockedSrcRect.pBits = (void *)pSurfaceSrc->pMipmapLevels[src.mipmap].pSurfaceData;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LockedSrcRect.Pitch = pSurfaceSrc->pMipmapLevels[src.mipmap].cbSurfacePitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceSrc->u.pTexture->LockRect(src.mipmap, /* Texture level */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceSrc->u.pSurface->LockRect(&LockedSrcRect,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LockedDestRect.pBits = (void *)pSurfaceDest->pMipmapLevels[dest.mipmap].pSurfaceData;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LockedDestRect.Pitch = pSurfaceDest->pMipmapLevels[dest.mipmap].cbSurfacePitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceDest->u.pTexture->LockRect(dest.mipmap, /* texture level */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceDest->u.pSurface->LockRect(&LockedDestRect,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint8_t *pDest = (uint8_t *)LockedDestRect.pBits + LockedDestRect.Pitch * pBox[i].y + pBox[i].x * pSurfaceDest->cbBlock;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint8_t *pSrc = (uint8_t *)LockedSrcRect.pBits + LockedSrcRect.Pitch * pBox[i].srcy + pBox[i].srcx * pSurfaceSrc->cbBlock;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pDest, pSrc, pBox[i].w * pSurfaceSrc->cbBlock);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceDest->u.pTexture->UnlockRect(dest.mipmap /* Texture level */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: Unlock failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceSrc->u.pTexture->UnlockRect(src.mipmap /* Texture level */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceCopy: Unlock failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Create D3D texture object for the specified surface. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dCreateTexture(PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Use the INTZ format for a depth/stencil surface that will be used as a texture */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync &pSurface->hSharedObject /* might result in poor performance */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: CreateTexture INTZ failed with %x\n", hr), VERR_INTERNAL_ERROR);
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* The format was probably not accepted; fall back to our old mode. */
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateTexture(pSurface->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync &pSurface->hSharedObject /* might result in poor performance */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pSurface->autogenFilter != SVGA3D_TEX_FILTER_NONE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Set the mip map generation filter settings. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dCreateTexture: SetAutoGenFilterType failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCreateTexture: sync dirty texture\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCreateTexture: sync dirty texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->pMipmapLevels[i].cbSurfacePitch));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint8_t *pSrc = (uint8_t *)pSurface->pMipmapLevels[i].pSurfaceData;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t j = 0; j < pSurface->pMipmapLevels[i].size.height; j++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pDest, pSrc, pSurface->pMipmapLevels[i].cbSurfacePitch);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCreateTexture: sync dirty texture from bounce buffer\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCreateTexture: UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* We will now use the bounce texture for all memory accesses, so free our surface memory buffer. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RTMemFree(pSurface->pMipmapLevels[i].pSurfaceData);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->idAssociatedContext = idAssociatedContext;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dBox destBox, SVGA3dSurfaceImageId src, SVGA3dBox srcBox, SVGA3dStretchBltMode mode)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sidSrc < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sidSrc < pState->cSurfaces && pState->papSurfaces[sidSrc]->id == sidSrc, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sidDest < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sidDest < pState->cSurfaces && pState->papSurfaces[sidDest]->id == sidDest, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurfaceSrc->faces[0].numMipLevels > src.mipmap, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurfaceDest->faces[0].numMipLevels > dest.mipmap, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceStretchBlt: src sid=%x (%d,%d)(%d,%d) dest sid=%x (%d,%d)(%d,%d) mode=%x\n", src.sid, srcBox.x, srcBox.y, srcBox.x + srcBox.w, srcBox.y + srcBox.h, dest.sid, destBox.x, destBox.y, destBox.x + destBox.w, destBox.y + destBox.h, mode));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceStretchBlt invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceStretchBlt: unknown src surface id=%x type=%d format=%d -> create texture\n", sidSrc, pSurfaceSrc->flags, pSurfaceSrc->format));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dCreateTexture(pContext, cid, pSurfaceSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceStretchBlt: unknown dest surface id=%x type=%d format=%d -> create texture\n", sidDest, pSurfaceDest->flags, pSurfaceDest->format));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dCreateTexture(pContext, cid, pSurfaceDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Flush the drawing pipeline for this surface as it could be used in a shared context. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync bool fSrcTexture = !!(pSurfaceSrc->flags & SVGA3D_SURFACE_HINT_TEXTURE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync bool fDestTexture = !!(pSurfaceDest->flags & SVGA3D_SURFACE_HINT_TEXTURE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectSrc.right = srcBox.x + srcBox.w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectSrc.bottom = srcBox.y + srcBox.h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectDest.right = destBox.x + destBox.w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RectDest.bottom = destBox.y + destBox.h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceSrc->u.pTexture->GetSurfaceLevel(src.mipmap /* Texture level */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurfaceDest->u.pTexture->GetSurfaceLevel(dest.mipmap /* Texture level */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->StretchRect(pSrc, &RectSrc, pDest, &RectDest, moded3d);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* GetSurfaceLevel increases the reference count; release the objects again. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Track the StretchRect operation. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, sidSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, sidDest);
de8636fc8bdeb02161ee5b329c407dd0c48b0885vboxsyncint vmsvga3dSurfaceDMA(PVGASTATE pThis, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->faces[0].numMipLevels > host.mipmap, VERR_INVALID_PARAMETER);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync Log(("vmsvga3dSurfaceDMA TEXTURE guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync Log(("vmsvga3dSurfaceDMA guestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n", guest.ptr.gmrId, guest.ptr.offset, guest.pitch, host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->pMipmapLevels[host.mipmap].pSurfaceData, VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < cCopyBoxes; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Copy box %d (%d,%d,%d)(%d,%d,%d)\n", i, pBoxes[i].srcx, pBoxes[i].srcy, pBoxes[i].srcz, pBoxes[i].w, pBoxes[i].h, pBoxes[i].d));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Apparently we're supposed to clip it (gmr test sample) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].x + pBoxes[i].w > pMipLevel->size.width)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].y + pBoxes[i].h > pMipLevel->size.height)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pBoxes[i].h = pMipLevel->size.height - pBoxes[i].y;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].z + pBoxes[i].d > pMipLevel->size.depth)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uDestOffset = pBoxes[i].x * pSurface->cbBlock + pBoxes[i].y * pMipLevel->cbSurfacePitch + pBoxes[i].z * pMipLevel->size.height * pMipLevel->cbSurfacePitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(uDestOffset + pBoxes[i].w * pSurface->cbBlock * pBoxes[i].h * pBoxes[i].d <= pMipLevel->cbSurface, VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync cbSrcPitch = (guest.pitch == 0) ? pBoxes[i].w * pSurface->cbBlock : guest.pitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pBoxes[i].srcx * pSurface->cbBlock + (pBoxes[i].srcy + pBoxes[i].srcz * pBoxes[i].h) * cbSrcPitch,
c6ade8a5a12fad69394e7223b7ea170bd729f0f4vboxsync Log4(("first line:\n%.*Rhxd\n", pMipLevel->cbSurfacePitch, pMipLevel->pSurfaceData));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[host.mipmap].fDirty = true;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Flush the drawing pipeline for this surface as it could be used in a shared context. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < cCopyBoxes; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Apparently we're supposed to clip it (gmr test sample) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].x + pBoxes[i].w > pMipLevel->size.width)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].y + pBoxes[i].h > pMipLevel->size.height)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pBoxes[i].h = pMipLevel->size.height - pBoxes[i].y;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pBoxes[i].z + pBoxes[i].d > pMipLevel->size.depth)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert((pBoxes[i].d == 1 || pBoxes[i].d == 0) && pBoxes[i].z == 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync cbSrcPitch = (guest.pitch == 0) ? pBoxes[i].w * pSurface->cbBlock : guest.pitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* no break */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* no break */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* no break */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Rect.right = pBoxes[i].x + pBoxes[i].w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Rect.bottom = pBoxes[i].y + pBoxes[i].h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo inefficient for VRAM buffers!! */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync && i == 0 /* only the first time */)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync Log(("vmsvga3dSurfaceDMA invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->papContexts[cid]->id));
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo only sync when something was actually rendered (since the last sync) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->bounce.pTexture->GetSurfaceLevel(host.mipmap, &pDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->GetSurfaceLevel(host.mipmap, &pSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->bounce.pTexture->LockRect(host.mipmap, /* texture level */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->LockRect(host.mipmap, /* texture level */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Lock TEXTURE (bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n", !!(pSurface->bounce.pTexture), Rect.left, Rect.top, Rect.right, Rect.bottom));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n", (pSurface->flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL) ? "DEPTH-STENCIL" : "RENDERTARGET", Rect.left, Rect.top, Rect.right, Rect.bottom));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pBoxes[i].srcx * pSurface->cbBlock + pBoxes[i].srcy * cbSrcPitch,
c6ade8a5a12fad69394e7223b7ea170bd729f0f4vboxsync Log4(("first line:\n%.*Rhxd\n", pBoxes[i].w * pSurface->cbBlock, LockedRect.pBits));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->bounce.pTexture->UnlockRect(host.mipmap);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceDMA: sync texture from bounce buffer\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Copy the new contents to the actual texture object. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Track the copy operation. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, pSurface->id);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->UnlockRect(host.mipmap);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* no break */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uDestOffset = pBoxes[i].x * pSurface->cbBlock + pBoxes[i].y * pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(uDestOffset + pBoxes[i].w * pSurface->cbBlock + (pBoxes[i].h - 1) * pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch <= pSurface->pMipmapLevels[host.mipmap].cbSurface, VERR_INTERNAL_ERROR);
de8636fc8bdeb02161ee5b329c407dd0c48b0885vboxsync /** @todo lock only as much as we really need */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n", (fVertex) ? "vertex" : "index", pBoxes[i].x, pBoxes[i].y, pBoxes[i].x + pBoxes[i].w, pBoxes[i].y + pBoxes[i].h));
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pBoxes[i].srcx * pSurface->cbBlock + pBoxes[i].srcy * cbSrcPitch,
c6ade8a5a12fad69394e7223b7ea170bd729f0f4vboxsync Log4(("first line:\n%.*Rhxd\n", cbSrcPitch, pData));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, uint32_t dest, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Requires SVGA_FIFO_CAP_SCREEN_OBJECT support */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceBlitToScreen: dest=%d (%d,%d)(%d,%d) surface=%x (face=%d, mipmap=%d) (%d,%d)(%d,%d) cRects=%d\n", dest, destRect.left, destRect.top, destRect.right, destRect.bottom, src.sid, src.face, src.mipmap, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, cRects));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSurfaceBlitToScreen: clipping rect %d (%d,%d)(%d,%d)\n", i, pRect[i].left, pRect[i].top, pRect[i].right, pRect[i].bottom));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo Only screen 0 for now. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(src.mipmap == 0 && src.face == 0, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo scaling */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(destRect.right - destRect.left == srcRect.right - srcRect.left && destRect.bottom - destRect.top == srcRect.bottom - srcRect.top, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* easy case; no clipping */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vgaR3UpdateDisplay(pThis, box.x, box.y, box.w, box.h);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo merge into one SurfaceDMA call */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* The clipping rectangle is relative to the top-left corner of srcRect & destRect. Adjust here. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vgaR3UpdateDisplay(pThis, box.x, box.y, box.w, box.h);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dGenerateMipmaps invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->GetSurfaceLevel(0/* Texture level */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->pDevice->ColorFill(pSrc, NULL, (D3DCOLOR)0x11122255);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dGenerateMipmaps(PVGASTATE pThis, uint32_t sid, SVGA3dTextureFilter filter)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dGenerateMipmaps: sid=%x filter=%d\n", sid, filter));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dGenerateMipmaps invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unknown surface type; turn it into a texture. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dGenerateMipmaps: unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->flags, pSurface->format));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dCreateTexture(pContext, cid, pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)filter);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dGenerateMipmaps: SetAutoGenFilterType failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Generate the mip maps. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dCommandPresent(PVGASTATE pThis, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo stricter checks for associated context */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandPresent: sid=%x cRects=%d cid=%x\n", sid, cRects, cid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandPresent: rectangle %d src=(%d,%d) (%d,%d)(%d,%d)\n", i, pRect[i].srcx, pRect[i].srcy, pRect[i].x, pRect[i].y, pRect[i].x + pRect[i].w, pRect[i].y + pRect[i].h));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandPresent invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetBackBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->GetSurfaceLevel(0, &pSurfaceD3D);
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Source surface different size? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pSurface->pMipmapLevels[0].size.width != pThis->svga.uWidth ||
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->pMipmapLevels[0].size.height != pThis->svga.uHeight)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync float xMultiplier = (float)pSurface->pMipmapLevels[0].size.width / (float)pThis->svga.uWidth;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync float yMultiplier = (float)pSurface->pMipmapLevels[0].size.height / (float)pThis->svga.uHeight;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync srcViewPort.x = (uint32_t)((float)pThis->svga.viewport.x * xMultiplier);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync srcViewPort.y = (uint32_t)((float)pThis->svga.viewport.y * yMultiplier);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync srcViewPort.cx = (uint32_t)((float)pThis->svga.viewport.cx * xMultiplier);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync srcViewPort.cy = (uint32_t)((float)pThis->svga.viewport.cy * yMultiplier);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @note the viewport doesn't affect blitting. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->StretchRect(pSurfaceD3D, &rectSrc, pBackBuffer, &rectDest, D3DTEXF_NONE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if ( pRect[i].x + pRect[i].w <= pThis->svga.viewport.x
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync || pThis->svga.viewport.x + pThis->svga.viewport.cx <= pRect[i].x
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync || pRect[i].y + pRect[i].h <= pThis->svga.viewport.y
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync || pThis->svga.viewport.y + pThis->svga.viewport.cy <= pRect[i].y)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Intersection is empty; skip */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectSrc.left = RT_MAX(pRect[i].srcx, srcViewPort.x);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectSrc.top = RT_MAX(pRect[i].srcy, srcViewPort.y);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectSrc.right = RT_MIN(pRect[i].srcx + pRect[i].w, srcViewPort.x + srcViewPort.cx);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectSrc.bottom = RT_MIN(pRect[i].srcy + pRect[i].h, srcViewPort.y + srcViewPort.cy);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectDest.left = RT_MAX(pRect[i].x, pThis->svga.viewport.x) - pThis->svga.viewport.x;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectDest.top = RT_MAX(pRect[i].y, pThis->svga.viewport.y) - pThis->svga.viewport.y;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectDest.right = RT_MIN(pRect[i].x + pRect[i].w, pThis->svga.viewport.x + pThis->svga.viewport.cx) - pThis->svga.viewport.x;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rectDest.bottom = RT_MIN(pRect[i].y + pRect[i].h, pThis->svga.viewport.y + pThis->svga.viewport.cy) - pThis->svga.viewport.y;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->StretchRect(pSurfaceD3D, &rectSrc, pBackBuffer, &rectDest, D3DTEXF_NONE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->Present(NULL, NULL, NULL, NULL);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: Present failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Create a new 3d context
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @returns VBox status code.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @param pThis VGA device instance data.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @param cid Context id
d7dbbf62e47482dad97a2d17ae567e879b5d57b6vboxsyncint vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync /* Grow the array. */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync void *pvNew = RTMemRealloc(pState->papContexts, sizeof(pState->papContexts[0]) * cNew);
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync pContext = (PVMSVGA3DCONTEXT)RTMemAllocZ(sizeof(*pContext));
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync pState->papContexts[pState->cContexts++] = pContext;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* If one already exists with this id, then destroy it now. */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i< RT_ELEMENTS(pContext->aSidActiveTexture); i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->aSidActiveTexture[i] = SVGA3D_INVALID_ID;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aRenderTargets[i] = SVGA3D_INVALID_ID;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create a context window. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pThis->svga.u64HostWindowId, VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync cs.dwExStyle = WS_EX_NOACTIVATE | WS_EX_NOPARENTNOTIFY | WS_EX_TRANSPARENT;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RTStrPrintf((char *)cs.lpszName, 256, "Context %d OpenGL Window", cid);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync cs.style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE | WS_CAPTION;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync cs.style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED | WS_CHILD | WS_VISIBLE;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_CREATEWINDOW, (WPARAM)&pContext->hwnd, (LPARAM)&cs);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Changed when the function returns. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pState->pD3D9->CreateDevice(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DCREATE_MULTITHREADED | D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pState->pD3D9->CreateDeviceEx(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DCREATE_MULTITHREADED | D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dContextDefine: CreateDevice failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dContextDefine: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Destroy an existing 3d context
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @returns VBox status code.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @param pThis VGA device instance data.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * @param cid Context id
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dContextDestroy(PVGASTATE pThis, uint32_t cid)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check for all surfaces that are associated with this context to remove all dependencies */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dContextDestroy: remove all dependencies for surface %x\n", sid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t multisampleCount = pSurface->multiSampleCount;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SVGA3dTextureFilter autogenFilter = pSurface->autogenFilter;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pMipLevelSize = (SVGA3dSize *)RTMemAllocZ(pSurface->faces[0].numMipLevels * pSurface->cFaces * sizeof(SVGA3dSize));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t face=0; face < pSurface->cFaces; face++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(&pMipLevelSize[idx], &pSurface->pMipmapLevels[idx].size, sizeof(SVGA3dSize));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(face, pSurface->faces, sizeof(pSurface->faces));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Recreate the surface with the original settings; destroys the contents, but that seems fairly safe since the context is also destroyed. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /** @todo not safe with shared objects */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dSurfaceDefine(pThis, sid, surfaceFlags, format, face, multisampleCount, autogenFilter, face[0].numMipLevels * cFaces, pMipLevelSize);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Check for a shared surface object. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTAvlU32Get(&pSurface->pSharedObjectTree, cid);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dContextDestroy: remove shared dependency for surface %x\n", sid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Destroy all leftover pixel shaders. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pContext->cPixelShaders; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderDestroy(pThis, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Destroy all leftover vertex shaders. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pContext->cVertexShaders; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderDestroy(pThis, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Release the D3D device object */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Destroy the window we've created. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_DESTROYWINDOW, (WPARAM)pContext->hwnd, 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic int vmsvga3dContextTrackUsage(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Inject fences to make sure we can track surface usage in case the client wants to reuse it in another context. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTexture); i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->aSidActiveTexture[i] != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->aSidActiveTexture[i]);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->sidRenderTarget != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->sidRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Handle resize */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Resize all active contexts. */
aec6fc9d2efe16d4e250b2ebaf8dbfbd49f8eaa6vboxsync PVMSVGA3DCONTEXT pContext = pState->papContexts[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Sync back all surface data as everything is lost after the Reset. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: sync back data of surface sid=%x (fDirty=%d)\n", sid, pSurface->fDirty));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Reallocate our surface memory buffers. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pSurface->cMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo only sync when something was actually rendered (since the last sync) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: sync bounce buffer (level %d)\n", i));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Copy the data one line at a time in case the internal pitch is different. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t j = 0; j < pMipmapLevel->size.height; j++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy((uint8_t *)pMipmapLevel->pSurfaceData + j * pMipmapLevel->cbSurfacePitch, (uint8_t *)LockedRect.pBits + j * LockedRect.Pitch, pMipmapLevel->cbSurfacePitch);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync switch (pSurface->flags & (SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET | SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_CUBEMAP))
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Resize window %x of context %d to (%d,%d)\n", pContext->hwnd, pContext->id, cs.cx, cs.cy));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: old viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewportOrg.X, viewportOrg.Y, viewportOrg.Width, viewportOrg.Height, (uint32_t)(viewportOrg.MinZ * 100.0), (uint32_t)(viewportOrg.MaxZ * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Resize the window. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_RESIZEWINDOW, (WPARAM)pContext->hwnd, (LPARAM)&cs);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Changed when the function returns. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* ResetEx does not trash the device state */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* ResetEx changes the viewport; restore it again. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: changed viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewport.X, viewport.Y, viewport.Width, viewport.Height, (uint32_t)(viewport.MinZ * 100.0), (uint32_t)(viewport.MaxZ * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* First set the render targets as they change the internal state (reset viewport etc) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Recreate render targets BEGIN\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aRenderTargets); j++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.aRenderTargets[j] != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dSetRenderTarget(pThis, cid, (SVGA3dRenderTargetType)j, target);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Recreate the render state */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Recreate render state BEGIN\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderState); i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SVGA3dRenderState *pRenderState = &pContext->state.aRenderState[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetRenderState(pThis, pContext->id, 1, pRenderState);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Recreate render state END\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Recreate the texture state */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Recreate texture state BEGIN\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t iStage = 0; iStage < SVGA3D_MAX_TEXTURE_STAGE; iStage++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync SVGA3dTextureState *pTextureState = &pContext->state.aTextureState[iStage][j];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureState);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dChangeMode: Recreate texture state END\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /** @todo restore more state data */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16])
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetTransform %x %s\n", cid, vmsvgaTransformToString(type)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetTransform invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save this matrix for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aTransformState[type].fValid = true;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pContext->state.aTransformState[type].matrix, matrix, sizeof(pContext->state.aTransformState[type].matrix));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_TRANSFORM;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Matrix [%d %d %d %d]\n", (int)(matrix[0] * 10.0), (int)(matrix[1] * 10.0), (int)(matrix[2] * 10.0), (int)(matrix[3] * 10.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log((" [%d %d %d %d]\n", (int)(matrix[4] * 10.0), (int)(matrix[5] * 10.0), (int)(matrix[6] * 10.0), (int)(matrix[7] * 10.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log((" [%d %d %d %d]\n", (int)(matrix[8] * 10.0), (int)(matrix[9] * 10.0), (int)(matrix[10] * 10.0), (int)(matrix[11] * 10.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log((" [%d %d %d %d]\n", (int)(matrix[12] * 10.0), (int)(matrix[13] * 10.0), (int)(matrix[14] * 10.0), (int)(matrix[15] * 10.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetTransform(d3dState, (const D3DMATRIX *)matrix);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTransform: SetTransform failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetZRange %x min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_ZRANGE;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetZRange: old viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewport.X, viewport.Y, viewport.Width, viewport.Height, (uint32_t)(viewport.MinZ * 100.0), (uint32_t)(viewport.MaxZ * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo convert the depth range from -1-1 to 0-1 although we shouldn't be getting such values in the first place... */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA blend op value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic DWORD vmsvga3dBlendOp2D3D(uint32_t blendOp, DWORD defaultBlendOp)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetRenderState(PVGASTATE pThis, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync Log(("vmsvga3dSetRenderState cid=%x cRenderStates=%d\n", cid, cRenderStates));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderState invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < cRenderStates; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DRENDERSTATETYPE renderState = D3DRS_FORCE_DWORD;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderState: state=%s (%d) val=%x\n", vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save the render state for vm state saving. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aRenderState[pRenderState[i].state] = pRenderState[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("SVGA3D_RS_POINTSIZE: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("SVGA3D_RS_POINTSIZEMIN: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("SVGA3D_RS_POINTSIZEMAX: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_AMBIENT: /* SVGA3dColor - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_CLIPPLANEENABLE: /* SVGA3dClipPlanes - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_FOGCOLOR: /* SVGA3dColor - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_FOGFUNC_PER_VERTEX: /* unable to find a d3d9 equivalent */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailedReturn(("Unsupported fog function SVGA3D_FOGFUNC_PER_VERTEX\n"), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailedReturn(("Unexpected fog function %d\n", mode.s.function), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* The fog type determines the render state. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailedReturn(("Unexpected fog type %d\n", mode.s.type), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Set the fog base to depth or range. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_DEPTHBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_RANGEBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* ignore */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailed(("Unexpected fog base %d\n", mode.s.base));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailedReturn(("Unexpected fill mode %d\n", mode.s.mode), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo ignoring face for now. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DSHADE_FLAT == SVGA3D_SHADEMODE_FLAT);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue; /* SVGA3dShadeMode == D3DSHADEMODE */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_LINEPATTERN: /* SVGA3dLinePattern */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* No longer supported by d3d; mesagl comments suggest not all backends support it */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("WARNING: SVGA3D_RS_LINEPATTERN %x not supported!!\n", pRenderState[i].uintValue));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_LINEPATTERN;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_BLENDEQUATION: /* SVGA3dBlendEquation - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_BLENDEQ_MAXIMUM == D3DBLENDOP_MAX);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgFailedReturn(("Unexpected cull mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_ZFUNC: /* SVGA3dCmpFunc - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_ALPHAFUNC: /* SVGA3dCmpFunc - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DSTENCILOP_KEEP == SVGA3D_STENCILOP_KEEP);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DSTENCILOP_DECR == SVGA3D_STENCILOP_DECR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_FRONTWINDING: /* SVGA3dFrontWinding */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pRenderState[i].uintValue == SVGA3D_FRONTWINDING_CW);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_FRONTWINDING; //D3DRS_TWOSIDEDSTENCILMODE
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_COORDINATETYPE: /* SVGA3dCoordinateType */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pRenderState[i].uintValue == SVGA3D_COORDINATE_LEFTHANDED);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo setup a view matrix to scale the world space by -1 in the z-direction for right handed coordinates. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_COORDINATETYPE;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo unknown meaning; depth bias is not identical
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_DEPTHBIAS;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_RS_ZBIAS\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_COLORWRITEENABLE: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_VERTEXMATERIALENABLE: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync //AssertFailed();
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_INDEXEDVERTEXBLENDENABLE; /* correct?? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_DIFFUSEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DMCS_COLOR2 == SVGA3D_VERTEXMATERIAL_SPECULAR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_SPECULARMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_AMBIENTMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_EMISSIVEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_TEXTUREFACTOR: /* SVGA3dColor - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_BLENDCOLOR: /* SVGA3dColor - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_STENCILENABLE2SIDED: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_CCWSTENCILFUNC: /* SVGA3dCmpFunc - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_VERTEXBLEND: /* SVGA3dVertexBlendFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_VBLEND_DISABLE == D3DVBF_DISABLE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync //AssertFailed();
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DRS_SRGBWRITEENABLE ??
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_OUTPUTGAMMA;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_ZVISIBLE;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP0: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP1: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP2: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP3: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP4: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP5: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP6: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP7: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP8: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP9: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP10: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP11: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP12: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP13: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP14: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_WRAP15: /* SVGA3dWrapFlags - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_MULTISAMPLEANTIALIAS: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_ANTIALIASEDLINEENABLE: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_COLORWRITEENABLE1: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_COLORWRITEENABLE2: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_COLORWRITEENABLE3: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation - identical */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_RS_TRANSPARENCYANTIALIAS: /* SVGA3dTransparencyAntialiasType */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_TRANSPARENCYANTIALIAS;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync renderState = D3DRS_LINEWIDTH;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pRenderState[i].uintValue;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderState(renderState, val);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetRenderTarget(PVGASTATE pThis, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(target.face == 0, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(target.mipmap == 0, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget cid=%x type=%x surface id=%x\n", cid, type, target.sid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Disable render target. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetDepthStencilSurface(NULL);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* ignore; correct?? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create a dummy render target to satisfy D3D. This path is usually taken only to render into a depth buffer without
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * wishing to update an actual color render target
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateRenderTarget(pThis->svga.uWidth,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pDummyRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, NULL);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(target.sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(target.sid < pState->cSurfaces && pState->papSurfaces[target.sid]->id == target.sid, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Query the nr of quality levels for this particular format */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync && pRenderTarget->multiSampleTypeD3D == D3DMULTISAMPLE_NONE
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget: Creating stencil surface as texture!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dCreateTexture(pContext, cid, pRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync ((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#if 0 /* doesn't work */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget: sync dirty depth/stencil buffer\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = 0; i < pRenderTarget->faces[0].numMipLevels; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pRenderTarget->u.pSurface->LockRect(&LockedRect,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget: sync dirty texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pRenderTarget->pMipmapLevels[i].cbSurfacePitch));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uint8_t *pSrc = (uint8_t *)pRenderTarget->pMipmapLevels[i].pSurfaceData;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t j = 0; j < pRenderTarget->pMipmapLevels[i].size.height; j++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pDest, pSrc, pRenderTarget->pMipmapLevels[i].cbSurfacePitch);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSrc += pRenderTarget->pMipmapLevels[i].cbSurfacePitch;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo Assert(!pRenderTarget->fDirty); */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRenderTarget->flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pRenderTarget->u.pTexture->GetSurfaceLevel(0, &pStencilSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetDepthStencilSurface(pStencilSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetDepthStencilSurface(pRenderTarget->u.pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pRenderTarget->flags & SVGA3D_SURFACE_HINT_TEXTURE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* A texture surface can be used as a render target to fill it and later on used as a texture. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->flags, pRenderTarget->format));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dCreateTexture(pContext, cid, pRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget; using texture %x created for another context (%d vs %d)\n", target.sid, pRenderTarget->idAssociatedContext, cid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pSharedSurface->u.pTexture->GetSurfaceLevel(0 /* Texture level 0 */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pRenderTarget->u.pTexture->GetSurfaceLevel(0 /* Texture level 0 */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Query the nr of quality levels for this particular format */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetRenderTarget COLOR; cQualityLevels=%d\n", cQualityLevels));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Create rendertarget (%d,%d) format=%x multisample=%x\n", pRenderTarget->pMipmapLevels[0].size.width, pRenderTarget->pMipmapLevels[0].size.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
2b114c590cf5a19f8047cd7bde9c7e5ae00aa22bvboxsync hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->pMipmapLevels[0].size.width,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync ((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pRenderTarget->fUsageD3D & D3DUSAGE_RENDERTARGET, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRenderTarget->flags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pSurface->Release(); /* Release reference to texture level 0 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Changing the render target resets the viewport; restore it here. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync /* Changing the render target also resets the scissor rectangle; restore it as well. */
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA texture combiner value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic DWORD vmsvga3dTextureCombiner2D3D(uint32_t value)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA texture arg data value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic DWORD vmsvga3dTextureArgData2D3D(uint32_t value)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Convert SVGA texture transform flag value to its D3D equivalent
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncstatic DWORD vmsvga3dTextTransformFlags2D3D(uint32_t value)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetTextureState(PVGASTATE pThis, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetTextureState %x cTextureState=%d\n", cid, cTextureStates));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetTextureState invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i = 0; i < cTextureStates; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DTEXTURESTAGESTATETYPE textureType = D3DTSS_FORCE_DWORD;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DSAMPLERSTATETYPE samplerType = D3DSAMP_FORCE_DWORD;
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync Log(("vmsvga3dSetTextureState: cid=%x stage=%d type=%s (%x) val=%x\n", cid, currentStage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync /** @todo Is this the appropriate limit for all kinds of textures? It is the
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync * size of aSidActiveTexture and for binding/unbinding we cannot exceed it. */
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync if (RT_UNLIKELY(currentStage >= SVGA3D_MAX_TEXTURE_STAGE))
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x\n", i, pTextureState[i].stage, pTextureState[i].name));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Record the texture state for vm state saving. */
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync pContext->state.aTextureState[currentStage][pTextureState[i].name] = pTextureState[i];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_COLOROP: /* SVGA3dTextureCombiner */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_COLORARG0: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_COLORARG1: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_COLORARG2: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ALPHAOP: /* SVGA3dTextureCombiner */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ALPHAARG0: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ALPHAARG1: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ALPHAARG2: /* SVGA3dTextureArgData */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_TEXTURETRANSFORMFLAGS: /* SVGA3dTexTransformFlags */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = vmsvga3dTextTransformFlags2D3D(pTextureState[i].value);
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture surface id=%x\n", currentStage, pTextureState[i].value));
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync pContext->aSidActiveTexture[currentStage] = SVGA3D_INVALID_ID;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unselect the currently associated texture. */
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync hr = pContext->pDevice->SetTexture(currentStage, NULL);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture surface id=%x (%d,%d)\n", currentStage, pTextureState[i].value, pSurface->pMipmapLevels[0].size.width, pSurface->pMipmapLevels[0].size.height));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->pMipmapLevels[0].size.width, pSurface->pMipmapLevels[0].size.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync int rc = vmsvga3dCreateTexture(pContext, cid, pSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetTextureState; using texture %x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pSurface);
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync hr = pContext->pDevice->SetTexture(currentStage, pSharedSurface->u.pTexture);
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync hr = pContext->pDevice->SetTexture(currentStage, pSurface->u.pTexture);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Finished; continue with the next one. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ADDRESSW: /* SVGA3dTextureAddress */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ADDRESSU: /* SVGA3dTextureAddress */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_ADDRESSV: /* SVGA3dTextureAddress */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_MIPFILTER: /* SVGA3dTextureFilter */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_MAGFILTER: /* SVGA3dTextureFilter */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_MINFILTER: /* SVGA3dTextureFilter */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync val = pTextureState[i].value; /* Identical otherwise */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL: /* uint32_t */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL: /* uint32_t */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Boolean in D3D */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Internal commands, that don't map directly to the SetTextureStageState API. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_TS_TEXCOORDGEN: /* SVGA3dTextureCoordGen */
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync hr = pContext->pDevice->SetTextureStageState(currentStage, textureType, val);
33444ab17e1a7381b720782fd083cb0e49b84dc1vboxsync hr = pContext->pDevice->SetSamplerState(currentStage, samplerType, val);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTextureStageState failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetMaterial(PVGASTATE pThis, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetMaterial %x face %d\n", cid, face));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetMaterial invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(face < SVGA3D_FACE_MAX, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aMaterial[face].material = *pMaterial;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_MATERIAL;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @note face not used for D3D9 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo ignore everything except SVGA3D_FACE_NONE? */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync //Assert(face == SVGA3D_FACE_NONE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetMaterial: SetMaterial failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetLightData(PVGASTATE pThis, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetLightData %x index=%d\n", cid, index));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetLightData invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_LIGHTTYPE_SPOT1: /* 1-cone, in degrees */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync case SVGA3D_LIGHTTYPE_SPOT2: /* 2-cone, in radians */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Store for vm state save/restore */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aLightData[index].fValidData = true;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync light.Position.z = pData->position[2]; /* @note 4th position not available in D3D9 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync light.Direction.z = pData->direction[2]; /* @note 4th position not available in D3D9 */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightData: SetLight failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetLightEnabled(PVGASTATE pThis, uint32_t cid, uint32_t index, uint32_t enabled)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetLightEnabled %x %d -> %d\n", cid, index, enabled));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetLightEnabled invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Store for vm state save/restore */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.aLightData[index].fEnabled = !!enabled;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->LightEnable(index, (BOOL)enabled);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightEnabled: LightEnable failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetViewPort %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetViewPort invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_VIEWPORT;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* viewPort.MinZ & MaxZ are not changed from the current setting. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid, uint32_t index, float plane[4])
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetClipPlane %x %d (%d,%d)(%d,%d)\n", cid, index, (unsigned)(plane[0] * 100.0), (unsigned)(plane[1] * 100.0), (unsigned)(plane[2] * 100.0), (unsigned)(plane[3] * 100.0)));
25c99e8727472c3f8c5fc85c09628f75cc6f2cc6vboxsync AssertReturn(index < SVGA3D_CLIPPLANE_MAX, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetClipPlane invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Store for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pContext->state.aClipPlane[index].plane, plane, sizeof(plane));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetClipPlane(index, plane);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetClipPlane: SetClipPlane failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandClear %x clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandClear invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRectD3D = (D3DRECT *)RTMemAlloc(sizeof(D3DRECT) * cRects);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned i=0; i < cRects; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dCommandClear: rect %d (%d,%d)(%d,%d)\n", i, pRect[i].x, pRect[i].y, pRect[i].x + pRect[i].w, pRect[i].y + pRect[i].h));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRectD3D[i].x2 = pRect[i].x + pRect[i].w; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRectD3D[i].y2 = pRect[i].y + pRect[i].h; /* exclusive */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->Clear(cRects, pRectD3D, clearFlagD3D, (D3DCOLOR)color, depth, stencil);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandClear: Clear failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Make sure we can track drawing usage of active render targets. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->sidRenderTarget != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->sidRenderTarget);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Convert VMWare vertex declaration to its D3D equivalent. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dVertexDecl2D3D(SVGA3dVertexArrayIdentity &identity, D3DVERTEXELEMENT9 *pVertexElement)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* usage, method and type are identical; make sure. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_DECLTYPE_FLOAT1 == D3DDECLTYPE_FLOAT1);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_DECLTYPE_FLOAT16_4 == D3DDECLTYPE_FLOAT16_4);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_DECLMETHOD_DEFAULT == D3DDECLMETHOD_DEFAULT);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED == D3DDECLMETHOD_LOOKUPPRESAMPLED);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DDECLUSAGE_POSITION == SVGA3D_DECLUSAGE_POSITION);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertCompile(D3DDECLUSAGE_SAMPLE == SVGA3D_DECLUSAGE_SAMPLE);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync/* Convert VMWare primitive type to its D3D equivalent. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dPrimitiveType2D3D(SVGA3dPrimitiveType PrimitiveType, D3DPRIMITIVETYPE *pPrimitiveTypeD3D)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dDrawPrimitivesProcessVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t idStream, D3DVERTEXELEMENT9 *pVertexElement)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Create a vertex declaration array */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned sidVertex = pVertexDecl[iVertex].array.surfaceId;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(sidVertex < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync AssertReturn(sidVertex < pState->cSurfaces && pState->papSurfaces[sidVertex]->id == sidVertex, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: vertex surface %x stream %d\n", sidVertex, idStream));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: type=%s (%d) method=%s (%d) usage=%s (%d) usageIndex=%d stride=%d offset=%d\n", vmsvgaDeclType2String(pVertexDecl[iVertex].identity.type), pVertexDecl[iVertex].identity.type, vmsvgaDeclMethod2String(pVertexDecl[iVertex].identity.method), pVertexDecl[iVertex].identity.method, vmsvgaDeclUsage2String(pVertexDecl[iVertex].identity.usage), pVertexDecl[iVertex].identity.usage, pVertexDecl[iVertex].identity.usageIndex, pVertexDecl[iVertex].array.stride, pVertexDecl[iVertex].array.offset));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dVertexDecl2D3D(pVertexDecl[iVertex].identity, &pVertexElement[iVertex]);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: stride == 0! Can be valid\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Find the min and max vertex offset to determine the right base offset to use in the vertex declaration. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pVertexDecl[iVertex].array.offset > uVertexMaxOffset)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uVertexMaxOffset = pVertexDecl[iVertex].array.offset;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pVertexDecl[iVertex].array.offset < uVertexMinOffset)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uVertexMinOffset = pVertexDecl[iVertex].array.offset;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: create vertex buffer fDirty=%d\n", pVertexSurface->fDirty));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateVertexBuffer(pVertexSurface->pMipmapLevels[0].cbSurface,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY /* possible severe performance penalty otherwise (according to d3d debug output) */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync 0, /* non-FVF */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync pVertexSurface->idAssociatedContext = pContext->id;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pVertexSurface->u.pVertexBuffer->Lock(0, 0, &pData, 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Lock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pData, pVertexSurface->pMipmapLevels[0].pSurfaceData, pVertexSurface->pMipmapLevels[0].cbSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Unlock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pVertexSurface->flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Set the right vertex offset values for each declaration. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pVertexElement[iVertex].Offset = pVertexDecl[iVertex].array.offset - uVertexMinOffset;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pVertexElement[iVertex].Offset >= pVertexDecl[0].array.stride)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: WARNING: offset > stride!!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: vertex %d offset = %d (stride %d) (min=%d max=%d)\n", iVertex, pVertexDecl[iVertex].array.offset, pVertexDecl[iVertex].array.stride, uVertexMinOffset, uVertexMaxOffset));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned sidVertex = pVertexDecl[0].array.surfaceId;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned strideVertex = pVertexDecl[0].array.stride;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: SetStreamSource %d min offset=%d stride=%d\n", idStream, uVertexMinOffset, strideVertex));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
07557d07616212d7ba6e7ab3059e85cb14633775vboxsyncint vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
07557d07616212d7ba6e7ab3059e85cb14633775vboxsync uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync IDirect3DVertexDeclaration9 *pVertexDeclD3D = NULL;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives %x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(numRanges && numRanges <= SVGA3D_MAX_DRAW_PRIMITIVE_RANGES, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(!cVertexDivisor || cVertexDivisor == numVertexDecls, VERR_INVALID_PARAMETER);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* @todo */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Begin a scene before rendering anything. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("BeginScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pVertexElement = (D3DVERTEXELEMENT9 *)RTMemAllocZ(sizeof(D3DVERTEXELEMENT9) * (numVertexDecls + 1));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Process all vertex declarations. Each vertex buffer is represented by one stream source id. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (iVertex = iCurrentVertex; iVertex < numVertexDecls; iVertex++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync && pVertexDecl[iVertex].array.surfaceId != sidVertex
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* We must put vertex declarations that start at a different element in another stream as d3d only handles offsets < stride. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync && pVertexDecl[iVertex].array.offset >= uVertexMinOffset + pVertexDecl[iCurrentVertex].array.stride
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (uVertexMinOffset > pVertexDecl[iVertex].array.offset)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync uVertexMinOffset = pVertexDecl[iVertex].array.offset;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pState, pContext, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex], iCurrentStreamId, &pVertexElement[iCurrentVertex]);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Mark the end. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(&pVertexElement[numVertexDecls], &VertexEnd, sizeof(VertexEnd));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateVertexDeclaration(&pVertexElement[0],
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexDeclaration failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetVertexDeclaration(pVertexDeclD3D);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetVertexDeclaration failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Now draw the primitives. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (unsigned iPrimitive = 0; iPrimitive < numRanges; iPrimitive++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned sidIndex = pRange[iPrimitive].indexArray.surfaceId;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Primitive %d: type %s\n", iPrimitive, vmsvga3dPrimitiveType2String(pRange[iPrimitive].primType)));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync rc = vmsvga3dPrimitiveType2D3D(pRange[iPrimitive].primType, &PrimitiveTypeD3D);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Triangle strips or fans with just one primitive don't make much sense and are identical to triangle lists.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync * Workaround for NVidia driver crash when encountering some of these.
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) || pRange[iPrimitive].indexWidth == sizeof(uint16_t), ("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
0ffa3979e9b800f5931dd30c51ec3c0aadc3a1f1vboxsync Assert(sidIndex < pState->cSurfaces && pState->papSurfaces[sidIndex]->id == sidIndex);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: index surface %x\n", sidIndex));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: create index buffer fDirty=%d\n", pIndexSurface->fDirty));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateIndexBuffer(pIndexSurface->pMipmapLevels[0].cbSurface,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY /* possible severe performance penalty otherwise (according to d3d debug output */,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync (pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? D3DFMT_INDEX16 : D3DFMT_INDEX32,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateIndexBuffer failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: sync index buffer\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pIndexSurface->u.pIndexBuffer->Lock(0, 0, &pData, 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Lock vertex failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pData, pIndexSurface->pMipmapLevels[0].pSurfaceData, pIndexSurface->pMipmapLevels[0].cbSurface);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Unlock vertex failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pIndexSurface->flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetIndices(pIndexSurface->u.pIndexBuffer);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex (NULL) failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned sidVertex = pVertexDecl[0].array.surfaceId;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync unsigned strideVertex = pVertexDecl[0].array.stride;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Render without an index buffer */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("DrawPrimitive %x primitivecount=%d index index bias=%d stride=%d\n", PrimitiveTypeD3D, pRange[iPrimitive].primitiveCount, pRange[iPrimitive].indexBias, strideVertex));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->DrawPrimitive(PrimitiveTypeD3D,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: DrawPrimitive failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Assert(pRange[iPrimitive].indexBias >= 0); /* @todo */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync numVertices = pVertexDecl[0].rangeHint.last - pVertexDecl[0].rangeHint.first + 1;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync numVertices = pVertexSurface->pMipmapLevels[0].cbSurface / strideVertex - pVertexDecl[0].array.offset / strideVertex - pVertexDecl[0].rangeHint.first - pRange[iPrimitive].indexBias;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Render with an index buffer */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("DrawIndexedPrimitive %x startindex=%d numVertices=%d, primitivecount=%d index format=%d index bias=%d stride=%d\n", PrimitiveTypeD3D, pVertexDecl[0].rangeHint.first, numVertices, pRange[iPrimitive].primitiveCount, (pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? D3DFMT_INDEX16 : D3DFMT_INDEX32, pRange[iPrimitive].indexBias, strideVertex));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->DrawIndexedPrimitive(PrimitiveTypeD3D,
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRange[iPrimitive].indexBias, /* BaseVertexIndex */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync 0, /* MinVertexIndex */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pRange[iPrimitive].indexArray.offset / pRange[iPrimitive].indexWidth, /* StartIndex */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: DrawIndexedPrimitive failed with %x\n", hr));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("EndScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Clear streams above 1 as they might accidentally be reused in the future. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dDrawPrimitives: clear stream %d\n", i));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetStreamSource(i, NULL, 0, 0);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync#if 0 /* Flush queue */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pQuery);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: CreateQuery failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: Issue failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync while (true)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Make sure we can track drawing usage of active render targets and textures. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync//// if (pContext->sidActiveTexture == 0x3d)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dCommandPresent(pThis, pContext->sidRenderTarget /*pContext->aSidActiveTexture[0] */, 0, &rect);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("EndScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetScissorRect %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dSetScissorRect invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Store for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_SCISSORRECT;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetScissorRect: SetScissorRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderDefine %x shid=%x type=%s cbData=%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
c6ade8a5a12fad69394e7223b7ea170bd729f0f4vboxsync Log3(("shader code:\n%.*Rhxd\n", cbData, pShaderData));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderDefine invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(shid < SVGA3D_MAX_SHADER_IDS, VERR_INVALID_PARAMETER);
9b37cfa6efe394762d21f3710df8fa46b2758880vboxsync void *pvNew = RTMemRealloc(pContext->paVertexShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memset(&pContext->paVertexShader[pContext->cVertexShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cVertexShaders));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = pContext->cVertexShaders; i < shid + 1; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->paVertexShader[i].id = SVGA3D_INVALID_ID;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* If one already exists with this id, then destroy it now. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paVertexShader[shid].type);
9b37cfa6efe394762d21f3710df8fa46b2758880vboxsync void *pvNew = RTMemRealloc(pContext->paPixelShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memset(&pContext->paPixelShader[pContext->cPixelShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cPixelShaders));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync for (uint32_t i = pContext->cPixelShaders; i < shid + 1; i++)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* If one already exists with this id, then destroy it now. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paPixelShader[shid].type);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertReturn(pShader->pShaderProgram, VERR_NO_MEMORY);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync memcpy(pShader->pShaderProgram, pShaderData, cbData);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreateVertexShader((const DWORD *)pShaderData, &pShader->u.pVertexShader);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->CreatePixelShader((const DWORD *)pShaderData, &pShader->u.pPixelShader);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderDefine: CreateVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderDestroy %x shid=%x type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderDestroy invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dShaderSet(PVGASTATE pThis, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderSet %x type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_VERTEXSHADER;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHADER pShader = &pContext->paVertexShader[shid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetVertexShader(pShader->u.pVertexShader);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unselect shader. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Save for vm state save/restore. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_PIXELSHADER;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSHADER pShader = &pContext->paPixelShader[shid];
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetPixelShader(pShader->u.pPixelShader);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync /* Unselect shader. */
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderSetConst %x reg=%x type=%s ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", ctype));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("vmsvga3dShaderSetConst invalid context id!\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync Log(("Constant %d: value=%x-%x-%x-%x\n", reg + i, pValues[i*4 + 0], pValues[i*4 + 1], pValues[i*4 + 2], pValues[i*4 + 3]));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync vmsvga3dSaveShaderConst(pContext, reg + i, type, ctype, pValues[i*4 + 0], pValues[i*4 + 1], pValues[i*4 + 2], pValues[i*4 + 3]);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetVertexShaderConstantF(reg, (const float *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetVertexShaderConstantI(reg, (const int *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetVertexShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetVertexShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetPixelShaderConstantF(reg, (const float *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetPixelShaderConstantI(reg, (const int *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync hr = pContext->pDevice->SetPixelShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetPixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dQueryBegin(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dQueryEnd(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsyncint vmsvga3dQueryWait(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
4b2cc0de52a6bda0d5420b7b3d1b62d333f2135evboxsync bool const fBufferingSaved = RTLogRelSetBuffering(true /*fBuffered*/);
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSRTPATCH)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSNPATCH)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps2 & D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps2 & D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->Caps3 & D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->Caps3 & D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_CANBLTSYSTONONLOCAL)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_CANRENDERAFTERFLIP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_EXECUTESYSTEMMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_EXECUTEVIDEOMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_SEPARATETEXTUREMEMORIES)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DDEVCAPS_SEPARATETEXTUREMEMORIES\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_TEXTURENONLOCALVIDMEM)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_TEXTURESYSTEMMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_TEXTUREVIDEOMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXSYSTEMMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXVIDEOMEMORY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTEXTURECAPS_NONPOW2CONDITIONAL\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_NOPROJECTEDBUMPENV)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTEXTURECAPS_NOPROJECTEDBUMPENV\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_PERSPECTIVE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_PROJECTED)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_SQUAREONLY)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_CLAMP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_INDEPENDENTUV)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRROR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRRORONCE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_WRAP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG1)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG2)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE2X)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE4X)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSIGNED2X)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDDIFFUSEALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDFACTORALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHAPM)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDCURRENTALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_PREMODULATE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync LogRel((" - D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA\n"));
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAPLUMINANCE)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
930b5f872e89407f445d4000d4e4aaecaa6a0998vboxsync if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MULTIPLYADD)
de8636fc8bdeb02161ee5b329c407dd0c48b0885vboxsync LogRel(("PixelShaderVersion: %#x (%u.%u)\n", pCaps->PixelShaderVersion,
de8636fc8bdeb02161ee5b329c407dd0c48b0885vboxsync D3DSHADER_VERSION_MAJOR(pCaps->PixelShaderVersion), D3DSHADER_VERSION_MINOR(pCaps->PixelShaderVersion)));
de8636fc8bdeb02161ee5b329c407dd0c48b0885vboxsync LogRel(("VertexShaderVersion: %#x (%u.%u)\n", pCaps->VertexShaderVersion,