D3D: Move some varying packing code into a new file.

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -35,6 +35,8 @@ struct Data;
 
 namespace rx
 {
+struct PackedVarying;
+struct SemanticInfo;
 class ShaderD3D;
 
 struct PixelShaderOutputVariable
@@ -45,39 +47,11 @@ struct PixelShaderOutputVariable
     size_t outputIndex;
 };
 
-struct PackedVarying
-{
-    PackedVarying(const sh::Varying &varyingIn)
-        : varying(&varyingIn), registerIndex(GL_INVALID_INDEX), columnIndex(0), vertexOnly(false)
-    {
-    }
-
-    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
-
-    void resetRegisterAssignment() { registerIndex = GL_INVALID_INDEX; }
-
-    const sh::Varying *varying;
-
-    // Assigned during link
-    unsigned int registerIndex;
-
-    // Assigned during link, Defaults to 0
-    unsigned int columnIndex;
-
-    // Transform feedback varyings can be only referenced in the VS.
-    bool vertexOnly;
-};
-
 class DynamicHLSL : angle::NonCopyable
 {
   public:
     explicit DynamicHLSL(RendererD3D *const renderer);
 
-    bool packVaryings(const gl::Caps &caps,
-                      gl::InfoLog &infoLog,
-                      std::vector<PackedVarying> *packedVaryings,
-                      const std::vector<std::string> &transformFeedbackVaryings,
-                      unsigned int *registerCountOut);
     std::string generateVertexShaderForInputLayout(
         const std::string &sourceShader,
         const gl::InputLayout &inputLayout,
@@ -112,15 +86,6 @@ class DynamicHLSL : angle::NonCopyable
   private:
     RendererD3D *const mRenderer;
 
-    struct SemanticInfo;
-
-    std::string getVaryingSemantic(bool programUsesPointSize) const;
-    SemanticInfo getSemanticInfo(ShaderType shaderType,
-                                 unsigned int startRegisters,
-                                 bool position,
-                                 bool fragCoord,
-                                 bool pointCoord,
-                                 bool pointSize) const;
     void generateVaryingLinkHLSL(const gl::Caps &caps,
                                  bool programUsesPointSize,
                                  const SemanticInfo &info,
@@ -142,6 +107,8 @@ class DynamicHLSL : angle::NonCopyable
     std::string generateAttributeConversionHLSL(gl::VertexFormatType vertexFormatType,
                                                 const sh::ShaderVariable &shaderAttrib) const;
 };
+
+std::string GetVaryingSemantic(int majorShaderModel, bool programUsesPointSize);
 }
 
 #endif  // LIBANGLE_RENDERER_D3D_DYNAMICHLSL_H_

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -20,6 +20,7 @@
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/ShaderD3D.h"
 #include "libANGLE/renderer/d3d/ShaderExecutableD3D.h"
+#include "libANGLE/renderer/d3d/VaryingPacking.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
 
 namespace rx
@@ -1261,8 +1262,8 @@ LinkResult ProgramD3D::link(const gl::Data &data, gl::InfoLog &infoLog)
 
     // Map the varyings to the register file
     unsigned int registerCount = 0;
-    if (!mDynamicHLSL->packVaryings(*data.caps, infoLog, &packedVaryings,
-                                    mData.getTransformFeedbackVaryingNames(), &registerCount))
+    if (!PackVaryings(*data.caps, infoLog, &packedVaryings,
+                      mData.getTransformFeedbackVaryingNames(), &registerCount))
     {
         return LinkResult(false, gl::Error(GL_NO_ERROR));
     }

src/libANGLE/renderer/d3d/VaryingPacking.h

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// VaryingPacking:
+//   Class which describes a mapping from varyings to registers in D3D
+//   for linking between shader stages.
+//
+
+#ifndef LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
+#define LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_
+
+#include "libANGLE/renderer/d3d/RendererD3D.h"
+
+namespace rx
+{
+
+struct PackedVarying
+{
+    PackedVarying(const sh::Varying &varyingIn)
+        : varying(&varyingIn), registerIndex(GL_INVALID_INDEX), columnIndex(0), vertexOnly(false)
+    {
+    }
+
+    bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
+
+    void resetRegisterAssignment() { registerIndex = GL_INVALID_INDEX; }
+
+    const sh::Varying *varying;
+
+    // Assigned during link
+    unsigned int registerIndex;
+
+    // Assigned during link, Defaults to 0
+    unsigned int columnIndex;
+
+    // Transform feedback varyings can be only referenced in the VS.
+    bool vertexOnly;
+};
+
+struct PackedVaryingRegister final
+{
+    PackedVaryingRegister() : varyingIndex(0), elementIndex(0), rowIndex(0) {}
+
+    PackedVaryingRegister(const PackedVaryingRegister &) = default;
+    PackedVaryingRegister &operator=(const PackedVaryingRegister &) = default;
+
+    unsigned int registerIndex(const gl::Caps &caps,
+                               const std::vector<PackedVarying> &packedVaryings) const;
+
+    size_t varyingIndex;
+    unsigned int elementIndex;
+    unsigned int rowIndex;
+};
+
+class PackedVaryingIterator final : public angle::NonCopyable
+{
+  public:
+    PackedVaryingIterator(const std::vector<PackedVarying> &packedVaryings);
+
+    class Iterator final
+    {
+      public:
+        Iterator(const PackedVaryingIterator &parent);
+
+        Iterator(const Iterator &) = default;
+        Iterator &operator=(const Iterator &) = delete;
+
+        Iterator &operator++();
+        bool operator==(const Iterator &other) const;
+        bool operator!=(const Iterator &other) const;
+
+        const PackedVaryingRegister &operator*() const { return mRegister; }
+        void setEnd() { mRegister.varyingIndex = mParent.mPackedVaryings.size(); }
+
+      private:
+        const PackedVaryingIterator &mParent;
+        PackedVaryingRegister mRegister;
+    };
+
+    Iterator begin() const;
+    const Iterator &end() const;
+
+  private:
+    const std::vector<PackedVarying> &mPackedVaryings;
+    Iterator mEnd;
+};
+
+typedef const PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
+
+bool PackVaryings(const gl::Caps &caps,
+                  gl::InfoLog &infoLog,
+                  std::vector<PackedVarying> *packedVaryings,
+                  const std::vector<std::string> &transformFeedbackVaryings,
+                  unsigned int *registerCountOut);
+
+struct SemanticInfo final
+{
+    struct BuiltinInfo final
+    {
+        BuiltinInfo();
+
+        std::string str() const;
+        void enableSystem(const std::string &systemValueSemantic);
+        void enable(const std::string &semanticVal, unsigned int indexVal);
+
+        bool enabled;
+        std::string semantic;
+        unsigned int index;
+        bool systemValue;
+    };
+
+    BuiltinInfo dxPosition;
+    BuiltinInfo glPosition;
+    BuiltinInfo glFragCoord;
+    BuiltinInfo glPointCoord;
+    BuiltinInfo glPointSize;
+};
+
+SemanticInfo GetSemanticInfo(ShaderType shaderType,
+                             unsigned int startRegisters,
+                             bool position,
+                             bool fragCoord,
+                             bool pointCoord,
+                             bool pointSize);
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_VARYINGPACKING_H_

src/libGLESv2.gypi

@@ -223,6 +223,8 @@
             'libANGLE/renderer/d3d/TextureStorage.h',
             'libANGLE/renderer/d3d/TransformFeedbackD3D.cpp',
             'libANGLE/renderer/d3d/TransformFeedbackD3D.h',
+            'libANGLE/renderer/d3d/VaryingPacking.cpp',
+            'libANGLE/renderer/d3d/VaryingPacking.h',
             'libANGLE/renderer/d3d/VertexBuffer.cpp',
             'libANGLE/renderer/d3d/VertexBuffer.h',
             'libANGLE/renderer/d3d/VertexDataManager.cpp',