Split register allocation of varyings from the translator.

src/common/shadervars.h

@@ -60,7 +60,7 @@ struct ShaderVariable
 struct Uniform : public ShaderVariable
 {
     unsigned int registerIndex;
-    unsigned int elementIndex;     // For struct varyings
+    unsigned int elementIndex; // Offset within a register, for struct members
     std::vector<Uniform> fields;
 
     Uniform(GLenum typeIn, GLenum precisionIn, const char *nameIn, unsigned int arraySizeIn,
@@ -105,22 +105,14 @@ struct Varying : public ShaderVariable
 {
     InterpolationType interpolation;
     std::vector<Varying> fields;
-    unsigned int registerIndex;    // Assigned during link
     std::string structName;
 
     Varying(GLenum typeIn, GLenum precisionIn, const char *nameIn, unsigned int arraySizeIn, InterpolationType interpolationIn)
       : ShaderVariable(typeIn, precisionIn, nameIn, arraySizeIn),
-        interpolation(interpolationIn),
-        registerIndex(GL_INVALID_INDEX)
+        interpolation(interpolationIn)
     {}
 
     bool isStruct() const { return !fields.empty(); }
-    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
-
-    void resetRegisterAssignment()
-    {
-        registerIndex = GL_INVALID_INDEX;
-    }
 };
 
 struct BlockMemberInfo

src/libGLESv2/DynamicHLSL.h

@@ -10,6 +10,7 @@
 #define LIBGLESV2_DYNAMIC_HLSL_H_
 
 #include "common/angleutils.h"
+#include "libGLESv2/constants.h"
 
 namespace rx
 {
@@ -27,24 +28,28 @@ struct LinkedVarying;
 class VertexAttribute;
 struct VertexFormat;
 struct ShaderVariable;
+struct Varying;
 struct Attribute;
+struct PackedVarying;
+
+typedef const PackedVarying *VaryingPacking[IMPLEMENTATION_MAX_VARYING_VECTORS][4];
 
 class DynamicHLSL
 {
   public:
     explicit DynamicHLSL(rx::Renderer *const renderer);
 
-    int packVaryings(InfoLog &infoLog, const ShaderVariable *packing[][4], FragmentShader *fragmentShader,
+    int packVaryings(InfoLog &infoLog, VaryingPacking packing, FragmentShader *fragmentShader,
                      VertexShader *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
     std::string generateInputLayoutHLSL(const VertexFormat inputLayout[], const Attribute shaderAttributes[]) const;
-    bool generateShaderLinkHLSL(InfoLog &infoLog, int registers, const ShaderVariable *packing[][4],
+    bool generateShaderLinkHLSL(InfoLog &infoLog, int registers, const VaryingPacking packing,
                                 std::string& pixelHLSL, std::string& vertexHLSL,
                                 FragmentShader *fragmentShader, VertexShader *vertexShader,
                                 const std::vector<std::string>& transformFeedbackVaryings,
                                 std::vector<LinkedVarying> *linkedVaryings,
                                 std::map<int, VariableLocation> *programOutputVars) const;
 
-    std::string generateGeometryShaderHLSL(int registers, const ShaderVariable *packing[][4], FragmentShader *fragmentShader, VertexShader *vertexShader) const;
+    std::string generateGeometryShaderHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const;
     void getInputLayoutSignature(const VertexFormat inputLayout[], GLenum signature[]) const;
 
     static const std::string VERTEX_ATTRIBUTE_STUB_STRING;
@@ -57,7 +62,7 @@ class DynamicHLSL
     std::string generateVaryingHLSL(VertexShader *shader, const std::string &varyingSemantic,
                                     std::vector<LinkedVarying> *linkedVaryings) const;
     void defineOutputVariables(FragmentShader *fragmentShader, std::map<int, VariableLocation> *programOutputVars) const;
-    std::string generatePointSpriteHLSL(int registers, const ShaderVariable *packing[][4], FragmentShader *fragmentShader, VertexShader *vertexShader) const;
+    std::string generatePointSpriteHLSL(int registers, FragmentShader *fragmentShader, VertexShader *vertexShader) const;
 
     // Prepend an underscore
     static std::string decorateVariable(const std::string &name);

src/libGLESv2/ProgramBinary.cpp

@@ -1013,17 +1013,17 @@ bool ProgramBinary::applyUniformBuffers(const std::vector<gl::Buffer*> boundBuff
 
 bool ProgramBinary::linkVaryings(InfoLog &infoLog, FragmentShader *fragmentShader, VertexShader *vertexShader)
 {
-    std::vector<gl::Varying> &fragmentVaryings = fragmentShader->getVaryings();
-    std::vector<gl::Varying> &vertexVaryings = vertexShader->getVaryings();
+    std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
+    std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
 
     for (size_t fragVaryingIndex = 0; fragVaryingIndex < fragmentVaryings.size(); fragVaryingIndex++)
     {
-        gl::Varying *input = &fragmentVaryings[fragVaryingIndex];
+        PackedVarying *input = &fragmentVaryings[fragVaryingIndex];
         bool matched = false;
 
         for (size_t vertVaryingIndex = 0; vertVaryingIndex < vertexVaryings.size(); vertVaryingIndex++)
         {
-            gl::Varying *output = &vertexVaryings[vertVaryingIndex];
+            PackedVarying *output = &vertexVaryings[vertVaryingIndex];
             if (output->name == input->name)
             {
                 if (!linkValidateVariables(infoLog, output->name, *input, *output))
@@ -1536,7 +1536,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
     mVertexWorkarounds = vertexShader->getD3DWorkarounds();
 
     // Map the varyings to the register file
-    const gl::ShaderVariable *packing[IMPLEMENTATION_MAX_VARYING_VECTORS][4] = {NULL};
+    VaryingPacking packing = { NULL };
     int registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShader, vertexShader, transformFeedbackVaryings);
 
     if (registers < 0)
@@ -1602,7 +1602,7 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
 
         if (usesGeometryShader())
         {
-            std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, packing, fragmentShader, vertexShader);
+            std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShader, vertexShader);
             mGeometryExecutable = mRenderer->compileToExecutable(infoLog, geometryHLSL.c_str(), rx::SHADER_GEOMETRY,
                                                                  mTransformFeedbackLinkedVaryings,
                                                                  (mTransformFeedbackBufferMode == GL_SEPARATE_ATTRIBS),

src/libGLESv2/Shader.cpp

@@ -125,7 +125,7 @@ const std::vector<InterfaceBlock> &Shader::getInterfaceBlocks() const
     return mActiveInterfaceBlocks;
 }
 
-std::vector<Varying> &Shader::getVaryings()
+std::vector<PackedVarying> &Shader::getVaryings()
 {
     return mVaryings;
 }
@@ -227,7 +227,11 @@ void Shader::parseVaryings(void *compiler)
     {
         std::vector<Varying> *activeVaryings;
         ShGetInfoPointer(compiler, SH_ACTIVE_VARYINGS_ARRAY, reinterpret_cast<void**>(&activeVaryings));
-        mVaryings = *activeVaryings;
+
+        for (size_t varyingIndex = 0; varyingIndex < activeVaryings->size(); varyingIndex++)
+        {
+            mVaryings.push_back(PackedVarying((*activeVaryings)[varyingIndex]));
+        }
 
         mUsesMultipleRenderTargets = mHlsl.find("GL_USES_MRT")          != std::string::npos;
         mUsesFragColor             = mHlsl.find("GL_USES_FRAG_COLOR")   != std::string::npos;
@@ -440,7 +444,7 @@ static const GLenum varyingPriorityList[] =
 };
 
 // true if varying x has a higher priority in packing than y
-bool Shader::compareVarying(const ShaderVariable &x, const ShaderVariable &y)
+bool Shader::compareVarying(const PackedVarying &x, const PackedVarying &y)
 {
     if (x.type == y.type)
     {

src/libGLESv2/Shader.h

@@ -32,6 +32,23 @@ namespace gl
 {
 class ResourceManager;
 
+struct PackedVarying : public Varying
+{
+    unsigned int registerIndex; // Assigned during link
+
+    PackedVarying(const Varying &varying)
+      : Varying(varying),
+        registerIndex(GL_INVALID_INDEX)
+    {}
+
+    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
+
+    void resetRegisterAssignment()
+    {
+        registerIndex = GL_INVALID_INDEX;
+    }
+};
+
 class Shader
 {
     friend class DynamicHLSL;
@@ -54,7 +71,7 @@ class Shader
     void getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
     const std::vector<Uniform> &getUniforms() const;
     const std::vector<InterfaceBlock> &getInterfaceBlocks() const;
-    std::vector<Varying> &getVaryings();
+    std::vector<PackedVarying> &getVaryings();
 
     virtual void compile() = 0;
     virtual void uncompile();
@@ -82,11 +99,11 @@ class Shader
 
     void getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer) const;
 
-    static bool compareVarying(const ShaderVariable &x, const ShaderVariable &y);
+    static bool compareVarying(const PackedVarying &x, const PackedVarying &y);
 
     const rx::Renderer *const mRenderer;
 
-    std::vector<Varying> mVaryings;
+    std::vector<PackedVarying> mVaryings;
 
     bool mUsesMultipleRenderTargets;
     bool mUsesFragColor;