The Tor Browser / file comparison

comparison: gfx/skia/trunk/include/utils/SkMatrix44.h

gfx/skia/trunk/include/utils/SkMatrix44.h

branch
TOR_BUG_9701
changeset 9
a63d609f5ebe
equal deleted inserted replaced
-1:000000000000 0:7e8851e6d0ac
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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial