added compound shape for raytrace testing

Demos/Raytracer/Raytracer.cpp

@@ -11,6 +11,48 @@
 
 
 
+#define IN_TO_M_CONSTANT   (0.0254f)
+#define M_TO_IN_CONSTANT   (39.3700787f)
+#define CM_TO_IN_CONSTANT  (0.393700787f)
+#define LBS_TO_KG_CONSTANT (0.45359237f)
+
+#define FEET_TO_IN(x) (12.0f * (float)(x))
+#define IN_TO_FT(x)   ((float)(x)/12.0f)
+#define IN_TO_M(x)    ((float)(x) * IN_TO_M_CONSTANT)
+#define M_TO_IN(x)    ((float)(x) * M_TO_IN_CONSTANT)
+#define CM_TO_IN(x)   ((float)(x) * CM_TO_IN_CONSTANT)
+#define FT_TO_M(x)    (IN_TO_M(FEET_TO_IN(x)))
+#define LBS_TO_KG(x)  ((float)(x) * LBS_TO_KG_CONSTANT)
+
+#define PIN_HEIGHT     IN_TO_M(15.0f)
+#define PIN_DIAMETER   IN_TO_M(4.76f)
+#define PIN_MASS       LBS_TO_KG(3.5f)
+#define PIN_FRICTION   (BALL_FRICTION) // a guess
+//#define PIN_COR        (0.67f) // was 0.67
+#define PIN_COR        (0.2f)
+
+#define BALL_DIAMETER     IN_TO_M(8.55f)
+#define BALL_MASS         LBS_TO_KG(16.0f)
+#define BALL_FRICTION     (0.3f) // max is 0.32
+#define BALL_COR          (0.7)
+#define BALL_MAX_FRICTION (0.32f)
+#define BALL_MAX_MASS     (16.0f) // lbs
+#define BALL_MIN_MASS     (8.0f)  // lbs
+
+#define LANE_DECK_FUDGE (IN_TO_M(6.0f))
+
+#define LANE_WIDTH        IN_TO_M(42.0f)
+#define LANE_TOTAL_WIDTH  IN_TO_M(62.88f)
+#define LANE_LENGTH       FT_TO_M(60.0f-LANE_DECK_FUDGE)
+
+#define GRAVITY_VECTOR (btVector3(0.0f,-9.81f,0.0f))
+
+#define PIN_Z_DIST IN_TO_M(10.3923048f)
+#define PIN_Y_DIST IN_TO_M(12.0f)
+
+#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
+
+
 /*
 Raytracer uses the Convex rayCast to visualize the Collision Shapes/Minkowski Sum.
 Very basic raytracer, rendering into a texture.
@@ -43,7 +85,7 @@ Very basic raytracer, rendering into a texture.
 #include "BulletCollision/CollisionShapes/btConvexHullShape.h"
 #include "LinearMath/btAabbUtil2.h"
 #include "BulletCollision/CollisionShapes/btBoxShape.h"
-
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
 
 
 #include "BulletCollision/CollisionShapes/btTetrahedronShape.h"
@@ -66,21 +108,23 @@ const int numObjects = 1;
 /// simplex contains the vertices, and some extra code to draw and debug
 GL_Simplex1to4	simplex;
 
-btConvexShape*	shapePtr[maxNumObjects];
+btCollisionShape*	shapePtr[maxNumObjects];
 btTransform transforms[maxNumObjects];
 
 renderTexture*	raytracePicture = 0;
 
 //this applies to the raytracer virtual screen/image buffer
-int screenWidth = 128;
+int screenWidth = 256;
 //float aspectRatio = (3.f/4.f);
-int screenHeight = 128;//screenWidth * aspectRatio;
+int screenHeight = 256;//screenWidth * aspectRatio;
 GLuint glTextureId;
 
 btSphereShape	mySphere(1);
 btBoxShape myBox(btVector3(0.4f,0.4f,0.4f));
 btCylinderShape myCylinder(btVector3(0.3f,0.3f,0.3f));
 btConeShape myCone(1,1);
+btCompoundShape compound;
+
 
 btMinkowskiSumShape myMink(&myCylinder,&myBox);
 GLDebugDrawer debugDrawer;
@@ -128,21 +172,51 @@ void	Raytracer::initPhysics()
 	};
 
 	//btMultiSphereShape* multiSphereShape = new btMultiSphereShape(inertiaHalfExtents,positions,radi,NUM_SPHERES);
-	btVector3 sphereOffset(0,0,0);
+
+	btVector3 sphereOffset1(0,0,0);
 	btScalar sphereRadius = 2.f;
 	btVector3 nonUniformScaling(0.5,2,0.5);
-	btMultiSphereShape* nonuniformScaledSphere = new btMultiSphereShape(inertiaHalfExtents,&sphereOffset,&sphereRadius,1);
+	btMultiSphereShape* nonuniformScaledSphere = new btMultiSphereShape(inertiaHalfExtents,&sphereOffset1,&sphereRadius,1);
 	nonuniformScaledSphere->setLocalScaling(nonUniformScaling);
 	nonuniformScaledSphere->setMargin(0.04);
 	btConvexHullShape* convexHullShape = new btConvexHullShape(&positions[0].getX(),3);
 
-
+	//attempt to approximate a bowling pin
 	//choose shape
-	shapePtr[0] = &myCone;//&myBox;//nonuniformScaledSphere;//&myCone;
+	shapePtr[0] = &myCone;//&compound;//&myCone;//&myBox;//nonuniformScaledSphere;//&myCone;
+	//	shapePtr[0] = &myCone;//&myBox;//nonuniformScaledSphere;//&myCone;
+	
 	shapePtr[1] =&simplex;
 	shapePtr[2] =convexHullShape;
 	shapePtr[3] =&myMink;//myBox;//multiSphereShape
 
+	btVector3 sphereOffset(0,PIN_HEIGHT/4.0f,0);
+
+	// create pin collision shape
+	btCollisionShape* cyl = new btCylinderShape(btVector3(PIN_DIAMETER/4.0f, PIN_HEIGHT/4.0f, PIN_DIAMETER/4.0f));
+	cyl->setMargin(IN_TO_M(0.000025f));
+	btVector3	spherepositions[3] = {btVector3(0,-PIN_HEIGHT/2.f +(PIN_DIAMETER/2.0f)+IN_TO_M(1.25f),0),
+btVector3(0,-PIN_HEIGHT/2.f +(PIN_DIAMETER/2.0f)+IN_TO_M(1.25f),0)+sphereOffset,
+btVector3(0,-PIN_HEIGHT/2.f +(PIN_DIAMETER/2.0f)+IN_TO_M(1.25f),0)-sphereOffset};
+	btScalar	radii[3] = {(PIN_DIAMETER/2.0f),(PIN_DIAMETER/4.0f),(PIN_DIAMETER/4.0f)};
+	btCollisionShape* sph = new btMultiSphereShape(inertiaHalfExtents,spherepositions,radii,3);
+	
+	btTransform ident;
+	ident.setIdentity();
+	ident.setOrigin(btVector3(0.f,-PIN_HEIGHT/4.f,0.f));
+	compound.addChildShape(ident,cyl);
+	ident.setIdentity();
+	//ident.setOrigin(btVector3(0.0f, -PIN_HEIGHT/2.0f + PIN_DIAMETER/2.0f + IN_TO_M(3.5f), 0.0f));
+	compound.addChildShape(ident,sph);
+
+	btVector3	spherepositions2[2] = {btVector3(0,+PIN_HEIGHT/2.f -(PIN_DIAMETER/4.0f),0),
+		btVector3(0,0,0)};
+	btScalar	radii2[2] = {(PIN_DIAMETER/4.0f),(PIN_DIAMETER/6.0f)};
+
+	btCollisionShape* sph2 = new btMultiSphereShape(inertiaHalfExtents,spherepositions2,radii2,2);
+	compound.addChildShape(ident,sph2);
+	
+	compound.setMargin(0.001);
 	simplex.setMargin(0.3f);
 
 
@@ -176,7 +250,7 @@ void Raytracer::displayCallback()
 		if (i < 2)
 		{
 			orn.setEuler(yaw,pitch,roll);
-			transforms[i].setRotation(orn);
+			//transforms[i].setRotation(orn);
 		}
 	}
 	myMink.setTransformA(btTransform(transforms[0].getRotation()));
@@ -266,10 +340,15 @@ void Raytracer::displayCallback()
 	}
 	
 
-	btConvexCast::CastResult rayResult;
+//	btConvexCast::CastResult rayResult;
 	btTransform rayToTrans;
 	rayToTrans.setIdentity();
 	btVector3 rayTo;
+	btTransform colObjWorldTransform;
+	colObjWorldTransform.setIdentity();
+
+	
+
 	for (x=0;x<screenWidth;x++)
 	{
 		for (int y=0;y<screenHeight;y++)
@@ -286,23 +365,36 @@ void Raytracer::displayCallback()
 				btScalar hitLambda = 1.f;
 				btVector3 hitNormal;
 
+				btCollisionWorld::ClosestRayResultCallback resultCallback(rayFrom,rayTo);
+				btCollisionObject	tmpObj;
+				tmpObj.setWorldTransform(transforms[s]);
+		
+
 				if (btRayAabb(rayFrom,rayTo,aabbMin,aabbMax,hitLambda,hitNormal))
 				{
+
+
+					btCollisionWorld::rayTestSingle(rayFromTrans,rayToTrans,
+					  &tmpObj,
+					  shapePtr[s],
+					  transforms[s],
+					  resultCallback);
 				
 					//choose the continuous collision detection method
-					btSubsimplexConvexCast convexCaster(&pointShape,shapePtr[s],&simplexSolver);
+					//btSubsimplexConvexCast convexCaster(&pointShape,shapePtr[s],&simplexSolver);
 					//GjkConvexCast convexCaster(&pointShape,shapePtr[0],&simplexSolver);
 					//ContinuousConvexCollision convexCaster(&pointShape,shapePtr[0],&simplexSolver,0);
 					
 					//reset previous result
-					rayResult.m_fraction = 1.f;
+					//rayResult.m_fraction = 1.f;
-					if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,transforms[s],transforms[s],rayResult))
+					if (resultCallback.HasHit())
+//					if (convexCaster.calcTimeOfImpact(rayFromTrans,rayToTrans,transforms[s],transforms[s],rayResult))
 					{
 						//float fog = 1.f - 0.1f * rayResult.m_fraction;
-						rayResult.m_normal.normalize();
+						resultCallback.m_hitNormalWorld.normalize();//.m_normal.normalize();
 
-						btVector3 worldNormal;
+						btVector3 worldNormal = resultCallback.m_hitNormalWorld;
-						worldNormal = transforms[s].getBasis() *rayResult.m_normal;
+//						worldNormal = transforms[s].getBasis() *rayResult.m_normal;
 						
 
 						float lightVec0 = worldNormal.dot(btVector3(0,-1,-1));//0.4f,-1.f,-0.4f));