Move shader variables into the base impl.

These variable types apply across shader types. Either we'll want a
way to cache them after we query them, or we'll do a pre-parse pass
similar to our current Chromium GLSL to GLSL pre-pass where we store
the variables in ANGLE. In either case, they're shared across GL
implementations so make sense as queries from gl::Shader.

BUG=angle:731

Change-Id: I23f5541423abb4af87a2bc2fc1e9f4047fd2ff90
Reviewed-on: https://chromium-review.googlesource.com/214870
Tested-by: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Geoff Lang <geofflang@chromium.org>

3 files changed, 34 insertions, 59 deletions

diff --git a/src/libGLESv2/renderer/d3d/DynamicHLSL.cpp b/src/libGLESv2/renderer/d3d/DynamicHLSL.cpp
index a83ed54f..7086f47b 100644
--- a/src/libGLESv2/renderer/d3d/DynamicHLSL.cpp
+++ b/src/libGLESv2/renderer/d3d/DynamicHLSL.cpp
@@ -218,9 +218,11 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::Frag
 
     std::set<std::string> packedVaryings;
 
-    for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
+    std::vector<gl::PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
+    std::vector<gl::PackedVarying> &vertexVaryings = vertexShader->getVaryings();
+    for (unsigned int varyingIndex = 0; varyingIndex < fragmentVaryings.size(); varyingIndex++)
     {
-        PackedVarying *varying = &fragmentShader->mVaryings[varyingIndex];
+        PackedVarying *varying = &fragmentVaryings[varyingIndex];
         if (packVarying(varying, maxVaryingVectors, packing))
         {
             packedVaryings.insert(varying->name);
@@ -238,9 +240,9 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, rx::Frag
         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 < vertexVaryings.size(); varyingIndex++)
             {
-                PackedVarying *varying = &vertexShader->mVaryings[varyingIndex];
+                PackedVarying *varying = &vertexVaryings[varyingIndex];
                 if (transformFeedbackVarying == varying->name)
                 {
                     if (!packVarying(varying, maxVaryingVectors, packing))
@@ -281,9 +283,10 @@ std::string DynamicHLSL::generateVaryingHLSL(rx::VertexShaderD3D *shader) const
     std::string varyingSemantic = getVaryingSemantic(shader->mUsesPointSize);
     std::string varyingHLSL;
 
-    for (unsigned int varyingIndex = 0; varyingIndex < shader->mVaryings.size(); varyingIndex++)
+    std::vector<gl::PackedVarying> &varyings = shader->getVaryings();
+    for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
     {
-        const PackedVarying &varying = shader->mVaryings[varyingIndex];
+        const PackedVarying &varying = varyings[varyingIndex];
         if (varying.registerAssigned())
         {
             GLenum transposedType = TransposeMatrixType(varying.type);
@@ -608,7 +611,7 @@ void DynamicHLSL::storeUserLinkedVaryings(const rx::VertexShaderD3D *vertexShade
                                           std::vector<LinkedVarying> *linkedVaryings) const
 {
     const std::string &varyingSemantic = getVaryingSemantic(vertexShader->mUsesPointSize);
-    const std::vector<PackedVarying> &varyings = vertexShader->mVaryings;
+    const std::vector<PackedVarying> &varyings = vertexShader->getVaryings();
 
     for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
     {
@@ -723,9 +726,10 @@ 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++)
+    const std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
+    for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexVaryings.size(); vertVaryingIndex++)
     {
-        const PackedVarying &varying = vertexShader->mVaryings[vertVaryingIndex];
+        const PackedVarying &varying = vertexVaryings[vertVaryingIndex];
         if (varying.registerAssigned())
         {
             for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
@@ -813,7 +817,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
     {
         defineOutputVariables(fragmentShader, programOutputVars);
 
-        const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
+        const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getActiveOutputVariables();
         for (auto locationIt = programOutputVars->begin(); locationIt != programOutputVars->end(); locationIt++)
         {
             const VariableLocation &outputLocation = locationIt->second;
@@ -897,9 +901,10 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
         }
     }
 
-    for (unsigned int varyingIndex = 0; varyingIndex < fragmentShader->mVaryings.size(); varyingIndex++)
+    const std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
+    for (unsigned int varyingIndex = 0; varyingIndex < fragmentVaryings.size(); varyingIndex++)
     {
-        const PackedVarying &varying = fragmentShader->mVaryings[varyingIndex];
+        const PackedVarying &varying = fragmentVaryings[varyingIndex];
         if (varying.registerAssigned())
         {
             for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
@@ -953,7 +958,7 @@ bool DynamicHLSL::generateShaderLinkHLSL(InfoLog &infoLog, int registers, const
 
 void DynamicHLSL::defineOutputVariables(rx::FragmentShaderD3D *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const
 {
-    const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getOutputVariables();
+    const std::vector<sh::Attribute> &shaderOutputVars = fragmentShader->getActiveOutputVariables();
 
     for (unsigned int outputVariableIndex = 0; outputVariableIndex < shaderOutputVars.size(); outputVariableIndex++)
     {
diff --git a/src/libGLESv2/renderer/d3d/ShaderD3D.cpp b/src/libGLESv2/renderer/d3d/ShaderD3D.cpp
index a033f024..f26df10e 100644
--- a/src/libGLESv2/renderer/d3d/ShaderD3D.cpp
+++ b/src/libGLESv2/renderer/d3d/ShaderD3D.cpp
@@ -135,7 +135,7 @@ void ShaderD3D::parseVaryings(void *compiler)
 
 void ShaderD3D::resetVaryingsRegisterAssignment()
 {
-    for (unsigned int varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
+    for (size_t varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
     {
         mVaryings[varyingIndex].resetRegisterAssignment();
     }
@@ -148,9 +148,6 @@ void ShaderD3D::uncompile()
     mHlsl.clear();
     mInfoLog.clear();
 
-    // set by parseVaryings
-    mVaryings.clear();
-
     mUsesMultipleRenderTargets = false;
     mUsesFragColor = false;
     mUsesFragData = false;
@@ -164,8 +161,11 @@ void ShaderD3D::uncompile()
     mUsesDiscardRewriting = false;
     mUsesNestedBreak = false;
 
-    mActiveUniforms.clear();
-    mActiveInterfaceBlocks.clear();
+    mVaryings.clear();
+    mUniforms.clear();
+    mInterfaceBlocks.clear();
+    mActiveAttributes.clear();
+    mActiveOutputVariables.clear();
 }
 
 void ShaderD3D::compileToHLSL(void *compiler, const std::string &source)
@@ -245,11 +245,11 @@ void ShaderD3D::compileToHLSL(void *compiler, const std::string &source)
 
         SafeDeleteArray(outputHLSL);
 
-        mActiveUniforms = *GetShaderVariables(ShGetUniforms(compiler));
+        mUniforms = *GetShaderVariables(ShGetUniforms(compiler));
 
-        for (size_t uniformIndex = 0; uniformIndex < mActiveUniforms.size(); uniformIndex++)
+        for (size_t uniformIndex = 0; uniformIndex < mUniforms.size(); uniformIndex++)
         {
-            const sh::Uniform &uniform = mActiveUniforms[uniformIndex];
+            const sh::Uniform &uniform = mUniforms[uniformIndex];
 
             unsigned int index = -1;
             bool result = ShGetUniformRegister(compiler, uniform.name.c_str(), &index);
@@ -259,11 +259,11 @@ void ShaderD3D::compileToHLSL(void *compiler, const std::string &source)
             mUniformRegisterMap[uniform.name] = index;
         }
 
-        mActiveInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
+        mInterfaceBlocks = *GetShaderVariables(ShGetInterfaceBlocks(compiler));
 
-        for (size_t blockIndex = 0; blockIndex < mActiveInterfaceBlocks.size(); blockIndex++)
+        for (size_t blockIndex = 0; blockIndex < mInterfaceBlocks.size(); blockIndex++)
         {
-            const sh::InterfaceBlock &interfaceBlock = mActiveInterfaceBlocks[blockIndex];
+            const sh::InterfaceBlock &interfaceBlock = mInterfaceBlocks[blockIndex];
 
             unsigned int index = -1;
             bool result = ShGetInterfaceBlockRegister(compiler, interfaceBlock.name.c_str(), &index);
@@ -388,14 +388,6 @@ bool VertexShaderD3D::compile(const std::string &source)
     return !getTranslatedSource().empty();
 }
 
-void VertexShaderD3D::uncompile()
-{
-    ShaderD3D::uncompile();
-
-    // set by ParseAttributes
-    mActiveAttributes.clear();
-}
-
 void VertexShaderD3D::parseAttributes()
 {
     const std::string &hlsl = getTranslatedSource();
@@ -405,12 +397,12 @@ void VertexShaderD3D::parseAttributes()
     }
 }
 
-int VertexShaderD3D::getSemanticIndex(const std::string &attributeName)
+int VertexShaderD3D::getSemanticIndex(const std::string &attributeName) const
 {
     if (!attributeName.empty())
     {
         int semanticIndex = 0;
-        for (unsigned int attributeIndex = 0; attributeIndex < mActiveAttributes.size(); attributeIndex++)
+        for (size_t attributeIndex = 0; attributeIndex < mActiveAttributes.size(); attributeIndex++)
         {
             const sh::ShaderVariable &attribute = mActiveAttributes[attributeIndex];
 
@@ -452,6 +444,7 @@ bool FragmentShaderD3D::compile(const std::string &source)
 
     compileToHLSL(mFragmentCompiler, source);
     parseVaryings(mFragmentCompiler);
+
     std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
 
     const std::string &hlsl = getTranslatedSource();
@@ -463,11 +456,4 @@ bool FragmentShaderD3D::compile(const std::string &source)
     return false;
 }
 
-void FragmentShaderD3D::uncompile()
-{
-    ShaderD3D::uncompile();
-
-    mActiveOutputVariables.clear();
-}
-
 }
diff --git a/src/libGLESv2/renderer/d3d/ShaderD3D.h b/src/libGLESv2/renderer/d3d/ShaderD3D.h
index e0b7a76e..d537f5bb 100644
--- a/src/libGLESv2/renderer/d3d/ShaderD3D.h
+++ b/src/libGLESv2/renderer/d3d/ShaderD3D.h
@@ -43,9 +43,6 @@ class ShaderD3D : public ShaderImpl
     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);
@@ -61,8 +58,6 @@ class ShaderD3D : public ShaderImpl
 
     rx::Renderer *mRenderer;
 
-    std::vector<gl::PackedVarying> mVaryings;
-
     int mShaderVersion;
 
     bool mUsesMultipleRenderTargets;
@@ -84,8 +79,6 @@ class ShaderD3D : public ShaderImpl
 
     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;
 };
@@ -102,17 +95,13 @@ class VertexShaderD3D : public ShaderD3D
     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; }
+    int getSemanticIndex(const std::string &attributeName) const;
 
   private:
     DISALLOW_COPY_AND_ASSIGN(VertexShaderD3D);
 
     void parseAttributes();
-
-    std::vector<sh::Attribute> mActiveAttributes;
 };
 
 class FragmentShaderD3D : public ShaderD3D
@@ -127,14 +116,9 @@ class FragmentShaderD3D : public ShaderD3D
     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;
 };
 
 }