From fae3f6b4153ff39c4f9e00dcf635b413d0ae4e85 Mon Sep 17 00:00:00 2001 From: Jason Sams Date: Thu, 24 Jun 2010 13:54:11 -0700 Subject: [PATCH] Add matrix ops to RSH headers. Change-Id: I7e2843983a12e0155114b4a18813799e4341d26f --- .../android/renderscript/FieldPacker.java | 2 +- .../java/ImageProcessing/res/raw/threshold.rs | 109 ++--- .../ImageProcessing/res/raw/threshold_bc.bc | Bin 8372 -> 8596 bytes libs/rs/rsScriptC_Lib.cpp | 196 -------- libs/rs/scriptc/rs_core.rsh | 451 ++++++++++++++++++ libs/rs/scriptc/rs_math.rsh | 32 -- libs/rs/scriptc/rs_types.rsh | 9 + 7 files changed, 499 insertions(+), 300 deletions(-) diff --git a/graphics/java/android/renderscript/FieldPacker.java b/graphics/java/android/renderscript/FieldPacker.java index d16697202f113..f03b51cbbb8eb 100644 --- a/graphics/java/android/renderscript/FieldPacker.java +++ b/graphics/java/android/renderscript/FieldPacker.java @@ -244,7 +244,7 @@ public class FieldPacker { addU32(v.w); } - public void addBoolean(Boolean v) { + public void addBoolean(boolean v) { addI8((byte)(v ? 1 : 0)); } diff --git a/libs/rs/java/ImageProcessing/res/raw/threshold.rs b/libs/rs/java/ImageProcessing/res/raw/threshold.rs index a8eb1648aaee4..9585e92e89248 100644 --- a/libs/rs/java/ImageProcessing/res/raw/threshold.rs +++ b/libs/rs/java/ImageProcessing/res/raw/threshold.rs @@ -4,6 +4,9 @@ #include "../../../../scriptc/rs_math.rsh" #include "../../../../scriptc/rs_graphics.rsh" +#pragma rs java_package_name(com.android.rs.image) + + #define MAX_RADIUS 25 int height; @@ -32,7 +35,7 @@ static float overInWMinInB; // Store our coefficients here static float gaussian[MAX_RADIUS * 2 + 1]; -static float colorMat[4][4]; +static rs_matrix3x3 colorMat; static void computeColorMatrix() { // Saturation @@ -48,17 +51,15 @@ static void computeColorMatrix() { float oneMinusS = 1.0f - saturation; - rsMatrixLoadIdentity((rs_matrix4x4 *)colorMat); - - colorMat[0][0] = oneMinusS * rWeight + saturation; - colorMat[0][1] = oneMinusS * rWeight; - colorMat[0][2] = oneMinusS * rWeight; - colorMat[1][0] = oneMinusS * gWeight; - colorMat[1][1] = oneMinusS * gWeight + saturation; - colorMat[1][2] = oneMinusS * gWeight; - colorMat[2][0] = oneMinusS * bWeight; - colorMat[2][1] = oneMinusS * bWeight; - colorMat[2][2] = oneMinusS * bWeight + saturation; + rsMatrixSet(&colorMat, 0, 0, oneMinusS * rWeight + saturation); + rsMatrixSet(&colorMat, 0, 1, oneMinusS * rWeight); + rsMatrixSet(&colorMat, 0, 2, oneMinusS * rWeight); + rsMatrixSet(&colorMat, 1, 0, oneMinusS * gWeight); + rsMatrixSet(&colorMat, 1, 1, oneMinusS * gWeight + saturation); + rsMatrixSet(&colorMat, 1, 2, oneMinusS * gWeight); + rsMatrixSet(&colorMat, 2, 0, oneMinusS * bWeight); + rsMatrixSet(&colorMat, 2, 1, oneMinusS * bWeight); + rsMatrixSet(&colorMat, 2, 2, oneMinusS * bWeight + saturation); inWMinInB = inWhite - inBlack; outWMinOutB = outWhite - outBlack; @@ -107,48 +108,10 @@ static void computeGaussianWeights() { // This needs to be inline static float4 levelsSaturation(float4 currentPixel) { -#if 0 - // Color matrix multiply - float tempX = colorMat[0][0] * currentPixel.x + colorMat[1][0] * currentPixel.y + colorMat[2][0] * currentPixel.z; - float tempY = colorMat[0][1] * currentPixel.x + colorMat[1][1] * currentPixel.y + colorMat[2][1] * currentPixel.z; - float tempZ = colorMat[0][2] * currentPixel.x + colorMat[1][2] * currentPixel.y + colorMat[2][2] * currentPixel.z; - - currentPixel.x = tempX; - currentPixel.y = tempY; - currentPixel.z = tempZ; - - // Clamp to 0..255 - // Inline the code here to avoid funciton calls - currentPixel.x = currentPixel.x > 255.0f ? 255.0f : currentPixel.x; - currentPixel.y = currentPixel.y > 255.0f ? 255.0f : currentPixel.y; - currentPixel.z = currentPixel.z > 255.0f ? 255.0f : currentPixel.z; - - currentPixel.x = currentPixel.x <= 0.0f ? 0.1f : currentPixel.x; - currentPixel.y = currentPixel.y <= 0.0f ? 0.1f : currentPixel.y; - currentPixel.z = currentPixel.z <= 0.0f ? 0.1f : currentPixel.z; - - currentPixel.x = pow( (currentPixel.x - inBlack) * overInWMinInB, gamma) * outWMinOutB + outBlack; - currentPixel.y = pow( (currentPixel.y - inBlack) * overInWMinInB, gamma) * outWMinOutB + outBlack; - currentPixel.z = pow( (currentPixel.z - inBlack) * overInWMinInB, gamma) * outWMinOutB + outBlack; - - currentPixel.x = currentPixel.x > 255.0f ? 255.0f : currentPixel.x; - currentPixel.y = currentPixel.y > 255.0f ? 255.0f : currentPixel.y; - currentPixel.z = currentPixel.z > 255.0f ? 255.0f : currentPixel.z; - - currentPixel.x = currentPixel.x <= 0.0f ? 0.1f : currentPixel.x; - currentPixel.y = currentPixel.y <= 0.0f ? 0.1f : currentPixel.y; - currentPixel.z = currentPixel.z <= 0.0f ? 0.1f : currentPixel.z; -#else - float3 temp; - // Color matrix multiply - temp.x = colorMat[0][0] * currentPixel.x + colorMat[1][0] * currentPixel.y + colorMat[2][0] * currentPixel.z; - temp.y = colorMat[0][1] * currentPixel.x + colorMat[1][1] * currentPixel.y + colorMat[2][1] * currentPixel.z; - temp.z = colorMat[0][2] * currentPixel.x + colorMat[1][2] * currentPixel.y + colorMat[2][2] * currentPixel.z; + float3 temp = rsMatrixMultiply(&colorMat, currentPixel.xyz); temp = (clamp(temp, 0.1f, 255.f) - inBlack) * overInWMinInB; temp = pow(temp, (float3)gamma); currentPixel.xyz = clamp(temp * outWMinOutB + outBlack, 0.1f, 255.f); -#endif - return currentPixel; } @@ -188,8 +151,10 @@ static void horizontalBlur() { // Horizontal blur int w, h, r; for(h = 0; h < height; h ++) { - for(w = 0; w < width; w ++) { + uchar4 *input = InPixel + h*width; + uchar4 *output = ScratchPixel + h*width; + for(w = 0; w < width; w ++) { blurredPixel = 0; for(r = -radius; r <= radius; r ++) { @@ -202,23 +167,22 @@ static void horizontalBlur() { if(validW > width - 1) { validW = width - 1; } - - uchar4 *input = InPixel + h*width + validW; + //int validW = rsClamp(w + r, 0, width - 1); float weight = gaussian[r + radius]; - currentPixel.x = (float)(input->x); - currentPixel.y = (float)(input->y); - currentPixel.z = (float)(input->z); + currentPixel.x = (float)(input[validW].x); + currentPixel.y = (float)(input[validW].y); + currentPixel.z = (float)(input[validW].z); //currentPixel.w = (float)(input->a); blurredPixel += currentPixel*weight; } - uchar4 *output = ScratchPixel + h*width + w; output->x = (uint8_t)blurredPixel.x; output->y = (uint8_t)blurredPixel.y; output->z = (uint8_t)blurredPixel.z; //output->a = (uint8_t)blurredPixel.w; + output++; } } } @@ -229,8 +193,9 @@ static void horizontalBlurLevels() { // Horizontal blur int w, h, r; for(h = 0; h < height; h ++) { - for(w = 0; w < width; w ++) { + uchar4 *output = OutPixel + h*width; + for(w = 0; w < width; w ++) { blurredPixel = 0; for(r = -radius; r <= radius; r ++) { @@ -243,6 +208,7 @@ static void horizontalBlurLevels() { if(validW > width - 1) { validW = width - 1; } + //int validW = rsClamp(w + r, 0, width - 1); uchar4 *input = InPixel + h*width + validW; @@ -252,16 +218,16 @@ static void horizontalBlurLevels() { currentPixel.z = (float)(input->z); //currentPixel.w = (float)(input->a); - blurredPixel += currentPixel*weight; + blurredPixel.xyz += currentPixel.xyz * weight; } blurredPixel = levelsSaturation(blurredPixel); - uchar4 *output = ScratchPixel + h*width + w; output->x = (uint8_t)blurredPixel.x; output->y = (uint8_t)blurredPixel.y; output->z = (uint8_t)blurredPixel.z; //output->a = (uint8_t)blurredPixel.w; + output++; } } } @@ -272,10 +238,13 @@ static void verticalBlur() { // Vertical blur int w, h, r; for(h = 0; h < height; h ++) { + uchar4 *output = OutPixel + h*width; + for(w = 0; w < width; w ++) { blurredPixel = 0; for(r = -radius; r <= radius; r ++) { +#if 1 int validH = h + r; // Clamp to zero and width if(validH < 0) { @@ -292,17 +261,21 @@ static void verticalBlur() { currentPixel.x = (float)(input->x); currentPixel.y = (float)(input->y); currentPixel.z = (float)(input->z); - //currentPixel.w = (float)(input->a); - blurredPixel += currentPixel*weight; + blurredPixel.xyz += currentPixel.xyz * weight; +#else + int validH = rsClamp(h + r, 0, height - 1); + uchar4 *input = ScratchPixel + validH*width + w; + blurredPixel.xyz += convert_float3(input->xyz) * gaussian[r + radius]; +#endif } - uchar4 *output = OutPixel + h*width + w; - + //output->xyz = convert_uchar3(blurredPixel.xyz); output->x = (uint8_t)blurredPixel.x; output->y = (uint8_t)blurredPixel.y; output->z = (uint8_t)blurredPixel.z; //output->a = (uint8_t)blurredPixel.w; + output++; } } } @@ -311,12 +284,6 @@ void filter() { RS_DEBUG(height); RS_DEBUG(width); RS_DEBUG(radius); - RS_DEBUG(inBlack); - RS_DEBUG(outBlack); - RS_DEBUG(inWhite); - RS_DEBUG(outWhite); - RS_DEBUG(gamma); - RS_DEBUG(saturation); computeColorMatrix(); diff --git a/libs/rs/java/ImageProcessing/res/raw/threshold_bc.bc b/libs/rs/java/ImageProcessing/res/raw/threshold_bc.bc index fd60f7655668b9e4092dec9e6c9703ea6b63ae27..95dcd8d61aef67fc5dad78ecfbd6f6e16b578e48 100644 GIT binary patch literal 8596 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 literal 8372 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 - - -////////////////////////////////////////////////////////////////////////////// -// Non-Updated code below -////////////////////////////////////////////////////////////////////////////// - -typedef struct { - float x; - float y; - float z; -} vec3_t; - -typedef struct { - float x; - float y; - float z; - float w; -} vec4_t; - -typedef struct { - float x; - float y; -} vec2_t; - - -////////////////////////////////////////////////////////////////////////////// -// Vec3 routines -////////////////////////////////////////////////////////////////////////////// - -static void SC_vec3Norm(vec3_t *v) -{ - float len = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z); - len = 1 / len; - v->x *= len; - v->y *= len; - v->z *= len; -} - -static float SC_vec3Length(const vec3_t *v) -{ - return sqrtf(v->x * v->x + v->y * v->y + v->z * v->z); -} - -static void SC_vec3Add(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs) -{ - dest->x = lhs->x + rhs->x; - dest->y = lhs->y + rhs->y; - dest->z = lhs->z + rhs->z; -} - -static void SC_vec3Sub(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs) -{ - dest->x = lhs->x - rhs->x; - dest->y = lhs->y - rhs->y; - dest->z = lhs->z - rhs->z; -} - -static void SC_vec3Cross(vec3_t *dest, const vec3_t *lhs, const vec3_t *rhs) -{ - float x = lhs->y * rhs->z - lhs->z * rhs->y; - float y = lhs->z * rhs->x - lhs->x * rhs->z; - float z = lhs->x * rhs->y - lhs->y * rhs->x; - dest->x = x; - dest->y = y; - dest->z = z; -} - -static float SC_vec3Dot(const vec3_t *lhs, const vec3_t *rhs) -{ - return lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z; -} - -static void SC_vec3Scale(vec3_t *lhs, float scale) -{ - lhs->x *= scale; - lhs->y *= scale; - lhs->z *= scale; -} - -////////////////////////////////////////////////////////////////////////////// -// Vec4 routines -////////////////////////////////////////////////////////////////////////////// - -static void SC_vec4Norm(vec4_t *v) -{ - float len = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z + v->w * v->w); - len = 1 / len; - v->x *= len; - v->y *= len; - v->z *= len; - v->w *= len; -} - -static float SC_vec4Length(const vec4_t *v) -{ - return sqrtf(v->x * v->x + v->y * v->y + v->z * v->z + v->w * v->w); -} - -static void SC_vec4Add(vec4_t *dest, const vec4_t *lhs, const vec4_t *rhs) -{ - dest->x = lhs->x + rhs->x; - dest->y = lhs->y + rhs->y; - dest->z = lhs->z + rhs->z; - dest->w = lhs->w + rhs->w; -} - -static void SC_vec4Sub(vec4_t *dest, const vec4_t *lhs, const vec4_t *rhs) -{ - dest->x = lhs->x - rhs->x; - dest->y = lhs->y - rhs->y; - dest->z = lhs->z - rhs->z; - dest->w = lhs->w - rhs->w; -} - -static float SC_vec4Dot(const vec4_t *lhs, const vec4_t *rhs) -{ - return lhs->x * rhs->x + lhs->y * rhs->y + lhs->z * rhs->z + lhs->w * rhs->w; -} - -static void SC_vec4Scale(vec4_t *lhs, float scale) -{ - lhs->x *= scale; - lhs->y *= scale; - lhs->z *= scale; - lhs->w *= scale; -} - ////////////////////////////////////////////////////////////////////////////// // Math routines ////////////////////////////////////////////////////////////////////////////// @@ -224,41 +97,6 @@ static int SC_randi2(int min, int max) return (int)SC_randf2(min, max); } -static int SC_clamp(int amount, int low, int high) -{ - return amount < low ? low : (amount > high ? high : amount); -} - -static float SC_roundf(float v) -{ - return floorf(v + 0.4999999999); -} - -static float SC_distf2(float x1, float y1, float x2, float y2) -{ - float x = x2 - x1; - float y = y2 - y1; - return sqrtf(x * x + y * y); -} - -static float SC_distf3(float x1, float y1, float z1, float x2, float y2, float z2) -{ - float x = x2 - x1; - float y = y2 - y1; - float z = z2 - z1; - return sqrtf(x * x + y * y + z * z); -} - -static float SC_magf2(float a, float b) -{ - return sqrtf(a * a + b * b); -} - -static float SC_magf3(float a, float b, float c) -{ - return sqrtf(a * a + b * b + c * c); -} - static float SC_frac(float v) { int i = (int)floor(v); @@ -512,24 +350,6 @@ static void SC_debugI32(const char *s, int32_t i) { LOGE("%s %i 0x%x", s, i, i); } -static uchar4 SC_convertColorTo8888_f3(float r, float g, float b) { - uchar4 t; - t.f[0] = (uint8_t)(r * 255.f); - t.f[1] = (uint8_t)(g * 255.f); - t.f[2] = (uint8_t)(b * 255.f); - t.f[3] = 0xff; - return t; -} - -static uchar4 SC_convertColorTo8888_f4(float r, float g, float b, float a) { - uchar4 t; - t.f[0] = (uint8_t)(r * 255.f); - t.f[1] = (uint8_t)(g * 255.f); - t.f[2] = (uint8_t)(b * 255.f); - t.f[3] = (uint8_t)(a * 255.f); - return t; -} - static uint32_t SC_toClient(void *data, int cmdID, int len, int waitForSpace) { GET_TLS(); @@ -640,16 +460,6 @@ static ScriptCState::SymbolTable_t gSyms[] = { { "rsAllocationGetDimFaces", (void *)&SC_allocGetDimFaces }, { "rsGetAllocation", (void *)&SC_getAllocation }, - // color - { "_Z17rsPackColorTo8888fff", (void *)&SC_convertColorTo8888_f3 }, - { "_Z17rsPackColorTo8888ffff", (void *)&SC_convertColorTo8888_f4 }, - //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float3); - //extern uchar4 __attribute__((overloadable)) rsPackColorTo8888(float4); - //extern float4 rsUnpackColor8888(uchar4); - //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float r, float g, float b); - //extern uchar4 __attribute__((overloadable)) rsPackColorTo565(float3); - //extern float4 rsUnpackColor565(uchar4); - // Debug { "_Z7rsDebugPKcf", (void *)&SC_debugF }, { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugFv2 }, @@ -703,12 +513,6 @@ static ScriptCState::SymbolTable_t gSyms[] = { //{ "sinf_fast", (void *)&SC_sinf_fast }, //{ "cosf_fast", (void *)&SC_cosf_fast }, - //{ "clamp", (void *)&SC_clamp }, - //{ "distf2", (void *)&SC_distf2 }, - //{ "distf3", (void *)&SC_distf3 }, - //{ "magf2", (void *)&SC_magf2 }, - //{ "magf3", (void *)&SC_magf3 }, - //{ "mapf", (void *)&SC_mapf }, { "scriptCall", (void *)&SC_scriptCall }, diff --git a/libs/rs/scriptc/rs_core.rsh b/libs/rs/scriptc/rs_core.rsh index ebf6876f669a6..91b30b913fecc 100644 --- a/libs/rs/scriptc/rs_core.rsh +++ b/libs/rs/scriptc/rs_core.rsh @@ -48,6 +48,457 @@ static float4 rsUnpackColor8888(uchar4 c) //extern float4 rsUnpackColor565(uchar4); +///////////////////////////////////////////////////// +// Matrix ops +///////////////////////////////////////////////////// + +static void __attribute__((overloadable)) +rsMatrixSet(rs_matrix4x4 *m, uint32_t row, uint32_t col, float v) { + m->m[row * 4 + col] = v; +} + +static float __attribute__((overloadable)) +rsMatrixGet(const rs_matrix4x4 *m, uint32_t row, uint32_t col) { + return m->m[row * 4 + col]; +} + +static void __attribute__((overloadable)) +rsMatrixSet(rs_matrix3x3 *m, uint32_t row, uint32_t col, float v) { + m->m[row * 3 + col] = v; +} + +static float __attribute__((overloadable)) +rsMatrixGet(const rs_matrix3x3 *m, uint32_t row, uint32_t col) { + return m->m[row * 3 + col]; +} + +static void __attribute__((overloadable)) +rsMatrixSet(rs_matrix2x2 *m, uint32_t row, uint32_t col, float v) { + m->m[row * 2 + col] = v; +} + +static float __attribute__((overloadable)) +rsMatrixGet(const rs_matrix2x2 *m, uint32_t row, uint32_t col) { + return m->m[row * 2 + col]; +} + +static void __attribute__((overloadable)) +rsMatrixLoadIdentity(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 __attribute__((overloadable)) +rsMatrixLoadIdentity(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 __attribute__((overloadable)) +rsMatrixLoadIdentity(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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[3]; + m->m[5] = v->m[4]; + m->m[6] = 0.f; + m->m[7] = 0.f; + m->m[8] = v->m[6]; + m->m[9] = v->m[7]; + 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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoad(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 __attribute__((overloadable)) +rsMatrixLoadRotate(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 __attribute__((overloadable)) +rsMatrixLoadScale(rs_matrix4x4 *m, float x, float y, float z) { + rsMatrixLoadIdentity(m); + m->m[0] = x; + m->m[5] = y; + m->m[10] = z; +} + +static void __attribute__((overloadable)) +rsMatrixLoadTranslate(rs_matrix4x4 *m, float x, float y, float z) { + rsMatrixLoadIdentity(m); + m->m[12] = x; + m->m[13] = y; + m->m[14] = z; +} + +static void __attribute__((overloadable)) +rsMatrixLoadMultiply(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 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix4x4 *m, const rs_matrix4x4 *rhs) { + rs_matrix4x4 mt; + rsMatrixLoadMultiply(&mt, m, rhs); + rsMatrixLoad(m, &mt); +} + +static void __attribute__((overloadable)) +rsMatrixLoadMultiply(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 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix3x3 *m, const rs_matrix3x3 *rhs) { + rs_matrix3x3 mt; + rsMatrixLoadMultiply(&mt, m, rhs); + rsMatrixLoad(m, &mt); +} + +static void __attribute__((overloadable)) +rsMatrixLoadMultiply(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 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix2x2 *m, const rs_matrix2x2 *rhs) { + rs_matrix2x2 mt; + rsMatrixLoadMultiply(&mt, m, rhs); + rsMatrixLoad(m, &mt); +} + +static void __attribute__((overloadable)) +rsMatrixRotate(rs_matrix4x4 *m, float rot, float x, float y, float z) { + rs_matrix4x4 m1; + rsMatrixLoadRotate(&m1, rot, x, y, z); + rsMatrixMultiply(m, &m1); +} + +static void __attribute__((overloadable)) +rsMatrixScale(rs_matrix4x4 *m, float x, float y, float z) { + rs_matrix4x4 m1; + rsMatrixLoadScale(&m1, x, y, z); + rsMatrixMultiply(m, &m1); +} + +static void __attribute__((overloadable)) +rsMatrixTranslate(rs_matrix4x4 *m, float x, float y, float z) { + rs_matrix4x4 m1; + rsMatrixLoadTranslate(&m1, x, y, z); + rsMatrixMultiply(m, &m1); +} + +static void __attribute__((overloadable)) +rsMatrixLoadOrtho(rs_matrix4x4 *m, float left, float right, float bottom, float top, float near, float far) { + rsMatrixLoadIdentity(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 __attribute__((overloadable)) +rsMatrixLoadFrustum(rs_matrix4x4 *m, float left, float right, float bottom, float top, float near, float far) { + rsMatrixLoadIdentity(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 float4 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix4x4 *m, float4 in) { + float4 ret; + ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + (m->m[8] * in.z) + (m->m[12] * in.w); + ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + (m->m[9] * in.z) + (m->m[13] * in.w); + ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + (m->m[10] * in.z) + (m->m[14] * in.w); + ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + (m->m[11] * in.z) + (m->m[15] * in.w); + return ret; +} + +static float4 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix4x4 *m, float3 in) { + float4 ret; + ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + (m->m[8] * in.z) + m->m[12]; + ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + (m->m[9] * in.z) + m->m[13]; + ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + (m->m[10] * in.z) + m->m[14]; + ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + (m->m[11] * in.z) + m->m[15]; + return ret; +} + +static float4 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix4x4 *m, float2 in) { + float4 ret; + ret.x = (m->m[0] * in.x) + (m->m[4] * in.y) + m->m[12]; + ret.y = (m->m[1] * in.x) + (m->m[5] * in.y) + m->m[13]; + ret.z = (m->m[2] * in.x) + (m->m[6] * in.y) + m->m[14]; + ret.w = (m->m[3] * in.x) + (m->m[7] * in.y) + m->m[15]; + return ret; +} + +static float3 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix3x3 *m, float3 in) { + float3 ret; + ret.x = (m->m[0] * in.x) + (m->m[3] * in.y) + (m->m[6] * in.z); + ret.y = (m->m[1] * in.x) + (m->m[4] * in.y) + (m->m[7] * in.z); + ret.z = (m->m[2] * in.x) + (m->m[5] * in.y) + (m->m[8] * in.z); + return ret; +} + +static float3 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix3x3 *m, float2 in) { + float3 ret; + ret.x = (m->m[0] * in.x) + (m->m[3] * in.y); + ret.y = (m->m[1] * in.x) + (m->m[4] * in.y); + ret.z = (m->m[2] * in.x) + (m->m[5] * in.y); + return ret; +} + +static float2 __attribute__((overloadable)) +rsMatrixMultiply(rs_matrix2x2 *m, float2 in) { + float2 ret; + ret.x = (m->m[0] * in.x) + (m->m[2] * in.y); + ret.y = (m->m[1] * in.x) + (m->m[3] * in.y); + return ret; +} + +///////////////////////////////////////////////////// +// int ops +///////////////////////////////////////////////////// + +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(uint amount, uint low, uint high) { + return amount < low ? low : (amount > high ? high : amount); +} +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(int amount, int low, int high) { + return amount < low ? low : (amount > high ? high : amount); +} +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(ushort amount, ushort low, ushort high) { + return amount < low ? low : (amount > high ? high : amount); +} +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(short amount, short low, short high) { + return amount < low ? low : (amount > high ? high : amount); +} +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(uchar amount, uchar low, uchar high) { + return amount < low ? low : (amount > high ? high : amount); +} +__inline__ static float __attribute__((overloadable, always_inline)) rsClamp(char amount, char low, char high) { + return amount < low ? low : (amount > high ? high : amount); +} + #endif diff --git a/libs/rs/scriptc/rs_math.rsh b/libs/rs/scriptc/rs_math.rsh index a26491f0e0b45..8bf53bf2666c2 100644 --- a/libs/rs/scriptc/rs_math.rsh +++ b/libs/rs/scriptc/rs_math.rsh @@ -44,18 +44,6 @@ extern int64_t rsElapsedTimeMillis(); extern int rsSendToClient(void *data, int cmdID, int len, int waitForSpace); -extern void rsMatrixLoadIdentity(rs_matrix4x4 *mat); -extern void rsMatrixLoadFloat(rs_matrix4x4 *mat, const float *f); -extern void rsMatrixLoadMat(rs_matrix4x4 *mat, const rs_matrix4x4 *newmat); -extern void rsMatrixLoadRotate(rs_matrix4x4 *mat, float rot, float x, float y, float z); -extern void rsMatrixLoadScale(rs_matrix4x4*mat, float x, float y, float z); -extern void rsMatrixLoadTranslate(rs_matrix4x4 *mat, float x, float y, float z); -extern void rsMatrixLoadMultiply(rs_matrix4x4 *mat, const rs_matrix4x4 *lhs, const rs_matrix4x4 *rhs); -extern void rsMatrixMultiply(rs_matrix4x4 *mat, const rs_matrix4x4 *rhs); -extern void rsMatrixRotate(rs_matrix4x4 *mat, float rot, float x, float y, float z); -extern void rsMatrixScale(rs_matrix4x4 *mat, float x, float y, float z); -extern void rsMatrixTranslate(rs_matrix4x4 *mat, float x, float y, float z); - // Script to Script extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input); extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input, rs_allocation output); @@ -65,23 +53,3 @@ extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation inpu extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input, rs_allocation output, int xStart, int yStart, int xEnd, int yEnd); -/////////////////////////////////////////////////////////////////// -// non update funcs - -/* -extern float3 float3Norm(float3); -extern float float3Length(float3); -extern float3 float3Add(float3 lhs, float3 rhs); -extern float3 float3Sub(float3 lhs, float3 rhs); -extern float3 float3Cross(float3 lhs, float3 rhs); -extern float float3Dot(float3 lhs, float3 rhs); -extern float3 float3Scale(float3 v, float scale); - -extern float4 float4Add(float4 lhs, float4 rhs); -extern float4 float4Sub(float4 lhs, float4 rhs); -extern float4 float4Cross(float4 lhs, float4 rhs); -extern float float4Dot(float4 lhs, float4 rhs); -extern float4 float4Scale(float4 v, float scale); -*/ - - diff --git a/libs/rs/scriptc/rs_types.rsh b/libs/rs/scriptc/rs_types.rsh index 465a4a51f8550..1d8f1bdacbc76 100644 --- a/libs/rs/scriptc/rs_types.rsh +++ b/libs/rs/scriptc/rs_types.rsh @@ -58,5 +58,14 @@ typedef struct { float m[16]; } rs_matrix4x4; +typedef struct { + float m[9]; +} rs_matrix3x3; + +typedef struct { + float m[4]; +} rs_matrix2x2; + + #define RS_PACKED __attribute__((packed, aligned(4)))