Compact the D3D shader specializations into one.

src/libGLESv2/ProgramBinary.cpp

@@ -1615,8 +1615,8 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
 
     mTransformFeedbackBufferMode = transformFeedbackBufferMode;
 
-    rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
-    rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader->getImplementation());
+    rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
+    rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
 
     mShaderVersion = vertexShaderD3D->getShaderVersion();
 
@@ -1718,7 +1718,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, const Shader *vertexShader)
 {
-    const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader->getImplementation());
+    const rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
 
     unsigned int usedLocations = 0;
     const std::vector<sh::Attribute> &activeAttributes = vertexShader->getActiveAttributes();
@@ -1896,8 +1896,8 @@ bool ProgramBinary::linkValidateInterfaceBlockFields(InfoLog &infoLog, const std
 
 bool ProgramBinary::linkUniforms(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader, const Caps &caps)
 {
-    const rx::VertexShaderD3D *vertexShaderD3D = rx::VertexShaderD3D::makeVertexShaderD3D(vertexShader.getImplementation());
-    const rx::FragmentShaderD3D *fragmentShaderD3D = rx::FragmentShaderD3D::makeFragmentShaderD3D(fragmentShader.getImplementation());
+    const rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader.getImplementation());
+    const rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader.getImplementation());
 
     const std::vector<sh::Uniform> &vertexUniforms = vertexShader.getUniforms();
     const std::vector<sh::Uniform> &fragmentUniforms = fragmentShader.getUniforms();

src/libGLESv2/renderer/ShaderImpl.h

@@ -20,6 +20,7 @@ namespace rx
 class ShaderImpl
 {
   public:
+    ShaderImpl() { }
     virtual ~ShaderImpl() { }
 
     virtual bool compile(const std::string &source) = 0;
@@ -39,6 +40,8 @@ class ShaderImpl
     std::vector<sh::Attribute> &getActiveOutputVariables() { return mActiveOutputVariables; }
 
   protected:
+    DISALLOW_COPY_AND_ASSIGN(ShaderImpl);
+
     std::vector<gl::PackedVarying> mVaryings;
     std::vector<sh::Uniform> mUniforms;
     std::vector<sh::InterfaceBlock> mInterfaceBlocks;

src/libGLESv2/renderer/d3d/DynamicHLSL.cpp

@@ -207,8 +207,8 @@ 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, rx::FragmentShaderD3D *fragmentShader,
-                              rx::VertexShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings)
+int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::ShaderD3D *fragmentShader,
+                              rx::ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings)
 {
     // TODO (geofflang):  Use context's caps
     const int maxVaryingVectors = mRenderer->getRendererCaps().maxVaryingVectors;
@@ -278,7 +278,7 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::Frag
     return registers;
 }
 
-std::string DynamicHLSL::generateVaryingHLSL(rx::VertexShaderD3D *shader) const
+std::string DynamicHLSL::generateVaryingHLSL(rx::ShaderD3D *shader) const
 {
     std::string varyingSemantic = getVaryingSemantic(shader->mUsesPointSize);
     std::string varyingHLSL;
@@ -607,7 +607,7 @@ void DynamicHLSL::storeBuiltinLinkedVaryings(const SemanticInfo &info,
     }
 }
 
-void DynamicHLSL::storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShader,
+void DynamicHLSL::storeUserLinkedVaryings(const rx::ShaderD3D *vertexShader,
                                           std::vector<LinkedVarying> *linkedVaryings) const
 {
     const std::string &varyingSemantic = getVaryingSemantic(vertexShader->mUsesPointSize);
@@ -630,7 +630,7 @@ void DynamicHLSL::storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShade
 
 bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const VaryingPacking packing,
                                          std::string& pixelHLSL, std::string& vertexHLSL,
-                                         rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader,
+                                         rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader,
                                          const std::vector<std::string>& transformFeedbackVaryings,
                                          std::vector<LinkedVarying> *linkedVaryings,
                                          std::map<int, VariableLocation> *programOutputVars,
@@ -956,7 +956,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
     return true;
 }
 
-void DynamicHLSL::defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
+void DynamicHLSL::defineOutputVariables(rx::ShaderD3D *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
 {
     const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getActiveOutputVariables();
 
@@ -982,14 +982,14 @@ void DynamicHLSL::defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, s
     }
 }
 
