add wavefront loader

start adding various scenes to test gpu rigid body pipeline
reserve more memory for shapes (concave triangle mesh can be huge) in GLInstancingRenderer
fix a few crashes when 0 objects

demo/gpudemo/rigidbody/ConcaveScene.cpp

@@ -0,0 +1,264 @@
+#include "ConcaveScene.h"
+#include "GpuRigidBodyDemo.h"
+#include "BulletCommon/btQuickprof.h"
+#include "OpenGLWindow/ShapeData.h"
+
+#include "OpenGLWindow/GLInstancingRenderer.h"
+#include "BulletCommon/btQuaternion.h"
+#include "OpenGLWindow/btgWindowInterface.h"
+#include "gpu_broadphase/host/btGpuSapBroadphase.h"
+#include "../GpuDemoInternalData.h"
+#include "basic_initialize/btOpenCLUtils.h"
+#include "OpenGLWindow/OpenGLInclude.h"
+#include "OpenGLWindow/GLInstanceRendererInternalData.h"
+#include "parallel_primitives/host/btLauncherCL.h"
+#include "gpu_rigidbody/host/btGpuRigidBodyPipeline.h"
+#include "gpu_rigidbody/host/btGpuNarrowPhase.h"
+#include "gpu_rigidbody/host/btConfig.h"
+#include "GpuRigidBodyDemoInternalData.h"
+#include"../../ObjLoader/objLoader.h"
+
+
+struct GraphicsVertex
+{
+	float xyzw[4];
+	float normal[3];
+	float uv[2];
+};
+struct GraphicsShape
+{
+	const float*	m_vertices;
+	int				m_numvertices;
+	const int*		m_indices;
+	int				m_numIndices;
+	float			m_scaling[4];
+};
+
+GraphicsShape* createGraphicsShapeFromWavefrontObj(objLoader* obj)
+{
+	btAlignedObjectArray<GraphicsVertex>* vertices = new btAlignedObjectArray<GraphicsVertex>;
+	{
+//		int numVertices = obj->vertexCount;
+	//	int numIndices = 0;
+		btAlignedObjectArray<int>* indicesPtr = new btAlignedObjectArray<int>;
+			/*
+		for (int v=0;v<obj->vertexCount;v++)
+		{
+			vtx.xyzw[0] = obj->vertexList[v]->e[0];
+			vtx.xyzw[1] = obj->vertexList[v]->e[1];
+			vtx.xyzw[2] = obj->vertexList[v]->e[2];
+			btVector3 n(vtx.xyzw[0],vtx.xyzw[1],vtx.xyzw[2]);
+			if (n.length2()>SIMD_EPSILON)
+			{
+				n.normalize();
+				vtx.normal[0] = n[0];
+				vtx.normal[1] = n[1];
+				vtx.normal[2] = n[2];
+
+			} else
+			{
+				vtx.normal[0] = 0; //todo
+				vtx.normal[1] = 1;
+				vtx.normal[2] = 0;
+			}
+			vtx.uv[0] = 0.5f;vtx.uv[1] = 0.5f;	//todo
+			vertices->push_back(vtx);
+		}
+		*/
+
+		for (int f=0;f<obj->faceCount;f++)
+		{
+			obj_face* face = obj->faceList[f];
+			//btVector3 normal(face.m_plane[0],face.m_plane[1],face.m_plane[2]);
+			if (face->vertex_count>=3)
+			{
+				btVector3 normal(0,1,0);
+				int vtxBaseIndex = vertices->size();
+
+				if (face->vertex_count<=4)
+				{
+					indicesPtr->push_back(vtxBaseIndex);
+					indicesPtr->push_back(vtxBaseIndex+1);
+					indicesPtr->push_back(vtxBaseIndex+2);
+					
+					GraphicsVertex vtx0;
+					vtx0.xyzw[0] = obj->vertexList[face->vertex_index[0]]->e[0];
+					vtx0.xyzw[1] = obj->vertexList[face->vertex_index[0]]->e[1];
+					vtx0.xyzw[2] = obj->vertexList[face->vertex_index[0]]->e[2];
+					vtx0.xyzw[3] = 0.f;//obj->vertexList[face->vertex_index[0]]->e[2];
+
+					vtx0.uv[0] = 0.5f;//obj->textureList[face->vertex_index[0]]->e[0];
+					vtx0.uv[1] = 0.5f;//obj->textureList[face->vertex_index[0]]->e[1];
+
+					GraphicsVertex vtx1;
+					vtx1.xyzw[0] = obj->vertexList[face->vertex_index[1]]->e[0];
+					vtx1.xyzw[1] = obj->vertexList[face->vertex_index[1]]->e[1];
+					vtx1.xyzw[2] = obj->vertexList[face->vertex_index[1]]->e[2];
+					vtx1.xyzw[3]= 0.f;
+					vtx1.uv[0] = 0.5f;//obj->textureList[face->vertex_index[1]]->e[0];
+					vtx1.uv[1] = 0.5f;//obj->textureList[face->vertex_index[1]]->e[1];
+
+					GraphicsVertex vtx2;
+					vtx2.xyzw[0] = obj->vertexList[face->vertex_index[2]]->e[0];
+					vtx2.xyzw[1] = obj->vertexList[face->vertex_index[2]]->e[1];
+					vtx2.xyzw[2] = obj->vertexList[face->vertex_index[2]]->e[2];
+					vtx2.xyzw[3] = 0.f;
+					vtx2.uv[0] = 0.5f;obj->textureList[face->vertex_index[2]]->e[0];
+					vtx2.uv[1] = 0.5f;obj->textureList[face->vertex_index[2]]->e[1];
+
+
+					btVector3 v0(vtx0.xyzw[0],vtx0.xyzw[1],vtx0.xyzw[2]);
+					btVector3 v1(vtx1.xyzw[0],vtx1.xyzw[1],vtx1.xyzw[2]);
+					btVector3 v2(vtx2.xyzw[0],vtx2.xyzw[1],vtx2.xyzw[2]);
+
+					normal = (v1-v0).cross(v2-v0);
+					normal.normalize();
+					vtx0.normal[0] = normal[0];
+					vtx0.normal[1] = normal[1];
+					vtx0.normal[2] = normal[2];
+					vtx1.normal[0] = normal[0];
+					vtx1.normal[1] = normal[1];
+					vtx1.normal[2] = normal[2];
+					vtx2.normal[0] = normal[0];
+					vtx2.normal[1] = normal[1];
+					vtx2.normal[2] = normal[2];
+					vertices->push_back(vtx0);
+					vertices->push_back(vtx1);
+					vertices->push_back(vtx2);
+				}
+				if (face->vertex_count==4)
+				{
+
+					indicesPtr->push_back(vtxBaseIndex);
+					indicesPtr->push_back(vtxBaseIndex+1);
+					indicesPtr->push_back(vtxBaseIndex+2);
+					indicesPtr->push_back(vtxBaseIndex+3);
+//
+					GraphicsVertex vtx3;
+					vtx3.xyzw[0] = obj->vertexList[face->vertex_index[3]]->e[0];
+					vtx3.xyzw[1] = obj->vertexList[face->vertex_index[3]]->e[1];
+					vtx3.xyzw[2] = obj->vertexList[face->vertex_index[3]]->e[2];
+					vtx3.uv[0] = 0.5;
+					vtx3.uv[1] = 0.5;
+
+					vtx3.normal[0] = normal[0];
+					vtx3.normal[1] = normal[1];
+					vtx3.normal[2] = normal[2];
+
+					vertices->push_back(vtx3);
+
+				}
+			}
+		}
+		
+		
+		GraphicsShape* gfxShape = new GraphicsShape;
+		gfxShape->m_vertices = &vertices->at(0).xyzw[0];
+		gfxShape->m_numvertices = vertices->size();
+		gfxShape->m_indices = &indicesPtr->at(0);
+		gfxShape->m_numIndices = indicesPtr->size();
+		for (int i=0;i<4;i++)
+			gfxShape->m_scaling[i] = 1;//bake the scaling into the vertices 
+		return gfxShape;
+	}
+}
+
+void ConcaveScene::setupScene(const ConstructionInfo& ci)
+{
+	objLoader* objData = new objLoader();
+//char* fileName = "data/plane.obj";
+	//char* fileName = "data/teddy.obj";//"plane.obj";
+	char* fileName = "data/sponza_closed.obj";//"plane.obj";
+
+	FILE* f = 0;
+
+	char relativeFileName[1024];
+	{
+		const char* prefix[]={"../","../../","../../../","../../../../"};
+		int numPrefixes = sizeof(prefix)/sizeof(char*);
+
+		for (int i=0;i<numPrefixes;i++)
+		{
+			
+			sprintf(relativeFileName,"%s%s",prefix[i],fileName);
+			f = fopen(relativeFileName,"r");
+			if (f)
+			{
+				fclose(f);
+				break;
+			}
+		}
+	}
+
+	if (f)
+		fclose(f);
+	else
+		return;
+
+	objData->load(relativeFileName);
+	
+	GraphicsShape* shape = createGraphicsShapeFromWavefrontObj(objData);
+	{
+		int strideInBytes = 9*sizeof(float);
+		int numVertices = sizeof(cube_vertices)/strideInBytes;
+		int numIndices = sizeof(cube_vertices)/sizeof(int);
+		//int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+		//int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+
+
+		int shapeId = ci.m_instancingRenderer->registerShape(shape->m_vertices, shape->m_numvertices, shape->m_indices, shape->m_numIndices);
+		btQuaternion orn(0,0,0,1);
+				
+		btVector4 color(0,1,0,1.f);//0.5);
+		btVector4 scaling(1,1,1,1);
+				
+		{
+			btVector3 position(0,0,0);
+			int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling);
+		}
+
+		
+
+	}
+
+	int strideInBytes = 9*sizeof(float);
+	int numVertices = sizeof(cube_vertices)/strideInBytes;
+	int numIndices = sizeof(cube_vertices)/sizeof(int);
+	//int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+	int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+	int group=1;
+	int mask=1;
+	int index=10;
+	float scaling[4] = {1,1,1,1};
+
+	int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling);
+
+	if (0)
+	{
+	for (int i=0;i<1;i++)
+	{
+		for (int j=0;j<ci.arraySizeY;j++)
+		{
+			for (int k=0;k<1;k++)
+			{
+				float mass = j==0? 0.f : 1.f;
+
+				btVector3 position(40+i*ci.gapX,j*ci.gapY,k*ci.gapZ);
+				btQuaternion orn(1,0,0,0);
+				
+				btVector4 color(0,1,0,1);
+				btVector4 scaling(1,1,1,1);
+				int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling);
+				int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index);
+				
+				index++;
+			}
+		}
+	}
+	}
+	float camPos[4]={0,0,0,0};//65.5,4.5,65.5,0};
+	//float camPos[4]={1,12.5,1.5,0};
+	m_instancingRenderer->setCameraTargetPosition(camPos);
+	m_instancingRenderer->setCameraDistance(16);
+
+}

