Start of mesh API cleanup. (164aaedf) · Commits · e / os / android_frameworks_base

graphics/java/android/renderscript/FileA3D.java

+1 −5

Original line number	Original line	Diff line number	Diff line
	@@ -36,7 +36,6 @@ public class FileA3D extends BaseObj {

	UNKNOWN,		UNKNOWN,
	MESH,		MESH,
	SIMPLE_MESH,
	TYPE,		TYPE,
	ELEMENT,		ELEMENT,
	ALLOCATION,		ALLOCATION,
	@@ -89,10 +88,7 @@ public class FileA3D extends BaseObj {

	switch (mClassID) {		switch (mClassID) {
	case MESH:		case MESH:
	mLoadedObj = null;		mLoadedObj = new Mesh(objectID, mRS);
	break;
	case SIMPLE_MESH:
	mLoadedObj = new SimpleMesh(objectID, mRS);
	break;		break;
	case TYPE:		case TYPE:
	mLoadedObj = new Type(objectID, mRS);		mLoadedObj = new Type(objectID, mRS);

graphics/java/android/renderscript/Mesh.java

0 → 100644

+447 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2008 The Android Open Source Project
			*
			* Licensed under the Apache License, Version 2.0 (the "License");
			* you may not use this file except in compliance with the License.
			* You may obtain a copy of the License at
			*
			* http://www.apache.org/licenses/LICENSE-2.0
			*
			* Unless required by applicable law or agreed to in writing, software
			* distributed under the License is distributed on an "AS IS" BASIS,
			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			* See the License for the specific language governing permissions and
			* limitations under the License.
			*/

			package android.renderscript;

			import java.util.Vector;

			import android.util.Config;
			import android.util.Log;

			/**
			* @hide
			*
			**/
			public class Mesh extends BaseObj {

			Allocation[] mVertexBuffers;
			Allocation[] mIndexBuffers;
			Primitive[] mPrimitives;

			Mesh(int id, RenderScript rs) {
			super(rs);
			mID = id;
			}

			public int getVertexAllocationCount() {
			if(mVertexBuffers == null) {
			return 0;
			}
			return mVertexBuffers.length;
			}
			public Allocation getVertexAllocation(int slot) {
			return mVertexBuffers[slot];
			}

			public int getPrimitiveCount() {
			if(mIndexBuffers == null) {
			return 0;
			}
			return mIndexBuffers.length;
			}
			public Allocation getIndexAllocation(int slot) {
			return mIndexBuffers[slot];
			}
			public Primitive getPrimitive(int slot) {
			return mPrimitives[slot];
			}

			public static class Builder {
			RenderScript mRS;

			class Entry {
			Type t;
			Element e;
			int size;
			Primitive prim;
			}

			int mVertexTypeCount;
			Entry[] mVertexTypes;
			Vector mIndexTypes;

			public Builder(RenderScript rs) {
			mRS = rs;
			mVertexTypeCount = 0;
			mVertexTypes = new Entry[16];
			mIndexTypes = new Vector();
			}

			public int addVertexType(Type t) throws IllegalStateException {
			if (mVertexTypeCount >= mVertexTypes.length) {
			throw new IllegalStateException("Max vertex types exceeded.");
			}

			int addedIndex = mVertexTypeCount;
			mVertexTypes[mVertexTypeCount] = new Entry();
			mVertexTypes[mVertexTypeCount].t = t;
			mVertexTypes[mVertexTypeCount].e = null;
			mVertexTypeCount++;
			return addedIndex;
			}

			public int addVertexType(Element e, int size) throws IllegalStateException {
			if (mVertexTypeCount >= mVertexTypes.length) {
			throw new IllegalStateException("Max vertex types exceeded.");
			}

			int addedIndex = mVertexTypeCount;
			mVertexTypes[mVertexTypeCount] = new Entry();
			mVertexTypes[mVertexTypeCount].t = null;
			mVertexTypes[mVertexTypeCount].e = e;
			mVertexTypes[mVertexTypeCount].size = size;
			mVertexTypeCount++;
			return addedIndex;
			}

			public int addIndexType(Type t, Primitive p) {
			int addedIndex = mIndexTypes.size();
			Entry indexType = new Entry();
			indexType.t = t;
			indexType.e = null;
			indexType.size = 0;
			indexType.prim = p;
			mIndexTypes.addElement(indexType);
			return addedIndex;
			}

			public int addIndexType(Primitive p) {
			int addedIndex = mIndexTypes.size();
			Entry indexType = new Entry();
			indexType.t = null;
			indexType.e = null;
			indexType.size = 0;
			indexType.prim = p;
			mIndexTypes.addElement(indexType);
			return addedIndex;
			}

			public int addIndexType(Element e, int size, Primitive p) {
			int addedIndex = mIndexTypes.size();
			Entry indexType = new Entry();
			indexType.t = null;
			indexType.e = e;
			indexType.size = size;
			indexType.prim = p;
			mIndexTypes.addElement(indexType);
			return addedIndex;
			}

			Type newType(Element e, int size) {
			Type.Builder tb = new Type.Builder(mRS, e);
			tb.add(Dimension.X, size);
			return tb.create();
			}

			static synchronized Mesh internalCreate(RenderScript rs, Builder b) {

			int id = rs.nMeshCreate(b.mVertexTypeCount, b.mIndexTypes.size());
			Mesh newMesh = new Mesh(id, rs);
			newMesh.mIndexBuffers = new Allocation[b.mIndexTypes.size()];
			newMesh.mPrimitives = new Primitive[b.mIndexTypes.size()];
			newMesh.mVertexBuffers = new Allocation[b.mVertexTypeCount];

			for(int ct = 0; ct < b.mIndexTypes.size(); ct ++) {
			Allocation alloc = null;
			Entry entry = (Entry)b.mIndexTypes.elementAt(ct);
			if (entry.t != null) {
			alloc = Allocation.createTyped(rs, entry.t);
			}
			else if(entry.e != null) {
			alloc = Allocation.createSized(rs, entry.e, entry.size);
			}
			int allocID = (alloc == null) ? 0 : alloc.getID();
			rs.nMeshBindIndex(id, allocID, entry.prim.mID, ct);
			newMesh.mIndexBuffers[ct] = alloc;
			newMesh.mPrimitives[ct] = entry.prim;
			}

			for(int ct = 0; ct < b.mVertexTypeCount; ct ++) {
			Allocation alloc = null;
			Entry entry = b.mVertexTypes[ct];
			if (entry.t != null) {
			alloc = Allocation.createTyped(rs, entry.t);
			} else if(entry.e != null) {
			alloc = Allocation.createSized(rs, entry.e, entry.size);
			}
			rs.nMeshBindVertex(id, alloc.getID(), ct);
			newMesh.mVertexBuffers[ct] = alloc;
			}

			return newMesh;
			}

			public Mesh create() {
			mRS.validate();
			Mesh sm = internalCreate(mRS, this);
			return sm;
			}
			}

			public static class AllocationBuilder {
			RenderScript mRS;

			class Entry {
			Allocation a;
			Primitive prim;
			}

			int mVertexTypeCount;
			Entry[] mVertexTypes;

			Vector mIndexTypes;

			public AllocationBuilder(RenderScript rs) {
			mRS = rs;
			mVertexTypeCount = 0;
			mVertexTypes = new Entry[16];
			mIndexTypes = new Vector();
			}

			public int addVertexAllocation(Allocation a) throws IllegalStateException {
			if (mVertexTypeCount >= mVertexTypes.length) {
			throw new IllegalStateException("Max vertex types exceeded.");
			}

			int addedIndex = mVertexTypeCount;
			mVertexTypes[mVertexTypeCount] = new Entry();
			mVertexTypes[mVertexTypeCount].a = a;
			mVertexTypeCount++;
			return addedIndex;
			}

			public int addIndexAllocation(Allocation a, Primitive p) {
			int addedIndex = mIndexTypes.size();
			Entry indexType = new Entry();
			indexType.a = a;
			indexType.prim = p;
			mIndexTypes.addElement(indexType);
			return addedIndex;
			}

			public int addIndexType(Primitive p) {
			int addedIndex = mIndexTypes.size();
			Entry indexType = new Entry();
			indexType.a = null;
			indexType.prim = p;
			mIndexTypes.addElement(indexType);
			return addedIndex;
			}

			static synchronized Mesh internalCreate(RenderScript rs, AllocationBuilder b) {

			int id = rs.nMeshCreate(b.mVertexTypeCount, b.mIndexTypes.size());
			Mesh newMesh = new Mesh(id, rs);
			newMesh.mIndexBuffers = new Allocation[b.mIndexTypes.size()];
			newMesh.mPrimitives = new Primitive[b.mIndexTypes.size()];
			newMesh.mVertexBuffers = new Allocation[b.mVertexTypeCount];

			for(int ct = 0; ct < b.mIndexTypes.size(); ct ++) {
			Entry entry = (Entry)b.mIndexTypes.elementAt(ct);
			int allocID = (entry.a == null) ? 0 : entry.a.getID();
			rs.nMeshBindIndex(id, allocID, entry.prim.mID, ct);
			newMesh.mIndexBuffers[ct] = entry.a;
			newMesh.mPrimitives[ct] = entry.prim;
			}

			for(int ct = 0; ct < b.mVertexTypeCount; ct ++) {
			Entry entry = b.mVertexTypes[ct];
			rs.nMeshBindVertex(id, entry.a.mID, ct);
			newMesh.mVertexBuffers[ct] = entry.a;
			}

			return newMesh;
			}

			public Mesh create() {
			mRS.validate();
			Mesh sm = internalCreate(mRS, this);
			return sm;
			}
			}


			public static class TriangleMeshBuilder {
			float mVtxData[];
			int mVtxCount;
			short mIndexData[];
			int mIndexCount;
			RenderScript mRS;
			Element mElement;

			float mNX = 0;
			float mNY = 0;
			float mNZ = -1;
			float mS0 = 0;
			float mT0 = 0;
			float mR = 1;
			float mG = 1;
			float mB = 1;
			float mA = 1;

			int mVtxSize;
			int mFlags;

			public static final int COLOR = 0x0001;
			public static final int NORMAL = 0x0002;
			public static final int TEXTURE_0 = 0x0100;

			public TriangleMeshBuilder(RenderScript rs, int vtxSize, int flags) {
			mRS = rs;
			mVtxCount = 0;
			mIndexCount = 0;
			mVtxData = new float[128];
			mIndexData = new short[128];
			mVtxSize = vtxSize;
			mFlags = flags;

			if (vtxSize < 2 \|\| vtxSize > 3) {
			throw new IllegalArgumentException("Vertex size out of range.");
			}
			}

			private void makeSpace(int count) {
			if ((mVtxCount + count) >= mVtxData.length) {
			float t[] = new float[mVtxData.length * 2];
			System.arraycopy(mVtxData, 0, t, 0, mVtxData.length);
			mVtxData = t;
			}
			}

			private void latch() {
			if ((mFlags & COLOR) != 0) {
			makeSpace(4);
			mVtxData[mVtxCount++] = mR;
			mVtxData[mVtxCount++] = mG;
			mVtxData[mVtxCount++] = mB;
			mVtxData[mVtxCount++] = mA;
			}
			if ((mFlags & TEXTURE_0) != 0) {
			makeSpace(2);
			mVtxData[mVtxCount++] = mS0;
			mVtxData[mVtxCount++] = mT0;
			}
			if ((mFlags & NORMAL) != 0) {
			makeSpace(3);
			mVtxData[mVtxCount++] = mNX;
			mVtxData[mVtxCount++] = mNY;
			mVtxData[mVtxCount++] = mNZ;
			}
			}

			public void addVertex(float x, float y) {
			if (mVtxSize != 2) {
			throw new IllegalStateException("add mistmatch with declared components.");
			}
			makeSpace(2);
			mVtxData[mVtxCount++] = x;
			mVtxData[mVtxCount++] = y;
			latch();
			}

			public void addVertex(float x, float y, float z) {
			if (mVtxSize != 3) {
			throw new IllegalStateException("add mistmatch with declared components.");
			}
			makeSpace(3);
			mVtxData[mVtxCount++] = x;
			mVtxData[mVtxCount++] = y;
			mVtxData[mVtxCount++] = z;
			latch();
			}

			public void setTexture(float s, float t) {
			if ((mFlags & TEXTURE_0) == 0) {
			throw new IllegalStateException("add mistmatch with declared components.");
			}
			mS0 = s;
			mT0 = t;
			}

			public void setNormal(float x, float y, float z) {
			if ((mFlags & NORMAL) == 0) {
			throw new IllegalStateException("add mistmatch with declared components.");
			}
			mNX = x;
			mNY = y;
			mNZ = z;
			}

			public void setColor(float r, float g, float b, float a) {
			if ((mFlags & COLOR) == 0) {
			throw new IllegalStateException("add mistmatch with declared components.");
			}
			mR = r;
			mG = g;
			mB = b;
			mA = a;
			}

			public void addTriangle(int idx1, int idx2, int idx3) {
			if((idx1 >= mVtxCount) \|\| (idx1 < 0) \|\|
			(idx2 >= mVtxCount) \|\| (idx2 < 0) \|\|
			(idx3 >= mVtxCount) \|\| (idx3 < 0)) {
			throw new IllegalStateException("Index provided greater than vertex count.");
			}
			if ((mIndexCount + 3) >= mIndexData.length) {
			short t[] = new short[mIndexData.length * 2];
			System.arraycopy(mIndexData, 0, t, 0, mIndexData.length);
			mIndexData = t;
			}
			mIndexData[mIndexCount++] = (short)idx1;
			mIndexData[mIndexCount++] = (short)idx2;
			mIndexData[mIndexCount++] = (short)idx3;
			}

			public Mesh create(boolean uploadToBufferObject) {
			Element.Builder b = new Element.Builder(mRS);
			int floatCount = mVtxSize;
			b.add(Element.createVector(mRS,
			Element.DataType.FLOAT_32,
			mVtxSize), "position");
			if ((mFlags & COLOR) != 0) {
			floatCount += 4;
			b.add(Element.F32_4(mRS), "color");
			}
			if ((mFlags & TEXTURE_0) != 0) {
			floatCount += 2;
			b.add(Element.F32_2(mRS), "texture0");
			}
			if ((mFlags & NORMAL) != 0) {
			floatCount += 3;
			b.add(Element.F32_3(mRS), "normal");
			}
			mElement = b.create();

			Builder smb = new Builder(mRS);
			smb.addVertexType(mElement, mVtxCount / floatCount);
			smb.addIndexType(Element.U16(mRS), mIndexCount, Primitive.TRIANGLE);

			Mesh sm = smb.create();

			sm.getVertexAllocation(0).data(mVtxData);
			if(uploadToBufferObject) {
			sm.getVertexAllocation(0).uploadToBufferObject();
			}

			sm.getIndexAllocation(0).data(mIndexData);
			sm.getIndexAllocation(0).uploadToBufferObject();

			return sm;
			}
			}
			}

graphics/java/android/renderscript/RenderScript.java

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -186,6 +186,10 @@ public class RenderScript {
	native void nLightSetColor(int l, float r, float g, float b);		native void nLightSetColor(int l, float r, float g, float b);
	native void nLightSetPosition(int l, float x, float y, float z);		native void nLightSetPosition(int l, float x, float y, float z);

			native int nMeshCreate(int vtxCount, int indexCount);
			native void nMeshBindVertex(int id, int alloc, int slot);
			native void nMeshBindIndex(int id, int alloc, int prim, int slot);

	native int nSimpleMeshCreate(int batchID, int idxID, int[] vtxID, int prim);		native int nSimpleMeshCreate(int batchID, int idxID, int[] vtxID, int prim);
	native void nSimpleMeshBindVertex(int id, int alloc, int slot);		native void nSimpleMeshBindVertex(int id, int alloc, int slot);
	native void nSimpleMeshBindIndex(int id, int alloc);		native void nSimpleMeshBindIndex(int id, int alloc);

graphics/jni/android_renderscript_RenderScript.cpp

+35 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1350,6 +1350,33 @@ nLightSetPosition(JNIEnv *_env, jobject _this, jint light, float x, float y, flo

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------

			static jint
			nMeshCreate(JNIEnv *_env, jobject _this, jint vtxCount, jint idxCount)
			{
			RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
			LOG_API("nMeshCreate, con(%p), vtxCount(%i), idxCount(%i)", con, vtxCount, idxCount);
			int id = (int)rsMeshCreate(con, vtxCount, idxCount);
			return id;
			}

			static void
			nMeshBindVertex(JNIEnv *_env, jobject _this, jint s, jint alloc, jint slot)
			{
			RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
			LOG_API("nMeshBindVertex, con(%p), Mesh(%p), Alloc(%p), slot(%i)", con, (RsMesh)s, (RsAllocation)alloc, slot);
			rsMeshBindVertex(con, (RsMesh)s, (RsAllocation)alloc, slot);
			}

			static void
			nMeshBindIndex(JNIEnv *_env, jobject _this, jint s, jint alloc, jint primID, jint slot)
			{
			RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
			LOG_API("nMeshBindIndex, con(%p), Mesh(%p), Alloc(%p)", con, (RsMesh)s, (RsAllocation)alloc);
			rsMeshBindIndex(con, (RsMesh)s, (RsAllocation)alloc, primID, slot);
			}

			// ---------------------------------------------------------------------------

	static jint		static jint
	nSimpleMeshCreate(JNIEnv *_env, jobject _this, jint batchID, jint indexID, jintArray vtxIDs, jint primID)		nSimpleMeshCreate(JNIEnv *_env, jobject _this, jint batchID, jint indexID, jintArray vtxIDs, jint primID)
	{		{
	@@ -1367,16 +1394,16 @@ static void
	nSimpleMeshBindVertex(JNIEnv *_env, jobject _this, jint s, jint alloc, jint slot)		nSimpleMeshBindVertex(JNIEnv *_env, jobject _this, jint s, jint alloc, jint slot)
	{		{
	RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));		RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
	LOG_API("nSimpleMeshBindVertex, con(%p), SimpleMesh(%p), Alloc(%p), slot(%i)", con, (RsSimpleMesh)s, (RsAllocation)alloc, slot);		LOG_API("nSimpleMeshBindVertex, con(%p), Mesh(%p), Alloc(%p), slot(%i)", con, (RsMesh)s, (RsAllocation)alloc, slot);
	rsSimpleMeshBindVertex(con, (RsSimpleMesh)s, (RsAllocation)alloc, slot);		rsSimpleMeshBindVertex(con, (RsMesh)s, (RsAllocation)alloc, slot);
	}		}

	static void		static void
	nSimpleMeshBindIndex(JNIEnv *_env, jobject _this, jint s, jint alloc)		nSimpleMeshBindIndex(JNIEnv *_env, jobject _this, jint s, jint alloc)
	{		{
	RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));		RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
	LOG_API("nSimpleMeshBindIndex, con(%p), SimpleMesh(%p), Alloc(%p)", con, (RsSimpleMesh)s, (RsAllocation)alloc);		LOG_API("nSimpleMeshBindIndex, con(%p), Mesh(%p), Alloc(%p)", con, (RsMesh)s, (RsAllocation)alloc);
	rsSimpleMeshBindIndex(con, (RsSimpleMesh)s, (RsAllocation)alloc);		rsSimpleMeshBindIndex(con, (RsMesh)s, (RsAllocation)alloc);
	}		}

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
	@@ -1513,6 +1540,10 @@ static JNINativeMethod methods[] = {
	{"nSimpleMeshBindVertex", "(III)V", (void*)nSimpleMeshBindVertex },		{"nSimpleMeshBindVertex", "(III)V", (void*)nSimpleMeshBindVertex },
	{"nSimpleMeshBindIndex", "(II)V", (void*)nSimpleMeshBindIndex },		{"nSimpleMeshBindIndex", "(II)V", (void*)nSimpleMeshBindIndex },

			{"nMeshCreate", "(II)I", (void*)nMeshCreate },
			{"nMeshBindVertex", "(III)V", (void*)nMeshBindVertex },
			{"nMeshBindIndex", "(IIII)V", (void*)nMeshBindIndex },

	};		};

	static int registerFuncs(JNIEnv *_env)		static int registerFuncs(JNIEnv *_env)

libs/rs/Android.mk

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -102,7 +102,6 @@ LOCAL_SRC_FILES:= \
	rsScriptC_LibGL.cpp \		rsScriptC_LibGL.cpp \
	rsShaderCache.cpp \		rsShaderCache.cpp \
	rsSignal.cpp \		rsSignal.cpp \
	rsSimpleMesh.cpp \
	rsStream.cpp \		rsStream.cpp \
	rsThreadIO.cpp \		rsThreadIO.cpp \
	rsType.cpp \		rsType.cpp \