Clean up VaryingPacking

src/libANGLE/VaryingPacking.cpp

@@ -318,14 +318,13 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                     for (const auto &field : varying->fields)
                     {
                         ASSERT(!field.isStruct() && !field.isArray());
-                        mPackedVaryings.push_back(
-                            PackedVarying(field, interpolation, varying->name));
+                        mPackedVaryings.emplace_back(field, interpolation, varying->name);
                         uniqueFullNames.insert(mPackedVaryings.back().fullName());
                     }
                 }
                 else
                 {
-                    mPackedVaryings.push_back(PackedVarying(*varying, interpolation));
+                    mPackedVaryings.emplace_back(*varying, interpolation);
                     uniqueFullNames.insert(mPackedVaryings.back().fullName());
                 }
                 continue;
@@ -395,13 +394,12 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
 
     std::sort(mPackedVaryings.begin(), mPackedVaryings.end(), ComparePackedVarying);
 
-    return packUserVaryings(infoLog, mPackedVaryings, tfVaryings);
+    return packUserVaryings(infoLog, mPackedVaryings);
 }
 
 // See comment on packVarying.
 bool VaryingPacking::packUserVaryings(gl::InfoLog &infoLog,
-                                      const std::vector<PackedVarying> &packedVaryings,
-                                      const std::vector<std::string> &transformFeedbackVaryings)
+                                      const std::vector<PackedVarying> &packedVaryings)
 {
 
     // "Variables are packed into the registers one at a time so that they each occupy a contiguous
@@ -426,13 +424,6 @@ bool VaryingPacking::packUserVaryings(gl::InfoLog &infoLog,
     // Sort the packed register list
     std::sort(mRegisterList.begin(), mRegisterList.end());
 
-    // Assign semantic indices
-    for (unsigned int semanticIndex = 0;
-         semanticIndex < static_cast<unsigned int>(mRegisterList.size()); ++semanticIndex)
-    {
-        mRegisterList[semanticIndex].semanticIndex = semanticIndex;
-    }
-
     return true;
 }
 

src/libANGLE/VaryingPacking.h

@@ -128,9 +128,6 @@ struct PackedVaryingRegister final
 
     // The column of the register row into which we've packed this varying.
     unsigned int registerColumn;
-
-    // Assigned after packing
-    unsigned int semanticIndex;
 };
 
 // Supported packing modes:
@@ -152,9 +149,7 @@ class VaryingPacking final : angle::NonCopyable
     VaryingPacking(GLuint maxVaryingVectors, PackMode packMode);
     ~VaryingPacking();
 
-    bool packUserVaryings(gl::InfoLog &infoLog,
-                          const std::vector<PackedVarying> &packedVaryings,
-                          const std::vector<std::string> &tfVaryings);
+    bool packUserVaryings(gl::InfoLog &infoLog, const std::vector<PackedVarying> &packedVaryings);
 
     bool collectAndPackUserVaryings(gl::InfoLog &infoLog,
                                     const ProgramMergedVaryings &mergedVaryings,

src/libANGLE/VaryingPacking_unittest.cpp

@@ -38,7 +38,7 @@ class VaryingPackingTest : public ::testing::TestWithParam<GLuint>
         InfoLog infoLog;
         std::vector<std::string> transformFeedbackVaryings;
 
-        return varyingPacking->packUserVaryings(infoLog, packedVaryings, transformFeedbackVaryings);
+        return varyingPacking->packUserVaryings(infoLog, packedVaryings);
     }
 
     // Uses the "relaxed" ANGLE packing mode.

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -411,8 +411,10 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
     std::string varyingSemantic =
         GetVaryingSemantic(mRenderer->getMajorShaderModel(), programUsesPointSize);
 
-    for (const PackedVaryingRegister &registerInfo : varyingPacking.getRegisterList())
+    const auto &registerInfos = varyingPacking.getRegisterList();
+    for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
     {
+        const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
         const auto &varying = *registerInfo.packedVarying->varying;
         ASSERT(!varying.isStruct());
 
@@ -442,8 +444,7 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
         GLenum componentType  = gl::VariableComponentType(transposedType);
         int columnCount       = gl::VariableColumnCount(transposedType);
         HLSLComponentTypeString(hlslStream, componentType, columnCount);
-        unsigned int semanticIndex = registerInfo.semanticIndex;
-        hlslStream << " v" << semanticIndex << " : " << varyingSemantic << semanticIndex << ";\n";
+        hlslStream << " v" << registerIndex << " : " << varyingSemantic << registerIndex << ";\n";
     }
 
     hlslStream << "};\n";
