Skip to content

A
angle
Commit 537dfde5 by Brandon Jones
Options

Refactoring Shader objects

This change refactors shaders to no longer be dependent on D3D-only concepts. BUG=angle:731 Change-Id: I4fc1efeba9df4f873b3d7c8ba6f67f00b6532b9c Reviewed-on: https://chromium-review.googlesource.com/213803Reviewed-by: 's avatarBrandon Jones <bajones@chromium.org> Tested-by: 's avatarBrandon Jones <bajones@chromium.org>
parent 549c7fdf
Showing with 860 additions and 586 deletions
projects/src/libGLESv2.vcxproj
......@@ -247,6 +247,7 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\TextureImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\Renderer.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderExecutable.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\loadimage.h"/>
<ClInclude Include="..\..\src\libGLESv2\renderer\copyimage.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"/>
......
projects/src/libGLESv2.vcxproj.filters
......@@ -282,6 +282,9 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\TransformFeedbackImpl.h">
<Filter>src\libGLESv2\renderer</Filter>
</ClInclude>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderImpl.h">
<Filter>src\libGLESv2\renderer</Filter>
</ClInclude>
<ClInclude Include="..\..\src\libGLESv2\renderer\ShaderExecutable.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,9 +411,15 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\VertexBuffer.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
<<<<<<< HEAD
<ClCompile Include="..\..\src\libGLESv2\renderer\d3d\TransformFeedbackD3D.cpp">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClCompile>
=======
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\ShaderD3D.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
>>>>>>> Refactoring Shader objects
<ClInclude Include="..\..\src\libGLESv2\renderer\d3d\BufferD3D.h">
<Filter>src\libGLESv2\renderer\d3d</Filter>
</ClInclude>
......
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',
......
src/libGLESv2/Context.cpp
......@@ -2383,6 +2383,11 @@ void Context::invalidateFrameBuffer(GLenum target, GLsizei numAttachments, const
}
}
void Context::releaseShaderCompiler()
{
mRenderer->releaseShaderCompiler();
}
void Context::initCaps(GLuint clientVersion)
{
mCaps = mRenderer->getRendererCaps();
......
src/libGLESv2/Context.h
......@@ -234,6 +234,8 @@ class Context
State &getState() { return mState; }
const State &getState() const { return mState; }
void releaseShaderCompiler();
private:
DISALLOW_COPY_AND_ASSIGN(Context);
......
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 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, Fragment
{
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 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, Fragment
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 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, Fragment
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::storeBuiltinLinkedVaryings(const SemanticInfo &info,
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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
// 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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
pixelHLSL += PIXEL_OUTPUT_STUB_STRING + "\n";
if (fragmentShader->mUsesFrontFacing)
if (fragmentShaderD3D->mUsesFrontFacing)
{
if (shaderModel >= 4)
{
......@@ -880,7 +891,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
pixelHLSL += " gl_PointCoord.y = 1.0 - input.gl_PointCoord.y;\n";
}
if (fragmentShader->mUsesFrontFacing)
if (fragmentShaderD3D->mUsesFrontFacing)
{
if (shaderModel <= 3)
{
......@@ -892,9 +903,9 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
}
}
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 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
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 @@ void DynamicHLSL::defineOutputVariables(FragmentShader *fragmentShader, std::map
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 @@ std::string DynamicHLSL::generatePointSpriteHLSL(int registers, FragmentShader *
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 @@ std::string DynamicHLSL::generatePointSpriteHLSL(int registers, FragmentShader *
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";
}
......
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::applyUniformBuffers(const std::vector<gl::Buffer*> boundBuff
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 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
mTransformFeedbackBufferMode = transformFeedbackBufferMode;
mShaderVersion = vertexShader->getShaderVersion();
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
mShaderVersion = vertexShaderD3D->getShaderVersion();
mPixelHLSL = fragmentShader->getHLSL();
mPixelWorkarounds = fragmentShader->getD3DWorkarounds();
mPixelHLSL = fragmentShaderD3D->getTranslatedSource();
mPixelWorkarounds = fragmentShaderD3D->getD3DWorkarounds();
mVertexHLSL = vertexShader->getHLSL();
mVertexWorkarounds = vertexShader->getD3DWorkarounds();
mVertexHLSL = vertexShaderD3D->getTranslatedSource();
mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds();
// Map the varyings to the register file
VaryingPacking packing = { NULL };
......@@ -1627,7 +1634,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
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 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
}
// 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 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
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 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
// 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 @@ bool ProgramBinary::linkAttributes(InfoLog &infoLog, const AttributeBindings &at
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::linkValidateInterfaceBlockFields(InfoLog &infoLog, const std
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 @@ bool ProgramBinary::linkUniforms(InfoLog &infoLog, const VertexShader &vertexSha
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 @@ bool ProgramBinary::linkUniforms(InfoLog &infoLog, const VertexShader &vertexSha
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::areMatchingInterfaceBlocks(InfoLog &infoLog, const sh::Inter
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 @@ void ProgramBinary::defineUniformBlockMembers(const std::vector<VarT> &fields, c
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 @@ bool ProgramBinary::defineUniformBlock(InfoLog &infoLog, const Shader &shader, c
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++)
{
......
src/libGLESv2/ResourceManager.cpp
......@@ -95,11 +95,11 @@ GLuint ResourceManager::createShader(GLenum type)
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();
......
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 @@ void Shader::setSource(GLsizei count, const char *const *string, const GLint *le
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 @@ void Shader::getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const
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::getSourceLength() const
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::getSource(GLsizei bufSize, GLsizei *length, char *buffer) const
void Shader::getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const
{
getSourceImpl(mHlsl, bufSize, length, buffer);
}
unsigned int Shader::getUniformRegister(const std::string &uniformName) const
{
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;
getSourceImpl(mShader->getTranslatedSource(), bufSize, length, buffer);
}
const std::vector<sh::Uniform> &Shader::getUniforms() const
void Shader::compile()
{
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 @@ void Shader::flagForDeletion()
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 @@ VertexShader::~VertexShader()
{
}
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 @@ FragmentShader::~FragmentShader()
{
}
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);
}
}
src/libGLESv2/Shader.h
......@@ -25,7 +25,7 @@
namespace rx
{
class Renderer;
class ShaderImpl;
}
namespace gl
......@@ -51,16 +51,17 @@ struct PackedVarying : public sh::Varying
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 @@ class Shader
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;
};
}
......
src/libGLESv2/libGLESv2.cpp
......@@ -3584,7 +3584,12 @@ void __stdcall glReleaseShaderCompiler(void)
{
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)
......
src/libGLESv2/renderer/Renderer.cpp
......@@ -40,7 +40,6 @@ Renderer::Renderer(egl::Display *display)
Renderer::~Renderer()
{
gl::Shader::releaseCompiler();
}
const gl::Caps &Renderer::getRendererCaps() const
......
src/libGLESv2/renderer/Renderer.h
......@@ -53,6 +53,7 @@ class BufferImpl;
class VertexArrayImpl;
class BufferStorage;
struct TranslatedIndexData;
class ShaderImpl;
class ShaderExecutable;
class SwapChain;
class RenderTarget;
......@@ -197,7 +198,11 @@ class Renderer
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;
......
src/libGLESv2/renderer/ShaderImpl.h 0 → 100644
//
// 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_
src/libGLESv2/renderer/d3d/ShaderD3D.cpp 0 → 100644
#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();
}
}
src/libGLESv2/renderer/d3d/ShaderD3D.h 0 → 100644
//
// 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_
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 @@ bool Renderer11::testDeviceResettable()
void Renderer11::release()
{
releaseShaderCompiler();
releaseDeviceResources();
SafeRelease(mDxgiFactory);
......@@ -2284,6 +2286,25 @@ RenderTarget *Renderer11::createRenderTarget(int width, int height, GLenum forma
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)
......
src/libGLESv2/renderer/d3d/d3d11/Renderer11.h
......@@ -145,7 +145,11 @@ class Renderer11 : public Renderer
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);
......
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 @@ Renderer9::~Renderer9()
void Renderer9::release()
{
releaseShaderCompiler();
releaseDeviceResources();
SafeRelease(mDevice);
......@@ -2785,6 +2787,25 @@ RenderTarget *Renderer9::createRenderTarget(int width, int height, GLenum format
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)
......
src/libGLESv2/renderer/d3d/d3d9/Renderer9.h
......@@ -147,7 +147,11 @@ class Renderer9 : public Renderer
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);
......
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