Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1afbf54d authored by Jason Sams's avatar Jason Sams
Browse files

Migrating functions for on device linking. 

Change-Id: I41dc1551ada53370f2b06c49cc76089b1e72ac5b
parent 40f13039

libs/rs/rsScriptC_Lib.cpp

+522 −0
Original line number Diff line number Diff line
@@ -347,6 +347,489 @@ void SC_ForEach2(RsScript vs, 
    s->runForEach(rsc, ain, aout, usr, call);

}





//////////////////////////////////////////////////////////////////////////////

// Heavy math functions

//////////////////////////////////////////////////////////////////////////////



typedef struct {

    float m[16];

} rs_matrix4x4;



typedef struct {

    float m[9];

} rs_matrix3x3;



typedef struct {

    float m[4];

} rs_matrix2x2;



static inline void

rsMatrixSet(rs_matrix4x4 *m, uint32_t row, uint32_t col, float v) {

    m->m[row * 4 + col] = v;

}



static inline float

rsMatrixGet(const rs_matrix4x4 *m, uint32_t row, uint32_t col) {

    return m->m[row * 4 + col];

}



static inline void

rsMatrixSet(rs_matrix3x3 *m, uint32_t row, uint32_t col, float v) {

    m->m[row * 3 + col] = v;

}



static inline float

rsMatrixGet(const rs_matrix3x3 *m, uint32_t row, uint32_t col) {

    return m->m[row * 3 + col];

}



static inline void

rsMatrixSet(rs_matrix2x2 *m, uint32_t row, uint32_t col, float v) {

    m->m[row * 2 + col] = v;

}



static inline float

rsMatrixGet(const rs_matrix2x2 *m, uint32_t row, uint32_t col) {

    return m->m[row * 2 + col];

}





static void SC_MatrixLoadIdentity_4x4(rs_matrix4x4 *m) {

    m->m[0] = 1.f;

    m->m[1] = 0.f;

    m->m[2] = 0.f;

    m->m[3] = 0.f;

    m->m[4] = 0.f;

    m->m[5] = 1.f;

    m->m[6] = 0.f;

    m->m[7] = 0.f;

    m->m[8] = 0.f;

    m->m[9] = 0.f;

    m->m[10] = 1.f;

    m->m[11] = 0.f;

    m->m[12] = 0.f;

    m->m[13] = 0.f;

    m->m[14] = 0.f;

    m->m[15] = 1.f;

}



static void SC_MatrixLoadIdentity_3x3(rs_matrix3x3 *m) {

    m->m[0] = 1.f;

    m->m[1] = 0.f;

    m->m[2] = 0.f;

    m->m[3] = 0.f;

    m->m[4] = 1.f;

    m->m[5] = 0.f;

    m->m[6] = 0.f;

    m->m[7] = 0.f;

    m->m[8] = 1.f;

}



static void SC_MatrixLoadIdentity_2x2(rs_matrix2x2 *m) {

    m->m[0] = 1.f;

    m->m[1] = 0.f;

    m->m[2] = 0.f;

    m->m[3] = 1.f;

}



static void SC_MatrixLoad_4x4_f(rs_matrix4x4 *m, const float *v) {

    m->m[0] = v[0];

    m->m[1] = v[1];

    m->m[2] = v[2];

    m->m[3] = v[3];

    m->m[4] = v[4];

    m->m[5] = v[5];

    m->m[6] = v[6];

    m->m[7] = v[7];

    m->m[8] = v[8];

    m->m[9] = v[9];

    m->m[10] = v[10];

    m->m[11] = v[11];

    m->m[12] = v[12];

    m->m[13] = v[13];

    m->m[14] = v[14];

    m->m[15] = v[15];

}



static void SC_MatrixLoad_3x3_f(rs_matrix3x3 *m, const float *v) {

    m->m[0] = v[0];

    m->m[1] = v[1];

    m->m[2] = v[2];

    m->m[3] = v[3];

    m->m[4] = v[4];

    m->m[5] = v[5];

    m->m[6] = v[6];

    m->m[7] = v[7];

    m->m[8] = v[8];

}



