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); }