diff --git a/graphics/java/android/renderscript/Allocation.java b/graphics/java/android/renderscript/Allocation.java
index 4b8c58e..9ac1a00 100644
--- a/graphics/java/android/renderscript/Allocation.java
+++ b/graphics/java/android/renderscript/Allocation.java
@@ -99,6 +99,14 @@
      */
     public static final int USAGE_GRAPHICS_CONSTANTS = 0x0008;
 
+    /**
+     * @hide
+     * USAGE_GRAPHICS_RENDER_TARGET The allcation will be used as a
+     * target for offscreen rendering
+     *
+     */
+    public static final int USAGE_GRAPHICS_RENDER_TARGET = 0x0010;
+
 
     /**
      * Controls mipmap behavior when using the bitmap creation and
@@ -137,7 +145,8 @@
         if ((usage & ~(USAGE_SCRIPT |
                        USAGE_GRAPHICS_TEXTURE |
                        USAGE_GRAPHICS_VERTEX |
-                       USAGE_GRAPHICS_CONSTANTS)) != 0) {
+                       USAGE_GRAPHICS_CONSTANTS |
+                       USAGE_GRAPHICS_RENDER_TARGET)) != 0) {
             throw new RSIllegalArgumentException("Unknown usage specified.");
         }
         mType = t;
diff --git a/graphics/java/android/renderscript/Element.java b/graphics/java/android/renderscript/Element.java
index fae22f0..0c1ad2a 100644
--- a/graphics/java/android/renderscript/Element.java
+++ b/graphics/java/android/renderscript/Element.java
@@ -124,7 +124,8 @@
         PIXEL_A (8),
         PIXEL_LA (9),
         PIXEL_RGB (10),
-        PIXEL_RGBA (11);
+        PIXEL_RGBA (11),
+        PIXEL_DEPTH (12);
 
         int mID;
         DataKind(int id) {
@@ -536,10 +537,12 @@
               dk == DataKind.PIXEL_A ||
               dk == DataKind.PIXEL_LA ||
               dk == DataKind.PIXEL_RGB ||
-              dk == DataKind.PIXEL_RGBA)) {
+              dk == DataKind.PIXEL_RGBA ||
+              dk == DataKind.PIXEL_DEPTH)) {
             throw new RSIllegalArgumentException("Unsupported DataKind");
         }
         if (!(dt == DataType.UNSIGNED_8 ||
+              dt == DataType.UNSIGNED_16 ||
               dt == DataType.UNSIGNED_5_6_5 ||
               dt == DataType.UNSIGNED_4_4_4_4 ||
               dt == DataType.UNSIGNED_5_5_5_1)) {
@@ -554,16 +557,25 @@
         if (dt == DataType.UNSIGNED_4_4_4_4 && dk != DataKind.PIXEL_RGBA) {
             throw new RSIllegalArgumentException("Bad kind and type combo");
         }
+        if (dt == DataType.UNSIGNED_16 &&
+            dk != DataKind.PIXEL_DEPTH) {
+            throw new RSIllegalArgumentException("Bad kind and type combo");
+        }
 
         int size = 1;
-        if (dk == DataKind.PIXEL_LA) {
+        switch (dk) {
+        case PIXEL_LA:
             size = 2;
-        }
-        if (dk == DataKind.PIXEL_RGB) {
+            break;
+        case PIXEL_RGB:
             size = 3;
-        }
-        if (dk == DataKind.PIXEL_RGBA) {
+            break;
+        case PIXEL_RGBA:
             size = 4;
+            break;
+        case PIXEL_DEPTH:
+            size = 2;
+            break;
         }
 
         boolean norm = true;
diff --git a/libs/rs/Android.mk b/libs/rs/Android.mk
index 14152d8..9100693 100644
--- a/libs/rs/Android.mk
+++ b/libs/rs/Android.mk
@@ -90,6 +90,7 @@
 	rsContext.cpp \
 	rsDevice.cpp \
 	rsElement.cpp \
+	rsFBOCache.cpp \
 	rsFileA3D.cpp \
 	rsFont.cpp \
 	rsLocklessFifo.cpp \
diff --git a/libs/rs/RenderScriptDefines.h b/libs/rs/RenderScriptDefines.h
index 4e1ac88..bb275b52 100644
--- a/libs/rs/RenderScriptDefines.h
+++ b/libs/rs/RenderScriptDefines.h
@@ -84,6 +84,7 @@
     RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE = 0x0002,
     RS_ALLOCATION_USAGE_GRAPHICS_VERTEX = 0x0004,
     RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS = 0x0008,
+    RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET = 0x0010,
 
     RS_ALLOCATION_USAGE_ALL = 0x000F
 };
@@ -147,6 +148,7 @@
     RS_KIND_PIXEL_LA,
     RS_KIND_PIXEL_RGB,
     RS_KIND_PIXEL_RGBA,
+    RS_KIND_PIXEL_DEPTH,
 };
 
 enum RsSamplerParam {
diff --git a/libs/rs/rsAllocation.cpp b/libs/rs/rsAllocation.cpp
index b8ddb0b..6b37e03 100644
--- a/libs/rs/rsAllocation.cpp
+++ b/libs/rs/rsAllocation.cpp
@@ -56,7 +56,8 @@
 
     mTextureID = 0;
     mBufferID = 0;
-    mUploadDefered = false;
+    mRenderTargetID = 0;
+    mUploadDeferred = false;
 
     mUserBitmapCallback = NULL;
     mUserBitmapCallbackData = NULL;
@@ -93,6 +94,10 @@
         glDeleteTextures(1, &mTextureID);
         mTextureID = 0;
     }
+    if (mRenderTargetID) {
+        glDeleteRenderbuffers(1, &mRenderTargetID);
+        mRenderTargetID = 0;
+    }
 #endif //ANDROID_RS_SERIALIZE
 }
 
@@ -112,9 +117,14 @@
     return false;
 }
 
-void Allocation::deferedUploadToTexture(const Context *rsc) {
+void Allocation::deferredUploadToTexture(const Context *rsc) {
     mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE;
-    mUploadDefered = true;
+    mUploadDeferred = true;
+}
+
+void Allocation::deferredAllocateRenderTarget(const Context *rsc) {
+    mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET;
+    mUploadDeferred = true;
 }
 
 uint32_t Allocation::getGLTarget() const {
@@ -155,8 +165,11 @@
     if (getIsBufferObject()) {
         uploadToBufferObject(rsc);
     }
+    if (getIsRenderTarget() && !getIsTexture()) {
+        allocateRenderTarget(rsc);
+    }
 
-    mUploadDefered = false;
+    mUploadDeferred = false;
 }
 
 void Allocation::uploadToTexture(const Context *rsc) {
@@ -184,7 +197,7 @@
             // Force a crash to 1: restart the app, 2: make sure we get a bugreport.
             LOGE("Upload to texture failed to gen mTextureID");
             rsc->dumpDebug();
-            mUploadDefered = true;
+            mUploadDeferred = true;
             return;
         }
         isFirstUpload = true;
@@ -200,6 +213,32 @@
 #endif //ANDROID_RS_SERIALIZE
 }
 
+void Allocation::allocateRenderTarget(const Context *rsc) {
+#ifndef ANDROID_RS_SERIALIZE
+    mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET;
+
+    GLenum format = mHal.state.type->getElement()->getComponent().getGLFormat();
+    if (!format) {
+        return;
+    }
+
+    if (!mRenderTargetID) {
+        glGenRenderbuffers(1, &mRenderTargetID);
+
+        if (!mRenderTargetID) {
+            // This should generally not happen
+            LOGE("allocateRenderTarget failed to gen mRenderTargetID");
+            rsc->dumpDebug();
+            return;
+        }
+        glBindRenderbuffer(GL_RENDERBUFFER, mRenderTargetID);
+        glRenderbufferStorage(GL_RENDERBUFFER, format,
+                              mHal.state.type->getDimX(),
+                              mHal.state.type->getDimY());
+    }
+#endif //ANDROID_RS_SERIALIZE
+}
+
 #ifndef ANDROID_RS_SERIALIZE
 const static GLenum gFaceOrder[] = {
     GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -271,9 +310,9 @@
 #endif //ANDROID_RS_SERIALIZE
 }
 
-void Allocation::deferedUploadToBufferObject(const Context *rsc) {
+void Allocation::deferredUploadToBufferObject(const Context *rsc) {
     mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_VERTEX;
-    mUploadDefered = true;
+    mUploadDeferred = true;
 }
 
 void Allocation::uploadToBufferObject(const Context *rsc) {
@@ -288,7 +327,7 @@
     }
     if (!mBufferID) {
         LOGE("Upload to buffer object failed");
-        mUploadDefered = true;
+        mUploadDeferred = true;
         return;
     }
     GLenum target = (GLenum)getGLTarget();
@@ -300,7 +339,7 @@
 }
 
 void Allocation::uploadCheck(Context *rsc) {
-    if (mUploadDefered) {
+    if (mUploadDeferred) {
         syncAll(rsc, RS_ALLOCATION_USAGE_SCRIPT);
     }
 }
@@ -329,7 +368,7 @@
 
     memcpy(ptr, data, size);
     sendDirty();
-    mUploadDefered = true;
+    mUploadDeferred = true;
 }
 
 void Allocation::data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
@@ -362,7 +401,7 @@
             dst += destW * eSize;
         }
         sendDirty();
-        mUploadDefered = true;
+        mUploadDeferred = true;
     } else {
         update2DTexture(data, xoff, yoff, lod, face, w, h);
     }
@@ -407,7 +446,7 @@
 
     memcpy(ptr, data, sizeBytes);
     sendDirty();
-    mUploadDefered = true;
+    mUploadDeferred = true;
 }
 
 void Allocation::elementData(Context *rsc, uint32_t x, uint32_t y,
@@ -450,7 +489,7 @@
 
     memcpy(ptr, data, sizeBytes);
     sendDirty();
-    mUploadDefered = true;
+    mUploadDeferred = true;
 }
 
 void Allocation::addProgramToDirty(const Program *p) {
@@ -617,12 +656,12 @@
 
 void rsi_AllocationUploadToTexture(Context *rsc, RsAllocation va, bool genmip, uint32_t baseMipLevel) {
     Allocation *alloc = static_cast<Allocation *>(va);
-    alloc->deferedUploadToTexture(rsc);
+    alloc->deferredUploadToTexture(rsc);
 }
 
 void rsi_AllocationUploadToBufferObject(Context *rsc, RsAllocation va) {
     Allocation *alloc = static_cast<Allocation *>(va);
-    alloc->deferedUploadToBufferObject(rsc);
+    alloc->deferredUploadToBufferObject(rsc);
 }
 
 static void mip565(const Adapter2D &out, const Adapter2D &in) {
@@ -792,7 +831,6 @@
     return alloc;
 }
 
-
 RsAllocation rsaAllocationCreateFromBitmap(RsContext con, RsType vtype,
                                            RsAllocationMipmapControl mips,
                                            const void *data, uint32_t usages) {
@@ -811,7 +849,7 @@
         rsaAllocationGenerateScriptMips(rsc, texAlloc);
     }
 
-    texAlloc->deferedUploadToTexture(rsc);
+    texAlloc->deferredUploadToTexture(rsc);
     return texAlloc;
 }
 
@@ -852,7 +890,7 @@
         rsaAllocationGenerateScriptMips(rsc, texAlloc);
     }
 
-    texAlloc->deferedUploadToTexture(rsc);
+    texAlloc->deferredUploadToTexture(rsc);
     return texAlloc;
 }
 
diff --git a/libs/rs/rsAllocation.h b/libs/rs/rsAllocation.h
index e63140c..d334841 100644
--- a/libs/rs/rsAllocation.h
+++ b/libs/rs/rsAllocation.h
@@ -71,13 +71,17 @@
 
     void syncAll(Context *rsc, RsAllocationUsageType src);
 
-    void deferedUploadToTexture(const Context *rsc);
+    void deferredUploadToTexture(const Context *rsc);
     void uploadToTexture(const Context *rsc);
     uint32_t getTextureID() const {return mTextureID;}
 
+    void deferredAllocateRenderTarget(const Context *rsc);
+    void allocateRenderTarget(const Context *rsc);
+    uint32_t getRenderTargetID() const {return mRenderTargetID;}
+
     uint32_t getGLTarget() const;
 
-    void deferedUploadToBufferObject(const Context *rsc);
+    void deferredUploadToBufferObject(const Context *rsc);
     void uploadToBufferObject(const Context *rsc);
     uint32_t getBufferObjectID() const {return mBufferID;}
 
@@ -118,6 +122,9 @@
     bool getIsTexture() const {
         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) != 0;
     }
+    bool getIsRenderTarget() const {
+        return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) != 0;
+    }
     bool getIsBufferObject() const {
         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) != 0;
     }
@@ -161,7 +168,10 @@
     // is allowed.
     uint32_t mBufferID;
 
-    bool mUploadDefered;
+    // Is this a legal structure to be used as an FBO render target
+    uint32_t mRenderTargetID;
+
+    bool mUploadDeferred;
 
 private:
     void init(Context *rsc, const Type *);
diff --git a/libs/rs/rsComponent.cpp b/libs/rs/rsComponent.cpp
index 4c4987a..e2ae043 100644
--- a/libs/rs/rsComponent.cpp
+++ b/libs/rs/rsComponent.cpp
@@ -18,6 +18,7 @@
 
 #ifndef ANDROID_RS_SERIALIZE
 #include <GLES/gl.h>
+#include <GLES2/gl2.h>
 #endif
 
 using namespace android;
@@ -207,6 +208,7 @@
     case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA;
     case RS_KIND_PIXEL_RGB: return GL_RGB;
     case RS_KIND_PIXEL_RGBA: return GL_RGBA;
+    case RS_KIND_PIXEL_DEPTH: return GL_DEPTH_COMPONENT16;
     default: break;
     }
 #endif //ANDROID_RS_SERIALIZE
diff --git a/libs/rs/rsContext.cpp b/libs/rs/rsContext.cpp
index c761c75..d727ba1 100644
--- a/libs/rs/rsContext.cpp
+++ b/libs/rs/rsContext.cpp
@@ -409,6 +409,7 @@
     mFragment->setupGL2(this, &mStateFragment, &mShaderCache);
     mRaster->setupGL2(this, &mStateRaster);
     mVertex->setupGL2(this, &mStateVertex, &mShaderCache);
+    mFBOCache.setupGL2(this);
     return true;
 }
 
diff --git a/libs/rs/rsContext.h b/libs/rs/rsContext.h
index 72574a6..eacfdf7 100644
--- a/libs/rs/rsContext.h
+++ b/libs/rs/rsContext.h
@@ -38,6 +38,7 @@
 #include "rsProgramRaster.h"
 #include "rsProgramVertex.h"
 #include "rsShaderCache.h"
+#include "rsFBOCache.h"
 #include "rsVertexArray.h"
 
 #include "rsgApiStructs.h"
@@ -119,6 +120,7 @@
 
     ScriptCState mScriptC;
     ShaderCache mShaderCache;
+    FBOCache mFBOCache;
 
     void swapBuffers();
     void setRootScript(Script *);
diff --git a/libs/rs/rsFBOCache.cpp b/libs/rs/rsFBOCache.cpp
new file mode 100644
index 0000000..78aa8ce
--- /dev/null
+++ b/libs/rs/rsFBOCache.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsFBOCache.h"
+
+#include "rsContext.h"
+#include "rsAllocation.h"
+
+#ifndef ANDROID_RS_SERIALIZE
+#include <GLES/gl.h>
+#include <GLES2/gl2.h>
+#endif //ANDROID_RS_SERIALIZE
+
+using namespace android;
+using namespace android::renderscript;
+
+
+FBOCache::FBOCache() {
+    mFBOId = 0;
+    mDirty = false;
+    mMaxTargets = 1;
+    mColorTargets = new ObjectBaseRef<Allocation>[mMaxTargets];
+}
+
+FBOCache::~FBOCache() {
+    delete[] mColorTargets;
+#ifndef ANDROID_RS_SERIALIZE
+    if(mFBOId != 0) {
+        glDeleteFramebuffers(1, &mFBOId);
+    }
+#endif //ANDROID_RS_SERIALIZE
+}
+
+void FBOCache::bindColorTarget(Context *rsc, Allocation *a, uint32_t slot) {
+    if (slot >= mMaxTargets) {
+        LOGE("Invalid render target index");
+        return;
+    }
+    if (a != NULL) {
+        if (!a->getIsTexture()) {
+            LOGE("Invalid Color Target");
+            return;
+        }
+        if (a->getIsTexture()) {
+            if (a->getTextureID() == 0) {
+                a->deferredUploadToTexture(rsc);
+            }
+        } else if (a->getRenderTargetID() == 0) {
+            a->deferredAllocateRenderTarget(rsc);
+        }
+    }
+    mColorTargets[slot].set(a);
+    mDirty = true;
+}
+
+void FBOCache::bindDepthTarget(Context *rsc, Allocation *a) {
+    if (a != NULL) {
+        if (!a->getIsRenderTarget()) {
+            LOGE("Invalid Depth Target");
+            return;
+        }
+        if (a->getIsTexture()) {
+            if (a->getTextureID() == 0) {
+                a->deferredUploadToTexture(rsc);
+            }
+        } else if (a->getRenderTargetID() == 0) {
+            a->deferredAllocateRenderTarget(rsc);
+        }
+    }
+    mDepthTarget.set(a);
+    mDirty = true;
+}
+
+void FBOCache::resetAll(Context *) {
+    for (uint32_t i = 0; i < mMaxTargets; i ++) {
+        mColorTargets[i].set(NULL);
+    }
+    mDepthTarget.set(NULL);
+    mDirty = true;
+}
+
+bool FBOCache::renderToFramebuffer() {
+    if (mDepthTarget.get() != NULL) {
+        return false;
+    }
+
+    for (uint32_t i = 0; i < mMaxTargets; i ++) {
+        if (mColorTargets[i].get() != NULL) {
+            return false;
+        }
+    }
+    return true;
+}
+
+void FBOCache::checkError(Context *rsc) {
+    GLenum status;
+    status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    switch (status) {
+    case GL_FRAMEBUFFER_COMPLETE:
+        break;
+    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+        rsc->setError(RS_ERROR_BAD_VALUE,
+                      "Unable to set up render Target: RFRAMEBUFFER_INCOMPLETE_ATTACHMENT");
+        break;
+    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+        rsc->setError(RS_ERROR_BAD_VALUE,
+                      "Unable to set up render Target: GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT");
+        break;
+    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+        rsc->setError(RS_ERROR_BAD_VALUE,
+                      "Unable to set up render Target: GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS");
+        break;
+    case GL_FRAMEBUFFER_UNSUPPORTED:
+        rsc->setError(RS_ERROR_BAD_VALUE,
+                      "Unable to set up render Target: GL_FRAMEBUFFER_UNSUPPORTED");
+        break;
+    }
+}
+
+void FBOCache::setDepthAttachment(Context *rsc) {
+#ifndef ANDROID_RS_SERIALIZE
+    if (mDepthTarget.get() != NULL) {
+        mDepthTarget->uploadCheck(rsc);
+        if (mDepthTarget->getIsTexture()) {
+            uint32_t texID = mDepthTarget->getTextureID();
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                   GL_TEXTURE_2D, texID, 0);
+        } else {
+            uint32_t texID = mDepthTarget->getRenderTargetID();
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                      GL_RENDERBUFFER, texID);
+        }
+    } else {
+        // Reset last attachment
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                  GL_RENDERBUFFER, 0);
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                               GL_TEXTURE_2D, 0, 0);
+    }
+#endif //ANDROID_RS_SERIALIZE
+}
+
+void FBOCache::setColorAttachment(Context *rsc) {
+#ifndef ANDROID_RS_SERIALIZE
+    // Now attach color targets
+    for (uint32_t i = 0; i < mMaxTargets; i ++) {
+        uint32_t texID = 0;
+        if (mColorTargets[i].get() != NULL) {
+            mColorTargets[i]->uploadCheck(rsc);
+            if (mColorTargets[i]->getIsTexture()) {
+                uint32_t texID = mColorTargets[i]->getTextureID();
+                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                       GL_TEXTURE_2D, texID, 0);
+            } else {
+                uint32_t texID = mDepthTarget->getRenderTargetID();
+                glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                          GL_RENDERBUFFER, texID);
+            }
+        } else {
+            // Reset last attachment
+            glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                      GL_RENDERBUFFER, 0);
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i,
+                                   GL_TEXTURE_2D, 0, 0);
+        }
+    }
+#endif //ANDROID_RS_SERIALIZE
+}
+
+void FBOCache::setupGL2(Context *rsc) {
+#ifndef ANDROID_RS_SERIALIZE
+    if (!mDirty) {
+        return;
+    }
+
+    bool framebuffer = renderToFramebuffer();
+
+    if (!framebuffer) {
+        if(mFBOId == 0) {
+            glGenFramebuffers(1, &mFBOId);
+        }
+        glBindFramebuffer(GL_FRAMEBUFFER, mFBOId);
+
+        setDepthAttachment(rsc);
+        setColorAttachment(rsc);
+
+        glViewport(0, 0, mColorTargets[0]->getType()->getDimX(),
+                         mColorTargets[0]->getType()->getDimY());
+
+        checkError(rsc);
+    } else {
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        glViewport(0, 0, rsc->getWidth(), rsc->getHeight());
+    }
+#endif //ANDROID_RS_SERIALIZE
+}
diff --git a/libs/rs/rsFBOCache.h b/libs/rs/rsFBOCache.h
new file mode 100644
index 0000000..9a0a3b6
--- /dev/null
+++ b/libs/rs/rsFBOCache.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_FRAME_BUFFER_OBJECT_CACHE_H
+#define ANDROID_FRAME_BUFFER_OBJECT_CACHE_H
+
+#include "rsObjectBase.h"
+
+// ---------------------------------------------------------------------------
+namespace android {
+namespace renderscript {
+
+class Allocation;
+
+class FBOCache {
+public:
+    FBOCache();
+    ~FBOCache();
+
+    void bindColorTarget(Context *rsc, Allocation *a, uint32_t slot);
+    void bindDepthTarget(Context *, Allocation *a);
+    void resetAll(Context *);
+
+    void setupGL2(Context *);
+
+protected:
+
+    bool mDirty;
+    uint32_t mMaxTargets;
+    void checkError(Context *);
+    void setColorAttachment(Context *rsc);
+    void setDepthAttachment(Context *rsc);
+    bool renderToFramebuffer();
+    ObjectBaseRef<Allocation> *mColorTargets;
+    ObjectBaseRef<Allocation> mDepthTarget;
+
+    uint32_t mFBOId;
+
+};
+
+} // renderscript
+} // android
+
+#endif //ANDROID_FRAME_BUFFER_OBJECT_CACHE_H
diff --git a/libs/rs/rsFont.cpp b/libs/rs/rsFont.cpp
index 01dbab8..595c89a 100644
--- a/libs/rs/rsFont.cpp
+++ b/libs/rs/rsFont.cpp
@@ -566,7 +566,7 @@
         indexPtr[i6 + 5] = i4 + 3;
     }
 
-    indexAlloc->deferedUploadToBufferObject(mRSC);
+    indexAlloc->deferredUploadToBufferObject(mRSC);
     mIndexBuffer.set(indexAlloc);
 
     const Element *posElem = Element::create(mRSC, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 3);
diff --git a/libs/rs/rsMesh.cpp b/libs/rs/rsMesh.cpp
index 76fe62d..e29c800 100644
--- a/libs/rs/rsMesh.cpp
+++ b/libs/rs/rsMesh.cpp
@@ -282,13 +282,13 @@
 void Mesh::uploadAll(Context *rsc) {
     for (uint32_t ct = 0; ct < mVertexBufferCount; ct ++) {
         if (mVertexBuffers[ct].get()) {
-            mVertexBuffers[ct]->deferedUploadToBufferObject(rsc);
+            mVertexBuffers[ct]->deferredUploadToBufferObject(rsc);
         }
     }
 
     for (uint32_t ct = 0; ct < mPrimitivesCount; ct ++) {
         if (mPrimitives[ct]->mIndexBuffer.get()) {
-            mPrimitives[ct]->mIndexBuffer->deferedUploadToBufferObject(rsc);
+            mPrimitives[ct]->mIndexBuffer->deferredUploadToBufferObject(rsc);
         }
     }
 }
diff --git a/libs/rs/rsScriptC_LibGL.cpp b/libs/rs/rsScriptC_LibGL.cpp
index 4047049..1ed0f31 100644
--- a/libs/rs/rsScriptC_LibGL.cpp
+++ b/libs/rs/rsScriptC_LibGL.cpp
@@ -86,6 +86,33 @@
     rsi_ContextBindProgramRaster(rsc, pv);
 }
 
+static void SC_bindFrameBufferObjectColorTarget(RsAllocation va, uint32_t slot) {
+    CHECK_OBJ(va);
+    GET_TLS();
+    rsc->mFBOCache.bindColorTarget(rsc, static_cast<Allocation *>(va), slot);
+}
+
+static void SC_bindFrameBufferObjectDepthTarget(RsAllocation va) {
+    CHECK_OBJ(va);
+    GET_TLS();
+    rsc->mFBOCache.bindDepthTarget(rsc, static_cast<Allocation *>(va));
+}
+
+static void SC_clearFrameBufferObjectColorTarget(uint32_t slot) {
+    GET_TLS();
+    rsc->mFBOCache.bindColorTarget(rsc, NULL, slot);
+}
+
+static void SC_clearFrameBufferObjectDepthTarget() {
+    GET_TLS();
+    rsc->mFBOCache.bindDepthTarget(rsc, NULL);
+}
+
+static void SC_clearFrameBufferObjectTargets() {
+    GET_TLS();
+    rsc->mFBOCache.resetAll(rsc);
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // VP
 //////////////////////////////////////////////////////////////////////////////
@@ -275,6 +302,10 @@
     pf->setConstantColor(rsc, r, g, b, a);
 }
 
+static void SC_finish() {
+    glFinish();
+}
+
 static void SC_allocationSyncAll(RsAllocation va) {
     CHECK_OBJ(va);
     GET_TLS();
@@ -291,6 +322,7 @@
 
 static void SC_ClearColor(float r, float g, float b, float a) {
     GET_TLS();
+    rsc->mFBOCache.setupGL2(rsc);
     rsc->setupProgramStore();
 
     glClearColor(r, g, b, a);
@@ -299,6 +331,7 @@
 
 static void SC_ClearDepth(float v) {
     GET_TLS();
+    rsc->mFBOCache.setupGL2(rsc);
     rsc->setupProgramStore();
 
     glClearDepthf(v);
@@ -444,8 +477,15 @@
     { "_Z11rsgBindFont7rs_font", (void *)&SC_BindFont, false },
     { "_Z12rsgFontColorffff", (void *)&SC_FontColor, false },
 
+    { "_Z18rsgBindColorTarget13rs_allocationj", (void *)&SC_bindFrameBufferObjectColorTarget, false },
+    { "_Z18rsgBindDepthTarget13rs_allocation", (void *)&SC_bindFrameBufferObjectDepthTarget, false },
+    { "_Z19rsgClearColorTargetj", (void *)&SC_clearFrameBufferObjectColorTarget, false },
+    { "_Z19rsgClearDepthTargetv", (void *)&SC_clearFrameBufferObjectDepthTarget, false },
+    { "_Z24rsgClearAllRenderTargetsv", (void *)&SC_clearFrameBufferObjectTargets, false },
+
     // misc
     { "_Z5colorffff", (void *)&SC_color, false },
+    { "_Z9rsgFinishv", (void *)&SC_finish, false },
 
     { NULL, NULL, false }
 };
diff --git a/libs/rs/scriptc/rs_graphics.rsh b/libs/rs/scriptc/rs_graphics.rsh
index 67ffc3d..d53bc95 100644
--- a/libs/rs/scriptc/rs_graphics.rsh
+++ b/libs/rs/scriptc/rs_graphics.rsh
@@ -1,6 +1,46 @@
 #ifndef __RS_GRAPHICS_RSH__
 #define __RS_GRAPHICS_RSH__
 
+/**
+ * Set the color target used for all subsequent rendering calls
+ * @param colorTarget
+ * @param slot
+ */
+extern void __attribute__((overloadable))
+    rsgBindColorTarget(rs_allocation colorTarget, uint slot);
+
+/**
+ * Clear the previously set color target
+ * @param slot
+ */
+extern void __attribute__((overloadable))
+    rsgClearColorTarget(uint slot);
+
+/**
+ * Set the depth target used for all subsequent rendering calls
+ * @param depthTarget
+ */
+extern void __attribute__((overloadable))
+    rsgBindDepthTarget(rs_allocation depthTarget);
+
+/**
+ * Clear the previously set depth target
+ */
+extern void __attribute__((overloadable))
+    rsgClearDepthTarget(void);
+
+/**
+ * Clear all color and depth targets and resume rendering into
+ * the framebuffer
+ */
+extern void __attribute__((overloadable))
+    rsgClearAllRenderTargets(void);
+
+/**
+ * Force RenderScript to finish all rendering commands
+ */
+extern uint __attribute__((overloadable))
+    rsgFinish(void);
 
 /**
  * Bind a new ProgramFragment to the rendering context.
diff --git a/tests/RenderScriptTests/FBOTest/Android.mk b/tests/RenderScriptTests/FBOTest/Android.mk
new file mode 100644
index 0000000..55525c4
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/Android.mk
@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2008 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+ifneq ($(TARGET_SIMULATOR),true)
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src)
+
+LOCAL_PACKAGE_NAME := FBOTest
+
+include $(BUILD_PACKAGE)
+
+endif
diff --git a/tests/RenderScriptTests/FBOTest/AndroidManifest.xml b/tests/RenderScriptTests/FBOTest/AndroidManifest.xml
new file mode 100644
index 0000000..c2e0cc6
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/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.fbotest">
+    <application android:label="_FBOTest">
+        <activity android:name="FBOTest"
+                  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/tests/RenderScriptTests/FBOTest/res/drawable/robot.png b/tests/RenderScriptTests/FBOTest/res/drawable/robot.png
new file mode 100644
index 0000000..f7353fd
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/res/drawable/robot.png
Binary files differ
diff --git a/tests/RenderScriptTests/FBOTest/res/raw/robot.a3d b/tests/RenderScriptTests/FBOTest/res/raw/robot.a3d
new file mode 100644
index 0000000..f48895c
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/res/raw/robot.a3d
Binary files differ
diff --git a/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTest.java b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTest.java
new file mode 100644
index 0000000..79d6012
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTest.java
@@ -0,0 +1,73 @@
+/*
+ * 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.fbotest;
+
+import android.renderscript.RSSurfaceView;
+import android.renderscript.RenderScript;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.provider.Settings.System;
+import android.util.Config;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.MenuInflater;
+import android.view.Window;
+import android.widget.Button;
+import android.widget.ListView;
+import android.net.Uri;
+
+import java.lang.Runtime;
+
+public class FBOTest extends Activity {
+
+    private FBOTestView 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 FBOTestView(this);
+        setContentView(mView);
+    }
+
+    @Override
+    protected void onResume() {
+        // Ideally a game should implement onResume() and onPause()
+        // to take appropriate action when the activity looses focus
+        super.onResume();
+        mView.resume();
+    }
+
+    @Override
+    protected void onPause() {
+        // Ideally a game should implement onResume() and onPause()
+        // to take appropriate action when the activity looses focus
+        super.onPause();
+        mView.pause();
+    }
+}
+
diff --git a/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestRS.java b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestRS.java
new file mode 100644
index 0000000..9e30c4b
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestRS.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.fbotest;
+
+import java.io.Writer;
+
+import android.content.res.Resources;
+import android.renderscript.*;
+import android.renderscript.Element.DataType;
+import android.renderscript.Element.DataKind;
+import android.renderscript.ProgramStore.DepthFunc;
+import android.renderscript.Type.Builder;
+import android.util.Log;
+
+
+public class FBOTestRS {
+
+    public FBOTestRS() {
+    }
+
+    public void init(RenderScriptGL rs, Resources res) {
+        mRS = rs;
+        mRes = res;
+        initRS();
+    }
+
+    public void surfaceChanged() {
+        mRS.getWidth();
+        mRS.getHeight();
+    }
+
+    private Resources mRes;
+    private RenderScriptGL mRS;
+    private Sampler mSampler;
+    private ProgramStore mPSBackground;
+    private ProgramFragment mPFBackground;
+    private ProgramVertex mPVBackground;
+    private ProgramVertexFixedFunction.Constants mPVA;
+
+    private Allocation mGridImage;
+    private Allocation mOffscreen;
+    private Allocation mOffscreenDepth;
+    private Allocation mAllocPV;
+
+    private Font mItalic;
+    private Allocation mTextAlloc;
+
+    private ScriptField_MeshInfo mMeshes;
+    private ScriptC_fbotest mScript;
+
+
+    public void onActionDown(float x, float y) {
+        mScript.invoke_onActionDown(x, y);
+    }
+
+    public void onActionScale(float scale) {
+        mScript.invoke_onActionScale(scale);
+    }
+
+    public void onActionMove(float x, float y) {
+        mScript.invoke_onActionMove(x, y);
+    }
+
+    private void initPFS() {
+        ProgramStore.Builder b = new ProgramStore.Builder(mRS);
+
+        b.setDepthFunc(ProgramStore.DepthFunc.LESS);
+        b.setDitherEnabled(false);
+        b.setDepthMaskEnabled(true);
+        mPSBackground = b.create();
+
+        mScript.set_gPFSBackground(mPSBackground);
+    }
+
+    private void initPF() {
+        Sampler.Builder bs = new Sampler.Builder(mRS);
+        bs.setMinification(Sampler.Value.LINEAR);
+        bs.setMagnification(Sampler.Value.LINEAR);
+        bs.setWrapS(Sampler.Value.CLAMP);
+        bs.setWrapT(Sampler.Value.CLAMP);
+        mSampler = bs.create();
+
+        ProgramFragmentFixedFunction.Builder b = new ProgramFragmentFixedFunction.Builder(mRS);
+        b.setTexture(ProgramFragmentFixedFunction.Builder.EnvMode.REPLACE,
+                     ProgramFragmentFixedFunction.Builder.Format.RGBA, 0);
+        mPFBackground = b.create();
+        mPFBackground.bindSampler(mSampler, 0);
+
+        mScript.set_gPFBackground(mPFBackground);
+    }
+
+    private void initPV() {
+        ProgramVertexFixedFunction.Builder pvb = new ProgramVertexFixedFunction.Builder(mRS);
+        mPVBackground = pvb.create();
+
+        mPVA = new ProgramVertexFixedFunction.Constants(mRS);
+        ((ProgramVertexFixedFunction)mPVBackground).bindConstants(mPVA);
+
+        mScript.set_gPVBackground(mPVBackground);
+    }
+
+    private void loadImage() {
+        mGridImage = Allocation.createFromBitmapResource(mRS, mRes, R.drawable.robot,
+                                                         Allocation.MipmapControl.MIPMAP_ON_SYNC_TO_TEXTURE,
+                                                         Allocation.USAGE_GRAPHICS_TEXTURE);
+        mScript.set_gTGrid(mGridImage);
+    }
+
+    private void initTextAllocation(String fileName) {
+        String allocString = "Displaying file: " + fileName;
+        mTextAlloc = Allocation.createFromString(mRS, allocString, Allocation.USAGE_SCRIPT);
+        mScript.set_gTextAlloc(mTextAlloc);
+    }
+
+    private void initMeshes(FileA3D model) {
+        int numEntries = model.getIndexEntryCount();
+        int numMeshes = 0;
+        for (int i = 0; i < numEntries; i ++) {
+            FileA3D.IndexEntry entry = model.getIndexEntry(i);
+            if (entry != null && entry.getEntryType() == FileA3D.EntryType.MESH) {
+                numMeshes ++;
+            }
+        }
+
+        if (numMeshes > 0) {
+            mMeshes = new ScriptField_MeshInfo(mRS, numMeshes);
+
+            for (int i = 0; i < numEntries; i ++) {
+                FileA3D.IndexEntry entry = model.getIndexEntry(i);
+                if (entry != null && entry.getEntryType() == FileA3D.EntryType.MESH) {
+                    Mesh mesh = entry.getMesh();
+                    mMeshes.set_mMesh(i, mesh, false);
+                    mMeshes.set_mNumIndexSets(i, mesh.getPrimitiveCount(), false);
+                }
+            }
+            mMeshes.copyAll();
+        } else {
+            throw new RSRuntimeException("No valid meshes in file");
+        }
+
+        mScript.bind_gMeshes(mMeshes);
+        mScript.invoke_updateMeshInfo();
+    }
+
+    public void loadA3DFile(String path) {
+        FileA3D model = FileA3D.createFromFile(mRS, path);
+        initMeshes(model);
+        initTextAllocation(path);
+    }
+
+    private void initRS() {
+
+        mScript = new ScriptC_fbotest(mRS, mRes, R.raw.fbotest);
+
+        initPFS();
+        initPF();
+        initPV();
+
+        loadImage();
+
+        Type.Builder b = new Type.Builder(mRS, Element.RGBA_8888(mRS));
+        b.setX(512).setY(512);
+        mOffscreen = Allocation.createTyped(mRS,
+                                            b.create(),
+                                            Allocation.USAGE_GRAPHICS_TEXTURE |
+                                            Allocation.USAGE_GRAPHICS_RENDER_TARGET);
+        mScript.set_gOffscreen(mOffscreen);
+
+        b = new Type.Builder(mRS,
+                             Element.createPixel(mRS, DataType.UNSIGNED_16,
+                             DataKind.PIXEL_DEPTH));
+        b.setX(512).setY(512);
+        mOffscreenDepth = Allocation.createTyped(mRS,
+                                                 b.create(),
+                                                 Allocation.USAGE_GRAPHICS_RENDER_TARGET);
+        mScript.set_gOffscreenDepth(mOffscreenDepth);
+
+        FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.robot);
+        initMeshes(model);
+
+        mItalic = Font.create(mRS, mRes, "serif", Font.Style.ITALIC, 8);
+        mScript.set_gItalic(mItalic);
+
+        initTextAllocation("R.raw.robot");
+
+        mRS.bindRootScript(mScript);
+    }
+}
+
+
+
diff --git a/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestView.java b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestView.java
new file mode 100644
index 0000000..c9598ee
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/FBOTestView.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.fbotest;
+
+import android.renderscript.RSSurfaceView;
+import android.renderscript.RenderScriptGL;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.SurfaceHolder;
+import android.view.ScaleGestureDetector;
+import android.util.Log;
+
+public class FBOTestView extends RSSurfaceView {
+
+    private RenderScriptGL mRS;
+    private FBOTestRS mRender;
+
+    private ScaleGestureDetector mScaleDetector;
+
+    private static final int INVALID_POINTER_ID = -1;
+    private int mActivePointerId = INVALID_POINTER_ID;
+
+    public FBOTestView(Context context) {
+        super(context);
+        ensureRenderScript();
+        mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
+    }
+
+    private void ensureRenderScript() {
+        if (mRS == null) {
+            RenderScriptGL.SurfaceConfig sc = new RenderScriptGL.SurfaceConfig();
+            sc.setDepth(16, 24);
+            mRS = createRenderScriptGL(sc);
+            mRender = new FBOTestRS();
+            mRender.init(mRS, getResources());
+        }
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        ensureRenderScript();
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+        super.surfaceChanged(holder, format, w, h);
+        mRender.surfaceChanged();
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        mRender = null;
+        if (mRS != null) {
+            mRS = null;
+            destroyRenderScriptGL();
+        }
+    }
+
+    public void loadA3DFile(String path) {
+        mRender.loadA3DFile(path);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        mScaleDetector.onTouchEvent(ev);
+
+        boolean ret = false;
+        float x = ev.getX();
+        float y = ev.getY();
+
+        final int action = ev.getAction();
+
+        switch (action & MotionEvent.ACTION_MASK) {
+        case MotionEvent.ACTION_DOWN: {
+            mRender.onActionDown(x, y);
+            mActivePointerId = ev.getPointerId(0);
+            ret = true;
+            break;
+        }
+        case MotionEvent.ACTION_MOVE: {
+            if (!mScaleDetector.isInProgress()) {
+                mRender.onActionMove(x, y);
+            }
+            mRender.onActionDown(x, y);
+            ret = true;
+            break;
+        }
+
+        case MotionEvent.ACTION_UP: {
+            mActivePointerId = INVALID_POINTER_ID;
+            break;
+        }
+
+        case MotionEvent.ACTION_CANCEL: {
+            mActivePointerId = INVALID_POINTER_ID;
+            break;
+        }
+
+        case MotionEvent.ACTION_POINTER_UP: {
+            final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
+                    >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+            final int pointerId = ev.getPointerId(pointerIndex);
+            if (pointerId == mActivePointerId) {
+                // This was our active pointer going up. Choose a new
+                // active pointer and adjust accordingly.
+                final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+                x = ev.getX(newPointerIndex);
+                y = ev.getY(newPointerIndex);
+                mRender.onActionDown(x, y);
+                mActivePointerId = ev.getPointerId(newPointerIndex);
+            }
+            break;
+        }
+        }
+
+        return ret;
+    }
+
+    private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
+        @Override
+        public boolean onScale(ScaleGestureDetector detector) {
+            mRender.onActionScale(detector.getScaleFactor());
+            return true;
+        }
+    }
+}
+
+
diff --git a/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/fbotest.rs b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/fbotest.rs
new file mode 100644
index 0000000..31dd3e9
--- /dev/null
+++ b/tests/RenderScriptTests/FBOTest/src/com/android/fbotest/fbotest.rs
@@ -0,0 +1,221 @@
+// Copyright (C) 2011 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma version(1)
+
+#pragma rs java_package_name(com.android.fbotest)
+
+#include "rs_graphics.rsh"
+
+rs_program_vertex gPVBackground;
+rs_program_fragment gPFBackground;
+
+rs_allocation gTGrid;
+
+rs_program_store gPFSBackground;
+
+rs_font gItalic;
+rs_allocation gTextAlloc;
+
+rs_allocation gOffscreen;
+rs_allocation gOffscreenDepth;
+
+typedef struct MeshInfo {
+    rs_mesh mMesh;
+    int mNumIndexSets;
+    float3 bBoxMin;
+    float3 bBoxMax;
+} MeshInfo_t;
+
+MeshInfo_t *gMeshes;
+
+static float3 gLookAt;
+
+static float gRotateX;
+static float gRotateY;
+static float gZoom;
+
+static float gLastX;
+static float gLastY;
+
+void onActionDown(float x, float y) {
+    gLastX = x;
+    gLastY = y;
+}
+
+void onActionScale(float scale) {
+
+    gZoom *= 1.0f / scale;
+    gZoom = max(0.1f, min(gZoom, 500.0f));
+}
+
+void onActionMove(float x, float y) {
+    float dx = gLastX - x;
+    float dy = gLastY - y;
+
+    if (fabs(dy) <= 2.0f) {
+        dy = 0.0f;
+    }
+    if (fabs(dx) <= 2.0f) {
+        dx = 0.0f;
+    }
+
+    gRotateY -= dx;
+    if (gRotateY > 360) {
+        gRotateY -= 360;
+    }
+    if (gRotateY < 0) {
+        gRotateY += 360;
+    }
+
+    gRotateX -= dy;
+    gRotateX = min(gRotateX, 80.0f);
+    gRotateX = max(gRotateX, -80.0f);
+
+    gLastX = x;
+    gLastY = y;
+}
+
+void init() {
+    gRotateX = 0.0f;
+    gRotateY = 0.0f;
+    gZoom = 50.0f;
+    gLookAt = 0.0f;
+}
+
+void updateMeshInfo() {
+    rs_allocation allMeshes = rsGetAllocation(gMeshes);
+    int size = rsAllocationGetDimX(allMeshes);
+    gLookAt = 0.0f;
+    float minX, minY, minZ, maxX, maxY, maxZ;
+    for (int i = 0; i < size; i++) {
+        MeshInfo_t *info = (MeshInfo_t*)rsGetElementAt(allMeshes, i);
+        rsgMeshComputeBoundingBox(info->mMesh,
+                                  &minX, &minY, &minZ,
+                                  &maxX, &maxY, &maxZ);
+        info->bBoxMin = (minX, minY, minZ);
+        info->bBoxMax = (maxX, maxY, maxZ);
+        gLookAt += (info->bBoxMin + info->bBoxMax)*0.5f;
+    }
+    gLookAt = gLookAt / (float)size;
+}
+
+static void renderAllMeshes() {
+    rs_allocation allMeshes = rsGetAllocation(gMeshes);
+    int size = rsAllocationGetDimX(allMeshes);
+    gLookAt = 0.0f;
+    float minX, minY, minZ, maxX, maxY, maxZ;
+    for (int i = 0; i < size; i++) {
+        MeshInfo_t *info = (MeshInfo_t*)rsGetElementAt(allMeshes, i);
+        rsgDrawMesh(info->mMesh);
+    }
+}
+
+static void drawDescription() {
+    uint width = rsgGetWidth();
+    uint height = rsgGetHeight();
+    int left = 0, right = 0, top = 0, bottom = 0;
+
+    rsgBindFont(gItalic);
+
+    rsgMeasureText(gTextAlloc, &left, &right, &top, &bottom);
+    rsgDrawText(gTextAlloc, 2 -left, height - 2 + bottom);
+}
+
+static void renderOffscreen(bool useDepth) {
+
+    rsgBindColorTarget(gOffscreen, 0);
+    if (useDepth) {
+        rsgBindDepthTarget(gOffscreenDepth);
+        rsgClearDepth(1.0f);
+    } else {
+        rsgClearDepthTarget();
+    }
+    rsgClearColor(0.8f, 0.8f, 0.8f, 1.0f);
+
+    rsgBindProgramVertex(gPVBackground);
+    rs_matrix4x4 proj;
+    float aspect = (float)rsAllocationGetDimX(gOffscreen) / (float)rsAllocationGetDimY(gOffscreen);
+    rsMatrixLoadPerspective(&proj, 30.0f, aspect, 1.0f, 100.0f);
+    rsgProgramVertexLoadProjectionMatrix(&proj);
+
+    rsgBindProgramFragment(gPFBackground);
+    rsgBindProgramStore(gPFSBackground);
+    rsgBindTexture(gPFBackground, 0, gTGrid);
+
+    rs_matrix4x4 matrix;
+    rsMatrixLoadIdentity(&matrix);
+    // Position our models on the screen
+    rsMatrixTranslate(&matrix, gLookAt.x, gLookAt.y, gLookAt.z - gZoom);
+    rsMatrixRotate(&matrix, gRotateX, 1.0f, 0.0f, 0.0f);
+    rsMatrixRotate(&matrix, gRotateY, 0.0f, 1.0f, 0.0f);
+    rsgProgramVertexLoadModelMatrix(&matrix);
+
+    renderAllMeshes();
+
+    // Render into the frambuffer
+    rsgClearAllRenderTargets();
+}
+
+static void drawOffscreenResult(int posX, int posY) {
+    // display the result
+    rs_matrix4x4 proj, matrix;
+    rsMatrixLoadOrtho(&proj, 0, rsgGetWidth(), rsgGetHeight(), 0, -500, 500);
+    rsgProgramVertexLoadProjectionMatrix(&proj);
+    rsMatrixLoadIdentity(&matrix);
+    rsgProgramVertexLoadModelMatrix(&matrix);
+    rsgBindTexture(gPFBackground, 0, gOffscreen);
+    float startX = posX, startY = posY;
+    float width = 256, height = 256;
+    rsgDrawQuadTexCoords(startX, startY, 0, 0, 1,
+                         startX, startY + height, 0, 0, 0,
+                         startX + width, startY + height, 0, 1, 0,
+                         startX + width, startY, 0, 1, 1);
+}
+
+int root(int launchID) {
+
+    rsgClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+    rsgClearDepth(1.0f);
+
+    renderOffscreen(true);
+    drawOffscreenResult(0, 0);
+
+    renderOffscreen(false);
+    drawOffscreenResult(0, 256);
+
+    rsgBindProgramVertex(gPVBackground);
+    rs_matrix4x4 proj;
+    float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
+    rsMatrixLoadPerspective(&proj, 30.0f, aspect, 1.0f, 100.0f);
+    rsgProgramVertexLoadProjectionMatrix(&proj);
+
+    rsgBindProgramFragment(gPFBackground);
+    rsgBindProgramStore(gPFSBackground);
+    rsgBindTexture(gPFBackground, 0, gTGrid);
+
+    rs_matrix4x4 matrix;
+    rsMatrixLoadIdentity(&matrix);
+    // Position our models on the screen
+    rsMatrixTranslate(&matrix, gLookAt.x, gLookAt.y, gLookAt.z - gZoom);
+    rsMatrixRotate(&matrix, gRotateX, 1.0f, 0.0f, 0.0f);
+    rsMatrixRotate(&matrix, gRotateY, 0.0f, 1.0f, 0.0f);
+    rsgProgramVertexLoadModelMatrix(&matrix);
+
+    renderAllMeshes();
+
+    drawDescription();
+
+    return 0;
+}
diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java
index 9757ec6..5443ef8 100644
--- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java
+++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/RsBenchRS.java
@@ -22,6 +22,8 @@
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.renderscript.*;
+import android.renderscript.Element.DataKind;
+import android.renderscript.Element.DataType;
 import android.renderscript.Allocation.MipmapControl;
 import android.renderscript.Program.TextureType;
 import android.renderscript.ProgramStore.DepthFunc;
@@ -399,6 +401,23 @@
         initProgramRaster();
         initCustomShaders();
 
+        Type.Builder b = new Type.Builder(mRS, Element.RGBA_8888(mRS));
+        b.setX(1280).setY(720);
+        Allocation offscreen = Allocation.createTyped(mRS,
+                                                      b.create(),
+                                                      Allocation.USAGE_GRAPHICS_TEXTURE |
+                                                      Allocation.USAGE_GRAPHICS_RENDER_TARGET);
+        mScript.set_gRenderBufferColor(offscreen);
+
+        b = new Type.Builder(mRS,
+                             Element.createPixel(mRS, DataType.UNSIGNED_16,
+                             DataKind.PIXEL_DEPTH));
+        b.setX(1280).setY(720);
+        offscreen = Allocation.createTyped(mRS,
+                                           b.create(),
+                                           Allocation.USAGE_GRAPHICS_RENDER_TARGET);
+        mScript.set_gRenderBufferDepth(offscreen);
+
         mRS.bindRootScript(mScript);
     }
 }
diff --git a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs
index 3c92725..fd0f16f 100644
--- a/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs
+++ b/tests/RenderScriptTests/PerfTest/src/com/android/perftest/rsbench.rs
@@ -76,11 +76,17 @@
 rs_program_fragment gProgFragmentPixelLight;
 rs_program_fragment gProgFragmentMultitex;
 
+rs_allocation gRenderBufferColor;
+rs_allocation gRenderBufferDepth;
+
 float gDt = 0;
 
 void init() {
 }
 
+static int gRenderSurfaceW;
+static int gRenderSurfaceH;
+
 static const char *sampleText = "This is a sample of small text for performace";
 // Offsets for multiple layer of text
 static int textOffsets[] = { 0,  0, -5, -5, 5,  5, -8, -8, 8,  8};
@@ -91,6 +97,11 @@
                              0.5f, 0.6f, 0.7f, 1.0f,
 };
 
+static void setupOffscreenTarget() {
+    rsgBindColorTarget(gRenderBufferColor, 0);
+    rsgBindDepthTarget(gRenderBufferDepth);
+}
+
 static void displayFontSamples(int fillNum) {
 
     rs_font fonts[5];
@@ -100,8 +111,8 @@
     rsSetObject(&fonts[3], gFontSerifBoldItalic);
     rsSetObject(&fonts[4], gFontSans);
 
-    uint width = rsgGetWidth();
-    uint height = rsgGetHeight();
+    uint width = gRenderSurfaceW;
+    uint height = gRenderSurfaceH;
     int left = 0, right = 0, top = 0, bottom = 0;
     rsgMeasureText(sampleText, &left, &right, &top, &bottom);
 
@@ -136,7 +147,7 @@
     rsgBindProgramVertex(gProgVertex);
     // Setup the projection matrix
     rs_matrix4x4 proj;
-    rsMatrixLoadOrtho(&proj, 0, rsgGetWidth(), rsgGetHeight(), 0, -500, 500);
+    rsMatrixLoadOrtho(&proj, 0, gRenderSurfaceW, gRenderSurfaceH, 0, -500, 500);
     rsgProgramVertexLoadProjectionMatrix(&proj);
 }
 
@@ -158,7 +169,7 @@
 
     for (int i = 0; i < quadCount; i ++) {
         float startX = 10 * i, startY = 10 * i;
-        float width = rsgGetWidth() - startX, height = rsgGetHeight() - startY;
+        float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY;
         rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                              startX, startY + height, 0, 0, 1,
                              startX + width, startY + height, 0, 1, 1,
@@ -216,7 +227,7 @@
 
     bindProgramVertexOrtho();
     rs_matrix4x4 matrix;
-    rsMatrixLoadTranslate(&matrix, rsgGetWidth()/2, rsgGetHeight()/2, 0);
+    rsMatrixLoadTranslate(&matrix, gRenderSurfaceW/2, gRenderSurfaceH/2, 0);
     rsgProgramVertexLoadModelMatrix(&matrix);
 
     // Fragment shader with texture
@@ -344,7 +355,7 @@
     rsgBindProgramRaster(gCullBack);
     // Setup the projection matrix with 30 degree field of view
     rs_matrix4x4 proj;
-    float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
+    float aspect = (float)gRenderSurfaceW / (float)gRenderSurfaceH;
     rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
     rsgProgramVertexLoadProjectionMatrix(&proj);
 
@@ -445,7 +456,7 @@
     }
 
     // Setup the projection matrix
-    float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
+    float aspect = (float)gRenderSurfaceW / (float)gRenderSurfaceH;
     rsMatrixLoadPerspective(&gVSConstants->proj, 30.0f, aspect, 0.1f, 100.0f);
     setupCustomShaderLights();
 
@@ -476,7 +487,7 @@
     gVSConstPixel->time = rsUptimeMillis()*0.005;
 
     // Setup the projection matrix
-    float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
+    float aspect = (float)gRenderSurfaceW / (float)gRenderSurfaceH;
     rsMatrixLoadPerspective(&gVSConstPixel->proj, 30.0f, aspect, 0.1f, 100.0f);
     setupCustomShaderLights();
 
@@ -520,7 +531,7 @@
 
     for (int i = 0; i < quadCount; i ++) {
         float startX = 10 * i, startY = 10 * i;
-        float width = rsgGetWidth() - startX, height = rsgGetHeight() - startY;
+        float width = gRenderSurfaceW - startX, height = gRenderSurfaceH - startY;
         rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                              startX, startY + height, 0, 0, 1,
                              startX + width, startY + height, 0, 1, 1,
@@ -535,7 +546,7 @@
     gAnisoTime += gDt;
 
     rsgBindProgramVertex(gProgVertex);
-    float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
+    float aspect = (float)gRenderSurfaceW / (float)gRenderSurfaceH;
     rs_matrix4x4 proj;
     rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
     rsgProgramVertexLoadProjectionMatrix(&proj);
@@ -592,10 +603,6 @@
 
     static int countdown = 5;
 
-    if (countdown == 0) {
-        gDt = 0;
-        countdown --;
-    }
     // Perform all the uploads so we only measure rendered time
     if(countdown > 1) {
         displayFontSamples(5);
@@ -612,19 +619,13 @@
         countdown --;
         rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f);
 
-        // Now use text metrics to center the text
-        uint width = rsgGetWidth();
-        uint height = rsgGetHeight();
-        int left = 0, right = 0, top = 0, bottom = 0;
-
         rsgFontColor(0.9f, 0.9f, 0.95f, 1.0f);
         rsgBindFont(gFontSerifBoldItalic);
-
-        const char* text = "Initializing";
-        rsgMeasureText(text, &left, &right, &top, &bottom);
-        int centeredPosX = width / 2 - (right - left) / 2;
-        int centeredPosY = height / 2 - (top - bottom) / 2;
-        rsgDrawText(text, centeredPosX, centeredPosY);
+        if (countdown == 1) {
+            rsgDrawText("Rendering", 50, 50);
+        } else {
+            rsgDrawText("Initializing", 50, 50);
+        }
 
         return false;
     }
@@ -632,70 +633,40 @@
     return true;
 }
 
-static int frameCount = 0;
-static int totalFramesRendered = 0;
 static int benchMode = 0;
 
-#define testTime 5.0f
-static float curTestTime = testTime;
-
 static const char *testNames[] = {
-    "Finished text fill 1",
-    "Finished text fill 2",
-    "Finished text fill 3",
-    "Finished text fill 4",
-    "Finished text fill 5",
-    "Finished 25.6k geo flat color",
-    "Finished 51.2k geo flat color",
-    "Finished 204.8k geo raster load flat color",
-    "Finished 25.6k geo texture",
-    "Finished 51.2k geo texture",
-    "Finished 204.8k geo raster load texture",
-    "Finished full screen mesh 10 by 10",
-    "Finished full screen mesh 100 by 100",
-    "Finished full screen mesh W / 4 by H / 4",
-    "Finished 25.6k geo heavy vertex",
-    "Finished 51.2k geo heavy vertex",
-    "Finished 204.8k geo raster load heavy vertex",
-    "Finished singletexture 5x fill",
-    "Finished 3tex multitexture 5x fill",
-    "Finished blend singletexture 5x fill",
-    "Finished blend 3tex multitexture 5x fill",
-    "Finished 25.6k geo heavy fragment",
-    "Finished 51.2k geo heavy fragment",
-    "Finished 204.8k geo raster load heavy fragment",
-    "Finished 25.6k geo heavy fragment, heavy vertex",
-    "Finished 51.2k geo heavy fragment, heavy vertex",
-    "Finished 204.8k geo raster load heavy fragment, heavy vertex",
+    "Finished text fill 1,",
+    "Finished text fill 2,",
+    "Finished text fill 3,",
+    "Finished text fill 4,",
+    "Finished text fill 5,",
+    "Finished 25.6k geo flat color,",
+    "Finished 51.2k geo flat color,",
+    "Finished 204.8k geo raster load flat color,",
+    "Finished 25.6k geo texture,",
+    "Finished 51.2k geo texture,",
+    "Finished 204.8k geo raster load texture,",
+    "Finished full screen mesh 10 by 10,",
+    "Finished full screen mesh 100 by 100,",
+    "Finished full screen mesh W / 4 by H / 4,",
+    "Finished 25.6k geo heavy vertex,",
+    "Finished 51.2k geo heavy vertex,",
+    "Finished 204.8k geo raster load heavy vertex,",
+    "Finished singletexture 5x fill,",
+    "Finished 3tex multitexture 5x fill,",
+    "Finished blend singletexture 5x fill,",
+    "Finished blend 3tex multitexture 5x fill,",
+    "Finished 25.6k geo heavy fragment,",
+    "Finished 51.2k geo heavy fragment,",
+    "Finished 204.8k geo raster load heavy fragment,",
+    "Finished 25.6k geo heavy fragment heavy vertex,",
+    "Finished 51.2k geo heavy fragment heavy vertex,",
+    "Finished 204.8k geo raster load heavy fragment heavy vertex,",
 };
 
-int root(int launchID) {
-
-    gDt = rsGetDt();
-
-    rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f);
-    rsgClearDepth(1.0f);
-
-    if(!checkInit()) {
-        return 1;
-    }
-
-    curTestTime -= gDt;
-    if(curTestTime < 0.0f) {
-        float fps = (float)(frameCount) / (testTime - curTestTime);
-        rsDebug(testNames[benchMode], fps);
-        benchMode ++;
-        curTestTime = testTime;
-        totalFramesRendered += frameCount;
-        frameCount = 0;
-        gTorusRotation = 0;
-
-        if (benchMode > gMaxModes) {
-            benchMode = 0;
-        }
-    }
-
-    switch (benchMode) {
+static void runTest(int index) {
+    switch (index) {
     case 0:
         displayFontSamples(1);
         break;
@@ -777,10 +748,87 @@
     case 26:
         displayPixelLightSamples(8, true);
         break;
+    }
+}
 
+static void drawOffscreenResult(int posX, int posY, int width, int height) {
+    bindProgramVertexOrtho();
+
+    rs_matrix4x4 matrix;
+    rsMatrixLoadIdentity(&matrix);
+    rsgProgramVertexLoadModelMatrix(&matrix);
+
+    rsgBindProgramFragment(gProgFragmentTexture);
+
+    rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
+    rsgBindTexture(gProgFragmentTexture, 0, gRenderBufferColor);
+
+    float startX = posX, startY = posY;
+    rsgDrawQuadTexCoords(startX, startY, 0, 0, 1,
+                         startX, startY + height, 0, 0, 0,
+                         startX + width, startY + height, 0, 1, 0,
+                         startX + width, startY, 0, 1, 1);
+}
+
+int root(int launchID) {
+
+    gRenderSurfaceW = rsgGetWidth();
+    gRenderSurfaceH = rsgGetHeight();
+    rsgClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+    rsgClearDepth(1.0f);
+    if(!checkInit()) {
+        return 1;
     }
 
-    frameCount ++;
+    rsgFinish();
+    int64_t start = rsUptimeMillis();
+    rsGetDt();
+
+    int drawPos = 0;
+    int frameCount = 100;
+    for(int i = 0; i < frameCount; i ++) {
+        setupOffscreenTarget();
+        gRenderSurfaceW = rsAllocationGetDimX(gRenderBufferColor);
+        gRenderSurfaceH = rsAllocationGetDimY(gRenderBufferColor);
+        rsgClearColor(0.1f, 0.1f, 0.1f, 1.0f);
+        rsgClearDepth(1.0f);
+
+        runTest(benchMode);
+        rsgClearAllRenderTargets();
+        gRenderSurfaceW = rsgGetWidth();
+        gRenderSurfaceH = rsgGetHeight();
+        int size = 8;
+        drawOffscreenResult((drawPos+=size)%gRenderSurfaceW, (gRenderSurfaceH * 3) / 4, size, size);
+        gDt = rsGetDt();
+    }
+
+    rsgFinish();
+
+    int64_t end = rsUptimeMillis();
+    float fps = (float)(frameCount) / ((float)(end - start)*0.001f);
+    rsDebug(testNames[benchMode], fps);
+
+    drawOffscreenResult(0, 0,
+                        gRenderSurfaceW / 2,
+                        gRenderSurfaceH / 2);
+
+    const char* text = testNames[benchMode];
+    int left = 0, right = 0, top = 0, bottom = 0;
+    uint width = rsgGetWidth();
+    uint height = rsgGetHeight();
+    rsgFontColor(0.9f, 0.9f, 0.95f, 1.0f);
+    rsgBindFont(gFontSerifBoldItalic);
+    rsgMeasureText(text, &left, &right, &top, &bottom);
+    rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
+    rsgDrawText(text, 2 -left, height - 2 + bottom);
+
+    benchMode ++;
+
+    gTorusRotation = 0;
+
+    if (benchMode > gMaxModes) {
+        benchMode = 0;
+    }
 
     return 1;
 }