-std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const
+std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const
 {
     // for now we only handle point sprite emulation
     ASSERT(vertexShader->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
     return generatePointSpriteHLSL(registers, fragmentShader, vertexShader);
 }
 
-std::string DynamicHLSL::generatePointSpriteHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const
+std::string DynamicHLSL::generatePointSpriteHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const
 {
     ASSERT(registers >= 0);
     ASSERT(vertexShader->mUsesPointSize);

src/libGLESv2/renderer/d3d/DynamicHLSL.h

@@ -42,8 +42,6 @@ namespace rx
 {
 class Renderer;
 class ShaderD3D;
-class VertexShaderD3D;
-class FragmentShaderD3D;
 
 typedef const gl::PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
 
@@ -60,22 +58,22 @@ class DynamicHLSL
   public:
     explicit DynamicHLSL(rx::Renderer *const renderer);
 
-    int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, rx::FragmentShaderD3D *fragmentShader,
-                     rx::VertexShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
+    int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, rx::ShaderD3D *fragmentShader,
+                     rx::ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
     std::string generateVertexShaderForInputLayout(const std::string &sourceShader, const gl::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(gl::InfoLog &infoLog, int registers, const VaryingPacking packing,
                                 std::string& pixelHLSL, std::string& vertexHLSL,
-                                rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader,
+                                rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader,
                                 const std::vector<std::string>& transformFeedbackVaryings,
                                 std::vector<gl::LinkedVarying> *linkedVaryings,
                                 std::map<int, gl::VariableLocation> *programOutputVars,
                                 std::vector<PixelShaderOuputVariable> *outPixelShaderKey,
                                 bool *outUsesFragDepth) const;
 
-    std::string generateGeometryShaderHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const;
+    std::string generateGeometryShaderHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const;
     void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const;
 
   private:
@@ -89,11 +87,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(rx::VertexShaderD3D *shader) const;
-    void storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShader, std::vector<gl::LinkedVarying> *linkedVaryings) const;
+    std::string generateVaryingHLSL(rx::ShaderD3D *shader) const;
+    void storeUserLinkedVaryings(const rx::ShaderD3D *vertexShader, std::vector<gl::LinkedVarying> *linkedVaryings) const;
     void storeBuiltinLinkedVaryings(const SemanticInfo &info, std::vector<gl::LinkedVarying> *linkedVaryings) const;
-    void defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, std::map<int, gl::VariableLocation> *programOutputVars) const;
-    std::string generatePointSpriteHLSL(int registers, rx::FragmentShaderD3D *fragmentShader, rx::VertexShaderD3D *vertexShader) const;
+    void defineOutputVariables(rx::ShaderD3D *fragmentShader, std::map<int, gl::VariableLocation> *programOutputVars) const;
+    std::string generatePointSpriteHLSL(int registers, rx::ShaderD3D *fragmentShader, rx::ShaderD3D *vertexShader) const;
 
     // Prepend an underscore
     static std::string decorateVariable(const std::string &name);

src/libGLESv2/renderer/d3d/ShaderD3D.cpp

@@ -27,8 +27,8 @@ const std::vector<VarT> *GetShaderVariables(const std::vector<VarT> *variableLis
     return variableList;
 }
 
-ShaderD3D::ShaderD3D(rx::Renderer *renderer)
-    : ShaderImpl(),
+ShaderD3D::ShaderD3D(GLenum type, rx::Renderer *renderer)
+    : mType(type),
       mRenderer(renderer),
       mShaderVersion(100)
 {
@@ -340,15 +340,28 @@ unsigned int ShaderD3D::getInterfaceBlockRegister(const std::string &blockName)
     return mInterfaceBlockRegisterMap.find(blockName)->second;
 }
 
+void *ShaderD3D::getCompiler()
+{
+    if (mType == GL_VERTEX_SHADER)
+    {
+        return mVertexCompiler;
+    }
+    else
+    {
+        ASSERT(mType == GL_FRAGMENT_SHADER);
+        return mFragmentCompiler;
+    }
+}
+
 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;
+      case GL_VERTEX_SHADER:   compiler = mVertexCompiler;   break;
+      case GL_FRAGMENT_SHADER: compiler = mFragmentCompiler; break;
+      default: UNREACHABLE();  return SH_HLSL9_OUTPUT;
     }
 
     size_t outputType = 0;
@@ -357,47 +370,45 @@ ShShaderOutput ShaderD3D::getCompilerOutputType(GLenum shader)
     return static_cast<ShShaderOutput>(outputType);
 }
 
-VertexShaderD3D::VertexShaderD3D(rx::Renderer *renderer) : ShaderD3D(renderer)
+bool ShaderD3D::compile(const std::string &source)
 {
-}
+    uncompile();
 
-VertexShaderD3D::~VertexShaderD3D()
-{
-}
+    void *compiler = getCompiler();
 
-VertexShaderD3D *VertexShaderD3D::makeVertexShaderD3D(ShaderImpl *impl)
-{
-    ASSERT(HAS_DYNAMIC_TYPE(VertexShaderD3D*, impl));
-    return static_cast<VertexShaderD3D*>(impl);
-}
+    compileToHLSL(compiler, source);
 
-const VertexShaderD3D *VertexShaderD3D::makeVertexShaderD3D(const ShaderImpl *impl)
-{
-    ASSERT(HAS_DYNAMIC_TYPE(const VertexShaderD3D*, impl));
-    return static_cast<const VertexShaderD3D*>(impl);
-}
+    if (mType == GL_VERTEX_SHADER)
+    {
+        parseAttributes(compiler);
+    }
 
