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 "utils/Compare.h"
28 #include "Matrix.h"
29
30 namespace android {
31 namespace uirenderer {
32
loadIdentity()33 void Matrix4::loadIdentity() {
34 data[kScaleX] = 1.0f;
35 data[kSkewY] = 0.0f;
36 data[2] = 0.0f;
37 data[kPerspective0] = 0.0f;
38
39 data[kSkewX] = 0.0f;
40 data[kScaleY] = 1.0f;
41 data[6] = 0.0f;
42 data[kPerspective1] = 0.0f;
43
44 data[8] = 0.0f;
45 data[9] = 0.0f;
46 data[kScaleZ] = 1.0f;
47 data[11] = 0.0f;
48
49 data[kTranslateX] = 0.0f;
50 data[kTranslateY] = 0.0f;
51 data[kTranslateZ] = 0.0f;
52 data[kPerspective2] = 1.0f;
53
54 mIsIdentity = true;
55 mSimpleMatrix = true;
56 }
57
changesBounds()58 bool Matrix4::changesBounds() {
59 return !(data[0] == 1.0f && data[1] == 0.0f && data[2] == 0.0f && data[4] == 0.0f &&
60 data[5] == 1.0f && data[6] == 0.0f && data[8] == 0.0f && data[9] == 0.0f &&
61 data[10] == 1.0f);
62 }
63
isPureTranslate()64 bool Matrix4::isPureTranslate() {
65 return mSimpleMatrix && data[kScaleX] == 1.0f && data[kScaleY] == 1.0f;
66 }
67
isSimple()68 bool Matrix4::isSimple() {
69 return mSimpleMatrix;
70 }
71
isIdentity()72 bool Matrix4::isIdentity() {
73 return mIsIdentity;
74 }
75
load(const float * v)76 void Matrix4::load(const float* v) {
77 memcpy(data, v, sizeof(data));
78 // TODO: Do something smarter here
79 mSimpleMatrix = false;
80 mIsIdentity = false;
81 }
82
load(const Matrix4 & v)83 void Matrix4::load(const Matrix4& v) {
84 memcpy(data, v.data, sizeof(data));
85 mSimpleMatrix = v.mSimpleMatrix;
86 mIsIdentity = v.mIsIdentity;
87 }
88
load(const SkMatrix & v)89 void Matrix4::load(const SkMatrix& v) {
90 memset(data, 0, sizeof(data));
91
92 data[kScaleX] = v[SkMatrix::kMScaleX];
93 data[kSkewX] = v[SkMatrix::kMSkewX];
94 data[kTranslateX] = v[SkMatrix::kMTransX];
95
96 data[kSkewY] = v[SkMatrix::kMSkewY];
97 data[kScaleY] = v[SkMatrix::kMScaleY];
98 data[kTranslateY] = v[SkMatrix::kMTransY];
99
100 data[kPerspective0] = v[SkMatrix::kMPersp0];
101 data[kPerspective1] = v[SkMatrix::kMPersp1];
102 data[kPerspective2] = v[SkMatrix::kMPersp2];
103
104 data[kScaleZ] = 1.0f;
105
106 mSimpleMatrix = (v.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask));
107 mIsIdentity = v.isIdentity();
108 }
109
copyTo(SkMatrix & v) const110 void Matrix4::copyTo(SkMatrix& v) const {
111 v.reset();
112
113 v.set(SkMatrix::kMScaleX, data[kScaleX]);
114 v.set(SkMatrix::kMSkewX, data[kSkewX]);
115 v.set(SkMatrix::kMTransX, data[kTranslateX]);
116
117 v.set(SkMatrix::kMSkewY, data[kSkewY]);
118 v.set(SkMatrix::kMScaleY, data[kScaleY]);
119 v.set(SkMatrix::kMTransY, data[kTranslateY]);
120
121 v.set(SkMatrix::kMPersp0, data[kPerspective0]);
122 v.set(SkMatrix::kMPersp1, data[kPerspective1]);
123 v.set(SkMatrix::kMPersp2, data[kPerspective2]);
124 }
125
loadInverse(const Matrix4 & v)126 void Matrix4::loadInverse(const Matrix4& v) {
127 double scale = 1.0 /
128 (v.data[kScaleX] * ((double) v.data[kScaleY] * v.data[kPerspective2] -
129 (double) v.data[kTranslateY] * v.data[kPerspective1]) +
130 v.data[kSkewX] * ((double) v.data[kTranslateY] * v.data[kPerspective0] -
131 (double) v.data[kSkewY] * v.data[kPerspective2]) +
132 v.data[kTranslateX] * ((double) v.data[kSkewY] * v.data[kPerspective1] -
133 (double) v.data[kScaleY] * v.data[kPerspective0]));
134
135 data[kScaleX] = (v.data[kScaleY] * v.data[kPerspective2] -
136 v.data[kTranslateY] * v.data[kPerspective1]) * scale;
137 data[kSkewX] = (v.data[kTranslateX] * v.data[kPerspective1] -
138 v.data[kSkewX] * v.data[kPerspective2]) * scale;
139 data[kTranslateX] = (v.data[kSkewX] * v.data[kTranslateY] -
140 v.data[kTranslateX] * v.data[kScaleY]) * scale;
141
142 data[kSkewY] = (v.data[kTranslateY] * v.data[kPerspective0] -
143 v.data[kSkewY] * v.data[kPerspective2]) * scale;
144 data[kScaleY] = (v.data[kScaleX] * v.data[kPerspective2] -
145 v.data[kTranslateX] * v.data[kPerspective0]) * scale;
146 data[kTranslateY] = (v.data[kTranslateX] * v.data[kSkewY] -
147 v.data[kScaleX] * v.data[kTranslateY]) * scale;
148
149 data[kPerspective0] = (v.data[kSkewY] * v.data[kPerspective1] -
150 v.data[kScaleY] * v.data[kPerspective0]) * scale;
151 data[kPerspective1] = (v.data[kSkewX] * v.data[kPerspective0] -
152 v.data[kScaleX] * v.data[kPerspective1]) * scale;
153 data[kPerspective2] = (v.data[kScaleX] * v.data[kScaleY] -
154 v.data[kSkewX] * v.data[kSkewY]) * scale;
155
156 mSimpleMatrix = v.mSimpleMatrix;
157 mIsIdentity = v.mIsIdentity;
158 }
159
copyTo(float * v) const160 void Matrix4::copyTo(float* v) const {
161 memcpy(v, data, sizeof(data));
162 }
163
getTranslateX()164 float Matrix4::getTranslateX() {
165 return data[kTranslateX];
166 }
167
getTranslateY()168 float Matrix4::getTranslateY() {
169 return data[kTranslateY];
170 }
171
multiply(float v)172 void Matrix4::multiply(float v) {
173 for (int i = 0; i < 16; i++) {
174 data[i] *= v;
175 }
176 mIsIdentity = false;
177 }
178
loadTranslate(float x,float y,float z)179 void Matrix4::loadTranslate(float x, float y, float z) {
180 loadIdentity();
181
182 data[kTranslateX] = x;
183 data[kTranslateY] = y;
184 data[kTranslateZ] = z;
185
186 mIsIdentity = false;
187 }
188
loadScale(float sx,float sy,float sz)189 void Matrix4::loadScale(float sx, float sy, float sz) {
190 loadIdentity();
191
192 data[kScaleX] = sx;
193 data[kScaleY] = sy;
194 data[kScaleZ] = sz;
195
196 mIsIdentity = false;
197 }
198
loadSkew(float sx,float sy)199 void Matrix4::loadSkew(float sx, float sy) {
200 loadIdentity();
201
202 data[kScaleX] = 1.0f;
203 data[kSkewX] = sx;
204 data[kTranslateX] = 0.0f;
205
206 data[kSkewY] = sy;
207 data[kScaleY] = 1.0f;
208 data[kTranslateY] = 0.0f;
209
210 data[kPerspective0] = 0.0f;
211 data[kPerspective1] = 0.0f;
212 data[kPerspective2] = 1.0f;
213
214 mSimpleMatrix = false;
215 mIsIdentity = false;
216 }
217
loadRotate(float angle,float x,float y,float z)218 void Matrix4::loadRotate(float angle, float x, float y, float z) {
219 data[kPerspective0] = 0.0f;
220 data[kPerspective1] = 0.0f;
221 data[11] = 0.0f;
222 data[kTranslateX] = 0.0f;
223 data[kTranslateY] = 0.0f;
224 data[kTranslateZ] = 0.0f;
225 data[kPerspective2] = 1.0f;
226
227 angle *= float(M_PI / 180.0f);
228 float c = cosf(angle);
229 float s = sinf(angle);
230
231 const float length = sqrtf(x * x + y * y + z * z);
232 float recipLen = 1.0f / length;
233 x *= recipLen;
234 y *= recipLen;
235 z *= recipLen;
236
237 const float nc = 1.0f - c;
238 const float xy = x * y;
239 const float yz = y * z;
240 const float zx = z * x;
241 const float xs = x * s;
242 const float ys = y * s;
243 const float zs = z * s;
244
245 data[kScaleX] = x * x * nc + c;
246 data[kSkewX] = xy * nc - zs;
247 data[8] = zx * nc + ys;
248 data[kSkewY] = xy * nc + zs;
249 data[kScaleY] = y * y * nc + c;
250 data[9] = yz * nc - xs;
251 data[2] = zx * nc - ys;
252 data[6] = yz * nc + xs;
253 data[kScaleZ] = z * z * nc + c;
254
255 mSimpleMatrix = false;
256 mIsIdentity = false;
257 }
258
loadMultiply(const Matrix4 & u,const Matrix4 & v)259 void Matrix4::loadMultiply(const Matrix4& u, const Matrix4& v) {
260 for (int i = 0 ; i < 4 ; i++) {
261 float x = 0;
262 float y = 0;
263 float z = 0;
264 float w = 0;
265
266 for (int j = 0 ; j < 4 ; j++) {
267 const float e = v.get(i, j);
268 x += u.get(j, 0) * e;
269 y += u.get(j, 1) * e;
270 z += u.get(j, 2) * e;
271 w += u.get(j, 3) * e;
272 }
273
274 set(i, 0, x);
275 set(i, 1, y);
276 set(i, 2, z);
277 set(i, 3, w);
278 }
279
280 mSimpleMatrix = u.mSimpleMatrix && v.mSimpleMatrix;
281 mIsIdentity = false;
282 }
283
loadOrtho(float left,float right,float bottom,float top,float near,float far)284 void Matrix4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
285 loadIdentity();
286
287 data[kScaleX] = 2.0f / (right - left);
288 data[kScaleY] = 2.0f / (top - bottom);
289 data[kScaleZ] = -2.0f / (far - near);
290 data[kTranslateX] = -(right + left) / (right - left);
291 data[kTranslateY] = -(top + bottom) / (top - bottom);
292 data[kTranslateZ] = -(far + near) / (far - near);
293
294 mIsIdentity = false;
295 }
296
297 #define MUL_ADD_STORE(a, b, c) a = (a) * (b) + (c)
298
mapPoint(float & x,float & y) const299 void Matrix4::mapPoint(float& x, float& y) const {
300 if (mSimpleMatrix) {
301 MUL_ADD_STORE(x, data[kScaleX], data[kTranslateX]);
302 MUL_ADD_STORE(y, data[kScaleY], data[kTranslateY]);
303 return;
304 }
305
306 float dx = x * data[kScaleX] + y * data[kSkewX] + data[kTranslateX];
307 float dy = x * data[kSkewY] + y * data[kScaleY] + data[kTranslateY];
308 float dz = x * data[kPerspective0] + y * data[kPerspective1] + data[kPerspective2];
309 if (dz) dz = 1.0f / dz;
310
311 x = dx * dz;
312 y = dy * dz;
313 }
314
mapRect(Rect & r) const315 void Matrix4::mapRect(Rect& r) const {
316 if (mSimpleMatrix) {
317 MUL_ADD_STORE(r.left, data[kScaleX], data[kTranslateX]);
318 MUL_ADD_STORE(r.right, data[kScaleX], data[kTranslateX]);
319 MUL_ADD_STORE(r.top, data[kScaleY], data[kTranslateY]);
320 MUL_ADD_STORE(r.bottom, data[kScaleY], data[kTranslateY]);
321
322 if (r.left > r.right) {
323 float x = r.left;
324 r.left = r.right;
325 r.right = x;
326 }
327
328 if (r.top > r.bottom) {
329 float y = r.top;
330 r.top = r.bottom;
331 r.bottom = y;
332 }
333
334 return;
335 }
336
337 float vertices[] = {
338 r.left, r.top,
339 r.right, r.top,
340 r.right, r.bottom,
341 r.left, r.bottom
342 };
343
344 float x, y, z;
345
346 for (int i = 0; i < 8; i+= 2) {
347 float px = vertices[i];
348 float py = vertices[i + 1];
349
350 x = px * data[kScaleX] + py * data[kSkewX] + data[kTranslateX];
351 y = px * data[kSkewY] + py * data[kScaleY] + data[kTranslateY];
352 z = px * data[kPerspective0] + py * data[kPerspective1] + data[kPerspective2];
353 if (z) z = 1.0f / z;
354
355 vertices[i] = x * z;
356 vertices[i + 1] = y * z;
357 }
358
359 r.left = r.right = vertices[0];
360 r.top = r.bottom = vertices[1];
361
362 for (int i = 2; i < 8; i += 2) {
363 x = vertices[i];
364 y = vertices[i + 1];
365
366 if (x < r.left) r.left = x;
367 else if (x > r.right) r.right = x;
368 if (y < r.top) r.top = y;
369 else if (y > r.bottom) r.bottom = y;
370 }
371 }
372
dump() const373 void Matrix4::dump() const {
374 ALOGD("Matrix4[simple=%d", mSimpleMatrix);
375 ALOGD(" %f %f %f %f", data[kScaleX], data[kSkewX], data[8], data[kTranslateX]);
376 ALOGD(" %f %f %f %f", data[kSkewY], data[kScaleY], data[9], data[kTranslateY]);
377 ALOGD(" %f %f %f %f", data[2], data[6], data[kScaleZ], data[kTranslateZ]);
378 ALOGD(" %f %f %f %f", data[kPerspective0], data[kPerspective1], data[11], data[kPerspective2]);
379 ALOGD("]");
380 }
381
382 }; // namespace uirenderer
383 }; // namespace android
384