Merge "Adding bounding box computation."
diff --git a/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs b/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
index 4ed5aba..58c9acf 100644
--- a/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
+++ b/java/ImageProcessing/src/com/android/rs/image/horizontal_blur.rs
@@ -8,43 +8,23 @@
const uchar4 *input = (const uchar4 *)rsGetElementAt(fs->ain, 0, y);
float3 blurredPixel = 0;
- float3 currentPixel = 0;
-
const float *gPtr = fs->gaussian;
if ((x > fs->radius) && (x < (fs->width - fs->radius))) {
const uchar4 *i = input + (x - fs->radius);
for(int r = -fs->radius; r <= fs->radius; r ++) {
- currentPixel.x = (float)(i->x);
- currentPixel.y = (float)(i->y);
- currentPixel.z = (float)(i->z);
- blurredPixel += currentPixel * gPtr[0];
+ blurredPixel += convert_float3(i->xyz) * gPtr[0];
gPtr++;
i++;
}
} else {
for(int r = -fs->radius; r <= fs->radius; r ++) {
// Stepping left and right away from the pixel
- int validW = x + r;
- // Clamp to zero and width max() isn't exposed for ints yet
- if(validW < 0) {
- validW = 0;
- }
- if(validW > fs->width - 1) {
- validW = fs->width - 1;
- }
- //int validW = rsClamp(w + r, 0, width - 1);
-
- currentPixel.x = (float)(input[validW].x);
- currentPixel.y = (float)(input[validW].y);
- currentPixel.z = (float)(input[validW].z);
-
- blurredPixel += currentPixel * gPtr[0];
+ int validW = rsClamp(x + r, (uint)0, (uint)(fs->width - 1));
+ blurredPixel += convert_float3(input[validW].xyz) * gPtr[0];
gPtr++;
}
}
- output->x = (uint8_t)blurredPixel.x;
- output->y = (uint8_t)blurredPixel.y;
- output->z = (uint8_t)blurredPixel.z;
+ output->xyz = convert_uchar3(blurredPixel);
}
diff --git a/java/SceneGraph/Android.mk b/java/SceneGraph/Android.mk
new file mode 100644
index 0000000..5520446
--- /dev/null
+++ b/java/SceneGraph/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_STATIC_JAVA_LIBRARIES := android.renderscript
+
+LOCAL_PACKAGE_NAME := SceneGraph
+
+include $(BUILD_PACKAGE)
+
+endif
diff --git a/java/SceneGraph/AndroidManifest.xml b/java/SceneGraph/AndroidManifest.xml
new file mode 100644
index 0000000..8a8f87a
--- /dev/null
+++ b/java/SceneGraph/AndroidManifest.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.scenegraph">
+ <application android:label="SceneGraph">
+ <activity android:name="SceneGraph"
+ android:theme="@android:style/Theme.Black.NoTitleBar">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/java/SceneGraph/res/drawable/robot.png b/java/SceneGraph/res/drawable/robot.png
new file mode 100644
index 0000000..f7353fd
--- /dev/null
+++ b/java/SceneGraph/res/drawable/robot.png
Binary files differ
diff --git a/java/SceneGraph/res/raw/robot.a3d b/java/SceneGraph/res/raw/robot.a3d
new file mode 100644
index 0000000..2d7d32b
--- /dev/null
+++ b/java/SceneGraph/res/raw/robot.a3d
Binary files differ
diff --git a/java/SceneGraph/src/com/android/scenegraph/SceneGraph.java b/java/SceneGraph/src/com/android/scenegraph/SceneGraph.java
new file mode 100644
index 0000000..5daa4ac
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/SceneGraph.java
@@ -0,0 +1,71 @@
+/*
+ * 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.scenegraph;
+
+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 SceneGraph extends Activity {
+
+ private SceneGraphView 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 SceneGraphView(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.onResume();
+ }
+
+ @Override
+ protected void onPause() {
+ // Ideally a game should implement onResume() and onPause()
+ // to take appropriate action when the activity looses focus
+ super.onPause();
+ mView.onPause();
+ }
+
+}
+
diff --git a/java/SceneGraph/src/com/android/scenegraph/SceneGraphRS.java b/java/SceneGraph/src/com/android/scenegraph/SceneGraphRS.java
new file mode 100644
index 0000000..3db4a2b
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/SceneGraphRS.java
@@ -0,0 +1,220 @@
+/*
+ * 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.scenegraph;
+
+import java.io.Writer;
+import java.util.Map;
+import java.util.Vector;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.renderscript.Element.Builder;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.util.Log;
+
+
+public class SceneGraphRS {
+
+ private final int STATE_LAST_FOCUS = 1;
+
+ int mWidth;
+ int mHeight;
+ int mRotation;
+
+ public SceneGraphRS() {
+ }
+
+ public void init(RenderScriptGL rs, Resources res, int width, int height) {
+ mRS = rs;
+ mRes = res;
+ mWidth = width;
+ mHeight = height;
+ mRotation = 0;
+ initRS();
+ }
+
+ private Resources mRes;
+ private RenderScriptGL mRS;
+ private Sampler mSampler;
+ private ProgramStore mPSBackground;
+ private ProgramFragment mPFBackground;
+ private ProgramVertex mPVBackground;
+ private ProgramVertex.MatrixAllocation mPVA;
+
+ private Allocation mGridImage;
+ private Allocation mAllocPV;
+
+ private Mesh mMesh;
+
+ private Font mItalic;
+ private Allocation mTextAlloc;
+
+ private ScriptC_Scenegraph mScript;
+ private ScriptC_Transform mTransformScript;
+
+ int mLastX;
+ int mLastY;
+
+ public void touchEvent(int x, int y) {
+ int dx = mLastX - x;
+ if(Math.abs(dx) > 50 || Math.abs(dx) < 3) {
+ dx = 0;
+ }
+
+ mRotation -= dx;
+ if(mRotation > 360) {
+ mRotation -= 360;
+ }
+ if(mRotation < 0) {
+ mRotation += 360;
+ }
+
+ mScript.set_gRotate(-(float)mRotation);
+
+ mLastX = x;
+ mLastY = y;
+ }
+
+ private void initPFS() {
+ ProgramStore.Builder b = new ProgramStore.Builder(mRS, null, null);
+
+ b.setDepthFunc(ProgramStore.DepthFunc.LESS);
+ b.setDitherEnable(false);
+ b.setDepthMask(true);
+ mPSBackground = b.create();
+
+ mScript.set_gPFSBackground(mPSBackground);
+ }
+
+ private void initPF() {
+ Sampler.Builder bs = new Sampler.Builder(mRS);
+ bs.setMin(Sampler.Value.LINEAR);
+ bs.setMag(Sampler.Value.LINEAR);
+ bs.setWrapS(Sampler.Value.CLAMP);
+ bs.setWrapT(Sampler.Value.WRAP);
+ mSampler = bs.create();
+
+ ProgramFragment.Builder b = new ProgramFragment.Builder(mRS);
+ b.setTexture(ProgramFragment.Builder.EnvMode.REPLACE,
+ ProgramFragment.Builder.Format.RGBA, 0);
+ mPFBackground = b.create();
+ mPFBackground.bindSampler(mSampler, 0);
+
+ mScript.set_gPFBackground(mPFBackground);
+ }
+
+ private void initPV() {
+ ProgramVertex.Builder pvb = new ProgramVertex.Builder(mRS, null, null);
+ mPVBackground = pvb.create();
+
+ mPVA = new ProgramVertex.MatrixAllocation(mRS);
+ mPVBackground.bindAllocation(mPVA);
+ mPVA.setupProjectionNormalized(mWidth, mHeight);
+
+ mScript.set_gPVBackground(mPVBackground);
+ }
+
+ private void loadImage() {
+ mGridImage = Allocation.createFromBitmapResourceBoxed(mRS, mRes, R.drawable.robot, Element.RGB_565(mRS), true);
+ mGridImage.uploadToTexture(0);
+
+ mScript.set_gTGrid(mGridImage);
+ }
+
+ private void initTextAllocation() {
+ String allocString = "Displaying file: R.raw.robot";
+ mTextAlloc = Allocation.createFromString(mRS, allocString);
+ mScript.set_gTextAlloc(mTextAlloc);
+ }
+
+ SgTransform mRootTransform;
+ SgTransform mGroup1;
+
+ SgTransform mRobot1;
+ SgTransform mRobot2;
+
+ void initTransformHierarchy() {
+ mRootTransform = new SgTransform(mRS);
+
+ mGroup1 = new SgTransform(mRS);
+ mRootTransform.addChild(mGroup1);
+
+ mRobot1 = new SgTransform(mRS);
+ mRobot2 = new SgTransform(mRS);
+
+ mGroup1.addChild(mRobot1);
+ mGroup1.addChild(mRobot2);
+
+ mGroup1.setTransform(0, new Float4(0.0f, 0.0f, 5.0f, 0.0f), TransformType.TRANSLATE);
+ mGroup1.setTransform(1, new Float4(0.0f, 1.0f, 0.0f, 15.0f), TransformType.ROTATE);
+
+ mRobot1.setTransform(0, new Float4(-2.0f, -0.5f, 0.0f, 0.0f), TransformType.TRANSLATE);
+ mRobot1.setTransform(1, new Float4(0.0f, 1.0f, 0.0f, 20.0f), TransformType.ROTATE);
+ mRobot1.setTransform(2, new Float4(0.2f, 0.2f, 0.2f, 0.0f), TransformType.SCALE);
+
+ mRobot2.setTransform(0, new Float4(2.0f, 0.0f, 0.0f, 0.0f), TransformType.TRANSLATE);
+ mRobot2.setTransform(1, new Float4(0.0f, 1.0f, 0.0f, -20.0f), TransformType.ROTATE);
+ mRobot2.setTransform(2, new Float4(0.3f, 0.3f, 0.3f, 0.0f), TransformType.SCALE);
+ }
+
+ private void initRS() {
+
+ mScript = new ScriptC_Scenegraph(mRS, mRes, R.raw.scenegraph, true);
+ mTransformScript = new ScriptC_Transform(mRS, mRes, R.raw.transform, false);
+ mTransformScript.set_transformScript(mTransformScript);
+
+ mScript.set_gTransformRS(mTransformScript);
+
+ initPFS();
+ initPF();
+ initPV();
+
+ loadImage();
+
+ FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.robot);
+ FileA3D.IndexEntry entry = model.getIndexEntry(0);
+ if(entry == null || entry.getClassID() != FileA3D.ClassID.MESH) {
+ Log.e("rs", "could not load model");
+ }
+ else {
+ mMesh = (Mesh)entry.getObject();
+ mScript.set_gTestMesh(mMesh);
+ }
+
+ mItalic = Font.create(mRS, mRes, "DroidSerif-Italic.ttf", 8);
+ mScript.set_gItalic(mItalic);
+
+ initTextAllocation();
+
+ initTransformHierarchy();
+
+ Log.v("========SceneGraph========", "transform hierarchy initialized");
+
+ mScript.bind_gRootNode(mRootTransform.getField());
+
+ mScript.bind_gGroup(mGroup1.mParent.mChildField);
+ mScript.bind_gRobot1(mRobot1.mParent.mChildField);
+ mScript.set_gRobot1Index(mRobot1.mIndexInParentGroup);
+ mScript.bind_gRobot2(mRobot2.mParent.mChildField);
+ mScript.set_gRobot2Index(mRobot2.mIndexInParentGroup);
+
+ mRS.contextBindRootScript(mScript);
+ }
+}
+
+
+
diff --git a/java/SceneGraph/src/com/android/scenegraph/SceneGraphView.java b/java/SceneGraph/src/com/android/scenegraph/SceneGraphView.java
new file mode 100644
index 0000000..ae94869
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/SceneGraphView.java
@@ -0,0 +1,94 @@
+/*
+ * 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.scenegraph;
+
+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 SceneGraphView extends RSSurfaceView {
+
+ public SceneGraphView(Context context) {
+ super(context);
+ //setFocusable(true);
+ }
+
+ private RenderScriptGL mRS;
+ private SceneGraphRS mRender;
+
+
+ public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+ super.surfaceChanged(holder, format, w, h);
+ if (mRS == null) {
+ mRS = createRenderScript(true);
+ mRS.contextSetSurface(w, h, holder.getSurface());
+ mRender = new SceneGraphRS();
+ mRender.init(mRS, getResources(), w, h);
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ if(mRS != null) {
+ mRS = null;
+ destroyRenderScript();
+ }
+ }
+
+ @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)
+ {
+ boolean ret = true;
+ int act = ev.getAction();
+ if (act == ev.ACTION_UP) {
+ ret = false;
+ }
+
+ mRender.touchEvent((int)ev.getX(), (int)ev.getY());
+ return ret;
+ }
+}
+
+
diff --git a/java/SceneGraph/src/com/android/scenegraph/SgTransform.java b/java/SceneGraph/src/com/android/scenegraph/SgTransform.java
new file mode 100644
index 0000000..e81f1a7
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/SgTransform.java
@@ -0,0 +1,165 @@
+/*
+ * 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.scenegraph;
+
+import java.io.Writer;
+import java.util.Map;
+import java.util.Vector;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.renderscript.Element.Builder;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.util.Log;
+
+enum TransformType {
+
+ NONE(0),
+ TRANSLATE(1),
+ ROTATE(2),
+ SCALE(3);
+
+ int mID;
+ TransformType(int id) {
+ mID = id;
+ }
+}
+
+public class SgTransform {
+
+
+ ScriptField_SgTransform mTransformField;
+ ScriptField_SgTransform mChildField;
+ public ScriptField_SgTransform.Item mTransformData;
+
+ Float4[] mTransforms;
+ TransformType[] mTransformTypes;
+
+ RenderScript mRS;
+
+ Vector mChildren;
+ SgTransform mParent;
+ int mIndexInParentGroup;
+
+ public void setParent(SgTransform parent, int parentIndex) {
+ mParent = parent;
+ mIndexInParentGroup = parentIndex;
+ }
+
+ public void addChild(SgTransform child) {
+ mChildren.add(child);
+ child.setParent(this, mChildren.size() - 1);
+ }
+
+ public void setTransform(int index, Float4 value, TransformType type) {
+ mTransforms[index] = value;
+ mTransformTypes[index] = type;
+ }
+
+ void initData() {
+ int numTransforms = 16;
+ mTransforms = new Float4[numTransforms];
+ mTransformTypes = new TransformType[numTransforms];
+ for(int i = 0; i < numTransforms; i ++) {
+ mTransforms[i] = new Float4(0, 0, 0, 0);
+ mTransformTypes[i] = TransformType.NONE;
+ }
+ }
+
+ void setData() {
+
+ mTransformData.globalMat_Row0 = new Float4(1, 0, 0, 0);
+ mTransformData.globalMat_Row1 = new Float4(0, 1, 0, 0);
+ mTransformData.globalMat_Row2 = new Float4(0, 0, 1, 0);
+ mTransformData.globalMat_Row3 = new Float4(0, 0, 0, 1);
+
+ mTransformData.localMat_Row0 = new Float4(1, 0, 0, 0);
+ mTransformData.localMat_Row1 = new Float4(0, 1, 0, 0);
+ mTransformData.localMat_Row2 = new Float4(0, 0, 1, 0);
+ mTransformData.localMat_Row3 = new Float4(0, 0, 0, 1);
+
+ mTransformData.transforms0 = mTransforms[0];
+ mTransformData.transforms1 = mTransforms[1];
+ mTransformData.transforms2 = mTransforms[2];
+ mTransformData.transforms3 = mTransforms[3];
+ mTransformData.transforms4 = mTransforms[4];
+ mTransformData.transforms5 = mTransforms[5];
+ mTransformData.transforms6 = mTransforms[6];
+ mTransformData.transforms7 = mTransforms[7];
+ mTransformData.transforms8 = mTransforms[8];
+ mTransformData.transforms9 = mTransforms[9];
+ mTransformData.transforms10 = mTransforms[10];
+ mTransformData.transforms11 = mTransforms[11];
+ mTransformData.transforms12 = mTransforms[12];
+ mTransformData.transforms13 = mTransforms[13];
+ mTransformData.transforms14 = mTransforms[14];
+ mTransformData.transforms15 = mTransforms[15];
+
+ mTransformData.transformType0 = mTransformTypes[0].mID;
+ mTransformData.transformType1 = mTransformTypes[1].mID;
+ mTransformData.transformType2 = mTransformTypes[2].mID;
+ mTransformData.transformType3 = mTransformTypes[3].mID;
+ mTransformData.transformType4 = mTransformTypes[4].mID;
+ mTransformData.transformType5 = mTransformTypes[5].mID;
+ mTransformData.transformType6 = mTransformTypes[6].mID;
+ mTransformData.transformType7 = mTransformTypes[7].mID;
+ mTransformData.transformType8 = mTransformTypes[8].mID;
+ mTransformData.transformType9 = mTransformTypes[9].mID;
+ mTransformData.transformType10 = mTransformTypes[10].mID;
+ mTransformData.transformType11 = mTransformTypes[11].mID;
+ mTransformData.transformType12 = mTransformTypes[12].mID;
+ mTransformData.transformType13 = mTransformTypes[13].mID;
+ mTransformData.transformType14 = mTransformTypes[14].mID;
+ mTransformData.transformType15 = mTransformTypes[15].mID;
+
+ mTransformData.isDirty = 1;
+ mTransformData.children = null;
+
+ }
+
+ public SgTransform(RenderScript rs) {
+ mRS = rs;
+ mTransformData = new ScriptField_SgTransform.Item();
+ mChildren = new Vector();
+ initData();
+ }
+
+ public ScriptField_SgTransform.Item getData() {
+ setData();
+ if(mChildren.size() != 0) {
+ mChildField = new ScriptField_SgTransform(mRS, mChildren.size());
+ mTransformData.children = mChildField.getAllocation();
+
+ for(int i = 0; i < mChildren.size(); i ++) {
+ SgTransform child = (SgTransform)mChildren.get(i);
+ mChildField.set(child.getData(), i, false);
+ }
+ mChildField.copyAll();
+ }
+
+ return mTransformData;
+ }
+
+ public ScriptField_SgTransform getField() {
+ mTransformField = new ScriptField_SgTransform(mRS, 1);
+ mTransformField.set(getData(), 0, true);
+ return mTransformField;
+ }
+}
+
+
+
diff --git a/java/SceneGraph/src/com/android/scenegraph/scenegraph.rs b/java/SceneGraph/src/com/android/scenegraph/scenegraph.rs
new file mode 100644
index 0000000..e6ae6df
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/scenegraph.rs
@@ -0,0 +1,92 @@
+// 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.scenegraph)
+
+#include "rs_graphics.rsh"
+#include "transform_def.rsh"
+
+rs_program_vertex gPVBackground;
+rs_program_fragment gPFBackground;
+
+rs_allocation gTGrid;
+rs_mesh gTestMesh;
+
+rs_program_store gPFSBackground;
+
+float gRotate;
+
+rs_font gItalic;
+rs_allocation gTextAlloc;
+
+rs_script gTransformRS;
+
+SgTransform *gGroup;
+SgTransform *gRobot1;
+int gRobot1Index;
+SgTransform *gRobot2;
+int gRobot2Index;
+
+SgTransform *gRootNode;
+
+#pragma rs export_var(gPVBackground, gPFBackground, gTGrid, gTestMesh, gPFSBackground, gRotate, gItalic, gTextAlloc, gTransformRS, gGroup, gRobot1, gRobot1Index, gRobot2, gRobot2Index, gRootNode)
+
+float gDT;
+int64_t gLastTime;
+
+void init() {
+ gRotate = 0.0f;
+}
+
+int root(int launchID) {
+
+ gGroup->transforms1.w += 0.5f;
+ gGroup->isDirty = 1;
+
+ SgTransform *robot1Ptr = gRobot1 + gRobot1Index;
+
+ robot1Ptr->transforms1.w -= 1.5f;
+ robot1Ptr->isDirty = 1;
+
+ SgTransform *robot2Ptr = gRobot2 + gRobot2Index;
+ robot2Ptr->transforms1.w += 2.5f;
+ robot2Ptr->isDirty = 1;
+
+ rsForEach(gTransformRS, gRootNode->children, gRootNode->children, 0);
+
+ rsgClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+ rsgClearDepth(1.0f);
+
+ rsgBindProgramVertex(gPVBackground);
+
+ rsgBindProgramFragment(gPFBackground);
+ rsgBindProgramStore(gPFSBackground);
+ rsgBindTexture(gPFBackground, 0, gTGrid);
+
+ rsgProgramVertexLoadModelMatrix((rs_matrix4x4 *)&robot1Ptr->globalMat_Row0);
+ rsgDrawMesh(gTestMesh);
+
+ rsgProgramVertexLoadModelMatrix((rs_matrix4x4 *)&robot2Ptr->globalMat_Row0);
+ rsgDrawMesh(gTestMesh);
+
+ color(0.3f, 0.3f, 0.3f, 1.0f);
+ rsgDrawText("Renderscript transform test", 30, 695);
+
+ rsgBindFont(gItalic);
+ rsgDrawText(gTextAlloc, 30, 730);
+
+ return 10;
+}
diff --git a/java/SceneGraph/src/com/android/scenegraph/transform.rs b/java/SceneGraph/src/com/android/scenegraph/transform.rs
new file mode 100644
index 0000000..a62d12b
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/transform.rs
@@ -0,0 +1,102 @@
+// 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.scenegraph)
+
+#include "transform_def.rsh"
+
+rs_script transformScript;
+
+#pragma rs export_var(transformScript)
+
+typedef struct {
+ int changed;
+ rs_matrix4x4 *mat;
+} ParentData;
+
+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 void *v_in, void *v_out, const void *usrData, uint32_t x, uint32_t y) {
+
+ SgTransform *data = (SgTransform *)v_out;
+ const ParentData *parent = (const ParentData *)usrData;
+
+ //rsDebug("Transform data", (int)data);
+ //rsDebug("Entering parent", (int)parent);
+
+ rs_matrix4x4 *localMat = (rs_matrix4x4*)&data->localMat_Row0;
+ rs_matrix4x4 *globalMat = (rs_matrix4x4*)&data->globalMat_Row0;
+
+ ParentData toChild;
+ toChild.changed = 0;
+ toChild.mat = globalMat;
+
+ //rsDebug("Transform is dirty", data->isDirty);
+
+ // Refresh matrices if dirty
+ if(data->isDirty) {
+ data->isDirty = 0;
+ toChild.changed = 1;
+
+ // Reset our local matrix
+ rsMatrixLoadIdentity(localMat);
+
+ float4 *transformSource = &data->transforms0;
+ int *transformTypes = &data->transformType0;
+
+ for(int i = 0; i < 16; i ++) {
+ if(transformTypes[i] == TRANSFORM_NONE) {
+ break;
+ }
+ //rsDebug("Transform adding transformation", transformTypes[i]);
+ appendTransformation(transformTypes[i], transformSource[i], localMat);
+ }
+ }
+
+ //rsDebug("Transform checking parent", (int)0);
+
+ if(parent) {
+ if(parent->changed) {
+ toChild.changed = 1;
+
+ rsMatrixLoad(globalMat, parent->mat);
+ rsMatrixMultiply(globalMat, localMat);
+ }
+ }
+ else {
+ rsMatrixLoad(globalMat, localMat);
+ }
+
+ //rsDebug("Transform calling self with child ", (int)data->children.p);
+ if(data->children.p) {
+ rsForEach(transformScript, data->children, data->children, (void*)&toChild);
+ }
+}
diff --git a/java/SceneGraph/src/com/android/scenegraph/transform_def.rsh b/java/SceneGraph/src/com/android/scenegraph/transform_def.rsh
new file mode 100644
index 0000000..10aac37
--- /dev/null
+++ b/java/SceneGraph/src/com/android/scenegraph/transform_def.rsh
@@ -0,0 +1,73 @@
+// 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.scenegraph)
+
+#define TRANSFORM_NONE 0
+#define TRANSFORM_TRANSLATE 1
+#define TRANSFORM_ROTATE 2
+#define TRANSFORM_SCALE 3
+
+typedef struct {
+ float4 globalMat_Row0;
+ float4 globalMat_Row1;
+ float4 globalMat_Row2;
+ float4 globalMat_Row3;
+
+ float4 localMat_Row0;
+ float4 localMat_Row1;
+ float4 localMat_Row2;
+ float4 localMat_Row3;
+
+ float4 transforms0;
+ float4 transforms1;
+ float4 transforms2;
+ float4 transforms3;
+ float4 transforms4;
+ float4 transforms5;
+ float4 transforms6;
+ float4 transforms7;
+ float4 transforms8;
+ float4 transforms9;
+ float4 transforms10;
+ float4 transforms11;
+ float4 transforms12;
+ float4 transforms13;
+ float4 transforms14;
+ float4 transforms15;
+
+ int transformType0;
+ int transformType1;
+ int transformType2;
+ int transformType3;
+ int transformType4;
+ int transformType5;
+ int transformType6;
+ int transformType7;
+ int transformType8;
+ int transformType9;
+ int transformType10;
+ int transformType11;
+ int transformType12;
+ int transformType13;
+ int transformType14;
+ int transformType15;
+
+ int isDirty;
+
+ rs_allocation children;
+
+} SgTransform;
diff --git a/java/tests/Android.mk b/java/tests/Android.mk
new file mode 100644
index 0000000..6c992d5
--- /dev/null
+++ b/java/tests/Android.mk
@@ -0,0 +1,30 @@
+#
+# 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
+
+include $(BUILD_PACKAGE)
+
+endif
diff --git a/java/tests/AndroidManifest.xml b/java/tests/AndroidManifest.xml
new file mode 100644
index 0000000..bc144ab
--- /dev/null
+++ b/java/tests/AndroidManifest.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.rs.test">
+ <application
+ android:label="_RS_Test"
+ android:icon="@drawable/test_pattern">
+ <activity android:name="RSTest">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+</manifest>
diff --git a/java/tests/res/drawable/test_pattern.png b/java/tests/res/drawable/test_pattern.png
new file mode 100644
index 0000000..e7d1455
--- /dev/null
+++ b/java/tests/res/drawable/test_pattern.png
Binary files differ
diff --git a/java/tests/src/com/android/rs/test/RSTest.java b/java/tests/src/com/android/rs/test/RSTest.java
new file mode 100644
index 0000000..121793d
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/RSTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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;
+
+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 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 looses focus
+ super.onResume();
+ mView.onResume();
+ }
+
+ @Override
+ protected void onPause() {
+ // Ideally a game should implement onResume() and onPause()
+ // to take appropriate action when the activity looses focus
+ super.onPause();
+ mView.onPause();
+ }
+
+ static void log(String message) {
+ if (LOG_ENABLED) {
+ Log.v(LOG_TAG, message);
+ }
+ }
+
+
+}
+
diff --git a/java/tests/src/com/android/rs/test/RSTestCore.java b/java/tests/src/com/android/rs/test/RSTestCore.java
new file mode 100644
index 0000000..c1a16dd
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/RSTestCore.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.rs.test;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.util.Log;
+
+
+public class RSTestCore {
+ public static final int PART_COUNT = 50000;
+
+ public RSTestCore() {
+ }
+
+ private Resources mRes;
+ private RenderScriptGL mRS;
+
+ private ScriptC_Test_root mRootScript;
+
+ private boolean fp_mad() {
+ ScriptC_Fp_mad s = new ScriptC_Fp_mad(mRS, mRes, R.raw.fp_mad, true);
+ s.invoke_doTest(0, 0);
+ return true;
+ }
+
+ //private ScriptC_Fountain mScript;
+ public void init(RenderScriptGL rs, Resources res, int width, int height) {
+ mRS = rs;
+ mRes = res;
+
+ mRootScript = new ScriptC_Test_root(mRS, mRes, R.raw.test_root, true);
+
+ fp_mad();
+
+
+ /*
+ ProgramFragment.Builder pfb = new ProgramFragment.Builder(rs);
+ pfb.setVaryingColor(true);
+ rs.contextBindProgramFragment(pfb.create());
+
+ ScriptField_Point points = new ScriptField_Point(mRS, PART_COUNT);
+
+ Mesh.AllocationBuilder smb = new Mesh.AllocationBuilder(mRS);
+ smb.addVertexAllocation(points.getAllocation());
+ smb.addIndexType(Primitive.POINT);
+ Mesh sm = smb.create();
+
+ mScript = new ScriptC_Fountain(mRS, mRes, R.raw.fountain, true);
+ mScript.set_partMesh(sm);
+ mScript.bind_point(points);
+ mRS.contextBindRootScript(mScript);
+ */
+ }
+
+ public void newTouchPosition(float x, float y, float pressure, int id) {
+ }
+}
diff --git a/java/tests/src/com/android/rs/test/RSTestView.java b/java/tests/src/com/android/rs/test/RSTestView.java
new file mode 100644
index 0000000..7ae0c08
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/RSTestView.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.rs.test;
+
+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 {
+
+ public RSTestView(Context context) {
+ super(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) {
+ mRS = createRenderScript(false);
+ mRS.contextSetSurface(w, h, holder.getSurface());
+ mRender = new RSTestCore();
+ mRender.init(mRS, getResources(), w, h);
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ if(mRS != null) {
+ mRS = null;
+ destroyRenderScript();
+ }
+ }
+
+/*
+ @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/java/tests/src/com/android/rs/test/fp_mad.rs b/java/tests/src/com/android/rs/test/fp_mad.rs
new file mode 100644
index 0000000..494ff35
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/fp_mad.rs
@@ -0,0 +1,173 @@
+#include "shared.rsh"
+
+const int TEST_COUNT = 1;
+
+#pragma rs export_var(g_results)
+#pragma rs export_func(doTest)
+
+
+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 (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 doTest(uint32_t index, int test_num) {
+ for (int 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);
+}
+
+
diff --git a/java/tests/src/com/android/rs/test/shared.rsh b/java/tests/src/com/android/rs/test/shared.rsh
new file mode 100644
index 0000000..1773e47
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/shared.rsh
@@ -0,0 +1,25 @@
+#pragma version(1)
+
+#pragma rs java_package_name(com.android.rs.test)
+
+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;
+}
+
diff --git a/java/tests/src/com/android/rs/test/test_root.rs b/java/tests/src/com/android/rs/test/test_root.rs
new file mode 100644
index 0000000..72b391d
--- /dev/null
+++ b/java/tests/src/com/android/rs/test/test_root.rs
@@ -0,0 +1,26 @@
+// 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;
+
+#pragma rs export_var(results)
+//#pragma rs export_func(addParticles)
+
+int root() {
+
+ return 0;
+}
+
+
diff --git a/rsScript.h b/rsScript.h
index 455ece7..0a20344 100644
--- a/rsScript.h
+++ b/rsScript.h
@@ -56,6 +56,8 @@
char * mScriptText;
uint32_t mScriptTextLength;
+
+ bool mIsThreadable;
};
Enviroment_t mEnviroment;
diff --git a/rsScriptC.cpp b/rsScriptC.cpp
index 7c7b037..a140e22 100644
--- a/rsScriptC.cpp
+++ b/rsScriptC.cpp
@@ -278,7 +278,7 @@
}
- if ((rsc->getWorkerPoolSize() > 1) &&
+ if ((rsc->getWorkerPoolSize() > 1) && mEnviroment.mIsThreadable &&
((mtls.dimY * mtls.dimZ * mtls.dimArray) > 1)) {
//LOGE("launch 1");
@@ -350,10 +350,12 @@
static BCCvoid* symbolLookup(BCCvoid* pContext, const BCCchar* name)
{
const ScriptCState::SymbolTable_t *sym;
+ ScriptC *s = (ScriptC *)pContext;
sym = ScriptCState::lookupSymbol(name);
if (sym) {
return sym->mPtr;
}
+ s->mEnviroment.mIsThreadable = false;
sym = ScriptCState::lookupSymbolCL(name);
if (sym) {
return sym->mPtr;
@@ -371,8 +373,9 @@
LOGV("ScriptCState::runCompiler ");
s->mBccScript = bccCreateScript();
+ s->mEnviroment.mIsThreadable = true;
bccScriptBitcode(s->mBccScript, s->mEnviroment.mScriptText, s->mEnviroment.mScriptTextLength);
- bccRegisterSymbolCallback(s->mBccScript, symbolLookup, NULL);
+ bccRegisterSymbolCallback(s->mBccScript, symbolLookup, s);
bccCompileScript(s->mBccScript);
bccGetScriptLabel(s->mBccScript, "root", (BCCvoid**) &s->mProgram.mRoot);
bccGetScriptLabel(s->mBccScript, "init", (BCCvoid**) &s->mProgram.mInit);
diff --git a/scriptc/rs_math.rsh b/scriptc/rs_math.rsh
index 45f6bf4..bb4aafb 100644
--- a/scriptc/rs_math.rsh
+++ b/scriptc/rs_math.rsh
@@ -112,8 +112,19 @@
extern void __attribute__((overloadable))
rsSendToClientBlocking(int cmdID, const void *data, uint len);
+
// Script to Script
+enum rs_for_each_strategy {
+ RS_FOR_EACH_STRATEGY_SERIAL,
+ RS_FOR_EACH_STRATEGY_DONT_CARE,
+ RS_FOR_EACH_STRATEGY_DST_LINEAR,
+ RS_FOR_EACH_STRATEGY_TILE_SMALL,
+ RS_FOR_EACH_STRATEGY_TILE_MEDIUM,
+ RS_FOR_EACH_STRATEGY_TILE_LARGE
+};
+
typedef struct rs_script_call {
+ enum rs_for_each_strategy strategy;
uint32_t xStart;
uint32_t xEnd;
uint32_t yStart;
@@ -122,7 +133,6 @@
uint32_t zEnd;
uint32_t arrayStart;
uint32_t arrayEnd;
-
} rs_script_call_t;
extern void __attribute__((overloadable))