static void SC_MatrixLoad_2x2_f(rs_matrix2x2 *m, const float *v) {

    m->m[0] = v[0];

    m->m[1] = v[1];

    m->m[2] = v[2];

    m->m[3] = v[3];

}



static void SC_MatrixLoad_4x4_4x4(rs_matrix4x4 *m, const rs_matrix4x4 *v) {

    m->m[0] = v->m[0];

    m->m[1] = v->m[1];

    m->m[2] = v->m[2];

    m->m[3] = v->m[3];

    m->m[4] = v->m[4];

    m->m[5] = v->m[5];

    m->m[6] = v->m[6];

    m->m[7] = v->m[7];

    m->m[8] = v->m[8];

    m->m[9] = v->m[9];

    m->m[10] = v->m[10];

    m->m[11] = v->m[11];

    m->m[12] = v->m[12];

    m->m[13] = v->m[13];

    m->m[14] = v->m[14];

    m->m[15] = v->m[15];

}



static void SC_MatrixLoad_4x4_3x3(rs_matrix4x4 *m, const rs_matrix3x3 *v) {

    m->m[0] = v->m[0];

    m->m[1] = v->m[1];

    m->m[2] = v->m[2];

    m->m[3] = 0.f;

    m->m[4] = v->m[3];

    m->m[5] = v->m[4];

    m->m[6] = v->m[5];

    m->m[7] = 0.f;

    m->m[8] = v->m[6];

    m->m[9] = v->m[7];

    m->m[10] = v->m[8];

    m->m[11] = 0.f;

    m->m[12] = 0.f;

    m->m[13] = 0.f;

    m->m[14] = 0.f;

    m->m[15] = 1.f;

}



static void SC_MatrixLoad_4x4_2x2(rs_matrix4x4 *m, const rs_matrix2x2 *v) {

    m->m[0] = v->m[0];

    m->m[1] = v->m[1];

    m->m[2] = 0.f;

    m->m[3] = 0.f;

    m->m[4] = v->m[2];

    m->m[5] = v->m[3];

    m->m[6] = 0.f;

    m->m[7] = 0.f;

    m->m[8] = 0.f;

    m->m[9] = 0.f;

    m->m[10] = 1.f;

    m->m[11] = 0.f;

    m->m[12] = 0.f;

    m->m[13] = 0.f;

    m->m[14] = 0.f;

    m->m[15] = 1.f;

}



static void SC_MatrixLoad_3x3_3x3(rs_matrix3x3 *m, const rs_matrix3x3 *v) {

    m->m[0] = v->m[0];

    m->m[1] = v->m[1];

    m->m[2] = v->m[2];

    m->m[3] = v->m[3];

    m->m[4] = v->m[4];

    m->m[5] = v->m[5];

    m->m[6] = v->m[6];

    m->m[7] = v->m[7];

    m->m[8] = v->m[8];

}



static void SC_MatrixLoad_2x2_2x2(rs_matrix2x2 *m, const rs_matrix2x2 *v) {

    m->m[0] = v->m[0];

    m->m[1] = v->m[1];

    m->m[2] = v->m[2];

    m->m[3] = v->m[3];

}



static void SC_MatrixLoadRotate(rs_matrix4x4 *m, float rot, float x, float y, float z) {

    float c, s;

    m->m[3] = 0;

    m->m[7] = 0;

    m->m[11]= 0;

    m->m[12]= 0;

    m->m[13]= 0;

    m->m[14]= 0;

    m->m[15]= 1;

    rot *= (float)(M_PI / 180.0f);

    c = cos(rot);

    s = sin(rot);



    const float len = x*x + y*y + z*z;

    if (len != 1) {

        const float recipLen = 1.f / sqrt(len);

        x *= recipLen;

        y *= recipLen;

        z *= recipLen;

    }

    const float nc = 1.0f - c;

    const float xy = x * y;

    const float yz = y * z;

    const float zx = z * x;

    const float xs = x * s;

    const float ys = y * s;

    const float zs = z * s;

    m->m[ 0] = x*x*nc +  c;

    m->m[ 4] =  xy*nc - zs;

    m->m[ 8] =  zx*nc + ys;

    m->m[ 1] =  xy*nc + zs;

    m->m[ 5] = y*y*nc +  c;

    m->m[ 9] =  yz*nc - xs;

    m->m[ 2] =  zx*nc - ys;

    m->m[ 6] =  yz*nc + xs;

    m->m[10] = z*z*nc +  c;

}



