#ifndef __DEVVMWARE3D_STATE_H__

#define __DEVVMWARE3D_STATE_H__

int vmsvga3dLoadExec(PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)

{

PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;

AssertReturn(pState, VERR_NO_MEMORY);

int rc;

uint32_t cContexts, cSurfaces;

/* Must initialize now as the recreation calls below rely on an initialized 3d subsystem. */

vmsvga3dPowerOn(pThis);

/* Get the generic 3d state first. */

rc = SSMR3GetStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);

AssertRCReturn(rc, rc);

cContexts = pState->cContexts;

cSurfaces = pState->cSurfaces;

pState->cContexts = 0;

pState->cSurfaces = 0;

/* Fetch all active contexts. */

for (uint32_t i = 0; i < cContexts; i++)

{

PVMSVGA3DCONTEXT pContext;

uint32_t cid;

/* Get the context id */

rc = SSMR3GetU32(pSSM, &cid);

AssertRCReturn(rc, rc);

if (cid != SVGA3D_INVALID_ID)

{

uint32_t cPixelShaderConst, cVertexShaderConst, cPixelShaders, cVertexShaders;

rc = vmsvga3dContextDefine(pThis, cid);

AssertRCReturn(rc, rc);

pContext = &pState->paContext[i];

AssertReturn(pContext->id == cid, VERR_INTERNAL_ERROR);

rc = SSMR3GetStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);

AssertRCReturn(rc, rc);

cPixelShaders = pContext->cPixelShaders;

cVertexShaders = pContext->cVertexShaders;

cPixelShaderConst = pContext->state.cPixelShaderConst;

cVertexShaderConst = pContext->state.cVertexShaderConst;

pContext->cPixelShaders = 0;

pContext->cVertexShaders = 0;

pContext->state.cPixelShaderConst = 0;

pContext->state.cVertexShaderConst = 0;

/* Fetch all pixel shaders. */

for (uint32_t j = 0; j < cPixelShaders; j++)

{

VMSVGA3DSHADER shader;

uint32_t shid;

/* Fetch the id first. */

rc = SSMR3GetU32(pSSM, &shid);

AssertRCReturn(rc, rc);

if (shid != SVGA3D_INVALID_ID)

{

uint32_t *pData;

/* Fetch a copy of the shader struct. */

rc = SSMR3GetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);

AssertRCReturn(rc, rc);

pData = (uint32_t *)RTMemAlloc(shader.cbData);

AssertReturn(pData, VERR_NO_MEMORY);

rc = SSMR3GetMem(pSSM, pData, shader.cbData);

AssertRCReturn(rc, rc);

rc = vmsvga3dShaderDefine(pThis, cid, shid, shader.type, shader.cbData, pData);

AssertRCReturn(rc, rc);

RTMemFree(pData);

}

}

/* Fetch all vertex shaders. */

for (uint32_t j = 0; j < cVertexShaders; j++)

{

VMSVGA3DSHADER shader;

uint32_t shid;

/* Fetch the id first. */

rc = SSMR3GetU32(pSSM, &shid);

AssertRCReturn(rc, rc);

if (shid != SVGA3D_INVALID_ID)

{

uint32_t *pData;

/* Fetch a copy of the shader struct. */

rc = SSMR3GetStructEx(pSSM, &shader, sizeof(shader), 0, g_aVMSVGA3DSHADERFields, NULL);

AssertRCReturn(rc, rc);

pData = (uint32_t *)RTMemAlloc(shader.cbData);

AssertReturn(pData, VERR_NO_MEMORY);

rc = SSMR3GetMem(pSSM, pData, shader.cbData);

AssertRCReturn(rc, rc);

rc = vmsvga3dShaderDefine(pThis, cid, shid, shader.type, shader.cbData, pData);

AssertRCReturn(rc, rc);

RTMemFree(pData);

}

}

/* Fetch pixel shader constants. */

for (uint32_t j = 0; j < cPixelShaderConst; j++)

{

VMSVGASHADERCONST ShaderConst;

rc = SSMR3GetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);

AssertRCReturn(rc, rc);

if (ShaderConst.fValid)

{

rc = vmsvga3dShaderSetConst(pThis, cid, j, SVGA3D_SHADERTYPE_PS, ShaderConst.ctype, 1, ShaderConst.value);

AssertRCReturn(rc, rc);

}

}

