You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
427 lines
14 KiB
427 lines
14 KiB
/*
|
|
* Copyright 2020 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef SkM44_DEFINED
|
|
#define SkM44_DEFINED
|
|
|
|
#include "include/core/SkMatrix.h"
|
|
#include "include/core/SkRect.h"
|
|
#include "include/core/SkScalar.h"
|
|
|
|
struct SK_API SkV2 {
|
|
float x, y;
|
|
|
|
bool operator==(const SkV2 v) const { return x == v.x && y == v.y; }
|
|
bool operator!=(const SkV2 v) const { return !(*this == v); }
|
|
|
|
static SkScalar Dot(SkV2 a, SkV2 b) { return a.x * b.x + a.y * b.y; }
|
|
static SkScalar Cross(SkV2 a, SkV2 b) { return a.x * b.y - a.y * b.x; }
|
|
static SkV2 Normalize(SkV2 v) { return v * (1.0f / v.length()); }
|
|
|
|
SkV2 operator-() const { return {-x, -y}; }
|
|
SkV2 operator+(SkV2 v) const { return {x+v.x, y+v.y}; }
|
|
SkV2 operator-(SkV2 v) const { return {x-v.x, y-v.y}; }
|
|
|
|
SkV2 operator*(SkV2 v) const { return {x*v.x, y*v.y}; }
|
|
friend SkV2 operator*(SkV2 v, SkScalar s) { return {v.x*s, v.y*s}; }
|
|
friend SkV2 operator*(SkScalar s, SkV2 v) { return {v.x*s, v.y*s}; }
|
|
friend SkV2 operator/(SkV2 v, SkScalar s) { return {v.x/s, v.y/s}; }
|
|
|
|
void operator+=(SkV2 v) { *this = *this + v; }
|
|
void operator-=(SkV2 v) { *this = *this - v; }
|
|
void operator*=(SkV2 v) { *this = *this * v; }
|
|
void operator*=(SkScalar s) { *this = *this * s; }
|
|
void operator/=(SkScalar s) { *this = *this / s; }
|
|
|
|
SkScalar lengthSquared() const { return Dot(*this, *this); }
|
|
SkScalar length() const { return SkScalarSqrt(this->lengthSquared()); }
|
|
|
|
SkScalar dot(SkV2 v) const { return Dot(*this, v); }
|
|
SkScalar cross(SkV2 v) const { return Cross(*this, v); }
|
|
SkV2 normalize() const { return Normalize(*this); }
|
|
|
|
const float* ptr() const { return &x; }
|
|
float* ptr() { return &x; }
|
|
};
|
|
|
|
struct SK_API SkV3 {
|
|
float x, y, z;
|
|
|
|
bool operator==(const SkV3& v) const {
|
|
return x == v.x && y == v.y && z == v.z;
|
|
}
|
|
bool operator!=(const SkV3& v) const { return !(*this == v); }
|
|
|
|
static SkScalar Dot(const SkV3& a, const SkV3& b) { return a.x*b.x + a.y*b.y + a.z*b.z; }
|
|
static SkV3 Cross(const SkV3& a, const SkV3& b) {
|
|
return { a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x };
|
|
}
|
|
static SkV3 Normalize(const SkV3& v) { return v * (1.0f / v.length()); }
|
|
|
|
SkV3 operator-() const { return {-x, -y, -z}; }
|
|
SkV3 operator+(const SkV3& v) const { return { x + v.x, y + v.y, z + v.z }; }
|
|
SkV3 operator-(const SkV3& v) const { return { x - v.x, y - v.y, z - v.z }; }
|
|
|
|
SkV3 operator*(const SkV3& v) const {
|
|
return { x*v.x, y*v.y, z*v.z };
|
|
}
|
|
friend SkV3 operator*(const SkV3& v, SkScalar s) {
|
|
return { v.x*s, v.y*s, v.z*s };
|
|
}
|
|
friend SkV3 operator*(SkScalar s, const SkV3& v) { return v*s; }
|
|
|
|
void operator+=(SkV3 v) { *this = *this + v; }
|
|
void operator-=(SkV3 v) { *this = *this - v; }
|
|
void operator*=(SkV3 v) { *this = *this * v; }
|
|
void operator*=(SkScalar s) { *this = *this * s; }
|
|
|
|
SkScalar lengthSquared() const { return Dot(*this, *this); }
|
|
SkScalar length() const { return SkScalarSqrt(Dot(*this, *this)); }
|
|
|
|
SkScalar dot(const SkV3& v) const { return Dot(*this, v); }
|
|
SkV3 cross(const SkV3& v) const { return Cross(*this, v); }
|
|
SkV3 normalize() const { return Normalize(*this); }
|
|
|
|
const float* ptr() const { return &x; }
|
|
float* ptr() { return &x; }
|
|
};
|
|
|
|
struct SK_API SkV4 {
|
|
float x, y, z, w;
|
|
|
|
bool operator==(const SkV4& v) const {
|
|
return x == v.x && y == v.y && z == v.z && w == v.w;
|
|
}
|
|
bool operator!=(const SkV4& v) const { return !(*this == v); }
|
|
|
|
SkV4 operator-() const { return {-x, -y, -z, -w}; }
|
|
SkV4 operator+(const SkV4& v) const { return { x + v.x, y + v.y, z + v.z, w + v.w }; }
|
|
SkV4 operator-(const SkV4& v) const { return { x - v.x, y - v.y, z - v.z, w - v.w }; }
|
|
|
|
SkV4 operator*(const SkV4& v) const {
|
|
return { x*v.x, y*v.y, z*v.z, w*v.w };
|
|
}
|
|
friend SkV4 operator*(const SkV4& v, SkScalar s) {
|
|
return { v.x*s, v.y*s, v.z*s, v.w*s };
|
|
}
|
|
friend SkV4 operator*(SkScalar s, const SkV4& v) { return v*s; }
|
|
|
|
const float* ptr() const { return &x; }
|
|
float* ptr() { return &x; }
|
|
|
|
float operator[](int i) const {
|
|
SkASSERT(i >= 0 && i < 4);
|
|
return this->ptr()[i];
|
|
}
|
|
float& operator[](int i) {
|
|
SkASSERT(i >= 0 && i < 4);
|
|
return this->ptr()[i];
|
|
}
|
|
};
|
|
|
|
/**
|
|
* 4x4 matrix used by SkCanvas and other parts of Skia.
|
|
*
|
|
* Skia assumes a right-handed coordinate system:
|
|
* +X goes to the right
|
|
* +Y goes down
|
|
* +Z goes into the screen (away from the viewer)
|
|
*/
|
|
class SK_API SkM44 {
|
|
public:
|
|
SkM44(const SkM44& src) = default;
|
|
SkM44& operator=(const SkM44& src) = default;
|
|
|
|
constexpr SkM44()
|
|
: fMat{1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1}
|
|
{}
|
|
|
|
SkM44(const SkM44& a, const SkM44& b) {
|
|
this->setConcat(a, b);
|
|
}
|
|
|
|
enum Uninitialized_Constructor {
|
|
kUninitialized_Constructor
|
|
};
|
|
SkM44(Uninitialized_Constructor) {}
|
|
|
|
enum NaN_Constructor {
|
|
kNaN_Constructor
|
|
};
|
|
constexpr SkM44(NaN_Constructor)
|
|
: fMat{SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
|
|
SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
|
|
SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN,
|
|
SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN, SK_ScalarNaN}
|
|
{}
|
|
|
|
/**
|
|
* The constructor parameters are in row-major order.
|
|
*/
|
|
constexpr SkM44(SkScalar m0, SkScalar m4, SkScalar m8, SkScalar m12,
|
|
SkScalar m1, SkScalar m5, SkScalar m9, SkScalar m13,
|
|
SkScalar m2, SkScalar m6, SkScalar m10, SkScalar m14,
|
|
SkScalar m3, SkScalar m7, SkScalar m11, SkScalar m15)
|
|
// fMat is column-major order in memory.
|
|
: fMat{m0, m1, m2, m3,
|
|
m4, m5, m6, m7,
|
|
m8, m9, m10, m11,
|
|
m12, m13, m14, m15}
|
|
{}
|
|
|
|
static SkM44 Rows(const SkV4& r0, const SkV4& r1, const SkV4& r2, const SkV4& r3) {
|
|
SkM44 m(kUninitialized_Constructor);
|
|
m.setRow(0, r0);
|
|
m.setRow(1, r1);
|
|
m.setRow(2, r2);
|
|
m.setRow(3, r3);
|
|
return m;
|
|
}
|
|
static SkM44 Cols(const SkV4& c0, const SkV4& c1, const SkV4& c2, const SkV4& c3) {
|
|
SkM44 m(kUninitialized_Constructor);
|
|
m.setCol(0, c0);
|
|
m.setCol(1, c1);
|
|
m.setCol(2, c2);
|
|
m.setCol(3, c3);
|
|
return m;
|
|
}
|
|
|
|
static SkM44 RowMajor(const SkScalar r[16]) {
|
|
return SkM44(r[ 0], r[ 1], r[ 2], r[ 3],
|
|
r[ 4], r[ 5], r[ 6], r[ 7],
|
|
r[ 8], r[ 9], r[10], r[11],
|
|
r[12], r[13], r[14], r[15]);
|
|
}
|
|
static SkM44 ColMajor(const SkScalar c[16]) {
|
|
return SkM44(c[0], c[4], c[ 8], c[12],
|
|
c[1], c[5], c[ 9], c[13],
|
|
c[2], c[6], c[10], c[14],
|
|
c[3], c[7], c[11], c[15]);
|
|
}
|
|
|
|
static SkM44 Translate(SkScalar x, SkScalar y, SkScalar z = 0) {
|
|
return SkM44(1, 0, 0, x,
|
|
0, 1, 0, y,
|
|
0, 0, 1, z,
|
|
0, 0, 0, 1);
|
|
}
|
|
|
|
static SkM44 Scale(SkScalar x, SkScalar y, SkScalar z = 1) {
|
|
return SkM44(x, 0, 0, 0,
|
|
0, y, 0, 0,
|
|
0, 0, z, 0,
|
|
0, 0, 0, 1);
|
|
}
|
|
|
|
static SkM44 Rotate(SkV3 axis, SkScalar radians) {
|
|
SkM44 m(kUninitialized_Constructor);
|
|
m.setRotate(axis, radians);
|
|
return m;
|
|
}
|
|
|
|
// Scales and translates 'src' to fill 'dst' exactly.
|
|
static SkM44 RectToRect(const SkRect& src, const SkRect& dst);
|
|
|
|
static SkM44 LookAt(const SkV3& eye, const SkV3& center, const SkV3& up);
|
|
static SkM44 Perspective(float near, float far, float angle);
|
|
|
|
bool operator==(const SkM44& other) const;
|
|
bool operator!=(const SkM44& other) const {
|
|
return !(other == *this);
|
|
}
|
|
|
|
void getColMajor(SkScalar v[]) const {
|
|
memcpy(v, fMat, sizeof(fMat));
|
|
}
|
|
void getRowMajor(SkScalar v[]) const;
|
|
|
|
SkScalar rc(int r, int c) const {
|
|
SkASSERT(r >= 0 && r <= 3);
|
|
SkASSERT(c >= 0 && c <= 3);
|
|
return fMat[c*4 + r];
|
|
}
|
|
void setRC(int r, int c, SkScalar value) {
|
|
SkASSERT(r >= 0 && r <= 3);
|
|
SkASSERT(c >= 0 && c <= 3);
|
|
fMat[c*4 + r] = value;
|
|
}
|
|
|
|
SkV4 row(int i) const {
|
|
SkASSERT(i >= 0 && i <= 3);
|
|
return {fMat[i + 0], fMat[i + 4], fMat[i + 8], fMat[i + 12]};
|
|
}
|
|
SkV4 col(int i) const {
|
|
SkASSERT(i >= 0 && i <= 3);
|
|
return {fMat[i*4 + 0], fMat[i*4 + 1], fMat[i*4 + 2], fMat[i*4 + 3]};
|
|
}
|
|
|
|
void setRow(int i, const SkV4& v) {
|
|
SkASSERT(i >= 0 && i <= 3);
|
|
fMat[i + 0] = v.x;
|
|
fMat[i + 4] = v.y;
|
|
fMat[i + 8] = v.z;
|
|
fMat[i + 12] = v.w;
|
|
}
|
|
void setCol(int i, const SkV4& v) {
|
|
SkASSERT(i >= 0 && i <= 3);
|
|
memcpy(&fMat[i*4], v.ptr(), sizeof(v));
|
|
}
|
|
|
|
SkM44& setIdentity() {
|
|
*this = { 1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1 };
|
|
return *this;
|
|
}
|
|
|
|
SkM44& setTranslate(SkScalar x, SkScalar y, SkScalar z = 0) {
|
|
*this = { 1, 0, 0, x,
|
|
0, 1, 0, y,
|
|
0, 0, 1, z,
|
|
0, 0, 0, 1 };
|
|
return *this;
|
|
}
|
|
|
|
SkM44& setScale(SkScalar x, SkScalar y, SkScalar z = 1) {
|
|
*this = { x, 0, 0, 0,
|
|
0, y, 0, 0,
|
|
0, 0, z, 0,
|
|
0, 0, 0, 1 };
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Set this matrix to rotate about the specified unit-length axis vector,
|
|
* by an angle specified by its sin() and cos().
|
|
*
|
|
* This does not attempt to verify that axis.length() == 1 or that the sin,cos values
|
|
* are correct.
|
|
*/
|
|
SkM44& setRotateUnitSinCos(SkV3 axis, SkScalar sinAngle, SkScalar cosAngle);
|
|
|
|
/**
|
|
* Set this matrix to rotate about the specified unit-length axis vector,
|
|
* by an angle specified in radians.
|
|
*
|
|
* This does not attempt to verify that axis.length() == 1.
|
|
*/
|
|
SkM44& setRotateUnit(SkV3 axis, SkScalar radians) {
|
|
return this->setRotateUnitSinCos(axis, SkScalarSin(radians), SkScalarCos(radians));
|
|
}
|
|
|
|
/**
|
|
* Set this matrix to rotate about the specified axis vector,
|
|
* by an angle specified in radians.
|
|
*
|
|
* Note: axis is not assumed to be unit-length, so it will be normalized internally.
|
|
* If axis is already unit-length, call setRotateAboutUnitRadians() instead.
|
|
*/
|
|
SkM44& setRotate(SkV3 axis, SkScalar radians);
|
|
|
|
SkM44& setConcat(const SkM44& a, const SkM44& b);
|
|
|
|
friend SkM44 operator*(const SkM44& a, const SkM44& b) {
|
|
return SkM44(a, b);
|
|
}
|
|
|
|
SkM44& preConcat(const SkM44& m) {
|
|
return this->setConcat(*this, m);
|
|
}
|
|
|
|
SkM44& postConcat(const SkM44& m) {
|
|
return this->setConcat(m, *this);
|
|
}
|
|
|
|
/**
|
|
* A matrix is categorized as 'perspective' if the bottom row is not [0, 0, 0, 1].
|
|
* For most uses, a bottom row of [0, 0, 0, X] behaves like a non-perspective matrix, though
|
|
* it will be categorized as perspective. Calling normalizePerspective() will change the
|
|
* matrix such that, if its bottom row was [0, 0, 0, X], it will be changed to [0, 0, 0, 1]
|
|
* by scaling the rest of the matrix by 1/X.
|
|
*
|
|
* | A B C D | | A/X B/X C/X D/X |
|
|
* | E F G H | -> | E/X F/X G/X H/X | for X != 0
|
|
* | I J K L | | I/X J/X K/X L/X |
|
|
* | 0 0 0 X | | 0 0 0 1 |
|
|
*/
|
|
void normalizePerspective();
|
|
|
|
/** Returns true if all elements of the matrix are finite. Returns false if any
|
|
element is infinity, or NaN.
|
|
|
|
@return true if matrix has only finite elements
|
|
*/
|
|
bool isFinite() const { return SkScalarsAreFinite(fMat, 16); }
|
|
|
|
/** If this is invertible, return that in inverse and return true. If it is
|
|
* not invertible, return false and leave the inverse parameter unchanged.
|
|
*/
|
|
bool SK_WARN_UNUSED_RESULT invert(SkM44* inverse) const;
|
|
|
|
SkM44 SK_WARN_UNUSED_RESULT transpose() const;
|
|
|
|
void dump() const;
|
|
|
|
////////////
|
|
|
|
SkV4 map(float x, float y, float z, float w) const;
|
|
SkV4 operator*(const SkV4& v) const {
|
|
return this->map(v.x, v.y, v.z, v.w);
|
|
}
|
|
SkV3 operator*(SkV3 v) const {
|
|
auto v4 = this->map(v.x, v.y, v.z, 0);
|
|
return {v4.x, v4.y, v4.z};
|
|
}
|
|
////////////////////// Converting to/from SkMatrix
|
|
|
|
/* When converting from SkM44 to SkMatrix, the third row and
|
|
* column is dropped. When converting from SkMatrix to SkM44
|
|
* the third row and column remain as identity:
|
|
* [ a b c ] [ a b 0 c ]
|
|
* [ d e f ] -> [ d e 0 f ]
|
|
* [ g h i ] [ 0 0 1 0 ]
|
|
* [ g h 0 i ]
|
|
*/
|
|
SkMatrix asM33() const {
|
|
return SkMatrix::MakeAll(fMat[0], fMat[4], fMat[12],
|
|
fMat[1], fMat[5], fMat[13],
|
|
fMat[3], fMat[7], fMat[15]);
|
|
}
|
|
|
|
explicit SkM44(const SkMatrix& src)
|
|
: SkM44(src[SkMatrix::kMScaleX], src[SkMatrix::kMSkewX], 0, src[SkMatrix::kMTransX],
|
|
src[SkMatrix::kMSkewY], src[SkMatrix::kMScaleY], 0, src[SkMatrix::kMTransY],
|
|
0, 0, 1, 0,
|
|
src[SkMatrix::kMPersp0], src[SkMatrix::kMPersp1], 0, src[SkMatrix::kMPersp2])
|
|
{}
|
|
|
|
SkM44& preTranslate(SkScalar x, SkScalar y, SkScalar z = 0);
|
|
SkM44& postTranslate(SkScalar x, SkScalar y, SkScalar z = 0);
|
|
|
|
SkM44& preScale(SkScalar x, SkScalar y);
|
|
SkM44& preScale(SkScalar x, SkScalar y, SkScalar z);
|
|
SkM44& preConcat(const SkMatrix&);
|
|
|
|
private:
|
|
/* Stored in column-major.
|
|
* Indices
|
|
* 0 4 8 12 1 0 0 trans_x
|
|
* 1 5 9 13 e.g. 0 1 0 trans_y
|
|
* 2 6 10 14 0 0 1 trans_z
|
|
* 3 7 11 15 0 0 0 1
|
|
*/
|
|
SkScalar fMat[16];
|
|
|
|
friend class SkMatrixPriv;
|
|
};
|
|
|
|
#endif
|