Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 1 | /* |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 2 | * Copyright (C) 2011-2012 The Android Open Source Project |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 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 | |
Stephen Hines | 43cfc0c | 2013-08-15 10:02:11 -0700 | [diff] [blame] | 17 | #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) |
Glenn Kasten | 72f4f4c | 2011-12-15 09:51:17 -0800 | [diff] [blame] | 18 | #include <cutils/compiler.h> |
Tim Murray | 0b575de | 2013-03-15 15:56:43 -0700 | [diff] [blame] | 19 | #endif |
Glenn Kasten | 72f4f4c | 2011-12-15 09:51:17 -0800 | [diff] [blame] | 20 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 21 | #include "rsContext.h" |
| 22 | #include "rsScriptC.h" |
| 23 | #include "rsMatrix4x4.h" |
| 24 | #include "rsMatrix3x3.h" |
| 25 | #include "rsMatrix2x2.h" |
| 26 | |
Jason Sams | 709a097 | 2012-11-15 18:18:04 -0800 | [diff] [blame] | 27 | #include "rsCpuCore.h" |
| 28 | #include "rsCpuScript.h" |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 29 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 30 | using namespace android; |
| 31 | using namespace android::renderscript; |
| 32 | |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 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 | } |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 42 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 43 | ////////////////////////////////////////////////////////////////////////////// |
| 44 | // Float util |
| 45 | ////////////////////////////////////////////////////////////////////////////// |
| 46 | |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 47 | // Handle missing Gingerbread functions like tgammaf. |
| 48 | float SC_tgammaf(float x) { |
Stephen Hines | 11418c8 | 2013-08-14 16:46:21 -0700 | [diff] [blame] | 49 | #ifdef RS_COMPATIBILITY_LIB |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 50 | return tgamma(x); |
Stephen Hines | 11418c8 | 2013-08-14 16:46:21 -0700 | [diff] [blame] | 51 | #else |
| 52 | return tgammaf(x); |
| 53 | #endif |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | uint32_t SC_abs_i32(int32_t v) {return abs(v);} |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 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 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 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 | |
Stephen Hines | b93cb42 | 2013-03-27 17:32:31 -0700 | [diff] [blame] | 103 | float SC_randf2(float min, float max) { |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 104 | float r = (float)rand(); |
Jason Sams | b8fa756 | 2011-04-22 14:19:42 -0700 | [diff] [blame] | 105 | r /= RAND_MAX; |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 106 | r = r * (max - min) + min; |
Jason Sams | b8fa756 | 2011-04-22 14:19:42 -0700 | [diff] [blame] | 107 | return r; |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 108 | } |
| 109 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 110 | static float SC_frac(float v) { |
| 111 | int i = (int)floor(v); |
| 112 | return fmin(v - i, 0x1.fffffep-1f); |
| 113 | } |
| 114 | |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 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) |
Pirama Arumuga Nainar | 6fdd060 | 2015-01-13 11:21:13 -0800 | [diff] [blame] | 140 | int SC_ilogbf(float v) {return ilogbf(v); } |
Tim Murray | d6f1f46 | 2013-03-25 16:36:59 -0700 | [diff] [blame] | 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) |
Stephen Hines | cadee38 | 2013-12-12 13:21:00 -0800 | [diff] [blame] | 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 | } |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 215 | |
Jason Sams | 87fe59a | 2011-04-20 15:09:01 -0700 | [diff] [blame] | 216 | |