Removed the last references to DynamicHLSL from ProgramBinary.

src/libGLESv2/ProgramBinary.cpp

@@ -24,7 +24,6 @@
 #include "libGLESv2/Program.h"
 #include "libGLESv2/renderer/ProgramImpl.h"
 #include "libGLESv2/renderer/Renderer.h"
-#include "libGLESv2/renderer/d3d/DynamicHLSL.h"
 #include "libGLESv2/renderer/d3d/ShaderD3D.h"
 #include "libGLESv2/renderer/d3d/VertexDataManager.h"
 #include "libGLESv2/Context.h"
@@ -195,8 +194,6 @@ ProgramBinary::ProgramBinary(rx::ProgramImpl *impl)
       mGeometryExecutable(NULL),
       mUsedVertexSamplerRange(0),
       mUsedPixelSamplerRange(0),
-      mUsesPointSize(false),
-      mShaderVersion(100),
       mDirtySamplerMapping(true),
       mValidated(false),
       mSerial(issueSerial())
@@ -220,11 +217,6 @@ unsigned int ProgramBinary::getSerial() const
     return mSerial;
 }
 
-int ProgramBinary::getShaderVersion() const
-{
-    return mShaderVersion;
-}
-
 unsigned int ProgramBinary::issueSerial()
 {
     return mCurrentSerial++;
@@ -284,7 +276,7 @@ rx::ShaderExecutable *ProgramBinary::getPixelExecutableForOutputLayout(const std
 rx::ShaderExecutable *ProgramBinary::getVertexExecutableForInputLayout(const VertexFormat inputLayout[MAX_VERTEX_ATTRIBS])
 {
     GLenum signature[MAX_VERTEX_ATTRIBS];
-    mProgram->getDynamicHLSL()->getInputLayoutSignature(inputLayout, signature);
+    mProgram->getInputLayoutSignature(inputLayout, signature);
 
     for (size_t executableIndex = 0; executableIndex < mVertexExecutables.size(); executableIndex++)
     {
@@ -357,17 +349,7 @@ GLint ProgramBinary::getUsedSamplerRange(SamplerType type)
 
 bool ProgramBinary::usesPointSize() const
 {
-    return mUsesPointSize;
-}
-
-bool ProgramBinary::usesPointSpriteEmulation() const
-{
-    return mUsesPointSize && mProgram->getRenderer()->getMajorShaderModel() >= 4;
-}
-
-bool ProgramBinary::usesGeometryShader() const
-{
-    return usesPointSpriteEmulation();
+    return mProgram->usesPointSize();
 }
 
 GLint ProgramBinary::getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps)
@@ -1155,8 +1137,6 @@ bool ProgramBinary::load(InfoLog &infoLog, GLenum binaryFormat, const void *bina
 
     stream.readInt(&mUsedVertexSamplerRange);
     stream.readInt(&mUsedPixelSamplerRange);
-    stream.readBool(&mUsesPointSize);
-    stream.readInt(&mShaderVersion);
 
     const unsigned int uniformCount = stream.readInt<unsigned int>();
     if (stream.error())
@@ -1278,7 +1258,7 @@ bool ProgramBinary::load(InfoLog &infoLog, GLenum binaryFormat, const void *bina
 
         // generated converted input layout
         GLenum signature[MAX_VERTEX_ATTRIBS];
-        mProgram->getDynamicHLSL()->getInputLayoutSignature(inputLayout, signature);
+        mProgram->getInputLayoutSignature(inputLayout, signature);
 
         // add new binary
         mVertexExecutables.push_back(new VertexExecutable(inputLayout, signature, shaderExecutable));
@@ -1398,8 +1378,6 @@ bool ProgramBinary::save(GLenum *binaryFormat, void *binary, GLsizei bufSize, GL
 
     stream.writeInt(mUsedVertexSamplerRange);
     stream.writeInt(mUsedPixelSamplerRange);
-    stream.writeInt(mUsesPointSize);
-    stream.writeInt(mShaderVersion);
 
     stream.writeInt(mUniforms.size());
     for (size_t uniformIndex = 0; uniformIndex < mUniforms.size(); ++uniformIndex)
@@ -1598,8 +1576,6 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
     rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
     rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
 
-    mShaderVersion = vertexShaderD3D->getShaderVersion();
-
     int registers;
     std::vector<LinkedVarying> linkedVaryings;
     if (!mProgram->link(infoLog, fragmentShader, vertexShader, transformFeedbackVaryings, &registers, &linkedVaryings, &mOutputVariables))
@@ -1607,8 +1583,6 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
         return false;
     }
 
-    mUsesPointSize = vertexShaderD3D->usesPointSize();
-
     bool success = true;
 
     if (!linkAttributes(infoLog, attributeBindings, vertexShader))
@@ -1651,16 +1625,15 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
         std::vector<GLenum> defaultPixelOutput = GetDefaultOutputLayoutFromShader(mProgram->getPixelShaderKey());
         rx::ShaderExecutable *defaultPixelExecutable = getPixelExecutableForOutputLayout(defaultPixelOutput);
 
-        if (usesGeometryShader())
+        if (mProgram->usesGeometryShader())
         {
-            std::string geometryHLSL = mProgram->getDynamicHLSL()->generateGeometryShaderHLSL(registers, fragmentShaderD3D, vertexShaderD3D);
-            mGeometryExecutable = mProgram->getRenderer()->compileToExecutable(infoLog, geometryHLSL.c_str(),
-                                                                               rx::SHADER_GEOMETRY, mTransformFeedbackLinkedVaryings,
-                                                                               (mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS),
-                                                                               rx::ANGLE_D3D_WORKAROUND_NONE);
+            mGeometryExecutable = mProgram->getGeometryExecutable(infoLog, fragmentShader, vertexShader,
+                                                                  mTransformFeedbackLinkedVaryings,
+                                                                  (mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS),
+                                                                  registers);
         }
 
-        if (!defaultVertexExecutable || !defaultPixelExecutable || (usesGeometryShader() && !mGeometryExecutable))
+        if (!defaultVertexExecutable || !defaultPixelExecutable || (mProgram->usesGeometryShader() && !mGeometryExecutable))
         {
             infoLog.append("Failed to create D3D shaders.");
             success = false;
@@ -1708,7 +1681,7 @@ bool ProgramBinary::linkAttributes(InfoLog &infoLog, const AttributeBindings &at
 
                 // In GLSL 3.00, attribute aliasing produces a link error
                 // In GLSL 1.00, attribute aliasing is allowed
-                if (mShaderVersion >= 300)
+                if (mProgram->getShaderVersion() >= 300)
                 {
                     if (!linkedAttribute.name.empty())
                     {
@@ -2797,7 +2770,6 @@ void ProgramBinary::reset()
 {
     SafeDeleteContainer(mVertexExecutables);
     SafeDeleteContainer(mPixelExecutables);
-
     SafeDelete(mGeometryExecutable);
 
     mTransformFeedbackBufferMode = GL_NONE;
@@ -2808,8 +2780,6 @@ void ProgramBinary::reset()
 
     mUsedVertexSamplerRange = 0;
     mUsedPixelSamplerRange = 0;
-    mUsesPointSize = false;
-    mShaderVersion = 0;
     mDirtySamplerMapping = true;
 
     SafeDeleteContainer(mUniforms);

src/libGLESv2/ProgramBinary.h

@@ -113,8 +113,6 @@ class ProgramBinary : public RefCountObject
     GLenum getSamplerTextureType(SamplerType type, unsigned int samplerIndex);
     GLint getUsedSamplerRange(SamplerType type);
     bool usesPointSize() const;
-    bool usesPointSpriteEmulation() const;
-    bool usesGeometryShader() const;
 
     GLint getUniformLocation(std::string name);
     GLuint getUniformIndex(std::string name);
@@ -188,7 +186,6 @@ class ProgramBinary : public RefCountObject
     void updateSamplerMapping();
 
     unsigned int getSerial() const;
-    int getShaderVersion() const;
 
     void initAttributesByLayout();
     void sortAttributesByLayout(rx::TranslatedAttribute attributes[MAX_VERTEX_ATTRIBS], int sortedSemanticIndices[MAX_VERTEX_ATTRIBS]) const;
@@ -293,7 +290,6 @@ class ProgramBinary : public RefCountObject
 
     std::vector<VertexExecutable *> mVertexExecutables;
     std::vector<PixelExecutable *> mPixelExecutables;
-
     rx::ShaderExecutable *mGeometryExecutable;
 
     sh::Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
@@ -308,8 +304,6 @@ class ProgramBinary : public RefCountObject
     std::vector<Sampler> mSamplersVS;
     GLuint mUsedVertexSamplerRange;
     GLuint mUsedPixelSamplerRange;
-    bool mUsesPointSize;
-    int mShaderVersion;
     bool mDirtySamplerMapping;
 
     std::vector<LinkedUniform*> mUniforms;

src/libGLESv2/renderer/ProgramImpl.h

@@ -17,7 +17,6 @@
 namespace rx
 {
 
-class DynamicHLSL;
 class Renderer;
 
 class ProgramImpl
@@ -27,9 +26,12 @@ public:
 
     // TODO: Temporary interfaces to ease migration. Remove soon!
     virtual Renderer *getRenderer() = 0;
-    virtual DynamicHLSL *getDynamicHLSL() = 0;
     virtual const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() = 0;
 
+    virtual bool usesPointSize() const = 0;
+    virtual bool usesGeometryShader() const = 0;
+    virtual int getShaderVersion() const = 0;
+
     virtual GLenum getBinaryFormat() = 0;
     virtual bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) = 0;
     virtual bool save(gl::BinaryOutputStream *stream) = 0;
@@ -42,12 +44,17 @@ public:
                                                                     const sh::Attribute shaderAttributes[],
                                                                     const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
                                                                     bool separatedOutputBuffers) = 0;
+    virtual rx::ShaderExecutable *getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
+                                                        bool separatedOutputBuffers, int registers) = 0;
 
     virtual bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
                       const std::vector<std::string> &transformFeedbackVaryings, int *registers,
                       std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int,
                       gl::VariableLocation> *outputVariables) = 0;
 
+    virtual void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const = 0;
+
     virtual void initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms) = 0;
 
     virtual void reset() = 0;

src/libGLESv2/renderer/d3d/ProgramD3D.cpp

@@ -25,8 +25,10 @@ ProgramD3D::ProgramD3D(rx::Renderer *renderer)
       mDynamicHLSL(NULL),
       mVertexWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
       mPixelWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE),
+      mUsesPointSize(false),
       mVertexUniformStorage(NULL),
-      mFragmentUniformStorage(NULL)
+      mFragmentUniformStorage(NULL),
+      mShaderVersion(100)
 {
     mDynamicHLSL = new rx::DynamicHLSL(renderer);
 }
@@ -49,13 +51,31 @@ const ProgramD3D *ProgramD3D::makeProgramD3D(const ProgramImpl *impl)
     return static_cast<const ProgramD3D*>(impl);
 }
 
+bool ProgramD3D::usesPointSize() const
+{
+    return mUsesPointSize;
+}
+
+bool ProgramD3D::usesPointSpriteEmulation() const
+{
+    return mUsesPointSize && mRenderer->getMajorShaderModel() >= 4;
+}
+
+bool ProgramD3D::usesGeometryShader() const
+{
+    return usesPointSpriteEmulation();
+}
+
 bool ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 {
+    stream->readInt(&mShaderVersion);
+
     stream->readString(&mVertexHLSL);
     stream->readInt(&mVertexWorkarounds);
     stream->readString(&mPixelHLSL);
     stream->readInt(&mPixelWorkarounds);
     stream->readBool(&mUsesFragDepth);
+    stream->readBool(&mUsesPointSize);
 
     const size_t pixelShaderKeySize = stream->readInt<unsigned int>();
     mPixelShaderKey.resize(pixelShaderKeySize);
@@ -72,11 +92,14 @@ bool ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream)
 
 bool ProgramD3D::save(gl::BinaryOutputStream *stream)
 {
+    stream->writeInt(mShaderVersion);
+
     stream->writeString(mVertexHLSL);
     stream->writeInt(mVertexWorkarounds);
     stream->writeString(mPixelHLSL);
     stream->writeInt(mPixelWorkarounds);
     stream->writeInt(mUsesFragDepth);
+    stream->writeInt(mUsesPointSize);
 
     const std::vector<rx::PixelShaderOutputVariable> &pixelShaderKey = mPixelShaderKey;
     stream->writeInt(pixelShaderKey.size());
@@ -125,6 +148,22 @@ rx::ShaderExecutable *ProgramD3D::getVertexExecutableForInputLayout(gl::InfoLog
     return vertexExecutable;
 }
 
+rx::ShaderExecutable *ProgramD3D::getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                                        const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
+                                                        bool separatedOutputBuffers, int registers)
+{
+    rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation());
+    rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation());
+
+    std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShaderD3D, vertexShaderD3D);
+
+    rx::ShaderExecutable *geometryExecutable = mRenderer->compileToExecutable(infoLog, geometryHLSL.c_str(),
+                                                                              rx::SHADER_GEOMETRY, transformFeedbackLinkedVaryings,
+                                                                              separatedOutputBuffers, rx::ANGLE_D3D_WORKAROUND_NONE);
+
+    return geometryExecutable;
+}
+
 bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
                       const std::vector<std::string> &transformFeedbackVaryings, int *registers,
                       std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables)
