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 inline bool hasPerspective() const { 202 return SkToBool(this->getType() & kPerspective_Mask); 203 } 204 205 void setIdentity(); 206 inline void reset() { this->setIdentity();} 207 208 /** 209 * get a value from the matrix. The row,col parameters work as follows: 210 * (0, 0) scale-x 211 * (0, 3) translate-x 212 * (3, 0) perspective-x 213 */ 214 inline SkMScalar get(int row, int col) const { 215 SkASSERT((unsigned)row <= 3); 216 SkASSERT((unsigned)col <= 3); 217 return fMat[col][row]; 218 } 219 220 /** 221 * set a value in the matrix. The row,col parameters work as follows: 222 * (0, 0) scale-x 223 * (0, 3) translate-x 224 * (3, 0) perspective-x 225 */ 226 inline void set(int row, int col, SkMScalar value) { 227 SkASSERT((unsigned)row <= 3); 228 SkASSERT((unsigned)col <= 3); 229 fMat[col][row] = value; 230 this->dirtyTypeMask(); 231 } 232 233 inline double getDouble(int row, int col) const { 234 return SkMScalarToDouble(this->get(row, col)); 235 } 236 inline void setDouble(int row, int col, double value) { 237 this->set(row, col, SkDoubleToMScalar(value)); 238 } 239 inline float getFloat(int row, int col) const { 240 return SkMScalarToFloat(this->get(row, col)); 241 } 242 inline void setFloat(int row, int col, float value) { 243 this->set(row, col, SkFloatToMScalar(value)); 244 } 245 246 /** These methods allow one to efficiently read matrix entries into an 247 * array. The given array must have room for exactly 16 entries. Whenever 248 * possible, they will try to use memcpy rather than an entry-by-entry 249 * copy. 250 */ 251 void asColMajorf(float[]) const; 252 void asColMajord(double[]) const; 253 void asRowMajorf(float[]) const; 254 void asRowMajord(double[]) const; 255 256 /** These methods allow one to efficiently set all matrix entries from an 257 * array. The given array must have room for exactly 16 entries. Whenever 258 * possible, they will try to use memcpy rather than an entry-by-entry 259 * copy. 260 */ 261 void setColMajorf(const float[]); 262 void setColMajord(const double[]); 263 void setRowMajorf(const float[]); 264 void setRowMajord(const double[]); 265 266 #ifdef SK_MSCALAR_IS_FLOAT 267 void setColMajor(const SkMScalar data[]) { this->setColMajorf(data); } 268 void setRowMajor(const SkMScalar data[]) { this->setRowMajorf(data); } 269 #else 270 void setColMajor(const SkMScalar data[]) { this->setColMajord(data); } 271 void setRowMajor(const SkMScalar data[]) { this->setRowMajord(data); } 272 #endif 273 274 /* This sets the top-left of the matrix and clears the translation and 275 * perspective components (with [3][3] set to 1). */ 276 void set3x3(SkMScalar m00, SkMScalar m01, SkMScalar m02, 277 SkMScalar m10, SkMScalar m11, SkMScalar m12, 278 SkMScalar m20, SkMScalar m21, SkMScalar m22); 279 280 void setTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 281 void preTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 282 void postTranslate(SkMScalar dx, SkMScalar dy, SkMScalar dz); 283 284 void setScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 285 void preScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 286 void postScale(SkMScalar sx, SkMScalar sy, SkMScalar sz); 287 288 inline void setScale(SkMScalar scale) { 289 this->setScale(scale, scale, scale); 290 } 291 inline void preScale(SkMScalar scale) { 292 this->preScale(scale, scale, scale); 293 } 294 inline void postScale(SkMScalar scale) { 295 this->postScale(scale, scale, scale); 296 } 297 298 void setRotateDegreesAbout(SkMScalar x, SkMScalar y, SkMScalar z, 299 SkMScalar degrees) { 300 this->setRotateAbout(x, y, z, degrees * SK_MScalarPI / 180); 301 } 302 303 /** Rotate about the vector [x,y,z]. If that vector is not unit-length, 304 it will be automatically resized. 305 */ 306 void setRotateAbout(SkMScalar x, SkMScalar y, SkMScalar z, 307 SkMScalar radians); 308 /** Rotate about the vector [x,y,z]. Does not check the length of the 309 vector, assuming it is unit-length. 310 */ 311 void setRotateAboutUnit(SkMScalar x, SkMScalar y, SkMScalar z, 312 SkMScalar radians); 313 314 void setConcat(const SkMatrix44& a, const SkMatrix44& b); 315 inline void preConcat(const SkMatrix44& m) { 316 this->setConcat(*this, m); 317 } 318 inline void postConcat(const SkMatrix44& m) { 319 this->setConcat(m, *this); 320 } 321 322 friend SkMatrix44 operator*(const SkMatrix44& a, const SkMatrix44& b) { 323 return SkMatrix44(a, b); 324 } 325 326 /** If this is invertible, return that in inverse and return true. If it is 327 not invertible, return false and ignore the inverse parameter. 328 */ 329 bool invert(SkMatrix44* inverse) const; 330 331 /** Transpose this matrix in place. */ 332 void transpose(); 333 334 /** Apply the matrix to the src vector, returning the new vector in dst. 335 It is legal for src and dst to point to the same memory. 336 */ 337 void mapScalars(const SkScalar src[4], SkScalar dst[4]) const; 338 inline void mapScalars(SkScalar vec[4]) const { 339 this->mapScalars(vec, vec); 340 } 341 342 SK_ATTR_DEPRECATED("use mapScalars") 343 void map(const SkScalar src[4], SkScalar dst[4]) const { 344 this->mapScalars(src, dst); 345 } 346 347 SK_ATTR_DEPRECATED("use mapScalars") 348 void map(SkScalar vec[4]) const { 349 this->mapScalars(vec, vec); 350 } 351 352 #ifdef SK_MSCALAR_IS_DOUBLE 353 void mapMScalars(const SkMScalar src[4], SkMScalar dst[4]) const; 354 #elif defined SK_MSCALAR_IS_FLOAT 355 inline void mapMScalars(const SkMScalar src[4], SkMScalar dst[4]) const { 356 this->mapScalars(src, dst); 357 } 358 #endif 359 inline void mapMScalars(SkMScalar vec[4]) const { 360 this->mapMScalars(vec, vec); 361 } 362 363 friend SkVector4 operator*(const SkMatrix44& m, const SkVector4& src) { 364 SkVector4 dst; 365 m.mapScalars(src.fData, dst.fData); 366 return dst; 367 } 368 369 /** 370 * map an array of [x, y, 0, 1] through the matrix, returning an array 371 * of [x', y', z', w']. 372 * 373 * @param src2 array of [x, y] pairs, with implied z=0 and w=1 374 * @param count number of [x, y] pairs in src2 375 * @param dst4 array of [x', y', z', w'] quads as the output. 376 */ 377 void map2(const float src2[], int count, float dst4[]) const; 378 void map2(const double src2[], int count, double dst4[]) const; 379 380 void dump() const; 381 382 double determinant() const; 383 384 private: 385 SkMScalar fMat[4][4]; 386 mutable unsigned fTypeMask; 387 388 enum { 389 kUnknown_Mask = 0x80, 390 391 kAllPublic_Masks = 0xF 392 }; 393 394 SkMScalar transX() const { return fMat[3][0]; } 395 SkMScalar transY() const { return fMat[3][1]; } 396 SkMScalar transZ() const { return fMat[3][2]; } 397 398 SkMScalar scaleX() const { return fMat[0][0]; } 399 SkMScalar scaleY() const { return fMat[1][1]; } 400 SkMScalar scaleZ() const { return fMat[2][2]; } 401 402 SkMScalar perspX() const { return fMat[0][3]; } 403 SkMScalar perspY() const { return fMat[1][3]; } 404 SkMScalar perspZ() const { return fMat[2][3]; } 405 406 int computeTypeMask() const; 407 408 inline void dirtyTypeMask() { 409 fTypeMask = kUnknown_Mask; 410 } 411 412 inline void setTypeMask(int mask) { 413 SkASSERT(0 == (~(kAllPublic_Masks | kUnknown_Mask) & mask)); 414 fTypeMask = mask; 415 } 416 417 /** 418 * Does not take the time to 'compute' the typemask. Only returns true if 419 * we already know that this matrix is identity. 420 */ 421 inline bool isTriviallyIdentity() const { 422 return 0 == fTypeMask; 423 } 424 }; 425 426 #endif 427
