D3D: Rework varying packing code.

src/libANGLE/Shader.cpp

@@ -48,6 +48,8 @@ const std::vector<VarT> &GetShaderVariables(const std::vector<VarT> *variableLis
     return *variableList;
 }
 
+}  // anonymous namespace
+
 // true if varying x has a higher priority in packing than y
 bool CompareVarying(const sh::Varying &x, const sh::Varying &y)
 {
@@ -70,8 +72,6 @@ bool CompareVarying(const sh::Varying &x, const sh::Varying &y)
     return gl::VariableSortOrder(x.type) < gl::VariableSortOrder(y.type);
 }
 
-}  // anonymous namespace
-
 Shader::Data::Data(GLenum shaderType) : mShaderType(shaderType), mShaderVersion(100)
 {
 }

src/libANGLE/Shader.h

@@ -137,6 +137,7 @@ class Shader : angle::NonCopyable
     ResourceManager *mResourceManager;
 };
 
+bool CompareVarying(const sh::Varying &x, const sh::Varying &y);
 }
 
 #endif   // LIBANGLE_SHADER_H_

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -37,8 +37,8 @@ namespace rx
 {
 struct PackedVarying;
 class ProgramD3DMetadata;
-struct SemanticInfo;
 class ShaderD3D;
+class VaryingPacking;
 
 struct PixelShaderOutputVariable
 {
@@ -65,19 +65,11 @@ class DynamicHLSL : angle::NonCopyable
     bool generateShaderLinkHLSL(const gl::Data &data,
                                 const gl::Program::Data &programData,
                                 const ProgramD3DMetadata &programMetadata,
-                                gl::InfoLog &infoLog,
-                                unsigned int registerCount,
+                                const VaryingPacking &varyingPacking,
                                 std::string *pixelHLSL,
-                                std::string *vertexHLSL,
-                                const std::vector<PackedVarying> &packedVaryings,
-                                std::vector<D3DVarying> *d3dVaryingsOut) const;
+                                std::string *vertexHLSL) const;
 
-    std::string generateGeometryShaderPreamble(
-        const gl::Data &data,
-        const gl::Program::Data &programData,
-        const ProgramD3DMetadata &programMetadata,
-        unsigned int registers,
-        const std::vector<PackedVarying> &packedVaryings) const;
+    std::string generateGeometryShaderPreamble(const VaryingPacking &varyingPacking) const;
 
     std::string generateGeometryShaderHLSL(gl::PrimitiveType primitiveType,
                                            const gl::Data &data,
@@ -92,20 +84,11 @@ class DynamicHLSL : angle::NonCopyable
   private:
     RendererD3D *const mRenderer;
 
-    void generateVaryingLinkHLSL(const gl::Caps &caps,
-                                 bool programUsesPointSize,
-                                 const SemanticInfo &info,
-                                 const std::vector<PackedVarying> &packedVaryings,
+    void generateVaryingLinkHLSL(ShaderType shaderType,
+                                 const VaryingPacking &varyingPacking,
                                  std::stringstream &linkStream) const;
-    void generateVaryingHLSL(const gl::Caps &caps,
-                             const std::vector<PackedVarying> &varyings,
-                             bool programUsesPointSize,
+    void generateVaryingHLSL(const VaryingPacking &varyingPacking,
                              std::stringstream &hlslStream) const;
-    void storeUserVaryings(const std::vector<PackedVarying> &packedVaryings,
-                           bool programUsesPointSize,
-                           std::vector<D3DVarying> *d3dVaryingsOut) const;
-    void storeBuiltinVaryings(const SemanticInfo &info,
-                              std::vector<D3DVarying> *d3dVaryingsOut) const;
 
     // Prepend an underscore
     static std::string decorateVariable(const std::string &name);

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -80,26 +80,21 @@ struct D3DUniformBlock
     unsigned int psRegisterIndex;
 };
 
-struct D3DVarying
+struct D3DVarying final
 {
     D3DVarying();
-    D3DVarying(const std::string &name,
-               GLenum type,
-               GLsizei size,
-               const std::string &semanticName,
-               unsigned int semanticIndex,
-               unsigned int semanticIndexCount);
-
-    // Original GL name
-    std::string name;
+    D3DVarying(const std::string &semanticNameIn,
+               unsigned int semanticIndexIn,
+               unsigned int componentCountIn,
+               unsigned int outputSlotIn);
 
-    GLenum type;
-    GLsizei size;
+    D3DVarying(const D3DVarying &) = default;
+    D3DVarying &operator=(const D3DVarying &) = default;
 
-    // DirectX semantic information
     std::string semanticName;
     unsigned int semanticIndex;
-    unsigned int semanticIndexCount;
+    unsigned int componentCount;
+    unsigned int outputSlot;
 };
 
 class ProgramD3DMetadata : angle::NonCopyable
@@ -336,7 +331,7 @@ class ProgramD3D : public ProgramImpl
 
     LinkResult compileProgramExecutables(const gl::Data &data, gl::InfoLog &infoLog);
 
-    void gatherTransformFeedbackVaryings(const std::vector<D3DVarying> &varyings);
+    void gatherTransformFeedbackVaryings(const VaryingPacking &varyings);
     D3DUniform *getD3DUniformByName(const std::string &name);
     D3DUniform *getD3DUniformFromLocation(GLint location);
 
@@ -394,7 +389,7 @@ class ProgramD3D : public ProgramImpl
     VertexExecutable::Signature mCachedVertexSignature;
     gl::InputLayout mCachedInputLayout;
 
-    std::vector<D3DVarying> mTransformFeedbackD3DVaryings;
+    std::vector<D3DVarying> mStreamOutVaryings;
     std::vector<D3DUniform *> mD3DUniforms;
     std::vector<D3DUniformBlock> mD3DUniformBlocks;
 

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -56,7 +56,8 @@ enum ShaderType
 {
     SHADER_VERTEX,
     SHADER_PIXEL,
-    SHADER_GEOMETRY
+    SHADER_GEOMETRY,
+    SHADER_TYPE_MAX
 };
 
 struct DeviceIdentifier
@@ -206,13 +207,13 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     virtual gl::Error loadExecutable(const void *function,
                                      size_t length,
                                      ShaderType type,
-                                     const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                     const std::vector<D3DVarying> &streamOutVaryings,
                                      bool separatedOutputBuffers,
                                      ShaderExecutableD3D **outExecutable) = 0;
     virtual gl::Error compileToExecutable(gl::InfoLog &infoLog,
                                           const std::string &shaderHLSL,
                                           ShaderType type,
-                                          const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                          const std::vector<D3DVarying> &streamOutVaryings,
                                           bool separatedOutputBuffers,
                                           const D3DCompilerWorkarounds &workarounds,
                                           ShaderExecutableD3D **outExectuable) = 0;

src/libANGLE/renderer/d3d/VaryingPacking.h

@@ -19,88 +19,92 @@ class ProgramD3DMetadata;
 
 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; }
+    PackedVarying(const sh::Varying &varyingIn) : varying(&varyingIn), vertexOnly(false) {}
 
     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()
+        : packedVarying(nullptr),
+          varyingArrayIndex(0),
+          varyingRowIndex(0),
+          registerRow(0),
+          registerColumn(0)
+    {
+    }
 
     PackedVaryingRegister(const PackedVaryingRegister &) = default;
     PackedVaryingRegister &operator=(const PackedVaryingRegister &) = default;
 
-    unsigned int registerIndex(const gl::Caps &caps,
-                               const std::vector<PackedVarying> &packedVaryings) const;
+    bool operator<(const PackedVaryingRegister &other) const
+    {
+        return sortOrder() < other.sortOrder();
+    }
+
+    unsigned int sortOrder() const
+    {
+        // TODO(jmadill): Handle interpolation types
+        return registerRow * 4 + registerColumn;
+    }
+
+    // Index to the array of varyings.
+    const PackedVarying *packedVarying;
+
+    // The array element of the packed varying.
+    unsigned int varyingArrayIndex;
+
+    // The row of the array element of the packed varying.
+    unsigned int varyingRowIndex;
+
+    // The register row to which we've assigned this packed varying.
+    unsigned int registerRow;
 
-    size_t varyingIndex;
-    unsigned int elementIndex;
-    unsigned int rowIndex;
+    // The column of the register row into which we've packed this varying.
+    unsigned int registerColumn;
+
+    // Assigned after packing
+    unsigned int semanticIndex;
 };
 
-class PackedVaryingIterator final : public angle::NonCopyable
+class VaryingPacking final : angle::NonCopyable
 {
   public:
-    PackedVaryingIterator(const std::vector<PackedVarying> &packedVaryings);
-
-    class Iterator final
-    {
-      public:
-        Iterator(const PackedVaryingIterator &parent);
+    VaryingPacking(GLuint maxVaryingVectors);
 
-        Iterator(const Iterator &) = default;
-        Iterator &operator=(const Iterator &) = delete;
+    bool packVaryings(gl::InfoLog &infoLog,
+                      const std::vector<PackedVarying> &packedVaryings,
+                      const std::vector<std::string> &transformFeedbackVaryings);
 
-        Iterator &operator++();
-        bool operator==(const Iterator &other) const;
-        bool operator!=(const Iterator &other) const;
+    struct Register
+    {
+        Register() { data[0] = data[1] = data[2] = data[3] = false; }
 
-        const PackedVaryingRegister &operator*() const { return mRegister; }
-        void setEnd() { mRegister.varyingIndex = mParent.mPackedVaryings.size(); }
+        bool &operator[](unsigned int index) { return data[index]; }
+        bool operator[](unsigned int index) const { return data[index]; }
 
-      private:
-        const PackedVaryingIterator &mParent;
-        PackedVaryingRegister mRegister;
+        bool data[4];
     };
 
-    Iterator begin() const;
-    const Iterator &end() const;
+    Register &operator[](unsigned int index) { return mRegisterMap[index]; }
+    const Register &operator[](unsigned int index) const { return mRegisterMap[index]; }
 
-  private:
-    const std::vector<PackedVarying> &mPackedVaryings;
-    Iterator mEnd;
-};
-
-typedef const PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
+    const std::vector<PackedVaryingRegister> &getRegisterList() const { return mRegisterList; }
+    unsigned int getMaxSemanticIndex() const
+    {
+        return static_cast<unsigned int>(mRegisterList.size());
+    }
+    unsigned int getRegisterCount() const;
 
-bool PackVaryings(const gl::Caps &caps,
-                  gl::InfoLog &infoLog,
-                  std::vector<PackedVarying> *packedVaryings,
-                  const std::vector<std::string> &transformFeedbackVaryings,
-                  unsigned int *registerCountOut);
+    void enableBuiltins(ShaderType shaderType, const ProgramD3DMetadata &programMetadata);
 
-struct SemanticInfo final
-{
-    struct BuiltinInfo final
+    struct BuiltinVarying final : angle::NonCopyable
     {
-        BuiltinInfo();
+        BuiltinVarying();
 
         std::string str() const;
         void enableSystem(const std::string &systemValueSemantic);
@@ -112,16 +116,34 @@ struct SemanticInfo final
         bool systemValue;
     };
 
-    BuiltinInfo dxPosition;
-    BuiltinInfo glPosition;
-    BuiltinInfo glFragCoord;
-    BuiltinInfo glPointCoord;
-    BuiltinInfo glPointSize;
-};
+    struct BuiltinInfo
+    {
+        BuiltinVarying dxPosition;
+        BuiltinVarying glPosition;
+        BuiltinVarying glFragCoord;
+        BuiltinVarying glPointCoord;
+        BuiltinVarying glPointSize;
+    };
 
-SemanticInfo GetSemanticInfo(ShaderType shaderType,
-                             const ProgramD3DMetadata &programMetadata,
-                             unsigned int startRegisters);
+    const BuiltinInfo &builtins(ShaderType shaderType) const { return mBuiltinInfo[shaderType]; }
+
+    bool usesPointSize() const { return mBuiltinInfo[SHADER_VERTEX].glPointSize.enabled; }
+
+  private:
+    bool packVarying(const PackedVarying &packedVarying);
+    bool isFree(unsigned int registerRow,
+                unsigned int registerColumn,
+                unsigned int varyingRows,
+                unsigned int varyingColumns) const;
+    void insert(unsigned int registerRow,
+                unsigned int registerColumn,
+                const PackedVarying &packedVarying);
+
+    std::vector<Register> mRegisterMap;
+    std::vector<PackedVaryingRegister> mRegisterList;
+
+    std::vector<BuiltinInfo> mBuiltinInfo;
+};
 
 }  // namespace rx
 

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -3257,7 +3257,7 @@ ProgramImpl *Renderer11::createProgram(const gl::Program::Data &data)
 gl::Error Renderer11::loadExecutable(const void *function,
                                      size_t length,
                                      ShaderType type,
-                                     const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                     const std::vector<D3DVarying> &streamOutVaryings,
                                      bool separatedOutputBuffers,
                                      ShaderExecutableD3D **outExecutable)
 {
@@ -3275,25 +3275,22 @@ gl::Error Renderer11::loadExecutable(const void *function,
                 return gl::Error(GL_OUT_OF_MEMORY, "Failed to create vertex shader, result: 0x%X.", result);
             }
 
-            if (transformFeedbackVaryings.size() > 0)
+            if (!streamOutVaryings.empty())
             {
                 std::vector<D3D11_SO_DECLARATION_ENTRY> soDeclaration;
-                for (size_t i = 0; i < transformFeedbackVaryings.size(); i++)
+                soDeclaration.reserve(streamOutVaryings.size());
+
+                for (const auto &streamOutVarying : streamOutVaryings)
                 {
-                    const D3DVarying &varying = transformFeedbackVaryings[i];
-                    GLenum transposedType = gl::TransposeMatrixType(varying.type);
-
-                    for (unsigned int j = 0; j < varying.semanticIndexCount; j++)
-                    {
-                        D3D11_SO_DECLARATION_ENTRY entry = { 0 };
-                        entry.Stream = 0;
-                        entry.SemanticName = varying.semanticName.c_str();
-                        entry.SemanticIndex = varying.semanticIndex + j;
-                        entry.StartComponent = 0;
-                        entry.ComponentCount = static_cast<BYTE>(gl::VariableColumnCount(transposedType));
-                        entry.OutputSlot = static_cast<BYTE>((separatedOutputBuffers ? i : 0));
-                        soDeclaration.push_back(entry);
-                    }
+                    D3D11_SO_DECLARATION_ENTRY entry = {0};
+                    entry.Stream                     = 0;
+                    entry.SemanticName               = streamOutVarying.semanticName.c_str();
+                    entry.SemanticIndex              = streamOutVarying.semanticIndex;
+                    entry.StartComponent             = 0;
+                    entry.ComponentCount             = static_cast<BYTE>(streamOutVarying.componentCount);
+                    entry.OutputSlot = static_cast<BYTE>(
+                        (separatedOutputBuffers ? streamOutVarying.outputSlot : 0));
+                    soDeclaration.push_back(entry);
                 }
 
                 result = mDevice->CreateGeometryShaderWithStreamOutput(
@@ -3349,7 +3346,7 @@ gl::Error Renderer11::loadExecutable(const void *function,
 gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
                                           const std::string &shaderHLSL,
                                           ShaderType type,
-                                          const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                          const std::vector<D3DVarying> &streamOutVaryings,
                                           bool separatedOutputBuffers,
                                           const D3DCompilerWorkarounds &workarounds,
                                           ShaderExecutableD3D **outExectuable)
@@ -3422,7 +3419,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
     }
 
     error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                           transformFeedbackVaryings, separatedOutputBuffers, outExectuable);
+                           streamOutVaryings, separatedOutputBuffers, outExectuable);
 
     SafeRelease(binary);
     if (error.isError())

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -191,13 +191,13 @@ class Renderer11 : public RendererD3D
     gl::Error loadExecutable(const void *function,
                              size_t length,
                              ShaderType type,
-                             const std::vector<D3DVarying> &transformFeedbackVaryings,
+                             const std::vector<D3DVarying> &streamOutVaryings,
                              bool separatedOutputBuffers,
                              ShaderExecutableD3D **outExecutable) override;
     gl::Error compileToExecutable(gl::InfoLog &infoLog,
                                   const std::string &shaderHLSL,
                                   ShaderType type,
-                                  const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                  const std::vector<D3DVarying> &streamOutVaryings,
                                   bool separatedOutputBuffers,
                                   const D3DCompilerWorkarounds &workarounds,
                                   ShaderExecutableD3D **outExectuable) override;

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -2735,12 +2735,12 @@ ProgramImpl *Renderer9::createProgram(const gl::Program::Data &data)
 gl::Error Renderer9::loadExecutable(const void *function,
                                     size_t length,
                                     ShaderType type,
-                                    const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                    const std::vector<D3DVarying> &streamOutVaryings,
                                     bool separatedOutputBuffers,
                                     ShaderExecutableD3D **outExecutable)
 {
     // Transform feedback is not supported in ES2 or D3D9
-    ASSERT(transformFeedbackVaryings.size() == 0);
+    ASSERT(streamOutVaryings.empty());
 
     switch (type)
     {
@@ -2777,13 +2777,13 @@ gl::Error Renderer9::loadExecutable(const void *function,
 gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
                                          const std::string &shaderHLSL,
                                          ShaderType type,
-                                         const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                         const std::vector<D3DVarying> &streamOutVaryings,
                                          bool separatedOutputBuffers,
                                          const D3DCompilerWorkarounds &workarounds,
                                          ShaderExecutableD3D **outExectuable)
 {
     // Transform feedback is not supported in ES2 or D3D9
-    ASSERT(transformFeedbackVaryings.size() == 0);
+    ASSERT(streamOutVaryings.empty());
 
     const char *profileType = NULL;
     switch (type)
@@ -2846,7 +2846,7 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
     }
 
     error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
-                           transformFeedbackVaryings, separatedOutputBuffers, outExectuable);
+                           streamOutVaryings, separatedOutputBuffers, outExectuable);
 
     SafeRelease(binary);
     if (error.isError())

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -179,13 +179,13 @@ class Renderer9 : public RendererD3D
     gl::Error loadExecutable(const void *function,
                              size_t length,
                              ShaderType type,
-                             const std::vector<D3DVarying> &transformFeedbackVaryings,
+                             const std::vector<D3DVarying> &streamOutVaryings,
                              bool separatedOutputBuffers,
                              ShaderExecutableD3D **outExecutable) override;
     gl::Error compileToExecutable(gl::InfoLog &infoLog,
                                   const std::string &shaderHLSL,
                                   ShaderType type,
-                                  const std::vector<D3DVarying> &transformFeedbackVaryings,
+                                  const std::vector<D3DVarying> &streamOutVaryings,
                                   bool separatedOutputBuffers,
                                   const D3DCompilerWorkarounds &workarounds,
                                   ShaderExecutableD3D **outExectuable) override;

