// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#include "Direct3DStateBlock9.hpp"
|
|
#include "Direct3DDevice9.hpp"
|
#include "Direct3DVertexDeclaration9.hpp"
|
#include "Direct3DIndexBuffer9.hpp"
|
#include "Direct3DVertexBuffer9.hpp"
|
#include "Direct3DBaseTexture9.hpp"
|
#include "Direct3DPixelShader9.hpp"
|
#include "Direct3DVertexShader9.hpp"
|
#include "Debug.hpp"
|
|
#include <assert.h>
|
|
namespace D3D9
|
{
|
Direct3DStateBlock9::Direct3DStateBlock9(Direct3DDevice9 *device, D3DSTATEBLOCKTYPE type) : device(device), type(type)
|
{
|
vertexDeclaration = 0;
|
|
indexBuffer = 0;
|
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
streamSource[stream].vertexBuffer = 0;
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
texture[sampler] = 0;
|
}
|
|
pixelShader = 0;
|
vertexShader = 0;
|
|
clear();
|
|
if(type == D3DSBT_PIXELSTATE || type == D3DSBT_ALL)
|
{
|
capturePixelRenderStates();
|
capturePixelTextureStates();
|
capturePixelSamplerStates();
|
capturePixelShaderStates();
|
}
|
|
if(type == D3DSBT_VERTEXSTATE || type == D3DSBT_ALL)
|
{
|
captureVertexRenderStates();
|
captureVertexSamplerStates();
|
captureVertexTextureStates();
|
captureNPatchMode();
|
captureLightStates();
|
captureVertexShaderStates();
|
captureStreamSourceFrequencies();
|
captureFVF();
|
captureVertexDeclaration();
|
}
|
|
if(type == D3DSBT_ALL) // Capture remaining states
|
{
|
captureTextures();
|
captureTexturePalette();
|
captureVertexStreams();
|
captureIndexBuffer();
|
captureViewport();
|
captureScissorRectangle();
|
captureTransforms();
|
captureTextureTransforms();
|
captureClippingPlanes();
|
captureMaterial();
|
}
|
}
|
|
Direct3DStateBlock9::~Direct3DStateBlock9()
|
{
|
clear();
|
}
|
|
long Direct3DStateBlock9::QueryInterface(const IID &iid, void **object)
|
{
|
CriticalSection cs(device);
|
|
TRACE("");
|
|
if(iid == IID_IDirect3DStateBlock9 ||
|
iid == IID_IUnknown)
|
{
|
AddRef();
|
*object = this;
|
|
return S_OK;
|
}
|
|
*object = 0;
|
|
return NOINTERFACE(iid);
|
}
|
|
unsigned long Direct3DStateBlock9::AddRef()
|
{
|
TRACE("");
|
|
return Unknown::AddRef();
|
}
|
|
unsigned long Direct3DStateBlock9::Release()
|
{
|
TRACE("");
|
|
return Unknown::Release();
|
}
|
|
long Direct3DStateBlock9::Apply()
|
{
|
CriticalSection cs(device);
|
|
TRACE("");
|
|
if(device->isRecording())
|
{
|
return INVALIDCALL();
|
}
|
|
if(fvfCaptured)
|
{
|
device->SetFVF(FVF);
|
}
|
|
if(vertexDeclarationCaptured)
|
{
|
device->SetVertexDeclaration(vertexDeclaration);
|
}
|
|
if(indexBufferCaptured)
|
{
|
device->SetIndices(indexBuffer);
|
}
|
|
for(int state = D3DRS_ZENABLE; state <= D3DRS_BLENDOPALPHA; state++)
|
{
|
if(renderStateCaptured[state])
|
{
|
device->SetRenderState((D3DRENDERSTATETYPE)state, renderState[state]);
|
}
|
}
|
|
if(nPatchModeCaptured)
|
{
|
device->SetNPatchMode(nPatchMode);
|
}
|
|
for(int stage = 0; stage < 8; stage++)
|
{
|
for(int state = D3DTSS_COLOROP; state <= D3DTSS_CONSTANT; state++)
|
{
|
if(textureStageStateCaptured[stage][state])
|
{
|
device->SetTextureStageState(stage, (D3DTEXTURESTAGESTATETYPE)state, textureStageState[stage][state]);
|
}
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
for(int state = D3DSAMP_ADDRESSU; state <= D3DSAMP_DMAPOFFSET; state++)
|
{
|
if(samplerStateCaptured[sampler][state])
|
{
|
int index = sampler < 16 ? sampler : D3DVERTEXTEXTURESAMPLER0 + (sampler - 16);
|
device->SetSamplerState(index, (D3DSAMPLERSTATETYPE)state, samplerState[sampler][state]);
|
}
|
}
|
}
|
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
if(streamSourceCaptured[stream])
|
{
|
device->SetStreamSource(stream, streamSource[stream].vertexBuffer, streamSource[stream].offset, streamSource[stream].stride);
|
}
|
|
if(streamSourceFrequencyCaptured[stream])
|
{
|
device->SetStreamSourceFreq(stream, streamSourceFrequency[stream]);
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
if(textureCaptured[sampler])
|
{
|
int index = sampler < 16 ? sampler : D3DVERTEXTEXTURESAMPLER0 + (sampler - 16);
|
device->SetTexture(index, texture[sampler]);
|
}
|
}
|
|
for(int state = 0; state < 512; state++)
|
{
|
if(transformCaptured[state])
|
{
|
device->SetTransform((D3DTRANSFORMSTATETYPE)state, &transform[state]);
|
}
|
}
|
|
if(materialCaptured)
|
{
|
device->SetMaterial(&material);
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
if(lightCaptured[index])
|
{
|
device->SetLight(index, &light[index]);
|
}
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
if(lightEnableCaptured[index])
|
{
|
device->LightEnable(index, lightEnableState[index]);
|
}
|
}
|
|
if(pixelShaderCaptured)
|
{
|
device->SetPixelShader(pixelShader);
|
}
|
|
if(vertexShaderCaptured)
|
{
|
device->SetVertexShader(vertexShader);
|
}
|
|
if(viewportCaptured)
|
{
|
device->SetViewport(&viewport);
|
}
|
|
for(int i = 0; i < MAX_PIXEL_SHADER_CONST; i++)
|
{
|
if(*(int*)pixelShaderConstantF[i] != 0x80000000)
|
{
|
device->SetPixelShaderConstantF(i, pixelShaderConstantF[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(pixelShaderConstantI[i][0] != 0x80000000)
|
{
|
device->SetPixelShaderConstantI(i, pixelShaderConstantI[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(pixelShaderConstantB[i] != 0x80000000)
|
{
|
device->SetPixelShaderConstantB(i, &pixelShaderConstantB[i], 1);
|
}
|
}
|
|
for(int i = 0; i < MAX_VERTEX_SHADER_CONST; i++)
|
{
|
if(*(int*)vertexShaderConstantF[i] != 0x80000000)
|
{
|
device->SetVertexShaderConstantF(i, vertexShaderConstantF[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(vertexShaderConstantI[i][0] != 0x80000000)
|
{
|
device->SetVertexShaderConstantI(i, vertexShaderConstantI[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(vertexShaderConstantB[i] != 0x80000000)
|
{
|
device->SetVertexShaderConstantB(i, &vertexShaderConstantB[i], 1);
|
}
|
}
|
|
for(int index = 0; index < 6; index++)
|
{
|
if(clipPlaneCaptured[index])
|
{
|
device->SetClipPlane(index, clipPlane[index]);
|
}
|
}
|
|
if(scissorRectCaptured)
|
{
|
device->SetScissorRect(&scissorRect);
|
}
|
|
if(paletteNumberCaptured)
|
{
|
device->SetCurrentTexturePalette(paletteNumber);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DStateBlock9::Capture()
|
{
|
CriticalSection cs(device);
|
|
TRACE("");
|
|
if(fvfCaptured)
|
{
|
device->GetFVF(&FVF);
|
}
|
|
if(vertexDeclarationCaptured)
|
{
|
Direct3DVertexDeclaration9 *vertexDeclaration;
|
device->GetVertexDeclaration(reinterpret_cast<IDirect3DVertexDeclaration9**>(&vertexDeclaration));
|
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->bind();
|
vertexDeclaration->Release();
|
}
|
|
if(this->vertexDeclaration)
|
{
|
this->vertexDeclaration->unbind();
|
}
|
|
this->vertexDeclaration = vertexDeclaration;
|
}
|
|
if(indexBufferCaptured)
|
{
|
Direct3DIndexBuffer9 *indexBuffer;
|
device->GetIndices(reinterpret_cast<IDirect3DIndexBuffer9**>(&indexBuffer));
|
|
if(indexBuffer)
|
{
|
indexBuffer->bind();
|
indexBuffer->Release();
|
}
|
|
if(this->indexBuffer)
|
{
|
this->indexBuffer->unbind();
|
}
|
|
this->indexBuffer = indexBuffer;
|
}
|
|
for(int state = 0; state < D3DRS_BLENDOPALPHA + 1; state++)
|
{
|
if(renderStateCaptured[state])
|
{
|
device->GetRenderState((D3DRENDERSTATETYPE)state, &renderState[state]);
|
}
|
}
|
|
if(nPatchModeCaptured)
|
{
|
nPatchMode = device->GetNPatchMode();
|
}
|
|
for(int stage = 0; stage < 8; stage++)
|
{
|
for(int state = 0; state < D3DTSS_CONSTANT + 1; state++)
|
{
|
if(textureStageStateCaptured[stage][state])
|
{
|
device->GetTextureStageState(stage, (D3DTEXTURESTAGESTATETYPE)state, &textureStageState[stage][state]);
|
}
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
for(int state = 0; state < D3DSAMP_DMAPOFFSET + 1; state++)
|
{
|
if(samplerStateCaptured[sampler][state])
|
{
|
int index = sampler < 16 ? sampler : D3DVERTEXTEXTURESAMPLER0 + (sampler - 16);
|
device->GetSamplerState(index, (D3DSAMPLERSTATETYPE)state, &samplerState[sampler][state]);
|
}
|
}
|
}
|
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
if(streamSourceCaptured[stream])
|
{
|
Direct3DVertexBuffer9 *vertexBuffer;
|
device->GetStreamSource(stream, reinterpret_cast<IDirect3DVertexBuffer9**>(&vertexBuffer), &streamSource[stream].offset, &streamSource[stream].stride);
|
|
if(vertexBuffer)
|
{
|
vertexBuffer->bind();
|
vertexBuffer->Release();
|
}
|
|
if(streamSource[stream].vertexBuffer)
|
{
|
streamSource[stream].vertexBuffer->unbind();
|
}
|
|
streamSource[stream].vertexBuffer = vertexBuffer;
|
}
|
|
if(streamSourceFrequencyCaptured[stream])
|
{
|
device->GetStreamSourceFreq(stream, &streamSourceFrequency[stream]);
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
if(textureCaptured[sampler])
|
{
|
Direct3DBaseTexture9 *texture;
|
int index = sampler < 16 ? sampler : D3DVERTEXTEXTURESAMPLER0 + (sampler - 16);
|
device->GetTexture(index, reinterpret_cast<IDirect3DBaseTexture9**>(&texture));
|
|
if(texture)
|
{
|
texture->bind();
|
texture->Release();
|
}
|
|
if(this->texture[sampler])
|
{
|
this->texture[sampler]->unbind();
|
}
|
|
this->texture[sampler] = texture;
|
}
|
}
|
|
for(int state = 0; state < 512; state++)
|
{
|
if(transformCaptured[state])
|
{
|
device->GetTransform((D3DTRANSFORMSTATETYPE)state, &transform[state]);
|
}
|
}
|
|
if(materialCaptured)
|
{
|
device->GetMaterial(&material);
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
if(lightCaptured[index])
|
{
|
device->GetLight(index, &light[index]);
|
}
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
if(lightEnableCaptured[index])
|
{
|
lightEnableState[index] = false;
|
device->GetLightEnable(index, &lightEnableState[index]);
|
}
|
}
|
|
if(pixelShaderCaptured)
|
{
|
Direct3DPixelShader9 *pixelShader;
|
device->GetPixelShader(reinterpret_cast<IDirect3DPixelShader9**>(&pixelShader));
|
|
if(pixelShader)
|
{
|
pixelShader->bind();
|
pixelShader->Release();
|
}
|
|
if(this->pixelShader)
|
{
|
this->pixelShader->unbind();
|
}
|
|
this->pixelShader = pixelShader;
|
}
|
|
if(vertexShaderCaptured)
|
{
|
Direct3DVertexShader9 *vertexShader;
|
device->GetVertexShader(reinterpret_cast<IDirect3DVertexShader9**>(&vertexShader));
|
|
if(vertexShader)
|
{
|
vertexShader->bind();
|
vertexShader->Release();
|
}
|
|
if(this->vertexShader)
|
{
|
this->vertexShader->unbind();
|
}
|
|
this->vertexShader = vertexShader;
|
}
|
|
if(viewportCaptured)
|
{
|
device->GetViewport(&viewport);
|
}
|
|
for(int i = 0; i < MAX_PIXEL_SHADER_CONST; i++)
|
{
|
if(*(int*)pixelShaderConstantF[i] != 0x80000000)
|
{
|
device->GetPixelShaderConstantF(i, pixelShaderConstantF[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(pixelShaderConstantI[i][0] != 0x80000000)
|
{
|
device->GetPixelShaderConstantI(i, pixelShaderConstantI[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(pixelShaderConstantB[i] != 0x80000000)
|
{
|
device->GetPixelShaderConstantB(i, &pixelShaderConstantB[i], 1);
|
}
|
}
|
|
for(int i = 0; i < MAX_VERTEX_SHADER_CONST; i++)
|
{
|
if(*(int*)vertexShaderConstantF[i] != 0x80000000)
|
{
|
device->GetVertexShaderConstantF(i, vertexShaderConstantF[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(vertexShaderConstantI[i][0] != 0x80000000)
|
{
|
device->GetVertexShaderConstantI(i, vertexShaderConstantI[i], 1);
|
}
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
if(vertexShaderConstantB[i] != 0x80000000)
|
{
|
device->GetVertexShaderConstantB(i, &vertexShaderConstantB[i], 1);
|
}
|
}
|
|
for(int index = 0; index < 6; index++)
|
{
|
if(clipPlaneCaptured[index])
|
{
|
device->GetClipPlane(index, clipPlane[index]);
|
}
|
}
|
|
if(scissorRectCaptured)
|
{
|
device->GetScissorRect(&scissorRect);
|
}
|
|
if(paletteNumberCaptured)
|
{
|
device->GetCurrentTexturePalette(&paletteNumber);
|
}
|
|
return D3D_OK;
|
}
|
|
long Direct3DStateBlock9::GetDevice(IDirect3DDevice9 **device)
|
{
|
CriticalSection cs(this->device);
|
|
TRACE("");
|
|
if(!device)
|
{
|
return INVALIDCALL();
|
}
|
|
this->device->AddRef();
|
*device = this->device;
|
|
return D3D_OK;
|
}
|
|
void Direct3DStateBlock9::lightEnable(unsigned long index, int enable)
|
{
|
if(index < 8)
|
{
|
lightEnableCaptured[index] = true;
|
lightEnableState[index] = enable;
|
}
|
else ASSERT(false); // FIXME: Support unlimited index
|
}
|
|
void Direct3DStateBlock9::setClipPlane(unsigned long index, const float *plane)
|
{
|
clipPlaneCaptured[index] = true;
|
clipPlane[index][0] = plane[0];
|
clipPlane[index][1] = plane[1];
|
clipPlane[index][2] = plane[2];
|
clipPlane[index][3] = plane[3];
|
}
|
|
void Direct3DStateBlock9::setCurrentTexturePalette(unsigned int paletteNumber)
|
{
|
paletteNumberCaptured = true;
|
this->paletteNumber = paletteNumber;
|
}
|
|
void Direct3DStateBlock9::setFVF(unsigned long FVF)
|
{
|
fvfCaptured = true;
|
this->FVF = FVF;
|
}
|
|
void Direct3DStateBlock9::setIndices(Direct3DIndexBuffer9 *indexBuffer)
|
{
|
if(indexBuffer) indexBuffer->bind();
|
if(this->indexBuffer) this->indexBuffer->unbind();
|
|
indexBufferCaptured = true;
|
this->indexBuffer = indexBuffer;
|
}
|
|
void Direct3DStateBlock9::setLight(unsigned long index, const D3DLIGHT9 *light)
|
{
|
if(index < 8)
|
{
|
lightCaptured[index] = true;
|
this->light[index] = *light;
|
}
|
else ASSERT(false); // FIXME: Support unlimited index
|
}
|
|
void Direct3DStateBlock9::setMaterial(const D3DMATERIAL9 *material)
|
{
|
materialCaptured = true;
|
this->material = *material;
|
}
|
|
void Direct3DStateBlock9::setNPatchMode(float segments)
|
{
|
nPatchModeCaptured = true;
|
nPatchMode = segments;
|
}
|
|
void Direct3DStateBlock9::setPixelShader(Direct3DPixelShader9 *pixelShader)
|
{
|
if(pixelShader) pixelShader->bind();
|
if(this->pixelShader) this->pixelShader->unbind();
|
|
pixelShaderCaptured = true;
|
this->pixelShader = pixelShader;
|
}
|
|
void Direct3DStateBlock9::setPixelShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
memcpy(&pixelShaderConstantB[startRegister], constantData, count * sizeof(int));
|
}
|
|
void Direct3DStateBlock9::setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
|
{
|
memcpy(pixelShaderConstantF[startRegister], constantData, count * sizeof(float[4]));
|
}
|
|
void Direct3DStateBlock9::setPixelShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
memcpy(pixelShaderConstantI[startRegister], constantData, count * sizeof(int[4]));
|
}
|
|
void Direct3DStateBlock9::setRenderState(D3DRENDERSTATETYPE state, unsigned long value)
|
{
|
renderStateCaptured[state] = true;
|
renderState[state] = value;
|
}
|
|
void Direct3DStateBlock9::setSamplerState(unsigned long index, D3DSAMPLERSTATETYPE state, unsigned long value)
|
{
|
unsigned int sampler = index < 16 ? index : (index - D3DVERTEXTEXTURESAMPLER0) + 16;
|
|
if(sampler >= 16 + 4)
|
{
|
return;
|
}
|
|
samplerStateCaptured[sampler][state] = true;
|
samplerState[sampler][state] = value;
|
}
|
|
void Direct3DStateBlock9::setScissorRect(const RECT *rect)
|
{
|
scissorRectCaptured = true;
|
scissorRect = *rect;
|
}
|
|
void Direct3DStateBlock9::setStreamSource(unsigned int stream, Direct3DVertexBuffer9 *vertexBuffer, unsigned int offset, unsigned int stride)
|
{
|
if(vertexBuffer) vertexBuffer->bind();
|
if(streamSource[stream].vertexBuffer) streamSource[stream].vertexBuffer->unbind();
|
|
streamSourceCaptured[stream] = true;
|
streamSource[stream].vertexBuffer = vertexBuffer;
|
streamSource[stream].offset = offset;
|
streamSource[stream].stride = stride;
|
}
|
|
void Direct3DStateBlock9::setStreamSourceFreq(unsigned int streamNumber, unsigned int divider)
|
{
|
streamSourceFrequencyCaptured[streamNumber] = true;
|
streamSourceFrequency[streamNumber] = divider;
|
}
|
|
void Direct3DStateBlock9::setTexture(unsigned long index, Direct3DBaseTexture9 *texture)
|
{
|
unsigned int sampler = index < 16 ? index : (index - D3DVERTEXTEXTURESAMPLER0) + 16;
|
|
if(sampler >= 16 + 4)
|
{
|
return;
|
}
|
|
if(texture) texture->bind();
|
if(this->texture[sampler]) this->texture[sampler]->unbind();
|
|
textureCaptured[sampler] = true;
|
this->texture[sampler] = texture;
|
}
|
|
void Direct3DStateBlock9::setTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type, unsigned long value)
|
{
|
textureStageStateCaptured[stage][type] = true;
|
textureStageState[stage][type] = value;
|
}
|
|
void Direct3DStateBlock9::setTransform(D3DTRANSFORMSTATETYPE state, const D3DMATRIX *matrix)
|
{
|
transformCaptured[state] = true;
|
transform[state] = *matrix;
|
}
|
|
void Direct3DStateBlock9::setViewport(const D3DVIEWPORT9 *viewport)
|
{
|
viewportCaptured = true;
|
this->viewport = *viewport;
|
}
|
|
void Direct3DStateBlock9::setVertexDeclaration(Direct3DVertexDeclaration9 *vertexDeclaration)
|
{
|
if(vertexDeclaration) vertexDeclaration->bind();
|
if(this->vertexDeclaration) this->vertexDeclaration->unbind();
|
|
vertexDeclarationCaptured = true;
|
this->vertexDeclaration = vertexDeclaration;
|
}
|
|
void Direct3DStateBlock9::setVertexShader(Direct3DVertexShader9 *vertexShader)
|
{
|
if(vertexShader) vertexShader->bind();
|
if(this->vertexShader) this->vertexShader->unbind();
|
|
vertexShaderCaptured = true;
|
this->vertexShader = vertexShader;
|
}
|
|
void Direct3DStateBlock9::setVertexShaderConstantB(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
memcpy(&vertexShaderConstantB[startRegister], constantData, count * sizeof(int));
|
}
|
|
void Direct3DStateBlock9::setVertexShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count)
|
{
|
memcpy(vertexShaderConstantF[startRegister], constantData, count * sizeof(float[4]));
|
}
|
|
void Direct3DStateBlock9::setVertexShaderConstantI(unsigned int startRegister, const int *constantData, unsigned int count)
|
{
|
memcpy(vertexShaderConstantI[startRegister], constantData, count * sizeof(int[4]));
|
}
|
|
void Direct3DStateBlock9::clear()
|
{
|
// Erase capture flags
|
fvfCaptured = false;
|
vertexDeclarationCaptured = false;
|
|
indexBufferCaptured = false;
|
|
for(int state = 0; state < D3DRS_BLENDOPALPHA + 1; state++)
|
{
|
renderStateCaptured[state] = false;
|
}
|
|
nPatchModeCaptured = false;
|
|
for(int stage = 0; stage < 8; stage++)
|
{
|
for(int state = 0; state < D3DTSS_CONSTANT + 1; state++)
|
{
|
textureStageStateCaptured[stage][state] = false;
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
for(int state = 0; state < D3DSAMP_DMAPOFFSET + 1; state++)
|
{
|
samplerStateCaptured[sampler][state] = false;
|
}
|
}
|
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
streamSourceCaptured[stream] = false;
|
streamSourceFrequencyCaptured[stream] = false;
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
textureCaptured[sampler] = false;
|
}
|
|
for(int state = 0; state < 512; state++)
|
{
|
transformCaptured[state] = false;
|
}
|
|
materialCaptured = false;
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
lightCaptured[index] = false;
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
lightEnableCaptured[index] = false;
|
}
|
|
scissorRectCaptured = false;
|
|
pixelShaderCaptured = false;
|
vertexShaderCaptured = false;
|
|
viewportCaptured = false;
|
|
for(int i = 0; i < MAX_PIXEL_SHADER_CONST; i++)
|
{
|
(int&)pixelShaderConstantF[i][0] = 0x80000000;
|
(int&)pixelShaderConstantF[i][1] = 0x80000000;
|
(int&)pixelShaderConstantF[i][2] = 0x80000000;
|
(int&)pixelShaderConstantF[i][3] = 0x80000000;
|
}
|
|
for(int i = 0; i < MAX_VERTEX_SHADER_CONST; i++)
|
{
|
(int&)vertexShaderConstantF[i][0] = 0x80000000;
|
(int&)vertexShaderConstantF[i][1] = 0x80000000;
|
(int&)vertexShaderConstantF[i][2] = 0x80000000;
|
(int&)vertexShaderConstantF[i][3] = 0x80000000;
|
}
|
|
for(int i = 0; i < 16; i++)
|
{
|
pixelShaderConstantI[i][0] = 0x80000000;
|
pixelShaderConstantI[i][1] = 0x80000000;
|
pixelShaderConstantI[i][2] = 0x80000000;
|
pixelShaderConstantI[i][3] = 0x80000000;
|
|
pixelShaderConstantB[i] = 0x80000000;
|
|
vertexShaderConstantI[i][0] = 0x80000000;
|
vertexShaderConstantI[i][1] = 0x80000000;
|
vertexShaderConstantI[i][2] = 0x80000000;
|
vertexShaderConstantI[i][3] = 0x80000000;
|
|
vertexShaderConstantB[i] = 0x80000000;
|
}
|
|
for(int index = 0; index < 6; index++)
|
{
|
clipPlaneCaptured[index] = false;
|
}
|
|
paletteNumberCaptured = false;
|
|
// unbind resources
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->unbind();
|
vertexDeclaration = 0;
|
}
|
|
if(indexBuffer)
|
{
|
indexBuffer->unbind();
|
indexBuffer = 0;
|
}
|
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
if(streamSource[stream].vertexBuffer)
|
{
|
streamSource[stream].vertexBuffer->unbind();
|
streamSource[stream].vertexBuffer = 0;
|
}
|
}
|
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
if(texture[sampler])
|
{
|
texture[sampler]->unbind();
|
texture[sampler] = 0;
|
}
|
}
|
|
if(pixelShader)
|
{
|
pixelShader->unbind();
|
pixelShader = 0;
|
}
|
|
if(vertexShader)
|
{
|
vertexShader->unbind();
|
vertexShader = 0;
|
}
|
}
|
|
void Direct3DStateBlock9::captureRenderState(D3DRENDERSTATETYPE state)
|
{
|
device->GetRenderState(state, &renderState[state]);
|
renderStateCaptured[state] = true;
|
}
|
|
void Direct3DStateBlock9::captureSamplerState(unsigned long index, D3DSAMPLERSTATETYPE state)
|
{
|
if(index < 16)
|
{
|
device->GetSamplerState(index, state, &samplerState[index][state]);
|
samplerStateCaptured[index][state] = true;
|
}
|
else if(index >= D3DVERTEXTEXTURESAMPLER0)
|
{
|
unsigned int sampler = 16 + (index - D3DVERTEXTEXTURESAMPLER0);
|
|
device->GetSamplerState(index, state, &samplerState[sampler][state]);
|
samplerStateCaptured[sampler][state] = true;
|
}
|
}
|
|
void Direct3DStateBlock9::captureTextureStageState(unsigned long stage, D3DTEXTURESTAGESTATETYPE type)
|
{
|
device->GetTextureStageState(stage, type, &textureStageState[stage][type]);
|
textureStageStateCaptured[stage][type] = true;
|
}
|
|
void Direct3DStateBlock9::captureTransform(D3DTRANSFORMSTATETYPE state)
|
{
|
device->GetTransform(state, &transform[state]);
|
transformCaptured[state] = true;
|
}
|
|
void Direct3DStateBlock9::capturePixelRenderStates()
|
{
|
captureRenderState(D3DRS_ZENABLE);
|
captureRenderState(D3DRS_FILLMODE);
|
captureRenderState(D3DRS_SHADEMODE);
|
captureRenderState(D3DRS_ZWRITEENABLE);
|
captureRenderState(D3DRS_ALPHATESTENABLE);
|
captureRenderState(D3DRS_LASTPIXEL);
|
captureRenderState(D3DRS_SRCBLEND);
|
captureRenderState(D3DRS_DESTBLEND);
|
captureRenderState(D3DRS_ZFUNC);
|
captureRenderState(D3DRS_ALPHAREF);
|
captureRenderState(D3DRS_ALPHAFUNC);
|
captureRenderState(D3DRS_DITHERENABLE);
|
captureRenderState(D3DRS_FOGSTART);
|
captureRenderState(D3DRS_FOGEND);
|
captureRenderState(D3DRS_FOGDENSITY);
|
captureRenderState(D3DRS_ALPHABLENDENABLE);
|
captureRenderState(D3DRS_DEPTHBIAS);
|
captureRenderState(D3DRS_STENCILENABLE);
|
captureRenderState(D3DRS_STENCILFAIL);
|
captureRenderState(D3DRS_STENCILZFAIL);
|
captureRenderState(D3DRS_STENCILPASS);
|
captureRenderState(D3DRS_STENCILFUNC);
|
captureRenderState(D3DRS_STENCILREF);
|
captureRenderState(D3DRS_STENCILMASK);
|
captureRenderState(D3DRS_STENCILWRITEMASK);
|
captureRenderState(D3DRS_TEXTUREFACTOR);
|
captureRenderState(D3DRS_WRAP0);
|
captureRenderState(D3DRS_WRAP1);
|
captureRenderState(D3DRS_WRAP2);
|
captureRenderState(D3DRS_WRAP3);
|
captureRenderState(D3DRS_WRAP4);
|
captureRenderState(D3DRS_WRAP5);
|
captureRenderState(D3DRS_WRAP6);
|
captureRenderState(D3DRS_WRAP7);
|
captureRenderState(D3DRS_WRAP8);
|
captureRenderState(D3DRS_WRAP9);
|
captureRenderState(D3DRS_WRAP10);
|
captureRenderState(D3DRS_WRAP11);
|
captureRenderState(D3DRS_WRAP12);
|
captureRenderState(D3DRS_WRAP13);
|
captureRenderState(D3DRS_WRAP14);
|
captureRenderState(D3DRS_WRAP15);
|
captureRenderState(D3DRS_COLORWRITEENABLE);
|
captureRenderState(D3DRS_BLENDOP);
|
captureRenderState(D3DRS_SCISSORTESTENABLE);
|
captureRenderState(D3DRS_SLOPESCALEDEPTHBIAS);
|
captureRenderState(D3DRS_ANTIALIASEDLINEENABLE);
|
captureRenderState(D3DRS_TWOSIDEDSTENCILMODE);
|
captureRenderState(D3DRS_CCW_STENCILFAIL);
|
captureRenderState(D3DRS_CCW_STENCILZFAIL);
|
captureRenderState(D3DRS_CCW_STENCILPASS);
|
captureRenderState(D3DRS_CCW_STENCILFUNC);
|
captureRenderState(D3DRS_COLORWRITEENABLE1);
|
captureRenderState(D3DRS_COLORWRITEENABLE2);
|
captureRenderState(D3DRS_COLORWRITEENABLE3);
|
captureRenderState(D3DRS_BLENDFACTOR);
|
captureRenderState(D3DRS_SRGBWRITEENABLE);
|
captureRenderState(D3DRS_SEPARATEALPHABLENDENABLE);
|
captureRenderState(D3DRS_SRCBLENDALPHA);
|
captureRenderState(D3DRS_DESTBLENDALPHA);
|
captureRenderState(D3DRS_BLENDOPALPHA);
|
}
|
|
void Direct3DStateBlock9::capturePixelTextureStates()
|
{
|
for(int stage = 0; stage < 8; stage++)
|
{
|
captureTextureStageState(stage, D3DTSS_COLOROP);
|
captureTextureStageState(stage, D3DTSS_COLORARG1);
|
captureTextureStageState(stage, D3DTSS_COLORARG2);
|
captureTextureStageState(stage, D3DTSS_ALPHAOP);
|
captureTextureStageState(stage, D3DTSS_ALPHAARG1);
|
captureTextureStageState(stage, D3DTSS_ALPHAARG2);
|
captureTextureStageState(stage, D3DTSS_BUMPENVMAT00);
|
captureTextureStageState(stage, D3DTSS_BUMPENVMAT01);
|
captureTextureStageState(stage, D3DTSS_BUMPENVMAT10);
|
captureTextureStageState(stage, D3DTSS_BUMPENVMAT11);
|
captureTextureStageState(stage, D3DTSS_TEXCOORDINDEX);
|
captureTextureStageState(stage, D3DTSS_BUMPENVLSCALE);
|
captureTextureStageState(stage, D3DTSS_BUMPENVLOFFSET);
|
captureTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS);
|
captureTextureStageState(stage, D3DTSS_COLORARG0);
|
captureTextureStageState(stage, D3DTSS_ALPHAARG0);
|
captureTextureStageState(stage, D3DTSS_RESULTARG);
|
}
|
}
|
|
void Direct3DStateBlock9::capturePixelSamplerStates()
|
{
|
for(int sampler = 0; sampler <= D3DVERTEXTEXTURESAMPLER3; sampler++)
|
{
|
captureSamplerState(sampler, D3DSAMP_ADDRESSU);
|
captureSamplerState(sampler, D3DSAMP_ADDRESSV);
|
captureSamplerState(sampler, D3DSAMP_ADDRESSW);
|
captureSamplerState(sampler, D3DSAMP_BORDERCOLOR);
|
captureSamplerState(sampler, D3DSAMP_MAGFILTER);
|
captureSamplerState(sampler, D3DSAMP_MINFILTER);
|
captureSamplerState(sampler, D3DSAMP_MIPFILTER);
|
captureSamplerState(sampler, D3DSAMP_MIPMAPLODBIAS);
|
captureSamplerState(sampler, D3DSAMP_MAXMIPLEVEL);
|
captureSamplerState(sampler, D3DSAMP_MAXANISOTROPY);
|
captureSamplerState(sampler, D3DSAMP_SRGBTEXTURE);
|
captureSamplerState(sampler, D3DSAMP_ELEMENTINDEX);
|
}
|
}
|
|
void Direct3DStateBlock9::capturePixelShaderStates()
|
{
|
pixelShaderCaptured = true;
|
device->GetPixelShader(reinterpret_cast<IDirect3DPixelShader9**>(&pixelShader));
|
|
if(pixelShader)
|
{
|
pixelShader->bind();
|
pixelShader->Release();
|
}
|
|
device->GetPixelShaderConstantF(0, pixelShaderConstantF[0], 32);
|
device->GetPixelShaderConstantI(0, pixelShaderConstantI[0], 16);
|
device->GetPixelShaderConstantB(0, pixelShaderConstantB, 16);
|
}
|
|
void Direct3DStateBlock9::captureVertexRenderStates()
|
{
|
captureRenderState(D3DRS_CULLMODE);
|
captureRenderState(D3DRS_FOGENABLE);
|
captureRenderState(D3DRS_FOGCOLOR);
|
captureRenderState(D3DRS_FOGTABLEMODE);
|
captureRenderState(D3DRS_FOGSTART);
|
captureRenderState(D3DRS_FOGEND);
|
captureRenderState(D3DRS_FOGDENSITY);
|
captureRenderState(D3DRS_RANGEFOGENABLE);
|
captureRenderState(D3DRS_AMBIENT);
|
captureRenderState(D3DRS_COLORVERTEX);
|
captureRenderState(D3DRS_FOGVERTEXMODE);
|
captureRenderState(D3DRS_CLIPPING);
|
captureRenderState(D3DRS_LIGHTING);
|
captureRenderState(D3DRS_LOCALVIEWER);
|
captureRenderState(D3DRS_EMISSIVEMATERIALSOURCE);
|
captureRenderState(D3DRS_AMBIENTMATERIALSOURCE);
|
captureRenderState(D3DRS_DIFFUSEMATERIALSOURCE);
|
captureRenderState(D3DRS_SPECULARMATERIALSOURCE);
|
captureRenderState(D3DRS_VERTEXBLEND);
|
captureRenderState(D3DRS_CLIPPLANEENABLE);
|
captureRenderState(D3DRS_POINTSIZE);
|
captureRenderState(D3DRS_POINTSIZE_MIN);
|
captureRenderState(D3DRS_POINTSPRITEENABLE);
|
captureRenderState(D3DRS_POINTSCALEENABLE);
|
captureRenderState(D3DRS_POINTSCALE_A);
|
captureRenderState(D3DRS_POINTSCALE_B);
|
captureRenderState(D3DRS_POINTSCALE_C);
|
captureRenderState(D3DRS_MULTISAMPLEANTIALIAS);
|
captureRenderState(D3DRS_MULTISAMPLEMASK);
|
captureRenderState(D3DRS_PATCHEDGESTYLE);
|
captureRenderState(D3DRS_POINTSIZE_MAX);
|
captureRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE);
|
captureRenderState(D3DRS_TWEENFACTOR);
|
captureRenderState(D3DRS_POSITIONDEGREE);
|
captureRenderState(D3DRS_NORMALDEGREE);
|
captureRenderState(D3DRS_MINTESSELLATIONLEVEL);
|
captureRenderState(D3DRS_MAXTESSELLATIONLEVEL);
|
captureRenderState(D3DRS_ADAPTIVETESS_X);
|
captureRenderState(D3DRS_ADAPTIVETESS_Y);
|
captureRenderState(D3DRS_ADAPTIVETESS_Z);
|
captureRenderState(D3DRS_ADAPTIVETESS_W);
|
captureRenderState(D3DRS_ENABLEADAPTIVETESSELLATION);
|
captureRenderState(D3DRS_NORMALIZENORMALS);
|
captureRenderState(D3DRS_SPECULARENABLE);
|
captureRenderState(D3DRS_SHADEMODE);
|
}
|
|
void Direct3DStateBlock9::captureVertexSamplerStates()
|
{
|
for(int sampler = 0; sampler <= D3DVERTEXTEXTURESAMPLER3; sampler++)
|
{
|
captureSamplerState(sampler, D3DSAMP_DMAPOFFSET);
|
}
|
}
|
|
void Direct3DStateBlock9::captureVertexTextureStates()
|
{
|
for(int stage = 0; stage < 8; stage++)
|
{
|
captureTextureStageState(stage, D3DTSS_TEXCOORDINDEX);
|
captureTextureStageState(stage, D3DTSS_TEXTURETRANSFORMFLAGS);
|
}
|
}
|
|
void Direct3DStateBlock9::captureNPatchMode()
|
{
|
nPatchMode = device->GetNPatchMode();
|
nPatchModeCaptured = true;
|
}
|
|
void Direct3DStateBlock9::captureLightStates()
|
{
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
long result = device->GetLight(index, &light[index]);
|
lightCaptured[index] = SUCCEEDED(result);
|
}
|
|
for(int index = 0; index < 8; index++) // FIXME: Support unlimited index
|
{
|
lightEnableState[index] = false;
|
long result = device->GetLightEnable(index, &lightEnableState[index]);
|
lightEnableCaptured[index] = SUCCEEDED(result);
|
}
|
}
|
|
void Direct3DStateBlock9::captureVertexShaderStates()
|
{
|
vertexShaderCaptured = true;
|
device->GetVertexShader(reinterpret_cast<IDirect3DVertexShader9**>(&vertexShader));
|
|
if(vertexShader)
|
{
|
vertexShader->bind();
|
vertexShader->Release();
|
}
|
|
device->GetVertexShaderConstantF(0, vertexShaderConstantF[0], MAX_VERTEX_SHADER_CONST);
|
device->GetVertexShaderConstantI(0, vertexShaderConstantI[0], 16);
|
device->GetVertexShaderConstantB(0, vertexShaderConstantB, 16);
|
}
|
|
void Direct3DStateBlock9::captureStreamSourceFrequencies()
|
{
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
streamSourceFrequencyCaptured[stream] = true;
|
device->GetStreamSourceFreq(stream, &streamSourceFrequency[stream]);
|
}
|
}
|
|
void Direct3DStateBlock9::captureFVF()
|
{
|
device->GetFVF(&FVF);
|
fvfCaptured = true;
|
}
|
|
void Direct3DStateBlock9::captureVertexDeclaration()
|
{
|
vertexDeclarationCaptured = true;
|
device->GetVertexDeclaration(reinterpret_cast<IDirect3DVertexDeclaration9**>(&vertexDeclaration));
|
|
if(vertexDeclaration)
|
{
|
vertexDeclaration->bind();
|
vertexDeclaration->Release();
|
}
|
}
|
|
void Direct3DStateBlock9::captureTextures()
|
{
|
for(int sampler = 0; sampler < 16 + 4; sampler++)
|
{
|
textureCaptured[sampler] = true;
|
int index = sampler < 16 ? sampler : D3DVERTEXTEXTURESAMPLER0 + (sampler - 16);
|
device->GetTexture(index, reinterpret_cast<IDirect3DBaseTexture9**>(&texture[sampler]));
|
|
if(texture[sampler])
|
{
|
texture[sampler]->bind();
|
texture[sampler]->Release();
|
}
|
}
|
}
|
|
void Direct3DStateBlock9::captureTexturePalette()
|
{
|
paletteNumberCaptured = true;
|
device->GetCurrentTexturePalette(&paletteNumber);
|
}
|
|
void Direct3DStateBlock9::captureVertexStreams()
|
{
|
for(int stream = 0; stream < MAX_VERTEX_INPUTS; stream++)
|
{
|
streamSourceCaptured[stream] = true;
|
device->GetStreamSource(stream, reinterpret_cast<IDirect3DVertexBuffer9**>(&streamSource[stream].vertexBuffer), &streamSource[stream].offset, &streamSource[stream].stride);
|
|
if(streamSource[stream].vertexBuffer)
|
{
|
streamSource[stream].vertexBuffer->bind();
|
streamSource[stream].vertexBuffer->Release();
|
}
|
}
|
}
|
|
void Direct3DStateBlock9::captureIndexBuffer()
|
{
|
indexBufferCaptured = true;
|
device->GetIndices(reinterpret_cast<IDirect3DIndexBuffer9**>(&indexBuffer));
|
|
if(indexBuffer)
|
{
|
indexBuffer->bind();
|
indexBuffer->Release();
|
}
|
}
|
|
void Direct3DStateBlock9::captureViewport()
|
{
|
device->GetViewport(&viewport);
|
viewportCaptured = true;
|
}
|
|
void Direct3DStateBlock9::captureScissorRectangle()
|
{
|
device->GetScissorRect(&scissorRect);
|
scissorRectCaptured = true;
|
}
|
|
void Direct3DStateBlock9::captureTransforms()
|
{
|
captureTransform(D3DTS_VIEW);
|
captureTransform(D3DTS_PROJECTION);
|
captureTransform(D3DTS_WORLD);
|
}
|
|
void Direct3DStateBlock9::captureTextureTransforms()
|
{
|
captureTransform(D3DTS_TEXTURE0);
|
captureTransform(D3DTS_TEXTURE1);
|
captureTransform(D3DTS_TEXTURE2);
|
captureTransform(D3DTS_TEXTURE3);
|
captureTransform(D3DTS_TEXTURE4);
|
captureTransform(D3DTS_TEXTURE5);
|
captureTransform(D3DTS_TEXTURE6);
|
captureTransform(D3DTS_TEXTURE7);
|
}
|
|
void Direct3DStateBlock9::captureClippingPlanes()
|
{
|
for(int index = 0; index < 6; index++)
|
{
|
device->GetClipPlane(index, (float*)&clipPlane[index]);
|
clipPlaneCaptured[index] = true;
|
}
|
}
|
|
void Direct3DStateBlock9::captureMaterial()
|
{
|
device->GetMaterial(&material);
|
materialCaptured = true;
|
}
|
}
|
