void SkMatrix44::setRotateAboutUnit(SkMScalar x, SkMScalar y, SkMScalar z,
SkMScalar radians) {
double c = cos(radians);
double s = sin(radians);
double C = 1 - c;
double xs = x * s;
double ys = y * s;
double zs = z * s;
double xC = x * C;
double yC = y * C;
double zC = z * C;
double xyC = x * yC;
double yzC = y * zC;
double zxC = z * xC;
// if you're looking at wikipedia, remember that we're column major.
this->set3x3(SkDoubleToMScalar(x * xC + c), // scale x
SkDoubleToMScalar(xyC + zs), // skew x
SkDoubleToMScalar(zxC - ys), // trans x
SkDoubleToMScalar(xyC - zs), // skew y
SkDoubleToMScalar(y * yC + c), // scale y
SkDoubleToMScalar(yzC + xs), // trans y
SkDoubleToMScalar(zxC + ys), // persp x
SkDoubleToMScalar(yzC - xs), // persp y
SkDoubleToMScalar(z * zC + c)); // persp 2
}
void SkMatrix44::setRotateAbout(SkMScalar x, SkMScalar y, SkMScalar z,
SkMScalar radians) {
double len2 = x * x + y * y + z * z;
if (len2 != 1) {
if (len2 == 0) {
this->setIdentity();
return;
}
double scale = 1 / sqrt(len2);
x = SkDoubleToMScalar(x * scale);
y = SkDoubleToMScalar(y * scale);
z = SkDoubleToMScalar(z * scale);
}
this->setRotateAboutUnit(x, y, z, radians);
}
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] = SkDoubleToMScalar(123456789);
dstB[i] = SkDoubleToMScalar(987654321);
}
mat.map2(src2, 1, dstA);
mat.mapMScalars(src4, dstB);
for (int i = 0; i < 4; ++i) {
REPORTER_ASSERT(reporter, dstA[i] == dstB[i]);
}
}
bool SkMatrix44::invert(SkMatrix44* inverse) const {
double det = this->determinant();
if (dabs(det) < TOO_SMALL_FOR_DETERMINANT) {
return false;
}
if (NULL == inverse) {
return true;
}
// we explicitly promote to doubles to keep the intermediate values in
// higher precision (assuming SkMScalar isn't already a double)
double m00 = fMat[0][0];
double m01 = fMat[0][1];
double m02 = fMat[0][2];
double m03 = fMat[0][3];
double m10 = fMat[1][0];
double m11 = fMat[1][1];
double m12 = fMat[1][2];
double m13 = fMat[1][3];
double m20 = fMat[2][0];
double m21 = fMat[2][1];
double m22 = fMat[2][2];
double m23 = fMat[2][3];
double m30 = fMat[3][0];
double m31 = fMat[3][1];
double m32 = fMat[3][2];
double m33 = fMat[3][3];
double tmp[4][4];
tmp[0][0] = m12*m23*m31 - m13*m22*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33 + m11*m22*m33;
tmp[0][1] = m03*m22*m31 - m02*m23*m31 - m03*m21*m32 + m01*m23*m32 + m02*m21*m33 - m01*m22*m33;
tmp[0][2] = m02*m13*m31 - m03*m12*m31 + m03*m11*m32 - m01*m13*m32 - m02*m11*m33 + m01*m12*m33;
tmp[0][3] = m03*m12*m21 - m02*m13*m21 - m03*m11*m22 + m01*m13*m22 + m02*m11*m23 - m01*m12*m23;
tmp[1][0] = m13*m22*m30 - m12*m23*m30 - m13*m20*m32 + m10*m23*m32 + m12*m20*m33 - m10*m22*m33;
tmp[1][1] = m02*m23*m30 - m03*m22*m30 + m03*m20*m32 - m00*m23*m32 - m02*m20*m33 + m00*m22*m33;
tmp[1][2] = m03*m12*m30 - m02*m13*m30 - m03*m10*m32 + m00*m13*m32 + m02*m10*m33 - m00*m12*m33;
tmp[1][3] = m02*m13*m20 - m03*m12*m20 + m03*m10*m22 - m00*m13*m22 - m02*m10*m23 + m00*m12*m23;
tmp[2][0] = m11*m23*m30 - m13*m21*m30 + m13*m20*m31 - m10*m23*m31 - m11*m20*m33 + m10*m21*m33;
tmp[2][1] = m03*m21*m30 - m01*m23*m30 - m03*m20*m31 + m00*m23*m31 + m01*m20*m33 - m00*m21*m33;
tmp[2][2] = m01*m13*m30 - m03*m11*m30 + m03*m10*m31 - m00*m13*m31 - m01*m10*m33 + m00*m11*m33;
tmp[2][3] = m03*m11*m20 - m01*m13*m20 - m03*m10*m21 + m00*m13*m21 + m01*m10*m23 - m00*m11*m23;
tmp[3][0] = m12*m21*m30 - m11*m22*m30 - m12*m20*m31 + m10*m22*m31 + m11*m20*m32 - m10*m21*m32;
tmp[3][1] = m01*m22*m30 - m02*m21*m30 + m02*m20*m31 - m00*m22*m31 - m01*m20*m32 + m00*m21*m32;
tmp[3][2] = m02*m11*m30 - m01*m12*m30 - m02*m10*m31 + m00*m12*m31 + m01*m10*m32 - m00*m11*m32;
tmp[3][3] = m01*m12*m20 - m02*m11*m20 + m02*m10*m21 - m00*m12*m21 - m01*m10*m22 + m00*m11*m22;
double invDet = 1.0 / det;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
inverse->fMat[i][j] = SkDoubleToMScalar(tmp[i][j] * invDet);
}
}
return true;
}
void SkMatrix44::setConcat(const SkMatrix44& a, const SkMatrix44& b) {
SkMScalar result[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
double value = 0;
for (int k = 0; k < 4; k++) {
value += SkMScalarToDouble(a.fMat[k][i]) * b.fMat[j][k];
}
result[j][i] = SkDoubleToMScalar(value);
}
}
memcpy(fMat, result, sizeof(result));
}
// SkMatrix44::setConcat() has a fast path for matrices that are at most scale+translate.
SetConcatMatrix44Bench(bool fastPath)
: INHERITED(fastPath ? "setconcat_fast" : "setconcat_general")
{
if (fastPath) {
const SkMScalar v = SkDoubleToMScalar(1.5);
fM1.setScale(v,v,v);
fM2.setTranslate(v,v,v);
} else {
SkRandom rand;
for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4; y++) {
fM1.setFloat(x,y, rand.nextF());
fM2.setFloat(x,y, rand.nextF());
}}
}
}
static void test44() {
SkMatrix44 m0, m1, m2;
test_inv("identity", m0);
m0.setTranslate(2,3,4);
test_inv("translate", m0);
m0.setScale(2,3,4);
test_inv("scale", m0);
m0.postTranslate(5, 6, 7);
test_inv("postTranslate", m0);
m0.setScale(2,3,4);
m1.setTranslate(5, 6, 7);
m0.setConcat(m0, m1);
test_inv("postTranslate2", m0);
m0.setScale(2,3,4);
m0.preTranslate(5, 6, 7);
test_inv("preTranslate", m0);
m0.setScale(2, 4, 6);
m0.postScale(SkDoubleToMScalar(0.5));
test_inv("scale/postscale to 1,2,3", m0);
m0.reset();
test_map(1, 0, 0, m0, 1, 0, 0);
test_map(0, 1, 0, m0, 0, 1, 0);
test_map(0, 0, 1, m0, 0, 0, 1);
m0.setScale(2, 3, 4);
test_map(1, 0, 0, m0, 2, 0, 0);
test_map(0, 1, 0, m0, 0, 3, 0);
test_map(0, 0, 1, m0, 0, 0, 4);
m0.setTranslate(2, 3, 4);
test_map(0, 0, 0, m0, 2, 3, 4);
m0.preScale(5, 6, 7);
test_map(1, 0, 0, m0, 7, 3, 4);
test_map(0, 1, 0, m0, 2, 9, 4);
test_map(0, 0, 1, m0, 2, 3, 11);
SkMScalar deg = 45;
m0.setRotateDegreesAbout(0, 0, 1, deg);
test_map(1, 0, 0, m0, 0.707106769, -0.707106769, 0);
m0.reset();
test_33(m0, 1, 0, 0, 0, 1, 0);
m0.setTranslate(3, 4, 5);
test_33(m0, 1, 0, 3, 0, 1, 4);
}
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();
auto v = SkDoubleToMScalar(1.0e-12);
mat.setScale(v,v,v);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(v,v,v);
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(SkDoubleToMScalar(1.0e-2),
SkDoubleToMScalar(3.0),
SkDoubleToMScalar(1.0e+2));
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(SkDoubleToMScalar(1.0e+2),
SkDoubleToMScalar(3.0),
SkDoubleToMScalar(1.0e-2));
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);
test_preserves_2d_axis_alignment(reporter);
test_toint(reporter);
}
PreScaleMatrix44Bench()
: INHERITED("prescale")
{
fX = fY = fZ = SkDoubleToMScalar(1.5);
}
static inline SkMScalar det2x2(double m00, double m01, double m10, double m11) {
return SkDoubleToMScalar(m00 * m11 - m10 * m01);
}
PreScaleMatrix44Bench()
: INHERITED("prescale")
, fM0(SkMatrix44::kUninitialized_Constructor)
{
fX = fY = fZ = SkDoubleToMScalar(1.5);
}
PreScaleMatrix44Bench(void* param) : INHERITED(param, "prescale") {
fX = fY = fZ = SkDoubleToMScalar(1.5);
}
SetConcatMatrix44Bench(void* param) : INHERITED(param, "setconcat") {
fX = fY = fZ = SkDoubleToMScalar(1.5);
fM1.setScale(fX, fY, fZ);
fM2.setTranslate(fX, fY, fZ);
}