demo/gpudemo/rigidbody/ConcaveScene.h

@@ -0,0 +1,27 @@
+#ifndef CONCAVE_SCENE_H
+#define CONCAVE_SCENE_H
+
+#include "GpuRigidBodyDemo.h"
+
+class ConcaveScene : public GpuRigidBodyDemo
+{
+public:
+
+	ConcaveScene(){}
+	virtual ~ConcaveScene(){}
+	virtual const char* getName()
+	{
+		return "GRBConcave";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new ConcaveScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+};
+
+#endif //CONCAVE_SCENE_H

demo/gpudemo/rigidbody/GpuConvexScene.cpp

@@ -0,0 +1,61 @@
+#include "GpuConvexScene.h"
+#include "GpuRigidBodyDemo.h"
+#include "BulletCommon/btQuickprof.h"
+#include "OpenGLWindow/ShapeData.h"
+
+#include "OpenGLWindow/GLInstancingRenderer.h"
+#include "BulletCommon/btQuaternion.h"
+#include "OpenGLWindow/btgWindowInterface.h"
+#include "gpu_broadphase/host/btGpuSapBroadphase.h"
+#include "../GpuDemoInternalData.h"
+#include "basic_initialize/btOpenCLUtils.h"
+#include "OpenGLWindow/OpenGLInclude.h"
+#include "OpenGLWindow/GLInstanceRendererInternalData.h"
+#include "parallel_primitives/host/btLauncherCL.h"
+#include "gpu_rigidbody/host/btGpuRigidBodyPipeline.h"
+#include "gpu_rigidbody/host/btGpuNarrowPhase.h"
+#include "gpu_rigidbody/host/btConfig.h"
+#include "GpuRigidBodyDemoInternalData.h"
+
+void GpuConvexScene::setupScene(const ConstructionInfo& ci)
+{
+	int strideInBytes = 9*sizeof(float);
+	int numVertices = sizeof(cube_vertices)/strideInBytes;
+	int numIndices = sizeof(cube_vertices)/sizeof(int);
+	//int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+	int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
+	int group=1;
+	int mask=1;
+	int index=10;
+	float scaling[4] = {1,1,1,1};
+
+	int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling);
+
+		
+	for (int i=0;i<ci.arraySizeX;i++)
+	{
+		for (int j=0;j<ci.arraySizeY;j++)
+		{
+			for (int k=0;k<ci.arraySizeZ;k++)
+			{
+				float mass = j==0? 0.f : 1.f;
+
+				btVector3 position(i*ci.gapX,j*ci.gapY,k*ci.gapZ);
+				btQuaternion orn(1,0,0,0);
+				
+				btVector4 color(0,1,0,1);
+				btVector4 scaling(1,1,1,1);
+				int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling);
+				int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index);
+				
+				index++;
+			}
+		}
+	}
+
+	float camPos[4]={65.5,4.5,65.5,0};
+	//float camPos[4]={1,12.5,1.5,0};
+	m_instancingRenderer->setCameraTargetPosition(camPos);
+	m_instancingRenderer->setCameraDistance(90);
+	
+}