@@ -583,13 +584,15 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context,
         vertexStream << "    output.gl_FragCoord = gl_Position;\n";
     }
 
-    for (const PackedVaryingRegister &registerInfo : varyingPacking.getRegisterList())
+    const auto &registerInfos = varyingPacking.getRegisterList();
+    for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
     {
+        const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
         const auto &packedVarying = *registerInfo.packedVarying;
         const auto &varying = *packedVarying.varying;
         ASSERT(!varying.isStruct());
 
-        vertexStream << "    output.v" << registerInfo.semanticIndex << " = ";
+        vertexStream << "    output.v" << registerIndex << " = ";
 
         if (packedVarying.isStructField())
         {
@@ -787,8 +790,9 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context,
         }
     }
 
-    for (const PackedVaryingRegister &registerInfo : varyingPacking.getRegisterList())
+    for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
     {
+        const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
         const auto &packedVarying = *registerInfo.packedVarying;
         const auto &varying = *packedVarying.varying;
         ASSERT(!varying.isBuiltIn() && !varying.isStruct());
@@ -818,7 +822,7 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context,
             WriteArrayString(pixelStream, registerInfo.varyingRowIndex);
         }
 
-        pixelStream << " = input.v" << registerInfo.semanticIndex;
+        pixelStream << " = input.v" << registerIndex;
 
         switch (VariableColumnCount(transposedType))
         {
@@ -967,14 +971,16 @@ std::string DynamicHLSL::generateGeometryShaderPreamble(const VaryingPacking &va
         }
     }
 
-    for (const PackedVaryingRegister &varyingRegister : varyingPacking.getRegisterList())
+    const auto &registerInfos = varyingPacking.getRegisterList();
+    for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
     {
-        preambleStream << "    output.v" << varyingRegister.semanticIndex << " = ";
+        const PackedVaryingRegister &varyingRegister = registerInfos[registerIndex];
+        preambleStream << "    output.v" << registerIndex << " = ";
         if (varyingRegister.packedVarying->interpolation == sh::INTERPOLATION_FLAT)
         {
             preambleStream << "flat";
         }
-        preambleStream << "input.v" << varyingRegister.semanticIndex << "; \n";
+        preambleStream << "input.v" << registerIndex << "; \n";
     }
 
     if (vertexBuiltins.glFragCoord.enabled)

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -2607,29 +2607,31 @@ void ProgramD3D::gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyi
         {
             if (builtins.glPosition.enabled)
             {
-                mStreamOutVaryings.push_back(D3DVarying(builtins.glPosition.semantic,
-                                                        builtins.glPosition.index, 4, outputSlot));
+                mStreamOutVaryings.emplace_back(builtins.glPosition.semantic,
+                                                builtins.glPosition.index, 4, outputSlot);
             }
         }
         else if (tfVaryingName == "gl_FragCoord")
         {
             if (builtins.glFragCoord.enabled)
             {
-                mStreamOutVaryings.push_back(D3DVarying(builtins.glFragCoord.semantic,
-                                                        builtins.glFragCoord.index, 4, outputSlot));
+                mStreamOutVaryings.emplace_back(builtins.glFragCoord.semantic,
+                                                builtins.glFragCoord.index, 4, outputSlot);
             }
         }
         else if (tfVaryingName == "gl_PointSize")
         {
             if (builtins.glPointSize.enabled)
             {
-                mStreamOutVaryings.push_back(D3DVarying("PSIZE", 0, 1, outputSlot));
+                mStreamOutVaryings.emplace_back("PSIZE", 0, 1, outputSlot);
             }
         }
         else
         {
-            for (const auto &registerInfo : varyingPacking.getRegisterList())
+            const auto &registerInfos = varyingPacking.getRegisterList();
+            for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
             {
+                const auto &registerInfo = registerInfos[registerIndex];
                 const auto &varying   = *registerInfo.packedVarying->varying;
                 GLenum transposedType = gl::TransposeMatrixType(varying.type);
                 int componentCount    = gl::VariableColumnCount(transposedType);
@@ -2639,8 +2641,8 @@ void ProgramD3D::gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyi
                 // register needs its own stream out entry.
                 if (registerInfo.tfVaryingName() == tfVaryingName)
                 {
-                    mStreamOutVaryings.push_back(D3DVarying(
-                        varyingSemantic, registerInfo.semanticIndex, componentCount, outputSlot));
+                    mStreamOutVaryings.emplace_back(varyingSemantic, registerIndex, componentCount,
+                                                    outputSlot);
                 }
             }
         }