Creating the jni and java layer to integrate a3d

Change-Id: I438359633bae59bf9188cd2c4664a92ca16c5f37

41 files changed, 1127 insertions, 166 deletions

diff --git a/graphics/java/android/renderscript/FileA3D.java b/graphics/java/android/renderscript/FileA3D.java
new file mode 100644
index 0000000..fb36f1f
--- /dev/null
+++ b/graphics/java/android/renderscript/FileA3D.java
@@ -0,0 +1,214 @@
+/*
+ * 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 android.renderscript;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import android.content.res.Resources;
+import android.content.res.AssetManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.util.Log;
+import android.util.TypedValue;
+
+/**
+ * @hide
+ *
+ **/
+public class FileA3D extends BaseObj {
+
+    public enum ClassID {
+
+        UNKNOWN,
+        MESH,
+        SIMPLE_MESH,
+        TYPE,
+        ELEMENT,
+        ALLOCATION,
+        PROGRAM_VERTEX,
+        PROGRAM_RASTER,
+        PROGRAM_FRAGMENT,
+        PROGRAM_STORE,
+        SAMPLER,
+        ANIMATION,
+        LIGHT,
+        ADAPTER_1D,
+        ADAPTER_2D,
+        SCRIPT_C;
+
+        public static ClassID toClassID(int intID) {
+            return ClassID.values()[intID];
+        }
+    }
+
+    // Read only class with index entries
+    public class IndexEntry {
+        RenderScript mRS;
+        int mIndex;
+        int mID;
+        String mName;
+        ClassID mClassID;
+        BaseObj mLoadedObj;
+
+        public String getName() {
+            return mName;
+        }
+
+        public ClassID getClassID() {
+            return mClassID;
+        }
+
+        public BaseObj getObject() {
+            if(mLoadedObj != null) {
+                return mLoadedObj;
+            }
+
+            if(mClassID == ClassID.UNKNOWN) {
+                return null;
+            }
+
+            int objectID = mRS.nFileA3DGetEntryByIndex(mID, mIndex);
+            if(objectID == 0) {
+                return null;
+            }
+
+            switch (mClassID) {
+            case MESH:
+                mLoadedObj = null;
+                break;
+            case SIMPLE_MESH:
+                mLoadedObj = new SimpleMesh(objectID, mRS);
+                break;
+            case TYPE:
+                mLoadedObj = new Type(objectID, mRS);
+                break;
+            case ELEMENT:
+                mLoadedObj = null;
+                break;
+            case ALLOCATION:
+                mLoadedObj = null;
+                break;
+            case PROGRAM_VERTEX:
+                mLoadedObj = new ProgramVertex(objectID, mRS);
+                break;
+            case PROGRAM_RASTER:
+                break;
+            case PROGRAM_FRAGMENT:
+                break;
+            case PROGRAM_STORE:
+                break;
+            case SAMPLER:
+                break;
+            case ANIMATION:
+                break;
+            case LIGHT:
+                break;
+            case ADAPTER_1D:
+                break;
+            case ADAPTER_2D:
+                break;
+            case SCRIPT_C:
+                break;
+            }
+
+            return mLoadedObj;
+        }
+
+        IndexEntry(RenderScript rs, int index, int id, String name, ClassID classID) {
+            mRS = rs;
+            mIndex = index;
+            mID = id;
+            mName = name;
+            mClassID = classID;
+            mLoadedObj = null;
+        }
+    }
+
+    IndexEntry[] mFileEntries;
+
+    FileA3D(int id, RenderScript rs) {
+        super(rs);
+        mID = id;
+    }
+
+    private void initEntries() {
+        int numFileEntries = mRS.nFileA3DGetNumIndexEntries(mID);
+        if(numFileEntries <= 0) {
+            return;
+        }
+
+        mFileEntries = new IndexEntry[numFileEntries];
+        int[] ids = new int[numFileEntries];
+        String[] names = new String[numFileEntries];
+
+        mRS.nFileA3DGetIndexEntries(mID, numFileEntries, ids, names);
+
+        for(int i = 0; i < numFileEntries; i ++) {
+            mFileEntries[i] = new IndexEntry(mRS, i, mID, names[i], ClassID.toClassID(ids[i]));
+        }
+    }
+
+    public int getNumIndexEntries() {
+        if(mFileEntries == null) {
+            return 0;
+        }
+        return mFileEntries.length;
+    }
+
+    public IndexEntry getIndexEntry(int index) {
+        if(getNumIndexEntries() == 0 || index < 0 || index >= mFileEntries.length) {
+            return null;
+        }
+        return mFileEntries[index];
+    }
+
+    static public FileA3D createFromResource(RenderScript rs, Resources res, int id)
+        throws IllegalArgumentException {
+
+        rs.validate();
+        InputStream is = null;
+        try {
+            final TypedValue value = new TypedValue();
+            is = res.openRawResource(id, value);
+
+            int asset = ((AssetManager.AssetInputStream) is).getAssetInt();
+
+            int fileId = rs.nFileA3DCreateFromAssetStream(asset);
+
+            if(fileId == 0) {
+                throw new IllegalStateException("Load failed.");
+            }
+            FileA3D fa3d = new FileA3D(fileId, rs);
+            fa3d.initEntries();
+            return fa3d;
+
+        } catch (Exception e) {
+            // Ignore
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                } catch (IOException e) {
+                    // Ignore
+                }
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/graphics/java/android/renderscript/RenderScript.java b/graphics/java/android/renderscript/RenderScript.java
index eda849e..d35cf8b 100644
--- a/graphics/java/android/renderscript/RenderScript.java
+++ b/graphics/java/android/renderscript/RenderScript.java
@@ -117,6 +117,11 @@ public class RenderScript {
     native void nAllocationSubDataFromObject(int id, Type t, int offset, Object o);
     native void nAllocationSubReadFromObject(int id, Type t, int offset, Object o);
 
+    native int  nFileA3DCreateFromAssetStream(int assetStream);
+    native int  nFileA3DGetNumIndexEntries(int fileA3D);
+    native void nFileA3DGetIndexEntries(int fileA3D, int numEntries, int[] IDs, String[] names);
+    native int  nFileA3DGetEntryByIndex(int fileA3D, int index);
+
     native void nAdapter1DBindAllocation(int ad, int alloc);
     native void nAdapter1DSetConstraint(int ad, int dim, int value);
     native void nAdapter1DData(int ad, int[] d);
diff --git a/graphics/jni/android_renderscript_RenderScript.cpp b/graphics/jni/android_renderscript_RenderScript.cpp
index 223ef4b..86d7ba4 100644
--- a/graphics/jni/android_renderscript_RenderScript.cpp
+++ b/graphics/jni/android_renderscript_RenderScript.cpp
@@ -700,6 +700,59 @@ nAllocationSubReadFromObject(JNIEnv *_env, jobject _this, jint alloc, jobject _t
     free(bufAlloc);
 }
 
+// -----------------------------------
+
+static int
+nFileA3DCreateFromAssetStream(JNIEnv *_env, jobject _this, jint native_asset)
+{
+    LOGV("______nFileA3D %u", (uint32_t) native_asset);
+    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
+
+    Asset* asset = reinterpret_cast<Asset*>(native_asset);
+
+    jint id = (jint)rsFileA3DCreateFromAssetStream(con, asset->getBuffer(false), asset->getLength());
+    return id;
+}
+
+static int
+nFileA3DGetNumIndexEntries(JNIEnv *_env, jobject _this, jint fileA3D)
+{
+    LOGV("______nFileA3D %u", (uint32_t) fileA3D);
+    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
+
+    int32_t numEntries = 0;
+    rsFileA3DGetNumIndexEntries(con, &numEntries, (RsFile)fileA3D);
+    LOGV("______nFileA3D NumEntries %u", (uint32_t) numEntries);
+    return numEntries;
+}
+
+static void
+nFileA3DGetIndexEntries(JNIEnv *_env, jobject _this, jint fileA3D, jint numEntries, jintArray _ids, jobjectArray _entries)
+{
+    LOGV("______nFileA3D %u", (uint32_t) fileA3D);
+    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
+
+    RsFileIndexEntry *fileEntries = (RsFileIndexEntry*)malloc((uint32_t)numEntries * sizeof(RsFileIndexEntry));
+
+    rsFileA3DGetIndexEntries(con, fileEntries, (uint32_t)numEntries, (RsFile)fileA3D);
+
+    for(jint i = 0; i < numEntries; i ++) {
+        _env->SetObjectArrayElement(_entries, i, _env->NewStringUTF(fileEntries[i].objectName));
+        _env->SetIntArrayRegion(_ids, i, 1, (const jint*)&fileEntries[i].classID);
+    }
+
+    free(fileEntries);
+}
+
+static int
+nFileA3DGetEntryByIndex(JNIEnv *_env, jobject _this, jint fileA3D, jint index)
+{
+    LOGV("______nFileA3D %u", (uint32_t) fileA3D);
+    RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
+
+    jint id = (jint)rsFileA3DGetEntryByIndex(con, (uint32_t)index, (RsFile)fileA3D);
+    return id;
+}
 
 // -----------------------------------
 
@@ -1442,6 +1495,11 @@ static JNINativeMethod methods[] = {
 {"nSimpleMeshBindVertex",          "(III)V",                               (void*)nSimpleMeshBindVertex },
 {"nSimpleMeshBindIndex",           "(II)V",                                (void*)nSimpleMeshBindIndex },
 
+{"nFileA3DCreateFromAssetStream", "(I)I",                                 (void*)nFileA3DCreateFromAssetStream },
+{"nFileA3DGetNumIndexEntries",     "(I)I",                                 (void*)nFileA3DGetNumIndexEntries },
+{"nFileA3DGetIndexEntries",        "(II[I[Ljava/lang/String;)V",          (void*)nFileA3DGetIndexEntries },
+{"nFileA3DGetEntryByIndex",        "(II)I",                                (void*)nFileA3DGetEntryByIndex },
+
 };
 
 static int registerFuncs(JNIEnv *_env)
diff --git a/libs/rs/RenderScript.h b/libs/rs/RenderScript.h
index 5e246ce..e7c0274 100644
--- a/libs/rs/RenderScript.h
+++ b/libs/rs/RenderScript.h
@@ -40,6 +40,7 @@ typedef void * RsScript;
 typedef void * RsSimpleMesh;
 typedef void * RsType;
 typedef void * RsLight;
+typedef void * RsObjectBase;
 
 typedef void * RsProgram;
 typedef void * RsProgramVertex;
@@ -229,6 +230,30 @@ enum RsAnimationEdge {
     RS_ANIMATION_EDGE_CYLE_RELATIVE
 };
 
+enum RsA3DClassID {
+    RS_A3D_CLASS_ID_UNKNOWN,
+    RS_A3D_CLASS_ID_MESH,
+    RS_A3D_CLASS_ID_SIMPLE_MESH,
+    RS_A3D_CLASS_ID_TYPE,
+    RS_A3D_CLASS_ID_ELEMENT,
+    RS_A3D_CLASS_ID_ALLOCATION,
+    RS_A3D_CLASS_ID_PROGRAM_VERTEX,
+    RS_A3D_CLASS_ID_PROGRAM_RASTER,
+    RS_A3D_CLASS_ID_PROGRAM_FRAGMENT,
+    RS_A3D_CLASS_ID_PROGRAM_STORE,
+    RS_A3D_CLASS_ID_SAMPLER,
+    RS_A3D_CLASS_ID_ANIMATION,
+    RS_A3D_CLASS_ID_LIGHT,
+    RS_A3D_CLASS_ID_ADAPTER_1D,
+    RS_A3D_CLASS_ID_ADAPTER_2D,
+    RS_A3D_CLASS_ID_SCRIPT_C
+};
+
+typedef struct {
+    RsA3DClassID classID;
+    const char* objectName;
+} RsFileIndexEntry;
+
 #ifndef NO_RS_FUNCS
 #include "rsgApiFuncDecl.h"
 #endif
diff --git a/libs/rs/java/ModelViewer/Android.mk b/libs/rs/java/ModelViewer/Android.mk
new file mode 100644
index 0000000..8bec6d6
--- /dev/null
+++ b/libs/rs/java/ModelViewer/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)
+#LOCAL_STATIC_JAVA_LIBRARIES := android.renderscript
+
+LOCAL_PACKAGE_NAME := ModelViewer
+
+include $(BUILD_PACKAGE)
diff --git a/libs/rs/java/ModelViewer/AndroidManifest.xml b/libs/rs/java/ModelViewer/AndroidManifest.xml
new file mode 100644
index 0000000..ebbe743
--- /dev/null
+++ b/libs/rs/java/ModelViewer/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.modelviewer">
+    <application android:label="ModelViewer">
+        <activity android:name="ModelViewer"
+                  android:screenOrientation="portrait"
+                  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/ModelViewer/res/drawable/robot.png b/libs/rs/java/ModelViewer/res/drawable/robot.png
new file mode 100644
index 0000000..7c85e56
--- /dev/null
+++ b/libs/rs/java/ModelViewer/res/drawable/robot.png
diff --git a/libs/rs/java/ModelViewer/res/raw/modelviewer.rs b/libs/rs/java/ModelViewer/res/raw/modelviewer.rs
new file mode 100644
index 0000000..6a98f90
--- /dev/null
+++ b/libs/rs/java/ModelViewer/res/raw/modelviewer.rs
@@ -0,0 +1,59 @@
+// 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)
+
+#include "../../../../scriptc/rs_types.rsh"
+#include "../../../../scriptc/rs_math.rsh"
+#include "../../../../scriptc/rs_graphics.rsh"
+
+rs_program_vertex gPVBackground;
+rs_program_fragment gPFBackground;
+
+rs_allocation gTGrid;
+rs_mesh gTestMesh;
+
+rs_program_store gPFSBackground;
+
+float gRotate;
+
+#pragma rs export_var(gPVBackground, gPFBackground, gTGrid, gTestMesh, gPFSBackground, gRotate)
+
+void init() {
+    gRotate = 0.0f;
+}
+
+int root(int launchID) {
+
+    rsgClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+    rsgClearDepth(1.0f);
+
+    rsgBindProgramVertex(gPVBackground);
+
+    rsgBindProgramFragment(gPFBackground);
+    rsgBindProgramStore(gPFSBackground);
+    rsgBindTexture(gPFBackground, 0, gTGrid);
+
+    rs_matrix4x4 matrix;
+    rsMatrixLoadIdentity(&matrix);
+    // Position our model on the screen
+    rsMatrixTranslate(&matrix, 0.0f, -0.3f, 1.2f);
+    rsMatrixScale(&matrix, 0.2f, 0.2f, 0.2f);
+    rsMatrixRotate(&matrix, gRotate, 0.0f, 1.0f, 0.0f);
+    rsgProgramVertexLoadModelMatrix(&matrix);
+
+    rsgDrawSimpleMesh(gTestMesh);
+
+    return 10;
+}
diff --git a/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc b/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc
new file mode 100644
index 0000000..b02250b
--- /dev/null
+++ b/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc
diff --git a/libs/rs/java/ModelViewer/res/raw/robot.a3d b/libs/rs/java/ModelViewer/res/raw/robot.a3d
new file mode 100644
index 0000000..c0c66ae
--- /dev/null
+++ b/libs/rs/java/ModelViewer/res/raw/robot.a3d
diff --git a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewer.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewer.java
new file mode 100644
index 0000000..7491744
--- /dev/null
+++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewer.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.modelviewer;
+
+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 ModelViewer extends Activity {
+
+    private ModelViewerView 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 ModelViewerView(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/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java
new file mode 100644
index 0000000..dd52955
--- /dev/null
+++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java
@@ -0,0 +1,156 @@
+/*
+ * 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.modelviewer;
+
+import java.io.Writer;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.util.Log;
+
+
+public class ModelViewerRS {
+
+    private final int STATE_LAST_FOCUS = 1;
+
+    int mWidth;
+    int mHeight;
+    int mRotation;
+
+    public ModelViewerRS() {
+    }
+
+    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 SimpleMesh mMesh;
+
+    private ScriptC_ModelViewer mScript;
+
+    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(1);
+
+        mScript.set_gTGrid(mGridImage);
+    }
+
+    private void initRS() {
+
+        mScript = new ScriptC_ModelViewer(mRS, mRes, true);
+
+        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.SIMPLE_MESH) {
+            Log.e("rs", "could not load model");
+        }
+        else {
+            mMesh = (SimpleMesh)entry.getObject();
+            mScript.set_gTestMesh(mMesh);
+        }
+
+        mRS.contextBindRootScript(mScript);
+    }
+}
+
+
+
diff --git a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerView.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerView.java
new file mode 100644
index 0000000..ce76e1a
--- /dev/null
+++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerView.java
@@ -0,0 +1,95 @@
+/*
+ * 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.modelviewer;
+
+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 ModelViewerView extends RSSurfaceView {
+
+    public ModelViewerView(Context context) {
+        super(context);
+        //setFocusable(true);
+    }
+
+    private RenderScriptGL mRS;
+    private ModelViewerRS 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 ModelViewerRS();
+            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;
+        }
+
+        Log.v("rs", "Values " + (int)ev.getX() + " " + (int)ev.getY());
+        mRender.touchEvent((int)ev.getX(), (int)ev.getY());
+        return ret;
+    }
+}
+
+
diff --git a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_ModelViewer.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_ModelViewer.java
new file mode 100644
index 0000000..f617c77
--- /dev/null
+++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_ModelViewer.java
@@ -0,0 +1,42 @@
+
+package com.android.modelviewer;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.util.Log;
+
+
+
+public class ScriptC_ModelViewer
+    extends android.renderscript.ScriptC
+{
+    public ScriptC_ModelViewer(RenderScript rs, Resources resources, boolean isRoot) {
+        super(rs, resources, R.raw.modelviewer_bc, isRoot);
+    }
+
+    public void set_gPVBackground(ProgramVertex v) {
+        setVar(0, v.getID());
+    }
+
+    public void set_gPFBackground(ProgramFragment v) {
+        setVar(1, v.getID());
+    }
+
+    public void set_gTGrid(Allocation v) {
+        setVar(2, v.getID());
+    }
+
+    public void set_gTestMesh(SimpleMesh v) {
+        setVar(3, v.getID());
+    }
+
+    public void set_gPFSBackground(ProgramStore v) {
+        setVar(4, v.getID());
+    }
+
+    public void set_gRotate(float v) {
+        setVar(5, v);
+    }
+
+}
+
diff --git a/libs/rs/rs.spec b/libs/rs/rs.spec
index 2a872cd..4867cad 100644
--- a/libs/rs/rs.spec
+++ b/libs/rs/rs.spec
@@ -441,12 +441,34 @@ LightSetColor {
 	param float b
 	}
 
+FileA3DCreateFromAssetStream {
+	param const void * data
+	param size_t len
+	ret RsFile
+	}
+
 FileOpen {
 	ret RsFile
 	param const char *name
 	param size_t len
 	}
 
+FileA3DGetNumIndexEntries {
+	param int32_t * numEntries
+	param RsFile file
+	}
+
+FileA3DGetIndexEntries {
+	param RsFileIndexEntry * fileEntries
+	param uint32_t numEntries
+	param RsFile fileA3D
+	}
+
+FileA3DGetEntryByIndex {
+	param uint32_t index
+	param RsFile file
+	ret RsObjectBase
+	}
 
 SimpleMeshCreate {
 	ret RsSimpleMesh
diff --git a/libs/rs/rsAdapter.h b/libs/rs/rsAdapter.h
index 937ef50..449e7ad 100644
--- a/libs/rs/rsAdapter.h
+++ b/libs/rs/rsAdapter.h
@@ -49,9 +49,9 @@ public:
 
     void subData(uint32_t xoff, uint32_t count, const void *data);
     void data(const void *data);
-    
+
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_ADAPTER_1D; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ADAPTER_1D; }
     static Adapter1D *createFromStream(Context *rsc, IStream *stream);
 
 protected:
@@ -85,9 +85,9 @@ public:
 
     void data(const void *data);
     void subData(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h, const void *data);
-    
+
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_ADAPTER_2D; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ADAPTER_2D; }
     static Adapter2D *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsAllocation.cpp b/libs/rs/rsAllocation.cpp
index 4db6a04..289cb30 100644
--- a/libs/rs/rsAllocation.cpp
+++ b/libs/rs/rsAllocation.cpp
@@ -348,8 +348,8 @@ void Allocation::serialize(OStream *stream) const
 Allocation *Allocation::createFromStream(Context *rsc, IStream *stream)
 {
     // First make sure we are reading the correct object
-    A3DClassID classID = (A3DClassID)stream->loadU32();
-    if(classID != A3D_CLASS_ID_ALLOCATION) {
+    RsA3DClassID classID = (RsA3DClassID)stream->loadU32();
+    if(classID != RS_A3D_CLASS_ID_ALLOCATION) {
         LOGE("allocation loading skipped due to invalid class id\n");
         return NULL;
     }
diff --git a/libs/rs/rsAllocation.h b/libs/rs/rsAllocation.h
index 84a7c85..a408a57 100644
--- a/libs/rs/rsAllocation.h
+++ b/libs/rs/rsAllocation.h
@@ -73,7 +73,7 @@ public:
 
     virtual void dumpLOGV(const char *prefix) const;
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_ALLOCATION; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ALLOCATION; }
     static Allocation *createFromStream(Context *rsc, IStream *stream);
 
     virtual void uploadCheck(const Context *rsc);
diff --git a/libs/rs/rsAnimation.h b/libs/rs/rsAnimation.h
index ed92c1a..340314e 100644
--- a/libs/rs/rsAnimation.h
+++ b/libs/rs/rsAnimation.h
@@ -36,9 +36,9 @@ public:
                               RsAnimationEdge pre, RsAnimationEdge post);
 
     float eval(float) const;
-    
+
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_ANIMATION; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ANIMATION; }
     static Animation *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsElement.cpp b/libs/rs/rsElement.cpp
index 3b18c98..8fbf004 100644
--- a/libs/rs/rsElement.cpp
+++ b/libs/rs/rsElement.cpp
@@ -109,8 +109,8 @@ void Element::serialize(OStream *stream) const
 Element *Element::createFromStream(Context *rsc, IStream *stream)
 {
     // First make sure we are reading the correct object
-    A3DClassID classID = (A3DClassID)stream->loadU32();
-    if(classID != A3D_CLASS_ID_ELEMENT) {
+    RsA3DClassID classID = (RsA3DClassID)stream->loadU32();
+    if(classID != RS_A3D_CLASS_ID_ELEMENT) {
         LOGE("element loading skipped due to invalid class id\n");
         return NULL;
     }
diff --git a/libs/rs/rsElement.h b/libs/rs/rsElement.h
index a3025539..5c4f5c4 100644
--- a/libs/rs/rsElement.h
+++ b/libs/rs/rsElement.h
@@ -60,7 +60,7 @@ public:
 
     void dumpLOGV(const char *prefix) const;
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_ELEMENT; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ELEMENT; }
     static Element *createFromStream(Context *rsc, IStream *stream);
 
     static const Element * create(Context *rsc, RsDataType dt, RsDataKind dk,
diff --git a/libs/rs/rsFileA3D.cpp b/libs/rs/rsFileA3D.cpp
index b88f7b0..23c0cf5 100644
--- a/libs/rs/rsFileA3D.cpp
+++ b/libs/rs/rsFileA3D.cpp
@@ -29,11 +29,8 @@
 using namespace android;
 using namespace android::renderscript;
 
-
-
-FileA3D::FileA3D()
+FileA3D::FileA3D(Context *rsc) : ObjectBase(rsc)
 {
-    mRsc = NULL;
     mAlloc = NULL;
     mData = NULL;
     mWriteStream = NULL;
@@ -63,7 +60,110 @@ FileA3D::~FileA3D()
     }
 }
 
-bool FileA3D::load(Context *rsc, FILE *f)
+void FileA3D::parseHeader(IStream *headerStream)
+{
+    mMajorVersion = headerStream->loadU32();
+    mMinorVersion = headerStream->loadU32();
+    uint32_t flags = headerStream->loadU32();
+    mUse64BitOffsets = (flags & 1) != 0;
+
+    LOGE("file open 64bit = %i", mUse64BitOffsets);
+
+    uint32_t numIndexEntries = headerStream->loadU32();
+    for(uint32_t i = 0; i < numIndexEntries; i ++) {
+        A3DIndexEntry *entry = new A3DIndexEntry();
+        headerStream->loadString(&entry->mObjectName);
+        LOGE("Header data, entry name = %s", entry->mObjectName.string());
+        entry->mType = (RsA3DClassID)headerStream->loadU32();
+        if(mUse64BitOffsets){
+            entry->mOffset = headerStream->loadOffset();
+            entry->mLength = headerStream->loadOffset();
+        }
+        else {
+            entry->mOffset = headerStream->loadU32();
+            entry->mLength = headerStream->loadU32();
+        }
+        entry->mRsObj = NULL;
+        mIndex.push(entry);
+    }
+}
+
+bool FileA3D::load(const void *data, size_t length)
+{
+    LOGE("Loading data. Size: %u", length);
+    const uint8_t *localData = (const uint8_t *)data;
+
+    size_t lengthRemaining = length;
+    size_t magicStrLen = 12;
+    if ((length < magicStrLen) ||
+        memcmp(data, "Android3D_ff", magicStrLen)) {
+        return false;
+    }
+
+    localData += magicStrLen;
+    lengthRemaining -= magicStrLen;
+
+    // Next we get our header size
+    uint64_t headerSize = 0;
+    if(lengthRemaining < sizeof(headerSize)) {
+        return false;
+    }
+
+    memcpy(&headerSize, localData, sizeof(headerSize));
+    localData += sizeof(headerSize);
+    lengthRemaining -= sizeof(headerSize);
+
+    LOGE("Loading data, headerSize = %lli", headerSize);
+
+    if(lengthRemaining < headerSize) {
+        return false;
+    }
+
+    uint8_t *headerData = (uint8_t *)malloc(headerSize);
+    if(!headerData) {
+        return false;
+    }
+
+    memcpy(headerData, localData, headerSize);
+
+    // Now open the stream to parse the header
+    IStream headerStream(headerData, false);
+    parseHeader(&headerStream);
+
+    free(headerData);
+
+    localData += headerSize;
+    lengthRemaining -= headerSize;
+
+    if(lengthRemaining < sizeof(mDataSize)) {
+        return false;
+    }
+
+    // Read the size of the data
+    memcpy(&mDataSize, localData, sizeof(mDataSize));
+    localData += sizeof(mDataSize);
+    lengthRemaining -= sizeof(mDataSize);
+
+    LOGE("Loading data, mDataSize = %lli", mDataSize);
+
+    if(lengthRemaining < mDataSize) {
+        return false;
+    }
+
+    // We should know enough to read the file in at this point.
+    mAlloc = malloc(mDataSize);
+    if (!mAlloc) {
+        return false;
+    }
+    mData = (uint8_t *)mAlloc;
+    memcpy(mAlloc, localData, mDataSize);
+
+    mReadStream = new IStream(mData, mUse64BitOffsets);
+
+    return true;
+}
+
+bool FileA3D::load(FILE *f)
 {
     char magicString[12];
     size_t len;
@@ -94,28 +194,9 @@ bool FileA3D::load(Context *rsc, FILE *f)
 
     // Now open the stream to parse the header
     IStream headerStream(headerData, false);
+    parseHeader(&headerStream);
 
-    mMajorVersion = headerStream.loadU32();
-    mMinorVersion = headerStream.loadU32();
-    uint32_t flags = headerStream.loadU32();
-    mUse64BitOffsets = (flags & 1) != 0;
-
-    LOGE("file open 64bit = %i", mUse64BitOffsets);
-
-    uint32_t numIndexEntries = headerStream.loadU32();
-    for(uint32_t i = 0; i < numIndexEntries; i ++) {
-        A3DIndexEntry *entry = new A3DIndexEntry();
-        headerStream.loadString(&entry->mID);
-        entry->mType = (A3DClassID)headerStream.loadU32();
-        if(mUse64BitOffsets){
-            entry->mOffset = headerStream.loadOffset();
-        }
-        else {
-            entry->mOffset = headerStream.loadU32();
-        }
-        entry->mRsObj = NULL;
-        mIndex.push(entry);
-    }
+    free(headerData);
 
     // Next thing is the size of the header
     len = fread(&mDataSize, 1, sizeof(mDataSize), f);
@@ -138,65 +219,90 @@ bool FileA3D::load(Context *rsc, FILE *f)
 
     mReadStream = new IStream(mData, mUse64BitOffsets);
 
-    mRsc = rsc;
-
     LOGE("Header is read an stream initialized");
     return true;
 }
 
-size_t FileA3D::getNumLoadedEntries() const {
+size_t FileA3D::getNumIndexEntries() const {
     return mIndex.size();
 }
 
-const FileA3D::A3DIndexEntry *FileA3D::getLoadedEntry(size_t index) const {
+const FileA3D::A3DIndexEntry *FileA3D::getIndexEntry(size_t index) const {
     if(index < mIndex.size()) {
         return mIndex[index];
     }
     return NULL;
 }
 
-ObjectBase *FileA3D::initializeFromEntry(const FileA3D::A3DIndexEntry *entry) {
+ObjectBase *FileA3D::initializeFromEntry(size_t index) {
+    if(index >= mIndex.size()) {
+        return NULL;
+    }
+
+    FileA3D::A3DIndexEntry *entry = mIndex[index];
     if(!entry) {
         return NULL;
     }
 
+    if(entry->mRsObj) {
+        entry->mRsObj->incUserRef();
+        return entry->mRsObj;
+    }
+
     // Seek to the beginning of object
     mReadStream->reset(entry->mOffset);
     switch (entry->mType) {
-        case A3D_CLASS_ID_UNKNOWN:
+        case RS_A3D_CLASS_ID_UNKNOWN:
             return NULL;
-        case A3D_CLASS_ID_MESH:
-            return Mesh::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_SIMPLE_MESH:
-            return SimpleMesh::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_TYPE:
-            return Type::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_ELEMENT:
-            return Element::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_ALLOCATION:
-            return Allocation::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_PROGRAM_VERTEX:
-            return ProgramVertex::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_PROGRAM_RASTER:
-            return ProgramRaster::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_PROGRAM_FRAGMENT:
-            return ProgramFragment::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_PROGRAM_STORE:
-            return ProgramStore::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_SAMPLER:
-            return Sampler::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_ANIMATION:
-            return Animation::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_LIGHT:
-            return Light::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_ADAPTER_1D:
-            return Adapter1D::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_ADAPTER_2D:
-            return Adapter2D::createFromStream(mRsc, mReadStream);
-        case A3D_CLASS_ID_SCRIPT_C:
+        case RS_A3D_CLASS_ID_MESH:
+            entry->mRsObj = Mesh::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_SIMPLE_MESH:
+            entry->mRsObj = SimpleMesh::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_TYPE:
+            entry->mRsObj = Type::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_ELEMENT:
+            entry->mRsObj = Element::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_ALLOCATION:
+            entry->mRsObj = Allocation::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_PROGRAM_VERTEX:
+            entry->mRsObj = ProgramVertex::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_PROGRAM_RASTER:
+            entry->mRsObj = ProgramRaster::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_PROGRAM_FRAGMENT:
+            entry->mRsObj = ProgramFragment::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_PROGRAM_STORE:
+            entry->mRsObj = ProgramStore::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_SAMPLER:
+            entry->mRsObj = Sampler::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_ANIMATION:
+            entry->mRsObj = Animation::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_LIGHT:
+            entry->mRsObj = Light::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_ADAPTER_1D:
+            entry->mRsObj = Adapter1D::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_ADAPTER_2D:
+            entry->mRsObj = Adapter2D::createFromStream(mRSC, mReadStream);
+            break;
+        case RS_A3D_CLASS_ID_SCRIPT_C:
             return NULL;
     }
-    return NULL;
+    if(entry->mRsObj) {
+        entry->mRsObj->incUserRef();
+    }
+    return entry->mRsObj;
 }
 
 bool FileA3D::writeFile(const char *filename)
@@ -226,14 +332,17 @@ bool FileA3D::writeFile(const char *filename)
     uint32_t writeIndexSize = mWriteIndex.size();
     headerStream.addU32(writeIndexSize);
     for(uint32_t i = 0; i < writeIndexSize; i ++) {
-        headerStream.addString(&mWriteIndex[i]->mID);
+        headerStream.addString(&mWriteIndex[i]->mObjectName);
         headerStream.addU32((uint32_t)mWriteIndex[i]->mType);
         if(mUse64BitOffsets){
             headerStream.addOffset(mWriteIndex[i]->mOffset);
+            headerStream.addOffset(mWriteIndex[i]->mLength);
         }
         else {
             uint32_t offset = (uint32_t)mWriteIndex[i]->mOffset;
             headerStream.addU32(offset);
+            offset = (uint32_t)mWriteIndex[i]->mLength;
+            headerStream.addU32(offset);
         }
     }
 
@@ -273,26 +382,93 @@ void FileA3D::appendToFile(ObjectBase *obj) {
         mWriteStream = new OStream(initialStreamSize, false);
     }
     A3DIndexEntry *indexEntry = new A3DIndexEntry();
-    indexEntry->mID.setTo(obj->getName());
+    indexEntry->mObjectName.setTo(obj->getName());
     indexEntry->mType = obj->getClassId();
     indexEntry->mOffset = mWriteStream->getPos();
-    indexEntry->mRsObj = (void*)obj;
+    indexEntry->mRsObj = obj;
     mWriteIndex.push(indexEntry);
     obj->serialize(mWriteStream);
+    indexEntry->mLength = mWriteStream->getPos() - indexEntry->mOffset;
+    mWriteStream->align(4);
 }
 
 namespace android {
 namespace renderscript {
 
+void rsi_FileA3DGetNumIndexEntries(Context *rsc, int32_t *numEntries, RsFile file)
+{
+    FileA3D *fa3d = static_cast<FileA3D *>(file);
+
+    if(fa3d) {
+        *numEntries = fa3d->getNumIndexEntries();
+    }
+    else {
+        *numEntries = 0;
+    }
+}
+
+void rsi_FileA3DGetIndexEntries(Context *rsc, RsFileIndexEntry *fileEntries, uint32_t numEntries, RsFile file)
+{
+    FileA3D *fa3d = static_cast<FileA3D *>(file);
+
+    if(!fa3d) {
+        LOGE("Can't load index entries. No valid file");
+        return;
+    }
+
+    uint32_t numFileEntries = fa3d->getNumIndexEntries();
+    if(numFileEntries != numEntries || numEntries == 0 || fileEntries == NULL) {
+        LOGE("Can't load index entries. Invalid number requested");
+        return;
+    }
+
+    for(uint32_t i = 0; i < numFileEntries; i ++) {
+        const FileA3D::A3DIndexEntry *entry = fa3d->getIndexEntry(i);
+        fileEntries[i].classID = entry->getType();
+        fileEntries[i].objectName = entry->getObjectName().string();
+    }
+
+}
+
+RsObjectBase rsi_FileA3DGetEntryByIndex(Context *rsc, uint32_t index, RsFile file)
+{
+    FileA3D *fa3d = static_cast<FileA3D *>(file);
+    if(!fa3d) {
+        LOGE("Can't load entry. No valid file");
+        return NULL;
+    }
+
+    ObjectBase *obj = fa3d->initializeFromEntry(index);
+    LOGE("Returning object with name %s", obj->getName());
+
+    return obj;
+}
+
+RsFile rsi_FileA3DCreateFromAssetStream(Context *rsc, const void *data, uint32_t len)
+{
+    if (data == NULL) {
+        LOGE("File load failed. Asset stream is NULL");
+        return NULL;
+    }
+
+    FileA3D *fa3d = new FileA3D(rsc);
+
+    fa3d->load(data, len);
+    fa3d->incUserRef();
+
+    return fa3d;
+}
+
 
 RsFile rsi_FileOpen(Context *rsc, char const *path, unsigned int len)
 {
-    FileA3D *fa3d = new FileA3D;
+    FileA3D *fa3d = new FileA3D(rsc);
 
     FILE *f = fopen("/sdcard/test.a3d", "rb");
     if (f) {
-        fa3d->load(rsc, f);
+        fa3d->load(f);
         fclose(f);
+        fa3d->incUserRef();
         return fa3d;
     }
     delete fa3d;
diff --git a/libs/rs/rsFileA3D.h b/libs/rs/rsFileA3D.h
index e744291..b985907 100644
--- a/libs/rs/rsFileA3D.h
+++ b/libs/rs/rsFileA3D.h
@@ -18,21 +18,23 @@
 #define ANDROID_RS_FILE_A3D_H
 
 #include "RenderScript.h"
-#include "rsFileA3DDecls.h"
 #include "rsMesh.h"
 
 #include <utils/String8.h>
 #include "rsStream.h"
 #include <stdio.h>
 
+#define A3D_MAGIC_KEY "Android3D_ff"
+
 // ---------------------------------------------------------------------------
 namespace android {
+
 namespace renderscript {
 
-class FileA3D
+class FileA3D : public ObjectBase
 {
 public:
-    FileA3D();
+    FileA3D(Context *rsc);
     ~FileA3D();
 
     uint32_t mMajorVersion;
@@ -41,27 +43,47 @@ public:
     uint64_t mStringTableOffset;
     bool mUse64BitOffsets;
 
-    struct A3DIndexEntry {
-        String8 mID;
-        A3DClassID mType;
+    class A3DIndexEntry {
+        String8 mObjectName;
+        RsA3DClassID mType;
         uint64_t mOffset;
-        void * mRsObj;
+        uint64_t mLength;
+        ObjectBase *mRsObj;
+    public:
+        friend class FileA3D;
+        const String8 &getObjectName() const {
+            return mObjectName;
+        }
+        RsA3DClassID getType() const {
+            return mType;
+        }
     };
 
-    bool load(Context *rsc, FILE *f);
-    size_t getNumLoadedEntries() const;
-    const A3DIndexEntry* getLoadedEntry(size_t index) const;
-    ObjectBase *initializeFromEntry(const A3DIndexEntry *entry);
+    bool load(FILE *f);
+    bool load(const void *data, size_t length);
+
+    size_t getNumIndexEntries() const;
+    const A3DIndexEntry* getIndexEntry(size_t index) const;
+    ObjectBase *initializeFromEntry(size_t index);
 
     void appendToFile(ObjectBase *obj);
     bool writeFile(const char *filename);
 
+    // Currently files do not get serialized,
+    // but we need to inherit from ObjectBase for ref tracking
+    virtual void serialize(OStream *stream) const {
+    }
+    virtual RsA3DClassID getClassId() const {
+        return RS_A3D_CLASS_ID_UNKNOWN;
+    }
+
 protected:
 
+    void parseHeader(IStream *headerStream);
+
     const uint8_t * mData;
     void * mAlloc;
     uint64_t mDataSize;
-    Context * mRsc;
 
     OStream *mWriteStream;
     Vector<A3DIndexEntry*> mWriteIndex;
diff --git a/libs/rs/rsFileA3DDecls.h b/libs/rs/rsFileA3DDecls.h
deleted file mode 100644
index b752442..0000000
--- a/libs/rs/rsFileA3DDecls.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ANDROID_RS_FILE_A3D_DECLS_H
-#define ANDROID_RS_FILE_A3D_DECLS_H
-
-
-#define A3D_MAGIC_KEY "Android3D_ff"
-
-namespace android {
-namespace renderscript {
-
-    enum A3DClassID {
-        A3D_CLASS_ID_UNKNOWN,
-        A3D_CLASS_ID_MESH,
-        A3D_CLASS_ID_SIMPLE_MESH,
-        A3D_CLASS_ID_TYPE,
-        A3D_CLASS_ID_ELEMENT,
-        A3D_CLASS_ID_ALLOCATION,
-        A3D_CLASS_ID_PROGRAM_VERTEX,
-        A3D_CLASS_ID_PROGRAM_RASTER,
-        A3D_CLASS_ID_PROGRAM_FRAGMENT,
-        A3D_CLASS_ID_PROGRAM_STORE,
-        A3D_CLASS_ID_SAMPLER,
-        A3D_CLASS_ID_ANIMATION,
-        A3D_CLASS_ID_LIGHT,
-        A3D_CLASS_ID_ADAPTER_1D,
-        A3D_CLASS_ID_ADAPTER_2D,
-        A3D_CLASS_ID_SCRIPT_C
-    };
-
-
-}
-}
-#endif //ANDROID_RS_FILE_A3D_H
-
-
-
diff --git a/libs/rs/rsLight.h b/libs/rs/rsLight.h
index 4216052..bd58979 100644
--- a/libs/rs/rsLight.h
+++ b/libs/rs/rsLight.h
@@ -38,7 +38,7 @@ public:
 
     void setupGL(uint32_t num) const;
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_LIGHT; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_LIGHT; }
     static Light *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsMesh.cpp b/libs/rs/rsMesh.cpp
index b51e28a..bd9cd27 100644
--- a/libs/rs/rsMesh.cpp
+++ b/libs/rs/rsMesh.cpp
@@ -107,8 +107,8 @@ void Mesh::serialize(OStream *stream) const
 Mesh *Mesh::createFromStream(Context *rsc, IStream *stream)
 {
     // First make sure we are reading the correct object
-    A3DClassID classID = (A3DClassID)stream->loadU32();
-    if(classID != A3D_CLASS_ID_MESH) {
+    RsA3DClassID classID = (RsA3DClassID)stream->loadU32();
+    if(classID != RS_A3D_CLASS_ID_MESH) {
         LOGE("mesh loading skipped due to invalid class id");
         return NULL;
     }
diff --git a/libs/rs/rsMesh.h b/libs/rs/rsMesh.h
index e3edf52..8c7e8a4 100644
--- a/libs/rs/rsMesh.h
+++ b/libs/rs/rsMesh.h
@@ -70,9 +70,9 @@ public:
 
     void analyzeElement();
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_MESH; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_MESH; }
     static Mesh *createFromStream(Context *rsc, IStream *stream);
-    
+
 protected:
 };
 
diff --git a/libs/rs/rsObjectBase.h b/libs/rs/rsObjectBase.h
index f423232..ad95b81 100644
--- a/libs/rs/rsObjectBase.h
+++ b/libs/rs/rsObjectBase.h
@@ -54,7 +54,7 @@ public:
 
     virtual void dumpLOGV(const char *prefix) const;
     virtual void serialize(OStream *stream) const = 0;
-    virtual A3DClassID getClassId() const = 0;
+    virtual RsA3DClassID getClassId() const = 0;
 
 protected:
     const char *mAllocFile;
diff --git a/libs/rs/rsProgramFragment.h b/libs/rs/rsProgramFragment.h
index 68593b5..e5bbe1b 100644
--- a/libs/rs/rsProgramFragment.h
+++ b/libs/rs/rsProgramFragment.h
@@ -41,7 +41,7 @@ public:
     virtual void loadShader(Context *rsc);
     virtual void init(Context *rsc);
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_PROGRAM_FRAGMENT; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_PROGRAM_FRAGMENT; }
     static ProgramFragment *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsProgramRaster.h b/libs/rs/rsProgramRaster.h
index 477208c..79b1475 100644
--- a/libs/rs/rsProgramRaster.h
+++ b/libs/rs/rsProgramRaster.h
@@ -37,7 +37,7 @@ public:
     virtual void setupGL(const Context *, ProgramRasterState *);
     virtual void setupGL2(const Context *, ProgramRasterState *);
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_PROGRAM_RASTER; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_PROGRAM_RASTER; }
     static ProgramRaster *createFromStream(Context *rsc, IStream *stream);
 
     void setLineWidth(float w);
diff --git a/libs/rs/rsProgramStore.h b/libs/rs/rsProgramStore.h
index c6c312f..fe8d78e 100644
--- a/libs/rs/rsProgramStore.h
+++ b/libs/rs/rsProgramStore.h
@@ -44,7 +44,7 @@ public:
     void setDitherEnable(bool);
 
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_PROGRAM_STORE; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_PROGRAM_STORE; }
     static ProgramStore *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsProgramVertex.h b/libs/rs/rsProgramVertex.h
index 734fabd..cb93eaf 100644
--- a/libs/rs/rsProgramVertex.h
+++ b/libs/rs/rsProgramVertex.h
@@ -53,7 +53,7 @@ public:
     virtual void init(Context *);
 
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_PROGRAM_VERTEX; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_PROGRAM_VERTEX; }
     static ProgramVertex *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsSampler.h b/libs/rs/rsSampler.h
index 1742111..3786439 100644
--- a/libs/rs/rsSampler.h
+++ b/libs/rs/rsSampler.h
@@ -45,9 +45,9 @@ public:
 
     void bindToContext(SamplerState *, uint32_t slot);
     void unbindFromContext(SamplerState *);
-    
+
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_SAMPLER; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_SAMPLER; }
     static Sampler *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsScriptC.h b/libs/rs/rsScriptC.h
index a144234..50e8a4c 100644
--- a/libs/rs/rsScriptC.h
+++ b/libs/rs/rsScriptC.h
@@ -61,9 +61,8 @@ public:
     virtual void runForEach(Context *rsc, const Allocation *ain, Allocation *aout, uint32_t xStart, uint32_t xEnd);
     virtual void runForEach(Context *rsc, const Allocation *ain, Allocation *aout, uint32_t xStart, uint32_t yStart, uint32_t xEnd, uint32_t yEnd);
 
-
     virtual void serialize(OStream *stream) const {    }
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_SCRIPT_C; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_SCRIPT_C; }
     static Type *createFromStream(Context *rsc, IStream *stream) { return NULL; }
 
 protected:
diff --git a/libs/rs/rsSimpleMesh.cpp b/libs/rs/rsSimpleMesh.cpp
index 2dd082d..5eb4b80 100644
--- a/libs/rs/rsSimpleMesh.cpp
+++ b/libs/rs/rsSimpleMesh.cpp
@@ -48,15 +48,18 @@ SimpleMesh::~SimpleMesh()
 void SimpleMesh::render(Context *rsc) const
 {
     if (mPrimitiveType.get()) {
+        LOGE("Rendering primitive");
         renderRange(rsc, 0, mPrimitiveType->getDimX());
         return;
     }
 
     if (mIndexType.get()) {
+        LOGE("Rendering index");
         renderRange(rsc, 0, mIndexType->getDimX());
         return;
     }
 
+    LOGE("Rendering non-indexed");
     renderRange(rsc, 0, mVertexTypes[0]->getDimX());
 }
 
@@ -150,8 +153,8 @@ void SimpleMesh::serialize(OStream *stream) const
 SimpleMesh *SimpleMesh::createFromStream(Context *rsc, IStream *stream)
 {
     // First make sure we are reading the correct object
-    A3DClassID classID = (A3DClassID)stream->loadU32();
-    if(classID != A3D_CLASS_ID_SIMPLE_MESH) {
+    RsA3DClassID classID = (RsA3DClassID)stream->loadU32();
+    if(classID != RS_A3D_CLASS_ID_SIMPLE_MESH) {
         LOGE("simple mesh loading skipped due to invalid class id");
         return NULL;
     }
@@ -189,6 +192,25 @@ SimpleMesh *SimpleMesh::createFromStream(Context *rsc, IStream *stream)
         }
     }
 
+    LOGE("Triangles: %u", indexType->getDimX()/3);
+    uint16_t *indices = (uint16_t*)indexAlloc->getPtr();
+    for(uint32_t i = 0; i < indexType->getDimX(); i += 3) {
+        LOGE("T: %.2u %.2u %2.u", indices[i], indices[i+1], indices[i+2]);
+    }
+
+    uint32_t numVerts = mesh->mVertexTypes[0]->getDimX();
+    LOGE("Vertices: %u", numVerts);
+    float *verts = (float*)mesh->mVertexBuffers[0]->getPtr();
+
+    for(uint32_t i = 0; i < numVerts; i ++) {
+
+        LOGE("Vpnt: %+4.2f %+4.2f %+4.2f %+4.2f %+4.2f %+4.2f %+4.2f %+4.2f", verts[8*i], verts[8*i+1], verts[8*i+2],
+                                                                                    verts[8*i+3], verts[8*i+4], verts[8*i+5],
+                                                                                    verts[8*i+6], verts[8*i+7] );
+    }
+
+    mesh->uploadAll(rsc);
+
     return mesh;
 }
 
diff --git a/libs/rs/rsSimpleMesh.h b/libs/rs/rsSimpleMesh.h
index 94e6a26..362c7fb 100644
--- a/libs/rs/rsSimpleMesh.h
+++ b/libs/rs/rsSimpleMesh.h
@@ -49,9 +49,9 @@ public:
     void renderRange(Context *, uint32_t start, uint32_t len) const;
     void uploadAll(Context *);
     void updateGLPrimitive();
-    
+
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_SIMPLE_MESH; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_SIMPLE_MESH; }
     static SimpleMesh *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsStream.cpp b/libs/rs/rsStream.cpp
index 03827dce..39874a9 100644
--- a/libs/rs/rsStream.cpp
+++ b/libs/rs/rsStream.cpp
@@ -53,10 +53,9 @@ uint64_t IStream::loadOffset()
 
 void IStream::loadString(String8 *s)
 {
-    LOGE("loadString");
     uint32_t len = loadU32();
-    LOGE("loadString len %i", len);
     s->setTo((const char *)&mData[mPos], len);
+    LOGE("loadString %s", s->string());
     mPos += len;
 }
 
diff --git a/libs/rs/rsStream.h b/libs/rs/rsStream.h
index 5ccd6ca..d401cd1 100644
--- a/libs/rs/rsStream.h
+++ b/libs/rs/rsStream.h
@@ -86,6 +86,13 @@ public:
     OStream(uint64_t length, bool use64);
     ~OStream();
     
+    void align(uint32_t bytes) {
+        mPos = (mPos + (bytes - 1)) & (~(bytes - 1));
+        if(mPos >= mLength) {
+            growSize();
+        }
+    }
+    
     void addF(float v) {
         uint32_t uintV = *reinterpret_cast<uint32_t*> (&v);
         addU32(uintV);
diff --git a/libs/rs/rsType.cpp b/libs/rs/rsType.cpp
index 89e73b0..75abc76 100644
--- a/libs/rs/rsType.cpp
+++ b/libs/rs/rsType.cpp
@@ -200,8 +200,8 @@ void Type::serialize(OStream *stream) const
 Type *Type::createFromStream(Context *rsc, IStream *stream)
 {
     // First make sure we are reading the correct object
-    A3DClassID classID = (A3DClassID)stream->loadU32();
-    if(classID != A3D_CLASS_ID_TYPE) {
+    RsA3DClassID classID = (RsA3DClassID)stream->loadU32();
+    if(classID != RS_A3D_CLASS_ID_TYPE) {
         LOGE("type loading skipped due to invalid class id\n");
         return NULL;
     }
diff --git a/libs/rs/rsType.h b/libs/rs/rsType.h
index f598f64..5b51e20 100644
--- a/libs/rs/rsType.h
+++ b/libs/rs/rsType.h
@@ -74,7 +74,7 @@ public:
 
     void dumpLOGV(const char *prefix) const;
     virtual void serialize(OStream *stream) const;
-    virtual A3DClassID getClassId() const { return A3D_CLASS_ID_TYPE; }
+    virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_TYPE; }
     static Type *createFromStream(Context *rsc, IStream *stream);
 
 protected:
diff --git a/libs/rs/rsUtils.h b/libs/rs/rsUtils.h
index 7ea3b61..b0eb520 100644
--- a/libs/rs/rsUtils.h
+++ b/libs/rs/rsUtils.h
@@ -23,7 +23,6 @@
 #include <utils/Log.h>
 
 #include "rsStream.h"
-#include "rsFileA3DDecls.h"
 
 #include <utils/String8.h>
 #include <utils/Vector.h>