First draft of fbo in renderscript.
Updating samples and benchmark
Change-Id: I469bf8b842fca72b59475c8fa024c12cf0e14954
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;
}