/* Fetch vertex shader constants. */

for (uint32_t j = 0; j < cVertexShaderConst; j++)

{

VMSVGASHADERCONST ShaderConst;

rc = SSMR3GetStructEx(pSSM, &ShaderConst, sizeof(ShaderConst), 0, g_aVMSVGASHADERCONSTFields, NULL);

AssertRCReturn(rc, rc);

if (ShaderConst.fValid)

{

rc = vmsvga3dShaderSetConst(pThis, cid, j, SVGA3D_SHADERTYPE_VS, ShaderConst.ctype, 1, ShaderConst.value);

AssertRCReturn(rc, rc);

}

}

}

}

/* Fetch all surfaces. */

for (uint32_t i = 0; i < cSurfaces; i++)

{

uint32_t sid;

/* Fetch the id first. */

rc = SSMR3GetU32(pSSM, &sid);

AssertRCReturn(rc, rc);

if (sid != SVGA3D_INVALID_ID)

{

VMSVGA3DSURFACE surface;

/* Fetch the surface structure first. */

rc = SSMR3GetStructEx(pSSM, &surface, sizeof(surface), 0, g_aVMSVGA3DSURFACEFields, NULL);

AssertRCReturn(rc, rc);

{

uint32_t cMipLevels = surface.faces[0].numMipLevels * surface.cFaces;

PVMSVGA3DMIPMAPLEVEL pMipmapLevel = (PVMSVGA3DMIPMAPLEVEL)RTMemAlloc(cMipLevels * sizeof(VMSVGA3DMIPMAPLEVEL));

AssertReturn(pMipmapLevel, VERR_NO_MEMORY);

SVGA3dSize *pMipmapLevelSize = (SVGA3dSize *)RTMemAlloc(cMipLevels * sizeof(SVGA3dSize));

AssertReturn(pMipmapLevelSize, VERR_NO_MEMORY);

/* Load the mip map level info. */

for (uint32_t face=0; face < surface.cFaces; face++)

{

for (uint32_t j = 0; j < surface.faces[0].numMipLevels; j++)

{

uint32_t idx = j + face * surface.faces[0].numMipLevels;

/* Load the mip map level struct. */

rc = SSMR3GetStructEx(pSSM, &pMipmapLevel[idx], sizeof(pMipmapLevel[idx]), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);

AssertRCReturn(rc, rc);

pMipmapLevelSize[idx] = pMipmapLevel[idx].size;

}

}

rc = vmsvga3dSurfaceDefine(pThis, sid, surface.flags, surface.format, surface.faces, surface.multiSampleCount, surface.autogenFilter, cMipLevels, pMipmapLevelSize);

AssertRCReturn(rc, rc);

RTMemFree(pMipmapLevelSize);

RTMemFree(pMipmapLevel);

}

PVMSVGA3DSURFACE pSurface = &pState->paSurface[sid];

Assert(pSurface->id == sid);

pSurface->fDirty = false;

/* Load the mip map level data. */

for (uint32_t j = 0; j < pSurface->faces[0].numMipLevels * pSurface->cFaces; j++)

{

PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[j];

bool fDataPresent = false;

Assert(pMipmapLevel->cbSurface);

pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);

AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);

/* Fetch the data present boolean first. */

rc = SSMR3GetBool(pSSM, &fDataPresent);

AssertRCReturn(rc, rc);

Log(("Surface sid=%x: load mipmap level %d with %x bytes data (present=%d).\n", sid, j, pMipmapLevel->cbSurface, fDataPresent));

if (fDataPresent)

{

rc = SSMR3GetMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);

AssertRCReturn(rc, rc);

pMipmapLevel->fDirty = true;

pSurface->fDirty = true;

}

else

{

pMipmapLevel->fDirty = false;

}

}

}

}

/* Reinitialize all active contexts. */

for (uint32_t i = 0; i < pState->cContexts; i++)

{

PVMSVGA3DCONTEXT pContext = &pState->paContext[i];

uint32_t cid = pContext->id;

if (cid != SVGA3D_INVALID_ID)

{

/* First set the render targets as they change the internal state (reset viewport etc) */

Log(("vmsvga3dLoadExec: Recreate render targets BEGIN\n"));

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aRenderTargets); j++)

{

if (pContext->state.aRenderTargets[j] != SVGA3D_INVALID_ID)

{

SVGA3dSurfaceImageId target;

target.sid = pContext->state.aRenderTargets[j];

target.face = 0;

target.mipmap = 0;

rc = vmsvga3dSetRenderTarget(pThis, cid, (SVGA3dRenderTargetType)j, target);

AssertRCReturn(rc, rc);

}

}

Log(("vmsvga3dLoadExec: Recreate render targets END\n"));

/* Recreate the render state */

Log(("vmsvga3dLoadExec: Recreate render state BEGIN\n"));

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aRenderState); j++)

{

SVGA3dRenderState *pRenderState = &pContext->state.aRenderState[j];

if (pRenderState->state != SVGA3D_RS_INVALID)

vmsvga3dSetRenderState(pThis, pContext->id, 1, pRenderState);

}

Log(("vmsvga3dLoadExec: Recreate render state END\n"));

/* Recreate the texture state */

Log(("vmsvga3dLoadExec: Recreate texture state BEGIN\n"));

for (uint32_t iStage = 0; iStage < SVGA3D_MAX_TEXTURE_STAGE; iStage++)

{

for (uint32_t j = 0; j < SVGA3D_TS_MAX; j++)

{

SVGA3dTextureState *pTextureState = &pContext->state.aTextureState[iStage][j];

if (pTextureState->name != SVGA3D_TS_INVALID)

vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureState);

}

}

Log(("vmsvga3dLoadExec: Recreate texture state END\n"));

/* Reprogram the clip planes. */

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aClipPlane); j++)

{

if (pContext->state.aClipPlane[j].fValid == true)

vmsvga3dSetClipPlane(pThis, cid, j, pContext->state.aClipPlane[j].plane);

}

/* Reprogram the light data. */

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aLightData); j++)

{

if (pContext->state.aLightData[j].fValidData == true)

vmsvga3dSetLightData(pThis, cid, j, &pContext->state.aLightData[j].data);

if (pContext->state.aLightData[j].fEnabled)

vmsvga3dSetLightEnabled(pThis, cid, j, true);

}

/* Recreate the transform state. */

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_TRANSFORM)

{

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aTransformState); j++)

{

if (pContext->state.aTransformState[j].fValid == true)

vmsvga3dSetTransform(pThis, cid, (SVGA3dTransformType)j, pContext->state.aTransformState[j].matrix);

}

}

/* Reprogram the material data. */

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_MATERIAL)

{

for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aMaterial); j++)

{

if (pContext->state.aMaterial[j].fValid == true)

vmsvga3dSetMaterial(pThis, cid, (SVGA3dFace)j, &pContext->state.aMaterial[j].material);

}

}

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)

vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)

vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)

vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)

vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);

if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)

vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);

}

}

return VINF_SUCCESS;

}

int vmsvga3dSaveExec(PVGASTATE pThis, PSSMHANDLE pSSM)

