1 /* 2 * Copyright (C) 2011-2012 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 #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) 18 #include <cutils/compiler.h> 19 #endif 20 21 #include "rsContext.h" 22 #include "rsScriptC.h" 23 #include "rsMatrix4x4.h" 24 #include "rsMatrix3x3.h" 25 #include "rsMatrix2x2.h" 26 27 #include "rsCpuCore.h" 28 #include "rsCpuScript.h" 29 30 using namespace android; 31 using namespace android::renderscript; 32 33 #define EXPORT_F32_FN_F32(func) \ 34 float __attribute__((overloadable)) SC_##func(float v) { \ 35 return func(v); \ 36 } 37 38 #define EXPORT_F32_FN_F32_F32(func) \ 39 float __attribute__((overloadable)) SC_##func(float t, float v) { \ 40 return func(t, v); \ 41 } 42 43 ////////////////////////////////////////////////////////////////////////////// 44 // Float util 45 ////////////////////////////////////////////////////////////////////////////// 46 47 // Handle missing Gingerbread functions like tgammaf. 48 float SC_tgammaf(float x) { 49 #ifdef RS_COMPATIBILITY_LIB 50 return tgamma(x); 51 #else 52 return tgammaf(x); 53 #endif 54 } 55 56 uint32_t SC_abs_i32(int32_t v) {return abs(v);} 57 58 static void SC_MatrixLoadRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 59 m->loadRotate(rot, x, y, z); 60 } 61 static void SC_MatrixLoadScale(Matrix4x4 *m, float x, float y, float z) { 62 m->loadScale(x, y, z); 63 } 64 static void SC_MatrixLoadTranslate(Matrix4x4 *m, float x, float y, float z) { 65 m->loadTranslate(x, y, z); 66 } 67 static void SC_MatrixRotate(Matrix4x4 *m, float rot, float x, float y, float z) { 68 m->rotate(rot, x, y, z); 69 } 70 static void SC_MatrixScale(Matrix4x4 *m, float x, float y, float z) { 71 m->scale(x, y, z); 72 } 73 static void SC_MatrixTranslate(Matrix4x4 *m, float x, float y, float z) { 74 m->translate(x, y, z); 75 } 76 77 static void SC_MatrixLoadOrtho(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) { 78 m->loadOrtho(l, r, b, t, n, f); 79 } 80 static void SC_MatrixLoadFrustum(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) { 81 m->loadFrustum(l, r, b, t, n, f); 82 } 83 static void SC_MatrixLoadPerspective(Matrix4x4 *m, float fovy, float aspect, float near, float far) { 84 m->loadPerspective(fovy, aspect, near, far); 85 } 86 87 static bool SC_MatrixInverse_4x4(Matrix4x4 *m) { 88 return m->inverse(); 89 } 90 static bool SC_MatrixInverseTranspose_4x4(Matrix4x4 *m) { 91 return m->inverseTranspose(); 92 } 93 static void SC_MatrixTranspose_4x4(Matrix4x4 *m) { 94 m->transpose(); 95 } 96 static void SC_MatrixTranspose_3x3(Matrix3x3 *m) { 97 m->transpose(); 98 } 99 static void SC_MatrixTranspose_2x2(Matrix2x2 *m) { 100 m->transpose(); 101 } 102 103 float SC_randf2(float min, float max) { 104 float r = (float)rand(); 105 r /= RAND_MAX; 106 r = r * (max - min) + min; 107 return r; 108 } 109 110 static float SC_frac(float v) { 111 int i = (int)floor(v); 112 return fmin(v - i, 0x1.fffffep-1f); 113 } 114 115 EXPORT_F32_FN_F32(acosf) 116 EXPORT_F32_FN_F32(acoshf) 117 EXPORT_F32_FN_F32(asinf) 118 EXPORT_F32_FN_F32(asinhf) 119 EXPORT_F32_FN_F32(atanf) 120 EXPORT_F32_FN_F32_F32(atan2f) 121 EXPORT_F32_FN_F32(atanhf) 122 EXPORT_F32_FN_F32(cbrtf) 123 EXPORT_F32_FN_F32(ceilf) 124 EXPORT_F32_FN_F32_F32(copysignf) 125 EXPORT_F32_FN_F32(cosf) 126 EXPORT_F32_FN_F32(coshf) 127 EXPORT_F32_FN_F32(erfcf) 128 EXPORT_F32_FN_F32(erff) 129 EXPORT_F32_FN_F32(expf) 130 EXPORT_F32_FN_F32(exp2f) 131 EXPORT_F32_FN_F32(expm1f) 132 EXPORT_F32_FN_F32_F32(fdimf) 133 EXPORT_F32_FN_F32(floorf) 134 float SC_fmaf(float u, float t, float v) {return fmaf(u, t, v);} 135 EXPORT_F32_FN_F32_F32(fmaxf) 136 EXPORT_F32_FN_F32_F32(fminf) 137 EXPORT_F32_FN_F32_F32(fmodf) 138 float SC_frexpf(float v, int* ptr) {return frexpf(v, ptr);} 139 EXPORT_F32_FN_F32_F32(hypotf) 140 int SC_ilogbf(float v) {return ilogbf(v); } 141 float SC_ldexpf(float v, int i) {return ldexpf(v, i);} 142 EXPORT_F32_FN_F32(lgammaf) 143 float SC_lgammaf_r(float v, int* ptr) {return lgammaf_r(v, ptr);} 144 EXPORT_F32_FN_F32(logf) 145 EXPORT_F32_FN_F32(log10f) 146 EXPORT_F32_FN_F32(log1pf) 147 EXPORT_F32_FN_F32(logbf) 148 float SC_modff(float v, float* ptr) {return modff(v, ptr);} 149 EXPORT_F32_FN_F32_F32(nextafterf) 150 EXPORT_F32_FN_F32_F32(powf) 151 EXPORT_F32_FN_F32_F32(remainderf) 152 float SC_remquof(float t, float v, int* ptr) {return remquof(t, v, ptr);} 153 EXPORT_F32_FN_F32(rintf) 154 EXPORT_F32_FN_F32(roundf) 155 EXPORT_F32_FN_F32(sinf) 156 EXPORT_F32_FN_F32(sinhf) 157 EXPORT_F32_FN_F32(sqrtf) 158 EXPORT_F32_FN_F32(tanf) 159 EXPORT_F32_FN_F32(tanhf) 160 EXPORT_F32_FN_F32(truncf) 161 float __attribute__((overloadable)) rsFrac(float f) { 162 return SC_frac(f); 163 } 164 void __attribute__((overloadable)) rsMatrixLoadRotate(rs_matrix4x4 *m, 165 float rot, float x, float y, float z) { 166 SC_MatrixLoadRotate((Matrix4x4 *) m, rot, x, y, z); 167 } 168 void __attribute__((overloadable)) rsMatrixLoadScale(rs_matrix4x4 *m, 169 float x, float y, float z) { 170 SC_MatrixLoadScale((Matrix4x4 *) m, x, y, z); 171 } 172 void __attribute__((overloadable)) rsMatrixLoadTranslate(rs_matrix4x4 *m, 173 float x, float y, float z) { 174 SC_MatrixLoadTranslate((Matrix4x4 *) m, x, y, z); 175 } 176 void __attribute__((overloadable)) rsMatrixRotate(rs_matrix4x4 *m, float rot, 177 float x, float y, float z) { 178 SC_MatrixRotate((Matrix4x4 *) m, rot, x, y, z); 179 } 180 void __attribute__((overloadable)) rsMatrixScale(rs_matrix4x4 *m, float x, 181 float y, float z) { 182 SC_MatrixScale((Matrix4x4 *) m, x, y, z); 183 } 184 void __attribute__((overloadable)) rsMatrixTranslate(rs_matrix4x4 *m, float x, 185 float y, float z) { 186 SC_MatrixTranslate((Matrix4x4 *) m, x, y, z); 187 } 188 void __attribute__((overloadable)) rsMatrixLoadOrtho(rs_matrix4x4 *m, float l, 189 float r, float b, float t, float n, float f) { 190 SC_MatrixLoadOrtho((Matrix4x4 *) m, l, r, b, t, n, f); 191 } 192 void __attribute__((overloadable)) rsMatrixLoadFrustum(rs_matrix4x4 *m, 193 float l, float r, float b, float t, float n, float f) { 194 SC_MatrixLoadFrustum((Matrix4x4 *) m, l, r, b, t, n, f); 195 } 196 void __attribute__((overloadable)) rsMatrixLoadPerspective(rs_matrix4x4 *m, 197 float fovy, float aspect, float near, float far) { 198 SC_MatrixLoadPerspective((Matrix4x4 *) m, fovy, aspect, near, far); 199 } 200 bool __attribute__((overloadable)) rsMatrixInverse(rs_matrix4x4 *m) { 201 return SC_MatrixInverse_4x4((Matrix4x4 *) m); 202 } 203 bool __attribute__((overloadable)) rsMatrixInverseTranspose(rs_matrix4x4 *m) { 204 return SC_MatrixInverseTranspose_4x4((Matrix4x4 *) m); 205 } 206 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix4x4 *m) { 207 SC_MatrixTranspose_4x4((Matrix4x4 *) m); 208 } 209 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix3x3 *m) { 210 SC_MatrixTranspose_3x3((Matrix3x3 *) m); 211 } 212 void __attribute__((overloadable)) rsMatrixTranspose(rs_matrix2x2 *m) { 213 SC_MatrixTranspose_2x2((Matrix2x2 *) m); 214 } 215 216 217