demo/gpudemo/rigidbody/GpuConvexScene.h

@@ -0,0 +1,27 @@
+#ifndef GPU_CONVEX_SCENE_H
+#define GPU_CONVEX_SCENE_H
+
+#include "GpuRigidBodyDemo.h"
+
+class GpuConvexScene : public GpuRigidBodyDemo
+{
+public:
+
+	GpuConvexScene(){}
+	virtual ~GpuConvexScene(){}
+	virtual const char* getName()
+	{
+		return "GRBConvex";
+	}
+
+	static GpuDemo* MyCreateFunc()
+	{
+		GpuDemo* demo = new GpuConvexScene;
+		return demo;
+	}
+
+	virtual void setupScene(const ConstructionInfo& ci);
+
+};
+
+#endif //GPU_CONVEX_SCENE_H

demo/gpudemo/rigidbody/GpuRigidBodyDemo.cpp

@@ -13,6 +13,7 @@
 #include "gpu_rigidbody/host/btGpuRigidBodyPipeline.h"
 #include "gpu_rigidbody/host/btGpuNarrowPhase.h"
 #include "gpu_rigidbody/host/btConfig.h"
+#include "GpuRigidBodyDemoInternalData.h"
 
 static btKeyboardCallback oldCallback = 0;
 extern bool gReset;
