Skip to content

A
angle
Commit 7162096e by Brandon Jones
Options

More shader refactor cleanup

Removed VertexShader and FragmentShader in favor of using a single Shader object Used VertexShaderD3D and FragmentShaderD3D directly when appropriate. BUG=angle:731 Change-Id: Ib1ffdf85ee0bfa7c88bb9ddb1029ccbd63a9dbe1 Reviewed-on: https://chromium-review.googlesource.com/213840Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Tested-by: 's avatarBrandon Jones <bajones@chromium.org>
parent e3929050
Showing with 77 additions and 136 deletions
src/libGLESv2/DynamicHLSL.cpp
......@@ -206,22 +206,19 @@ static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, Var
// Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
// Returns the number of used varying registers, or -1 if unsuccesful
int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, FragmentShader *fragmentShader,
VertexShader *vertexShader, const std::vector<std::string>& transformFeedbackVaryings)
int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::FragmentShaderD3D *fragmentShader,
rx::VertexShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings)
{
const int maxVaryingVectors = mRenderer->getMaxVaryingVectors();
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
vertexShaderD3D->resetVaryingsRegisterAssignment();
fragmentShaderD3D->resetVaryingsRegisterAssignment();
vertexShader->resetVaryingsRegisterAssignment();
fragmentShader->resetVaryingsRegisterAssignment();
std::set<std::string> packedVaryings;
for (unsigned int varyingIndex = 0; varyingIndex < fragmentShaderD3D->mVaryings.size(); varyingIndex++)
for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
{
PackedVarying *varying = &fragmentShaderD3D->mVaryings[varyingIndex];
PackedVarying *varying = &fragmentShader->mVaryings[varyingIndex];
if (packVarying(varying, maxVaryingVectors, packing))
{
packedVaryings.insert(varying->name);
......@@ -239,9 +236,9 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, Fragment
if (packedVaryings.find(transformFeedbackVarying) == packedVaryings.end())
{
bool found = false;
for (unsigned int varyingIndex = 0; varyingIndex < vertexShaderD3D->mVaryings.size(); varyingIndex++)
for (unsigned int varyingIndex = 0; varyingIndex < vertexShader->mVaryings.size(); varyingIndex++)
{
PackedVarying *varying = &vertexShaderD3D->mVaryings[varyingIndex];
PackedVarying *varying = &vertexShader->mVaryings[varyingIndex];
if (transformFeedbackVarying == varying->name)
{
if (!packVarying(varying, maxVaryingVectors, packing))
......@@ -277,16 +274,14 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, Fragment
return registers;
}
std::string DynamicHLSL::generateVaryingHLSL(VertexShader *shader) const
std::string DynamicHLSL::generateVaryingHLSL(rx::VertexShaderD3D *shader) const
{
rx::VertexShaderD3D *shaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(shader->getImplementation());
std::string varyingSemantic = getVaryingSemantic(shaderD3D->mUsesPointSize);
std::string varyingSemantic = getVaryingSemantic(shader->mUsesPointSize);
std::string varyingHLSL;
for (unsigned int varyingIndex = 0; varyingIndex < shaderD3D->mVaryings.size(); varyingIndex++)
for (unsigned int varyingIndex = 0; varyingIndex < shader->mVaryings.size(); varyingIndex++)
{
const PackedVarying &varying = shaderD3D->mVaryings[varyingIndex];
const PackedVarying &varying = shader->mVaryings[varyingIndex];
if (varying.registerAssigned())
{
GLenum transposedType = TransposeMatrixType(varying.type);
......@@ -607,13 +602,11 @@ void DynamicHLSL::storeBuiltinLinkedVaryings(const SemanticInfo &info,
}
}
void DynamicHLSL::storeUserLinkedVaryings(const VertexShader *vertexShader,
void DynamicHLSL::storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShader,
std::vector<LinkedVarying> *linkedVaryings) const
{
const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
const std::string &varyingSemantic = getVaryingSemantic(vertexShaderD3D->mUsesPointSize);
const std::vector<PackedVarying> &varyings = vertexShaderD3D->mVaryings;
const std::string &varyingSemantic = getVaryingSemantic(vertexShader->mUsesPointSize);
const std::vector<PackedVarying> &varyings = vertexShader->mVaryings;
for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
{
......@@ -632,7 +625,7 @@ void DynamicHLSL::storeUserLinkedVaryings(const VertexShader *vertexShader,
bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const VaryingPacking packing,
std::string& pixelHLSL, std::string& vertexHLSL,
FragmentShader *fragmentShader, VertexShader *vertexShader,
rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader,
const std::vector<std::string>& transformFeedbackVaryings,
std::vector<LinkedVarying> *linkedVaryings,
std::map<int, VariableLocation> *programOutputVars,
......@@ -644,15 +637,12 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
return false;
}
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;
bool usesMRT = fragmentShader->mUsesMultipleRenderTargets;
bool usesFragColor = fragmentShader->mUsesFragColor;
bool usesFragData = fragmentShader->mUsesFragData;
bool usesFragCoord = fragmentShader->mUsesFragCoord;
bool usesPointCoord = fragmentShader->mUsesPointCoord;
bool usesPointSize = vertexShader->mUsesPointSize;
if (usesFragColor && usesFragData)
{
......@@ -669,10 +659,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 = (fragmentShaderD3D->mUsesFragColor && mRenderer->getCurrentClientVersion() < 3);
const bool broadcast = (fragmentShader->mUsesFragColor && mRenderer->getCurrentClientVersion() < 3);
const unsigned int numRenderTargets = (broadcast || usesMRT ? mRenderer->getRendererCaps().maxDrawBuffers : 1);
int shaderVersion = vertexShaderD3D->getShaderVersion();
int shaderVersion = vertexShader->getShaderVersion();
if (registersNeeded > maxVaryingVectors)
{
......@@ -729,9 +719,9 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
vertexHLSL += " output.gl_FragCoord = gl_Position;\n";
}
for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexShaderD3D->mVaryings.size(); vertVaryingIndex++)
for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexShader->mVaryings.size(); vertVaryingIndex++)
{
const PackedVarying &varying = vertexShaderD3D->mVaryings[vertVaryingIndex];
const PackedVarying &varying = vertexShader->mVaryings[vertVaryingIndex];
if (varying.registerAssigned())
{
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
......@@ -813,13 +803,13 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
outPixelShaderKey->push_back(outputKeyVariable);
}
*outUsesFragDepth = fragmentShaderD3D->mUsesFragDepth;
*outUsesFragDepth = fragmentShader->mUsesFragDepth;
}
else
{
defineOutputVariables(fragmentShader, programOutputVars);
const std::vector<sh::Attribute> &shaderOutputVars = fragmentShaderD3D->getOutputVariables();
const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
for (auto locationIt = programOutputVars->begin(); locationIt != programOutputVars->end(); locationIt++)
{
const VariableLocation &outputLocation = locationIt->second;
......@@ -841,7 +831,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
pixelHLSL += PIXEL_OUTPUT_STUB_STRING + "\n";
if (fragmentShaderD3D->mUsesFrontFacing)
if (fragmentShader->mUsesFrontFacing)
{
if (shaderModel >= 4)
{
......@@ -891,7 +881,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
pixelHLSL += " gl_PointCoord.y = 1.0 - input.gl_PointCoord.y;\n";
}
if (fragmentShaderD3D->mUsesFrontFacing)
if (fragmentShader->mUsesFrontFacing)
{
if (shaderModel <= 3)
{
......@@ -903,9 +893,9 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
}
}
for (unsigned int varyingIndex = 0; varyingIndex < fragmentShaderD3D->mVaryings.size(); varyingIndex++)
for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
{
const PackedVarying &varying = fragmentShaderD3D->mVaryings[varyingIndex];
const PackedVarying &varying = fragmentShader->mVaryings[varyingIndex];
if (varying.registerAssigned())
{
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
......@@ -957,10 +947,9 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
return true;
}
void DynamicHLSL::defineOutputVariables(FragmentShader *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
void DynamicHLSL::defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
{
rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
const std::vector<sh::Attribute> &shaderOutputVars = fragmentShaderD3D->getOutputVariables();
const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
for (unsigned int outputVariableIndex = 0; outputVariableIndex < shaderOutputVars.size(); outputVariableIndex++)
{
......@@ -984,28 +973,25 @@ void DynamicHLSL::defineOutputVariables(FragmentShader *fragmentShader, std::map
}
}
std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const
std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const
{
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
// for now we only handle point sprite emulation
ASSERT(vertexShaderD3D->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
ASSERT(vertexShader->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
return generatePointSpriteHLSL(registers, fragmentShader, vertexShader);
}
std::string DynamicHLSL::generatePointSpriteHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const
std::string DynamicHLSL::generatePointSpriteHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const
{
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
ASSERT(registers >= 0);
ASSERT(vertexShaderD3D->mUsesPointSize);
ASSERT(vertexShader->mUsesPointSize);
ASSERT(mRenderer->getMajorShaderModel() >= 4);
std::string geomHLSL;
const SemanticInfo &inSemantics = getSemanticInfo(registers, fragmentShaderD3D->mUsesFragCoord,
const SemanticInfo &inSemantics = getSemanticInfo(registers, fragmentShader->mUsesFragCoord,
false, true, false);
const SemanticInfo &outSemantics = getSemanticInfo(registers, fragmentShaderD3D->mUsesFragCoord,
fragmentShaderD3D->mUsesPointCoord, true, false);
const SemanticInfo &outSemantics = getSemanticInfo(registers, fragmentShader->mUsesFragCoord,
fragmentShader->mUsesPointCoord, true, false);
std::string varyingHLSL = generateVaryingHLSL(vertexShader);
std::string inLinkHLSL = generateVaryingLinkHLSL(inSemantics, varyingHLSL);
......@@ -1048,7 +1034,7 @@ std::string DynamicHLSL::generatePointSpriteHLSL(int registers, FragmentShader *
geomHLSL += " output.v" + Str(r) + " = input[0].v" + Str(r) + ";\n";
}
if (fragmentShaderD3D->mUsesFragCoord)
if (fragmentShader->mUsesFragCoord)
{
geomHLSL += " output.gl_FragCoord = input[0].gl_FragCoord;\n";
}
......@@ -1063,7 +1049,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 (fragmentShaderD3D->mUsesPointCoord)
if (fragmentShader->mUsesPointCoord)
{
geomHLSL += " output.gl_PointCoord = pointSpriteTexcoords[" + Str(corner) + "];\n";
}
......
src/libGLESv2/DynamicHLSL.h
......@@ -15,6 +15,9 @@
namespace rx
{
class Renderer;
class ShaderD3D;
class VertexShaderD3D;
class FragmentShaderD3D;
}
namespace sh
......@@ -27,8 +30,6 @@ namespace gl
{
class InfoLog;
class FragmentShader;
class VertexShader;
struct VariableLocation;
struct LinkedVarying;
struct VertexAttribute;
......@@ -50,22 +51,22 @@ class DynamicHLSL
public:
explicit DynamicHLSL(rx::Renderer *const renderer);
int packVaryings(InfoLog &infoLog, VaryingPacking packing, FragmentShader *fragmentShader,
VertexShader *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
int packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::FragmentShaderD3D *fragmentShader,
rx::VertexShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
std::string generateVertexShaderForInputLayout(const std::string &sourceShader, const VertexFormat inputLayout[],
const sh::Attribute shaderAttributes[]) const;
std::string generatePixelShaderForOutputSignature(const std::string &sourceShader, const std::vector<PixelShaderOuputVariable> &outputVariables,
bool usesFragDepth, const std::vector<GLenum> &outputLayout) const;
bool generateShaderLinkHLSL(InfoLog &infoLog, int registers, const VaryingPacking packing,
std::string& pixelHLSL, std::string& vertexHLSL,
FragmentShader *fragmentShader, VertexShader *vertexShader,
rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader,
const std::vector<std::string>& transformFeedbackVaryings,
std::vector<LinkedVarying> *linkedVaryings,
std::map<int, VariableLocation> *programOutputVars,
std::vector<PixelShaderOuputVariable> *outPixelShaderKey,
bool *outUsesFragDepth) const;
std::string generateGeometryShaderHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const;
std::string generateGeometryShaderHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const;
void getInputLayoutSignature(const VertexFormat inputLayout[], GLenum signature[]) const;
private:
......@@ -79,11 +80,11 @@ class DynamicHLSL
SemanticInfo getSemanticInfo(int startRegisters, bool fragCoord, bool pointCoord, bool pointSize,
bool pixelShader) const;
std::string generateVaryingLinkHLSL(const SemanticInfo &info, const std::string &varyingHLSL) const;
std::string generateVaryingHLSL(VertexShader *shader) const;
void storeUserLinkedVaryings(const VertexShader *vertexShader, std::vector<LinkedVarying> *linkedVaryings) const;
std::string generateVaryingHLSL(rx::VertexShaderD3D *shader) const;
void storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShader, std::vector<LinkedVarying> *linkedVaryings) const;
void storeBuiltinLinkedVaryings(const SemanticInfo &info, std::vector<LinkedVarying> *linkedVaryings) const;
void defineOutputVariables(FragmentShader *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const;
std::string generatePointSpriteHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const;
void defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const;
std::string generatePointSpriteHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const;
// Prepend an underscore
static std::string decorateVariable(const std::string &name);
......
src/libGLESv2/Program.cpp
......@@ -173,7 +173,7 @@ bool Program::attachShader(Shader *shader)
return false;
}
mVertexShader = (VertexShader*)shader;
mVertexShader = shader;
mVertexShader->addRef();
}
else if (shader->getType() == GL_FRAGMENT_SHADER)
......@@ -183,7 +183,7 @@ bool Program::attachShader(Shader *shader)
return false;
}
mFragmentShader = (FragmentShader*)shader;
mFragmentShader = shader;
mFragmentShader->addRef();
}
else UNREACHABLE();
......
src/libGLESv2/Program.h
......@@ -26,8 +26,6 @@ class Renderer;
namespace gl
{
class ResourceManager;
class FragmentShader;
class VertexShader;
class Shader;
extern const char * const g_fakepath;
......@@ -121,8 +119,8 @@ class Program
void unlink(bool destroy = false);
void resetUniformBlockBindings();
FragmentShader *mFragmentShader;
VertexShader *mVertexShader;
Shader *mFragmentShader;
Shader *mVertexShader;
AttributeBindings mAttributeBindings;
......
src/libGLESv2/ProgramBinary.cpp
......@@ -1061,7 +1061,7 @@ bool ProgramBinary::applyUniformBuffers(const std::vector<gl::Buffer*> boundBuff
return mRenderer->setUniformBuffers(vertexUniformBuffers, fragmentUniformBuffers);
}
bool ProgramBinary::linkVaryings(InfoLog &infoLog, FragmentShader *fragmentShader, VertexShader *vertexShader)
bool ProgramBinary::linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader)
{
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
......@@ -1602,18 +1602,20 @@ GLint ProgramBinary::getLength()
}
}
bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBindings, FragmentShader *fragmentShader, VertexShader *vertexShader,
bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBindings, Shader *fragmentShader, Shader *vertexShader,
const std::vector<std::string>& transformFeedbackVaryings, GLenum transformFeedbackBufferMode)
{
if (!fragmentShader || !fragmentShader->isCompiled())
{
return false;
}
ASSERT(fragmentShader->getType() == GL_FRAGMENT_SHADER);
if (!vertexShader || !vertexShader->isCompiled())
{
return false;
}
ASSERT(vertexShader->getType() == GL_VERTEX_SHADER);
reset();
......@@ -1632,7 +1634,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
// Map the varyings to the register file
VaryingPacking packing = { NULL };
int registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShader, vertexShader, transformFeedbackVaryings);
int registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings);
if (registers < 0)
{
......@@ -1647,7 +1649,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
mUsesPointSize = vertexShaderD3D->usesPointSize();
std::vector<LinkedVarying> linkedVaryings;
if (!mDynamicHLSL->generateShaderLinkHLSL(infoLog, registers, packing, mPixelHLSL, mVertexHLSL,
fragmentShader, vertexShader, transformFeedbackVaryings,
fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings,
&linkedVaryings, &mOutputVariables, &mPixelShaderKey, &mUsesFragDepth))
{
return false;
......@@ -1701,7 +1703,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
if (usesGeometryShader())
{
std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShader, vertexShader);
std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShaderD3D, vertexShaderD3D);
mGeometryExecutable = mRenderer->compileToExecutable(infoLog, geometryHLSL.c_str(), rx::SHADER_GEOMETRY,
mTransformFeedbackLinkedVaryings,
(mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS),
......@@ -1720,7 +1722,7 @@ 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)
bool ProgramBinary::linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, Shader *fragmentShader, Shader *vertexShader)
{
rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
......@@ -1898,7 +1900,7 @@ bool ProgramBinary::linkValidateInterfaceBlockFields(InfoLog &infoLog, const std
return true;
}
bool ProgramBinary::linkUniforms(InfoLog &infoLog, const VertexShader &vertexShader, const FragmentShader &fragmentShader)
bool ProgramBinary::linkUniforms(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader)
{
const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader.getImplementation());
const rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader.getImplementation());
......@@ -2171,8 +2173,7 @@ bool ProgramBinary::areMatchingInterfaceBlocks(InfoLog &infoLog, const sh::Inter
return true;
}
bool ProgramBinary::linkUniformBlocks(InfoLog &infoLog, const VertexShader &vertexShader,
const FragmentShader &fragmentShader)
bool ProgramBinary::linkUniformBlocks(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader)
{
const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader.getImplementation());
const rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader.getImplementation());
......
src/libGLESv2/ProgramBinary.h
......@@ -39,8 +39,7 @@ class UniformStorage;
namespace gl
{
class FragmentShader;
class VertexShader;
class Shader;
class InfoLog;
class AttributeBindings;
class Buffer;
......@@ -137,7 +136,7 @@ class ProgramBinary : public RefCountObject
bool save(GLenum *binaryFormat, void *binary, GLsizei bufSize, GLsizei *length);
GLint getLength();
bool link(InfoLog &infoLog, const AttributeBindings &attributeBindings, FragmentShader *fragmentShader, VertexShader *vertexShader,
bool link(InfoLog &infoLog, const AttributeBindings &attributeBindings, Shader *fragmentShader, Shader *vertexShader,
const std::vector<std::string>& transformFeedbackVaryings, GLenum transformFeedbackBufferMode);
void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders);
......@@ -194,8 +193,8 @@ class ProgramBinary : public RefCountObject
void reset();
bool linkVaryings(InfoLog &infoLog, FragmentShader *fragmentShader, VertexShader *vertexShader);
bool linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, FragmentShader *fragmentShader, VertexShader *vertexShader);
bool linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader);
bool linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, Shader *fragmentShader, Shader *vertexShader);
bool linkValidateVariablesBase(InfoLog &infoLog,
const std::string &variableName,
......@@ -206,7 +205,7 @@ class ProgramBinary : public RefCountObject
bool linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform);
bool linkValidateVaryings(InfoLog &infoLog, const std::string &varyingName, const sh::Varying &vertexVarying, const sh::Varying &fragmentVarying);
bool linkValidateInterfaceBlockFields(InfoLog &infoLog, const std::string &uniformName, const sh::InterfaceBlockField &vertexUniform, const sh::InterfaceBlockField &fragmentUniform);
bool linkUniforms(InfoLog &infoLog, const VertexShader &vertexShader, const FragmentShader &fragmentShader);
bool linkUniforms(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader);
void defineUniformBase(GLenum shader, const sh::Uniform &uniform, unsigned int uniformRegister);
void defineUniform(GLenum shader, const sh::ShaderVariable &uniform, const std::string &fullName, sh::HLSLBlockEncoder *encoder);
bool indexSamplerUniform(const LinkedUniform &uniform, InfoLog &infoLog);
......@@ -214,7 +213,7 @@ class ProgramBinary : public RefCountObject
static bool assignSamplers(unsigned int startSamplerIndex, GLenum samplerType, unsigned int samplerCount,
Sampler *outArray, GLuint *usedRange, unsigned int limit);
bool areMatchingInterfaceBlocks(InfoLog &infoLog, const sh::InterfaceBlock &vertexInterfaceBlock, const sh::InterfaceBlock &fragmentInterfaceBlock);
bool linkUniformBlocks(InfoLog &infoLog, const VertexShader &vertexShader, const FragmentShader &fragmentShader);
bool linkUniformBlocks(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader);
bool gatherTransformFeedbackLinkedVaryings(InfoLog &infoLog, const std::vector<LinkedVarying> &linkedVaryings,
const std::vector<std::string> &transformFeedbackVaryingNames,
GLenum transformFeedbackBufferMode,
......@@ -225,7 +224,7 @@ class ProgramBinary : public RefCountObject
bool inRowMajorLayout);
bool defineUniformBlock(InfoLog &infoLog, const Shader &shader, const sh::InterfaceBlock &interfaceBlock);
bool assignUniformBlockRegister(InfoLog &infoLog, UniformBlock *uniformBlock, GLenum shader, unsigned int registerIndex);
void defineOutputVariables(FragmentShader *fragmentShader);
void defineOutputVariables(Shader *fragmentShader);
void initializeUniformStorage();
template <typename T>
......
src/libGLESv2/ResourceManager.cpp
......@@ -93,13 +93,9 @@ GLuint ResourceManager::createShader(GLenum type)
{
GLuint handle = mProgramShaderHandleAllocator.allocate();
if (type == GL_VERTEX_SHADER)
if (type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER)
{
mShaderMap[handle] = new VertexShader(this, mRenderer->createShader(type), handle);
}
else if (type == GL_FRAGMENT_SHADER)
{
mShaderMap[handle] = new FragmentShader(this, mRenderer->createShader(type), handle);
mShaderMap[handle] = new Shader(this, mRenderer->createShader(type), type, handle);
}
else UNREACHABLE();
......
src/libGLESv2/Shader.cpp
......@@ -149,22 +149,4 @@ void Shader::flagForDeletion()
mDeleteStatus = true;
}
VertexShader::VertexShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle)
: Shader(manager, impl, GL_VERTEX_SHADER, handle)
{
}
VertexShader::~VertexShader()
{
}
FragmentShader::FragmentShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle)
: Shader(manager, impl, GL_FRAGMENT_SHADER, handle)
{
}
FragmentShader::~FragmentShader()
{
}
}
src/libGLESv2/Shader.h
......@@ -96,28 +96,6 @@ class Shader
ResourceManager *mResourceManager;
};
// TODO: These are now stubs. We should remove them and use Shader exclusively.
class VertexShader : public Shader
{
public:
VertexShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle);
~VertexShader();
private:
DISALLOW_COPY_AND_ASSIGN(VertexShader);
};
class FragmentShader : public Shader
{
public:
FragmentShader(ResourceManager *manager, rx::ShaderImpl *impl, GLuint handle);
~FragmentShader();
private:
DISALLOW_COPY_AND_ASSIGN(FragmentShader);
};
}
#endif // LIBGLESV2_SHADER_H_
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