diff options
Diffstat (limited to 'libs/rs')
22 files changed, 366 insertions, 499 deletions
diff --git a/libs/rs/Android.mk b/libs/rs/Android.mk index 7afc4f2..37c418b 100644 --- a/libs/rs/Android.mk +++ b/libs/rs/Android.mk @@ -102,7 +102,6 @@ LOCAL_SRC_FILES:= \ rsScriptC_LibGL.cpp \ rsShaderCache.cpp \ rsSignal.cpp \ - rsSimpleMesh.cpp \ rsStream.cpp \ rsThreadIO.cpp \ rsType.cpp \ diff --git a/libs/rs/RenderScript.h b/libs/rs/RenderScript.h index 1428318..8e6b5c6 100644 --- a/libs/rs/RenderScript.h +++ b/libs/rs/RenderScript.h @@ -38,7 +38,7 @@ typedef void * RsFile; typedef void * RsFont; typedef void * RsSampler; typedef void * RsScript; -typedef void * RsSimpleMesh; +typedef void * RsMesh; typedef void * RsType; typedef void * RsLight; typedef void * RsObjectBase; @@ -229,7 +229,6 @@ enum RsAnimationEdge { enum RsA3DClassID { RS_A3D_CLASS_ID_UNKNOWN, RS_A3D_CLASS_ID_MESH, - RS_A3D_CLASS_ID_SIMPLE_MESH, RS_A3D_CLASS_ID_TYPE, RS_A3D_CLASS_ID_ELEMENT, RS_A3D_CLASS_ID_ALLOCATION, diff --git a/libs/rs/RenderScriptEnv.h b/libs/rs/RenderScriptEnv.h index 144e539..9225904 100644 --- a/libs/rs/RenderScriptEnv.h +++ b/libs/rs/RenderScriptEnv.h @@ -9,7 +9,7 @@ typedef void * RsDevice; typedef void * RsElement; typedef void * RsSampler; typedef void * RsScript; -typedef void * RsSimpleMesh; +typedef void * RsMesh; typedef void * RsType; typedef void * RsProgramFragment; typedef void * RsProgramStore; diff --git a/libs/rs/java/Fountain/res/raw/fountain.rs b/libs/rs/java/Fountain/res/raw/fountain.rs index 2ecb391..c8c10cd 100644 --- a/libs/rs/java/Fountain/res/raw/fountain.rs +++ b/libs/rs/java/Fountain/res/raw/fountain.rs @@ -35,7 +35,7 @@ int root() { p++; } - rsgDrawSimpleMesh(partMesh); + rsgDrawMesh(partMesh); return 1; } diff --git a/libs/rs/java/Fountain/res/raw/fountain_bc.bc b/libs/rs/java/Fountain/res/raw/fountain_bc.bc Binary files differindex 822f30a..2c8ce8b 100644 --- a/libs/rs/java/Fountain/res/raw/fountain_bc.bc +++ b/libs/rs/java/Fountain/res/raw/fountain_bc.bc diff --git a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java index c001e84..cfe8e27 100644 --- a/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java +++ b/libs/rs/java/Fountain/src/com/android/fountain/FountainRS.java @@ -36,11 +36,10 @@ public class FountainRS { ScriptField_Point points = new ScriptField_Point(mRS, PART_COUNT); - SimpleMesh.Builder smb = new SimpleMesh.Builder(mRS); - int vtxSlot = smb.addVertexType(points.getType()); - smb.setPrimitive(Primitive.POINT); - SimpleMesh sm = smb.create(); - sm.bindVertexAllocation(points.getAllocation(), vtxSlot); + Mesh.AllocationBuilder smb = new Mesh.AllocationBuilder(mRS); + smb.addVertexAllocation(points.getAllocation()); + smb.addIndexType(Primitive.POINT); + Mesh sm = smb.create(); mScript = new ScriptC_Fountain(mRS, mRes, R.raw.fountain_bc, true); mScript.set_partMesh(sm); diff --git a/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java b/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java index 95ce1ab..0ec0009 100644 --- a/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java +++ b/libs/rs/java/Fountain/src/com/android/fountain/ScriptC_Fountain.java @@ -27,13 +27,13 @@ public class ScriptC_Fountain extends ScriptC { } private final static int mExportVarIdx_partMesh = 0; - private SimpleMesh mExportVar_partMesh; - public void set_partMesh(SimpleMesh v) { + private Mesh mExportVar_partMesh; + public void set_partMesh(Mesh v) { mExportVar_partMesh = v; setVar(mExportVarIdx_partMesh, (v == null) ? 0 : v.getID()); } - public SimpleMesh get_partMesh() { + public Mesh get_partMesh() { return mExportVar_partMesh; } diff --git a/libs/rs/java/ModelViewer/res/raw/modelviewer.rs b/libs/rs/java/ModelViewer/res/raw/modelviewer.rs index 91194e8..559bf48 100644 --- a/libs/rs/java/ModelViewer/res/raw/modelviewer.rs +++ b/libs/rs/java/ModelViewer/res/raw/modelviewer.rs @@ -62,7 +62,7 @@ int root(int launchID) { rsMatrixRotate(&matrix, gRotate, 0.0f, 1.0f, 0.0f); rsgProgramVertexLoadModelMatrix(&matrix); - rsgDrawSimpleMesh(gTestMesh); + rsgDrawMesh(gTestMesh); color(0.3f, 0.3f, 0.3f, 1.0f); rsgDrawText("Renderscript model test", 30, 695); diff --git a/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc b/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc Binary files differindex a64e725..fb85028 100644 --- a/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc +++ b/libs/rs/java/ModelViewer/res/raw/modelviewer_bc.bc diff --git a/libs/rs/java/ModelViewer/res/raw/robot.a3d b/libs/rs/java/ModelViewer/res/raw/robot.a3d Binary files differindex c0c66ae..430fe95 100644 --- a/libs/rs/java/ModelViewer/res/raw/robot.a3d +++ b/libs/rs/java/ModelViewer/res/raw/robot.a3d diff --git a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java index b6485dc..37eb9c1 100644 --- a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java +++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ModelViewerRS.java @@ -55,7 +55,7 @@ public class ModelViewerRS { private Allocation mGridImage; private Allocation mAllocPV; - private SimpleMesh mMesh; + private Mesh mMesh; private Font mItalic; private Allocation mTextAlloc; @@ -149,15 +149,15 @@ public class ModelViewerRS { FileA3D model = FileA3D.createFromResource(mRS, mRes, R.raw.robot); FileA3D.IndexEntry entry = model.getIndexEntry(0); - if(entry == null || entry.getClassID() != FileA3D.ClassID.SIMPLE_MESH) { + if(entry == null || entry.getClassID() != FileA3D.ClassID.MESH) { Log.e("rs", "could not load model"); } else { - mMesh = (SimpleMesh)entry.getObject(); + mMesh = (Mesh)entry.getObject(); mScript.set_gTestMesh(mMesh); } - mItalic = Font.create(mRS, mRes, "DroidSerif-Italic.ttf", 10); + mItalic = Font.create(mRS, mRes, "DroidSerif-Italic.ttf", 8); mScript.set_gItalic(mItalic); initTextAllocation(); diff --git a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_Modelviewer.java b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_Modelviewer.java index d3a2a29..06c10ab 100644 --- a/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_Modelviewer.java +++ b/libs/rs/java/ModelViewer/src/com/android/modelviewer/ScriptC_Modelviewer.java @@ -60,13 +60,13 @@ public class ScriptC_Modelviewer extends ScriptC { } private final static int mExportVarIdx_gTestMesh = 3; - private SimpleMesh mExportVar_gTestMesh; - public void set_gTestMesh(SimpleMesh v) { + private Mesh mExportVar_gTestMesh; + public void set_gTestMesh(Mesh v) { mExportVar_gTestMesh = v; setVar(mExportVarIdx_gTestMesh, (v == null) ? 0 : v.getID()); } - public SimpleMesh get_gTestMesh() { + public Mesh get_gTestMesh() { return mExportVar_gTestMesh; } diff --git a/libs/rs/rs.spec b/libs/rs/rs.spec index 3694b65..172ba66 100644 --- a/libs/rs/rs.spec +++ b/libs/rs/rs.spec @@ -478,8 +478,34 @@ FontCreateFromFile { ret RsFont } +MeshCreate { + ret RsMesh + param uint32_t vtxCount + param uint32_t idxCount + } + +MeshBindIndex { + param RsMesh mesh + param RsAllocation idx + param uint32_t primType + param uint32_t slot + } + +MeshBindPrimitive { + param RsMesh mesh + param RsAllocation prim + param uint32_t primType + param uint32_t slot + } + +MeshBindVertex { + param RsMesh mesh + param RsAllocation vtx + param uint32_t slot + } + SimpleMeshCreate { - ret RsSimpleMesh + ret RsMesh param RsAllocation prim param RsAllocation index param RsAllocation *vtx @@ -489,17 +515,17 @@ SimpleMeshCreate { SimpleMeshBindIndex { - param RsSimpleMesh mesh + param RsMesh mesh param RsAllocation idx } SimpleMeshBindPrimitive { - param RsSimpleMesh mesh + param RsMesh mesh param RsAllocation prim } SimpleMeshBindVertex { - param RsSimpleMesh mesh + param RsMesh mesh param RsAllocation vtx param uint32_t slot } diff --git a/libs/rs/rsContext.h b/libs/rs/rsContext.h index 73f478a..06433a1 100644 --- a/libs/rs/rsContext.h +++ b/libs/rs/rsContext.h @@ -24,7 +24,6 @@ #include "rsType.h" #include "rsMatrix.h" #include "rsAllocation.h" -#include "rsSimpleMesh.h" #include "rsMesh.h" #include "rsDevice.h" #include "rsScriptC.h" diff --git a/libs/rs/rsContextHostStub.h b/libs/rs/rsContextHostStub.h index be1fff6..c437606 100644 --- a/libs/rs/rsContextHostStub.h +++ b/libs/rs/rsContextHostStub.h @@ -24,7 +24,6 @@ #include "rsType.h" #include "rsMatrix.h" #include "rsAllocation.h" -#include "rsSimpleMesh.h" #include "rsMesh.h" //#include "rsDevice.h" #include "rsScriptC.h" diff --git a/libs/rs/rsFileA3D.cpp b/libs/rs/rsFileA3D.cpp index 4fac421..5709f2a 100644 --- a/libs/rs/rsFileA3D.cpp +++ b/libs/rs/rsFileA3D.cpp @@ -258,9 +258,6 @@ ObjectBase *FileA3D::initializeFromEntry(size_t index) { case RS_A3D_CLASS_ID_MESH: entry->mRsObj = Mesh::createFromStream(mRSC, mReadStream); break; - case RS_A3D_CLASS_ID_SIMPLE_MESH: - entry->mRsObj = SimpleMesh::createFromStream(mRSC, mReadStream); - break; case RS_A3D_CLASS_ID_TYPE: entry->mRsObj = Type::createFromStream(mRSC, mReadStream); break; diff --git a/libs/rs/rsMesh.cpp b/libs/rs/rsMesh.cpp index bd9cd27..4f90f36 100644 --- a/libs/rs/rsMesh.cpp +++ b/libs/rs/rsMesh.cpp @@ -35,43 +35,138 @@ Mesh::Mesh(Context *rsc) : ObjectBase(rsc) { mAllocFile = __FILE__; mAllocLine = __LINE__; - mVerticies = NULL; - mVerticiesCount = 0; mPrimitives = NULL; mPrimitivesCount = 0; + mVertexBuffers = NULL; + mVertexTypes = NULL; + mVertexBufferCount = 0; } Mesh::~Mesh() { + if(mVertexTypes) { + delete[] mVertexTypes; + } + + if(mVertexBuffers) { + delete[] mVertexBuffers; + } + + if(mPrimitives) { + for(uint32_t i = 0; i < mPrimitivesCount; i ++) { + delete mPrimitives[i]; + } + delete[] mPrimitives; + } } -void Mesh::serialize(OStream *stream) const +void Mesh::render(Context *rsc) const { - // Need to identify ourselves - stream->addU32((uint32_t)getClassId()); + for(uint32_t ct = 0; ct < mPrimitivesCount; ct ++) { + renderPrimitive(rsc, ct); + } +} - String8 name(getName()); - stream->addString(&name); +void Mesh::renderPrimitive(Context *rsc, uint32_t primIndex) const { + if (primIndex >= mPrimitivesCount) { + LOGE("Invalid primitive index"); + return; + } - stream->addU32(mVerticiesCount); + Primitive_t *prim = mPrimitives[primIndex]; - for(uint32_t vCount = 0; vCount < mVerticiesCount; vCount ++) { - Verticies_t *verts = mVerticies[vCount]; + if (prim->mIndexBuffer.get()) { + renderPrimitiveRange(rsc, primIndex, 0, prim->mIndexBuffer->getType()->getDimX()); + return; + } - stream->addU32(verts->mAllocationCount); + if (prim->mPrimitiveBuffer.get()) { + renderPrimitiveRange(rsc, primIndex, 0, prim->mPrimitiveBuffer->getType()->getDimX()); + return; + } + + renderPrimitiveRange(rsc, primIndex, 0, mVertexBuffers[0]->getType()->getDimX()); +} - for (uint32_t aCount = 0; aCount < verts->mAllocationCount; aCount++) { - verts->mAllocations[aCount]->serialize(stream); +void Mesh::renderPrimitiveRange(Context *rsc, uint32_t primIndex, uint32_t start, uint32_t len) const +{ + if (len < 1 || primIndex >= mPrimitivesCount) { + return; + } + + rsc->checkError("Mesh::renderPrimitiveRange 1"); + VertexArray va; + for (uint32_t ct=0; ct < mVertexBufferCount; ct++) { + mVertexBuffers[ct]->uploadCheck(rsc); + if (mVertexBuffers[ct]->getIsBufferObject()) { + va.setActiveBuffer(mVertexBuffers[ct]->getBufferObjectID()); + } else { + va.setActiveBuffer(mVertexBuffers[ct]->getPtr()); } - stream->addU32(verts->mVertexDataSize); + mVertexBuffers[ct]->getType()->enableGLVertexBuffer(&va); + } + va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache); + + rsc->checkError("Mesh::renderPrimitiveRange 2"); + Primitive_t *prim = mPrimitives[primIndex]; + if (prim->mIndexBuffer.get()) { + prim->mIndexBuffer->uploadCheck(rsc); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prim->mIndexBuffer->getBufferObjectID()); + glDrawElements(prim->mGLPrimitive, len, GL_UNSIGNED_SHORT, (uint16_t *)(start * 2)); + } else { + glDrawArrays(prim->mGLPrimitive, start, len); + } + + rsc->checkError("Mesh::renderPrimitiveRange"); +} - stream->addU32(verts->mOffsetCoord); - stream->addU32(verts->mOffsetTex); - stream->addU32(verts->mOffsetNorm); - stream->addU32(verts->mSizeCoord); - stream->addU32(verts->mSizeTex); - stream->addU32(verts->mSizeNorm ); +void Mesh::uploadAll(Context *rsc) +{ + for (uint32_t ct = 0; ct < mVertexBufferCount; ct ++) { + if (mVertexBuffers[ct].get()) { + mVertexBuffers[ct]->deferedUploadToBufferObject(rsc); + } + } + + for (uint32_t ct = 0; ct < mPrimitivesCount; ct ++) { + if (mPrimitives[ct]->mIndexBuffer.get()) { + mPrimitives[ct]->mIndexBuffer->deferedUploadToBufferObject(rsc); + } + if (mPrimitives[ct]->mPrimitiveBuffer.get()) { + mPrimitives[ct]->mPrimitiveBuffer->deferedUploadToBufferObject(rsc); + } + } + + rsc->checkError("Mesh::uploadAll"); +} + +void Mesh::updateGLPrimitives() +{ + for(uint32_t i = 0; i < mPrimitivesCount; i ++) { + switch(mPrimitives[i]->mPrimitive) { + case RS_PRIMITIVE_POINT: mPrimitives[i]->mGLPrimitive = GL_POINTS; break; + case RS_PRIMITIVE_LINE: mPrimitives[i]->mGLPrimitive = GL_LINES; break; + case RS_PRIMITIVE_LINE_STRIP: mPrimitives[i]->mGLPrimitive = GL_LINE_STRIP; break; + case RS_PRIMITIVE_TRIANGLE: mPrimitives[i]->mGLPrimitive = GL_TRIANGLES; break; + case RS_PRIMITIVE_TRIANGLE_STRIP: mPrimitives[i]->mGLPrimitive = GL_TRIANGLE_STRIP; break; + case RS_PRIMITIVE_TRIANGLE_FAN: mPrimitives[i]->mGLPrimitive = GL_TRIANGLE_FAN; break; + } + } +} + +void Mesh::serialize(OStream *stream) const +{ + // Need to identify ourselves + stream->addU32((uint32_t)getClassId()); + + String8 name(getName()); + stream->addString(&name); + + // Store number of vertex streams + stream->addU32(mVertexBufferCount); + for(uint32_t vCount = 0; vCount < mVertexBufferCount; vCount ++) { + mVertexBuffers[vCount]->serialize(stream); } stream->addU32(mPrimitivesCount); @@ -79,27 +174,22 @@ void Mesh::serialize(OStream *stream) const for (uint32_t pCount = 0; pCount < mPrimitivesCount; pCount ++) { Primitive_t * prim = mPrimitives[pCount]; - stream->addU8((uint8_t)prim->mType); + stream->addU8((uint8_t)prim->mPrimitive); - // We store the index to the vertices - // So iterate over our vertices to find which one we point to - uint32_t vertexIndex = 0; - for(uint32_t vCount = 0; vCount < mVerticiesCount; vCount ++) { - if(prim->mVerticies == mVerticies[vCount]) { - vertexIndex = vCount; - break; - } + if(prim->mIndexBuffer.get()) { + stream->addU32(1); + prim->mIndexBuffer->serialize(stream); } - stream->addU32(vertexIndex); - - stream->addU32(prim->mIndexCount); - for (uint32_t ct = 0; ct < prim->mIndexCount; ct++) { - stream->addU16(prim->mIndicies[ct]); + else { + stream->addU32(0); } - stream->addU32(prim->mRestartCounts); - for (uint32_t ct = 0; ct < prim->mRestartCounts; ct++) { - stream->addU16(prim->mRestarts[ct]); + if(prim->mPrimitiveBuffer.get()) { + stream->addU32(1); + prim->mPrimitiveBuffer->serialize(stream); + } + else { + stream->addU32(0); } } } @@ -119,86 +209,46 @@ Mesh *Mesh::createFromStream(Context *rsc, IStream *stream) stream->loadString(&name); mesh->setName(name.string(), name.size()); - mesh->mVerticiesCount = stream->loadU32(); - if(mesh->mVerticiesCount) { - mesh->mVerticies = new Verticies_t *[mesh->mVerticiesCount]; - } - else { - mesh->mVerticies = NULL; - } - - for(uint32_t vCount = 0; vCount < mesh->mVerticiesCount; vCount ++) { - Verticies_t *verts = new Verticies_t(); - // Store our vertices one the mesh - mesh->mVerticies[vCount] = verts; - - verts->mAllocationCount = stream->loadU32(); - verts->mAllocations = new Allocation *[verts->mAllocationCount]; + mesh->mVertexBufferCount = stream->loadU32(); + if(mesh->mVertexBufferCount) { + mesh->mVertexBuffers = new ObjectBaseRef<Allocation>[mesh->mVertexBufferCount]; - LOGE("processChunk_Verticies count %i", verts->mAllocationCount); - for (uint32_t aCount = 0; aCount < verts->mAllocationCount; aCount++) { - verts->mAllocations[aCount] = Allocation::createFromStream(rsc, stream); + for(uint32_t vCount = 0; vCount < mesh->mVertexBufferCount; vCount ++) { + Allocation *vertexAlloc = Allocation::createFromStream(rsc, stream); + mesh->mVertexBuffers[vCount].set(vertexAlloc); } - verts->mVertexDataSize = stream->loadU32(); - - verts->mOffsetCoord = stream->loadU32(); - verts->mOffsetTex = stream->loadU32(); - verts->mOffsetNorm = stream->loadU32(); - - verts->mSizeCoord = stream->loadU32(); - verts->mSizeTex = stream->loadU32(); - verts->mSizeNorm = stream->loadU32(); } mesh->mPrimitivesCount = stream->loadU32(); if(mesh->mPrimitivesCount) { mesh->mPrimitives = new Primitive_t *[mesh->mPrimitivesCount]; - } - else { - mesh->mPrimitives = NULL; - } - // load all primitives - for (uint32_t pCount = 0; pCount < mesh->mPrimitivesCount; pCount ++) { - Primitive_t * prim = new Primitive_t; - mesh->mPrimitives[pCount] = prim; + // load all primitives + for (uint32_t pCount = 0; pCount < mesh->mPrimitivesCount; pCount ++) { + Primitive_t * prim = new Primitive_t; + mesh->mPrimitives[pCount] = prim; - prim->mType = (RsPrimitive)stream->loadU8(); - - // We store the index to the vertices - uint32_t vertexIndex = stream->loadU32(); - if(vertexIndex < mesh->mVerticiesCount) { - prim->mVerticies = mesh->mVerticies[vertexIndex]; - } - else { - prim->mVerticies = NULL; - } + prim->mPrimitive = (RsPrimitive)stream->loadU8(); - prim->mIndexCount = stream->loadU32(); - if(prim->mIndexCount){ - prim->mIndicies = new uint16_t[prim->mIndexCount]; - for (uint32_t ct = 0; ct < prim->mIndexCount; ct++) { - prim->mIndicies[ct] = stream->loadU16(); + // Check to see if the index buffer was stored + uint32_t isIndexPresent = stream->loadU32(); + if(isIndexPresent) { + Allocation *indexAlloc = Allocation::createFromStream(rsc, stream); + prim->mIndexBuffer.set(indexAlloc); } - } - else { - prim->mIndicies = NULL; - } - - prim->mRestartCounts = stream->loadU32(); - if (prim->mRestartCounts) { - prim->mRestarts = new uint16_t[prim->mRestartCounts]; - for (uint32_t ct = 0; ct < prim->mRestartCounts; ct++) { - prim->mRestarts[ct] = stream->loadU16(); + // Check to see if the primitive buffer was stored + uint32_t isPrimitivePresent = stream->loadU32(); + if(isPrimitivePresent) { + Allocation *primitiveAlloc = Allocation::createFromStream(rsc, stream); + prim->mPrimitiveBuffer.set(primitiveAlloc); } } - else { - prim->mRestarts = NULL; - } - } + mesh->updateGLPrimitives(); + mesh->uploadAll(rsc); + return mesh; } @@ -211,3 +261,103 @@ MeshContext::~MeshContext() { } +namespace android { +namespace renderscript { + +RsMesh rsi_MeshCreate(Context *rsc, uint32_t vtxCount, uint32_t idxCount) +{ + Mesh *sm = new Mesh(rsc); + sm->incUserRef(); + + sm->mPrimitivesCount = idxCount; + sm->mPrimitives = new Mesh::Primitive_t *[sm->mPrimitivesCount]; + for(uint32_t ct = 0; ct < idxCount; ct ++) { + sm->mPrimitives[ct] = new Mesh::Primitive_t; + } + + sm->mVertexBufferCount = vtxCount; + sm->mVertexBuffers = new ObjectBaseRef<Allocation>[vtxCount]; + sm->mVertexTypes = new ObjectBaseRef<const Type>[vtxCount]; + + return sm; +} + +void rsi_MeshBindVertex(Context *rsc, RsMesh mv, RsAllocation va, uint32_t slot) +{ + Mesh *sm = static_cast<Mesh *>(mv); + rsAssert(slot < sm->mVertexBufferCount); + + sm->mVertexBuffers[slot].set((Allocation *)va); +} + +void rsi_MeshBindIndex(Context *rsc, RsMesh mv, RsAllocation va, uint32_t primType, uint32_t slot) +{ + Mesh *sm = static_cast<Mesh *>(mv); + rsAssert(slot < sm->mPrimitivesCount); + + sm->mPrimitives[slot]->mIndexBuffer.set((Allocation *)va); + sm->mPrimitives[slot]->mPrimitive = (RsPrimitive)primType; + sm->updateGLPrimitives(); +} + +void rsi_MeshBindPrimitive(Context *rsc, RsMesh mv, RsAllocation va, uint32_t primType, uint32_t slot) +{ + Mesh *sm = static_cast<Mesh *>(mv); + rsAssert(slot < sm->mPrimitivesCount); + + sm->mPrimitives[slot]->mPrimitiveBuffer.set((Allocation *)va); + sm->mPrimitives[slot]->mPrimitive = (RsPrimitive)primType; + sm->updateGLPrimitives(); +} + + +// Route all the simple mesh through mesh + +RsMesh rsi_SimpleMeshCreate(Context *rsc, RsType prim, RsType idx, RsType *vtx, uint32_t vtxCount, uint32_t primType) +{ + Mesh *sm = new Mesh(rsc); + sm->incUserRef(); + + sm->mPrimitivesCount = 1; + sm->mPrimitives = new Mesh::Primitive_t *[sm->mPrimitivesCount]; + sm->mPrimitives[0] = new Mesh::Primitive_t; + + sm->mPrimitives[0]->mIndexType.set((const Type *)idx); + sm->mPrimitives[0]->mPrimitiveType.set((const Type *)prim); + sm->mPrimitives[0]->mPrimitive = (RsPrimitive)primType; + sm->updateGLPrimitives(); + + sm->mVertexBufferCount = vtxCount; + sm->mVertexTypes = new ObjectBaseRef<const Type>[vtxCount]; + sm->mVertexBuffers = new ObjectBaseRef<Allocation>[vtxCount]; + for (uint32_t ct=0; ct < vtxCount; ct++) { + sm->mVertexTypes[ct].set((const Type *)vtx[ct]); + } + + return sm; +} + +void rsi_SimpleMeshBindVertex(Context *rsc, RsMesh mv, RsAllocation va, uint32_t slot) +{ + Mesh *sm = static_cast<Mesh *>(mv); + rsAssert(slot < sm->mVertexBufferCount); + + sm->mVertexBuffers[slot].set((Allocation *)va); +} + +void rsi_SimpleMeshBindIndex(Context *rsc, RsMesh mv, RsAllocation va) +{ + Mesh *sm = static_cast<Mesh *>(mv); + sm->mPrimitives[0]->mIndexBuffer.set((Allocation *)va); +} + +void rsi_SimpleMeshBindPrimitive(Context *rsc, RsMesh mv, RsAllocation va) +{ + Mesh *sm = static_cast<Mesh *>(mv); + sm->mPrimitives[0]->mPrimitiveBuffer.set((Allocation *)va); +} + + + + +}} diff --git a/libs/rs/rsMesh.h b/libs/rs/rsMesh.h index 8c7e8a4..66174b7 100644 --- a/libs/rs/rsMesh.h +++ b/libs/rs/rsMesh.h @@ -32,43 +32,35 @@ public: Mesh(Context *); ~Mesh(); - struct Verticies_t - { - Allocation ** mAllocations; - uint32_t mAllocationCount; - - size_t mVertexDataSize; - - size_t mOffsetCoord; - size_t mOffsetTex; - size_t mOffsetNorm; - - size_t mSizeCoord; - size_t mSizeTex; - size_t mSizeNorm; - - uint32_t mBufferObject; - }; - + // Contains vertex data + // Position, normal, texcoord, etc could either be strided in one allocation + // of provided separetely in multiple ones + ObjectBaseRef<Allocation> *mVertexBuffers; + ObjectBaseRef<const Type> *mVertexTypes; + uint32_t mVertexBufferCount; + + // Either mIndexBuffer, mPrimitiveBuffer or both could have a NULL reference + // If both are null, mPrimitive only would be used to render the mesh struct Primitive_t { - RsPrimitive mType; - Verticies_t *mVerticies; - - uint32_t mIndexCount; - uint16_t *mIndicies; + ObjectBaseRef<Allocation> mIndexBuffer; + ObjectBaseRef<Allocation> mPrimitiveBuffer; + ObjectBaseRef<const Type> mIndexType; + ObjectBaseRef<const Type> mPrimitiveType; - uint32_t mRestartCounts; - uint16_t *mRestarts; + RsPrimitive mPrimitive; + uint32_t mGLPrimitive; }; - Verticies_t ** mVerticies; - uint32_t mVerticiesCount; - Primitive_t ** mPrimitives; uint32_t mPrimitivesCount; - void analyzeElement(); + void render(Context *) const; + void renderPrimitive(Context *, uint32_t primIndex) const; + void renderPrimitiveRange(Context *, uint32_t primIndex, uint32_t start, uint32_t len) const; + void uploadAll(Context *); + void updateGLPrimitives(); + virtual void serialize(OStream *stream) const; virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_MESH; } static Mesh *createFromStream(Context *rsc, IStream *stream); @@ -90,3 +82,4 @@ public: #endif //ANDROID_RS_TRIANGLE_MESH_H + diff --git a/libs/rs/rsScriptC_LibGL.cpp b/libs/rs/rsScriptC_LibGL.cpp index dbd398e..7185009 100644 --- a/libs/rs/rsScriptC_LibGL.cpp +++ b/libs/rs/rsScriptC_LibGL.cpp @@ -43,10 +43,10 @@ using namespace android::renderscript; // IO routines ////////////////////////////////////////////////////////////////////////////// -static void SC_updateSimpleMesh(RsSimpleMesh mesh) +static void SC_updateSimpleMesh(RsMesh mesh) { GET_TLS(); - SimpleMesh *sm = static_cast<SimpleMesh *>(mesh); + Mesh *sm = static_cast<Mesh *>(mesh); sm->uploadAll(rsc); } @@ -220,24 +220,54 @@ static void SC_drawRect(float x1, float y1, x1, y1, z); } -static void SC_drawSimpleMesh(RsSimpleMesh vsm) +static void SC_drawSimpleMesh(RsMesh vsm) { GET_TLS(); - SimpleMesh *sm = static_cast<SimpleMesh *>(vsm); + Mesh *sm = static_cast<Mesh *>(vsm); + if (!rsc->setupCheck()) { + return; + } + sm->renderPrimitive(rsc, 0); +} + +static void SC_drawSimpleMeshRange(RsMesh vsm, uint32_t start, uint32_t len) +{ + GET_TLS(); + Mesh *sm = static_cast<Mesh *>(vsm); + if (!rsc->setupCheck()) { + return; + } + sm->renderPrimitiveRange(rsc, 0, start, len); +} + +static void SC_drawMesh(RsMesh vsm) +{ + GET_TLS(); + Mesh *sm = static_cast<Mesh *>(vsm); if (!rsc->setupCheck()) { return; } sm->render(rsc); } -static void SC_drawSimpleMeshRange(RsSimpleMesh vsm, uint32_t start, uint32_t len) +static void SC_drawMeshPrimitive(RsMesh vsm, uint32_t primIndex) { GET_TLS(); - SimpleMesh *sm = static_cast<SimpleMesh *>(vsm); + Mesh *sm = static_cast<Mesh *>(vsm); if (!rsc->setupCheck()) { return; } - sm->renderRange(rsc, start, len); + sm->renderPrimitive(rsc, primIndex); +} + +static void SC_drawMeshPrimitiveRange(RsMesh vsm, uint32_t primIndex, uint32_t start, uint32_t len) +{ + GET_TLS(); + Mesh *sm = static_cast<Mesh *>(vsm); + if (!rsc->setupCheck()) { + return; + } + sm->renderPrimitiveRange(rsc, primIndex, start, len); } @@ -375,6 +405,10 @@ static ScriptCState::SymbolTable_t gSyms[] = { { "_Z17rsgDrawSimpleMesh7rs_mesh", (void *)&SC_drawSimpleMesh }, { "_Z17rsgDrawSimpleMesh7rs_meshii", (void *)&SC_drawSimpleMeshRange }, + { "_Z11rsgDrawMesh7rs_mesh", (void *)&SC_drawMesh }, + { "_Z11rsgDrawMesh7rs_meshi", (void *)&SC_drawMeshPrimitive }, + { "_Z11rsgDrawMesh7rs_meshiii", (void *)&SC_drawMeshPrimitiveRange }, + { "rsgClearColor", (void *)&SC_ClearColor }, { "rsgClearDepth", (void *)&SC_ClearDepth }, diff --git a/libs/rs/rsSimpleMesh.cpp b/libs/rs/rsSimpleMesh.cpp deleted file mode 100644 index e5c2eb5..0000000 --- a/libs/rs/rsSimpleMesh.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - * Copyright (C) 2009 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ANDROID_RS_BUILD_FOR_HOST -#include "rsContext.h" - -#include <GLES/gl.h> -#include <GLES2/gl2.h> -#include <GLES/glext.h> -#else -#include "rsContextHostStub.h" - -#include <OpenGL/gl.h> -#include <OpenGl/glext.h> -#endif - -using namespace android; -using namespace android::renderscript; - - - - -SimpleMesh::SimpleMesh(Context *rsc) : ObjectBase(rsc) -{ - mAllocFile = __FILE__; - mAllocLine = __LINE__; -} - -SimpleMesh::~SimpleMesh() -{ - delete[] mVertexTypes; - delete[] mVertexBuffers; -} - -void SimpleMesh::render(Context *rsc) const -{ - if (mPrimitiveType.get()) { - renderRange(rsc, 0, mPrimitiveType->getDimX()); - return; - } - - if (mIndexType.get()) { - renderRange(rsc, 0, mIndexType->getDimX()); - return; - } - - renderRange(rsc, 0, mVertexTypes[0]->getDimX()); -} - -void SimpleMesh::renderRange(Context *rsc, uint32_t start, uint32_t len) const -{ - if (len < 1) { - return; - } - - rsc->checkError("SimpleMesh::renderRange 1"); - VertexArray va; - for (uint32_t ct=0; ct < mVertexTypeCount; ct++) { - mVertexBuffers[ct]->uploadCheck(rsc); - if (mVertexBuffers[ct]->getIsBufferObject()) { - va.setActiveBuffer(mVertexBuffers[ct]->getBufferObjectID()); - } else { - va.setActiveBuffer(mVertexBuffers[ct]->getPtr()); - } - mVertexTypes[ct]->enableGLVertexBuffer(&va); - } - va.setupGL2(rsc, &rsc->mStateVertexArray, &rsc->mShaderCache); - - rsc->checkError("SimpleMesh::renderRange 2"); - if (mIndexType.get()) { - mIndexBuffer->uploadCheck(rsc); - glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer->getBufferObjectID()); - glDrawElements(mGLPrimitive, len, GL_UNSIGNED_SHORT, (uint16_t *)(start * 2)); - } else { - glDrawArrays(mGLPrimitive, start, len); - } - - rsc->checkError("SimpleMesh::renderRange"); -} - -void SimpleMesh::uploadAll(Context *rsc) -{ - for (uint32_t ct=0; ct < mVertexTypeCount; ct++) { - if (mVertexBuffers[ct].get()) { - mVertexBuffers[ct]->deferedUploadToBufferObject(rsc); - } - } - if (mIndexBuffer.get()) { - mIndexBuffer->deferedUploadToBufferObject(rsc); - } - if (mPrimitiveBuffer.get()) { - mPrimitiveBuffer->deferedUploadToBufferObject(rsc); - } - rsc->checkError("SimpleMesh::uploadAll"); -} - -void SimpleMesh::updateGLPrimitive() -{ - switch(mPrimitive) { - case RS_PRIMITIVE_POINT: mGLPrimitive = GL_POINTS; break; - case RS_PRIMITIVE_LINE: mGLPrimitive = GL_LINES; break; - case RS_PRIMITIVE_LINE_STRIP: mGLPrimitive = GL_LINE_STRIP; break; - case RS_PRIMITIVE_TRIANGLE: mGLPrimitive = GL_TRIANGLES; break; - case RS_PRIMITIVE_TRIANGLE_STRIP: mGLPrimitive = GL_TRIANGLE_STRIP; break; - case RS_PRIMITIVE_TRIANGLE_FAN: mGLPrimitive = GL_TRIANGLE_FAN; break; - } -} - -void SimpleMesh::serialize(OStream *stream) const -{ - // Need to identify ourselves - stream->addU32((uint32_t)getClassId()); - - String8 name(getName()); - stream->addString(&name); - - // Add primitive type - stream->addU8((uint8_t)mPrimitive); - - // And now serialize the allocations - mIndexBuffer->serialize(stream); - - // We need to indicate if the primitive buffer is present - if(mPrimitiveBuffer.get() != NULL) { - // Write if the primitive buffer is present - stream->addU32(1); - mPrimitiveBuffer->serialize(stream); - } - else { - // No buffer present, will need this when we read - stream->addU32(0); - } - - // Store number of vertex streams - stream->addU32(mVertexTypeCount); - for(uint32_t vCount = 0; vCount < mVertexTypeCount; vCount ++) { - mVertexBuffers[vCount]->serialize(stream); - } -} - -SimpleMesh *SimpleMesh::createFromStream(Context *rsc, IStream *stream) -{ - // First make sure we are reading the correct object - RsA3DClassID classID = (RsA3DClassID)stream->loadU32(); - if(classID != RS_A3D_CLASS_ID_SIMPLE_MESH) { - LOGE("simple mesh loading skipped due to invalid class id"); - return NULL; - } - - SimpleMesh * mesh = new SimpleMesh(rsc); - - String8 name; - stream->loadString(&name); - mesh->setName(name.string(), name.size()); - - mesh->mPrimitive = (RsPrimitive)stream->loadU8(); - mesh->updateGLPrimitive(); - - Allocation *indexAlloc = Allocation::createFromStream(rsc, stream); - const Type *indexType = indexAlloc->getType(); - mesh->mIndexBuffer.set(indexAlloc); - mesh->mIndexType.set(indexType); - - bool isPrimitivePresent = stream->loadU32() != 0; - if(isPrimitivePresent) { - mesh->mPrimitiveBuffer.set(Allocation::createFromStream(rsc, stream)); - mesh->mPrimitiveType.set(mesh->mPrimitiveBuffer->getType()); - } - - mesh->mVertexTypeCount = stream->loadU32(); - if(mesh->mVertexTypeCount) { - mesh->mVertexTypes = new ObjectBaseRef<const Type>[mesh->mVertexTypeCount]; - mesh->mVertexBuffers = new ObjectBaseRef<Allocation>[mesh->mVertexTypeCount]; - - for(uint32_t vCount = 0; vCount < mesh->mVertexTypeCount; vCount ++) { - Allocation *vertexAlloc = Allocation::createFromStream(rsc, stream); - const Type *vertexType = vertexAlloc->getType(); - mesh->mVertexBuffers[vCount].set(vertexAlloc); - mesh->mVertexTypes[vCount].set(vertexType); - } - } - - mesh->uploadAll(rsc); - - return mesh; -} - - -SimpleMeshContext::SimpleMeshContext() -{ -} - -SimpleMeshContext::~SimpleMeshContext() -{ -} - - -namespace android { -namespace renderscript { - - -RsSimpleMesh rsi_SimpleMeshCreate(Context *rsc, RsType prim, RsType idx, RsType *vtx, uint32_t vtxCount, uint32_t primType) -{ - SimpleMesh *sm = new SimpleMesh(rsc); - sm->incUserRef(); - - sm->mIndexType.set((const Type *)idx); - sm->mPrimitiveType.set((const Type *)prim); - - sm->mVertexTypeCount = vtxCount; - sm->mVertexTypes = new ObjectBaseRef<const Type>[vtxCount]; - sm->mVertexBuffers = new ObjectBaseRef<Allocation>[vtxCount]; - for (uint32_t ct=0; ct < vtxCount; ct++) { - sm->mVertexTypes[ct].set((const Type *)vtx[ct]); - } - - sm->mPrimitive = (RsPrimitive)primType; - sm->updateGLPrimitive(); - return sm; -} - -void rsi_SimpleMeshBindVertex(Context *rsc, RsSimpleMesh mv, RsAllocation va, uint32_t slot) -{ - SimpleMesh *sm = static_cast<SimpleMesh *>(mv); - rsAssert(slot < sm->mVertexTypeCount); - - sm->mVertexBuffers[slot].set((Allocation *)va); -} - -void rsi_SimpleMeshBindIndex(Context *rsc, RsSimpleMesh mv, RsAllocation va) -{ - SimpleMesh *sm = static_cast<SimpleMesh *>(mv); - sm->mIndexBuffer.set((Allocation *)va); -} - -void rsi_SimpleMeshBindPrimitive(Context *rsc, RsSimpleMesh mv, RsAllocation va) -{ - SimpleMesh *sm = static_cast<SimpleMesh *>(mv); - sm->mPrimitiveBuffer.set((Allocation *)va); -} - - - - -}} - diff --git a/libs/rs/rsSimpleMesh.h b/libs/rs/rsSimpleMesh.h deleted file mode 100644 index 362c7fb..0000000 --- a/libs/rs/rsSimpleMesh.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (C) 2009 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef ANDROID_RS_SIMPLE_MESH_H -#define ANDROID_RS_SIMPLE_MESH_H - - -#include "RenderScript.h" - -// --------------------------------------------------------------------------- -namespace android { -namespace renderscript { - - -// An element is a group of Components that occupies one cell in a structure. -class SimpleMesh : public ObjectBase -{ -public: - SimpleMesh(Context *); - ~SimpleMesh(); - - ObjectBaseRef<const Type> mIndexType; - ObjectBaseRef<const Type> mPrimitiveType; - ObjectBaseRef<const Type> *mVertexTypes; - uint32_t mVertexTypeCount; - - ObjectBaseRef<Allocation> mIndexBuffer; - ObjectBaseRef<Allocation> mPrimitiveBuffer; - ObjectBaseRef<Allocation> *mVertexBuffers; - - RsPrimitive mPrimitive; - uint32_t mGLPrimitive; - - - void render(Context *) const; - void renderRange(Context *, uint32_t start, uint32_t len) const; - void uploadAll(Context *); - void updateGLPrimitive(); - - virtual void serialize(OStream *stream) const; - virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_SIMPLE_MESH; } - static SimpleMesh *createFromStream(Context *rsc, IStream *stream); - -protected: -}; - -class SimpleMeshContext -{ -public: - SimpleMeshContext(); - ~SimpleMeshContext(); - - -}; - - -} -} -#endif //ANDROID_RS_SIMPLE_MESH_H - diff --git a/libs/rs/scriptc/rs_graphics.rsh b/libs/rs/scriptc/rs_graphics.rsh index fba3d6d..1f1f1ac 100644 --- a/libs/rs/scriptc/rs_graphics.rsh +++ b/libs/rs/scriptc/rs_graphics.rsh @@ -32,6 +32,10 @@ extern void rsgDrawSpriteScreenspace(float x, float y, float z, float w, float h extern void __attribute__((overloadable)) rsgDrawSimpleMesh(rs_mesh ism); extern void __attribute__((overloadable)) rsgDrawSimpleMesh(rs_mesh ism, int start, int len); +extern void __attribute__((overloadable)) rsgDrawMesh(rs_mesh ism); +extern void __attribute__((overloadable)) rsgDrawMesh(rs_mesh ism, int primitiveIndex); +extern void __attribute__((overloadable)) rsgDrawMesh(rs_mesh ism, int primitiveIndex, int start, int len); + extern void rsgClearColor(float, float, float, float); extern void rsgClearDepth(float); |