-bool VertexShaderD3D::compile(const std::string &source)
-{
-    uncompile();
+    parseVaryings(compiler);
+
+    if (mType == GL_FRAGMENT_SHADER)
+    {
+        std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
 
-    compileToHLSL(mVertexCompiler, source);
-    parseAttributes();
-    parseVaryings(mVertexCompiler);
+        const std::string &hlsl = getTranslatedSource();
+        if (!hlsl.empty())
+        {
+            mActiveOutputVariables = *GetShaderVariables(ShGetOutputVariables(compiler));
+        }
+    }
 
     return !getTranslatedSource().empty();
 }
 
-void VertexShaderD3D::parseAttributes()
+void ShaderD3D::parseAttributes(void *compiler)
 {
     const std::string &hlsl = getTranslatedSource();
     if (!hlsl.empty())
     {
-        mActiveAttributes = *GetShaderVariables(ShGetAttributes(mVertexCompiler));
+        mActiveAttributes = *GetShaderVariables(ShGetAttributes(compiler));
     }
 }
 
-int VertexShaderD3D::getSemanticIndex(const std::string &attributeName) const
+int ShaderD3D::getSemanticIndex(const std::string &attributeName) const
 {
     if (!attributeName.empty())
     {
@@ -418,42 +429,4 @@ int VertexShaderD3D::getSemanticIndex(const std::string &attributeName) const
     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;
-}
-
 }

src/libGLESv2/renderer/d3d/ShaderD3D.h

@@ -23,7 +23,7 @@ class ShaderD3D : public ShaderImpl
     friend class DynamicHLSL;
 
   public:
-    ShaderD3D(rx::Renderer *renderer);
+    ShaderD3D(GLenum type, rx::Renderer *renderer);
     virtual ~ShaderD3D();
 
     static ShaderD3D *makeShaderD3D(ShaderImpl *impl);
@@ -38,6 +38,7 @@ class ShaderD3D : public ShaderImpl
     void resetVaryingsRegisterAssignment();
     unsigned int getUniformRegister(const std::string &uniformName) const;
     unsigned int getInterfaceBlockRegister(const std::string &blockName) const;
+    int getSemanticIndex(const std::string &attributeName) const;
 
     rx::D3DWorkaroundType getD3DWorkarounds() const;
     int getShaderVersion() const { return mShaderVersion; }
@@ -47,15 +48,24 @@ class ShaderD3D : public ShaderImpl
     static void releaseCompiler();
     static ShShaderOutput getCompilerOutputType(GLenum shader);
 
-  protected:
+    virtual bool compile(const std::string &source);
+
+  private:
+    DISALLOW_COPY_AND_ASSIGN(ShaderD3D);
+
     void compileToHLSL(void *compiler, const std::string &source);
     void parseVaryings(void *compiler);
 
+    void initializeCompiler();
+    void parseAttributes(void *compiler);
+    void *getCompiler();
+
     static bool compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y);
 
     static void *mFragmentCompiler;
     static void *mVertexCompiler;
 
+    GLenum mType;
     rx::Renderer *mRenderer;
 
     int mShaderVersion;
@@ -72,55 +82,12 @@ class ShaderD3D : public ShaderImpl
     bool mUsesDiscardRewriting;
     bool mUsesNestedBreak;
 
-  private:
-    DISALLOW_COPY_AND_ASSIGN(ShaderD3D);
-
-    void initializeCompiler();
-
     std::string mHlsl;
     std::string mInfoLog;
     std::map<std::string, unsigned int> mUniformRegisterMap;
     std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
 };
 
-class VertexShaderD3D : public ShaderD3D
-{
-    friend class 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);
-
-    int getSemanticIndex(const std::string &attributeName) const;
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(VertexShaderD3D);
-
-    void parseAttributes();
-};
-
-class FragmentShaderD3D : public ShaderD3D
-{
-    friend class 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);
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(FragmentShaderD3D);
-};
-
 }
 
 #endif // LIBGLESV2_RENDERER_SHADERD3D_H_

src/libGLESv2/renderer/d3d/d3d11/Renderer11.cpp

@@ -2207,16 +2207,7 @@ RenderTarget *Renderer11::createRenderTarget(int width, int height, GLenum forma
 
 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;
-    }
+    return new ShaderD3D(type, this);
 }
 
 void Renderer11::releaseShaderCompiler()

src/libGLESv2/renderer/d3d/d3d9/Renderer9.cpp

@@ -2760,16 +2760,7 @@ RenderTarget *Renderer9::createRenderTarget(int width, int height, GLenum format
 
 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;
-    }
+    return new ShaderD3D(type, this);
 }
 
 void Renderer9::releaseShaderCompiler()