Skip to content

A
angle
Commit 81970bc3 by Jiawei Shao Committed by Commit Bot
Options

Use ShaderMap in DynamicHLSL and StateManager11 - Part I

This patch is the first one of using ShaderMap in both DynamicHLSL and StateManager11 to make the code cleaner and more straightforward. BUG=angleproject:2169 Change-Id: I2b206d0250f5ced071cc1c3632367b16e5e02dfb Reviewed-on: https://chromium-review.googlesource.com/1089473Reviewed-by: 's avatarJiajia Qin <jiajia.qin@intel.com> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
parent e1a057e8
Showing with 111 additions and 194 deletions
src/libANGLE/renderer/d3d/DynamicHLSL.cpp
...@@ -1349,7 +1349,7 @@ void BuiltinVaryingsD3D::updateBuiltins(gl::ShaderType shaderType, ...@@ -1349,7 +1349,7 @@ void BuiltinVaryingsD3D::updateBuiltins(gl::ShaderType shaderType,
unsigned int reservedSemanticIndex = packing.getMaxSemanticIndex(); unsigned int reservedSemanticIndex = packing.getMaxSemanticIndex();
BuiltinInfo *builtins = &mBuiltinInfo[static_cast<size_t>(shaderType)]; BuiltinInfo *builtins = &mBuiltinInfo[shaderType];
if (metadata.getRendererMajorShaderModel() >= 4) if (metadata.getRendererMajorShaderModel() >= 4)
{ {
......
src/libANGLE/renderer/d3d/DynamicHLSL.h
...@@ -98,26 +98,20 @@ class BuiltinVaryingsD3D ...@@ -98,26 +98,20 @@ class BuiltinVaryingsD3D
BuiltinVaryingsD3D(const ProgramD3DMetadata &metadata, const gl::VaryingPacking &packing); BuiltinVaryingsD3D(const ProgramD3DMetadata &metadata, const gl::VaryingPacking &packing);
~BuiltinVaryingsD3D(); ~BuiltinVaryingsD3D();
bool usesPointSize() const bool usesPointSize() const { return mBuiltinInfo[gl::ShaderType::Vertex].glPointSize.enabled; }
{
return mBuiltinInfo[static_cast<size_t>(gl::ShaderType::Vertex)].glPointSize.enabled;
}
const BuiltinInfo &operator[](gl::ShaderType shaderType) const const BuiltinInfo &operator[](gl::ShaderType shaderType) const
{ {
return mBuiltinInfo[static_cast<size_t>(shaderType)]; return mBuiltinInfo[shaderType];
}
BuiltinInfo &operator[](gl::ShaderType shaderType)
{
return mBuiltinInfo[static_cast<size_t>(shaderType)];
} }
BuiltinInfo &operator[](gl::ShaderType shaderType) { return mBuiltinInfo[shaderType]; }
private: private:
void updateBuiltins(gl::ShaderType shaderType, void updateBuiltins(gl::ShaderType shaderType,
const ProgramD3DMetadata &metadata, const ProgramD3DMetadata &metadata,
const gl::VaryingPacking &packing); const gl::VaryingPacking &packing);
std::array<BuiltinInfo, static_cast<size_t>(gl::ShaderType::EnumCount)> mBuiltinInfo; gl::ShaderMap<BuiltinInfo> mBuiltinInfo;
}; };
class DynamicHLSL : angle::NonCopyable class DynamicHLSL : angle::NonCopyable
......
src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
...@@ -244,23 +244,12 @@ void StateManager11::ViewCache<ViewType, DescType>::clear() ...@@ -244,23 +244,12 @@ void StateManager11::ViewCache<ViewType, DescType>::clear()
StateManager11::SRVCache *StateManager11::getSRVCache(gl::ShaderType shaderType) StateManager11::SRVCache *StateManager11::getSRVCache(gl::ShaderType shaderType)
{ {
switch (shaderType) ASSERT(shaderType != gl::ShaderType::InvalidEnum);
{ return &mCurShaderSRVs[shaderType];
case gl::ShaderType::Vertex:
return &mCurVertexSRVs;
case gl::ShaderType::Fragment:
return &mCurPixelSRVs;
case gl::ShaderType::Compute:
return &mCurComputeSRVs;
default:
UNREACHABLE();
return &mCurVertexSRVs;
}
} }
// ShaderConstants11 implementation // ShaderConstants11 implementation
ShaderConstants11::ShaderConstants11() ShaderConstants11::ShaderConstants11() : mNumActiveShaderSamplers({})
: mNumActiveVSSamplers(0), mNumActivePSSamplers(0), mNumActiveCSSamplers(0)
{ {
mShaderConstantsDirty.set(); mShaderConstantsDirty.set();
} }
...@@ -271,33 +260,44 @@ ShaderConstants11::~ShaderConstants11() ...@@ -271,33 +260,44 @@ ShaderConstants11::~ShaderConstants11()
void ShaderConstants11::init(const gl::Caps &caps) void ShaderConstants11::init(const gl::Caps &caps)
{ {
mSamplerMetadataVS.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]); for (gl::ShaderType shaderType : gl::AllShaderTypes())
mSamplerMetadataPS.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]); {
mSamplerMetadataCS.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Compute]); mShaderSamplerMetadata[shaderType].resize(caps.maxShaderTextureImageUnits[shaderType]);
}
} }
size_t ShaderConstants11::getRequiredBufferSize(gl::ShaderType shaderType) const size_t ShaderConstants11::GetShaderConstantsStructSize(gl::ShaderType shaderType)
{ {
switch (shaderType) switch (shaderType)
{ {
case gl::ShaderType::Vertex: case gl::ShaderType::Vertex:
return sizeof(Vertex) + mSamplerMetadataVS.size() * sizeof(SamplerMetadata); return sizeof(Vertex);
case gl::ShaderType::Fragment: case gl::ShaderType::Fragment:
return sizeof(Pixel) + mSamplerMetadataPS.size() * sizeof(SamplerMetadata); return sizeof(Pixel);
case gl::ShaderType::Compute: case gl::ShaderType::Compute:
return sizeof(Compute) + mSamplerMetadataCS.size() * sizeof(SamplerMetadata); return sizeof(Compute);
// TODO(jiawei.shao@intel.com): return geometry shader constant struct size
case gl::ShaderType::Geometry:
return 0u;
default: default:
UNREACHABLE(); UNREACHABLE();
return 0; return 0u;
} }
} }
size_t ShaderConstants11::getRequiredBufferSize(gl::ShaderType shaderType) const
{
ASSERT(shaderType != gl::ShaderType::InvalidEnum);
return GetShaderConstantsStructSize(shaderType) +
mShaderSamplerMetadata[shaderType].size() * sizeof(SamplerMetadata);
}
void ShaderConstants11::markDirty() void ShaderConstants11::markDirty()
{ {
mShaderConstantsDirty.set(); mShaderConstantsDirty.set();
mNumActiveVSSamplers = 0; mNumActiveShaderSamplers.fill(0);
mNumActivePSSamplers = 0;
mNumActiveCSSamplers = 0;
} }
bool ShaderConstants11::updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture) bool ShaderConstants11::updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture)
...@@ -463,29 +463,10 @@ void ShaderConstants11::onSamplerChange(gl::ShaderType shaderType, ...@@ -463,29 +463,10 @@ void ShaderConstants11::onSamplerChange(gl::ShaderType shaderType,
unsigned int samplerIndex, unsigned int samplerIndex,
const gl::Texture &texture) const gl::Texture &texture)
{ {
switch (shaderType) ASSERT(shaderType != gl::ShaderType::InvalidEnum);
if (updateSamplerMetadata(&mShaderSamplerMetadata[shaderType][samplerIndex], texture))
{ {
case gl::ShaderType::Vertex: mNumActiveShaderSamplers[shaderType] = 0;
if (updateSamplerMetadata(&mSamplerMetadataVS[samplerIndex], texture))
{
mNumActiveVSSamplers = 0;
}
break;
case gl::ShaderType::Fragment:
if (updateSamplerMetadata(&mSamplerMetadataPS[samplerIndex], texture))
{
mNumActivePSSamplers = 0;
}
break;
case gl::ShaderType::Compute:
if (updateSamplerMetadata(&mSamplerMetadataCS[samplerIndex], texture))
{
mNumActiveCSSamplers = 0;
}
break;
default:
UNREACHABLE();
break;
} }
} }
...@@ -494,43 +475,30 @@ gl::Error ShaderConstants11::updateBuffer(Renderer11 *renderer, ...@@ -494,43 +475,30 @@ gl::Error ShaderConstants11::updateBuffer(Renderer11 *renderer,
const ProgramD3D &programD3D, const ProgramD3D &programD3D,
const d3d11::Buffer &driverConstantBuffer) const d3d11::Buffer &driverConstantBuffer)
{ {
bool dirty = false;
size_t dataSize = 0;
const uint8_t *data = nullptr;
const uint8_t *samplerData = nullptr;
// Re-upload the sampler meta-data if the current program uses more samplers // Re-upload the sampler meta-data if the current program uses more samplers
// than we previously uploaded. // than we previously uploaded.
int numSamplers = programD3D.getUsedSamplerRange(shaderType); const int numSamplers = programD3D.getUsedSamplerRange(shaderType);
const bool dirty =
mShaderConstantsDirty[shaderType] || (mNumActiveShaderSamplers[shaderType] < numSamplers);
const size_t dataSize = GetShaderConstantsStructSize(shaderType);
const uint8_t *samplerData =
reinterpret_cast<const uint8_t *>(mShaderSamplerMetadata[shaderType].data());
mNumActiveShaderSamplers[shaderType] = numSamplers;
mShaderConstantsDirty.set(shaderType, false);
const uint8_t *data = nullptr;
switch (shaderType) switch (shaderType)
{ {
case gl::ShaderType::Vertex: case gl::ShaderType::Vertex:
dirty = mShaderConstantsDirty[gl::ShaderType::Vertex] || data = reinterpret_cast<const uint8_t *>(&mVertex);
(mNumActiveVSSamplers < numSamplers);
dataSize = sizeof(Vertex);
data = reinterpret_cast<const uint8_t *>(&mVertex);
samplerData = reinterpret_cast<const uint8_t *>(mSamplerMetadataVS.data());
mShaderConstantsDirty.set(gl::ShaderType::Vertex, false);
mNumActiveVSSamplers = numSamplers;
break; break;
case gl::ShaderType::Fragment: case gl::ShaderType::Fragment:
dirty = mShaderConstantsDirty[gl::ShaderType::Fragment] || data = reinterpret_cast<const uint8_t *>(&mPixel);
(mNumActivePSSamplers < numSamplers);
dataSize = sizeof(Pixel);
data = reinterpret_cast<const uint8_t *>(&mPixel);
samplerData = reinterpret_cast<const uint8_t *>(mSamplerMetadataPS.data());
mShaderConstantsDirty.set(gl::ShaderType::Fragment, false);
mNumActivePSSamplers = numSamplers;
break; break;
case gl::ShaderType::Compute: case gl::ShaderType::Compute:
dirty = mShaderConstantsDirty[gl::ShaderType::Compute] || data = reinterpret_cast<const uint8_t *>(&mCompute);
(mNumActiveCSSamplers < numSamplers);
dataSize = sizeof(Compute);
data = reinterpret_cast<const uint8_t *>(&mCompute);
samplerData = reinterpret_cast<const uint8_t *>(mSamplerMetadataCS.data());
mShaderConstantsDirty.set(gl::ShaderType::Compute, false);
mNumActiveCSSamplers = numSamplers;
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();
...@@ -1438,8 +1406,10 @@ void StateManager11::processFramebufferInvalidation(const gl::Context *context) ...@@ -1438,8 +1406,10 @@ void StateManager11::processFramebufferInvalidation(const gl::Context *context)
void StateManager11::invalidateBoundViews() void StateManager11::invalidateBoundViews()
{ {
mCurVertexSRVs.clear(); for (SRVCache &curShaderSRV : mCurShaderSRVs)
mCurPixelSRVs.clear(); {
curShaderSRV.clear();
}
invalidateRenderTarget(); invalidateRenderTarget();
} }
...@@ -1728,11 +1698,14 @@ void StateManager11::unsetConflictingAttachmentResources( ...@@ -1728,11 +1698,14 @@ void StateManager11::unsetConflictingAttachmentResources(
gl::Error StateManager11::initialize(const gl::Caps &caps, const gl::Extensions &extensions) gl::Error StateManager11::initialize(const gl::Caps &caps, const gl::Extensions &extensions)
{ {
mCurVertexSRVs.initialize(caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]); for (gl::ShaderType shaderType : gl::AllShaderTypes())
mCurPixelSRVs.initialize(caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]); {
const GLuint maxShaderTextureImageUnits = caps.maxShaderTextureImageUnits[shaderType];
// TODO(xinghua.cao@intel.com): need to add compute shader texture image units. mCurShaderSRVs[shaderType].initialize(maxShaderTextureImageUnits);
mCurComputeSRVs.initialize(caps.maxImageUnits); mForceSetShaderSamplerStates[shaderType].resize(maxShaderTextureImageUnits, true);
mCurShaderSamplerStates[shaderType].resize(maxShaderTextureImageUnits);
}
mCurComputeUAVs.initialize(caps.maxImageUnits); mCurComputeUAVs.initialize(caps.maxImageUnits);
...@@ -1743,17 +1716,6 @@ gl::Error StateManager11::initialize(const gl::Caps &caps, const gl::Extensions ...@@ -1743,17 +1716,6 @@ gl::Error StateManager11::initialize(const gl::Caps &caps, const gl::Extensions
mCurrentValueAttribs.resize(caps.maxVertexAttributes); mCurrentValueAttribs.resize(caps.maxVertexAttributes);
mForceSetVertexSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex],
true);
mForceSetPixelSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment],
true);
mForceSetComputeSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Compute],
true);
mCurVertexSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex]);
mCurPixelSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]);
mCurComputeSamplerStates.resize(caps.maxShaderTextureImageUnits[gl::ShaderType::Compute]);
mShaderConstants.init(caps); mShaderConstants.init(caps);
mIsMultiviewEnabled = extensions.multiview; mIsMultiviewEnabled = extensions.multiview;
...@@ -1801,11 +1763,11 @@ gl::Error StateManager11::syncFramebuffer(const gl::Context *context) ...@@ -1801,11 +1763,11 @@ gl::Error StateManager11::syncFramebuffer(const gl::Context *context)
RTVArray framebufferRTVs = {{}}; RTVArray framebufferRTVs = {{}};
const auto &colorRTs = mFramebuffer11->getCachedColorRenderTargets(); const auto &colorRTs = mFramebuffer11->getCachedColorRenderTargets();
size_t appliedRTIndex = 0; size_t appliedRTIndex = 0;
bool skipInactiveRTs = mRenderer->getWorkarounds().mrtPerfWorkaround; bool skipInactiveRTs = mRenderer->getWorkarounds().mrtPerfWorkaround;
const auto &drawStates = mFramebuffer11->getState().getDrawBufferStates(); const auto &drawStates = mFramebuffer11->getState().getDrawBufferStates();
gl::DrawBufferMask activeProgramOutputs = mProgramD3D->getState().getActiveOutputVariables(); gl::DrawBufferMask activeProgramOutputs = mProgramD3D->getState().getActiveOutputVariables();
UINT maxExistingRT = 0; UINT maxExistingRT = 0;
const auto &colorAttachments = mFramebuffer11->getState().getColorAttachments(); const auto &colorAttachments = mFramebuffer11->getState().getColorAttachments();
for (size_t rtIndex = 0; rtIndex < colorRTs.size(); ++rtIndex) for (size_t rtIndex = 0; rtIndex < colorRTs.size(); ++rtIndex)
...@@ -2177,11 +2139,11 @@ void StateManager11::setVertexShader(const d3d11::VertexShader *shader) ...@@ -2177,11 +2139,11 @@ void StateManager11::setVertexShader(const d3d11::VertexShader *shader)
{ {
ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0);
if (serial != mAppliedVertexShader) if (serial != mAppliedShaders[gl::ShaderType::Vertex])
{ {
ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr; ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0); mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0);
mAppliedVertexShader = serial; mAppliedShaders[gl::ShaderType::Vertex] = serial;
invalidateShaders(); invalidateShaders();
} }
} }
...@@ -2190,11 +2152,11 @@ void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader) ...@@ -2190,11 +2152,11 @@ void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader)
{ {
ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0);
if (serial != mAppliedGeometryShader) if (serial != mAppliedShaders[gl::ShaderType::Geometry])
{ {
ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr; ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0); mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0);
mAppliedGeometryShader = serial; mAppliedShaders[gl::ShaderType::Geometry] = serial;
invalidateShaders(); invalidateShaders();
} }
} }
...@@ -2203,11 +2165,11 @@ void StateManager11::setPixelShader(const d3d11::PixelShader *shader) ...@@ -2203,11 +2165,11 @@ void StateManager11::setPixelShader(const d3d11::PixelShader *shader)
{ {
ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0);
if (serial != mAppliedPixelShader) if (serial != mAppliedShaders[gl::ShaderType::Fragment])
{ {
ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr; ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0); mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0);
mAppliedPixelShader = serial; mAppliedShaders[gl::ShaderType::Fragment] = serial;
invalidateShaders(); invalidateShaders();
} }
} }
...@@ -2216,11 +2178,11 @@ void StateManager11::setComputeShader(const d3d11::ComputeShader *shader) ...@@ -2216,11 +2178,11 @@ void StateManager11::setComputeShader(const d3d11::ComputeShader *shader)
{ {
ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0); ResourceSerial serial = shader ? shader->getSerial() : ResourceSerial(0);
if (serial != mAppliedComputeShader) if (serial != mAppliedShaders[gl::ShaderType::Compute])
{ {
ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr; ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr;
mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0); mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0);
mAppliedComputeShader = serial; mAppliedShaders[gl::ShaderType::Compute] = serial;
// TODO(jmadill): Dirty bits for compute. // TODO(jmadill): Dirty bits for compute.
} }
} }
...@@ -2360,7 +2322,7 @@ void StateManager11::setSimplePixelTextureAndSampler(const d3d11::SharedSRV &srv ...@@ -2360,7 +2322,7 @@ void StateManager11::setSimplePixelTextureAndSampler(const d3d11::SharedSRV &srv
deviceContext->PSSetSamplers(0, 1, samplerState.getPointer()); deviceContext->PSSetSamplers(0, 1, samplerState.getPointer());
mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE); mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE);
mForceSetPixelSamplerStates[0] = true; mForceSetShaderSamplerStates[gl::ShaderType::Fragment][0] = true;
} }
void StateManager11::setSimpleScissorRect(const gl::Rectangle &glRect) void StateManager11::setSimpleScissorRect(const gl::Rectangle &glRect)
...@@ -2386,8 +2348,8 @@ void StateManager11::setScissorRectD3D(const D3D11_RECT &d3dRect) ...@@ -2386,8 +2348,8 @@ void StateManager11::setScissorRectD3D(const D3D11_RECT &d3dRect)
gl::Error StateManager11::applyTextures(const gl::Context *context, gl::ShaderType shaderType) gl::Error StateManager11::applyTextures(const gl::Context *context, gl::ShaderType shaderType)
{ {
ASSERT(shaderType != gl::ShaderType::Compute); ASSERT(shaderType != gl::ShaderType::Compute);
const auto &glState = context->getGLState(); const auto &glState = context->getGLState();
const auto &caps = context->getCaps(); const auto &caps = context->getCaps();
ASSERT(!mProgramD3D->isSamplerMappingDirty()); ASSERT(!mProgramD3D->isSamplerMappingDirty());
...@@ -2428,9 +2390,7 @@ gl::Error StateManager11::applyTextures(const gl::Context *context, gl::ShaderTy ...@@ -2428,9 +2390,7 @@ gl::Error StateManager11::applyTextures(const gl::Context *context, gl::ShaderTy
} }
// Set all the remaining textures to NULL // Set all the remaining textures to NULL
size_t samplerCount = (shaderType == gl::ShaderType::Fragment) size_t samplerCount = caps.maxShaderTextureImageUnits[shaderType];
? caps.maxShaderTextureImageUnits[gl::ShaderType::Fragment]
: caps.maxShaderTextureImageUnits[gl::ShaderType::Vertex];
ANGLE_TRY(clearSRVs(shaderType, samplerRange, samplerCount)); ANGLE_TRY(clearSRVs(shaderType, samplerRange, samplerCount));
return gl::NoError(); return gl::NoError();
...@@ -2459,69 +2419,45 @@ gl::Error StateManager11::setSamplerState(const gl::Context *context, ...@@ -2459,69 +2419,45 @@ gl::Error StateManager11::setSamplerState(const gl::Context *context,
auto *deviceContext = mRenderer->getDeviceContext(); auto *deviceContext = mRenderer->getDeviceContext();
if (type == gl::ShaderType::Fragment) ASSERT(static_cast<unsigned int>(index) <
{ mRenderer->getNativeCaps().maxShaderTextureImageUnits[type]);
ASSERT(static_cast<unsigned int>(index) <
mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Fragment]);
if (mForceSetPixelSamplerStates[index] ||
memcmp(&samplerState, &mCurPixelSamplerStates[index], sizeof(gl::SamplerState)) != 0)
{
ID3D11SamplerState *dxSamplerState = nullptr;
ANGLE_TRY(mRenderer->getSamplerState(samplerState, &dxSamplerState));
ASSERT(dxSamplerState != nullptr);
deviceContext->PSSetSamplers(index, 1, &dxSamplerState);
mCurPixelSamplerStates[index] = samplerState; if (mForceSetShaderSamplerStates[type][index] ||
} memcmp(&samplerState, &mCurShaderSamplerStates[type][index], sizeof(gl::SamplerState)) != 0)
mForceSetPixelSamplerStates[index] = false;
}
else if (type == gl::ShaderType::Vertex)
{ {
ASSERT(static_cast<unsigned int>(index) < ID3D11SamplerState *dxSamplerState = nullptr;
mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Vertex]); ANGLE_TRY(mRenderer->getSamplerState(samplerState, &dxSamplerState));
if (mForceSetVertexSamplerStates[index] ||
memcmp(&samplerState, &mCurVertexSamplerStates[index], sizeof(gl::SamplerState)) != 0)
{
ID3D11SamplerState *dxSamplerState = nullptr;
ANGLE_TRY(mRenderer->getSamplerState(samplerState, &dxSamplerState));
ASSERT(dxSamplerState != nullptr);
deviceContext->VSSetSamplers(index, 1, &dxSamplerState);
mCurVertexSamplerStates[index] = samplerState;
}
mForceSetVertexSamplerStates[index] = false; ASSERT(dxSamplerState != nullptr);
}
else if (type == gl::ShaderType::Compute)
{
ASSERT(static_cast<unsigned int>(index) <
mRenderer->getNativeCaps().maxShaderTextureImageUnits[gl::ShaderType::Compute]);
if (mForceSetComputeSamplerStates[index] || switch (type)
memcmp(&samplerState, &mCurComputeSamplerStates[index], sizeof(gl::SamplerState)) != 0)
{ {
ID3D11SamplerState *dxSamplerState = nullptr; case gl::ShaderType::Vertex:
ANGLE_TRY(mRenderer->getSamplerState(samplerState, &dxSamplerState)); deviceContext->VSSetSamplers(index, 1, &dxSamplerState);
break;
ASSERT(dxSamplerState != nullptr); case gl::ShaderType::Fragment:
deviceContext->CSSetSamplers(index, 1, &dxSamplerState); deviceContext->PSSetSamplers(index, 1, &dxSamplerState);
break;
mCurComputeSamplerStates[index] = samplerState; case gl::ShaderType::Compute:
deviceContext->CSSetSamplers(index, 1, &dxSamplerState);
break;
case gl::ShaderType::Geometry:
deviceContext->GSSetSamplers(index, 1, &dxSamplerState);
break;
default:
UNREACHABLE();
break;
} }
mForceSetComputeSamplerStates[index] = false; mCurShaderSamplerStates[type][index] = samplerState;
} }
else
UNREACHABLE(); mForceSetShaderSamplerStates[type][index] = false;
// Sampler metadata that's passed to shaders in uniforms is stored separately from rest of the // Sampler metadata that's passed to shaders in uniforms is stored separately from rest of the
// sampler state since having it in contiguous memory makes it possible to memcpy to a constant // sampler state since having it in contiguous memory makes it possible to memcpy to a constant
// buffer, and it doesn't affect the state set by PSSetSamplers/VSSetSamplers. // buffer, and it doesn't affect the state set by
// PSSetSamplers/VSSetSamplers/CSSetSamplers/GSSetSamplers.
mShaderConstants.onSamplerChange(type, index, *texture); mShaderConstants.onSamplerChange(type, index, *texture);
return gl::NoError(); return gl::NoError();
...@@ -2569,8 +2505,8 @@ gl::Error StateManager11::setTexture(const gl::Context *context, ...@@ -2569,8 +2505,8 @@ gl::Error StateManager11::setTexture(const gl::Context *context,
gl::Error StateManager11::syncTexturesForCompute(const gl::Context *context) gl::Error StateManager11::syncTexturesForCompute(const gl::Context *context)
{ {
const auto &glState = context->getGLState(); const auto &glState = context->getGLState();
const auto &caps = context->getCaps(); const auto &caps = context->getCaps();
// TODO(xinghua.cao@intel.com): Implement sampler feature in compute shader. // TODO(xinghua.cao@intel.com): Implement sampler feature in compute shader.
unsigned int readonlyImageRange = mProgramD3D->getUsedImageRange(gl::ShaderType::Compute, true); unsigned int readonlyImageRange = mProgramD3D->getUsedImageRange(gl::ShaderType::Compute, true);
......
src/libANGLE/renderer/d3d/d3d11/StateManager11.h
...@@ -124,6 +124,8 @@ class ShaderConstants11 : angle::NonCopyable ...@@ -124,6 +124,8 @@ class ShaderConstants11 : angle::NonCopyable
static_assert(sizeof(SamplerMetadata) == 16u, static_assert(sizeof(SamplerMetadata) == 16u,
"Sampler metadata struct must be one 4-vec / 16 bytes."); "Sampler metadata struct must be one 4-vec / 16 bytes.");
static size_t GetShaderConstantsStructSize(gl::ShaderType shaderType);
// Return true if dirty. // Return true if dirty.
bool updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture); bool updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture);
...@@ -132,12 +134,8 @@ class ShaderConstants11 : angle::NonCopyable ...@@ -132,12 +134,8 @@ class ShaderConstants11 : angle::NonCopyable
Compute mCompute; Compute mCompute;
gl::ShaderBitSet mShaderConstantsDirty; gl::ShaderBitSet mShaderConstantsDirty;
std::vector<SamplerMetadata> mSamplerMetadataVS; gl::ShaderMap<std::vector<SamplerMetadata>> mShaderSamplerMetadata;
int mNumActiveVSSamplers; gl::ShaderMap<int> mNumActiveShaderSamplers;
std::vector<SamplerMetadata> mSamplerMetadataPS;
int mNumActivePSSamplers;
std::vector<SamplerMetadata> mSamplerMetadataCS;
int mNumActiveCSSamplers;
}; };
class StateManager11 final : angle::NonCopyable class StateManager11 final : angle::NonCopyable
...@@ -461,9 +459,7 @@ class StateManager11 final : angle::NonCopyable ...@@ -461,9 +459,7 @@ class StateManager11 final : angle::NonCopyable
using SRVCache = ViewCache<ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC>; using SRVCache = ViewCache<ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC>;
using UAVCache = ViewCache<ID3D11UnorderedAccessView, D3D11_UNORDERED_ACCESS_VIEW_DESC>; using UAVCache = ViewCache<ID3D11UnorderedAccessView, D3D11_UNORDERED_ACCESS_VIEW_DESC>;
SRVCache mCurVertexSRVs; gl::ShaderMap<SRVCache> mCurShaderSRVs;
SRVCache mCurPixelSRVs;
SRVCache mCurComputeSRVs;
UAVCache mCurComputeUAVs; UAVCache mCurComputeUAVs;
SRVCache *getSRVCache(gl::ShaderType shaderType); SRVCache *getSRVCache(gl::ShaderType shaderType);
...@@ -491,20 +487,11 @@ class StateManager11 final : angle::NonCopyable ...@@ -491,20 +487,11 @@ class StateManager11 final : angle::NonCopyable
GLsizei mCurrentMinimumDrawCount; GLsizei mCurrentMinimumDrawCount;
// Currently applied shaders // Currently applied shaders
ResourceSerial mAppliedVertexShader; gl::ShaderMap<ResourceSerial> mAppliedShaders;
ResourceSerial mAppliedGeometryShader;
ResourceSerial mAppliedPixelShader;
ResourceSerial mAppliedComputeShader;
// Currently applied sampler states // Currently applied sampler states
std::vector<bool> mForceSetVertexSamplerStates; gl::ShaderMap<std::vector<bool>> mForceSetShaderSamplerStates;
std::vector<gl::SamplerState> mCurVertexSamplerStates; gl::ShaderMap<std::vector<gl::SamplerState>> mCurShaderSamplerStates;
std::vector<bool> mForceSetPixelSamplerStates;
std::vector<gl::SamplerState> mCurPixelSamplerStates;
std::vector<bool> mForceSetComputeSamplerStates;
std::vector<gl::SamplerState> mCurComputeSamplerStates;
// Special dirty bit for swizzles. Since they use internal shaders, must be done in a pre-pass. // Special dirty bit for swizzles. Since they use internal shaders, must be done in a pre-pass.
bool mDirtySwizzles; bool mDirtySwizzles;
......
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