diff options
28 files changed, 1721 insertions, 1381 deletions
@@ -106,7 +106,7 @@ LOCAL_SRC_FILES:= \ rsVertexArray.cpp -LOCAL_SHARED_LIBRARIES += libcutils libutils libEGL libGLESv1_CM libGLESv2 libui libacc +LOCAL_SHARED_LIBRARIES += libcutils libutils libEGL libGLESv1_CM libGLESv2 libui libbcc LOCAL_LDLIBS := -lpthread -ldl LOCAL_MODULE:= libRS LOCAL_MODULE_TAGS := optional diff --git a/java/Film/src/com/android/film/FilmRS.java b/java/Film/src/com/android/film/FilmRS.java index 7d045022..f45684cd 100644 --- a/java/Film/src/com/android/film/FilmRS.java +++ b/java/Film/src/com/android/film/FilmRS.java @@ -217,8 +217,8 @@ public class FilmRS { ScriptC.Builder sb = new ScriptC.Builder(mRS); sb.setScript(mRes, R.raw.filmstrip); - sb.setRoot(true); - sb.setType(mStripPositionType, "Pos", 1); + //sb.setRoot(true); + //sb.setType(mStripPositionType, "Pos", 1); mScriptStrip = sb.create(); mScriptStrip.setClearColor(0.0f, 0.0f, 0.0f, 1.0f); diff --git a/java/Fountain/res/raw/fountain.c b/java/Fountain/res/raw/fountain.c deleted file mode 100644 index 73b819b3..00000000 --- a/java/Fountain/res/raw/fountain.c +++ /dev/null @@ -1,52 +0,0 @@ -// Fountain test script -#pragma version(1) - -int newPart = 0; - -int main(int launchID) { - int ct; - int count = Control->count; - int rate = Control->rate; - float height = getHeight(); - struct point_s * p = (struct point_s *)point; - - if (rate) { - float rMax = ((float)rate) * 0.005f; - int x = Control->x; - int y = Control->y; - int color = ((int)(Control->r * 255.f)) | - ((int)(Control->g * 255.f)) << 8 | - ((int)(Control->b * 255.f)) << 16 | - (0xf0 << 24); - struct point_s * np = &p[newPart]; - - while (rate--) { - vec2Rand((float *)&np->delta.x, rMax); - np->position.x = x; - np->position.y = y; - np->color = color; - newPart++; - np++; - if (newPart >= count) { - newPart = 0; - np = &p[newPart]; - } - } - } - - for (ct=0; ct < count; ct++) { - float dy = p->delta.y + 0.15f; - float posy = p->position.y + dy; - if ((posy > height) && (dy > 0)) { - dy *= -0.3f; - } - p->delta.y = dy; - p->position.x += p->delta.x; - p->position.y = posy; - p++; - } - - uploadToBufferObject(NAMED_PartBuffer); - drawSimpleMesh(NAMED_PartMesh); - return 1; -} diff --git a/java/Fountain/res/raw/fountain.rs b/java/Fountain/res/raw/fountain.rs new file mode 100644 index 00000000..5562a776 --- /dev/null +++ b/java/Fountain/res/raw/fountain.rs @@ -0,0 +1,69 @@ +// Fountain test script +#pragma version(1) + +#include "../../../../scriptc/rs_types.rsh" +#include "../../../../scriptc/rs_math.rsh" +#include "../../../../scriptc/rs_graphics.rsh" + +static int newPart = 0; + +float4 partColor; +rs_mesh partMesh; +rs_allocation partBuffer; + +typedef struct __attribute__((packed, aligned(4))) Point_s { + float2 delta; + rs_position2 pos; + rs_color4u color; +} Point_t; +Point_t *point; + +#pragma rs export_var(point, partColor, partMesh, partBuffer) +//#pragma rs export_type(Point_s) +//#pragma rs export_element(point) + +int root() { + debugPf(1, partColor.x); + debugPi(4, partMesh); + debugPi(5, partBuffer); + + float height = getHeight(); + int size = allocGetDimX(partBuffer); + + Point_t * p = point; + for (int ct=0; ct < size; ct++) { + p->delta.y += 0.15f; + p->pos += p->delta; + if ((p->pos.y > height) && (p->delta.y > 0)) { + p->delta.y *= -0.3f; + } + p++; + } + + uploadToBufferObject(partBuffer); + drawSimpleMesh(partMesh); + return 1; +} + +void addParticles(int rate, int x, int y) +{ + float rMax = ((float)rate) * 0.005f; + int size = allocGetDimX(partBuffer); + + rs_color4u c = convertColorTo8888(partColor.x, partColor.y, partColor.z); + Point_t * np = &point[newPart]; + + float2 p = {x, y}; + while (rate--) { + np->delta = vec2Rand(rMax); + np->pos = p; + np->color = c; + newPart++; + np++; + if (newPart >= size) { + newPart = 0; + np = &point[newPart]; + } + } +} + diff --git a/java/Fountain/res/raw/fountain2.rs b/java/Fountain/res/raw/fountain2.rs deleted file mode 100644 index 5d36e35f..00000000 --- a/java/Fountain/res/raw/fountain2.rs +++ /dev/null @@ -1,73 +0,0 @@ -// Fountain test script -#pragma version(1) - -#include "../../../../scriptc/rs_types.rsh" -#include "../../../../scriptc/rs_math.rsh" -#include "../../../../scriptc/rs_graphics.rsh" - -static int newPart = 0; - -typedef struct Control_s { - int x, y; - int rate; - int count; - float r, g, b; - rs_mesh partMesh; - rs_allocation partBuffer; -} Control_t; -Control_t *Control; - -typedef struct Point_s{ - float2 delta; - rs_position2 pos; - rs_color4u color; -} Point_t; -Point_t *point; - -int main(int launchID) { - int ct; - int count = Control->count; - int rate = Control->rate; - float height = getHeight(); - Point_t * p = point; - - if (rate) { - float rMax = ((float)rate) * 0.005f; - int color = ((int)(Control->r * 255.f)) | - ((int)(Control->g * 255.f)) << 8 | - ((int)(Control->b * 255.f)) << 16 | - (0xf0 << 24); - Point_t * np = &p[newPart]; - - while (rate--) { - np->delta.x = rand(rMax); - np->delta.y = rand(rMax); - //np->delta = vec2Rand(rMax); - np->pos.x = Control->x; - np->pos.y = Control->y; - np->color = color; - newPart++; - np++; - if (newPart >= count) { - newPart = 0; - np = &p[newPart]; - } - } - } - - for (ct=0; ct < count; ct++) { - float dy = p->delta.y + 0.15f; - float posy = p->pos.y + dy; - if ((posy > height) && (dy > 0)) { - dy *= -0.3f; - } - p->delta.y = dy; - p->pos.x += p->delta.x; - p->pos.y = posy; - p++; - } - - uploadToBufferObject(Control->partBuffer); - drawSimpleMesh(Control->partMesh); - return 1; -} diff --git a/java/Fountain/res/raw/fountain_bc.bc b/java/Fountain/res/raw/fountain_bc.bc Binary files differnew file mode 100644 index 00000000..f1470687 --- /dev/null +++ b/java/Fountain/res/raw/fountain_bc.bc diff --git a/java/Fountain/src/com/android/fountain/FountainRS.java b/java/Fountain/src/com/android/fountain/FountainRS.java index 93565796..d193134c 100644 --- a/java/Fountain/src/com/android/fountain/FountainRS.java +++ b/java/Fountain/src/com/android/fountain/FountainRS.java @@ -24,16 +24,6 @@ import android.util.Log; public class FountainRS { public static final int PART_COUNT = 20000; - static class SomeData { - public int x; - public int y; - public int rate; - public int count; - public float r; - public float g; - public float b; - } - public FountainRS() { } @@ -43,21 +33,28 @@ public class FountainRS { initRS(); } + Float4 tmpColor = new Float4(); + boolean holdingColor = false; public void newTouchPosition(int x, int y, int rate) { - if (mSD.rate == 0) { - mSD.r = ((x & 0x1) != 0) ? 0.f : 1.f; - mSD.g = ((x & 0x2) != 0) ? 0.f : 1.f; - mSD.b = ((x & 0x4) != 0) ? 0.f : 1.f; - if ((mSD.r + mSD.g + mSD.b) < 0.9f) { - mSD.r = 0.8f; - mSD.g = 0.5f; - mSD.b = 1.f; + if (rate > 0) { + if (true/*!holdingColor*/) { + tmpColor.x = ((x & 0x1) != 0) ? 0.f : 1.f; + tmpColor.y = ((x & 0x2) != 0) ? 0.f : 1.f; + tmpColor.z = ((x & 0x4) != 0) ? 0.f : 1.f; + if ((tmpColor.x + tmpColor.y + tmpColor.z) < 0.9f) { + tmpColor.x = 0.8f; + tmpColor.y = 0.5f; + tmpColor.z = 1.0f; + } + android.util.Log.e("rs", "set color " + tmpColor.x + ", " + tmpColor.y + ", " + tmpColor.z); + mScript.set_partColor(tmpColor); } + mScript.invokable_addParticles(rate, x, y); + holdingColor = true; + } else { + holdingColor = false; } - mSD.rate = rate; - mSD.x = x; - mSD.y = y; - mIntAlloc.data(mSD); + } @@ -65,49 +62,26 @@ public class FountainRS { private Resources mRes; + private ScriptField_Point mPoints; + private ScriptC_Fountain mScript; private RenderScriptGL mRS; - private Allocation mIntAlloc; private SimpleMesh mSM; - private SomeData mSD; - private Type mSDType; private void initRS() { - mSD = new SomeData(); - mSDType = Type.createFromClass(mRS, SomeData.class, 1, "SomeData"); - mIntAlloc = Allocation.createTyped(mRS, mSDType); - mSD.count = PART_COUNT; - mIntAlloc.data(mSD); - - Element.Builder eb = new Element.Builder(mRS); - eb.add(Element.createVector(mRS, Element.DataType.FLOAT_32, 2), "delta"); - eb.add(Element.createAttrib(mRS, Element.DataType.FLOAT_32, Element.DataKind.POSITION, 2), "position"); - eb.add(Element.createAttrib(mRS, Element.DataType.UNSIGNED_8, Element.DataKind.COLOR, 4), "color"); - Element primElement = eb.create(); - + mPoints = new ScriptField_Point(mRS, PART_COUNT); SimpleMesh.Builder smb = new SimpleMesh.Builder(mRS); - int vtxSlot = smb.addVertexType(primElement, PART_COUNT); + int vtxSlot = smb.addVertexType(mPoints.getType()); smb.setPrimitive(Primitive.POINT); mSM = smb.create(); - mSM.setName("PartMesh"); - - Allocation partAlloc = mSM.createVertexAllocation(vtxSlot); - partAlloc.setName("PartBuffer"); - mSM.bindVertexAllocation(partAlloc, 0); - - // All setup of named objects should be done by this point - // because we are about to compile the script. - ScriptC.Builder sb = new ScriptC.Builder(mRS); - sb.setScript(mRes, R.raw.fountain); - sb.setRoot(true); - sb.setType(mSDType, "Control", 0); - sb.setType(mSM.getVertexType(0), "point", 1); - Script script = sb.create(); - script.setClearColor(0.0f, 0.0f, 0.0f, 1.0f); - - script.bindAllocation(mIntAlloc, 0); - script.bindAllocation(partAlloc, 1); - mRS.contextBindRootScript(script); + mSM.bindVertexAllocation(mPoints.getAllocation(), vtxSlot); + + mScript = new ScriptC_Fountain(mRS, mRes, true); + mScript.setClearColor(0.0f, 0.0f, 0.0f, 1.0f); + mScript.set_partMesh(mSM); + mScript.set_partBuffer(mPoints.getAllocation()); + mScript.bind_point(mPoints); + mRS.contextBindRootScript(mScript); } } diff --git a/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java b/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java new file mode 100644 index 00000000..7cff390c --- /dev/null +++ b/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java @@ -0,0 +1,49 @@ + +package com.android.fountain; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +public class ScriptC_Fountain + extends android.renderscript.ScriptC +{ + public ScriptC_Fountain(RenderScript rs, Resources resources, boolean isRoot) { + super(rs, resources, R.raw.fountain_bc, isRoot); + } + + public void set_partColor(Float4 v) { + FieldPacker fp = new FieldPacker(16); + fp.addF32(v); + setVar(0, fp); + } + public void set_partMesh(SimpleMesh v) { + setVar(1, v.getID()); + } + public void set_partBuffer(Allocation v) { + setVar(2, v.getID()); + } + + private ScriptField_Point mField_point; + public void bind_point(ScriptField_Point f) { + mField_point = f; + if (f == null) { + bindAllocation(null, 3); + } else { + bindAllocation(f.getAllocation(), 3); + } + } + public ScriptField_Point get_point() { + return mField_point; + } + + + public void invokable_addParticles(int count, int x, int y) { + FieldPacker fp = new FieldPacker(12); + fp.addI32(count); + fp.addI32(x); + fp.addI32(y); + invokeV(0, fp); + } +} + diff --git a/java/Fountain/src/com/android/fountain/ScriptField_Point.java b/java/Fountain/src/com/android/fountain/ScriptField_Point.java new file mode 100644 index 00000000..edd18d58 --- /dev/null +++ b/java/Fountain/src/com/android/fountain/ScriptField_Point.java @@ -0,0 +1,67 @@ + +package com.android.fountain; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +public class ScriptField_Point + extends android.renderscript.Script.FieldBase +{ + + static public class Item { + Item() { + delta = new Float2(); + pos = new Float2(); + color = new Short4(); + } + + public static final int sizeof = (5*4); + Float2 delta; + Float2 pos; + Short4 color; + } + private Item mItemArray[]; + + + public ScriptField_Point(RenderScript rs, int count) { + // Allocate a pack/unpack buffer + mIOBuffer = new FieldPacker(Item.sizeof * count); + mItemArray = new Item[count]; + + Element.Builder eb = new Element.Builder(rs); + eb.add(Element.createVector(rs, Element.DataType.FLOAT_32, 2), "delta"); + eb.add(Element.createAttrib(rs, Element.DataType.FLOAT_32, Element.DataKind.POSITION, 2), "pos"); + eb.add(Element.createAttrib(rs, Element.DataType.UNSIGNED_8, Element.DataKind.COLOR, 4), "color"); + mElement = eb.create(); + + init(rs, count); + } + + private void copyToArray(Item i, int index) { + mIOBuffer.reset(index * Item.sizeof); + mIOBuffer.addF32(i.delta); + mIOBuffer.addF32(i.pos); + mIOBuffer.addU8(i.color); + } + + public void set(Item i, int index, boolean copyNow) { + mItemArray[index] = i; + if (copyNow) { + copyToArray(i, index); + mAllocation.subData1D(index * Item.sizeof, Item.sizeof, mIOBuffer.getData()); + } + } + + public void copyAll() { + for (int ct=0; ct < mItemArray.length; ct++) { + copyToArray(mItemArray[ct], ct); + } + mAllocation.data(mIOBuffer.getData()); + } + + + private FieldPacker mIOBuffer; + + +} diff --git a/java/ImageProcessing/res/raw/threshold.rs b/java/ImageProcessing/res/raw/threshold.rs index 888f0cdb..8dc614e2 100644 --- a/java/ImageProcessing/res/raw/threshold.rs +++ b/java/ImageProcessing/res/raw/threshold.rs @@ -1,62 +1,49 @@ -/* -// block of defines matching what RS will insert at runtime. -struct Params_s{ - int inHeight; - int inWidth; - int outHeight; - int outWidth; - float threshold; -}; -struct Params_s * Params; -struct InPixel_s{ - char a; - char b; - char g; - char r; -}; -struct InPixel_s * InPixel; -struct OutPixel_s{ - char a; - char b; - char g; - char r; -}; -struct OutPixel_s * OutPixel; -*/ - -struct color_s { - char b; - char g; - char r; - char a; -}; - -void main() { - int t = uptimeMillis(); - - struct color_s *in = (struct color_s *) InPixel; - struct color_s *out = (struct color_s *) OutPixel; - - int count = Params->inWidth * Params->inHeight; - int i; - float threshold = (Params->threshold * 255.f); - - for (i = 0; i < count; i++) { - float luminance = 0.2125f * in->r + - 0.7154f * in->g + - 0.0721f * in->b; - if (luminance > threshold) { - *out = *in; - } else { - *((int *)out) = *((int *)in) & 0xff000000; - } - +#pragma version(1) + +#include "../../../../scriptc/rs_types.rsh" +#include "../../../../scriptc/rs_math.rsh" +#include "../../../../scriptc/rs_graphics.rsh" + +int height; +int width; +float threshold; + +typedef struct c4u_s { + char r, g, b, a; +} c4u_t; + +//rs_color4u * InPixel; +//rs_color4u * OutPixel; +c4u_t * InPixel; +c4u_t * OutPixel; + +#pragma rs export_var(height, width, threshold, InPixel, OutPixel) + +void filter() { + debugP(0, (void *)height); + debugP(0, (void *)width); + debugP(0, (void *)((int)threshold)); + debugP(0, (void *)InPixel); + debugP(0, (void *)OutPixel); + + rs_color4u *in = (rs_color4u *)InPixel; + rs_color4u *out = (rs_color4u *)OutPixel; + //const rs_color4u mask = {0,0,0,0xff}; + + int count = width * height; + int tf = threshold * 255 * 255; + int masks[2] = {0xffffffff, 0xff000000}; + + while (count--) { + int luminance = 54 * in->x + + 182 * in->y + + 18 * in->z; + int idx = ((uint32_t)(luminance - tf)) >> 31; + *((int *)out) = *((int *)in) & masks[idx]; in++; out++; } - t= uptimeMillis() - t; - debugI32("Filter time", t); - sendToClient(&count, 1, 4, 0); } + diff --git a/java/ImageProcessing/res/raw/threshold2.rs b/java/ImageProcessing/res/raw/threshold2.rs deleted file mode 100644 index 9f687b5e..00000000 --- a/java/ImageProcessing/res/raw/threshold2.rs +++ /dev/null @@ -1,49 +0,0 @@ -#pragma version(1) - -#include "../../../../scriptc/rs_types.rsh" -#include "../../../../scriptc/rs_math.rsh" -#include "../../../../scriptc/rs_graphics.rsh" - -typedef struct Params_s{ - int inHeight; - int inWidth; - int outHeight; - int outWidth; - float threshold; -} Params_t; - -Params_t * Params; -rs_color4u * InPixel; -rs_color4u * OutPixel; - - -int main() { - int t = uptimeMillis(); - - rs_color4u *in = InPixel; - rs_color4u *out = OutPixel; - - int count = Params->inWidth * Params->inHeight; - int i; - float threshold = Params->threshold * 255.f; - - for (i = 0; i < count; i++) { - float luminance = 0.2125f * in->x + - 0.7154f * in->y + - 0.0721f * in->z; - if (luminance > threshold) { - *out = *in; - } else { - *((int *)out) = *((int *)in) & 0xff000000; - } - - in++; - out++; - } - - t= uptimeMillis() - t; - debugI32("Filter time", t); - - sendToClient(&count, 1, 4, 0); - return 0; -} diff --git a/java/ImageProcessing/res/raw/threshold_bc.bc b/java/ImageProcessing/res/raw/threshold_bc.bc Binary files differnew file mode 100644 index 00000000..55d514cd --- /dev/null +++ b/java/ImageProcessing/res/raw/threshold_bc.bc diff --git a/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java index 9ce53d81..aec5e23c 100644 --- a/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java +++ b/java/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java @@ -34,19 +34,14 @@ import android.widget.SeekBar; import java.lang.Math; public class ImageProcessingActivity extends Activity implements SurfaceHolder.Callback { - private Bitmap mBitmap; - private Params mParams; - private Script.Invokable mInvokable; - private int[] mInData; - private int[] mOutData; + private Bitmap mBitmapIn; + private Bitmap mBitmapOut; + private ScriptC_Threshold mScript; + private float mThreshold = 0.5f; @SuppressWarnings({"FieldCanBeLocal"}) private RenderScript mRS; @SuppressWarnings({"FieldCanBeLocal"}) - private Type mParamsType; - @SuppressWarnings({"FieldCanBeLocal"}) - private Allocation mParamsAllocation; - @SuppressWarnings({"FieldCanBeLocal"}) private Type mPixelType; @SuppressWarnings({"FieldCanBeLocal"}) private Allocation mInPixelsAllocation; @@ -56,28 +51,9 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C private SurfaceView mSurfaceView; private ImageView mDisplayView; - static class Params { - public int inWidth; - public int outWidth; - public int inHeight; - public int outHeight; - - public float threshold; - } - - static class Pixel { - public byte a; - public byte r; - public byte g; - public byte b; - } - class FilterCallback extends RenderScript.RSMessage { private Runnable mAction = new Runnable() { public void run() { - mOutPixelsAllocation.readData(mOutData); - mBitmap.setPixels(mOutData, 0, mParams.outWidth, 0, 0, - mParams.outWidth, mParams.outHeight); mDisplayView.invalidate(); } }; @@ -89,29 +65,35 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C } } + int in[]; + int out[]; private void javaFilter() { - long t = java.lang.System.currentTimeMillis(); - int count = mParams.inWidth * mParams.inHeight; - float threshold = mParams.threshold * 255.f; + final int w = mBitmapIn.getWidth(); + final int h = mBitmapIn.getHeight(); + final int count = w * h; + + if (in == null) { + in = new int[count]; + out = new int[count]; + mBitmapIn.getPixels(in, 0, w, 0, 0, w, h); + } - for (int i = 0; i < count; i++) { - final float r = (float)((mInData[i] >> 0) & 0xff); - final float g = (float)((mInData[i] >> 8) & 0xff); - final float b = (float)((mInData[i] >> 16) & 0xff); + int threshold = (int)(mThreshold * 255.f) * 255; + //long t = java.lang.System.currentTimeMillis(); - final float luminance = 0.2125f * r + - 0.7154f * g + - 0.0721f * b; + for (int i = 0; i < count; i++) { + final int luminance = 54 * ((in[i] >> 0) & 0xff) + + 182* ((in[i] >> 8) & 0xff) + + 18 * ((in[i] >> 16) & 0xff); if (luminance > threshold) { - mOutData[i] = mInData[i]; + out[i] = in[i]; } else { - mOutData[i] = mInData[i] & 0xff000000; + out[i] = in[i] & 0xff000000; } } - - t = java.lang.System.currentTimeMillis() - t; - - android.util.Log.v("Img", "frame time ms " + t); + //t = java.lang.System.currentTimeMillis() - t; + //android.util.Log.v("Img", "frame time ms " + t); + mBitmapOut.setPixels(out, 0, w, 0, 0, w, h); } @Override @@ -119,29 +101,31 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C super.onCreate(savedInstanceState); setContentView(R.layout.main); - mBitmap = loadBitmap(R.drawable.data); + mBitmapIn = loadBitmap(R.drawable.data); + mBitmapOut = loadBitmap(R.drawable.data); mSurfaceView = (SurfaceView) findViewById(R.id.surface); mSurfaceView.getHolder().addCallback(this); mDisplayView = (ImageView) findViewById(R.id.display); - mDisplayView.setImageBitmap(mBitmap); + mDisplayView.setImageBitmap(mBitmapOut); ((SeekBar) findViewById(R.id.threshold)).setOnSeekBarChangeListener( new SeekBar.OnSeekBarChangeListener() { public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { if (fromUser) { - mParams.threshold = progress / 100.0f; - mParamsAllocation.data(mParams); + mThreshold = progress / 100.0f; + mScript.set_threshold(mThreshold); + long t = java.lang.System.currentTimeMillis(); if (true) { - mInvokable.execute(); + mScript.invokable_Filter(); } else { javaFilter(); - mBitmap.setPixels(mOutData, 0, mParams.outWidth, 0, 0, - mParams.outWidth, mParams.outHeight); mDisplayView.invalidate(); } + t = java.lang.System.currentTimeMillis() - t; + android.util.Log.v("Img", "frame time core ms " + t); } } @@ -154,10 +138,8 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C } public void surfaceCreated(SurfaceHolder holder) { - mParams = createParams(); - mInvokable = createScript(); - - mInvokable.execute(); + createScript(); + mScript.invokable_Filter(); } public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { @@ -166,54 +148,19 @@ public class ImageProcessingActivity extends Activity implements SurfaceHolder.C public void surfaceDestroyed(SurfaceHolder holder) { } - private Script.Invokable createScript() { + private void createScript() { mRS = RenderScript.create(); mRS.mMessageCallback = new FilterCallback(); - mParamsType = Type.createFromClass(mRS, Params.class, 1, "Parameters"); - mParamsAllocation = Allocation.createTyped(mRS, mParamsType); - mParamsAllocation.data(mParams); - - final int pixelCount = mParams.inWidth * mParams.inHeight; - - mPixelType = Type.createFromClass(mRS, Pixel.class, 1, "Pixel"); - mInPixelsAllocation = Allocation.createSized(mRS, - Element.createUser(mRS, Element.DataType.SIGNED_32), - pixelCount); - mOutPixelsAllocation = Allocation.createSized(mRS, - Element.createUser(mRS, Element.DataType.SIGNED_32), - pixelCount); - - mInData = new int[pixelCount]; - mBitmap.getPixels(mInData, 0, mParams.inWidth, 0, 0, mParams.inWidth, mParams.inHeight); - mInPixelsAllocation.data(mInData); - - mOutData = new int[pixelCount]; - mOutPixelsAllocation.data(mOutData); - - ScriptC.Builder sb = new ScriptC.Builder(mRS); - sb.setType(mParamsType, "Params", 0); - sb.setType(mPixelType, "InPixel", 1); - sb.setType(mPixelType, "OutPixel", 2); - sb.setType(true, 2); - Script.Invokable invokable = sb.addInvokable("main"); - sb.setScript(getResources(), R.raw.threshold); - //sb.setRoot(true); - - ScriptC script = sb.create(); - script.bindAllocation(mParamsAllocation, 0); - script.bindAllocation(mInPixelsAllocation, 1); - script.bindAllocation(mOutPixelsAllocation, 2); - - return invokable; - } + mInPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapIn); + mOutPixelsAllocation = Allocation.createBitmapRef(mRS, mBitmapOut); - private Params createParams() { - final Params params = new Params(); - params.inWidth = params.outWidth = mBitmap.getWidth(); - params.inHeight = params.outHeight = mBitmap.getHeight(); - params.threshold = 0.5f; - return params; + mScript = new ScriptC_Threshold(mRS, getResources(), false); + mScript.set_width(mBitmapIn.getWidth()); + mScript.set_height(mBitmapIn.getHeight()); + mScript.set_threshold(mThreshold); + mScript.bind_InPixel(mInPixelsAllocation); + mScript.bind_OutPixel(mOutPixelsAllocation); } private Bitmap loadBitmap(int resource) { diff --git a/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java b/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java new file mode 100644 index 00000000..dbaa18c2 --- /dev/null +++ b/java/ImageProcessing/src/com/android/rs/image/ScriptC_Threshold.java @@ -0,0 +1,67 @@ + +package com.android.rs.image; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +public class ScriptC_Threshold + extends android.renderscript.ScriptC +{ + private final static int mFieldIndex_height = 0; + private final static int mFieldIndex_width = 1; + private final static int mFieldIndex_threshold = 2; + private final static int mFieldIndex_InPixel = 3; + private final static int mFieldIndex_OutPixel = 4; + + private Allocation mField_InPixel; + private Allocation mField_OutPixel; + + public ScriptC_Threshold(RenderScript rs, Resources resources, boolean isRoot) { + super(rs, resources, R.raw.threshold_bc, isRoot); + } + + public void bind_InPixel(Allocation f) { + if (f != null) { + //if (f.getType().getElement() != Element.ATTRIB_COLOR_U8_4(mRS)) { + //throw new IllegalArgumentException("Element type mismatch."); + //} + } + bindAllocation(f, mFieldIndex_InPixel); + mField_InPixel = f; + } + public Allocation get_InPixel() { + return mField_InPixel; + } + + public void bind_OutPixel(Allocation f) { + if (f != null) { + //if (f.getType().getElement() != Element.ATTRIB_COLOR_U8_4(mRS)) { + //throw new IllegalArgumentException("Element type mismatch."); + //} + } + bindAllocation(f, mFieldIndex_OutPixel); + mField_OutPixel = f; + } + public Allocation get_OutPixel() { + return mField_OutPixel; + } + + public void set_height(int v) { + setVar(mFieldIndex_height, v); + } + + public void set_width(int v) { + setVar(mFieldIndex_width, v); + } + + public void set_threshold(float v) { + setVar(mFieldIndex_threshold, v); + } + + private final static int mInvokableIndex_Filter = 0; + public void invokable_Filter() { + invokeData(mInvokableIndex_Filter); + } +} + @@ -272,27 +272,51 @@ ScriptSetClearStencil { param uint32_t stencil } -ScriptSetType { - param RsType type + +ScriptInvoke { + param RsScript s param uint32_t slot - param bool isWritable - param const char * name } -ScriptSetInvoke { - param const char * name +ScriptInvokeData { + param RsScript s param uint32_t slot + param void * data } -ScriptInvoke { +ScriptInvokeV { param RsScript s param uint32_t slot + param const void * data + param uint32_t dataLen + handcodeApi + togglePlay } ScriptSetRoot { param bool isRoot } +ScriptSetVarI { + param RsScript s + param uint32_t slot + param int value + } + +ScriptSetVarF { + param RsScript s + param uint32_t slot + param float value + } + +ScriptSetVarV { + param RsScript s + param uint32_t slot + param const void * data + param uint32_t dataLen + handcodeApi + togglePlay + } ScriptCSetScript { diff --git a/rsContext.cpp b/rsContext.cpp index 4107229d..017500ba 100644 --- a/rsContext.cpp +++ b/rsContext.cpp @@ -154,7 +154,6 @@ void Context::checkError(const char *msg) const uint32_t Context::runRootScript() { timerSet(RS_TIMER_CLEAR_SWAP); - rsAssert(mRootScript->mEnviroment.mIsRoot); eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth); eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight); @@ -640,28 +639,6 @@ void Context::removeName(ObjectBase *obj) } } -ObjectBase * Context::lookupName(const char *name) const -{ - for(size_t ct=0; ct < mNames.size(); ct++) { - if (!strcmp(name, mNames[ct]->getName())) { - return mNames[ct]; - } - } - return NULL; -} - -void Context::appendNameDefines(String8 *str) const -{ - char buf[256]; - for (size_t ct=0; ct < mNames.size(); ct++) { - str->append("#define NAMED_"); - str->append(mNames[ct]->getName()); - str->append(" "); - sprintf(buf, "%i\n", (int)mNames[ct]); - str->append(buf); - } -} - bool Context::objDestroyOOBInit() { if (!mObjDestroy.mMutex.init()) { diff --git a/rsContext.h b/rsContext.h index 8e755a90..8249f5b8 100644 --- a/rsContext.h +++ b/rsContext.h @@ -104,8 +104,6 @@ public: void assignName(ObjectBase *obj, const char *name, uint32_t len); void removeName(ObjectBase *obj); - ObjectBase * lookupName(const char *name) const; - void appendNameDefines(String8 *str) const; uint32_t getMessageToClient(void *data, size_t *receiveLen, size_t bufferLen, bool wait); bool sendMessageToClient(void *data, uint32_t cmdID, size_t len, bool waitForSpace); diff --git a/rsHandcode.h b/rsHandcode.h index 800eddde..f6e56aca 100644 --- a/rsHandcode.h +++ b/rsHandcode.h @@ -1,6 +1,49 @@ #define DATA_SYNC_SIZE 1024 +static inline void rsHCAPI_ScriptInvokeV (RsContext rsc, RsScript va, uint32_t slot, const void * data, uint32_t sizeBytes) +{ + ThreadIO *io = &((Context *)rsc)->mIO; + uint32_t size = sizeof(RS_CMD_ScriptInvokeV); + if (sizeBytes < DATA_SYNC_SIZE) { + size += (sizeBytes + 3) & ~3; + } + RS_CMD_ScriptInvokeV *cmd = static_cast<RS_CMD_ScriptInvokeV *>(io->mToCore.reserve(size)); + cmd->s = va; + cmd->slot = slot; + cmd->dataLen = sizeBytes; + cmd->data = data; + if (sizeBytes < DATA_SYNC_SIZE) { + cmd->data = (void *)(cmd+1); + memcpy(cmd+1, data, sizeBytes); + io->mToCore.commit(RS_CMD_ID_ScriptInvokeV, size); + } else { + io->mToCore.commitSync(RS_CMD_ID_ScriptInvokeV, size); + } +} + + +static inline void rsHCAPI_ScriptSetVarV (RsContext rsc, RsScript va, uint32_t slot, const void * data, uint32_t sizeBytes) +{ + ThreadIO *io = &((Context *)rsc)->mIO; + uint32_t size = sizeof(RS_CMD_ScriptSetVarV); + if (sizeBytes < DATA_SYNC_SIZE) { + size += (sizeBytes + 3) & ~3; + } + RS_CMD_ScriptSetVarV *cmd = static_cast<RS_CMD_ScriptSetVarV *>(io->mToCore.reserve(size)); + cmd->s = va; + cmd->slot = slot; + cmd->dataLen = sizeBytes; + cmd->data = data; + if (sizeBytes < DATA_SYNC_SIZE) { + cmd->data = (void *)(cmd+1); + memcpy(cmd+1, data, sizeBytes); + io->mToCore.commit(RS_CMD_ID_ScriptSetVarV, size); + } else { + io->mToCore.commitSync(RS_CMD_ID_ScriptSetVarV, size); + } +} + static inline void rsHCAPI_AllocationData (RsContext rsc, RsAllocation va, const void * data, uint32_t sizeBytes) { ThreadIO *io = &((Context *)rsc)->mIO; diff --git a/rsProgramFragment.cpp b/rsProgramFragment.cpp index c17b94c1..d192195e 100644 --- a/rsProgramFragment.cpp +++ b/rsProgramFragment.cpp @@ -328,6 +328,7 @@ RsProgramFragment rsi_ProgramFragmentCreate(Context *rsc, { ProgramFragment *pf = new ProgramFragment(rsc, params, paramLength); pf->incUserRef(); + LOGE("rsi_ProgramFragmentCreate %p", pf); return pf; } @@ -337,6 +338,7 @@ RsProgramFragment rsi_ProgramFragmentCreate2(Context *rsc, const char * shaderTe { ProgramFragment *pf = new ProgramFragment(rsc, shaderText, shaderLength, params, paramLength); pf->incUserRef(); + LOGE("rsi_ProgramFragmentCreate2 %p", pf); return pf; } diff --git a/rsScript.cpp b/rsScript.cpp index a33933b6..1c63c115 100644 --- a/rsScript.cpp +++ b/rsScript.cpp @@ -30,13 +30,25 @@ Script::Script(Context *rsc) : ObjectBase(rsc) mEnviroment.mClearColor[3] = 1; mEnviroment.mClearDepth = 1; mEnviroment.mClearStencil = 0; - mEnviroment.mIsRoot = false; } Script::~Script() { } +void Script::setVar(uint32_t slot, const void *val, uint32_t len) +{ + int32_t *destPtr = ((int32_t **)mEnviroment.mFieldAddress)[slot]; + if (destPtr) { + //LOGE("setVar f1 %f", ((const float *)destPtr)[0]); + //LOGE("setVar %p %i", destPtr, len); + memcpy(destPtr, val, len); + //LOGE("setVar f2 %f", ((const float *)destPtr)[0]); + } else { + LOGE("Calling setVar on slot = %i which is null", slot); + } +} + namespace android { namespace renderscript { @@ -44,7 +56,9 @@ namespace renderscript { void rsi_ScriptBindAllocation(Context * rsc, RsScript vs, RsAllocation va, uint32_t slot) { Script *s = static_cast<Script *>(vs); - s->mSlots[slot].set(static_cast<Allocation *>(va)); + Allocation *a = static_cast<Allocation *>(va); + s->mSlots[slot].set(a); + //LOGE("rsi_ScriptBindAllocation %i %p %p", slot, a, a->getPtr()); } void rsi_ScriptSetClearColor(Context * rsc, RsScript vs, float r, float g, float b, float a) @@ -80,35 +94,111 @@ void rsi_ScriptSetType(Context * rsc, RsType vt, uint32_t slot, bool writable, c const Type *t = static_cast<const Type *>(vt); ss->mConstantBufferTypes[slot].set(t); ss->mSlotWritable[slot] = writable; - if (name) { - ss->mSlotNames[slot].setTo(name); - } else { - ss->mSlotNames[slot].setTo(""); - } + LOGE("rsi_ScriptSetType"); } void rsi_ScriptSetInvoke(Context *rsc, const char *name, uint32_t slot) { - ScriptCState *ss = &rsc->mScriptC; - ss->mInvokableNames[slot] = name; + LOGE("rsi_ScriptSetInvoke"); } + void rsi_ScriptInvoke(Context *rsc, RsScript vs, uint32_t slot) { + //LOGE("rsi_ScriptInvoke %i", slot); Script *s = static_cast<Script *>(vs); - if (s->mEnviroment.mInvokables[slot] == NULL) { + if ((slot >= s->mEnviroment.mInvokeFunctionCount) || + (s->mEnviroment.mInvokeFunctions[slot] == NULL)) { rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script"); return; } s->setupScript(); - s->mEnviroment.mInvokables[slot](); + //LOGE("invoking %i %p", slot, s->mEnviroment.mInvokeFunctions[slot]); + s->mEnviroment.mInvokeFunctions[slot](); + //LOGE("invoke finished"); } +void rsi_ScriptInvokeData(Context *rsc, RsScript vs, uint32_t slot, void *data) +{ + //LOGE("rsi_ScriptInvoke %i", slot); + Script *s = static_cast<Script *>(vs); + if ((slot >= s->mEnviroment.mInvokeFunctionCount) || + (s->mEnviroment.mInvokeFunctions[slot] == NULL)) { + rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script"); + return; + } + s->setupScript(); + //LOGE("invoking %i %p", slot, s->mEnviroment.mInvokeFunctions[slot]); + s->mEnviroment.mInvokeFunctions[slot](); + //LOGE("invoke finished"); +} + +void rsi_ScriptInvokeV(Context *rsc, RsScript vs, uint32_t slot, const void *data, uint32_t len) +{ + //LOGE("rsi_ScriptInvoke %i", slot); + Script *s = static_cast<Script *>(vs); + if ((slot >= s->mEnviroment.mInvokeFunctionCount) || + (s->mEnviroment.mInvokeFunctions[slot] == NULL)) { + rsc->setError(RS_ERROR_BAD_SCRIPT, "Calling invoke on bad script"); + return; + } + s->setupScript(); + + LOGE("rsi_ScriptInvokeV, len=%i", len); + const uint32_t * dPtr = (const uint32_t *)data; + switch(len) { + case 0: + s->mEnviroment.mInvokeFunctions[slot](); + break; + case 4: + ((void (*)(uint32_t)) + s->mEnviroment.mInvokeFunctions[slot])(dPtr[0]); + break; + case 8: + ((void (*)(uint32_t, uint32_t)) + s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1]); + break; + case 12: + ((void (*)(uint32_t, uint32_t, uint32_t)) + s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2]); + break; + case 16: + ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t)) + s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3]); + break; + case 20: + ((void (*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)) + s->mEnviroment.mInvokeFunctions[slot])(dPtr[0], dPtr[1], dPtr[2], dPtr[3], dPtr[4]); + break; + + + } + +} + void rsi_ScriptSetRoot(Context * rsc, bool isRoot) { - ScriptCState *ss = &rsc->mScriptC; - ss->mScript->mEnviroment.mIsRoot = isRoot; + LOGE("rsi_ScriptSetRoot"); +} + +void rsi_ScriptSetVarI(Context *rsc, RsScript vs, uint32_t slot, int value) +{ + Script *s = static_cast<Script *>(vs); + s->setVar(slot, &value, sizeof(value)); +} + +void rsi_ScriptSetVarF(Context *rsc, RsScript vs, uint32_t slot, float value) +{ + Script *s = static_cast<Script *>(vs); + s->setVar(slot, &value, sizeof(value)); +} + +void rsi_ScriptSetVarV(Context *rsc, RsScript vs, uint32_t slot, const void *data, uint32_t len) +{ + const float *fp = (const float *)data; + Script *s = static_cast<Script *>(vs); + s->setVar(slot, data, len); } @@ -29,7 +29,7 @@ class ProgramFragment; class ProgramRaster; class ProgramFragmentStore; -#define MAX_SCRIPT_BANKS 16 +#define MAX_SCRIPT_BANKS 32 class Script : public ObjectBase { @@ -39,9 +39,7 @@ public: Script(Context *); virtual ~Script(); - struct Enviroment_t { - bool mIsRoot; float mClearColor[4]; float mClearDepth; uint32_t mClearStencil; @@ -53,21 +51,22 @@ public: ObjectBaseRef<ProgramFragment> mFragment; ObjectBaseRef<ProgramRaster> mRaster; ObjectBaseRef<ProgramFragmentStore> mFragmentStore; - InvokeFunc_t mInvokables[MAX_SCRIPT_BANKS]; + + uint32_t mInvokeFunctionCount; + InvokeFunc_t *mInvokeFunctions; + uint32_t mFieldCount; + void ** mFieldAddress; + char * mScriptText; uint32_t mScriptTextLength; }; Enviroment_t mEnviroment; - uint32_t mCounstantBufferCount; - - ObjectBaseRef<Allocation> mSlots[MAX_SCRIPT_BANKS]; ObjectBaseRef<const Type> mTypes[MAX_SCRIPT_BANKS]; - String8 mSlotNames[MAX_SCRIPT_BANKS]; bool mSlotWritable[MAX_SCRIPT_BANKS]; - + void setVar(uint32_t slot, const void *val, uint32_t len); virtual void setupScript() = 0; virtual uint32_t run(Context *, uint32_t launchID) = 0; diff --git a/rsScriptC.cpp b/rsScriptC.cpp index 1f237730..45c30522 100644 --- a/rsScriptC.cpp +++ b/rsScriptC.cpp @@ -17,8 +17,7 @@ #include "rsContext.h" #include "rsScriptC.h" #include "rsMatrix.h" - -#include "acc/acc.h" +#include "../../../external/llvm/libbcc/include/bcc/bcc.h" #include "utils/Timers.h" #include <GLES/gl.h> @@ -37,14 +36,14 @@ ScriptC::ScriptC(Context *rsc) : Script(rsc) { mAllocFile = __FILE__; mAllocLine = __LINE__; - mAccScript = NULL; + mBccScript = NULL; memset(&mProgram, 0, sizeof(mProgram)); } ScriptC::~ScriptC() { - if (mAccScript) { - accDeleteScript(mAccScript); + if (mBccScript) { + bccDeleteScript(mBccScript); } free(mEnviroment.mScriptText); mEnviroment.mScriptText = NULL; @@ -52,9 +51,22 @@ ScriptC::~ScriptC() void ScriptC::setupScript() { - for (int ct=0; ct < MAX_SCRIPT_BANKS; ct++) { - if (mProgram.mSlotPointers[ct]) { - *mProgram.mSlotPointers[ct] = mSlots[ct]->getPtr(); + for (uint32_t ct=0; ct < mEnviroment.mFieldCount; ct++) { + if (!mSlots[ct].get()) + continue; + void *ptr = mSlots[ct]->getPtr(); + void **dest = ((void ***)mEnviroment.mFieldAddress)[ct]; + //LOGE("setupScript %i %p = %p %p %i", ct, dest, ptr, mSlots[ct]->getType(), mSlots[ct]->getType()->getDimX()); + + //const uint32_t *p32 = (const uint32_t *)ptr; + //for (uint32_t ct2=0; ct2 < mSlots[ct]->getType()->getDimX(); ct2++) { + //LOGE(" %i = 0x%08x ", ct2, p32[ct2]); + //} + + if (dest) { + *dest = ptr; + } else { + LOGE("ScriptC::setupScript, NULL var binding address."); } } } @@ -62,7 +74,7 @@ void ScriptC::setupScript() uint32_t ScriptC::run(Context *rsc, uint32_t launchIndex) { - if (mProgram.mScript == NULL) { + if (mProgram.mRoot == NULL) { rsc->setError(RS_ERROR_BAD_SCRIPT, "Attempted to run bad script"); return 0; } @@ -92,8 +104,10 @@ uint32_t ScriptC::run(Context *rsc, uint32_t launchIndex) uint32_t ret = 0; tls->mScript = this; - ret = mProgram.mScript(launchIndex); + //LOGE("ScriptC::run %p", mProgram.mRoot); + ret = mProgram.mRoot(); tls->mScript = NULL; + //LOGE("ScriptC::run ret %i", ret); return ret; } @@ -113,19 +127,14 @@ void ScriptCState::clear() { for (uint32_t ct=0; ct < MAX_SCRIPT_BANKS; ct++) { mConstantBufferTypes[ct].clear(); - mSlotNames[ct].setTo(""); - mInvokableNames[ct].setTo(""); mSlotWritable[ct] = false; } delete mScript; mScript = new ScriptC(NULL); - - mInt32Defines.clear(); - mFloatDefines.clear(); } -static ACCvoid* symbolLookup(ACCvoid* pContext, const ACCchar* name) +static BCCvoid* symbolLookup(BCCvoid* pContext, const BCCchar* name) { const ScriptCState::SymbolTable_t *sym = ScriptCState::lookupSymbol(name); if (sym) { @@ -137,51 +146,39 @@ static ACCvoid* symbolLookup(ACCvoid* pContext, const ACCchar* name) void ScriptCState::runCompiler(Context *rsc, ScriptC *s) { - s->mAccScript = accCreateScript(); - String8 tmp; - - rsc->appendNameDefines(&tmp); - appendDecls(&tmp); - appendVarDefines(rsc, &tmp); - appendTypes(rsc, &tmp); - tmp.append("#line 1\n"); - - const char* scriptSource[] = {tmp.string(), s->mEnviroment.mScriptText}; - int scriptLength[] = {tmp.length(), s->mEnviroment.mScriptTextLength} ; - accScriptSource(s->mAccScript, sizeof(scriptLength) / sizeof(int), scriptSource, scriptLength); - accRegisterSymbolCallback(s->mAccScript, symbolLookup, NULL); - accCompileScript(s->mAccScript); - accGetScriptLabel(s->mAccScript, "main", (ACCvoid**) &s->mProgram.mScript); - accGetScriptLabel(s->mAccScript, "init", (ACCvoid**) &s->mProgram.mInit); - rsAssert(s->mProgram.mScript); - - if (!s->mProgram.mScript) { - ACCchar buf[4096]; - ACCsizei len; - accGetScriptInfoLog(s->mAccScript, sizeof(buf), &len, buf); - LOGE(buf); - rsc->setError(RS_ERROR_BAD_SCRIPT, "Error compiling user script."); - return; - } + LOGE("ScriptCState::runCompiler "); + + s->mBccScript = bccCreateScript(); + bccScriptBitcode(s->mBccScript, s->mEnviroment.mScriptText, s->mEnviroment.mScriptTextLength); + bccRegisterSymbolCallback(s->mBccScript, symbolLookup, NULL); + LOGE("ScriptCState::runCompiler 3"); + bccCompileScript(s->mBccScript); + LOGE("ScriptCState::runCompiler 4"); + bccGetScriptLabel(s->mBccScript, "root", (BCCvoid**) &s->mProgram.mRoot); + bccGetScriptLabel(s->mBccScript, "init", (BCCvoid**) &s->mProgram.mInit); + LOGE("root %p, init %p", s->mProgram.mRoot, s->mProgram.mInit); if (s->mProgram.mInit) { s->mProgram.mInit(); } - for (int ct=0; ct < MAX_SCRIPT_BANKS; ct++) { - if (mSlotNames[ct].length() > 0) { - accGetScriptLabel(s->mAccScript, - mSlotNames[ct].string(), - (ACCvoid**) &s->mProgram.mSlotPointers[ct]); - } + s->mEnviroment.mInvokeFunctions = (Script::InvokeFunc_t *)calloc(100, sizeof(void *)); + BCCchar **labels = new char*[100]; + bccGetFunctions(s->mBccScript, (BCCsizei *)&s->mEnviroment.mInvokeFunctionCount, + 100, (BCCchar **)labels); + //LOGE("func count %i", s->mEnviroment.mInvokeFunctionCount); + for (uint32_t i=0; i < s->mEnviroment.mInvokeFunctionCount; i++) { + BCCsizei length; + bccGetFunctionBinary(s->mBccScript, labels[i], (BCCvoid **)&(s->mEnviroment.mInvokeFunctions[i]), &length); + //LOGE("func %i %p", i, s->mEnviroment.mInvokeFunctions[i]); } - for (int ct=0; ct < MAX_SCRIPT_BANKS; ct++) { - if (mInvokableNames[ct].length() > 0) { - accGetScriptLabel(s->mAccScript, - mInvokableNames[ct].string(), - (ACCvoid**) &s->mEnviroment.mInvokables[ct]); - } + s->mEnviroment.mFieldAddress = (void **)calloc(100, sizeof(void *)); + bccGetExportVars(s->mBccScript, (BCCsizei *)&s->mEnviroment.mFieldCount, + 100, s->mEnviroment.mFieldAddress); + //LOGE("var count %i", s->mEnviroment.mFieldCount); + for (uint32_t i=0; i < s->mEnviroment.mFieldCount; i++) { + //LOGE("var %i %p", i, s->mEnviroment.mFieldAddress[i]); } s->mEnviroment.mFragment.set(rsc->getDefaultProgramFragment()); @@ -189,11 +186,11 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) s->mEnviroment.mFragmentStore.set(rsc->getDefaultProgramFragmentStore()); s->mEnviroment.mRaster.set(rsc->getDefaultProgramRaster()); - if (s->mProgram.mScript) { + if (s->mProgram.mRoot) { const static int pragmaMax = 16; - ACCsizei pragmaCount; - ACCchar * str[pragmaMax]; - accGetPragmas(s->mAccScript, &pragmaCount, pragmaMax, &str[0]); + BCCsizei pragmaCount; + BCCchar * str[pragmaMax]; + bccGetPragmas(s->mBccScript, &pragmaCount, pragmaMax, &str[0]); for (int ct=0; ct < pragmaCount; ct+=2) { if (!strcmp(str[ct], "version")) { @@ -208,11 +205,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) s->mEnviroment.mVertex.clear(); continue; } - ProgramVertex * pv = (ProgramVertex *)rsc->lookupName(str[ct+1]); - if (pv != NULL) { - s->mEnviroment.mVertex.set(pv); - continue; - } LOGE("Unreconized value %s passed to stateVertex", str[ct+1]); } @@ -224,11 +216,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) s->mEnviroment.mRaster.clear(); continue; } - ProgramRaster * pr = (ProgramRaster *)rsc->lookupName(str[ct+1]); - if (pr != NULL) { - s->mEnviroment.mRaster.set(pr); - continue; - } LOGE("Unreconized value %s passed to stateRaster", str[ct+1]); } @@ -240,11 +227,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) s->mEnviroment.mFragment.clear(); continue; } - ProgramFragment * pf = (ProgramFragment *)rsc->lookupName(str[ct+1]); - if (pf != NULL) { - s->mEnviroment.mFragment.set(pf); - continue; - } LOGE("Unreconized value %s passed to stateFragment", str[ct+1]); } @@ -256,12 +238,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) s->mEnviroment.mFragmentStore.clear(); continue; } - ProgramFragmentStore * pfs = - (ProgramFragmentStore *)rsc->lookupName(str[ct+1]); - if (pfs != NULL) { - s->mEnviroment.mFragmentStore.set(pfs); - continue; - } LOGE("Unreconized value %s passed to stateStore", str[ct+1]); } @@ -273,111 +249,6 @@ void ScriptCState::runCompiler(Context *rsc, ScriptC *s) } } -static void appendElementBody(String8 *s, const Element *e) -{ - s->append(" {\n"); - for (size_t ct2=0; ct2 < e->getFieldCount(); ct2++) { - const Element *c = e->getField(ct2); - s->append(" "); - s->append(c->getCType()); - s->append(" "); - s->append(e->getFieldName(ct2)); - s->append(";\n"); - } - s->append("}"); -} - -void ScriptCState::appendVarDefines(const Context *rsc, String8 *str) -{ - char buf[256]; - if (rsc->props.mLogScripts) { - LOGD("appendVarDefines mInt32Defines.size()=%d mFloatDefines.size()=%d\n", - mInt32Defines.size(), mFloatDefines.size()); - } - for (size_t ct=0; ct < mInt32Defines.size(); ct++) { - str->append("#define "); - str->append(mInt32Defines.keyAt(ct)); - str->append(" "); - sprintf(buf, "%i\n", (int)mInt32Defines.valueAt(ct)); - str->append(buf); - } - for (size_t ct=0; ct < mFloatDefines.size(); ct++) { - str->append("#define "); - str->append(mFloatDefines.keyAt(ct)); - str->append(" "); - sprintf(buf, "%ff\n", mFloatDefines.valueAt(ct)); - str->append(buf); - } -} - - - -void ScriptCState::appendTypes(const Context *rsc, String8 *str) -{ - char buf[256]; - String8 tmp; - - str->append("struct vecF32_2_s {float x; float y;};\n"); - str->append("struct vecF32_3_s {float x; float y; float z;};\n"); - str->append("struct vecF32_4_s {float x; float y; float z; float w;};\n"); - str->append("struct vecU8_4_s {char r; char g; char b; char a;};\n"); - str->append("#define vecF32_2_t struct vecF32_2_s\n"); - str->append("#define vecF32_3_t struct vecF32_3_s\n"); - str->append("#define vecF32_4_t struct vecF32_4_s\n"); - str->append("#define vecU8_4_t struct vecU8_4_s\n"); - str->append("#define vecI8_4_t struct vecU8_4_s\n"); - - for (size_t ct=0; ct < MAX_SCRIPT_BANKS; ct++) { - const Type *t = mConstantBufferTypes[ct].get(); - if (!t) { - continue; - } - const Element *e = t->getElement(); - if (e->getName() && (e->getFieldCount() > 1)) { - String8 s("struct struct_"); - s.append(e->getName()); - s.append(e->getCStructBody()); - s.append(";\n"); - - s.append("#define "); - s.append(e->getName()); - s.append("_t struct struct_"); - s.append(e->getName()); - s.append("\n\n"); - if (rsc->props.mLogScripts) { - LOGV(s); - } - str->append(s); - } - - if (mSlotNames[ct].length() > 0) { - String8 s; - if (e->getName()) { - // Use the named struct - s.setTo(e->getName()); - } else { - // create an struct named from the slot. - s.setTo("struct "); - s.append(mSlotNames[ct]); - s.append("_s"); - s.append(e->getCStructBody()); - //appendElementBody(&s, e); - s.append(";\n"); - s.append("struct "); - s.append(mSlotNames[ct]); - s.append("_s"); - } - - s.append(" * "); - s.append(mSlotNames[ct]); - s.append(";\n"); - if (rsc->props.mLogScripts) { - LOGV(s); - } - str->append(s); - } - } -} namespace android { @@ -420,7 +291,6 @@ RsScript rsi_ScriptCCreate(Context * rsc) s->setContext(rsc); for (int ct=0; ct < MAX_SCRIPT_BANKS; ct++) { s->mTypes[ct].set(ss->mConstantBufferTypes[ct].get()); - s->mSlotNames[ct] = ss->mSlotNames[ct]; s->mSlotWritable[ct] = ss->mSlotWritable[ct]; } @@ -430,14 +300,12 @@ RsScript rsi_ScriptCCreate(Context * rsc) void rsi_ScriptCSetDefineF(Context *rsc, const char* name, float value) { - ScriptCState *ss = &rsc->mScriptC; - ss->mFloatDefines.add(String8(name), value); + LOGE("Error rsi_ScriptCSetDefineF"); } void rsi_ScriptCSetDefineI32(Context *rsc, const char* name, int32_t value) { - ScriptCState *ss = &rsc->mScriptC; - ss->mInt32Defines.add(String8(name), value); + LOGE("Error rsi_ScriptCSetDefineI"); } } diff --git a/rsScriptC.h b/rsScriptC.h index 35abadfd..c23fb731 100644 --- a/rsScriptC.h +++ b/rsScriptC.h @@ -23,7 +23,7 @@ #include <utils/KeyedVector.h> -struct ACCscript; +struct BCCscript; // --------------------------------------------------------------------------- namespace android { @@ -34,7 +34,7 @@ namespace renderscript { class ScriptC : public Script { public: - typedef int (*RunScript_t)(uint32_t launchIndex); + typedef int (*RunScript_t)(); typedef void (*VoidFunc_t)(); ScriptC(Context *); @@ -44,15 +44,13 @@ public: int mVersionMajor; int mVersionMinor; - RunScript_t mScript; + RunScript_t mRoot; VoidFunc_t mInit; - - void ** mSlotPointers[MAX_SCRIPT_BANKS]; }; Program_t mProgram; - ACCscript* mAccScript; + BCCscript* mBccScript; virtual void setupScript(); virtual uint32_t run(Context *, uint32_t launchID); @@ -67,27 +65,19 @@ public: ScriptC *mScript; ObjectBaseRef<const Type> mConstantBufferTypes[MAX_SCRIPT_BANKS]; - String8 mSlotNames[MAX_SCRIPT_BANKS]; + //String8 mSlotNames[MAX_SCRIPT_BANKS]; bool mSlotWritable[MAX_SCRIPT_BANKS]; - String8 mInvokableNames[MAX_SCRIPT_BANKS]; + //String8 mInvokableNames[MAX_SCRIPT_BANKS]; void clear(); void runCompiler(Context *rsc, ScriptC *s); - void appendVarDefines(const Context *rsc, String8 *str); - void appendTypes(const Context *rsc, String8 *str); struct SymbolTable_t { const char * mName; void * mPtr; - const char * mRet; - const char * mParam; }; static SymbolTable_t gSyms[]; static const SymbolTable_t * lookupSymbol(const char *); - static void appendDecls(String8 *str); - - KeyedVector<String8,int> mInt32Defines; - KeyedVector<String8,float> mFloatDefines; }; diff --git a/rsScriptC_Lib.cpp b/rsScriptC_Lib.cpp index 202ca3d4..d94a62cf 100644 --- a/rsScriptC_Lib.cpp +++ b/rsScriptC_Lib.cpp @@ -39,140 +39,194 @@ using namespace android::renderscript; Context * rsc = tls->mContext; \ ScriptC * sc = (ScriptC *) tls->mScript -typedef struct { - float x; - float y; - float z; -} vec3_t; -typedef struct { - float x; - float y; - float z; - float w; -} vec4_t; +static float SC_acospi(float v) { + return acosf(v)/ M_PI; +} -typedef struct { - float x; - float y; -} vec2_t; +static float SC_asinpi(float v) { + return asinf(v) / M_PI; +} -////////////////////////////////////////////////////////////////////////////// -// IO routines -////////////////////////////////////////////////////////////////////////////// +static float SC_atanpi(float v) { + return atanf(v) / M_PI; +} -static float SC_loadF(uint32_t bank, uint32_t offset) -{ - GET_TLS(); - const void *vp = sc->mSlots[bank]->getPtr(); - const float *f = static_cast<const float *>(vp); - //LOGE("loadF %i %i = %f %x", bank, offset, f, ((int *)&f)[0]); - return f[offset]; +static float SC_atan2pi(float y, float x) { + return atan2f(y, x) / M_PI; } -static int32_t SC_loadI32(uint32_t bank, uint32_t offset) -{ - GET_TLS(); - const void *vp = sc->mSlots[bank]->getPtr(); - const int32_t *i = static_cast<const int32_t *>(vp); - //LOGE("loadI32 %i %i = %i", bank, offset, t); - return i[offset]; +static float SC_cospi(float v) { + return cosf(v * M_PI); } -static float* SC_loadArrayF(uint32_t bank, uint32_t offset) -{ - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - float *f = static_cast<float *>(vp); - return f + offset; +static float SC_exp10(float v) { + return pow(10.f, v); + } -static int32_t* SC_loadArrayI32(uint32_t bank, uint32_t offset) -{ - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - int32_t *i = static_cast<int32_t *>(vp); - return i + offset; +static float SC_fract(float v, int *iptr) { + int i = (int)floor(v); + iptr[0] = i; + return fmin(v - i, 0x1.fffffep-1f); } -static float* SC_loadSimpleMeshVerticesF(RsSimpleMesh mesh, uint32_t idx) -{ - SimpleMesh *tm = static_cast<SimpleMesh *>(mesh); - void *vp = tm->mVertexBuffers[idx]->getPtr();; - return static_cast<float *>(vp); +static float SC_log2(float v) { + return log10(v) / log10(2.f); } -static void SC_updateSimpleMesh(RsSimpleMesh mesh) +static float SC_pown(float v, int p) { + return powf(v, (float)p); +} + +static float SC_powr(float v, float p) { + return powf(v, p); +} + +float SC_rootn(float v, int r) { + return pow(v, 1.f / r); +} + +float SC_rsqrt(float v) { + return 1.f / sqrtf(v); +} + +float SC_sincos(float v, float *cosptr) { + *cosptr = cosf(v); + return sinf(v); +} + +static float SC_sinpi(float v) { + return sinf(v * M_PI); +} + +static float SC_tanpi(float v) { + return tanf(v * M_PI); +} + + //{ "logb", (void *)& }, + //{ "mad", (void *)& }, + //{ "nan", (void *)& }, + //{ "tgamma", (void *)& }, + +////////////////////////////////////////////////////////////////////////////// +// Integer +////////////////////////////////////////////////////////////////////////////// + + +static uint32_t SC_abs_i32(int32_t v) {return abs(v);} +static uint16_t SC_abs_i16(int16_t v) {return (uint16_t)abs(v);} +static uint8_t SC_abs_i8(int8_t v) {return (uint8_t)abs(v);} + +static uint32_t SC_clz_u32(uint32_t v) {return __builtin_clz(v);} +static uint16_t SC_clz_u16(uint16_t v) {return (uint16_t)__builtin_clz(v);} +static uint8_t SC_clz_u8(uint8_t v) {return (uint8_t)__builtin_clz(v);} +static int32_t SC_clz_i32(int32_t v) {return (int32_t)__builtin_clz((uint32_t)v);} +static int16_t SC_clz_i16(int16_t v) {return (int16_t)__builtin_clz(v);} +static int8_t SC_clz_i8(int8_t v) {return (int8_t)__builtin_clz(v);} + +static uint32_t SC_max_u32(uint32_t v, uint32_t v2) {return rsMax(v, v2);} +static uint16_t SC_max_u16(uint16_t v, uint16_t v2) {return rsMax(v, v2);} +static uint8_t SC_max_u8(uint8_t v, uint8_t v2) {return rsMax(v, v2);} +static int32_t SC_max_i32(int32_t v, int32_t v2) {return rsMax(v, v2);} +static int16_t SC_max_i16(int16_t v, int16_t v2) {return rsMax(v, v2);} +static int8_t SC_max_i8(int8_t v, int8_t v2) {return rsMax(v, v2);} + +static uint32_t SC_min_u32(uint32_t v, uint32_t v2) {return rsMin(v, v2);} +static uint16_t SC_min_u16(uint16_t v, uint16_t v2) {return rsMin(v, v2);} +static uint8_t SC_min_u8(uint8_t v, uint8_t v2) {return rsMin(v, v2);} +static int32_t SC_min_i32(int32_t v, int32_t v2) {return rsMin(v, v2);} +static int16_t SC_min_i16(int16_t v, int16_t v2) {return rsMin(v, v2);} +static int8_t SC_min_i8(int8_t v, int8_t v2) {return rsMin(v, v2);} + +////////////////////////////////////////////////////////////////////////////// +// Float util +////////////////////////////////////////////////////////////////////////////// + +static float SC_clamp_f32(float amount, float low, float high) { - GET_TLS(); - SimpleMesh *sm = static_cast<SimpleMesh *>(mesh); - sm->uploadAll(rsc); + return amount < low ? low : (amount > high ? high : amount); } -static uint32_t SC_loadU32(uint32_t bank, uint32_t offset) +static float SC_degrees(float radians) { - GET_TLS(); - const void *vp = sc->mSlots[bank]->getPtr(); - const uint32_t *i = static_cast<const uint32_t *>(vp); - return i[offset]; + return radians * (180.f / M_PI); } -static void SC_loadVec4(uint32_t bank, uint32_t offset, rsc_Vector4 *v) +static float SC_max_f32(float v, float v2) { - GET_TLS(); - const void *vp = sc->mSlots[bank]->getPtr(); - const float *f = static_cast<const float *>(vp); - memcpy(v, &f[offset], sizeof(rsc_Vector4)); + return rsMax(v, v2); } -static void SC_loadMatrix(uint32_t bank, uint32_t offset, rsc_Matrix *m) +static float SC_min_f32(float v, float v2) { - GET_TLS(); - const void *vp = sc->mSlots[bank]->getPtr(); - const float *f = static_cast<const float *>(vp); - memcpy(m, &f[offset], sizeof(rsc_Matrix)); + return rsMin(v, v2); } +static float SC_mix_f32(float start, float stop, float amount) +{ + //LOGE("lerpf %f %f %f", start, stop, amount); + return start + (stop - start) * amount; +} -static void SC_storeF(uint32_t bank, uint32_t offset, float v) +static float SC_radians(float degrees) { - //LOGE("storeF %i %i %f", bank, offset, v); - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - float *f = static_cast<float *>(vp); - f[offset] = v; + return degrees * (M_PI / 180.f); } -static void SC_storeI32(uint32_t bank, uint32_t offset, int32_t v) +static float SC_step_f32(float edge, float v) { - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - int32_t *f = static_cast<int32_t *>(vp); - static_cast<int32_t *>(sc->mSlots[bank]->getPtr())[offset] = v; + if (v < edge) return 0.f; + return 1.f; } -static void SC_storeU32(uint32_t bank, uint32_t offset, uint32_t v) +static float SC_sign_f32(float value) { - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - uint32_t *f = static_cast<uint32_t *>(vp); - static_cast<uint32_t *>(sc->mSlots[bank]->getPtr())[offset] = v; + if (value > 0) return 1.f; + if (value < 0) return -1.f; + return value; } -static void SC_storeVec4(uint32_t bank, uint32_t offset, const rsc_Vector4 *v) + + +////////////////////////////////////////////////////////////////////////////// +// 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; + +////////////////////////////////////////////////////////////////////////////// +// IO routines +////////////////////////////////////////////////////////////////////////////// + +static float* SC_loadSimpleMeshVerticesF(RsSimpleMesh mesh, uint32_t idx) { - GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - float *f = static_cast<float *>(vp); - memcpy(&f[offset], v, sizeof(rsc_Vector4)); + SimpleMesh *tm = static_cast<SimpleMesh *>(mesh); + void *vp = tm->mVertexBuffers[idx]->getPtr();; + return static_cast<float *>(vp); } -static void SC_storeMatrix(uint32_t bank, uint32_t offset, const rsc_Matrix *m) +static void SC_updateSimpleMesh(RsSimpleMesh mesh) { GET_TLS(); - void *vp = sc->mSlots[bank]->getPtr(); - float *f = static_cast<float *>(vp); - memcpy(&f[offset], m, sizeof(rsc_Matrix)); + SimpleMesh *sm = static_cast<SimpleMesh *>(mesh); + sm->uploadAll(rsc); } ////////////////////////////////////////////////////////////////////////////// @@ -281,10 +335,6 @@ static void SC_vec4Scale(vec4_t *lhs, float scale) // Math routines ////////////////////////////////////////////////////////////////////////////// -#define PI 3.1415926f -#define DEG_TO_RAD PI / 180.0f -#define RAD_TO_DEG 180.0f / PI - static float SC_sinf_fast(float x) { const float A = 1.0f / (2.0f * M_PI); @@ -325,6 +375,7 @@ static float SC_cosf_fast(float x) static float SC_randf(float max) { + //LOGE("max %f", max); float r = (float)rand(); return r / RAND_MAX * max; } @@ -340,46 +391,11 @@ static int SC_sign(int value) return (value > 0) - (value < 0); } -static float SC_signf(float value) -{ - return (value > 0) - (value < 0); -} - -static float SC_clampf(float amount, float low, float high) -{ - return amount < low ? low : (amount > high ? high : amount); -} - static int SC_clamp(int amount, int low, int high) { return amount < low ? low : (amount > high ? high : amount); } -static float SC_maxf(float a, float b) -{ - return a > b ? a : b; -} - -static float SC_minf(float a, float b) -{ - return a < b ? a : b; -} - -static float SC_sqrf(float v) -{ - return v * v; -} - -static int SC_sqr(int v) -{ - return v * v; -} - -static float SC_fracf(float v) -{ - return v - floorf(v); -} - static float SC_roundf(float v) { return floorf(v + 0.4999999999); @@ -410,21 +426,6 @@ static float SC_magf3(float a, float b, float c) return sqrtf(a * a + b * b + c * c); } -static float SC_radf(float degrees) -{ - return degrees * DEG_TO_RAD; -} - -static float SC_degf(float radians) -{ - return radians * RAD_TO_DEG; -} - -static float SC_lerpf(float start, float stop, float amount) -{ - return start + (stop - start) * amount; -} - static float SC_normf(float start, float stop, float value) { return (value - start) / (stop - start); @@ -435,6 +436,12 @@ static float SC_mapf(float minStart, float minStop, float maxStart, float maxSto return maxStart + (maxStart - maxStop) * ((value - minStart) / (minStop - minStart)); } +static float SC_frac(float v) +{ + int i = (int)floor(v); + return fmin(v - i, 0x1.fffffep-1f); +} + ////////////////////////////////////////////////////////////////////////////// // Time routines ////////////////////////////////////////////////////////////////////////////// @@ -602,12 +609,14 @@ static void SC_matrixTranslate(rsc_Matrix *mat, float x, float y, float z) } -static void SC_vec2Rand(float *vec, float maxLen) +static rsvF_2 SC_vec2Rand(float maxLen) { - float angle = SC_randf(PI * 2); + float2 t; + float angle = SC_randf(M_PI * 2); float len = SC_randf(maxLen); - vec[0] = len * sinf(angle); - vec[1] = len * cosf(angle); + t.f[0] = len * sinf(angle); + t.f[1] = len * cosf(angle); + return t.v; } @@ -829,6 +838,7 @@ static void SC_drawSprite(float x, float y, float z, float w, float h) static void SC_drawRect(float x1, float y1, float x2, float y2, float z) { + //LOGE("SC_drawRect %f,%f %f,%f %f", x1, y1, x2, y2, z); SC_drawQuad(x1, y2, z, x2, y2, z, x2, y1, z, @@ -860,45 +870,54 @@ static void SC_drawSimpleMeshRange(RsSimpleMesh vsm, uint32_t start, uint32_t le // ////////////////////////////////////////////////////////////////////////////// -static void SC_color(float r, float g, float b, float a) +static uint32_t SC_allocGetDimX(RsAllocation va) { GET_TLS(); - rsc->mStateVertex.color[0] = r; - rsc->mStateVertex.color[1] = g; - rsc->mStateVertex.color[2] = b; - rsc->mStateVertex.color[3] = a; - if (!rsc->checkVersion2_0()) { - glColor4f(r, g, b, a); - } + const Allocation *a = static_cast<const Allocation *>(va); + //LOGE("SC_allocGetDimX a=%p", a); + //LOGE(" type=%p", a->getType()); + return a->getType()->getDimX(); } -static void SC_ambient(float r, float g, float b, float a) +static uint32_t SC_allocGetDimY(RsAllocation va) { - GLfloat params[] = { r, g, b, a }; - glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, params); + GET_TLS(); + const Allocation *a = static_cast<const Allocation *>(va); + return a->getType()->getDimY(); } -static void SC_diffuse(float r, float g, float b, float a) +static uint32_t SC_allocGetDimZ(RsAllocation va) { - GLfloat params[] = { r, g, b, a }; - glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, params); + GET_TLS(); + const Allocation *a = static_cast<const Allocation *>(va); + return a->getType()->getDimZ(); } -static void SC_specular(float r, float g, float b, float a) +static uint32_t SC_allocGetDimLOD(RsAllocation va) { - GLfloat params[] = { r, g, b, a }; - glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, params); + GET_TLS(); + const Allocation *a = static_cast<const Allocation *>(va); + return a->getType()->getDimLOD(); } -static void SC_emission(float r, float g, float b, float a) +static uint32_t SC_allocGetDimFaces(RsAllocation va) { - GLfloat params[] = { r, g, b, a }; - glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, params); + GET_TLS(); + const Allocation *a = static_cast<const Allocation *>(va); + return a->getType()->getDimFaces(); } -static void SC_shininess(float s) + +static void SC_color(float r, float g, float b, float a) { - glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, s); + GET_TLS(); + rsc->mStateVertex.color[0] = r; + rsc->mStateVertex.color[1] = g; + rsc->mStateVertex.color[2] = b; + rsc->mStateVertex.color[3] = a; + if (!rsc->checkVersion2_0()) { + glColor4f(r, g, b, a); + } } static void SC_pointAttenuation(float a, float b, float c) @@ -964,8 +983,10 @@ static void SC_hsbToRgb(float h, float s, float b, float* rgb) static int SC_hsbToAbgr(float h, float s, float b, float a) { + //LOGE("hsb a %f, %f, %f %f", h, s, b, a); float rgb[3]; SC_hsbToRgb(h, s, b, rgb); + //LOGE("rgb %f, %f, %f ", rgb[0], rgb[1], rgb[2]); return int(a * 255.0f) << 24 | int(rgb[2] * 255.0f) << 16 | int(rgb[1] * 255.0f) << 8 | @@ -1045,27 +1066,28 @@ static uint32_t SC_getHeight() return rsc->getHeight(); } -static uint32_t SC_colorFloatRGBAtoUNorm8(float r, float g, float b, float a) -{ - uint32_t c = 0; - c |= (uint32_t)(r * 255.f + 0.5f); - c |= ((uint32_t)(g * 255.f + 0.5f)) << 8; - c |= ((uint32_t)(b * 255.f + 0.5f)) << 16; - c |= ((uint32_t)(a * 255.f + 0.5f)) << 24; - return c; +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 uint32_t SC_colorFloatRGBAto565(float r, float g, float b) -{ - uint32_t ir = (uint32_t)(r * 255.f + 0.5f); - uint32_t ig = (uint32_t)(g * 255.f + 0.5f); - uint32_t ib = (uint32_t)(b * 255.f + 0.5f); - return rs888to565(ir, ig, ib); +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(); + //LOGE("SC_toClient %i %i %i", cmdID, len, waitForSpace); return rsc->sendMessageToClient(data, cmdID, len, waitForSpace != 0); } @@ -1075,316 +1097,284 @@ static void SC_scriptCall(int scriptID) rsc->runScript((Script *)scriptID, 0); } +static void SC_debugP(int i, void *p) +{ + LOGE("debug P %i %p, %i", i, p, (int)p); +} + +static void SC_debugPi(int i, int p) +{ + LOGE("debug Pi %i 0x%08x, %i", i, p, (int)p); +} + +static void SC_debugPf(int i, float p) +{ + LOGE("debug Pf %i %f, 0x%08x", i, p, reinterpret_cast<uint32_t *>(&p)[0]); +} + +int SC_divsi3(int a, int b) +{ + return a / b; +} ////////////////////////////////////////////////////////////////////////////// // Class implementation ////////////////////////////////////////////////////////////////////////////// +// llvm name mangling ref +// <builtin-type> ::= v # void +// ::= b # bool +// ::= c # char +// ::= a # signed char +// ::= h # unsigned char +// ::= s # short +// ::= t # unsigned short +// ::= i # int +// ::= j # unsigned int +// ::= l # long +// ::= m # unsigned long +// ::= x # long long, __int64 +// ::= y # unsigned long long, __int64 +// ::= f # float +// ::= d # double + ScriptCState::SymbolTable_t ScriptCState::gSyms[] = { + { "__divsi3", (void *)&SC_divsi3 }, + // IO - { "loadI32", (void *)&SC_loadI32, - "int", "(int, int)" }, - //{ "loadU32", (void *)&SC_loadU32, "unsigned int", "(int, int)" }, - { "loadF", (void *)&SC_loadF, - "float", "(int, int)" }, - { "loadArrayF", (void *)&SC_loadArrayF, - "float*", "(int, int)" }, - { "loadArrayI32", (void *)&SC_loadArrayI32, - "int*", "(int, int)" }, - { "loadVec4", (void *)&SC_loadVec4, - "void", "(int, int, float *)" }, - { "loadMatrix", (void *)&SC_loadMatrix, - "void", "(int, int, float *)" }, - { "storeI32", (void *)&SC_storeI32, - "void", "(int, int, int)" }, - //{ "storeU32", (void *)&SC_storeU32, "void", "(int, int, unsigned int)" }, - { "storeF", (void *)&SC_storeF, - "void", "(int, int, float)" }, - { "storeVec4", (void *)&SC_storeVec4, - "void", "(int, int, float *)" }, - { "storeMatrix", (void *)&SC_storeMatrix, - "void", "(int, int, float *)" }, - { "loadSimpleMeshVerticesF", (void *)&SC_loadSimpleMeshVerticesF, - "float*", "(int, int)" }, - { "updateSimpleMesh", (void *)&SC_updateSimpleMesh, - "void", "(int)" }, - - // math - { "modf", (void *)&fmod, - "float", "(float, float)" }, - { "abs", (void *)&abs, - "int", "(int)" }, - { "absf", (void *)&fabsf, - "float", "(float)" }, - { "sinf_fast", (void *)&SC_sinf_fast, - "float", "(float)" }, - { "cosf_fast", (void *)&SC_cosf_fast, - "float", "(float)" }, - { "sinf", (void *)&sinf, - "float", "(float)" }, - { "cosf", (void *)&cosf, - "float", "(float)" }, - { "asinf", (void *)&asinf, - "float", "(float)" }, - { "acosf", (void *)&acosf, - "float", "(float)" }, - { "atanf", (void *)&atanf, - "float", "(float)" }, - { "atan2f", (void *)&atan2f, - "float", "(float, float)" }, - { "fabsf", (void *)&fabsf, - "float", "(float)" }, - { "randf", (void *)&SC_randf, - "float", "(float)" }, - { "randf2", (void *)&SC_randf2, - "float", "(float, float)" }, - { "floorf", (void *)&floorf, - "float", "(float)" }, - { "fracf", (void *)&SC_fracf, - "float", "(float)" }, - { "ceilf", (void *)&ceilf, - "float", "(float)" }, - { "roundf", (void *)&SC_roundf, - "float", "(float)" }, - { "expf", (void *)&expf, - "float", "(float)" }, - { "logf", (void *)&logf, - "float", "(float)" }, - { "powf", (void *)&powf, - "float", "(float, float)" }, - { "maxf", (void *)&SC_maxf, - "float", "(float, float)" }, - { "minf", (void *)&SC_minf, - "float", "(float, float)" }, - { "sqrt", (void *)&sqrt, - "int", "(int)" }, - { "sqrtf", (void *)&sqrtf, - "float", "(float)" }, - { "sqr", (void *)&SC_sqr, - "int", "(int)" }, - { "sqrf", (void *)&SC_sqrf, - "float", "(float)" }, - { "sign", (void *)&SC_sign, - "int", "(int)" }, - { "signf", (void *)&SC_signf, - "float", "(float)" }, - { "clamp", (void *)&SC_clamp, - "int", "(int, int, int)" }, - { "clampf", (void *)&SC_clampf, - "float", "(float, float, float)" }, - { "distf2", (void *)&SC_distf2, - "float", "(float, float, float, float)" }, - { "distf3", (void *)&SC_distf3, - "float", "(float, float, float, float, float, float)" }, - { "magf2", (void *)&SC_magf2, - "float", "(float, float)" }, - { "magf3", (void *)&SC_magf3, - "float", "(float, float, float)" }, - { "radf", (void *)&SC_radf, - "float", "(float)" }, - { "degf", (void *)&SC_degf, - "float", "(float)" }, - { "lerpf", (void *)&SC_lerpf, - "float", "(float, float, float)" }, - { "normf", (void *)&SC_normf, - "float", "(float, float, float)" }, - { "mapf", (void *)&SC_mapf, - "float", "(float, float, float, float, float)" }, - { "noisef", (void *)&SC_noisef, - "float", "(float)" }, - { "noisef2", (void *)&SC_noisef2, - "float", "(float, float)" }, - { "noisef3", (void *)&SC_noisef3, - "float", "(float, float, float)" }, - { "turbulencef2", (void *)&SC_turbulencef2, - "float", "(float, float, float)" }, - { "turbulencef3", (void *)&SC_turbulencef3, - "float", "(float, float, float, float)" }, + { "loadSimpleMeshVerticesF", (void *)&SC_loadSimpleMeshVerticesF }, + { "updateSimpleMesh", (void *)&SC_updateSimpleMesh }, + + // OpenCL math + { "_Z4acosf", (void *)&acosf }, + { "_Z5acoshf", (void *)&acoshf }, + { "_Z6acospif", (void *)&SC_acospi }, + { "_Z4asinf", (void *)&asinf }, + { "_Z5asinhf", (void *)&asinhf }, + { "_Z6asinpif", (void *)&SC_asinpi }, + { "_Z4atanf", (void *)&atanf }, + { "_Z5atan2f", (void *)&atan2f }, + { "_Z6atanpif", (void *)&SC_atanpi }, + { "_Z7atan2pif", (void *)&SC_atan2pi }, + { "_Z4cbrtf", (void *)&cbrtf }, + { "_Z4ceilf", (void *)&ceilf }, + { "_Z8copysignff", (void *)©signf }, + { "_Z3cosf", (void *)&cosf }, + { "_Z4coshf", (void *)&coshf }, + { "_Z5cospif", (void *)&SC_cospi }, + { "_Z4erfcf", (void *)&erfcf }, + { "_Z3erff", (void *)&erff }, + { "_Z3expf", (void *)&expf }, + { "_Z4exp2f", (void *)&exp2f }, + { "_Z5exp10f", (void *)&SC_exp10 }, + { "_Z5expm1f", (void *)&expm1f }, + { "_Z4fabsf", (void *)&fabsf }, + { "_Z4fdimff", (void *)&fdimf }, + { "_Z5floorf", (void *)&floorf }, + { "_Z3fmafff", (void *)&fmaf }, + { "_Z4fmaxff", (void *)&fmaxf }, + { "_Z4fminff", (void *)&fminf }, // float fmin(float, float) + { "_Z4fmodff", (void *)&fmodf }, + { "_Z5fractfPf", (void *)&SC_fract }, + { "_Z5frexpfPi", (void *)&frexpf }, + { "_Z5hypotff", (void *)&hypotf }, + { "_Z5ilogbf", (void *)&ilogbf }, + { "_Z5ldexpfi", (void *)&ldexpf }, + { "_Z6lgammaf", (void *)&lgammaf }, + { "_Z3logf", (void *)&logf }, + { "_Z4log2f", (void *)&SC_log2 }, + { "_Z5log10f", (void *)&log10f }, + { "_Z5log1pf", (void *)&log1pf }, + //{ "logb", (void *)& }, + //{ "mad", (void *)& }, + { "modf", (void *)&modff }, + //{ "nan", (void *)& }, + { "_Z9nextafterff", (void *)&nextafterf }, + { "_Z3powff", (void *)&powf }, + { "_Z4pownfi", (void *)&SC_pown }, + { "_Z4powrff", (void *)&SC_powr }, + { "_Z9remainderff", (void *)&remainderf }, + { "remquo", (void *)&remquof }, + { "_Z4rintf", (void *)&rintf }, + { "_Z5rootnfi", (void *)&SC_rootn }, + { "_Z5roundf", (void *)&roundf }, + { "_Z5rsqrtf", (void *)&SC_rsqrt }, + { "_Z3sinf", (void *)&sinf }, + { "sincos", (void *)&SC_sincos }, + { "_Z4sinhf", (void *)&sinhf }, + { "_Z5sinpif", (void *)&SC_sinpi }, + { "_Z4sqrtf", (void *)&sqrtf }, + { "_Z3tanf", (void *)&tanf }, + { "_Z4tanhf", (void *)&tanhf }, + { "_Z5tanpif", (void *)&SC_tanpi }, + //{ "tgamma", (void *)& }, + { "_Z5truncf", (void *)&truncf }, + + // OpenCL Int + { "_Z3absi", (void *)&SC_abs_i32 }, + { "_Z3abss", (void *)&SC_abs_i16 }, + { "_Z3absc", (void *)&SC_abs_i8 }, + { "_Z3clzj", (void *)&SC_clz_u32 }, + { "_Z3clzt", (void *)&SC_clz_u16 }, + { "_Z3clzh", (void *)&SC_clz_u8 }, + { "_Z3clzi", (void *)&SC_clz_i32 }, + { "_Z3clzs", (void *)&SC_clz_i16 }, + { "_Z3clzc", (void *)&SC_clz_i8 }, + { "_Z3maxjj", (void *)&SC_max_u32 }, + { "_Z3maxtt", (void *)&SC_max_u16 }, + { "_Z3maxhh", (void *)&SC_max_u8 }, + { "_Z3maxii", (void *)&SC_max_i32 }, + { "_Z3maxss", (void *)&SC_max_i16 }, + { "_Z3maxcc", (void *)&SC_max_i8 }, + { "_Z3minjj", (void *)&SC_min_u32 }, + { "_Z3mintt", (void *)&SC_min_u16 }, + { "_Z3minhh", (void *)&SC_min_u8 }, + { "_Z3minii", (void *)&SC_min_i32 }, + { "_Z3minss", (void *)&SC_min_i16 }, + { "_Z3mincc", (void *)&SC_min_i8 }, + + // OpenCL 6.11.4 + { "_Z5clampfff", (void *)&SC_clamp_f32 }, + { "_Z7degreesf", (void *)&SC_degrees }, + { "_Z3maxff", (void *)&SC_max_f32 }, + { "_Z3minff", (void *)&SC_min_f32 }, + { "_Z3mixfff", (void *)&SC_mix_f32 }, + { "_Z7radiansf", (void *)&SC_radians }, + { "_Z4stepff", (void *)&SC_step_f32 }, + //{ "smoothstep", (void *)& }, + { "_Z4signf", (void *)&SC_sign_f32 }, + + + + + { "modf", (void *)&fmod }, + { "_Z4fracf", (void *)&SC_frac }, + //{ "sinf_fast", (void *)&SC_sinf_fast }, + //{ "cosf_fast", (void *)&SC_cosf_fast }, + { "randf", (void *)&SC_randf }, + { "randf2", (void *)&SC_randf2 }, + { "sign", (void *)&SC_sign }, + { "clamp", (void *)&SC_clamp }, + { "distf2", (void *)&SC_distf2 }, + { "distf3", (void *)&SC_distf3 }, + { "magf2", (void *)&SC_magf2 }, + { "magf3", (void *)&SC_magf3 }, + { "normf", (void *)&SC_normf }, + { "mapf", (void *)&SC_mapf }, + { "noisef", (void *)&SC_noisef }, + { "noisef2", (void *)&SC_noisef2 }, + { "noisef3", (void *)&SC_noisef3 }, + { "turbulencef2", (void *)&SC_turbulencef2 }, + { "turbulencef3", (void *)&SC_turbulencef3 }, // time - { "second", (void *)&SC_second, - "int", "()" }, - { "minute", (void *)&SC_minute, - "int", "()" }, - { "hour", (void *)&SC_hour, - "int", "()" }, - { "day", (void *)&SC_day, - "int", "()" }, - { "month", (void *)&SC_month, - "int", "()" }, - { "year", (void *)&SC_year, - "int", "()" }, - { "uptimeMillis", (void*)&SC_uptimeMillis, - "int", "()" }, // TODO: use long instead - { "startTimeMillis", (void*)&SC_startTimeMillis, - "int", "()" }, // TODO: use long instead - { "elapsedTimeMillis", (void*)&SC_elapsedTimeMillis, - "int", "()" }, // TODO: use long instead + { "second", (void *)&SC_second }, + { "minute", (void *)&SC_minute }, + { "hour", (void *)&SC_hour }, + { "day", (void *)&SC_day }, + { "month", (void *)&SC_month }, + { "year", (void *)&SC_year }, + { "uptimeMillis", (void*)&SC_uptimeMillis }, // TODO: use long instead + { "startTimeMillis", (void*)&SC_startTimeMillis }, // TODO: use long instead + { "elapsedTimeMillis", (void*)&SC_elapsedTimeMillis }, // TODO: use long instead // matrix - { "matrixLoadIdentity", (void *)&SC_matrixLoadIdentity, - "void", "(float *mat)" }, - { "matrixLoadFloat", (void *)&SC_matrixLoadFloat, - "void", "(float *mat, float *f)" }, - { "matrixLoadMat", (void *)&SC_matrixLoadMat, - "void", "(float *mat, float *newmat)" }, - { "matrixLoadRotate", (void *)&SC_matrixLoadRotate, - "void", "(float *mat, float rot, float x, float y, float z)" }, - { "matrixLoadScale", (void *)&SC_matrixLoadScale, - "void", "(float *mat, float x, float y, float z)" }, - { "matrixLoadTranslate", (void *)&SC_matrixLoadTranslate, - "void", "(float *mat, float x, float y, float z)" }, - { "matrixLoadMultiply", (void *)&SC_matrixLoadMultiply, - "void", "(float *mat, float *lhs, float *rhs)" }, - { "matrixMultiply", (void *)&SC_matrixMultiply, - "void", "(float *mat, float *rhs)" }, - { "matrixRotate", (void *)&SC_matrixRotate, - "void", "(float *mat, float rot, float x, float y, float z)" }, - { "matrixScale", (void *)&SC_matrixScale, - "void", "(float *mat, float x, float y, float z)" }, - { "matrixTranslate", (void *)&SC_matrixTranslate, - "void", "(float *mat, float x, float y, float z)" }, + { "matrixLoadIdentity", (void *)&SC_matrixLoadIdentity }, + { "matrixLoadFloat", (void *)&SC_matrixLoadFloat }, + { "matrixLoadMat", (void *)&SC_matrixLoadMat }, + { "matrixLoadRotate", (void *)&SC_matrixLoadRotate }, + { "matrixLoadScale", (void *)&SC_matrixLoadScale }, + { "matrixLoadTranslate", (void *)&SC_matrixLoadTranslate }, + { "matrixLoadMultiply", (void *)&SC_matrixLoadMultiply }, + { "matrixMultiply", (void *)&SC_matrixMultiply }, + { "matrixRotate", (void *)&SC_matrixRotate }, + { "matrixScale", (void *)&SC_matrixScale }, + { "matrixTranslate", (void *)&SC_matrixTranslate }, // vector - { "vec2Rand", (void *)&SC_vec2Rand, - "void", "(float *vec, float maxLen)" }, + { "vec2Rand", (void *)&SC_vec2Rand }, // vec3 - { "vec3Norm", (void *)&SC_vec3Norm, - "void", "(struct vecF32_3_s *)" }, - { "vec3Length", (void *)&SC_vec3Length, - "float", "(struct vecF32_3_s *)" }, - { "vec3Add", (void *)&SC_vec3Add, - "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, - { "vec3Sub", (void *)&SC_vec3Sub, - "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, - { "vec3Cross", (void *)&SC_vec3Cross, - "void", "(struct vecF32_3_s *dest, struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, - { "vec3Dot", (void *)&SC_vec3Dot, - "float", "(struct vecF32_3_s *lhs, struct vecF32_3_s *rhs)" }, - { "vec3Scale", (void *)&SC_vec3Scale, - "void", "(struct vecF32_3_s *lhs, float scale)" }, + { "vec3Norm", (void *)&SC_vec3Norm }, + { "vec3Length", (void *)&SC_vec3Length }, + { "vec3Add", (void *)&SC_vec3Add }, + { "vec3Sub", (void *)&SC_vec3Sub }, + { "vec3Cross", (void *)&SC_vec3Cross }, + { "vec3Dot", (void *)&SC_vec3Dot }, + { "vec3Scale", (void *)&SC_vec3Scale }, // vec4 - { "vec4Norm", (void *)&SC_vec4Norm, - "void", "(struct vecF32_4_s *)" }, - { "vec4Length", (void *)&SC_vec4Length, - "float", "(struct vecF32_4_s *)" }, - { "vec4Add", (void *)&SC_vec4Add, - "void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, - { "vec4Sub", (void *)&SC_vec4Sub, - "void", "(struct vecF32_4_s *dest, struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, - { "vec4Dot", (void *)&SC_vec4Dot, - "float", "(struct vecF32_4_s *lhs, struct vecF32_4_s *rhs)" }, - { "vec4Scale", (void *)&SC_vec4Scale, - "void", "(struct vecF32_4_s *lhs, float scale)" }, + { "vec4Norm", (void *)&SC_vec4Norm }, + { "vec4Length", (void *)&SC_vec4Length }, + { "vec4Add", (void *)&SC_vec4Add }, + { "vec4Sub", (void *)&SC_vec4Sub }, + { "vec4Dot", (void *)&SC_vec4Dot }, + { "vec4Scale", (void *)&SC_vec4Scale }, // context - { "bindProgramFragment", (void *)&SC_bindProgramFragment, - "void", "(int)" }, - { "bindProgramFragmentStore", (void *)&SC_bindProgramFragmentStore, - "void", "(int)" }, - { "bindProgramStore", (void *)&SC_bindProgramFragmentStore, - "void", "(int)" }, - { "bindProgramVertex", (void *)&SC_bindProgramVertex, - "void", "(int)" }, - { "bindSampler", (void *)&SC_bindSampler, - "void", "(int, int, int)" }, - { "bindTexture", (void *)&SC_bindTexture, - "void", "(int, int, int)" }, + { "bindProgramFragment", (void *)&SC_bindProgramFragment }, + { "bindProgramFragmentStore", (void *)&SC_bindProgramFragmentStore }, + { "bindProgramStore", (void *)&SC_bindProgramFragmentStore }, + { "bindProgramVertex", (void *)&SC_bindProgramVertex }, + { "bindSampler", (void *)&SC_bindSampler }, + { "bindTexture", (void *)&SC_bindTexture }, // vp - { "vpLoadModelMatrix", (void *)&SC_vpLoadModelMatrix, - "void", "(void *)" }, - { "vpLoadTextureMatrix", (void *)&SC_vpLoadTextureMatrix, - "void", "(void *)" }, - + { "vpLoadModelMatrix", (void *)&SC_vpLoadModelMatrix }, + { "vpLoadTextureMatrix", (void *)&SC_vpLoadTextureMatrix }, + // allocation + { "allocGetDimX", (void *)&SC_allocGetDimX }, + { "allocGetDimY", (void *)&SC_allocGetDimY }, + { "allocGetDimZ", (void *)&SC_allocGetDimZ }, + { "allocGetDimLOD", (void *)&SC_allocGetDimLOD }, + { "allocGetDimFaces", (void *)&SC_allocGetDimFaces }, // drawing - { "drawRect", (void *)&SC_drawRect, - "void", "(float x1, float y1, float x2, float y2, float z)" }, - { "drawQuad", (void *)&SC_drawQuad, - "void", "(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4)" }, - { "drawQuadTexCoords", (void *)&SC_drawQuadTexCoords, - "void", "(float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3, float x4, float y4, float z4, float u4, float v4)" }, - { "drawSprite", (void *)&SC_drawSprite, - "void", "(float x, float y, float z, float w, float h)" }, - { "drawSpriteScreenspace", (void *)&SC_drawSpriteScreenspace, - "void", "(float x, float y, float z, float w, float h)" }, - { "drawSpriteScreenspaceCropped", (void *)&SC_drawSpriteScreenspaceCropped, - "void", "(float x, float y, float z, float w, float h, float cx0, float cy0, float cx1, float cy1)" }, - { "drawLine", (void *)&SC_drawLine, - "void", "(float x1, float y1, float z1, float x2, float y2, float z2)" }, - { "drawPoint", (void *)&SC_drawPoint, - "void", "(float x1, float y1, float z1)" }, - { "drawSimpleMesh", (void *)&SC_drawSimpleMesh, - "void", "(int ism)" }, - { "drawSimpleMeshRange", (void *)&SC_drawSimpleMeshRange, - "void", "(int ism, int start, int len)" }, + { "drawRect", (void *)&SC_drawRect }, + { "drawQuad", (void *)&SC_drawQuad }, + { "drawQuadTexCoords", (void *)&SC_drawQuadTexCoords }, + { "drawSprite", (void *)&SC_drawSprite }, + { "drawSpriteScreenspace", (void *)&SC_drawSpriteScreenspace }, + { "drawSpriteScreenspaceCropped", (void *)&SC_drawSpriteScreenspaceCropped }, + { "drawLine", (void *)&SC_drawLine }, + { "drawPoint", (void *)&SC_drawPoint }, + { "drawSimpleMesh", (void *)&SC_drawSimpleMesh }, + { "drawSimpleMeshRange", (void *)&SC_drawSimpleMeshRange }, // misc - { "pfClearColor", (void *)&SC_ClearColor, - "void", "(float, float, float, float)" }, - { "color", (void *)&SC_color, - "void", "(float, float, float, float)" }, - { "hsb", (void *)&SC_hsb, - "void", "(float, float, float, float)" }, - { "hsbToRgb", (void *)&SC_hsbToRgb, - "void", "(float, float, float, float*)" }, - { "hsbToAbgr", (void *)&SC_hsbToAbgr, - "int", "(float, float, float, float)" }, - { "ambient", (void *)&SC_ambient, - "void", "(float, float, float, float)" }, - { "diffuse", (void *)&SC_diffuse, - "void", "(float, float, float, float)" }, - { "specular", (void *)&SC_specular, - "void", "(float, float, float, float)" }, - { "emission", (void *)&SC_emission, - "void", "(float, float, float, float)" }, - { "shininess", (void *)&SC_shininess, - "void", "(float)" }, - { "pointAttenuation", (void *)&SC_pointAttenuation, - "void", "(float, float, float)" }, - - { "uploadToTexture", (void *)&SC_uploadToTexture, - "void", "(int, int)" }, - { "uploadToBufferObject", (void *)&SC_uploadToBufferObject, - "void", "(int)" }, - - { "syncToGL", (void *)&SC_syncToGL, - "void", "(int)" }, - - { "colorFloatRGBAtoUNorm8", (void *)&SC_colorFloatRGBAtoUNorm8, - "int", "(float, float, float, float)" }, - { "colorFloatRGBto565", (void *)&SC_colorFloatRGBAto565, - "int", "(float, float, float)" }, - - - { "getWidth", (void *)&SC_getWidth, - "int", "()" }, - { "getHeight", (void *)&SC_getHeight, - "int", "()" }, - - { "sendToClient", (void *)&SC_toClient, - "int", "(void *data, int cmdID, int len, int waitForSpace)" }, - - - { "debugF", (void *)&SC_debugF, - "void", "(void *, float)" }, - { "debugI32", (void *)&SC_debugI32, - "void", "(void *, int)" }, - { "debugHexF", (void *)&SC_debugHexF, - "void", "(void *, float)" }, - { "debugHexI32", (void *)&SC_debugHexI32, - "void", "(void *, int)" }, - - { "scriptCall", (void *)&SC_scriptCall, - "void", "(int)" }, - - - { NULL, NULL, NULL, NULL } + { "pfClearColor", (void *)&SC_ClearColor }, + { "color", (void *)&SC_color }, + { "hsb", (void *)&SC_hsb }, + { "hsbToRgb", (void *)&SC_hsbToRgb }, + { "hsbToAbgr", (void *)&SC_hsbToAbgr }, + { "pointAttenuation", (void *)&SC_pointAttenuation }, + + { "uploadToTexture", (void *)&SC_uploadToTexture }, + { "uploadToBufferObject", (void *)&SC_uploadToBufferObject }, + + { "syncToGL", (void *)&SC_syncToGL }, + + { "getWidth", (void *)&SC_getWidth }, + { "getHeight", (void *)&SC_getHeight }, + + { "sendToClient", (void *)&SC_toClient }, + + { "_Z18convertColorTo8888fff", (void *)&SC_convertColorTo8888_f3 }, + { "_Z18convertColorTo8888ffff", (void *)&SC_convertColorTo8888_f4 }, + + { "debugF", (void *)&SC_debugF }, + { "debugI32", (void *)&SC_debugI32 }, + { "debugHexF", (void *)&SC_debugHexF }, + { "debugHexI32", (void *)&SC_debugHexI32 }, + { "debugP", (void *)&SC_debugP }, + { "debugPf", (void *)&SC_debugPf }, + { "debugPi", (void *)&SC_debugPi }, + + { "scriptCall", (void *)&SC_scriptCall }, + + { NULL, NULL } }; const ScriptCState::SymbolTable_t * ScriptCState::lookupSymbol(const char *sym) @@ -1400,17 +1390,3 @@ const ScriptCState::SymbolTable_t * ScriptCState::lookupSymbol(const char *sym) return NULL; } -void ScriptCState::appendDecls(String8 *str) -{ - ScriptCState::SymbolTable_t *syms = gSyms; - while (syms->mPtr) { - str->append(syms->mRet); - str->append(" "); - str->append(syms->mName); - str->append(syms->mParam); - str->append(";\n"); - syms++; - } -} - - @@ -41,6 +41,38 @@ namespace renderscript { #define rsAssert(v) while(0) #endif +typedef float rsvF_2 __attribute__ ((vector_size (8))); +typedef float rsvF_4 __attribute__ ((vector_size (16))); +typedef float rsvF_8 __attribute__ ((vector_size (32))); +typedef float rsvF_16 __attribute__ ((vector_size (64))); +typedef uint8_t rsvU8_4 __attribute__ ((vector_size (4))); + +union float2 { + rsvF_2 v; + float f[2]; +}; + +union float4 { + rsvF_4 v; + float f[4]; +}; + +union float8 { + rsvF_8 v; + float f[8]; +}; + +union float16 { + rsvF_16 v; + float f[16]; +}; + +union uchar4 { + rsvU8_4 v; + uint8_t f[4]; + uint32_t packed; +}; + template<typename T> T rsMin(T in1, T in2) { diff --git a/scriptc/rs_geom.rsh b/scriptc/rs_geom.rsh deleted file mode 100644 index 6e9e9fca..00000000 --- a/scriptc/rs_geom.rsh +++ /dev/null @@ -1,26 +0,0 @@ - -extern float3 __attribute__((overloadable)) cross(float3, float3); -extern float4 __attribute__((overloadable)) cross(float4, float4); - -//extern float __attribute__((overloadable)) dot(float, float); -extern float __attribute__((overloadable)) dot(float2, float2); -extern float __attribute__((overloadable)) dot(float3, float3); -extern float __attribute__((overloadable)) dot(float4, float4); - -//extern float __attribute__((overloadable)) distance(float, float); -extern float __attribute__((overloadable)) distance(float2, float2); -extern float __attribute__((overloadable)) distance(float3, float3); -extern float __attribute__((overloadable)) distance(float4, float4); - -//extern float __attribute__((overloadable)) length(float); -extern float __attribute__((overloadable)) length(float2); -extern float __attribute__((overloadable)) length(float3); -extern float __attribute__((overloadable)) length(float4); - -extern float2 __attribute__((overloadable)) normalize(float2); -extern float3 __attribute__((overloadable)) normalize(float3); -extern float4 __attribute__((overloadable)) normalize(float4); - - - - diff --git a/scriptc/rs_graphics.rsh b/scriptc/rs_graphics.rsh index 0f03732a..4696fb33 100644 --- a/scriptc/rs_graphics.rsh +++ b/scriptc/rs_graphics.rsh @@ -2,6 +2,7 @@ extern float rand(float max); +//extern void vec2Rand(float *, float len); extern float2 vec2Rand(float len); extern float3 float3Norm(float3); @@ -59,9 +60,21 @@ extern int getHeight(); extern int sendToClient(void *data, int cmdID, int len, int waitForSpace); -extern void debugF(const char *, float); -extern void debugI32(const char *, int); -extern void debugHexI32(const char *, int); - +extern uint32_t allocGetDimX(rs_allocation); +extern uint32_t allocGetDimY(rs_allocation); +extern uint32_t allocGetDimZ(rs_allocation); +extern uint32_t allocGetDimLOD(rs_allocation); +extern uint32_t allocGetDimFaces(rs_allocation); + +// +extern float normf(float start, float stop, float value); +extern float clampf(float amount, float low, float high); +extern float turbulencef2(float x, float y, float octaves); +extern float turbulencef3(float x, float y, float z, float octaves); + +extern uchar4 __attribute__((overloadable)) convertColorTo8888(float r, float g, float b); +extern uchar4 __attribute__((overloadable)) convertColorTo8888(float r, float g, float b, float a); +extern uchar4 __attribute__((overloadable)) convertColorTo8888(float3); +extern uchar4 __attribute__((overloadable)) convertColorTo8888(float4); diff --git a/scriptc/rs_math.rsh b/scriptc/rs_math.rsh index fba0f8f7..48ab0666 100644 --- a/scriptc/rs_math.rsh +++ b/scriptc/rs_math.rsh @@ -1,285 +1,653 @@ -// Float ops - -extern float __attribute__((overloadable)) abs(float); -//extern float2 __attribute__((overloadable)) abs(float2); -//extern float3 __attribute__((overloadable)) abs(float3); -//extern float4 __attribute__((overloadable)) abs(float4); -//extern float8 __attribute__((overloadable)) abs(float8); -//extern float16 __attribute__((overloadable)) abs(float16); +// Float ops, 6.11.2 extern float __attribute__((overloadable)) acos(float); -//extern float2 __attribute__((overloadable)) acos(float2); -//extern float3 __attribute__((overloadable)) acos(float3); -//extern float4 __attribute__((overloadable)) acos(float4); -//extern float8 __attribute__((overloadable)) acos(float8); -//extern float16 __attribute__((overloadable)) acos(float16); +extern float2 __attribute__((overloadable)) acos(float2); +extern float3 __attribute__((overloadable)) acos(float3); +extern float4 __attribute__((overloadable)) acos(float4); +extern float8 __attribute__((overloadable)) acos(float8); +extern float16 __attribute__((overloadable)) acos(float16); + +extern float __attribute__((overloadable)) acosh(float); +extern float2 __attribute__((overloadable)) acosh(float2); +extern float3 __attribute__((overloadable)) acosh(float3); +extern float4 __attribute__((overloadable)) acosh(float4); +extern float8 __attribute__((overloadable)) acosh(float8); +extern float16 __attribute__((overloadable)) acosh(float16); + +extern float __attribute__((overloadable)) acospi(float); +extern float2 __attribute__((overloadable)) acospi(float2); +extern float3 __attribute__((overloadable)) acospi(float3); +extern float4 __attribute__((overloadable)) acospi(float4); +extern float8 __attribute__((overloadable)) acospi(float8); +extern float16 __attribute__((overloadable)) acospi(float16); extern float __attribute__((overloadable)) asin(float); -//extern float2 __attribute__((overloadable)) asin(float2); -//extern float3 __attribute__((overloadable)) asin(float3); -//extern float4 __attribute__((overloadable)) asin(float4); -//extern float8 __attribute__((overloadable)) asin(float8); -//extern float16 __attribute__((overloadable)) asin(float16); +extern float2 __attribute__((overloadable)) asin(float2); +extern float3 __attribute__((overloadable)) asin(float3); +extern float4 __attribute__((overloadable)) asin(float4); +extern float8 __attribute__((overloadable)) asin(float8); +extern float16 __attribute__((overloadable)) asin(float16); + +extern float __attribute__((overloadable)) asinh(float); +extern float2 __attribute__((overloadable)) asinh(float2); +extern float3 __attribute__((overloadable)) asinh(float3); +extern float4 __attribute__((overloadable)) asinh(float4); +extern float8 __attribute__((overloadable)) asinh(float8); +extern float16 __attribute__((overloadable)) asinh(float16); + +extern float __attribute__((overloadable)) asinpi(float); +extern float2 __attribute__((overloadable)) asinpi(float2); +extern float3 __attribute__((overloadable)) asinpi(float3); +extern float4 __attribute__((overloadable)) asinpi(float4); +extern float8 __attribute__((overloadable)) asinpi(float8); +extern float16 __attribute__((overloadable)) asinpi(float16); extern float __attribute__((overloadable)) atan(float); -//extern float2 __attribute__((overloadable)) atan(float2); -//extern float3 __attribute__((overloadable)) atan(float3); -//extern float4 __attribute__((overloadable)) atan(float4); -//extern float8 __attribute__((overloadable)) atan(float8); -//extern float16 __attribute__((overloadable)) atan(float16); +extern float2 __attribute__((overloadable)) atan(float2); +extern float3 __attribute__((overloadable)) atan(float3); +extern float4 __attribute__((overloadable)) atan(float4); +extern float8 __attribute__((overloadable)) atan(float8); +extern float16 __attribute__((overloadable)) atan(float16); extern float __attribute__((overloadable)) atan2(float, float); -//extern float2 __attribute__((overloadable)) atan2(float2, float2); -//extern float3 __attribute__((overloadable)) atan2(float3, float3); -//extern float4 __attribute__((overloadable)) atan2(float4, float4); -//extern float8 __attribute__((overloadable)) atan2(float8, float8); -//extern float16 __attribute__((overloadable)) atan2(float16, float16); +extern float2 __attribute__((overloadable)) atan2(float2, float2); +extern float3 __attribute__((overloadable)) atan2(float3, float3); +extern float4 __attribute__((overloadable)) atan2(float4, float4); +extern float8 __attribute__((overloadable)) atan2(float8, float8); +extern float16 __attribute__((overloadable)) atan2(float16, float16); + +extern float __attribute__((overloadable)) atanh(float); +extern float2 __attribute__((overloadable)) atanh(float2); +extern float3 __attribute__((overloadable)) atanh(float3); +extern float4 __attribute__((overloadable)) atanh(float4); +extern float8 __attribute__((overloadable)) atanh(float8); +extern float16 __attribute__((overloadable)) atanh(float16); + +extern float __attribute__((overloadable)) atanpi(float); +extern float2 __attribute__((overloadable)) atanpi(float2); +extern float3 __attribute__((overloadable)) atanpi(float3); +extern float4 __attribute__((overloadable)) atanpi(float4); +extern float8 __attribute__((overloadable)) atanpi(float8); +extern float16 __attribute__((overloadable)) atanpi(float16); + +extern float __attribute__((overloadable)) atan2pi(float, float); +extern float2 __attribute__((overloadable)) atan2pi(float2, float2); +extern float3 __attribute__((overloadable)) atan2pi(float3, float3); +extern float4 __attribute__((overloadable)) atan2pi(float4, float4); +extern float8 __attribute__((overloadable)) atan2pi(float8, float8); +extern float16 __attribute__((overloadable)) atan2pi(float16, float16); + +extern float __attribute__((overloadable)) cbrt(float); +extern float2 __attribute__((overloadable)) cbrt(float2); +extern float3 __attribute__((overloadable)) cbrt(float3); +extern float4 __attribute__((overloadable)) cbrt(float4); +extern float8 __attribute__((overloadable)) cbrt(float8); +extern float16 __attribute__((overloadable)) cbrt(float16); extern float __attribute__((overloadable)) ceil(float); -//extern float2 __attribute__((overloadable)) ceil(float2); -//extern float3 __attribute__((overloadable)) ceil(float3); -//extern float4 __attribute__((overloadable)) ceil(float4); -//extern float8 __attribute__((overloadable)) ceil(float8); -//extern float16 __attribute__((overloadable)) ceil(float16); - -extern float __attribute__((overloadable)) clamp(float, float, float); -//extern float2 __attribute__((overloadable)) clamp(float2, float2, float2); -//extern float3 __attribute__((overloadable)) clamp(float3, float3, float3); -//extern float4 __attribute__((overloadable)) clamp(float4, float4, float4); -//extern float8 __attribute__((overloadable)) clamp(float8, float8, float8); -//extern float16 __attribute__((overloadable)) clamp(float16, float16, float16); -//extern float2 __attribute__((overloadable)) clamp(float2, float, float); -//extern float3 __attribute__((overloadable)) clamp(float3, float, float); -//extern float4 __attribute__((overloadable)) clamp(float4, float, float); -//extern float8 __attribute__((overloadable)) clamp(float8, float, float); -//extern float16 __attribute__((overloadable)) clamp(float16, float, float); +extern float2 __attribute__((overloadable)) ceil(float2); +extern float3 __attribute__((overloadable)) ceil(float3); +extern float4 __attribute__((overloadable)) ceil(float4); +extern float8 __attribute__((overloadable)) ceil(float8); +extern float16 __attribute__((overloadable)) ceil(float16); extern float __attribute__((overloadable)) copysign(float, float); -//extern float2 __attribute__((overloadable)) copysign(float2, float2); -//extern float3 __attribute__((overloadable)) copysign(float3, float3); -//extern float4 __attribute__((overloadable)) copysign(float4, float4); -//extern float8 __attribute__((overloadable)) copysign(float8, float8); -//extern float16 __attribute__((overloadable)) copysign(float16, float16); +extern float2 __attribute__((overloadable)) copysign(float2, float2); +extern float3 __attribute__((overloadable)) copysign(float3, float3); +extern float4 __attribute__((overloadable)) copysign(float4, float4); +extern float8 __attribute__((overloadable)) copysign(float8, float8); +extern float16 __attribute__((overloadable)) copysign(float16, float16); extern float __attribute__((overloadable)) cos(float); -//extern float2 __attribute__((overloadable)) cos(float2); -//extern float3 __attribute__((overloadable)) cos(float3); -//extern float4 __attribute__((overloadable)) cos(float4); -//extern float8 __attribute__((overloadable)) cos(float8); -//extern float16 __attribute__((overloadable)) cos(float16); - -extern float __attribute__((overloadable)) degrees(float); -//extern float2 __attribute__((overloadable)) degrees(float2); -//extern float3 __attribute__((overloadable)) degrees(float3); -//extern float4 __attribute__((overloadable)) degrees(float4); -//extern float8 __attribute__((overloadable)) degrees(float8); -//extern float16 __attribute__((overloadable)) degrees(float16); +extern float2 __attribute__((overloadable)) cos(float2); +extern float3 __attribute__((overloadable)) cos(float3); +extern float4 __attribute__((overloadable)) cos(float4); +extern float8 __attribute__((overloadable)) cos(float8); +extern float16 __attribute__((overloadable)) cos(float16); + +extern float __attribute__((overloadable)) cosh(float); +extern float2 __attribute__((overloadable)) cosh(float2); +extern float3 __attribute__((overloadable)) cosh(float3); +extern float4 __attribute__((overloadable)) cosh(float4); +extern float8 __attribute__((overloadable)) cosh(float8); +extern float16 __attribute__((overloadable)) cosh(float16); + +extern float __attribute__((overloadable)) cospi(float); +extern float2 __attribute__((overloadable)) cospi(float2); +extern float3 __attribute__((overloadable)) cospi(float3); +extern float4 __attribute__((overloadable)) cospi(float4); +extern float8 __attribute__((overloadable)) cospi(float8); +extern float16 __attribute__((overloadable)) cospi(float16); + +extern float __attribute__((overloadable)) erfc(float); +extern float2 __attribute__((overloadable)) erfc(float2); +extern float3 __attribute__((overloadable)) erfc(float3); +extern float4 __attribute__((overloadable)) erfc(float4); +extern float8 __attribute__((overloadable)) erfc(float8); +extern float16 __attribute__((overloadable)) erfc(float16); + +extern float __attribute__((overloadable)) erf(float); +extern float2 __attribute__((overloadable)) erf(float2); +extern float3 __attribute__((overloadable)) erf(float3); +extern float4 __attribute__((overloadable)) erf(float4); +extern float8 __attribute__((overloadable)) erf(float8); +extern float16 __attribute__((overloadable)) erf(float16); extern float __attribute__((overloadable)) exp(float); -//extern float2 __attribute__((overloadable)) exp(float2); -//extern float3 __attribute__((overloadable)) exp(float3); -//extern float4 __attribute__((overloadable)) exp(float4); -//extern float8 __attribute__((overloadable)) exp(float8); -//extern float16 __attribute__((overloadable)) exp(float16); +extern float2 __attribute__((overloadable)) exp(float2); +extern float3 __attribute__((overloadable)) exp(float3); +extern float4 __attribute__((overloadable)) exp(float4); +extern float8 __attribute__((overloadable)) exp(float8); +extern float16 __attribute__((overloadable)) exp(float16); extern float __attribute__((overloadable)) exp2(float); -//extern float2 __attribute__((overloadable)) exp2(float2); -//extern float3 __attribute__((overloadable)) exp2(float3); -//extern float4 __attribute__((overloadable)) exp2(float4); -//extern float8 __attribute__((overloadable)) exp2(float8); -//extern float16 __attribute__((overloadable)) exp2(float16); +extern float2 __attribute__((overloadable)) exp2(float2); +extern float3 __attribute__((overloadable)) exp2(float3); +extern float4 __attribute__((overloadable)) exp2(float4); +extern float8 __attribute__((overloadable)) exp2(float8); +extern float16 __attribute__((overloadable)) exp2(float16); extern float __attribute__((overloadable)) exp10(float); -//extern float2 __attribute__((overloadable)) exp10(float2); -//extern float3 __attribute__((overloadable)) exp10(float3); -//extern float4 __attribute__((overloadable)) exp10(float4); -//extern float8 __attribute__((overloadable)) exp10(float8); -//extern float16 __attribute__((overloadable)) exp10(float16); +extern float2 __attribute__((overloadable)) exp10(float2); +extern float3 __attribute__((overloadable)) exp10(float3); +extern float4 __attribute__((overloadable)) exp10(float4); +extern float8 __attribute__((overloadable)) exp10(float8); +extern float16 __attribute__((overloadable)) exp10(float16); + +extern float __attribute__((overloadable)) expm1(float); +extern float2 __attribute__((overloadable)) expm1(float2); +extern float3 __attribute__((overloadable)) expm1(float3); +extern float4 __attribute__((overloadable)) expm1(float4); +extern float8 __attribute__((overloadable)) expm1(float8); +extern float16 __attribute__((overloadable)) expm1(float16); extern float __attribute__((overloadable)) fabs(float); -//extern float2 __attribute__((overloadable)) fabs(float2); -//extern float3 __attribute__((overloadable)) fabs(float3); -//extern float4 __attribute__((overloadable)) fabs(float4); -//extern float8 __attribute__((overloadable)) fabs(float8); -//extern float16 __attribute__((overloadable)) fabs(float16); +extern float2 __attribute__((overloadable)) fabs(float2); +extern float3 __attribute__((overloadable)) fabs(float3); +extern float4 __attribute__((overloadable)) fabs(float4); +extern float8 __attribute__((overloadable)) fabs(float8); +extern float16 __attribute__((overloadable)) fabs(float16); + +extern float __attribute__((overloadable)) fdim(float, float); +extern float2 __attribute__((overloadable)) fdim(float2, float2); +extern float3 __attribute__((overloadable)) fdim(float3, float3); +extern float4 __attribute__((overloadable)) fdim(float4, float4); +extern float8 __attribute__((overloadable)) fdim(float8, float8); +extern float16 __attribute__((overloadable)) fdim(float16, float16); extern float __attribute__((overloadable)) floor(float); -//extern float2 __attribute__((overloadable)) floor(float2); -//extern float3 __attribute__((overloadable)) floor(float3); -//extern float4 __attribute__((overloadable)) floor(float4); -//extern float8 __attribute__((overloadable)) floor(float8); -//extern float16 __attribute__((overloadable)) floor(float16); +extern float2 __attribute__((overloadable)) floor(float2); +extern float3 __attribute__((overloadable)) floor(float3); +extern float4 __attribute__((overloadable)) floor(float4); +extern float8 __attribute__((overloadable)) floor(float8); +extern float16 __attribute__((overloadable)) floor(float16); + +extern float __attribute__((overloadable)) fma(float, float, float); +extern float2 __attribute__((overloadable)) fma(float2, float2, float2); +extern float3 __attribute__((overloadable)) fma(float3, float3, float3); +extern float4 __attribute__((overloadable)) fma(float4, float4, float4); +extern float8 __attribute__((overloadable)) fma(float8, float8, float8); +extern float16 __attribute__((overloadable)) fma(float16, float16, float16); extern float __attribute__((overloadable)) fmax(float, float); -//extern float2 __attribute__((overloadable)) fmax(float2, float2); -//extern float3 __attribute__((overloadable)) fmax(float3, float3); -//extern float4 __attribute__((overloadable)) fmax(float4, float4); -//extern float8 __attribute__((overloadable)) fmax(float8, float8); -//extern float16 __attribute__((overloadable)) fmax(float16, float16); -//extern float2 __attribute__((overloadable)) fmax(float2, float); -//extern float3 __attribute__((overloadable)) fmax(float3, float); -//extern float4 __attribute__((overloadable)) fmax(float4, float); -//extern float8 __attribute__((overloadable)) fmax(float8, float); -//extern float16 __attribute__((overloadable)) fmax(float16, float); +extern float2 __attribute__((overloadable)) fmax(float2, float2); +extern float3 __attribute__((overloadable)) fmax(float3, float3); +extern float4 __attribute__((overloadable)) fmax(float4, float4); +extern float8 __attribute__((overloadable)) fmax(float8, float8); +extern float16 __attribute__((overloadable)) fmax(float16, float16); +extern float2 __attribute__((overloadable)) fmax(float2, float); +extern float3 __attribute__((overloadable)) fmax(float3, float); +extern float4 __attribute__((overloadable)) fmax(float4, float); +extern float8 __attribute__((overloadable)) fmax(float8, float); +extern float16 __attribute__((overloadable)) fmax(float16, float); extern float __attribute__((overloadable)) fmin(float, float); -//extern float2 __attribute__((overloadable)) fmin(float2, float2); -//extern float3 __attribute__((overloadable)) fmin(float3, float3); -//extern float4 __attribute__((overloadable)) fmin(float4, float4); -//extern float8 __attribute__((overloadable)) fmin(float8, float8); -//extern float16 __attribute__((overloadable)) fmin(float16, float16); -//extern float2 __attribute__((overloadable)) fmin(float2, float); -//extern float3 __attribute__((overloadable)) fmin(float3, float); -//extern float4 __attribute__((overloadable)) fmin(float4, float); -//extern float8 __attribute__((overloadable)) fmin(float8, float); -//extern float16 __attribute__((overloadable)) fmin(float16, float); +extern float2 __attribute__((overloadable)) fmin(float2, float2); +extern float3 __attribute__((overloadable)) fmin(float3, float3); +extern float4 __attribute__((overloadable)) fmin(float4, float4); +extern float8 __attribute__((overloadable)) fmin(float8, float8); +extern float16 __attribute__((overloadable)) fmin(float16, float16); +extern float2 __attribute__((overloadable)) fmin(float2, float); +extern float3 __attribute__((overloadable)) fmin(float3, float); +extern float4 __attribute__((overloadable)) fmin(float4, float); +extern float8 __attribute__((overloadable)) fmin(float8, float); +extern float16 __attribute__((overloadable)) fmin(float16, float); extern float __attribute__((overloadable)) fmod(float, float); -//extern float2 __attribute__((overloadable)) fmod(float2, float2); -//extern float3 __attribute__((overloadable)) fmod(float3, float3); -//extern float4 __attribute__((overloadable)) fmod(float4, float4); -//extern float8 __attribute__((overloadable)) fmod(float8, float8); -//extern float16 __attribute__((overloadable)) fmod(float16, float16); +extern float2 __attribute__((overloadable)) fmod(float2, float2); +extern float3 __attribute__((overloadable)) fmod(float3, float3); +extern float4 __attribute__((overloadable)) fmod(float4, float4); +extern float8 __attribute__((overloadable)) fmod(float8, float8); +extern float16 __attribute__((overloadable)) fmod(float16, float16); + +extern float __attribute__((overloadable)) fract(float, float *); +extern float2 __attribute__((overloadable)) fract(float2, float2 *); +extern float3 __attribute__((overloadable)) fract(float3, float3 *); +extern float4 __attribute__((overloadable)) fract(float4, float4 *); +extern float8 __attribute__((overloadable)) fract(float8, float8 *); +extern float16 __attribute__((overloadable)) fract(float16, float16 *); + +extern float __attribute__((overloadable)) frexp(float, float *); +extern float2 __attribute__((overloadable)) frexp(float2, float2 *); +extern float3 __attribute__((overloadable)) frexp(float3, float3 *); +extern float4 __attribute__((overloadable)) frexp(float4, float4 *); +extern float8 __attribute__((overloadable)) frexp(float8, float8 *); +extern float16 __attribute__((overloadable)) frexp(float16, float16 *); + +extern float __attribute__((overloadable)) hypot(float, float); +extern float2 __attribute__((overloadable)) hypot(float2, float2); +extern float3 __attribute__((overloadable)) hypot(float3, float3); +extern float4 __attribute__((overloadable)) hypot(float4, float4); +extern float8 __attribute__((overloadable)) hypot(float8, float8); +extern float16 __attribute__((overloadable)) hypot(float16, float16); + +extern int __attribute__((overloadable)) ilogb(float); +extern int2 __attribute__((overloadable)) ilogb(float2); +extern int3 __attribute__((overloadable)) ilogb(float3); +extern int4 __attribute__((overloadable)) ilogb(float4); +extern int8 __attribute__((overloadable)) ilogb(float8); +extern int16 __attribute__((overloadable)) ilogb(float16); + +extern float __attribute__((overloadable)) ldexp(float, int); +extern float2 __attribute__((overloadable)) ldexp(float2, int2); +extern float3 __attribute__((overloadable)) ldexp(float3, int3); +extern float4 __attribute__((overloadable)) ldexp(float4, int4); +extern float8 __attribute__((overloadable)) ldexp(float8, int8); +extern float16 __attribute__((overloadable)) ldexp(float16, int16); +extern float2 __attribute__((overloadable)) ldexp(float2, int); +extern float3 __attribute__((overloadable)) ldexp(float3, int); +extern float4 __attribute__((overloadable)) ldexp(float4, int); +extern float8 __attribute__((overloadable)) ldexp(float8, int); +extern float16 __attribute__((overloadable)) ldexp(float16, int); + +extern float __attribute__((overloadable)) lgamma(float); +extern float2 __attribute__((overloadable)) lgamma(float2); +extern float3 __attribute__((overloadable)) lgamma(float3); +extern float4 __attribute__((overloadable)) lgamma(float4); +extern float8 __attribute__((overloadable)) lgamma(float8); +extern float16 __attribute__((overloadable)) lgamma(float16); +extern float __attribute__((overloadable)) lgamma(float, float *); +extern float2 __attribute__((overloadable)) lgamma(float2, float2 *); +extern float3 __attribute__((overloadable)) lgamma(float3, float3 *); +extern float4 __attribute__((overloadable)) lgamma(float4, float4 *); +extern float8 __attribute__((overloadable)) lgamma(float8, float8 *); +extern float16 __attribute__((overloadable)) lgamma(float16, float16 *); extern float __attribute__((overloadable)) log(float); -//extern float2 __attribute__((overloadable)) log(float2); -//extern float3 __attribute__((overloadable)) log(float3); -//extern float4 __attribute__((overloadable)) log(float4); -//extern float8 __attribute__((overloadable)) log(float8); -//extern float16 __attribute__((overloadable)) log(float16); +extern float2 __attribute__((overloadable)) log(float2); +extern float3 __attribute__((overloadable)) log(float3); +extern float4 __attribute__((overloadable)) log(float4); +extern float8 __attribute__((overloadable)) log(float8); +extern float16 __attribute__((overloadable)) log(float16); extern float __attribute__((overloadable)) log2(float); -//extern float2 __attribute__((overloadable)) log2(float2); -//extern float3 __attribute__((overloadable)) log2(float3); -//extern float4 __attribute__((overloadable)) log2(float4); -//extern float8 __attribute__((overloadable)) log2(float8); -//extern float16 __attribute__((overloadable)) log2(float16); +extern float2 __attribute__((overloadable)) log2(float2); +extern float3 __attribute__((overloadable)) log2(float3); +extern float4 __attribute__((overloadable)) log2(float4); +extern float8 __attribute__((overloadable)) log2(float8); +extern float16 __attribute__((overloadable)) log2(float16); extern float __attribute__((overloadable)) log10(float); -//extern float2 __attribute__((overloadable)) log10(float2); -//extern float3 __attribute__((overloadable)) log10(float3); -//extern float4 __attribute__((overloadable)) log10(float4); -//extern float8 __attribute__((overloadable)) log10(float8); -//extern float16 __attribute__((overloadable)) log10(float16); - -extern float __attribute__((overloadable)) max(float, float); -//extern float2 __attribute__((overloadable)) max(float2, float2); -//extern float3 __attribute__((overloadable)) max(float3, float3); -//extern float4 __attribute__((overloadable)) max(float4, float4); -//extern float8 __attribute__((overloadable)) max(float8, float8); -//extern float16 __attribute__((overloadable)) max(float16, float16); - -extern float __attribute__((overloadable)) min(float, float); -//extern float2 __attribute__((overloadable)) min(float2, float2); -//extern float3 __attribute__((overloadable)) min(float3, float3); -//extern float4 __attribute__((overloadable)) min(float4, float4); -//extern float8 __attribute__((overloadable)) min(float8, float8); -//extern float16 __attribute__((overloadable)) min(float16, float16); - -extern float __attribute__((overloadable)) mix(float, float, float); -//extern float2 __attribute__((overloadable)) mix(float2, float2, float2); -//extern float3 __attribute__((overloadable)) mix(float3, float3, float3); -//extern float4 __attribute__((overloadable)) mix(float4, float4, float4); -//extern float8 __attribute__((overloadable)) mix(float8, float8, float8); -//extern float16 __attribute__((overloadable)) mix(float16, float16, float16); -//extern float2 __attribute__((overloadable)) mix(float2, float2, float); -//extern float3 __attribute__((overloadable)) mix(float3, float3, float); -//extern float4 __attribute__((overloadable)) mix(float4, float4, float); -//extern float8 __attribute__((overloadable)) mix(float8, float8, float); -//extern float16 __attribute__((overloadable)) mix(float16, float16, float); +extern float2 __attribute__((overloadable)) log10(float2); +extern float3 __attribute__((overloadable)) log10(float3); +extern float4 __attribute__((overloadable)) log10(float4); +extern float8 __attribute__((overloadable)) log10(float8); +extern float16 __attribute__((overloadable)) log10(float16); + +extern float __attribute__((overloadable)) log1p(float); +extern float2 __attribute__((overloadable)) log1p(float2); +extern float3 __attribute__((overloadable)) log1p(float3); +extern float4 __attribute__((overloadable)) log1p(float4); +extern float8 __attribute__((overloadable)) log1p(float8); +extern float16 __attribute__((overloadable)) log1p(float16); + +extern float __attribute__((overloadable)) logb(float); +extern float2 __attribute__((overloadable)) logb(float2); +extern float3 __attribute__((overloadable)) logb(float3); +extern float4 __attribute__((overloadable)) logb(float4); +extern float8 __attribute__((overloadable)) logb(float8); +extern float16 __attribute__((overloadable)) logb(float16); + +extern float __attribute__((overloadable)) mad(float, float, float); +extern float2 __attribute__((overloadable)) mad(float2, float2, float2); +extern float3 __attribute__((overloadable)) mad(float3, float3, float3); +extern float4 __attribute__((overloadable)) mad(float4, float4, float4); +extern float8 __attribute__((overloadable)) mad(float8, float8, float8); +extern float16 __attribute__((overloadable)) mad(float16, float16, float16); + +extern float __attribute__((overloadable)) modf(float, float *); +extern float2 __attribute__((overloadable)) modf(float2, float2 *); +extern float3 __attribute__((overloadable)) modf(float3, float3 *); +extern float4 __attribute__((overloadable)) modf(float4, float4 *); +extern float8 __attribute__((overloadable)) modf(float8, float8 *); +extern float16 __attribute__((overloadable)) modf(float16, float16 *); + +extern float __attribute__((overloadable)) nan(uint); +extern float2 __attribute__((overloadable)) nan(uint2); +extern float3 __attribute__((overloadable)) nan(uint3); +extern float4 __attribute__((overloadable)) nan(uint4); +extern float8 __attribute__((overloadable)) nan(uint8); +extern float16 __attribute__((overloadable)) nan(uint16); + +extern float __attribute__((overloadable)) nextafter(float, float); +extern float2 __attribute__((overloadable)) nextafter(float2, float2); +extern float3 __attribute__((overloadable)) nextafter(float3, float3); +extern float4 __attribute__((overloadable)) nextafter(float4, float4); +extern float8 __attribute__((overloadable)) nextafter(float8, float8); +extern float16 __attribute__((overloadable)) nextafter(float16, float16); extern float __attribute__((overloadable)) pow(float, float); -//extern float2 __attribute__((overloadable)) pow(float2, float2); -//extern float3 __attribute__((overloadable)) pow(float3, float3); -//extern float4 __attribute__((overloadable)) pow(float4, float4); -//extern float8 __attribute__((overloadable)) pow(float8, float8); -//extern float16 __attribute__((overloadable)) pow(float16, float16); - -extern float __attribute__((overloadable)) radians(float); -//extern float2 __attribute__((overloadable)) radians(float2); -//extern float3 __attribute__((overloadable)) radians(float3); -//extern float4 __attribute__((overloadable)) radians(float4); -//extern float8 __attribute__((overloadable)) radians(float8); -//extern float16 __attribute__((overloadable)) radians(float16); +extern float2 __attribute__((overloadable)) pow(float2, float2); +extern float3 __attribute__((overloadable)) pow(float3, float3); +extern float4 __attribute__((overloadable)) pow(float4, float4); +extern float8 __attribute__((overloadable)) pow(float8, float8); +extern float16 __attribute__((overloadable)) pow(float16, float16); + +extern float __attribute__((overloadable)) pown(float, int); +extern float2 __attribute__((overloadable)) pown(float2, int2); +extern float3 __attribute__((overloadable)) pown(float3, int3); +extern float4 __attribute__((overloadable)) pown(float4, int4); +extern float8 __attribute__((overloadable)) pown(float8, int8); +extern float16 __attribute__((overloadable)) pown(float16, int16); + +extern float __attribute__((overloadable)) powr(float, float); +extern float2 __attribute__((overloadable)) powr(float2, float2); +extern float3 __attribute__((overloadable)) powr(float3, float3); +extern float4 __attribute__((overloadable)) powr(float4, float4); +extern float8 __attribute__((overloadable)) powr(float8, float8); +extern float16 __attribute__((overloadable)) powr(float16, float16); + +extern float __attribute__((overloadable)) remainder(float, float); +extern float2 __attribute__((overloadable)) remainder(float2, float2); +extern float3 __attribute__((overloadable)) remainder(float3, float3); +extern float4 __attribute__((overloadable)) remainder(float4, float4); +extern float8 __attribute__((overloadable)) remainder(float8, float8); +extern float16 __attribute__((overloadable)) remainder(float16, float16); + +extern float __attribute__((overloadable)) remquo(float, float, float *); +extern float2 __attribute__((overloadable)) remquo(float2, float2, float2 *); +extern float3 __attribute__((overloadable)) remquo(float3, float3, float3 *); +extern float4 __attribute__((overloadable)) remquo(float4, float4, float4 *); +extern float8 __attribute__((overloadable)) remquo(float8, float8, float8 *); +extern float16 __attribute__((overloadable)) remquo(float16, float16, float16 *); extern float __attribute__((overloadable)) rint(float); -//extern float2 __attribute__((overloadable)) rint(float2); -//extern float3 __attribute__((overloadable)) rint(float3); -//extern float4 __attribute__((overloadable)) rint(float4); -//extern float8 __attribute__((overloadable)) rint(float8); -//extern float16 __attribute__((overloadable)) rint(float16); +extern float2 __attribute__((overloadable)) rint(float2); +extern float3 __attribute__((overloadable)) rint(float3); +extern float4 __attribute__((overloadable)) rint(float4); +extern float8 __attribute__((overloadable)) rint(float8); +extern float16 __attribute__((overloadable)) rint(float16); + +extern float __attribute__((overloadable)) rootn(float, int); +extern float2 __attribute__((overloadable)) rootn(float2, int2); +extern float3 __attribute__((overloadable)) rootn(float3, int3); +extern float4 __attribute__((overloadable)) rootn(float4, int4); +extern float8 __attribute__((overloadable)) rootn(float8, int8); +extern float16 __attribute__((overloadable)) rootn(float16, int16); extern float __attribute__((overloadable)) round(float); -//extern float2 __attribute__((overloadable)) round(float2); -//extern float3 __attribute__((overloadable)) round(float3); -//extern float4 __attribute__((overloadable)) round(float4); -//extern float8 __attribute__((overloadable)) round(float8); -//extern float16 __attribute__((overloadable)) round(float16); +extern float2 __attribute__((overloadable)) round(float2); +extern float3 __attribute__((overloadable)) round(float3); +extern float4 __attribute__((overloadable)) round(float4); +extern float8 __attribute__((overloadable)) round(float8); +extern float16 __attribute__((overloadable)) round(float16); extern float __attribute__((overloadable)) rsqrt(float); -//extern float2 __attribute__((overloadable)) rsqrt(float2); -//extern float3 __attribute__((overloadable)) rsqrt(float3); -//extern float4 __attribute__((overloadable)) rsqrt(float4); -//extern float8 __attribute__((overloadable)) rsqrt(float8); -//extern float16 __attribute__((overloadable)) rsqrt(float16); - -extern float __attribute__((overloadable)) sign(float); -//extern float2 __attribute__((overloadable)) sign(float2); -//extern float3 __attribute__((overloadable)) sign(float3); -//extern float4 __attribute__((overloadable)) sign(float4); -//extern float8 __attribute__((overloadable)) sign(float8); -//extern float16 __attribute__((overloadable)) sign(float16); +extern float2 __attribute__((overloadable)) rsqrt(float2); +extern float3 __attribute__((overloadable)) rsqrt(float3); +extern float4 __attribute__((overloadable)) rsqrt(float4); +extern float8 __attribute__((overloadable)) rsqrt(float8); +extern float16 __attribute__((overloadable)) rsqrt(float16); extern float __attribute__((overloadable)) sin(float); -//extern float2 __attribute__((overloadable)) sin(float2); -//extern float3 __attribute__((overloadable)) sin(float3); -//extern float4 __attribute__((overloadable)) sin(float4); -//extern float8 __attribute__((overloadable)) sin(float8); -//extern float16 __attribute__((overloadable)) sin(float16); +extern float2 __attribute__((overloadable)) sin(float2); +extern float3 __attribute__((overloadable)) sin(float3); +extern float4 __attribute__((overloadable)) sin(float4); +extern float8 __attribute__((overloadable)) sin(float8); +extern float16 __attribute__((overloadable)) sin(float16); + +extern float __attribute__((overloadable)) sincos(float, float *); +extern float2 __attribute__((overloadable)) sincos(float2, float2 *); +extern float3 __attribute__((overloadable)) sincos(float3, float3 *); +extern float4 __attribute__((overloadable)) sincos(float4, float4 *); +extern float8 __attribute__((overloadable)) sincos(float8, float8 *); +extern float16 __attribute__((overloadable)) sincos(float16, float16 *); + +extern float __attribute__((overloadable)) sinh(float); +extern float2 __attribute__((overloadable)) sinh(float2); +extern float3 __attribute__((overloadable)) sinh(float3); +extern float4 __attribute__((overloadable)) sinh(float4); +extern float8 __attribute__((overloadable)) sinh(float8); +extern float16 __attribute__((overloadable)) sinh(float16); + +extern float __attribute__((overloadable)) sinpi(float); +extern float2 __attribute__((overloadable)) sinpi(float2); +extern float3 __attribute__((overloadable)) sinpi(float3); +extern float4 __attribute__((overloadable)) sinpi(float4); +extern float8 __attribute__((overloadable)) sinpi(float8); +extern float16 __attribute__((overloadable)) sinpi(float16); extern float __attribute__((overloadable)) sqrt(float); -//extern float2 __attribute__((overloadable)) sqrt(float2); -//extern float3 __attribute__((overloadable)) sqrt(float3); -//extern float4 __attribute__((overloadable)) sqrt(float4); -//extern float8 __attribute__((overloadable)) sqrt(float8); -//extern float16 __attribute__((overloadable)) sqrt(float16); +extern float2 __attribute__((overloadable)) sqrt(float2); +extern float3 __attribute__((overloadable)) sqrt(float3); +extern float4 __attribute__((overloadable)) sqrt(float4); +extern float8 __attribute__((overloadable)) sqrt(float8); +extern float16 __attribute__((overloadable)) sqrt(float16); extern float __attribute__((overloadable)) tan(float); -//extern float2 __attribute__((overloadable)) tan(float2); -//extern float3 __attribute__((overloadable)) tan(float3); -//extern float4 __attribute__((overloadable)) tan(float4); -//extern float8 __attribute__((overloadable)) tan(float8); -//extern float16 __attribute__((overloadable)) tan(float16); +extern float2 __attribute__((overloadable)) tan(float2); +extern float3 __attribute__((overloadable)) tan(float3); +extern float4 __attribute__((overloadable)) tan(float4); +extern float8 __attribute__((overloadable)) tan(float8); +extern float16 __attribute__((overloadable)) tan(float16); + +extern float __attribute__((overloadable)) tanh(float); +extern float2 __attribute__((overloadable)) tanh(float2); +extern float3 __attribute__((overloadable)) tanh(float3); +extern float4 __attribute__((overloadable)) tanh(float4); +extern float8 __attribute__((overloadable)) tanh(float8); +extern float16 __attribute__((overloadable)) tanh(float16); + +extern float __attribute__((overloadable)) tanpi(float); +extern float2 __attribute__((overloadable)) tanpi(float2); +extern float3 __attribute__((overloadable)) tanpi(float3); +extern float4 __attribute__((overloadable)) tanpi(float4); +extern float8 __attribute__((overloadable)) tanpi(float8); +extern float16 __attribute__((overloadable)) tanpi(float16); + +extern float __attribute__((overloadable)) tgamma(float); +extern float2 __attribute__((overloadable)) tgamma(float2); +extern float3 __attribute__((overloadable)) tgamma(float3); +extern float4 __attribute__((overloadable)) tgamma(float4); +extern float8 __attribute__((overloadable)) tgamma(float8); +extern float16 __attribute__((overloadable)) tgamma(float16); extern float __attribute__((overloadable)) trunc(float); -//extern float2 __attribute__((overloadable)) trunc(float2); -//extern float3 __attribute__((overloadable)) trunc(float3); -//extern float4 __attribute__((overloadable)) trunc(float4); -//extern float8 __attribute__((overloadable)) trunc(float8); -//extern float16 __attribute__((overloadable)) trunc(float16); +extern float2 __attribute__((overloadable)) trunc(float2); +extern float3 __attribute__((overloadable)) trunc(float3); +extern float4 __attribute__((overloadable)) trunc(float4); +extern float8 __attribute__((overloadable)) trunc(float8); +extern float16 __attribute__((overloadable)) trunc(float16); + + +// Int ops (partial), 6.11.3 +extern uint __attribute__((overloadable)) abs(int); +extern ushort __attribute__((overloadable)) abs(short); +extern uchar __attribute__((overloadable)) abs(char); +extern uint __attribute__((overloadable)) clz(uint); +extern int __attribute__((overloadable)) clz(int); +extern ushort __attribute__((overloadable)) clz(ushort); +extern short __attribute__((overloadable)) clz(short); +extern uchar __attribute__((overloadable)) clz(uchar); +extern char __attribute__((overloadable)) clz(char); -// Int ops +extern uint __attribute__((overloadable)) min(uint); +extern int __attribute__((overloadable)) min(int); +extern ushort __attribute__((overloadable)) min(ushort); +extern short __attribute__((overloadable)) min(short); +extern uchar __attribute__((overloadable)) min(uchar); +extern char __attribute__((overloadable)) min(char); -extern int __attribute__((overloadable)) abs(int); -//extern int2 __attribute__((overloadable)) abs(int2); -//extern int3 __attribute__((overloadable)) abs(int3); -//extern int4 __attribute__((overloadable)) abs(int4); -//extern int8 __attribute__((overloadable)) abs(int8); -//extern int16 __attribute__((overloadable)) abs(int16); +extern uint __attribute__((overloadable)) max(uint); +extern int __attribute__((overloadable)) max(int); +extern ushort __attribute__((overloadable)) max(ushort); +extern short __attribute__((overloadable)) max(short); +extern uchar __attribute__((overloadable)) max(uchar); +extern char __attribute__((overloadable)) max(char); -/* -extern float modf(float, float); + +// 6.11.4 + +extern float __attribute__((overloadable)) clamp(float, float, float); +extern float2 __attribute__((overloadable)) clamp(float2, float2, float2); +extern float3 __attribute__((overloadable)) clamp(float3, float3, float3); +extern float4 __attribute__((overloadable)) clamp(float4, float4, float4); +extern float8 __attribute__((overloadable)) clamp(float8, float8, float8); +extern float16 __attribute__((overloadable)) clamp(float16, float16, float16); +extern float2 __attribute__((overloadable)) clamp(float2, float, float); +extern float3 __attribute__((overloadable)) clamp(float3, float, float); +extern float4 __attribute__((overloadable)) clamp(float4, float, float); +extern float8 __attribute__((overloadable)) clamp(float8, float, float); +extern float16 __attribute__((overloadable)) clamp(float16, float, float); + +extern float __attribute__((overloadable)) degrees(float); +extern float2 __attribute__((overloadable)) degrees(float2); +extern float3 __attribute__((overloadable)) degrees(float3); +extern float4 __attribute__((overloadable)) degrees(float4); +extern float8 __attribute__((overloadable)) degrees(float8); +extern float16 __attribute__((overloadable)) degrees(float16); + +extern float __attribute__((overloadable)) max(float, float); +extern float2 __attribute__((overloadable)) max(float2, float2); +extern float3 __attribute__((overloadable)) max(float3, float3); +extern float4 __attribute__((overloadable)) max(float4, float4); +extern float8 __attribute__((overloadable)) max(float8, float8); +extern float16 __attribute__((overloadable)) max(float16, float16); +extern float2 __attribute__((overloadable)) max(float2, float); +extern float3 __attribute__((overloadable)) max(float3, float); +extern float4 __attribute__((overloadable)) max(float4, float); +extern float8 __attribute__((overloadable)) max(float8, float); +extern float16 __attribute__((overloadable)) max(float16, float); + +extern float __attribute__((overloadable)) min(float, float); +extern float2 __attribute__((overloadable)) min(float2, float2); +extern float3 __attribute__((overloadable)) min(float3, float3); +extern float4 __attribute__((overloadable)) min(float4, float4); +extern float8 __attribute__((overloadable)) min(float8, float8); +extern float16 __attribute__((overloadable)) min(float16, float16); +extern float2 __attribute__((overloadable)) min(float2, float); +extern float3 __attribute__((overloadable)) min(float3, float); +extern float4 __attribute__((overloadable)) min(float4, float); +extern float8 __attribute__((overloadable)) min(float8, float); +extern float16 __attribute__((overloadable)) min(float16, float); + +extern float __attribute__((overloadable)) mix(float, float, float); +extern float2 __attribute__((overloadable)) mix(float2, float2, float2); +extern float3 __attribute__((overloadable)) mix(float3, float3, float3); +extern float4 __attribute__((overloadable)) mix(float4, float4, float4); +extern float8 __attribute__((overloadable)) mix(float8, float8, float8); +extern float16 __attribute__((overloadable)) mix(float16, float16, float16); +extern float2 __attribute__((overloadable)) mix(float2, float2, float); +extern float3 __attribute__((overloadable)) mix(float3, float3, float); +extern float4 __attribute__((overloadable)) mix(float4, float4, float); +extern float8 __attribute__((overloadable)) mix(float8, float8, float); +extern float16 __attribute__((overloadable)) mix(float16, float16, float); + +extern float __attribute__((overloadable)) radians(float); +extern float2 __attribute__((overloadable)) radians(float2); +extern float3 __attribute__((overloadable)) radians(float3); +extern float4 __attribute__((overloadable)) radians(float4); +extern float8 __attribute__((overloadable)) radians(float8); +extern float16 __attribute__((overloadable)) radians(float16); + +extern float __attribute__((overloadable)) step(float, float); +extern float2 __attribute__((overloadable)) step(float2, float2); +extern float3 __attribute__((overloadable)) step(float3, float3); +extern float4 __attribute__((overloadable)) step(float4, float4); +extern float8 __attribute__((overloadable)) step(float8, float8); +extern float16 __attribute__((overloadable)) step(float16, float16); +extern float2 __attribute__((overloadable)) step(float, float2); +extern float3 __attribute__((overloadable)) step(float, float3); +extern float4 __attribute__((overloadable)) step(float, float4); +extern float8 __attribute__((overloadable)) step(float, float8); +extern float16 __attribute__((overloadable)) step(float, float16); + +extern float __attribute__((overloadable)) smoothstep(float, float, float); +extern float2 __attribute__((overloadable)) smoothstep(float2, float2, float2); +extern float3 __attribute__((overloadable)) smoothstep(float3, float3, float3); +extern float4 __attribute__((overloadable)) smoothstep(float4, float4, float4); +extern float8 __attribute__((overloadable)) smoothstep(float8, float8, float8); +extern float16 __attribute__((overloadable)) smoothstep(float16, float16, float16); +extern float2 __attribute__((overloadable)) smoothstep(float, float, float2); +extern float3 __attribute__((overloadable)) smoothstep(float, float, float3); +extern float4 __attribute__((overloadable)) smoothstep(float, float, float4); +extern float8 __attribute__((overloadable)) smoothstep(float, float, float8); +extern float16 __attribute__((overloadable)) smoothstep(float, float, float16); + +extern float __attribute__((overloadable)) sign(float); +extern float2 __attribute__((overloadable)) sign(float2); +extern float3 __attribute__((overloadable)) sign(float3); +extern float4 __attribute__((overloadable)) sign(float4); +extern float8 __attribute__((overloadable)) sign(float8); +extern float16 __attribute__((overloadable)) sign(float16); + +// 6.11.5 +extern float3 __attribute__((overloadable)) cross(float2, float2); +extern float3 __attribute__((overloadable)) cross(float3, float3); +extern float4 __attribute__((overloadable)) cross(float4, float4); + +extern float __attribute__((overloadable)) dot(float, float); +extern float __attribute__((overloadable)) dot(float2, float2); +extern float __attribute__((overloadable)) dot(float3, float3); +extern float __attribute__((overloadable)) dot(float4, float4); + +extern float __attribute__((overloadable)) distance(float, float); +extern float __attribute__((overloadable)) distance(float2, float2); +extern float __attribute__((overloadable)) distance(float3, float3); +extern float __attribute__((overloadable)) distance(float4, float4); + +extern float __attribute__((overloadable)) length(float); +extern float __attribute__((overloadable)) length(float2); +extern float __attribute__((overloadable)) length(float3); +extern float __attribute__((overloadable)) length(float4); + +extern float __attribute__((overloadable)) normalize(float); +extern float2 __attribute__((overloadable)) normalize(float2); +extern float3 __attribute__((overloadable)) normalize(float3); +extern float4 __attribute__((overloadable)) normalize(float4); + + +// RS specific functions extern float randf(float); extern float randf2(float, float); -extern float fracf(float); -extern float lerpf(float, float, float); extern float mapf(float, float, float, float, float); -*/ + +extern float __attribute__((overloadable)) frac(float); + +extern void debugP(int, void *); +extern void debugPi(int, int); +extern void debugPf(int, float); +extern void debugF(const char *, float); +extern void debugI32(const char *, int); +extern void debugHexI32(const char *, int); + +extern void matrixLoadIdentity(void *mat); +extern void matrixLoadFloat(void *mat, const float *f); +extern void matrixLoadMat(void *mat, const void *newmat); +extern void matrixLoadRotate(void *mat, float rot, float x, float y, float z); +extern void matrixLoadScale(void *mat, float x, float y, float z); +extern void matrixLoadTranslate(void *mat, float x, float y, float z); +extern void matrixLoadMultiply(void *mat, const void *lhs, const void *rhs); +extern void matrixMultiply(void *mat, const void *rhs); +extern void matrixRotate(void *mat, float rot, float x, float y, float z); +extern void matrixScale(void *mat, float x, float y, float z); +extern void matrixTranslate(void *mat, float x, float y, float z); + |