GLES1: glLoadIdentity / glLoadMatrix(f|x)

src/common/matrix_utils.h

@@ -94,6 +94,28 @@ class Matrix
         memcpy(mElements.data(), res.data(), numElts * sizeof(float));
     }
 
+    bool operator==(const Matrix<T> &m) const
+    {
+        ASSERT(columns() == m.columns());
+        ASSERT(rows() == m.rows());
+        return mElements == m.elements();
+    }
+
+    bool operator!=(const Matrix<T> &m) const { return !(mElements == m.elements()); }
+
+    bool nearlyEqual(T epsilon, const Matrix<T> &m) const
+    {
+        ASSERT(columns() == m.columns());
+        ASSERT(rows() == m.rows());
+        const auto &otherElts = m.elements();
+        for (size_t i = 0; i < otherElts.size(); i++)
+        {
+            if ((mElements[i] - otherElts[i] > epsilon) && (otherElts[i] - mElements[i] > epsilon))
+                return false;
+        }
+        return true;
+    }
+
     unsigned int size() const
     {
         ASSERT(rows() == columns());

src/common/matrix_utils_unittest.cpp

@@ -505,8 +505,8 @@ TEST(MatrixUtilsTest, Mat4Translate)
     Mat4 golden1(elementsExpected1);
     Mat4 golden2(elementsExpected2);
 
-    Mat4 t1 = Mat4::Translate(Vector3(1.f, 1.f, 1.f));
-    Mat4 t2 = Mat4::Translate(Vector3(2.f, 2.f, 2.f));
+    Mat4 t1   = Mat4::Translate(Vector3(1.f, 1.f, 1.f));
+    Mat4 t2   = Mat4::Translate(Vector3(2.f, 2.f, 2.f));
     Mat4 t1t1 = t1.product(t1);
 
     CheckMat4ExactlyEq(t1, golden1);
@@ -549,12 +549,11 @@ TEST(MatrixUtilsTest, Mat4Scale)
     Mat4 golden2(elementsExpected2);
     Mat4 golden4(elementsExpected4);
 
-    Mat4 t2 = Mat4::Scale(Vector3(2.f, 2.f, 2.f));
+    Mat4 t2   = Mat4::Scale(Vector3(2.f, 2.f, 2.f));
     Mat4 t2t2 = t2.product(t2);
 
     CheckMat4ExactlyEq(t2, golden2);
     CheckMat4ExactlyEq(t2t2, golden4);
-
 }
 
 // Tests frustum matrices.
@@ -1207,4 +1206,36 @@ TEST(MatrixUtilsTest, Mat4Mult)
     Mat4 t = r.product(r);
     CheckMatrixCloseToGolden(s.data(), t);
 }
+
+// Tests exact equality.
+TEST(MatrixUtilsTest, ExactEquality)
+{
+    Mat4 a, b;
+    EXPECT_EQ(a, b);
+    Mat4 c;
+    c(0, 0) += 0.000001f;
+    EXPECT_NE(a, c);
+}
+
+// Tests near equality.
+TEST(MatrixUtilsTest, NearEquality)
+{
+    Mat4 a, b;
+
+    float *bData = b.data();
+    for (int i = 0; i < 16; i++)
+    {
+        bData[i] += 0.09f;
+    }
+
+    EXPECT_TRUE(a.nearlyEqual(0.1f, b));
+
+    for (int i = 0; i < 16; i++)
+    {
+        bData[i] -= 2 * 0.09f;
+    }
+
+    EXPECT_TRUE(a.nearlyEqual(0.1f, b));
 }
+
+}  // namespace

src/libANGLE/Context.cpp

@@ -1289,9 +1289,18 @@ void Context::getFloatvImpl(GLenum pname, GLfloat *params)
         case GL_PATH_MODELVIEW_MATRIX_CHROMIUM:
         case GL_PATH_PROJECTION_MATRIX_CHROMIUM:
         {
-            ASSERT(mExtensions.pathRendering);
-            const GLfloat *m = mGLState.getPathRenderingMatrix(pname);
-            memcpy(params, m, 16 * sizeof(GLfloat));
+            // GLES1 emulation: // GL_PATH_(MODELVIEW|PROJECTION)_MATRIX_CHROMIUM collides with the
+            // GLES1 constants for modelview/projection matrix.
+            if (getClientVersion() < Version(2, 0))
+            {
+                mGLState.getFloatv(pname, params);
+            }
+            else
+            {
+                ASSERT(mExtensions.pathRendering);
+                const GLfloat *m = mGLState.getPathRenderingMatrix(pname);
+                memcpy(params, m, 16 * sizeof(GLfloat));
+            }
         }
         break;
 
