void ConcaveScene::createConcaveMesh(const ConstructionInfo& ci, const char* fileName, const b3Vector3& shift, const b3Vector3& scaling) { char relativeFileName[1024]; const char* prefix[]={"./data/","../data/","../../data/","../../../data/","../../../../data/"}; int prefixIndex=-1; { int numPrefixes = sizeof(prefix)/sizeof(char*); for (int i=0;i<numPrefixes;i++) { FILE* f = 0; sprintf(relativeFileName,"%s%s",prefix[i],fileName); f = fopen(relativeFileName,"r"); if (f) { fclose(f); prefixIndex = i; break; } } } if (prefixIndex<0) return; int index=10; { std::vector<tinyobj::shape_t> shapes; std::string err = tinyobj::LoadObj(shapes, relativeFileName, prefix[prefixIndex]); GLInstanceGraphicsShape* shape = createGraphicsShapeFromWavefrontObj(shapes); b3AlignedObjectArray<b3Vector3> verts; for (int i=0;i<shape->m_numvertices;i++) { for (int j=0;j<3;j++) shape->m_vertices->at(i).xyzw[j] += shift[j]; b3Vector3 vtx=b3MakeVector3(shape->m_vertices->at(i).xyzw[0], shape->m_vertices->at(i).xyzw[1], shape->m_vertices->at(i).xyzw[2]); verts.push_back(vtx*scaling); } int colIndex = m_data->m_np->registerConcaveMesh(&verts,shape->m_indices,b3MakeVector3(1,1,1)); { int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/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->at(0).xyzw[0], shape->m_numvertices, &shape->m_indices->at(0), shape->m_numIndices); b3Quaternion orn(0,0,0,1); b3Vector4 color=b3MakeVector4(0.3,0.3,1,1.f);//0.5);//1.f { float mass = 0.f; b3Vector3 position=b3MakeVector3(0,0,0); int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index,false); index++; } delete shape->m_indices; delete shape->m_vertices; delete shape; } } }
void ConcaveScene::setupScene(const ConstructionInfo& ci) { if (1) { //char* fileName = "slopedPlane100.obj"; //char* fileName = "plane100.obj"; // char* fileName = "plane100.obj"; //char* fileName = "teddy.obj";//"plane.obj"; // char* fileName = "sponza_closed.obj";//"plane.obj"; //char* fileName = "leoTest1.obj"; char* fileName = "samurai_monastry.obj"; // char* fileName = "teddy2_VHACD_CHs.obj"; b3Vector3 shift1=b3MakeVector3(0,0,0);//0,230,80);//150,-100,-120); b3Vector4 scaling=b3MakeVector4(10,10,10,1); // createConcaveMesh(ci,"plane100.obj",shift1,scaling); //createConcaveMesh(ci,"plane100.obj",shift,scaling); // b3Vector3 shift2(0,0,0);//0,230,80);//150,-100,-120); // createConcaveMesh(ci,"teddy.obj",shift2,scaling); // b3Vector3 shift3(130,-150,-75);//0,230,80);//150,-100,-120); // createConcaveMesh(ci,"leoTest1.obj",shift3,scaling); createConcaveMesh(ci,fileName,shift1,scaling); } else { int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/sizeof(int); int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int group=1; int mask=1; int index=0; { b3Vector4 scaling=b3MakeVector4(400,1.,400,1); int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); b3Vector3 position=b3MakeVector3(0,-2,0); b3Quaternion orn(0,0,0,1); b3Vector4 color=b3MakeVector4(0,0,1,1); int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(0.f,position,orn,colIndex,index,false); } } createDynamicObjects(ci); m_data->m_rigidBodyPipeline->writeAllInstancesToGpu(); 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->setCameraPitch(45); m_instancingRenderer->setCameraTargetPosition(camPos); m_instancingRenderer->setCameraDistance(355); char msg[1024]; int numInstances = m_data->m_rigidBodyPipeline->getNumBodies(); sprintf(msg,"Num objects = %d",numInstances); if (ci.m_gui) ci.m_gui->setStatusBarMessage(msg,true); }
/* Create from TetGen .ele, .face, .node data */ void GpuTetraScene::createFromTetGenData(const char* ele, const char* node) { b3Scalar scaling(10); b3AlignedObjectArray<b3Vector3> pos; int nnode=0; int ndims=0; int nattrb=0; int hasbounds=0; int result = sscanf(node,"%d %d %d %d",&nnode,&ndims,&nattrb,&hasbounds); result = sscanf(node,"%d %d %d %d",&nnode,&ndims,&nattrb,&hasbounds); node += nextLine(node); //b3AlignedObjectArray<b3Vector3> rigidBodyPositions; //b3AlignedObjectArray<int> rigidBodyIds; pos.resize(nnode); for(int i=0;i<pos.size();++i) { int index=0; //int bound=0; float x,y,z; sscanf(node,"%d %f %f %f",&index,&x,&y,&z); // sn>>index; // sn>>x;sn>>y;sn>>z; node += nextLine(node); //for(int j=0;j<nattrb;++j) // sn>>a; //if(hasbounds) // sn>>bound; pos[index].setX(b3Scalar(x)*scaling); pos[index].setY(b3Scalar(y)*scaling); pos[index].setZ(b3Scalar(z)*scaling); } if(ele&&ele[0]) { int ntetra=0; int ncorner=0; int neattrb=0; sscanf(ele,"%d %d %d",&ntetra,&ncorner,&neattrb); ele += nextLine(ele); //se>>ntetra;se>>ncorner;se>>neattrb; for(int i=0;i<ntetra;++i) { int index=0; int ni[4]; //se>>index; //se>>ni[0];se>>ni[1];se>>ni[2];se>>ni[3]; sscanf(ele,"%d %d %d %d %d",&index,&ni[0],&ni[1],&ni[2],&ni[3]); ele+=nextLine(ele); b3Vector3 average=b3MakeVector3(0,0,0); for (int v=0;v<4;v++) { average+=pos[ni[v]]; } average/=4; for (int v=0;v<4;v++) { b3Vector3 shiftedPos = pos[ni[v]]-average; mytetra_vertices[0+v*9] = shiftedPos.getX(); mytetra_vertices[1+v*9] = shiftedPos.getY(); mytetra_vertices[2+v*9] = shiftedPos.getZ(); } //todo: subtract average int strideInBytes = 9*sizeof(float); int numVertices = sizeof(mytetra_vertices)/strideInBytes; int numIndices = sizeof(mytetra_indices)/sizeof(int); int shapeId = m_instancingRenderer->registerShape(&mytetra_vertices[0],numVertices,mytetra_indices,numIndices); int group=1; int mask=1; { b3Vector4 scaling=b3MakeVector4(1,1,1,1); int colIndex = m_data->m_np->registerConvexHullShape(&mytetra_vertices[0],strideInBytes,numVertices, scaling); b3Vector3 position=b3MakeVector3(0,150,0); // position+=average;//*1.2;//*2; position+=average*1.2;//*2; //rigidBodyPositions.push_back(position); b3Quaternion orn(0,0,0,1); static int curColor=0; b3Vector4 color = colors[curColor++]; curColor&=3; int id = m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(1.f,position,orn,colIndex,0,false); //rigidBodyIds.push_back(pid); } //for(int j=0;j<neattrb;++j) // se>>a; //psb->appendTetra(ni[0],ni[1],ni[2],ni[3]); } // printf("Nodes: %u\r\n",psb->m_nodes.size()); // printf("Links: %u\r\n",psb->m_links.size()); // printf("Faces: %u\r\n",psb->m_faces.size()); // printf("Tetras: %u\r\n",psb->m_tetras.size()); } m_data->m_rigidBodyPipeline->writeAllInstancesToGpu(); m_data->m_np->writeAllBodiesToGpu(); m_data->m_bp->writeAabbsToGpu(); m_data->m_rigidBodyPipeline->setupGpuAabbsFull(); m_data->m_bp->calculateOverlappingPairs(m_data->m_config.m_maxBroadphasePairs); int numPairs = m_data->m_bp->getNumOverlap(); cl_mem pairs = m_data->m_bp->getOverlappingPairBuffer(); b3OpenCLArray<b3Int2> clPairs(m_clData->m_clContext,m_clData->m_clQueue); clPairs.setFromOpenCLBuffer(pairs,numPairs); b3AlignedObjectArray<b3Int2> allPairs; clPairs.copyToHost(allPairs); for (int p=0;p<allPairs.size();p++) { b3Vector3 posA,posB; b3Quaternion ornA,ornB; int bodyIndexA = allPairs[p].x; int bodyIndexB = allPairs[p].y; m_data->m_np->getObjectTransformFromCpu(posA,ornA,bodyIndexA); m_data->m_np->getObjectTransformFromCpu(posB,ornB,bodyIndexB); b3Vector3 pivotWorld = (posA+posB)*0.5f; b3Transform transA,transB; transA.setIdentity(); transA.setOrigin(posA); transA.setRotation(ornA); transB.setIdentity(); transB.setOrigin(posB); transB.setRotation(ornB); b3Vector3 pivotInA = transA.inverse()*pivotWorld; b3Vector3 pivotInB = transB.inverse()*pivotWorld; b3Transform frameInA,frameInB; frameInA.setIdentity(); frameInB.setIdentity(); frameInA.setOrigin(pivotInA); frameInB.setOrigin(pivotInB); b3Quaternion relTargetAB = frameInA.getRotation()*frameInB.getRotation().inverse(); //c = new b3FixedConstraint(pid,prevBody,frameInA,frameInB); float breakingThreshold = 45;//37.f; //c->setBreakingImpulseThreshold(37.1); bool useGPU = true; if (useGPU) { int cid = m_data->m_rigidBodyPipeline->createFixedConstraint(bodyIndexA,bodyIndexB,pivotInA,pivotInB,relTargetAB,breakingThreshold); } else { b3FixedConstraint* c = new b3FixedConstraint(bodyIndexA,bodyIndexB,frameInA,frameInB); c->setBreakingImpulseThreshold(breakingThreshold); m_data->m_rigidBodyPipeline->addConstraint(c); } } printf("numPairs = %d\n",numPairs); }
b3Vector4 make_float4(float x,float y, float z, float w) { return b3MakeVector4 (x,y,z,w); }
public: virtual const char* getName() { return "TetraBreakable"; } virtual int createDynamicsObjects(); }; b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,1,1,1), b3MakeVector4(1,1,0,1), }; void GpuConvexScene::setupScene() { m_raycaster = new b3GpuRaycast(m_clData->m_clContext,m_clData->m_clDevice,m_clData->m_clQueue); int index=0; createStaticEnvironment(); index+=createDynamicsObjects();
int GpuConvexScene::createDynamicsObjects2( const float* vertices, int numVertices, const int* indices, int numIndices) { int strideInBytes = 9*sizeof(float); int textureIndex = -1; if (0) { int width,height,n; const char* filename = "data/cube.png"; const unsigned char* image=0; const char* prefix[]={"./","../","../../","../../../","../../../../"}; int numprefix = sizeof(prefix)/sizeof(const char*); for (int i=0;!image && i<numprefix;i++) { char relativeFileName[1024]; sprintf(relativeFileName,"%s%s",prefix[i],filename); image = loadImage(relativeFileName,width,height,n); } b3Assert(image); if (image) { textureIndex = m_instancingRenderer->registerTexture(image,width,height); } } int shapeId = m_guiHelper->getRenderInterface()->registerShape(&vertices[0],numVertices,indices,numIndices,B3_GL_TRIANGLES,textureIndex); int group=1; int mask=1; int index=0; { int curColor = 0; float scaling[4] = {1,1,1,1}; int prevBody = -1; int insta = 0; b3ConvexUtility* utilPtr = new b3ConvexUtility(); { b3AlignedObjectArray<b3Vector3> verts; unsigned char* vts = (unsigned char*) vertices; for (int i=0;i<numVertices;i++) { float* vertex = (float*) &vts[i*strideInBytes]; verts.push_back(b3MakeVector3(vertex[0]*scaling[0],vertex[1]*scaling[1],vertex[2]*scaling[2])); } bool merge = true; if (numVertices) { utilPtr->initializePolyhedralFeatures(&verts[0],verts.size(),merge); } } int colIndex=-1; if (gUseInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); //int colIndex = m_data->m_np->registerSphereShape(1); for (int i=0;i<gGpuArraySizeX;i++) { //printf("%d of %d\n", i, ci.arraySizeX); for (int j=0;j<gGpuArraySizeY;j++) { for (int k=0;k<gGpuArraySizeZ;k++) { //int colIndex = m_data->m_np->registerConvexHullShape(&vertices[0],strideInBytes,numVertices, scaling); if (!gUseInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); float mass = 1.f; if (j==0)//ci.arraySizeY-1) { //mass=0.f; } b3Vector3 position = b3MakeVector3(((j+1)&1)+i*2.2,1+j*2.,((j+1)&1)+k*2.2); //b3Vector3 position = b3MakeVector3(i*2,1+j*2,k*2); //b3Vector3 position=b3MakeVector3(1,0.9,1); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scalin=b3MakeVector4(1,1,1,1); int id = m_guiHelper->getRenderInterface()->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index,false); if (prevBody>=0) { //b3Point2PointConstraint* p2p = new b3Point2PointConstraint(pid,prevBody,b3Vector3(0,-1.1,0),b3Vector3(0,1.1,0)); // m_data->m_rigidBodyPipeline->addConstraint(p2p);//,false); } prevBody = pid; index++; } } } delete utilPtr; } return index; }
void ConcaveCompoundScene::createDynamicObjects(const ConstructionInfo& ci) { int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/sizeof(int); b3AlignedObjectArray<GLInstanceVertex> vertexArray; b3AlignedObjectArray<int> indexArray; //int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int group=1; int mask=1; int index=0; float scaling[4] = {1,1,1,1}; int colIndex = 0; GLInstanceVertex* cubeVerts = (GLInstanceVertex*)&cube_vertices[0]; int stride2 = sizeof(GLInstanceVertex); b3Assert(stride2 == strideInBytes); { int childColIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); b3Vector3 childPositions[3] = { b3MakeVector3(0,-2,0), b3MakeVector3(0,0,0), b3MakeVector3(0,0,2) }; b3AlignedObjectArray<b3GpuChildShape> childShapes; int numChildShapes = 3; for (int i=0;i<numChildShapes;i++) { //for now, only support polyhedral child shapes b3GpuChildShape child; child.m_shapeIndex = childColIndex; b3Vector3 pos = childPositions[i]; b3Quaternion orn(0,0,0,1); for (int v=0;v<4;v++) { child.m_childPosition[v] = pos[v]; child.m_childOrientation[v] = orn[v]; } childShapes.push_back(child); b3Transform tr; tr.setIdentity(); tr.setOrigin(pos); tr.setRotation(orn); int baseIndex = vertexArray.size(); for (int j=0;j<numIndices;j++) indexArray.push_back(cube_indices[j]+baseIndex); //add transformed graphics vertices and indices for (int v=0;v<numVertices;v++) { GLInstanceVertex vert = cubeVerts[v]; b3Vector3 vertPos=b3MakeVector3(vert.xyzw[0],vert.xyzw[1],vert.xyzw[2]); b3Vector3 newPos = tr*vertPos; vert.xyzw[0] = newPos[0]; vert.xyzw[1] = newPos[1]; vert.xyzw[2] = newPos[2]; vert.xyzw[3] = 0.f; vertexArray.push_back(vert); } } colIndex= m_data->m_np->registerCompoundShape(&childShapes); } //int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int shapeId = ci.m_instancingRenderer->registerShape(&vertexArray[0].xyzw[0],vertexArray.size(),&indexArray[0],indexArray.size()); b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,0,1,1), b3MakeVector4(0,1,1,1), }; int curColor = 0; 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 = 1;//j==0? 0.f : 1.f; b3Vector3 position=b3MakeVector3((-ci.arraySizeX/2+i)*ci.gapX,50+j*ci.gapY,(-ci.arraySizeZ/2+k)*ci.gapZ); //b3Quaternion orn(0,0,0,1); b3Quaternion orn(b3MakeVector3(1,0,0),0.7); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scaling=b3MakeVector4(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,false); index++; } } } }
void GpuSphereScene::setupScene(const ConstructionInfo& ci) { int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/sizeof(int); //int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int group=1; int mask=1; int index=0; bool writeInstanceToGpu = false; if (0) { float radius = 60; int prevGraphicsShapeIndex = -1; { if (1)//radius>=100) { int numVertices = sizeof(detailed_sphere_vertices)/strideInBytes; int numIndices = sizeof(detailed_sphere_indices)/sizeof(int); prevGraphicsShapeIndex = ci.m_instancingRenderer->registerShape(&detailed_sphere_vertices[0],numVertices,detailed_sphere_indices,numIndices); } else { bool usePointSprites = false; if (usePointSprites) { int numVertices = sizeof(point_sphere_vertices)/strideInBytes; int numIndices = sizeof(point_sphere_indices)/sizeof(int); prevGraphicsShapeIndex = ci.m_instancingRenderer->registerShape(&point_sphere_vertices[0],numVertices,point_sphere_indices,numIndices,B3_GL_POINTS); } else { if (radius>=10) { int numVertices = sizeof(medium_sphere_vertices)/strideInBytes; int numIndices = sizeof(medium_sphere_indices)/sizeof(int); prevGraphicsShapeIndex = ci.m_instancingRenderer->registerShape(&medium_sphere_vertices[0],numVertices,medium_sphere_indices,numIndices); } else { int numVertices = sizeof(low_sphere_vertices)/strideInBytes; int numIndices = sizeof(low_sphere_indices)/sizeof(int); prevGraphicsShapeIndex = ci.m_instancingRenderer->registerShape(&low_sphere_vertices[0],numVertices,low_sphere_indices,numIndices); } } } } b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,1,1,1), b3MakeVector4(1,1,0,1), }; int curColor = 0; //int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); int colIndex = m_data->m_np->registerSphereShape(radius);//>registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); float mass = 0.f; //b3Vector3 position((j&1)+i*2.2,1+j*2.,(j&1)+k*2.2); b3Vector3 position=b3MakeVector3(0,0,0); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scaling=b3MakeVector4(radius,radius,radius,1); int id = ci.m_instancingRenderer->registerGraphicsInstance(prevGraphicsShapeIndex,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index, writeInstanceToGpu); index++; } b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,1,1,1), b3MakeVector4(1,1,0,1), }; int curColor = 0; float radius = 61; //int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); int colIndex = m_data->m_np->registerSphereShape(radius);//>registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); int prevGraphicsShapeIndex = registerGraphicsSphereShape(ci,radius,false); //for (int i=0;i<ci.arraySizeX;i++) { // for (int j=0;j<ci.arraySizeY;j++) { // for (int k=0;k<ci.arraySizeZ;k++) { int i=0,j=0,k=0; float mass = 0.f; b3Vector3 position=b3MakeVector3(0,0,0); //b3Vector3 position((j&1)+i*142.2,-51+j*142.,(j&1)+k*142.2); //b3Vector3 position(0,-41,0);//0,0,0);//i*radius*3,-41+j*radius*3,k*radius*3); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scaling=b3MakeVector4(radius,radius,radius,1); int id = ci.m_instancingRenderer->registerGraphicsInstance(prevGraphicsShapeIndex,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index, writeInstanceToGpu); index++; } } } if (1) { int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); b3Vector4 scaling=b3MakeVector4(0.5,0.5,0.5,1);//1,1,1,1);//0.1,0.1,0.1,1); int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); b3Vector3 normal=b3MakeVector3(0,-1,0); float constant=2; for (int j=-10;j<10;j++) for (int i=-10;i<10;i++) for (int k=0;k<30;k++) //int i=0;int j=0; { //int colIndex = m_data->m_np->registerPlaneShape(normal,constant);//>registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); b3Vector4 position=b3MakeVector4(2*i,70+k*2,2*j+8,0); //b3Quaternion orn(0,0,0,1); b3Quaternion orn(b3MakeVector3(1,0,0),0.3); b3Vector4 color=b3MakeVector4(0,0,1,1); int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(1.f,position,orn,colIndex,index,false); index++; } } if (!writeInstanceToGpu) { m_data->m_rigidBodyPipeline->writeAllInstancesToGpu(); } float camPos[4]={ci.arraySizeX,ci.arraySizeY/2,ci.arraySizeZ,0}; //float camPos[4]={1,12.5,1.5,0}; m_instancingRenderer->setCameraTargetPosition(camPos); m_instancingRenderer->setCameraDistance(130); char msg[1024]; int numInstances = index; sprintf(msg,"Num objects = %d",numInstances); ci.m_gui->setStatusBarMessage(msg,true); }
void ConcaveCompound2Scene::createDynamicObjects(const ConstructionInfo& ci) { const char* fileName = "teddy2_VHACD_CHs.obj"; //char* fileName = "cube_offset.obj"; b3Vector3 shift=b3MakeVector3(0,0,0);//0,230,80);//150,-100,-120); b3Vector4 scaling=b3MakeVector4(1,1,1,1); const char* prefix[]={"./data/","../data/","../../data/","../../../data/","../../../../data/"}; int prefixIndex=-1; char relativeFileName[1024]; { int numPrefixes = sizeof(prefix)/sizeof(char*); for (int i=0;i<numPrefixes;i++) { sprintf(relativeFileName,"%s%s",prefix[i],fileName); FILE* f = 0; f = fopen(relativeFileName,"r"); if (f) { prefixIndex = i; fclose(f); break; } } } if (prefixIndex<0) return; std::vector<tinyobj::shape_t> shapes; std::string err = tinyobj::LoadObj(shapes, relativeFileName, prefix[prefixIndex]); if (shapes.size()>0) { int strideInBytes = 9*sizeof(float); b3AlignedObjectArray<GLInstanceVertex> vertexArray; b3AlignedObjectArray<int> indexArray; //int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int group=1; int mask=1; int index=0; int colIndex = 0; b3AlignedObjectArray<GLInstanceVertex> vertices; int stride2 = sizeof(GLInstanceVertex); b3Assert(stride2 == strideInBytes); { b3AlignedObjectArray<b3GpuChildShape> childShapes; int numChildShapes = shapes.size(); for (int i=0;i<numChildShapes;i++) // int i=4; { tinyobj::shape_t& shape = shapes[i]; int numVertices = shape.mesh.positions.size()/3; int numFaces = shape.mesh.indices.size()/3; //for now, only support polyhedral child shapes b3GpuChildShape child; b3Vector3 pos=b3MakeVector3(0,0,0); b3Quaternion orn(0,0,0,1); for (int v=0;v<4;v++) { child.m_childPosition[v] = pos[v]; child.m_childOrientation[v] = orn[v]; } b3Transform tr; tr.setIdentity(); tr.setOrigin(pos); tr.setRotation(orn); int baseIndex = vertexArray.size(); for (int f=0;f<numFaces;f++) { for (int i=0;i<3;i++) { indexArray.push_back(baseIndex+shape.mesh.indices[f*3+i]); } } b3Vector3 center=b3MakeVector3(0,0,0); b3AlignedObjectArray<GLInstanceVertex> tmpVertices; //add transformed graphics vertices and indices b3Vector3 myScaling=b3MakeVector3(50,50,50);//300,300,300); for (int v=0;v<numVertices;v++) { GLInstanceVertex vert; vert.uv[0] = 0.5f; vert.uv[1] = 0.5f; vert.normal[0]=0.f; vert.normal[1]=1.f; vert.normal[2]=0.f; b3Vector3 vertPos; vertPos[0] = shape.mesh.positions[v*3+0]*myScaling[0]; vertPos[1] = shape.mesh.positions[v*3+1]*myScaling[1]; vertPos[2] = shape.mesh.positions[v*3+2]*myScaling[2]; vertPos[3] =0.f; center+=vertPos; } center/=numVertices; for (int v=0;v<numVertices;v++) { GLInstanceVertex vert; vert.uv[0] = 0.5f; vert.uv[1] = 0.5f; vert.normal[0]=0.f; vert.normal[1]=1.f; vert.normal[2]=0.f; b3Vector3 vertPos; vertPos[0] = shape.mesh.positions[v*3+0]*myScaling[0]; vertPos[1] = shape.mesh.positions[v*3+1]*myScaling[1]; vertPos[2] = shape.mesh.positions[v*3+2]*myScaling[2]; vertPos[3] =0.f; // vertPos-=center; vert.xyzw[0] = vertPos[0]; vert.xyzw[1] = vertPos[1]; vert.xyzw[2] = vertPos[2]; tmpVertices.push_back(vert); b3Vector3 newPos = tr*vertPos; vert.xyzw[0] = newPos[0]; vert.xyzw[1] = newPos[1]; vert.xyzw[2] = newPos[2]; vert.xyzw[3] = 0.f; vertexArray.push_back(vert); } int childColIndex = m_data->m_np->registerConvexHullShape(&tmpVertices[0].xyzw[0],strideInBytes,numVertices, scaling); child.m_shapeIndex = childColIndex; childShapes.push_back(child); colIndex = childColIndex; } colIndex= m_data->m_np->registerCompoundShape(&childShapes); } //int shapeId = ci.m_instancingRenderer->registerShape(&cube_vertices[0],numVertices,cube_indices,numIndices); int shapeId = ci.m_instancingRenderer->registerShape(&vertexArray[0].xyzw[0],vertexArray.size(),&indexArray[0],indexArray.size()); b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,0,1,1), b3MakeVector4(0,1,1,1), }; int curColor = 0; for (int i=0;i<1;i++)//ci.arraySizeX;i++) { for (int j=0;j<4;j++) { // for (int k=0;k<ci.arraySizeZ;k++) int k=0; { float mass = 1;//j==0? 0.f : 1.f; //b3Vector3 position(i*10*ci.gapX,j*ci.gapY,k*10*ci.gapZ); b3Vector3 position=b3MakeVector3(i*10*ci.gapX,10+j*10*ci.gapY,k*10*ci.gapZ); // b3Quaternion orn(0,0,0,1); b3Quaternion orn(b3MakeVector3(0,0,1),1.8); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scaling=b3MakeVector4(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,false); index++; } } } } }
void ConcaveScene::createDynamicObjects(const ConstructionInfo& ci) { int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/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=0; if (1) { int curColor = 0; b3Vector4 colors[4] = { b3MakeVector4(1,1,1,1), b3MakeVector4(1,1,0.3,1), b3MakeVector4(0.3,1,1,1), b3MakeVector4(0.3,0.3,1,1), }; b3ConvexUtility* utilPtr = new b3ConvexUtility(); b3Vector4 scaling=b3MakeVector4(1,1,1,1); { b3AlignedObjectArray<b3Vector3> verts; unsigned char* vts = (unsigned char*) cube_vertices; for (int i=0;i<numVertices;i++) { float* vertex = (float*) &vts[i*strideInBytes]; verts.push_back(b3MakeVector3(vertex[0]*scaling[0],vertex[1]*scaling[1],vertex[2]*scaling[2])); } bool merge = true; if (numVertices) { utilPtr->initializePolyhedralFeatures(&verts[0],verts.size(),merge); } } // int colIndex = m_data->m_np->registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); int colIndex=-1; if (ci.m_useInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); for (int i=0;i<ci.arraySizeX;i++) { for (int j=0;j<ci.arraySizeY;j++) { for (int k=0;k<ci.arraySizeZ;k++) { if (!ci.m_useInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); float mass = 1; //b3Vector3 position(-2*ci.gapX+i*ci.gapX,25+j*ci.gapY,-2*ci.gapZ+k*ci.gapZ); b3Vector3 position=b3MakeVector3(-(ci.arraySizeX/2)*CONCAVE_GAPX+i*CONCAVE_GAPX, 23+j*CONCAVE_GAPY, -(ci.arraySizeZ/2)*CONCAVE_GAPZ+k*CONCAVE_GAPZ); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; int id = ci.m_instancingRenderer->registerGraphicsInstance(shapeId,position,orn,color,scaling); int pid = m_data->m_rigidBodyPipeline->registerPhysicsInstance(mass,position,orn,colIndex,index,false); index++; } } } } }
int GpuConvexScene::createDynamicsObjects2(const ConstructionInfo& ci, const float* vertices, int numVertices, const int* indices, int numIndices) { int strideInBytes = 9*sizeof(float); int shapeId = ci.m_instancingRenderer->registerShape(&vertices[0],numVertices,indices,numIndices); int group=1; int mask=1; int index=0; { int curColor = 0; float scaling[4] = {1,1,1,1}; int prevBody = -1; int insta = 0; b3ConvexUtility* utilPtr = new b3ConvexUtility(); { b3AlignedObjectArray<b3Vector3> verts; unsigned char* vts = (unsigned char*) vertices; for (int i=0;i<numVertices;i++) { float* vertex = (float*) &vts[i*strideInBytes]; verts.push_back(b3MakeVector3(vertex[0]*scaling[0],vertex[1]*scaling[1],vertex[2]*scaling[2])); } bool merge = true; if (numVertices) { utilPtr->initializePolyhedralFeatures(&verts[0],verts.size(),merge); } } int colIndex=-1; if (ci.m_useInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); //int colIndex = m_data->m_np->registerSphereShape(1); for (int i=0;i<ci.arraySizeX;i++) { //printf("%d of %d\n", i, ci.arraySizeX); for (int j=0;j<ci.arraySizeY;j++) { for (int k=0;k<ci.arraySizeZ;k++) { //int colIndex = m_data->m_np->registerConvexHullShape(&vertices[0],strideInBytes,numVertices, scaling); if (!ci.m_useInstancedCollisionShapes) colIndex = m_data->m_np->registerConvexHullShape(utilPtr); float mass = 1.f; if (j==0)//ci.arraySizeY-1) { //mass=0.f; } b3Vector3 position = b3MakeVector3(((j+1)&1)+i*2.2,1+j*2.,((j+1)&1)+k*2.2); //b3Vector3 position(i*2.2,10+j*1.9,k*2.2); //b3Vector3 position=b3MakeVector3(1,0.9,1); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scalin=b3MakeVector4(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,false); if (prevBody>=0) { //b3Point2PointConstraint* p2p = new b3Point2PointConstraint(pid,prevBody,b3Vector3(0,-1.1,0),b3Vector3(0,1.1,0)); // m_data->m_rigidBodyPipeline->addConstraint(p2p);//,false); } prevBody = pid; index++; } } } delete utilPtr; } return index; }
int GpuRaytraceScene::createDynamicsObjects(const ConstructionInfo& ci2) { //m_raytraceData->m_renderToTexture->init(ci2.m_instancingRenderer->getScreenWidth(),ci2.m_instancingRenderer->getScreenHeight()); ConstructionInfo ci = ci2; ci.arraySizeX = 2; ci.arraySizeY = 50; ci.arraySizeZ = 2; int strideInBytes = 9*sizeof(float); int numVertices = sizeof(cube_vertices)/strideInBytes; int numIndices = sizeof(cube_indices)/sizeof(int); return createDynamicsObjects2(ci,cube_vertices,numVertices,cube_indices,numIndices); float radius=1.f; int colIndex = m_data->m_np->registerSphereShape(radius);//>registerConvexHullShape(&cube_vertices[0],strideInBytes,numVertices, scaling); int shapeId = registerGraphicsSphereShape(ci,radius,false); int group=1; int mask=1; int index=0; { b3Vector4 colors[4] = { b3MakeVector4(1,0,0,1), b3MakeVector4(0,1,0,1), b3MakeVector4(0,1,1,1), b3MakeVector4(1,1,0,1), }; int curColor = 0; float scaling[4] = {1,1,1,1}; int prevBody = -1; int insta = 0; //int colIndex = m_data->m_np->registerSphereShape(1); for (int i=0;i<1;i++) //for (int i=0;i<ci.arraySizeX;i++) { //for (int j=0;j<ci.arraySizeY;j++) for (int j=0;j<10;j++) { // for (int k=0;k<ci.arraySizeZ;k++) for (int k=0;k<1;k++) { float mass = 1.f; if (j==0)//ci.arraySizeY-1) { //mass=0.f; } b3Vector3 position=b3MakeVector3((j&1)+i*2.2,1+j*2.,(j&1)+k*2.2); //b3Vector3 position(i*2.2,10+j*1.9,k*2.2); b3Quaternion orn(0,0,0,1); b3Vector4 color = colors[curColor]; curColor++; curColor&=3; b3Vector4 scaling=b3MakeVector4(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,false); if (prevBody>=0) { //b3Point2PointConstraint* p2p = new b3Point2PointConstraint(pid,prevBody,b3Vector3(0,-1.1,0),b3Vector3(0,1.1,0)); // m_data->m_rigidBodyPipeline->addConstraint(p2p);//,false); } prevBody = pid; index++; } } } } return index; }
Tutorial(GUIHelperInterface* guiHelper, int tutorialIndex) :m_app(guiHelper->getAppInterface()), m_guiHelper(guiHelper), m_tutorialIndex(tutorialIndex), m_stage(0), m_counter(0), m_timeSeriesCanvas0(0), m_timeSeriesCanvas1(0) { int numBodies = 1; m_app->setUpAxis(1); m_app->m_renderer->enableBlend(true); switch (m_tutorialIndex) { case TUT_VELOCITY: { numBodies=10; m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Constant Velocity"); m_timeSeriesCanvas0 ->setupTimeSeries(2,60, 0); m_timeSeriesCanvas0->addDataSource("X position (m)", 255,0,0); m_timeSeriesCanvas0->addDataSource("X velocity (m/s)", 0,0,255); m_timeSeriesCanvas0->addDataSource("dX/dt (m/s)", 0,0,0); break; } case TUT_ACCELERATION: { numBodies=10; m_timeSeriesCanvas1 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,256,512,"Constant Acceleration"); m_timeSeriesCanvas1 ->setupTimeSeries(50,60, 0); m_timeSeriesCanvas1->addDataSource("Y position (m)", 255,0,0); m_timeSeriesCanvas1->addDataSource("Y velocity (m/s)", 0,0,255); m_timeSeriesCanvas1->addDataSource("dY/dt (m/s)", 0,0,0); break; } case TUT_COLLISION: { numBodies=2; m_timeSeriesCanvas1 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,200,"Distance"); m_timeSeriesCanvas1 ->setupTimeSeries(1.5,60, 0); m_timeSeriesCanvas1->addDataSource("distance", 255,0,0); break; } case TUT_SOLVE_CONTACT_CONSTRAINT: { numBodies=2; m_timeSeriesCanvas1 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,200,"Collision Impulse"); m_timeSeriesCanvas1 ->setupTimeSeries(1.5,60, 0); m_timeSeriesCanvas1->addDataSource("Distance", 0,0,255); m_timeSeriesCanvas1->addDataSource("Impulse magnutide", 255,0,0); { SliderParams slider("Restitution",&gRestitution); slider.m_minVal=0; slider.m_maxVal=1; m_guiHelper->getParameterInterface()->registerSliderFloatParameter(slider); } { SliderParams slider("Mass A",&gMassA); slider.m_minVal=0; slider.m_maxVal=100; m_guiHelper->getParameterInterface()->registerSliderFloatParameter(slider); } { SliderParams slider("Mass B",&gMassB); slider.m_minVal=0; slider.m_maxVal=100; m_guiHelper->getParameterInterface()->registerSliderFloatParameter(slider); } break; } default: { m_timeSeriesCanvas0 = new TimeSeriesCanvas(m_app->m_2dCanvasInterface,512,256,"Unknown"); m_timeSeriesCanvas0 ->setupTimeSeries(1,60, 0); } }; if (m_tutorialIndex==TUT_VELOCITY) { int boxId = m_app->registerCubeShape(100,1,100); b3Vector3 pos = b3MakeVector3(0,-3.5,0); b3Quaternion orn(0,0,0,1); b3Vector4 color = b3MakeVector4(1,1,1,1); b3Vector3 scaling = b3MakeVector3(1,1,1); m_app->m_renderer->registerGraphicsInstance(boxId,pos,orn,color,scaling); } for (int i=0;i<numBodies;i++) { m_bodies.push_back(new LWRigidBody()); } for (int i=0;i<m_bodies.size();i++) { m_bodies[i]->m_worldPose.m_position.setValue((i/4)*5,3,(i&3)*5); } { int textureIndex = -1; if (1) { int width,height,n; const char* filename = "data/cube.png"; const unsigned char* image=0; const char* prefix[]={"./","../","../../","../../../","../../../../"}; int numprefix = sizeof(prefix)/sizeof(const char*); for (int i=0;!image && i<numprefix;i++) { char relativeFileName[1024]; sprintf(relativeFileName,"%s%s",prefix[i],filename); image = stbi_load(relativeFileName, &width, &height, &n, 0); } b3Assert(image); if (image) { textureIndex = m_app->m_renderer->registerTexture(image,width,height); } } // int boxId = m_app->registerCubeShape(1,1,1,textureIndex); int boxId = m_app->registerGraphicsUnitSphereShape(SPHERE_LOD_HIGH, textureIndex); b3Vector4 color = b3MakeVector4(1,1,1,0.8); b3Vector3 scaling = b3MakeVector3(SPHERE_RADIUS,SPHERE_RADIUS,SPHERE_RADIUS); for (int i=0;i<m_bodies.size();i++) { m_bodies[i]->m_collisionShape.m_sphere.m_radius = SPHERE_RADIUS; m_bodies[i]->m_collisionShape.m_type = LW_SPHERE_TYPE; m_bodies[i]->m_graphicsIndex = m_app->m_renderer->registerGraphicsInstance(boxId,m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation,color,scaling); m_app->m_renderer->writeSingleInstanceTransformToCPU(m_bodies[i]->m_worldPose.m_position, m_bodies[i]->m_worldPose.m_orientation, m_bodies[i]->m_graphicsIndex); } } if (m_tutorialIndex == TUT_SOLVE_CONTACT_CONSTRAINT) { m_bodies[0]->m_invMass = gMassA? 1./gMassA : 0; m_bodies[0]->m_collisionShape.m_sphere.computeLocalInertia(gMassA,m_bodies[0]->m_localInertia); m_bodies[1]->m_invMass =gMassB? 1./gMassB : 0; m_bodies[1]->m_collisionShape.m_sphere.computeLocalInertia(gMassB,m_bodies[1]->m_localInertia); if (gMassA) m_bodies[0]->m_linearVelocity.setValue(0,0,1); if (gMassB) m_bodies[1]->m_linearVelocity.setValue(0,0,-1); } m_app->m_renderer->writeTransforms(); }