{

PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;

AssertReturn(pState, VERR_NO_MEMORY);

int rc;

/* Save a copy of the generic 3d state first. */

rc = SSMR3PutStructEx(pSSM, pState, sizeof(*pState), 0, g_aVMSVGA3DSTATEFields, NULL);

AssertRCReturn(rc, rc);

/* Save all active contexts. */

for (uint32_t i = 0; i < pState->cContexts; i++)

{

PVMSVGA3DCONTEXT pContext = &pState->paContext[i];

uint32_t cid = pContext->id;

/* Save the id first. */

rc = SSMR3PutU32(pSSM, cid);

AssertRCReturn(rc, rc);

if (cid != SVGA3D_INVALID_ID)

{

/* Save a copy of the context structure first. */

rc = SSMR3PutStructEx(pSSM, pContext, sizeof(*pContext), 0, g_aVMSVGA3DCONTEXTFields, NULL);

AssertRCReturn(rc, rc);

/* Save all pixel shaders. */

for (uint32_t j = 0; j < pContext->cPixelShaders; j++)

{

PVMSVGA3DSHADER pShader = &pContext->paPixelShader[j];

/* Save the id first. */

rc = SSMR3PutU32(pSSM, pShader->id);

AssertRCReturn(rc, rc);

if (pShader->id != SVGA3D_INVALID_ID)

{

uint32_t cbData = pShader->cbData;

/* Save a copy of the shader struct. */

rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);

AssertRCReturn(rc, rc);

Log(("Save pixelshader shid=%d with %x bytes code.\n", pShader->id, cbData));

rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);

AssertRCReturn(rc, rc);

}

}

/* Save all vertex shaders. */

for (uint32_t j = 0; j < pContext->cVertexShaders; j++)

{

PVMSVGA3DSHADER pShader = &pContext->paVertexShader[j];

/* Save the id first. */

rc = SSMR3PutU32(pSSM, pShader->id);

AssertRCReturn(rc, rc);

if (pShader->id != SVGA3D_INVALID_ID)

{

uint32_t cbData = pShader->cbData;

/* Save a copy of the shader struct. */

rc = SSMR3PutStructEx(pSSM, pShader, sizeof(*pShader), 0, g_aVMSVGA3DSHADERFields, NULL);

AssertRCReturn(rc, rc);

Log(("Save vertex shader shid=%d with %x bytes code.\n", pShader->id, cbData));

/* Fetch the shader code and save it. */

rc = SSMR3PutMem(pSSM, pShader->pShaderProgram, cbData);

AssertRCReturn(rc, rc);

}

}

/* Save pixel shader constants. */

for (uint32_t j = 0; j < pContext->state.cPixelShaderConst; j++)

{

rc = SSMR3PutStructEx(pSSM, &pContext->state.paPixelShaderConst[j], sizeof(pContext->state.paPixelShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);

AssertRCReturn(rc, rc);

}

/* Save vertex shader constants. */

for (uint32_t j = 0; j < pContext->state.cVertexShaderConst; j++)

{

rc = SSMR3PutStructEx(pSSM, &pContext->state.paVertexShaderConst[j], sizeof(pContext->state.paVertexShaderConst[j]), 0, g_aVMSVGASHADERCONSTFields, NULL);

AssertRCReturn(rc, rc);

}

}

}

/* Save all active surfaces. */

for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)

{

PVMSVGA3DSURFACE pSurface = &pState->paSurface[sid];

/* Save the id first. */

rc = SSMR3PutU32(pSSM, pSurface->id);

AssertRCReturn(rc, rc);

if (pSurface->id != SVGA3D_INVALID_ID)

{

/* Save a copy of the surface structure first. */

rc = SSMR3PutStructEx(pSSM, pSurface, sizeof(*pSurface), 0, g_aVMSVGA3DSURFACEFields, NULL);

AssertRCReturn(rc, rc);

/* Save the mip map level info. */

for (uint32_t face=0; face < pSurface->cFaces; face++)

{

for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)

{

uint32_t idx = i + face * pSurface->faces[0].numMipLevels;

PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];

/* Save a copy of the mip map level struct. */

rc = SSMR3PutStructEx(pSSM, pMipmapLevel, sizeof(*pMipmapLevel), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);

AssertRCReturn(rc, rc);

}

}

/* Save the mip map level data. */

for (uint32_t face=0; face < pSurface->cFaces; face++)

{

for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)

{

uint32_t idx = i + face * pSurface->faces[0].numMipLevels;

PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[idx];

Log(("Surface sid=%d: save mipmap level %d with %x bytes data.\n", sid, i, pMipmapLevel->cbSurface));

#ifdef VMSVGA3D_DIRECT3D

if (!pSurface->u.pSurface)

#else

if (pSurface->oglId.texture == OPENGL_INVALID_ID)

#endif

{

if (pMipmapLevel->fDirty)

{

/* Data follows */

rc = SSMR3PutBool(pSSM, true);

AssertRCReturn(rc, rc);

Assert(pMipmapLevel->cbSurface);

rc = SSMR3PutMem(pSSM, pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);

AssertRCReturn(rc, rc);

}

else

{

/* No data follows */

rc = SSMR3PutBool(pSSM, false);

AssertRCReturn(rc, rc);

}

}

else

{

#ifdef VMSVGA3D_DIRECT3D

void *pData;

bool fRenderTargetTexture = false;

bool fTexture = false;

bool fVertex = false;

bool fSkipSave = false;

HRESULT hr;

Assert(pMipmapLevel->cbSurface);

pData = RTMemAllocZ(pMipmapLevel->cbSurface);

AssertReturn(pData, VERR_NO_MEMORY);

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))