src/tests/gl_tests/GLSLTest.cpp

@@ -828,8 +828,14 @@ TEST_P(GLSLTest, MaxVaryingVec3Array)
 }
 
 // Disabled because of a failure in D3D9
-TEST_P(GLSLTest, DISABLED_MaxVaryingVec3AndOneFloat)
+TEST_P(GLSLTest, MaxVaryingVec3AndOneFloat)
 {
+    if (isD3D9())
+    {
+        std::cout << "Test disabled on D3D9." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
@@ -837,8 +843,14 @@ TEST_P(GLSLTest, DISABLED_MaxVaryingVec3AndOneFloat)
 }
 
 // Disabled because of a failure in D3D9
-TEST_P(GLSLTest, DISABLED_MaxVaryingVec3ArrayAndOneFloatArray)
+TEST_P(GLSLTest, MaxVaryingVec3ArrayAndOneFloatArray)
 {
+    if (isD3D9())
+    {
+        std::cout << "Test disabled on D3D9." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
@@ -846,8 +858,14 @@ TEST_P(GLSLTest, DISABLED_MaxVaryingVec3ArrayAndOneFloatArray)
 }
 
 // Disabled because of a failure in D3D9
-TEST_P(GLSLTest, DISABLED_TwiceMaxVaryingVec2)
+TEST_P(GLSLTest, TwiceMaxVaryingVec2)
 {
+    if (isD3D9())
+    {
+        std::cout << "Test disabled on D3D9." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 
@@ -855,8 +873,14 @@ TEST_P(GLSLTest, DISABLED_TwiceMaxVaryingVec2)
 }
 
 // Disabled because of a failure in D3D9
-TEST_P(GLSLTest, DISABLED_MaxVaryingVec2Arrays)
+TEST_P(GLSLTest, MaxVaryingVec2Arrays)
 {
+    if (isD3DSM3())
+    {
+        std::cout << "Test disabled on SM3." << std::endl;
+        return;
+    }
+
     GLint maxVaryings = 0;
     glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
 

src/tests/test_utils/ANGLETest.cpp

@@ -298,6 +298,24 @@ bool ANGLETest::isD3D11() const
     return (rendererString.find("Direct3D11 vs_5_0") != std::string::npos);
 }
 
+bool ANGLETest::isD3D11_FL93() const
+{
+    std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
+    return (rendererString.find("Direct3D11 vs_4_0_") != std::string::npos);
+}
+
+bool ANGLETest::isD3D9() const
+{
+    std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
+    return (rendererString.find("Direct3D9") != std::string::npos);
+}
+
+bool ANGLETest::isD3DSM3() const
+{
+    std::string rendererString(reinterpret_cast<const char *>(glGetString(GL_RENDERER)));
+    return isD3D9() || isD3D11_FL93();
+}
+
 EGLint ANGLETest::getPlatformRenderer() const
 {
     assert(mEGLWindow);

src/tests/test_utils/ANGLETest.h

@@ -100,6 +100,11 @@ class ANGLETest : public ::testing::TestWithParam<angle::PlatformParameters>
     bool isNVidia() const;
     // Note: FL9_3 is explicitly *not* considered D3D11.
     bool isD3D11() const;
+    bool isD3D11_FL93() const;
+    // Is a D3D9-class renderer.
+    bool isD3D9() const;
+    // Is D3D9 or SM9_3 renderer.
+    bool isD3DSM3() const;
     EGLint getPlatformRenderer() const;
 
   private:

util/Vector.cpp

@@ -19,6 +19,22 @@ Vector2::Vector2(float x, float y) : x(x), y(y)
 {
 }
 
+bool Vector2::operator==(const Vector2 &vec) const
+{
+    return x == vec.x && y == vec.y;
+}
+
+bool Vector2::operator!=(const Vector2 &vec) const
+{
+    return !(*this == vec);
+}
+
+std::ostream &operator<<(std::ostream &stream, const Vector2 &vec)
+{
+    stream << "(" << vec.x << "," << vec.y << ")";
+    return stream;
+}
+
 float Vector2::length(const Vector2 &vec)
 {
     float lenSquared = lengthSquared(vec);

util/Vector.h

@@ -10,11 +10,16 @@
 #ifndef UTIL_VECTOR_H
 #define UTIL_VECTOR_H
 
+#include <ostream>
+
 struct Vector2
 {
     Vector2();
     Vector2(float x, float y);
 
+    bool operator==(const Vector2 &vec) const;
+    bool operator!=(const Vector2 &vec) const;
+
     static float length(const Vector2 &vec);
     static float lengthSquared(const Vector2 &vec);
 
@@ -26,6 +31,8 @@ struct Vector2
     float x, y;
 };
 
+std::ostream &operator<<(std::ostream &stream, const Vector2 &vec);
+
 struct Vector3
 {
     Vector3();