@@ -46,26 +47,7 @@ __kernel void
 );
 
 
-struct	GpuRigidBodyDemoInternalData
-{
-	
-	cl_kernel	m_copyTransformsToVBOKernel;
 
-	btOpenCLArray<btVector4>*	m_instancePosOrnColor;
-
-	class btGpuRigidBodyPipeline* m_rigidBodyPipeline;
-
-	btGpuNarrowPhase* m_np;
-	btGpuSapBroadphase* m_bp;
-
-	GpuRigidBodyDemoInternalData()
-		:m_instancePosOrnColor(0),
-		m_copyTransformsToVBOKernel(0),	m_rigidBodyPipeline(0),
-		m_np(0),
-		m_bp(0)
-	{
-	}
-};
 
 
 GpuRigidBodyDemo::GpuRigidBodyDemo()
@@ -97,11 +79,26 @@ static void PairKeyboardCallback(int key, int state)
 	oldCallback(key,state);
 }
 
+void	GpuRigidBodyDemo::setupScene(const ConstructionInfo& ci)
+{
 
+}
 
 void	GpuRigidBodyDemo::initPhysics(const ConstructionInfo& ci)
 {
+
+	if (ci.m_window)
+	{
+		m_window = ci.m_window;
+		oldCallback = ci.m_window->getKeyboardCallback();
+		ci.m_window->setKeyboardCallback(PairKeyboardCallback);
+
+	}
+
+	m_instancingRenderer = ci.m_instancingRenderer;
+
 	initCL(ci.preferredOpenCLDeviceIndex,ci.preferredOpenCLPlatformIndex);
+
 	if (m_clData->m_clContext)
 	{
 		int errNum=0;
@@ -117,62 +114,13 @@ void	GpuRigidBodyDemo::initPhysics(const ConstructionInfo& ci)
 
 		m_data->m_rigidBodyPipeline = new btGpuRigidBodyPipeline(m_clData->m_clContext,m_clData->m_clDevice,m_clData->m_clQueue, np, bp);
 
-		int strideInBytes = 9*sizeof(float);
-		int numVertices = sizeof(cube_vertices)/strideInBytes;
-		int numIndices = sizeof(cube_vertices)/sizeof(int);
-		//int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
-		int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices);
-		int group=1;
-		int mask=1;
-		int index=10;
-		float scaling[4] = {1,1,1,1};
 
-		int colIndex = np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling);
+		setupScene(ci);
 
-		
-		for (int i=0;i<ci.arraySizeX;i++)
-		{
-			for (int j=0;j<ci.arraySizeY;j++)
-			{
-				for (int k=0;k<ci.arraySizeZ;k++)
-				{
-					float mass = j==0? 0.f : 1.f;
-
-					btVector3 position(i*ci.gapX,j*ci.gapY,k*ci.gapZ);
-					btQuaternion orn(1,0,0,0);
-				
-					btVector4 color(0,1,0,1);
-					btVector4 scaling(1,1,1,1);
-					int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling);
-					int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index);
-				
-					index++;
-				}
-			}
-		}
 		np->writeAllBodiesToGpu();
 		bp->writeAabbsToGpu();
 	}
 
