Home | History | Annotate | Download | only in rs
      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
     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
     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 
    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 
    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 
    153 void Matrix4x4::load(const float *v) {
    154     memcpy(m, v, sizeof(m));
    155 }
    156 
    157 void Matrix4x4::load(const rs_matrix4x4 *v) {
    158     memcpy(m, v->m, sizeof(m));
    159 }
    160 
    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 
    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 
    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 
    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 
    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 
    252 void Matrix4x4::loadMultiply(const rs_matrix4x4 *lhs, const rs_matrix4x4 *rhs) {
    253     for (int i=0 ; i<4 ; i++) {
    254         float ri0 = 0;
    255         float ri1 = 0;
    256         float ri2 = 0;
    257         float ri3 = 0;
    258         for (int j=0 ; j<4 ; j++) {
    259             const float rhs_ij = ((const Matrix4x4 *)rhs)->get(i,j);
    260             ri0 += ((const Matrix4x4 *)lhs)->get(j,0) * rhs_ij;
    261             ri1 += ((const Matrix4x4 *)lhs)->get(j,1) * rhs_ij;
    262             ri2 += ((const Matrix4x4 *)lhs)->get(j,2) * rhs_ij;
    263             ri3 += ((const Matrix4x4 *)lhs)->get(j,3) * rhs_ij;
    264         }
    265         set(i,0, ri0);
    266         set(i,1, ri1);
    267         set(i,2, ri2);
    268         set(i,3, ri3);
    269     }
    270 }
    271 
    272 void Matrix4x4::loadOrtho(float left, float right, float bottom, float top, float near, float far) {
    273     loadIdentity();
    274     m[0] = 2.f / (right - left);
    275     m[5] = 2.f / (top - bottom);
    276     m[10]= -2.f / (far - near);
    277     m[12]= -(right + left) / (right - left);
    278     m[13]= -(top + bottom) / (top - bottom);
    279     m[14]= -(far + near) / (far - near);
    280 }
    281 
    282 void Matrix4x4::loadFrustum(float left, float right, float bottom, float top, float near, float far) {
    283     loadIdentity();
    284     m[0] = 2.f * near / (right - left);
    285     m[5] = 2.f * near / (top - bottom);
    286     m[8] = (right + left) / (right - left);
    287     m[9] = (top + bottom) / (top - bottom);
    288     m[10]= -(far + near) / (far - near);
    289     m[11]= -1.f;
    290     m[14]= -2.f * far * near / (far - near);
    291     m[15]= 0.f;
    292 }
    293 
    294 void Matrix4x4::loadPerspective(float fovy, float aspect, float near, float far) {
    295     float top = near * tan((float) (fovy * M_PI / 360.0f));
    296     float bottom = -top;
    297     float left = bottom * aspect;
    298     float right = top * aspect;
    299     loadFrustum(left, right, bottom, top, near, far);
    300 }
    301 
    302 void Matrix4x4::vectorMultiply(float *out, const float *in) const {
    303     out[0] = (m[0] * in[0]) + (m[4] * in[1]) + (m[8] * in[2]) + m[12];
    304     out[1] = (m[1] * in[0]) + (m[5] * in[1]) + (m[9] * in[2]) + m[13];
    305     out[2] = (m[2] * in[0]) + (m[6] * in[1]) + (m[10] * in[2]) + m[14];
    306     out[3] = (m[3] * in[0]) + (m[7] * in[1]) + (m[11] * in[2]) + m[15];
    307 }
    308 
    309 void Matrix4x4::logv(const char *s) const {
    310     ALOGV("%s {%f, %f, %f, %f",  s, m[0], m[4], m[8], m[12]);
    311     ALOGV("%s  %f, %f, %f, %f",  s, m[1], m[5], m[9], m[13]);
    312     ALOGV("%s  %f, %f, %f, %f",  s, m[2], m[6], m[10], m[14]);
    313     ALOGV("%s  %f, %f, %f, %f}", s, m[3], m[7], m[11], m[15]);
    314 }
    315