@@ -137,6 +176,7 @@ bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shad
 
     mVertexHLSL = vertexShaderD3D->getTranslatedSource();
     mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds();
+    mShaderVersion = vertexShaderD3D->getShaderVersion();
 
     // Map the varyings to the register file
     rx::VaryingPacking packing = { NULL };
@@ -159,9 +199,16 @@ bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shad
         return false;
     }
 
+    mUsesPointSize = vertexShaderD3D->usesPointSize();
+
     return true;
 }
 
+void ProgramD3D::getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const
+{
+    mDynamicHLSL->getInputLayoutSignature(inputLayout, signature);
+}
+
 void ProgramD3D::initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms)
 {
     // Compute total default block size
@@ -192,11 +239,13 @@ void ProgramD3D::reset()
 {
     mVertexHLSL.clear();
     mVertexWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
+    mShaderVersion = 100;
 
     mPixelHLSL.clear();
     mPixelWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE;
     mUsesFragDepth = false;
     mPixelShaderKey.clear();
+    mUsesPointSize = false;
 
     SafeDelete(mVertexUniformStorage);
     SafeDelete(mFragmentUniformStorage);

src/libGLESv2/renderer/d3d/ProgramD3D.h

@@ -36,8 +36,12 @@ class ProgramD3D : public ProgramImpl
     static const ProgramD3D *makeProgramD3D(const ProgramImpl *impl);
 
     Renderer *getRenderer() { return mRenderer; }
-    DynamicHLSL *getDynamicHLSL() { return mDynamicHLSL; }
     const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() { return mPixelShaderKey; }
+    int getShaderVersion() const { return mShaderVersion; }
+
+    bool usesPointSize() const;
+    bool usesPointSpriteEmulation() const;
+    bool usesGeometryShader() const;
 
     GLenum getBinaryFormat() { return GL_PROGRAM_BINARY_ANGLE; }
     bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream);
@@ -51,11 +55,16 @@ class ProgramD3D : public ProgramImpl
                                                         const sh::Attribute shaderAttributes[],
                                                         const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
                                                         bool separatedOutputBuffers);
+    ShaderExecutable *getGeometryExecutable(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
+                                            const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings,
+                                            bool separatedOutputBuffers, int registers);
 
     bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
               const std::vector<std::string> &transformFeedbackVaryings, int *registers,
               std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables);
 
+    void getInputLayoutSignature(const gl::VertexFormat inputLayout[], GLenum signature[]) const;
+
     // D3D only
     void initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms);
 
@@ -78,8 +87,12 @@ class ProgramD3D : public ProgramImpl
     bool mUsesFragDepth;
     std::vector<rx::PixelShaderOutputVariable> mPixelShaderKey;
 
+    bool mUsesPointSize;
+
     UniformStorage *mVertexUniformStorage;
     UniformStorage *mFragmentUniformStorage;
+
+    int mShaderVersion;
 };
 
 }