static void SC_MatrixLoadScale(rs_matrix4x4 *m, float x, float y, float z) {

    SC_MatrixLoadIdentity_4x4(m);

    m->m[0] = x;

    m->m[5] = y;

    m->m[10] = z;

}



static void SC_MatrixLoadTranslate(rs_matrix4x4 *m, float x, float y, float z) {

    SC_MatrixLoadIdentity_4x4(m);

    m->m[12] = x;

    m->m[13] = y;

    m->m[14] = z;

}



static void SC_MatrixLoadMultiply_4x4_4x4_4x4(rs_matrix4x4 *m, const rs_matrix4x4 *lhs, const rs_matrix4x4 *rhs) {

    for (int i=0 ; i<4 ; i++) {

        float ri0 = 0;

        float ri1 = 0;

        float ri2 = 0;

        float ri3 = 0;

        for (int j=0 ; j<4 ; j++) {

            const float rhs_ij = rsMatrixGet(rhs, i,j);

            ri0 += rsMatrixGet(lhs, j, 0) * rhs_ij;

            ri1 += rsMatrixGet(lhs, j, 1) * rhs_ij;

            ri2 += rsMatrixGet(lhs, j, 2) * rhs_ij;

            ri3 += rsMatrixGet(lhs, j, 3) * rhs_ij;

        }

        rsMatrixSet(m, i, 0, ri0);

        rsMatrixSet(m, i, 1, ri1);

        rsMatrixSet(m, i, 2, ri2);

        rsMatrixSet(m, i, 3, ri3);

    }

}



static void SC_MatrixMultiply_4x4_4x4(rs_matrix4x4 *m, const rs_matrix4x4 *rhs) {

    rs_matrix4x4 mt;

    SC_MatrixLoadMultiply_4x4_4x4_4x4(&mt, m, rhs);

    SC_MatrixLoad_4x4_4x4(m, &mt);

}



static void SC_MatrixLoadMultiply_3x3_3x3_3x3(rs_matrix3x3 *m, const rs_matrix3x3 *lhs, const rs_matrix3x3 *rhs) {

    for (int i=0 ; i<3 ; i++) {

        float ri0 = 0;

        float ri1 = 0;

        float ri2 = 0;

        for (int j=0 ; j<3 ; j++) {

            const float rhs_ij = rsMatrixGet(rhs, i,j);

            ri0 += rsMatrixGet(lhs, j, 0) * rhs_ij;

            ri1 += rsMatrixGet(lhs, j, 1) * rhs_ij;

            ri2 += rsMatrixGet(lhs, j, 2) * rhs_ij;

        }

        rsMatrixSet(m, i, 0, ri0);

        rsMatrixSet(m, i, 1, ri1);

        rsMatrixSet(m, i, 2, ri2);

    }

}



static void SC_MatrixMultiply_3x3_3x3(rs_matrix3x3 *m, const rs_matrix3x3 *rhs) {

    rs_matrix3x3 mt;

    SC_MatrixLoadMultiply_3x3_3x3_3x3(&mt, m, rhs);

    SC_MatrixLoad_3x3_3x3(m, &mt);

}



