• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
SkFloatToMScalar(float x)20     static inline double SkFloatToMScalar(float x) {
21         return static_cast<double>(x);
22     }
SkMScalarToFloat(double x)23     static inline float SkMScalarToFloat(double x) {
24         return static_cast<float>(x);
25     }
SkDoubleToMScalar(double x)26     static inline double SkDoubleToMScalar(double x) {
27         return x;
28     }
SkMScalarToDouble(double x)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 
SkFloatToMScalar(float x)39     static inline float SkFloatToMScalar(float x) {
40         return x;
41     }
SkMScalarToFloat(float x)42     static inline float SkMScalarToFloat(float x) {
43         return x;
44     }
SkDoubleToMScalar(double x)45     static inline float SkDoubleToMScalar(double x) {
46         return static_cast<float>(x);
47     }
SkMScalarToDouble(float x)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 
SkVector4SkVector464     SkVector4() {
65         this->set(0, 0, 0, 1);
66     }
SkVector4SkVector467     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 
SkMatrix44(Uninitialized_Constructor)112     SkMatrix44(Uninitialized_Constructor) { }
SkMatrix44(Identity_Constructor)113     SkMatrix44(Identity_Constructor) { this->setIdentity(); }
114 
115     SK_ATTR_DEPRECATED("use the constructors that take an enum")
SkMatrix44()116     SkMatrix44() { this->setIdentity(); }
117 
SkMatrix44(const SkMatrix44 & src)118     SkMatrix44(const SkMatrix44& src) {
119         memcpy(fMat, src.fMat, sizeof(fMat));
120         fTypeMask = src.fTypeMask;
121     }
122 
SkMatrix44(const SkMatrix44 & a,const SkMatrix44 & b)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      */
getType()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      */
isIdentity()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      */
isTranslate()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      */
isScaleTranslate()197     inline bool isScaleTranslate() const {
198         return !(this->getType() & ~(kScale_Mask | kTranslate_Mask));
199     }
200 
201     void setIdentity();
reset()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      */
get(int row,int col)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      */
set(int row,int col,SkMScalar value)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 
getDouble(int row,int col)229     inline double getDouble(int row, int col) const {
230         return SkMScalarToDouble(this->get(row, col));
231     }
setDouble(int row,int col,double value)232     inline void setDouble(int row, int col, double value) {
233         this->set(row, col, SkDoubleToMScalar(value));
234     }
getFloat(int row,int col)235     inline float getFloat(int row, int col) const {
236         return SkMScalarToFloat(this->get(row, col));
237     }
setFloat(int row,int col,float value)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
setColMajor(const SkMScalar data[])263     void setColMajor(const SkMScalar data[]) { this->setColMajorf(data); }
setRowMajor(const SkMScalar data[])264     void setRowMajor(const SkMScalar data[]) { this->setRowMajorf(data); }
265 #else
setColMajor(const SkMScalar data[])266     void setColMajor(const SkMScalar data[]) { this->setColMajord(data); }
setRowMajor(const SkMScalar 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 
setScale(SkMScalar scale)284     inline void setScale(SkMScalar scale) {
285         this->setScale(scale, scale, scale);
286     }
preScale(SkMScalar scale)287     inline void preScale(SkMScalar scale) {
288         this->preScale(scale, scale, scale);
289     }
postScale(SkMScalar scale)290     inline void postScale(SkMScalar scale) {
291         this->postScale(scale, scale, scale);
292     }
293 
setRotateDegreesAbout(SkMScalar x,SkMScalar y,SkMScalar z,SkMScalar degrees)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);
preConcat(const SkMatrix44 & m)311     inline void preConcat(const SkMatrix44& m) {
312         this->setConcat(*this, m);
313     }
postConcat(const SkMatrix44 & m)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;
mapScalars(SkScalar vec[4])334     inline void mapScalars(SkScalar vec[4]) const {
335         this->mapScalars(vec, vec);
336     }
337 
338     SK_ATTR_DEPRECATED("use mapScalars")
map(const SkScalar src[4],SkScalar dst[4])339     void map(const SkScalar src[4], SkScalar dst[4]) const {
340         this->mapScalars(src, dst);
341     }
342 
343     SK_ATTR_DEPRECATED("use mapScalars")
map(SkScalar vec[4])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
mapMScalars(const SkMScalar src[4],SkMScalar dst[4])351     inline void mapMScalars(const SkMScalar src[4], SkMScalar dst[4]) const {
352         this->mapScalars(src, dst);
353     }
354 #endif
mapMScalars(SkMScalar vec[4])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 
transX()390     SkMScalar transX() const { return fMat[3][0]; }
transY()391     SkMScalar transY() const { return fMat[3][1]; }
transZ()392     SkMScalar transZ() const { return fMat[3][2]; }
393 
scaleX()394     SkMScalar scaleX() const { return fMat[0][0]; }
scaleY()395     SkMScalar scaleY() const { return fMat[1][1]; }
scaleZ()396     SkMScalar scaleZ() const { return fMat[2][2]; }
397 
perspX()398     SkMScalar perspX() const { return fMat[0][3]; }
perspY()399     SkMScalar perspY() const { return fMat[1][3]; }
perspZ()400     SkMScalar perspZ() const { return fMat[2][3]; }
401 
402     int computeTypeMask() const;
403 
dirtyTypeMask()404     inline void dirtyTypeMask() {
405         fTypeMask = kUnknown_Mask;
406     }
407 
setTypeMask(int mask)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      */
isTriviallyIdentity()417     inline bool isTriviallyIdentity() const {
418         return 0 == fTypeMask;
419     }
420 };
421 
422 #endif
423