Add perspective support to SkMatrix44 initializers.

tests/Matrix44Test.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #include "SkMatrix44.h"
 
 static bool nearly_equal_double(double a, double b) {
     const double tolerance = 1e-7;
     double diff = a - b;
     if (diff < 0)
         diff = -diff;
     return diff <= tolerance;
 }
 
-static bool nearly_equal_scalar(SkMScalar a, SkMScalar b) {
+static bool nearly_equal_mscalar(SkMScalar a, SkMScalar b) {
+    const SkMScalar tolerance = SK_MScalar1 / 200000;
+
+    return SkTAbs<SkMScalar>(a - b) <= tolerance;
+}
+
+static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
     // Note that we get more compounded error for multiple operations when
     // SK_SCALAR_IS_FIXED.
 #ifdef SK_SCALAR_IS_FLOAT
     const SkScalar tolerance = SK_Scalar1 / 200000;
 #else
     const SkScalar tolerance = SK_Scalar1 / 1024;
 #endif
 
-    return SkTAbs<SkMScalar>(a - b) <= tolerance;
+    return SkScalarAbs(a - b) <= tolerance;
 }
 
 template <typename T> void assert16(skiatest::Reporter* reporter, const T data[],
                                     T m0,  T m1,  T m2,  T m3,
                                     T m4,  T m5,  T m6,  T m7,
                                     T m8,  T m9,  T m10, T m11,
                                     T m12, T m13, T m14, T m15) {
     REPORTER_ASSERT(reporter, data[0] == m0);
     REPORTER_ASSERT(reporter, data[1] == m1);
     REPORTER_ASSERT(reporter, data[2] == m2);
@@ skipping 11 matching lines @@
 
     REPORTER_ASSERT(reporter, data[12] == m12);
     REPORTER_ASSERT(reporter, data[13] == m13);
     REPORTER_ASSERT(reporter, data[14] == m14);
     REPORTER_ASSERT(reporter, data[15] == m15);
 }
 
 static bool nearly_equal(const SkMatrix44& a, const SkMatrix44& b) {
     for (int i = 0; i < 4; ++i) {
         for (int j = 0; j < 4; ++j) {
-            if (!nearly_equal_scalar(a.get(i, j), b.get(i, j))) {
+            if (!nearly_equal_mscalar(a.get(i, j), b.get(i, j))) {
                 printf("not equal %g %g\n", a.get(i, j), b.get(i, j));
                 return false;
             }
         }
     }
     return true;
 }
 
 static bool is_identity(const SkMatrix44& m) {
     SkMatrix44 identity;
@@ skipping 393 matching lines @@
     b.transpose();
     REPORTER_ASSERT(reporter, nearly_equal(a, b));
     a.asColMajorf(bufferf);
     b.setColMajorf(bufferf);
     REPORTER_ASSERT(reporter, nearly_equal(a, b));
     b.setRowMajorf(bufferf);
     b.transpose();
     REPORTER_ASSERT(reporter, nearly_equal(a, b));
 }
 
+static void test_3x3_conversion(skiatest::Reporter* reporter) {
+    SkMScalar values4x4[16] = { 1, 2, 3, 4,
+                                5, 6, 7, 8,
+                                9, 10, 11, 12,
+                                13, 14, 15, 16 };
+    SkScalar values3x3[9] = { 1, 2, 4,
+                              5, 6, 8,
+                              13, 14, 16 };
+    SkMScalar values4x4flattened[16] = { 1, 2, 0, 4,
+                                         5, 6, 0, 8,
+                                         0, 0, 1, 0,
+                                         13, 14, 0, 16 };
+    SkMatrix44 a44;
+    a44.setRowMajor(values4x4);
+
+    SkMatrix a33 = a44;
+    SkMatrix expected33;
+    for (int i = 0; i < 9; i++) expected33[i] = values3x3[i];
+    REPORTER_ASSERT(reporter, expected33 == a33);
+
+    SkMatrix44 a44flattened = a33;
+    SkMatrix44 expected44flattened;
+    expected44flattened.setRowMajor(values4x4flattened);
+    REPORTER_ASSERT(reporter, nearly_equal(a44flattened, expected44flattened));
+
+    // Test that a point with a Z value of 0 is transformed the same way.
+    SkScalar vec4[4] = { 2, 4, 0, 8 };
+    SkScalar vec3[3] = { 2, 4, 8 };
+
+    SkScalar vec4transformed[4];
+    SkScalar vec3transformed[3];
+    SkScalar vec4transformed2[4];
+    a44.mapScalars(vec4, vec4transformed);
+    a33.mapHomogeneousPoints(vec3transformed, vec3, 1);
+    a44flattened.mapScalars(vec4, vec4transformed2);
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[0], vec3transformed[0]));
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[1], vec3transformed[1]));
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[3], vec3transformed[2]));
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[0], vec4transformed2[0]));
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[1], vec4transformed2[1]));
+    REPORTER_ASSERT(reporter, !nearly_equal_scalar(vec4transformed[2], vec4transformed2[2]));
+    REPORTER_ASSERT(reporter, nearly_equal_scalar(vec4transformed[3], vec4transformed2[3]));
+}
+
 static void TestMatrix44(skiatest::Reporter* reporter) {
     SkMatrix44 mat, inverse, iden1, iden2, rot;
 
     mat.reset();
     mat.setTranslate(1, 1, 1);
     mat.invert(&inverse);
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
 
     mat.setScale(2, 2, 2);
@@ skipping 81 matching lines @@
     test_constructor(reporter);
     test_gettype(reporter);
     test_determinant(reporter);
     test_invert(reporter);
     test_transpose(reporter);
     test_get_set_double(reporter);
     test_set_row_col_major(reporter);
     test_translate(reporter);
     test_scale(reporter);
     test_map2(reporter);
+    test_3x3_conversion(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Matrix44", Matrix44TestClass, TestMatrix44)