static void SC_MatrixLoadMultiply_2x2_2x2_2x2(rs_matrix2x2 *m, const rs_matrix2x2 *lhs, const rs_matrix2x2 *rhs) {

    for (int i=0 ; i<2 ; i++) {

        float ri0 = 0;

        float ri1 = 0;

        for (int j=0 ; j<2 ; j++) {

            const float rhs_ij = rsMatrixGet(rhs, i,j);

            ri0 += rsMatrixGet(lhs, j, 0) * rhs_ij;

            ri1 += rsMatrixGet(lhs, j, 1) * rhs_ij;

        }

        rsMatrixSet(m, i, 0, ri0);

        rsMatrixSet(m, i, 1, ri1);

    }

}



static void SC_MatrixMultiply_2x2_2x2(rs_matrix2x2 *m, const rs_matrix2x2 *rhs) {

    rs_matrix2x2 mt;

    SC_MatrixLoadMultiply_2x2_2x2_2x2(&mt, m, rhs);

    SC_MatrixLoad_2x2_2x2(m, &mt);

}



static void SC_MatrixRotate(rs_matrix4x4 *m, float rot, float x, float y, float z) {

    rs_matrix4x4 m1;

    SC_MatrixLoadRotate(&m1, rot, x, y, z);

    SC_MatrixMultiply_4x4_4x4(m, &m1);

}



static void SC_MatrixScale(rs_matrix4x4 *m, float x, float y, float z) {

    rs_matrix4x4 m1;

    SC_MatrixLoadScale(&m1, x, y, z);

    SC_MatrixMultiply_4x4_4x4(m, &m1);

}



static void SC_MatrixTranslate(rs_matrix4x4 *m, float x, float y, float z) {

    rs_matrix4x4 m1;

    SC_MatrixLoadTranslate(&m1, x, y, z);

    SC_MatrixMultiply_4x4_4x4(m, &m1);

}



static void SC_MatrixLoadOrtho(rs_matrix4x4 *m, float left, float right, float bottom, float top, float near, float far) {

    SC_MatrixLoadIdentity_4x4(m);

    m->m[0] = 2.f / (right - left);

    m->m[5] = 2.f / (top - bottom);

    m->m[10]= -2.f / (far - near);

    m->m[12]= -(right + left) / (right - left);

    m->m[13]= -(top + bottom) / (top - bottom);

    m->m[14]= -(far + near) / (far - near);

}



static void SC_MatrixLoadFrustum(rs_matrix4x4 *m, float left, float right, float bottom, float top, float near, float far) {

    SC_MatrixLoadIdentity_4x4(m);

    m->m[0] = 2.f * near / (right - left);

    m->m[5] = 2.f * near / (top - bottom);

    m->m[8] = (right + left) / (right - left);

    m->m[9] = (top + bottom) / (top - bottom);

    m->m[10]= -(far + near) / (far - near);

    m->m[11]= -1.f;

    m->m[14]= -2.f * far * near / (far - near);

    m->m[15]= 0.f;

}



static void SC_MatrixLoadPerspective(rs_matrix4x4* m, float fovy, float aspect, float near, float far) {

    float top = near * tan((float) (fovy * M_PI / 360.0f));

    float bottom = -top;

    float left = bottom * aspect;

    float right = top * aspect;

    SC_MatrixLoadFrustum(m, left, right, bottom, top, near, far);

}





// Returns true if the matrix was successfully inversed

static bool SC_MatrixInverse_4x4(rs_matrix4x4 *m) {

    rs_matrix4x4 result;



    int i, j;

    for (i = 0; i < 4; ++i) {

        for (j = 0; j < 4; ++j) {

            // computeCofactor for int i, int j

            int c0 = (i+1) % 4;

            int c1 = (i+2) % 4;

            int c2 = (i+3) % 4;

            int r0 = (j+1) % 4;

            int r1 = (j+2) % 4;

            int r2 = (j+3) % 4;



            float minor = (m->m[c0 + 4*r0] * (m->m[c1 + 4*r1] * m->m[c2 + 4*r2] - m->m[c1 + 4*r2] * m->m[c2 + 4*r1]))

                         - (m->m[c0 + 4*r1] * (m->m[c1 + 4*r0] * m->m[c2 + 4*r2] - m->m[c1 + 4*r2] * m->m[c2 + 4*r0]))

                         + (m->m[c0 + 4*r2] * (m->m[c1 + 4*r0] * m->m[c2 + 4*r1] - m->m[c1 + 4*r1] * m->m[c2 + 4*r0]));



            float cofactor = (i+j) & 1 ? -minor : minor;



            result.m[4*i + j] = cofactor;

        }

    }



    // Dot product of 0th column of source and 0th row of result

    float det = m->m[0]*result.m[0] + m->m[4]*result.m[1] +

                 m->m[8]*result.m[2] + m->m[12]*result.m[3];



    if (fabs(det) < 1e-6) {

        return false;

    }



    det = 1.0f / det;

    for (i = 0; i < 16; ++i) {

        m->m[i] = result.m[i] * det;

    }



    return true;

}



