Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 17 | #pragma once |
Romain Guy | 71e36aa | 2011-10-12 14:11:32 -0700 | [diff] [blame] | 18 | |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 19 | #include "Rect.h" |
| 20 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 21 | #include <SkMatrix.h> |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 22 | #include <cutils/compiler.h> |
| 23 | #include <iomanip> |
| 24 | #include <ostream> |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 25 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 26 | namespace android { |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 27 | namespace uirenderer { |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 28 | |
Chris Craik | 629f677 | 2014-02-05 13:00:24 -0800 | [diff] [blame] | 29 | #define SK_MATRIX_STRING "[%.2f %.2f %.2f] [%.2f %.2f %.2f] [%.2f %.2f %.2f]" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 30 | #define SK_MATRIX_ARGS(m) \ |
| 31 | (m)->get(0), (m)->get(1), (m)->get(2), (m)->get(3), (m)->get(4), (m)->get(5), (m)->get(6), \ |
| 32 | (m)->get(7), (m)->get(8) |
Chris Craik | 28ce94a | 2013-05-31 11:38:03 -0700 | [diff] [blame] | 33 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 34 | #define MATRIX_4_STRING \ |
| 35 | "[%.2f %.2f %.2f %.2f] [%.2f %.2f %.2f %.2f]" \ |
Chris Craik | 629f677 | 2014-02-05 13:00:24 -0800 | [diff] [blame] | 36 | " [%.2f %.2f %.2f %.2f] [%.2f %.2f %.2f %.2f]" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 37 | #define MATRIX_4_ARGS(m) \ |
| 38 | (m)->data[0], (m)->data[4], (m)->data[8], (m)->data[12], (m)->data[1], (m)->data[5], \ |
| 39 | (m)->data[9], (m)->data[13], (m)->data[2], (m)->data[6], (m)->data[10], (m)->data[14], \ |
| 40 | (m)->data[3], (m)->data[7], (m)->data[11], (m)->data[15] |
Chris Craik | 629f677 | 2014-02-05 13:00:24 -0800 | [diff] [blame] | 41 | |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 42 | /////////////////////////////////////////////////////////////////////////////// |
| 43 | // Classes |
| 44 | /////////////////////////////////////////////////////////////////////////////// |
| 45 | |
Romain Guy | 71e36aa | 2011-10-12 14:11:32 -0700 | [diff] [blame] | 46 | class ANDROID_API Matrix4 { |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 47 | public: |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 48 | float data[16]; |
Romain Guy | c7d5349 | 2010-06-25 13:41:57 -0700 | [diff] [blame] | 49 | |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 50 | enum Entry { |
| 51 | kScaleX = 0, |
| 52 | kSkewY = 1, |
| 53 | kPerspective0 = 3, |
| 54 | kSkewX = 4, |
| 55 | kScaleY = 5, |
| 56 | kPerspective1 = 7, |
| 57 | kScaleZ = 10, |
| 58 | kTranslateX = 12, |
| 59 | kTranslateY = 13, |
| 60 | kTranslateZ = 14, |
| 61 | kPerspective2 = 15 |
| 62 | }; |
| 63 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 64 | // NOTE: The flags from kTypeIdentity to kTypePerspective |
| 65 | // must be kept in sync with the type flags found |
| 66 | // in SkMatrix |
| 67 | enum Type { |
| 68 | kTypeIdentity = 0, |
| 69 | kTypeTranslate = 0x1, |
| 70 | kTypeScale = 0x2, |
| 71 | kTypeAffine = 0x4, |
| 72 | kTypePerspective = 0x8, |
| 73 | kTypeRectToRect = 0x10, |
Chris Craik | 996fe65 | 2013-09-20 17:13:18 -0700 | [diff] [blame] | 74 | kTypeUnknown = 0x20, |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 75 | }; |
| 76 | |
| 77 | static const int sGeometryMask = 0xf; |
| 78 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 79 | Matrix4() { loadIdentity(); } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 80 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 81 | explicit Matrix4(const float* v) { load(v); } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 82 | |
Chih-Hung Hsieh | f21b0b6 | 2018-12-20 13:48:02 -0800 | [diff] [blame] | 83 | Matrix4(const SkMatrix& v) { // NOLINT(google-explicit-constructor) |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 84 | load(v); |
| 85 | } |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 86 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 87 | float operator[](int index) const { return data[index]; } |
Romain Guy | 3b75382 | 2013-03-05 10:27:35 -0800 | [diff] [blame] | 88 | |
| 89 | float& operator[](int index) { |
| 90 | mType = kTypeUnknown; |
| 91 | return data[index]; |
| 92 | } |
| 93 | |
| 94 | Matrix4& operator=(const SkMatrix& v) { |
| 95 | load(v); |
| 96 | return *this; |
| 97 | } |
| 98 | |
Romain Guy | bd3055f | 2013-03-13 16:14:47 -0700 | [diff] [blame] | 99 | friend bool operator==(const Matrix4& a, const Matrix4& b) { |
| 100 | return !memcmp(&a.data[0], &b.data[0], 16 * sizeof(float)); |
| 101 | } |
| 102 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 103 | friend bool operator!=(const Matrix4& a, const Matrix4& b) { return !(a == b); } |
Romain Guy | bd3055f | 2013-03-13 16:14:47 -0700 | [diff] [blame] | 104 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 105 | void loadIdentity(); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 106 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 107 | void load(const float* v); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 108 | void load(const SkMatrix& v); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 109 | |
Romain Guy | 079ba2c | 2010-07-16 14:12:24 -0700 | [diff] [blame] | 110 | void loadInverse(const Matrix4& v); |
| 111 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 112 | void loadTranslate(float x, float y, float z); |
| 113 | void loadScale(float sx, float sy, float sz); |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 114 | void loadSkew(float sx, float sy); |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 115 | void loadRotate(float angle); |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 116 | void loadRotate(float angle, float x, float y, float z); |
| 117 | void loadMultiply(const Matrix4& u, const Matrix4& v); |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 118 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 119 | void loadOrtho(float left, float right, float bottom, float top, float near, float far); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 120 | void loadOrtho(int width, int height) { loadOrtho(0, width, height, 0, -1, 1); } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 121 | |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 122 | uint8_t getType() const; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 123 | |
Chris Craik | fca52b75 | 2015-04-28 11:45:59 -0700 | [diff] [blame] | 124 | void multiplyInverse(const Matrix4& v) { |
| 125 | Matrix4 inv; |
| 126 | inv.loadInverse(v); |
| 127 | multiply(inv); |
| 128 | } |
| 129 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 130 | void multiply(const Matrix4& v) { |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 131 | if (!v.isIdentity()) { |
| 132 | Matrix4 u; |
| 133 | u.loadMultiply(*this, v); |
| 134 | *this = u; |
| 135 | } |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 136 | } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 137 | |
Romain Guy | ddb80be | 2010-09-20 19:04:33 -0700 | [diff] [blame] | 138 | void multiply(float v); |
| 139 | |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 140 | void translate(float x, float y, float z = 0) { |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 141 | if ((getType() & sGeometryMask) <= kTypeTranslate) { |
Romain Guy | 4c2547f | 2013-06-11 16:19:24 -0700 | [diff] [blame] | 142 | data[kTranslateX] += x; |
| 143 | data[kTranslateY] += y; |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 144 | data[kTranslateZ] += z; |
John Reck | a447d29 | 2014-06-11 18:39:44 -0700 | [diff] [blame] | 145 | mType |= kTypeUnknown; |
Romain Guy | 4c2547f | 2013-06-11 16:19:24 -0700 | [diff] [blame] | 146 | } else { |
| 147 | // Doing a translation will only affect the translate bit of the type |
| 148 | // Save the type |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 149 | uint8_t type = mType; |
Romain Guy | 4c2547f | 2013-06-11 16:19:24 -0700 | [diff] [blame] | 150 | |
| 151 | Matrix4 u; |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 152 | u.loadTranslate(x, y, z); |
Romain Guy | 4c2547f | 2013-06-11 16:19:24 -0700 | [diff] [blame] | 153 | multiply(u); |
| 154 | |
| 155 | // Restore the type and fix the translate bit |
| 156 | mType = type; |
| 157 | if (data[kTranslateX] != 0.0f || data[kTranslateY] != 0.0f) { |
| 158 | mType |= kTypeTranslate; |
| 159 | } else { |
| 160 | mType &= ~kTypeTranslate; |
| 161 | } |
| 162 | } |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 163 | } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 164 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 165 | void scale(float sx, float sy, float sz) { |
| 166 | Matrix4 u; |
| 167 | u.loadScale(sx, sy, sz); |
| 168 | multiply(u); |
| 169 | } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 170 | |
Romain Guy | 807daf7 | 2011-01-18 11:19:19 -0800 | [diff] [blame] | 171 | void skew(float sx, float sy) { |
| 172 | Matrix4 u; |
| 173 | u.loadSkew(sx, sy); |
| 174 | multiply(u); |
| 175 | } |
| 176 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 177 | void rotate(float angle, float x, float y, float z) { |
| 178 | Matrix4 u; |
| 179 | u.loadRotate(angle, x, y, z); |
| 180 | multiply(u); |
| 181 | } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 182 | |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 183 | /** |
| 184 | * If the matrix is identity or translate and/or scale. |
| 185 | */ |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 186 | bool isSimple() const; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 187 | bool isPureTranslate() const; |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 188 | bool isIdentity() const; |
Romain Guy | a3dc55f | 2012-09-28 13:55:44 -0700 | [diff] [blame] | 189 | bool isPerspective() const; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 190 | bool rectToRect() const; |
Chris Craik | d965bc5 | 2013-09-16 14:47:13 -0700 | [diff] [blame] | 191 | bool positiveScale() const; |
Romain Guy | 6620c6d | 2010-12-06 18:07:02 -0800 | [diff] [blame] | 192 | |
Chris Craik | 710f46d | 2012-09-17 17:25:49 -0700 | [diff] [blame] | 193 | bool changesBounds() const; |
Romain Guy | e8cb9c14 | 2010-10-04 14:14:11 -0700 | [diff] [blame] | 194 | |
Romain Guy | 7ae7ac4 | 2010-06-25 13:46:18 -0700 | [diff] [blame] | 195 | void copyTo(float* v) const; |
| 196 | void copyTo(SkMatrix& v) const; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 197 | |
Chris Craik | b79a3e3 | 2014-03-11 12:20:17 -0700 | [diff] [blame] | 198 | float mapZ(const Vector3& orig) const; |
Chris Craik | f57776b | 2013-10-25 18:30:17 -0700 | [diff] [blame] | 199 | void mapPoint3d(Vector3& vec) const; |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 200 | void mapPoint(float& x, float& y) const; // 2d only |
| 201 | void mapRect(Rect& r) const; // 2d only |
Romain Guy | 9d5316e | 2010-06-24 19:30:36 -0700 | [diff] [blame] | 202 | |
Romain Guy | 624234f | 2013-03-05 16:43:31 -0800 | [diff] [blame] | 203 | float getTranslateX() const; |
| 204 | float getTranslateY() const; |
Romain Guy | bd6b79b | 2010-06-26 00:13:53 -0700 | [diff] [blame] | 205 | |
Romain Guy | 3b75382 | 2013-03-05 10:27:35 -0800 | [diff] [blame] | 206 | void decomposeScale(float& sx, float& sy) const; |
| 207 | |
Chris Craik | e84a208 | 2014-12-22 14:28:49 -0800 | [diff] [blame] | 208 | void dump(const char* label = nullptr) const; |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 209 | |
Chris Craik | 91eff22 | 2016-02-22 13:39:33 -0800 | [diff] [blame] | 210 | friend std::ostream& operator<<(std::ostream& os, const Matrix4& matrix) { |
| 211 | if (matrix.isSimple()) { |
| 212 | os << "offset " << matrix.getTranslateX() << "x" << matrix.getTranslateY(); |
| 213 | if (!matrix.isPureTranslate()) { |
| 214 | os << ", scale " << matrix[kScaleX] << "x" << matrix[kScaleY]; |
| 215 | } |
| 216 | } else { |
| 217 | os << "[" << matrix[0]; |
| 218 | for (int i = 1; i < 16; i++) { |
| 219 | os << ", " << matrix[i]; |
| 220 | } |
| 221 | os << "]"; |
| 222 | } |
| 223 | return os; |
| 224 | } |
| 225 | |
Romain Guy | c74f45a | 2013-02-26 19:10:14 -0800 | [diff] [blame] | 226 | static const Matrix4& identity(); |
| 227 | |
John Reck | 2f69d6d | 2016-04-28 13:18:51 -0700 | [diff] [blame] | 228 | void invalidateType() { mType = kTypeUnknown; } |
| 229 | |
Romain Guy | f6a11b8 | 2010-06-23 17:47:49 -0700 | [diff] [blame] | 230 | private: |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 231 | mutable uint8_t mType; |
Romain Guy | af28b51 | 2010-08-12 14:34:44 -0700 | [diff] [blame] | 232 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 233 | inline float get(int i, int j) const { return data[i * 4 + j]; } |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 234 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 235 | inline void set(int i, int j, float v) { data[i * 4 + j] = v; } |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 236 | |
Romain Guy | f6bed4f | 2013-06-20 17:52:07 -0700 | [diff] [blame] | 237 | uint8_t getGeometryType() const; |
Romain Guy | 8ce0030 | 2013-01-15 18:51:42 -0800 | [diff] [blame] | 238 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 239 | }; // class Matrix4 |
Romain Guy | 08ae317 | 2010-06-21 19:35:50 -0700 | [diff] [blame] | 240 | |
| 241 | /////////////////////////////////////////////////////////////////////////////// |
| 242 | // Types |
| 243 | /////////////////////////////////////////////////////////////////////////////// |
| 244 | |
| 245 | typedef Matrix4 mat4; |
| 246 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 247 | }; // namespace uirenderer |
| 248 | }; // namespace android |