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 #define LOG_TAG "OpenGLRenderer"
18
19 #include <math.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include <utils/Log.h>
24
25 #include <SkMatrix.h>
26
27 #include "Matrix.h"
28
29 namespace android {
30 namespace uirenderer {
31
32 ///////////////////////////////////////////////////////////////////////////////
33 // Defines
34 ///////////////////////////////////////////////////////////////////////////////
35
36 static const float EPSILON = 0.0000001f;
37
38 ///////////////////////////////////////////////////////////////////////////////
39 // Matrix
40 ///////////////////////////////////////////////////////////////////////////////
41
identity()42 const Matrix4& Matrix4::identity() {
43 static Matrix4 sIdentity;
44 return sIdentity;
45 }
46
loadIdentity()47 void Matrix4::loadIdentity() {
48 data[kScaleX] = 1.0f;
49 data[kSkewY] = 0.0f;
50 data[2] = 0.0f;
51 data[kPerspective0] = 0.0f;
52
53 data[kSkewX] = 0.0f;
54 data[kScaleY] = 1.0f;
55 data[6] = 0.0f;
56 data[kPerspective1] = 0.0f;
57
58 data[8] = 0.0f;
59 data[9] = 0.0f;
60 data[kScaleZ] = 1.0f;
61 data[11] = 0.0f;
62
63 data[kTranslateX] = 0.0f;
64 data[kTranslateY] = 0.0f;
65 data[kTranslateZ] = 0.0f;
66 data[kPerspective2] = 1.0f;
67
68 mType = kTypeIdentity | kTypeRectToRect;
69 }
70
isZero(float f)71 static bool isZero(float f) {
72 return fabs(f) <= EPSILON;
73 }
74
getType() const75 uint32_t Matrix4::getType() const {
76 if (mType & kTypeUnknown) {
77 mType = kTypeIdentity;
78
79 if (data[kPerspective0] != 0.0f || data[kPerspective1] != 0.0f ||
80 data[kPerspective2] != 1.0f) {
81 mType |= kTypePerspective;
82 }
83
84 if (data[kTranslateX] != 0.0f || data[kTranslateY] != 0.0f) {
85 mType |= kTypeTranslate;
86 }
87
88 float m00 = data[kScaleX];
89 float m01 = data[kSkewX];
90 float m10 = data[kSkewY];
91 float m11 = data[kScaleY];
92
93 if (m01 != 0.0f || m10 != 0.0f) {
94 mType |= kTypeAffine;
95 }
96
97 if (m00 != 1.0f || m11 != 1.0f) {
98 mType |= kTypeScale;
99 }
100
101 // The following section determines whether the matrix will preserve
102 // rectangles. For instance, a rectangle transformed by a pure
103 // translation matrix will result in a rectangle. A rectangle
104 // transformed by a 45 degrees rotation matrix is not a rectangle.
105 // If the matrix has a perspective component then we already know
106 // it doesn't preserve rectangles.
107 if (!(mType & kTypePerspective)) {
108 if ((isZero(m00) && isZero(m11) && !isZero(m01) && !isZero(m10)) ||
109 (isZero(m01) && isZero(m10) && !isZero(m00) && !isZero(m11))) {
110 mType |= kTypeRectToRect;
111 }
112 }
113 }
114 return mType;
115 }
116
getGeometryType() const117 uint32_t Matrix4::getGeometryType() const {
118 return getType() & sGeometryMask;
119 }
120
rectToRect() const121 bool Matrix4::rectToRect() const {
122 return getType() & kTypeRectToRect;
123 }
124
changesBounds() const125 bool Matrix4::changesBounds() const {
126 return getType() & (kTypeScale | kTypeAffine | kTypePerspective);
127 }
128
isPureTranslate() const129 bool Matrix4::isPureTranslate() const {
130 return getGeometryType() == kTypeTranslate;
131 }
132
isSimple() const133 bool Matrix4::isSimple() const {
134 return getGeometryType() <= (kTypeScale | kTypeTranslate);
135 }
136
isIdentity() const137 bool Matrix4::isIdentity() const {
138 return getGeometryType() == kTypeIdentity;
139 }
140
isPerspective() const141 bool Matrix4::isPerspective() const {
142 return getType() & kTypePerspective;
143 }
144
load(const float * v)145 void Matrix4::load(const float* v) {
146 memcpy(data, v, sizeof(data));
147 mType = kTypeUnknown;
148 }
149
load(const Matrix4 & v)150 void Matrix4::load(const Matrix4& v) {
151 memcpy(data, v.data, sizeof(data));
152 mType = v.getType();
153 }
154
load(const SkMatrix & v)155 void Matrix4::load(const SkMatrix& v) {
156 memset(data, 0, sizeof(data));
157
158 data[kScaleX] = v[SkMatrix::kMScaleX];
159 data[kSkewX] = v[SkMatrix::kMSkewX];
160 data[kTranslateX] = v[SkMatrix::kMTransX];
161
162 data[kSkewY] = v[SkMatrix::kMSkewY];
163 data[kScaleY] = v[SkMatrix::kMScaleY];
164 data[kTranslateY] = v[SkMatrix::kMTransY];
165
166 data[kPerspective0] = v[SkMatrix::kMPersp0];
167 data[kPerspective1] = v[SkMatrix::kMPersp1];
168 data[kPerspective2] = v[SkMatrix::kMPersp2];
169
170 data[kScaleZ] = 1.0f;
171
172 // NOTE: The flags are compatible between SkMatrix and this class.
173 // However, SkMatrix::getType() does not return the flag
174 // kRectStaysRect. The return value is masked with 0xF
175 // so we need the extra rectStaysRect() check
176 mType = v.getType();
177 if (v.rectStaysRect()) {
178 mType |= kTypeRectToRect;
179 }
180 }
181
copyTo(SkMatrix & v) const182 void Matrix4::copyTo(SkMatrix& v) const {
183 v.reset();
184
185 v.set(SkMatrix::kMScaleX, data[kScaleX]);
186 v.set(SkMatrix::kMSkewX, data[kSkewX]);
187 v.set(SkMatrix::kMTransX, data[kTranslateX]);
188
189 v.set(SkMatrix::kMSkewY, data[kSkewY]);
190 v.set(SkMatrix::kMScaleY, data[kScaleY]);
191 v.set(SkMatrix::kMTransY, data[kTranslateY]);
192
193 v.set(SkMatrix::kMPersp0, data[kPerspective0]);
194 v.set(SkMatrix::kMPersp1, data[kPerspective1]);
195 v.set(SkMatrix::kMPersp2, data[kPerspective2]);
196 }
197
loadInverse(const Matrix4 & v)198 void Matrix4::loadInverse(const Matrix4& v) {
199 double scale = 1.0 /
200 (v.data[kScaleX] * ((double) v.data[kScaleY] * v.data[kPerspective2] -
201 (double) v.data[kTranslateY] * v.data[kPerspective1]) +
202 v.data[kSkewX] * ((double) v.data[kTranslateY] * v.data[kPerspective0] -
203 (double) v.data[kSkewY] * v.data[kPerspective2]) +
204 v.data[kTranslateX] * ((double) v.data[kSkewY] * v.data[kPerspective1] -
205 (double) v.data[kScaleY] * v.data[kPerspective0]));
206
207 data[kScaleX] = (v.data[kScaleY] * v.data[kPerspective2] -
208 v.data[kTranslateY] * v.data[kPerspective1]) * scale;
209 data[kSkewX] = (v.data[kTranslateX] * v.data[kPerspective1] -
210 v.data[kSkewX] * v.data[kPerspective2]) * scale;
211 data[kTranslateX] = (v.data[kSkewX] * v.data[kTranslateY] -
212 v.data[kTranslateX] * v.data[kScaleY]) * scale;
213
214 data[kSkewY] = (v.data[kTranslateY] * v.data[kPerspective0] -
215 v.data[kSkewY] * v.data[kPerspective2]) * scale;
216 data[kScaleY] = (v.data[kScaleX] * v.data[kPerspective2] -
217 v.data[kTranslateX] * v.data[kPerspective0]) * scale;
218 data[kTranslateY] = (v.data[kTranslateX] * v.data[kSkewY] -
219 v.data[kScaleX] * v.data[kTranslateY]) * scale;
220
221 data[kPerspective0] = (v.data[kSkewY] * v.data[kPerspective1] -
222 v.data[kScaleY] * v.data[kPerspective0]) * scale;
223 data[kPerspective1] = (v.data[kSkewX] * v.data[kPerspective0] -
224 v.data[kScaleX] * v.data[kPerspective1]) * scale;
225 data[kPerspective2] = (v.data[kScaleX] * v.data[kScaleY] -
226 v.data[kSkewX] * v.data[kSkewY]) * scale;
227
228 mType = kTypeUnknown;
229 }
230
copyTo(float * v) const231 void Matrix4::copyTo(float* v) const {
232 memcpy(v, data, sizeof(data));
233 }
234
getTranslateX() const235 float Matrix4::getTranslateX() const {
236 return data[kTranslateX];
237 }
238
getTranslateY() const239 float Matrix4::getTranslateY() const {
240 return data[kTranslateY];
241 }
242
multiply(float v)243 void Matrix4::multiply(float v) {
244 for (int i = 0; i < 16; i++) {
245 data[i] *= v;
246 }
247 mType = kTypeUnknown;
248 }
249
loadTranslate(float x,float y,float z)250 void Matrix4::loadTranslate(float x, float y, float z) {
251 loadIdentity();
252
253 data[kTranslateX] = x;
254 data[kTranslateY] = y;
255 data[kTranslateZ] = z;
256
257 mType = kTypeTranslate | kTypeRectToRect;
258 }
259
loadScale(float sx,float sy,float sz)260 void Matrix4::loadScale(float sx, float sy, float sz) {
261 loadIdentity();
262
263 data[kScaleX] = sx;
264 data[kScaleY] = sy;
265 data[kScaleZ] = sz;
266
267 mType = kTypeScale | kTypeRectToRect;
268 }
269
loadSkew(float sx,float sy)270 void Matrix4::loadSkew(float sx, float sy) {
271 loadIdentity();
272
273 data[kScaleX] = 1.0f;
274 data[kSkewX] = sx;
275 data[kTranslateX] = 0.0f;
276
277 data[kSkewY] = sy;
278 data[kScaleY] = 1.0f;
279 data[kTranslateY] = 0.0f;
280
281 data[kPerspective0] = 0.0f;
282 data[kPerspective1] = 0.0f;
283 data[kPerspective2] = 1.0f;
284
285 mType = kTypeUnknown;
286 }
287
loadRotate(float angle)288 void Matrix4::loadRotate(float angle) {
289 angle *= float(M_PI / 180.0f);
290 float c = cosf(angle);
291 float s = sinf(angle);
292
293 loadIdentity();
294
295 data[kScaleX] = c;
296 data[kSkewX] = -s;
297
298 data[kSkewY] = s;
299 data[kScaleY] = c;
300
301 mType = kTypeUnknown;
302 }
303
loadRotate(float angle,float x,float y,float z)304 void Matrix4::loadRotate(float angle, float x, float y, float z) {
305 data[kPerspective0] = 0.0f;
306 data[kPerspective1] = 0.0f;
307 data[11] = 0.0f;
308 data[kTranslateX] = 0.0f;
309 data[kTranslateY] = 0.0f;
310 data[kTranslateZ] = 0.0f;
311 data[kPerspective2] = 1.0f;
312
313 angle *= float(M_PI / 180.0f);
314 float c = cosf(angle);
315 float s = sinf(angle);
316
317 const float length = sqrtf(x * x + y * y + z * z);
318 float recipLen = 1.0f / length;
319 x *= recipLen;
320 y *= recipLen;
321 z *= recipLen;
322
323 const float nc = 1.0f - c;
324 const float xy = x * y;
325 const float yz = y * z;
326 const float zx = z * x;
327 const float xs = x * s;
328 const float ys = y * s;
329 const float zs = z * s;
330
331 data[kScaleX] = x * x * nc + c;
332 data[kSkewX] = xy * nc - zs;
333 data[8] = zx * nc + ys;
334 data[kSkewY] = xy * nc + zs;
335 data[kScaleY] = y * y * nc + c;
336 data[9] = yz * nc - xs;
337 data[2] = zx * nc - ys;
338 data[6] = yz * nc + xs;
339 data[kScaleZ] = z * z * nc + c;
340
341 mType = kTypeUnknown;
342 }
343
loadMultiply(const Matrix4 & u,const Matrix4 & v)344 void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) {
345 for (int i = 0 ; i < 4 ; i++) {
346 float x = 0;
347 float y = 0;
348 float z = 0;
349 float w = 0;
350
351 for (int j = 0 ; j < 4 ; j++) {
352 const float e = v.get(i, j);
353 x += u.get(j, 0) * e;
354 y += u.get(j, 1) * e;
355 z += u.get(j, 2) * e;
356 w += u.get(j, 3) * e;
357 }
358
359 set(i, 0, x);
360 set(i, 1, y);
361 set(i, 2, z);
362 set(i, 3, w);
363 }
364
365 mType = kTypeUnknown;
366 }
367
loadOrtho(float left,float right,float bottom,float top,float near,float far)368 void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
369 loadIdentity();
370
371 data[kScaleX] = 2.0f / (right - left);
372 data[kScaleY] = 2.0f / (top - bottom);
373 data[kScaleZ] = -2.0f / (far - near);
374 data[kTranslateX] = -(right + left) / (right - left);
375 data[kTranslateY] = -(top + bottom) / (top - bottom);
376 data[kTranslateZ] = -(far + near) / (far - near);
377
378 mType = kTypeTranslate | kTypeScale | kTypeRectToRect;
379 }
380
381 #define MUL_ADD_STORE(a, b, c) a = (a) * (b) + (c)
382
mapPoint(float & x,float & y) const383 void Matrix4::mapPoint(float& x, float& y) const {
384 if (isSimple()) {
385 MUL_ADD_STORE(x, data[kScaleX], data[kTranslateX]);
386 MUL_ADD_STORE(y, data[kScaleY], data[kTranslateY]);
387 return;
388 }
389
390 float dx = x * data[kScaleX] + y * data[kSkewX] + data[kTranslateX];
391 float dy = x * data[kSkewY] + y * data[kScaleY] + data[kTranslateY];
392 float dz = x * data[kPerspective0] + y * data[kPerspective1] + data[kPerspective2];
393 if (dz) dz = 1.0f / dz;
394
395 x = dx * dz;
396 y = dy * dz;
397 }
398
mapRect(Rect & r) const399 void Matrix4::mapRect(Rect& r) const {
400 if (isSimple()) {
401 MUL_ADD_STORE(r.left, data[kScaleX], data[kTranslateX]);
402 MUL_ADD_STORE(r.right, data[kScaleX], data[kTranslateX]);
403 MUL_ADD_STORE(r.top, data[kScaleY], data[kTranslateY]);
404 MUL_ADD_STORE(r.bottom, data[kScaleY], data[kTranslateY]);
405
406 if (r.left > r.right) {
407 float x = r.left;
408 r.left = r.right;
409 r.right = x;
410 }
411
412 if (r.top > r.bottom) {
413 float y = r.top;
414 r.top = r.bottom;
415 r.bottom = y;
416 }
417
418 return;
419 }
420
421 float vertices[] = {
422 r.left, r.top,
423 r.right, r.top,
424 r.right, r.bottom,
425 r.left, r.bottom
426 };
427
428 float x, y, z;
429
430 for (int i = 0; i < 8; i+= 2) {
431 float px = vertices[i];
432 float py = vertices[i + 1];
433
434 x = px * data[kScaleX] + py * data[kSkewX] + data[kTranslateX];
435 y = px * data[kSkewY] + py * data[kScaleY] + data[kTranslateY];
436 z = px * data[kPerspective0] + py * data[kPerspective1] + data[kPerspective2];
437 if (z) z = 1.0f / z;
438
439 vertices[i] = x * z;
440 vertices[i + 1] = y * z;
441 }
442
443 r.left = r.right = vertices[0];
444 r.top = r.bottom = vertices[1];
445
446 for (int i = 2; i < 8; i += 2) {
447 x = vertices[i];
448 y = vertices[i + 1];
449
450 if (x < r.left) r.left = x;
451 else if (x > r.right) r.right = x;
452 if (y < r.top) r.top = y;
453 else if (y > r.bottom) r.bottom = y;
454 }
455 }
456
decomposeScale(float & sx,float & sy) const457 void Matrix4::decomposeScale(float& sx, float& sy) const {
458 float len;
459 len = data[mat4::kScaleX] * data[mat4::kScaleX] + data[mat4::kSkewX] * data[mat4::kSkewX];
460 sx = copysignf(sqrtf(len), data[mat4::kScaleX]);
461 len = data[mat4::kScaleY] * data[mat4::kScaleY] + data[mat4::kSkewY] * data[mat4::kSkewY];
462 sy = copysignf(sqrtf(len), data[mat4::kScaleY]);
463 }
464
dump() const465 void Matrix4::dump() const {
466 ALOGD("Matrix4[simple=%d, type=0x%x", isSimple(), getType());
467 ALOGD(" %f %f %f %f", data[kScaleX], data[kSkewX], data[8], data[kTranslateX]);
468 ALOGD(" %f %f %f %f", data[kSkewY], data[kScaleY], data[9], data[kTranslateY]);
469 ALOGD(" %f %f %f %f", data[2], data[6], data[kScaleZ], data[kTranslateZ]);
470 ALOGD(" %f %f %f %f", data[kPerspective0], data[kPerspective1], data[11], data[kPerspective2]);
471 ALOGD("]");
472 }
473
474 }; // namespace uirenderer
475 }; // namespace android
476