// Returns true if the matrix was successfully inversed

static bool SC_MatrixInverseTranspose_4x4(rs_matrix4x4 *m) {

    rs_matrix4x4 result;



    int i, j;

    for (i = 0; i < 4; ++i) {

        for (j = 0; j < 4; ++j) {

            // computeCofactor for int i, int j

            int c0 = (i+1) % 4;

            int c1 = (i+2) % 4;

            int c2 = (i+3) % 4;

            int r0 = (j+1) % 4;

            int r1 = (j+2) % 4;

            int r2 = (j+3) % 4;



            float minor = (m->m[c0 + 4*r0] * (m->m[c1 + 4*r1] * m->m[c2 + 4*r2] - m->m[c1 + 4*r2] * m->m[c2 + 4*r1]))

                         - (m->m[c0 + 4*r1] * (m->m[c1 + 4*r0] * m->m[c2 + 4*r2] - m->m[c1 + 4*r2] * m->m[c2 + 4*r0]))

                         + (m->m[c0 + 4*r2] * (m->m[c1 + 4*r0] * m->m[c2 + 4*r1] - m->m[c1 + 4*r1] * m->m[c2 + 4*r0]));



            float cofactor = (i+j) & 1 ? -minor : minor;



            result.m[4*j + i] = cofactor;

        }

    }



    // Dot product of 0th column of source and 0th column of result

    float det = m->m[0]*result.m[0] + m->m[4]*result.m[4] +

                 m->m[8]*result.m[8] + m->m[12]*result.m[12];



    if (fabs(det) < 1e-6) {

        return false;

    }



    det = 1.0f / det;

    for (i = 0; i < 16; ++i) {

        m->m[i] = result.m[i] * det;

    }



    return true;

}



static void SC_MatrixTranspose_4x4(rs_matrix4x4 *m) {

    int i, j;

    float temp;

    for (i = 0; i < 3; ++i) {

        for (j = i + 1; j < 4; ++j) {

            temp = m->m[i*4 + j];

            m->m[i*4 + j] = m->m[j*4 + i];

            m->m[j*4 + i] = temp;

        }

    }

}



static void SC_MatrixTranspose_3x3(rs_matrix3x3 *m) {

    int i, j;

    float temp;

    for (i = 0; i < 2; ++i) {

        for (j = i + 1; j < 3; ++j) {

            temp = m->m[i*3 + j];

            m->m[i*3 + j] = m->m[j*4 + i];

            m->m[j*3 + i] = temp;

        }

    }

}



static void SC_MatrixTranspose_2x2(rs_matrix2x2 *m) {

    float temp = m->m[1];

    m->m[1] = m->m[2];

    m->m[2] = temp;

}





//////////////////////////////////////////////////////////////////////////////

// Class implementation