@@ -7027,6 +7036,12 @@ bool Context::getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *nu
                 *type      = GL_FLOAT;
                 *numParams = 3;
                 return true;
+            case GL_MODELVIEW_MATRIX:
+            case GL_PROJECTION_MATRIX:
+            case GL_TEXTURE_MATRIX:
+                *type      = GL_FLOAT;
+                *numParams = 16;
+                return true;
         }
     }
 

src/libANGLE/Context_gles_1_0.cpp

@@ -224,17 +224,25 @@ void Context::lineWidthx(GLfixed width)
 
 void Context::loadIdentity()
 {
-    UNIMPLEMENTED();
+    mGLState.gles1().loadMatrix(angle::Mat4());
 }
 
 void Context::loadMatrixf(const GLfloat *m)
 {
-    UNIMPLEMENTED();
+    mGLState.gles1().loadMatrix(angle::Mat4(m));
 }
 
 void Context::loadMatrixx(const GLfixed *m)
 {
-    UNIMPLEMENTED();
+    angle::Mat4 matrixAsFloat;
+    GLfloat *floatData = matrixAsFloat.data();
+
+    for (int i = 0; i < 16; i++)
+    {
+        floatData[i] = FixedToFloat(m[i]);
+    }
+
+    mGLState.gles1().loadMatrix(matrixAsFloat);
 }
 
 void Context::logicOp(GLenum opcode)

src/libANGLE/GLES1State.cpp

@@ -257,4 +257,9 @@ const GLES1State::MatrixStack &GLES1State::currentMatrixStack() const
     }
 }
 
+void GLES1State::loadMatrix(const angle::Mat4 &m)
+{
+    currentMatrixStack().back() = m;
+}
+
 }  // namespace gl

src/libANGLE/GLES1State.h

@@ -147,6 +147,8 @@ class GLES1State final : angle::NonCopyable
     MatrixStack &currentMatrixStack();
     const MatrixStack &currentMatrixStack() const;
 
+    void loadMatrix(const angle::Mat4 &m);
+
   private:
     friend class State;
 

src/libANGLE/State.cpp

@@ -1956,6 +1956,16 @@ void State::getFloatv(GLenum pname, GLfloat *params)
             params[3]            = texcoord.q;
             break;
         }
+        case GL_MODELVIEW_MATRIX:
+            memcpy(params, mGLES1State.mModelviewMatrices.back().data(), 16 * sizeof(GLfloat));
+            break;
+        case GL_PROJECTION_MATRIX:
+            memcpy(params, mGLES1State.mProjectionMatrices.back().data(), 16 * sizeof(GLfloat));
+            break;
+        case GL_TEXTURE_MATRIX:
+            memcpy(params, mGLES1State.mTextureMatrices[mActiveSampler].back().data(),
+                   16 * sizeof(GLfloat));
+            break;
         default:
             UNREACHABLE();
             break;

src/libANGLE/validationES1.cpp

@@ -323,19 +323,19 @@ bool ValidateLineWidthx(Context *context, GLfixed width)
 
 bool ValidateLoadIdentity(Context *context)
 {
-    UNIMPLEMENTED();
+    ANGLE_VALIDATE_IS_GLES1(context);
     return true;
 }
 
 bool ValidateLoadMatrixf(Context *context, const GLfloat *m)
 {
-    UNIMPLEMENTED();
+    ANGLE_VALIDATE_IS_GLES1(context);
     return true;
 }
 
 bool ValidateLoadMatrixx(Context *context, const GLfixed *m)
 {
-    UNIMPLEMENTED();
+    ANGLE_VALIDATE_IS_GLES1(context);
     return true;
 }
 

src/tests/angle_end2end_tests.gypi

@@ -52,6 +52,7 @@
             '<(angle_path)/src/tests/gl_tests/gles1/CurrentColorTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/CurrentNormalTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/CurrentTextureCoordsTest.cpp',
+            '<(angle_path)/src/tests/gl_tests/gles1/MatrixLoadTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/MatrixModeTest.cpp',
             '<(angle_path)/src/tests/gl_tests/gles1/MatrixStackTest.cpp',
             '<(angle_path)/src/tests/gl_tests/GLSLTest.cpp',

src/tests/gl_tests/gles1/MatrixLoadTest.cpp

+//
+// Copyright 2018 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.
+//
+
+// MatrixLoadTest.cpp: Tests basic usage of glColor4(f|ub|x).
+
+#include "test_utils/ANGLETest.h"
+#include "test_utils/gl_raii.h"
+
+#include "common/matrix_utils.h"
+#include "random_utils.h"
+
+#include <stdint.h>
+
+using namespace angle;
+
+class MatrixLoadTest : public ANGLETest
+{
+  protected:
+    MatrixLoadTest()
+    {
+        setWindowWidth(32);
+        setWindowHeight(32);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(24);
+    }
+};
+
+// Checks that a matrix can be loaded.
+TEST_P(MatrixLoadTest, Basic)
+{
+    angle::Mat4 testMatrix(0.0f, 4.0f, 8.0f, 12.0f, 1.0f, 5.0f, 9.0f, 10.0f, 2.0f, 6.0f, 10.0f,
+                           14.0f, 3.0f, 7.0f, 11.0f, 15.0f);
+
+    angle::Mat4 outputMatrix;
+
+    glLoadMatrixf(testMatrix.data());
+    EXPECT_GL_NO_ERROR();
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, outputMatrix.data());
+    EXPECT_GL_NO_ERROR();
+
+    EXPECT_EQ(testMatrix, outputMatrix);
+}
+
+// Checks that loading a matrix doesn't affect the matrix below in the stack.
+TEST_P(MatrixLoadTest, PushPop)
+{
+    glPushMatrix();
+
+    angle::Mat4 testMatrix(0.0f, 4.0f, 8.0f, 12.0f, 1.0f, 5.0f, 9.0f, 10.0f, 2.0f, 6.0f, 10.0f,
+                           14.0f, 3.0f, 7.0f, 11.0f, 15.0f);
+
+    angle::Mat4 outputMatrix;
+
+    glLoadMatrixf(testMatrix.data());
+    EXPECT_GL_NO_ERROR();
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, outputMatrix.data());
+    EXPECT_GL_NO_ERROR();
+
+    EXPECT_EQ(testMatrix, outputMatrix);
+
+    glPopMatrix();
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, outputMatrix.data());
+    EXPECT_GL_NO_ERROR();
+    EXPECT_EQ(angle::Mat4(), outputMatrix);
+}
+
+// Checks that matrices can be loaded for each type of matrix.
+TEST_P(MatrixLoadTest, Modes)
+{
+    angle::Mat4 testMatrix(0.0f, 4.0f, 8.0f, 12.0f, 1.0f, 5.0f, 9.0f, 10.0f, 2.0f, 6.0f, 10.0f,
+                           14.0f, 3.0f, 7.0f, 11.0f, 15.0f);
+    angle::Mat4 outputMatrix;
+
+    std::vector<std::pair<GLenum, GLenum>> modeTypes = {{GL_PROJECTION, GL_PROJECTION_MATRIX},
+                                                        {GL_MODELVIEW, GL_MODELVIEW_MATRIX},
+                                                        {GL_TEXTURE, GL_TEXTURE_MATRIX}};
+
+    for (auto modeType : modeTypes)
+    {
+        auto mode       = modeType.first;
+        auto matrixType = modeType.second;
+
+        glMatrixMode(mode);
+        EXPECT_GL_NO_ERROR();
+        glGetFloatv(matrixType, outputMatrix.data());
+        EXPECT_GL_NO_ERROR();
+        EXPECT_EQ(angle::Mat4(), outputMatrix);
+
+        glLoadMatrixf(testMatrix.data());
+        glGetFloatv(matrixType, outputMatrix.data());
+        EXPECT_GL_NO_ERROR();
+        EXPECT_EQ(testMatrix, outputMatrix);
+    }
+}
+
+ANGLE_INSTANTIATE_TEST(MatrixLoadTest, ES1_D3D11(), ES1_OPENGL(), ES1_OPENGLES());