Removed unnecessary change based on comments.
Now using android utils lib.
collada_to_a3d seems to work with android util libs.
Integrating old changelist
Changing assert to rsAssrt in VertexArray
making context compile.
Change-Id: I33890defa777f09253bfab630d97782359ec49d7
Added serialization code to rsLib
Integrated old changelist
Change-Id: Ie4746113f6d1817fbb3264f97fdddde25b779311
Added serialization code to rsLib
Change-Id: Ie4746113f6d1817fbb3264f97fdddde25b779311
diff --git a/libs/rs/rsMesh.cpp b/libs/rs/rsMesh.cpp
index d595b4e..b51e28a 100644
--- a/libs/rs/rsMesh.cpp
+++ b/libs/rs/rsMesh.cpp
@@ -14,14 +14,23 @@
* 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;
-#include <GLES/gl.h>
-#include <GLES/glext.h>
-
Mesh::Mesh(Context *rsc) : ObjectBase(rsc)
{
mAllocFile = __FILE__;
@@ -36,6 +45,162 @@
{
}
+void Mesh::serialize(OStream *stream) const
+{
+ // Need to identify ourselves
+ stream->addU32((uint32_t)getClassId());
+
+ String8 name(getName());
+ stream->addString(&name);
+
+ stream->addU32(mVerticiesCount);
+
+ for(uint32_t vCount = 0; vCount < mVerticiesCount; vCount ++) {
+ Verticies_t *verts = mVerticies[vCount];
+
+ stream->addU32(verts->mAllocationCount);
+
+ for (uint32_t aCount = 0; aCount < verts->mAllocationCount; aCount++) {
+ verts->mAllocations[aCount]->serialize(stream);
+ }
+ stream->addU32(verts->mVertexDataSize);
+
+ stream->addU32(verts->mOffsetCoord);
+ stream->addU32(verts->mOffsetTex);
+ stream->addU32(verts->mOffsetNorm);
+
+ stream->addU32(verts->mSizeCoord);
+ stream->addU32(verts->mSizeTex);
+ stream->addU32(verts->mSizeNorm );
+ }
+
+ stream->addU32(mPrimitivesCount);
+ // Store the primitives
+ for (uint32_t pCount = 0; pCount < mPrimitivesCount; pCount ++) {
+ Primitive_t * prim = mPrimitives[pCount];
+
+ stream->addU8((uint8_t)prim->mType);
+
+ // 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;
+ }
+ }
+ stream->addU32(vertexIndex);
+
+ stream->addU32(prim->mIndexCount);
+ for (uint32_t ct = 0; ct < prim->mIndexCount; ct++) {
+ stream->addU16(prim->mIndicies[ct]);
+ }
+
+ stream->addU32(prim->mRestartCounts);
+ for (uint32_t ct = 0; ct < prim->mRestartCounts; ct++) {
+ stream->addU16(prim->mRestarts[ct]);
+ }
+ }
+}
+
+Mesh *Mesh::createFromStream(Context *rsc, IStream *stream)
+{
+ // First make sure we are reading the correct object
+ A3DClassID classID = (A3DClassID)stream->loadU32();
+ if(classID != A3D_CLASS_ID_MESH) {
+ LOGE("mesh loading skipped due to invalid class id");
+ return NULL;
+ }
+
+ Mesh * mesh = new Mesh(rsc);
+
+ String8 name;
+ 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];
+
+ LOGE("processChunk_Verticies count %i", verts->mAllocationCount);
+ for (uint32_t aCount = 0; aCount < verts->mAllocationCount; aCount++) {
+ verts->mAllocations[aCount] = Allocation::createFromStream(rsc, stream);
+ }
+ 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;
+
+ 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->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();
+ }
+ }
+ 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();
+
+ }
+ }
+ else {
+ prim->mRestarts = NULL;
+ }
+
+ }
+
+ return mesh;
+}
MeshContext::MeshContext()