1 /* 2 * Copyright 2011 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkMatrix44_DEFINED 9 #define SkMatrix44_DEFINED 10 11 #include "SkMatrix.h" 12 #include "SkScalar.h" 13 14 #ifdef SK_MSCALAR_IS_DOUBLE 15 #ifdef SK_MSCALAR_IS_FLOAT 16 #error "can't define MSCALAR both as DOUBLE and FLOAT" 17 #endif 18 typedef double SkMScalar; 19 20 static inline double SkFloatToMScalar(float x) { 21 return static_cast<double>(x); 22 } 23 static inline float SkMScalarToFloat(double x) { 24 return static_cast<float>(x); 25 } 26 static inline double SkDoubleToMScalar(double x) { 27 return x; 28 } 29 static inline double SkMScalarToDouble(double x) { 30 return x; 31 } 32 static const SkMScalar SK_MScalarPI = 3.141592653589793; 33 #elif defined SK_MSCALAR_IS_FLOAT 34 #ifdef SK_MSCALAR_IS_DOUBLE 35 #error "can't define MSCALAR both as DOUBLE and FLOAT" 36 #endif 37 typedef float SkMScalar; 38 39 static inline float SkFloatToMScalar(float x) { 40 return x; 41 } 42 static inline float SkMScalarToFloat(float x) { 43 return x; 44 } 45 static inline float SkDoubleToMScalar(double x) { 46 return static_cast<float>(x); 47 } 48 static inline double SkMScalarToDouble(float x) { 49 return static_cast<double>(x); 50 } 51 static const SkMScalar SK_MScalarPI = 3.14159265f; 52 #endif 53 54 #define SkMScalarToScalar SkMScalarToFloat 55 #define SkScalarToMScalar SkFloatToMScalar 56 57 static const SkMScalar SK_MScalar1 = 1; 58 59 /////////////////////////////////////////////////////////////////////////////// 60 61 struct SkVector4 { 62 SkScalar fData[4]; 63 64 SkVector4() { 65 this->set(0, 0, 0, 1); 66 } 67 SkVector4(const SkVector4& src) { 68 memcpy(fData, src.fData, sizeof(fData)); 69 } 70 SkVector4(SkScalar x, SkScalar y, SkScalar z, SkScalar w = SK_Scalar1) { 71 fData[0] = x; 72 fData[1] = y; 73 fData[2] = z; 74 fData[3] = w; 75 } 76 77 SkVector4& operator=(const SkVector4& src) { 78 memcpy(fData, src.fData, sizeof(fData)); 79 return *this; 80 } 81 82 bool operator==(const SkVector4& v) { 83 return fData[0] == v.fData[0] && fData[1] == v.fData[1] && 84 fData[2] == v.fData[2] && fData[3] == v.fData[3]; 85 } 86 bool operator!=(const SkVector4& v) { 87 return !(*this == v); 88 } 89 bool equals(SkScalar x, SkScalar y, SkScalar z, SkScalar w = SK_Scalar1) { 90 return fData[0] == x && fData[1] == y && 91 fData[2] == z && fData[3] == w; 92 } 93 94 void set(SkScalar x, SkScalar y, SkScalar z, SkScalar w = SK_Scalar1) { 95 fData[0] = x; 96 fData[1] = y; 97 fData[2] = z; 98 fData[3] = w; 99 } 100 }; 101 102 class SK_API SkMatrix44 { 103 public: 104 105 enum Uninitialized_Constructor { 106 kUninitialized_Constructor 107 }; 108 enum Identity_Constructor { 109 kIdentity_Constructor 110 }; 111 112 SkMatrix44(Uninitialized_Constructor) { } 113 SkMatrix44(Identity_Constructor) { this->setIdentity(); } 114 115 SK_ATTR_DEPRECATED("use the constructors that take an enum") 116 SkMatrix44() { this->setIdentity(); } 117 118 SkMatrix44(const SkMatrix44& src) { 119 memcpy(fMat, src.fMat, sizeof(fMat)); 120 fTypeMask = src.fTypeMask; 121 } 122 123 SkMatrix44(const SkMatrix44& a, const SkMatrix44& b) { 124 this->setConcat(a, b); 125 } 126 127 SkMatrix44& operator=(const SkMatrix44& src) { 128 if (&src != this) { 129 memcpy(fMat, src.fMat, sizeof(fMat)); 130 fTypeMask = src.fTypeMask; 131 } 132 return *this; 133 } 134 135 bool operator==(const SkMatrix44& other) const; 136 bool operator!=(const SkMatrix44& other) const { 137 return !(other == *this); 138 } 139 140 /* When converting from SkMatrix44 to SkMatrix, the third row and 141 * column is dropped. When converting from SkMatrix to SkMatrix44 142 * the third row and column remain as identity: 143 * [ a b c ] [ a b 0 c ] 144 * [ d e f ] -> [ d e 0 f ] 145 * [ g h i ] [ 0 0 1 0 ] 146 * [ g h 0 i ] 147 */ 148 SkMatrix44(const SkMatrix&); 149 SkMatrix44& operator=(const SkMatrix& src); 150 operator SkMatrix() const; 151 152 /** 153 * Return a reference to a const identity matrix 154 */ 155 static const SkMatrix44& I(); 156 157 enum TypeMask { 158 kIdentity_Mask = 0, 159 kTranslate_Mask = 0x01, //!< set if the matrix has translation 160 kScale_Mask = 0x02, //!< set if the matrix has any scale != 1 161 kAffine_Mask = 0x04, //!< set if the matrix skews or rotates 162 kPerspective_Mask = 0x08 //!< set if the matrix is in perspective 163 }; 164 165 /** 166 * Returns a bitfield describing the transformations the matrix may 167 * perform. The bitfield is computed conservatively, so it may include 168 * false positives. For example, when kPerspective_Mask is true, all 169 * other bits may be set to true even in the case of a pure perspective 170 * transform. 171 */ 172 inline TypeMask getType() const { 173 if (fTypeMask & kUnknown_Mask) { 174 fTypeMask = this->computeTypeMask(); 175 } 176 SkASSERT(!(fTypeMask & kUnknown_Mask)); 177 return (TypeMask)fTypeMask; 178 } 179 180 /** 181 * Return true if the matrix is identity. 182 */ 183 inline bool isIdentity() const { 184 return kIdentity_Mask == this->getType(); 185 } 186 187 /** 188 * Return true if the matrix contains translate or is identity. 189 */ 190 inline bool isTranslate() const { 191 return !(this->getType() & ~kTranslate_Mask); 192 } 193 194 /** 195 * Return true if the matrix only contains scale or translate or is identity. 196 */ 197 inline bool isScaleTranslate() const { 198 return !(this->getType() & ~(kScale_Mask | kTranslate_Mask)); 199 } 200 201 void setIdentity(); 202 inline void reset() { this->setIdentity();} 203 204 /** 205 * get a value from the matrix. The row,col parameters work as follows: 206 * (0, 0) scale-x 207 * (0, 3) translate-x 208 * (3, 0) perspective-x 209 */ 210 inline SkMScalar get(int row, int col) const { 211 SkASSERT((unsigned)row <= 3); 212 SkASSERT((unsigned)col <= 3); 213 return fMat[col][row]; 214 } 215 216 /** 217 * set a value in the matrix. The row,col parameters work as follows: 218 * (0, 0) scale-x 219 * (0, 3) translate-x 220 * (3, 0) perspective-x 221 */ 222 inline void set(int row, int col, SkMScalar value) { 223 SkASSERT((unsigned)row <= 3); 224 SkASSERT((unsigned)col <= 3); 225 fMat[col][row] = value; 226 this->dirtyTypeMask(); 227 } 228 229 inline double getDouble(int row, int col) const { 230 return SkMScalarToDouble(this->get(row, col)); 231 } 232 inline void setDouble(int row, int col, double value) { 233 this->set(row, col, SkDoubleToMScalar(value)); 234 } 235 inline float getFloat(int row, int col) const { 236 return SkMScalarToFloat(this->get(row, col)); 237 } 238 inline void setFloat(int row, int col, float value) { 239 this->set(row, col, SkFloatToMScalar(value)); 240 } 241 242 /** These methods allow one to efficiently read matrix entries into an 243 * array. The given array must have room for exactly 16 entries. Whenever 244 * possible, they will try to use memcpy rather than an entry-by-entry 245 * copy. 246 */ 247 void asColMajorf(float[]) const; 248 void asColMajord(double[]) const; 249 void asRowMajorf(float[]) const; 250 void asRowMajord(double[]) const; 251 252 /** These methods allow one to efficiently set all matrix entries from an 253 * array. The given array must have room for exactly 16 entries. Whenever 254 * possible, they will try to use memcpy rather than an entry-by-entry 255 * copy. 256 */ 257 void setColMajorf(const float[]); 258 void setColMajord(const double[]); 259 void setRowMajorf(const float[]); 260 void setRowMajord(const double[]); 261 262 #ifdef SK_MSCALAR_IS_FLOAT 263 void setColMajor(const SkMScalar data[]) { this->setColMajorf(data); } 264 void setRowMajor(const SkMScalar data[]) { this->setRowMajorf(data); } 265 #else 266 void setColMajor(const SkMScalar data[]) { this->setColMajord(data); } 267 void setRowMajor(const SkMScalar data[]) { this->setRowMajord(data); } 268 #endif 269 270 /* This sets the top-left of the matrix and clears the translation and 271 * perspective components (with [3][3] set to 1). */ 272 void set3x3(SkMScalar m00, SkMScalar m01, SkMScalar m02, 273 SkMScalar m10, SkMScalar m11, SkMScalar m12, 274 SkMScalar m20, SkMScalar m21, SkMScalar m22); 275 276 void setTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 277 void preTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 278 void postTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 279 280 void setScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 281 void preScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 282 void postScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 283 284 inline void setScale(SkMScalar scale) { 285 this->setScale(scale, scale, scale); 286 } 287 inline void preScale(SkMScalar scale) { 288 this->preScale(scale, scale, scale); 289 } 290 inline void postScale(SkMScalar scale) { 291 this->postScale(scale, scale, scale); 292 } 293 294 void setRotateDegreesAbout(SkMScalar x, SkMScalar y, SkMScalar z, 295 SkMScalar degrees) { 296 this->setRotateAbout(x, y, z, degrees * SK_MScalarPI / 180); 297 } 298 299 /** Rotate about the vector [x,y,z]. If that vector is not unit-length, 300 it will be automatically resized. 301 */ 302 void setRotateAbout(SkMScalar x, SkMScalar y, SkMScalar z, 303 SkMScalar radians); 304 /** Rotate about the vector [x,y,z]. Does not check the length of the 305 vector, assuming it is unit-length. 306 */ 307 void setRotateAboutUnit(SkMScalar x, SkMScalar y, SkMScalar z, 308 SkMScalar radians); 309 310 void setConcat(const SkMatrix44& a, const SkMatrix44& b); 311 inline void preConcat(const SkMatrix44& m) { 312 this->setConcat(*this, m); 313 } 314 inline void postConcat(const SkMatrix44& m) { 315 this->setConcat(m, *this); 316 } 317 318 friend SkMatrix44 operator*(const SkMatrix44& a, const SkMatrix44& b) { 319 return SkMatrix44(a, b); 320 } 321 322 /** If this is invertible, return that in inverse and return true. If it is 323 not invertible, return false and ignore the inverse parameter. 324 */ 325 bool invert(SkMatrix44* inverse) const; 326 327 /** Transpose this matrix in place. */ 328 void transpose(); 329 330 /** Apply the matrix to the src vector, returning the new vector in dst. 331 It is legal for src and dst to point to the same memory. 332 */ 333 void mapScalars(const SkScalar src[4], SkScalar dst[4]) const; 334 inline void mapScalars(SkScalar vec[4]) const { 335 this->mapScalars(vec, vec); 336 } 337 338 SK_ATTR_DEPRECATED("use mapScalars") 339 void map(const SkScalar src[4], SkScalar dst[4]) const { 340 this->mapScalars(src, dst); 341 } 342 343 SK_ATTR_DEPRECATED("use mapScalars") 344 void map(SkScalar vec[4]) const { 345 this->mapScalars(vec, vec); 346 } 347 348 #ifdef SK_MSCALAR_IS_DOUBLE 349 void mapMScalars(const SkMScalar src[4], SkMScalar dst[4]) const; 350 #elif defined SK_MSCALAR_IS_FLOAT 351 inline void mapMScalars(const SkMScalar src[4], SkMScalar dst[4]) const { 352 this->mapScalars(src, dst); 353 } 354 #endif 355 inline void mapMScalars(SkMScalar vec[4]) const { 356 this->mapMScalars(vec, vec); 357 } 358 359 friend SkVector4 operator*(const SkMatrix44& m, const SkVector4& src) { 360 SkVector4 dst; 361 m.mapScalars(src.fData, dst.fData); 362 return dst; 363 } 364 365 /** 366 * map an array of [x, y, 0, 1] through the matrix, returning an array 367 * of [x', y', z', w']. 368 * 369 * @param src2 array of [x, y] pairs, with implied z=0 and w=1 370 * @param count number of [x, y] pairs in src2 371 * @param dst4 array of [x', y', z', w'] quads as the output. 372 */ 373 void map2(const float src2[], int count, float dst4[]) const; 374 void map2(const double src2[], int count, double dst4[]) const; 375 376 void dump() const; 377 378 double determinant() const; 379 380 private: 381 SkMScalar fMat[4][4]; 382 mutable unsigned fTypeMask; 383 384 enum { 385 kUnknown_Mask = 0x80, 386 387 kAllPublic_Masks = 0xF 388 }; 389 390 SkMScalar transX() const { return fMat[3][0]; } 391 SkMScalar transY() const { return fMat[3][1]; } 392 SkMScalar transZ() const { return fMat[3][2]; } 393 394 SkMScalar scaleX() const { return fMat[0][0]; } 395 SkMScalar scaleY() const { return fMat[1][1]; } 396 SkMScalar scaleZ() const { return fMat[2][2]; } 397 398 SkMScalar perspX() const { return fMat[0][3]; } 399 SkMScalar perspY() const { return fMat[1][3]; } 400 SkMScalar perspZ() const { return fMat[2][3]; } 401 402 int computeTypeMask() const; 403 404 inline void dirtyTypeMask() { 405 fTypeMask = kUnknown_Mask; 406 } 407 408 inline void setTypeMask(int mask) { 409 SkASSERT(0 == (~(kAllPublic_Masks | kUnknown_Mask) & mask)); 410 fTypeMask = mask; 411 } 412 413 /** 414 * Does not take the time to 'compute' the typemask. Only returns true if 415 * we already know that this matrix is identity. 416 */ 417 inline bool isTriviallyIdentity() const { 418 return 0 == fTypeMask; 419 } 420 }; 421 422 #endif 423