-	
-	
-	
-	
-	if (ci.m_window)
-	{
-		m_window = ci.m_window;
-		oldCallback = ci.m_window->getKeyboardCallback();
-		ci.m_window->setKeyboardCallback(PairKeyboardCallback);
-
-	}
-
-	m_instancingRenderer = ci.m_instancingRenderer;
-
-
-	float camPos[4]={65.5,4.5,65.5,0};
-	//float camPos[4]={1,12.5,1.5,0};
-	m_instancingRenderer->setCameraTargetPosition(camPos);
-	m_instancingRenderer->setCameraDistance(90);
 
 	m_instancingRenderer->writeTransforms();
 	
@@ -204,9 +152,10 @@ void GpuRigidBodyDemo::renderScene()
 void GpuRigidBodyDemo::clientMoveAndDisplay()
 {
 	bool animate=true;
-	int numObjects= m_instancingRenderer->getInternalData()->m_totalNumInstances;
+	int numObjects= m_data->m_rigidBodyPipeline->getNumBodies();
+//m_instancingRenderer->getInternalData()->m_totalNumInstances;
 	btVector4* positions = 0;
-	if (animate)
+	if (animate && numObjects)
 	{
 		GLuint vbo = m_instancingRenderer->getInternalData()->m_vbo;
 		int arraySizeInBytes  = numObjects * (3)*sizeof(btVector4);
@@ -222,9 +171,10 @@ void GpuRigidBodyDemo::clientMoveAndDisplay()
 			m_data->m_instancePosOrnColor->copyFromHostPointer(positions,3*numObjects,0);
 		}
 	}
-
+	
 	m_data->m_rigidBodyPipeline->stepSimulation(1./60.f);
 
+	if (numObjects)
 	{
 		int ciErrNum = 0;
 		cl_mem bodies = m_data->m_rigidBodyPipeline->getBodyBuffer();
@@ -236,7 +186,7 @@ void GpuRigidBodyDemo::clientMoveAndDisplay()
 		oclCHECKERROR(ciErrNum, CL_SUCCESS);
 	}
 
-	if (animate)
+	if (animate && numObjects)
 	{
 		GLint err = glGetError();
 		assert(err==GL_NO_ERROR);

demo/gpudemo/rigidbody/GpuRigidBodyDemo.h

@@ -5,7 +5,7 @@
 
 class GpuRigidBodyDemo : public GpuDemo
 {
-	
+protected:
 	class GLInstancingRenderer* m_instancingRenderer;
 	class btgWindowInterface*	m_window;
 
@@ -17,7 +17,11 @@ public:
 	virtual ~GpuRigidBodyDemo();
 
 	virtual void	initPhysics(const ConstructionInfo& ci);
-	
+
+	virtual void	setupScene(const ConstructionInfo& ci);
+
+	virtual void	destroyScene(){};
+
 	virtual void	exitPhysics();
 	
 	virtual const char* getName()
@@ -30,8 +34,6 @@ public:
 		return demo;
 	}
 	
-	
-	
 	virtual void renderScene();
 	
 	virtual void clientMoveAndDisplay();

demo/gpudemo/rigidbody/GpuRigidBodyDemoInternalData.h

@@ -0,0 +1,30 @@
+#ifndef GPU_RIGIDBODY_INTERNAL_DATA_H
+#define GPU_RIGIDBODY_INTERNAL_DATA_H
+
+#include "basic_initialize/btOpenCLUtils.h"
+#include "parallel_primitives/host/btOpenCLArray.h"
+#include "BulletCommon/btVector3.h"
+
+struct	GpuRigidBodyDemoInternalData
+{
+	
+	cl_kernel	m_copyTransformsToVBOKernel;
+
+	btOpenCLArray<btVector4>*	m_instancePosOrnColor;
+
+	class btGpuRigidBodyPipeline* m_rigidBodyPipeline;
+
+	class btGpuNarrowPhase* m_np;
+	class btGpuSapBroadphase* m_bp;
+
+	GpuRigidBodyDemoInternalData()
+		:m_instancePosOrnColor(0),
+		m_copyTransformsToVBOKernel(0),	m_rigidBodyPipeline(0),
+		m_np(0),
+		m_bp(0)
+	{
+	}
+};
+
+#endif//GPU_RIGIDBODY_INTERNAL_DATA_H
+