Skip to content

A
angle
Commit 417df92f by Jamie Madill Committed by Commit Bot
Options

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 2cd9d7e0. Change-Id: Ic1610d20ba0449b423528fa9840aa951c012cf84 Reviewed-on: https://chromium-review.googlesource.com/427229Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent afcc41ce
Showing with 165 additions and 818 deletions
src/compiler/translator/OutputHLSL.cpp
......@@ -115,11 +115,6 @@ OutputHLSL::OutputHLSL(sh::GLenum shaderType,
mUsesInstanceID = false;
mUsesVertexID = false;
mUsesFragDepth = false;
mUsesNumWorkGroups = false;
mUsesWorkGroupID = false;
mUsesLocalInvocationID = false;
mUsesGlobalInvocationID = false;
mUsesLocalInvocationIndex = false;
mUsesXor = false;
mUsesDiscardRewriting = false;
mUsesNestedBreak = false;
......@@ -545,7 +540,7 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
out << "#define GL_USES_FRAG_DATA\n";
}
}
else if (mShaderType == GL_VERTEX_SHADER)
else // Vertex shader
{
out << "// Attributes\n";
out << attributes;
......@@ -636,40 +631,6 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
out << "\n";
}
}
else // Compute shader
{
ASSERT(mShaderType == GL_COMPUTE_SHADER);
if (mUsesNumWorkGroups)
{
out << "cbuffer DriverConstants : register(b1)\n"
"{\n";
out << " uint3 gl_NumWorkGroups : packoffset(c0);\n";
out << "};\n";
}
// Follow built-in variables would be initialized in
// DynamicHLSL::generateComputeShaderLinkHLSL, if they
// are used in compute shader.
if (mUsesWorkGroupID)
{
out << "static uint3 gl_WorkGroupID = uint3(0, 0, 0);\n";
}
if (mUsesLocalInvocationID)
{
out << "static uint3 gl_LocalInvocationID = uint3(0, 0, 0);\n";
}
if (mUsesGlobalInvocationID)
{
out << "static uint3 gl_GlobalInvocationID = uint3(0, 0, 0);\n";
}
if (mUsesLocalInvocationIndex)
{
out << "static uint gl_LocalInvocationIndex = uint(0);\n";
}
}
bool getDimensionsIgnoresBaseLevel =
(mCompileOptions & SH_HLSL_GET_DIMENSIONS_IGNORES_BASE_LEVEL) != 0;
......@@ -705,31 +666,6 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
out << "#define GL_USES_DEPTH_RANGE\n";
}
if (mUsesNumWorkGroups)
{
out << "#define GL_USES_NUM_WORK_GROUPS\n";
}
if (mUsesWorkGroupID)
{
out << "#define GL_USES_WORK_GROUP_ID\n";
}
if (mUsesLocalInvocationID)
{
out << "#define GL_USES_LOCAL_INVOCATION_ID\n";
}
if (mUsesGlobalInvocationID)
{
out << "#define GL_USES_GLOBAL_INVOCATION_ID\n";
}
if (mUsesLocalInvocationIndex)
{
out << "#define GL_USES_LOCAL_INVOCATION_INDEX\n";
}
if (mUsesXor)
{
out << "bool xor(bool p, bool q)\n"
......@@ -843,31 +779,6 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node)
mUsesFragDepth = true;
out << "gl_Depth";
}
else if (qualifier == EvqNumWorkGroups)
{
mUsesNumWorkGroups = true;
out << name;
}
else if (qualifier == EvqWorkGroupID)
{
mUsesWorkGroupID = true;
out << name;
}
else if (qualifier == EvqLocalInvocationID)
{
mUsesLocalInvocationID = true;
out << name;
}
else if (qualifier == EvqGlobalInvocationID)
{
mUsesGlobalInvocationID = true;
out << name;
}
else if (qualifier == EvqLocalInvocationIndex)
{
mUsesLocalInvocationIndex = true;
out << name;
}
else
{
out << DecorateIfNeeded(node->getName());
......
src/compiler/translator/OutputHLSL.h
......@@ -173,11 +173,6 @@ class OutputHLSL : public TIntermTraverser
bool mUsesInstanceID;
bool mUsesVertexID;
bool mUsesFragDepth;
bool mUsesNumWorkGroups;
bool mUsesWorkGroupID;
bool mUsesLocalInvocationID;
bool mUsesGlobalInvocationID;
bool mUsesLocalInvocationIndex;
bool mUsesXor;
bool mUsesDiscardRewriting;
bool mUsesNestedBreak;
......
src/libANGLE/angletypes.h
......@@ -42,8 +42,7 @@ PrimitiveType GetPrimitiveType(GLenum drawMode);
enum SamplerType
{
SAMPLER_PIXEL,
SAMPLER_VERTEX,
SAMPLER_COMPUTE
SAMPLER_VERTEX
};
struct Rectangle
......@@ -289,11 +288,6 @@ inline DestT *GetImplAs(SrcT *src)
return GetAs<DestT>(src->getImplementation());
}
template <typename DestT, typename SrcT>
inline DestT *SafeGetImplAs(SrcT *src)
{
return src != nullptr ? GetAs<DestT>(src->getImplementation()) : nullptr;
}
}
#include "angletypes.inl"
......
src/libANGLE/renderer/d3d/DynamicHLSL.cpp
......@@ -764,79 +764,6 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
*pixelHLSL = pixelStream.str();
}
std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const
{
const gl::Shader *computeShaderGL = programData.getAttachedComputeShader();
std::stringstream computeStream;
std::string translatedSource = computeShaderGL->getTranslatedSource();
computeStream << translatedSource;
bool usesWorkGroupID = translatedSource.find("GL_USES_WORK_GROUP_ID") != std::string::npos;
bool usesLocalInvocationID =
translatedSource.find("GL_USES_LOCAL_INVOCATION_ID") != std::string::npos;
bool usesGlobalInvocationID =
translatedSource.find("GL_USES_GLOBAL_INVOCATION_ID") != std::string::npos;
bool usesLocalInvocationIndex =
translatedSource.find("GL_USES_LOCAL_INVOCATION_INDEX") != std::string::npos;
computeStream << "\nstruct CS_INPUT\n{\n";
if (usesWorkGroupID)
{
computeStream << " uint3 dx_WorkGroupID : "
<< "SV_GroupID;\n";
}
if (usesLocalInvocationID)
{
computeStream << " uint3 dx_LocalInvocationID : "
<< "SV_GroupThreadID;\n";
}
if (usesGlobalInvocationID)
{
computeStream << " uint3 dx_GlobalInvocationID : "
<< "SV_DispatchThreadID;\n";
}
if (usesLocalInvocationIndex)
{
computeStream << " uint dx_LocalInvocationIndex : "
<< "SV_GroupIndex;\n";
}
computeStream << "};\n\n";
const sh::WorkGroupSize &localSize = computeShaderGL->getWorkGroupSize();
computeStream << "[numthreads(" << localSize[0] << ", " << localSize[1] << ", " << localSize[2]
<< ")]\n";
computeStream << "void main(CS_INPUT input)\n"
<< "{\n";
if (usesWorkGroupID)
{
computeStream << " gl_WorkGroupID = input.dx_WorkGroupID;\n";
}
if (usesLocalInvocationID)
{
computeStream << " gl_LocalInvocationID = input.dx_LocalInvocationID;\n";
}
if (usesGlobalInvocationID)
{
computeStream << " gl_GlobalInvocationID = input.dx_GlobalInvocationID;\n";
}
if (usesLocalInvocationIndex)
{
computeStream << " gl_LocalInvocationIndex = input.dx_LocalInvocationIndex;\n";
}
computeStream << "\n"
<< " gl_main();\n"
<< "}\n";
return computeStream.str();
}
std::string DynamicHLSL::generateGeometryShaderPreamble(const VaryingPacking &varyingPacking,
const BuiltinVaryingsD3D &builtinsD3D) const
{
......
src/libANGLE/renderer/d3d/DynamicHLSL.h
......@@ -115,7 +115,6 @@ class DynamicHLSL : angle::NonCopyable
const BuiltinVaryingsD3D &builtinsD3D,
std::string *pixelHLSL,
std::string *vertexHLSL) const;
std::string generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const;
std::string generateGeometryShaderPreamble(const gl::VaryingPacking &varyingPacking,
const BuiltinVaryingsD3D &builtinsD3D) const;
......
src/libANGLE/renderer/d3d/ProgramD3D.cpp
......@@ -246,7 +246,6 @@ D3DUniform::D3DUniform(GLenum typeIn,
dirty(true),
vsRegisterIndex(GL_INVALID_INDEX),
psRegisterIndex(GL_INVALID_INDEX),
csRegisterIndex(GL_INVALID_INDEX),
registerCount(0),
registerElement(0)
{
......@@ -284,11 +283,6 @@ bool D3DUniform::isReferencedByFragmentShader() const
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 @@ unsigned int ProgramD3D::mCurrentSerial = 1;
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 @@ GLint ProgramD3D::getSamplerMapping(gl::SamplerType type,
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 @@ GLenum ProgramD3D::getSamplerTextureType(gl::SamplerType type, unsigned int samp
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 @@ GLuint ProgramD3D::getUsedSamplerRange(gl::SamplerType type) const
return mUsedPixelSamplerRange;
case gl::SAMPLER_VERTEX:
return mUsedVertexSamplerRange;
case gl::SAMPLER_COMPUTE:
return mUsedComputeSamplerRange;
default:
UNREACHABLE();
return 0u;
......@@ -671,22 +649,6 @@ void ProgramD3D::updateSamplerMapping()
}
}
}
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 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
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 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
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 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
D3DUniformBlock uniformBlock;
stream->readInt(&uniformBlock.psRegisterIndex);
stream->readInt(&uniformBlock.vsRegisterIndex);
stream->readInt(&uniformBlock.csRegisterIndex);
mD3DUniformBlocks.push_back(uniformBlock);
}
......@@ -867,8 +816,8 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
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 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
}
// 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 @@ LinkResult ProgramD3D::load(const ContextImpl *contextImpl,
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 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
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 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
// 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 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
{
stream->writeIntOrNegOne(uniformBlock.psRegisterIndex);
stream->writeIntOrNegOne(uniformBlock.vsRegisterIndex);
stream->writeIntOrNegOne(uniformBlock.csRegisterIndex);
}
stream->writeInt(mStreamOutVaryings.size());
......@@ -1059,7 +974,7 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
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 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
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 @@ gl::Error ProgramD3D::save(gl::BinaryOutputStream *stream)
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 @@ gl::Error ProgramD3D::getPixelExecutableForOutputLayout(const std::vector<GLenum
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 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::InputLayout &i
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::Error ProgramD3D::getGeometryExecutableForPrimitiveType(const gl::ContextSta
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::Error ProgramD3D::getGeometryExecutableForPrimitiveType(const gl::ContextSta
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 @@ gl::Error ProgramD3D::getGeometryExecutableForPrimitiveType(const gl::ContextSta
<< 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 @@ LinkResult ProgramD3D::compileProgramExecutables(const gl::ContextState &context
(!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)
{
mSamplersCS.resize(data.getCaps().maxComputeTextureImageUnits);
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
defineUniformsAndAssignRegisters();
const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
LinkResult result = compileComputeExecutable(infoLog);
if (result.isError())
{
infoLog << result.getError().getMessage();
return result;
}
else if (!result.getResult())
{
infoLog << "Failed to create D3D compute shader.";
return result;
}
mSamplersVS.resize(data.getCaps().maxVertexTextureImageUnits);
mSamplersPS.resize(data.getCaps().maxTextureImageUnits);
initUniformBlockInfo(computeShader);
}
else
{
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
vertexShaderD3D->generateWorkarounds(&mVertexWorkarounds);
fragmentShaderD3D->generateWorkarounds(&mPixelWorkarounds);
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)
if (mRenderer->getNativeLimitations().noFrontFacingSupport)
{
if (fragmentShaderD3D->usesFrontFacing())
{
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);
// 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;
}
mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
&mVertexHLSL);
ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
BuiltinVaryingsD3D builtins(metadata, packing);
mUsesPointSize = vertexShaderD3D->usesPointSize();
mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
mUsesFragDepth = metadata.usesFragDepth();
mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
&mVertexHLSL);
// Cache if we use flat shading
mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
FindFlatInterpolationVarying(vertexShader->getVaryings()));
mUsesPointSize = vertexShaderD3D->usesPointSize();
mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
mUsesFragDepth = metadata.usesFragDepth();
if (mRenderer->getMajorShaderModel() >= 4)
{
mGeometryShaderPreamble =
mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
}
// Cache if we use flat shading
mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
FindFlatInterpolationVarying(vertexShader->getVaryings()));
initAttribLocationsToD3DSemantic();
if (mRenderer->getMajorShaderModel() >= 4)
{
mGeometryShaderPreamble = mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
}
defineUniformsAndAssignRegisters();
initAttribLocationsToD3DSemantic();
gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
defineUniformsAndAssignRegisters();
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;
}
gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
initUniformBlockInfo(vertexShader);
initUniformBlockInfo(fragmentShader);
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 @@ GLboolean ProgramD3D::validate(const gl::Caps & /*caps*/, gl::InfoLog * /*infoLo
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 (!vertexBlock.staticUse && vertexBlock.layout == sh::BLOCKLAYOUT_PACKED)
continue;
if (mBlockDataSizes.count(vertexBlock.name) > 0)
continue;
size_t dataSize = getUniformBlockInfo(vertexBlock);
mBlockDataSizes[vertexBlock.name] = dataSize;
}
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
for (const sh::InterfaceBlock &fragmentBlock : fragmentShader->getInterfaceBlocks())
{
if (!interfaceBlock.staticUse && interfaceBlock.layout == sh::BLOCKLAYOUT_PACKED)
if (!fragmentBlock.staticUse && fragmentBlock.layout == sh::BLOCKLAYOUT_PACKED)
continue;
if (mBlockDataSizes.count(interfaceBlock.name) > 0)
if (mBlockDataSizes.count(fragmentBlock.name) > 0)
continue;
size_t dataSize = getUniformBlockInfo(interfaceBlock);
mBlockDataSizes[interfaceBlock.name] = dataSize;
size_t dataSize = getUniformBlockInfo(fragmentBlock);
mBlockDataSizes[fragmentBlock.name] = dataSize;
}
}
......@@ -1599,10 +1459,8 @@ void ProgramD3D::ensureUniformBlocksInitialized()
}
// 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 @@ void ProgramD3D::ensureUniformBlocksInitialized()
if (uniformBlock.vertexStaticUse)
{
ASSERT(vertexShaderD3D != nullptr);
unsigned int baseRegister =
vertexShaderD3D->getInterfaceBlockRegister(uniformBlock.name);
d3dUniformBlock.vsRegisterIndex = baseRegister + uniformBlockElement;
......@@ -1620,20 +1477,11 @@ void ProgramD3D::ensureUniformBlocksInitialized()
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 @@ void ProgramD3D::initializeUniformStorage()
// 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 @@ void ProgramD3D::initializeUniformStorage()
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::setUniformBlockBinding(GLuint /*uniformBlockIndex*/,
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 (computeUniform.staticUse)
{
defineUniformBase(computeShader, computeUniform, &uniformMap);
}
}
}
else
{
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
if (vertexUniform.staticUse)
{
if (vertexUniform.staticUse)
{
defineUniformBase(vertexShader, vertexUniform, &uniformMap);
}
defineUniformBase(vertexShader, vertexUniform, &uniformMap);
}
}
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
{
if (fragmentUniform.staticUse)
{
if (fragmentUniform.staticUse)
{
defineUniformBase(fragmentShader, fragmentUniform, &uniformMap);
}
defineUniformBase(fragmentShader, fragmentUniform, &uniformMap);
}
}
......@@ -2051,14 +1874,10 @@ void ProgramD3D::defineUniform(GLenum shaderType,
{
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::assignAllSamplerRegisters()
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::AssignSamplers(unsigned int startSamplerIndex,
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 @@ void ProgramD3D::reset()
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);
......
src/libANGLE/renderer/d3d/ProgramD3D.h
......@@ -44,7 +44,6 @@ struct D3DUniform : angle::NonCopyable
unsigned int elementCount() const { return std::max(1u, arraySize); }
bool isReferencedByVertexShader() const;
bool isReferencedByFragmentShader() const;
bool isReferencedByComputeShader() const;
// Duplicated from the GL layer
GLenum type;
......@@ -61,7 +60,6 @@ struct D3DUniform : angle::NonCopyable
// Register information.
unsigned int vsRegisterIndex;
unsigned int psRegisterIndex;
unsigned int csRegisterIndex;
unsigned int registerCount;
// Register "elements" are used for uniform structs in ES3, to appropriately identify single
......@@ -72,22 +70,14 @@ struct D3DUniform : angle::NonCopyable
struct D3DUniformBlock
{
D3DUniformBlock()
: vsRegisterIndex(GL_INVALID_INDEX),
psRegisterIndex(GL_INVALID_INDEX),
csRegisterIndex(GL_INVALID_INDEX)
{
}
D3DUniformBlock() : vsRegisterIndex(GL_INVALID_INDEX), psRegisterIndex(GL_INVALID_INDEX) {}
bool vertexStaticUse() const { return vsRegisterIndex != GL_INVALID_INDEX; }
bool fragmentStaticUse() const { return psRegisterIndex != GL_INVALID_INDEX; }
bool computeStaticUse() const { return csRegisterIndex != GL_INVALID_INDEX; }
unsigned int vsRegisterIndex;
unsigned int psRegisterIndex;
unsigned int csRegisterIndex;
};
struct D3DVarying final
......@@ -176,9 +166,6 @@ class ProgramD3D : public ProgramImpl
GLenum drawMode,
ShaderExecutableD3D **outExecutable,
gl::InfoLog *infoLog);
gl::Error getComputeExecutable(const gl::ContextState &data,
ShaderExecutableD3D **outExecutable,
gl::InfoLog *infoLog);
LinkResult link(const gl::ContextState &data,
const gl::VaryingPacking &packing,
......@@ -249,18 +236,8 @@ class ProgramD3D : public ProgramImpl
void setUniformBlockBinding(GLuint uniformBlockIndex, GLuint uniformBlockBinding) override;
const UniformStorageD3D &getVertexUniformStorage() const
{
return *mVertexUniformStorage.get();
}
const UniformStorageD3D &getFragmentUniformStorage() const
{
return *mFragmentUniformStorage.get();
}
const UniformStorageD3D &getComputeUniformStorage() const
{
return *mComputeUniformStorage.get();
}
const UniformStorageD3D &getVertexUniformStorage() const { return *mVertexUniformStorage; }
const UniformStorageD3D &getFragmentUniformStorage() const { return *mFragmentUniformStorage; }
unsigned int getSerial() const;
......@@ -375,7 +352,6 @@ class ProgramD3D : public ProgramImpl
GLenum targetUniformType);
LinkResult compileProgramExecutables(const gl::ContextState &data, gl::InfoLog &infoLog);
LinkResult compileComputeExecutable(gl::InfoLog &infoLog);
void gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyings,
const BuiltinInfo &builtins);
......@@ -387,16 +363,15 @@ class ProgramD3D : public ProgramImpl
void reset();
void ensureUniformBlocksInitialized();
void initUniformBlockInfo(const gl::Shader *shader);
void initUniformBlockInfo();
size_t getUniformBlockInfo(const sh::InterfaceBlock &interfaceBlock);
RendererD3D *mRenderer;
DynamicHLSL *mDynamicHLSL;
std::vector<std::unique_ptr<VertexExecutable>> mVertexExecutables;
std::vector<std::unique_ptr<PixelExecutable>> mPixelExecutables;
std::vector<std::unique_ptr<ShaderExecutableD3D>> mGeometryExecutables;
std::unique_ptr<ShaderExecutableD3D> mComputeExecutable;
std::vector<VertexExecutable *> mVertexExecutables;
std::vector<PixelExecutable *> mPixelExecutables;
std::vector<ShaderExecutableD3D *> mGeometryExecutables;
std::string mVertexHLSL;
angle::CompilerWorkaroundsD3D mVertexWorkarounds;
......@@ -414,16 +389,13 @@ class ProgramD3D : public ProgramImpl
bool mUsesPointSize;
bool mUsesFlatInterpolation;
std::unique_ptr<UniformStorageD3D> mVertexUniformStorage;
std::unique_ptr<UniformStorageD3D> mFragmentUniformStorage;
std::unique_ptr<UniformStorageD3D> mComputeUniformStorage;
UniformStorageD3D *mVertexUniformStorage;
UniformStorageD3D *mFragmentUniformStorage;
std::vector<Sampler> mSamplersPS;
std::vector<Sampler> mSamplersVS;
std::vector<Sampler> mSamplersCS;
GLuint mUsedVertexSamplerRange;
GLuint mUsedPixelSamplerRange;
GLuint mUsedComputeSamplerRange;
bool mDirtySamplerMapping;
// Cache for getPixelExecutableForFramebuffer
......
src/libANGLE/renderer/d3d/RendererD3D.h
......@@ -75,7 +75,6 @@ enum ShaderType
SHADER_VERTEX,
SHADER_PIXEL,
SHADER_GEOMETRY,
SHADER_COMPUTE,
SHADER_TYPE_MAX
};
......
src/libANGLE/renderer/d3d/ShaderD3D.cpp
......@@ -29,9 +29,6 @@ const char *GetShaderTypeString(GLenum type)
case GL_FRAGMENT_SHADER:
return "FRAGMENT";
case GL_COMPUTE_SHADER:
return "COMPUTE";
default:
UNREACHABLE();
return "";
......@@ -195,7 +192,7 @@ bool ShaderD3D::postTranslateCompile(gl::Compiler *compiler, std::string *infoLo
mUsesPointSize = translatedSource.find("GL_USES_POINT_SIZE") != std::string::npos;
mUsesPointCoord = translatedSource.find("GL_USES_POINT_COORD") != std::string::npos;
mUsesDepthRange = translatedSource.find("GL_USES_DEPTH_RANGE") != std::string::npos;
mUsesFragDepth = translatedSource.find("GL_USES_FRAG_DEPTH") != std::string::npos;
mUsesFragDepth = translatedSource.find("GL_USES_FRAG_DEPTH") != std::string::npos;
mUsesDiscardRewriting =
translatedSource.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos;
mUsesNestedBreak = translatedSource.find("ANGLE_USES_NESTED_BREAK") != std::string::npos;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -3459,14 +3459,15 @@ gl::Error Renderer11::loadExecutable(const void *function,
{
case SHADER_VERTEX:
{
ID3D11VertexShader *vertexShader = nullptr;
ID3D11GeometryShader *streamOutShader = nullptr;
ID3D11VertexShader *vertexShader = NULL;
ID3D11GeometryShader *streamOutShader = NULL;
HRESULT result = mDevice->CreateVertexShader(function, length, NULL, &vertexShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create vertex shader, " << result;
return gl::Error(GL_OUT_OF_MEMORY, "Failed to create vertex shader, result: 0x%X.",
result);
}
if (!streamOutVaryings.empty())
......@@ -3494,7 +3495,8 @@ gl::Error Renderer11::loadExecutable(const void *function,
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create steam output shader, " << result;
return gl::Error(GL_OUT_OF_MEMORY,
"Failed to create steam output shader, result: 0x%X.", result);
}
}
......@@ -3504,13 +3506,14 @@ gl::Error Renderer11::loadExecutable(const void *function,
break;
case SHADER_PIXEL:
{
ID3D11PixelShader *pixelShader = nullptr;
ID3D11PixelShader *pixelShader = NULL;
HRESULT result = mDevice->CreatePixelShader(function, length, NULL, &pixelShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create pixel shader, " << result;
return gl::Error(GL_OUT_OF_MEMORY, "Failed to create pixel shader, result: 0x%X.",
result);
}
*outExecutable = new ShaderExecutable11(function, length, pixelShader);
......@@ -3518,32 +3521,19 @@ gl::Error Renderer11::loadExecutable(const void *function,
break;
case SHADER_GEOMETRY:
{
ID3D11GeometryShader *geometryShader = nullptr;
ID3D11GeometryShader *geometryShader = NULL;
HRESULT result = mDevice->CreateGeometryShader(function, length, NULL, &geometryShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create geometry shader, " << result;
return gl::Error(GL_OUT_OF_MEMORY,
"Failed to create geometry shader, result: 0x%X.", result);
}
*outExecutable = new ShaderExecutable11(function, length, geometryShader);
}
break;
case SHADER_COMPUTE:
{
ID3D11ComputeShader *computeShader = nullptr;
HRESULT result = mDevice->CreateComputeShader(function, length, NULL, &computeShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create compute shader, " << result;
}
*outExecutable = new ShaderExecutable11(function, length, computeShader);
}
break;
default:
UNREACHABLE();
return gl::Error(GL_INVALID_OPERATION);
......@@ -3573,9 +3563,6 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
case SHADER_GEOMETRY:
profileStream << "gs";
break;
case SHADER_COMPUTE:
profileStream << "cs";
break;
default:
UNREACHABLE();
return gl::Error(GL_INVALID_OPERATION);
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
......@@ -17,42 +17,27 @@ ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D
: ShaderExecutableD3D(function, length)
{
mPixelExecutable = executable;
mVertexExecutable = nullptr;
mGeometryExecutable = nullptr;
mStreamOutExecutable = nullptr;
mComputeExecutable = nullptr;
mVertexExecutable = NULL;
mGeometryExecutable = NULL;
mStreamOutExecutable = NULL;
}
ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut)
: ShaderExecutableD3D(function, length)
{
mVertexExecutable = executable;
mPixelExecutable = nullptr;
mGeometryExecutable = nullptr;
mPixelExecutable = NULL;
mGeometryExecutable = NULL;
mStreamOutExecutable = streamOut;
mComputeExecutable = nullptr;
}
ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable)
: ShaderExecutableD3D(function, length)
{
mGeometryExecutable = executable;
mVertexExecutable = nullptr;
mPixelExecutable = nullptr;
mStreamOutExecutable = nullptr;
mComputeExecutable = nullptr;
}
ShaderExecutable11::ShaderExecutable11(const void *function,
size_t length,
ID3D11ComputeShader *executable)
: ShaderExecutableD3D(function, length)
{
mComputeExecutable = executable;
mPixelExecutable = nullptr;
mVertexExecutable = nullptr;
mGeometryExecutable = nullptr;
mStreamOutExecutable = nullptr;
mVertexExecutable = NULL;
mPixelExecutable = NULL;
mStreamOutExecutable = NULL;
}
ShaderExecutable11::~ShaderExecutable11()
......@@ -61,7 +46,6 @@ ShaderExecutable11::~ShaderExecutable11()
SafeRelease(mPixelExecutable);
SafeRelease(mGeometryExecutable);
SafeRelease(mStreamOutExecutable);
SafeRelease(mComputeExecutable);
}
ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
......@@ -84,11 +68,6 @@ ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
return mStreamOutExecutable;
}
ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
{
return mComputeExecutable;
}
UniformStorage11::UniformStorage11(Renderer11 *renderer, size_t initialSize)
: UniformStorageD3D(initialSize),
mConstantBuffer(NULL)
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
......@@ -23,7 +23,6 @@ class ShaderExecutable11 : public ShaderExecutableD3D
ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable);
ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut);
ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable);
ShaderExecutable11(const void *function, size_t length, ID3D11ComputeShader *executable);
virtual ~ShaderExecutable11();
......@@ -31,14 +30,12 @@ class ShaderExecutable11 : public ShaderExecutableD3D
ID3D11VertexShader *getVertexShader() const;
ID3D11GeometryShader *getGeometryShader() const;
ID3D11GeometryShader *getStreamOutShader() const;
ID3D11ComputeShader *getComputeShader() const;
private:
ID3D11PixelShader *mPixelExecutable;
ID3D11VertexShader *mVertexExecutable;
ID3D11GeometryShader *mGeometryExecutable;
ID3D11GeometryShader *mStreamOutExecutable;
ID3D11ComputeShader *mComputeExecutable;
};
class UniformStorage11 : public UniformStorageD3D
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
......@@ -830,84 +830,6 @@ size_t GetMaximumPixelTextureUnits(D3D_FEATURE_LEVEL featureLevel)
}
}
std::array<GLuint, 3> GetMaxComputeWorkGroupCount(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return {{D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION,
D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION,
D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION}};
break;
default:
return {{0, 0, 0}};
}
}
std::array<GLuint, 3> GetMaxComputeWorkGroupSize(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return {{D3D11_CS_THREAD_GROUP_MAX_X, D3D11_CS_THREAD_GROUP_MAX_Y,
D3D11_CS_THREAD_GROUP_MAX_Z}};
break;
default:
return {{0, 0, 0}};
}
}
size_t GetMaxComputeWorkGroupInvocations(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return D3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP;
default:
return 0;
}
}
size_t GetMaximumComputeUniformVectors(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT;
default:
return 0;
}
}
size_t GetMaximumComputeUniformBlocks(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT -
d3d11::RESERVED_CONSTANT_BUFFER_SLOT_COUNT;
default:
return 0;
}
}
size_t GetMaximumComputeTextureUnits(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
{
case D3D_FEATURE_LEVEL_11_1:
case D3D_FEATURE_LEVEL_11_0:
return D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT;
default:
return 0;
}
}
int GetMinimumTexelOffset(D3D_FEATURE_LEVEL featureLevel)
{
switch (featureLevel)
......@@ -1238,18 +1160,6 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons
caps->minProgramTexelOffset = GetMinimumTexelOffset(featureLevel);
caps->maxProgramTexelOffset = GetMaximumTexelOffset(featureLevel);
// Compute shader limits
caps->maxComputeWorkGroupCount = GetMaxComputeWorkGroupCount(featureLevel);
caps->maxComputeWorkGroupSize = GetMaxComputeWorkGroupSize(featureLevel);
caps->maxComputeWorkGroupInvocations =
static_cast<GLuint>(GetMaxComputeWorkGroupInvocations(featureLevel));
caps->maxComputeUniformComponents =
static_cast<GLuint>(GetMaximumComputeUniformVectors(featureLevel)) * 4;
caps->maxComputeUniformBlocks =
static_cast<GLuint>(GetMaximumComputeUniformBlocks(featureLevel));
caps->maxComputeTextureImageUnits =
static_cast<GLuint>(GetMaximumComputeTextureUnits(featureLevel));
// Aggregate shader limits
caps->maxUniformBufferBindings = caps->maxVertexUniformBlocks + caps->maxFragmentUniformBlocks;
caps->maxUniformBlockSize = GetMaximumConstantBufferSize(featureLevel);
......@@ -1265,9 +1175,6 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons
static_cast<GLint64>(caps->maxVertexUniformComponents);
caps->maxCombinedFragmentUniformComponents = (static_cast<GLint64>(caps->maxFragmentUniformBlocks) * static_cast<GLint64>(caps->maxUniformBlockSize / 4)) +
static_cast<GLint64>(caps->maxFragmentUniformComponents);
caps->maxCombinedComputeUniformComponents =
static_cast<GLuint>(caps->maxComputeUniformBlocks * (caps->maxUniformBlockSize / 4) +
caps->maxComputeUniformComponents);
caps->maxVaryingComponents =
static_cast<GLuint>(GetMaximumVertexOutputVectors(featureLevel)) * 4;
caps->maxVaryingVectors = static_cast<GLuint>(GetMaximumVertexOutputVectors(featureLevel));
......
src/tests/gl_tests/ComputeShaderTest.cpp
......@@ -211,41 +211,6 @@ TEST_P(ComputeShaderTest, AttachmentCount)
EXPECT_GL_NO_ERROR();
}
// Access all compute shader special variables.
TEST_P(ComputeShaderTest, AccessAllSpecialVariables)
{
const std::string csSource =
"#version 310 es\n"
"layout(local_size_x=4, local_size_y=3, local_size_z=2) in;\n"
"void main()\n"
"{\n"
" uvec3 temp1 = gl_NumWorkGroups;\n"
" uvec3 temp2 = gl_WorkGroupSize;\n"
" uvec3 temp3 = gl_WorkGroupID;\n"
" uvec3 temp4 = gl_LocalInvocationID;\n"
" uvec3 temp5 = gl_GlobalInvocationID;\n"
" uint temp6 = gl_LocalInvocationIndex;\n"
"}\n";
ANGLE_GL_COMPUTE_PROGRAM(program, csSource);
}
// Access part compute shader special variables.
TEST_P(ComputeShaderTest, AccessPartSpecialVariables)
{
const std::string csSource =
"#version 310 es\n"
"layout(local_size_x=4, local_size_y=3, local_size_z=2) in;\n"
"void main()\n"
"{\n"
" uvec3 temp1 = gl_WorkGroupSize;\n"
" uvec3 temp2 = gl_WorkGroupID;\n"
" uint temp3 = gl_LocalInvocationIndex;\n"
"}\n";
ANGLE_GL_COMPUTE_PROGRAM(program, csSource);
}
// Check that it is not possible to create a compute shader when the context does not support ES
// 3.10
TEST_P(ComputeShaderTestES3, NotSupported)
......@@ -255,7 +220,7 @@ TEST_P(ComputeShaderTestES3, NotSupported)
EXPECT_GL_ERROR(GL_INVALID_ENUM);
}
ANGLE_INSTANTIATE_TEST(ComputeShaderTest, ES31_OPENGL(), ES31_OPENGLES(), ES31_D3D11());
ANGLE_INSTANTIATE_TEST(ComputeShaderTest, ES31_OPENGL(), ES31_OPENGLES());
ANGLE_INSTANTIATE_TEST(ComputeShaderTestES3, ES3_OPENGL(), ES3_OPENGLES());
} // namespace
src/tests/gl_tests/ProgramBinaryTest.cpp
......@@ -335,69 +335,6 @@ TEST_P(ProgramBinaryES3Test, UniformBlockBindingNoDraw)
ANGLE_INSTANTIATE_TEST(ProgramBinaryES3Test, ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES());
class ProgramBinaryES31Test : public ANGLETest
{
protected:
ProgramBinaryES31Test()
{
setWindowWidth(128);
setWindowHeight(128);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
}
};
// Tests that saving and loading a program attached with computer shader.
TEST_P(ProgramBinaryES31Test, ProgramBinaryWithComputeShader)
{
// We can't run the test if no program binary formats are supported.
GLint binaryFormatCount = 0;
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &binaryFormatCount);
if (binaryFormatCount == 0)
{
std::cout << "Test skipped because no program binary formats available." << std::endl;
return;
}
const std::string &computeShader =
"#version 310 es\n"
"layout(local_size_x=4, local_size_y=3, local_size_z=1) in;\n"
"uniform block {\n"
" vec2 f;\n"
"};\n"
"uniform vec2 g;\n"
"uniform highp sampler2D tex;\n"
"void main() {\n"
" vec4 color = texture(tex, f + g);\n"
"}";
ANGLE_GL_COMPUTE_PROGRAM(program, computeShader);
// Read back the binary.
GLint programLength = 0;
glGetProgramiv(program.get(), GL_PROGRAM_BINARY_LENGTH, &programLength);
ASSERT_GL_NO_ERROR();
GLsizei readLength = 0;
GLenum binaryFormat = GL_NONE;
std::vector<uint8_t> binary(programLength);
glGetProgramBinary(program.get(), programLength, &readLength, &binaryFormat, binary.data());
ASSERT_GL_NO_ERROR();
EXPECT_EQ(static_cast<GLsizei>(programLength), readLength);
// Load a new program with the binary.
ANGLE_GL_BINARY_ES3_PROGRAM(binaryProgram, binary, binaryFormat);
// TODO(Xinghua): add dispatch support when available.
ASSERT_GL_NO_ERROR();
}
ANGLE_INSTANTIATE_TEST(ProgramBinaryES31Test, ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES());
class ProgramBinaryTransformFeedbackTest : public ANGLETest
{
protected:
......
src/tests/test_utils/angle_test_configs.cpp
......@@ -491,21 +491,6 @@ PlatformParameters ES3_D3D11_FL10_1()
return PlatformParameters(3, 0, egl_platform::D3D11_FL10_1());
}
PlatformParameters ES31_D3D11()
{
return PlatformParameters(3, 1, egl_platform::D3D11());
}
PlatformParameters ES31_D3D11_FL11_1()
{
return PlatformParameters(3, 1, egl_platform::D3D11_FL11_1());
}
PlatformParameters ES31_D3D11_FL11_0()
{
return PlatformParameters(3, 1, egl_platform::D3D11_FL11_0());
}
PlatformParameters ES3_D3D11_WARP()
{
return PlatformParameters(3, 0, egl_platform::D3D11_WARP());
......
src/tests/test_utils/angle_test_configs.h
......@@ -113,9 +113,6 @@ PlatformParameters ES3_D3D11();
PlatformParameters ES3_D3D11_FL11_1();
PlatformParameters ES3_D3D11_FL11_0();
PlatformParameters ES3_D3D11_FL10_1();
PlatformParameters ES31_D3D11();
PlatformParameters ES31_D3D11_FL11_1();
PlatformParameters ES31_D3D11_FL11_0();
PlatformParameters ES3_D3D11_WARP();
PlatformParameters ES3_D3D11_FL11_1_WARP();
......
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