mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
129 lines
3.1 KiB
C++
129 lines
3.1 KiB
C++
// Copyright 2013 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "flutter/flow/matrix_decomposition.h"
|
|
|
|
namespace flutter {
|
|
|
|
static inline SkV3 SkV3Combine(const SkV3& a,
|
|
float a_scale,
|
|
const SkV3& b,
|
|
float b_scale) {
|
|
return (a * a_scale) + (b * b_scale);
|
|
}
|
|
|
|
MatrixDecomposition::MatrixDecomposition(const SkMatrix& matrix)
|
|
: MatrixDecomposition(SkM44{matrix}) {}
|
|
|
|
// Use custom normalize to avoid skia precision loss/normalize() privatization.
|
|
static inline void SkV3Normalize(SkV3* v) {
|
|
double mag = sqrt(v->x * v->x + v->y * v->y + v->z * v->z);
|
|
double scale = 1.0 / mag;
|
|
v->x *= scale;
|
|
v->y *= scale;
|
|
v->z *= scale;
|
|
}
|
|
|
|
MatrixDecomposition::MatrixDecomposition(SkM44 matrix) : valid_(false) {
|
|
if (matrix.rc(3, 3) == 0) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
for (int j = 0; j < 4; j++) {
|
|
matrix.setRC(j, i, matrix.rc(j, i) / matrix.rc(3, 3));
|
|
}
|
|
}
|
|
|
|
SkM44 perpective_matrix = matrix;
|
|
for (int i = 0; i < 3; i++) {
|
|
perpective_matrix.setRC(3, i, 0.0);
|
|
}
|
|
|
|
perpective_matrix.setRC(3, 3, 1.0);
|
|
|
|
SkM44 inverted(SkM44::Uninitialized_Constructor::kUninitialized_Constructor);
|
|
if (!perpective_matrix.invert(&inverted)) {
|
|
return;
|
|
}
|
|
|
|
if (matrix.rc(3, 0) != 0.0 || matrix.rc(3, 1) != 0.0 ||
|
|
matrix.rc(3, 2) != 0.0) {
|
|
const SkV4 right_hand_side = matrix.row(3);
|
|
|
|
perspective_ = inverted.transpose() * right_hand_side;
|
|
|
|
matrix.setRow(3, {0, 0, 0, 1});
|
|
}
|
|
|
|
translation_ = {matrix.rc(0, 3), matrix.rc(1, 3), matrix.rc(2, 3)};
|
|
|
|
matrix.setRC(0, 3, 0.0);
|
|
matrix.setRC(1, 3, 0.0);
|
|
matrix.setRC(2, 3, 0.0);
|
|
|
|
SkV3 row[3];
|
|
for (int i = 0; i < 3; i++) {
|
|
row[i] = {matrix.rc(0, i), matrix.rc(1, i), matrix.rc(2, i)};
|
|
}
|
|
|
|
scale_.x = row[0].length();
|
|
|
|
SkV3Normalize(&row[0]);
|
|
|
|
shear_.x = row[0].dot(row[1]);
|
|
row[1] = SkV3Combine(row[1], 1.0, row[0], -shear_.x);
|
|
|
|
scale_.y = row[1].length();
|
|
|
|
SkV3Normalize(&row[1]);
|
|
|
|
shear_.x /= scale_.y;
|
|
|
|
shear_.y = row[0].dot(row[2]);
|
|
row[2] = SkV3Combine(row[2], 1.0, row[0], -shear_.y);
|
|
shear_.z = row[1].dot(row[2]);
|
|
row[2] = SkV3Combine(row[2], 1.0, row[1], -shear_.z);
|
|
|
|
scale_.z = row[2].length();
|
|
|
|
SkV3Normalize(&row[2]);
|
|
|
|
shear_.y /= scale_.z;
|
|
shear_.z /= scale_.z;
|
|
|
|
if (row[0].dot(row[1].cross(row[2])) < 0) {
|
|
scale_ *= -1;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
row[i] *= -1;
|
|
}
|
|
}
|
|
|
|
rotation_.x = 0.5 * sqrt(fmax(1.0 + row[0].x - row[1].y - row[2].z, 0.0));
|
|
rotation_.y = 0.5 * sqrt(fmax(1.0 - row[0].x + row[1].y - row[2].z, 0.0));
|
|
rotation_.z = 0.5 * sqrt(fmax(1.0 - row[0].x - row[1].y + row[2].z, 0.0));
|
|
rotation_.w = 0.5 * sqrt(fmax(1.0 + row[0].x + row[1].y + row[2].z, 0.0));
|
|
|
|
if (row[2].y > row[1].z) {
|
|
rotation_.x = -rotation_.x;
|
|
}
|
|
if (row[0].z > row[2].x) {
|
|
rotation_.y = -rotation_.y;
|
|
}
|
|
if (row[1].x > row[0].y) {
|
|
rotation_.z = -rotation_.z;
|
|
}
|
|
|
|
valid_ = true;
|
|
}
|
|
|
|
MatrixDecomposition::~MatrixDecomposition() = default;
|
|
|
|
bool MatrixDecomposition::IsValid() const {
|
|
return valid_;
|
|
}
|
|
|
|
} // namespace flutter
|