Revert "D3D11: Add support to compile and link compute shaders."
Fails https://build.chromium.org/p/chromium.gpu.fyi/builders/Linux%20Debug%20%28New%20Intel%29/builds/5769
BUG=angleproject:1442
This reverts commit 2cd9d7e032fb412b539a907c58342060340387a1.
Change-Id: Ic1610d20ba0449b423528fa9840aa951c012cf84
Reviewed-on: https://chromium-review.googlesource.com/427229
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>
diff --git a/src/libANGLE/renderer/d3d/ProgramD3D.cpp b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
index 85acde7..420d8ee 100644
--- a/src/libANGLE/renderer/d3d/ProgramD3D.cpp
+++ b/src/libANGLE/renderer/d3d/ProgramD3D.cpp
@@ -246,7 +246,6 @@
dirty(true),
vsRegisterIndex(GL_INVALID_INDEX),
psRegisterIndex(GL_INVALID_INDEX),
- csRegisterIndex(GL_INVALID_INDEX),
registerCount(0),
registerElement(0)
{
@@ -284,11 +283,6 @@
return psRegisterIndex != GL_INVALID_INDEX;
}
-bool D3DUniform::isReferencedByComputeShader() const
-{
- return csRegisterIndex != GL_INVALID_INDEX;
-}
-
// D3DVarying Implementation
D3DVarying::D3DVarying() : semanticIndex(0), componentCount(0), outputSlot(0)
@@ -493,17 +487,14 @@
ProgramD3D::ProgramD3D(const gl::ProgramState &state, RendererD3D *renderer)
: ProgramImpl(state),
mRenderer(renderer),
- mDynamicHLSL(nullptr),
- mGeometryExecutables(gl::PRIMITIVE_TYPE_MAX),
- mComputeExecutable(nullptr),
+ mDynamicHLSL(NULL),
+ mGeometryExecutables(gl::PRIMITIVE_TYPE_MAX, nullptr),
mUsesPointSize(false),
mUsesFlatInterpolation(false),
- mVertexUniformStorage(nullptr),
- mFragmentUniformStorage(nullptr),
- mComputeUniformStorage(nullptr),
+ mVertexUniformStorage(NULL),
+ mFragmentUniformStorage(NULL),
mUsedVertexSamplerRange(0),
mUsedPixelSamplerRange(0),
- mUsedComputeSamplerRange(0),
mDirtySamplerMapping(true),
mSerial(issueSerial())
{
@@ -558,13 +549,6 @@
logicalTextureUnit = mSamplersVS[samplerIndex].logicalTextureUnit;
}
break;
- case gl::SAMPLER_COMPUTE:
- ASSERT(samplerIndex < caps.maxComputeTextureImageUnits);
- if (samplerIndex < mSamplersCS.size() && mSamplersCS[samplerIndex].active)
- {
- logicalTextureUnit = mSamplersCS[samplerIndex].logicalTextureUnit;
- }
- break;
default:
UNREACHABLE();
}
@@ -592,10 +576,6 @@
ASSERT(samplerIndex < mSamplersVS.size());
ASSERT(mSamplersVS[samplerIndex].active);
return mSamplersVS[samplerIndex].textureType;
- case gl::SAMPLER_COMPUTE:
- ASSERT(samplerIndex < mSamplersCS.size());
- ASSERT(mSamplersCS[samplerIndex].active);
- return mSamplersCS[samplerIndex].textureType;
default:
UNREACHABLE();
}
@@ -611,8 +591,6 @@
return mUsedPixelSamplerRange;
case gl::SAMPLER_VERTEX:
return mUsedVertexSamplerRange;
- case gl::SAMPLER_COMPUTE:
- return mUsedComputeSamplerRange;
default:
UNREACHABLE();
return 0u;
@@ -671,22 +649,6 @@
}
}
}
-
- if (d3dUniform->isReferencedByComputeShader())
- {
- unsigned int firstIndex = d3dUniform->csRegisterIndex;
-
- for (int i = 0; i < count; i++)
- {
- unsigned int samplerIndex = firstIndex + i;
-
- if (samplerIndex < mSamplersCS.size())
- {
- ASSERT(mSamplersCS[samplerIndex].active);
- mSamplersCS[samplerIndex].logicalTextureUnit = v[i][0];
- }
- }
- }
}
}
@@ -740,19 +702,8 @@
mSamplersVS.push_back(sampler);
}
- const unsigned int csSamplerCount = stream->readInt<unsigned int>();
- for (unsigned int i = 0; i < csSamplerCount; ++i)
- {
- Sampler sampler;
- stream->readBool(&sampler.active);
- stream->readInt(&sampler.logicalTextureUnit);
- stream->readInt(&sampler.textureType);
- mSamplersCS.push_back(sampler);
- }
-
stream->readInt(&mUsedVertexSamplerRange);
stream->readInt(&mUsedPixelSamplerRange);
- stream->readInt(&mUsedComputeSamplerRange);
const unsigned int uniformCount = stream->readInt<unsigned int>();
if (stream->error())
@@ -772,7 +723,6 @@
linkedUniform.isInDefaultBlock());
stream->readInt(&d3dUniform->psRegisterIndex);
stream->readInt(&d3dUniform->vsRegisterIndex);
- stream->readInt(&d3dUniform->csRegisterIndex);
stream->readInt(&d3dUniform->registerCount);
stream->readInt(&d3dUniform->registerElement);
@@ -792,7 +742,6 @@
D3DUniformBlock uniformBlock;
stream->readInt(&uniformBlock.psRegisterIndex);
stream->readInt(&uniformBlock.vsRegisterIndex);
- stream->readInt(&uniformBlock.csRegisterIndex);
mD3DUniformBlocks.push_back(uniformBlock);
}
@@ -867,8 +816,8 @@
VertexExecutable::getSignature(mRenderer, inputLayout, &signature);
// add new binary
- mVertexExecutables.push_back(std::unique_ptr<VertexExecutable>(
- new VertexExecutable(inputLayout, signature, shaderExecutable)));
+ mVertexExecutables.push_back(
+ new VertexExecutable(inputLayout, signature, shaderExecutable));
stream->skip(vertexShaderSize);
}
@@ -898,8 +847,7 @@
}
// add new binary
- mPixelExecutables.push_back(
- std::unique_ptr<PixelExecutable>(new PixelExecutable(outputs, shaderExecutable)));
+ mPixelExecutables.push_back(new PixelExecutable(outputs, shaderExecutable));
stream->skip(pixelShaderSize);
}
@@ -910,46 +858,24 @@
unsigned int geometryShaderSize = stream->readInt<unsigned int>();
if (geometryShaderSize == 0)
{
+ mGeometryExecutables[geometryExeIndex] = nullptr;
continue;
}
const unsigned char *geometryShaderFunction = binary + stream->offset();
- ShaderExecutableD3D *geometryExecutable = nullptr;
ANGLE_TRY(mRenderer->loadExecutable(geometryShaderFunction, geometryShaderSize,
SHADER_GEOMETRY, mStreamOutVaryings, separateAttribs,
- &geometryExecutable));
+ &mGeometryExecutables[geometryExeIndex]));
- if (!geometryExecutable)
+ if (!mGeometryExecutables[geometryExeIndex])
{
infoLog << "Could not create geometry shader.";
return false;
}
-
- mGeometryExecutables[geometryExeIndex].reset(geometryExecutable);
-
stream->skip(geometryShaderSize);
}
- unsigned int computeShaderSize = stream->readInt<unsigned int>();
- if (computeShaderSize > 0)
- {
- const unsigned char *computeShaderFunction = binary + stream->offset();
-
- ShaderExecutableD3D *computeExecutable = nullptr;
- ANGLE_TRY(mRenderer->loadExecutable(computeShaderFunction, computeShaderSize,
- SHADER_COMPUTE, std::vector<D3DVarying>(), false,
- &computeExecutable));
-
- if (!computeExecutable)
- {
- infoLog << "Could not create compute shader.";
- return false;
- }
-
- mComputeExecutable.reset(computeExecutable);
- }
-
initializeUniformStorage();
return true;
@@ -987,17 +913,8 @@
stream->writeInt(mSamplersVS[i].textureType);
}
- stream->writeInt(mSamplersCS.size());
- for (unsigned int i = 0; i < mSamplersCS.size(); ++i)
- {
- stream->writeInt(mSamplersCS[i].active);
- stream->writeInt(mSamplersCS[i].logicalTextureUnit);
- stream->writeInt(mSamplersCS[i].textureType);
- }
-
stream->writeInt(mUsedVertexSamplerRange);
stream->writeInt(mUsedPixelSamplerRange);
- stream->writeInt(mUsedComputeSamplerRange);
stream->writeInt(mD3DUniforms.size());
for (const D3DUniform *uniform : mD3DUniforms)
@@ -1005,7 +922,6 @@
// Type, name and arraySize are redundant, so aren't stored in the binary.
stream->writeIntOrNegOne(uniform->psRegisterIndex);
stream->writeIntOrNegOne(uniform->vsRegisterIndex);
- stream->writeIntOrNegOne(uniform->csRegisterIndex);
stream->writeInt(uniform->registerCount);
stream->writeInt(uniform->registerElement);
}
@@ -1019,7 +935,6 @@
{
stream->writeIntOrNegOne(uniformBlock.psRegisterIndex);
stream->writeIntOrNegOne(uniformBlock.vsRegisterIndex);
- stream->writeIntOrNegOne(uniformBlock.csRegisterIndex);
}
stream->writeInt(mStreamOutVaryings.size());
@@ -1059,7 +974,7 @@
for (size_t vertexExecutableIndex = 0; vertexExecutableIndex < mVertexExecutables.size();
vertexExecutableIndex++)
{
- VertexExecutable *vertexExecutable = mVertexExecutables[vertexExecutableIndex].get();
+ VertexExecutable *vertexExecutable = mVertexExecutables[vertexExecutableIndex];
const auto &inputLayout = vertexExecutable->inputs();
stream->writeInt(inputLayout.size());
@@ -1080,7 +995,7 @@
for (size_t pixelExecutableIndex = 0; pixelExecutableIndex < mPixelExecutables.size();
pixelExecutableIndex++)
{
- PixelExecutable *pixelExecutable = mPixelExecutables[pixelExecutableIndex].get();
+ PixelExecutable *pixelExecutable = mPixelExecutables[pixelExecutableIndex];
const std::vector<GLenum> outputs = pixelExecutable->outputSignature();
stream->writeInt(outputs.size());
@@ -1096,28 +1011,17 @@
stream->writeBytes(pixelBlob, pixelShaderSize);
}
- for (auto const &geometryExecutable : mGeometryExecutables)
+ for (const ShaderExecutableD3D *geometryExe : mGeometryExecutables)
{
- if (!geometryExecutable)
+ if (geometryExe == nullptr)
{
stream->writeInt(0);
continue;
}
- size_t geometryShaderSize = geometryExecutable->getLength();
+ size_t geometryShaderSize = geometryExe->getLength();
stream->writeInt(geometryShaderSize);
- stream->writeBytes(geometryExecutable->getFunction(), geometryShaderSize);
- }
-
- if (mComputeExecutable)
- {
- size_t computeShaderSize = mComputeExecutable->getLength();
- stream->writeInt(computeShaderSize);
- stream->writeBytes(mComputeExecutable->getFunction(), computeShaderSize);
- }
- else
- {
- stream->writeInt(0);
+ stream->writeBytes(geometryExe->getFunction(), geometryShaderSize);
}
return gl::NoError();
@@ -1183,8 +1087,7 @@
if (pixelExecutable)
{
- mPixelExecutables.push_back(std::unique_ptr<PixelExecutable>(
- new PixelExecutable(outputSignature, pixelExecutable)));
+ mPixelExecutables.push_back(new PixelExecutable(outputSignature, pixelExecutable));
}
else if (!infoLog)
{
@@ -1228,8 +1131,8 @@
if (vertexExecutable)
{
- mVertexExecutables.push_back(std::unique_ptr<VertexExecutable>(
- new VertexExecutable(inputLayout, mCachedVertexSignature, vertexExecutable)));
+ mVertexExecutables.push_back(
+ new VertexExecutable(inputLayout, mCachedVertexSignature, vertexExecutable));
}
else if (!infoLog)
{
@@ -1259,11 +1162,11 @@
gl::PrimitiveType geometryShaderType = GetGeometryShaderTypeFromDrawMode(drawMode);
- if (mGeometryExecutables[geometryShaderType])
+ if (mGeometryExecutables[geometryShaderType] != nullptr)
{
if (outExecutable)
{
- *outExecutable = mGeometryExecutables[geometryShaderType].get();
+ *outExecutable = mGeometryExecutables[geometryShaderType];
}
return gl::NoError();
}
@@ -1275,11 +1178,10 @@
gl::InfoLog tempInfoLog;
gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog;
- ShaderExecutableD3D *geometryExecutable = nullptr;
- gl::Error error = mRenderer->compileToExecutable(
+ gl::Error error = mRenderer->compileToExecutable(
*currentInfoLog, geometryHLSL, SHADER_GEOMETRY, mStreamOutVaryings,
(mState.getTransformFeedbackBufferMode() == GL_SEPARATE_ATTRIBS),
- angle::CompilerWorkaroundsD3D(), &geometryExecutable);
+ angle::CompilerWorkaroundsD3D(), &mGeometryExecutables[geometryShaderType]);
if (!infoLog && error.isError())
{
@@ -1287,14 +1189,9 @@
<< tempInfoLog.str() << std::endl;
}
- if (geometryExecutable != nullptr)
- {
- mGeometryExecutables[geometryShaderType].reset(geometryExecutable);
- }
-
if (outExecutable)
{
- *outExecutable = mGeometryExecutables[geometryShaderType].get();
+ *outExecutable = mGeometryExecutables[geometryShaderType];
}
return error;
}
@@ -1437,135 +1334,82 @@
(!usesGeometryShader(GL_POINTS) || pointGS));
}
-LinkResult ProgramD3D::compileComputeExecutable(gl::InfoLog &infoLog)
-{
- // Ensure the compiler is initialized to avoid race conditions.
- ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
-
- std::string computeShader = mDynamicHLSL->generateComputeShaderLinkHLSL(mState);
-
- ShaderExecutableD3D *computeExecutable = nullptr;
- ANGLE_TRY(mRenderer->compileToExecutable(infoLog, computeShader, SHADER_COMPUTE,
- std::vector<D3DVarying>(), false,
- angle::CompilerWorkaroundsD3D(), &computeExecutable));
-
- if (computeExecutable == nullptr)
- {
- ERR() << "Error compiling dynamic compute executable:" << std::endl
- << infoLog.str() << std::endl;
- }
- else
- {
- const ShaderD3D *computeShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedComputeShader());
- computeShaderD3D->appendDebugInfo(computeExecutable->getDebugInfo());
- mComputeExecutable.reset(computeExecutable);
- }
-
- return mComputeExecutable.get() != nullptr;
-}
-
LinkResult ProgramD3D::link(const gl::ContextState &data,
const gl::VaryingPacking &packing,
gl::InfoLog &infoLog)
{
reset();
- const gl::Shader *computeShader = mState.getAttachedComputeShader();
- if (computeShader)
+ const gl::Shader *vertexShader = mState.getAttachedVertexShader();
+ const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
+
+ const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
+ const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
+
+ mSamplersVS.resize(data.getCaps().maxVertexTextureImageUnits);
+ mSamplersPS.resize(data.getCaps().maxTextureImageUnits);
+
+ vertexShaderD3D->generateWorkarounds(&mVertexWorkarounds);
+ fragmentShaderD3D->generateWorkarounds(&mPixelWorkarounds);
+
+ if (mRenderer->getNativeLimitations().noFrontFacingSupport)
{
- mSamplersCS.resize(data.getCaps().maxComputeTextureImageUnits);
-
- defineUniformsAndAssignRegisters();
-
- LinkResult result = compileComputeExecutable(infoLog);
- if (result.isError())
+ if (fragmentShaderD3D->usesFrontFacing())
{
- infoLog << result.getError().getMessage();
- return result;
- }
- else if (!result.getResult())
- {
- infoLog << "Failed to create D3D compute shader.";
- return result;
- }
-
- initUniformBlockInfo(computeShader);
- }
- else
- {
- const gl::Shader *vertexShader = mState.getAttachedVertexShader();
- const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
-
- const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
- const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
-
- mSamplersVS.resize(data.getCaps().maxVertexTextureImageUnits);
- mSamplersPS.resize(data.getCaps().maxTextureImageUnits);
-
- vertexShaderD3D->generateWorkarounds(&mVertexWorkarounds);
- fragmentShaderD3D->generateWorkarounds(&mPixelWorkarounds);
-
- if (mRenderer->getNativeLimitations().noFrontFacingSupport)
- {
- if (fragmentShaderD3D->usesFrontFacing())
- {
- infoLog << "The current renderer doesn't support gl_FrontFacing";
- return false;
- }
- }
-
- // TODO(jmadill): Implement more sophisticated component packing in D3D9.
- // We can fail here because we use one semantic per GLSL varying. D3D11 can pack varyings
- // intelligently, but D3D9 assumes one semantic per register.
- if (mRenderer->getRendererClass() == RENDERER_D3D9 &&
- packing.getMaxSemanticIndex() > data.getCaps().maxVaryingVectors)
- {
- infoLog << "Cannot pack these varyings on D3D9.";
+ infoLog << "The current renderer doesn't support gl_FrontFacing";
return false;
}
-
- ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
- BuiltinVaryingsD3D builtins(metadata, packing);
-
- mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
- &mVertexHLSL);
-
- mUsesPointSize = vertexShaderD3D->usesPointSize();
- mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
- mUsesFragDepth = metadata.usesFragDepth();
-
- // Cache if we use flat shading
- mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
- FindFlatInterpolationVarying(vertexShader->getVaryings()));
-
- if (mRenderer->getMajorShaderModel() >= 4)
- {
- mGeometryShaderPreamble =
- mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
- }
-
- initAttribLocationsToD3DSemantic();
-
- defineUniformsAndAssignRegisters();
-
- gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
-
- LinkResult result = compileProgramExecutables(data, infoLog);
- if (result.isError())
- {
- infoLog << result.getError().getMessage();
- return result;
- }
- else if (!result.getResult())
- {
- infoLog << "Failed to create D3D shaders.";
- return result;
- }
-
- initUniformBlockInfo(vertexShader);
- initUniformBlockInfo(fragmentShader);
}
+ // TODO(jmadill): Implement more sophisticated component packing in D3D9.
+ // We can fail here because we use one semantic per GLSL varying. D3D11 can pack varyings
+ // intelligently, but D3D9 assumes one semantic per register.
+ if (mRenderer->getRendererClass() == RENDERER_D3D9 &&
+ packing.getMaxSemanticIndex() > data.getCaps().maxVaryingVectors)
+ {
+ infoLog << "Cannot pack these varyings on D3D9.";
+ return false;
+ }
+
+ ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
+ BuiltinVaryingsD3D builtins(metadata, packing);
+
+ mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
+ &mVertexHLSL);
+
+ mUsesPointSize = vertexShaderD3D->usesPointSize();
+ mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
+ mUsesFragDepth = metadata.usesFragDepth();
+
+ // Cache if we use flat shading
+ mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
+ FindFlatInterpolationVarying(vertexShader->getVaryings()));
+
+ if (mRenderer->getMajorShaderModel() >= 4)
+ {
+ mGeometryShaderPreamble = mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
+ }
+
+ initAttribLocationsToD3DSemantic();
+
+ defineUniformsAndAssignRegisters();
+
+ gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
+
+ LinkResult result = compileProgramExecutables(data, infoLog);
+ if (result.isError())
+ {
+ infoLog << result.getError().getMessage();
+ return result;
+ }
+ else if (!result.getResult())
+ {
+ infoLog << "Failed to create D3D shaders.";
+ return result;
+ }
+
+ initUniformBlockInfo();
+
return true;
}
@@ -1575,18 +1419,34 @@
return GL_TRUE;
}
-void ProgramD3D::initUniformBlockInfo(const gl::Shader *shader)
+void ProgramD3D::initUniformBlockInfo()
{
- for (const sh::InterfaceBlock &interfaceBlock : shader->getInterfaceBlocks())
+ const gl::Shader *vertexShader = mState.getAttachedVertexShader();
+
+ for (const sh::InterfaceBlock &vertexBlock : vertexShader->getInterfaceBlocks())
{
- if (!interfaceBlock.staticUse && interfaceBlock.layout == sh::BLOCKLAYOUT_PACKED)
+ if (!vertexBlock.staticUse && vertexBlock.layout == sh::BLOCKLAYOUT_PACKED)
continue;
- if (mBlockDataSizes.count(interfaceBlock.name) > 0)
+ if (mBlockDataSizes.count(vertexBlock.name) > 0)
continue;
- size_t dataSize = getUniformBlockInfo(interfaceBlock);
- mBlockDataSizes[interfaceBlock.name] = dataSize;
+ size_t dataSize = getUniformBlockInfo(vertexBlock);
+ mBlockDataSizes[vertexBlock.name] = dataSize;
+ }
+
+ const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
+
+ for (const sh::InterfaceBlock &fragmentBlock : fragmentShader->getInterfaceBlocks())
+ {
+ if (!fragmentBlock.staticUse && fragmentBlock.layout == sh::BLOCKLAYOUT_PACKED)
+ continue;
+
+ if (mBlockDataSizes.count(fragmentBlock.name) > 0)
+ continue;
+
+ size_t dataSize = getUniformBlockInfo(fragmentBlock);
+ mBlockDataSizes[fragmentBlock.name] = dataSize;
}
}
@@ -1599,10 +1459,8 @@
}
// Assign registers and update sizes.
- const ShaderD3D *vertexShaderD3D = SafeGetImplAs<ShaderD3D>(mState.getAttachedVertexShader());
- const ShaderD3D *fragmentShaderD3D =
- SafeGetImplAs<ShaderD3D>(mState.getAttachedFragmentShader());
- const ShaderD3D *computeShaderD3D = SafeGetImplAs<ShaderD3D>(mState.getAttachedComputeShader());
+ const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedVertexShader());
+ const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedFragmentShader());
for (const gl::UniformBlock &uniformBlock : mState.getUniformBlocks())
{
@@ -1612,7 +1470,6 @@
if (uniformBlock.vertexStaticUse)
{
- ASSERT(vertexShaderD3D != nullptr);
unsigned int baseRegister =
vertexShaderD3D->getInterfaceBlockRegister(uniformBlock.name);
d3dUniformBlock.vsRegisterIndex = baseRegister + uniformBlockElement;
@@ -1620,20 +1477,11 @@
if (uniformBlock.fragmentStaticUse)
{
- ASSERT(fragmentShaderD3D != nullptr);
unsigned int baseRegister =
fragmentShaderD3D->getInterfaceBlockRegister(uniformBlock.name);
d3dUniformBlock.psRegisterIndex = baseRegister + uniformBlockElement;
}
- if (uniformBlock.computeStaticUse)
- {
- ASSERT(computeShaderD3D != nullptr);
- unsigned int baseRegister =
- computeShaderD3D->getInterfaceBlockRegister(uniformBlock.name);
- d3dUniformBlock.csRegisterIndex = baseRegister + uniformBlockElement;
- }
-
mD3DUniformBlocks.push_back(d3dUniformBlock);
}
}
@@ -1643,7 +1491,6 @@
// Compute total default block size
unsigned int vertexRegisters = 0;
unsigned int fragmentRegisters = 0;
- unsigned int computeRegisters = 0;
for (const D3DUniform *d3dUniform : mD3DUniforms)
{
if (!d3dUniform->isSampler())
@@ -1658,20 +1505,11 @@
fragmentRegisters = std::max(
fragmentRegisters, d3dUniform->psRegisterIndex + d3dUniform->registerCount);
}
- if (d3dUniform->isReferencedByComputeShader())
- {
- computeRegisters = std::max(
- computeRegisters, d3dUniform->csRegisterIndex + d3dUniform->registerCount);
- }
}
}
- mVertexUniformStorage =
- std::unique_ptr<UniformStorageD3D>(mRenderer->createUniformStorage(vertexRegisters * 16u));
- mFragmentUniformStorage = std::unique_ptr<UniformStorageD3D>(
- mRenderer->createUniformStorage(fragmentRegisters * 16u));
- mComputeUniformStorage =
- std::unique_ptr<UniformStorageD3D>(mRenderer->createUniformStorage(computeRegisters * 16u));
+ mVertexUniformStorage = mRenderer->createUniformStorage(vertexRegisters * 16u);
+ mFragmentUniformStorage = mRenderer->createUniformStorage(fragmentRegisters * 16u);
}
gl::Error ProgramD3D::applyUniforms(GLenum drawMode)
@@ -1895,37 +1733,22 @@
void ProgramD3D::defineUniformsAndAssignRegisters()
{
D3DUniformMap uniformMap;
- const gl::Shader *computeShader = mState.getAttachedComputeShader();
- if (computeShader)
- {
- for (const sh::Uniform &computeUniform : computeShader->getUniforms())
+ const gl::Shader *vertexShader = mState.getAttachedVertexShader();
+ for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
+ {
+ if (vertexUniform.staticUse)
{
- if (computeUniform.staticUse)
- {
- defineUniformBase(computeShader, computeUniform, &uniformMap);
- }
+ defineUniformBase(vertexShader, vertexUniform, &uniformMap);
}
}
- else
+
+ const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
+ for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
{
- const gl::Shader *vertexShader = mState.getAttachedVertexShader();
- for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
-
+ if (fragmentUniform.staticUse)
{
- if (vertexUniform.staticUse)
- {
- defineUniformBase(vertexShader, vertexUniform, &uniformMap);
- }
- }
-
- const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
- for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
- {
- if (fragmentUniform.staticUse)
- {
- defineUniformBase(fragmentShader, fragmentUniform, &uniformMap);
- }
+ defineUniformBase(fragmentShader, fragmentUniform, &uniformMap);
}
}
@@ -2051,14 +1874,10 @@
{
d3dUniform->psRegisterIndex = reg;
}
- else if (shaderType == GL_VERTEX_SHADER)
- {
- d3dUniform->vsRegisterIndex = reg;
- }
else
{
- ASSERT(shaderType == GL_COMPUTE_SHADER);
- d3dUniform->csRegisterIndex = reg;
+ ASSERT(shaderType == GL_VERTEX_SHADER);
+ d3dUniform->vsRegisterIndex = reg;
}
// Arrays are treated as aggregate types
@@ -2221,37 +2040,22 @@
void ProgramD3D::assignSamplerRegisters(D3DUniform *d3dUniform)
{
ASSERT(d3dUniform->isSampler());
- const gl::Shader *computeShader = mState.getAttachedComputeShader();
- if (computeShader)
+ const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedVertexShader());
+ const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedFragmentShader());
+ ASSERT(vertexShaderD3D->hasUniform(d3dUniform) || fragmentShaderD3D->hasUniform(d3dUniform));
+ if (vertexShaderD3D->hasUniform(d3dUniform))
{
- const ShaderD3D *computeShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedComputeShader());
- ASSERT(computeShaderD3D->hasUniform(d3dUniform));
- d3dUniform->csRegisterIndex = computeShaderD3D->getUniformRegister(d3dUniform->name);
- ASSERT(d3dUniform->csRegisterIndex != GL_INVALID_INDEX);
- AssignSamplers(d3dUniform->csRegisterIndex, d3dUniform->type, d3dUniform->arraySize,
- mSamplersCS, &mUsedComputeSamplerRange);
+ d3dUniform->vsRegisterIndex = vertexShaderD3D->getUniformRegister(d3dUniform->name);
+ ASSERT(d3dUniform->vsRegisterIndex != GL_INVALID_INDEX);
+ AssignSamplers(d3dUniform->vsRegisterIndex, d3dUniform->type, d3dUniform->arraySize,
+ mSamplersVS, &mUsedVertexSamplerRange);
}
- else
+ if (fragmentShaderD3D->hasUniform(d3dUniform))
{
- const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(mState.getAttachedVertexShader());
- const ShaderD3D *fragmentShaderD3D =
- GetImplAs<ShaderD3D>(mState.getAttachedFragmentShader());
- ASSERT(vertexShaderD3D->hasUniform(d3dUniform) ||
- fragmentShaderD3D->hasUniform(d3dUniform));
- if (vertexShaderD3D->hasUniform(d3dUniform))
- {
- d3dUniform->vsRegisterIndex = vertexShaderD3D->getUniformRegister(d3dUniform->name);
- ASSERT(d3dUniform->vsRegisterIndex != GL_INVALID_INDEX);
- AssignSamplers(d3dUniform->vsRegisterIndex, d3dUniform->type, d3dUniform->arraySize,
- mSamplersVS, &mUsedVertexSamplerRange);
- }
- if (fragmentShaderD3D->hasUniform(d3dUniform))
- {
- d3dUniform->psRegisterIndex = fragmentShaderD3D->getUniformRegister(d3dUniform->name);
- ASSERT(d3dUniform->psRegisterIndex != GL_INVALID_INDEX);
- AssignSamplers(d3dUniform->psRegisterIndex, d3dUniform->type, d3dUniform->arraySize,
- mSamplersPS, &mUsedPixelSamplerRange);
- }
+ d3dUniform->psRegisterIndex = fragmentShaderD3D->getUniformRegister(d3dUniform->name);
+ ASSERT(d3dUniform->psRegisterIndex != GL_INVALID_INDEX);
+ AssignSamplers(d3dUniform->psRegisterIndex, d3dUniform->type, d3dUniform->arraySize,
+ mSamplersPS, &mUsedPixelSamplerRange);
}
}
@@ -2278,16 +2082,14 @@
void ProgramD3D::reset()
{
- mVertexExecutables.clear();
- mPixelExecutables.clear();
+ SafeDeleteContainer(mVertexExecutables);
+ SafeDeleteContainer(mPixelExecutables);
- for (auto &geometryExecutable : mGeometryExecutables)
+ for (auto &element : mGeometryExecutables)
{
- geometryExecutable.reset(nullptr);
+ SafeDelete(element);
}
- mComputeExecutable.reset(nullptr);
-
mVertexHLSL.clear();
mVertexWorkarounds = angle::CompilerWorkaroundsD3D();
@@ -2301,17 +2103,14 @@
SafeDeleteContainer(mD3DUniforms);
mD3DUniformBlocks.clear();
- mVertexUniformStorage.reset(nullptr);
- mFragmentUniformStorage.reset(nullptr);
- mComputeUniformStorage.reset(nullptr);
+ SafeDelete(mVertexUniformStorage);
+ SafeDelete(mFragmentUniformStorage);
mSamplersPS.clear();
mSamplersVS.clear();
- mSamplersCS.clear();
mUsedVertexSamplerRange = 0;
mUsedPixelSamplerRange = 0;
- mUsedComputeSamplerRange = 0;
mDirtySamplerMapping = true;
mAttribLocationToD3DSemantic.fill(-1);