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 17 #pragma once 18 19 #include "Rect.h" 20 21 #include <cutils/compiler.h> 22 #include <iomanip> 23 #include <ostream> 24 #include <SkMatrix.h> 25 26 namespace android { 27 namespace uirenderer { 28 29 #define SK_MATRIX_STRING "[%.2f %.2f %.2f] [%.2f %.2f %.2f] [%.2f %.2f %.2f]" 30 #define SK_MATRIX_ARGS(m) \ 31 (m)->get(0), (m)->get(1), (m)->get(2), \ 32 (m)->get(3), (m)->get(4), (m)->get(5), \ 33 (m)->get(6), (m)->get(7), (m)->get(8) 34 35 #define MATRIX_4_STRING "[%.2f %.2f %.2f %.2f] [%.2f %.2f %.2f %.2f]" \ 36 " [%.2f %.2f %.2f %.2f] [%.2f %.2f %.2f %.2f]" 37 #define MATRIX_4_ARGS(m) \ 38 (m)->data[0], (m)->data[4], (m)->data[8], (m)->data[12], \ 39 (m)->data[1], (m)->data[5], (m)->data[9], (m)->data[13], \ 40 (m)->data[2], (m)->data[6], (m)->data[10], (m)->data[14], \ 41 (m)->data[3], (m)->data[7], (m)->data[11], (m)->data[15] \ 42 43 /////////////////////////////////////////////////////////////////////////////// 44 // Classes 45 /////////////////////////////////////////////////////////////////////////////// 46 47 class ANDROID_API Matrix4 { 48 public: 49 float data[16]; 50 51 enum Entry { 52 kScaleX = 0, 53 kSkewY = 1, 54 kPerspective0 = 3, 55 kSkewX = 4, 56 kScaleY = 5, 57 kPerspective1 = 7, 58 kScaleZ = 10, 59 kTranslateX = 12, 60 kTranslateY = 13, 61 kTranslateZ = 14, 62 kPerspective2 = 15 63 }; 64 65 // NOTE: The flags from kTypeIdentity to kTypePerspective 66 // must be kept in sync with the type flags found 67 // in SkMatrix 68 enum Type { 69 kTypeIdentity = 0, 70 kTypeTranslate = 0x1, 71 kTypeScale = 0x2, 72 kTypeAffine = 0x4, 73 kTypePerspective = 0x8, 74 kTypeRectToRect = 0x10, 75 kTypeUnknown = 0x20, 76 }; 77 78 static const int sGeometryMask = 0xf; 79 Matrix4()80 Matrix4() { 81 loadIdentity(); 82 } 83 Matrix4(const float * v)84 explicit Matrix4(const float* v) { 85 load(v); 86 } 87 Matrix4(const SkMatrix & v)88 Matrix4(const SkMatrix& v) { // NOLINT, implicit 89 load(v); 90 } 91 92 float operator[](int index) const { 93 return data[index]; 94 } 95 96 float& operator[](int index) { 97 mType = kTypeUnknown; 98 return data[index]; 99 } 100 101 Matrix4& operator=(const SkMatrix& v) { 102 load(v); 103 return *this; 104 } 105 106 friend bool operator==(const Matrix4& a, const Matrix4& b) { 107 return !memcmp(&a.data[0], &b.data[0], 16 * sizeof(float)); 108 } 109 110 friend bool operator!=(const Matrix4& a, const Matrix4& b) { 111 return !(a == b); 112 } 113 114 void loadIdentity(); 115 116 void load(const float* v); 117 void load(const SkMatrix& v); 118 119 void loadInverse(const Matrix4& v); 120 121 void loadTranslate(float x, float y, float z); 122 void loadScale(float sx, float sy, float sz); 123 void loadSkew(float sx, float sy); 124 void loadRotate(float angle); 125 void loadRotate(float angle, float x, float y, float z); 126 void loadMultiply(const Matrix4& u, const Matrix4& v); 127 128 void loadOrtho(float left, float right, float bottom, float top, float near, float far); loadOrtho(int width,int height)129 void loadOrtho(int width, int height) { 130 loadOrtho(0, width, height, 0, -1, 1); 131 } 132 133 uint8_t getType() const; 134 multiplyInverse(const Matrix4 & v)135 void multiplyInverse(const Matrix4& v) { 136 Matrix4 inv; 137 inv.loadInverse(v); 138 multiply(inv); 139 } 140 multiply(const Matrix4 & v)141 void multiply(const Matrix4& v) { 142 if (!v.isIdentity()) { 143 Matrix4 u; 144 u.loadMultiply(*this, v); 145 *this = u; 146 } 147 } 148 149 void multiply(float v); 150 151 void translate(float x, float y, float z = 0) { 152 if ((getType() & sGeometryMask) <= kTypeTranslate) { 153 data[kTranslateX] += x; 154 data[kTranslateY] += y; 155 data[kTranslateZ] += z; 156 mType |= kTypeUnknown; 157 } else { 158 // Doing a translation will only affect the translate bit of the type 159 // Save the type 160 uint8_t type = mType; 161 162 Matrix4 u; 163 u.loadTranslate(x, y, z); 164 multiply(u); 165 166 // Restore the type and fix the translate bit 167 mType = type; 168 if (data[kTranslateX] != 0.0f || data[kTranslateY] != 0.0f) { 169 mType |= kTypeTranslate; 170 } else { 171 mType &= ~kTypeTranslate; 172 } 173 } 174 } 175 scale(float sx,float sy,float sz)176 void scale(float sx, float sy, float sz) { 177 Matrix4 u; 178 u.loadScale(sx, sy, sz); 179 multiply(u); 180 } 181 skew(float sx,float sy)182 void skew(float sx, float sy) { 183 Matrix4 u; 184 u.loadSkew(sx, sy); 185 multiply(u); 186 } 187 rotate(float angle,float x,float y,float z)188 void rotate(float angle, float x, float y, float z) { 189 Matrix4 u; 190 u.loadRotate(angle, x, y, z); 191 multiply(u); 192 } 193 194 /** 195 * If the matrix is identity or translate and/or scale. 196 */ 197 bool isSimple() const; 198 bool isPureTranslate() const; 199 bool isIdentity() const; 200 bool isPerspective() const; 201 bool rectToRect() const; 202 bool positiveScale() const; 203 204 bool changesBounds() const; 205 206 void copyTo(float* v) const; 207 void copyTo(SkMatrix& v) const; 208 209 float mapZ(const Vector3& orig) const; 210 void mapPoint3d(Vector3& vec) const; 211 void mapPoint(float& x, float& y) const; // 2d only 212 void mapRect(Rect& r) const; // 2d only 213 214 float getTranslateX() const; 215 float getTranslateY() const; 216 217 void decomposeScale(float& sx, float& sy) const; 218 219 void dump(const char* label = nullptr) const; 220 221 friend std::ostream& operator<<(std::ostream& os, const Matrix4& matrix) { 222 if (matrix.isSimple()) { 223 os << "offset " << matrix.getTranslateX() << "x" << matrix.getTranslateY(); 224 if (!matrix.isPureTranslate()) { 225 os << ", scale " << matrix[kScaleX] << "x" << matrix[kScaleY]; 226 } 227 } else { 228 os << "[" << matrix[0]; 229 for (int i = 1; i < 16; i++) { 230 os << ", " << matrix[i]; 231 } 232 os << "]"; 233 } 234 return os; 235 } 236 237 static const Matrix4& identity(); 238 invalidateType()239 void invalidateType() { mType = kTypeUnknown; } 240 241 private: 242 mutable uint8_t mType; 243 get(int i,int j)244 inline float get(int i, int j) const { 245 return data[i * 4 + j]; 246 } 247 set(int i,int j,float v)248 inline void set(int i, int j, float v) { 249 data[i * 4 + j] = v; 250 } 251 252 uint8_t getGeometryType() const; 253 254 }; // class Matrix4 255 256 /////////////////////////////////////////////////////////////////////////////// 257 // Types 258 /////////////////////////////////////////////////////////////////////////////// 259 260 typedef Matrix4 mat4; 261 262 }; // namespace uirenderer 263 }; // namespace android 264 265