blob: 0bd4a8ba13bb0d2454b38f02099405a75cd27b3a [file] [log] [blame]
/*
* 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 "SkMatrix44.h"
#include "Test.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_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) {
const SkScalar tolerance = SK_Scalar1 / 200000;
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);
REPORTER_ASSERT(reporter, data[3] == m3);
REPORTER_ASSERT(reporter, data[4] == m4);
REPORTER_ASSERT(reporter, data[5] == m5);
REPORTER_ASSERT(reporter, data[6] == m6);
REPORTER_ASSERT(reporter, data[7] == m7);
REPORTER_ASSERT(reporter, data[8] == m8);
REPORTER_ASSERT(reporter, data[9] == m9);
REPORTER_ASSERT(reporter, data[10] == m10);
REPORTER_ASSERT(reporter, data[11] == m11);
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_mscalar(a.get(i, j), b.get(i, j))) {
SkDebugf("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(SkMatrix44::kIdentity_Constructor);
return nearly_equal(m, identity);
}
///////////////////////////////////////////////////////////////////////////////
static bool bits_isonly(int value, int mask) {
return 0 == (value & ~mask);
}
static void test_constructor(skiatest::Reporter* reporter) {
// Allocate a matrix on the heap
SkMatrix44* placeholderMatrix = new SkMatrix44(SkMatrix44::kUninitialized_Constructor);
SkAutoTDelete<SkMatrix44> deleteMe(placeholderMatrix);
for (int row = 0; row < 4; ++row) {
for (int col = 0; col < 4; ++col) {
placeholderMatrix->setDouble(row, col, row * col);
}
}
// Use placement-new syntax to trigger the constructor on top of the heap
// address we already initialized. This allows us to check that the
// constructor did avoid initializing the matrix contents.
SkMatrix44* testMatrix = new(placeholderMatrix) SkMatrix44(SkMatrix44::kUninitialized_Constructor);
REPORTER_ASSERT(reporter, testMatrix == placeholderMatrix);
REPORTER_ASSERT(reporter, !testMatrix->isIdentity());
for (int row = 0; row < 4; ++row) {
for (int col = 0; col < 4; ++col) {
REPORTER_ASSERT(reporter, nearly_equal_double(row * col, testMatrix->getDouble(row, col)));
}
}
// Verify that kIdentity_Constructor really does initialize to an identity matrix.
testMatrix = 0;
testMatrix = new(placeholderMatrix) SkMatrix44(SkMatrix44::kIdentity_Constructor);
REPORTER_ASSERT(reporter, testMatrix == placeholderMatrix);
REPORTER_ASSERT(reporter, testMatrix->isIdentity());
REPORTER_ASSERT(reporter, *testMatrix == SkMatrix44::I());
}
static void test_translate(skiatest::Reporter* reporter) {
SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
mat.setTranslate(0, 0, 0);
REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kIdentity_Mask));
mat.setTranslate(1, 2, 3);
REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kTranslate_Mask));
REPORTER_ASSERT(reporter, mat.invert(&inverse));
REPORTER_ASSERT(reporter, bits_isonly(inverse.getType(), SkMatrix44::kTranslate_Mask));
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
a.set3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);
b.setTranslate(10, 11, 12);
c.setConcat(a, b);
mat = a;
mat.preTranslate(10, 11, 12);
REPORTER_ASSERT(reporter, mat == c);
c.setConcat(b, a);
mat = a;
mat.postTranslate(10, 11, 12);
REPORTER_ASSERT(reporter, mat == c);
}
static void test_scale(skiatest::Reporter* reporter) {
SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
mat.setScale(1, 1, 1);
REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kIdentity_Mask));
mat.setScale(1, 2, 3);
REPORTER_ASSERT(reporter, bits_isonly(mat.getType(), SkMatrix44::kScale_Mask));
REPORTER_ASSERT(reporter, mat.invert(&inverse));
REPORTER_ASSERT(reporter, bits_isonly(inverse.getType(), SkMatrix44::kScale_Mask));
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
a.set3x3(1, 2, 3, 4, 5, 6, 7, 8, 9);
b.setScale(10, 11, 12);
c.setConcat(a, b);
mat = a;
mat.preScale(10, 11, 12);
REPORTER_ASSERT(reporter, mat == c);
c.setConcat(b, a);
mat = a;
mat.postScale(10, 11, 12);
REPORTER_ASSERT(reporter, mat == c);
}
static void make_i(SkMatrix44* mat) { mat->setIdentity(); }
static void make_t(SkMatrix44* mat) { mat->setTranslate(1, 2, 3); }
static void make_s(SkMatrix44* mat) { mat->setScale(1, 2, 3); }
static void make_st(SkMatrix44* mat) {
mat->setScale(1, 2, 3);
mat->postTranslate(1, 2, 3);
}
static void make_a(SkMatrix44* mat) {
mat->setRotateDegreesAbout(1, 2, 3, 45);
}
static void make_p(SkMatrix44* mat) {
SkMScalar data[] = {
1, 2, 3, 4, 5, 6, 7, 8,
1, 2, 3, 4, 5, 6, 7, 8,
};
mat->setRowMajor(data);
}
typedef void (*Make44Proc)(SkMatrix44*);
static const Make44Proc gMakeProcs[] = {
make_i, make_t, make_s, make_st, make_a, make_p
};
static void test_map2(skiatest::Reporter* reporter, const SkMatrix44& mat) {
SkMScalar src2[] = { 1, 2 };
SkMScalar src4[] = { src2[0], src2[1], 0, 1 };
SkMScalar dstA[4], dstB[4];
for (int i = 0; i < 4; ++i) {
dstA[i] = 123456789;
dstB[i] = 987654321;
}
mat.map2(src2, 1, dstA);
mat.mapMScalars(src4, dstB);
for (int i = 0; i < 4; ++i) {
REPORTER_ASSERT(reporter, dstA[i] == dstB[i]);
}
}
static void test_map2(skiatest::Reporter* reporter) {
SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
for (size_t i = 0; i < SK_ARRAY_COUNT(gMakeProcs); ++i) {
gMakeProcs[i](&mat);
test_map2(reporter, mat);
}
}
static void test_gettype(skiatest::Reporter* reporter) {
SkMatrix44 matrix(SkMatrix44::kIdentity_Constructor);
REPORTER_ASSERT(reporter, matrix.isIdentity());
REPORTER_ASSERT(reporter, SkMatrix44::kIdentity_Mask == matrix.getType());
int expectedMask;
matrix.set(1, 1, 0);
expectedMask = SkMatrix44::kScale_Mask;
REPORTER_ASSERT(reporter, matrix.getType() == expectedMask);
matrix.set(0, 3, 1); // translate-x
expectedMask |= SkMatrix44::kTranslate_Mask;
REPORTER_ASSERT(reporter, matrix.getType() == expectedMask);
matrix.set(2, 0, 1);
expectedMask |= SkMatrix44::kAffine_Mask;
REPORTER_ASSERT(reporter, matrix.getType() == expectedMask);
matrix.set(3, 2, 1);
REPORTER_ASSERT(reporter, matrix.getType() & SkMatrix44::kPerspective_Mask);
// ensure that negative zero is treated as zero
SkMScalar dx = 0;
SkMScalar dy = 0;
SkMScalar dz = 0;
matrix.setTranslate(-dx, -dy, -dz);
REPORTER_ASSERT(reporter, matrix.isIdentity());
matrix.preTranslate(-dx, -dy, -dz);
REPORTER_ASSERT(reporter, matrix.isIdentity());
matrix.postTranslate(-dx, -dy, -dz);
REPORTER_ASSERT(reporter, matrix.isIdentity());
}
static void test_common_angles(skiatest::Reporter* reporter) {
SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
// Test precision of rotation in common cases
int common_angles[] = { 0, 90, -90, 180, -180, 270, -270, 360, -360 };
for (int i = 0; i < 9; ++i) {
rot.setRotateDegreesAbout(0, 0, -1, SkIntToScalar(common_angles[i]));
SkMatrix rot3x3 = rot;
REPORTER_ASSERT(reporter, rot3x3.rectStaysRect());
}
}
static void test_concat(skiatest::Reporter* reporter) {
int i;
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 c(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 d(SkMatrix44::kUninitialized_Constructor);
a.setTranslate(10, 10, 10);
b.setScale(2, 2, 2);
SkScalar src[8] = {
0, 0, 0, 1,
1, 1, 1, 1
};
SkScalar dst[8];
c.setConcat(a, b);
d = a;
d.preConcat(b);
REPORTER_ASSERT(reporter, d == c);
c.mapScalars(src, dst); c.mapScalars(src + 4, dst + 4);
for (i = 0; i < 3; ++i) {
REPORTER_ASSERT(reporter, 10 == dst[i]);
REPORTER_ASSERT(reporter, 12 == dst[i + 4]);
}
c.setConcat(b, a);
d = a;
d.postConcat(b);
REPORTER_ASSERT(reporter, d == c);
c.mapScalars(src, dst); c.mapScalars(src + 4, dst + 4);
for (i = 0; i < 3; ++i) {
REPORTER_ASSERT(reporter, 20 == dst[i]);
REPORTER_ASSERT(reporter, 22 == dst[i + 4]);
}
}
static void test_determinant(skiatest::Reporter* reporter) {
SkMatrix44 a(SkMatrix44::kIdentity_Constructor);
REPORTER_ASSERT(reporter, nearly_equal_double(1, a.determinant()));
a.set(1, 1, 2);
REPORTER_ASSERT(reporter, nearly_equal_double(2, a.determinant()));
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
REPORTER_ASSERT(reporter, a.invert(&b));
REPORTER_ASSERT(reporter, nearly_equal_double(0.5, b.determinant()));
SkMatrix44 c = b = a;
c.set(0, 1, 4);
b.set(1, 0, 4);
REPORTER_ASSERT(reporter,
nearly_equal_double(a.determinant(),
b.determinant()));
SkMatrix44 d = a;
d.set(0, 0, 8);
REPORTER_ASSERT(reporter, nearly_equal_double(16, d.determinant()));
SkMatrix44 e = a;
e.postConcat(d);
REPORTER_ASSERT(reporter, nearly_equal_double(32, e.determinant()));
e.set(0, 0, 0);
REPORTER_ASSERT(reporter, nearly_equal_double(0, e.determinant()));
}
static void test_invert(skiatest::Reporter* reporter) {
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
double inverseData[16];
SkMatrix44 identity(SkMatrix44::kIdentity_Constructor);
identity.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1);
SkMatrix44 translation(SkMatrix44::kUninitialized_Constructor);
translation.setTranslate(2, 3, 4);
translation.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
1, 0, 0, -2,
0, 1, 0, -3,
0, 0, 1, -4,
0, 0, 0, 1);
SkMatrix44 scale(SkMatrix44::kUninitialized_Constructor);
scale.setScale(2, 4, 8);
scale.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
0.5, 0, 0, 0,
0, 0.25, 0, 0,
0, 0, 0.125, 0,
0, 0, 0, 1);
SkMatrix44 scaleTranslation(SkMatrix44::kUninitialized_Constructor);
scaleTranslation.setScale(10, 100, 1000);
scaleTranslation.preTranslate(2, 3, 4);
scaleTranslation.invert(&inverse);
inverse.asRowMajord(inverseData);
assert16<double>(reporter, inverseData,
0.1, 0, 0, -2,
0, 0.01, 0, -3,
0, 0, 0.001, -4,
0, 0, 0, 1);
SkMatrix44 rotation(SkMatrix44::kUninitialized_Constructor);
rotation.setRotateDegreesAbout(0, 0, 1, 90);
rotation.invert(&inverse);
SkMatrix44 expected(SkMatrix44::kUninitialized_Constructor);
double expectedInverseRotation[16] =
{0, 1, 0, 0,
-1, 0, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1};
expected.setRowMajord(expectedInverseRotation);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 affine(SkMatrix44::kUninitialized_Constructor);
affine.setRotateDegreesAbout(0, 0, 1, 90);
affine.preScale(10, 20, 100);
affine.preTranslate(2, 3, 4);
affine.invert(&inverse);
double expectedInverseAffine[16] =
{0, 0.1, 0, -2,
-0.05, 0, 0, -3,
0, 0, 0.01, -4,
0, 0, 0, 1};
expected.setRowMajord(expectedInverseAffine);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 perspective(SkMatrix44::kIdentity_Constructor);
perspective.setDouble(3, 2, 1.0);
perspective.invert(&inverse);
double expectedInversePerspective[16] =
{1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, -1, 1};
expected.setRowMajord(expectedInversePerspective);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
SkMatrix44 affineAndPerspective(SkMatrix44::kIdentity_Constructor);
affineAndPerspective.setDouble(3, 2, 1.0);
affineAndPerspective.preScale(10, 20, 100);
affineAndPerspective.preTranslate(2, 3, 4);
affineAndPerspective.invert(&inverse);
double expectedInverseAffineAndPerspective[16] =
{0.1, 0, 2, -2,
0, 0.05, 3, -3,
0, 0, 4.01, -4,
0, 0, -1, 1};
expected.setRowMajord(expectedInverseAffineAndPerspective);
REPORTER_ASSERT(reporter, nearly_equal(expected, inverse));
}
static void test_transpose(skiatest::Reporter* reporter) {
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
int i = 0;
for (int row = 0; row < 4; ++row) {
for (int col = 0; col < 4; ++col) {
a.setDouble(row, col, i);
b.setDouble(col, row, i++);
}
}
a.transpose();
REPORTER_ASSERT(reporter, nearly_equal(a, b));
}
static void test_get_set_double(skiatest::Reporter* reporter) {
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
for (int row = 0; row < 4; ++row) {
for (int col = 0; col < 4; ++col) {
a.setDouble(row, col, 3.141592653589793);
REPORTER_ASSERT(reporter,
nearly_equal_double(3.141592653589793,
a.getDouble(row, col)));
a.setDouble(row, col, 0);
REPORTER_ASSERT(reporter,
nearly_equal_double(0, a.getDouble(row, col)));
}
}
}
static void test_set_row_col_major(skiatest::Reporter* reporter) {
SkMatrix44 a(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 b(SkMatrix44::kUninitialized_Constructor);
for (int row = 0; row < 4; ++row) {
for (int col = 0; col < 4; ++col) {
a.setDouble(row, col, row * 4 + col);
}
}
double bufferd[16];
float bufferf[16];
a.asColMajord(bufferd);
b.setColMajord(bufferd);
REPORTER_ASSERT(reporter, nearly_equal(a, b));
b.setRowMajord(bufferd);
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(SkMatrix44::kUninitialized_Constructor);
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(SkMatrix44::kUninitialized_Constructor);
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 test_has_perspective(skiatest::Reporter* reporter) {
SkMatrix44 transform(SkMatrix44::kIdentity_Constructor);
transform.set(3, 2, -0.1);
REPORTER_ASSERT(reporter, transform.hasPerspective());
transform.reset();
REPORTER_ASSERT(reporter, !transform.hasPerspective());
transform.set(3, 0, -1.0);
REPORTER_ASSERT(reporter, transform.hasPerspective());
transform.reset();
transform.set(3, 1, -1.0);
REPORTER_ASSERT(reporter, transform.hasPerspective());
transform.reset();
transform.set(3, 2, -0.3);
REPORTER_ASSERT(reporter, transform.hasPerspective());
transform.reset();
transform.set(3, 3, 0.5);
REPORTER_ASSERT(reporter, transform.hasPerspective());
transform.reset();
transform.set(3, 3, 0.0);
REPORTER_ASSERT(reporter, transform.hasPerspective());
}
DEF_TEST(Matrix44, reporter) {
SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 iden1(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 iden2(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
mat.setTranslate(1, 1, 1);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(2, 2, 2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(SK_MScalar1/2, SK_MScalar1/2, SK_MScalar1/2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(3, 3, 3);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
iden2.setConcat(inverse, mat);
REPORTER_ASSERT(reporter, is_identity(iden2));
// test tiny-valued matrix inverse
mat.reset();
mat.setScale(1.0e-12, 1.0e-12, 1.0e-12);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(1.0e-12, 1.0e-12, 1.0e-12);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test mixed-valued matrix inverse
mat.reset();
mat.setScale(1.0e-10, 3.0, 1.0e+10);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(1.0e+10, 3.0, 1.0e-10);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test degenerate matrix
mat.reset();
mat.set3x3(1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0);
REPORTER_ASSERT(reporter, !mat.invert(NULL));
// test rol/col Major getters
{
mat.setTranslate(2, 3, 4);
float dataf[16];
double datad[16];
mat.asColMajorf(dataf);
assert16<float>(reporter, dataf,
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asColMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asRowMajorf(dataf);
assert16<float>(reporter, dataf, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
mat.asRowMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
}
test_concat(reporter);
if (false) { // avoid bit rot, suppress warning (working on making this pass)
test_common_angles(reporter);
}
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);
test_has_perspective(reporter);
}