//////////////////////////////////////////////////////////////////////////////
@@ -473,6 +956,45 @@ static ScriptCState::SymbolTable_t gSyms[] = { 
    { "_Z22rsSendToClientBlockingi", (void *)&SC_toClientBlocking, false },

    { "_Z22rsSendToClientBlockingiPKvj", (void *)&SC_toClientBlocking2, false },



    // matrix

    { "_Z20rsMatrixLoadIdentityP12rs_matrix4x4", (void *)&SC_MatrixLoadIdentity_4x4, false },

    { "_Z20rsMatrixLoadIdentityP12rs_matrix3x3", (void *)&SC_MatrixLoadIdentity_3x3, false },

    { "_Z20rsMatrixLoadIdentityP12rs_matrix2x2", (void *)&SC_MatrixLoadIdentity_2x2, false },



    { "_Z12rsMatrixLoadP12rs_matrix4x4PKf", (void *)&SC_MatrixLoad_4x4_f, false },

    { "_Z12rsMatrixLoadP12rs_matrix3x3PKf", (void *)&SC_MatrixLoad_3x3_f, false },

    { "_Z12rsMatrixLoadP12rs_matrix2x2PKf", (void *)&SC_MatrixLoad_2x2_f, false },



    { "_Z12rsMatrixLoadP12rs_matrix4x4PKS_", (void *)&SC_MatrixLoad_4x4_4x4, false },

    { "_Z12rsMatrixLoadP12rs_matrix4x4PK12rs_matrix3x3", (void *)&SC_MatrixLoad_4x4_3x3, false },

    { "_Z12rsMatrixLoadP12rs_matrix4x4PK12rs_matrix2x2", (void *)&SC_MatrixLoad_4x4_2x2, false },

    { "_Z12rsMatrixLoadP12rs_matrix3x3PKS_", (void *)&SC_MatrixLoad_3x3_3x3, false },

    { "_Z12rsMatrixLoadP12rs_matrix2x2PKS_", (void *)&SC_MatrixLoad_2x2_2x2, false },



    { "_Z18rsMatrixLoadRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadRotate, false },

    { "_Z17rsMatrixLoadScaleP12rs_matrix4x4fff", (void *)&SC_MatrixLoadScale, false },

    { "_Z21rsMatrixLoadTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixLoadTranslate, false },

    { "_Z14rsMatrixRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixRotate, false },

    { "_Z13rsMatrixScaleP12rs_matrix4x4fff", (void *)&SC_MatrixScale, false },

    { "_Z17rsMatrixTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixTranslate, false },



    { "_Z20rsMatrixLoadMultiplyP12rs_matrix4x4PKS_S2_", (void *)&SC_MatrixLoadMultiply_4x4_4x4_4x4, false },

    { "_Z16rsMatrixMultiplyP12rs_matrix4x4PKS_", (void *)&SC_MatrixMultiply_4x4_4x4, false },

    { "_Z20rsMatrixLoadMultiplyP12rs_matrix3x3PKS_S2_", (void *)&SC_MatrixLoadMultiply_3x3_3x3_3x3, false },

    { "_Z16rsMatrixMultiplyP12rs_matrix3x3PKS_", (void *)&SC_MatrixMultiply_3x3_3x3, false },

    { "_Z20rsMatrixLoadMultiplyP12rs_matrix2x2PKS_S2_", (void *)&SC_MatrixLoadMultiply_2x2_2x2_2x2, false },

    { "_Z16rsMatrixMultiplyP12rs_matrix2x2PKS_", (void *)&SC_MatrixMultiply_2x2_2x2, false },



    { "_Z17rsMatrixLoadOrthoP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadOrtho, false },

    { "_Z19rsMatrixLoadFrustumP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadFrustum, false },

    { "_Z23rsMatrixLoadPerspectiveP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadPerspective, false },



    { "_Z15rsMatrixInverseP12rs_matrix4x4", (void *)&SC_MatrixInverse_4x4, false },

    { "_Z24rsMatrixInverseTransposeP12rs_matrix4x4", (void *)&SC_MatrixInverseTranspose_4x4, false },

    { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_4x4, false },

    { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_3x3, false },

    { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_2x2, false },



    { "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach, false },

    //{ "_Z9rsForEach9rs_script13rs_allocationS0_PKv", (void *)&SC_ForEach2, true },

libs/rs/scriptc/rs_core.rsh

+46 −446

File changed.

Preview size limit exceeded, changes collapsed.