Make PackedVarying a D3D-only type.

src/libANGLE/Program.cpp

@@ -1204,10 +1204,10 @@ bool Program::linkVaryings(InfoLog &infoLog,
                            const Shader *vertexShader,
                            const Shader *fragmentShader)
 {
-    const std::vector<PackedVarying> &vertexVaryings   = vertexShader->getVaryings();
-    const std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
+    const std::vector<sh::Varying> &vertexVaryings   = vertexShader->getVaryings();
+    const std::vector<sh::Varying> &fragmentVaryings = fragmentShader->getVaryings();
 
-    for (const PackedVarying &output : fragmentVaryings)
+    for (const sh::Varying &output : fragmentVaryings)
     {
         bool matched = false;
 
@@ -1217,7 +1217,7 @@ bool Program::linkVaryings(InfoLog &infoLog,
             continue;
         }
 
-        for (const PackedVarying &input : vertexVaryings)
+        for (const sh::Varying &input : vertexVaryings)
         {
             if (output.name == input.name)
             {

src/libANGLE/Shader.cpp

@@ -174,7 +174,7 @@ int Shader::getShaderVersion() const
     return mShader->getShaderVersion();
 }
 
-const std::vector<gl::PackedVarying> &Shader::getVaryings() const
+const std::vector<sh::Varying> &Shader::getVaryings() const
 {
     return mShader->getVaryings();
 }
@@ -199,7 +199,7 @@ const std::vector<sh::Attribute> &Shader::getActiveOutputVariables() const
     return mShader->getActiveOutputVariables();
 }
 
-std::vector<gl::PackedVarying> &Shader::getVaryings()
+std::vector<sh::Varying> &Shader::getVaryings()
 {
     return mShader->getVaryings();
 }

src/libANGLE/Shader.h

@@ -33,26 +33,6 @@ class Compiler;
 class ResourceManager;
 struct Data;
 
-struct PackedVarying : public sh::Varying
-{
-    // TODO(jmadill): Make these D3D-only or otherwise clearly separate from GL.
-    unsigned int registerIndex; // Assigned during link
-    unsigned int columnIndex; // Assigned during link, defaults to 0
-
-    PackedVarying(const sh::Varying &varying)
-      : sh::Varying(varying),
-        registerIndex(GL_INVALID_INDEX),
-        columnIndex(0)
-    {}
-
-    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
-
-    void resetRegisterAssignment()
-    {
-        registerIndex = GL_INVALID_INDEX;
-    }
-};
-
 class Shader : angle::NonCopyable
 {
   public:
@@ -87,13 +67,13 @@ class Shader : angle::NonCopyable
 
     int getShaderVersion() const;
 
-    const std::vector<gl::PackedVarying> &getVaryings() const;
+    const std::vector<sh::Varying> &getVaryings() const;
     const std::vector<sh::Uniform> &getUniforms() const;
     const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const;
     const std::vector<sh::Attribute> &getActiveAttributes() const;
     const std::vector<sh::Attribute> &getActiveOutputVariables() const;
 
-    std::vector<gl::PackedVarying> &getVaryings();
+    std::vector<sh::Varying> &getVaryings();
     std::vector<sh::Uniform> &getUniforms();
     std::vector<sh::InterfaceBlock> &getInterfaceBlocks();
     std::vector<sh::Attribute> &getActiveAttributes();

src/libANGLE/renderer/ShaderImpl.h

@@ -31,13 +31,13 @@ class ShaderImpl : angle::NonCopyable
 
     int getShaderVersion() const { return mShaderVersion; }
 
-    const std::vector<gl::PackedVarying> &getVaryings() const { return mVaryings; }
+    const std::vector<sh::Varying> &getVaryings() const { return mVaryings; }
     const std::vector<sh::Uniform> &getUniforms() const { return mUniforms; }
     const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const  { return mInterfaceBlocks; }
     const std::vector<sh::Attribute> &getActiveAttributes() const { return mActiveAttributes; }
     const std::vector<sh::Attribute> &getActiveOutputVariables() const { return mActiveOutputVariables; }
 
-    std::vector<gl::PackedVarying> &getVaryings() { return mVaryings; }
+    std::vector<sh::Varying> &getVaryings() { return mVaryings; }
     std::vector<sh::Uniform> &getUniforms() { return mUniforms; }
     std::vector<sh::InterfaceBlock> &getInterfaceBlocks() { return mInterfaceBlocks; }
     std::vector<sh::Attribute> &getActiveAttributes() { return mActiveAttributes; }
@@ -50,7 +50,7 @@ class ShaderImpl : angle::NonCopyable
     // TODO(jmadill): make part of shared non-Impl state
     int mShaderVersion;
 
-    std::vector<gl::PackedVarying> mVaryings;
+    std::vector<sh::Varying> mVaryings;
     std::vector<sh::Uniform> mUniforms;
     std::vector<sh::InterfaceBlock> mInterfaceBlocks;
     std::vector<sh::Attribute> mActiveAttributes;

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -30,7 +30,6 @@ class InfoLog;
 struct VariableLocation;
 struct LinkedVarying;
 struct VertexAttribute;
-struct PackedVarying;
 struct Data;
 }
 
@@ -39,8 +38,6 @@ namespace rx
 class RendererD3D;
 class ShaderD3D;
 
-typedef const gl::PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
-
 struct PixelShaderOutputVariable
 {
     GLenum type;
@@ -54,8 +51,10 @@ class DynamicHLSL : angle::NonCopyable
   public:
     explicit DynamicHLSL(RendererD3D *const renderer);
 
-    int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, ShaderD3D *fragmentShader,
-                     ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
+    int packVaryings(gl::InfoLog &infoLog,
+                     ShaderD3D *fragmentShader,
+                     ShaderD3D *vertexShader,
+                     const std::vector<std::string> &transformFeedbackVaryings);
     std::string generateVertexShaderForInputLayout(const std::string &sourceShader,
                                                    const gl::InputLayout &inputLayout,
                                                    const std::vector<sh::Attribute> &shaderAttributes) const;
@@ -65,7 +64,6 @@ class DynamicHLSL : angle::NonCopyable
                                 const gl::Program::Data &programData,
                                 gl::InfoLog &infoLog,
                                 int registers,
-                                const VaryingPacking packing,
                                 std::string &pixelHLSL,
                                 std::string &vertexHLSL,
                                 std::vector<gl::LinkedVarying> *linkedVaryings,

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -131,19 +131,19 @@ bool LinkVaryingRegisters(gl::InfoLog &infoLog,
                           ShaderD3D *vertexShaderD3D,
                           ShaderD3D *fragmentShaderD3D)
 {
-    for (gl::PackedVarying &input : fragmentShaderD3D->getVaryings())
+    for (PackedVarying &input : fragmentShaderD3D->getPackedVaryings())
     {
         bool matched = false;
 
         // Built-in varyings obey special rules
-        if (input.isBuiltIn())
+        if (input.varying->isBuiltIn())
         {
             continue;
         }
 
-        for (gl::PackedVarying &output : vertexShaderD3D->getVaryings())
+        for (PackedVarying &output : vertexShaderD3D->getPackedVaryings())
         {
-            if (output.name == input.name)
+            if (output.varying->name == input.varying->name)
             {
                 output.registerIndex = input.registerIndex;
                 output.columnIndex   = input.columnIndex;
@@ -154,7 +154,7 @@ bool LinkVaryingRegisters(gl::InfoLog &infoLog,
         }
 
         // We permit unmatched, unreferenced varyings
-        ASSERT(matched || !input.staticUse);
+        ASSERT(matched || !input.varying->staticUse);
     }
 
     return true;
@@ -1137,8 +1137,7 @@ LinkResult ProgramD3D::link(const gl::Data &data,
     }
 
     // Map the varyings to the register file
-    VaryingPacking packing = {};
-    int registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShaderD3D, vertexShaderD3D,
+    int registers = mDynamicHLSL->packVaryings(infoLog, fragmentShaderD3D, vertexShaderD3D,
                                                mData.getTransformFeedbackVaryingNames());
 
     if (registers < 0)
@@ -1149,7 +1148,7 @@ LinkResult ProgramD3D::link(const gl::Data &data,
     LinkVaryingRegisters(infoLog, vertexShaderD3D, fragmentShaderD3D);
 
     std::vector<gl::LinkedVarying> linkedVaryings;
-    if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registers, packing, mPixelHLSL,
+    if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registers, mPixelHLSL,
                                               mVertexHLSL, &linkedVaryings, &mPixelShaderKey,
                                               &mUsesFragDepth))
     {

src/libANGLE/renderer/d3d/ShaderD3D.cpp

@@ -35,6 +35,27 @@ const char *GetShaderTypeString(GLenum type)
     }
 }
 
+// true if varying x has a higher priority in packing than y
+bool CompareVarying(const sh::Varying &x, const sh::Varying &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);
+}
 }
 
 namespace rx
@@ -87,9 +108,11 @@ void ShaderD3D::parseVaryings(ShHandle compiler)
         const std::vector<sh::Varying> *varyings = ShGetVaryings(compiler);
         ASSERT(varyings);
 
+        mVaryings = *varyings;
+
         for (size_t varyingIndex = 0; varyingIndex < varyings->size(); varyingIndex++)
         {
-            mVaryings.push_back(gl::PackedVarying((*varyings)[varyingIndex]));
+            mPackedVaryings.push_back(PackedVarying(mVaryings[varyingIndex]));
         }
 
         mUsesMultipleRenderTargets   = mTranslatedSource.find("GL_USES_MRT")                          != std::string::npos;
@@ -112,7 +135,7 @@ void ShaderD3D::resetVaryingsRegisterAssignment()
 {
     for (size_t varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
     {
-        mVaryings[varyingIndex].resetRegisterAssignment();
+        mPackedVaryings[varyingIndex].resetRegisterAssignment();
     }
 }
 
@@ -285,28 +308,6 @@ void ShaderD3D::generateWorkarounds(D3DCompilerWorkarounds *workarounds) const
     }
 }
 
-// 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);
@@ -349,7 +350,7 @@ bool ShaderD3D::compile(gl::Compiler *compiler, const std::string &source)
 
     if (mShaderType == GL_FRAGMENT_SHADER)
     {
-        std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
+        std::sort(mVaryings.begin(), mVaryings.end(), CompareVarying);
 
         const std::string &hlsl = getTranslatedSource();
         if (!hlsl.empty())

src/libANGLE/renderer/d3d/ShaderD3D.h

@@ -20,6 +20,24 @@ namespace rx
 class DynamicHLSL;
 class RendererD3D;
 
+struct PackedVarying
+{
+    PackedVarying(const sh::Varying &varyingIn)
+        : varying(&varyingIn), registerIndex(GL_INVALID_INDEX), columnIndex(0)
+    {
+    }
+
+    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
+
+    void resetRegisterAssignment() { registerIndex = GL_INVALID_INDEX; }
+
+    const sh::Varying *varying;
+
+    // TODO(jmadill): Make these D3D-only or otherwise clearly separate from GL.
+    unsigned int registerIndex;  // Assigned during link
+    unsigned int columnIndex;    // Assigned during link, defaults to 0
+};
+
 class ShaderD3D : public ShaderImpl
 {
     friend class DynamicHLSL;
@@ -50,14 +68,17 @@ class ShaderD3D : public ShaderImpl
 
     virtual bool compile(gl::Compiler *compiler, const std::string &source);
 
+    const std::vector<PackedVarying> &getPackedVaryings() const { return mPackedVaryings; }
+
+    // TODO(jmadill): remove this
+    std::vector<PackedVarying> &getPackedVaryings() { return mPackedVaryings; }
+
   private:
     void compileToHLSL(ShHandle compiler, const std::string &source);
     void parseVaryings(ShHandle compiler);
 
     void parseAttributes(ShHandle compiler);
 
-    static bool compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y);
-
     GLenum mShaderType;
 
     bool mUsesMultipleRenderTargets;
@@ -79,6 +100,7 @@ class ShaderD3D : public ShaderImpl
     std::map<std::string, unsigned int> mUniformRegisterMap;
     std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
     RendererD3D *mRenderer;
+    std::vector<PackedVarying> mPackedVaryings;
 };
 
 }

src/libANGLE/renderer/gl/ShaderGL.cpp

@@ -123,12 +123,7 @@ bool ShaderGL::compile(gl::Compiler *compiler, const std::string &source)
         mActiveAttributes = GetFilteredShaderVariables(ShGetAttributes(compilerHandle));
     }
 
-    const std::vector<sh::Varying> &varyings = GetShaderVariables(ShGetVaryings(compilerHandle));
-    for (size_t varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
-    {
-        mVaryings.push_back(gl::PackedVarying(varyings[varyingIndex]));
-    }
-
+    mVaryings        = GetShaderVariables(ShGetVaryings(compilerHandle));
     mUniforms = GetShaderVariables(ShGetUniforms(compilerHandle));
     mInterfaceBlocks = GetShaderVariables(ShGetInterfaceBlocks(compilerHandle));