diff options
Diffstat (limited to 'tests/RenderScriptTests')
215 files changed, 18718 insertions, 1238 deletions
diff --git a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/ComputePerf.java b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/ComputePerf.java index f7abe8b..5446f66 100644 --- a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/ComputePerf.java +++ b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/ComputePerf.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2011-2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,10 +22,10 @@ import android.graphics.BitmapFactory; import android.graphics.Bitmap; import android.renderscript.RenderScript; import android.renderscript.Allocation; +import android.util.Log; import android.widget.ImageView; public class ComputePerf extends Activity { - private LaunchTest mLT; private Mandelbrot mMandel; private RenderScript mRS; @@ -35,14 +35,28 @@ public class ComputePerf extends Activity { super.onCreate(savedInstanceState); setContentView(R.layout.main); + final int numTries = 100; + + long timesXLW = 0; + long timesXYW = 0; + mRS = RenderScript.create(this); mLT = new LaunchTest(mRS, getResources()); - mLT.run(); - mLT.run(); + mLT.XLW(); + mLT.XYW(); + for (int i = 0; i < numTries; i++) { + timesXLW += mLT.XLW(); + timesXYW += mLT.XYW(); + } + + timesXLW /= numTries; + timesXYW /= numTries; + + // XLW and XYW running times should match pretty closely + Log.v("ComputePerf", "xlw launch test " + timesXLW + "ms"); + Log.v("ComputePerf", "xyw launch test " + timesXYW + "ms"); mMandel = new Mandelbrot(mRS, getResources()); mMandel.run(); - } - } diff --git a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/LaunchTest.java b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/LaunchTest.java index 0c29ce1..e2312ba 100644 --- a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/LaunchTest.java +++ b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/LaunchTest.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2011-2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,7 +19,7 @@ package com.example.android.rs.computeperf; import android.content.res.Resources; import android.renderscript.*; -public class LaunchTest implements Runnable { +public class LaunchTest { private RenderScript mRS; private Allocation mAllocationX; private Allocation mAllocationXY; @@ -40,18 +40,19 @@ public class LaunchTest implements Runnable { mScript_xlw.bind_buf(mAllocationXY); } - public void run() { + public long XLW() { long t = java.lang.System.currentTimeMillis(); mScript_xlw.forEach_root(mAllocationX); mRS.finish(); t = java.lang.System.currentTimeMillis() - t; - android.util.Log.v("ComputePerf", "xlw launch test ms " + t); + return t; + } - t = java.lang.System.currentTimeMillis(); + public long XYW() { + long t = java.lang.System.currentTimeMillis(); mScript_xyw.forEach_root(mAllocationXY); mRS.finish(); t = java.lang.System.currentTimeMillis() - t; - android.util.Log.v("ComputePerf", "xyw launch test ms " + t); + return t; } - } diff --git a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/mandelbrot.rs b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/mandelbrot.rs index a7987b3..0ffb0e5 100644 --- a/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/mandelbrot.rs +++ b/tests/RenderScriptTests/ComputePerf/src/com/example/android/rs/computeperf/mandelbrot.rs @@ -25,13 +25,14 @@ void root(uchar4 *v_out, uint32_t x, uint32_t y) { p.y = -1.f + ((float)y / gDimY) * 2.f; float2 t = 0; + float2 t2 = t * t; int iteration = 0; - while((t.x*t.x + t.y*t.y < 4.f) && (iteration < gMaxIteration)) { - float2 t2 = t * t; + while((t2.x + t2.y < 4.f) && (iteration < gMaxIteration)) { float xtemp = t2.x - t2.y + p.x; t.y = 2 * t.x * t.y + p.y; t.x = xtemp; iteration++; + t2 = t * t; } if(iteration >= gMaxIteration) { diff --git a/tests/RenderScriptTests/Fountain_v11/Android.mk b/tests/RenderScriptTests/Fountain_v11/Android.mk new file mode 100644 index 0000000..e51115c --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/Android.mk @@ -0,0 +1,32 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +ifneq ($(TARGET_SIMULATOR),true) + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) +#LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript + +LOCAL_PACKAGE_NAME := Fountain_v11 +LOCAL_SDK_VERSION := 11 + +include $(BUILD_PACKAGE) + +endif diff --git a/tests/RenderScriptTests/Fountain_v11/AndroidManifest.xml b/tests/RenderScriptTests/Fountain_v11/AndroidManifest.xml new file mode 100644 index 0000000..fcb4faf --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/AndroidManifest.xml @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.fountain_v11"> + <uses-sdk android:minSdkVersion="11" /> + <application + android:label="Fountain_v11" + android:icon="@drawable/test_pattern"> + <activity android:name="Fountain_v11"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/Fountain_v11/_index.html b/tests/RenderScriptTests/Fountain_v11/_index.html new file mode 100644 index 0000000..223242f --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/_index.html @@ -0,0 +1,5 @@ +<p>An example that renders many dots on the screen that follow a user's touch. The dots fall +to the bottom of the screen when the user releases the finger.</p> + + + diff --git a/tests/RenderScriptTests/Fountain_v11/res/drawable/test_pattern.png b/tests/RenderScriptTests/Fountain_v11/res/drawable/test_pattern.png Binary files differnew file mode 100644 index 0000000..e7d1455 --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/res/drawable/test_pattern.png diff --git a/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainRS.java b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainRS.java new file mode 100644 index 0000000..e858100 --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainRS.java @@ -0,0 +1,72 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain_v11; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + + +public class FountainRS { + public static final int PART_COUNT = 50000; + + public FountainRS() { + } + + private Resources mRes; + private RenderScriptGL mRS; + private ScriptC_fountain mScript; + public void init(RenderScriptGL rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + + ProgramFragmentFixedFunction.Builder pfb = new ProgramFragmentFixedFunction.Builder(rs); + pfb.setVaryingColor(true); + rs.bindProgramFragment(pfb.create()); + + ScriptField_Point points = new ScriptField_Point(mRS, PART_COUNT);// + // Allocation.USAGE_GRAPHICS_VERTEX); + + Mesh.AllocationBuilder smb = new Mesh.AllocationBuilder(mRS); + smb.addVertexAllocation(points.getAllocation()); + smb.addIndexSetType(Mesh.Primitive.POINT); + Mesh sm = smb.create(); + + mScript = new ScriptC_fountain(mRS, mRes, R.raw.fountain); + mScript.set_partMesh(sm); + mScript.bind_point(points); + mRS.bindRootScript(mScript); + } + + boolean holdingColor[] = new boolean[10]; + public void newTouchPosition(float x, float y, float pressure, int id) { + if (id >= holdingColor.length) { + return; + } + int rate = (int)(pressure * pressure * 500.f); + if (rate > 500) { + rate = 500; + } + if (rate > 0) { + mScript.invoke_addParticles(rate, x, y, id, !holdingColor[id]); + holdingColor[id] = true; + } else { + holdingColor[id] = false; + } + + } +} diff --git a/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainView.java b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainView.java new file mode 100644 index 0000000..e82376c --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/FountainView.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain_v11; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class FountainView extends RSSurfaceView { + + public FountainView(Context context) { + super(context); + //setFocusable(true); + } + + private RenderScriptGL mRS; + private FountainRS mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + if (mRS == null) { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + mRS = createRenderScriptGL(sc); + mRS.setSurface(holder, w, h); + mRender = new FountainRS(); + mRender.init(mRS, getResources(), w, h); + } + } + + @Override + protected void onDetachedFromWindow() { + if (mRS != null) { + mRS = null; + destroyRenderScriptGL(); + } + } + + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + int act = ev.getActionMasked(); + if (act == ev.ACTION_UP) { + mRender.newTouchPosition(0, 0, 0, ev.getPointerId(0)); + return false; + } else if (act == MotionEvent.ACTION_POINTER_UP) { + // only one pointer going up, we can get the index like this + int pointerIndex = ev.getActionIndex(); + int pointerId = ev.getPointerId(pointerIndex); + mRender.newTouchPosition(0, 0, 0, pointerId); + } + int count = ev.getHistorySize(); + int pcount = ev.getPointerCount(); + + for (int p=0; p < pcount; p++) { + int id = ev.getPointerId(p); + mRender.newTouchPosition(ev.getX(p), + ev.getY(p), + ev.getPressure(p), + id); + + for (int i=0; i < count; i++) { + mRender.newTouchPosition(ev.getHistoricalX(p, i), + ev.getHistoricalY(p, i), + ev.getHistoricalPressure(p, i), + id); + } + } + return true; + } +} + + diff --git a/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/Fountain_v11.java b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/Fountain_v11.java new file mode 100644 index 0000000..2c07b27 --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/Fountain_v11.java @@ -0,0 +1,96 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.fountain_v11; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Config; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class Fountain_v11 extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + private FountainView mView; + + // get the current looper (from your Activity UI thread for instance + + + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new FountainView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + Log.e("rs", "onResume"); + + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onResume(); + mView.resume(); + } + + @Override + protected void onPause() { + Log.e("rs", "onPause"); + + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onPause(); + mView.pause(); + + + + //Runtime.getRuntime().exit(0); + } + + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} + diff --git a/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/fountain.rs b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/fountain.rs new file mode 100644 index 0000000..3b6c89a --- /dev/null +++ b/tests/RenderScriptTests/Fountain_v11/src/com/android/fountain/fountain.rs @@ -0,0 +1,69 @@ +// Fountain test script +#pragma version(1) + +#pragma rs java_package_name(com.android.fountain_v11) + +#pragma stateFragment(parent) + +#include "rs_graphics.rsh" + +static int newPart = 0; +rs_mesh partMesh; + +typedef struct __attribute__((packed, aligned(4))) Point { + float2 delta; + float2 position; + uchar4 color; +} Point_t; +Point_t *point; + +int root() { + float dt = min(rsGetDt(), 0.1f); + rsgClearColor(0.f, 0.f, 0.f, 1.f); + const float height = rsgGetHeight(); + const int size = rsAllocationGetDimX(rsGetAllocation(point)); + float dy2 = dt * (10.f); + Point_t * p = point; + for (int ct=0; ct < size; ct++) { + p->delta.y += dy2; + p->position += p->delta; + if ((p->position.y > height) && (p->delta.y > 0)) { + p->delta.y *= -0.3f; + } + p++; + } + + rsgDrawMesh(partMesh); + return 1; +} + +static float4 partColor[10]; +void addParticles(int rate, float x, float y, int index, bool newColor) +{ + if (newColor) { + partColor[index].x = rsRand(0.5f, 1.0f); + partColor[index].y = rsRand(1.0f); + partColor[index].z = rsRand(1.0f); + } + float rMax = ((float)rate) * 0.02f; + int size = rsAllocationGetDimX(rsGetAllocation(point)); + uchar4 c = rsPackColorTo8888(partColor[index]); + + Point_t * np = &point[newPart]; + float2 p = {x, y}; + while (rate--) { + float angle = rsRand(3.14f * 2.f); + float len = rsRand(rMax); + np->delta.x = len * sin(angle); + np->delta.y = len * cos(angle); + np->position = p; + np->color = c; + newPart++; + np++; + if (newPart >= size) { + newPart = 0; + np = &point[newPart]; + } + } +} + diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java index 3615f60..7368260 100644 --- a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/ImageProcessingActivity.java @@ -283,6 +283,9 @@ public class ImageProcessingActivity extends Activity mRadius = MAX_RADIUS; mScript.set_radius(mRadius); + mScript.invoke_filter(); + mRS.finish(); + long t = java.lang.System.currentTimeMillis(); mScript.invoke_filter(); diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs index 86479d5..ee83496 100644 --- a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs @@ -1,4 +1,5 @@ #pragma version(1) +#pragma rs_fp_relaxed #include "ip.rsh" diff --git a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/vertical_blur.rs b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/vertical_blur.rs index 8b07bc2..a6da192 100644 --- a/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/vertical_blur.rs +++ b/tests/RenderScriptTests/ImageProcessing/src/com/android/rs/image/vertical_blur.rs @@ -1,4 +1,5 @@ #pragma version(1) +#pragma rs_fp_relaxed #include "ip.rsh" diff --git a/tests/RenderScriptTests/ModelViewer/src/com/android/modelviewer/simplemodel.rs b/tests/RenderScriptTests/ModelViewer/src/com/android/modelviewer/simplemodel.rs index 8cec409..de2a0a7 100644 --- a/tests/RenderScriptTests/ModelViewer/src/com/android/modelviewer/simplemodel.rs +++ b/tests/RenderScriptTests/ModelViewer/src/com/android/modelviewer/simplemodel.rs @@ -48,6 +48,14 @@ static float gZoom; static float gLastX; static float gLastY; +static float3 toFloat3(float x, float y, float z) { + float3 f; + f.x = x; + f.y = y; + f.z = z; + return f; +} + void onActionDown(float x, float y) { gLastX = x; gLastY = y; @@ -104,8 +112,8 @@ void updateMeshInfo() { rsgMeshComputeBoundingBox(info->mMesh, &minX, &minY, &minZ, &maxX, &maxY, &maxZ); - info->bBoxMin = (minX, minY, minZ); - info->bBoxMax = (maxX, maxY, maxZ); + info->bBoxMin = toFloat3(minX, minY, minZ); + info->bBoxMax = toFloat3(maxX, maxY, maxZ); gLookAt += (info->bBoxMin + info->bBoxMax)*0.5f; } gLookAt = gLookAt / (float)size; diff --git a/tests/RenderScriptTests/PerfTest/res/menu/loader_menu.xml b/tests/RenderScriptTests/PerfTest/res/menu/loader_menu.xml index 8234677..59a251d 100644 --- a/tests/RenderScriptTests/PerfTest/res/menu/loader_menu.xml +++ b/tests/RenderScriptTests/PerfTest/res/menu/loader_menu.xml @@ -18,8 +18,11 @@ --> <menu xmlns:android="http://schemas.android.com/apk/res/android"> - <item android:id="@+id/benchmark_mode" - android:title="@string/benchmark_mode" /> + <item android:id="@+id/benchmark_all" + android:title="@string/benchmark_all" /> + <item android:id="@+id/benchmark_one" + android:title="@string/benchmark_one" /> <item android:id="@+id/debug_mode" android:title="@string/debug_mode" /> </menu> + diff --git a/tests/RenderScriptTests/PerfTest/res/raw/singletexf.glsl b/tests/RenderScriptTests/PerfTest/res/raw/singletexf.glsl new file mode 100644 index 0000000..83dfc7f --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/res/raw/singletexf.glsl @@ -0,0 +1,8 @@ +varying vec2 varTex0; + +void main() { + lowp vec3 col0 = texture2D(UNI_Tex0, varTex0).rgb; + gl_FragColor.xyz = col0; + gl_FragColor.w = 0.5; +} + diff --git a/tests/RenderScriptTests/PerfTest/res/raw/singletexfm.glsl b/tests/RenderScriptTests/PerfTest/res/raw/singletexfm.glsl new file mode 100644 index 0000000..656961c --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/res/raw/singletexfm.glsl @@ -0,0 +1,8 @@ +varying vec2 varTex0; + +void main() { + lowp vec3 col0 = texture2D(UNI_Tex0, varTex0).rgb; + gl_FragColor.xyz = col0 * UNI_modulate.rgb; + gl_FragColor.w = UNI_modulate.a; +} + diff --git a/tests/RenderScriptTests/PerfTest/res/values/strings.xml b/tests/RenderScriptTests/PerfTest/res/values/strings.xml index 627ac21..ce9819e 100644 --- a/tests/RenderScriptTests/PerfTest/res/values/strings.xml +++ b/tests/RenderScriptTests/PerfTest/res/values/strings.xml @@ -19,6 +19,8 @@ <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> <skip /> - <string name="benchmark_mode">Benchmark Mode</string> + <string name="benchmark_all">Benchmark All</string> + <string name="benchmark_one">Benchmark One</string> <string name="debug_mode">Debug Mode</string> </resources> + diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/FillTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/FillTest.java new file mode 100644 index 0000000..41f664a --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/FillTest.java @@ -0,0 +1,171 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; + +import android.os.Environment; +import android.content.res.Resources; +import android.renderscript.*; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; + + +import android.util.Log; + + +public class FillTest implements RsBenchBaseTest{ + + private static final String TAG = "FillTest"; + private RenderScriptGL mRS; + private Resources mRes; + + // Custom shaders + private ProgramFragment mProgFragmentMultitex; + private ProgramFragment mProgFragmentSingletex; + private ProgramFragment mProgFragmentSingletexModulate; + private final BitmapFactory.Options mOptionsARGB = new BitmapFactory.Options(); + int mBenchmarkDimX; + int mBenchmarkDimY; + + private ScriptC_fill_test mFillScript; + ScriptField_TestScripts_s.Item[] mTests; + ScriptField_FillTestFragData_s mFragData; + + private final String[] mNames = { + "Fill screen 10x singletexture", + "Fill screen 10x 3tex multitexture", + "Fill screen 10x blended singletexture", + "Fill screen 10x blended 3tex multitexture", + "Fill screen 3x modulate blended singletexture", + "Fill screen 1x modulate blended singletexture", + }; + + public FillTest() { + mOptionsARGB.inScaled = false; + mOptionsARGB.inPreferredConfig = Bitmap.Config.ARGB_8888; + mBenchmarkDimX = 1280; + mBenchmarkDimY = 720; + } + + void addTest(int index, int testId, int blend, int quadCount) { + mTests[index] = new ScriptField_TestScripts_s.Item(); + mTests[index].testScript = mFillScript; + mTests[index].testName = Allocation.createFromString(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + mTests[index].debugName = RsBenchRS.createZeroTerminatedAlloc(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + + ScriptField_FillTestData_s.Item dataItem = new ScriptField_FillTestData_s.Item(); + dataItem.testId = testId; + dataItem.blend = blend; + dataItem.quadCount = quadCount; + ScriptField_FillTestData_s testData = new ScriptField_FillTestData_s(mRS, 1); + testData.set(dataItem, 0, true); + mTests[index].testData = testData.getAllocation(); + } + + public boolean init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + initCustomShaders(); + initFillScript(); + mTests = new ScriptField_TestScripts_s.Item[mNames.length]; + + int index = 0; + + addTest(index++, 1 /*testId*/, 0 /*blend*/, 10 /*quadCount*/); + addTest(index++, 0 /*testId*/, 0 /*blend*/, 10 /*quadCount*/); + addTest(index++, 1 /*testId*/, 1 /*blend*/, 10 /*quadCount*/); + addTest(index++, 0 /*testId*/, 1 /*blend*/, 10 /*quadCount*/); + addTest(index++, 2 /*testId*/, 1 /*blend*/, 3 /*quadCount*/); + addTest(index++, 2 /*testId*/, 1 /*blend*/, 1 /*quadCount*/); + + return true; + } + + public ScriptField_TestScripts_s.Item[] getTests() { + return mTests; + } + + public String[] getTestNames() { + return mNames; + } + + private void initCustomShaders() { + ProgramFragment.Builder pfbCustom = new ProgramFragment.Builder(mRS); + pfbCustom.setShader(mRes, R.raw.multitexf); + for (int texCount = 0; texCount < 3; texCount ++) { + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + } + mProgFragmentMultitex = pfbCustom.create(); + + pfbCustom = new ProgramFragment.Builder(mRS); + pfbCustom.setShader(mRes, R.raw.singletexf); + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + mProgFragmentSingletex = pfbCustom.create(); + + pfbCustom = new ProgramFragment.Builder(mRS); + pfbCustom.setShader(mRes, R.raw.singletexfm); + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + mFragData = new ScriptField_FillTestFragData_s(mRS, 1); + pfbCustom.addConstant(mFragData.getType()); + mProgFragmentSingletexModulate = pfbCustom.create(); + mProgFragmentSingletexModulate.bindConstants(mFragData.getAllocation(), 0); + } + + private Allocation loadTextureARGB(int id) { + Bitmap b = BitmapFactory.decodeResource(mRes, id, mOptionsARGB); + return Allocation.createFromBitmap(mRS, b, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + private Allocation loadTextureRGB(int id) { + return Allocation.createFromBitmapResource(mRS, mRes, id, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + void initFillScript() { + mFillScript = new ScriptC_fill_test(mRS, mRes, R.raw.fill_test); + + ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); + ProgramVertexFixedFunction progVertex = pvb.create(); + ProgramVertexFixedFunction.Constants PVA = new ProgramVertexFixedFunction.Constants(mRS); + ((ProgramVertexFixedFunction)progVertex).bindConstants(PVA); + Matrix4f proj = new Matrix4f(); + proj.loadOrthoWindow(mBenchmarkDimX, mBenchmarkDimY); + PVA.setProjection(proj); + mFillScript.set_gProgVertex(progVertex); + + mFillScript.set_gProgFragmentTexture(mProgFragmentSingletex); + mFillScript.set_gProgFragmentTextureModulate(mProgFragmentSingletexModulate); + mFillScript.set_gProgFragmentMultitex(mProgFragmentMultitex); + mFillScript.set_gProgStoreBlendNone(ProgramStore.BLEND_NONE_DEPTH_NONE(mRS)); + mFillScript.set_gProgStoreBlendAlpha(ProgramStore.BLEND_ALPHA_DEPTH_NONE(mRS)); + + mFillScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); + mFillScript.set_gLinearWrap(Sampler.WRAP_LINEAR(mRS)); + mFillScript.set_gTexTorus(loadTextureRGB(R.drawable.torusmap)); + mFillScript.set_gTexOpaque(loadTextureRGB(R.drawable.data)); + mFillScript.set_gTexTransparent(loadTextureARGB(R.drawable.leaf)); + mFillScript.set_gTexChecker(loadTextureRGB(R.drawable.checker)); + + mFillScript.bind_gFragData(mFragData); + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/MeshTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/MeshTest.java new file mode 100644 index 0000000..cdb4435 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/MeshTest.java @@ -0,0 +1,170 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; + +import android.os.Environment; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.renderscript.*; +import android.renderscript.Element.DataKind; +import android.renderscript.Element.DataType; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Program.TextureType; +import android.renderscript.RenderScript.RSMessageHandler; +import android.renderscript.Mesh.Primitive; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramVertexFixedFunction; + +import android.util.Log; + + +public class MeshTest implements RsBenchBaseTest{ + + private static final String TAG = "MeshTest"; + private RenderScriptGL mRS; + private Resources mRes; + + int mBenchmarkDimX; + int mBenchmarkDimY; + + private Mesh m10by10Mesh; + private Mesh m100by100Mesh; + private Mesh mWbyHMesh; + + private ScriptC_mesh_test mGeoScript; + + private final BitmapFactory.Options mOptionsARGB = new BitmapFactory.Options(); + + ScriptField_TestScripts_s.Item[] mTests; + + private final String[] mNames = { + "Full screen mesh 10 by 10", + "Full screen mesh 100 by 100", + "Full screen mesh W / 4 by H / 4" + }; + + public MeshTest() { + mBenchmarkDimX = 1280; + mBenchmarkDimY = 720; + } + + void addTest(int index, int meshNum) { + mTests[index] = new ScriptField_TestScripts_s.Item(); + mTests[index].testScript = mGeoScript; + mTests[index].testName = Allocation.createFromString(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + mTests[index].debugName = RsBenchRS.createZeroTerminatedAlloc(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + + ScriptField_MeshTestData_s.Item dataItem = new ScriptField_MeshTestData_s.Item(); + dataItem.meshNum = meshNum; + ScriptField_MeshTestData_s testData = new ScriptField_MeshTestData_s(mRS, 1); + testData.set(dataItem, 0, true); + mTests[index].testData = testData.getAllocation(); + } + + public boolean init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + initGeoScript(); + mTests = new ScriptField_TestScripts_s.Item[mNames.length]; + + int index = 0; + addTest(index++, 0 /*meshNum*/); + addTest(index++, 1 /*meshNum*/); + addTest(index++, 2 /*meshNum*/); + + return true; + } + + public ScriptField_TestScripts_s.Item[] getTests() { + return mTests; + } + + public String[] getTestNames() { + return mNames; + } + + private Mesh getMbyNMesh(float width, float height, int wResolution, int hResolution) { + + Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, + 2, Mesh.TriangleMeshBuilder.TEXTURE_0); + + for (int y = 0; y <= hResolution; y++) { + final float normalizedY = (float)y / hResolution; + final float yOffset = (normalizedY - 0.5f) * height; + for (int x = 0; x <= wResolution; x++) { + float normalizedX = (float)x / wResolution; + float xOffset = (normalizedX - 0.5f) * width; + tmb.setTexture((float)x % 2, (float)y % 2); + tmb.addVertex(xOffset, yOffset); + } + } + + for (int y = 0; y < hResolution; y++) { + final int curY = y * (wResolution + 1); + final int belowY = (y + 1) * (wResolution + 1); + for (int x = 0; x < wResolution; x++) { + int curV = curY + x; + int belowV = belowY + x; + tmb.addTriangle(curV, belowV, curV + 1); + tmb.addTriangle(belowV, belowV + 1, curV + 1); + } + } + + return tmb.create(true); + } + + private Allocation loadTextureRGB(int id) { + return Allocation.createFromBitmapResource(mRS, mRes, id, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + void initGeoScript() { + mGeoScript = new ScriptC_mesh_test(mRS, mRes, R.raw.mesh_test); + + ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); + ProgramVertexFixedFunction progVertex = pvb.create(); + ProgramVertexFixedFunction.Constants PVA = new ProgramVertexFixedFunction.Constants(mRS); + ((ProgramVertexFixedFunction)progVertex).bindConstants(PVA); + Matrix4f proj = new Matrix4f(); + proj.loadOrthoWindow(mBenchmarkDimX, mBenchmarkDimY); + PVA.setProjection(proj); + + mGeoScript.set_gProgVertex(progVertex); + ProgramFragmentFixedFunction.Builder texBuilder = new ProgramFragmentFixedFunction.Builder(mRS); + texBuilder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + mGeoScript.set_gProgFragmentTexture(texBuilder.create()); + mGeoScript.set_gProgStoreBlendNone(ProgramStore.BLEND_NONE_DEPTH_NONE(mRS)); + + mGeoScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); + mGeoScript.set_gTexOpaque(loadTextureRGB(R.drawable.data)); + + m10by10Mesh = getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, 10, 10); + m100by100Mesh = getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, 100, 100); + mWbyHMesh= getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, mBenchmarkDimX/4, mBenchmarkDimY/4); + + mGeoScript.set_g10by10Mesh(m10by10Mesh); + mGeoScript.set_g100by100Mesh(m100by100Mesh); + mGeoScript.set_gWbyHMesh(mWbyHMesh); + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBench.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBench.java index b336a4d..0dceafe 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBench.java +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBench.java @@ -93,22 +93,41 @@ public class RsBench extends Activity { public boolean onOptionsItemSelected(MenuItem item) { // Handle item selection switch (item.getItemId()) { - case R.id.benchmark_mode: - mView.setBenchmarkMode(); + case R.id.benchmark_all: + mView.setBenchmarkMode(-1); + mView.suspendRendering(false); return true; - case R.id.debug_mode: + case R.id.benchmark_one: + mView.suspendRendering(true); AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Pick a Test"); builder.setItems(mView.getTestNames(), new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int item) { Toast.makeText(getApplicationContext(), + "Starting to benchmark: " + mView.getTestNames()[item], + Toast.LENGTH_SHORT).show(); + mView.setBenchmarkMode(item); + mView.suspendRendering(false); + } + }); + builder.show(); + return true; + case R.id.debug_mode: + mView.suspendRendering(true); + AlertDialog.Builder debugBuilder = new AlertDialog.Builder(this); + debugBuilder.setTitle("Pick a Test"); + debugBuilder.setItems(mView.getTestNames(), + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int item) { + Toast.makeText(getApplicationContext(), "Switching to: " + mView.getTestNames()[item], Toast.LENGTH_SHORT).show(); mView.setDebugMode(item); + mView.suspendRendering(false); } }); - builder.show(); + debugBuilder.show(); return true; default: return super.onOptionsItemSelected(item); diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchBaseTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchBaseTest.java new file mode 100644 index 0000000..a9e1777 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchBaseTest.java @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; +import android.renderscript.*; +import android.content.res.Resources; + +interface RsBenchBaseTest { + boolean init(RenderScriptGL rs, Resources res); + + ScriptField_TestScripts_s.Item[] getTests(); + String[] getTestNames(); +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java index c375be5..4ac7dd5 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 The Android Open Source Project + * Copyright (C) 2010-2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,16 +26,11 @@ import java.io.OutputStream; import android.os.Environment; import android.content.res.Resources; -import android.graphics.Bitmap; -import android.graphics.BitmapFactory; import android.renderscript.*; import android.renderscript.Element.DataKind; import android.renderscript.Element.DataType; import android.renderscript.Allocation.MipmapControl; import android.renderscript.Program.TextureType; -import android.renderscript.ProgramStore.DepthFunc; -import android.renderscript.ProgramStore.BlendSrcFunc; -import android.renderscript.ProgramStore.BlendDstFunc; import android.renderscript.RenderScript.RSMessageHandler; import android.renderscript.Sampler.Value; import android.renderscript.Mesh.Primitive; @@ -48,10 +43,6 @@ import android.util.Log; public class RsBenchRS { private static final String TAG = "RsBenchRS"; - private static final String SAMPLE_TEXT = "Bench Test"; - private static final String LIST_TEXT = - "This is a sample list of text to show in the list view"; - private static int PARTICLES_COUNT = 12000; int mWidth; int mHeight; int mLoops; @@ -68,10 +59,7 @@ public class RsBenchRS { mRes = res; mWidth = width; mHeight = height; - mOptionsARGB.inScaled = false; - mOptionsARGB.inPreferredConfig = Bitmap.Config.ARGB_8888; mMode = 0; - mMaxModes = 0; mLoops = loops; mCurrentLoop = 0; mBenchmarkDimX = 1280; @@ -84,10 +72,8 @@ public class RsBenchRS { private Resources mRes; private RenderScriptGL mRS; - private ProgramStore mProgStoreBlendNoneDepth; private ProgramStore mProgStoreBlendNone; private ProgramStore mProgStoreBlendAlpha; - private ProgramStore mProgStoreBlendAdd; private ProgramFragment mProgFragmentTexture; private ProgramFragment mProgFragmentColor; @@ -96,58 +82,69 @@ public class RsBenchRS { private ProgramVertexFixedFunction.Constants mPVA; private ProgramVertexFixedFunction.Constants mPvProjectionAlloc; - // Custom shaders - private ProgramVertex mProgVertexCustom; - private ProgramFragment mProgFragmentCustom; - private ProgramFragment mProgFragmentMultitex; - private ProgramVertex mProgVertexPixelLight; - private ProgramVertex mProgVertexPixelLightMove; - private ProgramFragment mProgFragmentPixelLight; - private ScriptField_VertexShaderConstants_s mVSConst; - private ScriptField_FragentShaderConstants_s mFSConst; - private ScriptField_VertexShaderConstants3_s mVSConstPixel; - private ScriptField_FragentShaderConstants3_s mFSConstPixel; - - - private Allocation mTexTorus; - private Allocation mTexOpaque; - private Allocation mTexTransparent; - private Allocation mTexChecker; - private Allocation mTexGlobe; - - private Mesh m10by10Mesh; - private Mesh m100by100Mesh; - private Mesh mWbyHMesh; - private Mesh mTorus; - private Mesh mSingleMesh; - private Mesh mParticlesMesh; - - Font mFontSans; - Font mFontSerif; - private Allocation mTextAlloc; - - private ScriptField_ListAllocs_s mTextureAllocs; - private ScriptField_ListAllocs_s mSampleTextAllocs; - private ScriptField_ListAllocs_s mSampleListViewAllocs; - private ScriptField_VpConsts mPvStarAlloc; - - private ScriptC_rsbench mScript; - private ScriptC_text_test mTextScript; - private ScriptC_torus_test mTorusScript; - private final BitmapFactory.Options mOptionsARGB = new BitmapFactory.Options(); + ScriptField_TestScripts_s.Item[] mIndividualTests; int mMode; - int mMaxModes; String[] mTestNames; float[] mLocalTestResults; - public void onActionDown(int x, int y) { - mMode ++; - mMode = mMode % mMaxModes; - mScript.set_gDisplayMode(mMode); + static Allocation createZeroTerminatedAlloc(RenderScript rs, + String str, + int usage) { + byte[] allocArray = null; + try { + allocArray = str.getBytes("UTF-8"); + byte[] allocArrayZero = new byte[allocArray.length + 1]; + System.arraycopy(allocArray, 0, allocArrayZero, 0, allocArray.length); + allocArrayZero[allocArrayZero.length - 1] = '\0'; + Allocation alloc = Allocation.createSized(rs, Element.U8(rs), + allocArrayZero.length, usage); + alloc.copyFrom(allocArrayZero); + return alloc; + } + catch (Exception e) { + throw new RSRuntimeException("Could not convert string to utf-8."); + } + + } + + void appendTests(RsBenchBaseTest testSet) { + ScriptField_TestScripts_s.Item[] newTests = testSet.getTests(); + if (mIndividualTests != null) { + ScriptField_TestScripts_s.Item[] combined; + combined = new ScriptField_TestScripts_s.Item[newTests.length + mIndividualTests.length]; + System.arraycopy(mIndividualTests, 0, combined, 0, mIndividualTests.length); + System.arraycopy(newTests, 0, combined, mIndividualTests.length, newTests.length); + mIndividualTests = combined; + } else { + mIndividualTests = newTests; + } + + String[] newNames = testSet.getTestNames(); + if (mTestNames != null) { + String[] combinedNames; + combinedNames = new String[newNames.length + mTestNames.length]; + System.arraycopy(mTestNames, 0, combinedNames, 0, mTestNames.length); + System.arraycopy(newNames, 0, combinedNames, mTestNames.length, newNames.length); + mTestNames = combinedNames; + } else { + mTestNames = newNames; + } + } + + void createTestAllocation() { + int numTests = mIndividualTests.length; + mLocalTestResults = new float[numTests]; + ScriptField_TestScripts_s allTests; + allTests = new ScriptField_TestScripts_s(mRS, numTests); + for (int i = 0; i < numTests; i ++) { + allTests.set(mIndividualTests[i], i, false); + } + allTests.copyAll(); + mScript.bind_gTestScripts(allTests); } private void saveTestResults() { @@ -225,98 +222,6 @@ public class RsBenchRS { } } - ProgramStore BLEND_ADD_DEPTH_NONE(RenderScript rs) { - ProgramStore.Builder builder = new ProgramStore.Builder(rs); - builder.setDepthFunc(ProgramStore.DepthFunc.ALWAYS); - builder.setBlendFunc(BlendSrcFunc.ONE, BlendDstFunc.ONE); - builder.setDitherEnabled(false); - builder.setDepthMaskEnabled(false); - return builder.create(); - } - - private Mesh getMbyNMesh(float width, float height, int wResolution, int hResolution) { - - Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, - 2, Mesh.TriangleMeshBuilder.TEXTURE_0); - - for (int y = 0; y <= hResolution; y++) { - final float normalizedY = (float)y / hResolution; - final float yOffset = (normalizedY - 0.5f) * height; - for (int x = 0; x <= wResolution; x++) { - float normalizedX = (float)x / wResolution; - float xOffset = (normalizedX - 0.5f) * width; - tmb.setTexture((float)x % 2, (float)y % 2); - tmb.addVertex(xOffset, yOffset); - } - } - - for (int y = 0; y < hResolution; y++) { - final int curY = y * (wResolution + 1); - final int belowY = (y + 1) * (wResolution + 1); - for (int x = 0; x < wResolution; x++) { - int curV = curY + x; - int belowV = belowY + x; - tmb.addTriangle(curV, belowV, curV + 1); - tmb.addTriangle(belowV, belowV + 1, curV + 1); - } - } - - return tmb.create(true); - } - - /** - * Create a mesh with a single quad for the given width and height. - */ - private Mesh getSingleMesh(float width, float height) { - Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, - 2, Mesh.TriangleMeshBuilder.TEXTURE_0); - float xOffset = width/2; - float yOffset = height/2; - tmb.setTexture(0, 0); - tmb.addVertex(-1.0f * xOffset, -1.0f * yOffset); - tmb.setTexture(1, 0); - tmb.addVertex(xOffset, -1.0f * yOffset); - tmb.setTexture(1, 1); - tmb.addVertex(xOffset, yOffset); - tmb.setTexture(0, 1); - tmb.addVertex(-1.0f * xOffset, yOffset); - tmb.addTriangle(0, 3, 1); - tmb.addTriangle(1, 3, 2); - return tmb.create(true); - } - - private void initProgramStore() { - // Use stock the stock program store object - mProgStoreBlendNoneDepth = ProgramStore.BLEND_NONE_DEPTH_TEST(mRS); - mProgStoreBlendNone = ProgramStore.BLEND_NONE_DEPTH_NONE(mRS); - - // Create a custom program store - ProgramStore.Builder builder = new ProgramStore.Builder(mRS); - builder.setDepthFunc(ProgramStore.DepthFunc.ALWAYS); - builder.setBlendFunc(ProgramStore.BlendSrcFunc.SRC_ALPHA, - ProgramStore.BlendDstFunc.ONE_MINUS_SRC_ALPHA); - builder.setDitherEnabled(false); - builder.setDepthMaskEnabled(false); - mProgStoreBlendAlpha = builder.create(); - - mProgStoreBlendAdd = BLEND_ADD_DEPTH_NONE(mRS); - - mScript.set_gProgStoreBlendNoneDepth(mProgStoreBlendNoneDepth); - - mScript.set_gProgStoreBlendNone(mProgStoreBlendNone); - mScript.set_gProgStoreBlendAlpha(mProgStoreBlendAlpha); - mScript.set_gProgStoreBlendAdd(mProgStoreBlendAdd); - - // For GALAXY - builder = new ProgramStore.Builder(mRS); - builder.setBlendFunc(BlendSrcFunc.ONE, BlendDstFunc.ZERO); - mRS.bindProgramStore(builder.create()); - - builder.setBlendFunc(BlendSrcFunc.SRC_ALPHA, BlendDstFunc.ONE); - mScript.set_gPSLights(builder.create()); - - } - private void initProgramFragment() { ProgramFragmentFixedFunction.Builder texBuilder = new ProgramFragmentFixedFunction.Builder(mRS); @@ -329,64 +234,9 @@ public class RsBenchRS { colBuilder.setVaryingColor(false); mProgFragmentColor = colBuilder.create(); - mScript.set_gProgFragmentColor(mProgFragmentColor); - mScript.set_gProgFragmentTexture(mProgFragmentTexture); - - - - // For Galaxy live wallpaper drawing - ProgramFragmentFixedFunction.Builder builder = new ProgramFragmentFixedFunction.Builder(mRS); - builder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, - ProgramFragmentFixedFunction.Builder.Format.RGB, 0); - ProgramFragment pfb = builder.create(); - pfb.bindSampler(Sampler.WRAP_NEAREST(mRS), 0); - mScript.set_gPFBackground(pfb); - - builder = new ProgramFragmentFixedFunction.Builder(mRS); - builder.setPointSpriteTexCoordinateReplacement(true); - builder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.MODULATE, - ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); - builder.setVaryingColor(true); - ProgramFragment pfs = builder.create(); - pfs.bindSampler(Sampler.WRAP_LINEAR_MIP_LINEAR(mRS), 0); - mScript.set_gPFStars(pfs); - } - private Matrix4f getProjectionNormalized(int w, int h) { - // range -1,1 in the narrow axis at z = 0. - Matrix4f m1 = new Matrix4f(); - Matrix4f m2 = new Matrix4f(); - - if(w > h) { - float aspect = ((float)w) / h; - m1.loadFrustum(-aspect,aspect, -1,1, 1,100); - } else { - float aspect = ((float)h) / w; - m1.loadFrustum(-1,1, -aspect,aspect, 1,100); - } - - m2.loadRotate(180, 0, 1, 0); - m1.loadMultiply(m1, m2); - - m2.loadScale(-2, 2, 1); - m1.loadMultiply(m1, m2); - - m2.loadTranslate(0, 0, 2); - m1.loadMultiply(m1, m2); - return m1; - } - - private void updateProjectionMatrices() { - Matrix4f projNorm = getProjectionNormalized(mBenchmarkDimX, mBenchmarkDimY); - ScriptField_VpConsts.Item i = new ScriptField_VpConsts.Item(); - i.Proj = projNorm; - i.MVP = projNorm; - mPvStarAlloc.set(i, 0, true); - mPvProjectionAlloc.setProjection(projNorm); - } - private void initProgramVertex() { ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); mProgVertex = pvb.create(); @@ -398,201 +248,6 @@ public class RsBenchRS { mPVA.setProjection(proj); mScript.set_gProgVertex(mProgVertex); - - - // For galaxy live wallpaper - mPvStarAlloc = new ScriptField_VpConsts(mRS, 1); - mScript.bind_vpConstants(mPvStarAlloc); - mPvProjectionAlloc = new ProgramVertexFixedFunction.Constants(mRS); - updateProjectionMatrices(); - - pvb = new ProgramVertexFixedFunction.Builder(mRS); - ProgramVertex pvbp = pvb.create(); - ((ProgramVertexFixedFunction)pvbp).bindConstants(mPvProjectionAlloc); - mScript.set_gPVBkProj(pvbp); - - ProgramVertex.Builder sb = new ProgramVertex.Builder(mRS); - String t = "varying vec4 varColor;\n" + - "varying vec2 varTex0;\n" + - "void main() {\n" + - " float dist = ATTRIB_position.y;\n" + - " float angle = ATTRIB_position.x;\n" + - " float x = dist * sin(angle);\n" + - " float y = dist * cos(angle) * 0.892;\n" + - " float p = dist * 5.5;\n" + - " float s = cos(p);\n" + - " float t = sin(p);\n" + - " vec4 pos;\n" + - " pos.x = t * x + s * y;\n" + - " pos.y = s * x - t * y;\n" + - " pos.z = ATTRIB_position.z;\n" + - " pos.w = 1.0;\n" + - " gl_Position = UNI_MVP * pos;\n" + - " gl_PointSize = ATTRIB_color.a * 10.0;\n" + - " varColor.rgb = ATTRIB_color.rgb;\n" + - " varColor.a = 1.0;\n" + - "}\n"; - sb.setShader(t); - sb.addInput(mParticlesMesh.getVertexAllocation(0).getType().getElement()); - sb.addConstant(mPvStarAlloc.getType()); - ProgramVertex pvs = sb.create(); - pvs.bindConstants(mPvStarAlloc.getAllocation(), 0); - mScript.set_gPVStars(pvs); - } - - private void initCustomShaders() { - mVSConst = new ScriptField_VertexShaderConstants_s(mRS, 1); - mFSConst = new ScriptField_FragentShaderConstants_s(mRS, 1); - - - mVSConstPixel = new ScriptField_VertexShaderConstants3_s(mRS, 1); - mFSConstPixel = new ScriptField_FragentShaderConstants3_s(mRS, 1); - - - // Initialize the shader builder - ProgramVertex.Builder pvbCustom = new ProgramVertex.Builder(mRS); - // Specify the resource that contains the shader string - pvbCustom.setShader(mRes, R.raw.shaderv); - // Use a script field to specify the input layout - pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); - // Define the constant input layout - pvbCustom.addConstant(mVSConst.getAllocation().getType()); - mProgVertexCustom = pvbCustom.create(); - // Bind the source of constant data - mProgVertexCustom.bindConstants(mVSConst.getAllocation(), 0); - - ProgramFragment.Builder pfbCustom = new ProgramFragment.Builder(mRS); - // Specify the resource that contains the shader string - pfbCustom.setShader(mRes, R.raw.shaderf); - // Tell the builder how many textures we have - pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); - // Define the constant input layout - pfbCustom.addConstant(mFSConst.getAllocation().getType()); - mProgFragmentCustom = pfbCustom.create(); - // Bind the source of constant data - mProgFragmentCustom.bindConstants(mFSConst.getAllocation(), 0); - - pvbCustom = new ProgramVertex.Builder(mRS); - pvbCustom.setShader(mRes, R.raw.shader2v); - pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); - pvbCustom.addConstant(mVSConstPixel.getAllocation().getType()); - mProgVertexPixelLight = pvbCustom.create(); - mProgVertexPixelLight.bindConstants(mVSConstPixel.getAllocation(), 0); - - pvbCustom = new ProgramVertex.Builder(mRS); - pvbCustom.setShader(mRes, R.raw.shader2movev); - pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); - pvbCustom.addConstant(mVSConstPixel.getAllocation().getType()); - mProgVertexPixelLightMove = pvbCustom.create(); - mProgVertexPixelLightMove.bindConstants(mVSConstPixel.getAllocation(), 0); - - pfbCustom = new ProgramFragment.Builder(mRS); - pfbCustom.setShader(mRes, R.raw.shader2f); - pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); - pfbCustom.addConstant(mFSConstPixel.getAllocation().getType()); - mProgFragmentPixelLight = pfbCustom.create(); - mProgFragmentPixelLight.bindConstants(mFSConstPixel.getAllocation(), 0); - - pfbCustom = new ProgramFragment.Builder(mRS); - pfbCustom.setShader(mRes, R.raw.multitexf); - for (int texCount = 0; texCount < 3; texCount ++) { - pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); - } - mProgFragmentMultitex = pfbCustom.create(); - - - mScript.set_gProgFragmentMultitex(mProgFragmentMultitex); - } - - private Allocation loadTextureRGB(int id) { - return Allocation.createFromBitmapResource(mRS, mRes, id, - Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, - Allocation.USAGE_GRAPHICS_TEXTURE); - } - - private Allocation loadTextureARGB(int id) { - Bitmap b = BitmapFactory.decodeResource(mRes, id, mOptionsARGB); - return Allocation.createFromBitmap(mRS, b, - Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, - Allocation.USAGE_GRAPHICS_TEXTURE); - } - - private void loadImages() { - mTexTorus = loadTextureRGB(R.drawable.torusmap); - mTexOpaque = loadTextureRGB(R.drawable.data); - mTexTransparent = loadTextureARGB(R.drawable.leaf); - mTexChecker = loadTextureRGB(R.drawable.checker); - mTexGlobe = loadTextureRGB(R.drawable.globe); - - mScript.set_gTexTorus(mTexTorus); - mScript.set_gTexOpaque(mTexOpaque); - mScript.set_gTexTransparent(mTexTransparent); - mScript.set_gTexChecker(mTexChecker); - mScript.set_gTexGlobe(mTexGlobe); - - // For Galaxy live wallpaper - mScript.set_gTSpace(loadTextureRGB(R.drawable.space)); - mScript.set_gTLight1(loadTextureRGB(R.drawable.light1)); - mScript.set_gTFlares(loadTextureARGB(R.drawable.flares)); - } - - private void initFonts() { - // Sans font by family name - mFontSans = Font.create(mRS, mRes, "sans-serif", Font.Style.NORMAL, 8); - mFontSerif = Font.create(mRS, mRes, "serif", Font.Style.NORMAL, 8); - // Create fonts by family and style - - mTextAlloc = Allocation.createFromString(mRS, "String from allocation", Allocation.USAGE_SCRIPT); - - mScript.set_gFontSans(mFontSans); - mScript.set_gFontSerif(mFontSerif); - } - - private void createParticlesMesh() { - ScriptField_Particle p = new ScriptField_Particle(mRS, PARTICLES_COUNT); - - final Mesh.AllocationBuilder meshBuilder = new Mesh.AllocationBuilder(mRS); - meshBuilder.addVertexAllocation(p.getAllocation()); - final int vertexSlot = meshBuilder.getCurrentVertexTypeIndex(); - meshBuilder.addIndexSetType(Primitive.POINT); - mParticlesMesh = meshBuilder.create(); - - mScript.set_gParticlesMesh(mParticlesMesh); - mScript.bind_Particles(p); - } - - private void initMesh() { - m10by10Mesh = getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, 10, 10); - mScript.set_g10by10Mesh(m10by10Mesh); - m100by100Mesh = getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, 100, 100); - mScript.set_g100by100Mesh(m100by100Mesh); - mWbyHMesh= getMbyNMesh(mBenchmarkDimX, mBenchmarkDimY, mBenchmarkDimX/4, mBenchmarkDimY/4); - mScript.set_gWbyHMesh(mWbyHMesh); - mSingleMesh = getSingleMesh(1, 1); // a unit size mesh - mScript.set_gSingleMesh(mSingleMesh); - - FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.torus); - FileA3D.IndexEntry entry = model.getIndexEntry(0); - if (entry == null || entry.getEntryType() != FileA3D.EntryType.MESH) { - Log.e("rs", "could not load model"); - } else { - mTorus = (Mesh)entry.getObject(); - } - - createParticlesMesh(); - } - - private void initSamplers() { - mScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); - mScript.set_gLinearWrap(Sampler.WRAP_LINEAR(mRS)); - mScript.set_gMipLinearWrap(Sampler.WRAP_LINEAR_MIP_LINEAR(mRS)); - mScript.set_gNearestClamp(Sampler.CLAMP_NEAREST(mRS)); - } - - private void initProgramRaster() { - mScript.set_gCullBack(ProgramRaster.CULL_BACK(mRS)); - mScript.set_gCullFront(ProgramRaster.CULL_FRONT(mRS)); - mScript.set_gCullNone(ProgramRaster.CULL_NONE(mRS)); } private int strlen(byte[] array) { @@ -603,78 +258,30 @@ public class RsBenchRS { return count; } - private void prepareTestData() { - mTestNames = new String[mMaxModes]; - mLocalTestResults = new float[mMaxModes]; - int scratchSize = 1024; - Allocation scratch = Allocation.createSized(mRS, Element.U8(mRS), scratchSize); - byte[] tmp = new byte[scratchSize]; - mScript.bind_gStringBuffer(scratch); - for (int i = 0; i < mMaxModes; i ++) { - mScript.invoke_getTestName(i); - scratch.copyTo(tmp); - int len = strlen(tmp); - mTestNames[i] = new String(tmp, 0, len); - } - } - public void setDebugMode(int num) { mScript.invoke_setDebugMode(num); } - public void setBenchmarkMode() { - mScript.invoke_setBenchmarkMode(); + public void setBenchmarkMode(int benchNum) { + mScript.invoke_setBenchmarkMode(benchNum); } - void initTextScript() { - mTextScript = new ScriptC_text_test(mRS, mRes, R.raw.text_test); - mTextScript.set_gFontSans(mFontSans); - mTextScript.set_gFontSerif(mFontSerif); - } - - void initTorusScript() { - mTorusScript = new ScriptC_torus_test(mRS, mRes, R.raw.torus_test); - mTorusScript.set_gCullFront(ProgramRaster.CULL_FRONT(mRS)); - mTorusScript.set_gCullBack(ProgramRaster.CULL_BACK(mRS)); - mTorusScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); - mTorusScript.set_gTorusMesh(mTorus); - mTorusScript.set_gTexTorus(mTexTorus); - mTorusScript.set_gProgVertexCustom(mProgVertexCustom); - mTorusScript.set_gProgFragmentCustom(mProgFragmentCustom); - mTorusScript.set_gProgVertexPixelLight(mProgVertexPixelLight); - mTorusScript.set_gProgVertexPixelLightMove(mProgVertexPixelLightMove); - mTorusScript.set_gProgFragmentPixelLight(mProgFragmentPixelLight); - mTorusScript.bind_gVSConstPixel(mVSConstPixel); - mTorusScript.bind_gFSConstPixel(mFSConstPixel); - mTorusScript.bind_gVSConstants(mVSConst); - mTorusScript.bind_gFSConstants(mFSConst); - mTorusScript.set_gProgVertex(mProgVertex); - mTorusScript.set_gProgFragmentTexture(mProgFragmentTexture); - mTorusScript.set_gProgFragmentColor(mProgFragmentColor); - mTorusScript.set_gProgStoreBlendNoneDepth(mProgStoreBlendNoneDepth); + public void pause(boolean pause) { + mScript.set_gPauseRendering(pause); } private void initRS() { mScript = new ScriptC_rsbench(mRS, mRes, R.raw.rsbench); - + mRS.bindRootScript(mScript); mRS.setMessageHandler(mRsMessage); - mMaxModes = mScript.get_gMaxModes(); mScript.set_gMaxLoops(mLoops); - prepareTestData(); - - initSamplers(); - initMesh(); initProgramVertex(); - initProgramStore(); initProgramFragment(); - initFonts(); - loadImages(); - initProgramRaster(); - initCustomShaders(); + mScript.set_gFontSerif(Font.create(mRS, mRes, "serif", Font.Style.NORMAL, 8)); Type.Builder b = new Type.Builder(mRS, Element.RGBA_8888(mRS)); b.setX(mBenchmarkDimX).setY(mBenchmarkDimY); @@ -692,41 +299,30 @@ public class RsBenchRS { b.create(), Allocation.USAGE_GRAPHICS_RENDER_TARGET); mScript.set_gRenderBufferDepth(offscreen); + mScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); - mTextureAllocs = new ScriptField_ListAllocs_s(mRS, 100); - for (int i = 0; i < 100; i++) { - ScriptField_ListAllocs_s.Item texElem = new ScriptField_ListAllocs_s.Item(); - texElem.item = loadTextureRGB(R.drawable.globe); - mTextureAllocs.set(texElem, i, false); + RsBenchBaseTest test = new TextTest(); + if (test.init(mRS, mRes)) { + appendTests(test); } - mTextureAllocs.copyAll(); - mScript.bind_gTexList100(mTextureAllocs); - - mSampleTextAllocs = new ScriptField_ListAllocs_s(mRS, 100); - for (int i = 0; i < 100; i++) { - ScriptField_ListAllocs_s.Item textElem = new ScriptField_ListAllocs_s.Item(); - textElem.item = Allocation.createFromString(mRS, SAMPLE_TEXT, Allocation.USAGE_SCRIPT); - mSampleTextAllocs.set(textElem, i, false); + test = new FillTest(); + if (test.init(mRS, mRes)) { + appendTests(test); } - mSampleTextAllocs.copyAll(); - mScript.bind_gSampleTextList100(mSampleTextAllocs); - - mSampleListViewAllocs = new ScriptField_ListAllocs_s(mRS, 1000); - for (int i = 0; i < 1000; i++) { - ScriptField_ListAllocs_s.Item textElem = new ScriptField_ListAllocs_s.Item(); - textElem.item = Allocation.createFromString(mRS, LIST_TEXT, Allocation.USAGE_SCRIPT); - mSampleListViewAllocs.set(textElem, i, false); + test = new MeshTest(); + if (test.init(mRS, mRes)) { + appendTests(test); } - mSampleListViewAllocs.copyAll(); - mScript.bind_gListViewText(mSampleListViewAllocs); - - initTextScript(); - initTorusScript(); - - mScript.set_gFontScript(mTextScript); - mScript.set_gTorusScript(mTorusScript); - mScript.set_gDummyAlloc(Allocation.createSized(mRS, Element.I32(mRS), 1)); + test = new TorusTest(); + if (test.init(mRS, mRes)) { + appendTests(test); + } + test = new UiTest(); + if (test.init(mRS, mRes)) { + appendTests(test); + } + createTestAllocation(); - mRS.bindRootScript(mScript); + mScript.set_gLoadComplete(true); } } diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchView.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchView.java index 61aa3e1..124071e 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchView.java +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchView.java @@ -71,24 +71,6 @@ public class RsBenchView extends RSSurfaceView { } } - @Override - public boolean onKeyDown(int keyCode, KeyEvent event) { - return super.onKeyDown(keyCode, event); - } - - - @Override - public boolean onTouchEvent(MotionEvent ev) { - boolean ret = false; - int act = ev.getAction(); - if (act == ev.ACTION_DOWN) { - mRender.onActionDown((int)ev.getX(), (int)ev.getY()); - ret = true; - } - - return ret; - } - /** * Set the total number of loops the benchmark tests will run * before the test results are collected. @@ -106,8 +88,12 @@ public class RsBenchView extends RSSurfaceView { return mRender.testIsFinished(); } - void setBenchmarkMode() { - mRender.setBenchmarkMode(); + void setBenchmarkMode(int benchNum) { + mRender.setBenchmarkMode(benchNum); + } + + void suspendRendering(boolean pause) { + mRender.pause(pause); } void setDebugMode(int num) { diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TextTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TextTest.java new file mode 100644 index 0000000..3ca2792 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TextTest.java @@ -0,0 +1,93 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; + +import android.os.Environment; +import android.content.res.Resources; +import android.renderscript.*; +import android.util.DisplayMetrics; + +import android.util.Log; + + +public class TextTest implements RsBenchBaseTest{ + + private static final String TAG = "TextTest"; + private RenderScriptGL mRS; + private Resources mRes; + + private ScriptC_text_test mTextScript; + ScriptField_TestScripts_s.Item[] mTests; + + private final String[] mNames = { + "Fill screen with text 1 time", + "Fill screen with text 3 times", + "Fill screen with text 5 times" + }; + + public TextTest() { + } + + void addTest(int index, int fillNum) { + mTests[index] = new ScriptField_TestScripts_s.Item(); + mTests[index].testScript = mTextScript; + mTests[index].testName = Allocation.createFromString(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + mTests[index].debugName = RsBenchRS.createZeroTerminatedAlloc(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + + ScriptField_TextTestData_s.Item dataItem = new ScriptField_TextTestData_s.Item(); + dataItem.fillNum = fillNum; + ScriptField_TextTestData_s testData = new ScriptField_TextTestData_s(mRS, 1); + testData.set(dataItem, 0, true); + mTests[index].testData = testData.getAllocation(); + } + + public boolean init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + initTextScript(); + mTests = new ScriptField_TestScripts_s.Item[mNames.length]; + + int index = 0; + addTest(index++, 1 /*fillNum*/); + addTest(index++, 3 /*fillNum*/); + addTest(index++, 5 /*fillNum*/); + + return true; + } + + public ScriptField_TestScripts_s.Item[] getTests() { + return mTests; + } + + public String[] getTestNames() { + return mNames; + } + + void initTextScript() { + DisplayMetrics metrics = mRes.getDisplayMetrics(); + + mTextScript = new ScriptC_text_test(mRS, mRes, R.raw.text_test); + mTextScript.set_gFontSans(Font.create(mRS, mRes, "sans-serif", + Font.Style.NORMAL, 8.0f / metrics.density)); + mTextScript.set_gFontSerif(Font.create(mRS, mRes, "serif", + Font.Style.NORMAL, 8.0f / metrics.density)); + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TorusTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TorusTest.java new file mode 100644 index 0000000..5c9ecd5 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/TorusTest.java @@ -0,0 +1,272 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; + +import android.os.Environment; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.renderscript.*; +import android.renderscript.Element.DataKind; +import android.renderscript.Element.DataType; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Program.TextureType; +import android.renderscript.RenderScript.RSMessageHandler; +import android.renderscript.Mesh.Primitive; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramVertexFixedFunction; + +import android.util.Log; + + +public class TorusTest implements RsBenchBaseTest{ + + private static final String TAG = "TorusTest"; + private RenderScriptGL mRS; + private Resources mRes; + + private ProgramStore mProgStoreBlendNoneDepth; + private ProgramStore mProgStoreBlendNone; + private ProgramStore mProgStoreBlendAlpha; + + private ProgramFragment mProgFragmentTexture; + private ProgramFragment mProgFragmentColor; + + private ProgramVertex mProgVertex; + private ProgramVertexFixedFunction.Constants mPVA; + private ProgramVertexFixedFunction.Constants mPvProjectionAlloc; + + // Custom shaders + private ProgramVertex mProgVertexCustom; + private ProgramFragment mProgFragmentCustom; + private ProgramFragment mProgFragmentMultitex; + private ProgramVertex mProgVertexPixelLight; + private ProgramVertex mProgVertexPixelLightMove; + private ProgramFragment mProgFragmentPixelLight; + private ScriptField_VertexShaderConstants_s mVSConst; + private ScriptField_FragentShaderConstants_s mFSConst; + private ScriptField_VertexShaderConstants3_s mVSConstPixel; + private ScriptField_FragentShaderConstants3_s mFSConstPixel; + + private Allocation mTexTorus; + private Mesh mTorus; + + private ScriptC_torus_test mTorusScript; + + private final BitmapFactory.Options mOptionsARGB = new BitmapFactory.Options(); + + ScriptField_TestScripts_s.Item[] mTests; + + private final String[] mNames = { + "Geo test 25.6k flat color", + "Geo test 51.2k flat color", + "Geo test 204.8k small tries flat color", + "Geo test 25.6k single texture", + "Geo test 51.2k single texture", + "Geo test 204.8k small tries single texture", + "Geo test 25.6k geo heavy vertex", + "Geo test 51.2k geo heavy vertex", + "Geo test 204.8k geo raster load heavy vertex", + "Geo test 25.6k heavy fragment", + "Geo test 51.2k heavy fragment", + "Geo test 204.8k small tries heavy fragment", + "Geo test 25.6k heavy fragment heavy vertex", + "Geo test 51.2k heavy fragment heavy vertex", + "Geo test 204.8k small tries heavy fragment heavy vertex" + }; + + public TorusTest() { + } + + void addTest(int index, int testId, int user1, int user2) { + mTests[index] = new ScriptField_TestScripts_s.Item(); + mTests[index].testScript = mTorusScript; + mTests[index].testName = Allocation.createFromString(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + mTests[index].debugName = RsBenchRS.createZeroTerminatedAlloc(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + + ScriptField_TorusTestData_s.Item dataItem = new ScriptField_TorusTestData_s.Item(); + dataItem.testId = testId; + dataItem.user1 = user1; + dataItem.user2 = user2; + ScriptField_TorusTestData_s testData = new ScriptField_TorusTestData_s(mRS, 1); + testData.set(dataItem, 0, true); + mTests[index].testData = testData.getAllocation(); + } + + public boolean init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + initCustomShaders(); + loadImages(); + initMesh(); + initTorusScript(); + mTests = new ScriptField_TestScripts_s.Item[mNames.length]; + + int index = 0; + addTest(index++, 0, 0 /*useTexture*/, 1 /*numMeshes*/); + addTest(index++, 0, 0 /*useTexture*/, 2 /*numMeshes*/); + addTest(index++, 0, 0 /*useTexture*/, 8 /*numMeshes*/); + addTest(index++, 0, 1 /*useTexture*/, 1 /*numMeshes*/); + addTest(index++, 0, 1 /*useTexture*/, 2 /*numMeshes*/); + addTest(index++, 0, 1 /*useTexture*/, 8 /*numMeshes*/); + + // Secont test + addTest(index++, 1, 1 /*numMeshes*/, 0 /*unused*/); + addTest(index++, 1, 2 /*numMeshes*/, 0 /*unused*/); + addTest(index++, 1, 8 /*numMeshes*/, 0 /*unused*/); + + // Third test + addTest(index++, 2, 1 /*numMeshes*/, 0 /*heavyVertex*/); + addTest(index++, 2, 2 /*numMeshes*/, 0 /*heavyVertex*/); + addTest(index++, 2, 8 /*numMeshes*/, 0 /*heavyVertex*/); + addTest(index++, 2, 1 /*numMeshes*/, 1 /*heavyVertex*/); + addTest(index++, 2, 2 /*numMeshes*/, 1 /*heavyVertex*/); + addTest(index++, 2, 8 /*numMeshes*/, 1 /*heavyVertex*/); + + return true; + } + + public ScriptField_TestScripts_s.Item[] getTests() { + return mTests; + } + + public String[] getTestNames() { + return mNames; + } + + private void initCustomShaders() { + mVSConst = new ScriptField_VertexShaderConstants_s(mRS, 1); + mFSConst = new ScriptField_FragentShaderConstants_s(mRS, 1); + + mVSConstPixel = new ScriptField_VertexShaderConstants3_s(mRS, 1); + mFSConstPixel = new ScriptField_FragentShaderConstants3_s(mRS, 1); + + // Initialize the shader builder + ProgramVertex.Builder pvbCustom = new ProgramVertex.Builder(mRS); + // Specify the resource that contains the shader string + pvbCustom.setShader(mRes, R.raw.shaderv); + // Use a script field to specify the input layout + pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); + // Define the constant input layout + pvbCustom.addConstant(mVSConst.getAllocation().getType()); + mProgVertexCustom = pvbCustom.create(); + // Bind the source of constant data + mProgVertexCustom.bindConstants(mVSConst.getAllocation(), 0); + + ProgramFragment.Builder pfbCustom = new ProgramFragment.Builder(mRS); + // Specify the resource that contains the shader string + pfbCustom.setShader(mRes, R.raw.shaderf); + // Tell the builder how many textures we have + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + // Define the constant input layout + pfbCustom.addConstant(mFSConst.getAllocation().getType()); + mProgFragmentCustom = pfbCustom.create(); + // Bind the source of constant data + mProgFragmentCustom.bindConstants(mFSConst.getAllocation(), 0); + + pvbCustom = new ProgramVertex.Builder(mRS); + pvbCustom.setShader(mRes, R.raw.shader2v); + pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); + pvbCustom.addConstant(mVSConstPixel.getAllocation().getType()); + mProgVertexPixelLight = pvbCustom.create(); + mProgVertexPixelLight.bindConstants(mVSConstPixel.getAllocation(), 0); + + pvbCustom = new ProgramVertex.Builder(mRS); + pvbCustom.setShader(mRes, R.raw.shader2movev); + pvbCustom.addInput(ScriptField_VertexShaderInputs_s.createElement(mRS)); + pvbCustom.addConstant(mVSConstPixel.getAllocation().getType()); + mProgVertexPixelLightMove = pvbCustom.create(); + mProgVertexPixelLightMove.bindConstants(mVSConstPixel.getAllocation(), 0); + + pfbCustom = new ProgramFragment.Builder(mRS); + pfbCustom.setShader(mRes, R.raw.shader2f); + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + pfbCustom.addConstant(mFSConstPixel.getAllocation().getType()); + mProgFragmentPixelLight = pfbCustom.create(); + mProgFragmentPixelLight.bindConstants(mFSConstPixel.getAllocation(), 0); + + pfbCustom = new ProgramFragment.Builder(mRS); + pfbCustom.setShader(mRes, R.raw.multitexf); + for (int texCount = 0; texCount < 3; texCount ++) { + pfbCustom.addTexture(Program.TextureType.TEXTURE_2D); + } + mProgFragmentMultitex = pfbCustom.create(); + + ProgramFragmentFixedFunction.Builder colBuilder = new ProgramFragmentFixedFunction.Builder(mRS); + colBuilder.setVaryingColor(false); + mProgFragmentColor = colBuilder.create(); + + ProgramFragmentFixedFunction.Builder texBuilder = new ProgramFragmentFixedFunction.Builder(mRS); + texBuilder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + mProgFragmentTexture = texBuilder.create(); + + ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); + mProgVertex = pvb.create(); + ProgramVertexFixedFunction.Constants PVA = new ProgramVertexFixedFunction.Constants(mRS); + ((ProgramVertexFixedFunction)mProgVertex).bindConstants(PVA); + Matrix4f proj = new Matrix4f(); + proj.loadOrthoWindow(1280, 720); + PVA.setProjection(proj); + } + + private Allocation loadTextureRGB(int id) { + return Allocation.createFromBitmapResource(mRS, mRes, id, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + private void loadImages() { + mTexTorus = loadTextureRGB(R.drawable.torusmap); + } + + private void initMesh() { + FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.torus); + FileA3D.IndexEntry entry = model.getIndexEntry(0); + if (entry == null || entry.getEntryType() != FileA3D.EntryType.MESH) { + Log.e("rs", "could not load model"); + } else { + mTorus = (Mesh)entry.getObject(); + } + } + + void initTorusScript() { + mTorusScript = new ScriptC_torus_test(mRS, mRes, R.raw.torus_test); + mTorusScript.set_gCullFront(ProgramRaster.CULL_FRONT(mRS)); + mTorusScript.set_gCullBack(ProgramRaster.CULL_BACK(mRS)); + mTorusScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); + mTorusScript.set_gTorusMesh(mTorus); + mTorusScript.set_gTexTorus(mTexTorus); + mTorusScript.set_gProgVertexCustom(mProgVertexCustom); + mTorusScript.set_gProgFragmentCustom(mProgFragmentCustom); + mTorusScript.set_gProgVertexPixelLight(mProgVertexPixelLight); + mTorusScript.set_gProgVertexPixelLightMove(mProgVertexPixelLightMove); + mTorusScript.set_gProgFragmentPixelLight(mProgFragmentPixelLight); + mTorusScript.bind_gVSConstPixel(mVSConstPixel); + mTorusScript.bind_gFSConstPixel(mFSConstPixel); + mTorusScript.bind_gVSConstants(mVSConst); + mTorusScript.bind_gFSConstants(mFSConst); + mTorusScript.set_gProgVertex(mProgVertex); + mTorusScript.set_gProgFragmentTexture(mProgFragmentTexture); + mTorusScript.set_gProgFragmentColor(mProgFragmentColor); + mTorusScript.set_gProgStoreBlendNoneDepth(mProgStoreBlendNoneDepth); + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/UiTest.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/UiTest.java new file mode 100644 index 0000000..c8b58b2 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/UiTest.java @@ -0,0 +1,337 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.perftest; + +import android.os.Environment; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.renderscript.*; +import android.renderscript.Element.DataKind; +import android.renderscript.Element.DataType; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Program.TextureType; +import android.renderscript.ProgramStore.DepthFunc; +import android.renderscript.ProgramStore.BlendSrcFunc; +import android.renderscript.ProgramStore.BlendDstFunc; +import android.renderscript.RenderScript.RSMessageHandler; +import android.renderscript.Mesh.Primitive; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramVertexFixedFunction; + +import android.util.Log; + + +public class UiTest implements RsBenchBaseTest{ + + private static final String TAG = "UiTest"; + private static final String SAMPLE_TEXT = "Bench Test"; + private static final String LIST_TEXT = + "This is a sample list of text to show in the list view"; + private static int PARTICLES_COUNT = 12000; + + private RenderScriptGL mRS; + private Resources mRes; + + Font mFontSans; + + private ScriptField_ListAllocs_s mTextureAllocs; + private ScriptField_ListAllocs_s mSampleTextAllocs; + private ScriptField_ListAllocs_s mSampleListViewAllocs; + private ScriptField_VpConsts mPvStarAlloc; + private ProgramVertexFixedFunction.Constants mPvProjectionAlloc; + + private Mesh mSingleMesh; + private Mesh mParticlesMesh; + + private ScriptC_ui_test mUiScript; + + private final BitmapFactory.Options mOptionsARGB = new BitmapFactory.Options(); + + ScriptField_TestScripts_s.Item[] mTests; + + private final String[] mNames = { + "UI test with icon display 10 by 10", + "UI test with icon display 100 by 100", + "UI test with image and text display 3 pages", + "UI test with image and text display 5 pages", + "UI test with list view", + "UI test with live wallpaper" + }; + + public UiTest() { + } + + void addTest(int index, int testId, int user1, int user2, int user3) { + mTests[index] = new ScriptField_TestScripts_s.Item(); + mTests[index].testScript = mUiScript; + mTests[index].testName = Allocation.createFromString(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + mTests[index].debugName = RsBenchRS.createZeroTerminatedAlloc(mRS, + mNames[index], + Allocation.USAGE_SCRIPT); + + ScriptField_UiTestData_s.Item dataItem = new ScriptField_UiTestData_s.Item(); + dataItem.testId = testId; + dataItem.user1 = user1; + dataItem.user2 = user2; + dataItem.user3 = user3; + ScriptField_UiTestData_s testData = new ScriptField_UiTestData_s(mRS, 1); + testData.set(dataItem, 0, true); + mTests[index].testData = testData.getAllocation(); + } + + public boolean init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + mFontSans = Font.create(mRS, mRes, "sans-serif", Font.Style.NORMAL, 8); + mSingleMesh = getSingleMesh(1, 1); // a unit size mesh + + initUiScript(); + mTests = new ScriptField_TestScripts_s.Item[mNames.length]; + + int index = 0; + + addTest(index++, 0, 0 /*meshMode*/, 0 /*unused*/, 0 /*unused*/); + addTest(index++, 0, 1 /*meshMode*/, 0 /*unused*/, 0 /*unused*/); + addTest(index++, 1, 7 /*wResolution*/, 5 /*hResolution*/, 0 /*meshMode*/); + addTest(index++, 1, 7 /*wResolution*/, 5 /*hResolution*/, 1 /*meshMode*/); + addTest(index++, 2, 0 /*unused*/, 0 /*unused*/, 0 /*unused*/); + addTest(index++, 3, 7 /*wResolution*/, 5 /*hResolution*/, 0 /*unused*/); + + return true; + } + + public ScriptField_TestScripts_s.Item[] getTests() { + return mTests; + } + + public String[] getTestNames() { + return mNames; + } + + private Allocation loadTextureRGB(int id) { + return Allocation.createFromBitmapResource(mRS, mRes, id, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + private Allocation loadTextureARGB(int id) { + Bitmap b = BitmapFactory.decodeResource(mRes, id, mOptionsARGB); + return Allocation.createFromBitmap(mRS, b, + Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + } + + private void createParticlesMesh() { + ScriptField_Particle p = new ScriptField_Particle(mRS, PARTICLES_COUNT); + + final Mesh.AllocationBuilder meshBuilder = new Mesh.AllocationBuilder(mRS); + meshBuilder.addVertexAllocation(p.getAllocation()); + final int vertexSlot = meshBuilder.getCurrentVertexTypeIndex(); + meshBuilder.addIndexSetType(Primitive.POINT); + mParticlesMesh = meshBuilder.create(); + + mUiScript.set_gParticlesMesh(mParticlesMesh); + mUiScript.bind_Particles(p); + } + + /** + * Create a mesh with a single quad for the given width and height. + */ + private Mesh getSingleMesh(float width, float height) { + Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, + 2, Mesh.TriangleMeshBuilder.TEXTURE_0); + float xOffset = width/2; + float yOffset = height/2; + tmb.setTexture(0, 0); + tmb.addVertex(-1.0f * xOffset, -1.0f * yOffset); + tmb.setTexture(1, 0); + tmb.addVertex(xOffset, -1.0f * yOffset); + tmb.setTexture(1, 1); + tmb.addVertex(xOffset, yOffset); + tmb.setTexture(0, 1); + tmb.addVertex(-1.0f * xOffset, yOffset); + tmb.addTriangle(0, 3, 1); + tmb.addTriangle(1, 3, 2); + return tmb.create(true); + } + + private Matrix4f getProjectionNormalized(int w, int h) { + // range -1,1 in the narrow axis at z = 0. + Matrix4f m1 = new Matrix4f(); + Matrix4f m2 = new Matrix4f(); + + if(w > h) { + float aspect = ((float)w) / h; + m1.loadFrustum(-aspect,aspect, -1,1, 1,100); + } else { + float aspect = ((float)h) / w; + m1.loadFrustum(-1,1, -aspect,aspect, 1,100); + } + + m2.loadRotate(180, 0, 1, 0); + m1.loadMultiply(m1, m2); + + m2.loadScale(-2, 2, 1); + m1.loadMultiply(m1, m2); + + m2.loadTranslate(0, 0, 2); + m1.loadMultiply(m1, m2); + return m1; + } + + private void updateProjectionMatrices() { + Matrix4f projNorm = getProjectionNormalized(1280, 720); + ScriptField_VpConsts.Item i = new ScriptField_VpConsts.Item(); + i.Proj = projNorm; + i.MVP = projNorm; + mPvStarAlloc.set(i, 0, true); + mPvProjectionAlloc.setProjection(projNorm); + } + + void initUiScript() { + mUiScript = new ScriptC_ui_test(mRS, mRes, R.raw.ui_test); + + ProgramFragmentFixedFunction.Builder colBuilder = new ProgramFragmentFixedFunction.Builder(mRS); + colBuilder.setVaryingColor(false); + ProgramFragmentFixedFunction.Builder texBuilder = new ProgramFragmentFixedFunction.Builder(mRS); + texBuilder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + + ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); + ProgramVertexFixedFunction progVertex = pvb.create(); + ProgramVertexFixedFunction.Constants PVA = new ProgramVertexFixedFunction.Constants(mRS); + ((ProgramVertexFixedFunction)progVertex).bindConstants(PVA); + Matrix4f proj = new Matrix4f(); + proj.loadOrthoWindow(1280, 720); + PVA.setProjection(proj); + + mUiScript.set_gProgVertex(progVertex); + mUiScript.set_gProgFragmentColor(colBuilder.create()); + mUiScript.set_gProgFragmentTexture(texBuilder.create()); + mUiScript.set_gProgStoreBlendAlpha(ProgramStore.BLEND_ALPHA_DEPTH_NONE(mRS)); + + mUiScript.set_gLinearClamp(Sampler.CLAMP_LINEAR(mRS)); + + mUiScript.set_gTexTorus(loadTextureRGB(R.drawable.torusmap)); + mUiScript.set_gTexOpaque(loadTextureRGB(R.drawable.data)); + mUiScript.set_gTexGlobe(loadTextureRGB(R.drawable.globe)); + mUiScript.set_gSingleMesh(mSingleMesh); + + // For GALAXY + ProgramStore.Builder psb = new ProgramStore.Builder(mRS); + psb.setBlendFunc(BlendSrcFunc.ONE, BlendDstFunc.ZERO); + mRS.bindProgramStore(psb.create()); + + psb.setBlendFunc(BlendSrcFunc.SRC_ALPHA, BlendDstFunc.ONE); + mUiScript.set_gPSLights(psb.create()); + + // For Galaxy live wallpaper drawing + ProgramFragmentFixedFunction.Builder builder = new ProgramFragmentFixedFunction.Builder(mRS); + builder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGB, 0); + ProgramFragment pfb = builder.create(); + pfb.bindSampler(Sampler.WRAP_NEAREST(mRS), 0); + mUiScript.set_gPFBackground(pfb); + + builder = new ProgramFragmentFixedFunction.Builder(mRS); + builder.setPointSpriteTexCoordinateReplacement(true); + builder.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.MODULATE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + builder.setVaryingColor(true); + ProgramFragment pfs = builder.create(); + pfs.bindSampler(Sampler.WRAP_LINEAR_MIP_LINEAR(mRS), 0); + mUiScript.set_gPFStars(pfs); + + mTextureAllocs = new ScriptField_ListAllocs_s(mRS, 100); + for (int i = 0; i < 100; i++) { + ScriptField_ListAllocs_s.Item texElem = new ScriptField_ListAllocs_s.Item(); + texElem.item = loadTextureRGB(R.drawable.globe); + mTextureAllocs.set(texElem, i, false); + } + mTextureAllocs.copyAll(); + mUiScript.bind_gTexList100(mTextureAllocs); + + mSampleTextAllocs = new ScriptField_ListAllocs_s(mRS, 100); + for (int i = 0; i < 100; i++) { + ScriptField_ListAllocs_s.Item textElem = new ScriptField_ListAllocs_s.Item(); + textElem.item = Allocation.createFromString(mRS, SAMPLE_TEXT, Allocation.USAGE_SCRIPT); + mSampleTextAllocs.set(textElem, i, false); + } + mSampleTextAllocs.copyAll(); + mUiScript.bind_gSampleTextList100(mSampleTextAllocs); + + mSampleListViewAllocs = new ScriptField_ListAllocs_s(mRS, 1000); + for (int i = 0; i < 1000; i++) { + ScriptField_ListAllocs_s.Item textElem = new ScriptField_ListAllocs_s.Item(); + textElem.item = Allocation.createFromString(mRS, LIST_TEXT, Allocation.USAGE_SCRIPT); + mSampleListViewAllocs.set(textElem, i, false); + } + mSampleListViewAllocs.copyAll(); + mUiScript.bind_gListViewText(mSampleListViewAllocs); + + // For galaxy live wallpaper + mPvStarAlloc = new ScriptField_VpConsts(mRS, 1); + mUiScript.bind_vpConstants(mPvStarAlloc); + mPvProjectionAlloc = new ProgramVertexFixedFunction.Constants(mRS); + updateProjectionMatrices(); + + pvb = new ProgramVertexFixedFunction.Builder(mRS); + ProgramVertex pvbp = pvb.create(); + ((ProgramVertexFixedFunction)pvbp).bindConstants(mPvProjectionAlloc); + mUiScript.set_gPVBkProj(pvbp); + + createParticlesMesh(); + + ProgramVertex.Builder sb = new ProgramVertex.Builder(mRS); + String t = "varying vec4 varColor;\n" + + "varying vec2 varTex0;\n" + + "void main() {\n" + + " float dist = ATTRIB_position.y;\n" + + " float angle = ATTRIB_position.x;\n" + + " float x = dist * sin(angle);\n" + + " float y = dist * cos(angle) * 0.892;\n" + + " float p = dist * 5.5;\n" + + " float s = cos(p);\n" + + " float t = sin(p);\n" + + " vec4 pos;\n" + + " pos.x = t * x + s * y;\n" + + " pos.y = s * x - t * y;\n" + + " pos.z = ATTRIB_position.z;\n" + + " pos.w = 1.0;\n" + + " gl_Position = UNI_MVP * pos;\n" + + " gl_PointSize = ATTRIB_color.a * 10.0;\n" + + " varColor.rgb = ATTRIB_color.rgb;\n" + + " varColor.a = 1.0;\n" + + "}\n"; + sb.setShader(t); + sb.addInput(mParticlesMesh.getVertexAllocation(0).getType().getElement()); + sb.addConstant(mPvStarAlloc.getType()); + ProgramVertex pvs = sb.create(); + pvs.bindConstants(mPvStarAlloc.getAllocation(), 0); + mUiScript.set_gPVStars(pvs); + + // For Galaxy live wallpaper + mUiScript.set_gTSpace(loadTextureRGB(R.drawable.space)); + mUiScript.set_gTLight1(loadTextureRGB(R.drawable.light1)); + mUiScript.set_gTFlares(loadTextureARGB(R.drawable.flares)); + + mUiScript.set_gFontSans(mFontSans); + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/fill_test.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/fill_test.rs new file mode 100644 index 0000000..281f830 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/fill_test.rs @@ -0,0 +1,158 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.perftest) + +#include "rs_graphics.rsh" +#include "subtest_def.rsh" + +rs_program_vertex gProgVertex; +rs_program_fragment gProgFragmentTexture; +rs_program_fragment gProgFragmentTextureModulate; +rs_program_fragment gProgFragmentMultitex; + +rs_program_store gProgStoreBlendNone; +rs_program_store gProgStoreBlendAlpha; + +rs_allocation gTexOpaque; +rs_allocation gTexTorus; +rs_allocation gTexTransparent; +rs_allocation gTexChecker; + +rs_sampler gLinearClamp; +rs_sampler gLinearWrap; + +typedef struct FillTestData_s { + int testId; + int blend; + int quadCount; +} FillTestData; +FillTestData *gData; + +typedef struct FillTestFragData_s { + float4 modulate; +} FillTestFragData; +FillTestFragData *gFragData; + +static float gDt = 0.0f; + +void init() { +} + +static int gRenderSurfaceW = 1280; +static int gRenderSurfaceH = 720; + +static void bindProgramVertexOrtho() { + // Default vertex shader + rsgBindProgramVertex(gProgVertex); + // Setup the projection matrix + rs_matrix4x4 proj; + rsMatrixLoadOrtho(&proj, 0, gRenderSurfaceW, gRenderSurfaceH, 0, -500, 500); + rsgProgramVertexLoadProjectionMatrix(&proj); +} + +static void displaySingletexFill(bool blend, int quadCount, bool modulate) { + bindProgramVertexOrtho(); + rs_matrix4x4 matrix; + rsMatrixLoadIdentity(&matrix); + rsgProgramVertexLoadModelMatrix(&matrix); + + // Fragment shader with texture + if (!blend) { + rsgBindProgramStore(gProgStoreBlendNone); + } else { + rsgBindProgramStore(gProgStoreBlendAlpha); + } + if (modulate) { + rsgBindProgramFragment(gProgFragmentTextureModulate); + rsgBindSampler(gProgFragmentTextureModulate, 0, gLinearClamp); + rsgBindTexture(gProgFragmentTextureModulate, 0, gTexOpaque); + + gFragData->modulate.r = 0.8f; + gFragData->modulate.g = 0.7f; + gFragData->modulate.b = 0.8f; + gFragData->modulate.a = 0.5f; + rsgAllocationSyncAll(rsGetAllocation(gFragData)); + } else { + rsgBindProgramFragment(gProgFragmentTexture); + rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); + rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque); + } + + for (int i = 0; i < quadCount; i ++) { + float startX = 5 * i, startY = 5 * i; + float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY; + rsgDrawQuadTexCoords(startX, startY, 0, 0, 0, + startX, startY + height, 0, 0, 1, + startX + width, startY + height, 0, 1, 1, + startX + width, startY, 0, 1, 0); + } +} + +static void displayMultitextureSample(bool blend, int quadCount) { + bindProgramVertexOrtho(); + rs_matrix4x4 matrix; + rsMatrixLoadIdentity(&matrix); + rsgProgramVertexLoadModelMatrix(&matrix); + + // Fragment shader with texture + if (!blend) { + rsgBindProgramStore(gProgStoreBlendNone); + } else { + rsgBindProgramStore(gProgStoreBlendAlpha); + } + rsgBindProgramFragment(gProgFragmentMultitex); + rsgBindSampler(gProgFragmentMultitex, 0, gLinearClamp); + rsgBindSampler(gProgFragmentMultitex, 1, gLinearWrap); + rsgBindSampler(gProgFragmentMultitex, 2, gLinearClamp); + rsgBindTexture(gProgFragmentMultitex, 0, gTexChecker); + rsgBindTexture(gProgFragmentMultitex, 1, gTexTorus); + rsgBindTexture(gProgFragmentMultitex, 2, gTexTransparent); + + for (int i = 0; i < quadCount; i ++) { + float startX = 10 * i, startY = 10 * i; + float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY; + rsgDrawQuadTexCoords(startX, startY, 0, 0, 0, + startX, startY + height, 0, 0, 1, + startX + width, startY + height, 0, 1, 1, + startX + width, startY, 0, 1, 0); + } +} + + +void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) { + TestData *testData = (TestData*)usrData; + gRenderSurfaceW = testData->renderSurfaceW; + gRenderSurfaceH = testData->renderSurfaceH; + gDt = testData->dt; + + gData = (FillTestData*)v_in; + + switch(gData->testId) { + case 0: + displayMultitextureSample(gData->blend == 1 ? true : false, gData->quadCount); + break; + case 1: + displaySingletexFill(gData->blend == 1 ? true : false, gData->quadCount, false); + break; + case 2: + displaySingletexFill(gData->blend == 1 ? true : false, gData->quadCount, true); + break; + default: + rsDebug("Wrong test number", 0); + break; + } +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/mesh_test.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/mesh_test.rs new file mode 100644 index 0000000..d7e4857 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/mesh_test.rs @@ -0,0 +1,89 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.perftest) + +#include "rs_graphics.rsh" +#include "shader_def.rsh" +#include "subtest_def.rsh" + +rs_program_vertex gProgVertex; +rs_program_fragment gProgFragmentTexture; + +rs_program_store gProgStoreBlendNone; + +rs_allocation gTexOpaque; + +rs_mesh g10by10Mesh; +rs_mesh g100by100Mesh; +rs_mesh gWbyHMesh; + +rs_sampler gLinearClamp; +static int gRenderSurfaceW; +static int gRenderSurfaceH; + +static float gDt = 0; + +typedef struct MeshTestData_s { + int meshNum; +} MeshTestData; +MeshTestData *gData; + +void init() { +} + +static void bindProgramVertexOrtho() { + // Default vertex shader + rsgBindProgramVertex(gProgVertex); + // Setup the projection matrix + rs_matrix4x4 proj; + rsMatrixLoadOrtho(&proj, 0, gRenderSurfaceW, gRenderSurfaceH, 0, -500, 500); + rsgProgramVertexLoadProjectionMatrix(&proj); +} + +static void displayMeshSamples(int meshNum) { + + bindProgramVertexOrtho(); + rs_matrix4x4 matrix; + rsMatrixLoadTranslate(&matrix, gRenderSurfaceW/2, gRenderSurfaceH/2, 0); + rsgProgramVertexLoadModelMatrix(&matrix); + + // Fragment shader with texture + rsgBindProgramStore(gProgStoreBlendNone); + rsgBindProgramFragment(gProgFragmentTexture); + rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); + + rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque); + + if (meshNum == 0) { + rsgDrawMesh(g10by10Mesh); + } else if (meshNum == 1) { + rsgDrawMesh(g100by100Mesh); + } else if (meshNum == 2) { + rsgDrawMesh(gWbyHMesh); + } +} + +void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) { + TestData *testData = (TestData*)usrData; + gRenderSurfaceW = testData->renderSurfaceW; + gRenderSurfaceH = testData->renderSurfaceH; + gDt = testData->dt; + + gData = (MeshTestData*)v_in; + + displayMeshSamples(gData->meshNum); +} diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs index db97835..27e5b11 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs @@ -1,4 +1,4 @@ -// Copyright (C) 2009 The Android Open Source Project +// Copyright (C) 2010-2011 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -24,104 +24,34 @@ const int RS_MSG_TEST_DONE = 100; const int RS_MSG_RESULTS_READY = 101; -const int gMaxModes = 31; -int gMaxLoops; - -// Parameters for galaxy live wallpaper -rs_allocation gTSpace; -rs_allocation gTLight1; -rs_allocation gTFlares; -rs_mesh gParticlesMesh; - -rs_program_fragment gPFBackground; -rs_program_fragment gPFStars; -rs_program_vertex gPVStars; -rs_program_vertex gPVBkProj; -rs_program_store gPSLights; - -float gXOffset = 0.5f; - -#define ELLIPSE_RATIO 0.892f -#define PI 3.1415f -#define TWO_PI 6.283f -#define ELLIPSE_TWIST 0.023333333f - -static float angle = 50.f; -static int gOldWidth; -static int gOldHeight; -static int gWidth; -static int gHeight; -static float gSpeed[12000]; -static int gGalaxyRadius = 300; -static rs_allocation gParticlesBuffer; - -typedef struct __attribute__((packed, aligned(4))) Particle { - uchar4 color; - float3 position; -} Particle_t; -Particle_t *Particles; - -typedef struct VpConsts { - rs_matrix4x4 Proj; - rs_matrix4x4 MVP; -} VpConsts_t; -VpConsts_t *vpConstants; -// End of parameters for galaxy live wallpaper - -// Allocation to send test names back to java -char *gStringBuffer = 0; +static const int gMaxModes = 64; +int gMaxLoops = 1; +int gDisplayMode = 1; + // Allocation to write the results into static float gResultBuffer[gMaxModes]; -rs_program_vertex gProgVertex; -rs_program_fragment gProgFragmentColor; -rs_program_fragment gProgFragmentTexture; - -rs_program_store gProgStoreBlendNoneDepth; -rs_program_store gProgStoreBlendNone; -rs_program_store gProgStoreBlendAlpha; -rs_program_store gProgStoreBlendAdd; - -rs_allocation gTexOpaque; -rs_allocation gTexTorus; -rs_allocation gTexTransparent; -rs_allocation gTexChecker; -rs_allocation gTexGlobe; - -typedef struct ListAllocs_s { - rs_allocation item; -} ListAllocs; - -ListAllocs *gTexList100; -ListAllocs *gSampleTextList100; -ListAllocs *gListViewText; - -rs_mesh g10by10Mesh; -rs_mesh g100by100Mesh; -rs_mesh gWbyHMesh; -rs_mesh gSingleMesh; - -rs_font gFontSans; rs_font gFontSerif; - -int gDisplayMode; - rs_sampler gLinearClamp; -rs_sampler gLinearWrap; -rs_sampler gMipLinearWrap; -rs_sampler gNearestClamp; -rs_program_raster gCullBack; -rs_program_raster gCullFront; -rs_program_raster gCullNone; +rs_program_vertex gProgVertex; +rs_program_fragment gProgFragmentTexture; + +rs_allocation gRenderBufferColor; +rs_allocation gRenderBufferDepth; -// Export these out to easily set the inputs to shader VertexShaderInputs *gVSInputs; -rs_program_fragment gProgFragmentMultitex; +typedef struct TestScripts_s { + rs_allocation testData; + rs_allocation testName; + rs_allocation debugName; + rs_script testScript; +} TestScripts; +TestScripts *gTestScripts; -rs_allocation gRenderBufferColor; -rs_allocation gRenderBufferDepth; +bool gLoadComplete = false; +bool gPauseRendering = false; static float gDt = 0; @@ -131,158 +61,17 @@ void init() { static int gRenderSurfaceW; static int gRenderSurfaceH; -/** - * Methods to draw the galaxy live wall paper - */ -static float mapf(float minStart, float minStop, float maxStart, float maxStop, float value) { - return maxStart + (maxStart - maxStop) * ((value - minStart) / (minStop - minStart)); -} - -/** - * Helper function to generate the stars. - */ -static float randomGauss() { - float x1; - float x2; - float w = 2.f; - - while (w >= 1.0f) { - x1 = rsRand(2.0f) - 1.0f; - x2 = rsRand(2.0f) - 1.0f; - w = x1 * x1 + x2 * x2; - } - - w = sqrt(-2.0f * log(w) / w); - return x1 * w; +static void fillSurfaceParams(TestData *testData) { + testData->renderSurfaceW = gRenderSurfaceW; + testData->renderSurfaceH = gRenderSurfaceH; + testData->dt = gDt; } -/** - * Generates the properties for a given star. - */ -static void createParticle(Particle_t *part, int idx, float scale) { - float d = fabs(randomGauss()) * gGalaxyRadius * 0.5f + rsRand(64.0f); - float id = d / gGalaxyRadius; - float z = randomGauss() * 0.4f * (1.0f - id); - float p = -d * ELLIPSE_TWIST; - - if (d < gGalaxyRadius * 0.33f) { - part->color.x = (uchar) (220 + id * 35); - part->color.y = 220; - part->color.z = 220; - } else { - part->color.x = 180; - part->color.y = 180; - part->color.z = (uchar) clamp(140.f + id * 115.f, 140.f, 255.f); - } - // Stash point size * 10 in Alpha - part->color.w = (uchar) (rsRand(1.2f, 2.1f) * 60); - - if (d > gGalaxyRadius * 0.15f) { - z *= 0.6f * (1.0f - id); - } else { - z *= 0.72f; - } - - // Map to the projection coordinates (viewport.x = -1.0 -> 1.0) - d = mapf(-4.0f, gGalaxyRadius + 4.0f, 0.0f, scale, d); - - part->position.x = rsRand(TWO_PI); - part->position.y = d; - gSpeed[idx] = rsRand(0.0015f, 0.0025f) * (0.5f + (scale / d)) * 0.8f; - - part->position.z = z / 5.0f; -} - -/** - * Initialize all the starts, called from Java - */ -void initParticles() { - Particle_t *part = Particles; - float scale = gGalaxyRadius / (gWidth * 0.5f); - int count = rsAllocationGetDimX(gParticlesBuffer); - for (int i = 0; i < count; i ++) { - createParticle(part, i, scale); - part++; - } -} - -static void drawSpace() { - rsgBindProgramFragment(gPFBackground); - rsgBindTexture(gPFBackground, 0, gTSpace); - rsgDrawQuadTexCoords( - 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, - gWidth, 0.0f, 0.0f, 2.0f, 1.0f, - gWidth, gHeight, 0.0f, 2.0f, 0.0f, - 0.0f, gHeight, 0.0f, 0.0f, 0.0f); -} - -static void drawLights() { - rsgBindProgramVertex(gPVBkProj); - rsgBindProgramFragment(gPFBackground); - rsgBindTexture(gPFBackground, 0, gTLight1); - - float scale = 512.0f / gWidth; - float x = -scale - scale * 0.05f; - float y = -scale; - - scale *= 2.0f; - - rsgDrawQuad(x, y, 0.0f, - x + scale * 1.1f, y, 0.0f, - x + scale * 1.1f, y + scale, 0.0f, - x, y + scale, 0.0f); -} - -static void drawParticles(float offset) { - float a = offset * angle; - float absoluteAngle = fabs(a); - - rs_matrix4x4 matrix; - rsMatrixLoadTranslate(&matrix, 0.0f, 0.0f, 10.0f - 6.0f * absoluteAngle / 50.0f); - if (gHeight > gWidth) { - rsMatrixScale(&matrix, 6.6f, 6.0f, 1.0f); - } else { - rsMatrixScale(&matrix, 12.6f, 12.0f, 1.0f); - } - rsMatrixRotate(&matrix, absoluteAngle, 1.0f, 0.0f, 0.0f); - rsMatrixRotate(&matrix, a, 0.0f, 0.4f, 0.1f); - rsMatrixLoad(&vpConstants->MVP, &vpConstants->Proj); - rsMatrixMultiply(&vpConstants->MVP, &matrix); - rsgAllocationSyncAll(rsGetAllocation(vpConstants)); - - rsgBindProgramVertex(gPVStars); - rsgBindProgramFragment(gPFStars); - rsgBindProgramStore(gPSLights); - rsgBindTexture(gPFStars, 0, gTFlares); - - Particle_t *vtx = Particles; - int count = rsAllocationGetDimX(gParticlesBuffer); - for (int i = 0; i < count; i++) { - vtx->position.x = vtx->position.x + gSpeed[i]; - vtx++; - } - - rsgDrawMesh(gParticlesMesh); -} -/* end of methods for drawing galaxy */ - static void setupOffscreenTarget() { rsgBindColorTarget(gRenderBufferColor, 0); rsgBindDepthTarget(gRenderBufferDepth); } -rs_script gFontScript; -rs_script gTorusScript; -rs_allocation gDummyAlloc; - -static void displayFontSamples(int fillNum) { - TestData testData; - testData.renderSurfaceW = gRenderSurfaceW; - testData.renderSurfaceH = gRenderSurfaceH; - testData.user = fillNum; - rsForEach(gFontScript, gDummyAlloc, gDummyAlloc, &testData, sizeof(testData)); -} - static void bindProgramVertexOrtho() { // Default vertex shader rsgBindProgramVertex(gProgVertex); @@ -292,302 +81,31 @@ static void bindProgramVertexOrtho() { rsgProgramVertexLoadProjectionMatrix(&proj); } -static void displaySingletexFill(bool blend, int quadCount) { - bindProgramVertexOrtho(); - rs_matrix4x4 matrix; - rsMatrixLoadIdentity(&matrix); - rsgProgramVertexLoadModelMatrix(&matrix); - - // Fragment shader with texture - if (!blend) { - rsgBindProgramStore(gProgStoreBlendNone); - } else { - rsgBindProgramStore(gProgStoreBlendAlpha); - } - rsgBindProgramFragment(gProgFragmentTexture); - rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); - rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque); - - for (int i = 0; i < quadCount; i ++) { - float startX = 5 * i, startY = 5 * i; - float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY; - rsgDrawQuadTexCoords(startX, startY, 0, 0, 0, - startX, startY + height, 0, 0, 1, - startX + width, startY + height, 0, 1, 1, - startX + width, startY, 0, 1, 0); - } -} - -static void displayMeshSamples(int meshNum) { - - bindProgramVertexOrtho(); - rs_matrix4x4 matrix; - rsMatrixLoadTranslate(&matrix, gRenderSurfaceW/2, gRenderSurfaceH/2, 0); - rsgProgramVertexLoadModelMatrix(&matrix); - - // Fragment shader with texture - rsgBindProgramStore(gProgStoreBlendNone); - rsgBindProgramFragment(gProgFragmentTexture); - rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); - - rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque); - - if (meshNum == 0) { - rsgDrawMesh(g10by10Mesh); - } else if (meshNum == 1) { - rsgDrawMesh(g100by100Mesh); - } else if (meshNum == 2) { - rsgDrawMesh(gWbyHMesh); - } -} - -// Display sample images in a mesh with different texture -static void displayIcons(int meshMode) { - bindProgramVertexOrtho(); - - // Fragment shader with texture - rsgBindProgramStore(gProgStoreBlendAlpha); - rsgBindProgramFragment(gProgFragmentTexture); - rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); - rsgBindTexture(gProgFragmentTexture, 0, gTexTorus); - rsgDrawQuadTexCoords( - 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, - 0.0f, gRenderSurfaceH, 0.0f, 0.0f, 1.0f, - gRenderSurfaceW, gRenderSurfaceH, 0.0f, 1.0f, 1.0f, - gRenderSurfaceW, 0.0f, 0.0f, 1.0f, 0.0f); - - int meshCount = (int)pow(10.0f, (float)(meshMode + 1)); - - float wSize = gRenderSurfaceW/(float)meshCount; - float hSize = gRenderSurfaceH/(float)meshCount; - rs_matrix4x4 matrix; - rsMatrixLoadScale(&matrix, wSize, hSize, 1.0); - - float yPos = 0; - float yPad = hSize / 2; - float xPad = wSize / 2; - for (int y = 0; y < meshCount; y++) { - yPos = y * hSize + yPad; - float xPos = 0; - for (int x = 0; x < meshCount; x++) { - xPos = x * wSize + xPad; - rs_matrix4x4 transMatrix; - rsMatrixLoadTranslate(&transMatrix, xPos, yPos, 0); - rsMatrixMultiply(&transMatrix, &matrix); - rsgProgramVertexLoadModelMatrix(&transMatrix); - int i = (x + y * meshCount) % 100; - rsgBindTexture(gProgFragmentTexture, 0, gTexList100[i].item); - rsgDrawMesh(gSingleMesh); - } - } -} - -// Draw meshes in a single page with top left corner coordinates (xStart, yStart) -static void drawMeshInPage(float xStart, float yStart, int wResolution, int hResolution) { - // Draw wResolution * hResolution meshes in one page - float wMargin = 100.0f; - float hMargin = 100.0f; - float xPad = 50.0f; - float yPad = 20.0f; - float size = 100.0f; // size of images - - // font info - rs_font font = gFontSans; - rsgBindFont(font); - rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f); - - // Measure text size - int left = 0, right = 0, top = 0, bottom = 0; - rsgMeasureText(gSampleTextList100[0].item, &left, &right, &top, &bottom); - float textHeight = (float)(top - bottom); - float textWidth = (float)(right - left); - - rs_matrix4x4 matrix; - rsMatrixLoadScale(&matrix, size, size, 1.0); - - for (int y = 0; y < hResolution; y++) { - float yPos = yStart + hMargin + y * size + y * yPad; - for (int x = 0; x < wResolution; x++) { - float xPos = xStart + wMargin + x * size + x * xPad; - - rs_matrix4x4 transMatrix; - rsMatrixLoadTranslate(&transMatrix, xPos + size/2, yPos + size/2, 0); - rsMatrixMultiply(&transMatrix, &matrix); // scale the mesh - rsgProgramVertexLoadModelMatrix(&transMatrix); - - int i = (y * wResolution + x) % 100; - rsgBindTexture(gProgFragmentTexture, 0, gTexList100[i].item); - rsgDrawMesh(gSingleMesh); - rsgDrawText(gSampleTextList100[i].item, xPos, yPos + size + yPad/2 + textHeight); - } - } -} - -// Display both images and text as shown in launcher and homepage -// meshMode will decide how many pages we draw -// meshMode = 0: draw 3 pages of meshes -// meshMode = 1: draw 5 pages of meshes -static void displayImageWithText(int wResolution, int hResolution, int meshMode) { - bindProgramVertexOrtho(); - - // Fragment shader with texture - rsgBindProgramStore(gProgStoreBlendAlpha); - rsgBindProgramFragment(gProgFragmentTexture); - rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); - - drawMeshInPage(0, 0, wResolution, hResolution); - drawMeshInPage(-1.0f*gRenderSurfaceW, 0, wResolution, hResolution); - drawMeshInPage(1.0f*gRenderSurfaceW, 0, wResolution, hResolution); - if (meshMode == 1) { - // draw another two pages of meshes - drawMeshInPage(-2.0f*gRenderSurfaceW, 0, wResolution, hResolution); - drawMeshInPage(2.0f*gRenderSurfaceW, 0, wResolution, hResolution); - } -} - -// Display a list of text as the list view -static void displayListView() { - // set text color - rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); - rsgBindFont(gFontSans); - - // get the size of the list - rs_allocation textAlloc; - textAlloc = rsGetAllocation(gListViewText); - int allocSize = rsAllocationGetDimX(textAlloc); - - int listItemHeight = 80; - int yOffset = listItemHeight; - - // set the color for the list divider - rsgBindProgramFragment(gProgFragmentColor); - rsgProgramFragmentConstantColor(gProgFragmentColor, 1.0, 1.0, 1.0, 1); - - // draw the list with divider - for (int i = 0; i < allocSize; i++) { - if (yOffset - listItemHeight > gRenderSurfaceH) { - break; - } - rsgDrawRect(0, yOffset - 1, gRenderSurfaceW, yOffset, 0); - rsgDrawText(gListViewText[i].item, 20, yOffset - 10); - yOffset += listItemHeight; - } -} - -static void drawGalaxy() { - rsgClearColor(0.f, 0.f, 0.f, 1.f); - gParticlesBuffer = rsGetAllocation(Particles); - rsgBindProgramFragment(gPFBackground); - - gWidth = rsgGetWidth(); - gHeight = rsgGetHeight(); - if ((gWidth != gOldWidth) || (gHeight != gOldHeight)) { - initParticles(); - gOldWidth = gWidth; - gOldHeight = gHeight; - } - - float offset = mix(-1.0f, 1.0f, gXOffset); - drawSpace(); - drawParticles(offset); - drawLights(); -} - -// Display images and text with live wallpaper in the background -static void displayLiveWallPaper(int wResolution, int hResolution) { - bindProgramVertexOrtho(); - - drawGalaxy(); - - rsgBindProgramVertex(gProgVertex); - rsgBindProgramStore(gProgStoreBlendAlpha); - rsgBindProgramFragment(gProgFragmentTexture); - rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); - - drawMeshInPage(0, 0, wResolution, hResolution); - drawMeshInPage(-1.0f*gRenderSurfaceW, 0, wResolution, hResolution); - drawMeshInPage(1.0f*gRenderSurfaceW, 0, wResolution, hResolution); - drawMeshInPage(-2.0f*gRenderSurfaceW, 0, wResolution, hResolution); - drawMeshInPage(2.0f*gRenderSurfaceW, 0, wResolution, hResolution); -} - -// Quick hack to get some geometry numbers -static void displaySimpleGeoSamples(bool useTexture, int numMeshes) { +static void runSubTest(int index) { TestData testData; - testData.renderSurfaceW = gRenderSurfaceW; - testData.renderSurfaceH = gRenderSurfaceH; - testData.dt = gDt; - testData.user = 0; - testData.user1 = useTexture ? 1 : 0; - testData.user2 = numMeshes; - rsForEach(gTorusScript, gDummyAlloc, gDummyAlloc, &testData, sizeof(testData)); -} + fillSurfaceParams(&testData); -static void displayCustomShaderSamples(int numMeshes) { - TestData testData; - testData.renderSurfaceW = gRenderSurfaceW; - testData.renderSurfaceH = gRenderSurfaceH; - testData.dt = gDt; - testData.user = 1; - testData.user1 = numMeshes; - rsForEach(gTorusScript, gDummyAlloc, gDummyAlloc, &testData, sizeof(testData)); + rs_allocation null_alloc; + rsForEach(gTestScripts[index].testScript, + gTestScripts[index].testData, + null_alloc, + &testData, + sizeof(testData)); } -static void displayPixelLightSamples(int numMeshes, bool heavyVertex) { - TestData testData; - testData.renderSurfaceW = gRenderSurfaceW; - testData.renderSurfaceH = gRenderSurfaceH; - testData.dt = gDt; - testData.user = 2; - testData.user1 = numMeshes; - testData.user2 = heavyVertex ? 1 : 0; - rsForEach(gTorusScript, gDummyAlloc, gDummyAlloc, &testData, sizeof(testData)); -} - -static void displayMultitextureSample(bool blend, int quadCount) { - bindProgramVertexOrtho(); - rs_matrix4x4 matrix; - rsMatrixLoadIdentity(&matrix); - rsgProgramVertexLoadModelMatrix(&matrix); - - // Fragment shader with texture - if (!blend) { - rsgBindProgramStore(gProgStoreBlendNone); - } else { - rsgBindProgramStore(gProgStoreBlendAlpha); - } - rsgBindProgramFragment(gProgFragmentMultitex); - rsgBindSampler(gProgFragmentMultitex, 0, gLinearClamp); - rsgBindSampler(gProgFragmentMultitex, 1, gLinearWrap); - rsgBindSampler(gProgFragmentMultitex, 2, gLinearClamp); - rsgBindTexture(gProgFragmentMultitex, 0, gTexChecker); - rsgBindTexture(gProgFragmentMultitex, 1, gTexTorus); - rsgBindTexture(gProgFragmentMultitex, 2, gTexTransparent); - - for (int i = 0; i < quadCount; i ++) { - float startX = 10 * i, startY = 10 * i; - float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY; - rsgDrawQuadTexCoords(startX, startY, 0, 0, 0, - startX, startY + height, 0, 0, 1, - startX + width, startY + height, 0, 1, 1, - startX + width, startY, 0, 1, 0); - } -} static bool checkInit() { - static int countdown = 5; + static int countdown = 3; // Perform all the uploads so we only measure rendered time if(countdown > 1) { - displayFontSamples(5); - displaySingletexFill(true, 3); - displayMeshSamples(0); - displayMeshSamples(1); - displayMeshSamples(2); - displayMultitextureSample(true, 5); - displayPixelLightSamples(1, false); - displayPixelLightSamples(1, true); + int testCount = rsAllocationGetDimX(rsGetAllocation(gTestScripts)); + for(int i = 0; i < testCount; i ++) { + rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f); + runSubTest(i); + rsgFinish(); + } countdown --; rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f); @@ -606,43 +124,11 @@ static bool checkInit() { } static int benchMode = 0; +static bool benchmarkSingleTest = false; +static int benchSubMode = 0; static int runningLoops = 0; static bool sendMsgFlag = false; -static const char *testNames[] = { - "Fill screen with text 1 time", - "Fill screen with text 3 times", - "Fill screen with text 5 times", - "Geo test 25.6k flat color", - "Geo test 51.2k flat color", - "Geo test 204.8k small tries flat color", - "Geo test 25.6k single texture", - "Geo test 51.2k single texture", - "Geo test 204.8k small tries single texture", - "Full screen mesh 10 by 10", - "Full screen mesh 100 by 100", - "Full screen mesh W / 4 by H / 4", - "Geo test 25.6k geo heavy vertex", - "Geo test 51.2k geo heavy vertex", - "Geo test 204.8k geo raster load heavy vertex", - "Fill screen 10x singletexture", - "Fill screen 10x 3tex multitexture", - "Fill screen 10x blended singletexture", - "Fill screen 10x blended 3tex multitexture", - "Geo test 25.6k heavy fragment", - "Geo test 51.2k heavy fragment", - "Geo test 204.8k small tries heavy fragment", - "Geo test 25.6k heavy fragment heavy vertex", - "Geo test 51.2k heavy fragment heavy vertex", - "Geo test 204.8k small tries heavy fragment heavy vertex", - "UI test with icon display 10 by 10", - "UI test with icon display 100 by 100", - "UI test with image and text display 3 pages", - "UI test with image and text display 5 pages", - "UI test with list view", - "UI test with live wallpaper", -}; - static bool gIsDebugMode = false; void setDebugMode(int testNumber) { gIsDebugMode = true; @@ -650,122 +136,17 @@ void setDebugMode(int testNumber) { rsgClearAllRenderTargets(); } -void setBenchmarkMode() { +void setBenchmarkMode(int testNumber) { gIsDebugMode = false; - benchMode = 0; - runningLoops = 0; -} - - -void getTestName(int testIndex) { - int bufferLen = rsAllocationGetDimX(rsGetAllocation(gStringBuffer)); - if (testIndex >= gMaxModes) { - return; - } - uint charIndex = 0; - while (testNames[testIndex][charIndex] != '\0' && charIndex < bufferLen) { - gStringBuffer[charIndex] = testNames[testIndex][charIndex]; - charIndex ++; + if (testNumber == -1) { + benchmarkSingleTest = false; + benchMode = 0; + } else { + benchmarkSingleTest = true; + benchMode = testNumber; } - gStringBuffer[charIndex] = '\0'; -} -static void runTest(int index) { - switch (index) { - case 0: - displayFontSamples(1); - break; - case 1: - displayFontSamples(3); - break; - case 2: - displayFontSamples(5); - break; - case 3: - displaySimpleGeoSamples(false, 1); - break; - case 4: - displaySimpleGeoSamples(false, 2); - break; - case 5: - displaySimpleGeoSamples(false, 8); - break; - case 6: - displaySimpleGeoSamples(true, 1); - break; - case 7: - displaySimpleGeoSamples(true, 2); - break; - case 8: - displaySimpleGeoSamples(true, 8); - break; - case 9: - displayMeshSamples(0); - break; - case 10: - displayMeshSamples(1); - break; - case 11: - displayMeshSamples(2); - break; - case 12: - displayCustomShaderSamples(1); - break; - case 13: - displayCustomShaderSamples(2); - break; - case 14: - displayCustomShaderSamples(10); - break; - case 15: - displaySingletexFill(false, 10); - break; - case 16: - displayMultitextureSample(false, 10); - break; - case 17: - displaySingletexFill(true, 10); - break; - case 18: - displayMultitextureSample(true, 10); - break; - case 19: - displayPixelLightSamples(1, false); - break; - case 20: - displayPixelLightSamples(2, false); - break; - case 21: - displayPixelLightSamples(8, false); - break; - case 22: - displayPixelLightSamples(1, true); - break; - case 23: - displayPixelLightSamples(2, true); - break; - case 24: - displayPixelLightSamples(8, true); - break; - case 25: - displayIcons(0); - break; - case 26: - displayIcons(1); - break; - case 27: - displayImageWithText(7, 5, 0); - break; - case 28: - displayImageWithText(7, 5, 1); - break; - case 29: - displayListView(); - break; - case 30: - displayLiveWallPaper(7, 5); - break; - } + runningLoops = 0; } static void drawOffscreenResult(int posX, int posY, int width, int height) { @@ -803,7 +184,7 @@ static void benchmark() { rsgClearColor(0.1f, 0.1f, 0.1f, 1.0f); rsgClearDepth(1.0f); - runTest(benchMode); + runSubTest(benchMode); rsgClearAllRenderTargets(); gRenderSurfaceW = rsgGetWidth(); gRenderSurfaceH = rsgGetHeight(); @@ -816,25 +197,34 @@ static void benchmark() { int64_t end = rsUptimeMillis(); float fps = (float)(frameCount) / ((float)(end - start)*0.001f); - rsDebug(testNames[benchMode], fps); + const char *testName = rsGetElementAt(gTestScripts[benchMode].debugName, 0); + rsDebug(testName, fps); + gResultBuffer[benchMode] = fps; - drawOffscreenResult(0, 0, - gRenderSurfaceW / 2, - gRenderSurfaceH / 2); - const char* text = testNames[benchMode]; + int bufferW = rsAllocationGetDimX(gRenderBufferColor); + int bufferH = rsAllocationGetDimY(gRenderBufferColor); + + int quadW = gRenderSurfaceW / 2; + int quadH = (quadW * bufferH) / bufferW; + drawOffscreenResult(0, 0, quadW, quadH); + int left = 0, right = 0, top = 0, bottom = 0; uint width = rsgGetWidth(); uint height = rsgGetHeight(); rsgFontColor(0.9f, 0.9f, 0.95f, 1.0f); rsgBindFont(gFontSerif); - rsgMeasureText(text, &left, &right, &top, &bottom); + rsgMeasureText(gTestScripts[benchMode].testName, &left, &right, &top, &bottom); rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f); - rsgDrawText(text, 2 -left, height - 2 + bottom); + rsgDrawText(gTestScripts[benchMode].testName, 2 -left, height - 2 + bottom); - benchMode ++; + if (benchmarkSingleTest) { + return; + } - if (benchMode == gMaxModes) { - rsSendToClientBlocking(RS_MSG_RESULTS_READY, gResultBuffer, gMaxModes*sizeof(float)); + benchMode ++; + int testCount = rsAllocationGetDimX(rsGetAllocation(gTestScripts)); + if (benchMode == testCount) { + rsSendToClientBlocking(RS_MSG_RESULTS_READY, gResultBuffer, testCount*sizeof(float)); benchMode = 0; runningLoops++; if ((gMaxLoops > 0) && (runningLoops > gMaxLoops) && !sendMsgFlag) { @@ -844,14 +234,11 @@ static void benchmark() { sendMsgFlag = true; } } - } static void debug() { gDt = rsGetDt(); - - rsgFinish(); - runTest(benchMode); + runSubTest(benchMode); } int root(void) { @@ -859,10 +246,22 @@ int root(void) { gRenderSurfaceH = rsgGetHeight(); rsgClearColor(0.2f, 0.2f, 0.2f, 1.0f); rsgClearDepth(1.0f); + + if (!gLoadComplete) { + rsgFontColor(0.9f, 0.9f, 0.95f, 1.0f); + rsgBindFont(gFontSerif); + rsgDrawText("Loading", 50, 50); + return 0; + } + if(!checkInit()) { return 1; } + if (gPauseRendering) { + rsgDrawText("Paused", 50, 50); + return 30; + } if (gIsDebugMode) { debug(); } else { diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/subtest_def.rsh b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/subtest_def.rsh index b635373..43658b1 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/subtest_def.rsh +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/subtest_def.rsh @@ -20,9 +20,5 @@ typedef struct TestData_s { int renderSurfaceW; int renderSurfaceH; float dt; - int user; - int user1; - int user2; - int user3; } TestData; diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/text_test.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/text_test.rs index 0df6b35..7f10019 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/text_test.rs +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/text_test.rs @@ -22,6 +22,11 @@ rs_font gFontSans; rs_font gFontSerif; +typedef struct TextTestData_s { + int fillNum; +} TextTestData; +TextTestData *gData; + void init() { } @@ -78,5 +83,8 @@ void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32 TestData *testData = (TestData*)usrData; gRenderSurfaceW = testData->renderSurfaceW; gRenderSurfaceH = testData->renderSurfaceH; - displayFontSamples(testData->user); + + gData = (TextTestData*)v_in; + + displayFontSamples(gData->fillNum); } diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/torus_test.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/torus_test.rs index 26d5680..853a05d 100644 --- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/torus_test.rs +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/torus_test.rs @@ -47,6 +47,13 @@ rs_program_vertex gProgVertexPixelLight; rs_program_vertex gProgVertexPixelLightMove; rs_program_fragment gProgFragmentPixelLight; +typedef struct TorusTestData_s { + int testId; + int user1; + int user2; +} TorusTestData; +TorusTestData *gData; + static float gDt = 0.0f; static int gRenderSurfaceW; @@ -269,15 +276,20 @@ void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32 gRenderSurfaceH = testData->renderSurfaceH; gDt = testData->dt; - switch(testData->user) { + gData = (TorusTestData*)v_in; + + switch(gData->testId) { case 0: - displaySimpleGeoSamples(testData->user1 == 1 ? true : false, testData->user2); + displaySimpleGeoSamples(gData->user1 == 1 ? true : false, gData->user2); break; case 1: - displayCustomShaderSamples(testData->user1); + displayCustomShaderSamples(gData->user1); break; case 2: - displayPixelLightSamples(testData->user1, testData->user2 == 1 ? true : false); + displayPixelLightSamples(gData->user1, gData->user2 == 1 ? true : false); + break; + default: + rsDebug("Wrong test number", gData->testId); break; } } diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/ui_test.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/ui_test.rs new file mode 100644 index 0000000..5089092 --- /dev/null +++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/ui_test.rs @@ -0,0 +1,444 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.perftest) + +#include "rs_graphics.rsh" +#include "shader_def.rsh" +#include "subtest_def.rsh" + +// Parameters for galaxy live wallpaper +rs_allocation gTSpace; +rs_allocation gTLight1; +rs_allocation gTFlares; +rs_mesh gParticlesMesh; + +rs_program_fragment gPFBackground; +rs_program_fragment gPFStars; +rs_program_vertex gPVStars; +rs_program_vertex gPVBkProj; +rs_program_store gPSLights; + +float gXOffset = 0.5f; + +#define ELLIPSE_RATIO 0.892f +#define PI 3.1415f +#define TWO_PI 6.283f +#define ELLIPSE_TWIST 0.023333333f + +static float angle = 50.f; +static int gOldWidth; +static int gOldHeight; +static int gWidth; +static int gHeight; +static float gSpeed[12000]; +static int gGalaxyRadius = 300; +static rs_allocation gParticlesBuffer; + +typedef struct __attribute__((packed, aligned(4))) Particle { + uchar4 color; + float3 position; +} Particle_t; +Particle_t *Particles; + +typedef struct VpConsts { + rs_matrix4x4 Proj; + rs_matrix4x4 MVP; +} VpConsts_t; +VpConsts_t *vpConstants; +// End of parameters for galaxy live wallpaper + +rs_program_vertex gProgVertex; +rs_program_fragment gProgFragmentColor; +rs_program_fragment gProgFragmentTexture; + +rs_program_store gProgStoreBlendAlpha; + +rs_allocation gTexOpaque; +rs_allocation gTexTorus; +rs_allocation gTexGlobe; + +typedef struct ListAllocs_s { + rs_allocation item; +} ListAllocs; + +ListAllocs *gTexList100; +ListAllocs *gSampleTextList100; +ListAllocs *gListViewText; + +rs_mesh gSingleMesh; + +rs_font gFontSans; + +rs_sampler gLinearClamp; + +typedef struct UiTestData_s { + int testId; + int user1; + int user2; + int user3; +} UiTestData; +UiTestData *gData; + +static float gDt = 0; + + +void init() { +} + +static int gRenderSurfaceW; +static int gRenderSurfaceH; + +static void bindProgramVertexOrtho() { + // Default vertex shader + rsgBindProgramVertex(gProgVertex); + // Setup the projection matrix + rs_matrix4x4 proj; + rsMatrixLoadOrtho(&proj, 0, gRenderSurfaceW, gRenderSurfaceH, 0, -500, 500); + rsgProgramVertexLoadProjectionMatrix(&proj); +} + +/** + * Methods to draw the galaxy live wall paper + */ +static float mapf(float minStart, float minStop, float maxStart, float maxStop, float value) { + return maxStart + (maxStart - maxStop) * ((value - minStart) / (minStop - minStart)); +} + +/** + * Helper function to generate the stars. + */ +static float randomGauss() { + float x1; + float x2; + float w = 2.f; + + while (w >= 1.0f) { + x1 = rsRand(2.0f) - 1.0f; + x2 = rsRand(2.0f) - 1.0f; + w = x1 * x1 + x2 * x2; + } + + w = sqrt(-2.0f * log(w) / w); + return x1 * w; +} + +/** + * Generates the properties for a given star. + */ +static void createParticle(Particle_t *part, int idx, float scale) { + float d = fabs(randomGauss()) * gGalaxyRadius * 0.5f + rsRand(64.0f); + float id = d / gGalaxyRadius; + float z = randomGauss() * 0.4f * (1.0f - id); + float p = -d * ELLIPSE_TWIST; + + if (d < gGalaxyRadius * 0.33f) { + part->color.x = (uchar) (220 + id * 35); + part->color.y = 220; + part->color.z = 220; + } else { + part->color.x = 180; + part->color.y = 180; + part->color.z = (uchar) clamp(140.f + id * 115.f, 140.f, 255.f); + } + // Stash point size * 10 in Alpha + part->color.w = (uchar) (rsRand(1.2f, 2.1f) * 60); + + if (d > gGalaxyRadius * 0.15f) { + z *= 0.6f * (1.0f - id); + } else { + z *= 0.72f; + } + + // Map to the projection coordinates (viewport.x = -1.0 -> 1.0) + d = mapf(-4.0f, gGalaxyRadius + 4.0f, 0.0f, scale, d); + + part->position.x = rsRand(TWO_PI); + part->position.y = d; + gSpeed[idx] = rsRand(0.0015f, 0.0025f) * (0.5f + (scale / d)) * 0.8f; + + part->position.z = z / 5.0f; +} + +/** + * Initialize all the starts, called from Java + */ +void initParticles() { + Particle_t *part = Particles; + float scale = gGalaxyRadius / (gWidth * 0.5f); + int count = rsAllocationGetDimX(gParticlesBuffer); + for (int i = 0; i < count; i ++) { + createParticle(part, i, scale); + part++; + } +} + +static void drawSpace() { + rsgBindProgramFragment(gPFBackground); + rsgBindTexture(gPFBackground, 0, gTSpace); + rsgDrawQuadTexCoords( + 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, + gWidth, 0.0f, 0.0f, 2.0f, 1.0f, + gWidth, gHeight, 0.0f, 2.0f, 0.0f, + 0.0f, gHeight, 0.0f, 0.0f, 0.0f); +} + +static void drawLights() { + rsgBindProgramVertex(gPVBkProj); + rsgBindProgramFragment(gPFBackground); + rsgBindTexture(gPFBackground, 0, gTLight1); + + float scale = 512.0f / gWidth; + float x = -scale - scale * 0.05f; + float y = -scale; + + scale *= 2.0f; + + rsgDrawQuad(x, y, 0.0f, + x + scale * 1.1f, y, 0.0f, + x + scale * 1.1f, y + scale, 0.0f, + x, y + scale, 0.0f); +} + +static void drawParticles(float offset) { + float a = offset * angle; + float absoluteAngle = fabs(a); + + rs_matrix4x4 matrix; + rsMatrixLoadTranslate(&matrix, 0.0f, 0.0f, 10.0f - 6.0f * absoluteAngle / 50.0f); + if (gHeight > gWidth) { + rsMatrixScale(&matrix, 6.6f, 6.0f, 1.0f); + } else { + rsMatrixScale(&matrix, 12.6f, 12.0f, 1.0f); + } + rsMatrixRotate(&matrix, absoluteAngle, 1.0f, 0.0f, 0.0f); + rsMatrixRotate(&matrix, a, 0.0f, 0.4f, 0.1f); + rsMatrixLoad(&vpConstants->MVP, &vpConstants->Proj); + rsMatrixMultiply(&vpConstants->MVP, &matrix); + rsgAllocationSyncAll(rsGetAllocation(vpConstants)); + + rsgBindProgramVertex(gPVStars); + rsgBindProgramFragment(gPFStars); + rsgBindProgramStore(gPSLights); + rsgBindTexture(gPFStars, 0, gTFlares); + + Particle_t *vtx = Particles; + int count = rsAllocationGetDimX(gParticlesBuffer); + for (int i = 0; i < count; i++) { + vtx->position.x = vtx->position.x + gSpeed[i]; + vtx++; + } + + rsgDrawMesh(gParticlesMesh); +} +/* end of methods for drawing galaxy */ + +// Display sample images in a mesh with different texture +static void displayIcons(int meshMode) { + bindProgramVertexOrtho(); + + // Fragment shader with texture + rsgBindProgramStore(gProgStoreBlendAlpha); + rsgBindProgramFragment(gProgFragmentTexture); + rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); + rsgBindTexture(gProgFragmentTexture, 0, gTexTorus); + rsgDrawQuadTexCoords( + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, gRenderSurfaceH, 0.0f, 0.0f, 1.0f, + gRenderSurfaceW, gRenderSurfaceH, 0.0f, 1.0f, 1.0f, + gRenderSurfaceW, 0.0f, 0.0f, 1.0f, 0.0f); + + int meshCount = (int)pow(10.0f, (float)(meshMode + 1)); + + float wSize = gRenderSurfaceW/(float)meshCount; + float hSize = gRenderSurfaceH/(float)meshCount; + rs_matrix4x4 matrix; + rsMatrixLoadScale(&matrix, wSize, hSize, 1.0); + + float yPos = 0; + float yPad = hSize / 2; + float xPad = wSize / 2; + for (int y = 0; y < meshCount; y++) { + yPos = y * hSize + yPad; + float xPos = 0; + for (int x = 0; x < meshCount; x++) { + xPos = x * wSize + xPad; + rs_matrix4x4 transMatrix; + rsMatrixLoadTranslate(&transMatrix, xPos, yPos, 0); + rsMatrixMultiply(&transMatrix, &matrix); + rsgProgramVertexLoadModelMatrix(&transMatrix); + int i = (x + y * meshCount) % 100; + rsgBindTexture(gProgFragmentTexture, 0, gTexList100[i].item); + rsgDrawMesh(gSingleMesh); + } + } +} + +// Draw meshes in a single page with top left corner coordinates (xStart, yStart) +static void drawMeshInPage(float xStart, float yStart, int wResolution, int hResolution) { + // Draw wResolution * hResolution meshes in one page + float wMargin = 100.0f; + float hMargin = 100.0f; + float xPad = 50.0f; + float yPad = 20.0f; + float size = 100.0f; // size of images + + // font info + rs_font font = gFontSans; + rsgBindFont(font); + rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f); + + // Measure text size + int left = 0, right = 0, top = 0, bottom = 0; + rsgMeasureText(gSampleTextList100[0].item, &left, &right, &top, &bottom); + float textHeight = (float)(top - bottom); + float textWidth = (float)(right - left); + + rs_matrix4x4 matrix; + rsMatrixLoadScale(&matrix, size, size, 1.0); + + for (int y = 0; y < hResolution; y++) { + float yPos = yStart + hMargin + y * size + y * yPad; + for (int x = 0; x < wResolution; x++) { + float xPos = xStart + wMargin + x * size + x * xPad; + + rs_matrix4x4 transMatrix; + rsMatrixLoadTranslate(&transMatrix, xPos + size/2, yPos + size/2, 0); + rsMatrixMultiply(&transMatrix, &matrix); // scale the mesh + rsgProgramVertexLoadModelMatrix(&transMatrix); + + int i = (y * wResolution + x) % 100; + rsgBindTexture(gProgFragmentTexture, 0, gTexList100[i].item); + rsgDrawMesh(gSingleMesh); + rsgDrawText(gSampleTextList100[i].item, xPos, yPos + size + yPad/2 + textHeight); + } + } +} + +// Display both images and text as shown in launcher and homepage +// meshMode will decide how many pages we draw +// meshMode = 0: draw 3 pages of meshes +// meshMode = 1: draw 5 pages of meshes +static void displayImageWithText(int wResolution, int hResolution, int meshMode) { + bindProgramVertexOrtho(); + + // Fragment shader with texture + rsgBindProgramStore(gProgStoreBlendAlpha); + rsgBindProgramFragment(gProgFragmentTexture); + rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); + + drawMeshInPage(0, 0, wResolution, hResolution); + drawMeshInPage(-1.0f*gRenderSurfaceW, 0, wResolution, hResolution); + drawMeshInPage(1.0f*gRenderSurfaceW, 0, wResolution, hResolution); + if (meshMode == 1) { + // draw another two pages of meshes + drawMeshInPage(-2.0f*gRenderSurfaceW, 0, wResolution, hResolution); + drawMeshInPage(2.0f*gRenderSurfaceW, 0, wResolution, hResolution); + } +} + +// Display a list of text as the list view +static void displayListView() { + // set text color + rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); + rsgBindFont(gFontSans); + + // get the size of the list + rs_allocation textAlloc; + textAlloc = rsGetAllocation(gListViewText); + int allocSize = rsAllocationGetDimX(textAlloc); + + int listItemHeight = 80; + int yOffset = listItemHeight; + + // set the color for the list divider + rsgBindProgramFragment(gProgFragmentColor); + rsgProgramFragmentConstantColor(gProgFragmentColor, 1.0, 1.0, 1.0, 1); + + // draw the list with divider + for (int i = 0; i < allocSize; i++) { + if (yOffset - listItemHeight > gRenderSurfaceH) { + break; + } + rsgDrawRect(0, yOffset - 1, gRenderSurfaceW, yOffset, 0); + rsgDrawText(gListViewText[i].item, 20, yOffset - 10); + yOffset += listItemHeight; + } +} + +static void drawGalaxy() { + rsgClearColor(0.f, 0.f, 0.f, 1.f); + gParticlesBuffer = rsGetAllocation(Particles); + rsgBindProgramFragment(gPFBackground); + + gWidth = rsgGetWidth(); + gHeight = rsgGetHeight(); + if ((gWidth != gOldWidth) || (gHeight != gOldHeight)) { + initParticles(); + gOldWidth = gWidth; + gOldHeight = gHeight; + } + + float offset = mix(-1.0f, 1.0f, gXOffset); + drawSpace(); + drawParticles(offset); + drawLights(); +} + +// Display images and text with live wallpaper in the background +static void displayLiveWallPaper(int wResolution, int hResolution) { + bindProgramVertexOrtho(); + + drawGalaxy(); + + rsgBindProgramVertex(gProgVertex); + rsgBindProgramStore(gProgStoreBlendAlpha); + rsgBindProgramFragment(gProgFragmentTexture); + rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp); + + drawMeshInPage(0, 0, wResolution, hResolution); + drawMeshInPage(-1.0f*gRenderSurfaceW, 0, wResolution, hResolution); + drawMeshInPage(1.0f*gRenderSurfaceW, 0, wResolution, hResolution); + drawMeshInPage(-2.0f*gRenderSurfaceW, 0, wResolution, hResolution); + drawMeshInPage(2.0f*gRenderSurfaceW, 0, wResolution, hResolution); +} + +void root(const void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) { + TestData *testData = (TestData*)usrData; + gRenderSurfaceW = testData->renderSurfaceW; + gRenderSurfaceH = testData->renderSurfaceH; + gDt = testData->dt; + + gData = (UiTestData*)v_in; + + switch(gData->testId) { + case 0: + displayIcons(gData->user1); + break; + case 1: + displayImageWithText(gData->user1, gData->user2, gData->user3); + break; + case 2: + displayListView(); + break; + case 3: + displayLiveWallPaper(gData->user1, gData->user2); + break; + default: + rsDebug("Wrong test number", 0); + break; + } +} diff --git a/tests/RenderScriptTests/SampleTest/Android.mk b/tests/RenderScriptTests/SampleTest/Android.mk new file mode 100644 index 0000000..7d74c55 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/Android.mk @@ -0,0 +1,26 @@ +# +# Copyright (C) 2012 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) + +LOCAL_PACKAGE_NAME := SampleRS + +include $(BUILD_PACKAGE) diff --git a/tests/RenderScriptTests/SampleTest/AndroidManifest.xml b/tests/RenderScriptTests/SampleTest/AndroidManifest.xml new file mode 100644 index 0000000..ec115f7 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/AndroidManifest.xml @@ -0,0 +1,34 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +/* +* Copyright (C) 2012 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +--> + +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.rs.sample"> + <uses-sdk android:minSdkVersion="14" /> + <application android:label="Sample Test" + android:hardwareAccelerated="true"> + + <activity android:name="SampleRSActivity" + android:label="Sample Test"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/city.png b/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/city.png Binary files differnew file mode 100644 index 0000000..27c4618 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/city.png diff --git a/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/twobytwo.png b/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/twobytwo.png Binary files differnew file mode 100644 index 0000000..98cf963 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/res/drawable-nodpi/twobytwo.png diff --git a/tests/RenderScriptTests/SampleTest/res/layout/rs.xml b/tests/RenderScriptTests/SampleTest/res/layout/rs.xml new file mode 100644 index 0000000..f2a356f --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/res/layout/rs.xml @@ -0,0 +1,84 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- Copyright (C) 2012 The Android Open Source Project + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> + +<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + android:orientation="vertical" + android:layout_width="fill_parent" + android:layout_height="fill_parent" + android:id="@+id/toplevel"> + <ScrollView + android:layout_width="fill_parent" + android:layout_height="fill_parent"> + <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + android:orientation="vertical" + android:layout_width="fill_parent" + android:layout_height="fill_parent"> + <TextView + android:layout_width="match_parent" + android:layout_height="wrap_content" + android:textSize="8pt" + android:text="@string/wraplinear"/> + <TextureView + android:id="@+id/display" + android:layout_width="256sp" + android:layout_height="256sp" /> + <TextView + android:layout_width="match_parent" + android:layout_height="wrap_content" + android:textSize="8pt" + android:text="@string/clamplinear"/> + <TextureView + android:id="@+id/display2" + android:layout_width="256sp" + android:layout_height="256sp" /> + <TextView + android:layout_width="match_parent" + android:layout_height="wrap_content" + android:textSize="8pt" + android:text="@string/wrapnearest"/> + <TextureView + android:id="@+id/display3" + android:layout_width="256sp" + android:layout_height="256sp" /> + <TextView + android:layout_width="match_parent" + android:layout_height="wrap_content" + android:textSize="8pt" + android:text="@string/clampnearest"/> + <TextureView + android:id="@+id/display4" + android:layout_width="256sp" + android:layout_height="256sp" /> + <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + android:orientation="horizontal" + android:layout_width="fill_parent" + android:layout_height="wrap_content"> + <Button + android:layout_width="wrap_content" + android:layout_height="wrap_content" + android:text="@string/benchmark" + android:onClick="benchmark"/> + <TextView + android:id="@+id/benchmarkText" + android:layout_width="match_parent" + android:layout_height="wrap_content" + android:textSize="8pt" + android:text="@string/benchmark"/> + </LinearLayout> + </LinearLayout> + </ScrollView> +</LinearLayout> + diff --git a/tests/RenderScriptTests/SampleTest/res/values/strings.xml b/tests/RenderScriptTests/SampleTest/res/values/strings.xml new file mode 100644 index 0000000..a0a2499 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/res/values/strings.xml @@ -0,0 +1,28 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +/* +* Copyright (C) 2012 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +--> + +<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> + <!-- General --> + <skip /> + <string name="benchmark">Benchmark</string> + <string name="wraplinear">Wrap Linear</string> + <string name="clamplinear">Clamp Linear</string> + <string name="wrapnearest">Wrap Nearest</string> + <string name="clampnearest">Clamp Nearest</string> +</resources> diff --git a/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java b/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java new file mode 100644 index 0000000..77cbf84 --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/SampleRSActivity.java @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.sample; + +import android.app.Activity; +import android.graphics.Bitmap; +import android.graphics.Bitmap.Config; +import android.graphics.BitmapFactory; +import android.graphics.Canvas; +import android.graphics.SurfaceTexture; +import android.os.Bundle; +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.Matrix3f; +import android.renderscript.RenderScript; +import android.renderscript.Sampler; +import android.renderscript.Type; +import android.renderscript.Type.Builder; +import android.util.Log; +import android.view.TextureView; +import android.view.TextureView.SurfaceTextureListener; +import android.view.View; +import android.widget.ImageView; +import android.widget.SeekBar; +import android.widget.TextView; + +public class SampleRSActivity extends Activity { + class TextureViewUpdater implements TextureView.SurfaceTextureListener { + private Allocation mOutPixelsAllocation; + private Sampler mSampler; + + TextureViewUpdater(Allocation outAlloc, Sampler sampler) { + mOutPixelsAllocation = outAlloc; + mSampler = sampler; + } + + public void onSurfaceTextureUpdated(SurfaceTexture surface) { + } + + public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) { + mOutPixelsAllocation.setSurfaceTexture(surface); + } + + public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) { + mOutPixelsAllocation.setSurfaceTexture(surface); + filterAlloc(mOutPixelsAllocation, mSampler); + } + + public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) { + mOutPixelsAllocation.setSurfaceTexture(null); + return true; + } + } + + private final String TAG = "Img"; + private Bitmap mBitmapTwoByTwo; + private Bitmap mBitmapCity; + + private TextView mBenchmarkResult; + + private RenderScript mRS; + private Allocation mTwoByTwoAlloc; + private Allocation mCityAlloc; + private ScriptC_sample mScript; + + public void onStartTrackingTouch(SeekBar seekBar) { + } + + public void onStopTrackingTouch(SeekBar seekBar) { + } + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setContentView(R.layout.rs); + + mBitmapTwoByTwo = loadBitmap(R.drawable.twobytwo); + mBitmapCity = loadBitmap(R.drawable.city); + + mBenchmarkResult = (TextView) findViewById(R.id.benchmarkText); + mBenchmarkResult.setText("Result: not run"); + + mRS = RenderScript.create(this); + mTwoByTwoAlloc = Allocation.createFromBitmap(mRS, mBitmapTwoByTwo, + Allocation.MipmapControl.MIPMAP_NONE, + Allocation.USAGE_SCRIPT); + + mCityAlloc = Allocation.createFromBitmap(mRS, mBitmapCity, + Allocation.MipmapControl.MIPMAP_NONE, + Allocation.USAGE_SCRIPT); + + Type.Builder b = new Type.Builder(mRS, Element.RGBA_8888(mRS)); + + int usage = Allocation.USAGE_SCRIPT | Allocation.USAGE_IO_OUTPUT; + + int outX = 256; + int outY = 256; + + // Wrap Linear + Allocation outAlloc = Allocation.createTyped(mRS, b.setX(outX).setY(outY).create(), usage); + TextureViewUpdater updater = new TextureViewUpdater(outAlloc, Sampler.WRAP_LINEAR(mRS)); + TextureView displayView = (TextureView) findViewById(R.id.display); + displayView.setSurfaceTextureListener(updater); + + // Clamp Linear + outAlloc = Allocation.createTyped(mRS, b.setX(outX).setY(outY).create(), usage); + updater = new TextureViewUpdater(outAlloc, Sampler.CLAMP_LINEAR(mRS)); + displayView = (TextureView) findViewById(R.id.display2); + displayView.setSurfaceTextureListener(updater); + + // Wrap Nearest + outAlloc = Allocation.createTyped(mRS, b.setX(outX).setY(outY).create(), usage); + updater = new TextureViewUpdater(outAlloc, Sampler.WRAP_NEAREST(mRS)); + displayView = (TextureView) findViewById(R.id.display3); + displayView.setSurfaceTextureListener(updater); + + // Clamp Nearest + outAlloc = Allocation.createTyped(mRS, b.setX(outX).setY(outY).create(), usage); + updater = new TextureViewUpdater(outAlloc, Sampler.CLAMP_NEAREST(mRS)); + displayView = (TextureView) findViewById(R.id.display4); + displayView.setSurfaceTextureListener(updater); + + mScript = new ScriptC_sample(mRS, getResources(), R.raw.sample); + } + + private Bitmap loadBitmap(int resource) { + final BitmapFactory.Options options = new BitmapFactory.Options(); + options.inPreferredConfig = Bitmap.Config.ARGB_8888; + Bitmap b = BitmapFactory.decodeResource(getResources(), resource, options); + Bitmap b2 = Bitmap.createBitmap(b.getWidth(), b.getHeight(), b.getConfig()); + Canvas c = new Canvas(b2); + c.drawBitmap(b, 0, 0, null); + b.recycle(); + return b2; + } + + private synchronized void filterAlloc(Allocation alloc, Sampler sampler) { + long t = java.lang.System.currentTimeMillis(); + mScript.invoke_setSampleData(alloc, mTwoByTwoAlloc, sampler); + mScript.forEach_root(alloc); + alloc.ioSendOutput(); + mRS.finish(); + t = java.lang.System.currentTimeMillis() - t; + Log.i(TAG, "Filter time is: " + t + " ms"); + } + + public void benchmark(View v) { + /*filterAlloc(); + long t = java.lang.System.currentTimeMillis(); + filterAlloc(); + t = java.lang.System.currentTimeMillis() - t; + mDisplayView.invalidate(); + mBenchmarkResult.setText("Result: " + t + " ms");*/ + } +} diff --git a/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/sample.rs b/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/sample.rs new file mode 100644 index 0000000..e2bf43d --- /dev/null +++ b/tests/RenderScriptTests/SampleTest/src/com/android/rs/sample/sample.rs @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma version(1) +#pragma rs java_package_name(com.android.rs.sample) +#include "rs_graphics.rsh" + +static rs_allocation sourceAlloc; +static rs_allocation destAlloc; +static rs_sampler allocSampler; + +void setSampleData(rs_allocation dest, rs_allocation source, rs_sampler sampler) { + destAlloc = dest; + sourceAlloc = source; + allocSampler = sampler; +} + +void root(uchar4 *out, uint32_t x, uint32_t y) { + + float destX = (float)rsAllocationGetDimX(destAlloc) - 1.0f; + float destY = (float)rsAllocationGetDimY(destAlloc) - 1.0f; + + float2 uv; + uv.x = (float)x / destX; + uv.y = (float)y / destY; + + out->xyz = convert_uchar3(rsSample(sourceAlloc, allocSampler, uv*2.0f).xyz); + out->w = 0xff; +} + diff --git a/tests/RenderScriptTests/SceneGraph/Android.mk b/tests/RenderScriptTests/SceneGraph/Android.mk new file mode 100644 index 0000000..ba4b3c5 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/Android.mk @@ -0,0 +1,26 @@ +# +# Copyright (C) 2011 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) + +LOCAL_PACKAGE_NAME := SceneGraphTest + +include $(BUILD_PACKAGE) diff --git a/tests/RenderScriptTests/SceneGraph/AndroidManifest.xml b/tests/RenderScriptTests/SceneGraph/AndroidManifest.xml new file mode 100644 index 0000000..67af0fa --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/AndroidManifest.xml @@ -0,0 +1,29 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.testapp"> + <uses-permission + android:name="android.permission.INTERNET" /> + <application android:label="SceneGraphTest"> + <activity android:name="TestApp" + android:label="SceneGraphTest"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + <activity android:name="SimpleApp" + android:label="SimpleSceneGraph"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + <activity android:name="FileSelector" + android:label="FileSelector" + android:hardwareAccelerated="true"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/SceneGraph/assets/blue.jpg b/tests/RenderScriptTests/SceneGraph/assets/blue.jpg Binary files differnew file mode 100644 index 0000000..494e77a --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/blue.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/carbonfiber.jpg b/tests/RenderScriptTests/SceneGraph/assets/carbonfiber.jpg Binary files differnew file mode 100644 index 0000000..2fcecb0 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/carbonfiber.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/green.jpg b/tests/RenderScriptTests/SceneGraph/assets/green.jpg Binary files differnew file mode 100644 index 0000000..a86a754 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/green.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/grey.jpg b/tests/RenderScriptTests/SceneGraph/assets/grey.jpg Binary files differnew file mode 100644 index 0000000..5870b1a --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/grey.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/orange.jpg b/tests/RenderScriptTests/SceneGraph/assets/orange.jpg Binary files differnew file mode 100644 index 0000000..7dbe942 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/orange.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/orientation_test.a3d b/tests/RenderScriptTests/SceneGraph/assets/orientation_test.a3d Binary files differnew file mode 100644 index 0000000..07318ae --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/orientation_test.a3d diff --git a/tests/RenderScriptTests/SceneGraph/assets/orientation_test.dae b/tests/RenderScriptTests/SceneGraph/assets/orientation_test.dae new file mode 100644 index 0000000..7eef443 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/orientation_test.dae @@ -0,0 +1,1102 @@ +<?xml version="1.0" ?> +<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1"> + <asset> + <contributor> + <author>alexst</author> + <authoring_tool>OpenCOLLADA2010</authoring_tool> + <comments>ColladaMaya export options: bakeTransforms=0;relativePaths=0;copyTextures=0;exportTriangles=1;exportCgfxFileReferences=0; isSampling=0;curveConstrainSampling=0;removeStaticCurves=1;exportPolygonMeshes=1;exportLights=1; exportCameras=1;exportJointsAndSkin=1;exportAnimations=0;exportInvisibleNodes=0;exportDefaultCameras=0; exportTexCoords=1;exportNormals=1;exportNormalsPerVertex=1;exportVertexColors=0;exportVertexColorsPerVertex=0; exportTexTangents=0;exportTangents=0;exportReferencedMaterials=1;exportMaterialsOnly=0; exportXRefs=1;dereferenceXRefs=1;exportCameraAsLookat=0;cameraXFov=0;cameraYFov=1;doublePrecision=0</comments> + <source_data>file:///Volumes/Android/art/orientation_test.mb</source_data> + </contributor> + <created>2011-09-30T15:31:38</created> + <modified>2011-09-30T15:31:38</modified> + <unit meter="0.01" name="centimeter" /> + <up_axis>Y_UP</up_axis> + </asset> + <library_cameras> + <camera id="cameraShape1" name="cameraShape1"> + <optics> + <technique_common> + <perspective> + <yfov>37.8493</yfov> + <aspect_ratio>1.5</aspect_ratio> + <znear>1</znear> + <zfar>400</zfar> + </perspective> + </technique_common> + </optics> + <extra> + <technique profile="OpenCOLLADAMaya"> + <film_fit>0</film_fit> + <film_fit_offset>0</film_fit_offset> + <film_offsetX>0</film_offsetX> + <film_offsetY>0</film_offsetY> + <horizontal_aperture>3.599993</horizontal_aperture> + <lens_squeeze>1</lens_squeeze> + <originalMayaNodeId>cameraShape1</originalMayaNodeId> + <vertical_aperture>2.399995</vertical_aperture> + </technique> + </extra> + </camera> + <camera id="CameraDistShape" name="CameraDistShape"> + <optics> + <technique_common> + <perspective> + <yfov>37.8493</yfov> + <aspect_ratio>1.5</aspect_ratio> + <znear>1</znear> + <zfar>1000</zfar> + </perspective> + </technique_common> + </optics> + <extra> + <technique profile="OpenCOLLADAMaya"> + <film_fit>0</film_fit> + <film_fit_offset>0</film_fit_offset> + <film_offsetX>0</film_offsetX> + <film_offsetY>0</film_offsetY> + <horizontal_aperture>3.599993</horizontal_aperture> + <lens_squeeze>1</lens_squeeze> + <originalMayaNodeId>CameraDistShape</originalMayaNodeId> + <vertical_aperture>2.399995</vertical_aperture> + </technique> + </extra> + </camera> + </library_cameras> + <library_materials> + <material id="Paint1" name="Paint1"> + <instance_effect url="#Paint1-fx" /> + </material> + <material id="lambert2" name="lambert2"> + <instance_effect url="#lambert2-fx" /> + </material> + <material id="Plastic" name="Plastic"> + <instance_effect url="#Plastic-fx" /> + </material> + <material id="Metal" name="Metal"> + <instance_effect url="#Metal-fx" /> + </material> + <material id="PlasticCenter" name="PlasticCenter"> + <instance_effect url="#PlasticCenter-fx" /> + </material> + <material id="PlasticRed" name="PlasticRed"> + <instance_effect url="#PlasticRed-fx" /> + </material> + <material id="lambert10" name="lambert10"> + <instance_effect url="#lambert10-fx" /> + </material> + <material id="lambert11" name="lambert11"> + <instance_effect url="#lambert11-fx" /> + </material> + </library_materials> + <library_effects> + <effect id="Metal-fx"> + <profile_COMMON> + <newparam sid="file23-surface"> + <surface type="2D"> + <init_from>file23</init_from> + </surface> + </newparam> + <newparam sid="file23-sampler"> + <sampler2D> + <source>file23-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file23-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="Paint1-fx"> + <profile_COMMON> + <newparam sid="file25-surface"> + <surface type="2D"> + <init_from>file25</init_from> + </surface> + </newparam> + <newparam sid="file25-sampler"> + <sampler2D> + <source>file25-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file25-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="Plastic-fx"> + <profile_COMMON> + <newparam sid="file24-surface"> + <surface type="2D"> + <init_from>file24</init_from> + </surface> + </newparam> + <newparam sid="file24-sampler"> + <sampler2D> + <source>file24-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file24-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="PlasticCenter-fx"> + <profile_COMMON> + <newparam sid="file24-surface"> + <surface type="2D"> + <init_from>file24</init_from> + </surface> + </newparam> + <newparam sid="file24-sampler"> + <sampler2D> + <source>file24-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file24-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="PlasticRed-fx"> + <profile_COMMON> + <newparam sid="file23-surface"> + <surface type="2D"> + <init_from>file23</init_from> + </surface> + </newparam> + <newparam sid="file23-sampler"> + <sampler2D> + <source>file23-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file23-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="lambert10-fx"> + <profile_COMMON> + <newparam sid="file28-surface"> + <surface type="2D"> + <init_from>file28</init_from> + </surface> + </newparam> + <newparam sid="file28-sampler"> + <sampler2D> + <source>file28-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file28-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="lambert11-fx"> + <profile_COMMON> + <newparam sid="file29-surface"> + <surface type="2D"> + <init_from>file29</init_from> + </surface> + </newparam> + <newparam sid="file29-sampler"> + <sampler2D> + <source>file29-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file29-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + <effect id="lambert2-fx"> + <profile_COMMON> + <newparam sid="file22-surface"> + <surface type="2D"> + <init_from>file22</init_from> + </surface> + </newparam> + <newparam sid="file22-sampler"> + <sampler2D> + <source>file22-surface</source> + </sampler2D> + </newparam> + <technique sid="common"> + <lambert> + <emission> + <color>0 0 0 1</color> + </emission> + <ambient> + <color>0 0 0 1</color> + </ambient> + <diffuse> + <texture texture="file22-sampler" texcoord="TEX0"> + <extra> + <technique profile="OpenCOLLADAMaya"> + <blend_mode>NONE</blend_mode> + <coverageU>1</coverageU> + <coverageV>1</coverageV> + <fast>0</fast> + <mirrorU>0</mirrorU> + <mirrorV>0</mirrorV> + <noiseU>0</noiseU> + <noiseV>0</noiseV> + <offsetU>0</offsetU> + <offsetV>0</offsetV> + <repeatU>1</repeatU> + <repeatV>1</repeatV> + <rotateFrame>0</rotateFrame> + <rotateUV>0</rotateUV> + <stagger>0</stagger> + <translateFrameU>0</translateFrameU> + <translateFrameV>0</translateFrameV> + <wrapU>1</wrapU> + <wrapV>1</wrapV> + </technique> + </extra> + </texture> + </diffuse> + <transparent opaque="RGB_ZERO"> + <color>0 0 0 1</color> + </transparent> + <transparency> + <float>1</float> + </transparency> + </lambert> + </technique> + </profile_COMMON> + </effect> + </library_effects> + <library_images> + <image id="file29" name="file29" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/blue.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file29</originalMayaNodeId> + </technique> + </extra> + </image> + <image id="file25" name="file25" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/carbonfiber.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file25</originalMayaNodeId> + </technique> + </extra> + </image> + <image id="file28" name="file28" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/green.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file28</originalMayaNodeId> + </technique> + </extra> + </image> + <image id="file22" name="file22" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/grey.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file22</originalMayaNodeId> + </technique> + </extra> + </image> + <image id="file24" name="file24" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/orange.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file24</originalMayaNodeId> + </technique> + </extra> + </image> + <image id="file23" name="file23" height="0" width="0"> + <init_from>file:///Volumes/Android/Sanity/SceneGraph/assets/red.jpg</init_from> + <extra> + <technique profile="OpenCOLLADAMaya"> + <dgnode_type>kFile</dgnode_type> + <image_sequence>0</image_sequence> + <originalMayaNodeId>file23</originalMayaNodeId> + </technique> + </extra> + </image> + </library_images> + <library_visual_scenes> + <visual_scene id="VisualSceneNode" name="orientation_test"> + <node id="camera1" name="camera1"> + <translate sid="translate">24.5791 14.1321 31.4654</translate> + <rotate sid="rotateZ">0 0 1 0</rotate> + <rotate sid="rotateY">0 1 0 42</rotate> + <rotate sid="rotateX">1 0 0 -16.2</rotate> + <scale sid="scale">1 1 1</scale> + <instance_camera url="#cameraShape1" /> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>camera1</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="CameraAim" name="CameraAim"> + <translate sid="translate">0.0209301 3.68542 2.06912</translate> + <rotate sid="rotateY">0 1 0 43.2561</rotate> + <rotate sid="rotateX">1 0 0 -20</rotate> + <scale sid="scale">1 1 1</scale> + <node id="CameraDist" name="CameraDist"> + <translate sid="translate">0 0 45</translate> + <scale sid="scale">1 1 1</scale> + <instance_camera url="#CameraDistShape" /> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>CameraDist</originalMayaNodeId> + </technique> + </extra> + </node> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>CameraAim</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere4" name="pSphere4"> + <translate sid="translate">-9.69237 0 7.70498</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape4"> + <bind_material> + <technique_common> + <instance_material symbol="lambert7SG" target="#Paint1"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere4</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere1" name="pSphere1"> + <translate sid="translate">13.0966 0 5.76254</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape1"> + <bind_material> + <technique_common> + <instance_material symbol="lambert7SG" target="#Paint1"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere1</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere2" name="pSphere2"> + <translate sid="translate">21.7661 0 -13.6375</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape2"> + <bind_material> + <technique_common> + <instance_material symbol="lambert7SG" target="#Paint1"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere2</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere3" name="pSphere3"> + <translate sid="translate">-13.862 0 -13.6154</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape3"> + <bind_material> + <technique_common> + <instance_material symbol="lambert7SG" target="#Paint1"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere3</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere5" name="pSphere5"> + <translate sid="translate">31.0862 0 18.5992</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape5"> + <bind_material> + <technique_common> + <instance_material symbol="lambert7SG" target="#Paint1"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere5</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pCube1" name="pCube1"> + <translate sid="translate">0 0 0</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pCubeShape1"> + <bind_material> + <technique_common> + <instance_material symbol="lambert4SG" target="#lambert2"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pCube1</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="group1" name="group1"> + <translate sid="translate">0 0 0</translate> + <rotate sid="rotateZ">0 0 1 -162.693</rotate> + <rotate sid="rotateY">0 1 0 21.3345</rotate> + <rotate sid="rotateX">1 0 0 -100.567</rotate> + <scale sid="scale">1 1 1</scale> + <node id="pSphere6" name="pSphere6"> + <translate sid="translate">-13.862 0 -13.6154</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape6"> + <bind_material> + <technique_common> + <instance_material symbol="lambert6SG" target="#Plastic"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere6</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere7" name="pSphere7"> + <translate sid="translate">-9.69237 0 7.70498</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape7"> + <bind_material> + <technique_common> + <instance_material symbol="lambert6SG" target="#Plastic"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere7</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere8" name="pSphere8"> + <translate sid="translate">21.7661 0 -13.6375</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape8"> + <bind_material> + <technique_common> + <instance_material symbol="lambert6SG" target="#Plastic"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere8</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere9" name="pSphere9"> + <translate sid="translate">13.0966 0 5.76254</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape9"> + <bind_material> + <technique_common> + <instance_material symbol="lambert6SG" target="#Plastic"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere9</originalMayaNodeId> + </technique> + </extra> + </node> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>group1</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="group2" name="group2"> + <translate sid="translate">0 0 0</translate> + <rotate sid="rotateZ">0 0 1 45.4017</rotate> + <rotate sid="rotateY">0 1 0 79.393</rotate> + <rotate sid="rotateX">1 0 0 5.10889</rotate> + <scale sid="scale">1 1 1</scale> + <node id="pSphere10" name="pSphere10"> + <translate sid="translate">31.0862 0 18.5992</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape10"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere10</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere11" name="pSphere11"> + <translate sid="translate">13.0966 0 5.76254</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape11"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere11</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere12" name="pSphere12"> + <translate sid="translate">7.4784 16.3496 7.36882</translate> + <rotate sid="rotateZ">0 0 1 17.3073</rotate> + <rotate sid="rotateY">0 1 0 158.666</rotate> + <rotate sid="rotateX">1 0 0 79.4335</rotate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape12"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere12</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere13" name="pSphere13"> + <translate sid="translate">-9.69237 0 7.70498</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape13"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere13</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere14" name="pSphere14"> + <translate sid="translate">11.3635 -4.3926 2.21012</translate> + <rotate sid="rotateZ">0 0 1 17.3073</rotate> + <rotate sid="rotateY">0 1 0 158.666</rotate> + <rotate sid="rotateX">1 0 0 79.4335</rotate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape14"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere14</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere15" name="pSphere15"> + <translate sid="translate">21.7661 0 -13.6375</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape15"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere15</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere16" name="pSphere16"> + <translate sid="translate">-9.5945 -8.92317 -5.74901</translate> + <rotate sid="rotateZ">0 0 1 17.3073</rotate> + <rotate sid="rotateY">0 1 0 158.666</rotate> + <rotate sid="rotateX">1 0 0 79.4335</rotate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape16"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere16</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere17" name="pSphere17"> + <translate sid="translate">-13.862 0 -13.6154</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape17"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere17</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pSphere18" name="pSphere18"> + <translate sid="translate">-24.2135 6.497 -5.58935</translate> + <rotate sid="rotateZ">0 0 1 17.3073</rotate> + <rotate sid="rotateY">0 1 0 158.666</rotate> + <rotate sid="rotateX">1 0 0 79.4335</rotate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pSphereShape18"> + <bind_material> + <technique_common> + <instance_material symbol="lambert5SG" target="#Metal"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pSphere18</originalMayaNodeId> + </technique> + </extra> + </node> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>group2</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pCube2" name="pCube2"> + <translate sid="translate">0 0 0</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pCubeShape2"> + <bind_material> + <technique_common> + <instance_material symbol="lambert8SG" target="#PlasticCenter"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pCube2</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pCube3" name="pCube3"> + <translate sid="translate">15 0 0</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pCubeShape3"> + <bind_material> + <technique_common> + <instance_material symbol="lambert9SG" target="#PlasticRed"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pCube3</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pCube4" name="pCube4"> + <translate sid="translate">0 15 0</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pCubeShape4"> + <bind_material> + <technique_common> + <instance_material symbol="lambert10SG" target="#lambert10"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pCube4</originalMayaNodeId> + </technique> + </extra> + </node> + <node id="pCube5" name="pCube5"> + <translate sid="translate">0 0 15</translate> + <scale sid="scale">1 1 1</scale> + <instance_geometry url="#pCubeShape5"> + <bind_material> + <technique_common> + <instance_material symbol="lambert11SG" target="#lambert11"> + <bind_vertex_input semantic="TEX0" input_semantic="TEXCOORD" input_set="0" /> + </instance_material> + </technique_common> + </bind_material> + </instance_geometry> + <extra> + <technique profile="OpenCOLLADAMaya"> + <originalMayaNodeId>pCube5</originalMayaNodeId> + </technique> + </extra> + </node> + </visual_scene> + </library_visual_scenes> + <scene> + <instance_visual_scene url="#VisualSceneNode" /> + </scene> +</COLLADA> diff --git a/tests/RenderScriptTests/SceneGraph/assets/paint.jpg b/tests/RenderScriptTests/SceneGraph/assets/paint.jpg Binary files differnew file mode 100644 index 0000000..0791045 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/paint.jpg diff --git a/tests/RenderScriptTests/SceneGraph/assets/red.jpg b/tests/RenderScriptTests/SceneGraph/assets/red.jpg Binary files differnew file mode 100644 index 0000000..320a2a6 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/assets/red.jpg diff --git a/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/icon.png b/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/icon.png Binary files differnew file mode 100644 index 0000000..ff34a7f --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/icon.png diff --git a/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/robot.png b/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/robot.png Binary files differnew file mode 100644 index 0000000..f7353fd --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/drawable-nodpi/robot.png diff --git a/tests/RenderScriptTests/SceneGraph/res/menu/loader_menu.xml b/tests/RenderScriptTests/SceneGraph/res/menu/loader_menu.xml new file mode 100644 index 0000000..9ea30107 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/menu/loader_menu.xml @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +--> + +<menu xmlns:android="http://schemas.android.com/apk/res/android"> + <item android:id="@+id/load_model" + android:title="@string/load_model" /> + <item android:id="@+id/use_blur" + android:title="@string/use_blur" /> +</menu> diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/blur_h.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/blur_h.glsl new file mode 100644 index 0000000..c34adc9 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/blur_h.glsl @@ -0,0 +1,15 @@ +varying vec2 varTex0; + +void main() { + vec2 blurCoord = varTex0; + blurCoord.x = varTex0.x + UNI_blurOffset0; + vec3 col = texture2D(UNI_color, blurCoord).rgb; + blurCoord.x = varTex0.x + UNI_blurOffset1; + col += texture2D(UNI_color, blurCoord).rgb; + blurCoord.x = varTex0.x + UNI_blurOffset2; + col += texture2D(UNI_color, blurCoord).rgb; + blurCoord.x = varTex0.x + UNI_blurOffset3; + col += texture2D(UNI_color, blurCoord).rgb; + + gl_FragColor = vec4(col * 0.25, 0.0); +} diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/blur_v.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/blur_v.glsl new file mode 100644 index 0000000..ade05a2 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/blur_v.glsl @@ -0,0 +1,17 @@ +varying vec2 varTex0; + +void main() { + vec2 blurCoord = varTex0; + blurCoord.y = varTex0.y + UNI_blurOffset0; + vec3 col = texture2D(UNI_color, blurCoord).rgb; + blurCoord.y = varTex0.y + UNI_blurOffset1; + col += texture2D(UNI_color, blurCoord).rgb; + blurCoord.y = varTex0.y + UNI_blurOffset2; + col += texture2D(UNI_color, blurCoord).rgb; + blurCoord.y = varTex0.y + UNI_blurOffset3; + col += texture2D(UNI_color, blurCoord).rgb; + + col = col * 0.25; + + gl_FragColor = vec4(col, 0.0); +} diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/blur_vertex.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/blur_vertex.glsl new file mode 100644 index 0000000..bc824b6 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/blur_vertex.glsl @@ -0,0 +1,7 @@ +varying vec2 varTex0; + +void main() { + gl_Position = ATTRIB_position; + varTex0 = ATTRIB_texture0; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/diffuse.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/diffuse.glsl new file mode 100644 index 0000000..2eb1028 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/diffuse.glsl @@ -0,0 +1,19 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = (varWorldNormal); + + vec3 light0Vec = V; + vec3 light0R = reflect(light0Vec, worldNorm); + float light0_Diffuse = dot(worldNorm, light0Vec); + + vec2 t0 = varTex0.xy; + lowp vec4 col = texture2D(UNI_diffuse, t0).rgba; + col.xyz = col.xyz * light0_Diffuse * 1.2; + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/diffuse_lights.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/diffuse_lights.glsl new file mode 100644 index 0000000..ef93e1c --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/diffuse_lights.glsl @@ -0,0 +1,22 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = normalize(varWorldNormal); + + vec3 light0Vec = normalize(UNI_lightPos_0.xyz - varWorldPos.xyz); + float light0_Diffuse = clamp(dot(worldNorm, light0Vec), 0.0, 1.0); + + vec3 light1Vec = normalize(UNI_lightPos_1.xyz - varWorldPos.xyz); + float light1_Diffuse = clamp(dot(worldNorm, light1Vec), 0.0, 1.0); + + vec2 t0 = varTex0.xy; + lowp vec4 col = UNI_diffuse; + col.xyz = col.xyz * (light0_Diffuse * UNI_lightColor_0.xyz + + light1_Diffuse * UNI_lightColor_1.xyz); + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/metal.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/metal.glsl new file mode 100644 index 0000000..b90a7b2 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/metal.glsl @@ -0,0 +1,23 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = normalize(varWorldNormal); + + vec3 light0Vec = V; + vec3 light0R = reflect(light0Vec, worldNorm); + float light0_Diffuse = clamp(dot(worldNorm, light0Vec), 0.0, 1.0); + float light0Spec = clamp(dot(-light0R, V), 0.001, 1.0); + float light0_Specular = pow(light0Spec, 15.0) * 0.5; + + vec2 t0 = varTex0.xy; + lowp vec4 col = texture2D(UNI_diffuse, t0).rgba; + col.xyz = col.xyz * (textureCube(UNI_reflection, worldNorm).rgb * 0.5 + vec3(light0_Diffuse)); + col.xyz += light0_Specular * vec3(0.8, 0.8, 1.0); + + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/paintf.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/paintf.glsl new file mode 100644 index 0000000..f3b89ed --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/paintf.glsl @@ -0,0 +1,26 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = normalize(varWorldNormal); + + vec3 light0Vec = V; + vec3 light0R = reflect(light0Vec, worldNorm); + float light0_Diffuse = clamp(dot(worldNorm, light0Vec), 0.01, 0.99); + float light0Spec = clamp(dot(-light0R, V), 0.001, 1.0); + float light0_Specular = pow(light0Spec, 150.0) * 0.5; + + vec2 t0 = varTex0.xy; + lowp vec4 col = texture2D(UNI_diffuse, t0).rgba; + col.xyz = col.xyz * light0_Diffuse * 1.1; + col.xyz += light0_Specular * vec3(0.8, 0.8, 1.0); + + float fresnel = mix(pow(1.0 - light0_Diffuse, 15.0), 1.0, 0.1); + col.xyz = mix(col.xyz, textureCube(UNI_reflection, -light0R).rgb * 2.4, fresnel); + col.w = 0.8; + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/plastic.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/plastic.glsl new file mode 100644 index 0000000..56f7151 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/plastic.glsl @@ -0,0 +1,22 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = normalize(varWorldNormal); + + vec3 light0Vec = V; + vec3 light0R = reflect(light0Vec, worldNorm); + float light0_Diffuse = clamp(dot(worldNorm, light0Vec), 0.0, 1.0); + float light0Spec = clamp(dot(-light0R, V), 0.001, 1.0); + float light0_Specular = pow(light0Spec, 10.0) * 0.5; + + vec2 t0 = varTex0.xy; + lowp vec4 col = texture2D(UNI_diffuse, t0).rgba; + col.xyz = col.xyz * light0_Diffuse * 1.2; + col.xyz += light0_Specular * vec3(0.8, 0.8, 1.0); + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/plastic_lights.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/plastic_lights.glsl new file mode 100644 index 0000000..b253622 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/plastic_lights.glsl @@ -0,0 +1,29 @@ +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +void main() { + + vec3 V = normalize(UNI_cameraPos.xyz - varWorldPos.xyz); + vec3 worldNorm = normalize(varWorldNormal); + + vec3 light0Vec = normalize(UNI_lightPos_0.xyz - varWorldPos.xyz); + vec3 light0R = reflect(light0Vec, worldNorm); + float light0_Diffuse = clamp(dot(worldNorm, light0Vec), 0.0, 1.0); + float light0Spec = clamp(dot(-light0R, V), 0.001, 1.0); + float light0_Specular = pow(light0Spec, 10.0) * 0.7; + + vec3 light1Vec = normalize(UNI_lightPos_1.xyz - varWorldPos.xyz); + vec3 light1R = reflect(light1Vec, worldNorm); + float light1_Diffuse = clamp(dot(worldNorm, light1Vec), 0.0, 1.0); + float light1Spec = clamp(dot(-light1R, V), 0.001, 1.0); + float light1_Specular = pow(light1Spec, 10.0) * 0.7; + + vec2 t0 = varTex0.xy; + lowp vec4 col = UNI_diffuse; + col.xyz = col.xyz * (light0_Diffuse * UNI_lightColor_0.xyz + + light1_Diffuse * UNI_lightColor_1.xyz); + col.xyz += (light0_Specular + light1_Specular); + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/robot.a3d b/tests/RenderScriptTests/SceneGraph/res/raw/robot.a3d Binary files differnew file mode 100644 index 0000000..f48895c --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/robot.a3d diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/select_color.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/select_color.glsl new file mode 100644 index 0000000..1a927ca --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/select_color.glsl @@ -0,0 +1,13 @@ +varying vec2 varTex0; + +void main() { + vec3 col = texture2D(UNI_color, varTex0).rgb; + + vec3 desat = vec3(0.299, 0.587, 0.114); + float lum = dot(desat, col); + float stepVal = step(lum, 0.8); + col = mix(col, vec3(0.0), stepVal)*0.5; + + gl_FragColor = vec4(col, 0.0); +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/shader2v.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/shader2v.glsl new file mode 100644 index 0000000..7910a54 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/shader2v.glsl @@ -0,0 +1,22 @@ +/* + rs_matrix4x4 model; + rs_matrix4x4 viewProj; +*/ + +varying vec3 varWorldPos; +varying vec3 varWorldNormal; +varying vec2 varTex0; + +// This is where actual shader code begins +void main() { + vec4 objPos = ATTRIB_position; + vec4 worldPos = UNI_model * objPos; + gl_Position = UNI_viewProj * worldPos; + + mat3 model3 = mat3(UNI_model[0].xyz, UNI_model[1].xyz, UNI_model[2].xyz); + vec3 worldNorm = model3 * ATTRIB_normal; + + varWorldPos = worldPos.xyz; + varWorldNormal = worldNorm; + varTex0 = ATTRIB_texture0; +} diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/texture.glsl b/tests/RenderScriptTests/SceneGraph/res/raw/texture.glsl new file mode 100644 index 0000000..662ecd8 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/texture.glsl @@ -0,0 +1,7 @@ +varying vec2 varTex0; + +void main() { + lowp vec4 col = texture2D(UNI_color, varTex0).rgba; + gl_FragColor = col; +} + diff --git a/tests/RenderScriptTests/SceneGraph/res/raw/unit_obj.a3d b/tests/RenderScriptTests/SceneGraph/res/raw/unit_obj.a3d Binary files differnew file mode 100644 index 0000000..56eff04 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/raw/unit_obj.a3d diff --git a/tests/RenderScriptTests/SceneGraph/res/values/strings.xml b/tests/RenderScriptTests/SceneGraph/res/values/strings.xml new file mode 100644 index 0000000..c916d79 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/res/values/strings.xml @@ -0,0 +1,24 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +--> + +<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> + <skip /> + <string name="load_model">Load Model</string> + <string name="use_blur">Use Blur</string> +</resources> diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Camera.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Camera.java new file mode 100644 index 0000000..42f2be5 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Camera.java @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import com.android.scenegraph.SceneManager; + +import android.renderscript.*; +import android.renderscript.Matrix4f; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public class Camera extends SceneGraphBase { + + Transform mTransform; + + ScriptField_Camera_s.Item mData; + ScriptField_Camera_s mField; + + public Camera() { + mData = new ScriptField_Camera_s.Item(); + mData.near = 0.1f; + mData.far = 1000.0f; + mData.horizontalFOV = 60.0f; + mData.aspect = 0; + } + + public void setTransform(Transform t) { + mTransform = t; + if (mField != null) { + mField.set_transformMatrix(0, mTransform.getRSData().getAllocation(), true); + mField.set_isDirty(0, 1, true); + } + } + public void setFOV(float fov) { + mData.horizontalFOV = fov; + if (mField != null) { + mField.set_horizontalFOV(0, fov, true); + mField.set_isDirty(0, 1, true); + } + } + + public void setNear(float n) { + mData.near = n; + if (mField != null) { + mField.set_near(0, n, true); + mField.set_isDirty(0, 1, true); + } + } + + public void setFar(float f) { + mData.far = f; + if (mField != null) { + mField.set_far(0, f, true); + mField.set_isDirty(0, 1, true); + } + } + + public void setName(String n) { + super.setName(n); + if (mField != null) { + RenderScriptGL rs = SceneManager.getRS(); + mData.name = getNameAlloc(rs); + mField.set_name(0, mData.name, true); + mField.set_isDirty(0, 1, true); + } + } + + ScriptField_Camera_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + if (rs == null) { + return null; + } + + if (mTransform == null) { + throw new RuntimeException("Cameras without transforms are invalid"); + } + + mField = new ScriptField_Camera_s(rs, 1); + + mData.transformMatrix = mTransform.getRSData().getAllocation(); + mData.transformTimestamp = 1; + mData.timestamp = 1; + mData.isDirty = 1; + mData.name = getNameAlloc(rs); + mField.set(mData, 0, true); + + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaParser.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaParser.java new file mode 100644 index 0000000..b4b6fb9 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaParser.java @@ -0,0 +1,563 @@ +/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.scenegraph;
+import com.android.scenegraph.CompoundTransform.TranslateComponent;
+import com.android.scenegraph.CompoundTransform.RotateComponent;
+import com.android.scenegraph.CompoundTransform.ScaleComponent;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.StringTokenizer;
+import java.util.HashMap;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import android.renderscript.*;
+import android.util.Log;
+
+public class ColladaParser {
+ static final String TAG = "ColladaParser";
+ Document mDom;
+
+ HashMap<String, LightBase> mLights;
+ HashMap<String, Camera> mCameras;
+ HashMap<String, ArrayList<ShaderParam> > mEffectsParams;
+ HashMap<String, Texture2D> mImages;
+ HashMap<String, Texture2D> mSamplerImageMap;
+ HashMap<String, String> mMeshIdNameMap;
+ Scene mScene;
+
+ String mRootDir;
+
+ String toString(Float3 v) {
+ String valueStr = v.x + " " + v.y + " " + v.z;
+ return valueStr;
+ }
+
+ String toString(Float4 v) {
+ String valueStr = v.x + " " + v.y + " " + v.z + " " + v.w;
+ return valueStr;
+ }
+
+ public ColladaParser(){
+ mLights = new HashMap<String, LightBase>();
+ mCameras = new HashMap<String, Camera>();
+ mEffectsParams = new HashMap<String, ArrayList<ShaderParam> >();
+ mImages = new HashMap<String, Texture2D>();
+ mMeshIdNameMap = new HashMap<String, String>();
+ }
+
+ public void init(InputStream is, String rootDir) {
+ mLights.clear();
+ mCameras.clear();
+ mEffectsParams.clear();
+
+ mRootDir = rootDir;
+
+ long start = System.currentTimeMillis();
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ try {
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ mDom = db.parse(is);
+ } catch(ParserConfigurationException e) {
+ e.printStackTrace();
+ } catch(SAXException e) {
+ e.printStackTrace();
+ } catch(IOException e) {
+ e.printStackTrace();
+ }
+ long end = System.currentTimeMillis();
+ Log.v("TIMER", " Parse time: " + (end - start));
+ exportSceneData();
+ }
+
+ Scene getScene() {
+ return mScene;
+ }
+
+ private void exportSceneData(){
+ mScene = new Scene();
+
+ Element docEle = mDom.getDocumentElement();
+ NodeList nl = docEle.getElementsByTagName("light");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element l = (Element)nl.item(i);
+ convertLight(l);
+ }
+ }
+
+ nl = docEle.getElementsByTagName("camera");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element c = (Element)nl.item(i);
+ convertCamera(c);
+ }
+ }
+
+ nl = docEle.getElementsByTagName("image");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element img = (Element)nl.item(i);
+ convertImage(img);
+ }
+ }
+
+ nl = docEle.getElementsByTagName("effect");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element e = (Element)nl.item(i);
+ convertEffects(e);
+ }
+ }
+
+ // Material is just a link to the effect
+ nl = docEle.getElementsByTagName("material");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element m = (Element)nl.item(i);
+ convertMaterials(m);
+ }
+ }
+
+ // Look through the geometry list and build up a correlation between id's and names
+ nl = docEle.getElementsByTagName("geometry");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element m = (Element)nl.item(i);
+ convertGeometries(m);
+ }
+ }
+
+
+ nl = docEle.getElementsByTagName("visual_scene");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element s = (Element)nl.item(i);
+ getScene(s);
+ }
+ }
+ }
+
+ private void getRenderable(Element shape, Transform t) {
+ String geoURL = shape.getAttribute("url").substring(1);
+ String geoName = mMeshIdNameMap.get(geoURL);
+ if (geoName != null) {
+ geoURL = geoName;
+ }
+ //RenderableGroup group = new RenderableGroup();
+ //group.setName(geoURL.substring(1));
+ //mScene.appendRenderable(group);
+ NodeList nl = shape.getElementsByTagName("instance_material");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element materialRef = (Element)nl.item(i);
+ String meshIndexName = materialRef.getAttribute("symbol");
+ String materialName = materialRef.getAttribute("target");
+
+ Renderable d = new Renderable();
+ d.setMesh(geoURL, meshIndexName);
+ d.setMaterialName(materialName.substring(1));
+ d.setName(geoURL);
+
+ //Log.v(TAG, "Created drawable geo " + geoURL + " index " + meshIndexName + " material " + materialName);
+
+ d.setTransform(t);
+ //Log.v(TAG, "Set source param " + t.getName());
+
+ // Now find all the parameters that exist on the material
+ ArrayList<ShaderParam> materialParams;
+ materialParams = mEffectsParams.get(materialName.substring(1));
+ for (int pI = 0; pI < materialParams.size(); pI ++) {
+ d.appendSourceParams(materialParams.get(pI));
+ //Log.v(TAG, "Set source param i: " + pI + " name " + materialParams.get(pI).getParamName());
+ }
+ mScene.appendRenderable(d);
+ //group.appendChildren(d);
+ }
+ }
+ }
+
+ private void updateLight(Element shape, Transform t) {
+ String lightURL = shape.getAttribute("url");
+ // collada uses a uri structure to link things,
+ // but we ignore it for now and do a simple search
+ LightBase light = mLights.get(lightURL.substring(1));
+ if (light != null) {
+ light.setTransform(t);
+ //Log.v(TAG, "Set Light " + light.getName() + " " + t.getName());
+ }
+ }
+
+ private void updateCamera(Element shape, Transform t) {
+ String camURL = shape.getAttribute("url");
+ // collada uses a uri structure to link things,
+ // but we ignore it for now and do a simple search
+ Camera cam = mCameras.get(camURL.substring(1));
+ if (cam != null) {
+ cam.setTransform(t);
+ //Log.v(TAG, "Set Camera " + cam.getName() + " " + t.getName());
+ }
+ }
+
+ private void getNode(Element node, Transform parent, String indent) {
+ String name = node.getAttribute("name");
+ String id = node.getAttribute("id");
+ CompoundTransform current = new CompoundTransform();
+ current.setName(name);
+ if (parent != null) {
+ parent.appendChild(current);
+ } else {
+ mScene.appendTransform(current);
+ }
+
+ mScene.addToTransformMap(current);
+
+ //Log.v(TAG, indent + "|");
+ //Log.v(TAG, indent + "[" + name + "]");
+
+ Node childNode = node.getFirstChild();
+ while (childNode != null) {
+ if (childNode.getNodeType() == Node.ELEMENT_NODE) {
+ Element field = (Element)childNode;
+ String fieldName = field.getTagName();
+ String description = field.getAttribute("sid");
+ if (fieldName.equals("translate")) {
+ Float3 value = getFloat3(field);
+ current.addTranslate(description, value);
+ //Log.v(TAG, indent + " translate " + description + toString(value));
+ } else if (fieldName.equals("rotate")) {
+ Float4 value = getFloat4(field);
+ //Log.v(TAG, indent + " rotate " + description + toString(value));
+ Float3 axis = new Float3(value.x, value.y, value.z);
+ current.addRotate(description, axis, value.w);
+ } else if (fieldName.equals("scale")) {
+ Float3 value = getFloat3(field);
+ //Log.v(TAG, indent + " scale " + description + toString(value));
+ current.addScale(description, value);
+ } else if (fieldName.equals("instance_geometry")) {
+ getRenderable(field, current);
+ } else if (fieldName.equals("instance_light")) {
+ updateLight(field, current);
+ } else if (fieldName.equals("instance_camera")) {
+ updateCamera(field, current);
+ } else if (fieldName.equals("node")) {
+ getNode(field, current, indent + " ");
+ }
+ }
+ childNode = childNode.getNextSibling();
+ }
+ }
+
+ // This will find the actual texture node, which is sometimes hidden behind a sampler
+ // and sometimes referenced directly
+ Texture2D getTexture(String samplerName) {
+ String texName = samplerName;
+
+ // Check to see if the image file is hidden by a sampler surface link combo
+ Element sampler = mDom.getElementById(samplerName);
+ if (sampler != null) {
+ NodeList nl = sampler.getElementsByTagName("source");
+ if (nl != null && nl.getLength() == 1) {
+ Element ref = (Element)nl.item(0);
+ String surfaceName = getString(ref);
+ if (surfaceName == null) {
+ return null;
+ }
+
+ Element surface = mDom.getElementById(surfaceName);
+ if (surface == null) {
+ return null;
+ }
+ nl = surface.getElementsByTagName("init_from");
+ if (nl != null && nl.getLength() == 1) {
+ ref = (Element)nl.item(0);
+ texName = getString(ref);
+ }
+ }
+ }
+
+ //Log.v(TAG, "Extracted texture name " + texName);
+ return mImages.get(texName);
+ }
+
+ void extractParams(Element fx, ArrayList<ShaderParam> params) {
+ Node paramNode = fx.getFirstChild();
+ while (paramNode != null) {
+ if (paramNode.getNodeType() == Node.ELEMENT_NODE) {
+ String name = paramNode.getNodeName();
+ // Now find what type it is
+ Node typeNode = paramNode.getFirstChild();
+ while (typeNode != null && typeNode.getNodeType() != Node.ELEMENT_NODE) {
+ typeNode = typeNode.getNextSibling();
+ }
+ String paramType = typeNode.getNodeName();
+ Element typeElem = (Element)typeNode;
+ ShaderParam sceneParam = null;
+ if (paramType.equals("color")) {
+ Float4Param f4p = new Float4Param(name);
+ Float4 value = getFloat4(typeElem);
+ f4p.setValue(value);
+ sceneParam = f4p;
+ //Log.v(TAG, "Extracted " + sceneParam.getParamName() + " value " + toString(value));
+ } else if (paramType.equals("float")) {
+ Float4Param f4p = new Float4Param(name);
+ float value = getFloat(typeElem);
+ f4p.setValue(new Float4(value, value, value, value));
+ sceneParam = f4p;
+ //Log.v(TAG, "Extracted " + sceneParam.getParamName() + " value " + value);
+ } else if (paramType.equals("texture")) {
+ String samplerName = typeElem.getAttribute("texture");
+ Texture2D tex = getTexture(samplerName);
+ TextureParam texP = new TextureParam(name);
+ texP.setTexture(tex);
+ sceneParam = texP;
+ //Log.v(TAG, "Extracted texture " + tex);
+ }
+ if (sceneParam != null) {
+ params.add(sceneParam);
+ }
+ }
+ paramNode = paramNode.getNextSibling();
+ }
+ }
+
+ private void convertMaterials(Element mat) {
+ String id = mat.getAttribute("id");
+ NodeList nl = mat.getElementsByTagName("instance_effect");
+ if (nl != null && nl.getLength() == 1) {
+ Element ref = (Element)nl.item(0);
+ String url = ref.getAttribute("url");
+ ArrayList<ShaderParam> params = mEffectsParams.get(url.substring(1));
+ mEffectsParams.put(id, params);
+ }
+ }
+
+ private void convertGeometries(Element geo) {
+ String id = geo.getAttribute("id");
+ String name = geo.getAttribute("name");
+ if (!id.equals(name)) {
+ mMeshIdNameMap.put(id, name);
+ }
+ }
+
+ private void convertEffects(Element fx) {
+ String id = fx.getAttribute("id");
+ ArrayList<ShaderParam> params = new ArrayList<ShaderParam>();
+
+ NodeList nl = fx.getElementsByTagName("newparam");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element field = (Element)nl.item(i);
+ field.setIdAttribute("sid", true);
+ }
+ }
+
+ nl = fx.getElementsByTagName("blinn");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element field = (Element)nl.item(i);
+ //Log.v(TAG, "blinn");
+ extractParams(field, params);
+ }
+ }
+ nl = fx.getElementsByTagName("lambert");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element field = (Element)nl.item(i);
+ //Log.v(TAG, "lambert");
+ extractParams(field, params);
+ }
+ }
+ nl = fx.getElementsByTagName("phong");
+ if (nl != null) {
+ for(int i = 0; i < nl.getLength(); i++) {
+ Element field = (Element)nl.item(i);
+ //Log.v(TAG, "phong");
+ extractParams(field, params);
+ }
+ }
+ mEffectsParams.put(id, params);
+ }
+
+ private void convertLight(Element light) {
+ String name = light.getAttribute("name");
+ String id = light.getAttribute("id");
+
+ // Determine type
+ String[] knownTypes = { "point", "spot", "directional" };
+ final int POINT_LIGHT = 0;
+ final int SPOT_LIGHT = 1;
+ final int DIR_LIGHT = 2;
+ int type = -1;
+ for (int i = 0; i < knownTypes.length; i ++) {
+ NodeList nl = light.getElementsByTagName(knownTypes[i]);
+ if (nl != null && nl.getLength() != 0) {
+ type = i;
+ break;
+ }
+ }
+
+ //Log.v(TAG, "Found Light Type " + type);
+
+ LightBase sceneLight = null;
+ switch (type) {
+ case POINT_LIGHT:
+ sceneLight = new PointLight();
+ break;
+ case SPOT_LIGHT: // TODO: finish light types
+ break;
+ case DIR_LIGHT: // TODO: finish light types
+ break;
+ }
+
+ if (sceneLight == null) {
+ return;
+ }
+
+ Float3 color = getFloat3(light, "color");
+ sceneLight.setColor(color.x, color.y, color.z);
+ sceneLight.setName(name);
+ mScene.appendLight(sceneLight);
+ mLights.put(id, sceneLight);
+
+ //Log.v(TAG, "Light " + name + " color " + toString(color));
+ }
+
+ private void convertCamera(Element camera) {
+ String name = camera.getAttribute("name");
+ String id = camera.getAttribute("id");
+ float fov = 30.0f;
+ if (getString(camera, "yfov") != null) {
+ fov = getFloat(camera, "yfov");
+ } else if(getString(camera, "xfov") != null) {
+ float aspect = getFloat(camera, "aspect_ratio");
+ fov = getFloat(camera, "xfov") / aspect;
+ }
+
+ float near = getFloat(camera, "znear");
+ float far = getFloat(camera, "zfar");
+
+ Camera sceneCamera = new Camera();
+ sceneCamera.setFOV(fov);
+ sceneCamera.setNear(near);
+ sceneCamera.setFar(far);
+ sceneCamera.setName(name);
+ mScene.appendCamera(sceneCamera);
+ mCameras.put(id, sceneCamera);
+ }
+
+ private void convertImage(Element img) {
+ String name = img.getAttribute("name");
+ String id = img.getAttribute("id");
+ String file = getString(img, "init_from");
+
+ Texture2D tex = new Texture2D();
+ tex.setFileName(file);
+ tex.setFileDir(mRootDir);
+ mScene.appendTextures(tex);
+ mImages.put(id, tex);
+ }
+
+ private void getScene(Element scene) {
+ String name = scene.getAttribute("name");
+ String id = scene.getAttribute("id");
+
+ Node childNode = scene.getFirstChild();
+ while (childNode != null) {
+ if (childNode.getNodeType() == Node.ELEMENT_NODE) {
+ String indent = "";
+ getNode((Element)childNode, null, indent);
+ }
+ childNode = childNode.getNextSibling();
+ }
+ }
+
+ private String getString(Element elem, String name) {
+ String text = null;
+ NodeList nl = elem.getElementsByTagName(name);
+ if (nl != null && nl.getLength() != 0) {
+ text = ((Element)nl.item(0)).getFirstChild().getNodeValue();
+ }
+ return text;
+ }
+
+ private String getString(Element elem) {
+ String text = null;
+ text = elem.getFirstChild().getNodeValue();
+ return text;
+ }
+
+ private int getInt(Element elem, String name) {
+ return Integer.parseInt(getString(elem, name));
+ }
+
+ private float getFloat(Element elem, String name) {
+ return Float.parseFloat(getString(elem, name));
+ }
+
+ private float getFloat(Element elem) {
+ return Float.parseFloat(getString(elem));
+ }
+
+ private Float3 parseFloat3(String valueString) {
+ StringTokenizer st = new StringTokenizer(valueString);
+ float x = Float.parseFloat(st.nextToken());
+ float y = Float.parseFloat(st.nextToken());
+ float z = Float.parseFloat(st.nextToken());
+ return new Float3(x, y, z);
+ }
+
+ private Float4 parseFloat4(String valueString) {
+ StringTokenizer st = new StringTokenizer(valueString);
+ float x = Float.parseFloat(st.nextToken());
+ float y = Float.parseFloat(st.nextToken());
+ float z = Float.parseFloat(st.nextToken());
+ float w = Float.parseFloat(st.nextToken());
+ return new Float4(x, y, z, w);
+ }
+
+ private Float3 getFloat3(Element elem, String name) {
+ String valueString = getString(elem, name);
+ return parseFloat3(valueString);
+ }
+
+ private Float4 getFloat4(Element elem, String name) {
+ String valueString = getString(elem, name);
+ return parseFloat4(valueString);
+ }
+
+ private Float3 getFloat3(Element elem) {
+ String valueString = getString(elem);
+ return parseFloat3(valueString);
+ }
+
+ private Float4 getFloat4(Element elem) {
+ String valueString = getString(elem);
+ return parseFloat4(valueString);
+ }
+}
diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaScene.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaScene.java new file mode 100644 index 0000000..301075e --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ColladaScene.java @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.FileInputStream; +import java.io.BufferedInputStream; +import java.io.Writer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Element.Builder; +import android.renderscript.Font.Style; +import android.renderscript.Program.TextureType; +import android.renderscript.ProgramStore.DepthFunc; +import android.util.Log; +import com.android.scenegraph.SceneManager.SceneLoadedCallback; + + +public class ColladaScene { + + private String modelName; + private static String TAG = "ColladaScene"; + private final int STATE_LAST_FOCUS = 1; + boolean mLoadFromSD = false; + + SceneLoadedCallback mCallback; + + public ColladaScene(String name, SceneLoadedCallback cb) { + modelName = name; + mCallback = cb; + } + + public void init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + + mLoadFromSD = SceneManager.isSDCardPath(modelName); + + new ColladaLoaderTask().execute(modelName); + } + + private Resources mRes; + private RenderScriptGL mRS; + Scene mActiveScene; + + private class ColladaLoaderTask extends AsyncTask<String, Void, Boolean> { + ColladaParser sceneSource; + protected Boolean doInBackground(String... names) { + String rootDir = names[0].substring(0, names[0].lastIndexOf('/') + 1); + long start = System.currentTimeMillis(); + sceneSource = new ColladaParser(); + InputStream is = null; + try { + if (!mLoadFromSD) { + is = mRes.getAssets().open(names[0]); + } else { + File f = new File(names[0]); + is = new BufferedInputStream(new FileInputStream(f)); + } + } catch (IOException e) { + Log.e(TAG, "Could not open collada file"); + return new Boolean(false); + } + long end = System.currentTimeMillis(); + Log.v("TIMER", "Stream load time: " + (end - start)); + + start = System.currentTimeMillis(); + sceneSource.init(is, rootDir); + end = System.currentTimeMillis(); + Log.v("TIMER", "Collada parse time: " + (end - start)); + return new Boolean(true); + } + + protected void onPostExecute(Boolean result) { + mActiveScene = sceneSource.getScene(); + if (mCallback != null) { + mCallback.mLoadedScene = mActiveScene; + mCallback.run(); + } + + String shortName = modelName.substring(0, modelName.lastIndexOf('.')); + new A3DLoaderTask().execute(shortName + ".a3d"); + } + } + + private class A3DLoaderTask extends AsyncTask<String, Void, Boolean> { + protected Boolean doInBackground(String... names) { + long start = System.currentTimeMillis(); + FileA3D model; + if (!mLoadFromSD) { + model = FileA3D.createFromAsset(mRS, mRes.getAssets(), names[0]); + } else { + model = FileA3D.createFromFile(mRS, names[0]); + } + int numModels = model.getIndexEntryCount(); + for (int i = 0; i < numModels; i ++) { + FileA3D.IndexEntry entry = model.getIndexEntry(i); + if (entry != null && entry.getEntryType() == FileA3D.EntryType.MESH) { + mActiveScene.meshLoaded(entry.getMesh()); + } + } + long end = System.currentTimeMillis(); + Log.v("TIMER", "A3D load time: " + (end - start)); + return new Boolean(true); + } + + protected void onPostExecute(Boolean result) { + } + } + +} + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/CompoundTransform.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/CompoundTransform.java new file mode 100644 index 0000000..9274b17 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/CompoundTransform.java @@ -0,0 +1,215 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import com.android.scenegraph.SceneManager; + +import android.renderscript.*; +import android.renderscript.Float3; +import android.renderscript.Matrix4f; +import android.util.Log; + +/** + * @hide + */ +public class CompoundTransform extends Transform { + + public static abstract class Component { + String mName; + CompoundTransform mParent; + int mParentIndex; + protected ScriptField_TransformComponent_s.Item mData; + + Component(int type, String name) { + mData = new ScriptField_TransformComponent_s.Item(); + mData.type = type; + mName = name; + } + + void setNameAlloc() { + RenderScriptGL rs = SceneManager.getRS(); + if (mData.name != null) { + return; + } + mData.name = SceneManager.getCachedAlloc(getName()); + if (mData.name == null) { + mData.name = SceneManager.getStringAsAllocation(rs, getName()); + SceneManager.cacheAlloc(getName(), mData.name); + } + } + + ScriptField_TransformComponent_s.Item getRSData() { + setNameAlloc(); + return mData; + } + + protected void update() { + if (mParent != null) { + mParent.updateRSComponent(this); + } + } + + public String getName() { + return mName; + } + } + + public static class TranslateComponent extends Component { + public TranslateComponent(String name, Float3 translate) { + super(ScriptC_export.const_Transform_TRANSLATE, name); + setValue(translate); + } + public Float3 getValue() { + return new Float3(mData.value.x, mData.value.y, mData.value.z); + } + public void setValue(Float3 val) { + mData.value.x = val.x; + mData.value.y = val.y; + mData.value.z = val.z; + update(); + } + } + + public static class RotateComponent extends Component { + public RotateComponent(String name, Float3 axis, float angle) { + super(ScriptC_export.const_Transform_ROTATE, name); + setAxis(axis); + setAngle(angle); + } + public Float3 getAxis() { + return new Float3(mData.value.x, mData.value.y, mData.value.z); + } + public float getAngle() { + return mData.value.w; + } + public void setAxis(Float3 val) { + mData.value.x = val.x; + mData.value.y = val.y; + mData.value.z = val.z; + update(); + } + public void setAngle(float val) { + mData.value.w = val; + update(); + } + } + + public static class ScaleComponent extends Component { + public ScaleComponent(String name, Float3 scale) { + super(ScriptC_export.const_Transform_SCALE, name); + setValue(scale); + } + public Float3 getValue() { + return new Float3(mData.value.x, mData.value.y, mData.value.z); + } + public void setValue(Float3 val) { + mData.value.x = val.x; + mData.value.y = val.y; + mData.value.z = val.z; + update(); + } + } + + ScriptField_TransformComponent_s mComponentField; + public ArrayList<Component> mTransformComponents; + + public CompoundTransform() { + mTransformComponents = new ArrayList<Component>(); + } + + public TranslateComponent addTranslate(String name, Float3 translate) { + TranslateComponent c = new TranslateComponent(name, translate); + addComponent(c); + return c; + } + + public RotateComponent addRotate(String name, Float3 axis, float angle) { + RotateComponent c = new RotateComponent(name, axis, angle); + addComponent(c); + return c; + } + + public ScaleComponent addScale(String name, Float3 scale) { + ScaleComponent c = new ScaleComponent(name, scale); + addComponent(c); + return c; + } + + public void addComponent(Component c) { + if (c.mParent != null) { + throw new IllegalArgumentException("Transform components may not be shared"); + } + c.mParent = this; + c.mParentIndex = mTransformComponents.size(); + mTransformComponents.add(c); + updateRSComponentAllocation(); + } + + public void setComponent(int index, Component c) { + if (c.mParent != null) { + throw new IllegalArgumentException("Transform components may not be shared"); + } + if (index >= mTransformComponents.size()) { + throw new IllegalArgumentException("Invalid component index"); + } + c.mParent = this; + c.mParentIndex = index; + mTransformComponents.set(index, c); + updateRSComponent(c); + } + + void updateRSComponent(Component c) { + if (mField == null || mComponentField == null) { + return; + } + mComponentField.set(c.getRSData(), c.mParentIndex, true); + mField.set_isDirty(0, 1, true); + } + + void updateRSComponentAllocation() { + if (mField == null) { + return; + } + initLocalData(); + + mField.set_components(0, mTransformData.components, false); + mField.set_isDirty(0, 1, true); + } + + void initLocalData() { + RenderScriptGL rs = SceneManager.getRS(); + int numComponenets = mTransformComponents.size(); + if (numComponenets > 0) { + mComponentField = new ScriptField_TransformComponent_s(rs, numComponenets); + for (int i = 0; i < numComponenets; i ++) { + Component ith = mTransformComponents.get(i); + mComponentField.set(ith.getRSData(), i, false); + } + mComponentField.copyAll(); + + mTransformData.components = mComponentField.getAllocation(); + } + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Float4Param.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Float4Param.java new file mode 100644 index 0000000..1502458 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Float4Param.java @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import com.android.scenegraph.Scene; +import com.android.scenegraph.SceneManager; + +import android.renderscript.Element; +import android.renderscript.Float4; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public class Float4Param extends ShaderParam { + private static String TAG = "Float4Param"; + + LightBase mLight; + + public Float4Param(String name) { + super(name); + } + + public Float4Param(String name, float x) { + super(name); + set(x, 0, 0, 0); + } + + public Float4Param(String name, float x, float y) { + super(name); + set(x, y, 0, 0); + } + + public Float4Param(String name, float x, float y, float z) { + super(name); + set(x, y, z, 0); + } + + public Float4Param(String name, float x, float y, float z, float w) { + super(name); + set(x, y, z, w); + } + + void set(float x, float y, float z, float w) { + mData.float_value.x = x; + mData.float_value.y = y; + mData.float_value.z = z; + mData.float_value.w = w; + if (mField != null) { + mField.set_float_value(0, mData.float_value, true); + } + incTimestamp(); + } + + public void setValue(Float4 v) { + set(v.x, v.y, v.z, v.w); + } + + public Float4 getValue() { + return mData.float_value; + } + + public void setLight(LightBase l) { + mLight = l; + if (mField != null) { + mData.light = mLight.getRSData().getAllocation(); + mField.set_light(0, mData.light, true); + } + incTimestamp(); + } + + boolean findLight(String property) { + String indexStr = mParamName.substring(property.length() + 1); + if (indexStr == null) { + Log.e(TAG, "Invalid light index."); + return false; + } + int index = Integer.parseInt(indexStr); + if (index == -1) { + return false; + } + Scene parentScene = SceneManager.getInstance().getActiveScene(); + ArrayList<LightBase> allLights = parentScene.getLights(); + if (index >= allLights.size()) { + return false; + } + mLight = allLights.get(index); + if (mLight == null) { + return false; + } + return true; + } + + int getTypeFromName() { + int paramType = ScriptC_export.const_ShaderParam_FLOAT4_DATA; + if (mParamName.equalsIgnoreCase(cameraPos)) { + paramType = ScriptC_export.const_ShaderParam_FLOAT4_CAMERA_POS; + } else if(mParamName.equalsIgnoreCase(cameraDir)) { + paramType = ScriptC_export.const_ShaderParam_FLOAT4_CAMERA_DIR; + } else if(mParamName.startsWith(lightColor) && findLight(lightColor)) { + paramType = ScriptC_export.const_ShaderParam_FLOAT4_LIGHT_COLOR; + } else if(mParamName.startsWith(lightPos) && findLight(lightPos)) { + paramType = ScriptC_export.const_ShaderParam_FLOAT4_LIGHT_POS; + } else if(mParamName.startsWith(lightDir) && findLight(lightDir)) { + paramType = ScriptC_export.const_ShaderParam_FLOAT4_LIGHT_DIR; + } + return paramType; + } + + void initLocalData() { + mData.type = getTypeFromName(); + if (mCamera != null) { + mData.camera = mCamera.getRSData().getAllocation(); + } + if (mLight != null) { + mData.light = mLight.getRSData().getAllocation(); + } + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/FragmentShader.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/FragmentShader.java new file mode 100644 index 0000000..8a468db --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/FragmentShader.java @@ -0,0 +1,174 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import com.android.scenegraph.TextureBase; + +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.ProgramFragment.Builder; +import android.util.Log; + +/** + * @hide + */ +public class FragmentShader extends Shader { + ProgramFragment mProgram; + ScriptField_FragmentShader_s mField; + + public static class Builder { + + FragmentShader mShader; + ProgramFragment.Builder mBuilder; + + public Builder(RenderScriptGL rs) { + mShader = new FragmentShader(); + mBuilder = new ProgramFragment.Builder(rs); + } + + public Builder setShader(Resources resources, int resourceID) { + mBuilder.setShader(resources, resourceID); + return this; + } + + public Builder setShader(String code) { + mBuilder.setShader(code); + return this; + } + + public Builder setObjectConst(Type type) { + mShader.mPerObjConstants = type; + return this; + } + + public Builder setShaderConst(Type type) { + mShader.mPerShaderConstants = type; + return this; + } + + public Builder addShaderTexture(Program.TextureType texType, String name) { + mShader.mShaderTextureNames.add(name); + mShader.mShaderTextureTypes.add(texType); + return this; + } + + public Builder addTexture(Program.TextureType texType, String name) { + mShader.mTextureNames.add(name); + mShader.mTextureTypes.add(texType); + return this; + } + + public FragmentShader create() { + if (mShader.mPerShaderConstants != null) { + mBuilder.addConstant(mShader.mPerShaderConstants); + } + if (mShader.mPerObjConstants != null) { + mBuilder.addConstant(mShader.mPerObjConstants); + } + for (int i = 0; i < mShader.mTextureTypes.size(); i ++) { + mBuilder.addTexture(mShader.mTextureTypes.get(i), + mShader.mTextureNames.get(i)); + } + for (int i = 0; i < mShader.mShaderTextureTypes.size(); i ++) { + mBuilder.addTexture(mShader.mShaderTextureTypes.get(i), + mShader.mShaderTextureNames.get(i)); + } + + mShader.mProgram = mBuilder.create(); + return mShader; + } + } + + public ProgramFragment getProgram() { + return mProgram; + } + + ScriptField_ShaderParam_s getTextureParams() { + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (rs == null || res == null) { + return null; + } + + ArrayList<ScriptField_ShaderParam_s.Item> paramList; + paramList = new ArrayList<ScriptField_ShaderParam_s.Item>(); + + int shaderTextureStart = mTextureTypes.size(); + for (int i = 0; i < mShaderTextureNames.size(); i ++) { + ShaderParam sp = mSourceParams.get(mShaderTextureNames.get(i)); + if (sp != null && sp instanceof TextureParam) { + TextureParam p = (TextureParam)sp; + ScriptField_ShaderParam_s.Item paramRS = new ScriptField_ShaderParam_s.Item(); + paramRS.bufferOffset = shaderTextureStart + i; + paramRS.transformTimestamp = 0; + paramRS.dataTimestamp = 0; + paramRS.data = p.getRSData().getAllocation(); + paramList.add(paramRS); + } + } + + ScriptField_ShaderParam_s rsParams = null; + int paramCount = paramList.size(); + if (paramCount != 0) { + rsParams = new ScriptField_ShaderParam_s(rs, paramCount); + for (int i = 0; i < paramCount; i++) { + rsParams.set(paramList.get(i), i, false); + } + rsParams.copyAll(); + } + return rsParams; + } + + ScriptField_FragmentShader_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (rs == null || res == null) { + return null; + } + + ScriptField_FragmentShader_s.Item item = new ScriptField_FragmentShader_s.Item(); + item.program = mProgram; + + ScriptField_ShaderParam_s texParams = getTextureParams(); + if (texParams != null) { + item.shaderTextureParams = texParams.getAllocation(); + } + + linkConstants(rs); + if (mPerShaderConstants != null) { + item.shaderConst = mConstantBuffer; + item.shaderConstParams = mConstantBufferParams.getAllocation(); + mProgram.bindConstants(item.shaderConst, 0); + } + + item.objectConstIndex = -1; + if (mPerObjConstants != null) { + item.objectConstIndex = mPerShaderConstants != null ? 1 : 0; + } + + mField = new ScriptField_FragmentShader_s(rs, 1); + mField.set(item, 0, true); + return mField; + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/LightBase.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/LightBase.java new file mode 100644 index 0000000..8f5e2e7 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/LightBase.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.Float3; +import android.renderscript.Float4; +import android.renderscript.Matrix4f; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public abstract class LightBase extends SceneGraphBase { + static final int RS_LIGHT_POINT = 0; + static final int RS_LIGHT_DIRECTIONAL = 1; + + ScriptField_Light_s mField; + ScriptField_Light_s.Item mFieldData; + Transform mTransform; + Float4 mColor; + float mIntensity; + public LightBase() { + mColor = new Float4(0.0f, 0.0f, 0.0f, 0.0f); + mIntensity = 1.0f; + } + + public void setTransform(Transform t) { + mTransform = t; + updateRSData(); + } + + public void setColor(float r, float g, float b) { + mColor.x = r; + mColor.y = g; + mColor.z = b; + updateRSData(); + } + + public void setColor(Float3 c) { + setColor(c.x, c.y, c.z); + } + + public void setIntensity(float i) { + mIntensity = i; + updateRSData(); + } + + public void setName(String n) { + super.setName(n); + updateRSData(); + } + + protected void updateRSData() { + if (mField == null) { + return; + } + RenderScriptGL rs = SceneManager.getRS(); + mFieldData.transformMatrix = mTransform.getRSData().getAllocation(); + mFieldData.name = getNameAlloc(rs); + mFieldData.color = mColor; + mFieldData.intensity = mIntensity; + + initLocalData(); + + mField.set(mFieldData, 0, true); + } + + abstract void initLocalData(); + + ScriptField_Light_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + if (rs == null) { + return null; + } + if (mField == null) { + mField = new ScriptField_Light_s(rs, 1); + mFieldData = new ScriptField_Light_s.Item(); + } + + updateRSData(); + + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/MatrixTransform.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/MatrixTransform.java new file mode 100644 index 0000000..6d70bc9 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/MatrixTransform.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.Matrix4f; +import android.util.Log; + +/** + * @hide + */ +public class MatrixTransform extends Transform { + + Matrix4f mLocalMatrix; + public MatrixTransform() { + mLocalMatrix = new Matrix4f(); + } + + public void setMatrix(Matrix4f matrix) { + mLocalMatrix = matrix; + updateRSData(); + } + + public Matrix4f getMatrix() { + return new Matrix4f(mLocalMatrix.getArray()); + } + + void initLocalData() { + mTransformData.localMat = mLocalMatrix; + } + + void updateRSData() { + if (mField == null) { + return; + } + mField.set_localMat(0, mLocalMatrix, false); + mField.set_isDirty(0, 1, true); + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/PointLight.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/PointLight.java new file mode 100644 index 0000000..574bafc --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/PointLight.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.util.Log; + +/** + * @hide + */ +public class PointLight extends LightBase { + public PointLight() { + } + + void initLocalData() { + mFieldData.type = RS_LIGHT_POINT; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderPass.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderPass.java new file mode 100644 index 0000000..02fd69d --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderPass.java @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.util.Log; + +import android.renderscript.*; +import android.content.res.Resources; + +/** + * @hide + */ +public class RenderPass extends SceneGraphBase { + + TextureRenderTarget mColorTarget; + Float4 mClearColor; + boolean mShouldClearColor; + + TextureRenderTarget mDepthTarget; + float mClearDepth; + boolean mShouldClearDepth; + + ArrayList<RenderableBase> mObjectsToDraw; + + Camera mCamera; + + ScriptField_RenderPass_s.Item mRsField; + + public RenderPass() { + mObjectsToDraw = new ArrayList<RenderableBase>(); + mClearColor = new Float4(0.0f, 0.0f, 0.0f, 0.0f); + mShouldClearColor = true; + mClearDepth = 1.0f; + mShouldClearDepth = true; + } + + public void appendRenderable(Renderable d) { + mObjectsToDraw.add(d); + } + + public void setCamera(Camera c) { + mCamera = c; + } + + public void setColorTarget(TextureRenderTarget colorTarget) { + mColorTarget = colorTarget; + } + public void setClearColor(Float4 clearColor) { + mClearColor = clearColor; + } + public void setShouldClearColor(boolean shouldClearColor) { + mShouldClearColor = shouldClearColor; + } + + public void setDepthTarget(TextureRenderTarget depthTarget) { + mDepthTarget = depthTarget; + } + public void setClearDepth(float clearDepth) { + mClearDepth = clearDepth; + } + public void setShouldClearDepth(boolean shouldClearDepth) { + mShouldClearDepth = shouldClearDepth; + } + + public ArrayList<RenderableBase> getRenderables() { + return mObjectsToDraw; + } + + ScriptField_RenderPass_s.Item getRsField(RenderScriptGL rs, Resources res) { + if (mRsField != null) { + return mRsField; + } + + mRsField = new ScriptField_RenderPass_s.Item(); + if (mColorTarget != null) { + mRsField.color_target = mColorTarget.getRsData(true).get_texture(0); + } + if (mColorTarget != null) { + mRsField.depth_target = mDepthTarget.getRsData(true).get_texture(0); + } + mRsField.camera = mCamera != null ? mCamera.getRSData().getAllocation() : null; + + if (mObjectsToDraw.size() != 0) { + Allocation drawableData = Allocation.createSized(rs, + Element.ALLOCATION(rs), + mObjectsToDraw.size()); + Allocation[] drawableAllocs = new Allocation[mObjectsToDraw.size()]; + for (int i = 0; i < mObjectsToDraw.size(); i ++) { + Renderable dI = (Renderable)mObjectsToDraw.get(i); + drawableAllocs[i] = dI.getRsField(rs, res).getAllocation(); + } + drawableData.copyFrom(drawableAllocs); + mRsField.objects = drawableData; + } + + mRsField.clear_color = mClearColor; + mRsField.clear_depth = mClearDepth; + mRsField.should_clear_color = mShouldClearColor; + mRsField.should_clear_depth = mShouldClearDepth; + return mRsField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderState.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderState.java new file mode 100644 index 0000000..c08a722 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderState.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; +import android.content.res.Resources; + +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramRaster; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.RSRuntimeException; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public class RenderState extends SceneGraphBase { + VertexShader mVertex; + FragmentShader mFragment; + ProgramStore mStore; + ProgramRaster mRaster; + + ScriptField_RenderState_s mField; + + public RenderState(VertexShader pv, + FragmentShader pf, + ProgramStore ps, + ProgramRaster pr) { + mVertex = pv; + mFragment = pf; + mStore = ps; + mRaster = pr; + } + + public RenderState(RenderState r) { + mVertex = r.mVertex; + mFragment = r.mFragment; + mStore = r.mStore; + mRaster = r.mRaster; + } + + public void setProgramVertex(VertexShader pv) { + mVertex = pv; + updateRSData(); + } + + public void setProgramFragment(FragmentShader pf) { + mFragment = pf; + updateRSData(); + } + + public void setProgramStore(ProgramStore ps) { + mStore = ps; + updateRSData(); + } + + public void setProgramRaster(ProgramRaster pr) { + mRaster = pr; + updateRSData(); + } + + void updateRSData() { + if (mField == null) { + return; + } + ScriptField_RenderState_s.Item item = new ScriptField_RenderState_s.Item(); + item.pv = mVertex.getRSData().getAllocation(); + item.pf = mFragment.getRSData().getAllocation(); + item.ps = mStore; + item.pr = mRaster; + + mField.set(item, 0, true); + } + + public ScriptField_RenderState_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + if (rs == null) { + return null; + } + + mField = new ScriptField_RenderState_s(rs, 1); + updateRSData(); + + return mField; + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Renderable.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Renderable.java new file mode 100644 index 0000000..9266f30 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Renderable.java @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; + +import com.android.scenegraph.Float4Param; +import com.android.scenegraph.MatrixTransform; +import com.android.scenegraph.SceneManager; +import com.android.scenegraph.ShaderParam; +import com.android.scenegraph.TransformParam; + +import android.content.res.Resources; +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.Element.DataType; +import android.renderscript.Matrix4f; +import android.renderscript.Mesh; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public class Renderable extends RenderableBase { + HashMap<String, ShaderParam> mSourceParams; + + RenderState mRenderState; + Transform mTransform; + + String mMeshName; + String mMeshIndexName; + + public String mMaterialName; + + ScriptField_Renderable_s mField; + ScriptField_Renderable_s.Item mData; + + public Renderable() { + mSourceParams = new HashMap<String, ShaderParam>(); + mData = new ScriptField_Renderable_s.Item(); + } + + public void setCullType(int cull) { + mData.cullType = cull; + } + + public void setRenderState(RenderState renderState) { + mRenderState = renderState; + if (mField != null) { + RenderScriptGL rs = SceneManager.getRS(); + updateFieldItem(rs); + mField.set(mData, 0, true); + } + } + + public void setMesh(Mesh mesh) { + mData.mesh = mesh; + if (mField != null) { + mField.set_mesh(0, mData.mesh, true); + } + } + + public void setMesh(String mesh, String indexName) { + mMeshName = mesh; + mMeshIndexName = indexName; + } + + public void setMaterialName(String name) { + mMaterialName = name; + } + + public Transform getTransform() { + return mTransform; + } + + public void setTransform(Transform t) { + mTransform = t; + if (mField != null) { + RenderScriptGL rs = SceneManager.getRS(); + updateFieldItem(rs); + mField.set(mData, 0, true); + } + } + + public void appendSourceParams(ShaderParam p) { + mSourceParams.put(p.getParamName(), p); + // Possibly lift this restriction later + if (mField != null) { + throw new RuntimeException("Can't add source params to objects that are rendering"); + } + } + + public void resolveMeshData(Mesh mesh) { + mData.mesh = mesh; + if (mData.mesh == null) { + Log.v("DRAWABLE: ", "*** NO MESH *** " + mMeshName); + return; + } + int subIndexCount = mData.mesh.getPrimitiveCount(); + if (subIndexCount == 1 || mMeshIndexName == null) { + mData.meshIndex = 0; + } else { + for (int i = 0; i < subIndexCount; i ++) { + if (mData.mesh.getIndexSetAllocation(i).getName().equals(mMeshIndexName)) { + mData.meshIndex = i; + break; + } + } + } + if (mField != null) { + mField.set(mData, 0, true); + } + } + + void updateTextures(RenderScriptGL rs) { + Iterator<ShaderParam> allParamsIter = mSourceParams.values().iterator(); + int paramIndex = 0; + while (allParamsIter.hasNext()) { + ShaderParam sp = allParamsIter.next(); + if (sp instanceof TextureParam) { + TextureParam p = (TextureParam)sp; + TextureBase tex = p.getTexture(); + if (tex != null) { + mData.pf_textures[paramIndex++] = tex.getRsData(false).getAllocation(); + } + } + } + ProgramFragment pf = mRenderState.mFragment.mProgram; + mData.pf_num_textures = pf != null ? Math.min(pf.getTextureCount(), paramIndex) : 0; + if (mField != null) { + mField.set_pf_textures(0, mData.pf_textures, true); + mField.set_pf_num_textures(0, mData.pf_num_textures, true); + } + } + + public void setVisible(boolean vis) { + mData.cullType = vis ? 0 : 2; + if (mField != null) { + mField.set_cullType(0, mData.cullType, true); + } + } + + ScriptField_Renderable_s getRsField(RenderScriptGL rs, Resources res) { + if (mField != null) { + return mField; + } + updateFieldItem(rs); + updateTextures(rs); + + mField = new ScriptField_Renderable_s(rs, 1); + mField.set(mData, 0, true); + + return mField; + } + + void updateVertexConstants(RenderScriptGL rs) { + Allocation pvParams = null, vertexConstants = null; + VertexShader pv = mRenderState.mVertex; + if (pv != null && pv.getObjectConstants() != null) { + vertexConstants = Allocation.createTyped(rs, pv.getObjectConstants()); + Element vertexConst = vertexConstants.getType().getElement(); + pvParams = ShaderParam.fillInParams(vertexConst, mSourceParams, + mTransform).getAllocation(); + } + mData.pv_const = vertexConstants; + mData.pv_constParams = pvParams; + } + + void updateFragmentConstants(RenderScriptGL rs) { + Allocation pfParams = null, fragmentConstants = null; + FragmentShader pf = mRenderState.mFragment; + if (pf != null && pf.getObjectConstants() != null) { + fragmentConstants = Allocation.createTyped(rs, pf.getObjectConstants()); + Element fragmentConst = fragmentConstants.getType().getElement(); + pfParams = ShaderParam.fillInParams(fragmentConst, mSourceParams, + mTransform).getAllocation(); + } + mData.pf_const = fragmentConstants; + mData.pf_constParams = pfParams; + } + + void updateFieldItem(RenderScriptGL rs) { + if (mRenderState == null) { + mRenderState = SceneManager.getDefaultState(); + } + if (mTransform == null) { + mTransform = SceneManager.getDefaultTransform(); + } + updateVertexConstants(rs); + updateFragmentConstants(rs); + + mData.transformMatrix = mTransform.getRSData().getAllocation(); + + mData.name = getNameAlloc(rs); + mData.render_state = mRenderState.getRSData().getAllocation(); + mData.bVolInitialized = 0; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableBase.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableBase.java new file mode 100644 index 0000000..74535dd --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableBase.java @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.util.Log; + +/** + * @hide + */ +public class RenderableBase extends SceneGraphBase { + public RenderableBase() { + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableGroup.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableGroup.java new file mode 100644 index 0000000..590bbab --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/RenderableGroup.java @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.util.Log; + +/** + * @hide + */ +public class RenderableGroup extends RenderableBase { + + ArrayList<RenderableBase> mChildren; + + public RenderableGroup() { + mChildren = new ArrayList<RenderableBase>(); + } + + public void appendChildren(RenderableBase d) { + mChildren.add(d); + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Scene.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Scene.java new file mode 100644 index 0000000..27336ab --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Scene.java @@ -0,0 +1,373 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import com.android.scenegraph.Camera; +import com.android.scenegraph.CompoundTransform; +import com.android.scenegraph.RenderPass; +import com.android.scenegraph.Renderable; +import com.android.scenegraph.SceneManager; +import com.android.scenegraph.TextureBase; + +import android.content.res.Resources; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Mesh; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public class Scene extends SceneGraphBase { + private static String TIMER_TAG = "TIMER"; + + CompoundTransform mRootTransforms; + HashMap<String, Transform> mTransformMap; + ArrayList<RenderPass> mRenderPasses; + ArrayList<LightBase> mLights; + ArrayList<Camera> mCameras; + ArrayList<FragmentShader> mFragmentShaders; + ArrayList<VertexShader> mVertexShaders; + ArrayList<RenderableBase> mRenderables; + HashMap<String, RenderableBase> mRenderableMap; + ArrayList<Texture2D> mTextures; + + HashMap<String, ArrayList<Renderable> > mRenderableMeshMap; + + // RS Specific stuff + ScriptField_SgTransform mTransformRSData; + + RenderScriptGL mRS; + Resources mRes; + + ScriptField_RenderPass_s mRenderPassAlloc; + + public Scene() { + mRenderPasses = new ArrayList<RenderPass>(); + mLights = new ArrayList<LightBase>(); + mCameras = new ArrayList<Camera>(); + mFragmentShaders = new ArrayList<FragmentShader>(); + mVertexShaders = new ArrayList<VertexShader>(); + mRenderables = new ArrayList<RenderableBase>(); + mRenderableMap = new HashMap<String, RenderableBase>(); + mRenderableMeshMap = new HashMap<String, ArrayList<Renderable> >(); + mTextures = new ArrayList<Texture2D>(); + mRootTransforms = new CompoundTransform(); + mRootTransforms.setName("_scene_root_"); + mTransformMap = new HashMap<String, Transform>(); + } + + public void appendTransform(Transform t) { + if (t == null) { + throw new RuntimeException("Adding null object"); + } + mRootTransforms.appendChild(t); + } + + public CompoundTransform appendNewCompoundTransform() { + CompoundTransform t = new CompoundTransform(); + appendTransform(t); + return t; + } + + public MatrixTransform appendNewMatrixTransform() { + MatrixTransform t = new MatrixTransform(); + appendTransform(t); + return t; + } + + // temporary + public void addToTransformMap(Transform t) { + mTransformMap.put(t.getName(), t); + } + + public Transform getTransformByName(String name) { + return mTransformMap.get(name); + } + + public void appendRenderPass(RenderPass p) { + if (p == null) { + throw new RuntimeException("Adding null object"); + } + mRenderPasses.add(p); + } + + public RenderPass appendNewRenderPass() { + RenderPass p = new RenderPass(); + appendRenderPass(p); + return p; + } + + public void clearRenderPasses() { + mRenderPasses.clear(); + } + + public void appendLight(LightBase l) { + if (l == null) { + throw new RuntimeException("Adding null object"); + } + mLights.add(l); + } + + public void appendCamera(Camera c) { + if (c == null) { + throw new RuntimeException("Adding null object"); + } + mCameras.add(c); + } + + public Camera appendNewCamera() { + Camera c = new Camera(); + appendCamera(c); + return c; + } + + public void appendShader(FragmentShader f) { + if (f == null) { + throw new RuntimeException("Adding null object"); + } + mFragmentShaders.add(f); + } + + public void appendShader(VertexShader v) { + if (v == null) { + throw new RuntimeException("Adding null object"); + } + mVertexShaders.add(v); + } + + public ArrayList<Camera> getCameras() { + return mCameras; + } + + public ArrayList<LightBase> getLights() { + return mLights; + } + + public void appendRenderable(RenderableBase d) { + if (d == null) { + throw new RuntimeException("Adding null object"); + } + mRenderables.add(d); + if (d.getName() != null) { + mRenderableMap.put(d.getName(), d); + } + } + + public Renderable appendNewRenderable() { + Renderable r = new Renderable(); + appendRenderable(r); + return r; + } + + public ArrayList<RenderableBase> getRenderables() { + return mRenderables; + } + + public RenderableBase getRenderableByName(String name) { + return mRenderableMap.get(name); + } + + public void appendTextures(Texture2D tex) { + if (tex == null) { + throw new RuntimeException("Adding null object"); + } + mTextures.add(tex); + } + + public void assignRenderStateToMaterial(RenderState renderState, String regex) { + Pattern pattern = Pattern.compile(regex); + int numRenderables = mRenderables.size(); + for (int i = 0; i < numRenderables; i ++) { + Renderable shape = (Renderable)mRenderables.get(i); + Matcher m = pattern.matcher(shape.mMaterialName); + if (m.find()) { + shape.setRenderState(renderState); + } + } + } + + public void assignRenderState(RenderState renderState) { + int numRenderables = mRenderables.size(); + for (int i = 0; i < numRenderables; i ++) { + Renderable shape = (Renderable)mRenderables.get(i); + shape.setRenderState(renderState); + } + } + + public void meshLoaded(Mesh m) { + ArrayList<Renderable> entries = mRenderableMeshMap.get(m.getName()); + int numEntries = entries.size(); + for (int i = 0; i < numEntries; i++) { + Renderable d = entries.get(i); + d.resolveMeshData(m); + } + } + + void addToMeshMap(Renderable d) { + ArrayList<Renderable> entries = mRenderableMeshMap.get(d.mMeshName); + if (entries == null) { + entries = new ArrayList<Renderable>(); + mRenderableMeshMap.put(d.mMeshName, entries); + } + entries.add(d); + } + + public void destroyRS() { + SceneManager sceneManager = SceneManager.getInstance(); + mTransformRSData = null; + sceneManager.mRenderLoop.bind_gRootNode(mTransformRSData); + sceneManager.mRenderLoop.set_gRenderableObjects(null); + mRenderPassAlloc = null; + sceneManager.mRenderLoop.set_gRenderPasses(null); + sceneManager.mRenderLoop.bind_gFrontToBack(null); + sceneManager.mRenderLoop.bind_gBackToFront(null); + sceneManager.mRenderLoop.set_gCameras(null); + + mTransformMap = null; + mRenderPasses = null; + mLights = null; + mCameras = null; + mRenderables = null; + mRenderableMap = null; + mTextures = null; + mRenderableMeshMap = null; + mRootTransforms = null; + } + + public void initRenderPassRS(RenderScriptGL rs, SceneManager sceneManager) { + if (mRenderPasses.size() != 0) { + mRenderPassAlloc = new ScriptField_RenderPass_s(mRS, mRenderPasses.size()); + for (int i = 0; i < mRenderPasses.size(); i ++) { + mRenderPassAlloc.set(mRenderPasses.get(i).getRsField(mRS, mRes), i, false); + } + mRenderPassAlloc.copyAll(); + sceneManager.mRenderLoop.set_gRenderPasses(mRenderPassAlloc.getAllocation()); + } + } + + private void addDrawables(RenderScriptGL rs, Resources res, SceneManager sceneManager) { + Allocation drawableData = Allocation.createSized(rs, + Element.ALLOCATION(rs), + mRenderables.size()); + Allocation[] drawableAllocs = new Allocation[mRenderables.size()]; + for (int i = 0; i < mRenderables.size(); i ++) { + Renderable dI = (Renderable)mRenderables.get(i); + addToMeshMap(dI); + drawableAllocs[i] = dI.getRsField(rs, res).getAllocation(); + } + drawableData.copyFrom(drawableAllocs); + sceneManager.mRenderLoop.set_gRenderableObjects(drawableData); + + initRenderPassRS(rs, sceneManager); + } + + private void addShaders(RenderScriptGL rs, Resources res, SceneManager sceneManager) { + if (mVertexShaders.size() > 0) { + Allocation shaderData = Allocation.createSized(rs, Element.ALLOCATION(rs), + mVertexShaders.size()); + Allocation[] shaderAllocs = new Allocation[mVertexShaders.size()]; + for (int i = 0; i < mVertexShaders.size(); i ++) { + VertexShader sI = mVertexShaders.get(i); + shaderAllocs[i] = sI.getRSData().getAllocation(); + } + shaderData.copyFrom(shaderAllocs); + sceneManager.mRenderLoop.set_gVertexShaders(shaderData); + } + + if (mFragmentShaders.size() > 0) { + Allocation shaderData = Allocation.createSized(rs, Element.ALLOCATION(rs), + mFragmentShaders.size()); + Allocation[] shaderAllocs = new Allocation[mFragmentShaders.size()]; + for (int i = 0; i < mFragmentShaders.size(); i ++) { + FragmentShader sI = mFragmentShaders.get(i); + shaderAllocs[i] = sI.getRSData().getAllocation(); + } + shaderData.copyFrom(shaderAllocs); + sceneManager.mRenderLoop.set_gFragmentShaders(shaderData); + } + } + + public void initRS() { + SceneManager sceneManager = SceneManager.getInstance(); + mRS = SceneManager.getRS(); + mRes = SceneManager.getRes(); + long start = System.currentTimeMillis(); + mTransformRSData = mRootTransforms.getRSData(); + long end = System.currentTimeMillis(); + Log.v(TIMER_TAG, "Transform init time: " + (end - start)); + + start = System.currentTimeMillis(); + + sceneManager.mRenderLoop.bind_gRootNode(mTransformRSData); + end = System.currentTimeMillis(); + Log.v(TIMER_TAG, "Script init time: " + (end - start)); + + start = System.currentTimeMillis(); + addDrawables(mRS, mRes, sceneManager); + end = System.currentTimeMillis(); + Log.v(TIMER_TAG, "Renderable init time: " + (end - start)); + + addShaders(mRS, mRes, sceneManager); + + Allocation opaqueBuffer = null; + if (mRenderables.size() > 0) { + opaqueBuffer = Allocation.createSized(mRS, Element.U32(mRS), mRenderables.size()); + } + Allocation transparentBuffer = null; + if (mRenderables.size() > 0) { + transparentBuffer = Allocation.createSized(mRS, Element.U32(mRS), mRenderables.size()); + } + + sceneManager.mRenderLoop.bind_gFrontToBack(opaqueBuffer); + sceneManager.mRenderLoop.bind_gBackToFront(transparentBuffer); + + if (mCameras.size() > 0) { + Allocation cameraData; + cameraData = Allocation.createSized(mRS, Element.ALLOCATION(mRS), mCameras.size()); + Allocation[] cameraAllocs = new Allocation[mCameras.size()]; + for (int i = 0; i < mCameras.size(); i ++) { + cameraAllocs[i] = mCameras.get(i).getRSData().getAllocation(); + } + cameraData.copyFrom(cameraAllocs); + sceneManager.mRenderLoop.set_gCameras(cameraData); + } + + if (mLights.size() > 0) { + Allocation lightData = Allocation.createSized(mRS, + Element.ALLOCATION(mRS), + mLights.size()); + Allocation[] lightAllocs = new Allocation[mLights.size()]; + for (int i = 0; i < mLights.size(); i ++) { + lightAllocs[i] = mLights.get(i).getRSData().getAllocation(); + } + lightData.copyFrom(lightAllocs); + sceneManager.mRenderLoop.set_gLights(lightData); + } + } +} + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneGraphBase.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneGraphBase.java new file mode 100644 index 0000000..412ffbf --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneGraphBase.java @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import com.android.scenegraph.SceneManager; + +import android.renderscript.Allocation; +import android.renderscript.Element; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.RSRuntimeException; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public abstract class SceneGraphBase { + String mName; + Allocation mNameAlloc; + public void setName(String n) { + mName = n; + mNameAlloc = null; + } + + public String getName() { + return mName; + } + + Allocation getNameAlloc(RenderScriptGL rs) { + if (mNameAlloc == null) { + mNameAlloc = SceneManager.getStringAsAllocation(rs, getName()); + } + return mNameAlloc; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneManager.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneManager.java new file mode 100644 index 0000000..4ff2c8b --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/SceneManager.java @@ -0,0 +1,503 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.io.BufferedInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.Writer; +import java.lang.Math; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import com.android.scenegraph.Camera; +import com.android.scenegraph.FragmentShader; +import com.android.scenegraph.MatrixTransform; +import com.android.scenegraph.Scene; +import com.android.scenegraph.VertexShader; +import com.android.testapp.R; + +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Mesh; +import android.renderscript.RenderScriptGL; +import android.util.Log; +import android.view.SurfaceHolder; + +/** + * @hide + */ +public class SceneManager extends SceneGraphBase { + + HashMap<String, Allocation> mAllocationMap; + + ScriptC_render mRenderLoop; + ScriptC mCameraScript; + ScriptC mLightScript; + ScriptC mObjectParamsScript; + ScriptC mFragmentParamsScript; + ScriptC mVertexParamsScript; + ScriptC mCullScript; + ScriptC_transform mTransformScript; + ScriptC_export mExportScript; + + RenderScriptGL mRS; + Resources mRes; + Mesh mQuad; + int mWidth; + int mHeight; + + Scene mActiveScene; + private static SceneManager sSceneManager; + + private Allocation mDefault2D; + private Allocation mDefaultCube; + + private FragmentShader mColor; + private FragmentShader mTexture; + private VertexShader mDefaultVertex; + + private RenderState mDefaultState; + private Transform mDefaultTransform; + + private static Allocation getDefault(boolean isCube) { + final int dimension = 4; + final int bytesPerPixel = 4; + int arraySize = dimension * dimension * bytesPerPixel; + + RenderScriptGL rs = sSceneManager.mRS; + Type.Builder b = new Type.Builder(rs, Element.RGBA_8888(rs)); + b.setX(dimension).setY(dimension); + if (isCube) { + b.setFaces(true); + arraySize *= 6; + } + Type bitmapType = b.create(); + + Allocation.MipmapControl mip = Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE; + int usage = Allocation.USAGE_GRAPHICS_TEXTURE; + Allocation defaultImage = Allocation.createTyped(rs, bitmapType, mip, usage); + + byte imageData[] = new byte[arraySize]; + defaultImage.copyFrom(imageData); + return defaultImage; + } + + static Allocation getDefaultTex2D() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mDefault2D == null) { + sSceneManager.mDefault2D = getDefault(false); + } + return sSceneManager.mDefault2D; + } + + static Allocation getDefaultTexCube() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mDefaultCube == null) { + sSceneManager.mDefaultCube = getDefault(true); + } + return sSceneManager.mDefaultCube; + } + + public static boolean isSDCardPath(String path) { + int sdCardIndex = path.indexOf("sdcard/"); + // We are looking for /sdcard/ or sdcard/ + if (sdCardIndex == 0 || sdCardIndex == 1) { + return true; + } + sdCardIndex = path.indexOf("mnt/sdcard/"); + if (sdCardIndex == 0 || sdCardIndex == 1) { + return true; + } + return false; + } + + static Bitmap loadBitmap(String name, Resources res) { + InputStream is = null; + boolean loadFromSD = isSDCardPath(name); + try { + if (!loadFromSD) { + is = res.getAssets().open(name); + } else { + File f = new File(name); + is = new BufferedInputStream(new FileInputStream(f)); + } + } catch (IOException e) { + Log.e("ImageLoaderTask", " Message: " + e.getMessage()); + return null; + } + + Bitmap b = BitmapFactory.decodeStream(is); + try { + is.close(); + } catch (IOException e) { + Log.e("ImageLoaderTask", " Message: " + e.getMessage()); + } + return b; + } + + static Allocation createFromBitmap(Bitmap b, RenderScriptGL rs, boolean isCube) { + if (b == null) { + return null; + } + MipmapControl mip = MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE; + int usage = Allocation.USAGE_GRAPHICS_TEXTURE; + if (isCube) { + return Allocation.createCubemapFromBitmap(rs, b, mip, usage); + } + return Allocation.createFromBitmap(rs, b, mip, usage); + } + + public static Allocation loadCubemap(String name, RenderScriptGL rs, Resources res) { + return createFromBitmap(loadBitmap(name, res), rs, true); + } + + public static Allocation loadCubemap(int id, RenderScriptGL rs, Resources res) { + return createFromBitmap(BitmapFactory.decodeResource(res, id), rs, true); + } + + public static Allocation loadTexture2D(String name, RenderScriptGL rs, Resources res) { + return createFromBitmap(loadBitmap(name, res), rs, false); + } + + public static Allocation loadTexture2D(int id, RenderScriptGL rs, Resources res) { + return createFromBitmap(BitmapFactory.decodeResource(res, id), rs, false); + } + + public static ProgramStore BLEND_ADD_DEPTH_NONE(RenderScript rs) { + ProgramStore.Builder builder = new ProgramStore.Builder(rs); + builder.setDepthFunc(ProgramStore.DepthFunc.ALWAYS); + builder.setBlendFunc(ProgramStore.BlendSrcFunc.ONE, ProgramStore.BlendDstFunc.ONE); + builder.setDitherEnabled(false); + builder.setDepthMaskEnabled(false); + return builder.create(); + } + + static Allocation getStringAsAllocation(RenderScript rs, String str) { + if (str == null) { + return null; + } + if (str.length() == 0) { + return null; + } + byte[] allocArray = null; + byte[] nullChar = new byte[1]; + nullChar[0] = 0; + try { + allocArray = str.getBytes("UTF-8"); + Allocation alloc = Allocation.createSized(rs, Element.U8(rs), + allocArray.length + 1, + Allocation.USAGE_SCRIPT); + alloc.copy1DRangeFrom(0, allocArray.length, allocArray); + alloc.copy1DRangeFrom(allocArray.length, 1, nullChar); + return alloc; + } + catch (Exception e) { + throw new RSRuntimeException("Could not convert string to utf-8."); + } + } + + static Allocation getCachedAlloc(String str) { + if (sSceneManager == null) { + throw new RuntimeException("Scene manager not initialized"); + } + return sSceneManager.mAllocationMap.get(str); + } + + static void cacheAlloc(String str, Allocation alloc) { + if (sSceneManager == null) { + throw new RuntimeException("Scene manager not initialized"); + } + sSceneManager.mAllocationMap.put(str, alloc); + } + + public static class SceneLoadedCallback implements Runnable { + public Scene mLoadedScene; + public String mName; + public void run() { + } + } + + public Scene getActiveScene() { + return mActiveScene; + } + + public void setActiveScene(Scene s) { + mActiveScene = s; + + if (mActiveScene == null) { + return; + } + + // Do some sanity checking + if (mActiveScene.getCameras().size() == 0) { + Matrix4f camPos = new Matrix4f(); + camPos.translate(0, 0, 10); + MatrixTransform cameraTransform = new MatrixTransform(); + cameraTransform.setName("_DefaultCameraTransform"); + cameraTransform.setMatrix(camPos); + mActiveScene.appendTransform(cameraTransform); + Camera cam = new Camera(); + cam.setName("_DefaultCamera"); + cam.setTransform(cameraTransform); + mActiveScene.appendCamera(cam); + } + + mActiveScene.appendShader(getDefaultVS()); + mActiveScene.appendTransform(getDefaultTransform()); + } + + static RenderScriptGL getRS() { + if (sSceneManager == null) { + return null; + } + return sSceneManager.mRS; + } + + static Resources getRes() { + if (sSceneManager == null) { + return null; + } + return sSceneManager.mRes; + } + + // Provides the folowing inputs to fragment shader + // Assigned by default if nothing is present + // vec3 varWorldPos; + // vec3 varWorldNormal; + // vec2 varTex0; + public static VertexShader getDefaultVS() { + if (sSceneManager == null) { + return null; + } + + if (sSceneManager.mDefaultVertex == null) { + RenderScriptGL rs = getRS(); + Element.Builder b = new Element.Builder(rs); + b.add(Element.MATRIX_4X4(rs), "model"); + Type.Builder objConstBuilder = new Type.Builder(rs, b.create()); + + b = new Element.Builder(rs); + b.add(Element.MATRIX_4X4(rs), "viewProj"); + Type.Builder shaderConstBuilder = new Type.Builder(rs, b.create()); + + b = new Element.Builder(rs); + b.add(Element.F32_4(rs), "position"); + b.add(Element.F32_2(rs), "texture0"); + b.add(Element.F32_3(rs), "normal"); + Element defaultIn = b.create(); + + final String code = "\n" + + "varying vec3 varWorldPos;\n" + + "varying vec3 varWorldNormal;\n" + + "varying vec2 varTex0;\n" + + "void main() {" + + " vec4 objPos = ATTRIB_position;\n" + + " vec4 worldPos = UNI_model * objPos;\n" + + " gl_Position = UNI_viewProj * worldPos;\n" + + " mat3 model3 = mat3(UNI_model[0].xyz, UNI_model[1].xyz, UNI_model[2].xyz);\n" + + " vec3 worldNorm = model3 * ATTRIB_normal;\n" + + " varWorldPos = worldPos.xyz;\n" + + " varWorldNormal = worldNorm;\n" + + " varTex0 = ATTRIB_texture0;\n" + + "}\n"; + + VertexShader.Builder sb = new VertexShader.Builder(rs); + sb.addInput(defaultIn); + sb.setObjectConst(objConstBuilder.setX(1).create()); + sb.setShaderConst(shaderConstBuilder.setX(1).create()); + sb.setShader(code); + sSceneManager.mDefaultVertex = sb.create(); + } + + return sSceneManager.mDefaultVertex; + } + + public static FragmentShader getColorFS() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mColor == null) { + RenderScriptGL rs = getRS(); + Element.Builder b = new Element.Builder(rs); + b.add(Element.F32_4(rs), "color"); + Type.Builder objConstBuilder = new Type.Builder(rs, b.create()); + + final String code = "\n" + + "varying vec2 varTex0;\n" + + "void main() {\n" + + " lowp vec4 col = UNI_color;\n" + + " gl_FragColor = col;\n" + + "}\n"; + FragmentShader.Builder fb = new FragmentShader.Builder(rs); + fb.setShader(code); + fb.setObjectConst(objConstBuilder.create()); + sSceneManager.mColor = fb.create(); + } + + return sSceneManager.mColor; + } + + public static FragmentShader getTextureFS() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mTexture == null) { + RenderScriptGL rs = getRS(); + + final String code = "\n" + + "varying vec2 varTex0;\n" + + "void main() {\n" + + " lowp vec4 col = texture2D(UNI_color, varTex0).rgba;\n" + + " gl_FragColor = col;\n" + + "}\n"; + + FragmentShader.Builder fb = new FragmentShader.Builder(rs); + fb.setShader(code); + fb.addTexture(Program.TextureType.TEXTURE_2D, "color"); + sSceneManager.mTexture = fb.create(); + sSceneManager.mTexture.mProgram.bindSampler(Sampler.CLAMP_LINEAR_MIP_LINEAR(rs), 0); + } + + return sSceneManager.mTexture; + } + + static RenderState getDefaultState() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mDefaultState == null) { + sSceneManager.mDefaultState = new RenderState(getDefaultVS(), getColorFS(), null, null); + sSceneManager.mDefaultState.setName("__DefaultState"); + } + return sSceneManager.mDefaultState; + } + + static Transform getDefaultTransform() { + if (sSceneManager == null) { + return null; + } + if (sSceneManager.mDefaultTransform == null) { + sSceneManager.mDefaultTransform = new MatrixTransform(); + sSceneManager.mDefaultTransform.setName("__DefaultTransform"); + } + return sSceneManager.mDefaultTransform; + } + + public static SceneManager getInstance() { + if (sSceneManager == null) { + sSceneManager = new SceneManager(); + } + return sSceneManager; + } + + protected SceneManager() { + } + + public void loadModel(String name, SceneLoadedCallback cb) { + ColladaScene scene = new ColladaScene(name, cb); + scene.init(mRS, mRes); + } + + public Mesh getScreenAlignedQuad() { + if (mQuad != null) { + return mQuad; + } + + Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, + 3, Mesh.TriangleMeshBuilder.TEXTURE_0); + + tmb.setTexture(0.0f, 1.0f).addVertex(-1.0f, 1.0f, 1.0f); + tmb.setTexture(0.0f, 0.0f).addVertex(-1.0f, -1.0f, 1.0f); + tmb.setTexture(1.0f, 0.0f).addVertex(1.0f, -1.0f, 1.0f); + tmb.setTexture(1.0f, 1.0f).addVertex(1.0f, 1.0f, 1.0f); + + tmb.addTriangle(0, 1, 2); + tmb.addTriangle(2, 3, 0); + + mQuad = tmb.create(true); + return mQuad; + } + + public Renderable getRenderableQuad(String name, RenderState state) { + Renderable quad = new Renderable(); + quad.setTransform(new MatrixTransform()); + quad.setMesh(getScreenAlignedQuad()); + quad.setName(name); + quad.setRenderState(state); + quad.setCullType(1); + return quad; + } + + public void initRS(RenderScriptGL rs, Resources res, int w, int h) { + mRS = rs; + mRes = res; + mAllocationMap = new HashMap<String, Allocation>(); + + mQuad = null; + mDefault2D = null; + mDefaultCube = null; + mDefaultVertex = null; + mColor = null; + mTexture = null; + mDefaultState = null; + mDefaultTransform = null; + + mExportScript = new ScriptC_export(rs, res, R.raw.export); + + mTransformScript = new ScriptC_transform(rs, res, R.raw.transform); + mTransformScript.set_gTransformScript(mTransformScript); + + mCameraScript = new ScriptC_camera(rs, res, R.raw.camera); + mLightScript = new ScriptC_light(rs, res, R.raw.light); + mObjectParamsScript = new ScriptC_object_params(rs, res, R.raw.object_params); + mFragmentParamsScript = new ScriptC_object_params(rs, res, R.raw.fragment_params); + mVertexParamsScript = new ScriptC_object_params(rs, res, R.raw.vertex_params); + mCullScript = new ScriptC_cull(rs, res, R.raw.cull); + + mRenderLoop = new ScriptC_render(rs, res, R.raw.render); + mRenderLoop.set_gTransformScript(mTransformScript); + mRenderLoop.set_gCameraScript(mCameraScript); + mRenderLoop.set_gLightScript(mLightScript); + mRenderLoop.set_gObjectParamsScript(mObjectParamsScript); + mRenderLoop.set_gFragmentParamsScript(mFragmentParamsScript); + mRenderLoop.set_gVertexParamsScript(mVertexParamsScript); + mRenderLoop.set_gCullScript(mCullScript); + + mRenderLoop.set_gPFSBackground(ProgramStore.BLEND_NONE_DEPTH_TEST(mRS)); + } + + public ScriptC getRenderLoop() { + return mRenderLoop; + } +} + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Shader.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Shader.java new file mode 100644 index 0000000..4975114 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Shader.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; +import java.util.HashMap; + +import com.android.scenegraph.SceneGraphBase; +import com.android.scenegraph.ShaderParam; + +import android.renderscript.*; +import android.renderscript.ProgramFragment.Builder; +import android.util.Log; + +/** + * @hide + */ +public abstract class Shader extends SceneGraphBase { + protected Type mPerObjConstants; + protected Type mPerShaderConstants; + + protected HashMap<String, ShaderParam> mSourceParams; + protected ArrayList<String> mShaderTextureNames; + protected ArrayList<Program.TextureType > mShaderTextureTypes; + protected ArrayList<String> mTextureNames; + protected ArrayList<Program.TextureType > mTextureTypes; + + protected Allocation mConstantBuffer; + protected ScriptField_ShaderParam_s mConstantBufferParams; + + public Shader() { + mSourceParams = new HashMap<String, ShaderParam>(); + mShaderTextureNames = new ArrayList<String>(); + mShaderTextureTypes = new ArrayList<Program.TextureType>(); + mTextureNames = new ArrayList<String>(); + mTextureTypes = new ArrayList<Program.TextureType>(); + } + + public void appendSourceParams(ShaderParam p) { + mSourceParams.put(p.getParamName(), p); + } + + public Type getObjectConstants() { + return mPerObjConstants; + } + + public Type getShaderConstants() { + return mPerObjConstants; + } + + void linkConstants(RenderScriptGL rs) { + if (mPerShaderConstants == null) { + return; + } + + Element constElem = mPerShaderConstants.getElement(); + mConstantBufferParams = ShaderParam.fillInParams(constElem, mSourceParams, null); + + mConstantBuffer = Allocation.createTyped(rs, mPerShaderConstants); + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ShaderParam.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ShaderParam.java new file mode 100644 index 0000000..3dd41ca --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/ShaderParam.java @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; +import java.util.HashMap; + +import com.android.scenegraph.SceneManager; +import com.android.scenegraph.Transform; + +import android.renderscript.Element; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.RenderScriptGL; +import android.util.Log; + +/** + * @hide + */ +public abstract class ShaderParam extends SceneGraphBase { + + static final String cameraPos = "cameraPos"; + static final String cameraDir = "cameraDir"; + + static final String lightColor = "lightColor"; + static final String lightPos = "lightPos"; + static final String lightDir = "lightDir"; + + static final String view = "view"; + static final String proj = "proj"; + static final String viewProj = "viewProj"; + static final String model = "model"; + static final String modelView = "modelView"; + static final String modelViewProj = "modelViewProj"; + + static final long sMaxTimeStamp = 0xffffffffL; + + ScriptField_ShaderParamData_s.Item mData; + ScriptField_ShaderParamData_s mField; + + String mParamName; + Camera mCamera; + + static ScriptField_ShaderParam_s fillInParams(Element constantElem, + HashMap<String, ShaderParam> sourceParams, + Transform transform) { + RenderScriptGL rs = SceneManager.getRS(); + ArrayList<ScriptField_ShaderParam_s.Item> paramList; + paramList = new ArrayList<ScriptField_ShaderParam_s.Item>(); + + int subElemCount = constantElem.getSubElementCount(); + for (int i = 0; i < subElemCount; i ++) { + String inputName = constantElem.getSubElementName(i); + int offset = constantElem.getSubElementOffsetBytes(i); + + ShaderParam matchingParam = sourceParams.get(inputName); + Element subElem = constantElem.getSubElement(i); + // Make one if it's not there + if (matchingParam == null) { + if (subElem.getDataType() == Element.DataType.FLOAT_32) { + matchingParam = new Float4Param(inputName, 0.5f, 0.5f, 0.5f, 0.5f); + } else if (subElem.getDataType() == Element.DataType.MATRIX_4X4) { + TransformParam trParam = new TransformParam(inputName); + trParam.setTransform(transform); + matchingParam = trParam; + } + } + ScriptField_ShaderParam_s.Item paramRS = new ScriptField_ShaderParam_s.Item(); + paramRS.bufferOffset = offset; + paramRS.transformTimestamp = 0; + paramRS.dataTimestamp = 0; + paramRS.data = matchingParam.getRSData().getAllocation(); + if (subElem.getDataType() == Element.DataType.FLOAT_32) { + paramRS.float_vecSize = subElem.getVectorSize(); + } + + paramList.add(paramRS); + } + + ScriptField_ShaderParam_s rsParams = null; + int paramCount = paramList.size(); + if (paramCount != 0) { + rsParams = new ScriptField_ShaderParam_s(rs, paramCount); + for (int i = 0; i < paramCount; i++) { + rsParams.set(paramList.get(i), i, false); + } + rsParams.copyAll(); + } + return rsParams; + } + + public ShaderParam(String name) { + mParamName = name; + mData = new ScriptField_ShaderParamData_s.Item(); + } + + public String getParamName() { + return mParamName; + } + + public void setCamera(Camera c) { + mCamera = c; + if (mField != null) { + mData.camera = mCamera.getRSData().getAllocation(); + mField.set_camera(0, mData.camera, true); + } + } + + protected void incTimestamp() { + if (mField != null) { + mData.timestamp ++; + mData.timestamp %= sMaxTimeStamp; + mField.set_timestamp(0, mData.timestamp, true); + } + } + + abstract void initLocalData(); + + public ScriptField_ShaderParamData_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + mField = new ScriptField_ShaderParamData_s(rs, 1); + + if (mParamName != null) { + mData.paramName = SceneManager.getCachedAlloc(mParamName); + if (mData.paramName == null) { + mData.paramName = SceneManager.getStringAsAllocation(rs, mParamName); + SceneManager.cacheAlloc(mParamName, mData.paramName); + } + } + initLocalData(); + mData.timestamp = 1; + + mField.set(mData, 0, true); + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Texture2D.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Texture2D.java new file mode 100644 index 0000000..b53ab88 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Texture2D.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; + +import com.android.scenegraph.SceneManager; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +/** + * @hide + */ +public class Texture2D extends TextureBase { + String mFileName; + String mFileDir; + int mResourceID; + + public Texture2D() { + super(ScriptC_export.const_TextureType_TEXTURE_2D); + } + + public Texture2D(Allocation tex) { + super(ScriptC_export.const_TextureType_TEXTURE_2D); + setTexture(tex); + } + + public Texture2D(String dir, String file) { + super(ScriptC_export.const_TextureType_TEXTURE_CUBE); + setFileDir(dir); + setFileName(file); + } + + public Texture2D(int resourceID) { + super(ScriptC_export.const_TextureType_TEXTURE_2D); + mResourceID = resourceID; + } + + public void setFileDir(String dir) { + mFileDir = dir; + } + + public void setFileName(String file) { + mFileName = file; + } + + public String getFileName() { + return mFileName; + } + + public void setTexture(Allocation tex) { + mData.texture = tex != null ? tex : SceneManager.getDefaultTex2D(); + if (mField != null) { + mField.set_texture(0, mData.texture, true); + } + } + + void load() { + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (mFileName != null && mFileName.length() > 0) { + String shortName = mFileName.substring(mFileName.lastIndexOf('/') + 1); + setTexture(SceneManager.loadTexture2D(mFileDir + shortName, rs, res)); + } else if (mResourceID != 0) { + setTexture(SceneManager.loadTexture2D(mResourceID, rs, res)); + } + } + + ScriptField_Texture_s getRsData(boolean loadNow) { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (rs == null || res == null) { + return null; + } + + mField = new ScriptField_Texture_s(rs, 1); + + if (loadNow) { + load(); + } else { + mData.texture = SceneManager.getDefaultTex2D(); + new SingleImageLoaderTask().execute(this); + } + + mField.set(mData, 0, true); + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureBase.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureBase.java new file mode 100644 index 0000000..ba49d4e --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureBase.java @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; + +import com.android.scenegraph.SceneManager; +import android.os.AsyncTask; +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +/** + * @hide + */ +public abstract class TextureBase extends SceneGraphBase { + + class SingleImageLoaderTask extends AsyncTask<TextureBase, Void, Boolean> { + protected Boolean doInBackground(TextureBase... objects) { + TextureBase tex = objects[0]; + tex.load(); + return new Boolean(true); + } + protected void onPostExecute(Boolean result) { + } + } + + ScriptField_Texture_s.Item mData; + ScriptField_Texture_s mField; + TextureBase(int type) { + mData = new ScriptField_Texture_s.Item(); + mData.type = type; + } + + protected Allocation mRsTexture; + abstract ScriptField_Texture_s getRsData(boolean loadNow); + abstract void load(); +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureCube.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureCube.java new file mode 100644 index 0000000..1269e3c --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureCube.java @@ -0,0 +1,114 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; + +import com.android.scenegraph.SceneManager; +import com.android.scenegraph.TextureBase; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +/** + * @hide + */ +public class TextureCube extends TextureBase { + String mFileName; + String mFileDir; + int mResourceID; + + public TextureCube() { + super(ScriptC_export.const_TextureType_TEXTURE_CUBE); + } + + public TextureCube(Allocation tex) { + super(ScriptC_export.const_TextureType_TEXTURE_CUBE); + setTexture(tex); + } + + public TextureCube(String dir, String file) { + super(ScriptC_export.const_TextureType_TEXTURE_CUBE); + setFileDir(dir); + setFileName(file); + } + + public TextureCube(int resourceID) { + super(ScriptC_export.const_TextureType_TEXTURE_2D); + mResourceID = resourceID; + } + + public void setFileDir(String dir) { + mFileDir = dir; + } + + public void setFileName(String file) { + mFileName = file; + } + + public String getFileName() { + return mFileName; + } + + public void setTexture(Allocation tex) { + mData.texture = tex != null ? tex : SceneManager.getDefaultTexCube(); + if (mField != null) { + mField.set_texture(0, mData.texture, true); + } + } + + void load() { + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (mFileName != null && mFileName.length() > 0) { + String shortName = mFileName.substring(mFileName.lastIndexOf('/') + 1); + setTexture(SceneManager.loadCubemap(mFileDir + shortName, rs, res)); + } else if (mResourceID != 0) { + setTexture(SceneManager.loadCubemap(mResourceID , rs, res)); + } + } + + ScriptField_Texture_s getRsData(boolean loadNow) { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (rs == null || res == null) { + return null; + } + + mField = new ScriptField_Texture_s(rs, 1); + + if (loadNow) { + load(); + } else { + mData.texture = SceneManager.getDefaultTexCube(); + new SingleImageLoaderTask().execute(this); + } + + mField.set(mData, 0, true); + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureParam.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureParam.java new file mode 100644 index 0000000..e656ed2 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureParam.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.graphics.Camera; +import android.renderscript.RenderScriptGL; +import android.renderscript.Float4; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.Element; +import android.util.Log; + +/** + * @hide + */ +public class TextureParam extends ShaderParam { + + TextureBase mTexture; + + public TextureParam(String name) { + super(name); + } + + public TextureParam(String name, TextureBase t) { + super(name); + setTexture(t); + } + + public void setTexture(TextureBase t) { + mTexture = t; + } + + public TextureBase getTexture() { + return mTexture; + } + + void initLocalData() { + mData.type = ScriptC_export.const_ShaderParam_TEXTURE; + if (mTexture != null) { + mData.texture = mTexture.getRsData(false).getAllocation(); + } + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureRenderTarget.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureRenderTarget.java new file mode 100644 index 0000000..6aa29a5 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TextureRenderTarget.java @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; + +import com.android.scenegraph.SceneManager; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +/** + * @hide + */ +public class TextureRenderTarget extends TextureBase { + public TextureRenderTarget() { + super(ScriptC_export.const_TextureType_TEXTURE_RENDER_TARGET); + } + + public TextureRenderTarget(Allocation tex) { + super(ScriptC_export.const_TextureType_TEXTURE_RENDER_TARGET); + setTexture(tex); + } + + public void setTexture(Allocation tex) { + mData.texture = tex; + if (mField != null) { + mField.set_texture(0, mData.texture, true); + } + } + + void load() { + } + + ScriptField_Texture_s getRsData(boolean loadNow) { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + if (rs == null) { + return null; + } + + mField = new ScriptField_Texture_s(rs, 1); + mField.set(mData, 0, true); + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Transform.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Transform.java new file mode 100644 index 0000000..8180bd0 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/Transform.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.*; +import android.renderscript.Matrix4f; +import android.util.Log; + +/** + * @hide + */ +public abstract class Transform extends SceneGraphBase { + Transform mParent; + ArrayList<Transform> mChildren; + + ScriptField_SgTransform mField; + ScriptField_SgTransform.Item mTransformData; + + public Transform() { + mChildren = new ArrayList<Transform>(); + mParent = null; + } + + public void appendChild(Transform t) { + mChildren.add(t); + t.mParent = this; + updateRSChildData(true); + } + + abstract void initLocalData(); + + void updateRSChildData(boolean copyData) { + if (mField == null) { + return; + } + RenderScriptGL rs = SceneManager.getRS(); + if (mChildren.size() != 0) { + Allocation childRSData = Allocation.createSized(rs, Element.ALLOCATION(rs), + mChildren.size()); + mTransformData.children = childRSData; + + Allocation[] childrenAllocs = new Allocation[mChildren.size()]; + for (int i = 0; i < mChildren.size(); i ++) { + Transform child = mChildren.get(i); + childrenAllocs[i] = child.getRSData().getAllocation(); + } + childRSData.copyFrom(childrenAllocs); + } + if (copyData) { + mField.set(mTransformData, 0, true); + } + } + + ScriptField_SgTransform getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + if (rs == null) { + return null; + } + mField = new ScriptField_SgTransform(rs, 1); + + mTransformData = new ScriptField_SgTransform.Item(); + mTransformData.name = getNameAlloc(rs); + mTransformData.isDirty = 1; + mTransformData.timestamp = 1; + + initLocalData(); + updateRSChildData(false); + + mField.set(mTransformData, 0, true); + return mField; + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TransformParam.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TransformParam.java new file mode 100644 index 0000000..d120d5d --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/TransformParam.java @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.renderscript.RenderScriptGL; +import android.renderscript.Matrix4f; +import android.renderscript.ProgramFragment; +import android.renderscript.ProgramStore; +import android.renderscript.ProgramVertex; +import android.renderscript.Element; +import android.util.Log; + +/** + * @hide + */ +public class TransformParam extends ShaderParam { + + Transform mTransform; + LightBase mLight; + + public TransformParam(String name) { + super(name); + } + + public void setTransform(Transform t) { + mTransform = t; + if (mField != null && mTransform != null) { + mData.transform = mTransform.getRSData().getAllocation(); + } + incTimestamp(); + } + + int getTypeFromName() { + int paramType = ScriptC_export.const_ShaderParam_TRANSFORM_DATA; + if (mParamName.equalsIgnoreCase(view)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_VIEW; + } else if(mParamName.equalsIgnoreCase(proj)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_PROJ; + } else if(mParamName.equalsIgnoreCase(viewProj)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_VIEW_PROJ; + } else if(mParamName.equalsIgnoreCase(model)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_MODEL; + } else if(mParamName.equalsIgnoreCase(modelView)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_MODEL_VIEW; + } else if(mParamName.equalsIgnoreCase(modelViewProj)) { + paramType = ScriptC_export.const_ShaderParam_TRANSFORM_MODEL_VIEW_PROJ; + } + return paramType; + } + + void initLocalData() { + mData.type = getTypeFromName(); + if (mTransform != null) { + mData.transform = mTransform.getRSData().getAllocation(); + } + if (mCamera != null) { + mData.camera = mCamera.getRSData().getAllocation(); + } + if (mLight != null) { + mData.light = mLight.getRSData().getAllocation(); + } + } +} + + + + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/VertexShader.java b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/VertexShader.java new file mode 100644 index 0000000..4efaff7 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/VertexShader.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.scenegraph; + +import java.lang.Math; +import java.util.ArrayList; + +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; + +/** + * @hide + */ +public class VertexShader extends Shader { + ProgramVertex mProgram; + ScriptField_VertexShader_s mField; + + public static class Builder { + VertexShader mShader; + ProgramVertex.Builder mBuilder; + + public Builder(RenderScriptGL rs) { + mShader = new VertexShader(); + mBuilder = new ProgramVertex.Builder(rs); + } + + public Builder setShader(Resources resources, int resourceID) { + mBuilder.setShader(resources, resourceID); + return this; + } + + public Builder setShader(String code) { + mBuilder.setShader(code); + return this; + } + + public Builder setObjectConst(Type type) { + mShader.mPerObjConstants = type; + return this; + } + + public Builder setShaderConst(Type type) { + mShader.mPerShaderConstants = type; + return this; + } + + public Builder addInput(Element e) { + mBuilder.addInput(e); + return this; + } + + public VertexShader create() { + if (mShader.mPerShaderConstants != null) { + mBuilder.addConstant(mShader.mPerShaderConstants); + } + if (mShader.mPerObjConstants != null) { + mBuilder.addConstant(mShader.mPerObjConstants); + } + mShader.mProgram = mBuilder.create(); + return mShader; + } + } + + public ProgramVertex getProgram() { + return mProgram; + } + + ScriptField_VertexShader_s getRSData() { + if (mField != null) { + return mField; + } + + RenderScriptGL rs = SceneManager.getRS(); + Resources res = SceneManager.getRes(); + if (rs == null || res == null) { + return null; + } + + ScriptField_VertexShader_s.Item item = new ScriptField_VertexShader_s.Item(); + item.program = mProgram; + + linkConstants(rs); + if (mPerShaderConstants != null) { + item.shaderConst = mConstantBuffer; + item.shaderConstParams = mConstantBufferParams.getAllocation(); + mProgram.bindConstants(item.shaderConst, 0); + } + + item.objectConstIndex = -1; + if (mPerObjConstants != null) { + item.objectConstIndex = mPerShaderConstants != null ? 1 : 0; + } + + mField = new ScriptField_VertexShader_s(rs, 1); + mField.set(item, 0, true); + return mField; + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/camera.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/camera.rs new file mode 100644 index 0000000..dc0a885 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/camera.rs @@ -0,0 +1,66 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +//#define DEBUG_CAMERA +#include "scenegraph_objects.rsh" + +void root(const rs_allocation *v_in, rs_allocation *v_out, const float *usrData) { + + SgCamera *cam = (SgCamera *)rsGetElementAt(*v_in, 0); + float aspect = *usrData; + if (cam->aspect != aspect) { + cam->isDirty = 1; + cam->aspect = aspect; + } + if (cam->isDirty) { + rsMatrixLoadPerspective(&cam->proj, cam->horizontalFOV, cam->aspect, cam->near, cam->far); + } + + const SgTransform *camTransform = (const SgTransform *)rsGetElementAt(cam->transformMatrix, 0); + //rsDebug("Camera stamp", cam->transformTimestamp); + //rsDebug("Transform stamp", camTransform->timestamp); + if (camTransform->timestamp != cam->transformTimestamp || cam->isDirty) { + cam->isDirty = 1; + rs_matrix4x4 camPosMatrix; + rsMatrixLoad(&camPosMatrix, &camTransform->globalMat); + float4 zero = {0.0f, 0.0f, 0.0f, 1.0f}; + cam->position = rsMatrixMultiply(&camPosMatrix, zero); + + rsMatrixInverse(&camPosMatrix); + rsMatrixLoad(&cam->view, &camPosMatrix); + + rsMatrixLoad(&cam->viewProj, &cam->proj); + rsMatrixMultiply(&cam->viewProj, &cam->view); + + rsExtractFrustumPlanes(&cam->viewProj, + &cam->frustumPlanes[0], &cam->frustumPlanes[1], + &cam->frustumPlanes[2], &cam->frustumPlanes[3], + &cam->frustumPlanes[3], &cam->frustumPlanes[4]); + } + + if (cam->isDirty) { + cam->timestamp ++; + } + + cam->isDirty = 0; + cam->transformTimestamp = camTransform->timestamp; + +#ifdef DEBUG_CAMERA + printCameraInfo(cam); +#endif //DEBUG_CAMERA +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/cull.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/cull.rs new file mode 100644 index 0000000..024e026 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/cull.rs @@ -0,0 +1,86 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "scenegraph_objects.rsh" + +static void getTransformedSphere(SgRenderable *obj) { + obj->worldBoundingSphere = obj->boundingSphere; + obj->worldBoundingSphere.w = 1.0f; + const SgTransform *objTransform = (const SgTransform *)rsGetElementAt(obj->transformMatrix, 0); + obj->worldBoundingSphere = rsMatrixMultiply(&objTransform->globalMat, obj->worldBoundingSphere); + + const float4 unitVec = {0.57735f, 0.57735f, 0.57735f, 0.0f}; + float4 scaledVec = rsMatrixMultiply(&objTransform->globalMat, unitVec); + scaledVec.w = 0.0f; + obj->worldBoundingSphere.w = obj->boundingSphere.w * length(scaledVec); +} + +static bool frustumCulled(SgRenderable *obj, SgCamera *cam) { + if (!obj->bVolInitialized) { + float minX, minY, minZ, maxX, maxY, maxZ; + rsgMeshComputeBoundingBox(obj->mesh, + &minX, &minY, &minZ, + &maxX, &maxY, &maxZ); + //rsDebug("min", minX, minY, minZ); + //rsDebug("max", maxX, maxY, maxZ); + float4 sphere; + sphere.x = (maxX + minX) * 0.5f; + sphere.y = (maxY + minY) * 0.5f; + sphere.z = (maxZ + minZ) * 0.5f; + float3 radius; + radius.x = (maxX - sphere.x); + radius.y = (maxY - sphere.y); + radius.z = (maxZ - sphere.z); + + sphere.w = length(radius); + obj->boundingSphere = sphere; + obj->bVolInitialized = 1; + //rsDebug("Sphere", sphere); + } + + getTransformedSphere(obj); + + return !rsIsSphereInFrustum(&obj->worldBoundingSphere, + &cam->frustumPlanes[0], &cam->frustumPlanes[1], + &cam->frustumPlanes[2], &cam->frustumPlanes[3], + &cam->frustumPlanes[4], &cam->frustumPlanes[5]); +} + + +void root(rs_allocation *v_out, const void *usrData) { + + SgRenderable *drawable = (SgRenderable *)rsGetElementAt(*v_out, 0); + const SgCamera *camera = (const SgCamera*)usrData; + + drawable->isVisible = 0; + // Not loaded yet + if (!rsIsObject(drawable->mesh) || drawable->cullType == CULL_ALWAYS) { + return; + } + + // check to see if we are culling this object and if it's + // outside the frustum + if (drawable->cullType == CULL_FRUSTUM && frustumCulled(drawable, (SgCamera*)camera)) { +#ifdef DEBUG_RENDERABLES + rsDebug("Culled", drawable); + printName(drawable->name); +#endif // DEBUG_RENDERABLES + return; + } + drawable->isVisible = 1; +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/export.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/export.rs new file mode 100644 index 0000000..b438a43 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/export.rs @@ -0,0 +1,61 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +// The sole purpose of this script is to have various structs exposed +// so that java reflected classes are generated +#include "scenegraph_objects.rsh" + +// Export our native constants to java so that we don't have parallel definitions +const int ShaderParam_FLOAT4_DATA = SHADER_PARAM_FLOAT4_DATA; +const int ShaderParam_TRANSFORM_DATA = SHADER_PARAM_TRANSFORM_DATA; +const int ShaderParam_TRANSFORM_MODEL = SHADER_PARAM_TRANSFORM_MODEL; + +const int ShaderParam_FLOAT4_CAMERA_POS = SHADER_PARAM_FLOAT4_CAMERA_POS; +const int ShaderParam_FLOAT4_CAMERA_DIR = SHADER_PARAM_FLOAT4_CAMERA_DIR; +const int ShaderParam_TRANSFORM_VIEW = SHADER_PARAM_TRANSFORM_VIEW; +const int ShaderParam_TRANSFORM_PROJ = SHADER_PARAM_TRANSFORM_PROJ; +const int ShaderParam_TRANSFORM_VIEW_PROJ = SHADER_PARAM_TRANSFORM_VIEW_PROJ; +const int ShaderParam_TRANSFORM_MODEL_VIEW = SHADER_PARAM_TRANSFORM_MODEL_VIEW; +const int ShaderParam_TRANSFORM_MODEL_VIEW_PROJ = SHADER_PARAM_TRANSFORM_MODEL_VIEW_PROJ; + +const int ShaderParam_FLOAT4_LIGHT_COLOR = SHADER_PARAM_FLOAT4_LIGHT_COLOR; +const int ShaderParam_FLOAT4_LIGHT_POS = SHADER_PARAM_FLOAT4_LIGHT_POS; +const int ShaderParam_FLOAT4_LIGHT_DIR = SHADER_PARAM_FLOAT4_LIGHT_DIR; + +const int ShaderParam_TEXTURE = SHADER_PARAM_TEXTURE; + +const int Transform_TRANSLATE = TRANSFORM_TRANSLATE; +const int Transform_ROTATE = TRANSFORM_ROTATE; +const int Transform_SCALE = TRANSFORM_SCALE; + +const int TextureType_TEXTURE_2D = TEXTURE_2D; +const int TextureType_TEXTURE_CUBE = TEXTURE_CUBE; +const int TextureType_TEXTURE_RENDER_TARGET = TEXTURE_RENDER_TARGET; + +SgTransform *exportPtr; +SgTransformComponent *componentPtr; +SgRenderState *sExport; +SgRenderable *drExport; +SgRenderPass *pExport; +SgCamera *exportPtrCam; +SgLight *exportPtrLight; +SgShaderParam *spExport; +SgShaderParamData *spDataExport; +SgVertexShader *pvExport; +SgFragmentShader *pfExport; +SgTexture *texExport; diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/fragment_params.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/fragment_params.rs new file mode 100644 index 0000000..7202285 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/fragment_params.rs @@ -0,0 +1,30 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "scenegraph_objects.rsh" + +//#define DEBUG_PARAMS + +#include "params.rsh" + +void root(rs_allocation *v_out, const void *usrData) { + SgFragmentShader *shader = (SgFragmentShader *)rsGetElementAt(*v_out, 0); + const SgCamera *camera = (const SgCamera*)usrData; + processAllParams(shader->shaderConst, shader->shaderConstParams, camera); + processTextureParams(shader); +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/light.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/light.rs new file mode 100644 index 0000000..e11979f --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/light.rs @@ -0,0 +1,33 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +//#define DEBUG_LIGHT +#include "scenegraph_objects.rsh" + +void root(const rs_allocation *v_in, rs_allocation *v_out) { + + SgLight *light = (SgLight *)rsGetElementAt(*v_in, 0); + const SgTransform *lTransform = (const SgTransform *)rsGetElementAt(light->transformMatrix, 0); + + float4 zero = {0.0f, 0.0f, 0.0f, 1.0f}; + light->position = rsMatrixMultiply(&lTransform->globalMat, zero); + +#ifdef DEBUG_LIGHT + printLightInfo(light); +#endif //DEBUG_LIGHT +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/object_params.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/object_params.rs new file mode 100644 index 0000000..0d524a6 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/object_params.rs @@ -0,0 +1,36 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "scenegraph_objects.rsh" + +//#define DEBUG_PARAMS + +#include "params.rsh" + +void root(rs_allocation *v_out, const void *usrData) { + + SgRenderable *drawable = (SgRenderable *)rsGetElementAt(*v_out, 0); + // Visibility flag was set earlier in the cull stage + if (!drawable->isVisible) { + return; + } + + const SgCamera *camera = (const SgCamera*)usrData; + processAllParams(drawable->pf_const, drawable->pf_constParams, camera); + processAllParams(drawable->pv_const, drawable->pv_constParams, camera); +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/params.rsh b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/params.rsh new file mode 100644 index 0000000..575794b --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/params.rsh @@ -0,0 +1,193 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "scenegraph_objects.rsh" + +//#define DEBUG_PARAMS +static void debugParam(SgShaderParam *p, SgShaderParamData *pData) { + rsDebug("____________ Param ____________", p); + printName(pData->paramName); + rsDebug("bufferOffset", p->bufferOffset); + rsDebug("type ", pData->type); + rsDebug("data timestamp ", pData->timestamp); + rsDebug("param timestamp", p->dataTimestamp); + + const SgTransform *pTransform = NULL; + if (rsIsObject(pData->transform)) { + pTransform = (const SgTransform *)rsGetElementAt(pData->transform, 0); + + rsDebug("transform", pTransform); + printName(pTransform->name); + rsDebug("timestamp", pTransform->timestamp); + rsDebug("param timestamp", p->transformTimestamp); + } + + const SgLight *pLight = NULL; + if (rsIsObject(pData->light)) { + pLight = (const SgLight *)rsGetElementAt(pData->light, 0); + printLightInfo(pLight); + } +} + + +static void writeFloatData(float *ptr, const float4 *input, uint32_t vecSize) { +#ifdef DEBUG_PARAMS + rsDebug("Writing value ", *input); + rsDebug("Writing vec size ", vecSize); +#endif // DEBUG_PARAMS + + switch (vecSize) { + case 1: + *ptr = input->x; + break; + case 2: + *((float2*)ptr) = (*input).xy; + break; + case 3: + *((float3*)ptr) = (*input).xyz; + break; + case 4: + *((float4*)ptr) = *input; + break; + } +} + +static bool processParam(SgShaderParam *p, SgShaderParamData *pData, + uint8_t *constantBuffer, + const SgCamera *currentCam, + SgFragmentShader *shader) { + bool isDataOnly = (pData->type > SHADER_PARAM_DATA_ONLY); + const SgTransform *pTransform = NULL; + if (rsIsObject(pData->transform)) { + pTransform = (const SgTransform *)rsGetElementAt(pData->transform, 0); + } + + if (isDataOnly) { + // If we are a transform param and our transform is unchanged, nothing to do + if (pTransform) { + if (p->transformTimestamp == pTransform->timestamp) { + return false; + } + p->transformTimestamp = pTransform->timestamp; + } else { + if (p->dataTimestamp == pData->timestamp) { + return false; + } + p->dataTimestamp = pData->timestamp; + } + } + + const SgLight *pLight = NULL; + if (rsIsObject(pData->light)) { + pLight = (const SgLight *)rsGetElementAt(pData->light, 0); + } + + uint8_t *dataPtr = NULL; + const SgTexture *tex = NULL; + if (pData->type == SHADER_PARAM_TEXTURE) { + tex = rsGetElementAt(pData->texture, 0); + } else { + dataPtr = constantBuffer + p->bufferOffset; + } + + switch (pData->type) { + case SHADER_PARAM_TEXTURE: + rsgBindTexture(shader->program, p->bufferOffset, tex->texture); + break; + case SHADER_PARAM_FLOAT4_DATA: + writeFloatData((float*)dataPtr, &pData->float_value, p->float_vecSize); + break; + case SHADER_PARAM_FLOAT4_CAMERA_POS: + writeFloatData((float*)dataPtr, ¤tCam->position, p->float_vecSize); + break; + case SHADER_PARAM_FLOAT4_CAMERA_DIR: break; + case SHADER_PARAM_FLOAT4_LIGHT_COLOR: + writeFloatData((float*)dataPtr, &pLight->color, p->float_vecSize); + break; + case SHADER_PARAM_FLOAT4_LIGHT_POS: + writeFloatData((float*)dataPtr, &pLight->position, p->float_vecSize); + break; + case SHADER_PARAM_FLOAT4_LIGHT_DIR: break; + + case SHADER_PARAM_TRANSFORM_DATA: + rsMatrixLoad((rs_matrix4x4*)dataPtr, &pTransform->globalMat); + break; + case SHADER_PARAM_TRANSFORM_VIEW: + rsMatrixLoad((rs_matrix4x4*)dataPtr, ¤tCam->view); + break; + case SHADER_PARAM_TRANSFORM_PROJ: + rsMatrixLoad((rs_matrix4x4*)dataPtr, ¤tCam->proj); + break; + case SHADER_PARAM_TRANSFORM_VIEW_PROJ: + rsMatrixLoad((rs_matrix4x4*)dataPtr, ¤tCam->viewProj); + break; + case SHADER_PARAM_TRANSFORM_MODEL: + rsMatrixLoad((rs_matrix4x4*)dataPtr, &pTransform->globalMat); + break; + case SHADER_PARAM_TRANSFORM_MODEL_VIEW: + rsMatrixLoad((rs_matrix4x4*)dataPtr, ¤tCam->view); + rsMatrixLoadMultiply((rs_matrix4x4*)dataPtr, + (rs_matrix4x4*)dataPtr, + &pTransform->globalMat); + break; + case SHADER_PARAM_TRANSFORM_MODEL_VIEW_PROJ: + rsMatrixLoad((rs_matrix4x4*)dataPtr, ¤tCam->viewProj); + rsMatrixLoadMultiply((rs_matrix4x4*)dataPtr, + (rs_matrix4x4*)dataPtr, + &pTransform->globalMat); + break; + } + return true; +} + +static void processAllParams(rs_allocation shaderConst, + rs_allocation allParams, + const SgCamera *camera) { + if (rsIsObject(shaderConst)) { + uint8_t *constantBuffer = (uint8_t*)rsGetElementAt(shaderConst, 0); + + int numParams = 0; + if (rsIsObject(allParams)) { + numParams = rsAllocationGetDimX(allParams); + } + bool updated = false; + for (int i = 0; i < numParams; i ++) { + SgShaderParam *current = (SgShaderParam*)rsGetElementAt(allParams, i); + SgShaderParamData *currentData = (SgShaderParamData*)rsGetElementAt(current->data, 0); +#ifdef DEBUG_PARAMS + debugParam(current, currentData); +#endif // DEBUG_PARAMS + updated = processParam(current, currentData, constantBuffer, camera, NULL) || updated; + } + } +} + +static void processTextureParams(SgFragmentShader *shader) { + int numParams = 0; + if (rsIsObject(shader->shaderTextureParams)) { + numParams = rsAllocationGetDimX(shader->shaderTextureParams); + } + for (int i = 0; i < numParams; i ++) { + SgShaderParam *current = (SgShaderParam*)rsGetElementAt(shader->shaderTextureParams, i); + SgShaderParamData *currentData = (SgShaderParamData*)rsGetElementAt(current->data, 0); +#ifdef DEBUG_PARAMS + debugParam(current, currentData); +#endif // DEBUG_PARAMS + processParam(current, currentData, NULL, NULL, shader); + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/render.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/render.rs new file mode 100644 index 0000000..8a73dbd --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/render.rs @@ -0,0 +1,244 @@ +// Copyright (C) 2011-2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "rs_graphics.rsh" +#include "scenegraph_objects.rsh" + +rs_script gTransformScript; +rs_script gCameraScript; +rs_script gLightScript; +rs_script gObjectParamsScript; +rs_script gFragmentParamsScript; +rs_script gVertexParamsScript; +rs_script gCullScript; + +SgTransform *gRootNode; +rs_allocation gCameras; +rs_allocation gLights; +rs_allocation gFragmentShaders; +rs_allocation gVertexShaders; +rs_allocation gRenderableObjects; + +rs_allocation gRenderPasses; + +// Temporary shaders +rs_program_store gPFSBackground; + +uint32_t *gFrontToBack; +static uint32_t gFrontToBackCount = 0; +uint32_t *gBackToFront; +static uint32_t gBackToFrontCount = 0; + +static SgCamera *gActiveCamera = NULL; + +static rs_allocation nullAlloc; + +// #define DEBUG_RENDERABLES +static void draw(SgRenderable *obj) { +#ifdef DEBUG_RENDERABLES + const SgTransform *objTransform = (const SgTransform *)rsGetElementAt(obj->transformMatrix, 0); + rsDebug("**** Drawing object with transform", obj); + printName(objTransform->name); + rsDebug("Model matrix: ", &objTransform->globalMat); + printName(obj->name); +#endif //DEBUG_RENDERABLES + + const SgRenderState *renderState = (const SgRenderState *)rsGetElementAt(obj->render_state, 0); + const SgVertexShader *pv = (const SgVertexShader *)rsGetElementAt(renderState->pv, 0); + const SgFragmentShader *pf = (const SgFragmentShader *)rsGetElementAt(renderState->pf, 0); + + if (pv->objectConstIndex != -1) { + rsgBindConstant(pv->program, pv->objectConstIndex, obj->pv_const); + } + if (pf->objectConstIndex != -1) { + rsgBindConstant(pf->program, pf->objectConstIndex, obj->pf_const); + } + + if (rsIsObject(renderState->ps)) { + rsgBindProgramStore(renderState->ps); + } else { + rsgBindProgramStore(gPFSBackground); + } + + if (rsIsObject(renderState->pr)) { + rsgBindProgramRaster(renderState->pr); + } else { + rs_program_raster pr; + rsgBindProgramRaster(pr); + } + + rsgBindProgramVertex(pv->program); + rsgBindProgramFragment(pf->program); + + for (uint32_t i = 0; i < obj->pf_num_textures; i ++) { + const SgTexture *tex = rsGetElementAt(obj->pf_textures[i], 0); + rsgBindTexture(pf->program, i, tex->texture); + } + + rsgDrawMesh(obj->mesh, obj->meshIndex); +} + +static void sortToBucket(SgRenderable *obj) { + const SgRenderState *renderState = (const SgRenderState *)rsGetElementAt(obj->render_state, 0); + if (rsIsObject(renderState->ps)) { + bool isOpaque = false; + if (isOpaque) { + gFrontToBack[gFrontToBackCount++] = (uint32_t)obj; + } else { + gBackToFront[gBackToFrontCount++] = (uint32_t)obj; + } + } else { + gFrontToBack[gFrontToBackCount++] = (uint32_t)obj; + } +} + +static void updateActiveCamera(rs_allocation cam) { + gActiveCamera = (SgCamera *)rsGetElementAt(cam, 0); +} + +static void prepareCameras() { + // now compute all the camera matrices + if (rsIsObject(gCameras)) { + float aspect = (float)rsgGetWidth() / (float)rsgGetHeight(); + rsForEach(gCameraScript, gCameras, nullAlloc, &aspect, sizeof(aspect)); + } +} + +static void prepareLights() { + if (rsIsObject(gLights)) { + rsForEach(gLightScript, gLights, nullAlloc); + } +} + +static void drawSorted() { + for (int i = 0; i < gFrontToBackCount; i ++) { + SgRenderable *current = (SgRenderable*)gFrontToBack[i]; + draw(current); + } + + for (int i = 0; i < gBackToFrontCount; i ++) { + SgRenderable *current = (SgRenderable*)gBackToFront[i]; + draw(current); + } +} + +static void drawAllObjects(rs_allocation allObj) { + if (!rsIsObject(allObj)) { + return; + } + + if (rsIsObject(gVertexShaders)) { + rsForEach(gVertexParamsScript, nullAlloc, gVertexShaders, + gActiveCamera, sizeof(gActiveCamera)); + } + if (rsIsObject(gFragmentShaders)) { + rsForEach(gFragmentParamsScript, nullAlloc, gFragmentShaders, + gActiveCamera, sizeof(gActiveCamera)); + } + + // Run the params and cull script + rsForEach(gCullScript, nullAlloc, allObj, gActiveCamera, sizeof(gActiveCamera)); + rsForEach(gObjectParamsScript, nullAlloc, allObj, gActiveCamera, sizeof(gActiveCamera)); + + int numRenderables = rsAllocationGetDimX(allObj); + for (int i = 0; i < numRenderables; i ++) { + rs_allocation *drawAlloc = (rs_allocation*)rsGetElementAt(allObj, i); + SgRenderable *current = (SgRenderable*)rsGetElementAt(*drawAlloc, 0); + if (current->isVisible) { + sortToBucket(current); + } + } + drawSorted(); +} + +int root(void) { +#ifdef DEBUG_RENDERABLES + rsDebug("=============================================================================", 0); +#endif // DEBUG_RENDERABLES + + // first step is to update the transform hierachy + if (gRootNode && rsIsObject(gRootNode->children)) { + rsForEach(gTransformScript, gRootNode->children, nullAlloc, 0, 0); + } + + prepareCameras(); + prepareLights(); + + if (rsIsObject(gRenderPasses)) { + rsgClearDepth(1.0f); + int numPasses = rsAllocationGetDimX(gRenderPasses); + for (uint i = 0; i < numPasses; i ++) { + gFrontToBackCount = 0; + gBackToFrontCount = 0; + SgRenderPass *pass = (SgRenderPass*)rsGetElementAt(gRenderPasses, i); + if (rsIsObject(pass->color_target)) { + rsgBindColorTarget(pass->color_target, 0); + } + if (rsIsObject(pass->depth_target)) { + rsgBindDepthTarget(pass->depth_target); + } + if (!rsIsObject(pass->color_target) && + !rsIsObject(pass->depth_target)) { + rsgClearAllRenderTargets(); + } + updateActiveCamera(pass->camera); + if (pass->should_clear_color) { + rsgClearColor(pass->clear_color.x, pass->clear_color.y, + pass->clear_color.z, pass->clear_color.w); + } + if (pass->should_clear_depth) { + rsgClearDepth(pass->clear_depth); + } + drawAllObjects(pass->objects); + } + } else { + gFrontToBackCount = 0; + gBackToFrontCount = 0; + rsgClearColor(1.0f, 1.0f, 1.0f, 1.0f); + rsgClearDepth(1.0f); + + if (rsIsObject(gCameras)) { + rs_allocation *camAlloc = (rs_allocation*)rsGetElementAt(gCameras, 0); + updateActiveCamera(*camAlloc); + } + drawAllObjects(gRenderableObjects); + } + return 10; +} + +// Search through sorted and culled objects +void pick(int screenX, int screenY) { + float3 pnt, vec; + getCameraRay(gActiveCamera, screenX, screenY, &pnt, &vec); + + for (int i = 0; i < gFrontToBackCount; i ++) { + SgRenderable *current = (SgRenderable*)gFrontToBack[i]; + bool isPicked = intersect(current, pnt, vec); + if (isPicked) { + current->cullType = CULL_ALWAYS; + } + } + + for (int i = 0; i < gBackToFrontCount; i ++) { + SgRenderable *current = (SgRenderable*)gBackToFront[i]; + bool isPicked = intersect(current, pnt, vec); + if (isPicked) { + current->cullType = CULL_ALWAYS; + } + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/scenegraph_objects.rsh b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/scenegraph_objects.rsh new file mode 100644 index 0000000..bdca3ab --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/scenegraph_objects.rsh @@ -0,0 +1,323 @@ +// Copyright (C) 2011-2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#ifndef _TRANSFORM_DEF_ +#define _TRANSFORM_DEF_ + +#include "rs_graphics.rsh" + +#define TRANSFORM_NONE 0 +#define TRANSFORM_TRANSLATE 1 +#define TRANSFORM_ROTATE 2 +#define TRANSFORM_SCALE 3 + +#define CULL_FRUSTUM 0 +#define CULL_ALWAYS 2 + +#define LIGHT_POINT 0 +#define LIGHT_DIRECTIONAL 1 + +// Shader params that involve only data +#define SHADER_PARAM_DATA_ONLY 10000 +#define SHADER_PARAM_FLOAT4_DATA 10001 +#define SHADER_PARAM_TRANSFORM_DATA 10002 +#define SHADER_PARAM_TRANSFORM_MODEL 10003 + +// Shader params that involve camera +#define SHADER_PARAM_CAMERA 1000 +#define SHADER_PARAM_FLOAT4_CAMERA_POS 1001 +#define SHADER_PARAM_FLOAT4_CAMERA_DIR 1002 +#define SHADER_PARAM_TRANSFORM_VIEW 1003 +#define SHADER_PARAM_TRANSFORM_PROJ 1004 +#define SHADER_PARAM_TRANSFORM_VIEW_PROJ 1005 +#define SHADER_PARAM_TRANSFORM_MODEL_VIEW 1006 +#define SHADER_PARAM_TRANSFORM_MODEL_VIEW_PROJ 1007 + +// Shader Params that only involve lights +#define SHADER_PARAM_LIGHT 100 +#define SHADER_PARAM_FLOAT4_LIGHT_COLOR 103 +#define SHADER_PARAM_FLOAT4_LIGHT_POS 104 +#define SHADER_PARAM_FLOAT4_LIGHT_DIR 105 + +#define SHADER_PARAM_TEXTURE 10 + +#define TEXTURE_NONE 0 +#define TEXTURE_2D 1 +#define TEXTURE_CUBE 2 +#define TEXTURE_RENDER_TARGET 3 + +typedef struct TransformComponent_s { + float4 value; + int type; + rs_allocation name; +} SgTransformComponent; + +typedef struct __attribute__((packed, aligned(4))) SgTransform { + rs_matrix4x4 globalMat; + rs_matrix4x4 localMat; + + rs_allocation components; + int isDirty; + + rs_allocation children; + rs_allocation name; + + // Used to check whether transform params need to be updated + uint32_t timestamp; +} SgTransform; + +typedef struct VertexShader_s { + rs_program_vertex program; + // Buffer with vertex constant data + rs_allocation shaderConst; + // ShaderParam's that populate data + rs_allocation shaderConstParams; + // location of the per object constants on the buffer + int objectConstIndex; +} SgVertexShader; + +typedef struct FragmentShader_s { + rs_program_fragment program; + // Buffer with vertex constant data + rs_allocation shaderConst; + // ShaderParam's that populate data + rs_allocation shaderConstParams; + // ShaderParam's that set textures + rs_allocation shaderTextureParams; + // location of the per object constants on the buffer + int objectConstIndex; +} SgFragmentShader; + +typedef struct RenderState_s { + rs_allocation pv; // VertexShader struct + rs_allocation pf; // FragmentShader struct + rs_program_store ps; + rs_program_raster pr; +} SgRenderState; + +typedef struct Renderable_s { + rs_allocation render_state; + // Buffer with vertex constant data + rs_allocation pv_const; + // ShaderParam's that populate data + rs_allocation pv_constParams; + // Buffer with fragment constant data + rs_allocation pf_const; + // ShaderParam's that populate data + rs_allocation pf_constParams; + rs_allocation pf_textures[8]; + int pf_num_textures; + rs_mesh mesh; + int meshIndex; + rs_allocation transformMatrix; + rs_allocation name; + float4 boundingSphere; + float4 worldBoundingSphere; + int bVolInitialized; + int cullType; // specifies whether to frustum cull + int isVisible; +} SgRenderable; + +typedef struct RenderPass_s { + rs_allocation color_target; + rs_allocation depth_target; + rs_allocation camera; + rs_allocation objects; + + float4 clear_color; + float clear_depth; + bool should_clear_color; + bool should_clear_depth; +} SgRenderPass; + +typedef struct Camera_s { + rs_matrix4x4 proj; + rs_matrix4x4 view; + rs_matrix4x4 viewProj; + float4 position; + float near; + float far; + float horizontalFOV; + float aspect; + rs_allocation name; + rs_allocation transformMatrix; + float4 frustumPlanes[6]; + + int isDirty; + // Timestamp of the camera itself to signal params if anything changes + uint32_t timestamp; + // Timestamp of our transform + uint32_t transformTimestamp; +} SgCamera; + +typedef struct Light_s { + float4 position; + float4 color; + float intensity; + int type; + rs_allocation name; + rs_allocation transformMatrix; +} SgLight; + +// This represents the shader parameter data needed to set a float or transform data +typedef struct ShaderParamData_s { + int type; + float4 float_value; + uint32_t timestamp; + rs_allocation paramName; + rs_allocation camera; + rs_allocation light; + rs_allocation transform; + rs_allocation texture; +} SgShaderParamData; + +// This represents a shader parameter that knows how to update itself for a given +// renderable or shader and contains a timestamp for the last time this buffer was updated +typedef struct ShaderParam_s { + // Used to check whether transform params need to be updated + uint32_t transformTimestamp; + // Used to check whether data params need to be updated + // These are used when somebody set the matrix of float value directly in java + uint32_t dataTimestamp; + // Specifies where in the constant buffer data gets written to + int bufferOffset; + // An instance of SgShaderParamData that could be shared by multiple objects + rs_allocation data; + // How many components of the vector we need to write + int float_vecSize; +} SgShaderParam; + +// This represents a texture object +typedef struct Texture_s { + uint32_t type; + rs_allocation texture; +} SgTexture; + +static void printName(rs_allocation name) { + if (!rsIsObject(name)) { + rsDebug("no name", 0); + return; + } + + rsDebug((const char*)rsGetElementAt(name, 0), 0); +} + +static void printCameraInfo(const SgCamera *cam) { + rsDebug("***** Camera information. ptr:", cam); + printName(cam->name); + const SgTransform *camTransform = (const SgTransform *)rsGetElementAt(cam->transformMatrix, 0); + rsDebug("Transform name:", camTransform); + printName(camTransform->name); + + rsDebug("Aspect: ", cam->aspect); + rsDebug("Near: ", cam->near); + rsDebug("Far: ", cam->far); + rsDebug("Fov: ", cam->horizontalFOV); + rsDebug("Position: ", cam->position); + rsDebug("Proj: ", &cam->proj); + rsDebug("View: ", &cam->view); +} + +static void printLightInfo(const SgLight *light) { + rsDebug("***** Light information. ptr:", light); + printName(light->name); + const SgTransform *lTransform = (const SgTransform *)rsGetElementAt(light->transformMatrix, 0); + rsDebug("Transform name:", lTransform); + printName(lTransform->name); + + rsDebug("Position: ", light->position); + rsDebug("Color : ", light->color); + rsDebug("Intensity: ", light->intensity); + rsDebug("Type: ", light->type); +} + +static void getCameraRay(const SgCamera *cam, int screenX, int screenY, float3 *pnt, float3 *vec) { + rsDebug("=================================", screenX); + rsDebug("Point X", screenX); + rsDebug("Point Y", screenY); + + rs_matrix4x4 mvpInv; + rsMatrixLoad(&mvpInv, &cam->viewProj); + rsMatrixInverse(&mvpInv); + + float width = (float)rsgGetWidth(); + float height = (float)rsgGetHeight(); + + float4 pos = {(float)screenX, height - (float)screenY, 0.0f, 1.0f}; + + pos.x /= width; + pos.y /= height; + + rsDebug("Pre Norm X", pos.x); + rsDebug("Pre Norm Y", pos.y); + + pos.xy = pos.xy * 2.0f - 1.0f; + + rsDebug("Norm X", pos.x); + rsDebug("Norm Y", pos.y); + + pos = rsMatrixMultiply(&mvpInv, pos); + float oneOverW = 1.0f / pos.w; + pos.xyz *= oneOverW; + + rsDebug("World X", pos.x); + rsDebug("World Y", pos.y); + rsDebug("World Z", pos.z); + + rsDebug("Cam X", cam->position.x); + rsDebug("Cam Y", cam->position.y); + rsDebug("Cam Z", cam->position.z); + + *vec = normalize(pos.xyz - cam->position.xyz); + rsDebug("Vec X", vec->x); + rsDebug("Vec Y", vec->y); + rsDebug("Vec Z", vec->z); + *pnt = cam->position.xyz; +} + +static bool intersect(const SgRenderable *obj, float3 pnt, float3 vec) { + // Solving for t^2 + Bt + C = 0 + float3 originMinusCenter = pnt - obj->worldBoundingSphere.xyz; + float B = dot(originMinusCenter, vec) * 2.0f; + float C = dot(originMinusCenter, originMinusCenter) - + obj->worldBoundingSphere.w * obj->worldBoundingSphere.w; + + float discriminant = B * B - 4.0f * C; + if (discriminant < 0.0f) { + return false; + } + discriminant = sqrt(discriminant); + + float t0 = (-B - discriminant) * 0.5f; + float t1 = (-B + discriminant) * 0.5f; + + if (t0 > t1) { + float temp = t0; + t0 = t1; + t1 = temp; + } + + // The sphere is behind us + if (t1 < 0.0f) { + return false; + } + return true; +} + + +#endif // _TRANSFORM_DEF_ diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/transform.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/transform.rs new file mode 100644 index 0000000..941b5a8 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/transform.rs @@ -0,0 +1,127 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.modelviewer) + +#include "scenegraph_objects.rsh" + +rs_script gTransformScript; + +typedef struct { + int changed; + rs_matrix4x4 *mat; +} ParentData; + +//#define DEBUG_TRANSFORMS +static void debugTransform(SgTransform *data, const ParentData *parent) { + rsDebug("****** <Transform> ******", (int)data); + printName(data->name); + rsDebug("isDirty", data->isDirty); + rsDebug("parent", (int)parent); + rsDebug("child ", rsIsObject(data->children)); + + // Refresh matrices if dirty + if (data->isDirty && rsIsObject(data->components)) { + uint32_t numComponenets = rsAllocationGetDimX(data->components); + for (int i = 0; i < numComponenets; i ++) { + const SgTransformComponent *comp = NULL; + comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); + + if (rsIsObject(comp->name)) { + rsDebug((const char*)rsGetElementAt(comp->name, 0), comp->value); + rsDebug("Type", comp->type); + } else { + rsDebug("no name", comp->value); + rsDebug("Type", comp->type); + } + } + } + + rsDebug("timestamp", data->timestamp); + rsDebug("****** </Transform> ******", (int)data); +} + +static void appendTransformation(int type, float4 data, rs_matrix4x4 *mat) { + rs_matrix4x4 temp; + + switch (type) { + case TRANSFORM_TRANSLATE: + rsMatrixLoadTranslate(&temp, data.x, data.y, data.z); + break; + case TRANSFORM_ROTATE: + rsMatrixLoadRotate(&temp, data.w, data.x, data.y, data.z); + break; + case TRANSFORM_SCALE: + rsMatrixLoadScale(&temp, data.x, data.y, data.z); + break; + } + rsMatrixMultiply(mat, &temp); +} + +void root(const rs_allocation *v_in, rs_allocation *v_out, const void *usrData) { + + SgTransform *data = (SgTransform *)rsGetElementAt(*v_in, 0); + const ParentData *parent = (const ParentData *)usrData; + +#ifdef DEBUG_TRANSFORMS + debugTransform(data, parent); +#endif //DEBUG_TRANSFORMS + + rs_matrix4x4 *localMat = &data->localMat; + rs_matrix4x4 *globalMat = &data->globalMat; + + // Refresh matrices if dirty + if (data->isDirty && rsIsObject(data->components)) { + bool resetLocal = false; + uint32_t numComponenets = rsAllocationGetDimX(data->components); + for (int i = 0; i < numComponenets; i ++) { + if (!resetLocal) { + // Reset our local matrix only for component transforms + rsMatrixLoadIdentity(localMat); + resetLocal = true; + } + const SgTransformComponent *comp = NULL; + comp = (const SgTransformComponent *)rsGetElementAt(data->components, i); + appendTransformation(comp->type, comp->value, localMat); + } + } + + if (parent) { + data->isDirty = (parent->changed || data->isDirty) ? 1 : 0; + if (data->isDirty) { + rsMatrixLoad(globalMat, parent->mat); + rsMatrixMultiply(globalMat, localMat); + } + } else if (data->isDirty) { + rsMatrixLoad(globalMat, localMat); + } + + ParentData toChild; + toChild.changed = 0; + toChild.mat = globalMat; + + if (data->isDirty) { + toChild.changed = 1; + data->timestamp ++; + } + + if (rsIsObject(data->children)) { + rs_allocation nullAlloc; + rsForEach(gTransformScript, data->children, nullAlloc, &toChild, sizeof(toChild)); + } + + data->isDirty = 0; +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/vertex_params.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/vertex_params.rs new file mode 100644 index 0000000..88955a8 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/scenegraph/vertex_params.rs @@ -0,0 +1,29 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.scenegraph) + +#include "scenegraph_objects.rsh" + +//#define DEBUG_PARAMS + +#include "params.rsh" + +void root(rs_allocation *v_out, const void *usrData) { + SgVertexShader *shader = (SgVertexShader *)rsGetElementAt(*v_out, 0); + const SgCamera *camera = (const SgCamera*)usrData; + processAllParams(shader->shaderConst, shader->shaderConstParams, camera); +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FileSelector.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FileSelector.java new file mode 100644 index 0000000..420e133 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FileSelector.java @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import java.io.File; +import java.io.FileFilter; +import java.util.ArrayList; +import java.util.List; + +import android.app.ListActivity; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.view.View; +import android.widget.ArrayAdapter; +import android.widget.ListView; + +/** + * A list view where the last item the user clicked is placed in + * the "activated" state, causing its background to highlight. + */ +public class FileSelector extends ListActivity { + + File[] mCurrentSubList; + File mCurrentFile; + + class DAEFilter implements FileFilter { + public boolean accept(File file) { + if (file.isDirectory()) { + return true; + } + return file.getName().endsWith(".dae"); + } + } + + private void populateList(File file) { + + mCurrentFile = file; + setTitle(mCurrentFile.getAbsolutePath() + "/*.dae"); + List<String> names = new ArrayList<String>(); + names.add(".."); + + mCurrentSubList = mCurrentFile.listFiles(new DAEFilter()); + + if (mCurrentSubList != null) { + for (int i = 0; i < mCurrentSubList.length; i ++) { + String fileName = mCurrentSubList[i].getName(); + if (mCurrentSubList[i].isDirectory()) { + fileName = "/" + fileName; + } + names.add(fileName); + } + } + + // Use the built-in layout for showing a list item with a single + // line of text whose background is changes when activated. + setListAdapter(new ArrayAdapter<String>(this, + android.R.layout.simple_list_item_activated_1, names)); + getListView().setTextFilterEnabled(true); + + // Tell the list view to show one checked/activated item at a time. + getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + populateList(new File("/sdcard/")); + } + + @Override + protected void onListItemClick(ListView l, View v, int position, long id) { + if (position == 0) { + File parent = mCurrentFile.getParentFile(); + if (parent == null) { + return; + } + populateList(parent); + return; + } + + // the first thing in list is parent directory + File selectedFile = mCurrentSubList[position - 1]; + if (selectedFile.isDirectory()) { + populateList(selectedFile); + return; + } + + Intent resultIntent = new Intent(); + resultIntent.setData(Uri.fromFile(selectedFile)); + setResult(RESULT_OK, resultIntent); + finish(); + } + +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FullscreenBlur.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FullscreenBlur.java new file mode 100644 index 0000000..28f916c --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/FullscreenBlur.java @@ -0,0 +1,192 @@ +/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.android.testapp;
+
+import java.util.ArrayList;
+
+import com.android.scenegraph.*;
+
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.AsyncTask;
+import android.renderscript.*;
+import android.renderscript.Allocation.MipmapControl;
+import android.renderscript.Element.Builder;
+import android.renderscript.Font.Style;
+import android.renderscript.Program.TextureType;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.util.Log;
+
+class FullscreenBlur {
+
+ static TextureRenderTarget sRenderTargetBlur0Color;
+ static TextureRenderTarget sRenderTargetBlur0Depth;
+ static TextureRenderTarget sRenderTargetBlur1Color;
+ static TextureRenderTarget sRenderTargetBlur1Depth;
+ static TextureRenderTarget sRenderTargetBlur2Color;
+ static TextureRenderTarget sRenderTargetBlur2Depth;
+
+ static FragmentShader mPF_BlurH;
+ static FragmentShader mPF_BlurV;
+ static FragmentShader mPF_SelectColor;
+ static FragmentShader mPF_Texture;
+ static VertexShader mPV_Paint;
+ static VertexShader mPV_Blur;
+
+ static int targetWidth;
+ static int targetHeight;
+
+ // This is only used when full screen blur is enabled
+ // Basically, it's the offscreen render targets
+ static void createRenderTargets(RenderScriptGL rs, int w, int h) {
+ targetWidth = w/8;
+ targetHeight = h/8;
+ Type.Builder b = new Type.Builder(rs, Element.RGBA_8888(rs));
+ Type renderType = b.setX(targetWidth).setY(targetHeight).create();
+ int usage = Allocation.USAGE_GRAPHICS_TEXTURE | Allocation.USAGE_GRAPHICS_RENDER_TARGET;
+ sRenderTargetBlur0Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+ sRenderTargetBlur1Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+ sRenderTargetBlur2Color = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+
+ b = new Type.Builder(rs, Element.createPixel(rs, Element.DataType.UNSIGNED_16,
+ Element.DataKind.PIXEL_DEPTH));
+ renderType = b.setX(targetWidth).setY(targetHeight).create();
+ usage = Allocation.USAGE_GRAPHICS_RENDER_TARGET;
+ sRenderTargetBlur0Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+ sRenderTargetBlur1Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+ sRenderTargetBlur2Depth = new TextureRenderTarget(Allocation.createTyped(rs, renderType, usage));
+ }
+
+ static void addOffsets(Renderable quad, float advance) {
+ quad.appendSourceParams(new Float4Param("blurOffset0", - advance * 2.5f));
+ quad.appendSourceParams(new Float4Param("blurOffset1", - advance * 0.5f));
+ quad.appendSourceParams(new Float4Param("blurOffset2", advance * 1.5f));
+ quad.appendSourceParams(new Float4Param("blurOffset3", advance * 3.5f));
+ }
+
+ static RenderPass addPass(Scene scene, Camera cam, TextureRenderTarget color, TextureRenderTarget depth) {
+ RenderPass pass = new RenderPass();
+ pass.setColorTarget(color);
+ pass.setDepthTarget(depth);
+ pass.setShouldClearColor(false);
+ pass.setShouldClearDepth(false);
+ pass.setCamera(cam);
+ scene.appendRenderPass(pass);
+ return pass;
+ }
+
+ static void addBlurPasses(Scene scene, RenderScriptGL rs, Camera cam) {
+ SceneManager sceneManager = SceneManager.getInstance();
+ ArrayList<RenderableBase> allDraw = scene.getRenderables();
+ int numDraw = allDraw.size();
+
+ ProgramRaster cullNone = ProgramRaster.CULL_NONE(rs);
+ ProgramStore blendAdd = SceneManager.BLEND_ADD_DEPTH_NONE(rs);
+ ProgramStore blendNone = ProgramStore.BLEND_NONE_DEPTH_NONE(rs);
+
+ RenderState drawTex = new RenderState(mPV_Blur, mPF_Texture, blendAdd, cullNone);
+ RenderState selectCol = new RenderState(mPV_Blur, mPF_SelectColor, blendNone, cullNone);
+ RenderState hBlur = new RenderState(mPV_Blur, mPF_BlurH, blendNone, cullNone);
+ RenderState vBlur = new RenderState(mPV_Blur, mPF_BlurV, blendNone, cullNone);
+
+ // Renders the scene off screen
+ RenderPass blurSourcePass = addPass(scene, cam,
+ sRenderTargetBlur0Color,
+ sRenderTargetBlur0Depth);
+ blurSourcePass.setClearColor(new Float4(1.0f, 1.0f, 1.0f, 1.0f));
+ blurSourcePass.setShouldClearColor(true);
+ blurSourcePass.setClearDepth(1.0f);
+ blurSourcePass.setShouldClearDepth(true);
+ for (int i = 0; i < numDraw; i ++) {
+ blurSourcePass.appendRenderable((Renderable)allDraw.get(i));
+ }
+
+ // Pass for selecting bright colors
+ RenderPass selectColorPass = addPass(scene, cam,
+ sRenderTargetBlur2Color,
+ sRenderTargetBlur2Depth);
+ Renderable quad = sceneManager.getRenderableQuad("ScreenAlignedQuadS", selectCol);
+ quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur0Color));
+ selectColorPass.appendRenderable(quad);
+
+ // Horizontal blur
+ RenderPass horizontalBlurPass = addPass(scene, cam,
+ sRenderTargetBlur1Color,
+ sRenderTargetBlur1Depth);
+ quad = sceneManager.getRenderableQuad("ScreenAlignedQuadH", hBlur);
+ quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur2Color));
+ addOffsets(quad, 1.0f / (float)targetWidth);
+ horizontalBlurPass.appendRenderable(quad);
+
+ // Vertical Blur
+ RenderPass verticalBlurPass = addPass(scene, cam,
+ sRenderTargetBlur2Color,
+ sRenderTargetBlur2Depth);
+ quad = sceneManager.getRenderableQuad("ScreenAlignedQuadV", vBlur);
+ quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur1Color));
+ addOffsets(quad, 1.0f / (float)targetHeight);
+ verticalBlurPass.appendRenderable(quad);
+ }
+
+ // Additively renders the blurred colors on top of the scene
+ static void addCompositePass(Scene scene, RenderScriptGL rs, Camera cam) {
+ SceneManager sceneManager = SceneManager.getInstance();
+ RenderState drawTex = new RenderState(mPV_Blur, mPF_Texture,
+ SceneManager.BLEND_ADD_DEPTH_NONE(rs),
+ ProgramRaster.CULL_NONE(rs));
+
+ RenderPass compositePass = addPass(scene, cam, null, null);
+ Renderable quad = sceneManager.getRenderableQuad("ScreenAlignedQuadComposite", drawTex);
+ quad.appendSourceParams(new TextureParam("color", sRenderTargetBlur2Color));
+ compositePass.appendRenderable(quad);
+ }
+
+ static private FragmentShader getShader(Resources res, RenderScriptGL rs,
+ int resID, Type constants) {
+ FragmentShader.Builder fb = new FragmentShader.Builder(rs);
+ fb.setShader(res, resID);
+ fb.addTexture(TextureType.TEXTURE_2D, "color");
+ if (constants != null) {
+ fb.setObjectConst(constants);
+ }
+ FragmentShader prog = fb.create();
+ prog.getProgram().bindSampler(Sampler.CLAMP_LINEAR(rs), 0);
+ return prog;
+ }
+
+ static void initShaders(Resources res, RenderScriptGL rs) {
+ ScriptField_BlurOffsets blurConst = new ScriptField_BlurOffsets(rs, 1);
+ VertexShader.Builder vb = new VertexShader.Builder(rs);
+ vb.addInput(ScriptField_VertexShaderInputs.createElement(rs));
+ vb.setShader(res, R.raw.blur_vertex);
+ mPV_Blur = vb.create();
+
+ mPF_Texture = getShader(res, rs, R.raw.texture, null);
+ mPF_Texture.getProgram().bindSampler(Sampler.WRAP_LINEAR_MIP_LINEAR(rs), 0);
+ mPF_BlurH = getShader(res, rs, R.raw.blur_h, blurConst.getAllocation().getType());
+ mPF_BlurV = getShader(res, rs, R.raw.blur_v, blurConst.getAllocation().getType());
+ mPF_SelectColor = getShader(res, rs, R.raw.select_color, null);
+ }
+
+}
+
+
+
+
+
diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleApp.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleApp.java new file mode 100644 index 0000000..314db80 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleApp.java @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.os.Bundle; +import android.util.Log; +import android.view.View; +import android.view.Window; +import android.view.Window; +import android.net.Uri; + +import java.lang.Runtime; + +public class SimpleApp extends Activity { + + private SimpleAppView mView; + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new SimpleAppView(this); + setContentView(mView); + } +} + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppRS.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppRS.java new file mode 100644 index 0000000..fff6f34 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppRS.java @@ -0,0 +1,207 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +import com.android.scenegraph.*; +import com.android.scenegraph.SceneManager.SceneLoadedCallback; + +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Program.TextureType; +import android.util.Log; + +// This is where the scenegraph and the rendered objects are initialized and used +public class SimpleAppRS { + SceneManager mSceneManager; + + RenderScriptGL mRS; + Resources mRes; + + Scene mScene; + Mesh mSimpleMesh; + Mesh mSphereMesh; + Mesh mCubeMesh; + + public void init(RenderScriptGL rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + mSceneManager = SceneManager.getInstance(); + mSceneManager.initRS(mRS, mRes, width, height); + + mScene = new Scene(); + + setupGeometry(); + setupColoredQuad(); + setupTexturedQuad(); + setupShadedGeometry(); + setupCamera(); + setupRenderPass(); + + mSceneManager.setActiveScene(mScene); + + mScene.initRS(); + mRS.bindRootScript(mSceneManager.getRenderLoop()); + } + + private void setupGeometry() { + Mesh.TriangleMeshBuilder tmb = new Mesh.TriangleMeshBuilder(mRS, 3, + Mesh.TriangleMeshBuilder.TEXTURE_0); + + // Create four vertices with texture coordinates + tmb.setTexture(0.0f, 1.0f).addVertex(-1.0f, 1.0f, 0.0f); + tmb.setTexture(0.0f, 0.0f).addVertex(-1.0f, -1.0f, 0.0f); + tmb.setTexture(1.0f, 0.0f).addVertex(1.0f, -1.0f, 0.0f); + tmb.setTexture(1.0f, 1.0f).addVertex(1.0f, 1.0f, 0.0f); + + tmb.addTriangle(0, 1, 2); + tmb.addTriangle(2, 3, 0); + mSimpleMesh = tmb.create(true); + + // Load a file that constains two pieces of geometry, a sphere and a cube + FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.unit_obj); + for (int i = 0; i < model.getIndexEntryCount(); i ++) { + FileA3D.IndexEntry entry = model.getIndexEntry(i); + if (entry != null && entry.getName().equals("CubeMesh")) { + mCubeMesh = entry.getMesh(); + } else if (entry != null && entry.getName().equals("SphereMesh")) { + mSphereMesh = entry.getMesh(); + } + } + } + + private void setupColoredQuad() { + // Built-in shader that provides position, texcoord and normal + VertexShader genericV = SceneManager.getDefaultVS(); + // Built-in shader that displays a color + FragmentShader colorF = SceneManager.getColorFS(); + RenderState colorRS = new RenderState(genericV, colorF, null, null); + + // Draw a simple colored quad + Renderable quad = mScene.appendNewRenderable(); + quad.setMesh(mSimpleMesh); + // Our shader has a constant input called "color" + // This tells the scenegraph to assign the following float3 to that input + quad.appendSourceParams(new Float4Param("color", 0.2f, 0.3f, 0.4f)); + quad.setRenderState(colorRS); + } + + private void setupTexturedQuad() { + // Built-in shader that provides position, texcoord and normal + VertexShader genericV = SceneManager.getDefaultVS(); + // Built-in shader that displays a texture + FragmentShader textureF = SceneManager.getTextureFS(); + // We want to use transparency based on the alpha channel of the texture + ProgramStore alphaBlend = ProgramStore.BLEND_ALPHA_DEPTH_TEST(mRS); + RenderState texRS = new RenderState(genericV, textureF, alphaBlend, null); + + // Draw a textured quad + Renderable quad = mScene.appendNewRenderable(); + quad.setMesh(mSimpleMesh); + // Make a transform to position the quad + CompoundTransform t = mScene.appendNewCompoundTransform(); + t.addTranslate("position", new Float3(2, 2, 0)); + quad.setTransform(t); + // Our fragment shader has a constant texture input called "color" + // This will assign an icon from drawables to that input + quad.appendSourceParams(new TextureParam("color", new Texture2D(R.drawable.icon))); + quad.setRenderState(texRS); + } + + private FragmentShader createLambertShader() { + // Describe what constant inputs our shader wants + Element.Builder b = new Element.Builder(mRS); + b.add(Element.F32_4(mRS), "cameraPos"); + + // Create a shader from a text file in resources + FragmentShader.Builder fb = new FragmentShader.Builder(mRS); + // Tell the shader what constants we want + fb.setShaderConst(new Type.Builder(mRS, b.create()).setX(1).create()); + // Shader code location + fb.setShader(mRes, R.raw.diffuse); + // We want a texture called diffuse on our shader + fb.addTexture(TextureType.TEXTURE_2D, "diffuse"); + FragmentShader shader = fb.create(); + mScene.appendShader(shader); + return shader; + } + + private void setupShadedGeometry() { + // Built-in shader that provides position, texcoord and normal + VertexShader genericV = SceneManager.getDefaultVS(); + // Custom shader + FragmentShader diffuseF = createLambertShader(); + RenderState diffuseRS = new RenderState(genericV, diffuseF, null, null); + + // Draw a sphere + Renderable sphere = mScene.appendNewRenderable(); + // Use the sphere geometry loaded earlier + sphere.setMesh(mSphereMesh); + // Make a transform to position the sphere + CompoundTransform t = mScene.appendNewCompoundTransform(); + t.addTranslate("position", new Float3(-1, 2, 3)); + t.addScale("scale", new Float3(1.4f, 1.4f, 1.4f)); + sphere.setTransform(t); + // Tell the renderable which texture to use when we draw + // This will mean a texture param in the shader called "diffuse" + // will be assigned a texture called red.jpg + sphere.appendSourceParams(new TextureParam("diffuse", new Texture2D("", "red.jpg"))); + sphere.setRenderState(diffuseRS); + + // Draw a cube + Renderable cube = mScene.appendNewRenderable(); + cube.setMesh(mCubeMesh); + t = mScene.appendNewCompoundTransform(); + t.addTranslate("position", new Float3(-2, -2.1f, 0)); + t.addRotate("rotateX", new Float3(1, 0, 0), 30); + t.addRotate("rotateY", new Float3(0, 1, 0), 30); + t.addScale("scale", new Float3(2, 2, 2)); + cube.setTransform(t); + cube.appendSourceParams(new TextureParam("diffuse", new Texture2D("", "orange.jpg"))); + cube.setRenderState(diffuseRS); + } + + private void setupCamera() { + Camera camera = mScene.appendNewCamera(); + camera.setFar(200); + camera.setNear(0.1f); + camera.setFOV(60); + CompoundTransform cameraTransform = mScene.appendNewCompoundTransform(); + cameraTransform.addTranslate("camera", new Float3(0, 0, 10)); + camera.setTransform(cameraTransform); + } + + private void setupRenderPass() { + RenderPass mainPass = mScene.appendNewRenderPass(); + mainPass.setClearColor(new Float4(1.0f, 1.0f, 1.0f, 1.0f)); + mainPass.setShouldClearColor(true); + mainPass.setClearDepth(1.0f); + mainPass.setShouldClearDepth(true); + mainPass.setCamera(mScene.getCameras().get(0)); + ArrayList<RenderableBase> allRender = mScene.getRenderables(); + for (RenderableBase renderable : allRender) { + mainPass.appendRenderable((Renderable)renderable); + } + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppView.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppView.java new file mode 100644 index 0000000..2112181 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/SimpleAppView.java @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; + +import android.content.Context; +import android.content.res.Resources; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; + +public class SimpleAppView extends RSSurfaceView { + + public SimpleAppView(Context context) { + super(context); + } + + private RenderScriptGL mRS; + SimpleAppRS mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + if (mRS == null) { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + sc.setDepth(16, 24); + sc.setSamples(1, 2, 1); + mRS = createRenderScriptGL(sc); + mRS.setSurface(holder, w, h); + mRender = new SimpleAppRS(); + mRender.init(mRS, getResources(), w, h); + } + } + + @Override + protected void onDetachedFromWindow() { + if (mRS != null) { + mRender = null; + mRS = null; + destroyRenderScriptGL(); + } + } +} + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestApp.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestApp.java new file mode 100644 index 0000000..385a7ab --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestApp.java @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.content.Intent; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; +import android.view.MenuInflater; +import android.view.Window; +import android.net.Uri; + +import java.lang.Runtime; + +public class TestApp extends Activity { + + private TestAppView mView; + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new TestAppView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onResume(); + mView.resume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity looses focus + super.onPause(); + mView.pause(); + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + MenuInflater inflater = getMenuInflater(); + inflater.inflate(R.menu.loader_menu, menu); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + // Handle item selection + switch (item.getItemId()) { + case R.id.load_model: + loadModel(); + return true; + case R.id.use_blur: + mView.mRender.toggleBlur(); + return true; + default: + return super.onOptionsItemSelected(item); + } + } + + private static final int FIND_DAE_MODEL = 10; + public void onActivityResult(int requestCode, int resultCode, Intent data) { + if (resultCode == RESULT_OK) { + if (requestCode == FIND_DAE_MODEL) { + Uri selectedImageUri = data.getData(); + Log.e("Selected Path: ", selectedImageUri.getPath()); + mView.mRender.loadModel(selectedImageUri.getPath()); + } + } + } + + public void loadModel() { + Intent intent = new Intent(); + intent.setAction(Intent.ACTION_PICK); + intent.setClassName("com.android.testapp", + "com.android.testapp.FileSelector"); + startActivityForResult(intent, FIND_DAE_MODEL); + } + +} + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppLoadingScreen.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppLoadingScreen.java new file mode 100644 index 0000000..5bd8f0b --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppLoadingScreen.java @@ -0,0 +1,113 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +import com.android.scenegraph.SceneManager; + +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Allocation.MipmapControl; +import android.renderscript.Element.Builder; +import android.renderscript.Font.Style; +import android.renderscript.Program.TextureType; +import android.renderscript.ProgramStore.DepthFunc; +import android.util.Log; + +// This is where the scenegraph and the rendered objects are initialized and used +public class TestAppLoadingScreen { + + private static String TAG = "TestAppLoadingScreen"; + + private Resources mRes; + private RenderScriptGL mRS; + private ScriptC_test_app mScript; + + public TestAppLoadingScreen(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + // Shows the loading screen with some text + renderLoading(); + // Adds a little 3D bugdroid model to the laoding screen asynchronously. + new LoadingScreenLoaderTask().execute(); + } + + public void showLoadingScreen(boolean show) { + if (show) { + mRS.bindRootScript(mScript); + } else { + mRS.bindRootScript(SceneManager.getInstance().getRenderLoop()); + } + } + + // The loading screen has some elements that shouldn't be loaded on the UI thread + private class LoadingScreenLoaderTask extends AsyncTask<String, Void, Boolean> { + Allocation robotTex; + Mesh robotMesh; + protected Boolean doInBackground(String... names) { + long start = System.currentTimeMillis(); + robotTex = Allocation.createFromBitmapResource(mRS, mRes, R.drawable.robot, + MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE, + Allocation.USAGE_GRAPHICS_TEXTURE); + + FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.robot); + FileA3D.IndexEntry entry = model.getIndexEntry(0); + if (entry != null && entry.getEntryType() == FileA3D.EntryType.MESH) { + robotMesh = entry.getMesh(); + } + + mScript.set_gPFSBackground(ProgramStore.BLEND_NONE_DEPTH_TEST(mRS)); + + ProgramFragmentFixedFunction.Builder b = new ProgramFragmentFixedFunction.Builder(mRS); + b.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + ProgramFragment pfDefault = b.create(); + pfDefault.bindSampler(Sampler.CLAMP_LINEAR(mRS), 0); + mScript.set_gPFBackground(pfDefault); + + ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS); + ProgramVertexFixedFunction pvDefault = pvb.create(); + ProgramVertexFixedFunction.Constants va = new ProgramVertexFixedFunction.Constants(mRS); + ((ProgramVertexFixedFunction)pvDefault).bindConstants(va); + mScript.set_gPVBackground(pvDefault); + + long end = System.currentTimeMillis(); + Log.v("TIMER", "Loading load time: " + (end - start)); + return new Boolean(true); + } + + protected void onPostExecute(Boolean result) { + mScript.set_gRobotTex(robotTex); + mScript.set_gRobotMesh(robotMesh); + } + } + + // Creates a simple script to show a loding screen until everything is initialized + // Could also be used to do some custom renderscript work before handing things over + // to the scenegraph + void renderLoading() { + mScript = new ScriptC_test_app(mRS, mRes, R.raw.test_app); + mRS.bindRootScript(mScript); + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppRS.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppRS.java new file mode 100644 index 0000000..3aa80f4 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppRS.java @@ -0,0 +1,270 @@ +/* + * Copyright (C) 2011-2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +import com.android.scenegraph.*; +import com.android.scenegraph.SceneManager.SceneLoadedCallback; + +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.os.AsyncTask; +import android.renderscript.*; +import android.renderscript.Program.TextureType; +import android.util.Log; + +// This is where the scenegraph and the rendered objects are initialized and used +public class TestAppRS { + + private static String modelName = "orientation_test.dae"; + private static String TAG = "TestAppRS"; + private static String mFilePath = ""; + + int mWidth; + int mHeight; + + boolean mUseBlur; + + TestAppLoadingScreen mLoadingScreen; + + // Used to asynchronously load scene elements like meshes and transform hierarchies + SceneLoadedCallback mLoadedCallback = new SceneLoadedCallback() { + public void run() { + prepareToRender(mLoadedScene); + } + }; + + // Top level class that initializes all the elements needed to use the scene graph + SceneManager mSceneManager; + + // Used to move the camera around in the 3D world + TouchHandler mTouchHandler; + + private Resources mRes; + private RenderScriptGL mRS; + + // Shaders + private FragmentShader mPaintF; + private FragmentShader mLightsF; + private FragmentShader mLightsDiffF; + private FragmentShader mAluminumF; + private FragmentShader mPlasticF; + private FragmentShader mDiffuseF; + private FragmentShader mTextureF; + private VertexShader mGenericV; + + Scene mActiveScene; + + // This is a part of the test app, it's used to tests multiple render passes and is toggled + // on and off in the menu, off by default + void toggleBlur() { + mUseBlur = !mUseBlur; + + mActiveScene.clearRenderPasses(); + initRenderPasses(); + mActiveScene.initRenderPassRS(mRS, mSceneManager); + + // This is just a hardcoded object in the scene that gets turned on and off for the demo + // to make things look a bit better. This could be deleted in the cleanup + Renderable plane = (Renderable)mActiveScene.getRenderableByName("pPlaneShape1"); + if (plane != null) { + plane.setVisible(!mUseBlur); + } + } + + public void init(RenderScriptGL rs, Resources res, int width, int height) { + mUseBlur = false; + mRS = rs; + mRes = res; + mWidth = width; + mHeight = height; + + mTouchHandler = new TouchHandler(); + + mSceneManager = SceneManager.getInstance(); + // Initializes all the RS specific scenegraph elements + mSceneManager.initRS(mRS, mRes, mWidth, mHeight); + + mLoadingScreen = new TestAppLoadingScreen(mRS, mRes); + + // Initi renderscript stuff specific to the app. This will need to be abstracted out later. + FullscreenBlur.createRenderTargets(mRS, mWidth, mHeight); + initPaintShaders(); + + // Load a scene to render + mSceneManager.loadModel(mFilePath + modelName, mLoadedCallback); + } + + // When a new model file is selected from the UI, this function gets called to init everything + void loadModel(String path) { + mLoadingScreen.showLoadingScreen(true); + mActiveScene.destroyRS(); + mSceneManager.loadModel(path, mLoadedCallback); + } + + public void onActionDown(float x, float y) { + mTouchHandler.onActionDown(x, y); + } + + public void onActionScale(float scale) { + mTouchHandler.onActionScale(scale); + } + + public void onActionMove(float x, float y) { + mTouchHandler.onActionMove(x, y); + } + + FragmentShader createFromResource(int id, boolean addCubemap, Type constType) { + FragmentShader.Builder fb = new FragmentShader.Builder(mRS); + fb.setShaderConst(constType); + fb.setShader(mRes, id); + fb.addTexture(TextureType.TEXTURE_2D, "diffuse"); + if (addCubemap) { + fb.addShaderTexture(TextureType.TEXTURE_CUBE, "reflection"); + } + FragmentShader pf = fb.create(); + pf.getProgram().bindSampler(Sampler.WRAP_LINEAR_MIP_LINEAR(mRS), 0); + if (addCubemap) { + pf.getProgram().bindSampler(Sampler.CLAMP_LINEAR_MIP_LINEAR(mRS), 1); + } + return pf; + } + + private void initPaintShaders() { + mGenericV = SceneManager.getDefaultVS(); + + ScriptField_CameraParams camParams = new ScriptField_CameraParams(mRS, 1); + Type camParamType = camParams.getAllocation().getType(); + ScriptField_LightParams lightParams = new ScriptField_LightParams(mRS, 1); + + mPaintF = createFromResource(R.raw.paintf, true, camParamType); + // Assign a reflection map + TextureCube envCube = new TextureCube("sdcard/scenegraph/", "cube_env.png"); + mPaintF.appendSourceParams(new TextureParam("reflection", envCube)); + + mAluminumF = createFromResource(R.raw.metal, true, camParamType); + TextureCube diffCube = new TextureCube("sdcard/scenegraph/", "cube_spec.png"); + mAluminumF.appendSourceParams(new TextureParam("reflection", diffCube)); + + mPlasticF = createFromResource(R.raw.plastic, false, camParamType); + mDiffuseF = createFromResource(R.raw.diffuse, false, camParamType); + mTextureF = SceneManager.getTextureFS(); + + FragmentShader.Builder fb = new FragmentShader.Builder(mRS); + fb.setObjectConst(lightParams.getAllocation().getType()); + fb.setShader(mRes, R.raw.plastic_lights); + mLightsF = fb.create(); + + fb = new FragmentShader.Builder(mRS); + fb.setObjectConst(lightParams.getAllocation().getType()); + fb.setShader(mRes, R.raw.diffuse_lights); + mLightsDiffF = fb.create(); + + FullscreenBlur.initShaders(mRes, mRS); + } + + void initRenderPasses() { + ArrayList<RenderableBase> allDraw = mActiveScene.getRenderables(); + int numDraw = allDraw.size(); + + if (mUseBlur) { + FullscreenBlur.addBlurPasses(mActiveScene, mRS, mTouchHandler.getCamera()); + } + + RenderPass mainPass = new RenderPass(); + mainPass.setClearColor(new Float4(1.0f, 1.0f, 1.0f, 1.0f)); + mainPass.setShouldClearColor(true); + mainPass.setClearDepth(1.0f); + mainPass.setShouldClearDepth(true); + mainPass.setCamera(mTouchHandler.getCamera()); + for (int i = 0; i < numDraw; i ++) { + mainPass.appendRenderable((Renderable)allDraw.get(i)); + } + mActiveScene.appendRenderPass(mainPass); + + if (mUseBlur) { + FullscreenBlur.addCompositePass(mActiveScene, mRS, mTouchHandler.getCamera()); + } + } + + private void addShadersToScene() { + mActiveScene.appendShader(mPaintF); + mActiveScene.appendShader(mLightsF); + mActiveScene.appendShader(mLightsDiffF); + mActiveScene.appendShader(mAluminumF); + mActiveScene.appendShader(mPlasticF); + mActiveScene.appendShader(mDiffuseF); + mActiveScene.appendShader(mTextureF); + } + + public void prepareToRender(Scene s) { + mSceneManager.setActiveScene(s); + mActiveScene = s; + mTouchHandler.init(mActiveScene); + addShadersToScene(); + RenderState plastic = new RenderState(mGenericV, mPlasticF, null, null); + RenderState diffuse = new RenderState(mGenericV, mDiffuseF, null, null); + RenderState paint = new RenderState(mGenericV, mPaintF, null, null); + RenderState aluminum = new RenderState(mGenericV, mAluminumF, null, null); + RenderState lights = new RenderState(mGenericV, mLightsF, null, null); + RenderState diff_lights = new RenderState(mGenericV, mLightsDiffF, null, null); + RenderState diff_lights_no_cull = new RenderState(mGenericV, mLightsDiffF, null, + ProgramRaster.CULL_NONE(mRS)); + RenderState glassTransp = new RenderState(mGenericV, mPaintF, + ProgramStore.BLEND_ALPHA_DEPTH_TEST(mRS), null); + RenderState texState = new RenderState(mGenericV, mTextureF, null, null); + + initRenderPasses(); + + mActiveScene.assignRenderState(plastic); + + mActiveScene.assignRenderStateToMaterial(diffuse, "lambert2$"); + + mActiveScene.assignRenderStateToMaterial(paint, "^Paint"); + mActiveScene.assignRenderStateToMaterial(paint, "^Carbon"); + mActiveScene.assignRenderStateToMaterial(paint, "^Glass"); + mActiveScene.assignRenderStateToMaterial(paint, "^MainGlass"); + + mActiveScene.assignRenderStateToMaterial(aluminum, "^Metal"); + mActiveScene.assignRenderStateToMaterial(aluminum, "^Brake"); + + mActiveScene.assignRenderStateToMaterial(glassTransp, "^GlassLight"); + + mActiveScene.assignRenderStateToMaterial(lights, "^LightBlinn"); + mActiveScene.assignRenderStateToMaterial(diff_lights, "^LightLambert"); + mActiveScene.assignRenderStateToMaterial(diff_lights_no_cull, "^LightLambertNoCull"); + mActiveScene.assignRenderStateToMaterial(texState, "^TextureOnly"); + + Renderable plane = (Renderable)mActiveScene.getRenderableByName("pPlaneShape1"); + if (plane != null) { + plane.setRenderState(texState); + plane.setVisible(!mUseBlur); + } + + long start = System.currentTimeMillis(); + mActiveScene.initRS(); + long end = System.currentTimeMillis(); + Log.v("TIMER", "Scene init time: " + (end - start)); + + mLoadingScreen.showLoadingScreen(false); + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppView.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppView.java new file mode 100644 index 0000000..33ca1b8 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TestAppView.java @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.ScaleGestureDetector; + +public class TestAppView extends RSSurfaceView { + + public TestAppView(Context context) { + super(context); + mScaleDetector = new ScaleGestureDetector(context, new ScaleListener()); + } + + private RenderScriptGL mRS; + TestAppRS mRender; + + private ScaleGestureDetector mScaleDetector; + private static final int INVALID_POINTER_ID = -1; + private int mActivePointerId = INVALID_POINTER_ID; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + if (mRS == null) { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + sc.setDepth(16, 24); + sc.setSamples(1, 2, 1); + mRS = createRenderScriptGL(sc); + mRS.setSurface(holder, w, h); + mRender = new TestAppRS(); + mRender.init(mRS, getResources(), w, h); + } + } + + @Override + protected void onDetachedFromWindow() { + if (mRS != null) { + mRender = null; + mRS = null; + destroyRenderScriptGL(); + } + } + + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) + { + // break point at here + // this method doesn't work when 'extends View' include 'extends ScrollView'. + return super.onKeyDown(keyCode, event); + } + + + @Override + public boolean onTouchEvent(MotionEvent ev) { + mScaleDetector.onTouchEvent(ev); + + boolean ret = false; + float x = ev.getX(); + float y = ev.getY(); + + final int action = ev.getAction(); + + switch (action & MotionEvent.ACTION_MASK) { + case MotionEvent.ACTION_DOWN: { + mRender.onActionDown(x, y); + mActivePointerId = ev.getPointerId(0); + ret = true; + break; + } + case MotionEvent.ACTION_MOVE: { + if (!mScaleDetector.isInProgress()) { + mRender.onActionMove(x, y); + } + mRender.onActionDown(x, y); + ret = true; + break; + } + + case MotionEvent.ACTION_UP: { + mActivePointerId = INVALID_POINTER_ID; + break; + } + + case MotionEvent.ACTION_CANCEL: { + mActivePointerId = INVALID_POINTER_ID; + break; + } + + case MotionEvent.ACTION_POINTER_UP: { + final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) + >> MotionEvent.ACTION_POINTER_INDEX_SHIFT; + final int pointerId = ev.getPointerId(pointerIndex); + if (pointerId == mActivePointerId) { + // This was our active pointer going up. Choose a new + // active pointer and adjust accordingly. + final int newPointerIndex = pointerIndex == 0 ? 1 : 0; + x = ev.getX(newPointerIndex); + y = ev.getY(newPointerIndex); + mRender.onActionDown(x, y); + mActivePointerId = ev.getPointerId(newPointerIndex); + } + break; + } + } + + return ret; + } + + private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener { + @Override + public boolean onScale(ScaleGestureDetector detector) { + mRender.onActionScale(detector.getScaleFactor()); + return true; + } + } +} + + diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TouchHandler.java b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TouchHandler.java new file mode 100644 index 0000000..d0f9797 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/TouchHandler.java @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.testapp; + +import android.util.Log; +import android.renderscript.Float3; +import com.android.scenegraph.*; +import com.android.scenegraph.CompoundTransform.RotateComponent; +import com.android.scenegraph.CompoundTransform.TranslateComponent; + +public class TouchHandler { + private static String TAG = "TouchHandler"; + + float mLastX; + float mLastY; + + float mRotateXValue; + float mRotateYValue; + Float3 mDistValue; + Float3 mPosValue; + + CompoundTransform mCameraRig; + RotateComponent mRotateX; + RotateComponent mRotateY; + TranslateComponent mDist; + TranslateComponent mPosition; + Camera mCamera; + + public void init(Scene scene) { + // Some initial values for camera position + mRotateXValue = -20; + mRotateYValue = 0; + mDistValue = new Float3(0, 0, 45); + mPosValue = new Float3(0, 4, 0); + + // Make a camera transform we can manipulate + mCameraRig = scene.appendNewCompoundTransform(); + mCameraRig.setName("CameraRig"); + + mPosition = mCameraRig.addTranslate("Position", mPosValue); + mRotateY = mCameraRig.addRotate("RotateY", new Float3(0, 1, 0), mRotateYValue); + mRotateX = mCameraRig.addRotate("RotateX", new Float3(1, 0, 0), mRotateXValue); + mDist = mCameraRig.addTranslate("Distance", mDistValue); + + mCamera = scene.appendNewCamera(); + mCamera.setTransform(mCameraRig); + } + + public Camera getCamera() { + return mCamera; + } + + public void onActionDown(float x, float y) { + mLastX = x; + mLastY = y; + } + + public void onActionScale(float scale) { + if (mDist == null) { + return; + } + mDistValue.z *= 1.0f / scale; + mDistValue.z = Math.max(10.0f, Math.min(mDistValue.z, 150.0f)); + mDist.setValue(mDistValue); + } + + public void onActionMove(float x, float y) { + if (mRotateX == null) { + return; + } + + float dx = mLastX - x; + float dy = mLastY - y; + + if (Math.abs(dy) <= 2.0f) { + dy = 0.0f; + } + if (Math.abs(dx) <= 2.0f) { + dx = 0.0f; + } + + mRotateYValue += dx * 0.25f; + mRotateYValue %= 360.0f; + + mRotateXValue += dy * 0.25f; + mRotateXValue = Math.max(mRotateXValue , -80.0f); + mRotateXValue = Math.min(mRotateXValue , 0.0f); + + mRotateX.setAngle(mRotateXValue); + mRotateY.setAngle(mRotateYValue); + + mLastX = x; + mLastY = y; + } +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rs b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rs new file mode 100644 index 0000000..997a1a7 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rs @@ -0,0 +1,86 @@ +// Copyright (C) 2011 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.testapp) + +#include "rs_graphics.rsh" +#include "test_app.rsh" + +// Making sure these get reflected +FBlurOffsets *blurExport; +VShaderInputs *iExport; +FShaderParams *fConst; +FShaderLightParams *fConts2; +VSParams *vConst2; +VObjectParams *vConst3; + +rs_program_vertex gPVBackground; +rs_program_fragment gPFBackground; + +rs_allocation gRobotTex; +rs_mesh gRobotMesh; + +rs_program_store gPFSBackground; + +float gRotate; + +void init() { + gRotate = 0.0f; +} + +static int pos = 50; +static float gRotateY = 120.0f; +static float3 gLookAt = 0; +static float gZoom = 50.0f; +static void displayLoading() { + if (rsIsObject(gRobotTex) && rsIsObject(gRobotMesh)) { + rsgBindProgramVertex(gPVBackground); + rs_matrix4x4 proj; + float aspect = (float)rsgGetWidth() / (float)rsgGetHeight(); + rsMatrixLoadPerspective(&proj, 30.0f, aspect, 1.0f, 100.0f); + rsgProgramVertexLoadProjectionMatrix(&proj); + + rsgBindProgramFragment(gPFBackground); + rsgBindProgramStore(gPFSBackground); + rsgBindTexture(gPFBackground, 0, gRobotTex); + + rs_matrix4x4 matrix; + rsMatrixLoadIdentity(&matrix); + // Position our models on the screen + gRotateY += rsGetDt()*100; + rsMatrixTranslate(&matrix, 0, 0, -gZoom); + rsMatrixRotate(&matrix, 20.0f, 1.0f, 0.0f, 0.0f); + rsMatrixRotate(&matrix, gRotateY, 0.0f, 1.0f, 0.0f); + rsMatrixScale(&matrix, 0.2f, 0.2f, 0.2f); + rsgProgramVertexLoadModelMatrix(&matrix); + rsgDrawMesh(gRobotMesh); + } + + uint width = rsgGetWidth(); + uint height = rsgGetHeight(); + int left = 0, right = 0, top = 0, bottom = 0; + const char* text = "Initializing..."; + rsgMeasureText(text, &left, &right, &top, &bottom); + int centeredPos = width / 2 - (right - left) / 2; + rsgDrawText(text, centeredPos, height / 2 + height / 10); +} + +int root(void) { + rsgClearColor(1.0f, 1.0f, 1.0f, 1.0f); + rsgClearDepth(1.0f); + displayLoading(); + return 30; +} diff --git a/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rsh b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rsh new file mode 100644 index 0000000..5fbcbb2 --- /dev/null +++ b/tests/RenderScriptTests/SceneGraph/src/com/android/testapp/test_app.rsh @@ -0,0 +1,52 @@ +// Copyright (C) 2012 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.testapp) + +// Helpers +typedef struct ViewProjParams { + rs_matrix4x4 viewProj; +} VSParams; + +typedef struct ModelParams { + rs_matrix4x4 model; +} VObjectParams; + +typedef struct CameraParams { + float4 cameraPos; +} FShaderParams; + +typedef struct LightParams { + float4 lightPos_0; + float4 lightColor_0; + float4 lightPos_1; + float4 lightColor_1; + float4 cameraPos; + float4 diffuse; +} FShaderLightParams; + +typedef struct BlurOffsets { + float blurOffset0; + float blurOffset1; + float blurOffset2; + float blurOffset3; +} FBlurOffsets; + +typedef struct VertexShaderInputs { + float4 position; + float3 normal; + float2 texture0; +} VShaderInputs; diff --git a/tests/RenderScriptTests/ShadersTest/src/com/android/shaderstest/shaderstest.rs b/tests/RenderScriptTests/ShadersTest/src/com/android/shaderstest/shaderstest.rs index 53f10f9..ae32e3a 100644 --- a/tests/RenderScriptTests/ShadersTest/src/com/android/shaderstest/shaderstest.rs +++ b/tests/RenderScriptTests/ShadersTest/src/com/android/shaderstest/shaderstest.rs @@ -57,6 +57,14 @@ static float gZoom; static float gLastX; static float gLastY; +static float3 toFloat3(float x, float y, float z) { + float3 f; + f.x = x; + f.y = y; + f.z = z; + return f; +} + void onActionDown(float x, float y) { gLastX = x; gLastY = y; @@ -112,8 +120,8 @@ void updateMeshInfo() { rsgMeshComputeBoundingBox(info->mMesh, &minX, &minY, &minZ, &maxX, &maxY, &maxZ); - info->bBoxMin = (minX, minY, minZ); - info->bBoxMax = (maxX, maxY, maxZ); + info->bBoxMin = toFloat3(minX, minY, minZ); + info->bBoxMax = toFloat3(maxX, maxY, maxZ); gLookAt += (info->bBoxMin + info->bBoxMax)*0.5f; } gLookAt = gLookAt / (float)size; diff --git a/tests/RenderScriptTests/SurfaceTexture/Android.mk b/tests/RenderScriptTests/SurfaceTexture/Android.mk new file mode 100644 index 0000000..bbd4d55 --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/Android.mk @@ -0,0 +1,29 @@ +# +# Copyright (C) 2012 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) + +# TODO: build fails with this set +# LOCAL_SDK_VERSION := current + +LOCAL_PACKAGE_NAME := RsSurfaceTextureOpaque + +include $(BUILD_PACKAGE) diff --git a/tests/RenderScriptTests/SurfaceTexture/AndroidManifest.xml b/tests/RenderScriptTests/SurfaceTexture/AndroidManifest.xml new file mode 100644 index 0000000..8aaa239 --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/AndroidManifest.xml @@ -0,0 +1,21 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.example.android.rs.sto"> + <uses-sdk android:minSdkVersion="14" /> + <uses-permission android:name="android.permission.CAMERA" /> + <uses-feature android:name="android.hardware.camera" /> + <uses-feature android:name="android.hardware.camera.autofocus" /> + + <application + android:label="RsSurfaceTextureOpaque" + android:hardwareAccelerated="true" + android:icon="@drawable/test_pattern"> + + <activity android:name="SurfaceTextureOpaque"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/SurfaceTexture/res/drawable/test_pattern.png b/tests/RenderScriptTests/SurfaceTexture/res/drawable/test_pattern.png Binary files differnew file mode 100644 index 0000000..e7d1455 --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/res/drawable/test_pattern.png diff --git a/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/CameraCapture.java b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/CameraCapture.java new file mode 100644 index 0000000..afdab41 --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/CameraCapture.java @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package com.example.android.rs.sto; + +import android.graphics.SurfaceTexture; +import android.hardware.Camera; +import android.os.SystemClock; +import android.util.Log; + +import java.io.IOException; +import java.util.List; + +public class CameraCapture { + + public interface CameraFrameListener { + public void onNewCameraFrame(); + } + + static final int FRAMES_PER_SEC = 30; + + private Camera mCamera; + private SurfaceTexture mSurfaceTexture; + + private int mProgram; + + private int mCameraTransformHandle; + private int mTexSamplerHandle; + private int mTexCoordHandle; + private int mPosCoordHandle; + + private float[] mCameraTransform = new float[16]; + + private int mCameraId = 0; + private int mWidth; + private int mHeight; + + private long mStartCaptureTime = 0; + + private boolean mNewFrameAvailable = false; + private boolean mIsOpen = false; + + private CameraFrameListener mListener; + + public synchronized void beginCapture(int cameraId, int width, int height, + SurfaceTexture st) { + mCameraId = cameraId; + mSurfaceTexture = st; + + // Open the camera + openCamera(width, height); + + // Start the camera + mStartCaptureTime = SystemClock.elapsedRealtime(); + mCamera.startPreview(); + mIsOpen = true; + } + + public void getCurrentFrame() { + if (checkNewFrame()) { + if (mStartCaptureTime > 0 && SystemClock.elapsedRealtime() - mStartCaptureTime > 2000) { + // Lock white-balance and exposure for effects + Log.i("CC", "Locking white-balance and exposure!"); + Camera.Parameters params = mCamera.getParameters(); + params.setAutoWhiteBalanceLock(true); + params.setAutoExposureLock(true); + //mCamera.setParameters(params); + mStartCaptureTime = 0; + } + + mSurfaceTexture.updateTexImage(); + mSurfaceTexture.getTransformMatrix(mCameraTransform); + + // display it here + } + } + + public synchronized boolean hasNewFrame() { + return mNewFrameAvailable; + } + + public synchronized void endCapture() { + mIsOpen = false; + if (mCamera != null) { + mCamera.release(); + mCamera = null; + mSurfaceTexture = null; + } + } + + public synchronized boolean isOpen() { + return mIsOpen; + } + + public int getWidth() { + return mWidth; + } + + public int getHeight() { + return mHeight; + } + + public void setCameraFrameListener(CameraFrameListener listener) { + mListener = listener; + } + + private void openCamera(int width, int height) { + // Setup camera + mCamera = Camera.open(mCameraId); + mCamera.setParameters(calcCameraParameters(width, height)); + + // Create camera surface texture + try { + mCamera.setPreviewTexture(mSurfaceTexture); + } catch (IOException e) { + throw new RuntimeException("Could not bind camera surface texture: " + + e.getMessage() + "!"); + } + + // Connect SurfaceTexture to callback + mSurfaceTexture.setOnFrameAvailableListener(onCameraFrameAvailableListener); + } + + private Camera.Parameters calcCameraParameters(int width, int height) { + Camera.Parameters params = mCamera.getParameters(); + params.setPreviewSize(mWidth, mHeight); + + // Find closest size + int closestSize[] = findClosestSize(width, height, params); + mWidth = closestSize[0]; + mHeight = closestSize[1]; + params.setPreviewSize(mWidth, mHeight); + + // Find closest FPS + int closestRange[] = findClosestFpsRange(FRAMES_PER_SEC, params); + + params.setPreviewFpsRange(closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX], + closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]); + + return params; + } + + private int[] findClosestSize(int width, int height, Camera.Parameters parameters) { + List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes(); + int closestWidth = -1; + int closestHeight = -1; + int smallestWidth = previewSizes.get(0).width; + int smallestHeight = previewSizes.get(0).height; + for (Camera.Size size : previewSizes) { + // Best match defined as not being larger in either dimension than + // the requested size, but as close as possible. The below isn't a + // stable selection (reording the size list can give different + // results), but since this is a fallback nicety, that's acceptable. + if ( size.width <= width && + size.height <= height && + size.width >= closestWidth && + size.height >= closestHeight) { + closestWidth = size.width; + closestHeight = size.height; + } + if ( size.width < smallestWidth && + size.height < smallestHeight) { + smallestWidth = size.width; + smallestHeight = size.height; + } + } + if (closestWidth == -1) { + // Requested size is smaller than any listed size; match with smallest possible + closestWidth = smallestWidth; + closestHeight = smallestHeight; + } + int[] closestSize = {closestWidth, closestHeight}; + return closestSize; + } + + private int[] findClosestFpsRange(int fps, Camera.Parameters params) { + List<int[]> supportedFpsRanges = params.getSupportedPreviewFpsRange(); + int[] closestRange = supportedFpsRanges.get(0); + int fpsk = fps * 1000; + int minDiff = 1000000; + for (int[] range : supportedFpsRanges) { + int low = range[Camera.Parameters.PREVIEW_FPS_MIN_INDEX]; + int high = range[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]; + if (low <= fpsk && high >= fpsk) { + int diff = (fpsk - low) + (high - fpsk); + if (diff < minDiff) { + closestRange = range; + minDiff = diff; + } + } + } + Log.i("CC", "Found closest range: " + + closestRange[Camera.Parameters.PREVIEW_FPS_MIN_INDEX] + " - " + + closestRange[Camera.Parameters.PREVIEW_FPS_MAX_INDEX]); + return closestRange; + } + + private synchronized void signalNewFrame() { + mNewFrameAvailable = true; + if (mListener != null) { + mListener.onNewCameraFrame(); + } + } + + private synchronized boolean checkNewFrame() { + if (mNewFrameAvailable) { + mNewFrameAvailable = false; + return true; + } + return false; + } + + private SurfaceTexture.OnFrameAvailableListener onCameraFrameAvailableListener = + new SurfaceTexture.OnFrameAvailableListener() { + @Override + public void onFrameAvailable(SurfaceTexture surfaceTexture) { + signalNewFrame(); + } + }; +} diff --git a/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaque.java b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaque.java new file mode 100644 index 0000000..a51edaa --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaque.java @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.android.rs.sto; + +import android.app.Activity; +import android.os.Bundle; +import android.provider.Settings.System; +import android.util.Log; +import android.view.View; +import android.graphics.SurfaceTexture; + +import java.lang.Runtime; + +public class SurfaceTextureOpaque extends Activity { + private SurfaceTextureOpaqueView mView; + CameraCapture mCC; + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + mView = new SurfaceTextureOpaqueView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + super.onResume(); + mView.resume(); + startCamera(); + } + + @Override + protected void onPause() { + super.onPause(); + mView.pause(); + mCC.endCapture(); + } + + cfl mCFL; + public void startCamera() { + mCC = new CameraCapture(); + mCFL = new cfl(); + + mCC.setCameraFrameListener(mCFL); + + mCC.beginCapture(1, 640, 480, mView.getST()); + } + + public class cfl implements CameraCapture.CameraFrameListener { + public void onNewCameraFrame() { + mView.mRender.newFrame(); + } + } + +} + diff --git a/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueRS.java b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueRS.java new file mode 100644 index 0000000..b638b7d --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueRS.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.android.rs.sto; + +import android.content.res.Resources; +import android.renderscript.*; +import android.graphics.SurfaceTexture; +import android.util.Log; + + +public class SurfaceTextureOpaqueRS { + static final private int NUM_CAMERA_PREVIEW_BUFFERS = 2; + + public SurfaceTextureOpaqueRS() { + } + + private Resources mRes; + private RenderScriptGL mRS; + private ScriptC_sto mScript; + private SurfaceTexture mST; + private Allocation mSto; + private Allocation mSto2; + private Allocation mRto; + private ProgramFragment mPF; + + public void init(RenderScriptGL rs, Resources res) { + mRS = rs; + mRes = res; + + Type.Builder tb = new Type.Builder(mRS, Element.RGBA_8888(mRS)); + tb.setX(640); + tb.setY(480); + mSto = Allocation.createTyped(mRS, tb.create(), Allocation.USAGE_GRAPHICS_TEXTURE | + Allocation.USAGE_IO_INPUT); + mRto = Allocation.createTyped(mRS, tb.create(), Allocation.USAGE_GRAPHICS_RENDER_TARGET | + Allocation.USAGE_IO_OUTPUT); + mSto2 = Allocation.createTyped(mRS, tb.create(), Allocation.USAGE_GRAPHICS_TEXTURE | + Allocation.USAGE_IO_INPUT); + mST = mSto.getSurfaceTexture(); + mRto.setSurfaceTexture(mSto2.getSurfaceTexture()); + + ProgramFragmentFixedFunction.Builder pfb = new ProgramFragmentFixedFunction.Builder(rs); + pfb.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE, + ProgramFragmentFixedFunction.Builder.Format.RGBA, 0); + mPF = pfb.create(); + mPF.bindSampler(Sampler.CLAMP_NEAREST(mRS), 0); + rs.bindProgramFragment(mPF); + + mScript = new ScriptC_sto(mRS, mRes, R.raw.sto); + mScript.set_sto(mSto); + mScript.set_rto(mRto); + mScript.set_sto2(mSto2); + mScript.set_pf(mPF); + + mRS.bindRootScript(mScript); + + + android.util.Log.v("sto", "Init complete"); + } + + SurfaceTexture getST() { + return mST; + } + + public void newFrame() { + mSto.ioReceive(); + } + +} diff --git a/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueView.java b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueView.java new file mode 100644 index 0000000..f5e49f2 --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/SurfaceTextureOpaqueView.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.example.android.rs.sto; + + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScriptGL; +import android.content.Context; +import android.content.res.Resources; +import android.graphics.SurfaceTexture; +import android.util.Log; + +public class SurfaceTextureOpaqueView extends RSSurfaceView { + + public SurfaceTextureOpaqueView(Context context) { + super(context); + } + + RenderScriptGL mRS; + SurfaceTextureOpaqueRS mRender; + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + } + + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + if (mRS != null) { + mRS = null; + destroyRenderScriptGL(); + } + } + + SurfaceTexture getST() { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + mRS = createRenderScriptGL(sc); + mRender = new SurfaceTextureOpaqueRS(); + mRender.init(mRS, getResources()); + return mRender.getST(); + } + +} + + diff --git a/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/sto.rs b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/sto.rs new file mode 100644 index 0000000..efa901a --- /dev/null +++ b/tests/RenderScriptTests/SurfaceTexture/src/com/example/android/rs/sto/sto.rs @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma version(1) +#pragma rs java_package_name(com.example.android.rs.sto) + +#pragma stateFragment(parent) + +#include "rs_graphics.rsh" + + +rs_program_fragment pf; +rs_allocation sto; // camera in +rs_allocation sto2; +rs_allocation rto; // render target + +int root() { + rsgBindTexture(pf, 0, sto); + +#if 1 + rsgBindColorTarget(rto, 0); + + rsgClearColor(0.f, 1.f, 0.f, 1.f); + rsgDrawQuadTexCoords(0, 0, 0, 0,0, + 0,500,0, 1,0, + 500,500,0, 1, 1, + 500, 0, 0, 0, 1 ); + rsgClearColorTarget(0); + + // io ops + rsAllocationIoSend(rto); + rsAllocationIoReceive(sto2); + + rsgBindTexture(pf, 0, sto2); +#endif + + rsgClearColor(0.f, 1.f, 0.f, 1.f); + rsgDrawQuadTexCoords(0, 0, 0, 0,0, + 0,500,0, 1,0, + 500,500,0, 1, 1, + 500, 0, 0, 0, 1 ); + + return 1; +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/RSTestCore.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/RSTestCore.java index c038478..22e1bff 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/RSTestCore.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/RSTestCore.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008-2011 The Android Open Source Project + * Copyright (C) 2008-2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -65,15 +65,27 @@ public class RSTestCore { unitTests = new ArrayList<UnitTest>(); unitTests.add(new UT_primitives(this, mRes, mCtx)); + unitTests.add(new UT_constant(this, mRes, mCtx)); unitTests.add(new UT_vector(this, mRes, mCtx)); + unitTests.add(new UT_array_init(this, mRes, mCtx)); + unitTests.add(new UT_convert(this, mRes, mCtx)); unitTests.add(new UT_rsdebug(this, mRes, mCtx)); unitTests.add(new UT_rstime(this, mRes, mCtx)); unitTests.add(new UT_rstypes(this, mRes, mCtx)); unitTests.add(new UT_alloc(this, mRes, mCtx)); unitTests.add(new UT_refcount(this, mRes, mCtx)); unitTests.add(new UT_foreach(this, mRes, mCtx)); + unitTests.add(new UT_noroot(this, mRes, mCtx)); + unitTests.add(new UT_atomic(this, mRes, mCtx)); + unitTests.add(new UT_struct(this, mRes, mCtx)); unitTests.add(new UT_math(this, mRes, mCtx)); + unitTests.add(new UT_mesh(this, mRes, mCtx)); + unitTests.add(new UT_element(this, mRes, mCtx)); + unitTests.add(new UT_sampler(this, mRes, mCtx)); + unitTests.add(new UT_program_store(this, mRes, mCtx)); + unitTests.add(new UT_program_raster(this, mRes, mCtx)); unitTests.add(new UT_fp_mad(this, mRes, mCtx)); + /* unitTests.add(new UnitTest(null, "<Pass>", 1)); unitTests.add(new UnitTest()); @@ -91,7 +103,7 @@ public class RSTestCore { for (int i = 0; i < uta.length; i++) { ScriptField_ListAllocs_s.Item listElem = new ScriptField_ListAllocs_s.Item(); listElem.text = Allocation.createFromString(mRS, uta[i].name, Allocation.USAGE_SCRIPT); - listElem.result = uta[i].result; + listElem.result = uta[i].getResult(); mListAllocs.set(listElem, i, false); uta[i].setItem(listElem); } diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_array_init.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_array_init.java new file mode 100644 index 0000000..b98b753 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_array_init.java @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_array_init extends UnitTest { + private Resources mRes; + + protected UT_array_init(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Array Init", ctx); + mRes = res; + } + + private void checkInit(ScriptC_array_init s) { + float[] fa = s.get_fa(); + _RS_ASSERT("fa[0] == 1.0", fa[0] == 1.0); + _RS_ASSERT("fa[1] == 9.9999f", fa[1] == 9.9999f); + _RS_ASSERT("fa[2] == 0", fa[2] == 0); + _RS_ASSERT("fa[3] == 0", fa[3] == 0); + _RS_ASSERT("fa.length == 4", fa.length == 4); + + double[] da = s.get_da(); + _RS_ASSERT("da[0] == 7.0", da[0] == 7.0); + _RS_ASSERT("da[1] == 8.88888", da[1] == 8.88888); + _RS_ASSERT("da.length == 2", da.length == 2); + + byte[] ca = s.get_ca(); + _RS_ASSERT("ca[0] == 'a'", ca[0] == 'a'); + _RS_ASSERT("ca[1] == 7", ca[1] == 7); + _RS_ASSERT("ca[2] == 'b'", ca[2] == 'b'); + _RS_ASSERT("ca[3] == 'c'", ca[3] == 'c'); + _RS_ASSERT("ca.length == 4", ca.length == 4); + + short[] sa = s.get_sa(); + _RS_ASSERT("sa[0] == 1", sa[0] == 1); + _RS_ASSERT("sa[1] == 1", sa[1] == 1); + _RS_ASSERT("sa[2] == 2", sa[2] == 2); + _RS_ASSERT("sa[3] == 3", sa[3] == 3); + _RS_ASSERT("sa.length == 4", sa.length == 4); + + int[] ia = s.get_ia(); + _RS_ASSERT("ia[0] == 5", ia[0] == 5); + _RS_ASSERT("ia[1] == 8", ia[1] == 8); + _RS_ASSERT("ia[2] == 0", ia[2] == 0); + _RS_ASSERT("ia[3] == 0", ia[3] == 0); + _RS_ASSERT("ia.length == 4", ia.length == 4); + + long[] la = s.get_la(); + _RS_ASSERT("la[0] == 13", la[0] == 13); + _RS_ASSERT("la[1] == 21", la[1] == 21); + _RS_ASSERT("la.length == 4", la.length == 2); + + long[] lla = s.get_lla(); + _RS_ASSERT("lla[0] == 34", lla[0] == 34); + _RS_ASSERT("lla[1] == 0", lla[1] == 0); + _RS_ASSERT("lla[2] == 0", lla[2] == 0); + _RS_ASSERT("lla[3] == 0", lla[3] == 0); + _RS_ASSERT("lla.length == 4", lla.length == 4); + + boolean[] ba = s.get_ba(); + _RS_ASSERT("ba[0] == true", ba[0] == true); + _RS_ASSERT("ba[1] == false", ba[1] == false); + _RS_ASSERT("ba[2] == false", ba[2] == false); + _RS_ASSERT("ba.length == 3", ba.length == 3); + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_array_init s = new ScriptC_array_init(pRS, mRes, R.raw.array_init); + pRS.setMessageHandler(mRsMessage); + checkInit(s); + s.invoke_array_init_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + passTest(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_atomic.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_atomic.java new file mode 100644 index 0000000..267c5b2 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_atomic.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_atomic extends UnitTest { + private Resources mRes; + + protected UT_atomic(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Atomics", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_atomic s = new ScriptC_atomic(pRS, mRes, R.raw.atomic); + pRS.setMessageHandler(mRsMessage); + s.invoke_atomic_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_constant.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_constant.java new file mode 100644 index 0000000..adda5a3 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_constant.java @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_constant extends UnitTest { + private Resources mRes; + + protected UT_constant(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Const", ctx); + mRes = res; + } + + private void Assert(boolean b) { + if (!b) { + failTest(); + } + } + + public void run() { + Assert(ScriptC_constant.const_floatTest == 1.99f); + Assert(ScriptC_constant.const_doubleTest == 2.05); + Assert(ScriptC_constant.const_charTest == -8); + Assert(ScriptC_constant.const_shortTest == -16); + Assert(ScriptC_constant.const_intTest == -32); + Assert(ScriptC_constant.const_longTest == 17179869184l); + Assert(ScriptC_constant.const_longlongTest == 68719476736l); + + Assert(ScriptC_constant.const_ucharTest == 8); + Assert(ScriptC_constant.const_ushortTest == 16); + Assert(ScriptC_constant.const_uintTest == 32); + Assert(ScriptC_constant.const_ulongTest == 4611686018427387904L); + Assert(ScriptC_constant.const_int64_tTest == -17179869184l); + Assert(ScriptC_constant.const_uint64_tTest == 117179869184l); + + Assert(ScriptC_constant.const_boolTest == true); + + passTest(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_convert.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_convert.java new file mode 100644 index 0000000..4fc6c55 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_convert.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_convert extends UnitTest { + private Resources mRes; + + protected UT_convert(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Convert", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_convert s = new ScriptC_convert(pRS, mRes, R.raw.convert); + pRS.setMessageHandler(mRsMessage); + s.invoke_convert_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_element.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_element.java new file mode 100644 index 0000000..3e2a2ca --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_element.java @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.Element.*; +import android.renderscript.Element.DataKind.*; +import android.renderscript.Element.DataType.*; + +public class UT_element extends UnitTest { + private Resources mRes; + + Element simpleElem; + Element complexElem; + + final String subElemNames[] = { + "subElem0", + "subElem1", + "subElem2", + "arrayElem0", + "arrayElem1", + "subElem3", + "subElem4", + "subElem5", + "subElem6", + "subElem_7", + }; + + final int subElemArraySizes[] = { + 1, + 1, + 1, + 2, + 5, + 1, + 1, + 1, + 1, + 1, + }; + + final int subElemOffsets[] = { + 0, + 4, + 8, + 12, + 20, + 40, + 44, + 48, + 64, + 80, + }; + + protected UT_element(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Element", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_element s) { + simpleElem = Element.F32_3(RS); + complexElem = ScriptField_ComplexStruct.createElement(RS); + s.set_simpleElem(simpleElem); + s.set_complexElem(complexElem); + + ScriptField_ComplexStruct data = new ScriptField_ComplexStruct(RS, 1); + s.bind_complexStruct(data); + } + + private void testScriptSide(RenderScript pRS) { + ScriptC_element s = new ScriptC_element(pRS, mRes, R.raw.element); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_element_test(); + pRS.finish(); + waitForMessage(); + } + + private void testJavaSide(RenderScript RS) { + + int subElemCount = simpleElem.getSubElementCount(); + _RS_ASSERT("subElemCount == 0", subElemCount == 0); + _RS_ASSERT("simpleElem.getDataKind() == USER", + simpleElem.getDataKind() == DataKind.USER); + _RS_ASSERT("simpleElem.getDataType() == FLOAT_32", + simpleElem.getDataType() == DataType.FLOAT_32); + + subElemCount = complexElem.getSubElementCount(); + _RS_ASSERT("subElemCount == 10", subElemCount == 10); + _RS_ASSERT("complexElem.getDataKind() == USER", + complexElem.getDataKind() == DataKind.USER); + _RS_ASSERT("complexElemsimpleElem.getDataType() == NONE", + complexElem.getDataType() == DataType.NONE); + _RS_ASSERT("complexElem.getSizeBytes() == ScriptField_ComplexStruct.Item.sizeof", + complexElem.getSizeBytes() == ScriptField_ComplexStruct.Item.sizeof); + + for (int i = 0; i < subElemCount; i ++) { + _RS_ASSERT("complexElem.getSubElement(i) != null", + complexElem.getSubElement(i) != null); + _RS_ASSERT("complexElem.getSubElementName(i).equals(subElemNames[i])", + complexElem.getSubElementName(i).equals(subElemNames[i])); + _RS_ASSERT("complexElem.getSubElementArraySize(i) == subElemArraySizes[i]", + complexElem.getSubElementArraySize(i) == subElemArraySizes[i]); + _RS_ASSERT("complexElem.getSubElementOffsetBytes(i) == subElemOffsets[i]", + complexElem.getSubElementOffsetBytes(i) == subElemOffsets[i]); + } + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + testScriptSide(pRS); + testJavaSide(pRS); + passTest(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_foreach.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_foreach.java index 1d2555e..04e9270 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_foreach.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_foreach.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 The Android Open Source Project + * Copyright (C) 2011-2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -48,6 +48,9 @@ public class UT_foreach extends UnitTest { pRS.setMessageHandler(mRsMessage); initializeGlobals(pRS, s); s.forEach_root(A); + s.invoke_verify_root(); + s.forEach_foo(A, A); + s.invoke_verify_foo(); s.invoke_foreach_test(); pRS.finish(); waitForMessage(); diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_mesh.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_mesh.java new file mode 100644 index 0000000..0c93702 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_mesh.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.Mesh.*; + +public class UT_mesh extends UnitTest { + private Resources mRes; + + Mesh mesh; + + protected UT_mesh(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Mesh", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_mesh s) { + Allocation vAlloc0 = Allocation.createSized(RS, Element.F32(RS), 10); + Allocation vAlloc1 = Allocation.createSized(RS, Element.F32_2(RS), 10); + + Allocation iAlloc0 = Allocation.createSized(RS, Element.I16(RS), 10); + Allocation iAlloc2 = Allocation.createSized(RS, Element.I16(RS), 10); + + Mesh.AllocationBuilder mBuilder = new Mesh.AllocationBuilder(RS); + mBuilder.addVertexAllocation(vAlloc0); + mBuilder.addVertexAllocation(vAlloc1); + + mBuilder.addIndexSetAllocation(iAlloc0, Primitive.POINT); + mBuilder.addIndexSetType(Primitive.LINE); + mBuilder.addIndexSetAllocation(iAlloc2, Primitive.TRIANGLE); + + s.set_mesh(mBuilder.create()); + s.set_vertexAlloc0(vAlloc0); + s.set_vertexAlloc1(vAlloc1); + s.set_indexAlloc0(iAlloc0); + s.set_indexAlloc2(iAlloc2); + } + + private void testScriptSide(RenderScript pRS) { + ScriptC_mesh s = new ScriptC_mesh(pRS, mRes, R.raw.mesh); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_mesh_test(); + pRS.finish(); + waitForMessage(); + } + + private void testJavaSide(RenderScript RS) { + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + testScriptSide(pRS); + testJavaSide(pRS); + passTest(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_noroot.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_noroot.java new file mode 100644 index 0000000..c660fc5 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_noroot.java @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2011-2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_noroot extends UnitTest { + private Resources mRes; + private Allocation A; + + protected UT_noroot(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "ForEach (no root)", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_noroot s) { + Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS)); + int X = 5; + int Y = 7; + s.set_dimX(X); + s.set_dimY(Y); + typeBuilder.setX(X).setY(Y); + A = Allocation.createTyped(RS, typeBuilder.create()); + s.bind_a(A); + + return; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_noroot s = new ScriptC_noroot(pRS, mRes, R.raw.noroot); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.forEach_foo(A, A); + s.invoke_verify_foo(); + s.invoke_noroot_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_primitives.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_primitives.java index b7a65a5..18829c2 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_primitives.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_primitives.java @@ -92,8 +92,7 @@ public class UT_primitives extends UnitTest { ScriptC_primitives s = new ScriptC_primitives(pRS, mRes, R.raw.primitives); pRS.setMessageHandler(mRsMessage); if (!initializeGlobals(s)) { - // initializeGlobals failed - result = -1; + failTest(); } else { s.invoke_primitives_test(0, 0); pRS.finish(); diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_raster.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_raster.java new file mode 100644 index 0000000..1de4d71 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_raster.java @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.ProgramRaster; +import android.renderscript.ProgramRaster.CullMode; + +public class UT_program_raster extends UnitTest { + private Resources mRes; + + ProgramRaster pointSpriteEnabled; + ProgramRaster cullMode; + + protected UT_program_raster(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "ProgramRaster", ctx); + mRes = res; + } + + private ProgramRaster.Builder getDefaultBuilder(RenderScript RS) { + ProgramRaster.Builder b = new ProgramRaster.Builder(RS); + b.setCullMode(CullMode.BACK); + b.setPointSpriteEnabled(false); + return b; + } + + private void initializeGlobals(RenderScript RS, ScriptC_program_raster s) { + ProgramRaster.Builder b = getDefaultBuilder(RS); + pointSpriteEnabled = b.setPointSpriteEnabled(true).create(); + b = getDefaultBuilder(RS); + cullMode = b.setCullMode(CullMode.FRONT).create(); + + s.set_pointSpriteEnabled(pointSpriteEnabled); + s.set_cullMode(cullMode); + } + + private void testScriptSide(RenderScript pRS) { + ScriptC_program_raster s = new ScriptC_program_raster(pRS, mRes, R.raw.program_raster); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_program_raster_test(); + pRS.finish(); + waitForMessage(); + } + + private void testJavaSide(RenderScript RS) { + _RS_ASSERT("pointSpriteEnabled.getPointSpriteEnabled() == true", + pointSpriteEnabled.getPointSpriteEnabled() == true); + _RS_ASSERT("pointSpriteEnabled.getCullMode() == ProgramRaster.CullMode.BACK", + pointSpriteEnabled.getCullMode() == ProgramRaster.CullMode.BACK); + + _RS_ASSERT("cullMode.getPointSpriteEnabled() == false", + cullMode.getPointSpriteEnabled() == false); + _RS_ASSERT("cullMode.getCullMode() == ProgramRaster.CullMode.FRONT", + cullMode.getCullMode() == ProgramRaster.CullMode.FRONT); + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + testScriptSide(pRS); + testJavaSide(pRS); + passTest(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_store.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_store.java new file mode 100644 index 0000000..72a401d --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_program_store.java @@ -0,0 +1,175 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.ProgramStore.BlendDstFunc; +import android.renderscript.ProgramStore.BlendSrcFunc; +import android.renderscript.ProgramStore.Builder; +import android.renderscript.ProgramStore.DepthFunc; + +public class UT_program_store extends UnitTest { + private Resources mRes; + + ProgramStore ditherEnable; + ProgramStore colorRWriteEnable; + ProgramStore colorGWriteEnable; + ProgramStore colorBWriteEnable; + ProgramStore colorAWriteEnable; + ProgramStore blendSrc; + ProgramStore blendDst; + ProgramStore depthWriteEnable; + ProgramStore depthFunc; + + protected UT_program_store(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "ProgramStore", ctx); + mRes = res; + } + + private ProgramStore.Builder getDefaultBuilder(RenderScript RS) { + ProgramStore.Builder b = new ProgramStore.Builder(RS); + b.setBlendFunc(ProgramStore.BlendSrcFunc.ZERO, ProgramStore.BlendDstFunc.ZERO); + b.setColorMaskEnabled(false, false, false, false); + b.setDepthFunc(ProgramStore.DepthFunc.ALWAYS); + b.setDepthMaskEnabled(false); + b.setDitherEnabled(false); + return b; + } + + private void initializeGlobals(RenderScript RS, ScriptC_program_store s) { + ProgramStore.Builder b = getDefaultBuilder(RS); + ditherEnable = b.setDitherEnabled(true).create(); + + b = getDefaultBuilder(RS); + colorRWriteEnable = b.setColorMaskEnabled(true, false, false, false).create(); + + b = getDefaultBuilder(RS); + colorGWriteEnable = b.setColorMaskEnabled(false, true, false, false).create(); + + b = getDefaultBuilder(RS); + colorBWriteEnable = b.setColorMaskEnabled(false, false, true, false).create(); + + b = getDefaultBuilder(RS); + colorAWriteEnable = b.setColorMaskEnabled(false, false, false, true).create(); + + b = getDefaultBuilder(RS); + blendSrc = b.setBlendFunc(ProgramStore.BlendSrcFunc.DST_COLOR, + ProgramStore.BlendDstFunc.ZERO).create(); + + b = getDefaultBuilder(RS); + blendDst = b.setBlendFunc(ProgramStore.BlendSrcFunc.ZERO, + ProgramStore.BlendDstFunc.DST_ALPHA).create(); + + b = getDefaultBuilder(RS); + depthWriteEnable = b.setDepthMaskEnabled(true).create(); + + b = getDefaultBuilder(RS); + depthFunc = b.setDepthFunc(ProgramStore.DepthFunc.GREATER).create(); + + s.set_ditherEnable(ditherEnable); + s.set_colorRWriteEnable(colorRWriteEnable); + s.set_colorGWriteEnable(colorGWriteEnable); + s.set_colorBWriteEnable(colorBWriteEnable); + s.set_colorAWriteEnable(colorAWriteEnable); + s.set_blendSrc(blendSrc); + s.set_blendDst(blendDst); + s.set_depthWriteEnable(depthWriteEnable); + s.set_depthFunc(depthFunc); + } + + private void testScriptSide(RenderScript pRS) { + ScriptC_program_store s = new ScriptC_program_store(pRS, mRes, R.raw.program_store); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_program_store_test(); + pRS.finish(); + waitForMessage(); + } + + void checkObject(ProgramStore ps, + boolean depthMask, + DepthFunc df, + BlendSrcFunc bsf, + BlendDstFunc bdf, + boolean R, + boolean G, + boolean B, + boolean A, + boolean dither) { + _RS_ASSERT("ps.getDepthMaskEnabled() == depthMask", ps.getDepthMaskEnabled() == depthMask); + _RS_ASSERT("ps.getDepthFunc() == df", ps.getDepthFunc() == df); + _RS_ASSERT("ps.getBlendSrcFunc() == bsf", ps.getBlendSrcFunc() == bsf); + _RS_ASSERT("ps.getBlendDstFunc() == bdf", ps.getBlendDstFunc() == bdf); + _RS_ASSERT("ps.getColorMaskREnabled() == R", ps.getColorMaskREnabled() == R); + _RS_ASSERT("ps.getColorMaskGEnabled() == G", ps.getColorMaskGEnabled() == G); + _RS_ASSERT("ps.getColorMaskBEnabled() == B", ps.getColorMaskBEnabled() == B); + _RS_ASSERT("ps.getColorMaskAEnabled() == A", ps.getColorMaskAEnabled() == A); + _RS_ASSERT("ps.getDitherEnabled() == dither", ps.getDitherEnabled() == dither); + } + + void varyBuilderColorAndDither(ProgramStore.Builder pb, + boolean depthMask, + DepthFunc df, + BlendSrcFunc bsf, + BlendDstFunc bdf) { + for (int r = 0; r <= 1; r++) { + boolean isR = (r == 1); + for (int g = 0; g <= 1; g++) { + boolean isG = (g == 1); + for (int b = 0; b <= 1; b++) { + boolean isB = (b == 1); + for (int a = 0; a <= 1; a++) { + boolean isA = (a == 1); + for (int dither = 0; dither <= 1; dither++) { + boolean isDither = (dither == 1); + pb.setDitherEnabled(isDither); + pb.setColorMaskEnabled(isR, isG, isB, isA); + ProgramStore ps = pb.create(); + checkObject(ps, depthMask, df, bsf, bdf, isR, isG, isB, isA, isDither); + } + } + } + } + } + } + + public void testJavaSide(RenderScript RS) { + for (int depth = 0; depth <= 1; depth++) { + boolean depthMask = (depth == 1); + for (DepthFunc df : DepthFunc.values()) { + for (BlendSrcFunc bsf : BlendSrcFunc.values()) { + for (BlendDstFunc bdf : BlendDstFunc.values()) { + ProgramStore.Builder b = new ProgramStore.Builder(RS); + b.setDepthFunc(df); + b.setDepthMaskEnabled(depthMask); + b.setBlendFunc(bsf, bdf); + varyBuilderColorAndDither(b, depthMask, df, bsf, bdf); + } + } + } + } + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + testJavaSide(pRS); + testScriptSide(pRS); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_rstime.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_rstime.java index f302e1a..21e657c 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_rstime.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_rstime.java @@ -32,6 +32,7 @@ public class UT_rstime extends UnitTest { RenderScript pRS = RenderScript.create(mCtx); ScriptC_rstime s = new ScriptC_rstime(pRS, mRes, R.raw.rstime); pRS.setMessageHandler(mRsMessage); + s.setTimeZone("America/Los_Angeles"); s.invoke_test_rstime(0, 0); pRS.finish(); waitForMessage(); diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_sampler.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_sampler.java new file mode 100644 index 0000000..c328cf6 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_sampler.java @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.renderscript.Sampler; +import android.renderscript.Sampler.Value; + +public class UT_sampler extends UnitTest { + private Resources mRes; + + Sampler minification; + Sampler magnification; + Sampler wrapS; + Sampler wrapT; + Sampler anisotropy; + + protected UT_sampler(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Sampler", ctx); + mRes = res; + } + + private Sampler.Builder getDefaultBuilder(RenderScript RS) { + Sampler.Builder b = new Sampler.Builder(RS); + b.setMinification(Value.NEAREST); + b.setMagnification(Value.NEAREST); + b.setWrapS(Value.CLAMP); + b.setWrapT(Value.CLAMP); + b.setAnisotropy(1.0f); + return b; + } + + private void initializeGlobals(RenderScript RS, ScriptC_sampler s) { + Sampler.Builder b = getDefaultBuilder(RS); + b.setMinification(Value.LINEAR_MIP_LINEAR); + minification = b.create(); + + b = getDefaultBuilder(RS); + b.setMagnification(Value.LINEAR); + magnification = b.create(); + + b = getDefaultBuilder(RS); + b.setWrapS(Value.WRAP); + wrapS = b.create(); + + b = getDefaultBuilder(RS); + b.setWrapT(Value.WRAP); + wrapT = b.create(); + + b = getDefaultBuilder(RS); + b.setAnisotropy(8.0f); + anisotropy = b.create(); + + s.set_minification(minification); + s.set_magnification(magnification); + s.set_wrapS(wrapS); + s.set_wrapT(wrapT); + s.set_anisotropy(anisotropy); + } + + private void testScriptSide(RenderScript pRS) { + ScriptC_sampler s = new ScriptC_sampler(pRS, mRes, R.raw.sampler); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_sampler_test(); + pRS.finish(); + waitForMessage(); + } + + private void testJavaSide(RenderScript RS) { + _RS_ASSERT("minification.getMagnification() == Sampler.Value.NEAREST", + minification.getMagnification() == Sampler.Value.NEAREST); + _RS_ASSERT("minification.getMinification() == Sampler.Value.LINEAR_MIP_LINEAR", + minification.getMinification() == Sampler.Value.LINEAR_MIP_LINEAR); + _RS_ASSERT("minification.getWrapS() == Sampler.Value.CLAMP", + minification.getWrapS() == Sampler.Value.CLAMP); + _RS_ASSERT("minification.getWrapT() == Sampler.Value.CLAMP", + minification.getWrapT() == Sampler.Value.CLAMP); + _RS_ASSERT("minification.getAnisotropy() == 1.0f", + minification.getAnisotropy() == 1.0f); + + _RS_ASSERT("magnification.getMagnification() == Sampler.Value.LINEAR", + magnification.getMagnification() == Sampler.Value.LINEAR); + _RS_ASSERT("magnification.getMinification() == Sampler.Value.NEAREST", + magnification.getMinification() == Sampler.Value.NEAREST); + _RS_ASSERT("magnification.getWrapS() == Sampler.Value.CLAMP", + magnification.getWrapS() == Sampler.Value.CLAMP); + _RS_ASSERT("magnification.getWrapT() == Sampler.Value.CLAMP", + magnification.getWrapT() == Sampler.Value.CLAMP); + _RS_ASSERT("magnification.getAnisotropy() == 1.0f", + magnification.getAnisotropy() == 1.0f); + + _RS_ASSERT("wrapS.getMagnification() == Sampler.Value.NEAREST", + wrapS.getMagnification() == Sampler.Value.NEAREST); + _RS_ASSERT("wrapS.getMinification() == Sampler.Value.NEAREST", + wrapS.getMinification() == Sampler.Value.NEAREST); + _RS_ASSERT("wrapS.getWrapS() == Sampler.Value.WRAP", + wrapS.getWrapS() == Sampler.Value.WRAP); + _RS_ASSERT("wrapS.getWrapT() == Sampler.Value.CLAMP", + wrapS.getWrapT() == Sampler.Value.CLAMP); + _RS_ASSERT("wrapS.getAnisotropy() == 1.0f", + wrapS.getAnisotropy() == 1.0f); + + _RS_ASSERT("wrapT.getMagnification() == Sampler.Value.NEAREST", + wrapT.getMagnification() == Sampler.Value.NEAREST); + _RS_ASSERT("wrapT.getMinification() == Sampler.Value.NEAREST", + wrapT.getMinification() == Sampler.Value.NEAREST); + _RS_ASSERT("wrapT.getWrapS() == Sampler.Value.CLAMP", + wrapT.getWrapS() == Sampler.Value.CLAMP); + _RS_ASSERT("wrapT.getWrapT() == Sampler.Value.WRAP", + wrapT.getWrapT() == Sampler.Value.WRAP); + _RS_ASSERT("wrapT.getAnisotropy() == 1.0f", + wrapT.getAnisotropy() == 1.0f); + + _RS_ASSERT("anisotropy.getMagnification() == Sampler.Value.NEAREST", + anisotropy.getMagnification() == Sampler.Value.NEAREST); + _RS_ASSERT("anisotropy.getMinification() == Sampler.Value.NEAREST", + anisotropy.getMinification() == Sampler.Value.NEAREST); + _RS_ASSERT("anisotropy.getWrapS() == Sampler.Value.CLAMP", + anisotropy.getWrapS() == Sampler.Value.CLAMP); + _RS_ASSERT("anisotropy.getWrapT() == Sampler.Value.CLAMP", + anisotropy.getWrapT() == Sampler.Value.CLAMP); + _RS_ASSERT("anisotropy.getAnisotropy() == 1.0f", + anisotropy.getAnisotropy() == 8.0f); + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + testScriptSide(pRS); + testJavaSide(pRS); + passTest(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_struct.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_struct.java new file mode 100644 index 0000000..2a55686 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_struct.java @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_struct extends UnitTest { + private Resources mRes; + + protected UT_struct(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Struct", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_struct s = new ScriptC_struct(pRS, mRes, R.raw.struct); + pRS.setMessageHandler(mRsMessage); + + ScriptField_Point2 p = new ScriptField_Point2(pRS, 1); + ScriptField_Point2.Item i = new ScriptField_Point2.Item(); + int val = 100; + i.x = val; + i.y = val; + p.set(i, 0, true); + s.bind_point2(p); + s.invoke_struct_test(val); + pRS.finish(); + waitForMessage(); + + val = 200; + p.set_x(0, val, true); + p.set_y(0, val, true); + s.invoke_struct_test(val); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_vector.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_vector.java index 748701d..0ac09ca 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_vector.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UT_vector.java @@ -307,7 +307,7 @@ public class UT_vector extends UnitTest { ScriptC_vector s = new ScriptC_vector(pRS, mRes, R.raw.vector); pRS.setMessageHandler(mRsMessage); if (!initializeGlobals(s)) { - result = -1; + failTest(); } else { s.invoke_vector_test(); pRS.finish(); diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/UnitTest.java b/tests/RenderScriptTests/tests/src/com/android/rs/test/UnitTest.java index a97ffa7..fbac124 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/UnitTest.java +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/UnitTest.java @@ -21,7 +21,7 @@ import android.renderscript.RenderScript.RSMessageHandler; public class UnitTest extends Thread { public String name; - public int result; + private int result; private ScriptField_ListAllocs_s.Item mItem; private RSTestCore mRSTC; private boolean msgHandled; @@ -58,12 +58,12 @@ public class UnitTest extends Thread { protected void _RS_ASSERT(String message, boolean b) { if(b == false) { - result = -1; Log.e(name, message + " FAILED"); + failTest(); } } - protected void updateUI() { + private void updateUI() { if (mItem != null) { mItem.result = result; msgHandled = true; @@ -104,6 +104,22 @@ public class UnitTest extends Thread { } } + public int getResult() { + return result; + } + + public void failTest() { + result = -1; + updateUI(); + } + + public void passTest() { + if (result != -1) { + result = 1; + } + updateUI(); + } + public void setItem(ScriptField_ListAllocs_s.Item item) { mItem = item; } diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/array_init.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/array_init.rs new file mode 100644 index 0000000..842249a --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/array_init.rs @@ -0,0 +1,58 @@ +#include "shared.rsh" + +// Testing constant array initialization +float fa[4] = {1.0, 9.9999f}; +double da[2] = {7.0, 8.88888}; +char ca[4] = {'a', 7, 'b', 'c'}; +short sa[4] = {1, 1, 2, 3}; +int ia[4] = {5, 8}; +long la[2] = {13, 21}; +long long lla[4] = {34}; +bool ba[3] = {true, false}; + +void array_init_test() { + bool failed = false; + + _RS_ASSERT(fa[0] == 1.0); + _RS_ASSERT(fa[1] == 9.9999f); + _RS_ASSERT(fa[2] == 0); + _RS_ASSERT(fa[3] == 0); + + _RS_ASSERT(da[0] == 7.0); + _RS_ASSERT(da[1] == 8.88888); + + _RS_ASSERT(ca[0] == 'a'); + _RS_ASSERT(ca[1] == 7); + _RS_ASSERT(ca[2] == 'b'); + _RS_ASSERT(ca[3] == 'c'); + + _RS_ASSERT(sa[0] == 1); + _RS_ASSERT(sa[1] == 1); + _RS_ASSERT(sa[2] == 2); + _RS_ASSERT(sa[3] == 3); + + _RS_ASSERT(ia[0] == 5); + _RS_ASSERT(ia[1] == 8); + _RS_ASSERT(ia[2] == 0); + _RS_ASSERT(ia[3] == 0); + + _RS_ASSERT(la[0] == 13); + _RS_ASSERT(la[1] == 21); + + _RS_ASSERT(lla[0] == 34); + _RS_ASSERT(lla[1] == 0); + _RS_ASSERT(lla[2] == 0); + _RS_ASSERT(lla[3] == 0); + + _RS_ASSERT(ba[0] == true); + _RS_ASSERT(ba[1] == false); + _RS_ASSERT(ba[2] == false); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/atomic.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/atomic.rs new file mode 100644 index 0000000..f0a5041 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/atomic.rs @@ -0,0 +1,77 @@ +#include "shared.rsh" + +// Testing atomic operations +static bool testUMax(uint32_t dst, uint32_t src) { + bool failed = false; + uint32_t old = dst; + uint32_t expect = (dst > src ? dst : src); + uint32_t ret = rsAtomicMax(&dst, src); + _RS_ASSERT(old == ret); + _RS_ASSERT(dst == expect); + return failed; +} + +static bool testUMin(uint32_t dst, uint32_t src) { + bool failed = false; + uint32_t old = dst; + uint32_t expect = (dst < src ? dst : src); + uint32_t ret = rsAtomicMin(&dst, src); + _RS_ASSERT(old == ret); + _RS_ASSERT(dst == expect); + return failed; +} + +static bool testUCas(uint32_t dst, uint32_t cmp, uint32_t swp) { + bool failed = false; + uint32_t old = dst; + uint32_t expect = (dst == cmp ? swp : dst); + uint32_t ret = rsAtomicCas(&dst, cmp, swp); + _RS_ASSERT(old == ret); + _RS_ASSERT(dst == expect); + return failed; +} + +static bool test_atomics() { + bool failed = false; + + failed |= testUMax(5, 6); + failed |= testUMax(6, 5); + failed |= testUMax(5, 0xf0000006); + failed |= testUMax(0xf0000006, 5); + + failed |= testUMin(5, 6); + failed |= testUMin(6, 5); + failed |= testUMin(5, 0xf0000006); + failed |= testUMin(0xf0000006, 5); + + failed |= testUCas(4, 4, 5); + failed |= testUCas(4, 5, 5); + failed |= testUCas(5, 5, 4); + failed |= testUCas(5, 4, 4); + failed |= testUCas(0xf0000004, 0xf0000004, 0xf0000005); + failed |= testUCas(0xf0000004, 0xf0000005, 0xf0000005); + failed |= testUCas(0xf0000005, 0xf0000005, 0xf0000004); + failed |= testUCas(0xf0000005, 0xf0000004, 0xf0000004); + + if (failed) { + rsDebug("test_atomics FAILED", 0); + } + else { + rsDebug("test_atomics PASSED", 0); + } + + return failed; +} + +void atomic_test() { + bool failed = false; + failed |= test_atomics(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/constant.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/constant.rs new file mode 100644 index 0000000..732eaef --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/constant.rs @@ -0,0 +1,19 @@ +#include "shared.rsh" + +const float floatTest = 1.99f; +const double doubleTest = 2.05; +const char charTest = -8; +const short shortTest = -16; +const int intTest = -32; +const long longTest = 17179869184l; // 1 << 34 +const long long longlongTest = 68719476736l; // 1 << 36 + +const uchar ucharTest = 8; +const ushort ushortTest = 16; +const uint uintTest = 32; +const ulong ulongTest = 4611686018427387904L; +const int64_t int64_tTest = -17179869184l; // - 1 << 34 +const uint64_t uint64_tTest = 117179869184l; + +const bool boolTest = true; + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/convert.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/convert.rs new file mode 100644 index 0000000..e314f2b --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/convert.rs @@ -0,0 +1,37 @@ +#include "shared.rsh" + +float4 f4 = { 2.0f, 4.0f, 6.0f, 8.0f }; + +char4 i8_4 = { -1, -2, -3, 4 }; + +static bool test_convert() { + bool failed = false; + + f4 = convert_float4(i8_4); + _RS_ASSERT(f4.x == -1.0f); + _RS_ASSERT(f4.y == -2.0f); + _RS_ASSERT(f4.z == -3.0f); + _RS_ASSERT(f4.w == 4.0f); + + if (failed) { + rsDebug("test_convert FAILED", 0); + } + else { + rsDebug("test_convert PASSED", 0); + } + + return failed; +} + +void convert_test() { + bool failed = false; + failed |= test_convert(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/element.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/element.rs new file mode 100644 index 0000000..0c42d84 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/element.rs @@ -0,0 +1,158 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_element simpleElem; +rs_element complexElem; +typedef struct ComplexStruct { + float subElem0; + float subElem1; + int subElem2; + float arrayElem0[2]; + int arrayElem1[5]; + char subElem3; + float subElem4; + float2 subElem5; + float3 subElem6; + float4 subElem_7; +} ComplexStruct_t; + +ComplexStruct_t *complexStruct; + +static const char *subElemNames[] = { + "subElem0", + "subElem1", + "subElem2", + "arrayElem0", + "arrayElem1", + "subElem3", + "subElem4", + "subElem5", + "subElem6", + "subElem_7", +}; + +static uint32_t subElemNamesSizes[] = { + 8, + 8, + 8, + 10, + 10, + 8, + 8, + 8, + 8, + 9, +}; + +static uint32_t subElemArraySizes[] = { + 1, + 1, + 1, + 2, + 5, + 1, + 1, + 1, + 1, + 1, +}; + +static void resetStruct() { + uint8_t *bytePtr = (uint8_t*)complexStruct; + uint32_t sizeOfStruct = sizeof(*complexStruct); + for(uint32_t i = 0; i < sizeOfStruct; i ++) { + bytePtr[i] = 0; + } +} + +static bool equals(const char *name0, const char * name1, uint32_t len) { + for (uint32_t i = 0; i < len; i ++) { + if (name0[i] != name1[i]) { + return false; + } + } + return true; +} + +static bool test_element_getters() { + bool failed = false; + + uint32_t subElemOffsets[10]; + uint32_t index = 0; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem0 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem1 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem2 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->arrayElem0 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->arrayElem1 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem3 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem4 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem5 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem6 - (uint32_t)complexStruct; + subElemOffsets[index++] = (uint32_t)&complexStruct->subElem_7 - (uint32_t)complexStruct; + + uint32_t subElemCount = rsElementGetSubElementCount(simpleElem); + _RS_ASSERT(subElemCount == 0); + _RS_ASSERT(rsElementGetDataKind(simpleElem) == RS_KIND_USER); + _RS_ASSERT(rsElementGetDataType(simpleElem) == RS_TYPE_FLOAT_32); + _RS_ASSERT(rsElementGetVectorSize(simpleElem) == 3); + + subElemCount = rsElementGetSubElementCount(complexElem); + _RS_ASSERT(subElemCount == 10); + _RS_ASSERT(rsElementGetDataKind(complexElem) == RS_KIND_USER); + _RS_ASSERT(rsElementGetDataType(complexElem) == RS_TYPE_NONE); + _RS_ASSERT(rsElementGetVectorSize(complexElem) == 1); + _RS_ASSERT(rsElementGetSizeBytes(complexElem) == sizeof(*complexStruct)); + + char buffer[64]; + for (uint32_t i = 0; i < subElemCount; i ++) { + rs_element subElem = rsElementGetSubElement(complexElem, i); + _RS_ASSERT(rsIsObject(subElem)); + + _RS_ASSERT(rsElementGetSubElementNameLength(complexElem, i) == subElemNamesSizes[i] + 1); + + uint32_t written = rsElementGetSubElementName(complexElem, i, buffer, 64); + _RS_ASSERT(written == subElemNamesSizes[i]); + _RS_ASSERT(equals(buffer, subElemNames[i], written)); + + _RS_ASSERT(rsElementGetSubElementArraySize(complexElem, i) == subElemArraySizes[i]); + _RS_ASSERT(rsElementGetSubElementOffsetBytes(complexElem, i) == subElemOffsets[i]); + } + + // Tests error checking + rs_element subElem = rsElementGetSubElement(complexElem, subElemCount); + _RS_ASSERT(!rsIsObject(subElem)); + + _RS_ASSERT(rsElementGetSubElementNameLength(complexElem, subElemCount) == 0); + + _RS_ASSERT(rsElementGetSubElementName(complexElem, subElemCount, buffer, 64) == 0); + _RS_ASSERT(rsElementGetSubElementName(complexElem, 0, NULL, 64) == 0); + _RS_ASSERT(rsElementGetSubElementName(complexElem, 0, buffer, 0) == 0); + uint32_t written = rsElementGetSubElementName(complexElem, 0, buffer, 5); + _RS_ASSERT(written == 4); + _RS_ASSERT(buffer[4] == '\0'); + + _RS_ASSERT(rsElementGetSubElementArraySize(complexElem, subElemCount) == 0); + _RS_ASSERT(rsElementGetSubElementOffsetBytes(complexElem, subElemCount) == 0); + + if (failed) { + rsDebug("test_element_getters FAILED", 0); + } + else { + rsDebug("test_element_getters PASSED", 0); + } + + return failed; +} + +void element_test() { + bool failed = false; + failed |= test_element_getters(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/foreach.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/foreach.rs index 3ba3eef..ac527b5 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/foreach.rs +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/foreach.rs @@ -3,12 +3,19 @@ int *a; int dimX; int dimY; +static bool failed = false; void root(int *out, uint32_t x, uint32_t y) { *out = x + y * dimX; } -static bool test_foreach_output() { +void foo(const int *in, int *out, uint32_t x, uint32_t y) { + _RS_ASSERT(*in == (x + y * dimX)); + *out = 99 + x + y * dimX; + _RS_ASSERT(*out == (99 + x + y * dimX)); +} + +static bool test_root_output() { bool failed = false; int i, j; @@ -19,19 +26,44 @@ static bool test_foreach_output() { } if (failed) { - rsDebug("test_foreach_output FAILED", 0); + rsDebug("test_root_output FAILED", 0); } else { - rsDebug("test_foreach_output PASSED", 0); + rsDebug("test_root_output PASSED", 0); } return failed; } -void foreach_test() { +static bool test_foo_output() { bool failed = false; - failed |= test_foreach_output(); + int i, j; + + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + _RS_ASSERT(a[i + j * dimX] == (99 + i + j * dimX)); + } + } + + if (failed) { + rsDebug("test_foo_output FAILED", 0); + } + else { + rsDebug("test_foo_output PASSED", 0); + } + + return failed; +} +void verify_root() { + failed |= test_root_output(); +} + +void verify_foo() { + failed |= test_foo_output(); +} + +void foreach_test() { if (failed) { rsSendToClientBlocking(RS_MSG_TEST_FAILED); } diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/mesh.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/mesh.rs new file mode 100644 index 0000000..1354897 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/mesh.rs @@ -0,0 +1,64 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_mesh mesh; +rs_allocation vertexAlloc0; +rs_allocation vertexAlloc1; + +rs_allocation indexAlloc0; +rs_allocation indexAlloc2; + +static bool test_mesh_getters() { + bool failed = false; + + _RS_ASSERT(rsgMeshGetVertexAllocationCount(mesh) == 2); + _RS_ASSERT(rsgMeshGetPrimitiveCount(mesh) == 3); + + rs_allocation meshV0 = rsgMeshGetVertexAllocation(mesh, 0); + rs_allocation meshV1 = rsgMeshGetVertexAllocation(mesh, 1); + rs_allocation meshV2 = rsgMeshGetVertexAllocation(mesh, 2); + _RS_ASSERT(meshV0.p == vertexAlloc0.p); + _RS_ASSERT(meshV1.p == vertexAlloc1.p); + _RS_ASSERT(!rsIsObject(meshV2)); + + rs_allocation meshI0 = rsgMeshGetIndexAllocation(mesh, 0); + rs_allocation meshI1 = rsgMeshGetIndexAllocation(mesh, 1); + rs_allocation meshI2 = rsgMeshGetIndexAllocation(mesh, 2); + rs_allocation meshI3 = rsgMeshGetIndexAllocation(mesh, 3); + _RS_ASSERT(meshI0.p == indexAlloc0.p); + _RS_ASSERT(!rsIsObject(meshI1)); + _RS_ASSERT(meshI2.p == indexAlloc2.p); + _RS_ASSERT(!rsIsObject(meshI3)); + + rs_primitive p0 = rsgMeshGetPrimitive(mesh, 0); + rs_primitive p1 = rsgMeshGetPrimitive(mesh, 1); + rs_primitive p2 = rsgMeshGetPrimitive(mesh, 2); + rs_primitive p3 = rsgMeshGetPrimitive(mesh, 3); + + _RS_ASSERT(p0 == RS_PRIMITIVE_POINT); + _RS_ASSERT(p1 == RS_PRIMITIVE_LINE); + _RS_ASSERT(p2 == RS_PRIMITIVE_TRIANGLE); + _RS_ASSERT(p3 == RS_PRIMITIVE_INVALID); + + if (failed) { + rsDebug("test_mesh_getters FAILED", 0); + } + else { + rsDebug("test_mesh_getters PASSED", 0); + } + + return failed; +} + +void mesh_test() { + bool failed = false; + failed |= test_mesh_getters(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/noroot.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/noroot.rs new file mode 100644 index 0000000..33944aa --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/noroot.rs @@ -0,0 +1,44 @@ +#include "shared.rsh" + +int *a; +int dimX; +int dimY; +static bool failed = false; + +void foo(const int *in, int *out, uint32_t x, uint32_t y) { + *out = 99 + x + y * dimX; +} + +static bool test_foo_output() { + bool failed = false; + int i, j; + + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + _RS_ASSERT(a[i + j * dimX] == (99 + i + j * dimX)); + } + } + + if (failed) { + rsDebug("test_foo_output FAILED", 0); + } + else { + rsDebug("test_foo_output PASSED", 0); + } + + return failed; +} + +void verify_foo() { + failed |= test_foo_output(); +} + +void noroot_test() { + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/program_raster.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/program_raster.rs new file mode 100644 index 0000000..11b8c30 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/program_raster.rs @@ -0,0 +1,37 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_program_raster pointSpriteEnabled; +rs_program_raster cullMode; + +static bool test_program_raster_getters() { + bool failed = false; + + _RS_ASSERT(rsgProgramRasterGetPointSpriteEnabled(pointSpriteEnabled) == true); + _RS_ASSERT(rsgProgramRasterGetCullMode(pointSpriteEnabled) == RS_CULL_BACK); + + _RS_ASSERT(rsgProgramRasterGetPointSpriteEnabled(cullMode) == false); + _RS_ASSERT(rsgProgramRasterGetCullMode(cullMode) == RS_CULL_FRONT); + + if (failed) { + rsDebug("test_program_raster_getters FAILED", 0); + } + else { + rsDebug("test_program_raster_getters PASSED", 0); + } + + return failed; +} + +void program_raster_test() { + bool failed = false; + failed |= test_program_raster_getters(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/program_store.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/program_store.rs new file mode 100644 index 0000000..3cd8a20 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/program_store.rs @@ -0,0 +1,128 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_program_store ditherEnable; +rs_program_store colorRWriteEnable; +rs_program_store colorGWriteEnable; +rs_program_store colorBWriteEnable; +rs_program_store colorAWriteEnable; +rs_program_store blendSrc; +rs_program_store blendDst; +rs_program_store depthWriteEnable; +rs_program_store depthFunc; + +static bool test_program_store_getters() { + bool failed = false; + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(depthFunc) == RS_DEPTH_FUNC_GREATER); + _RS_ASSERT(rsgProgramStoreGetDepthMask(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(depthFunc) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(depthFunc) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(depthFunc) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(depthWriteEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(depthWriteEnable) == true); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(depthWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(depthWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(depthWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(depthWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(depthWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(depthWriteEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(depthWriteEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(colorRWriteEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(colorRWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(colorRWriteEnable) == true); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(colorRWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(colorRWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(colorRWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(colorRWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(colorRWriteEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(colorRWriteEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(colorGWriteEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(colorGWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(colorGWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(colorGWriteEnable) == true); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(colorGWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(colorGWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(colorGWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(colorGWriteEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(colorGWriteEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(colorBWriteEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(colorBWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(colorBWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(colorBWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(colorBWriteEnable) == true); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(colorBWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(colorBWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(colorBWriteEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(colorBWriteEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(colorAWriteEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(colorAWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(colorAWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(colorAWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(colorAWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(colorAWriteEnable) == true); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(colorAWriteEnable) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(colorAWriteEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(colorAWriteEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(ditherEnable) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(ditherEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(ditherEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(ditherEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(ditherEnable) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(ditherEnable) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(ditherEnable) == true); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(ditherEnable) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(ditherEnable) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(blendSrc) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(blendSrc) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(blendSrc) == RS_BLEND_SRC_DST_COLOR); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(blendSrc) == RS_BLEND_DST_ZERO); + + _RS_ASSERT(rsgProgramStoreGetDepthFunc(blendDst) == RS_DEPTH_FUNC_ALWAYS); + _RS_ASSERT(rsgProgramStoreGetDepthMask(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskR(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskG(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskB(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetColorMaskA(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetDitherEnabled(blendDst) == false); + _RS_ASSERT(rsgProgramStoreGetBlendSrcFunc(blendDst) == RS_BLEND_SRC_ZERO); + _RS_ASSERT(rsgProgramStoreGetBlendDstFunc(blendDst) == RS_BLEND_DST_DST_ALPHA); + + if (failed) { + rsDebug("test_program_store_getters FAILED", 0); + } + else { + rsDebug("test_program_store_getters PASSED", 0); + } + + return failed; +} + +void program_store_test() { + bool failed = false; + failed |= test_program_store_getters(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/rstime.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/rstime.rs index 5e3e078..7be955d 100644 --- a/tests/RenderScriptTests/tests/src/com/android/rs/test/rstime.rs +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/rstime.rs @@ -19,7 +19,7 @@ static bool basic_test(uint32_t index) { rsDebug("tm.tm_yday", tm.tm_yday); rsDebug("tm.tm_isdst", tm.tm_isdst); - // Test a specific time (only valid for PST localtime) + // Test a specific time (since we set America/Los_Angeles localtime) curTime = 1294438893; rsLocaltime(&tm, &curTime); diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/sampler.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/sampler.rs new file mode 100644 index 0000000..ff1c0a7 --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/sampler.rs @@ -0,0 +1,63 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" +rs_sampler minification; +rs_sampler magnification; +rs_sampler wrapS; +rs_sampler wrapT; +rs_sampler anisotropy; + +static bool test_sampler_getters() { + bool failed = false; + + _RS_ASSERT(rsSamplerGetMagnification(minification) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetMinification(minification) == RS_SAMPLER_LINEAR_MIP_LINEAR); + _RS_ASSERT(rsSamplerGetWrapS(minification) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetWrapT(minification) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetAnisotropy(minification) == 1.0f); + + _RS_ASSERT(rsSamplerGetMagnification(magnification) == RS_SAMPLER_LINEAR); + _RS_ASSERT(rsSamplerGetMinification(magnification) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetWrapS(magnification) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetWrapT(magnification) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetAnisotropy(magnification) == 1.0f); + + _RS_ASSERT(rsSamplerGetMagnification(wrapS) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetMinification(wrapS) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetWrapS(wrapS) == RS_SAMPLER_WRAP); + _RS_ASSERT(rsSamplerGetWrapT(wrapS) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetAnisotropy(wrapS) == 1.0f); + + _RS_ASSERT(rsSamplerGetMagnification(wrapT) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetMinification(wrapT) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetWrapS(wrapT) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetWrapT(wrapT) == RS_SAMPLER_WRAP); + _RS_ASSERT(rsSamplerGetAnisotropy(wrapT) == 1.0f); + + _RS_ASSERT(rsSamplerGetMagnification(anisotropy) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetMinification(anisotropy) == RS_SAMPLER_NEAREST); + _RS_ASSERT(rsSamplerGetWrapS(anisotropy) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetWrapT(anisotropy) == RS_SAMPLER_CLAMP); + _RS_ASSERT(rsSamplerGetAnisotropy(anisotropy) == 8.0f); + + if (failed) { + rsDebug("test_sampler_getters FAILED", 0); + } + else { + rsDebug("test_sampler_getters PASSED", 0); + } + + return failed; +} + +void sampler_test() { + bool failed = false; + failed |= test_sampler_getters(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests/src/com/android/rs/test/struct.rs b/tests/RenderScriptTests/tests/src/com/android/rs/test/struct.rs new file mode 100644 index 0000000..1cd728e --- /dev/null +++ b/tests/RenderScriptTests/tests/src/com/android/rs/test/struct.rs @@ -0,0 +1,37 @@ +#include "shared.rsh" + +typedef struct Point2 { + int x; + int y; +} Point_2; +Point_2 *point2; + +static bool test_Point_2(int expected) { + bool failed = false; + + rsDebug("Point: ", point2[0].x, point2[0].y); + _RS_ASSERT(point2[0].x == expected); + _RS_ASSERT(point2[0].y == expected); + + if (failed) { + rsDebug("test_Point_2 FAILED", 0); + } + else { + rsDebug("test_Point_2 PASSED", 0); + } + + return failed; +} + +void struct_test(int expected) { + bool failed = false; + failed |= test_Point_2(expected); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/Android.mk b/tests/RenderScriptTests/tests_v11/Android.mk new file mode 100644 index 0000000..93a429b --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/Android.mk @@ -0,0 +1,31 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +ifneq ($(TARGET_SIMULATOR),true) + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) + +LOCAL_PACKAGE_NAME := RSTest_v11 +LOCAL_SDK_VERSION := 11 + +include $(BUILD_PACKAGE) + +endif diff --git a/tests/RenderScriptTests/tests_v11/AndroidManifest.xml b/tests/RenderScriptTests/tests_v11/AndroidManifest.xml new file mode 100644 index 0000000..f4aeda2 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/AndroidManifest.xml @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.rs.test_v11"> + <uses-sdk android:minSdkVersion="11" /> + <application + android:label="_RS_Test_v11" + android:icon="@drawable/test_pattern"> + <activity android:name="RSTest_v11" + android:screenOrientation="portrait"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/tests_v11/res/drawable/test_pattern.png b/tests/RenderScriptTests/tests_v11/res/drawable/test_pattern.png Binary files differnew file mode 100644 index 0000000..e7d1455 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/res/drawable/test_pattern.png diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestCore.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestCore.java new file mode 100644 index 0000000..888cfe4 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestCore.java @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; +import java.util.ArrayList; +import java.util.ListIterator; +import java.util.Timer; +import java.util.TimerTask; + + +public class RSTestCore { + int mWidth; + int mHeight; + Context mCtx; + + public RSTestCore(Context ctx) { + mCtx = ctx; + } + + private Resources mRes; + private RenderScriptGL mRS; + + private Font mFont; + ScriptField_ListAllocs_s mListAllocs; + int mLastX; + int mLastY; + private ScriptC_rslist mScript; + + private ArrayList<UnitTest> unitTests; + private ListIterator<UnitTest> test_iter; + private UnitTest activeTest; + private boolean stopTesting; + + /* Periodic timer for ensuring future tests get scheduled */ + private Timer mTimer; + public static final int RS_TIMER_PERIOD = 100; + + public void init(RenderScriptGL rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + mWidth = width; + mHeight = height; + stopTesting = false; + + mScript = new ScriptC_rslist(mRS, mRes, R.raw.rslist); + + unitTests = new ArrayList<UnitTest>(); + + unitTests.add(new UT_primitives(this, mRes, mCtx)); + unitTests.add(new UT_rsdebug(this, mRes, mCtx)); + unitTests.add(new UT_rstime(this, mRes, mCtx)); + unitTests.add(new UT_rstypes(this, mRes, mCtx)); + unitTests.add(new UT_math(this, mRes, mCtx)); + unitTests.add(new UT_fp_mad(this, mRes, mCtx)); + /* + unitTests.add(new UnitTest(null, "<Pass>", 1)); + unitTests.add(new UnitTest()); + unitTests.add(new UnitTest(null, "<Fail>", -1)); + + for (int i = 0; i < 20; i++) { + unitTests.add(new UnitTest(null, "<Pass>", 1)); + } + */ + + UnitTest [] uta = new UnitTest[unitTests.size()]; + uta = unitTests.toArray(uta); + + mListAllocs = new ScriptField_ListAllocs_s(mRS, uta.length); + for (int i = 0; i < uta.length; i++) { + ScriptField_ListAllocs_s.Item listElem = new ScriptField_ListAllocs_s.Item(); + listElem.text = Allocation.createFromString(mRS, uta[i].name, Allocation.USAGE_SCRIPT); + listElem.result = uta[i].result; + mListAllocs.set(listElem, i, false); + uta[i].setItem(listElem); + } + + mListAllocs.copyAll(); + + mScript.bind_gList(mListAllocs); + + mFont = Font.create(mRS, mRes, "serif", Font.Style.BOLD, 8); + mScript.set_gFont(mFont); + + mRS.bindRootScript(mScript); + + test_iter = unitTests.listIterator(); + refreshTestResults(); /* Kick off the first test */ + + TimerTask pTask = new TimerTask() { + public void run() { + refreshTestResults(); + } + }; + + mTimer = new Timer(); + mTimer.schedule(pTask, RS_TIMER_PERIOD, RS_TIMER_PERIOD); + } + + public void checkAndRunNextTest() { + if (activeTest != null) { + if (!activeTest.isAlive()) { + /* Properly clean up on our last test */ + try { + activeTest.join(); + } + catch (InterruptedException e) { + } + activeTest = null; + } + } + + if (!stopTesting && activeTest == null) { + if (test_iter.hasNext()) { + activeTest = test_iter.next(); + activeTest.start(); + /* This routine will only get called once when a new test + * should start running. The message handler in UnitTest.java + * ensures this. */ + } + else { + if (mTimer != null) { + mTimer.cancel(); + mTimer.purge(); + mTimer = null; + } + } + } + } + + public void refreshTestResults() { + checkAndRunNextTest(); + + if (mListAllocs != null && mScript != null && mRS != null) { + mListAllocs.copyAll(); + + mScript.bind_gList(mListAllocs); + mRS.bindRootScript(mScript); + } + } + + public void cleanup() { + stopTesting = true; + UnitTest t = activeTest; + + /* Stop periodic refresh of testing */ + if (mTimer != null) { + mTimer.cancel(); + mTimer.purge(); + mTimer = null; + } + + /* Wait to exit until we finish the current test */ + if (t != null) { + try { + t.join(); + } + catch (InterruptedException e) { + } + t = null; + } + + } + + public void newTouchPosition(float x, float y, float pressure, int id) { + } + + public void onActionDown(int x, int y) { + mScript.set_gDY(0.0f); + mLastX = x; + mLastY = y; + refreshTestResults(); + } + + public void onActionMove(int x, int y) { + int dx = mLastX - x; + int dy = mLastY - y; + + if (Math.abs(dy) <= 2) { + dy = 0; + } + + mScript.set_gDY(dy); + + mLastX = x; + mLastY = y; + refreshTestResults(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestView.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestView.java new file mode 100644 index 0000000..b5bebe9 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTestView.java @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class RSTestView extends RSSurfaceView { + + private Context mCtx; + + public RSTestView(Context context) { + super(context); + mCtx = context; + //setFocusable(true); + } + + private RenderScriptGL mRS; + private RSTestCore mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + if (mRS == null) { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + mRS = createRenderScriptGL(sc); + mRS.setSurface(holder, w, h); + mRender = new RSTestCore(mCtx); + mRender.init(mRS, getResources(), w, h); + } + } + + @Override + protected void onDetachedFromWindow() { + if(mRS != null) { + mRender.cleanup(); + mRS = null; + destroyRenderScriptGL(); + } + } + + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) + { + return super.onKeyDown(keyCode, event); + } + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + boolean ret = false; + int act = ev.getAction(); + if (act == ev.ACTION_DOWN) { + mRender.onActionDown((int)ev.getX(), (int)ev.getY()); + ret = true; + } + else if (act == ev.ACTION_MOVE) { + mRender.onActionMove((int)ev.getX(), (int)ev.getY()); + ret = true; + } + + return ret; + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTest_v11.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTest_v11.java new file mode 100644 index 0000000..1dedfce --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/RSTest_v11.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Config; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class RSTest_v11 extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "libRS_jni"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = DEBUG ? Config.LOGD : Config.LOGV; + + private RSTestView mView; + + // get the current looper (from your Activity UI thread for instance + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new RSTestView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity loses focus + super.onResume(); + mView.resume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity loses focus + super.onPause(); + mView.pause(); + } + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_fp_mad.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_fp_mad.java new file mode 100644 index 0000000..5d72aa6 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_fp_mad.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_fp_mad extends UnitTest { + private Resources mRes; + + protected UT_fp_mad(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Fp_Mad", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_fp_mad s = new ScriptC_fp_mad(pRS, mRes, R.raw.fp_mad); + pRS.setMessageHandler(mRsMessage); + s.invoke_fp_mad_test(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_math.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_math.java new file mode 100644 index 0000000..7e356f8 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_math.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_math extends UnitTest { + private Resources mRes; + + protected UT_math(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Math", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_math s = new ScriptC_math(pRS, mRes, R.raw.math); + pRS.setMessageHandler(mRsMessage); + s.invoke_math_test(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_primitives.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_primitives.java new file mode 100644 index 0000000..dc3efbc --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_primitives.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_primitives extends UnitTest { + private Resources mRes; + + protected UT_primitives(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Primitives", ctx); + mRes = res; + } + + private boolean initializeGlobals(ScriptC_primitives s) { + float pF = s.get_floatTest(); + if (pF != 1.99f) { + return false; + } + s.set_floatTest(2.99f); + + double pD = s.get_doubleTest(); + if (pD != 2.05) { + return false; + } + s.set_doubleTest(3.05); + + byte pC = s.get_charTest(); + if (pC != -8) { + return false; + } + s.set_charTest((byte)-16); + + short pS = s.get_shortTest(); + if (pS != -16) { + return false; + } + s.set_shortTest((short)-32); + + int pI = s.get_intTest(); + if (pI != -32) { + return false; + } + s.set_intTest(-64); + + long pL = s.get_longTest(); + if (pL != 17179869184l) { + return false; + } + s.set_longTest(17179869185l); + + long puL = s.get_ulongTest(); + if (puL != 4611686018427387904L) { + return false; + } + s.set_ulongTest(4611686018427387903L); + + + long pLL = s.get_longlongTest(); + if (pLL != 68719476736L) { + return false; + } + s.set_longlongTest(68719476735L); + + long pu64 = s.get_uint64_tTest(); + if (pu64 != 117179869184l) { + return false; + } + s.set_uint64_tTest(117179869185l); + + return true; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_primitives s = new ScriptC_primitives(pRS, mRes, R.raw.primitives); + pRS.setMessageHandler(mRsMessage); + if (!initializeGlobals(s)) { + // initializeGlobals failed + result = -1; + } else { + s.invoke_primitives_test(0, 0); + pRS.finish(); + waitForMessage(); + } + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rsdebug.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rsdebug.java new file mode 100644 index 0000000..00dbaf5 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rsdebug.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rsdebug extends UnitTest { + private Resources mRes; + + protected UT_rsdebug(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsDebug", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rsdebug s = new ScriptC_rsdebug(pRS, mRes, R.raw.rsdebug); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rsdebug(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstime.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstime.java new file mode 100644 index 0000000..5b4c399 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstime.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rstime extends UnitTest { + private Resources mRes; + + protected UT_rstime(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsTime", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rstime s = new ScriptC_rstime(pRS, mRes, R.raw.rstime); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rstime(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstypes.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstypes.java new file mode 100644 index 0000000..72a97c9 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UT_rstypes.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rstypes extends UnitTest { + private Resources mRes; + + protected UT_rstypes(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsTypes", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rstypes s = new ScriptC_rstypes(pRS, mRes, R.raw.rstypes); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rstypes(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UnitTest.java b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UnitTest.java new file mode 100644 index 0000000..b62e535 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/UnitTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v11; +import android.content.Context; +import android.renderscript.RenderScript.RSMessageHandler; +import android.util.Log; + +public class UnitTest extends Thread { + public String name; + public int result; + private ScriptField_ListAllocs_s.Item mItem; + private RSTestCore mRSTC; + private boolean msgHandled; + protected Context mCtx; + + /* These constants must match those in shared.rsh */ + public static final int RS_MSG_TEST_PASSED = 100; + public static final int RS_MSG_TEST_FAILED = 101; + + private static int numTests = 0; + public int testID; + + protected UnitTest(RSTestCore rstc, String n, int initResult, Context ctx) { + super(); + mRSTC = rstc; + name = n; + msgHandled = false; + mCtx = ctx; + result = initResult; + testID = numTests++; + } + + protected UnitTest(RSTestCore rstc, String n, Context ctx) { + this(rstc, n, 0, ctx); + } + + protected UnitTest(RSTestCore rstc, Context ctx) { + this (rstc, "<Unknown>", ctx); + } + + protected UnitTest(Context ctx) { + this (null, ctx); + } + + protected RSMessageHandler mRsMessage = new RSMessageHandler() { + public void run() { + if (result == 0) { + switch (mID) { + case RS_MSG_TEST_PASSED: + result = 1; + break; + case RS_MSG_TEST_FAILED: + result = -1; + break; + default: + android.util.Log.v("RenderScript", "Unit test got unexpected message"); + return; + } + } + + if (mItem != null) { + mItem.result = result; + msgHandled = true; + try { + mRSTC.refreshTestResults(); + } + catch (IllegalStateException e) { + /* Ignore the case where our message receiver has been + disconnected. This happens when we leave the application + before it finishes running all of the unit tests. */ + } + } + } + }; + + public void waitForMessage() { + while (!msgHandled) { + yield(); + } + } + + public void setItem(ScriptField_ListAllocs_s.Item item) { + mItem = item; + } + + public void run() { + /* This method needs to be implemented for each subclass */ + if (mRSTC != null) { + mRSTC.refreshTestResults(); + } + } +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/fp_mad.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/fp_mad.rs new file mode 100644 index 0000000..b6f2b2a --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/fp_mad.rs @@ -0,0 +1,174 @@ +#include "shared.rsh" + +const int TEST_COUNT = 1; + +static float data_f1[1025]; +static float4 data_f4[1025]; + +static void test_mad4(uint32_t index) { + start(); + + float total = 0; + // Do ~1 billion ops + for (int ct=0; ct < 1000 * (1000 / 80); ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = (data_f4[i] * 0.02f + + data_f4[i+1] * 0.04f + + data_f4[i+2] * 0.05f + + data_f4[i+3] * 0.1f + + data_f4[i+4] * 0.2f + + data_f4[i+5] * 0.2f + + data_f4[i+6] * 0.1f + + data_f4[i+7] * 0.05f + + data_f4[i+8] * 0.04f + + data_f4[i+9] * 0.02f + 1.f); + } + } + + float time = end(index); + rsDebug("fp_mad4 M ops", 1000.f / time); +} + +static void test_mad(uint32_t index) { + start(); + + float total = 0; + // Do ~1 billion ops + for (int ct=0; ct < 1000 * (1000 / 20); ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = (data_f1[i] * 0.02f + + data_f1[i+1] * 0.04f + + data_f1[i+2] * 0.05f + + data_f1[i+3] * 0.1f + + data_f1[i+4] * 0.2f + + data_f1[i+5] * 0.2f + + data_f1[i+6] * 0.1f + + data_f1[i+7] * 0.05f + + data_f1[i+8] * 0.04f + + data_f1[i+9] * 0.02f + 1.f); + } + } + + float time = end(index); + rsDebug("fp_mad M ops", 1000.f / time); +} + +static void test_norm(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = normalize(data_f4[i]); + } + } + + float time = end(index); + rsDebug("fp_norm M ops", 10.f / time); +} + +static void test_sincos4(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10 / 4; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = sin(data_f4[i]) * cos(data_f4[i]); + } + } + + float time = end(index); + rsDebug("fp_sincos4 M ops", 10.f / time); +} + +static void test_sincos(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10; ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = sin(data_f1[i]) * cos(data_f1[i]); + } + } + + float time = end(index); + rsDebug("fp_sincos M ops", 10.f / time); +} + +static void test_clamp(uint32_t index) { + start(); + + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100; ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = clamp(data_f1[i], -1.f, 1.f); + } + } + + float time = end(index); + rsDebug("fp_clamp M ops", 100.f / time); + + start(); + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100; ct++) { + for (int i=0; i < (1000); i++) { + if (data_f1[i] < -1.f) data_f1[i] = -1.f; + if (data_f1[i] > -1.f) data_f1[i] = 1.f; + } + } + + time = end(index); + rsDebug("fp_clamp ref M ops", 100.f / time); +} + +static void test_clamp4(uint32_t index) { + start(); + + float total = 0; + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100 /4; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = clamp(data_f4[i], -1.f, 1.f); + } + } + + float time = end(index); + rsDebug("fp_clamp4 M ops", 100.f / time); +} + +void fp_mad_test(uint32_t index, int test_num) { + int x; + for (x=0; x < 1025; x++) { + data_f1[x] = (x & 0xf) * 0.1f; + data_f4[x].x = (x & 0xf) * 0.1f; + data_f4[x].y = (x & 0xf0) * 0.1f; + data_f4[x].z = (x & 0x33) * 0.1f; + data_f4[x].w = (x & 0x77) * 0.1f; + } + + test_mad4(index); + test_mad(index); + + for (x=0; x < 1025; x++) { + data_f1[x] = (x & 0xf) * 0.1f + 1.f; + data_f4[x].x = (x & 0xf) * 0.1f + 1.f; + data_f4[x].y = (x & 0xf0) * 0.1f + 1.f; + data_f4[x].z = (x & 0x33) * 0.1f + 1.f; + data_f4[x].w = (x & 0x77) * 0.1f + 1.f; + } + + test_norm(index); + test_sincos4(index); + test_sincos(index); + test_clamp4(index); + test_clamp(index); + + // TODO Actually verify test result accuracy + rsDebug("fp_mad_test PASSED", 0); + rsSendToClientBlocking(RS_MSG_TEST_PASSED); +} + + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/math.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/math.rs new file mode 100644 index 0000000..2867be1 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/math.rs @@ -0,0 +1,348 @@ +#include "shared.rsh" + +// Testing math library + +volatile float f1; +volatile float2 f2; +volatile float3 f3; +volatile float4 f4; + +volatile int i1; +volatile int2 i2; +volatile int3 i3; +volatile int4 i4; + +volatile uint ui1; +volatile uint2 ui2; +volatile uint3 ui3; +volatile uint4 ui4; + +volatile short s1; +volatile short2 s2; +volatile short3 s3; +volatile short4 s4; + +volatile ushort us1; +volatile ushort2 us2; +volatile ushort3 us3; +volatile ushort4 us4; + +volatile char c1; +volatile char2 c2; +volatile char3 c3; +volatile char4 c4; + +volatile uchar uc1; +volatile uchar2 uc2; +volatile uchar3 uc3; +volatile uchar4 uc4; + +#define TEST_FN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f2 = fnc(f2); \ + f3 = fnc(f3); \ + f4 = fnc(f4); + +#define TEST_FN_FUNC_FN_PFN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (float*) &f1); \ + f2 = fnc(f2, (float2*) &f2); \ + f3 = fnc(f3, (float3*) &f3); \ + f4 = fnc(f4, (float4*) &f4); + +#define TEST_FN_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f2); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f1); \ + f3 = fnc(f3, f1); \ + f4 = fnc(f4, f1); + +#define TEST_FN_FUNC_FN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i2); \ + f3 = fnc(f3, i3); \ + f4 = fnc(f4, i4); + +#define TEST_FN_FUNC_FN_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i1); \ + f3 = fnc(f3, i1); \ + f4 = fnc(f4, i1); + +#define TEST_FN_FUNC_FN_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f2, f2); \ + f3 = fnc(f3, f3, f3); \ + f4 = fnc(f4, f4, f4); + +#define TEST_FN_FUNC_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (int*) &i1); \ + f2 = fnc(f2, (int2*) &i2); \ + f3 = fnc(f3, (int3*) &i3); \ + f4 = fnc(f4, (int4*) &i4); + +#define TEST_FN_FUNC_FN_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, (int*) &i1); \ + f2 = fnc(f2, f2, (int2*) &i2); \ + f3 = fnc(f3, f3, (int3*) &i3); \ + f4 = fnc(f4, f4, (int4*) &i4); + +#define TEST_IN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + i1 = fnc(f1); \ + i2 = fnc(f2); \ + i3 = fnc(f3); \ + i4 = fnc(f4); + + +static bool test_fp_math(uint32_t index) { + bool failed = false; + start(); + + TEST_FN_FUNC_FN(acos); + TEST_FN_FUNC_FN(acosh); + TEST_FN_FUNC_FN(acospi); + TEST_FN_FUNC_FN(asin); + TEST_FN_FUNC_FN(asinh); + TEST_FN_FUNC_FN(asinpi); + TEST_FN_FUNC_FN(atan); + TEST_FN_FUNC_FN_FN(atan2); + TEST_FN_FUNC_FN(atanh); + TEST_FN_FUNC_FN(atanpi); + TEST_FN_FUNC_FN_FN(atan2pi); + TEST_FN_FUNC_FN(cbrt); + TEST_FN_FUNC_FN(ceil); + TEST_FN_FUNC_FN_FN(copysign); + TEST_FN_FUNC_FN(cos); + TEST_FN_FUNC_FN(cosh); + TEST_FN_FUNC_FN(cospi); + TEST_FN_FUNC_FN(erfc); + TEST_FN_FUNC_FN(erf); + TEST_FN_FUNC_FN(exp); + TEST_FN_FUNC_FN(exp2); + TEST_FN_FUNC_FN(exp10); + TEST_FN_FUNC_FN(expm1); + TEST_FN_FUNC_FN(fabs); + TEST_FN_FUNC_FN_FN(fdim); + TEST_FN_FUNC_FN(floor); + TEST_FN_FUNC_FN_FN_FN(fma); + TEST_FN_FUNC_FN_FN(fmax); + TEST_FN_FUNC_FN_F(fmax); + TEST_FN_FUNC_FN_FN(fmin); + TEST_FN_FUNC_FN_F(fmin); + TEST_FN_FUNC_FN_FN(fmod); + TEST_FN_FUNC_FN_PFN(fract); + TEST_FN_FUNC_FN_PIN(frexp); + TEST_FN_FUNC_FN_FN(hypot); + TEST_IN_FUNC_FN(ilogb); + TEST_FN_FUNC_FN_IN(ldexp); + TEST_FN_FUNC_FN_I(ldexp); + TEST_FN_FUNC_FN(lgamma); + TEST_FN_FUNC_FN_PIN(lgamma); + TEST_FN_FUNC_FN(log); + TEST_FN_FUNC_FN(log2); + TEST_FN_FUNC_FN(log10); + TEST_FN_FUNC_FN(log1p); + TEST_FN_FUNC_FN(logb); + TEST_FN_FUNC_FN_FN_FN(mad); + TEST_FN_FUNC_FN_PFN(modf); + // nan + TEST_FN_FUNC_FN_FN(nextafter); + TEST_FN_FUNC_FN_FN(pow); + TEST_FN_FUNC_FN_IN(pown); + TEST_FN_FUNC_FN_FN(powr); + TEST_FN_FUNC_FN_FN(remainder); + TEST_FN_FUNC_FN_FN_PIN(remquo); + TEST_FN_FUNC_FN(rint); + TEST_FN_FUNC_FN_IN(rootn); + TEST_FN_FUNC_FN(round); + TEST_FN_FUNC_FN(rsqrt); + TEST_FN_FUNC_FN(sin); + TEST_FN_FUNC_FN_PFN(sincos); + TEST_FN_FUNC_FN(sinh); + TEST_FN_FUNC_FN(sinpi); + TEST_FN_FUNC_FN(sqrt); + TEST_FN_FUNC_FN(tan); + TEST_FN_FUNC_FN(tanh); + TEST_FN_FUNC_FN(tanpi); + TEST_FN_FUNC_FN(tgamma); + TEST_FN_FUNC_FN(trunc); + + float time = end(index); + + if (failed) { + rsDebug("test_fp_math FAILED", time); + } + else { + rsDebug("test_fp_math PASSED", time); + } + + return failed; +} + +#define DECL_INT(prefix) \ +volatile char prefix##_c_1 = 1; \ +volatile char2 prefix##_c_2 = 1; \ +volatile char3 prefix##_c_3 = 1; \ +volatile char4 prefix##_c_4 = 1; \ +volatile uchar prefix##_uc_1 = 1; \ +volatile uchar2 prefix##_uc_2 = 1; \ +volatile uchar3 prefix##_uc_3 = 1; \ +volatile uchar4 prefix##_uc_4 = 1; \ +volatile short prefix##_s_1 = 1; \ +volatile short2 prefix##_s_2 = 1; \ +volatile short3 prefix##_s_3 = 1; \ +volatile short4 prefix##_s_4 = 1; \ +volatile ushort prefix##_us_1 = 1; \ +volatile ushort2 prefix##_us_2 = 1; \ +volatile ushort3 prefix##_us_3 = 1; \ +volatile ushort4 prefix##_us_4 = 1; \ +volatile int prefix##_i_1 = 1; \ +volatile int2 prefix##_i_2 = 1; \ +volatile int3 prefix##_i_3 = 1; \ +volatile int4 prefix##_i_4 = 1; \ +volatile uint prefix##_ui_1 = 1; \ +volatile uint2 prefix##_ui_2 = 1; \ +volatile uint3 prefix##_ui_3 = 1; \ +volatile uint4 prefix##_ui_4 = 1; \ +volatile long prefix##_l_1 = 1; \ +volatile ulong prefix##_ul_1 = 1; + +#define TEST_INT_OP_TYPE(op, type) \ +rsDebug("Testing " #op " for " #type "1", i++); \ +res_##type##_1 = src1_##type##_1 op src2_##type##_1; \ +rsDebug("Testing " #op " for " #type "2", i++); \ +res_##type##_2 = src1_##type##_2 op src2_##type##_2; \ +rsDebug("Testing " #op " for " #type "3", i++); \ +res_##type##_3 = src1_##type##_3 op src2_##type##_3; \ +rsDebug("Testing " #op " for " #type "4", i++); \ +res_##type##_4 = src1_##type##_4 op src2_##type##_4; + +#define TEST_INT_OP(op) \ +TEST_INT_OP_TYPE(op, c) \ +TEST_INT_OP_TYPE(op, uc) \ +TEST_INT_OP_TYPE(op, s) \ +TEST_INT_OP_TYPE(op, us) \ +TEST_INT_OP_TYPE(op, i) \ +TEST_INT_OP_TYPE(op, ui) \ +rsDebug("Testing " #op " for l1", i++); \ +res_l_1 = src1_l_1 op src2_l_1; \ +rsDebug("Testing " #op " for ul1", i++); \ +res_ul_1 = src1_ul_1 op src2_ul_1; + +DECL_INT(res) +DECL_INT(src1) +DECL_INT(src2) + +static bool test_basic_operators() { + bool failed = false; + int i = 0; + + TEST_INT_OP(+); + TEST_INT_OP(-); + TEST_INT_OP(*); + TEST_INT_OP(/); + TEST_INT_OP(%); + TEST_INT_OP(<<); + TEST_INT_OP(>>); + + if (failed) { + rsDebug("test_basic_operators FAILED", 0); + } + else { + rsDebug("test_basic_operators PASSED", 0); + } + + return failed; +} + +#define TEST_CVT(to, from, type) \ +rsDebug("Testing convert from " #from " to " #to, 0); \ +to##1 = from##1; \ +to##2 = convert_##type##2(from##2); \ +to##3 = convert_##type##3(from##3); \ +to##4 = convert_##type##4(from##4); + +#define TEST_CVT_MATRIX(to, type) \ +TEST_CVT(to, c, type); \ +TEST_CVT(to, uc, type); \ +TEST_CVT(to, s, type); \ +TEST_CVT(to, us, type); \ +TEST_CVT(to, i, type); \ +TEST_CVT(to, ui, type); \ +TEST_CVT(to, f, type); \ + +static bool test_convert() { + bool failed = false; + + TEST_CVT_MATRIX(c, char); + TEST_CVT_MATRIX(uc, uchar); + TEST_CVT_MATRIX(s, short); + TEST_CVT_MATRIX(us, ushort); + TEST_CVT_MATRIX(i, int); + TEST_CVT_MATRIX(ui, uint); + TEST_CVT_MATRIX(f, float); + + if (failed) { + rsDebug("test_convert FAILED", 0); + } + else { + rsDebug("test_convert PASSED", 0); + } + + return failed; +} + +#define INIT_PREFIX_TYPE(prefix, type) \ +prefix##_##type##_1 = 1; \ +prefix##_##type##_2.x = 1; \ +prefix##_##type##_2.y = 1; \ +prefix##_##type##_3.x = 1; \ +prefix##_##type##_3.y = 1; \ +prefix##_##type##_3.z = 1; \ +prefix##_##type##_4.x = 1; \ +prefix##_##type##_4.y = 1; \ +prefix##_##type##_4.z = 1; \ +prefix##_##type##_4.w = 1; + +#define INIT_TYPE(type) \ +INIT_PREFIX_TYPE(src1, type) \ +INIT_PREFIX_TYPE(src2, type) \ +INIT_PREFIX_TYPE(res, type) + +#define INIT_ALL \ +INIT_TYPE(c); \ +INIT_TYPE(uc); \ +INIT_TYPE(s); \ +INIT_TYPE(us); \ +INIT_TYPE(i); \ +INIT_TYPE(ui); + +void math_test(uint32_t index, int test_num) { + bool failed = false; + INIT_ALL; + failed |= test_convert(); + failed |= test_fp_math(index); + failed |= test_basic_operators(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/primitives.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/primitives.rs new file mode 100644 index 0000000..ce451da --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/primitives.rs @@ -0,0 +1,61 @@ +#include "shared.rsh" + +// Testing primitive types +float floatTest = 1.99f; +double doubleTest = 2.05; +char charTest = -8; +short shortTest = -16; +int intTest = -32; +long longTest = 17179869184l; // 1 << 34 +long long longlongTest = 68719476736l; // 1 << 36 + +uchar ucharTest = 8; +ushort ushortTest = 16; +uint uintTest = 32; +ulong ulongTest = 4611686018427387904L; +int64_t int64_tTest = -17179869184l; // - 1 << 34 +uint64_t uint64_tTest = 117179869184l; + +static bool test_primitive_types(uint32_t index) { + bool failed = false; + start(); + + _RS_ASSERT(floatTest == 2.99f); + _RS_ASSERT(doubleTest == 3.05); + _RS_ASSERT(charTest == -16); + _RS_ASSERT(shortTest == -32); + _RS_ASSERT(intTest == -64); + _RS_ASSERT(longTest == 17179869185l); + _RS_ASSERT(longlongTest == 68719476735l); + + _RS_ASSERT(ucharTest == 8); + _RS_ASSERT(ushortTest == 16); + _RS_ASSERT(uintTest == 32); + _RS_ASSERT(ulongTest == 4611686018427387903L); + _RS_ASSERT(int64_tTest == -17179869184l); + _RS_ASSERT(uint64_tTest == 117179869185l); + + float time = end(index); + + if (failed) { + rsDebug("test_primitives FAILED", time); + } + else { + rsDebug("test_primitives PASSED", time); + } + + return failed; +} + +void primitives_test(uint32_t index, int test_num) { + bool failed = false; + failed |= test_primitive_types(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rsdebug.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rsdebug.rs new file mode 100644 index 0000000..f7942a5 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rsdebug.rs @@ -0,0 +1,56 @@ +#include "shared.rsh" + +// Testing primitive types +float floatTest = 1.99f; +double doubleTest = 2.05; +char charTest = -8; +short shortTest = -16; +int intTest = -32; +long longTest = 17179869184l; // 1 << 34 +long long longlongTest = 68719476736l; // 1 << 36 + +uchar ucharTest = 8; +ushort ushortTest = 16; +uint uintTest = 32; +ulong ulongTest = 4611686018427387904L; +int64_t int64_tTest = -17179869184l; // - 1 << 34 +uint64_t uint64_tTest = 117179869184l; + +static bool basic_test(uint32_t index) { + bool failed = false; + + // This test focuses primarily on compilation-time, not run-time. + // For this reason, none of the outputs are actually checked. + + rsDebug("floatTest", floatTest); + rsDebug("doubleTest", doubleTest); + rsDebug("charTest", charTest); + rsDebug("shortTest", shortTest); + rsDebug("intTest", intTest); + rsDebug("longTest", longTest); + rsDebug("longlongTest", longlongTest); + + rsDebug("ucharTest", ucharTest); + rsDebug("ushortTest", ushortTest); + rsDebug("uintTest", uintTest); + rsDebug("ulongTest", ulongTest); + rsDebug("int64_tTest", int64_tTest); + rsDebug("uint64_tTest", uint64_tTest); + + return failed; +} + +void test_rsdebug(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rsdebug_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rsdebug_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rslist.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rslist.rs new file mode 100644 index 0000000..5b2501f --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rslist.rs @@ -0,0 +1,107 @@ +// Copyright (C) 2009 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test_v11) + +#include "rs_graphics.rsh" + +float gDY; + +rs_font gFont; + +typedef struct ListAllocs_s { + rs_allocation text; + int result; +} ListAllocs; + +ListAllocs *gList; + +void init() { + gDY = 0.0f; +} + +int textPos = 0; + +int root(int launchID) { + + rsgClearColor(0.0f, 0.0f, 0.0f, 0.0f); + rsgClearDepth(1.0f); + + textPos -= (int)gDY*2; + gDY *= 0.95; + + rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); + rsgBindFont(gFont); + + rs_allocation listAlloc; + rsSetObject(&listAlloc, rsGetAllocation(gList)); + int allocSize = rsAllocationGetDimX(listAlloc); + + int width = rsgGetWidth(); + int height = rsgGetHeight(); + + int itemHeight = 80; + int totalItemHeight = itemHeight * allocSize; + + /* Prevent scrolling above the top of the list */ + int firstItem = height - totalItemHeight; + if (firstItem < 0) { + firstItem = 0; + } + + /* Prevent scrolling past the last line of the list */ + int lastItem = -1 * (totalItemHeight - height); + if (lastItem > 0) { + lastItem = 0; + } + + if (textPos > firstItem) { + textPos = firstItem; + } + else if (textPos < lastItem) { + textPos = lastItem; + } + + int currentYPos = itemHeight + textPos; + + for(int i = 0; i < allocSize; i ++) { + if(currentYPos - itemHeight > height) { + break; + } + + if(currentYPos > 0) { + switch(gList[i].result) { + case 1: /* Passed */ + rsgFontColor(0.5f, 0.9f, 0.5f, 1.0f); + break; + case -1: /* Failed */ + rsgFontColor(0.9f, 0.5f, 0.5f, 1.0f); + break; + case 0: /* Still Testing */ + rsgFontColor(0.9f, 0.9f, 0.5f, 1.0f); + break; + default: /* Unknown */ + rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); + break; + } + rsgDrawRect(0, currentYPos - 1, width, currentYPos, 0); + rsgDrawText(gList[i].text, 30, currentYPos - 32); + } + currentYPos += itemHeight; + } + + return 10; +} diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstime.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstime.rs new file mode 100644 index 0000000..5e3e078 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstime.rs @@ -0,0 +1,52 @@ +#include "shared.rsh" + +static bool basic_test(uint32_t index) { + bool failed = false; + + rs_time_t curTime = rsTime(0); + rs_tm tm; + rsDebug("curTime", curTime); + + rsLocaltime(&tm, &curTime); + + rsDebug("tm.tm_sec", tm.tm_sec); + rsDebug("tm.tm_min", tm.tm_min); + rsDebug("tm.tm_hour", tm.tm_hour); + rsDebug("tm.tm_mday", tm.tm_mday); + rsDebug("tm.tm_mon", tm.tm_mon); + rsDebug("tm.tm_year", tm.tm_year); + rsDebug("tm.tm_wday", tm.tm_wday); + rsDebug("tm.tm_yday", tm.tm_yday); + rsDebug("tm.tm_isdst", tm.tm_isdst); + + // Test a specific time (only valid for PST localtime) + curTime = 1294438893; + rsLocaltime(&tm, &curTime); + + _RS_ASSERT(tm.tm_sec == 33); + _RS_ASSERT(tm.tm_min == 21); + _RS_ASSERT(tm.tm_hour == 14); + _RS_ASSERT(tm.tm_mday == 7); + _RS_ASSERT(tm.tm_mon == 0); + _RS_ASSERT(tm.tm_year == 111); + _RS_ASSERT(tm.tm_wday == 5); + _RS_ASSERT(tm.tm_yday == 6); + _RS_ASSERT(tm.tm_isdst == 0); + + return failed; +} + +void test_rstime(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rstime_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rstime_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstypes.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstypes.rs new file mode 100644 index 0000000..f3bf244 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/rstypes.rs @@ -0,0 +1,79 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_element elementTest; +rs_type typeTest; +rs_allocation allocationTest; +rs_sampler samplerTest; +rs_script scriptTest; +rs_mesh meshTest; +rs_program_fragment program_fragmentTest; +rs_program_vertex program_vertexTest; +rs_program_raster program_rasterTest; +rs_program_store program_storeTest; +rs_font fontTest; + +rs_matrix4x4 matrix4x4Test; +rs_matrix3x3 matrix3x3Test; +rs_matrix2x2 matrix2x2Test; + +struct my_struct { + int i; + rs_font fontTestStruct; +}; + +static bool basic_test(uint32_t index) { + bool failed = false; + + rs_matrix4x4 matrix4x4TestLocal; + rs_matrix3x3 matrix3x3TestLocal; + rs_matrix2x2 matrix2x2TestLocal; + + // This test focuses primarily on compilation-time, not run-time. + rs_element elementTestLocal; + rs_type typeTestLocal; + rs_allocation allocationTestLocal; + rs_sampler samplerTestLocal; + rs_script scriptTestLocal; + rs_mesh meshTestLocal; + rs_program_fragment program_fragmentTestLocal; + rs_program_vertex program_vertexTestLocal; + rs_program_raster program_rasterTestLocal; + rs_program_store program_storeTestLocal; + rs_font fontTestLocal; + + rs_font fontTestLocalArray[4]; + + rs_font fontTestLocalPreInit = fontTest; + + struct my_struct structTest; + + rsSetObject(&fontTestLocal, fontTest); + //allocationTestLocal = allocationTest; + + rsSetObject(&fontTest, fontTestLocal); + //allocationTest = allocationTestLocal; + + /*for (int i = 0; i < 4; i++) { + rsSetObject(&fontTestLocalArray[i], fontTestLocal); + }*/ + + /*rsSetObject(&fontTest, fontTestLocalArray[3]);*/ + + return failed; +} + +void test_rstypes(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rstypes_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rstypes_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/shared.rsh b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/shared.rsh new file mode 100644 index 0000000..6d34481 --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/shared.rsh @@ -0,0 +1,38 @@ +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test_v11) + +typedef struct TestResult_s { + rs_allocation name; + bool pass; + float score; + int64_t time; +} TestResult; +//TestResult *g_results; + +static int64_t g_time; + +static void start(void) { + g_time = rsUptimeMillis(); +} + +static float end(uint32_t idx) { + int64_t t = rsUptimeMillis() - g_time; + //g_results[idx].time = t; + //rsDebug("test time", (int)t); + return ((float)t) / 1000.f; +} + +#define _RS_ASSERT(b) \ +do { \ + if (!(b)) { \ + failed = true; \ + rsDebug(#b " FAILED", 0); \ + } \ +\ +} while (0) + +/* These constants must match those in UnitTest.java */ +static const int RS_MSG_TEST_PASSED = 100; +static const int RS_MSG_TEST_FAILED = 101; + diff --git a/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/test_root.rs b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/test_root.rs new file mode 100644 index 0000000..6dc83ba --- /dev/null +++ b/tests/RenderScriptTests/tests_v11/src/com/android/rs/test/test_root.rs @@ -0,0 +1,23 @@ +// Fountain test script +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test) + +#pragma stateFragment(parent) + +#include "rs_graphics.rsh" + + +typedef struct TestResult { + rs_allocation name; + bool pass; + float score; +} TestResult_t; +TestResult_t *results; + +int root() { + + return 0; +} + + diff --git a/tests/RenderScriptTests/tests_v14/Android.mk b/tests/RenderScriptTests/tests_v14/Android.mk new file mode 100644 index 0000000..c4c3a37 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/Android.mk @@ -0,0 +1,27 @@ +# +# Copyright (C) 2008 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_MODULE_TAGS := optional + +LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) + +LOCAL_PACKAGE_NAME := RSTest_v14 +LOCAL_SDK_VERSION := 14 + +include $(BUILD_PACKAGE) diff --git a/tests/RenderScriptTests/tests_v14/AndroidManifest.xml b/tests/RenderScriptTests/tests_v14/AndroidManifest.xml new file mode 100644 index 0000000..1cd9bbd --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/AndroidManifest.xml @@ -0,0 +1,16 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.rs.test_v14"> + <uses-sdk android:minSdkVersion="14" /> + <application + android:label="_RS_Test_v14" + android:icon="@drawable/test_pattern"> + <activity android:name="RSTest_v14" + android:screenOrientation="portrait"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/tests/RenderScriptTests/tests_v14/res/drawable-nodpi/test_pattern.png b/tests/RenderScriptTests/tests_v14/res/drawable-nodpi/test_pattern.png Binary files differnew file mode 100644 index 0000000..e7d1455 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/res/drawable-nodpi/test_pattern.png diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestCore.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestCore.java new file mode 100644 index 0000000..f1e81a4 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestCore.java @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2008-2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; +import android.util.Log; +import java.util.ArrayList; +import java.util.ListIterator; +import java.util.Timer; +import java.util.TimerTask; + + +public class RSTestCore { + int mWidth; + int mHeight; + Context mCtx; + + public RSTestCore(Context ctx) { + mCtx = ctx; + } + + private Resources mRes; + private RenderScriptGL mRS; + + private Font mFont; + ScriptField_ListAllocs_s mListAllocs; + int mLastX; + int mLastY; + private ScriptC_rslist mScript; + + private ArrayList<UnitTest> unitTests; + private ListIterator<UnitTest> test_iter; + private UnitTest activeTest; + private boolean stopTesting; + + /* Periodic timer for ensuring future tests get scheduled */ + private Timer mTimer; + public static final int RS_TIMER_PERIOD = 100; + + public void init(RenderScriptGL rs, Resources res, int width, int height) { + mRS = rs; + mRes = res; + mWidth = width; + mHeight = height; + stopTesting = false; + + mScript = new ScriptC_rslist(mRS, mRes, R.raw.rslist); + + unitTests = new ArrayList<UnitTest>(); + + unitTests.add(new UT_primitives(this, mRes, mCtx)); + unitTests.add(new UT_vector(this, mRes, mCtx)); + unitTests.add(new UT_rsdebug(this, mRes, mCtx)); + unitTests.add(new UT_rstime(this, mRes, mCtx)); + unitTests.add(new UT_rstypes(this, mRes, mCtx)); + unitTests.add(new UT_alloc(this, mRes, mCtx)); + unitTests.add(new UT_refcount(this, mRes, mCtx)); + unitTests.add(new UT_foreach(this, mRes, mCtx)); + unitTests.add(new UT_math(this, mRes, mCtx)); + unitTests.add(new UT_fp_mad(this, mRes, mCtx)); + /* + unitTests.add(new UnitTest(null, "<Pass>", 1)); + unitTests.add(new UnitTest()); + unitTests.add(new UnitTest(null, "<Fail>", -1)); + + for (int i = 0; i < 20; i++) { + unitTests.add(new UnitTest(null, "<Pass>", 1)); + } + */ + + UnitTest [] uta = new UnitTest[unitTests.size()]; + uta = unitTests.toArray(uta); + + mListAllocs = new ScriptField_ListAllocs_s(mRS, uta.length); + for (int i = 0; i < uta.length; i++) { + ScriptField_ListAllocs_s.Item listElem = new ScriptField_ListAllocs_s.Item(); + listElem.text = Allocation.createFromString(mRS, uta[i].name, Allocation.USAGE_SCRIPT); + listElem.result = uta[i].result; + mListAllocs.set(listElem, i, false); + uta[i].setItem(listElem); + } + + mListAllocs.copyAll(); + + mScript.bind_gList(mListAllocs); + + mFont = Font.create(mRS, mRes, "serif", Font.Style.BOLD, 8); + mScript.set_gFont(mFont); + + mRS.bindRootScript(mScript); + + test_iter = unitTests.listIterator(); + refreshTestResults(); /* Kick off the first test */ + + TimerTask pTask = new TimerTask() { + public void run() { + refreshTestResults(); + } + }; + + mTimer = new Timer(); + mTimer.schedule(pTask, RS_TIMER_PERIOD, RS_TIMER_PERIOD); + } + + public void checkAndRunNextTest() { + if (activeTest != null) { + if (!activeTest.isAlive()) { + /* Properly clean up on our last test */ + try { + activeTest.join(); + } + catch (InterruptedException e) { + } + activeTest = null; + } + } + + if (!stopTesting && activeTest == null) { + if (test_iter.hasNext()) { + activeTest = test_iter.next(); + activeTest.start(); + /* This routine will only get called once when a new test + * should start running. The message handler in UnitTest.java + * ensures this. */ + } + else { + if (mTimer != null) { + mTimer.cancel(); + mTimer.purge(); + mTimer = null; + } + } + } + } + + public void refreshTestResults() { + checkAndRunNextTest(); + + if (mListAllocs != null && mScript != null && mRS != null) { + mListAllocs.copyAll(); + + mScript.bind_gList(mListAllocs); + mRS.bindRootScript(mScript); + } + } + + public void cleanup() { + stopTesting = true; + UnitTest t = activeTest; + + /* Stop periodic refresh of testing */ + if (mTimer != null) { + mTimer.cancel(); + mTimer.purge(); + mTimer = null; + } + + /* Wait to exit until we finish the current test */ + if (t != null) { + try { + t.join(); + } + catch (InterruptedException e) { + } + t = null; + } + + } + + public void newTouchPosition(float x, float y, float pressure, int id) { + } + + public void onActionDown(int x, int y) { + mScript.set_gDY(0.0f); + mLastX = x; + mLastY = y; + refreshTestResults(); + } + + public void onActionMove(int x, int y) { + int dx = mLastX - x; + int dy = mLastY - y; + + if (Math.abs(dy) <= 2) { + dy = 0; + } + + mScript.set_gDY(dy); + + mLastX = x; + mLastY = y; + refreshTestResults(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestView.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestView.java new file mode 100644 index 0000000..40192e4 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTestView.java @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import java.io.Writer; +import java.util.ArrayList; +import java.util.concurrent.Semaphore; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; +import android.renderscript.RenderScriptGL; + +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.Message; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; +import android.view.SurfaceView; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class RSTestView extends RSSurfaceView { + + private Context mCtx; + + public RSTestView(Context context) { + super(context); + mCtx = context; + //setFocusable(true); + } + + private RenderScriptGL mRS; + private RSTestCore mRender; + + public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { + super.surfaceChanged(holder, format, w, h); + if (mRS == null) { + RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig(); + mRS = createRenderScriptGL(sc); + mRS.setSurface(holder, w, h); + mRender = new RSTestCore(mCtx); + mRender.init(mRS, getResources(), w, h); + } + } + + @Override + protected void onDetachedFromWindow() { + if(mRS != null) { + mRender.cleanup(); + mRS = null; + destroyRenderScriptGL(); + } + } + + @Override + public boolean onKeyDown(int keyCode, KeyEvent event) + { + return super.onKeyDown(keyCode, event); + } + + @Override + public boolean onTouchEvent(MotionEvent ev) + { + boolean ret = false; + int act = ev.getAction(); + if (act == ev.ACTION_DOWN) { + mRender.onActionDown((int)ev.getX(), (int)ev.getY()); + ret = true; + } + else if (act == ev.ACTION_MOVE) { + mRender.onActionMove((int)ev.getX(), (int)ev.getY()); + ret = true; + } + + return ret; + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTest_v14.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTest_v14.java new file mode 100644 index 0000000..da09691 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/RSTest_v14.java @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.renderscript.RSSurfaceView; +import android.renderscript.RenderScript; + +import android.app.Activity; +import android.content.res.Configuration; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings.System; +import android.util.Log; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.view.Window; +import android.widget.Button; +import android.widget.ListView; + +import java.lang.Runtime; + +public class RSTest_v14 extends Activity { + //EventListener mListener = new EventListener(); + + private static final String LOG_TAG = "RSTest_v14"; + private static final boolean DEBUG = false; + private static final boolean LOG_ENABLED = false; + + private RSTestView mView; + + // get the current looper (from your Activity UI thread for instance + + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + // Create our Preview view and set it as the content of our + // Activity + mView = new RSTestView(this); + setContentView(mView); + } + + @Override + protected void onResume() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity loses focus + super.onResume(); + mView.resume(); + } + + @Override + protected void onPause() { + // Ideally a game should implement onResume() and onPause() + // to take appropriate action when the activity loses focus + super.onPause(); + mView.pause(); + } + + @Override + protected void onStop() { + // Actually kill the app if we are stopping. We don't want to + // continue/resume this test ever. It should always start fresh. + finish(); + super.onStop(); + } + + static void log(String message) { + if (LOG_ENABLED) { + Log.v(LOG_TAG, message); + } + } + + +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_alloc.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_alloc.java new file mode 100644 index 0000000..da42b29 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_alloc.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_alloc extends UnitTest { + private Resources mRes; + + protected UT_alloc(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Alloc", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_alloc s) { + Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS)); + int X = 5; + int Y = 7; + int Z = 0; + s.set_dimX(X); + s.set_dimY(Y); + s.set_dimZ(Z); + typeBuilder.setX(X).setY(Y); + Allocation A = Allocation.createTyped(RS, typeBuilder.create()); + s.bind_a(A); + + typeBuilder = new Type.Builder(RS, Element.I32(RS)); + typeBuilder.setX(X).setY(Y).setFaces(true); + Allocation AFaces = Allocation.createTyped(RS, typeBuilder.create()); + s.set_aFaces(AFaces); + typeBuilder.setFaces(false).setMipmaps(true); + Allocation ALOD = Allocation.createTyped(RS, typeBuilder.create()); + s.set_aLOD(ALOD); + typeBuilder.setFaces(true).setMipmaps(true); + Allocation AFacesLOD = Allocation.createTyped(RS, typeBuilder.create()); + s.set_aFacesLOD(AFacesLOD); + + return; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_alloc s = new ScriptC_alloc(pRS, mRes, R.raw.alloc); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.invoke_alloc_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_foreach.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_foreach.java new file mode 100644 index 0000000..aeb5bb7 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_foreach.java @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_foreach extends UnitTest { + private Resources mRes; + private Allocation A; + + protected UT_foreach(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "ForEach", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_foreach s) { + Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS)); + int X = 5; + int Y = 7; + s.set_dimX(X); + s.set_dimY(Y); + typeBuilder.setX(X).setY(Y); + A = Allocation.createTyped(RS, typeBuilder.create()); + s.bind_a(A); + + return; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_foreach s = new ScriptC_foreach(pRS, mRes, R.raw.foreach); + pRS.setMessageHandler(mRsMessage); + initializeGlobals(pRS, s); + s.forEach_root(A); + s.invoke_foreach_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_fp_mad.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_fp_mad.java new file mode 100644 index 0000000..239496a --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_fp_mad.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_fp_mad extends UnitTest { + private Resources mRes; + + protected UT_fp_mad(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Fp_Mad", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_fp_mad s = new ScriptC_fp_mad(pRS, mRes, R.raw.fp_mad); + pRS.setMessageHandler(mRsMessage); + s.invoke_fp_mad_test(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_math.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_math.java new file mode 100644 index 0000000..7b135c4 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_math.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_math extends UnitTest { + private Resources mRes; + + protected UT_math(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Math", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_math s = new ScriptC_math(pRS, mRes, R.raw.math); + pRS.setMessageHandler(mRsMessage); + s.invoke_math_test(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_primitives.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_primitives.java new file mode 100644 index 0000000..d3c56f3 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_primitives.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_primitives extends UnitTest { + private Resources mRes; + + protected UT_primitives(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Primitives", ctx); + mRes = res; + } + + private boolean initializeGlobals(ScriptC_primitives s) { + float pF = s.get_floatTest(); + if (pF != 1.99f) { + return false; + } + s.set_floatTest(2.99f); + + double pD = s.get_doubleTest(); + if (pD != 2.05) { + return false; + } + s.set_doubleTest(3.05); + + byte pC = s.get_charTest(); + if (pC != -8) { + return false; + } + s.set_charTest((byte)-16); + + short pS = s.get_shortTest(); + if (pS != -16) { + return false; + } + s.set_shortTest((short)-32); + + int pI = s.get_intTest(); + if (pI != -32) { + return false; + } + s.set_intTest(-64); + + long pL = s.get_longTest(); + if (pL != 17179869184l) { + return false; + } + s.set_longTest(17179869185l); + + long puL = s.get_ulongTest(); + if (puL != 4611686018427387904L) { + return false; + } + s.set_ulongTest(4611686018427387903L); + + + long pLL = s.get_longlongTest(); + if (pLL != 68719476736L) { + return false; + } + s.set_longlongTest(68719476735L); + + long pu64 = s.get_uint64_tTest(); + if (pu64 != 117179869184l) { + return false; + } + s.set_uint64_tTest(117179869185l); + + return true; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_primitives s = new ScriptC_primitives(pRS, mRes, R.raw.primitives); + pRS.setMessageHandler(mRsMessage); + if (!initializeGlobals(s)) { + // initializeGlobals failed + result = -1; + } else { + s.invoke_primitives_test(0, 0); + pRS.finish(); + waitForMessage(); + } + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_refcount.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_refcount.java new file mode 100644 index 0000000..05a516b --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_refcount.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_refcount extends UnitTest { + private Resources mRes; + + protected UT_refcount(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Refcount", ctx); + mRes = res; + } + + private void initializeGlobals(RenderScript RS, ScriptC_refcount s) { + Type.Builder typeBuilder = new Type.Builder(RS, Element.I32(RS)); + int X = 500; + int Y = 700; + typeBuilder.setX(X).setY(Y); + Allocation A = Allocation.createTyped(RS, typeBuilder.create()); + s.set_globalA(A); + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + pRS.setMessageHandler(mRsMessage); + ScriptC_refcount s = new ScriptC_refcount(pRS, mRes, R.raw.refcount); + initializeGlobals(pRS, s); + s.invoke_refcount_test(); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rsdebug.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rsdebug.java new file mode 100644 index 0000000..95e92ee --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rsdebug.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rsdebug extends UnitTest { + private Resources mRes; + + protected UT_rsdebug(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsDebug", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rsdebug s = new ScriptC_rsdebug(pRS, mRes, R.raw.rsdebug); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rsdebug(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstime.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstime.java new file mode 100644 index 0000000..a72ede9 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstime.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rstime extends UnitTest { + private Resources mRes; + + protected UT_rstime(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsTime", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rstime s = new ScriptC_rstime(pRS, mRes, R.raw.rstime); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rstime(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstypes.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstypes.java new file mode 100644 index 0000000..ab96867 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_rstypes.java @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_rstypes extends UnitTest { + private Resources mRes; + + protected UT_rstypes(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "rsTypes", ctx); + mRes = res; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_rstypes s = new ScriptC_rstypes(pRS, mRes, R.raw.rstypes); + pRS.setMessageHandler(mRsMessage); + s.invoke_test_rstypes(0, 0); + pRS.finish(); + waitForMessage(); + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_vector.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_vector.java new file mode 100644 index 0000000..657413e --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UT_vector.java @@ -0,0 +1,318 @@ +/* + * Copyright (C) 2011 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; + +import android.content.Context; +import android.content.res.Resources; +import android.renderscript.*; + +public class UT_vector extends UnitTest { + private Resources mRes; + + protected UT_vector(RSTestCore rstc, Resources res, Context ctx) { + super(rstc, "Vector", ctx); + mRes = res; + } + + private boolean initializeGlobals(ScriptC_vector s) { + Float2 F2 = s.get_f2(); + if (F2.x != 1.0f || F2.y != 2.0f) { + return false; + } + F2.x = 2.99f; + F2.y = 3.99f; + s.set_f2(F2); + + Float3 F3 = s.get_f3(); + if (F3.x != 1.0f || F3.y != 2.0f || F3.z != 3.0f) { + return false; + } + F3.x = 2.99f; + F3.y = 3.99f; + F3.z = 4.99f; + s.set_f3(F3); + + Float4 F4 = s.get_f4(); + if (F4.x != 1.0f || F4.y != 2.0f || F4.z != 3.0f || F4.w != 4.0f) { + return false; + } + F4.x = 2.99f; + F4.y = 3.99f; + F4.z = 4.99f; + F4.w = 5.99f; + s.set_f4(F4); + + Double2 D2 = s.get_d2(); + if (D2.x != 1.0 || D2.y != 2.0) { + return false; + } + D2.x = 2.99; + D2.y = 3.99; + s.set_d2(D2); + + Double3 D3 = s.get_d3(); + if (D3.x != 1.0 || D3.y != 2.0 || D3.z != 3.0) { + return false; + } + D3.x = 2.99; + D3.y = 3.99; + D3.z = 4.99; + s.set_d3(D3); + + Double4 D4 = s.get_d4(); + if (D4.x != 1.0 || D4.y != 2.0 || D4.z != 3.0 || D4.w != 4.0) { + return false; + } + D4.x = 2.99; + D4.y = 3.99; + D4.z = 4.99; + D4.w = 5.99; + s.set_d4(D4); + + Byte2 B2 = s.get_i8_2(); + if (B2.x != 1 || B2.y != 2) { + return false; + } + B2.x = 2; + B2.y = 3; + s.set_i8_2(B2); + + Byte3 B3 = s.get_i8_3(); + if (B3.x != 1 || B3.y != 2 || B3.z != 3) { + return false; + } + B3.x = 2; + B3.y = 3; + B3.z = 4; + s.set_i8_3(B3); + + Byte4 B4 = s.get_i8_4(); + if (B4.x != 1 || B4.y != 2 || B4.z != 3 || B4.w != 4) { + return false; + } + B4.x = 2; + B4.y = 3; + B4.z = 4; + B4.w = 5; + s.set_i8_4(B4); + + Short2 S2 = s.get_u8_2(); + if (S2.x != 1 || S2.y != 2) { + return false; + } + S2.x = 2; + S2.y = 3; + s.set_u8_2(S2); + + Short3 S3 = s.get_u8_3(); + if (S3.x != 1 || S3.y != 2 || S3.z != 3) { + return false; + } + S3.x = 2; + S3.y = 3; + S3.z = 4; + s.set_u8_3(S3); + + Short4 S4 = s.get_u8_4(); + if (S4.x != 1 || S4.y != 2 || S4.z != 3 || S4.w != 4) { + return false; + } + S4.x = 2; + S4.y = 3; + S4.z = 4; + S4.w = 5; + s.set_u8_4(S4); + + S2 = s.get_i16_2(); + if (S2.x != 1 || S2.y != 2) { + return false; + } + S2.x = 2; + S2.y = 3; + s.set_i16_2(S2); + + S3 = s.get_i16_3(); + if (S3.x != 1 || S3.y != 2 || S3.z != 3) { + return false; + } + S3.x = 2; + S3.y = 3; + S3.z = 4; + s.set_i16_3(S3); + + S4 = s.get_i16_4(); + if (S4.x != 1 || S4.y != 2 || S4.z != 3 || S4.w != 4) { + return false; + } + S4.x = 2; + S4.y = 3; + S4.z = 4; + S4.w = 5; + s.set_i16_4(S4); + + Int2 I2 = s.get_u16_2(); + if (I2.x != 1 || I2.y != 2) { + return false; + } + I2.x = 2; + I2.y = 3; + s.set_u16_2(I2); + + Int3 I3 = s.get_u16_3(); + if (I3.x != 1 || I3.y != 2 || I3.z != 3) { + return false; + } + I3.x = 2; + I3.y = 3; + I3.z = 4; + s.set_u16_3(I3); + + Int4 I4 = s.get_u16_4(); + if (I4.x != 1 || I4.y != 2 || I4.z != 3 || I4.w != 4) { + return false; + } + I4.x = 2; + I4.y = 3; + I4.z = 4; + I4.w = 5; + s.set_u16_4(I4); + + I2 = s.get_i32_2(); + if (I2.x != 1 || I2.y != 2) { + return false; + } + I2.x = 2; + I2.y = 3; + s.set_i32_2(I2); + + I3 = s.get_i32_3(); + if (I3.x != 1 || I3.y != 2 || I3.z != 3) { + return false; + } + I3.x = 2; + I3.y = 3; + I3.z = 4; + s.set_i32_3(I3); + + I4 = s.get_i32_4(); + if (I4.x != 1 || I4.y != 2 || I4.z != 3 || I4.w != 4) { + return false; + } + I4.x = 2; + I4.y = 3; + I4.z = 4; + I4.w = 5; + s.set_i32_4(I4); + + Long2 L2 = s.get_u32_2(); + if (L2.x != 1 || L2.y != 2) { + return false; + } + L2.x = 2; + L2.y = 3; + s.set_u32_2(L2); + + Long3 L3 = s.get_u32_3(); + if (L3.x != 1 || L3.y != 2 || L3.z != 3) { + return false; + } + L3.x = 2; + L3.y = 3; + L3.z = 4; + s.set_u32_3(L3); + + Long4 L4 = s.get_u32_4(); + if (L4.x != 1 || L4.y != 2 || L4.z != 3 || L4.w != 4) { + return false; + } + L4.x = 2; + L4.y = 3; + L4.z = 4; + L4.w = 5; + s.set_u32_4(L4); + + L2 = s.get_i64_2(); + if (L2.x != 1 || L2.y != 2) { + return false; + } + L2.x = 2; + L2.y = 3; + s.set_i64_2(L2); + + L3 = s.get_i64_3(); + if (L3.x != 1 || L3.y != 2 || L3.z != 3) { + return false; + } + L3.x = 2; + L3.y = 3; + L3.z = 4; + s.set_i64_3(L3); + + L4 = s.get_i64_4(); + if (L4.x != 1 || L4.y != 2 || L4.z != 3 || L4.w != 4) { + return false; + } + L4.x = 2; + L4.y = 3; + L4.z = 4; + L4.w = 5; + s.set_i64_4(L4); + + L2 = s.get_u64_2(); + if (L2.x != 1 || L2.y != 2) { + return false; + } + L2.x = 2; + L2.y = 3; + s.set_u64_2(L2); + + L3 = s.get_u64_3(); + if (L3.x != 1 || L3.y != 2 || L3.z != 3) { + return false; + } + L3.x = 2; + L3.y = 3; + L3.z = 4; + s.set_u64_3(L3); + + L4 = s.get_u64_4(); + if (L4.x != 1 || L4.y != 2 || L4.z != 3 || L4.w != 4) { + return false; + } + L4.x = 2; + L4.y = 3; + L4.z = 4; + L4.w = 5; + s.set_u64_4(L4); + + return true; + } + + public void run() { + RenderScript pRS = RenderScript.create(mCtx); + ScriptC_vector s = new ScriptC_vector(pRS, mRes, R.raw.vector); + pRS.setMessageHandler(mRsMessage); + if (!initializeGlobals(s)) { + result = -1; + } else { + s.invoke_vector_test(); + pRS.finish(); + waitForMessage(); + } + pRS.destroy(); + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UnitTest.java b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UnitTest.java new file mode 100644 index 0000000..558a252 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/UnitTest.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.rs.test_v14; +import android.content.Context; +import android.util.Log; +import android.renderscript.RenderScript.RSMessageHandler; + +public class UnitTest extends Thread { + public String name; + public int result; + private ScriptField_ListAllocs_s.Item mItem; + private RSTestCore mRSTC; + private boolean msgHandled; + protected Context mCtx; + + /* These constants must match those in shared.rsh */ + public static final int RS_MSG_TEST_PASSED = 100; + public static final int RS_MSG_TEST_FAILED = 101; + + private static int numTests = 0; + public int testID; + + protected UnitTest(RSTestCore rstc, String n, int initResult, Context ctx) { + super(); + mRSTC = rstc; + name = n; + msgHandled = false; + mCtx = ctx; + result = initResult; + testID = numTests++; + } + + protected UnitTest(RSTestCore rstc, String n, Context ctx) { + this(rstc, n, 0, ctx); + } + + protected UnitTest(RSTestCore rstc, Context ctx) { + this (rstc, "<Unknown>", ctx); + } + + protected UnitTest(Context ctx) { + this (null, ctx); + } + + protected void _RS_ASSERT(String message, boolean b) { + if(b == false) { + result = -1; + Log.e(name, message + " FAILED"); + } + } + + protected void updateUI() { + if (mItem != null) { + mItem.result = result; + msgHandled = true; + try { + mRSTC.refreshTestResults(); + } + catch (IllegalStateException e) { + /* Ignore the case where our message receiver has been + disconnected. This happens when we leave the application + before it finishes running all of the unit tests. */ + } + } + } + + protected RSMessageHandler mRsMessage = new RSMessageHandler() { + public void run() { + if (result == 0) { + switch (mID) { + case RS_MSG_TEST_PASSED: + result = 1; + break; + case RS_MSG_TEST_FAILED: + result = -1; + break; + default: + RSTest_v14.log("Unit test got unexpected message"); + return; + } + } + + updateUI(); + } + }; + + public void waitForMessage() { + while (!msgHandled) { + yield(); + } + } + + public void setItem(ScriptField_ListAllocs_s.Item item) { + mItem = item; + } + + public void run() { + /* This method needs to be implemented for each subclass */ + if (mRSTC != null) { + mRSTC.refreshTestResults(); + } + } +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/alloc.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/alloc.rs new file mode 100644 index 0000000..3116e5a --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/alloc.rs @@ -0,0 +1,94 @@ +#include "shared.rsh" + +int *a; +int dimX; +int dimY; +int dimZ; + +rs_allocation aFaces; +rs_allocation aLOD; +rs_allocation aFacesLOD; + +static bool test_alloc_dims() { + bool failed = false; + int i, j; + + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + a[i + j * dimX] = i + j * dimX; + } + } + + rs_allocation alloc = rsGetAllocation(a); + _RS_ASSERT(rsAllocationGetDimX(alloc) == dimX); + _RS_ASSERT(rsAllocationGetDimY(alloc) == dimY); + _RS_ASSERT(rsAllocationGetDimZ(alloc) == dimZ); + + // Test 2D addressing + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + rsDebug("Verifying ", i + j * dimX); + const void *p = rsGetElementAt(alloc, i, j); + int val = *(const int *)p; + _RS_ASSERT(val == (i + j * dimX)); + } + } + + // Test 1D addressing + for (i = 0; i < dimX * dimY; i++) { + rsDebug("Verifying ", i); + const void *p = rsGetElementAt(alloc, i); + int val = *(const int *)p; + _RS_ASSERT(val == i); + } + + // Test 3D addressing + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + rsDebug("Verifying ", i + j * dimX); + const void *p = rsGetElementAt(alloc, i, j, 0); + int val = *(const int *)p; + _RS_ASSERT(val == (i + j * dimX)); + } + } + + _RS_ASSERT(rsAllocationGetDimX(aFaces) == dimX); + _RS_ASSERT(rsAllocationGetDimY(aFaces) == dimY); + _RS_ASSERT(rsAllocationGetDimZ(aFaces) == dimZ); + _RS_ASSERT(rsAllocationGetDimFaces(aFaces) != 0); + _RS_ASSERT(rsAllocationGetDimLOD(aFaces) == 0); + + _RS_ASSERT(rsAllocationGetDimX(aLOD) == dimX); + _RS_ASSERT(rsAllocationGetDimY(aLOD) == dimY); + _RS_ASSERT(rsAllocationGetDimZ(aLOD) == dimZ); + _RS_ASSERT(rsAllocationGetDimFaces(aLOD) == 0); + _RS_ASSERT(rsAllocationGetDimLOD(aLOD) != 0); + + _RS_ASSERT(rsAllocationGetDimX(aFacesLOD) == dimX); + _RS_ASSERT(rsAllocationGetDimY(aFacesLOD) == dimY); + _RS_ASSERT(rsAllocationGetDimZ(aFacesLOD) == dimZ); + _RS_ASSERT(rsAllocationGetDimFaces(aFacesLOD) != 0); + _RS_ASSERT(rsAllocationGetDimLOD(aFacesLOD) != 0); + + if (failed) { + rsDebug("test_alloc_dims FAILED", 0); + } + else { + rsDebug("test_alloc_dims PASSED", 0); + } + + return failed; +} + +void alloc_test() { + bool failed = false; + failed |= test_alloc_dims(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/foreach.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/foreach.rs new file mode 100644 index 0000000..3ba3eef --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/foreach.rs @@ -0,0 +1,42 @@ +#include "shared.rsh" + +int *a; +int dimX; +int dimY; + +void root(int *out, uint32_t x, uint32_t y) { + *out = x + y * dimX; +} + +static bool test_foreach_output() { + bool failed = false; + int i, j; + + for (j = 0; j < dimY; j++) { + for (i = 0; i < dimX; i++) { + _RS_ASSERT(a[i + j * dimX] == (i + j * dimX)); + } + } + + if (failed) { + rsDebug("test_foreach_output FAILED", 0); + } + else { + rsDebug("test_foreach_output PASSED", 0); + } + + return failed; +} + +void foreach_test() { + bool failed = false; + failed |= test_foreach_output(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/fp_mad.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/fp_mad.rs new file mode 100644 index 0000000..b6f2b2a --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/fp_mad.rs @@ -0,0 +1,174 @@ +#include "shared.rsh" + +const int TEST_COUNT = 1; + +static float data_f1[1025]; +static float4 data_f4[1025]; + +static void test_mad4(uint32_t index) { + start(); + + float total = 0; + // Do ~1 billion ops + for (int ct=0; ct < 1000 * (1000 / 80); ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = (data_f4[i] * 0.02f + + data_f4[i+1] * 0.04f + + data_f4[i+2] * 0.05f + + data_f4[i+3] * 0.1f + + data_f4[i+4] * 0.2f + + data_f4[i+5] * 0.2f + + data_f4[i+6] * 0.1f + + data_f4[i+7] * 0.05f + + data_f4[i+8] * 0.04f + + data_f4[i+9] * 0.02f + 1.f); + } + } + + float time = end(index); + rsDebug("fp_mad4 M ops", 1000.f / time); +} + +static void test_mad(uint32_t index) { + start(); + + float total = 0; + // Do ~1 billion ops + for (int ct=0; ct < 1000 * (1000 / 20); ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = (data_f1[i] * 0.02f + + data_f1[i+1] * 0.04f + + data_f1[i+2] * 0.05f + + data_f1[i+3] * 0.1f + + data_f1[i+4] * 0.2f + + data_f1[i+5] * 0.2f + + data_f1[i+6] * 0.1f + + data_f1[i+7] * 0.05f + + data_f1[i+8] * 0.04f + + data_f1[i+9] * 0.02f + 1.f); + } + } + + float time = end(index); + rsDebug("fp_mad M ops", 1000.f / time); +} + +static void test_norm(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = normalize(data_f4[i]); + } + } + + float time = end(index); + rsDebug("fp_norm M ops", 10.f / time); +} + +static void test_sincos4(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10 / 4; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = sin(data_f4[i]) * cos(data_f4[i]); + } + } + + float time = end(index); + rsDebug("fp_sincos4 M ops", 10.f / time); +} + +static void test_sincos(uint32_t index) { + start(); + + float total = 0; + // Do ~10 M ops + for (int ct=0; ct < 1000 * 10; ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = sin(data_f1[i]) * cos(data_f1[i]); + } + } + + float time = end(index); + rsDebug("fp_sincos M ops", 10.f / time); +} + +static void test_clamp(uint32_t index) { + start(); + + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100; ct++) { + for (int i=0; i < (1000); i++) { + data_f1[i] = clamp(data_f1[i], -1.f, 1.f); + } + } + + float time = end(index); + rsDebug("fp_clamp M ops", 100.f / time); + + start(); + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100; ct++) { + for (int i=0; i < (1000); i++) { + if (data_f1[i] < -1.f) data_f1[i] = -1.f; + if (data_f1[i] > -1.f) data_f1[i] = 1.f; + } + } + + time = end(index); + rsDebug("fp_clamp ref M ops", 100.f / time); +} + +static void test_clamp4(uint32_t index) { + start(); + + float total = 0; + // Do ~100 M ops + for (int ct=0; ct < 1000 * 100 /4; ct++) { + for (int i=0; i < (1000); i++) { + data_f4[i] = clamp(data_f4[i], -1.f, 1.f); + } + } + + float time = end(index); + rsDebug("fp_clamp4 M ops", 100.f / time); +} + +void fp_mad_test(uint32_t index, int test_num) { + int x; + for (x=0; x < 1025; x++) { + data_f1[x] = (x & 0xf) * 0.1f; + data_f4[x].x = (x & 0xf) * 0.1f; + data_f4[x].y = (x & 0xf0) * 0.1f; + data_f4[x].z = (x & 0x33) * 0.1f; + data_f4[x].w = (x & 0x77) * 0.1f; + } + + test_mad4(index); + test_mad(index); + + for (x=0; x < 1025; x++) { + data_f1[x] = (x & 0xf) * 0.1f + 1.f; + data_f4[x].x = (x & 0xf) * 0.1f + 1.f; + data_f4[x].y = (x & 0xf0) * 0.1f + 1.f; + data_f4[x].z = (x & 0x33) * 0.1f + 1.f; + data_f4[x].w = (x & 0x77) * 0.1f + 1.f; + } + + test_norm(index); + test_sincos4(index); + test_sincos(index); + test_clamp4(index); + test_clamp(index); + + // TODO Actually verify test result accuracy + rsDebug("fp_mad_test PASSED", 0); + rsSendToClientBlocking(RS_MSG_TEST_PASSED); +} + + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs new file mode 100644 index 0000000..e6b37f6 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs @@ -0,0 +1,462 @@ +#include "shared.rsh" + +// Testing math library + +volatile float f1; +volatile float2 f2; +volatile float3 f3; +volatile float4 f4; + +volatile int i1; +volatile int2 i2; +volatile int3 i3; +volatile int4 i4; + +volatile uint ui1; +volatile uint2 ui2; +volatile uint3 ui3; +volatile uint4 ui4; + +volatile short s1; +volatile short2 s2; +volatile short3 s3; +volatile short4 s4; + +volatile ushort us1; +volatile ushort2 us2; +volatile ushort3 us3; +volatile ushort4 us4; + +volatile char c1; +volatile char2 c2; +volatile char3 c3; +volatile char4 c4; + +volatile uchar uc1; +volatile uchar2 uc2; +volatile uchar3 uc3; +volatile uchar4 uc4; + +#define DECL_INT(prefix) \ +volatile char prefix##_c_1 = 1; \ +volatile char2 prefix##_c_2 = 1; \ +volatile char3 prefix##_c_3 = 1; \ +volatile char4 prefix##_c_4 = 1; \ +volatile uchar prefix##_uc_1 = 1; \ +volatile uchar2 prefix##_uc_2 = 1; \ +volatile uchar3 prefix##_uc_3 = 1; \ +volatile uchar4 prefix##_uc_4 = 1; \ +volatile short prefix##_s_1 = 1; \ +volatile short2 prefix##_s_2 = 1; \ +volatile short3 prefix##_s_3 = 1; \ +volatile short4 prefix##_s_4 = 1; \ +volatile ushort prefix##_us_1 = 1; \ +volatile ushort2 prefix##_us_2 = 1; \ +volatile ushort3 prefix##_us_3 = 1; \ +volatile ushort4 prefix##_us_4 = 1; \ +volatile int prefix##_i_1 = 1; \ +volatile int2 prefix##_i_2 = 1; \ +volatile int3 prefix##_i_3 = 1; \ +volatile int4 prefix##_i_4 = 1; \ +volatile uint prefix##_ui_1 = 1; \ +volatile uint2 prefix##_ui_2 = 1; \ +volatile uint3 prefix##_ui_3 = 1; \ +volatile uint4 prefix##_ui_4 = 1; \ +volatile long prefix##_l_1 = 1; \ +volatile ulong prefix##_ul_1 = 1; + +DECL_INT(res) +DECL_INT(src1) +DECL_INT(src2) + +#define TEST_INT_OP_TYPE(op, type) \ +rsDebug("Testing " #op " for " #type "1", i++); \ +res_##type##_1 = src1_##type##_1 op src2_##type##_1; \ +rsDebug("Testing " #op " for " #type "2", i++); \ +res_##type##_2 = src1_##type##_2 op src2_##type##_2; \ +rsDebug("Testing " #op " for " #type "3", i++); \ +res_##type##_3 = src1_##type##_3 op src2_##type##_3; \ +rsDebug("Testing " #op " for " #type "4", i++); \ +res_##type##_4 = src1_##type##_4 op src2_##type##_4; + +#define TEST_INT_OP(op) \ +TEST_INT_OP_TYPE(op, c) \ +TEST_INT_OP_TYPE(op, uc) \ +TEST_INT_OP_TYPE(op, s) \ +TEST_INT_OP_TYPE(op, us) \ +TEST_INT_OP_TYPE(op, i) \ +TEST_INT_OP_TYPE(op, ui) \ +rsDebug("Testing " #op " for l1", i++); \ +res_l_1 = src1_l_1 op src2_l_1; \ +rsDebug("Testing " #op " for ul1", i++); \ +res_ul_1 = src1_ul_1 op src2_ul_1; + +#define TEST_XN_FUNC_YN(typeout, fnc, typein) \ + res_##typeout##_1 = fnc(src1_##typein##_1); \ + res_##typeout##_2 = fnc(src1_##typein##_2); \ + res_##typeout##_3 = fnc(src1_##typein##_3); \ + res_##typeout##_4 = fnc(src1_##typein##_4); + +#define TEST_XN_FUNC_XN_XN(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1); \ + res_##type##_2 = fnc(src1_##type##_2, src2_##type##_2); \ + res_##type##_3 = fnc(src1_##type##_3, src2_##type##_3); \ + res_##type##_4 = fnc(src1_##type##_4, src2_##type##_4); + +#define TEST_X_FUNC_X_X_X(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1, src2_##type##_1); + +#define TEST_IN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, uc) \ + TEST_XN_FUNC_YN(c, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, us) \ + TEST_XN_FUNC_YN(s, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, ui) \ + TEST_XN_FUNC_YN(i, fnc, i) + +#define TEST_UIN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, i) \ + +#define TEST_IN_FUNC_IN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_XN_XN(uc, fnc) \ + TEST_XN_FUNC_XN_XN(c, fnc) \ + TEST_XN_FUNC_XN_XN(us, fnc) \ + TEST_XN_FUNC_XN_XN(s, fnc) \ + TEST_XN_FUNC_XN_XN(ui, fnc) \ + TEST_XN_FUNC_XN_XN(i, fnc) + +#define TEST_I_FUNC_I_I_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_X_FUNC_X_X_X(uc, fnc) \ + TEST_X_FUNC_X_X_X(c, fnc) \ + TEST_X_FUNC_X_X_X(us, fnc) \ + TEST_X_FUNC_X_X_X(s, fnc) \ + TEST_X_FUNC_X_X_X(ui, fnc) \ + TEST_X_FUNC_X_X_X(i, fnc) + +#define TEST_FN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f2 = fnc(f2); \ + f3 = fnc(f3); \ + f4 = fnc(f4); + +#define TEST_FN_FUNC_FN_PFN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (float*) &f1); \ + f2 = fnc(f2, (float2*) &f2); \ + f3 = fnc(f3, (float3*) &f3); \ + f4 = fnc(f4, (float4*) &f4); + +#define TEST_FN_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f2); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_F34_FUNC_F34_F34(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f1); \ + f3 = fnc(f3, f1); \ + f4 = fnc(f4, f1); + +#define TEST_F_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f1 = fnc(f2); \ + f1 = fnc(f3); \ + f1 = fnc(f4); + +#define TEST_F_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f1 = fnc(f2, f2); \ + f1 = fnc(f3, f3); \ + f1 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i2); \ + f3 = fnc(f3, i3); \ + f4 = fnc(f4, i4); + +#define TEST_FN_FUNC_FN_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i1); \ + f3 = fnc(f3, i1); \ + f4 = fnc(f4, i1); + +#define TEST_FN_FUNC_FN_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f2, f2); \ + f3 = fnc(f3, f3, f3); \ + f4 = fnc(f4, f4, f4); + +#define TEST_FN_FUNC_FN_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f1, f1); \ + f3 = fnc(f3, f1, f1); \ + f4 = fnc(f4, f1, f1); + +#define TEST_FN_FUNC_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (int*) &i1); \ + f2 = fnc(f2, (int2*) &i2); \ + f3 = fnc(f3, (int3*) &i3); \ + f4 = fnc(f4, (int4*) &i4); + +#define TEST_FN_FUNC_FN_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, (int*) &i1); \ + f2 = fnc(f2, f2, (int2*) &i2); \ + f3 = fnc(f3, f3, (int3*) &i3); \ + f4 = fnc(f4, f4, (int4*) &i4); + +#define TEST_IN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + i1 = fnc(f1); \ + i2 = fnc(f2); \ + i3 = fnc(f3); \ + i4 = fnc(f4); + +static bool test_fp_math(uint32_t index) { + bool failed = false; + start(); + + TEST_FN_FUNC_FN(acos); + TEST_FN_FUNC_FN(acosh); + TEST_FN_FUNC_FN(acospi); + TEST_FN_FUNC_FN(asin); + TEST_FN_FUNC_FN(asinh); + TEST_FN_FUNC_FN(asinpi); + TEST_FN_FUNC_FN(atan); + TEST_FN_FUNC_FN_FN(atan2); + TEST_FN_FUNC_FN(atanh); + TEST_FN_FUNC_FN(atanpi); + TEST_FN_FUNC_FN_FN(atan2pi); + TEST_FN_FUNC_FN(cbrt); + TEST_FN_FUNC_FN(ceil); + TEST_FN_FUNC_FN_FN_FN(clamp); + TEST_FN_FUNC_FN_FN_F(clamp); + TEST_FN_FUNC_FN_FN(copysign); + TEST_FN_FUNC_FN(cos); + TEST_FN_FUNC_FN(cosh); + TEST_FN_FUNC_FN(cospi); + TEST_F34_FUNC_F34_F34(cross); + TEST_FN_FUNC_FN(degrees); + TEST_F_FUNC_FN_FN(distance); + TEST_F_FUNC_FN_FN(dot); + TEST_FN_FUNC_FN(erfc); + TEST_FN_FUNC_FN(erf); + TEST_FN_FUNC_FN(exp); + TEST_FN_FUNC_FN(exp2); + TEST_FN_FUNC_FN(exp10); + TEST_FN_FUNC_FN(expm1); + TEST_FN_FUNC_FN(fabs); + TEST_FN_FUNC_FN_FN(fdim); + TEST_FN_FUNC_FN(floor); + TEST_FN_FUNC_FN_FN_FN(fma); + TEST_FN_FUNC_FN_FN(fmax); + TEST_FN_FUNC_FN_F(fmax); + TEST_FN_FUNC_FN_FN(fmin); + TEST_FN_FUNC_FN_F(fmin); + TEST_FN_FUNC_FN_FN(fmod); + TEST_FN_FUNC_FN_PFN(fract); + TEST_FN_FUNC_FN_PIN(frexp); + TEST_FN_FUNC_FN_FN(hypot); + TEST_IN_FUNC_FN(ilogb); + TEST_FN_FUNC_FN_IN(ldexp); + TEST_FN_FUNC_FN_I(ldexp); + TEST_F_FUNC_FN(length); + TEST_FN_FUNC_FN(lgamma); + TEST_FN_FUNC_FN_PIN(lgamma); + TEST_FN_FUNC_FN(log); + TEST_FN_FUNC_FN(log2); + TEST_FN_FUNC_FN(log10); + TEST_FN_FUNC_FN(log1p); + TEST_FN_FUNC_FN(logb); + TEST_FN_FUNC_FN_FN_FN(mad); + TEST_FN_FUNC_FN_FN(max); + TEST_FN_FUNC_FN_F(max); + TEST_FN_FUNC_FN_FN(min); + TEST_FN_FUNC_FN_F(min); + TEST_FN_FUNC_FN_FN_FN(mix); + TEST_FN_FUNC_FN_FN_F(mix); + TEST_FN_FUNC_FN_PFN(modf); + // nan + TEST_FN_FUNC_FN_FN(nextafter); + TEST_FN_FUNC_FN(normalize); + TEST_FN_FUNC_FN_FN(pow); + TEST_FN_FUNC_FN_IN(pown); + TEST_FN_FUNC_FN_FN(powr); + TEST_FN_FUNC_FN(radians); + TEST_FN_FUNC_FN_FN(remainder); + TEST_FN_FUNC_FN_FN_PIN(remquo); + TEST_FN_FUNC_FN(rint); + TEST_FN_FUNC_FN_IN(rootn); + TEST_FN_FUNC_FN(round); + TEST_FN_FUNC_FN(rsqrt); + TEST_FN_FUNC_FN(sign); + TEST_FN_FUNC_FN(sin); + TEST_FN_FUNC_FN_PFN(sincos); + TEST_FN_FUNC_FN(sinh); + TEST_FN_FUNC_FN(sinpi); + TEST_FN_FUNC_FN(sqrt); + TEST_FN_FUNC_FN_FN(step); + TEST_FN_FUNC_FN_F(step); + TEST_FN_FUNC_FN(tan); + TEST_FN_FUNC_FN(tanh); + TEST_FN_FUNC_FN(tanpi); + TEST_FN_FUNC_FN(tgamma); + TEST_FN_FUNC_FN(trunc); + + float time = end(index); + + if (failed) { + rsDebug("test_fp_math FAILED", time); + } + else { + rsDebug("test_fp_math PASSED", time); + } + + return failed; +} + +static bool test_int_math(uint32_t index) { + bool failed = false; + start(); + + TEST_UIN_FUNC_IN(abs); + TEST_IN_FUNC_IN(clz); + TEST_IN_FUNC_IN_IN(min); + TEST_IN_FUNC_IN_IN(max); + TEST_I_FUNC_I_I_I(rsClamp); + + float time = end(index); + + if (failed) { + rsDebug("test_int_math FAILED", time); + } + else { + rsDebug("test_int_math PASSED", time); + } + + return failed; +} + +static bool test_basic_operators() { + bool failed = false; + int i = 0; + + TEST_INT_OP(+); + TEST_INT_OP(-); + TEST_INT_OP(*); + TEST_INT_OP(/); + TEST_INT_OP(%); + TEST_INT_OP(<<); + TEST_INT_OP(>>); + + if (failed) { + rsDebug("test_basic_operators FAILED", 0); + } + else { + rsDebug("test_basic_operators PASSED", 0); + } + + return failed; +} + +#define TEST_CVT(to, from, type) \ +rsDebug("Testing convert from " #from " to " #to, 0); \ +to##1 = from##1; \ +to##2 = convert_##type##2(from##2); \ +to##3 = convert_##type##3(from##3); \ +to##4 = convert_##type##4(from##4); + +#define TEST_CVT_MATRIX(to, type) \ +TEST_CVT(to, c, type); \ +TEST_CVT(to, uc, type); \ +TEST_CVT(to, s, type); \ +TEST_CVT(to, us, type); \ +TEST_CVT(to, i, type); \ +TEST_CVT(to, ui, type); \ +TEST_CVT(to, f, type); \ + +static bool test_convert() { + bool failed = false; + + TEST_CVT_MATRIX(c, char); + TEST_CVT_MATRIX(uc, uchar); + TEST_CVT_MATRIX(s, short); + TEST_CVT_MATRIX(us, ushort); + TEST_CVT_MATRIX(i, int); + TEST_CVT_MATRIX(ui, uint); + TEST_CVT_MATRIX(f, float); + + if (failed) { + rsDebug("test_convert FAILED", 0); + } + else { + rsDebug("test_convert PASSED", 0); + } + + return failed; +} + +#define INIT_PREFIX_TYPE(prefix, type) \ +prefix##_##type##_1 = 1; \ +prefix##_##type##_2.x = 1; \ +prefix##_##type##_2.y = 1; \ +prefix##_##type##_3.x = 1; \ +prefix##_##type##_3.y = 1; \ +prefix##_##type##_3.z = 1; \ +prefix##_##type##_4.x = 1; \ +prefix##_##type##_4.y = 1; \ +prefix##_##type##_4.z = 1; \ +prefix##_##type##_4.w = 1; + +#define INIT_TYPE(type) \ +INIT_PREFIX_TYPE(src1, type) \ +INIT_PREFIX_TYPE(src2, type) \ +INIT_PREFIX_TYPE(res, type) + +#define INIT_ALL \ +INIT_TYPE(c); \ +INIT_TYPE(uc); \ +INIT_TYPE(s); \ +INIT_TYPE(us); \ +INIT_TYPE(i); \ +INIT_TYPE(ui); + +void math_test(uint32_t index, int test_num) { + bool failed = false; + INIT_ALL; + failed |= test_convert(); + failed |= test_fp_math(index); + failed |= test_int_math(index); + failed |= test_basic_operators(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.bak b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.bak new file mode 100644 index 0000000..ad802ca --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.bak @@ -0,0 +1,423 @@ +#include "shared.rsh" + +// Testing math library + +volatile float f1; +volatile float2 f2; +volatile float3 f3; +volatile float4 f4; + +volatile int i1; +volatile int2 i2; +volatile int3 i3; +volatile int4 i4; + +volatile uint ui1; +volatile uint2 ui2; +volatile uint3 ui3; +volatile uint4 ui4; + +volatile short s1; +volatile short2 s2; +volatile short3 s3; +volatile short4 s4; + +volatile ushort us1; +volatile ushort2 us2; +volatile ushort3 us3; +volatile ushort4 us4; + +volatile char c1; +volatile char2 c2; +volatile char3 c3; +volatile char4 c4; + +volatile uchar uc1; +volatile uchar2 uc2; +volatile uchar3 uc3; +volatile uchar4 uc4; + +#define DECL_INT(prefix) \ +volatile char prefix##_c_1 = 1; \ +volatile char2 prefix##_c_2 = 1; \ +volatile char3 prefix##_c_3 = 1; \ +volatile char4 prefix##_c_4 = 1; \ +volatile uchar prefix##_uc_1 = 1; \ +volatile uchar2 prefix##_uc_2 = 1; \ +volatile uchar3 prefix##_uc_3 = 1; \ +volatile uchar4 prefix##_uc_4 = 1; \ +volatile short prefix##_s_1 = 1; \ +volatile short2 prefix##_s_2 = 1; \ +volatile short3 prefix##_s_3 = 1; \ +volatile short4 prefix##_s_4 = 1; \ +volatile ushort prefix##_us_1 = 1; \ +volatile ushort2 prefix##_us_2 = 1; \ +volatile ushort3 prefix##_us_3 = 1; \ +volatile ushort4 prefix##_us_4 = 1; \ +volatile int prefix##_i_1 = 1; \ +volatile int2 prefix##_i_2 = 1; \ +volatile int3 prefix##_i_3 = 1; \ +volatile int4 prefix##_i_4 = 1; \ +volatile uint prefix##_ui_1 = 1; \ +volatile uint2 prefix##_ui_2 = 1; \ +volatile uint3 prefix##_ui_3 = 1; \ +volatile uint4 prefix##_ui_4 = 1; \ +volatile long prefix##_l_1 = 1; \ +volatile ulong prefix##_ul_1 = 1; + +DECL_INT(res) +DECL_INT(src1) +DECL_INT(src2) + +#define TEST_INT_OP_TYPE(op, type) \ +rsDebug("Testing " #op " for " #type "3", i++); \ +res_##type##_3 = src1_##type##_3 op src2_##type##_3; \ + +#define TEST_INT_OP(op) \ +TEST_INT_OP_TYPE(op, c) \ +TEST_INT_OP_TYPE(op, uc) \ + +#define TEST_XN_FUNC_YN(typeout, fnc, typein) \ + res_##typeout##_1 = fnc(src1_##typein##_1); \ + res_##typeout##_2 = fnc(src1_##typein##_2); \ + res_##typeout##_3 = fnc(src1_##typein##_3); \ + res_##typeout##_4 = fnc(src1_##typein##_4); + +#define TEST_XN_FUNC_XN_XN(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1); \ + res_##type##_2 = fnc(src1_##type##_2, src2_##type##_2); \ + res_##type##_3 = fnc(src1_##type##_3, src2_##type##_3); \ + res_##type##_4 = fnc(src1_##type##_4, src2_##type##_4); + +#define TEST_X_FUNC_X_X_X(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1, src2_##type##_1); + +#define TEST_IN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, uc) \ + TEST_XN_FUNC_YN(c, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, us) \ + TEST_XN_FUNC_YN(s, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, ui) \ + TEST_XN_FUNC_YN(i, fnc, i) + +#define TEST_UIN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, i) \ + +#define TEST_IN_FUNC_IN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_XN_XN(uc, fnc) \ + TEST_XN_FUNC_XN_XN(c, fnc) \ + TEST_XN_FUNC_XN_XN(us, fnc) \ + TEST_XN_FUNC_XN_XN(s, fnc) \ + TEST_XN_FUNC_XN_XN(ui, fnc) \ + TEST_XN_FUNC_XN_XN(i, fnc) + +#define TEST_I_FUNC_I_I_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_X_FUNC_X_X_X(uc, fnc) \ + TEST_X_FUNC_X_X_X(c, fnc) \ + TEST_X_FUNC_X_X_X(us, fnc) \ + TEST_X_FUNC_X_X_X(s, fnc) \ + TEST_X_FUNC_X_X_X(ui, fnc) \ + TEST_X_FUNC_X_X_X(i, fnc) + +#define TEST_FN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f2 = fnc(f2); \ + f3 = fnc(f3); \ + f4 = fnc(f4); + +#define TEST_FN_FUNC_FN_PFN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (float*) &f1); \ + f2 = fnc(f2, (float2*) &f2); \ + f3 = fnc(f3, (float3*) &f3); \ + f4 = fnc(f4, (float4*) &f4); + +#define TEST_FN_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f2); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_F34_FUNC_F34_F34(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f1); \ + f3 = fnc(f3, f1); \ + f4 = fnc(f4, f1); + +#define TEST_F_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f1 = fnc(f2); \ + f1 = fnc(f3); \ + f1 = fnc(f4); + +#define TEST_F_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f1 = fnc(f2, f2); \ + f1 = fnc(f3, f3); \ + f1 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i2); \ + f3 = fnc(f3, i3); \ + f4 = fnc(f4, i4); + +#define TEST_FN_FUNC_FN_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i1); \ + f3 = fnc(f3, i1); \ + f4 = fnc(f4, i1); + +#define TEST_FN_FUNC_FN_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f2, f2); \ + f3 = fnc(f3, f3, f3); \ + f4 = fnc(f4, f4, f4); + +#define TEST_FN_FUNC_FN_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f1, f1); \ + f3 = fnc(f3, f1, f1); \ + f4 = fnc(f4, f1, f1); + +#define TEST_FN_FUNC_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (int*) &i1); \ + f2 = fnc(f2, (int2*) &i2); \ + f3 = fnc(f3, (int3*) &i3); \ + f4 = fnc(f4, (int4*) &i4); + +#define TEST_FN_FUNC_FN_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, (int*) &i1); \ + f2 = fnc(f2, f2, (int2*) &i2); \ + f3 = fnc(f3, f3, (int3*) &i3); \ + f4 = fnc(f4, f4, (int4*) &i4); + +#define TEST_IN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + i1 = fnc(f1); \ + i2 = fnc(f2); \ + i3 = fnc(f3); \ + i4 = fnc(f4); + +static bool test_fp_math(uint32_t index) { + bool failed = false; + start(); + + TEST_FN_FUNC_FN(acos); + TEST_FN_FUNC_FN(acosh); + TEST_FN_FUNC_FN(acospi); + TEST_FN_FUNC_FN(asin); + TEST_FN_FUNC_FN(asinh); + TEST_FN_FUNC_FN(asinpi); + TEST_FN_FUNC_FN(atan); + TEST_FN_FUNC_FN_FN(atan2); + TEST_FN_FUNC_FN(atanh); + TEST_FN_FUNC_FN(atanpi); + TEST_FN_FUNC_FN_FN(atan2pi); + TEST_FN_FUNC_FN(cbrt); + TEST_FN_FUNC_FN(ceil); + TEST_FN_FUNC_FN_FN_FN(clamp); + TEST_FN_FUNC_FN_FN_F(clamp); + TEST_FN_FUNC_FN_FN(copysign); + TEST_FN_FUNC_FN(cos); + TEST_FN_FUNC_FN(cosh); + TEST_FN_FUNC_FN(cospi); + TEST_F34_FUNC_F34_F34(cross); + TEST_FN_FUNC_FN(degrees); + TEST_F_FUNC_FN_FN(distance); + TEST_F_FUNC_FN_FN(dot); + TEST_FN_FUNC_FN(erfc); + TEST_FN_FUNC_FN(erf); + TEST_FN_FUNC_FN(exp); + TEST_FN_FUNC_FN(exp2); + TEST_FN_FUNC_FN(exp10); + TEST_FN_FUNC_FN(expm1); + TEST_FN_FUNC_FN(fabs); + TEST_FN_FUNC_FN_FN(fdim); + TEST_FN_FUNC_FN(floor); + TEST_FN_FUNC_FN_FN_FN(fma); + TEST_FN_FUNC_FN_FN(fmax); + TEST_FN_FUNC_FN_F(fmax); + TEST_FN_FUNC_FN_FN(fmin); + TEST_FN_FUNC_FN_F(fmin); + TEST_FN_FUNC_FN_FN(fmod); + TEST_FN_FUNC_FN_PFN(fract); + TEST_FN_FUNC_FN_PIN(frexp); + TEST_FN_FUNC_FN_FN(hypot); + TEST_IN_FUNC_FN(ilogb); + TEST_FN_FUNC_FN_IN(ldexp); + TEST_FN_FUNC_FN_I(ldexp); + TEST_F_FUNC_FN(length); + TEST_FN_FUNC_FN(lgamma); + TEST_FN_FUNC_FN_PIN(lgamma); + TEST_FN_FUNC_FN(log); + TEST_FN_FUNC_FN(log2); + TEST_FN_FUNC_FN(log10); + TEST_FN_FUNC_FN(log1p); + TEST_FN_FUNC_FN(logb); + TEST_FN_FUNC_FN_FN_FN(mad); + TEST_FN_FUNC_FN_FN(max); + TEST_FN_FUNC_FN_F(max); + TEST_FN_FUNC_FN_FN(min); + TEST_FN_FUNC_FN_F(min); + TEST_FN_FUNC_FN_FN_FN(mix); + TEST_FN_FUNC_FN_FN_F(mix); + TEST_FN_FUNC_FN_PFN(modf); + // nan + TEST_FN_FUNC_FN_FN(nextafter); + TEST_FN_FUNC_FN(normalize); + TEST_FN_FUNC_FN_FN(pow); + TEST_FN_FUNC_FN_IN(pown); + TEST_FN_FUNC_FN_FN(powr); + TEST_FN_FUNC_FN(radians); + TEST_FN_FUNC_FN_FN(remainder); + TEST_FN_FUNC_FN_FN_PIN(remquo); + TEST_FN_FUNC_FN(rint); + TEST_FN_FUNC_FN_IN(rootn); + TEST_FN_FUNC_FN(round); + TEST_FN_FUNC_FN(rsqrt); + TEST_FN_FUNC_FN(sign); + TEST_FN_FUNC_FN(sin); + TEST_FN_FUNC_FN_PFN(sincos); + TEST_FN_FUNC_FN(sinh); + TEST_FN_FUNC_FN(sinpi); + TEST_FN_FUNC_FN(sqrt); + TEST_FN_FUNC_FN_FN(step); + TEST_FN_FUNC_FN_F(step); + TEST_FN_FUNC_FN(tan); + TEST_FN_FUNC_FN(tanh); + TEST_FN_FUNC_FN(tanpi); + TEST_FN_FUNC_FN(tgamma); + TEST_FN_FUNC_FN(trunc); + + float time = end(index); + + if (failed) { + rsDebug("test_fp_math FAILED", time); + } + else { + rsDebug("test_fp_math PASSED", time); + } + + return failed; +} + +static bool test_int_math(uint32_t index) { + bool failed = false; + start(); + + TEST_UIN_FUNC_IN(abs); + TEST_IN_FUNC_IN(clz); + TEST_IN_FUNC_IN_IN(min); + TEST_IN_FUNC_IN_IN(max); + TEST_I_FUNC_I_I_I(rsClamp); + + float time = end(index); + + if (failed) { + rsDebug("test_int_math FAILED", time); + } + else { + rsDebug("test_int_math PASSED", time); + } + + return failed; +} + +static bool test_basic_operators() { + bool failed = false; + int i = 0; + + TEST_INT_OP(+); + TEST_INT_OP(-); + TEST_INT_OP(*); + TEST_INT_OP(/); + TEST_INT_OP(%); + TEST_INT_OP(<<); + TEST_INT_OP(>>); + + if (failed) { + rsDebug("test_basic_operators FAILED", 0); + } + else { + rsDebug("test_basic_operators PASSED", 0); + } + + return failed; +} + +#define TEST_CVT(to, from, type) \ +rsDebug("Testing convert from " #from " to " #to, 0); \ +to##1 = from##1; \ +to##2 = convert_##type##2(from##2); \ +to##3 = convert_##type##3(from##3); \ +to##4 = convert_##type##4(from##4); + +#define TEST_CVT_MATRIX(to, type) \ +TEST_CVT(to, c, type); \ +TEST_CVT(to, uc, type); \ +TEST_CVT(to, s, type); \ +TEST_CVT(to, us, type); \ +TEST_CVT(to, i, type); \ +TEST_CVT(to, ui, type); \ +TEST_CVT(to, f, type); \ + +static bool test_convert() { + bool failed = false; + + TEST_CVT_MATRIX(c, char); + TEST_CVT_MATRIX(uc, uchar); + TEST_CVT_MATRIX(s, short); + TEST_CVT_MATRIX(us, ushort); + TEST_CVT_MATRIX(i, int); + TEST_CVT_MATRIX(ui, uint); + TEST_CVT_MATRIX(f, float); + + if (failed) { + rsDebug("test_convert FAILED", 0); + } + else { + rsDebug("test_convert PASSED", 0); + } + + return failed; +} + +void math_test(uint32_t index, int test_num) { + bool failed = false; + rsDebug("Here ", 1); + res_uc_3 = src1_uc_3 / src2_uc_3; + rsDebug("Here ", 2); + failed |= test_basic_operators(); + rsDebug("Here ", 3); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.orig b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.orig new file mode 100644 index 0000000..aae29a4 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/math.rs.orig @@ -0,0 +1,436 @@ +#include "shared.rsh" + +// Testing math library + +volatile float f1; +volatile float2 f2; +volatile float3 f3; +volatile float4 f4; + +volatile int i1; +volatile int2 i2; +volatile int3 i3; +volatile int4 i4; + +volatile uint ui1; +volatile uint2 ui2; +volatile uint3 ui3; +volatile uint4 ui4; + +volatile short s1; +volatile short2 s2; +volatile short3 s3; +volatile short4 s4; + +volatile ushort us1; +volatile ushort2 us2; +volatile ushort3 us3; +volatile ushort4 us4; + +volatile char c1; +volatile char2 c2; +volatile char3 c3; +volatile char4 c4; + +volatile uchar uc1; +volatile uchar2 uc2; +volatile uchar3 uc3; +volatile uchar4 uc4; + +#define DECL_INT(prefix) \ +volatile char prefix##_c_1 = 1; \ +volatile char2 prefix##_c_2 = 1; \ +volatile char3 prefix##_c_3 = 1; \ +volatile char4 prefix##_c_4 = 1; \ +volatile uchar prefix##_uc_1 = 1; \ +volatile uchar2 prefix##_uc_2 = 1; \ +volatile uchar3 prefix##_uc_3 = 1; \ +volatile uchar4 prefix##_uc_4 = 1; \ +volatile short prefix##_s_1 = 1; \ +volatile short2 prefix##_s_2 = 1; \ +volatile short3 prefix##_s_3 = 1; \ +volatile short4 prefix##_s_4 = 1; \ +volatile ushort prefix##_us_1 = 1; \ +volatile ushort2 prefix##_us_2 = 1; \ +volatile ushort3 prefix##_us_3 = 1; \ +volatile ushort4 prefix##_us_4 = 1; \ +volatile int prefix##_i_1 = 1; \ +volatile int2 prefix##_i_2 = 1; \ +volatile int3 prefix##_i_3 = 1; \ +volatile int4 prefix##_i_4 = 1; \ +volatile uint prefix##_ui_1 = 1; \ +volatile uint2 prefix##_ui_2 = 1; \ +volatile uint3 prefix##_ui_3 = 1; \ +volatile uint4 prefix##_ui_4 = 1; \ +volatile long prefix##_l_1 = 1; \ +volatile ulong prefix##_ul_1 = 1; + +DECL_INT(res) +DECL_INT(src1) +DECL_INT(src2) + +#define TEST_INT_OP_TYPE(op, type) \ +rsDebug("Testing " #op " for " #type "1", i++); \ +res_##type##_1 = src1_##type##_1 op src2_##type##_1; \ +rsDebug("Testing " #op " for " #type "2", i++); \ +res_##type##_2 = src1_##type##_2 op src2_##type##_2; \ +rsDebug("Testing " #op " for " #type "3", i++); \ +res_##type##_3 = src1_##type##_3 op src2_##type##_3; \ +rsDebug("Testing " #op " for " #type "4", i++); \ +res_##type##_4 = src1_##type##_4 op src2_##type##_4; + +#define TEST_INT_OP(op) \ +TEST_INT_OP_TYPE(op, c) \ +TEST_INT_OP_TYPE(op, uc) \ +TEST_INT_OP_TYPE(op, s) \ +TEST_INT_OP_TYPE(op, us) \ +TEST_INT_OP_TYPE(op, i) \ +TEST_INT_OP_TYPE(op, ui) \ +rsDebug("Testing " #op " for l1", i++); \ +res_l_1 = src1_l_1 op src2_l_1; \ +rsDebug("Testing " #op " for ul1", i++); \ +res_ul_1 = src1_ul_1 op src2_ul_1; + +#define TEST_XN_FUNC_YN(typeout, fnc, typein) \ + res_##typeout##_1 = fnc(src1_##typein##_1); \ + res_##typeout##_2 = fnc(src1_##typein##_2); \ + res_##typeout##_3 = fnc(src1_##typein##_3); \ + res_##typeout##_4 = fnc(src1_##typein##_4); + +#define TEST_XN_FUNC_XN_XN(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1); \ + res_##type##_2 = fnc(src1_##type##_2, src2_##type##_2); \ + res_##type##_3 = fnc(src1_##type##_3, src2_##type##_3); \ + res_##type##_4 = fnc(src1_##type##_4, src2_##type##_4); + +#define TEST_X_FUNC_X_X_X(type, fnc) \ + res_##type##_1 = fnc(src1_##type##_1, src2_##type##_1, src2_##type##_1); + +#define TEST_IN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, uc) \ + TEST_XN_FUNC_YN(c, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, us) \ + TEST_XN_FUNC_YN(s, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, ui) \ + TEST_XN_FUNC_YN(i, fnc, i) + +#define TEST_UIN_FUNC_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_YN(uc, fnc, c) \ + TEST_XN_FUNC_YN(us, fnc, s) \ + TEST_XN_FUNC_YN(ui, fnc, i) \ + +#define TEST_IN_FUNC_IN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_XN_FUNC_XN_XN(uc, fnc) \ + TEST_XN_FUNC_XN_XN(c, fnc) \ + TEST_XN_FUNC_XN_XN(us, fnc) \ + TEST_XN_FUNC_XN_XN(s, fnc) \ + TEST_XN_FUNC_XN_XN(ui, fnc) \ + TEST_XN_FUNC_XN_XN(i, fnc) + +#define TEST_I_FUNC_I_I_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + TEST_X_FUNC_X_X_X(uc, fnc) \ + TEST_X_FUNC_X_X_X(c, fnc) \ + TEST_X_FUNC_X_X_X(us, fnc) \ + TEST_X_FUNC_X_X_X(s, fnc) \ + TEST_X_FUNC_X_X_X(ui, fnc) \ + TEST_X_FUNC_X_X_X(i, fnc) + +#define TEST_FN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f2 = fnc(f2); \ + f3 = fnc(f3); \ + f4 = fnc(f4); + +#define TEST_FN_FUNC_FN_PFN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (float*) &f1); \ + f2 = fnc(f2, (float2*) &f2); \ + f3 = fnc(f3, (float3*) &f3); \ + f4 = fnc(f4, (float4*) &f4); + +#define TEST_FN_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f2); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_F34_FUNC_F34_F34(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f3 = fnc(f3, f3); \ + f4 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f2 = fnc(f2, f1); \ + f3 = fnc(f3, f1); \ + f4 = fnc(f4, f1); + +#define TEST_F_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1); \ + f1 = fnc(f2); \ + f1 = fnc(f3); \ + f1 = fnc(f4); + +#define TEST_F_FUNC_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1); \ + f1 = fnc(f2, f2); \ + f1 = fnc(f3, f3); \ + f1 = fnc(f4, f4); + +#define TEST_FN_FUNC_FN_IN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i2); \ + f3 = fnc(f3, i3); \ + f4 = fnc(f4, i4); + +#define TEST_FN_FUNC_FN_I(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, i1); \ + f2 = fnc(f2, i1); \ + f3 = fnc(f3, i1); \ + f4 = fnc(f4, i1); + +#define TEST_FN_FUNC_FN_FN_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f2, f2); \ + f3 = fnc(f3, f3, f3); \ + f4 = fnc(f4, f4, f4); + +#define TEST_FN_FUNC_FN_FN_F(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, f1); \ + f2 = fnc(f2, f1, f1); \ + f3 = fnc(f3, f1, f1); \ + f4 = fnc(f4, f1, f1); + +#define TEST_FN_FUNC_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, (int*) &i1); \ + f2 = fnc(f2, (int2*) &i2); \ + f3 = fnc(f3, (int3*) &i3); \ + f4 = fnc(f4, (int4*) &i4); + +#define TEST_FN_FUNC_FN_FN_PIN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + f1 = fnc(f1, f1, (int*) &i1); \ + f2 = fnc(f2, f2, (int2*) &i2); \ + f3 = fnc(f3, f3, (int3*) &i3); \ + f4 = fnc(f4, f4, (int4*) &i4); + +#define TEST_IN_FUNC_FN(fnc) \ + rsDebug("Testing " #fnc, 0); \ + i1 = fnc(f1); \ + i2 = fnc(f2); \ + i3 = fnc(f3); \ + i4 = fnc(f4); + +static bool test_fp_math(uint32_t index) { + bool failed = false; + start(); + + TEST_FN_FUNC_FN(acos); + TEST_FN_FUNC_FN(acosh); + TEST_FN_FUNC_FN(acospi); + TEST_FN_FUNC_FN(asin); + TEST_FN_FUNC_FN(asinh); + TEST_FN_FUNC_FN(asinpi); + TEST_FN_FUNC_FN(atan); + TEST_FN_FUNC_FN_FN(atan2); + TEST_FN_FUNC_FN(atanh); + TEST_FN_FUNC_FN(atanpi); + TEST_FN_FUNC_FN_FN(atan2pi); + TEST_FN_FUNC_FN(cbrt); + TEST_FN_FUNC_FN(ceil); + TEST_FN_FUNC_FN_FN_FN(clamp); + TEST_FN_FUNC_FN_FN_F(clamp); + TEST_FN_FUNC_FN_FN(copysign); + TEST_FN_FUNC_FN(cos); + TEST_FN_FUNC_FN(cosh); + TEST_FN_FUNC_FN(cospi); + TEST_F34_FUNC_F34_F34(cross); + TEST_FN_FUNC_FN(degrees); + TEST_F_FUNC_FN_FN(distance); + TEST_F_FUNC_FN_FN(dot); + TEST_FN_FUNC_FN(erfc); + TEST_FN_FUNC_FN(erf); + TEST_FN_FUNC_FN(exp); + TEST_FN_FUNC_FN(exp2); + TEST_FN_FUNC_FN(exp10); + TEST_FN_FUNC_FN(expm1); + TEST_FN_FUNC_FN(fabs); + TEST_FN_FUNC_FN_FN(fdim); + TEST_FN_FUNC_FN(floor); + TEST_FN_FUNC_FN_FN_FN(fma); + TEST_FN_FUNC_FN_FN(fmax); + TEST_FN_FUNC_FN_F(fmax); + TEST_FN_FUNC_FN_FN(fmin); + TEST_FN_FUNC_FN_F(fmin); + TEST_FN_FUNC_FN_FN(fmod); + TEST_FN_FUNC_FN_PFN(fract); + TEST_FN_FUNC_FN_PIN(frexp); + TEST_FN_FUNC_FN_FN(hypot); + TEST_IN_FUNC_FN(ilogb); + TEST_FN_FUNC_FN_IN(ldexp); + TEST_FN_FUNC_FN_I(ldexp); + TEST_F_FUNC_FN(length); + TEST_FN_FUNC_FN(lgamma); + TEST_FN_FUNC_FN_PIN(lgamma); + TEST_FN_FUNC_FN(log); + TEST_FN_FUNC_FN(log2); + TEST_FN_FUNC_FN(log10); + TEST_FN_FUNC_FN(log1p); + TEST_FN_FUNC_FN(logb); + TEST_FN_FUNC_FN_FN_FN(mad); + TEST_FN_FUNC_FN_FN(max); + TEST_FN_FUNC_FN_F(max); + TEST_FN_FUNC_FN_FN(min); + TEST_FN_FUNC_FN_F(min); + TEST_FN_FUNC_FN_FN_FN(mix); + TEST_FN_FUNC_FN_FN_F(mix); + TEST_FN_FUNC_FN_PFN(modf); + // nan + TEST_FN_FUNC_FN_FN(nextafter); + TEST_FN_FUNC_FN(normalize); + TEST_FN_FUNC_FN_FN(pow); + TEST_FN_FUNC_FN_IN(pown); + TEST_FN_FUNC_FN_FN(powr); + TEST_FN_FUNC_FN(radians); + TEST_FN_FUNC_FN_FN(remainder); + TEST_FN_FUNC_FN_FN_PIN(remquo); + TEST_FN_FUNC_FN(rint); + TEST_FN_FUNC_FN_IN(rootn); + TEST_FN_FUNC_FN(round); + TEST_FN_FUNC_FN(rsqrt); + TEST_FN_FUNC_FN(sign); + TEST_FN_FUNC_FN(sin); + TEST_FN_FUNC_FN_PFN(sincos); + TEST_FN_FUNC_FN(sinh); + TEST_FN_FUNC_FN(sinpi); + TEST_FN_FUNC_FN(sqrt); + TEST_FN_FUNC_FN_FN(step); + TEST_FN_FUNC_FN_F(step); + TEST_FN_FUNC_FN(tan); + TEST_FN_FUNC_FN(tanh); + TEST_FN_FUNC_FN(tanpi); + TEST_FN_FUNC_FN(tgamma); + TEST_FN_FUNC_FN(trunc); + + float time = end(index); + + if (failed) { + rsDebug("test_fp_math FAILED", time); + } + else { + rsDebug("test_fp_math PASSED", time); + } + + return failed; +} + +static bool test_int_math(uint32_t index) { + bool failed = false; + start(); + + TEST_UIN_FUNC_IN(abs); + TEST_IN_FUNC_IN(clz); + TEST_IN_FUNC_IN_IN(min); + TEST_IN_FUNC_IN_IN(max); + TEST_I_FUNC_I_I_I(rsClamp); + + float time = end(index); + + if (failed) { + rsDebug("test_int_math FAILED", time); + } + else { + rsDebug("test_int_math PASSED", time); + } + + return failed; +} + +static bool test_basic_operators() { + bool failed = false; + int i = 0; + + TEST_INT_OP(+); + TEST_INT_OP(-); + TEST_INT_OP(*); + TEST_INT_OP(/); + TEST_INT_OP(%); + TEST_INT_OP(<<); + TEST_INT_OP(>>); + + if (failed) { + rsDebug("test_basic_operators FAILED", 0); + } + else { + rsDebug("test_basic_operators PASSED", 0); + } + + return failed; +} + +#define TEST_CVT(to, from, type) \ +rsDebug("Testing convert from " #from " to " #to, 0); \ +to##1 = from##1; \ +to##2 = convert_##type##2(from##2); \ +to##3 = convert_##type##3(from##3); \ +to##4 = convert_##type##4(from##4); + +#define TEST_CVT_MATRIX(to, type) \ +TEST_CVT(to, c, type); \ +TEST_CVT(to, uc, type); \ +TEST_CVT(to, s, type); \ +TEST_CVT(to, us, type); \ +TEST_CVT(to, i, type); \ +TEST_CVT(to, ui, type); \ +TEST_CVT(to, f, type); \ + +static bool test_convert() { + bool failed = false; + + TEST_CVT_MATRIX(c, char); + TEST_CVT_MATRIX(uc, uchar); + TEST_CVT_MATRIX(s, short); + TEST_CVT_MATRIX(us, ushort); + TEST_CVT_MATRIX(i, int); + TEST_CVT_MATRIX(ui, uint); + TEST_CVT_MATRIX(f, float); + + if (failed) { + rsDebug("test_convert FAILED", 0); + } + else { + rsDebug("test_convert PASSED", 0); + } + + return failed; +} + +void math_test(uint32_t index, int test_num) { + bool failed = false; + failed |= test_convert(); + failed |= test_fp_math(index); + failed |= test_int_math(index); + failed |= test_basic_operators(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/primitives.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/primitives.rs new file mode 100644 index 0000000..ce451da --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/primitives.rs @@ -0,0 +1,61 @@ +#include "shared.rsh" + +// Testing primitive types +float floatTest = 1.99f; +double doubleTest = 2.05; +char charTest = -8; +short shortTest = -16; +int intTest = -32; +long longTest = 17179869184l; // 1 << 34 +long long longlongTest = 68719476736l; // 1 << 36 + +uchar ucharTest = 8; +ushort ushortTest = 16; +uint uintTest = 32; +ulong ulongTest = 4611686018427387904L; +int64_t int64_tTest = -17179869184l; // - 1 << 34 +uint64_t uint64_tTest = 117179869184l; + +static bool test_primitive_types(uint32_t index) { + bool failed = false; + start(); + + _RS_ASSERT(floatTest == 2.99f); + _RS_ASSERT(doubleTest == 3.05); + _RS_ASSERT(charTest == -16); + _RS_ASSERT(shortTest == -32); + _RS_ASSERT(intTest == -64); + _RS_ASSERT(longTest == 17179869185l); + _RS_ASSERT(longlongTest == 68719476735l); + + _RS_ASSERT(ucharTest == 8); + _RS_ASSERT(ushortTest == 16); + _RS_ASSERT(uintTest == 32); + _RS_ASSERT(ulongTest == 4611686018427387903L); + _RS_ASSERT(int64_tTest == -17179869184l); + _RS_ASSERT(uint64_tTest == 117179869185l); + + float time = end(index); + + if (failed) { + rsDebug("test_primitives FAILED", time); + } + else { + rsDebug("test_primitives PASSED", time); + } + + return failed; +} + +void primitives_test(uint32_t index, int test_num) { + bool failed = false; + failed |= test_primitive_types(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/refcount.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/refcount.rs new file mode 100644 index 0000000..4ea70e2 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/refcount.rs @@ -0,0 +1,13 @@ +#include "shared.rsh" + +// Testing reference counting of RS object types + +rs_allocation globalA; +static rs_allocation staticGlobalA; + +void refcount_test() { + staticGlobalA = globalA; + rsClearObject(&globalA); + rsSendToClientBlocking(RS_MSG_TEST_PASSED); +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rsdebug.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rsdebug.rs new file mode 100644 index 0000000..f7942a5 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rsdebug.rs @@ -0,0 +1,56 @@ +#include "shared.rsh" + +// Testing primitive types +float floatTest = 1.99f; +double doubleTest = 2.05; +char charTest = -8; +short shortTest = -16; +int intTest = -32; +long longTest = 17179869184l; // 1 << 34 +long long longlongTest = 68719476736l; // 1 << 36 + +uchar ucharTest = 8; +ushort ushortTest = 16; +uint uintTest = 32; +ulong ulongTest = 4611686018427387904L; +int64_t int64_tTest = -17179869184l; // - 1 << 34 +uint64_t uint64_tTest = 117179869184l; + +static bool basic_test(uint32_t index) { + bool failed = false; + + // This test focuses primarily on compilation-time, not run-time. + // For this reason, none of the outputs are actually checked. + + rsDebug("floatTest", floatTest); + rsDebug("doubleTest", doubleTest); + rsDebug("charTest", charTest); + rsDebug("shortTest", shortTest); + rsDebug("intTest", intTest); + rsDebug("longTest", longTest); + rsDebug("longlongTest", longlongTest); + + rsDebug("ucharTest", ucharTest); + rsDebug("ushortTest", ushortTest); + rsDebug("uintTest", uintTest); + rsDebug("ulongTest", ulongTest); + rsDebug("int64_tTest", int64_tTest); + rsDebug("uint64_tTest", uint64_tTest); + + return failed; +} + +void test_rsdebug(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rsdebug_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rsdebug_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rslist.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rslist.rs new file mode 100644 index 0000000..b3d8b9e --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rslist.rs @@ -0,0 +1,107 @@ +// Copyright (C) 2009 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test_v14) + +#include "rs_graphics.rsh" + +float gDY; + +rs_font gFont; + +typedef struct ListAllocs_s { + rs_allocation text; + int result; +} ListAllocs; + +ListAllocs *gList; + +void init() { + gDY = 0.0f; +} + +int textPos = 0; + +int root(void) { + + rsgClearColor(0.0f, 0.0f, 0.0f, 0.0f); + rsgClearDepth(1.0f); + + textPos -= (int)gDY*2; + gDY *= 0.95; + + rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); + rsgBindFont(gFont); + + rs_allocation listAlloc; + listAlloc = rsGetAllocation(gList); + int allocSize = rsAllocationGetDimX(listAlloc); + + int width = rsgGetWidth(); + int height = rsgGetHeight(); + + int itemHeight = 80; + int totalItemHeight = itemHeight * allocSize; + + /* Prevent scrolling above the top of the list */ + int firstItem = height - totalItemHeight; + if (firstItem < 0) { + firstItem = 0; + } + + /* Prevent scrolling past the last line of the list */ + int lastItem = -1 * (totalItemHeight - height); + if (lastItem > 0) { + lastItem = 0; + } + + if (textPos > firstItem) { + textPos = firstItem; + } + else if (textPos < lastItem) { + textPos = lastItem; + } + + int currentYPos = itemHeight + textPos; + + for(int i = 0; i < allocSize; i ++) { + if(currentYPos - itemHeight > height) { + break; + } + + if(currentYPos > 0) { + switch(gList[i].result) { + case 1: /* Passed */ + rsgFontColor(0.5f, 0.9f, 0.5f, 1.0f); + break; + case -1: /* Failed */ + rsgFontColor(0.9f, 0.5f, 0.5f, 1.0f); + break; + case 0: /* Still Testing */ + rsgFontColor(0.9f, 0.9f, 0.5f, 1.0f); + break; + default: /* Unknown */ + rsgFontColor(0.9f, 0.9f, 0.9f, 1.0f); + break; + } + rsgDrawRect(0, currentYPos - 1, width, currentYPos, 0); + rsgDrawText(gList[i].text, 30, currentYPos - 32); + } + currentYPos += itemHeight; + } + + return 10; +} diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstime.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstime.rs new file mode 100644 index 0000000..5e3e078 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstime.rs @@ -0,0 +1,52 @@ +#include "shared.rsh" + +static bool basic_test(uint32_t index) { + bool failed = false; + + rs_time_t curTime = rsTime(0); + rs_tm tm; + rsDebug("curTime", curTime); + + rsLocaltime(&tm, &curTime); + + rsDebug("tm.tm_sec", tm.tm_sec); + rsDebug("tm.tm_min", tm.tm_min); + rsDebug("tm.tm_hour", tm.tm_hour); + rsDebug("tm.tm_mday", tm.tm_mday); + rsDebug("tm.tm_mon", tm.tm_mon); + rsDebug("tm.tm_year", tm.tm_year); + rsDebug("tm.tm_wday", tm.tm_wday); + rsDebug("tm.tm_yday", tm.tm_yday); + rsDebug("tm.tm_isdst", tm.tm_isdst); + + // Test a specific time (only valid for PST localtime) + curTime = 1294438893; + rsLocaltime(&tm, &curTime); + + _RS_ASSERT(tm.tm_sec == 33); + _RS_ASSERT(tm.tm_min == 21); + _RS_ASSERT(tm.tm_hour == 14); + _RS_ASSERT(tm.tm_mday == 7); + _RS_ASSERT(tm.tm_mon == 0); + _RS_ASSERT(tm.tm_year == 111); + _RS_ASSERT(tm.tm_wday == 5); + _RS_ASSERT(tm.tm_yday == 6); + _RS_ASSERT(tm.tm_isdst == 0); + + return failed; +} + +void test_rstime(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rstime_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rstime_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstypes.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstypes.rs new file mode 100644 index 0000000..22d9c13 --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/rstypes.rs @@ -0,0 +1,79 @@ +#include "shared.rsh" +#include "rs_graphics.rsh" + +rs_element elementTest; +rs_type typeTest; +rs_allocation allocationTest; +rs_sampler samplerTest; +rs_script scriptTest; +rs_mesh meshTest; +rs_program_fragment program_fragmentTest; +rs_program_vertex program_vertexTest; +rs_program_raster program_rasterTest; +rs_program_store program_storeTest; +rs_font fontTest; + +rs_matrix4x4 matrix4x4Test; +rs_matrix3x3 matrix3x3Test; +rs_matrix2x2 matrix2x2Test; + +struct my_struct { + int i; + rs_font fontTestStruct; +}; + +static bool basic_test(uint32_t index) { + bool failed = false; + + rs_matrix4x4 matrix4x4TestLocal; + rs_matrix3x3 matrix3x3TestLocal; + rs_matrix2x2 matrix2x2TestLocal; + + // This test focuses primarily on compilation-time, not run-time. + rs_element elementTestLocal; + rs_type typeTestLocal; + rs_allocation allocationTestLocal; + rs_sampler samplerTestLocal; + rs_script scriptTestLocal; + rs_mesh meshTestLocal; + rs_program_fragment program_fragmentTestLocal; + rs_program_vertex program_vertexTestLocal; + rs_program_raster program_rasterTestLocal; + rs_program_store program_storeTestLocal; + rs_font fontTestLocal; + + rs_font fontTestLocalArray[4]; + + rs_font fontTestLocalPreInit = fontTest; + + struct my_struct structTest; + + fontTestLocal = fontTest; + //allocationTestLocal = allocationTest; + + fontTest = fontTestLocal; + //allocationTest = allocationTestLocal; + + /*for (int i = 0; i < 4; i++) { + fontTestLocalArray[i] = fontTestLocal; + }*/ + + /*fontTest = fontTestLocalArray[3];*/ + + return failed; +} + +void test_rstypes(uint32_t index, int test_num) { + bool failed = false; + failed |= basic_test(index); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + rsDebug("rstypes_test FAILED", -1); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + rsDebug("rstypes_test PASSED", 0); + } +} + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/shared.rsh b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/shared.rsh new file mode 100644 index 0000000..4a7151f --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/shared.rsh @@ -0,0 +1,38 @@ +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test_v14) + +typedef struct TestResult_s { + rs_allocation name; + bool pass; + float score; + int64_t time; +} TestResult; +//TestResult *g_results; + +static int64_t g_time; + +static void start(void) { + g_time = rsUptimeMillis(); +} + +static float end(uint32_t idx) { + int64_t t = rsUptimeMillis() - g_time; + //g_results[idx].time = t; + //rsDebug("test time", (int)t); + return ((float)t) / 1000.f; +} + +#define _RS_ASSERT(b) \ +do { \ + if (!(b)) { \ + failed = true; \ + rsDebug(#b " FAILED", 0); \ + } \ +\ +} while (0) + +/* These constants must match those in UnitTest.java */ +static const int RS_MSG_TEST_PASSED = 100; +static const int RS_MSG_TEST_FAILED = 101; + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/test_root.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/test_root.rs new file mode 100644 index 0000000..88fe34a --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/test_root.rs @@ -0,0 +1,23 @@ +// Fountain test script +#pragma version(1) + +#pragma rs java_package_name(com.android.rs.test_v14) + +#pragma stateFragment(parent) + +#include "rs_graphics.rsh" + + +typedef struct TestResult { + rs_allocation name; + bool pass; + float score; +} TestResult_t; +TestResult_t *results; + +int root() { + + return 0; +} + + diff --git a/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/vector.rs b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/vector.rs new file mode 100644 index 0000000..0430a2f --- /dev/null +++ b/tests/RenderScriptTests/tests_v14/src/com/android/rs/test/vector.rs @@ -0,0 +1,198 @@ +#include "shared.rsh" + +// Testing vector types +float2 f2 = { 1.0f, 2.0f }; +float3 f3 = { 1.0f, 2.0f, 3.0f }; +float4 f4 = { 1.0f, 2.0f, 3.0f, 4.0f }; + +double2 d2 = { 1.0, 2.0 }; +double3 d3 = { 1.0, 2.0, 3.0 }; +double4 d4 = { 1.0, 2.0, 3.0, 4.0 }; + +char2 i8_2 = { 1, 2 }; +char3 i8_3 = { 1, 2, 3 }; +char4 i8_4 = { 1, 2, 3, 4 }; + +uchar2 u8_2 = { 1, 2 }; +uchar3 u8_3 = { 1, 2, 3 }; +uchar4 u8_4 = { 1, 2, 3, 4 }; + +short2 i16_2 = { 1, 2 }; +short3 i16_3 = { 1, 2, 3 }; +short4 i16_4 = { 1, 2, 3, 4 }; + +ushort2 u16_2 = { 1, 2 }; +ushort3 u16_3 = { 1, 2, 3 }; +ushort4 u16_4 = { 1, 2, 3, 4 }; + +int2 i32_2 = { 1, 2 }; +int3 i32_3 = { 1, 2, 3 }; +int4 i32_4 = { 1, 2, 3, 4 }; + +uint2 u32_2 = { 1, 2 }; +uint3 u32_3 = { 1, 2, 3 }; +uint4 u32_4 = { 1, 2, 3, 4 }; + +long2 i64_2 = { 1, 2 }; +long3 i64_3 = { 1, 2, 3 }; +long4 i64_4 = { 1, 2, 3, 4 }; + +ulong2 u64_2 = { 1, 2 }; +ulong3 u64_3 = { 1, 2, 3 }; +ulong4 u64_4 = { 1, 2, 3, 4 }; + +static bool test_vector_types() { + bool failed = false; + + rsDebug("Testing F32", 0); + _RS_ASSERT(f2.x == 2.99f); + _RS_ASSERT(f2.y == 3.99f); + + _RS_ASSERT(f3.x == 2.99f); + _RS_ASSERT(f3.y == 3.99f); + _RS_ASSERT(f3.z == 4.99f); + + _RS_ASSERT(f4.x == 2.99f); + _RS_ASSERT(f4.y == 3.99f); + _RS_ASSERT(f4.z == 4.99f); + _RS_ASSERT(f4.w == 5.99f); + + rsDebug("Testing F64", 0); + _RS_ASSERT(d2.x == 2.99); + _RS_ASSERT(d2.y == 3.99); + + _RS_ASSERT(d3.x == 2.99); + _RS_ASSERT(d3.y == 3.99); + _RS_ASSERT(d3.z == 4.99); + + _RS_ASSERT(d4.x == 2.99); + _RS_ASSERT(d4.y == 3.99); + _RS_ASSERT(d4.z == 4.99); + _RS_ASSERT(d4.w == 5.99); + + rsDebug("Testing I8", 0); + _RS_ASSERT(i8_2.x == 2); + _RS_ASSERT(i8_2.y == 3); + + _RS_ASSERT(i8_3.x == 2); + _RS_ASSERT(i8_3.y == 3); + _RS_ASSERT(i8_3.z == 4); + + _RS_ASSERT(i8_4.x == 2); + _RS_ASSERT(i8_4.y == 3); + _RS_ASSERT(i8_4.z == 4); + _RS_ASSERT(i8_4.w == 5); + + rsDebug("Testing U8", 0); + _RS_ASSERT(u8_2.x == 2); + _RS_ASSERT(u8_2.y == 3); + + _RS_ASSERT(u8_3.x == 2); + _RS_ASSERT(u8_3.y == 3); + _RS_ASSERT(u8_3.z == 4); + + _RS_ASSERT(u8_4.x == 2); + _RS_ASSERT(u8_4.y == 3); + _RS_ASSERT(u8_4.z == 4); + _RS_ASSERT(u8_4.w == 5); + + rsDebug("Testing I16", 0); + _RS_ASSERT(i16_2.x == 2); + _RS_ASSERT(i16_2.y == 3); + + _RS_ASSERT(i16_3.x == 2); + _RS_ASSERT(i16_3.y == 3); + _RS_ASSERT(i16_3.z == 4); + + _RS_ASSERT(i16_4.x == 2); + _RS_ASSERT(i16_4.y == 3); + _RS_ASSERT(i16_4.z == 4); + _RS_ASSERT(i16_4.w == 5); + + rsDebug("Testing U16", 0); + _RS_ASSERT(u16_2.x == 2); + _RS_ASSERT(u16_2.y == 3); + + _RS_ASSERT(u16_3.x == 2); + _RS_ASSERT(u16_3.y == 3); + _RS_ASSERT(u16_3.z == 4); + + _RS_ASSERT(u16_4.x == 2); + _RS_ASSERT(u16_4.y == 3); + _RS_ASSERT(u16_4.z == 4); + _RS_ASSERT(u16_4.w == 5); + + rsDebug("Testing I32", 0); + _RS_ASSERT(i32_2.x == 2); + _RS_ASSERT(i32_2.y == 3); + + _RS_ASSERT(i32_3.x == 2); + _RS_ASSERT(i32_3.y == 3); + _RS_ASSERT(i32_3.z == 4); + + _RS_ASSERT(i32_4.x == 2); + _RS_ASSERT(i32_4.y == 3); + _RS_ASSERT(i32_4.z == 4); + _RS_ASSERT(i32_4.w == 5); + + rsDebug("Testing U32", 0); + _RS_ASSERT(u32_2.x == 2); + _RS_ASSERT(u32_2.y == 3); + + _RS_ASSERT(u32_3.x == 2); + _RS_ASSERT(u32_3.y == 3); + _RS_ASSERT(u32_3.z == 4); + + _RS_ASSERT(u32_4.x == 2); + _RS_ASSERT(u32_4.y == 3); + _RS_ASSERT(u32_4.z == 4); + _RS_ASSERT(u32_4.w == 5); + + rsDebug("Testing I64", 0); + _RS_ASSERT(i64_2.x == 2); + _RS_ASSERT(i64_2.y == 3); + + _RS_ASSERT(i64_3.x == 2); + _RS_ASSERT(i64_3.y == 3); + _RS_ASSERT(i64_3.z == 4); + + _RS_ASSERT(i64_4.x == 2); + _RS_ASSERT(i64_4.y == 3); + _RS_ASSERT(i64_4.z == 4); + _RS_ASSERT(i64_4.w == 5); + + rsDebug("Testing U64", 0); + _RS_ASSERT(u64_2.x == 2); + _RS_ASSERT(u64_2.y == 3); + + _RS_ASSERT(u64_3.x == 2); + _RS_ASSERT(u64_3.y == 3); + _RS_ASSERT(u64_3.z == 4); + + _RS_ASSERT(u64_4.x == 2); + _RS_ASSERT(u64_4.y == 3); + _RS_ASSERT(u64_4.z == 4); + _RS_ASSERT(u64_4.w == 5); + + if (failed) { + rsDebug("test_vector FAILED", 0); + } + else { + rsDebug("test_vector PASSED", 0); + } + + return failed; +} + +void vector_test() { + bool failed = false; + failed |= test_vector_types(); + + if (failed) { + rsSendToClientBlocking(RS_MSG_TEST_FAILED); + } + else { + rsSendToClientBlocking(RS_MSG_TEST_PASSED); + } +} + |