{

case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:

case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE:

/* @todo unable to easily fetch depth surface data in d3d 9 */

fSkipSave = true;

break;

case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:

fRenderTargetTexture = true;

/* no break */

case SVGA3D_SURFACE_HINT_TEXTURE:

fTexture = true;

/* no break */

case SVGA3D_SURFACE_HINT_RENDERTARGET:

{

D3DLOCKED_RECT LockedRect;

if (fTexture)

{

if (pSurface->bounce.pTexture)

{

if ( !pSurface->fDirty

&& fRenderTargetTexture

&& i == 0 /* only the first time */)

{

IDirect3DSurface9 *pSrc, *pDest;

/* @todo stricter checks for associated context */

uint32_t cid = pSurface->idAssociatedContext;

if ( cid >= pState->cContexts

|| pState->paContext[cid].id != cid)

{

Log(("vmsvga3dSaveExec invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->paContext[cid].id));

AssertFailedReturn(VERR_INVALID_PARAMETER);

}

PVMSVGA3DCONTEXT pContext = &pState->paContext[cid];

hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);

hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);

hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);

pSrc->Release();

pDest->Release();

}

hr = pSurface->bounce.pTexture->LockRect(i, /* texture level */

&LockedRect,

NULL,

D3DLOCK_READONLY);

}

else

hr = pSurface->u.pTexture->LockRect(i, /* texture level */

&LockedRect,

NULL,

D3DLOCK_READONLY);

}

else

hr = pSurface->u.pSurface->LockRect(&LockedRect,

NULL,

D3DLOCK_READONLY);

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);

/* Copy the data one line at a time in case the internal pitch is different. */

for (uint32_t j = 0; j < pMipmapLevel->size.height; j++)

{

memcpy((uint8_t *)pData + j * pMipmapLevel->cbSurfacePitch, (uint8_t *)LockedRect.pBits + j * LockedRect.Pitch, pMipmapLevel->cbSurfacePitch);

}

if (fTexture)

{

if (pSurface->bounce.pTexture)

{

hr = pSurface->bounce.pTexture->UnlockRect(i);

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);

}

else

hr = pSurface->u.pTexture->UnlockRect(i);

}

else

hr = pSurface->u.pSurface->UnlockRect();

AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSaveExec: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);

break;

}

case SVGA3D_SURFACE_HINT_VERTEXBUFFER:

fVertex = true;

/* no break */

case SVGA3D_SURFACE_HINT_INDEXBUFFER:

{

uint8_t *pD3DData;

if (fVertex)

hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);

else

hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pD3DData, D3DLOCK_READONLY);

AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));

memcpy(pData, pD3DData, pMipmapLevel->cbSurface);

if (fVertex)

hr = pSurface->u.pVertexBuffer->Unlock();

else

hr = pSurface->u.pIndexBuffer->Unlock();

AssertMsg(hr == D3D_OK, ("vmsvga3dSaveExec: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));

break;

}

default:

AssertFailed();

break;

}

if (!fSkipSave)

{

/* Data follows */

rc = SSMR3PutBool(pSSM, true);

AssertRCReturn(rc, rc);

/* And write the surface data. */

rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);

AssertRCReturn(rc, rc);

}

else

{

/* No data follows */

rc = SSMR3PutBool(pSSM, false);

AssertRCReturn(rc, rc);

}

RTMemFree(pData);

#elif defined(VMSVGA3D_OPENGL)

void *pData = NULL;

# ifdef VMSVGA3D_OGL_WITH_SHARED_CTX

PVMSVGA3DCONTEXT pContext = &pState->SharedCtx;

VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);

# else

/* @todo stricter checks for associated context */

uint32_t cid = pSurface->idAssociatedContext;

if ( cid >= pState->cContexts

|| pState->paContext[cid].id != cid)

{

Log(("vmsvga3dSaveExec: invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->paContext[cid].id));

AssertFailedReturn(VERR_INVALID_PARAMETER);

}

PVMSVGA3DCONTEXT pContext = &pState->paContext[cid];

VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);

# endif

Assert(pMipmapLevel->cbSurface);

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))

{

default:

AssertFailed();

/* no break */

case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:

case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE:

/* @todo fetch data from the renderbuffer */

/* No data follows */

rc = SSMR3PutBool(pSSM, false);

AssertRCReturn(rc, rc);

break;

case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:

case SVGA3D_SURFACE_HINT_TEXTURE:

case SVGA3D_SURFACE_HINT_RENDERTARGET:

{

GLint activeTexture;

pData = RTMemAllocZ(pMipmapLevel->cbSurface);

AssertReturn(pData, VERR_NO_MEMORY);

glGetIntegerv(GL_TEXTURE_BINDING_2D, &activeTexture);

VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);

glBindTexture(GL_TEXTURE_2D, pSurface->oglId.texture);

VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);

glGetTexImage(GL_TEXTURE_2D,

i,

pSurface->formatGL,

pSurface->typeGL,

pData);

VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);

/* Data follows */

rc = SSMR3PutBool(pSSM, true);

AssertRCReturn(rc, rc);

/* And write the surface data. */

rc = SSMR3PutMem(pSSM, pData, pMipmapLevel->cbSurface);

AssertRCReturn(rc, rc);

/* Restore the old active texture. */

glBindTexture(GL_TEXTURE_2D, activeTexture);

VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);

break;

}

case SVGA3D_SURFACE_HINT_VERTEXBUFFER:

case SVGA3D_SURFACE_HINT_INDEXBUFFER:

{

uint8_t *pBufferData;

pState->ext.glBindBuffer(GL_ARRAY_BUFFER, pSurface->oglId.buffer);

VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);

pBufferData = (uint8_t *)pState->ext.glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);

VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);

Assert(pBufferData);

/* Data follows */

rc = SSMR3PutBool(pSSM, true);

AssertRCReturn(rc, rc);

/* And write the surface data. */

rc = SSMR3PutMem(pSSM, pBufferData, pMipmapLevel->cbSurface);

AssertRCReturn(rc, rc);

pState->ext.glUnmapBuffer(GL_ARRAY_BUFFER);

VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);

pState->ext.glBindBuffer(GL_ARRAY_BUFFER, 0);

VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);

}

}

if (pData)

RTMemFree(pData);

#else

#error "Unexpected 3d backend"

#endif

}

}

}

}

}

return VINF_SUCCESS;

}

static uint32_t vmsvga3dSaveShaderConst(PVMSVGA3DCONTEXT pContext, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t val1, uint32_t val2, uint32_t val3, uint32_t val4)

{

/* Choose a sane upper limit. */

AssertReturn(reg < _32K, VERR_INVALID_PARAMETER);

if (type == SVGA3D_SHADERTYPE_VS)

{

if (pContext->state.cVertexShaderConst <= reg)

{

pContext->state.paVertexShaderConst = (PVMSVGASHADERCONST)RTMemRealloc(pContext->state.paVertexShaderConst, sizeof(VMSVGASHADERCONST) * (reg + 1));

AssertReturn(pContext->state.paVertexShaderConst, VERR_NO_MEMORY);

for (uint32_t i = pContext->state.cVertexShaderConst; i < reg + 1; i++)

pContext->state.paVertexShaderConst[i].fValid = false;

pContext->state.cVertexShaderConst = reg + 1;

}

pContext->state.paVertexShaderConst[reg].fValid = true;

pContext->state.paVertexShaderConst[reg].ctype = ctype;

pContext->state.paVertexShaderConst[reg].value[0] = val1;

pContext->state.paVertexShaderConst[reg].value[1] = val2;

pContext->state.paVertexShaderConst[reg].value[2] = val3;

pContext->state.paVertexShaderConst[reg].value[3] = val4;

}

else

{

Assert(type == SVGA3D_SHADERTYPE_PS);

if (pContext->state.cPixelShaderConst <= reg)

{

pContext->state.paPixelShaderConst = (PVMSVGASHADERCONST)RTMemRealloc(pContext->state.paPixelShaderConst, sizeof(VMSVGASHADERCONST) * (reg + 1));

AssertReturn(pContext->state.paPixelShaderConst, VERR_NO_MEMORY);

for (uint32_t i = pContext->state.cPixelShaderConst; i < reg + 1; i++)

pContext->state.paPixelShaderConst[i].fValid = false;

pContext->state.cPixelShaderConst = reg + 1;

}

pContext->state.paPixelShaderConst[reg].fValid = true;

pContext->state.paPixelShaderConst[reg].ctype = ctype;

pContext->state.paPixelShaderConst[reg].value[0] = val1;

pContext->state.paPixelShaderConst[reg].value[1] = val2;

pContext->state.paPixelShaderConst[reg].value[2] = val3;

pContext->state.paPixelShaderConst[reg].value[3] = val4;

}

return VINF_SUCCESS;

}

#endif /* __DEVVMWARE3D_STATE_H__ */