Refactoring Shader objects (Take 2)
This change refactors shaders to no longer be dependent on D3D-only concepts.
BUG=angle:731
Change-Id: I1006112f1d31b7e41bd14bd3225ea157b7d6c6c9
Reviewed-on: https://chromium-review.googlesource.com/214467
Tested-by: Brandon Jones <bajones@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
diff --git a/projects/src/libGLESv2.vcxproj b/projects/src/libGLESv2.vcxproj
index 3d57d94..8949b85 100644
--- a/projects/src/libGLESv2.vcxproj
+++ b/projects/src/libGLESv2.vcxproj
@@ -246,6 +246,7 @@
<ClInclude Include="..\..\src\libGLESv2\validationES.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\TextureImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\Renderer.h"/>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderExecutable.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\loadimage.h"/>
@@ -271,6 +272,7 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\IndexDataManager.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\TransformFeedbackD3D.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\VertexBuffer.h"/>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\d3d\ShaderD3D.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\BufferD3D.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\VertexDataManager.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\d3d11\Clear11.h"/>
@@ -431,6 +433,7 @@
<ClCompile Include="..\..\src\libGLESv2\renderer\Renderer.cpp"/>
<ClCompile Include="..\..\src\libGLESv2\renderer\IndexRangeCache.cpp"/>
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\HLSLCompiler.cpp"/>
+ <ClCompile Include="..\..\src\libGLESv2\renderer\d3d\ShaderD3D.cpp"/>
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\BufferD3D.cpp"/>
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\IndexBuffer.cpp"/>
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\VertexBuffer.cpp"/>
diff --git a/projects/src/libGLESv2.vcxproj.filters b/projects/src/libGLESv2.vcxproj.filters
index 700044c..c64a8a5 100644
--- a/projects/src/libGLESv2.vcxproj.filters
+++ b/projects/src/libGLESv2.vcxproj.filters
@@ -279,6 +279,9 @@
<None Include="..\..\src\libGLESv2\renderer\loadimage.inl">
<Filter>src\libGLESv2\renderer</Filter>
</None>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h">
+ <Filter>src\libGLESv2\renderer</Filter>
+ </ClInclude>
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h">
<Filter>src\libGLESv2\renderer</Filter>
</ClInclude>
@@ -357,6 +360,9 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\IndexBuffer.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
+ <ClCompile Include="..\..\src\libGLESv2\renderer\d3d\ShaderD3D.cpp">
+ <Filter>src\libGLESv2\renderer\d3d</Filter>
+ </ClCompile>
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\HLSLCompiler.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
@@ -405,6 +411,9 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\VertexBuffer.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\d3d\ShaderD3D.h">
+ <Filter>src\libGLESv2\renderer\d3d</Filter>
+ </ClInclude>
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\TransformFeedbackD3D.cpp">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClCompile>
diff --git a/projects/src/libGLESv2_static.vcxproj b/projects/src/libGLESv2_static.vcxproj
index e9af9ca..06bc461 100644
--- a/projects/src/libGLESv2_static.vcxproj
+++ b/projects/src/libGLESv2_static.vcxproj
@@ -243,6 +243,7 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\TextureImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\Renderer.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\SwapChain.h"/>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\imageformats.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderExecutable.h"/>
diff --git a/projects/src/libGLESv2_static.vcxproj.filters b/projects/src/libGLESv2_static.vcxproj.filters
index 85f9d2f..5a8815f 100644
--- a/projects/src/libGLESv2_static.vcxproj.filters
+++ b/projects/src/libGLESv2_static.vcxproj.filters
@@ -270,6 +270,9 @@
<ClCompile Include="..\..\src\libGLESv2\renderer\Image.cpp">
<Filter>src\libGLESv2\renderer</Filter>
</ClCompile>
+ <ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h">
+ <Filter>src\libGLESv2\renderer</Filter>
+ </ClInclude>
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h">
<Filter>src\libGLESv2\renderer</Filter>
</ClInclude>
diff --git a/src/libGLESv2.gypi b/src/libGLESv2.gypi
index f54ced3..d232daf 100644
--- a/src/libGLESv2.gypi
+++ b/src/libGLESv2.gypi
@@ -112,6 +112,7 @@
'libGLESv2/renderer/Renderer.cpp',
'libGLESv2/renderer/Renderer.h',
'libGLESv2/renderer/ShaderExecutable.h',
+ 'libGLESv2/renderer/ShaderImpl.h',
'libGLESv2/renderer/SwapChain.h',
'libGLESv2/renderer/TextureImpl.h',
'libGLESv2/renderer/TransformFeedbackImpl.h',
@@ -155,6 +156,8 @@
'libGLESv2/renderer/d3d/IndexDataManager.h',
'libGLESv2/renderer/d3d/MemoryBuffer.cpp',
'libGLESv2/renderer/d3d/MemoryBuffer.h',
+ 'libGLESv2/renderer/d3d/ShaderD3D.cpp',
+ 'libGLESv2/renderer/d3d/ShaderD3D.h',
'libGLESv2/renderer/d3d/TextureD3D.cpp',
'libGLESv2/renderer/d3d/TextureD3D.h',
'libGLESv2/renderer/d3d/TextureStorage.cpp',
diff --git a/src/libGLESv2/Context.cpp b/src/libGLESv2/Context.cpp
index 671bb1c..5cdc261 100644
--- a/src/libGLESv2/Context.cpp
+++ b/src/libGLESv2/Context.cpp
@@ -2383,6 +2383,11 @@
}
}
+void Context::releaseShaderCompiler()
+{
+ mRenderer->releaseShaderCompiler();
+}
+
void Context::initCaps(GLuint clientVersion)
{
mCaps = mRenderer->getRendererCaps();
diff --git a/src/libGLESv2/Context.h b/src/libGLESv2/Context.h
index 8e71688..6ec9553 100644
--- a/src/libGLESv2/Context.h
+++ b/src/libGLESv2/Context.h
@@ -234,6 +234,8 @@
State &getState() { return mState; }
const State &getState() const { return mState; }
+ void releaseShaderCompiler();
+
private:
DISALLOW_COPY_AND_ASSIGN(Context);
diff --git a/src/libGLESv2/DynamicHLSL.cpp b/src/libGLESv2/DynamicHLSL.cpp
index e3ec391..f09cf63 100644
--- a/src/libGLESv2/DynamicHLSL.cpp
+++ b/src/libGLESv2/DynamicHLSL.cpp
@@ -11,6 +11,7 @@
#include "libGLESv2/DynamicHLSL.h"
#include "libGLESv2/Shader.h"
#include "libGLESv2/Program.h"
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
#include "libGLESv2/renderer/Renderer.h"
#include "common/utilities.h"
#include "libGLESv2/ProgramBinary.h"
@@ -210,14 +211,17 @@
{
const int maxVaryingVectors = mRenderer->getMaxVaryingVectors();
- vertexShader->resetVaryingsRegisterAssignment();
- fragmentShader->resetVaryingsRegisterAssignment();
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
+
+ vertexShaderD3D->resetVaryingsRegisterAssignment();
+ fragmentShaderD3D->resetVaryingsRegisterAssignment();
std::set<std::string> packedVaryings;
- for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
+ for (unsigned int varyingIndex = 0; varyingIndex < fragmentShaderD3D->mVaryings.size(); varyingIndex++)
{
- PackedVarying *varying = &fragmentShader->mVaryings[varyingIndex];
+ PackedVarying *varying = &fragmentShaderD3D->mVaryings[varyingIndex];
if (packVarying(varying, maxVaryingVectors, packing))
{
packedVaryings.insert(varying->name);
@@ -235,9 +239,9 @@
if (packedVaryings.find(transformFeedbackVarying) == packedVaryings.end())
{
bool found = false;
- for (unsigned int varyingIndex = 0; varyingIndex < vertexShader->mVaryings.size(); varyingIndex++)
+ for (unsigned int varyingIndex = 0; varyingIndex < vertexShaderD3D->mVaryings.size(); varyingIndex++)
{
- PackedVarying *varying = &vertexShader->mVaryings[varyingIndex];
+ PackedVarying *varying = &vertexShaderD3D->mVaryings[varyingIndex];
if (transformFeedbackVarying == varying->name)
{
if (!packVarying(varying, maxVaryingVectors, packing))
@@ -275,12 +279,14 @@
std::string DynamicHLSL::generateVaryingHLSL(VertexShader *shader) const
{
- std::string varyingSemantic = getVaryingSemantic(shader->mUsesPointSize);
+ rx::VertexShaderD3D *shaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(shader->getImplementation());
+
+ std::string varyingSemantic = getVaryingSemantic(shaderD3D->mUsesPointSize);
std::string varyingHLSL;
- for (unsigned int varyingIndex = 0; varyingIndex < shader->mVaryings.size(); varyingIndex++)
+ for (unsigned int varyingIndex = 0; varyingIndex < shaderD3D->mVaryings.size(); varyingIndex++)
{
- const PackedVarying &varying = shader->mVaryings[varyingIndex];
+ const PackedVarying &varying = shaderD3D->mVaryings[varyingIndex];
if (varying.registerAssigned())
{
GLenum transposedType = TransposeMatrixType(varying.type);
@@ -604,8 +610,10 @@
void DynamicHLSL::storeUserLinkedVaryings(const VertexShader *vertexShader,
std::vector<LinkedVarying> *linkedVaryings) const
{
- const std::string &varyingSemantic = getVaryingSemantic(vertexShader->mUsesPointSize);
- const std::vector<PackedVarying> &varyings = vertexShader->mVaryings;
+ const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+
+ const std::string &varyingSemantic = getVaryingSemantic(vertexShaderD3D->mUsesPointSize);
+ const std::vector<PackedVarying> &varyings = vertexShaderD3D->mVaryings;
for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
{
@@ -636,12 +644,15 @@
return false;
}
- bool usesMRT = fragmentShader->mUsesMultipleRenderTargets;
- bool usesFragColor = fragmentShader->mUsesFragColor;
- bool usesFragData = fragmentShader->mUsesFragData;
- bool usesFragCoord = fragmentShader->mUsesFragCoord;
- bool usesPointCoord = fragmentShader->mUsesPointCoord;
- bool usesPointSize = vertexShader->mUsesPointSize;
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
+
+ bool usesMRT = fragmentShaderD3D->mUsesMultipleRenderTargets;
+ bool usesFragColor = fragmentShaderD3D->mUsesFragColor;
+ bool usesFragData = fragmentShaderD3D->mUsesFragData;
+ bool usesFragCoord = fragmentShaderD3D->mUsesFragCoord;
+ bool usesPointCoord = fragmentShaderD3D->mUsesPointCoord;
+ bool usesPointSize = vertexShaderD3D->mUsesPointSize;
if (usesFragColor && usesFragData)
{
@@ -658,10 +669,10 @@
// Two cases when writing to gl_FragColor and using ESSL 1.0:
// - with a 3.0 context, the output color is copied to channel 0
// - with a 2.0 context, the output color is broadcast to all channels
- const bool broadcast = (fragmentShader->mUsesFragColor && mRenderer->getCurrentClientVersion() < 3);
+ const bool broadcast = (fragmentShaderD3D->mUsesFragColor && mRenderer->getCurrentClientVersion() < 3);
const unsigned int numRenderTargets = (broadcast || usesMRT ? mRenderer->getRendererCaps().maxDrawBuffers : 1);
- int shaderVersion = vertexShader->getShaderVersion();
+ int shaderVersion = vertexShaderD3D->getShaderVersion();
if (registersNeeded > maxVaryingVectors)
{
@@ -718,9 +729,9 @@
vertexHLSL += " output.gl_FragCoord = gl_Position;\n";
}
- for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexShader->mVaryings.size(); vertVaryingIndex++)
+ for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexShaderD3D->mVaryings.size(); vertVaryingIndex++)
{
- const PackedVarying &varying = vertexShader->mVaryings[vertVaryingIndex];
+ const PackedVarying &varying = vertexShaderD3D->mVaryings[vertVaryingIndex];
if (varying.registerAssigned())
{
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
@@ -802,13 +813,13 @@
outPixelShaderKey->push_back(outputKeyVariable);
}
- *outUsesFragDepth = fragmentShader->mUsesFragDepth;
+ *outUsesFragDepth = fragmentShaderD3D->mUsesFragDepth;
}
else
{
defineOutputVariables(fragmentShader, programOutputVars);
- const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
+ const std::vector<sh::Attribute> &shaderOutputVars = fragmentShaderD3D->getOutputVariables();
for (auto locationIt = programOutputVars->begin(); locationIt != programOutputVars->end(); locationIt++)
{
const VariableLocation &outputLocation = locationIt->second;
@@ -830,7 +841,7 @@
pixelHLSL += PIXEL_OUTPUT_STUB_STRING + "\n";
- if (fragmentShader->mUsesFrontFacing)
+ if (fragmentShaderD3D->mUsesFrontFacing)
{
if (shaderModel >= 4)
{
@@ -880,7 +891,7 @@
pixelHLSL += " gl_PointCoord.y = 1.0 - input.gl_PointCoord.y;\n";
}
- if (fragmentShader->mUsesFrontFacing)
+ if (fragmentShaderD3D->mUsesFrontFacing)
{
if (shaderModel <= 3)
{
@@ -892,9 +903,9 @@
}
}
- for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
+ for (unsigned int varyingIndex = 0; varyingIndex < fragmentShaderD3D->mVaryings.size(); varyingIndex++)
{
- const PackedVarying &varying = fragmentShader->mVaryings[varyingIndex];
+ const PackedVarying &varying = fragmentShaderD3D->mVaryings[varyingIndex];
if (varying.registerAssigned())
{
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
@@ -948,7 +959,8 @@
void DynamicHLSL::defineOutputVariables(FragmentShader *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
{
- const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
+ const std::vector<sh::Attribute> &shaderOutputVars = fragmentShaderD3D->getOutputVariables();
for (unsigned int outputVariableIndex = 0; outputVariableIndex < shaderOutputVars.size(); outputVariableIndex++)
{
@@ -974,23 +986,26 @@
std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const
{
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
// for now we only handle point sprite emulation
- ASSERT(vertexShader->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
+ ASSERT(vertexShaderD3D->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
return generatePointSpriteHLSL(registers, fragmentShader, vertexShader);
}
std::string DynamicHLSL::generatePointSpriteHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const
{
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
ASSERT(registers >= 0);
- ASSERT(vertexShader->mUsesPointSize);
+ ASSERT(vertexShaderD3D->mUsesPointSize);
ASSERT(mRenderer->getMajorShaderModel() >= 4);
std::string geomHLSL;
- const SemanticInfo &inSemantics = getSemanticInfo(registers, fragmentShader->mUsesFragCoord,
+ const SemanticInfo &inSemantics = getSemanticInfo(registers, fragmentShaderD3D->mUsesFragCoord,
false, true, false);
- const SemanticInfo &outSemantics = getSemanticInfo(registers, fragmentShader->mUsesFragCoord,
- fragmentShader->mUsesPointCoord, true, false);
+ const SemanticInfo &outSemantics = getSemanticInfo(registers, fragmentShaderD3D->mUsesFragCoord,
+ fragmentShaderD3D->mUsesPointCoord, true, false);
std::string varyingHLSL = generateVaryingHLSL(vertexShader);
std::string inLinkHLSL = generateVaryingLinkHLSL(inSemantics, varyingHLSL);
@@ -1033,7 +1048,7 @@
geomHLSL += " output.v" + Str(r) + " = input[0].v" + Str(r) + ";\n";
}
- if (fragmentShader->mUsesFragCoord)
+ if (fragmentShaderD3D->mUsesFragCoord)
{
geomHLSL += " output.gl_FragCoord = input[0].gl_FragCoord;\n";
}
@@ -1048,7 +1063,7 @@
geomHLSL += " \n"
" output.dx_Position = dx_Position + float4(pointSpriteCorners[" + Str(corner) + "] * viewportScale * gl_PointSize, 0.0f, 0.0f);\n";
- if (fragmentShader->mUsesPointCoord)
+ if (fragmentShaderD3D->mUsesPointCoord)
{
geomHLSL += " output.gl_PointCoord = pointSpriteTexcoords[" + Str(corner) + "];\n";
}
diff --git a/src/libGLESv2/ProgramBinary.cpp b/src/libGLESv2/ProgramBinary.cpp
index cac88e3..06d0265 100644
--- a/src/libGLESv2/ProgramBinary.cpp
+++ b/src/libGLESv2/ProgramBinary.cpp
@@ -22,6 +22,7 @@
#include "libGLESv2/Shader.h"
#include "libGLESv2/Program.h"
#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
#include "libGLESv2/renderer/d3d/VertexDataManager.h"
#include "libGLESv2/Context.h"
#include "libGLESv2/Buffer.h"
@@ -1052,8 +1053,11 @@
bool ProgramBinary::linkVaryings(InfoLog &infoLog, FragmentShader *fragmentShader, VertexShader *vertexShader)
{
- std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
- std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
+
+ std::vector<PackedVarying> &fragmentVaryings = fragmentShaderD3D->getVaryings();
+ std::vector<PackedVarying> &vertexVaryings = vertexShaderD3D->getVaryings();
for (size_t fragVaryingIndex = 0; fragVaryingIndex < fragmentVaryings.size(); fragVaryingIndex++)
{
@@ -1605,13 +1609,16 @@
mTransformFeedbackBufferMode = transformFeedbackBufferMode;
- mShaderVersion = vertexShader->getShaderVersion();
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+ rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
- mPixelHLSL = fragmentShader->getHLSL();
- mPixelWorkarounds = fragmentShader->getD3DWorkarounds();
+ mShaderVersion = vertexShaderD3D->getShaderVersion();
- mVertexHLSL = vertexShader->getHLSL();
- mVertexWorkarounds = vertexShader->getD3DWorkarounds();
+ mPixelHLSL = fragmentShaderD3D->getTranslatedSource();
+ mPixelWorkarounds = fragmentShaderD3D->getD3DWorkarounds();
+
+ mVertexHLSL = vertexShaderD3D->getTranslatedSource();
+ mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds();
// Map the varyings to the register file
VaryingPacking packing = { NULL };
@@ -1627,7 +1634,7 @@
return false;
}
- mUsesPointSize = vertexShader->usesPointSize();
+ mUsesPointSize = vertexShaderD3D->usesPointSize();
std::vector<LinkedVarying> linkedVaryings;
if (!mDynamicHLSL->generateShaderLinkHLSL(infoLog, registers, packing, mPixelHLSL, mVertexHLSL,
fragmentShader, vertexShader, transformFeedbackVaryings,
@@ -1649,7 +1656,7 @@
}
// special case for gl_DepthRange, the only built-in uniform (also a struct)
- if (vertexShader->usesDepthRange() || fragmentShader->usesDepthRange())
+ if (vertexShaderD3D->usesDepthRange() || fragmentShaderD3D->usesDepthRange())
{
const sh::BlockMemberInfo &defaultInfo = sh::BlockMemberInfo::getDefaultBlockInfo();
@@ -1672,7 +1679,7 @@
if (success)
{
VertexFormat defaultInputLayout[MAX_VERTEX_ATTRIBS];
- GetInputLayoutFromShader(vertexShader->activeAttributes(), defaultInputLayout);
+ GetInputLayoutFromShader(vertexShaderD3D->getActiveAttributes(), defaultInputLayout);
rx::ShaderExecutable *defaultVertexExecutable = getVertexExecutableForInputLayout(defaultInputLayout);
std::vector<GLenum> defaultPixelOutput(IMPLEMENTATION_MAX_DRAW_BUFFERS);
@@ -1705,8 +1712,10 @@
// Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices
bool ProgramBinary::linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, FragmentShader *fragmentShader, VertexShader *vertexShader)
{
+ rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+
unsigned int usedLocations = 0;
- const std::vector<sh::Attribute> &activeAttributes = vertexShader->activeAttributes();
+ const std::vector<sh::Attribute> &activeAttributes = vertexShaderD3D->getActiveAttributes();
// Link attributes that have a binding location
for (unsigned int attributeIndex = 0; attributeIndex < activeAttributes.size(); attributeIndex++)
@@ -1773,7 +1782,7 @@
for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; )
{
- int index = vertexShader->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
+ int index = vertexShaderD3D->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
int rows = VariableRegisterCount(mLinkedAttribute[attributeIndex].type);
for (int r = 0; r < rows; r++)
@@ -1881,8 +1890,11 @@
bool ProgramBinary::linkUniforms(InfoLog &infoLog, const VertexShader &vertexShader, const FragmentShader &fragmentShader)
{
- const std::vector<sh::Uniform> &vertexUniforms = vertexShader.getUniforms();
- const std::vector<sh::Uniform> &fragmentUniforms = fragmentShader.getUniforms();
+ const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader.getImplementation());
+ const rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader.getImplementation());
+
+ const std::vector<sh::Uniform> &vertexUniforms = vertexShaderD3D->getUniforms();
+ const std::vector<sh::Uniform> &fragmentUniforms = fragmentShaderD3D->getUniforms();
// Check that uniforms defined in the vertex and fragment shaders are identical
typedef std::map<std::string, const sh::Uniform*> UniformMap;
@@ -1912,13 +1924,13 @@
for (unsigned int uniformIndex = 0; uniformIndex < vertexUniforms.size(); uniformIndex++)
{
const sh::Uniform &uniform = vertexUniforms[uniformIndex];
- defineUniformBase(GL_VERTEX_SHADER, uniform, vertexShader.getUniformRegister(uniform.name));
+ defineUniformBase(GL_VERTEX_SHADER, uniform, vertexShaderD3D->getUniformRegister(uniform.name));
}
for (unsigned int uniformIndex = 0; uniformIndex < fragmentUniforms.size(); uniformIndex++)
{
const sh::Uniform &uniform = fragmentUniforms[uniformIndex];
- defineUniformBase(GL_FRAGMENT_SHADER, uniform, fragmentShader.getUniformRegister(uniform.name));
+ defineUniformBase(GL_FRAGMENT_SHADER, uniform, fragmentShaderD3D->getUniformRegister(uniform.name));
}
if (!indexUniforms(infoLog))
@@ -1933,7 +1945,7 @@
void ProgramBinary::defineUniformBase(GLenum shader, const sh::Uniform &uniform, unsigned int uniformRegister)
{
- ShShaderOutput outputType = Shader::getCompilerOutputType(shader);
+ ShShaderOutput outputType = rx::ShaderD3D::getCompilerOutputType(shader);
sh::HLSLBlockEncoder encoder(sh::HLSLBlockEncoder::GetStrategyFor(outputType));
encoder.skipRegisters(uniformRegister);
@@ -2152,8 +2164,11 @@
bool ProgramBinary::linkUniformBlocks(InfoLog &infoLog, const VertexShader &vertexShader,
const FragmentShader &fragmentShader)
{
- const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks = vertexShader.getInterfaceBlocks();
- const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks = fragmentShader.getInterfaceBlocks();
+ const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader.getImplementation());
+ const rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader.getImplementation());
+
+ const std::vector<sh::InterfaceBlock> &vertexInterfaceBlocks = vertexShaderD3D->getInterfaceBlocks();
+ const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks = fragmentShaderD3D->getInterfaceBlocks();
// Check that interface blocks defined in the vertex and fragment shaders are identical
typedef std::map<std::string, const sh::InterfaceBlock*> UniformBlockMap;
@@ -2293,6 +2308,8 @@
bool ProgramBinary::defineUniformBlock(InfoLog &infoLog, const Shader &shader, const sh::InterfaceBlock &interfaceBlock)
{
+ const rx::ShaderD3D* shaderD3D = rx::ShaderD3D::makeShaderD3D(shader.getImplementation());
+
// create uniform block entries if they do not exist
if (getUniformBlockIndex(interfaceBlock.name) == GL_INVALID_INDEX)
{
@@ -2340,7 +2357,7 @@
ASSERT(blockIndex != GL_INVALID_INDEX);
ASSERT(blockIndex + elementCount <= mUniformBlocks.size());
- unsigned int interfaceBlockRegister = shader.getInterfaceBlockRegister(interfaceBlock.name);
+ unsigned int interfaceBlockRegister = shaderD3D->getInterfaceBlockRegister(interfaceBlock.name);
for (unsigned int uniformBlockElement = 0; uniformBlockElement < elementCount; uniformBlockElement++)
{
diff --git a/src/libGLESv2/ResourceManager.cpp b/src/libGLESv2/ResourceManager.cpp
index 750e4d9..9f04110 100644
--- a/src/libGLESv2/ResourceManager.cpp
+++ b/src/libGLESv2/ResourceManager.cpp
@@ -95,11 +95,11 @@
if (type == GL_VERTEX_SHADER)
{
- mShaderMap[handle] = new VertexShader(this, mRenderer, handle);
+ mShaderMap[handle] = new VertexShader(this, mRenderer->createShader(type), handle);
}
else if (type == GL_FRAGMENT_SHADER)
{
- mShaderMap[handle] = new FragmentShader(this, mRenderer, handle);
+ mShaderMap[handle] = new FragmentShader(this, mRenderer->createShader(type), handle);
}
else UNREACHABLE();
diff --git a/src/libGLESv2/Shader.cpp b/src/libGLESv2/Shader.cpp
index 0d7f601..05e11ad 100644
--- a/src/libGLESv2/Shader.cpp
+++ b/src/libGLESv2/Shader.cpp
@@ -14,31 +14,22 @@
#include "GLSLANG/ShaderLang.h"
#include "common/utilities.h"
#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/renderer/ShaderImpl.h"
#include "libGLESv2/Constants.h"
#include "libGLESv2/ResourceManager.h"
namespace gl
{
-void *Shader::mFragmentCompiler = NULL;
-void *Shader::mVertexCompiler = NULL;
-template <typename VarT>
-const std::vector<VarT> *GetShaderVariables(const std::vector<VarT> *variableList)
+Shader::Shader(ResourceManager *manager, rx::ShaderImpl *impl, GLenum type, GLuint handle)
+ : mShader(impl),
+ mType(type),
+ mHandle(handle),
+ mResourceManager(manager),
+ mRefCount(0),
+ mDeleteStatus(false),
+ mCompiled(false)
{
- // TODO: handle staticUse. for now, assume all returned variables are active.
- ASSERT(variableList);
- return variableList;
-}
-
-Shader::Shader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle)
- : mHandle(handle), mRenderer(renderer), mResourceManager(manager)
-{
- uncompile();
- initializeCompiler();
-
- mRefCount = 0;
- mDeleteStatus = false;
- mShaderVersion = 100;
}
Shader::~Shader()
@@ -64,7 +55,7 @@
int Shader::getInfoLogLength() const
{
- return mInfoLog.empty() ? 0 : (mInfoLog.length() + 1);
+ return mShader->getInfoLog().empty() ? 0 : (mShader->getInfoLog().length() + 1);
}
void Shader::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
@@ -73,8 +64,8 @@
if (bufSize > 0)
{
- index = std::min(bufSize - 1, static_cast<GLsizei>(mInfoLog.length()));
- memcpy(infoLog, mInfoLog.c_str(), index);
+ index = std::min(bufSize - 1, static_cast<GLsizei>(mShader->getInfoLog().length()));
+ memcpy(infoLog, mShader->getInfoLog().c_str(), index);
infoLog[index] = '\0';
}
@@ -92,10 +83,10 @@
int Shader::getTranslatedSourceLength() const
{
- return mHlsl.empty() ? 0 : (mHlsl.length() + 1);
+ return mShader->getTranslatedSource().empty() ? 0 : (mShader->getTranslatedSource().length() + 1);
}
-void Shader::getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer) const
+void Shader::getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer)
{
int index = 0;
@@ -120,44 +111,12 @@
void Shader::getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const
{
- getSourceImpl(mHlsl, bufSize, length, buffer);
+ getSourceImpl(mShader->getTranslatedSource(), bufSize, length, buffer);
}
-unsigned int Shader::getUniformRegister(const std::string &uniformName) const
+void Shader::compile()
{
- ASSERT(mUniformRegisterMap.count(uniformName) > 0);
- return mUniformRegisterMap.find(uniformName)->second;
-}
-
-unsigned int Shader::getInterfaceBlockRegister(const std::string &blockName) const
-{
- ASSERT(mInterfaceBlockRegisterMap.count(blockName) > 0);
- return mInterfaceBlockRegisterMap.find(blockName)->second;
-}
-
-const std::vector<sh::Uniform> &Shader::getUniforms() const
-{
- return mActiveUniforms;
-}
-
-const std::vector<sh::InterfaceBlock> &Shader::getInterfaceBlocks() const
-{
- return mActiveInterfaceBlocks;
-}
-
-std::vector<PackedVarying> &Shader::getVaryings()
-{
- return mVaryings;
-}
-
-bool Shader::isCompiled() const
-{
- return !mHlsl.empty();
-}
-
-const std::string &Shader::getHLSL() const
-{
- return mHlsl;
+ mCompiled = mShader->compile(mSource);
}
void Shader::addRef()
@@ -190,289 +149,8 @@
mDeleteStatus = true;
}
-// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
-void Shader::initializeCompiler()
-{
- if (!mFragmentCompiler)
- {
- int result = ShInitialize();
-
- if (result)
- {
- ShShaderOutput hlslVersion = (mRenderer->getMajorShaderModel() >= 4) ? SH_HLSL11_OUTPUT : SH_HLSL9_OUTPUT;
-
- ShBuiltInResources resources;
- ShInitBuiltInResources(&resources);
-
- // TODO(geofflang): use context's caps
- const gl::Caps &caps = mRenderer->getRendererCaps();
- const gl::Extensions &extensions = mRenderer->getRendererExtensions();
-
- resources.MaxVertexAttribs = caps.maxVertexAttributes;
- resources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
- resources.MaxVaryingVectors = mRenderer->getMaxVaryingVectors();
- resources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
- resources.MaxCombinedTextureImageUnits = mRenderer->getMaxCombinedTextureImageUnits();
- resources.MaxTextureImageUnits = caps.maxTextureImageUnits;
- resources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
- resources.MaxDrawBuffers = caps.maxDrawBuffers;
- resources.OES_standard_derivatives = extensions.standardDerivatives;
- resources.EXT_draw_buffers = extensions.drawBuffers;
- resources.EXT_shader_texture_lod = 1;
- // resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
- resources.FragmentPrecisionHigh = 1; // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
- resources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
- // GLSL ES 3.0 constants
- resources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
- resources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
- resources.MinProgramTexelOffset = caps.minProgramTexelOffset;
- resources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
-
- mFragmentCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
- mVertexCompiler = ShConstructCompiler(GL_VERTEX_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
- }
- }
-}
-
-void Shader::releaseCompiler()
-{
- ShDestruct(mFragmentCompiler);
- ShDestruct(mVertexCompiler);
-
- mFragmentCompiler = NULL;
- mVertexCompiler = NULL;
-
- ShFinalize();
-}
-
-void Shader::parseVaryings(void *compiler)
-{
- if (!mHlsl.empty())
- {
- const std::vector<sh::Varying> *activeVaryings = ShGetVaryings(compiler);
- ASSERT(activeVaryings);
-
- for (size_t varyingIndex = 0; varyingIndex < activeVaryings->size(); varyingIndex++)
- {
- mVaryings.push_back(PackedVarying((*activeVaryings)[varyingIndex]));
- }
-
- mUsesMultipleRenderTargets = mHlsl.find("GL_USES_MRT") != std::string::npos;
- mUsesFragColor = mHlsl.find("GL_USES_FRAG_COLOR") != std::string::npos;
- mUsesFragData = mHlsl.find("GL_USES_FRAG_DATA") != std::string::npos;
- mUsesFragCoord = mHlsl.find("GL_USES_FRAG_COORD") != std::string::npos;
- mUsesFrontFacing = mHlsl.find("GL_USES_FRONT_FACING") != std::string::npos;
- mUsesPointSize = mHlsl.find("GL_USES_POINT_SIZE") != std::string::npos;
- mUsesPointCoord = mHlsl.find("GL_USES_POINT_COORD") != std::string::npos;
- mUsesDepthRange = mHlsl.find("GL_USES_DEPTH_RANGE") != std::string::npos;
- mUsesFragDepth = mHlsl.find("GL_USES_FRAG_DEPTH") != std::string::npos;
- mUsesDiscardRewriting = mHlsl.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos;
- mUsesNestedBreak = mHlsl.find("ANGLE_USES_NESTED_BREAK") != std::string::npos;
- }
-}
-
-void Shader::resetVaryingsRegisterAssignment()
-{
- for (unsigned int varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
- {
- mVaryings[varyingIndex].resetRegisterAssignment();
- }
-}
-
-// initialize/clean up previous state
-void Shader::uncompile()
-{
- // set by compileToHLSL
- mHlsl.clear();
- mInfoLog.clear();
-
- // set by parseVaryings
- mVaryings.clear();
-
- mUsesMultipleRenderTargets = false;
- mUsesFragColor = false;
- mUsesFragData = false;
- mUsesFragCoord = false;
- mUsesFrontFacing = false;
- mUsesPointSize = false;
- mUsesPointCoord = false;
- mUsesDepthRange = false;
- mUsesFragDepth = false;
- mShaderVersion = 100;
- mUsesDiscardRewriting = false;
- mUsesNestedBreak = false;
-
- mActiveUniforms.clear();
- mActiveInterfaceBlocks.clear();
-}
-
-void Shader::compileToHLSL(void *compiler)
-{
- // ensure the compiler is loaded
- initializeCompiler();
-
- int compileOptions = SH_OBJECT_CODE;
- std::string sourcePath;
- if (perfActive())
- {
- sourcePath = getTempPath();
- writeFile(sourcePath.c_str(), mSource.c_str(), mSource.length());
- compileOptions |= SH_LINE_DIRECTIVES;
- }
-
- int result;
- if (sourcePath.empty())
- {
- const char* sourceStrings[] =
- {
- mSource.c_str(),
- };
-
- result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions);
- }
- else
- {
- const char* sourceStrings[] =
- {
- sourcePath.c_str(),
- mSource.c_str(),
- };
-
- result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions | SH_SOURCE_PATH);
- }
-
- size_t shaderVersion = 100;
- ShGetInfo(compiler, SH_SHADER_VERSION, &shaderVersion);
-
- mShaderVersion = static_cast<int>(shaderVersion);
-
- if (shaderVersion == 300 && mRenderer->getCurrentClientVersion() < 3)
- {
- mInfoLog = "GLSL ES 3.00 is not supported by OpenGL ES 2.0 contexts";
- TRACE("\n%s", mInfoLog.c_str());
- }
- else if (result)
- {
- size_t objCodeLen = 0;
- ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &objCodeLen);
-
- char* outputHLSL = new char[objCodeLen];
- ShGetObjectCode(compiler, outputHLSL);
-
-#ifdef _DEBUG
- std::ostringstream hlslStream;
- hlslStream << "// GLSL\n";
- hlslStream << "//\n";
-
- size_t curPos = 0;
- while (curPos != std::string::npos)
- {
- size_t nextLine = mSource.find("\n", curPos);
- size_t len = (nextLine == std::string::npos) ? std::string::npos : (nextLine - curPos + 1);
-
- hlslStream << "// " << mSource.substr(curPos, len);
-
- curPos = (nextLine == std::string::npos) ? std::string::npos : (nextLine + 1);
- }
- hlslStream << "\n\n";
- hlslStream << outputHLSL;
- mHlsl = hlslStream.str();
-#else
- mHlsl = outputHLSL;
-#endif
-
- SafeDeleteArray(outputHLSL);
-
- mActiveUniforms = *GetShaderVariables(ShGetUniforms(compiler));
-
- for (size_t uniformIndex = 0; uniformIndex < mActiveUniforms.size(); uniformIndex++)
- {
- const sh::Uniform &uniform = mActiveUniforms[uniformIndex];
-
- unsigned int index = -1;
- bool result = ShGetUniformRegister(compiler, uniform.name.c_str(), &index);
- UNUSED_ASSERTION_VARIABLE(result);
- ASSERT(result);
-
- mUniformRegisterMap[uniform.name] = index;
- }
-
- mActiveInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
-
- for (size_t blockIndex = 0; blockIndex < mActiveInterfaceBlocks.size(); blockIndex++)
- {
- const sh::InterfaceBlock &interfaceBlock = mActiveInterfaceBlocks[blockIndex];
-
- unsigned int index = -1;
- bool result = ShGetInterfaceBlockRegister(compiler, interfaceBlock.name.c_str(), &index);
- UNUSED_ASSERTION_VARIABLE(result);
- ASSERT(result);
-
- mInterfaceBlockRegisterMap[interfaceBlock.name] = index;
- }
- }
- else
- {
- size_t infoLogLen = 0;
- ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &infoLogLen);
-
- char* infoLog = new char[infoLogLen];
- ShGetInfoLog(compiler, infoLog);
- mInfoLog = infoLog;
-
- TRACE("\n%s", mInfoLog.c_str());
- }
-}
-
-rx::D3DWorkaroundType Shader::getD3DWorkarounds() const
-{
- if (mUsesDiscardRewriting)
- {
- // ANGLE issue 486:
- // Work-around a D3D9 compiler bug that presents itself when using conditional discard, by disabling optimization
- return rx::ANGLE_D3D_WORKAROUND_SKIP_OPTIMIZATION;
- }
-
- if (mUsesNestedBreak)
- {
- // ANGLE issue 603:
- // Work-around a D3D9 compiler bug that presents itself when using break in a nested loop, by maximizing optimization
- // We want to keep the use of ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION minimal to prevent hangs, so usesDiscard takes precedence
- return rx::ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION;
- }
-
- return rx::ANGLE_D3D_WORKAROUND_NONE;
-}
-
-// true if varying x has a higher priority in packing than y
-bool Shader::compareVarying(const PackedVarying &x, const PackedVarying &y)
-{
- if (x.type == y.type)
- {
- return x.arraySize > y.arraySize;
- }
-
- // Special case for handling structs: we sort these to the end of the list
- if (x.type == GL_STRUCT_ANGLEX)
- {
- return false;
- }
-
- if (y.type == GL_STRUCT_ANGLEX)
- {
- return true;
- }
-
- return gl::VariableSortOrder(x.type) <= gl::VariableSortOrder(y.type);
-}
-
-int Shader::getShaderVersion() const
-{
- return mShaderVersion;
-}
-
-VertexShader::VertexShader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle)
- : Shader(manager, renderer, handle)
+VertexShader::VertexShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle)
+ : Shader(manager, impl, GL_VERTEX_SHADER, handle)
{
}
@@ -480,60 +158,8 @@
{
}
-GLenum VertexShader::getType() const
-{
- return GL_VERTEX_SHADER;
-}
-
-void VertexShader::uncompile()
-{
- Shader::uncompile();
-
- // set by ParseAttributes
- mActiveAttributes.clear();
-}
-
-void VertexShader::compile()
-{
- uncompile();
-
- compileToHLSL(mVertexCompiler);
- parseAttributes();
- parseVaryings(mVertexCompiler);
-}
-
-int VertexShader::getSemanticIndex(const std::string &attributeName)
-{
- if (!attributeName.empty())
- {
- int semanticIndex = 0;
- for (unsigned int attributeIndex = 0; attributeIndex < mActiveAttributes.size(); attributeIndex++)
- {
- const sh::ShaderVariable &attribute = mActiveAttributes[attributeIndex];
-
- if (attribute.name == attributeName)
- {
- return semanticIndex;
- }
-
- semanticIndex += VariableRegisterCount(attribute.type);
- }
- }
-
- return -1;
-}
-
-void VertexShader::parseAttributes()
-{
- const std::string &hlsl = getHLSL();
- if (!hlsl.empty())
- {
- mActiveAttributes = *GetShaderVariables(ShGetAttributes(mVertexCompiler));
- }
-}
-
-FragmentShader::FragmentShader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle)
- : Shader(manager, renderer, handle)
+FragmentShader::FragmentShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle)
+ : Shader(manager, impl, GL_FRAGMENT_SHADER, handle)
{
}
@@ -541,53 +167,4 @@
{
}
-GLenum FragmentShader::getType() const
-{
- return GL_FRAGMENT_SHADER;
-}
-
-void FragmentShader::compile()
-{
- uncompile();
-
- compileToHLSL(mFragmentCompiler);
- parseVaryings(mFragmentCompiler);
- std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
-
- const std::string &hlsl = getHLSL();
- if (!hlsl.empty())
- {
- mActiveOutputVariables = *GetShaderVariables(ShGetOutputVariables(mFragmentCompiler));
- }
-}
-
-void FragmentShader::uncompile()
-{
- Shader::uncompile();
-
- mActiveOutputVariables.clear();
-}
-
-const std::vector<sh::Attribute> &FragmentShader::getOutputVariables() const
-{
- return mActiveOutputVariables;
-}
-
-ShShaderOutput Shader::getCompilerOutputType(GLenum shader)
-{
- void *compiler = NULL;
-
- switch (shader)
- {
- case GL_VERTEX_SHADER: compiler = mVertexCompiler; break;
- case GL_FRAGMENT_SHADER: compiler = mFragmentCompiler; break;
- default: UNREACHABLE(); return SH_HLSL9_OUTPUT;
- }
-
- size_t outputType = 0;
- ShGetInfo(compiler, SH_OUTPUT_TYPE, &outputType);
-
- return static_cast<ShShaderOutput>(outputType);
-}
-
}
diff --git a/src/libGLESv2/Shader.h b/src/libGLESv2/Shader.h
index c322520..e34c197 100644
--- a/src/libGLESv2/Shader.h
+++ b/src/libGLESv2/Shader.h
@@ -25,7 +25,7 @@
namespace rx
{
-class Renderer;
+class ShaderImpl;
}
namespace gl
@@ -51,16 +51,17 @@
class Shader
{
- friend class DynamicHLSL;
-
public:
- Shader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle);
+ Shader(ResourceManager *manager, rx::ShaderImpl *impl, GLenum type, GLuint handle);
virtual ~Shader();
- virtual GLenum getType() const = 0;
+ GLenum getType() const { return mType; }
GLuint getHandle() const;
+ rx::ShaderImpl *getImplementation() { return mShader; }
+ const rx::ShaderImpl *getImplementation() const { return mShader; }
+
void deleteSource();
void setSource(GLsizei count, const char *const *string, const GLint *length);
int getInfoLogLength() const;
@@ -69,121 +70,53 @@
void getSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
int getTranslatedSourceLength() const;
void getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
- const std::vector<sh::Uniform> &getUniforms() const;
- const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const;
- std::vector<PackedVarying> &getVaryings();
- virtual void compile() = 0;
- virtual void uncompile();
- bool isCompiled() const;
- const std::string &getHLSL() const;
+ void compile();
+ bool isCompiled() const { return mCompiled; }
void addRef();
void release();
unsigned int getRefCount() const;
bool isFlaggedForDeletion() const;
void flagForDeletion();
- int getShaderVersion() const;
- void resetVaryingsRegisterAssignment();
-
- static void releaseCompiler();
- static ShShaderOutput getCompilerOutputType(GLenum shader);
- unsigned int getUniformRegister(const std::string &uniformName) const;
- unsigned int getInterfaceBlockRegister(const std::string &blockName) const;
-
- bool usesDepthRange() const { return mUsesDepthRange; }
- bool usesPointSize() const { return mUsesPointSize; }
- rx::D3DWorkaroundType getD3DWorkarounds() const;
-
- protected:
- void parseVaryings(void *compiler);
-
- void compileToHLSL(void *compiler);
-
- void getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer) const;
-
- static bool compareVarying(const PackedVarying &x, const PackedVarying &y);
-
- const rx::Renderer *const mRenderer;
-
- std::vector<PackedVarying> mVaryings;
-
- bool mUsesMultipleRenderTargets;
- bool mUsesFragColor;
- bool mUsesFragData;
- bool mUsesFragCoord;
- bool mUsesFrontFacing;
- bool mUsesPointSize;
- bool mUsesPointCoord;
- bool mUsesDepthRange;
- bool mUsesFragDepth;
- int mShaderVersion;
- bool mUsesDiscardRewriting;
- bool mUsesNestedBreak;
-
- static void *mFragmentCompiler;
- static void *mVertexCompiler;
private:
DISALLOW_COPY_AND_ASSIGN(Shader);
- void initializeCompiler();
+ static void getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer);
+ rx::ShaderImpl *mShader;
const GLuint mHandle;
+ const GLenum mType;
+ std::string mSource;
unsigned int mRefCount; // Number of program objects this shader is attached to
bool mDeleteStatus; // Flag to indicate that the shader can be deleted when no longer in use
-
- std::string mSource;
- std::string mHlsl;
- std::string mInfoLog;
- std::vector<sh::Uniform> mActiveUniforms;
- std::vector<sh::InterfaceBlock> mActiveInterfaceBlocks;
- std::map<std::string, unsigned int> mUniformRegisterMap;
- std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
+ bool mCompiled; // Indicates if this shader has been successfully compiled
ResourceManager *mResourceManager;
};
+// TODO: These are now stubs. We should remove them and use Shader exclusively.
class VertexShader : public Shader
{
- friend class DynamicHLSL;
-
public:
- VertexShader(ResourceManager *manager, const rx::Renderer *renderer, GLuint handle);
+ VertexShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle);
~VertexShader();
- virtual GLenum getType() const;
- virtual void compile();
- virtual void uncompile();
- int getSemanticIndex(const std::string &attributeName);
-
- const std::vector<sh::Attribute> &activeAttributes() const { return mActiveAttributes; }
-
private:
DISALLOW_COPY_AND_ASSIGN(VertexShader);
-
- void parseAttributes();
-
- std::vector<sh::Attribute> mActiveAttributes;
};
class FragmentShader : public Shader
{
public:
- FragmentShader(ResourceManager *manager,const rx::Renderer *renderer, GLuint handle);
+ FragmentShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle);
~FragmentShader();
- virtual GLenum getType() const;
- virtual void compile();
- virtual void uncompile();
- const std::vector<sh::Attribute> &getOutputVariables() const;
-
private:
DISALLOW_COPY_AND_ASSIGN(FragmentShader);
-
- std::vector<sh::Attribute> mActiveOutputVariables;
};
}
diff --git a/src/libGLESv2/libGLESv2.cpp b/src/libGLESv2/libGLESv2.cpp
index aeeddcc..5dd0855 100644
--- a/src/libGLESv2/libGLESv2.cpp
+++ b/src/libGLESv2/libGLESv2.cpp
@@ -3584,7 +3584,12 @@
{
EVENT("()");
- gl::Shader::releaseCompiler();
+ gl::Context *context = gl::getNonLostContext();
+
+ if (context)
+ {
+ context->releaseShaderCompiler();
+ }
}
void __stdcall glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
diff --git a/src/libGLESv2/renderer/Renderer.cpp b/src/libGLESv2/renderer/Renderer.cpp
index 0cab199..5a61d42 100644
--- a/src/libGLESv2/renderer/Renderer.cpp
+++ b/src/libGLESv2/renderer/Renderer.cpp
@@ -40,7 +40,6 @@
Renderer::~Renderer()
{
- gl::Shader::releaseCompiler();
}
const gl::Caps &Renderer::getRendererCaps() const
diff --git a/src/libGLESv2/renderer/Renderer.h b/src/libGLESv2/renderer/Renderer.h
index e4c0476..00c15e4 100644
--- a/src/libGLESv2/renderer/Renderer.h
+++ b/src/libGLESv2/renderer/Renderer.h
@@ -53,6 +53,7 @@
class VertexArrayImpl;
class BufferStorage;
struct TranslatedIndexData;
+class ShaderImpl;
class ShaderExecutable;
class SwapChain;
class RenderTarget;
@@ -197,7 +198,11 @@
virtual RenderTarget *createRenderTarget(SwapChain *swapChain, bool depth) = 0;
virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples) = 0;
+ // Shader creation
+ virtual ShaderImpl *createShader(GLenum type) = 0;
+
// Shader operations
+ virtual void releaseShaderCompiler() = 0;
virtual ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers) = 0;
diff --git a/src/libGLESv2/renderer/ShaderImpl.h b/src/libGLESv2/renderer/ShaderImpl.h
new file mode 100644
index 0000000..e87d40e
--- /dev/null
+++ b/src/libGLESv2/renderer/ShaderImpl.h
@@ -0,0 +1,29 @@
+//
+// Copyright 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ShaderImpl.h: Defines the abstract rx::ShaderImpl class.
+
+#ifndef LIBGLESV2_RENDERER_SHADERIMPL_H_
+#define LIBGLESV2_RENDERER_SHADERIMPL_H_
+
+#include "common/angleutils.h"
+
+namespace rx
+{
+
+class ShaderImpl
+{
+ public:
+ virtual ~ShaderImpl() { }
+
+ virtual bool compile(const std::string &source) = 0;
+ virtual const std::string &getInfoLog() const = 0;
+ virtual const std::string &getTranslatedSource() const = 0;
+};
+
+}
+
+#endif // LIBGLESV2_RENDERER_SHADERIMPL_H_
diff --git a/src/libGLESv2/renderer/d3d/ShaderD3D.cpp b/src/libGLESv2/renderer/d3d/ShaderD3D.cpp
new file mode 100644
index 0000000..08cc047
--- /dev/null
+++ b/src/libGLESv2/renderer/d3d/ShaderD3D.cpp
@@ -0,0 +1,474 @@
+#include "precompiled.h"
+//
+// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ShaderD3D.cpp: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
+
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
+
+#include "common/utilities.h"
+#include "libGLESv2/Shader.h"
+#include "libGLESv2/renderer/Renderer.h"
+#include "libGLESv2/main.h"
+
+namespace rx
+{
+
+void *ShaderD3D::mFragmentCompiler = NULL;
+void *ShaderD3D::mVertexCompiler = NULL;
+
+template <typename VarT>
+const std::vector<VarT> *GetShaderVariables(const std::vector<VarT> *variableList)
+{
+ // TODO: handle staticUse. for now, assume all returned variables are active.
+ ASSERT(variableList);
+ return variableList;
+}
+
+ShaderD3D::ShaderD3D(rx::Renderer *renderer)
+ : ShaderImpl(),
+ mRenderer(renderer),
+ mShaderVersion(100)
+{
+ uncompile();
+ initializeCompiler();
+}
+
+ShaderD3D::~ShaderD3D()
+{
+}
+
+ShaderD3D *ShaderD3D::makeShaderD3D(ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(ShaderD3D*, impl));
+ return static_cast<ShaderD3D*>(impl);
+}
+
+const ShaderD3D *ShaderD3D::makeShaderD3D(const ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(const ShaderD3D*, impl));
+ return static_cast<const ShaderD3D*>(impl);
+}
+
+// Perform a one-time initialization of the shader compiler (or after being destructed by releaseCompiler)
+void ShaderD3D::initializeCompiler()
+{
+ if (!mFragmentCompiler)
+ {
+ int result = ShInitialize();
+
+ if (result)
+ {
+ ShShaderOutput hlslVersion = (mRenderer->getMajorShaderModel() >= 4) ? SH_HLSL11_OUTPUT : SH_HLSL9_OUTPUT;
+
+ ShBuiltInResources resources;
+ ShInitBuiltInResources(&resources);
+
+ // TODO(geofflang): use context's caps
+ const gl::Caps &caps = mRenderer->getRendererCaps();
+ const gl::Extensions &extensions = mRenderer->getRendererExtensions();
+
+ resources.MaxVertexAttribs = caps.maxVertexAttributes;
+ resources.MaxVertexUniformVectors = caps.maxVertexUniformVectors;
+ resources.MaxVaryingVectors = mRenderer->getMaxVaryingVectors();
+ resources.MaxVertexTextureImageUnits = caps.maxVertexTextureImageUnits;
+ resources.MaxCombinedTextureImageUnits = mRenderer->getMaxCombinedTextureImageUnits();
+ resources.MaxTextureImageUnits = caps.maxTextureImageUnits;
+ resources.MaxFragmentUniformVectors = caps.maxFragmentUniformVectors;
+ resources.MaxDrawBuffers = caps.maxDrawBuffers;
+ resources.OES_standard_derivatives = extensions.standardDerivatives;
+ resources.EXT_draw_buffers = extensions.drawBuffers;
+ resources.EXT_shader_texture_lod = 1;
+ // resources.OES_EGL_image_external = mRenderer->getShareHandleSupport() ? 1 : 0; // TODO: commented out until the extension is actually supported.
+ resources.FragmentPrecisionHigh = 1; // Shader Model 2+ always supports FP24 (s16e7) which corresponds to highp
+ resources.EXT_frag_depth = 1; // Shader Model 2+ always supports explicit depth output
+ // GLSL ES 3.0 constants
+ resources.MaxVertexOutputVectors = caps.maxVertexOutputComponents / 4;
+ resources.MaxFragmentInputVectors = caps.maxFragmentInputComponents / 4;
+ resources.MinProgramTexelOffset = caps.minProgramTexelOffset;
+ resources.MaxProgramTexelOffset = caps.maxProgramTexelOffset;
+
+ mFragmentCompiler = ShConstructCompiler(GL_FRAGMENT_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
+ mVertexCompiler = ShConstructCompiler(GL_VERTEX_SHADER, SH_GLES2_SPEC, hlslVersion, &resources);
+ }
+ }
+}
+
+void ShaderD3D::releaseCompiler()
+{
+ ShDestruct(mFragmentCompiler);
+ ShDestruct(mVertexCompiler);
+
+ mFragmentCompiler = NULL;
+ mVertexCompiler = NULL;
+
+ ShFinalize();
+}
+
+void ShaderD3D::parseVaryings(void *compiler)
+{
+ if (!mHlsl.empty())
+ {
+ const std::vector<sh::Varying> *activeVaryings = ShGetVaryings(compiler);
+ ASSERT(activeVaryings);
+
+ for (size_t varyingIndex = 0; varyingIndex < activeVaryings->size(); varyingIndex++)
+ {
+ mVaryings.push_back(gl::PackedVarying((*activeVaryings)[varyingIndex]));
+ }
+
+ mUsesMultipleRenderTargets = mHlsl.find("GL_USES_MRT") != std::string::npos;
+ mUsesFragColor = mHlsl.find("GL_USES_FRAG_COLOR") != std::string::npos;
+ mUsesFragData = mHlsl.find("GL_USES_FRAG_DATA") != std::string::npos;
+ mUsesFragCoord = mHlsl.find("GL_USES_FRAG_COORD") != std::string::npos;
+ mUsesFrontFacing = mHlsl.find("GL_USES_FRONT_FACING") != std::string::npos;
+ mUsesPointSize = mHlsl.find("GL_USES_POINT_SIZE") != std::string::npos;
+ mUsesPointCoord = mHlsl.find("GL_USES_POINT_COORD") != std::string::npos;
+ mUsesDepthRange = mHlsl.find("GL_USES_DEPTH_RANGE") != std::string::npos;
+ mUsesFragDepth = mHlsl.find("GL_USES_FRAG_DEPTH") != std::string::npos;
+ mUsesDiscardRewriting = mHlsl.find("ANGLE_USES_DISCARD_REWRITING") != std::string::npos;
+ mUsesNestedBreak = mHlsl.find("ANGLE_USES_NESTED_BREAK") != std::string::npos;
+ }
+}
+
+void ShaderD3D::resetVaryingsRegisterAssignment()
+{
+ for (unsigned int varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
+ {
+ mVaryings[varyingIndex].resetRegisterAssignment();
+ }
+}
+
+// initialize/clean up previous state
+void ShaderD3D::uncompile()
+{
+ // set by compileToHLSL
+ mHlsl.clear();
+ mInfoLog.clear();
+
+ // set by parseVaryings
+ mVaryings.clear();
+
+ mUsesMultipleRenderTargets = false;
+ mUsesFragColor = false;
+ mUsesFragData = false;
+ mUsesFragCoord = false;
+ mUsesFrontFacing = false;
+ mUsesPointSize = false;
+ mUsesPointCoord = false;
+ mUsesDepthRange = false;
+ mUsesFragDepth = false;
+ mShaderVersion = 100;
+ mUsesDiscardRewriting = false;
+ mUsesNestedBreak = false;
+
+ mActiveUniforms.clear();
+ mActiveInterfaceBlocks.clear();
+}
+
+void ShaderD3D::compileToHLSL(void *compiler, const std::string &source)
+{
+ // ensure the compiler is loaded
+ initializeCompiler();
+
+ int compileOptions = SH_OBJECT_CODE;
+ std::string sourcePath;
+ if (gl::perfActive())
+ {
+ sourcePath = getTempPath();
+ writeFile(sourcePath.c_str(), source.c_str(), source.length());
+ compileOptions |= SH_LINE_DIRECTIVES;
+ }
+
+ int result;
+ if (sourcePath.empty())
+ {
+ const char* sourceStrings[] =
+ {
+ source.c_str(),
+ };
+
+ result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions);
+ }
+ else
+ {
+ const char* sourceStrings[] =
+ {
+ sourcePath.c_str(),
+ source.c_str(),
+ };
+
+ result = ShCompile(compiler, sourceStrings, ArraySize(sourceStrings), compileOptions | SH_SOURCE_PATH);
+ }
+
+ size_t shaderVersion = 100;
+ ShGetInfo(compiler, SH_SHADER_VERSION, &shaderVersion);
+
+ mShaderVersion = static_cast<int>(shaderVersion);
+
+ if (shaderVersion == 300 && mRenderer->getCurrentClientVersion() < 3)
+ {
+ mInfoLog = "GLSL ES 3.00 is not supported by OpenGL ES 2.0 contexts";
+ TRACE("\n%s", mInfoLog.c_str());
+ }
+ else if (result)
+ {
+ size_t objCodeLen = 0;
+ ShGetInfo(compiler, SH_OBJECT_CODE_LENGTH, &objCodeLen);
+
+ char* outputHLSL = new char[objCodeLen];
+ ShGetObjectCode(compiler, outputHLSL);
+
+#ifdef _DEBUG
+ std::ostringstream hlslStream;
+ hlslStream << "// GLSL\n";
+ hlslStream << "//\n";
+
+ size_t curPos = 0;
+ while (curPos != std::string::npos)
+ {
+ size_t nextLine = source.find("\n", curPos);
+ size_t len = (nextLine == std::string::npos) ? std::string::npos : (nextLine - curPos + 1);
+
+ hlslStream << "// " << source.substr(curPos, len);
+
+ curPos = (nextLine == std::string::npos) ? std::string::npos : (nextLine + 1);
+ }
+ hlslStream << "\n\n";
+ hlslStream << outputHLSL;
+ mHlsl = hlslStream.str();
+#else
+ mHlsl = outputHLSL;
+#endif
+
+ SafeDeleteArray(outputHLSL);
+
+ mActiveUniforms = *GetShaderVariables(ShGetUniforms(compiler));
+
+ for (size_t uniformIndex = 0; uniformIndex < mActiveUniforms.size(); uniformIndex++)
+ {
+ const sh::Uniform &uniform = mActiveUniforms[uniformIndex];
+
+ unsigned int index = -1;
+ bool result = ShGetUniformRegister(compiler, uniform.name.c_str(), &index);
+ UNUSED_ASSERTION_VARIABLE(result);
+ ASSERT(result);
+
+ mUniformRegisterMap[uniform.name] = index;
+ }
+
+ mActiveInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
+
+ for (size_t blockIndex = 0; blockIndex < mActiveInterfaceBlocks.size(); blockIndex++)
+ {
+ const sh::InterfaceBlock &interfaceBlock = mActiveInterfaceBlocks[blockIndex];
+
+ unsigned int index = -1;
+ bool result = ShGetInterfaceBlockRegister(compiler, interfaceBlock.name.c_str(), &index);
+ UNUSED_ASSERTION_VARIABLE(result);
+ ASSERT(result);
+
+ mInterfaceBlockRegisterMap[interfaceBlock.name] = index;
+ }
+ }
+ else
+ {
+ size_t infoLogLen = 0;
+ ShGetInfo(compiler, SH_INFO_LOG_LENGTH, &infoLogLen);
+
+ char* infoLog = new char[infoLogLen];
+ ShGetInfoLog(compiler, infoLog);
+ mInfoLog = infoLog;
+
+ TRACE("\n%s", mInfoLog.c_str());
+ }
+}
+
+rx::D3DWorkaroundType ShaderD3D::getD3DWorkarounds() const
+{
+ if (mUsesDiscardRewriting)
+ {
+ // ANGLE issue 486:
+ // Work-around a D3D9 compiler bug that presents itself when using conditional discard, by disabling optimization
+ return rx::ANGLE_D3D_WORKAROUND_SKIP_OPTIMIZATION;
+ }
+
+ if (mUsesNestedBreak)
+ {
+ // ANGLE issue 603:
+ // Work-around a D3D9 compiler bug that presents itself when using break in a nested loop, by maximizing optimization
+ // We want to keep the use of ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION minimal to prevent hangs, so usesDiscard takes precedence
+ return rx::ANGLE_D3D_WORKAROUND_MAX_OPTIMIZATION;
+ }
+
+ return rx::ANGLE_D3D_WORKAROUND_NONE;
+}
+
+// true if varying x has a higher priority in packing than y
+bool ShaderD3D::compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y)
+{
+ if (x.type == y.type)
+ {
+ return x.arraySize > y.arraySize;
+ }
+
+ // Special case for handling structs: we sort these to the end of the list
+ if (x.type == GL_STRUCT_ANGLEX)
+ {
+ return false;
+ }
+
+ if (y.type == GL_STRUCT_ANGLEX)
+ {
+ return true;
+ }
+
+ return gl::VariableSortOrder(x.type) <= gl::VariableSortOrder(y.type);
+}
+
+unsigned int ShaderD3D::getUniformRegister(const std::string &uniformName) const
+{
+ ASSERT(mUniformRegisterMap.count(uniformName) > 0);
+ return mUniformRegisterMap.find(uniformName)->second;
+}
+
+unsigned int ShaderD3D::getInterfaceBlockRegister(const std::string &blockName) const
+{
+ ASSERT(mInterfaceBlockRegisterMap.count(blockName) > 0);
+ return mInterfaceBlockRegisterMap.find(blockName)->second;
+}
+
+ShShaderOutput ShaderD3D::getCompilerOutputType(GLenum shader)
+{
+ void *compiler = NULL;
+
+ switch (shader)
+ {
+ case GL_VERTEX_SHADER: compiler = mVertexCompiler; break;
+ case GL_FRAGMENT_SHADER: compiler = mFragmentCompiler; break;
+ default: UNREACHABLE(); return SH_HLSL9_OUTPUT;
+ }
+
+ size_t outputType = 0;
+ ShGetInfo(compiler, SH_OUTPUT_TYPE, &outputType);
+
+ return static_cast<ShShaderOutput>(outputType);
+}
+
+VertexShaderD3D::VertexShaderD3D(rx::Renderer *renderer) : ShaderD3D(renderer)
+{
+}
+
+VertexShaderD3D::~VertexShaderD3D()
+{
+}
+
+VertexShaderD3D *VertexShaderD3D::makeVertexShaderD3D(ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(VertexShaderD3D*, impl));
+ return static_cast<VertexShaderD3D*>(impl);
+}
+
+const VertexShaderD3D *VertexShaderD3D::makeVertexShaderD3D(const ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(const VertexShaderD3D*, impl));
+ return static_cast<const VertexShaderD3D*>(impl);
+}
+
+bool VertexShaderD3D::compile(const std::string &source)
+{
+ uncompile();
+
+ compileToHLSL(mVertexCompiler, source);
+ parseAttributes();
+ parseVaryings(mVertexCompiler);
+
+ return !getTranslatedSource().empty();
+}
+
+void VertexShaderD3D::uncompile()
+{
+ ShaderD3D::uncompile();
+
+ // set by ParseAttributes
+ mActiveAttributes.clear();
+}
+
+void VertexShaderD3D::parseAttributes()
+{
+ const std::string &hlsl = getTranslatedSource();
+ if (!hlsl.empty())
+ {
+ mActiveAttributes = *GetShaderVariables(ShGetAttributes(mVertexCompiler));
+ }
+}
+
+int VertexShaderD3D::getSemanticIndex(const std::string &attributeName)
+{
+ if (!attributeName.empty())
+ {
+ int semanticIndex = 0;
+ for (unsigned int attributeIndex = 0; attributeIndex < mActiveAttributes.size(); attributeIndex++)
+ {
+ const sh::ShaderVariable &attribute = mActiveAttributes[attributeIndex];
+
+ if (attribute.name == attributeName)
+ {
+ return semanticIndex;
+ }
+
+ semanticIndex += gl::VariableRegisterCount(attribute.type);
+ }
+ }
+
+ return -1;
+}
+
+FragmentShaderD3D::FragmentShaderD3D(rx::Renderer *renderer) : ShaderD3D(renderer)
+{
+}
+
+FragmentShaderD3D::~FragmentShaderD3D()
+{
+}
+
+FragmentShaderD3D *FragmentShaderD3D::makeFragmentShaderD3D(ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(FragmentShaderD3D*, impl));
+ return static_cast<FragmentShaderD3D*>(impl);
+}
+
+const FragmentShaderD3D *FragmentShaderD3D::makeFragmentShaderD3D(const ShaderImpl *impl)
+{
+ ASSERT(HAS_DYNAMIC_TYPE(const FragmentShaderD3D*, impl));
+ return static_cast<const FragmentShaderD3D*>(impl);
+}
+
+bool FragmentShaderD3D::compile(const std::string &source)
+{
+ uncompile();
+
+ compileToHLSL(mFragmentCompiler, source);
+ parseVaryings(mFragmentCompiler);
+ std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
+
+ const std::string &hlsl = getTranslatedSource();
+ if (!hlsl.empty())
+ {
+ mActiveOutputVariables = *GetShaderVariables(ShGetOutputVariables(mFragmentCompiler));
+ return true;
+ }
+ return false;
+}
+
+void FragmentShaderD3D::uncompile()
+{
+ ShaderD3D::uncompile();
+
+ mActiveOutputVariables.clear();
+}
+
+}
diff --git a/src/libGLESv2/renderer/d3d/ShaderD3D.h b/src/libGLESv2/renderer/d3d/ShaderD3D.h
new file mode 100644
index 0000000..ce856ea
--- /dev/null
+++ b/src/libGLESv2/renderer/d3d/ShaderD3D.h
@@ -0,0 +1,145 @@
+//
+// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ShaderD3D.h: Defines the rx::ShaderD3D class which implements rx::ShaderImpl.
+
+#ifndef LIBGLESV2_RENDERER_SHADERD3D_H_
+#define LIBGLESV2_RENDERER_SHADERD3D_H_
+
+#include "libGLESv2/Shader.h"
+#include "libGLESv2/renderer/ShaderImpl.h"
+
+namespace gl
+{
+class DynamicHLSL;
+}
+
+namespace rx
+{
+class Renderer;
+
+class ShaderD3D : public ShaderImpl
+{
+ friend class gl::DynamicHLSL;
+
+ public:
+ ShaderD3D(rx::Renderer *renderer);
+ virtual ~ShaderD3D();
+
+ static ShaderD3D *makeShaderD3D(ShaderImpl *impl);
+ static const ShaderD3D *makeShaderD3D(const ShaderImpl *impl);
+
+ // ShaderImpl implementation
+ const std::string &getInfoLog() const { return mInfoLog; }
+ const std::string &getTranslatedSource() const { return mHlsl; }
+
+ // D3D-specific methods
+ virtual void uncompile();
+ void resetVaryingsRegisterAssignment();
+ unsigned int getUniformRegister(const std::string &uniformName) const;
+ unsigned int getInterfaceBlockRegister(const std::string &blockName) const;
+
+ rx::D3DWorkaroundType getD3DWorkarounds() const;
+ int getShaderVersion() const { return mShaderVersion; }
+ bool usesDepthRange() const { return mUsesDepthRange; }
+ bool usesPointSize() const { return mUsesPointSize; }
+ std::vector<gl::PackedVarying> &getVaryings() { return mVaryings; }
+ const std::vector<sh::Uniform> &getUniforms() const { return mActiveUniforms; }
+ const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const { return mActiveInterfaceBlocks; }
+
+ static void releaseCompiler();
+ static ShShaderOutput getCompilerOutputType(GLenum shader);
+
+ protected:
+ void compileToHLSL(void *compiler, const std::string &source);
+ void parseVaryings(void *compiler);
+
+ static bool compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y);
+
+ static void *mFragmentCompiler;
+ static void *mVertexCompiler;
+
+ rx::Renderer *mRenderer;
+
+ std::vector<gl::PackedVarying> mVaryings;
+
+ int mShaderVersion;
+
+ bool mUsesMultipleRenderTargets;
+ bool mUsesFragColor;
+ bool mUsesFragData;
+ bool mUsesFragCoord;
+ bool mUsesFrontFacing;
+ bool mUsesPointSize;
+ bool mUsesPointCoord;
+ bool mUsesDepthRange;
+ bool mUsesFragDepth;
+ bool mUsesDiscardRewriting;
+ bool mUsesNestedBreak;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ShaderD3D);
+
+ void initializeCompiler();
+
+ std::string mHlsl;
+ std::string mInfoLog;
+ std::vector<sh::Uniform> mActiveUniforms;
+ std::vector<sh::InterfaceBlock> mActiveInterfaceBlocks;
+ std::map<std::string, unsigned int> mUniformRegisterMap;
+ std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
+};
+
+class VertexShaderD3D : public ShaderD3D
+{
+ friend class gl::DynamicHLSL;
+
+ public:
+ VertexShaderD3D(rx::Renderer *renderer);
+ virtual ~VertexShaderD3D();
+
+ static VertexShaderD3D *makeVertexShaderD3D(ShaderImpl *impl);
+ static const VertexShaderD3D *makeVertexShaderD3D(const ShaderImpl *impl);
+
+ virtual bool compile(const std::string &source);
+ virtual void uncompile();
+
+ int getSemanticIndex(const std::string &attributeName);
+ virtual const std::vector<sh::Attribute> &getActiveAttributes() const { return mActiveAttributes; }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(VertexShaderD3D);
+
+ void parseAttributes();
+
+ std::vector<sh::Attribute> mActiveAttributes;
+};
+
+class FragmentShaderD3D : public ShaderD3D
+{
+ friend class gl::DynamicHLSL;
+
+ public:
+ FragmentShaderD3D(rx::Renderer *renderer);
+ virtual ~FragmentShaderD3D();
+
+ static FragmentShaderD3D *makeFragmentShaderD3D(ShaderImpl *impl);
+ static const FragmentShaderD3D *makeFragmentShaderD3D(const ShaderImpl *impl);
+
+ virtual bool compile(const std::string &source);
+ virtual void uncompile();
+
+ virtual const std::vector<sh::Attribute> &getOutputVariables() const { return mActiveOutputVariables; }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(FragmentShaderD3D);
+
+ std::vector<sh::Attribute> mActiveOutputVariables;
+};
+
+}
+
+#endif // LIBGLESV2_RENDERER_SHADERD3D_H_
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
index 0c94728..f7ad0c7 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp
@@ -13,6 +13,7 @@
#include "libGLESv2/FramebufferAttachment.h"
#include "libGLESv2/ProgramBinary.h"
#include "libGLESv2/Framebuffer.h"
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
#include "libGLESv2/renderer/d3d/TextureD3D.h"
#include "libGLESv2/renderer/d3d/TransformFeedbackD3D.h"
#include "libGLESv2/renderer/d3d/d3d11/Renderer11.h"
@@ -1692,6 +1693,7 @@
void Renderer11::release()
{
+ releaseShaderCompiler();
releaseDeviceResources();
SafeRelease(mDxgiFactory);
@@ -2284,6 +2286,25 @@
return renderTarget;
}
+ShaderImpl *Renderer11::createShader(GLenum type)
+{
+ switch (type)
+ {
+ case GL_VERTEX_SHADER:
+ return new VertexShaderD3D(this);
+ case GL_FRAGMENT_SHADER:
+ return new FragmentShaderD3D(this);
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+void Renderer11::releaseShaderCompiler()
+{
+ ShaderD3D::releaseCompiler();
+}
+
ShaderExecutable *Renderer11::loadExecutable(const void *function, size_t length, rx::ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers)
diff --git a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
index 3288f2b..bbdbc58 100644
--- a/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
+++ b/src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
@@ -145,7 +145,11 @@
virtual RenderTarget *createRenderTarget(SwapChain *swapChain, bool depth);
virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples);
+ // Shader creation
+ virtual ShaderImpl *createShader(GLenum type);
+
// Shader operations
+ virtual void releaseShaderCompiler();
virtual ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers);
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
index 0abe089..1446ee4 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
+++ b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp
@@ -17,6 +17,7 @@
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/ProgramBinary.h"
#include "libGLESv2/renderer/d3d/IndexDataManager.h"
+#include "libGLESv2/renderer/d3d/ShaderD3D.h"
#include "libGLESv2/renderer/d3d/TextureD3D.h"
#include "libGLESv2/renderer/d3d/TransformFeedbackD3D.h"
#include "libGLESv2/renderer/d3d/d3d9/Renderer9.h"
@@ -154,6 +155,7 @@
void Renderer9::release()
{
+ releaseShaderCompiler();
releaseDeviceResources();
SafeRelease(mDevice);
@@ -2785,6 +2787,25 @@
return renderTarget;
}
+ShaderImpl *Renderer9::createShader(GLenum type)
+{
+ switch (type)
+ {
+ case GL_VERTEX_SHADER:
+ return new VertexShaderD3D(this);
+ case GL_FRAGMENT_SHADER:
+ return new FragmentShaderD3D(this);
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+void Renderer9::releaseShaderCompiler()
+{
+ ShaderD3D::releaseCompiler();
+}
+
ShaderExecutable *Renderer9::loadExecutable(const void *function, size_t length, rx::ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers)
diff --git a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
index 2fee522..df7c0b3 100644
--- a/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
+++ b/src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
@@ -147,7 +147,11 @@
virtual RenderTarget *createRenderTarget(SwapChain *swapChain, bool depth);
virtual RenderTarget *createRenderTarget(int width, int height, GLenum format, GLsizei samples);
+ // Shader creation
+ virtual ShaderImpl *createShader(GLenum type);
+
// Shader operations
+ virtual void releaseShaderCompiler();
virtual ShaderExecutable *loadExecutable(const void *function, size_t length, rx::ShaderType type,
const std::vector<gl::LinkedVarying> &transformFeedbackVaryings,
bool separatedOutputBuffers);
