Add sprite fountain test.
It's still called "Calc".
diff --git a/libs/rs/Android.mk b/libs/rs/Android.mk
index 73c1eea..83d3d66 100644
--- a/libs/rs/Android.mk
+++ b/libs/rs/Android.mk
@@ -2,9 +2,9 @@
ifeq ($(BUILD_RENDERSCRIPT),true)
TOP_LOCAL_PATH:=$(call my-dir)
+include $(CLEAR_VARS)
LOCAL_PATH:= $(TOP_LOCAL_PATH)
-
# Build rsg-generator
LOCAL_MODULE := rsg-generator
@@ -50,7 +50,7 @@
rsgApiFuncDecl.h \
)
-$(GEN) : PRIVATE_CUSTOM_TOOL = $(RSG_GENERATOR) $< $@ <$(LOCAL_PATH)/rs.spec
+$(GEN) : PRIVATE_CUSTOM_TOOL = $(RSG_GENERATOR) $< $@ <$(TOP_LOCAL_PATH)/rs.spec
$(GEN) : $(RSG_GENERATOR) $(LOCAL_PATH)/rs.spec
$(GEN): $(intermediates)/%.h : $(LOCAL_PATH)/%.h.rsg
$(transform-generated-source)
@@ -63,7 +63,7 @@
rsgApiReplay.cpp \
)
-$(GEN) : PRIVATE_CUSTOM_TOOL = $(RSG_GENERATOR) $< $@ <$(LOCAL_PATH)/rs.spec
+$(GEN) : PRIVATE_CUSTOM_TOOL = $(RSG_GENERATOR) $< $@ <$(TOP_LOCAL_PATH)/rs.spec
$(GEN) : $(RSG_GENERATOR) $(LOCAL_PATH)/rs.spec
$(GEN): $(intermediates)/%.cpp : $(LOCAL_PATH)/%.cpp.rsg
$(transform-generated-source)
@@ -129,4 +129,5 @@
include $(BUILD_SHARED_LIBRARY)
-endif # BUILD_RENDERSCRIPT
\ No newline at end of file
+include $(call all-subdir-makefiles)
+endif # BUILD_RENDERSCRIPT
diff --git a/libs/rs/java/Android.mk b/libs/rs/java/Android.mk
new file mode 100644
index 0000000..5053e7d
--- /dev/null
+++ b/libs/rs/java/Android.mk
@@ -0,0 +1 @@
+include $(call all-subdir-makefiles)
diff --git a/libs/rs/java/Calc/Android.mk b/libs/rs/java/Calc/Android.mk
new file mode 100644
index 0000000..179009f
--- /dev/null
+++ b/libs/rs/java/Calc/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.
+#
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := Calc
+
+include $(BUILD_PACKAGE)
+##################################################
+include $(CLEAR_VARS)
+
+include $(BUILD_MULTI_PREBUILT)
+
+# Use the folloing include to make our test apk.
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/libs/rs/java/Calc/AndroidManifest.xml b/libs/rs/java/Calc/AndroidManifest.xml
new file mode 100644
index 0000000..8eee0663
--- /dev/null
+++ b/libs/rs/java/Calc/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.calc">
+ <application android:label="Calc">
+ <activity android:name="Calc"
+ 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/libs/rs/java/Calc/src/com/android/calc/Calc.java b/libs/rs/java/Calc/src/com/android/calc/Calc.java
new file mode 100644
index 0000000..94fdb8e
--- /dev/null
+++ b/libs/rs/java/Calc/src/com/android/calc/Calc.java
@@ -0,0 +1,87 @@
+/*
+ * 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.calc;
+
+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 Calc 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 CalcView 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 CalcView(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();
+
+ Runtime.getRuntime().exit(0);
+ }
+
+
+ static void log(String message) {
+ if (LOG_ENABLED) {
+ Log.v(LOG_TAG, message);
+ }
+ }
+
+
+}
+
diff --git a/libs/rs/java/Calc/src/com/android/calc/CalcView.java b/libs/rs/java/Calc/src/com/android/calc/CalcView.java
new file mode 100644
index 0000000..ecde910
--- /dev/null
+++ b/libs/rs/java/Calc/src/com/android/calc/CalcView.java
@@ -0,0 +1,135 @@
+/*
+ * 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.calc;
+
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.concurrent.Semaphore;
+
+import android.content.Context;
+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 CalcView extends RSSurfaceView {
+
+ public CalcView(Context context) {
+ super(context);
+
+ //setFocusable(true);
+ }
+
+ private RenderScript mRS;
+ private RenderScript.Allocation mIntAlloc;
+ private RenderScript.Allocation mPartAlloc;
+ private RenderScript.Allocation mVertAlloc;
+ private RenderScript.Script mScript;
+ private RenderScript.ProgramFragmentStore mPFS;
+ private RenderScript.ProgramFragment mPF;
+
+ int mParams[] = new int[10];
+
+ private void initRS() {
+ mRS = createRenderScript();
+
+ int partCount = 1024;
+
+ mIntAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, 10);
+ mPartAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 3 * 3);
+ mVertAlloc = mRS.allocationCreatePredefSized(RenderScript.ElementPredefined.USER_I32, partCount * 5 + 1);
+
+ mRS.programFragmentStoreBegin(null, null);
+ mRS.programFragmentStoreBlendFunc(RenderScript.BlendSrcFunc.SRC_ALPHA, RenderScript.BlendDstFunc.ONE);
+ mRS.programFragmentStoreDepthFunc(RenderScript.DepthFunc.ALWAYS);
+ mPFS = mRS.programFragmentStoreCreate();
+ mRS.contextBindProgramFragmentStore(mPFS);
+
+ mRS.programFragmentBegin(null, null);
+ mPF = mRS.programFragmentCreate();
+ mRS.contextBindProgramFragment(mPF);
+
+ mParams[0] = 0;
+ mParams[1] = partCount;
+ mParams[2] = 0;
+ mParams[3] = 0;
+ mParams[4] = 0;
+ mParams[5] = mPartAlloc.mID;
+ mIntAlloc.data(mParams);
+
+ int t2[] = new int[partCount * 4*3];
+ for (int ct=0; ct < t2.length; ct++) {
+ t2[ct] = 0;
+ }
+ mPartAlloc.data(t2);
+
+ mRS.scriptCBegin();
+ mRS.scriptCSetClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+ mRS.scriptCSetScript("");
+ mRS.scriptCSetRoot(true);
+ mScript = mRS.scriptCCreate();
+
+ mScript.bindAllocation(mIntAlloc, 0);
+ mScript.bindAllocation(mPartAlloc, 1);
+ mScript.bindAllocation(mVertAlloc, 2);
+ mRS.contextBindRootScript(mScript);
+
+ }
+
+ public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+ super.surfaceChanged(holder, format, w, h);
+
+ initRS();
+ }
+
+ @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);
+ }
+
+ int mTouchAction;
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev)
+ {
+ //Log.e("CalcView", ev.toString());
+ boolean ret = true;
+ int act = ev.getAction();
+ mParams[1] = (int)ev.getX();
+ mParams[2] = (int)ev.getY();
+
+ if (act == ev.ACTION_DOWN) {
+ mParams[0] = 1;
+ } else if (act == ev.ACTION_UP) {
+ //mParams[0] = 0;
+ ret = false;
+ }
+ mIntAlloc.subData1D(2, 3, mParams);
+
+ return ret;
+ }
+}
+
+
diff --git a/libs/rs/java/Calc/src/com/android/calc/RSSurfaceView.java b/libs/rs/java/Calc/src/com/android/calc/RSSurfaceView.java
new file mode 100644
index 0000000..d18270a
--- /dev/null
+++ b/libs/rs/java/Calc/src/com/android/calc/RSSurfaceView.java
@@ -0,0 +1,154 @@
+/*
+ * 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.calc;
+
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.concurrent.Semaphore;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Message;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public class RSSurfaceView extends SurfaceView implements SurfaceHolder.Callback {
+ private SurfaceHolder mSurfaceHolder;
+
+ /**
+ * Standard View constructor. In order to render something, you
+ * must call {@link #setRenderer} to register a renderer.
+ */
+ public RSSurfaceView(Context context) {
+ super(context);
+ init();
+ Log.v("***", "RSSurfaceView");
+ }
+
+ /**
+ * Standard View constructor. In order to render something, you
+ * must call {@link #setRenderer} to register a renderer.
+ */
+ public RSSurfaceView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init();
+ Log.v("***", "RSSurfaceView");
+ }
+
+ private void init() {
+ // Install a SurfaceHolder.Callback so we get notified when the
+ // underlying surface is created and destroyed
+ SurfaceHolder holder = getHolder();
+ holder.addCallback(this);
+ holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of RSSurfaceView.
+ */
+ public void surfaceCreated(SurfaceHolder holder) {
+ Log.v("***", "surfaceCreated");
+ mSurfaceHolder = holder;
+ //mGLThread.surfaceCreated();
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of RSSurfaceView.
+ */
+ public void surfaceDestroyed(SurfaceHolder holder) {
+ // Surface will be destroyed when we return
+ Log.v("***", "surfaceDestroyed");
+ //mGLThread.surfaceDestroyed();
+ }
+
+ /**
+ * This method is part of the SurfaceHolder.Callback interface, and is
+ * not normally called or subclassed by clients of RSSurfaceView.
+ */
+ public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+ Log.v("***", "surfaceChanged");
+
+ //mGLThread.onWindowResize(w, h);
+ }
+
+ /**
+ * Inform the view that the activity is paused. The owner of this view must
+ * call this method when the activity is paused. Calling this method will
+ * pause the rendering thread.
+ * Must not be called before a renderer has been set.
+ */
+ public void onPause() {
+ Log.v("***", "onPause");
+ //mGLThread.onPause();
+ }
+
+ /**
+ * Inform the view that the activity is resumed. The owner of this view must
+ * call this method when the activity is resumed. Calling this method will
+ * recreate the OpenGL display and resume the rendering
+ * thread.
+ * Must not be called before a renderer has been set.
+ */
+ public void onResume() {
+ Log.v("***", "onResume");
+ //mGLThread.onResume();
+ }
+
+ /**
+ * Queue a runnable to be run on the GL rendering thread. This can be used
+ * to communicate with the Renderer on the rendering thread.
+ * Must not be called before a renderer has been set.
+ * @param r the runnable to be run on the GL rendering thread.
+ */
+ public void queueEvent(Runnable r) {
+ Log.v("***", "queueEvent");
+ //mGLThread.queueEvent(r);
+ }
+
+ /**
+ * This method is used as part of the View class and is not normally
+ * called or subclassed by clients of RSSurfaceView.
+ * Must not be called before a renderer has been set.
+ */
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+ //mGLThread.requestExitAndWait();
+ }
+
+ // ----------------------------------------------------------------------
+
+ public RenderScript createRenderScript() {
+ Log.v("***", "createRenderScript 1");
+ Surface sur = null;
+ while ((sur == null) || (mSurfaceHolder == null)) {
+ sur = getHolder().getSurface();
+ }
+ Log.v("***", "createRenderScript 2");
+ RenderScript rs = new RenderScript(sur);
+ Log.v("***", "createRenderScript 3 rs");
+ return rs;
+ }
+
+}
+
diff --git a/libs/rs/java/Calc/src/com/android/calc/RenderScript.java b/libs/rs/java/Calc/src/com/android/calc/RenderScript.java
new file mode 100644
index 0000000..bab9666
--- /dev/null
+++ b/libs/rs/java/Calc/src/com/android/calc/RenderScript.java
@@ -0,0 +1,717 @@
+/*
+ * 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.calc;
+
+import android.os.Bundle;
+import android.util.Log;
+import android.util.Config;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.Window;
+import android.view.View;
+import android.view.Surface;
+
+public class RenderScript {
+ 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;
+
+
+
+ /*
+ * We use a class initializer to allow the native code to cache some
+ * field offsets.
+ */
+ private static boolean sInitialized;
+ native private static void _nInit();
+
+ static {
+ sInitialized = false;
+ try {
+ System.loadLibrary("RS_jni");
+ Log.e(LOG_TAG, "*** Renderscript INIT");
+ _nInit();
+ Log.e(LOG_TAG, "*** Renderscript INIT 3");
+ sInitialized = true;
+ } catch (UnsatisfiedLinkError e) {
+ Log.d(LOG_TAG, "RenderScript JNI library not found!");
+ }
+ }
+
+ native private int nDeviceCreate();
+ native private void nDeviceDestroy(int dev);
+ native private int nContextCreate(int dev, Surface sur, int ver);
+ native private void nContextDestroy(int con);
+
+ //void rsContextBindSampler (uint32_t slot, RsSampler sampler);
+ //void rsContextBindRootScript (RsScript sampler);
+ native private void nContextBindRootScript(int script);
+ native private void nContextBindSampler(int sampler, int slot);
+ native private void nContextBindProgramFragmentStore(int pfs);
+ native private void nContextBindProgramFragment(int pf);
+
+ native private void nElementBegin();
+ native private void nElementAddPredefined(int predef);
+ native private void nElementAdd(int kind, int type, int norm, int bits);
+ native private int nElementCreate();
+ native private int nElementGetPredefined(int predef);
+ native private void nElementDestroy(int obj);
+
+ native private void nTypeBegin(int elementID);
+ native private void nTypeAdd(int dim, int val);
+ native private int nTypeCreate();
+ native private void nTypeDestroy(int id);
+
+ native private int nAllocationCreateTyped(int type);
+ native private int nAllocationCreatePredefSized(int predef, int count);
+ native private int nAllocationCreateSized(int elem, int count);
+ //native private int nAllocationCreateFromBitmap(type.mID);
+ native private void nAllocationUploadToTexture(int alloc, int baseMioLevel);
+ native private void nAllocationDestroy(int alloc);
+ native private void nAllocationData(int id, int[] d);
+ native private void nAllocationData(int id, float[] d);
+ native private void nAllocationSubData1D(int id, int off, int count, int[] d);
+ native private void nAllocationSubData1D(int id, int off, int count, float[] d);
+ native private void nAllocationSubData2D(int id, int xoff, int yoff, int w, int h, int[] d);
+ native private void nAllocationSubData2D(int id, int xoff, int yoff, int w, int h, float[] d);
+
+ native private void nTriangleMeshDestroy(int id);
+ native private void nTriangleMeshBegin(int vertex, int index);
+ native private void nTriangleMeshAddVertex_XY (float x, float y);
+ native private void nTriangleMeshAddVertex_XYZ (float x, float y, float z);
+ native private void nTriangleMeshAddVertex_XY_ST (float x, float y, float s, float t);
+ native private void nTriangleMeshAddVertex_XYZ_ST (float x, float y, float z, float s, float t);
+ native private void nTriangleMeshAddTriangle(int i1, int i2, int i3);
+ native private int nTriangleMeshCreate();
+
+ native private void nAdapter1DDestroy(int id);
+ native private void nAdapter1DBindAllocation(int ad, int alloc);
+ native private void nAdapter1DSetConstraint(int ad, int dim, int value);
+ native private void nAdapter1DData(int ad, int[] d);
+ native private void nAdapter1DSubData(int ad, int off, int count, int[] d);
+ native private void nAdapter1DData(int ad, float[] d);
+ native private void nAdapter1DSubData(int ad, int off, int count, float[] d);
+ native private int nAdapter1DCreate();
+
+ native private void nScriptDestroy(int script);
+ native private void nScriptBindAllocation(int vtm, int alloc, int slot);
+ native private void nScriptCBegin();
+ native private void nScriptCSetClearColor(float r, float g, float b, float a);
+ native private void nScriptCSetClearDepth(float depth);
+ native private void nScriptCSetClearStencil(int stencil);
+ native private void nScriptCAddType(int type);
+ native private void nScriptCSetRoot(boolean isRoot);
+ native private void nScriptCSetScript(String s);
+ native private int nScriptCCreate();
+
+
+ native private void nProgramFragmentStoreBegin(int in, int out);
+ native private void nProgramFragmentStoreDepthFunc(int func);
+ native private void nProgramFragmentStoreDepthMask(boolean enable);
+ native private void nProgramFragmentStoreColorMask(boolean r, boolean g, boolean b, boolean a);
+ native private void nProgramFragmentStoreBlendFunc(int src, int dst);
+ native private void nProgramFragmentStoreDither(boolean enable);
+ native private int nProgramFragmentStoreCreate();
+
+ native private void nProgramFragmentBegin(int in, int out);
+ native private void nProgramFragmentBindTexture(int vpf, int slot, int a);
+ native private void nProgramFragmentBindSampler(int vpf, int slot, int s);
+ native private void nProgramFragmentSetType(int slot, int vt);
+ native private void nProgramFragmentSetEnvMode(int slot, int env);
+ native private void nProgramFragmentSetTexEnable(int slot, boolean enable);
+ native private int nProgramFragmentCreate();
+
+
+ private int mDev;
+ private int mContext;
+ private Surface mSurface;
+
+
+
+ ///////////////////////////////////////////////////////////////////////////////////
+ //
+
+ RenderScript(Surface sur) {
+ mSurface = sur;
+ mDev = nDeviceCreate();
+ mContext = nContextCreate(mDev, mSurface, 0);
+ }
+
+ private class BaseObj {
+ BaseObj() {
+ mID = 0;
+ }
+
+ int mID;
+ protected void finalize() throws Throwable
+ {
+ if (mID != 0) {
+ Log.v(LOG_TAG,
+ "Element finalized without having released the RS reference.");
+ }
+ super.finalize();
+ }
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Element
+
+ public enum ElementPredefined {
+ USER_U8 (0),
+ USER_I8 (1),
+ USER_U16 (2),
+ USER_I16 (3),
+ USER_U32 (4),
+ USER_I32 (5),
+ USER_FLOAT (6),
+
+ RGB_565 (7),
+ RGBA_5551 (8),
+ RGBA_4444 (9),
+ RGB_888 (10),
+ RGBA_8888 (11),
+
+ INDEX_16 (12),
+ INDEX_32 (13),
+ XY_F32 (14),
+ XYZ_F32 (15),
+ ST_XY_F32 (16),
+ ST_XYZ_F32 (17),
+ NORM_XYZ_F32 (18),
+ NORM_ST_XYZ_F32 (19);
+
+ int mID;
+ ElementPredefined(int id) {
+ mID = id;
+ }
+ }
+
+ public enum DataType {
+ FLOAT (0),
+ UNSIGNED (1),
+ SIGNED (2);
+
+ int mID;
+ DataType(int id) {
+ mID = id;
+ }
+ }
+
+ public enum DataKind {
+ USER (0),
+ RED (1),
+ GREEN (2),
+ BLUE (3),
+ ALPHA (4),
+ LUMINANCE (5),
+ INTENSITY (6),
+ X (7),
+ Y (8),
+ Z (9),
+ W (10),
+ S (11),
+ T (12),
+ Q (13),
+ R (14),
+ NX (15),
+ NY (16),
+ NZ (17),
+ INDEX (18);
+
+ int mID;
+ DataKind(int id) {
+ mID = id;
+ }
+ }
+
+ public enum DepthFunc {
+ ALWAYS (0),
+ LESS (1),
+ LEQUAL (2),
+ GREATER (3),
+ GEQUAL (4),
+ EQUAL (5),
+ NOTEQUAL (6);
+
+ int mID;
+ DepthFunc(int id) {
+ mID = id;
+ }
+ }
+
+ public enum BlendSrcFunc {
+ ZERO (0),
+ ONE (1),
+ DST_COLOR (2),
+ ONE_MINUS_DST_COLOR (3),
+ SRC_ALPHA (4),
+ ONE_MINUS_SRC_ALPHA (5),
+ DST_ALPHA (6),
+ ONE_MINUS_DST_ALPA (7),
+ SRC_ALPHA_SATURATE (8);
+
+ int mID;
+ BlendSrcFunc(int id) {
+ mID = id;
+ }
+ }
+
+ public enum BlendDstFunc {
+ ZERO (0),
+ ONE (1),
+ SRC_COLOR (2),
+ ONE_MINUS_SRC_COLOR (3),
+ SRC_ALPHA (4),
+ ONE_MINUS_SRC_ALPHA (5),
+ DST_ALPHA (6),
+ ONE_MINUS_DST_ALPA (7);
+
+ int mID;
+ BlendDstFunc(int id) {
+ mID = id;
+ }
+ }
+
+ public enum EnvMode {
+ REPLACE (0),
+ MODULATE (1),
+ DECAL (2);
+
+ int mID;
+ EnvMode(int id) {
+ mID = id;
+ }
+ }
+
+ public class Element extends BaseObj {
+ Element(int id) {
+ mID = id;
+ }
+
+ public void estroy() {
+ nElementDestroy(mID);
+ mID = 0;
+ }
+ }
+
+ public void elementBegin() {
+ nElementBegin();
+ }
+
+ public void elementAddPredefined(ElementPredefined e) {
+ nElementAddPredefined(e.mID);
+ }
+
+ public void elementAdd(DataType dt, DataKind dk, boolean isNormalized, int bits) {
+ int norm = 0;
+ if (isNormalized) {
+ norm = 1;
+ }
+ nElementAdd(dt.mID, dk.mID, norm, bits);
+ }
+
+ public Element elementCreate() {
+ int id = nElementCreate();
+ return new Element(id);
+ }
+
+ public Element elementGetPredefined(ElementPredefined predef) {
+ int id = nElementGetPredefined(predef.mID);
+ return new Element(id);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Type
+
+ public enum Dimension {
+ X (0),
+ Y (1),
+ Z (2),
+ LOD (3),
+ FACE (4),
+ ARRAY_0 (100);
+
+ int mID;
+ Dimension(int id) {
+ mID = id;
+ }
+ }
+
+ public class Type extends BaseObj {
+ Type(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nTypeDestroy(mID);
+ mID = 0;
+ }
+ }
+
+ public void typeBegin(Element e) {
+ nTypeBegin(e.mID);
+ }
+
+ public void typeAdd(Dimension d, int value) {
+ nTypeAdd(d.mID, value);
+ }
+
+ public Type typeCreate() {
+ int id = nTypeCreate();
+ return new Type(id);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Allocation
+
+ public class Allocation extends BaseObj {
+ Allocation(int id) {
+ mID = id;
+ }
+
+ public void uploadToTexture(int baseMipLevel) {
+ nAllocationUploadToTexture(mID, baseMipLevel);
+ }
+
+ public void destroy() {
+ nAllocationDestroy(mID);
+ mID = 0;
+ }
+
+ public void data(int[] d) {
+ nAllocationData(mID, d);
+ }
+
+ public void data(float[] d) {
+ nAllocationData(mID, d);
+ }
+
+ public void subData1D(int off, int count, int[] d) {
+ nAllocationSubData1D(mID, off, count, d);
+ }
+
+ public void subData1D(int off, int count, float[] d) {
+ nAllocationSubData1D(mID, off, count, d);
+ }
+
+ public void subData2D(int xoff, int yoff, int w, int h, int[] d) {
+ nAllocationSubData2D(mID, xoff, yoff, w, h, d);
+ }
+
+ public void subData2D(int xoff, int yoff, int w, int h, float[] d) {
+ nAllocationSubData2D(mID, xoff, yoff, w, h, d);
+ }
+ }
+
+ public Allocation allocationCreateTyped(Type type) {
+ int id = nAllocationCreateTyped(type.mID);
+ return new Allocation(id);
+ }
+
+ public Allocation allocationCreatePredefSized(ElementPredefined e, int count) {
+ int id = nAllocationCreatePredefSized(e.mID, count);
+ return new Allocation(id);
+ }
+
+ public Allocation allocationCreateSized(Element e, int count) {
+ int id = nAllocationCreateSized(e.mID, count);
+ return new Allocation(id);
+ }
+
+ //public Allocation allocationCreateFromBitmap(string file, boolean genMips) {
+ //int id = nAllocationCreateTyped(type.mID);
+ //return new Allocation(id);
+ //}
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Adapter1D
+
+ public class Adapter1D extends BaseObj {
+ Adapter1D(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nAdapter1DDestroy(mID);
+ mID = 0;
+ }
+
+ public void bindAllocation(Allocation a) {
+ nAdapter1DBindAllocation(mID, a.mID);
+ }
+
+ public void setConstraint(Dimension dim, int value) {
+ nAdapter1DSetConstraint(mID, dim.mID, value);
+ }
+
+ public void data(int[] d) {
+ nAdapter1DData(mID, d);
+ }
+
+ public void subData(int off, int count, int[] d) {
+ nAdapter1DSubData(mID, off, count, d);
+ }
+
+ public void data(float[] d) {
+ nAdapter1DData(mID, d);
+ }
+
+ public void subData(int off, int count, float[] d) {
+ nAdapter1DSubData(mID, off, count, d);
+ }
+ }
+
+ public Adapter1D adapter1DCreate() {
+ int id = nAdapter1DCreate();
+ return new Adapter1D(id);
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Triangle Mesh
+
+ public class TriangleMesh extends BaseObj {
+ TriangleMesh(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nTriangleMeshDestroy(mID);
+ mID = 0;
+ }
+ }
+
+ public void triangleMeshBegin(Element vertex, Element index) {
+ nTriangleMeshBegin(vertex.mID, index.mID);
+ }
+
+ public void triangleMeshAddVertex_XY(float x, float y) {
+ nTriangleMeshAddVertex_XY(x, y);
+ }
+
+ public void triangleMeshAddVertex_XYZ(float x, float y, float z) {
+ nTriangleMeshAddVertex_XYZ(x, y, z);
+ }
+
+ public void triangleMeshAddVertex_XY_ST(float x, float y, float s, float t) {
+ nTriangleMeshAddVertex_XY_ST(x, y, s, t);
+ }
+
+ public void triangleMeshAddVertex_XYZ_ST(float x, float y, float z, float s, float t) {
+ nTriangleMeshAddVertex_XYZ_ST(x, y, z, s, t);
+ }
+
+ public void triangleMeshAddTriangle(int i1, int i2, int i3) {
+ nTriangleMeshAddTriangle(i1, i2, i3);
+ }
+
+ public TriangleMesh triangleMeshCreate() {
+ int id = nTriangleMeshCreate();
+ return new TriangleMesh(id);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // Script
+
+ public class Script extends BaseObj {
+ Script(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nScriptDestroy(mID);
+ mID = 0;
+ }
+
+ public void bindAllocation(Allocation va, int slot) {
+ nScriptBindAllocation(mID, va.mID, slot);
+ }
+ }
+
+ public void scriptCBegin() {
+ nScriptCBegin();
+ }
+
+ public void scriptCSetClearColor(float r, float g, float b, float a) {
+ nScriptCSetClearColor(r, g, b, a);
+ }
+
+ public void scriptCSetClearDepth(float d) {
+ nScriptCSetClearDepth(d);
+ }
+
+ public void scriptCSetClearStencil(int stencil) {
+ nScriptCSetClearStencil(stencil);
+ }
+
+ public void scriptCAddType(Type t) {
+ nScriptCAddType(t.mID);
+ }
+
+ public void scriptCSetRoot(boolean r) {
+ nScriptCSetRoot(r);
+ }
+
+ public void scriptCSetScript(String s) {
+ nScriptCSetScript(s);
+ }
+
+ public Script scriptCCreate() {
+ int id = nScriptCCreate();
+ return new Script(id);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // ProgramFragmentStore
+
+ public class ProgramFragmentStore extends BaseObj {
+ ProgramFragmentStore(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nScriptDestroy(mID);
+ mID = 0;
+ }
+ }
+
+ public void programFragmentStoreBegin(Element in, Element out) {
+ int inID = 0;
+ int outID = 0;
+ if (in != null) {
+ inID = in.mID;
+ }
+ if (out != null) {
+ outID = out.mID;
+ }
+ nProgramFragmentStoreBegin(inID, outID);
+ }
+
+ public void programFragmentStoreDepthFunc(DepthFunc func) {
+ nProgramFragmentStoreDepthFunc(func.mID);
+ }
+
+ public void programFragmentStoreDepthMask(boolean enable) {
+ nProgramFragmentStoreDepthMask(enable);
+ }
+
+ public void programFragmentStoreColorMask(boolean r, boolean g, boolean b, boolean a) {
+ nProgramFragmentStoreColorMask(r,g,b,a);
+ }
+
+ public void programFragmentStoreBlendFunc(BlendSrcFunc src, BlendDstFunc dst) {
+ nProgramFragmentStoreBlendFunc(src.mID, dst.mID);
+ }
+
+ public void programFragmentStoreDitherEnable(boolean enable) {
+ nProgramFragmentStoreDither(enable);
+ }
+
+ public ProgramFragmentStore programFragmentStoreCreate() {
+ int id = nProgramFragmentStoreCreate();
+ return new ProgramFragmentStore(id);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////
+ // ProgramFragment
+
+ public class ProgramFragment extends BaseObj {
+ ProgramFragment(int id) {
+ mID = id;
+ }
+
+ public void destroy() {
+ nScriptDestroy(mID);
+ mID = 0;
+ }
+
+ public void bindTexture(Allocation va, int slot) {
+ nProgramFragmentBindTexture(mID, slot, va.mID);
+ }
+
+ //public void bindSampler(Sampler vs, int slot) {
+ //nProgramFragmentBindSampler(mID, slot, vs.mID);
+ //}
+ }
+
+ public void programFragmentBegin(Element in, Element out) {
+ int inID = 0;
+ int outID = 0;
+ if (in != null) {
+ inID = in.mID;
+ }
+ if (out != null) {
+ outID = out.mID;
+ }
+ nProgramFragmentBegin(inID, outID);
+ }
+
+ public void programFragmentSetType(int slot, Type t) {
+ nProgramFragmentSetType(slot, t.mID);
+ }
+
+ public void programFragmentSetType(int slot, EnvMode t) {
+ nProgramFragmentSetEnvMode(slot, t.mID);
+ }
+
+ public void programFragmentSetTexEnable(int slot, boolean enable) {
+ nProgramFragmentSetTexEnable(slot, enable);
+ }
+
+ public ProgramFragment programFragmentCreate() {
+ int id = nProgramFragmentCreate();
+ return new ProgramFragment(id);
+ }
+
+
+ ///////////////////////////////////////////////////////////////////////////////////
+ // Root state
+
+ public void contextBindRootScript(Script s) {
+ nContextBindRootScript(s.mID);
+ }
+
+ //public void contextBindSampler(Sampler s, int slot) {
+ //nContextBindSampler(s.mID);
+ //}
+
+ public void contextBindProgramFragmentStore(ProgramFragmentStore pfs) {
+ nContextBindProgramFragmentStore(pfs.mID);
+ }
+
+ public void contextBindProgramFragment(ProgramFragment pf) {
+ nContextBindProgramFragment(pf.mID);
+ }
+
+/*
+ RsAdapter2D rsAdapter2DCreate ();
+ void rsAdapter2DBindAllocation (RsAdapter2D adapt, RsAllocation alloc);
+ void rsAdapter2DDestroy (RsAdapter2D adapter);
+ void rsAdapter2DSetConstraint (RsAdapter2D adapter, RsDimension dim, uint32_t value);
+ void rsAdapter2DData (RsAdapter2D adapter, const void * data);
+ void rsAdapter2DSubData (RsAdapter2D adapter, uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, const void * data);
+ void rsSamplerBegin ();
+ void rsSamplerSet (RsSamplerParam p, RsSamplerValue value);
+ RsSampler rsSamplerCreate ();
+ void rsSamplerBind (RsSampler sampler, RsAllocation alloc);
+*/
+
+}
+
