1 /*
2  * Copyright (C) 2011 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 #include "rsMatrix2x2.h"
18 #include "rsMatrix3x3.h"
19 #include "rsMatrix4x4.h"
20 
21 #include "stdlib.h"
22 #include "string.h"
23 #include "math.h"
24 
25 using namespace android;
26 using namespace android::renderscript;
27 
28 //////////////////////////////////////////////////////////////////////////////
29 // Heavy math functions
30 //////////////////////////////////////////////////////////////////////////////
31 
32 
33 
34 
35 
36 // Returns true if the matrix was successfully inversed
inverse()37 bool Matrix4x4::inverse() {
38     rs_matrix4x4 result;
39 
40     int i, j;
41     for (i = 0; i < 4; ++i) {
42         for (j = 0; j < 4; ++j) {
43             // computeCofactor for int i, int j
44             int c0 = (i+1) % 4;
45             int c1 = (i+2) % 4;
46             int c2 = (i+3) % 4;
47             int r0 = (j+1) % 4;
48             int r1 = (j+2) % 4;
49             int r2 = (j+3) % 4;
50 
51             float minor =
52                 (m[c0 + 4*r0] * (m[c1 + 4*r1] * m[c2 + 4*r2] - m[c1 + 4*r2] * m[c2 + 4*r1]))
53                 - (m[c0 + 4*r1] * (m[c1 + 4*r0] * m[c2 + 4*r2] - m[c1 + 4*r2] * m[c2 + 4*r0]))
54                 + (m[c0 + 4*r2] * (m[c1 + 4*r0] * m[c2 + 4*r1] - m[c1 + 4*r1] * m[c2 + 4*r0]));
55 
56             float cofactor = (i+j) & 1 ? -minor : minor;
57 
58             result.m[4*i + j] = cofactor;
59         }
60     }
61 
62     // Dot product of 0th column of source and 0th row of result
63     float det = m[0]*result.m[0] + m[4]*result.m[1] +
64                  m[8]*result.m[2] + m[12]*result.m[3];
65 
66     if (fabs(det) < 1e-6) {
67         return false;
68     }
69 
70     det = 1.0f / det;
71     for (i = 0; i < 16; ++i) {
72         m[i] = result.m[i] * det;
73     }
74 
75     return true;
76 }
77 
78 // Returns true if the matrix was successfully inversed
inverseTranspose()79 bool Matrix4x4::inverseTranspose() {
80     rs_matrix4x4 result;
81 
82     int i, j;
83     for (i = 0; i < 4; ++i) {
84         for (j = 0; j < 4; ++j) {
85             // computeCofactor for int i, int j
86             int c0 = (i+1) % 4;
87             int c1 = (i+2) % 4;
88             int c2 = (i+3) % 4;
89             int r0 = (j+1) % 4;
90             int r1 = (j+2) % 4;
91             int r2 = (j+3) % 4;
92 
93             float minor = (m[c0 + 4*r0] * (m[c1 + 4*r1] * m[c2 + 4*r2] - m[c1 + 4*r2] * m[c2 + 4*r1]))
94                          - (m[c0 + 4*r1] * (m[c1 + 4*r0] * m[c2 + 4*r2] - m[c1 + 4*r2] * m[c2 + 4*r0]))
95                          + (m[c0 + 4*r2] * (m[c1 + 4*r0] * m[c2 + 4*r1] - m[c1 + 4*r1] * m[c2 + 4*r0]));
96 
97             float cofactor = (i+j) & 1 ? -minor : minor;
98 
99             result.m[4*j + i] = cofactor;
100         }
101     }
102 
103     // Dot product of 0th column of source and 0th column of result
104     float det = m[0]*result.m[0] + m[4]*result.m[4] +
105                  m[8]*result.m[8] + m[12]*result.m[12];
106 
107     if (fabs(det) < 1e-6) {
108         return false;
109     }
110 
111     det = 1.0f / det;
112     for (i = 0; i < 16; ++i) {
113         m[i] = result.m[i] * det;
114     }
115 
116     return true;
117 }
118 
transpose()119 void Matrix4x4::transpose() {
120     int i, j;
121     float temp;
122     for (i = 0; i < 3; ++i) {
123         for (j = i + 1; j < 4; ++j) {
124             temp = m[i*4 + j];
125             m[i*4 + j] = m[j*4 + i];
126             m[j*4 + i] = temp;
127         }
128     }
129 }
130 
131 
132 ///////////////////////////////////////////////////////////////////////////////////
133 
loadIdentity()134 void Matrix4x4::loadIdentity() {
135     m[0] = 1.f;
136     m[1] = 0.f;
137     m[2] = 0.f;
138     m[3] = 0.f;
139     m[4] = 0.f;
140     m[5] = 1.f;
141     m[6] = 0.f;
142     m[7] = 0.f;
143     m[8] = 0.f;
144     m[9] = 0.f;
145     m[10] = 1.f;
146     m[11] = 0.f;
147     m[12] = 0.f;
148     m[13] = 0.f;
149     m[14] = 0.f;
150     m[15] = 1.f;
151 }
152 
load(const float * v)153 void Matrix4x4::load(const float *v) {
154     memcpy(m, v, sizeof(m));
155 }
156 
load(const rs_matrix4x4 * v)157 void Matrix4x4::load(const rs_matrix4x4 *v) {
158     memcpy(m, v->m, sizeof(m));
159 }
160 
load(const rs_matrix3x3 * v)161 void Matrix4x4::load(const rs_matrix3x3 *v) {
162     m[0] = v->m[0];
163     m[1] = v->m[1];
164     m[2] = v->m[2];
165     m[3] = 0.f;
166     m[4] = v->m[3];
167     m[5] = v->m[4];
168     m[6] = v->m[5];
169     m[7] = 0.f;
170     m[8] = v->m[6];
171     m[9] = v->m[7];
172     m[10] = v->m[8];
173     m[11] = 0.f;
174     m[12] = 0.f;
175     m[13] = 0.f;
176     m[14] = 0.f;
177     m[15] = 1.f;
178 }
179 
load(const rs_matrix2x2 * v)180 void Matrix4x4::load(const rs_matrix2x2 *v) {
181     m[0] = v->m[0];
182     m[1] = v->m[1];
183     m[2] = 0.f;
184     m[3] = 0.f;
185     m[4] = v->m[2];
186     m[5] = v->m[3];
187     m[6] = 0.f;
188     m[7] = 0.f;
189     m[8] = 0.f;
190     m[9] = 0.f;
191     m[10] = 1.f;
192     m[11] = 0.f;
193     m[12] = 0.f;
194     m[13] = 0.f;
195     m[14] = 0.f;
196     m[15] = 1.f;
197 }
198 
199 
loadRotate(float rot,float x,float y,float z)200 void Matrix4x4::loadRotate(float rot, float x, float y, float z) {
201     float c, s;
202     m[3] = 0;
203     m[7] = 0;
204     m[11]= 0;
205     m[12]= 0;
206     m[13]= 0;
207     m[14]= 0;
208     m[15]= 1;
209     rot *= float(M_PI / 180.0f);
210     c = cosf(rot);
211     s = sinf(rot);
212 
213     const float len = x*x + y*y + z*z;
214     if (len != 1) {
215         const float recipLen = 1.f / sqrtf(len);
216         x *= recipLen;
217         y *= recipLen;
218         z *= recipLen;
219     }
220     const float nc = 1.0f - c;
221     const float xy = x * y;
222     const float yz = y * z;
223     const float zx = z * x;
224     const float xs = x * s;
225     const float ys = y * s;
226     const float zs = z * s;
227     m[ 0] = x*x*nc +  c;
228     m[ 4] =  xy*nc - zs;
229     m[ 8] =  zx*nc + ys;
230     m[ 1] =  xy*nc + zs;
231     m[ 5] = y*y*nc +  c;
232     m[ 9] =  yz*nc - xs;
233     m[ 2] =  zx*nc - ys;
234     m[ 6] =  yz*nc + xs;
235     m[10] = z*z*nc +  c;
236 }
237 
loadScale(float x,float y,float z)238 void Matrix4x4::loadScale(float x, float y, float z) {
239     loadIdentity();
240     set(0, 0, x);
241     set(1, 1, y);
242     set(2, 2, z);
243 }
244 
loadTranslate(float x,float y,float z)245 void Matrix4x4::loadTranslate(float x, float y, float z) {
246     loadIdentity();
247     m[12] = x;
248     m[13] = y;
249     m[14] = z;
250 }
251 
loadMultiply(const rs_matrix4x4 * lhs,const rs_matrix4x4 * rhs)252 void Matrix4x4::loadMultiply(const rs_matrix4x4 *lhs, const rs_matrix4x4 *rhs) {
253     // Use a temporary variable to support the case where one of the inputs
254     // is also the destination, e.g. left.loadMultiply(left, right);
255     Matrix4x4 temp;
256     for (int i=0 ; i<4 ; i++) {
257         float ri0 = 0;
258         float ri1 = 0;
259         float ri2 = 0;
260         float ri3 = 0;
261         for (int j=0 ; j<4 ; j++) {
262             const float rhs_ij = ((const Matrix4x4 *)rhs)->get(i,j);
263             ri0 += ((const Matrix4x4 *)lhs)->get(j,0) * rhs_ij;
264             ri1 += ((const Matrix4x4 *)lhs)->get(j,1) * rhs_ij;
265             ri2 += ((const Matrix4x4 *)lhs)->get(j,2) * rhs_ij;
266             ri3 += ((const Matrix4x4 *)lhs)->get(j,3) * rhs_ij;
267         }
268         temp.set(i,0, ri0);
269         temp.set(i,1, ri1);
270         temp.set(i,2, ri2);
271         temp.set(i,3, ri3);
272     }
273     load(&temp);
274 }
275 
loadOrtho(float left,float right,float bottom,float top,float near,float far)276 void Matrix4x4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
277     loadIdentity();
278     m[0] = 2.f / (right - left);
279     m[5] = 2.f / (top - bottom);
280     m[10]= -2.f / (far - near);
281     m[12]= -(right + left) / (right - left);
282     m[13]= -(top + bottom) / (top - bottom);
283     m[14]= -(far + near) / (far - near);
284 }
285 
loadFrustum(float left,float right,float bottom,float top,float near,float far)286 void Matrix4x4::loadFrustum(float left, float right, float bottom, float top, float near, float far) {
287     loadIdentity();
288     m[0] = 2.f * near / (right - left);
289     m[5] = 2.f * near / (top - bottom);
290     m[8] = (right + left) / (right - left);
291     m[9] = (top + bottom) / (top - bottom);
292     m[10]= -(far + near) / (far - near);
293     m[11]= -1.f;
294     m[14]= -2.f * far * near / (far - near);
295     m[15]= 0.f;
296 }
297 
loadPerspective(float fovy,float aspect,float near,float far)298 void Matrix4x4::loadPerspective(float fovy, float aspect, float near, float far) {
299     float top = near * tan((float) (fovy * M_PI / 360.0f));
300     float bottom = -top;
301     float left = bottom * aspect;
302     float right = top * aspect;
303     loadFrustum(left, right, bottom, top, near, far);
304 }
305 
306 // Note: This assumes that the input vector (in) is of length 3.
vectorMultiply(float * out,const float * in) const307 void Matrix4x4::vectorMultiply(float *out, const float *in) const {
308     out[0] = (m[0] * in[0]) + (m[4] * in[1]) + (m[8] * in[2]) + m[12];
309     out[1] = (m[1] * in[0]) + (m[5] * in[1]) + (m[9] * in[2]) + m[13];
310     out[2] = (m[2] * in[0]) + (m[6] * in[1]) + (m[10] * in[2]) + m[14];
311     out[3] = (m[3] * in[0]) + (m[7] * in[1]) + (m[11] * in[2]) + m[15];
312 }
313 
logv(const char * s) const314 void Matrix4x4::logv(const char *s) const {
315     ALOGV("%s {%f, %f, %f, %f",  s, m[0], m[4], m[8], m[12]);
316     ALOGV("%s  %f, %f, %f, %f",  s, m[1], m[5], m[9], m[13]);
317     ALOGV("%s  %f, %f, %f, %f",  s, m[2], m[6], m[10], m[14]);
318     ALOGV("%s  %f, %f, %f, %f}", s, m[3], m[7], m[11], m[15]);
319 }
320