Skip to content

A
angle
Commit a59a1c1e by Jamie Madill Committed by Commit Bot
Options

D3D11: Consolidate shader state application.

This consolidates all the state changes for shaders into StateManager11. BUG=angleproject:2052 Change-Id: I64dc3af5b0f1459442369e09f93a9ca8ce3232b3 Reviewed-on: https://chromium-review.googlesource.com/531796Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent 95107bc8
Showing with 154 additions and 134 deletions
src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
......@@ -966,7 +966,7 @@ gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *
ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
ANGLE_TRY(mQuad2DVS.resolve(mRenderer));
supportOut->inputLayout = &mQuad2DIL.getObj();
supportOut->vertexShader = mQuad2DVS.get();
supportOut->vertexShader = &mQuad2DVS.getObj();
supportOut->geometryShader = nullptr;
supportOut->vertexWriteFunction = Write2DVertices;
}
......@@ -977,8 +977,8 @@ gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *
ANGLE_TRY(mQuad3DVS.resolve(mRenderer));
ANGLE_TRY(mQuad3DGS.resolve(mRenderer));
supportOut->inputLayout = &mQuad2DIL.getObj();
supportOut->vertexShader = mQuad3DVS.get();
supportOut->geometryShader = mQuad3DGS.get();
supportOut->vertexShader = &mQuad3DVS.getObj();
supportOut->geometryShader = &mQuad3DGS.getObj();
supportOut->vertexWriteFunction = Write3DVertices;
}
......@@ -1095,10 +1095,9 @@ gl::Error Blit11::swizzleTexture(const gl::Context *context,
// Apply shaders
stateManager->setInputLayout(support.inputLayout);
stateManager->setPrimitiveTopology(topology);
deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
deviceContext->PSSetShader(shader->pixelShader.get(), nullptr, 0);
deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
&shader->pixelShader);
// Unset the currently bound shader resource to avoid conflicts
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
......@@ -1230,10 +1229,9 @@ gl::Error Blit11::copyTexture(const gl::Context *context,
// Apply shaders
stateManager->setInputLayout(support.inputLayout);
stateManager->setPrimitiveTopology(topology);
deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
deviceContext->PSSetShader(shader->pixelShader.get(), nullptr, 0);
deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
&shader->pixelShader);
// Unset the currently bound shader resource to avoid conflicts
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
......@@ -1362,10 +1360,8 @@ gl::Error Blit11::copyDepth(const gl::Context *context,
// Apply shaders
stateManager->setInputLayout(&mQuad2DIL.getObj());
stateManager->setPrimitiveTopology(topology);
deviceContext->VSSetShader(mQuad2DVS.get(), nullptr, 0);
deviceContext->PSSetShader(mDepthPS.get(), nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
stateManager->setDrawShaders(&mQuad2DVS.getObj(), nullptr, &mDepthPS.getObj());
// Unset the currently bound shader resource to avoid conflicts
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
......@@ -2021,8 +2017,8 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *conte
// Apply the necessary state changes to the D3D11 immediate device context.
stateManager->setInputLayout(nullptr);
stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
deviceContext->VSSetShader(mResolveDepthStencilVS.get(), nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr,
&mResolveDepthPS.getObj());
deviceContext->RSSetState(nullptr);
deviceContext->OMSetDepthStencilState(mDepthStencilState.get(), 0xFFFFFFFF);
deviceContext->OMSetRenderTargets(0, nullptr, mResolvedDepthDSView.get());
......@@ -2042,8 +2038,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *conte
deviceContext->PSSetShaderResources(0, 1, pixelViews);
deviceContext->PSSetShader(mResolveDepthPS.get(), nullptr, 0);
// Trigger the blit on the GPU.
deviceContext->Draw(6, 0);
......@@ -2178,11 +2172,25 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *con
ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
// Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
// writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
// because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
const d3d11::PixelShader *pixelShader = nullptr;
if (alsoDepth)
{
ANGLE_TRY(mResolveDepthStencilPS.resolve(mRenderer));
pixelShader = &mResolveDepthStencilPS.getObj();
}
else
{
ANGLE_TRY(mResolveStencilPS.resolve(mRenderer));
pixelShader = &mResolveStencilPS.getObj();
}
// Apply the necessary state changes to the D3D11 immediate device context.
stateManager->setInputLayout(nullptr);
stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
deviceContext->VSSetShader(mResolveDepthStencilVS.get(), nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr, pixelShader);
deviceContext->RSSetState(nullptr);
deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
deviceContext->OMSetRenderTargets(1, rtvs, nullptr);
......@@ -2204,20 +2212,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *con
deviceContext->PSSetShaderResources(0, 2, pixelViews);
// Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
// writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
// because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
if (alsoDepth)
{
ANGLE_TRY(mResolveDepthStencilPS.resolve(mRenderer));
deviceContext->PSSetShader(mResolveDepthStencilPS.get(), nullptr, 0);
}
else
{
ANGLE_TRY(mResolveStencilPS.resolve(mRenderer));
deviceContext->PSSetShader(mResolveStencilPS.get(), nullptr, 0);
}
// Trigger the blit on the GPU.
deviceContext->Draw(6, 0);
......
src/libANGLE/renderer/d3d/d3d11/Blit11.h
......@@ -201,8 +201,8 @@ class Blit11 : angle::NonCopyable
struct ShaderSupport
{
const d3d11::InputLayout *inputLayout;
ID3D11VertexShader *vertexShader;
ID3D11GeometryShader *geometryShader;
const d3d11::VertexShader *vertexShader;
const d3d11::GeometryShader *geometryShader;
WriteVertexFunction vertexWriteFunction;
};
......
src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
......@@ -99,8 +99,8 @@ Clear11::ShaderManager::~ShaderManager()
gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
const INT clearType,
const d3d11::InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps)
const d3d11::VertexShader **vs,
const d3d11::PixelShader **ps)
{
if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
{
......@@ -120,29 +120,29 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
}
*vs = mVs9.get();
*vs = &mVs9.getObj();
*il = &mIl9;
*ps = mPsFloat9.get();
*ps = &mPsFloat9.getObj();
return gl::NoError();
}
ANGLE_TRY(mVs.resolve(renderer));
*vs = mVs.get();
*vs = &mVs.getObj();
*il = nullptr;
switch (clearType)
{
case GL_FLOAT:
ANGLE_TRY(mPsFloat.resolve(renderer));
*ps = mPsFloat.get();
*ps = &mPsFloat.getObj();
break;
case GL_UNSIGNED_INT:
ANGLE_TRY(mPsUInt.resolve(renderer));
*ps = mPsUInt.get();
*ps = &mPsUInt.getObj();
break;
case GL_INT:
ANGLE_TRY(mPsSInt.resolve(renderer));
*ps = mPsSInt.get();
*ps = &mPsSInt.getObj();
break;
default:
UNREACHABLE();
......@@ -680,16 +680,14 @@ gl::Error Clear11::clearFramebuffer(const gl::Context *context,
auto *stateManager = mRenderer->getStateManager();
// Get Shaders
ID3D11VertexShader *vs = nullptr;
const d3d11::InputLayout *il = nullptr;
ID3D11PixelShader *ps = nullptr;
const d3d11::VertexShader *vs = nullptr;
const d3d11::InputLayout *il = nullptr;
const d3d11::PixelShader *ps = nullptr;
ANGLE_TRY(mShaderManager.getShadersAndLayout(mRenderer, clearParams.colorType, &il, &vs, &ps));
// Apply Shaders
deviceContext->VSSetShader(vs, nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
deviceContext->PSSetShader(ps, nullptr, 0);
stateManager->setDrawShaders(vs, nullptr, ps);
ID3D11Buffer *constantBuffer = mConstantBuffer.get();
deviceContext->PSSetConstantBuffers(0, 1, &constantBuffer);
......
src/libANGLE/renderer/d3d/d3d11/Clear11.h
......@@ -51,8 +51,8 @@ class Clear11 : angle::NonCopyable
gl::Error getShadersAndLayout(Renderer11 *renderer,
const INT clearType,
const d3d11::InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps);
const d3d11::VertexShader **vs,
const d3d11::PixelShader **ps);
private:
d3d11::InputLayout mIl9;
......
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
......@@ -157,7 +157,7 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
ASSERT(mRenderer->supportsFastCopyBufferToTexture(destinationFormat));
ID3D11PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
const d3d11::PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
ASSERT(pixelShader);
// The SRV must be in the proper read format, which may be different from the destination format
......@@ -186,13 +186,10 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
// Are we doing a 2D or 3D copy?
ID3D11GeometryShader *geometryShader =
((destSize.depth > 1) ? mBufferToTextureGS.get() : nullptr);
auto stateManager = mRenderer->getStateManager();
const auto *geometryShader = ((destSize.depth > 1) ? &mBufferToTextureGS : nullptr);
auto stateManager = mRenderer->getStateManager();
deviceContext->VSSetShader(mBufferToTextureVS.get(), nullptr, 0);
deviceContext->GSSetShader(geometryShader, nullptr, 0);
deviceContext->PSSetShader(pixelShader, nullptr, 0);
stateManager->setDrawShaders(&mBufferToTextureVS, geometryShader, pixelShader);
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, bufferSRV);
stateManager->setInputLayout(nullptr);
stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
......@@ -261,7 +258,7 @@ gl::Error PixelTransfer11::buildShaderMap()
return gl::NoError();
}
ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
const d3d11::PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
{
GLenum componentType = gl::GetSizedInternalFormatInfo(internalFormat).componentType;
if (componentType == GL_SIGNED_NORMALIZED || componentType == GL_UNSIGNED_NORMALIZED)
......@@ -270,7 +267,7 @@ ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat)
}
auto shaderMapIt = mBufferToTexturePSMap.find(componentType);
return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second.get());
return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : &shaderMapIt->second);
}
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h
......@@ -73,7 +73,7 @@ class PixelTransfer11
gl::Error loadResources();
gl::Error buildShaderMap();
ID3D11PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
const d3d11::PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
Renderer11 *mRenderer;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -423,11 +423,6 @@ Renderer11::Renderer11(egl::Display *display)
mDxgiAdapter = nullptr;
mDxgiFactory = nullptr;
mAppliedVertexShader = angle::DirtyPointer;
mAppliedGeometryShader = angle::DirtyPointer;
mAppliedPixelShader = angle::DirtyPointer;
mAppliedComputeShader = angle::DirtyPointer;
mAppliedTFObject = angle::DirtyPointer;
ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription));
......@@ -1858,7 +1853,7 @@ gl::Error Renderer11::drawArraysImpl(const gl::Context *context,
// won't get the correct output. To work around this, draw with *only* the stream out
// first (no pixel shader) to feed the stream out buffers and then draw again with the
// geometry shader + pixel shader to rasterize the primitives.
mDeviceContext->PSSetShader(nullptr, nullptr, 0);
mStateManager.setPixelShader(nullptr);
if (instances > 0)
{
......@@ -1879,20 +1874,15 @@ gl::Error Renderer11::drawArraysImpl(const gl::Context *context,
return gl::NoError();
}
ID3D11PixelShader *pixelShader = GetAs<ShaderExecutable11>(pixelExe)->getPixelShader();
ASSERT(reinterpret_cast<uintptr_t>(pixelShader) == mAppliedPixelShader);
mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
mStateManager.setPixelShader(&GetAs<ShaderExecutable11>(pixelExe)->getPixelShader());
// Retrieve the geometry shader.
rx::ShaderExecutableD3D *geometryExe = nullptr;
ANGLE_TRY(
programD3D->getGeometryExecutableForPrimitiveType(data, mode, &geometryExe, nullptr));
ID3D11GeometryShader *geometryShader =
(geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
ASSERT(geometryShader);
mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
mStateManager.setGeometryShader(
&GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader());
if (instances > 0)
{
......@@ -2379,45 +2369,29 @@ gl::Error Renderer11::applyShaders(const gl::Context *context, GLenum drawMode)
ANGLE_TRY(
programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr));
ID3D11VertexShader *vertexShader =
(vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
const d3d11::VertexShader *vertexShader =
(vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
// Skip pixel shader if we're doing rasterizer discard.
ID3D11PixelShader *pixelShader = nullptr;
const d3d11::PixelShader *pixelShader = nullptr;
if (!glState.getRasterizerState().rasterizerDiscard)
{
pixelShader = (pixelExe ? GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
}
ID3D11GeometryShader *geometryShader = nullptr;
const d3d11::GeometryShader *geometryShader = nullptr;
if (glState.isTransformFeedbackActiveUnpaused())
{
geometryShader =
(vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
(vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
}
else
{
geometryShader =
(geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
(geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
}
if (reinterpret_cast<uintptr_t>(vertexShader) != mAppliedVertexShader)
{
mDeviceContext->VSSetShader(vertexShader, nullptr, 0);
mAppliedVertexShader = reinterpret_cast<uintptr_t>(vertexShader);
}
if (reinterpret_cast<uintptr_t>(geometryShader) != mAppliedGeometryShader)
{
mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
}
if (reinterpret_cast<uintptr_t>(pixelShader) != mAppliedPixelShader)
{
mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
mAppliedPixelShader = reinterpret_cast<uintptr_t>(pixelShader);
}
mStateManager.setDrawShaders(vertexShader, geometryShader, pixelShader);
return programD3D->applyUniforms(drawMode);
}
......@@ -2761,11 +2735,6 @@ void Renderer11::markAllStateDirty(const gl::Context *context)
mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
mAppliedIBOffset = 0;
mAppliedVertexShader = angle::DirtyPointer;
mAppliedGeometryShader = angle::DirtyPointer;
mAppliedPixelShader = angle::DirtyPointer;
mAppliedComputeShader = angle::DirtyPointer;
mAppliedTFObject = angle::DirtyPointer;
memset(&mAppliedVertexConstants, 0, sizeof(dx_VertexConstants11));
......@@ -4748,15 +4717,9 @@ gl::Error Renderer11::applyComputeShader(const gl::ContextState &data)
ShaderExecutableD3D *computeExe = nullptr;
ANGLE_TRY(programD3D->getComputeExecutable(&computeExe));
ASSERT(computeExe != nullptr);
ID3D11ComputeShader *computeShader = GetAs<ShaderExecutable11>(computeExe)->getComputeShader();
if (reinterpret_cast<uintptr_t>(computeShader) != mAppliedComputeShader)
{
mDeviceContext->CSSetShader(computeShader, nullptr, 0);
mAppliedComputeShader = reinterpret_cast<uintptr_t>(computeShader);
}
mStateManager.setComputeShader(&GetAs<ShaderExecutable11>(computeExe)->getComputeShader());
return programD3D->applyComputeUniforms();
}
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -630,12 +630,6 @@ class Renderer11 : public RendererD3D
// Currently applied transform feedback buffers
uintptr_t mAppliedTFObject;
// Currently applied shaders
uintptr_t mAppliedVertexShader;
uintptr_t mAppliedGeometryShader;
uintptr_t mAppliedPixelShader;
uintptr_t mAppliedComputeShader;
dx_VertexConstants11 mAppliedVertexConstants;
d3d11::Buffer mDriverConstantBufferVS;
SamplerMetadataD3D11 mSamplerMetadataVS;
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
......@@ -66,29 +66,29 @@ ShaderExecutable11::~ShaderExecutable11()
{
}
ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
const d3d11::VertexShader &ShaderExecutable11::getVertexShader() const
{
return mVertexExecutable.get();
return mVertexExecutable;
}
ID3D11PixelShader *ShaderExecutable11::getPixelShader() const
const d3d11::PixelShader &ShaderExecutable11::getPixelShader() const
{
return mPixelExecutable.get();
return mPixelExecutable;
}
ID3D11GeometryShader *ShaderExecutable11::getGeometryShader() const
const d3d11::GeometryShader &ShaderExecutable11::getGeometryShader() const
{
return mGeometryExecutable.get();
return mGeometryExecutable;
}
ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
const d3d11::GeometryShader &ShaderExecutable11::getStreamOutShader() const
{
return mStreamOutExecutable.get();
return mStreamOutExecutable;
}
ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
const d3d11::ComputeShader &ShaderExecutable11::getComputeShader() const
{
return mComputeExecutable.get();
return mComputeExecutable;
}
UniformStorage11::UniformStorage11(size_t initialSize)
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
......@@ -31,11 +31,11 @@ class ShaderExecutable11 : public ShaderExecutableD3D
virtual ~ShaderExecutable11();
ID3D11PixelShader *getPixelShader() const;
ID3D11VertexShader *getVertexShader() const;
ID3D11GeometryShader *getGeometryShader() const;
ID3D11GeometryShader *getStreamOutShader() const;
ID3D11ComputeShader *getComputeShader() const;
const d3d11::PixelShader &getPixelShader() const;
const d3d11::VertexShader &getVertexShader() const;
const d3d11::GeometryShader &getGeometryShader() const;
const d3d11::GeometryShader &getStreamOutShader() const;
const d3d11::ComputeShader &getComputeShader() const;
private:
d3d11::PixelShader mPixelExecutable;
......
src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
......@@ -848,6 +848,11 @@ void StateManager11::invalidateEverything(const gl::Context *context)
invalidateVertexBuffer();
mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
mAppliedVertexShader.dirty();
mAppliedGeometryShader.dirty();
mAppliedPixelShader.dirty();
mAppliedComputeShader.dirty();
}
void StateManager11::invalidateVertexBuffer()
......@@ -1294,4 +1299,61 @@ void StateManager11::setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopo
}
}
void StateManager11::setDrawShaders(const d3d11::VertexShader *vertexShader,
const d3d11::GeometryShader *geometryShader,
const d3d11::PixelShader *pixelShader)
{
setVertexShader(vertexShader);
setGeometryShader(geometryShader);
setPixelShader(pixelShader);
}
void StateManager11::setVertexShader(const d3d11::VertexShader *shader)
{
ResourceSerial serial = shader ? shader->getSerial() : 0;
if (serial != mAppliedVertexShader)
{
ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0);
mAppliedVertexShader = serial;
}
}
void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader)
{
ResourceSerial serial = shader ? shader->getSerial() : 0;
if (serial != mAppliedGeometryShader)
{
ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0);
mAppliedGeometryShader = serial;
}
}
void StateManager11::setPixelShader(const d3d11::PixelShader *shader)
{
ResourceSerial serial = shader ? shader->getSerial() : 0;
if (serial != mAppliedPixelShader)
{
ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0);
mAppliedPixelShader = serial;
}
}
void StateManager11::setComputeShader(const d3d11::ComputeShader *shader)
{
ResourceSerial serial = shader ? shader->getSerial() : 0;
if (serial != mAppliedComputeShader)
{
ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0);
mAppliedComputeShader = serial;
}
}
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/StateManager11.h
......@@ -111,6 +111,14 @@ class StateManager11 final : angle::NonCopyable
void setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology);
void setDrawShaders(const d3d11::VertexShader *vertexShader,
const d3d11::GeometryShader *geometryShader,
const d3d11::PixelShader *pixelShader);
void setVertexShader(const d3d11::VertexShader *shader);
void setGeometryShader(const d3d11::GeometryShader *shader);
void setPixelShader(const d3d11::PixelShader *shader);
void setComputeShader(const d3d11::ComputeShader *shader);
private:
void unsetConflictingSRVs(gl::SamplerType shaderType,
uintptr_t resource,
......@@ -249,6 +257,12 @@ class StateManager11 final : angle::NonCopyable
// Currently applied primitive topology
D3D11_PRIMITIVE_TOPOLOGY mCurrentPrimitiveTopology;
// Currently applied shaders
ResourceSerial mAppliedVertexShader;
ResourceSerial mAppliedGeometryShader;
ResourceSerial mAppliedPixelShader;
ResourceSerial mAppliedComputeShader;
};
} // namespace rx
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
......@@ -814,9 +814,7 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(const gl::Context *context,
// Apply shaders
stateManager->setInputLayout(&mPassThroughIL);
stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS.get(), nullptr, 0);
deviceContext->PSSetShader(mPassThroughPS.get(), nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
stateManager->setDrawShaders(&mPassThroughVS, nullptr, &mPassThroughPS);
// Apply render targets. Use the proxy context in display.
stateManager->setOneTimeRenderTarget(context, mBackBufferRTView.get(), nullptr);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment