CollisionBody::CollisionBody(glm::vec3 passPosition, int type)
{
trans.setIdentity();
trans.setOrigin(btVector3(0,0,0));
CurrentPosition.x = passPosition.x;
CurrentPosition.y = passPosition.y;
CurrentPosition.z = passPosition.z;
swap = 0;
if(type == 1)
{
cout<<"type 1";
CreateRigidBody(passPosition, 2.5);
}
else if(type == 3)
{
//createplane();
}
else
{
cout<<"type2";
CreateRigidBody(passPosition, 10,10,10);
}
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
NewtonBody* floorBody;
NewtonCollision* shape;
// initialize the camera
InitCamera (dVector (-15.0f, 5.0f, 0.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f));
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
floor->LoadMesh ("FloorBox.dat");
// add static floor Physics
shape = CreateNewtonBox (world, floor, 0);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// set the Transformation Matrix for this rigid body
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// find the floor base, and add some distance up;
dFloat floorY = FindFloor (world, 0.0f, 0.0f) + 2.0f;
// this is the width of the Box;
dFloat boxWidth = 0.42f;
// Make a small pyramid of Boxes
for (int i = 0; i < PYRAMID_BASE + 1; i ++) {
for (int j = 0; j < PYRAMID_BASE - i; j ++) {
Entity* smilly;
NewtonBody* smillyBody;
// crate a visual Box and place in a pyramid formation above the floor
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_x = 0.0f;
smilly->m_curPosition.m_z = dFloat (j) * boxWidth + dFloat (i) * (boxWidth * 0.5f);
smilly->m_curPosition.m_y = floorY + dFloat (i) * boxWidth;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, 0);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonDestroyCollision(shape);
// we want some nice object placement, with zero penetration and and zero jitter
// therefore we are going use use a Convex Cast function to snap the Box to the closest contact surface
ConvexCastPlacement (smillyBody);
}
}
}
int CcdChapter::Init()
{
CreateScene();
// load resource
LoadResource();
CreateBullet();
Plane plane(Vector3::UNIT_Y, 0);
MeshManager::getSingleton().createPlane("ground", ResourceGroup, plane, 500, 500, 1, 1, true, 1, 5, 5, Vector3::UNIT_Z);
Entity *groundEntity = m_pkSceneManager->createEntity("GroundEntity", "ground");
groundEntity->setMaterialName("BulletPlane", ResourceGroup);
groundEntity->setCastShadows(true);
SceneNode *pkNode = m_pkRootNode->createChildSceneNode();
pkNode->attachObject(groundEntity);
btCollisionShape *shape = CreateCollisionShape(SHAPE_TYPE::SHAPE_PLANE, Vector3::ZERO);
m_CollisionShapes.push_back(shape);
btRigidBody *body = CreateRigidBody(shape, false, pkNode, 100);
m_RigidBodies.push_back(body);
m_pkDynamicsWorld->addRigidBody(body);
body->setUserPointer(pkNode);
//body->setFriction(100);
return 0;
}
void LoadTetrahedraCube(DemoEntityManager* const scene, int materialID)
{
dFloat mass = 5.0f;
NewtonWorld* const world = scene->GetNewton();
char name[2048];
dGetWorkingFileName ("box.tet", name);
NewtonMesh* const tetraCube = NewtonMeshLoadTetrahedraMesh(scene->GetNewton(), name);
dMatrix aligmentUV(dGetIdentityMatrix());
int material = LoadTexture("smilli.tga");
NewtonMeshApplyBoxMapping(tetraCube, material, material, material, &aligmentUV[0][0]);
NewtonMeshCalculateVertexNormals(tetraCube, 60.0f * dDegreeToRad);
// make a deformable collision mesh
NewtonCollision* const deformableCollision = NewtonCreateDeformableSolid(world, tetraCube, materialID);
//create a rigid body with a deformable mesh
m_body = CreateRigidBody(scene, mass, deformableCollision);
// create the soft body mesh
//m_mesh = new TetrahedraSoftMesh(tetraCube, m_body);
DemoMesh* const mesh = new TetrahedraSoftMesh(scene, tetraCube, m_body);
SetMesh(mesh, dGetIdentityMatrix());
// do not forget to destroy this objects, else you get bad memory leaks.
mesh->Release ();
NewtonDestroyCollision(deformableCollision);
NewtonMeshDestroy(tetraCube);
}
void BuildRegularTetrahedra (DemoEntityManager* const scene, int materialID)
{
dFloat mass = 5.0f;
NewtonWorld* const world = scene->GetNewton();
dVector tetra[] = { dVector(-1.0f, 0.0f, -0.71f, 0.0f),
dVector(1.0f, 0.0f, -0.71f, 0.0f),
dVector(0.0f, -1.0f, 0.71f, 0.0f),
dVector(0.0f, 1.0f, 0.71f, 0.0f) };
NewtonMesh* const tetrahedra = NewtonMeshCreate(scene->GetNewton());
NewtonMeshBeginBuild(tetrahedra);
AddTetra (tetrahedra, 0, 1, 2, 3, tetra, 0);
NewtonMeshEndBuild(tetrahedra);
dMatrix aligmentUV(dGetIdentityMatrix());
int material = LoadTexture("smilli.tga");
NewtonMeshApplyBoxMapping (tetrahedra, material, material, material, &aligmentUV[0][0]);
NewtonMeshCalculateVertexNormals (tetrahedra, 60.0f * dDegreeToRad);
// make a deformable collision mesh
NewtonCollision* const deformableCollision = NewtonCreateDeformableSolid(world, tetrahedra, materialID);
//create a rigid body with a deformable mesh
m_body = CreateRigidBody (scene, mass, deformableCollision);
// create the soft body mesh
DemoMesh* const mesh = new TetrahedraSoftMesh(scene, tetrahedra, m_body);
SetMesh(mesh, dGetIdentityMatrix());
// do not forget to destroy this objects, else you get bad memory leaks.
mesh->Release ();
NewtonMeshDestroy (tetrahedra);
NewtonDestroyCollision(deformableCollision);
}
// LinkGeometry()
// this function will link the geometry to the correct rigid body object
// it will search up in the tree until it find a valid rigid object
// then it will make its geometry transformed relative to it
// this will add the geometry (and the mass) to it
void VDSGeom::LinkGeometry()
{
// if this is a root.. create a body
if ( m_pParent == NULL )
{
CreateRigidBody();
}
}
NewtonBody* CPhysics::CreateBox(NewtonWorld *world, CObject3D *object, float x, float y, float z, float mass, Vector3 offset)
{
Matrix4 offsetMat;
offsetMat.SetPosition(offset);
float m[16];
offsetMat.FlattenToArray(m);
NewtonCollision *collision = NewtonCreateBox(world, x, y, z, 0, m);
return CreateRigidBody(world, object, collision, mass);
}
CollisionBody::CollisionBody(glm::vec3 passPosition,float length, float width, float height)
{
trans.setIdentity();
trans.setOrigin(btVector3(0,0,0));
CurrentPosition.x = passPosition.x;
CurrentPosition.y = passPosition.y;
CurrentPosition.z = passPosition.z;
swap = 0;
CreateRigidBody(passPosition, length,width,height);
}
// Constructor
_Collision::_Collision(const SpawnStruct &Object)
: _Object(),
TriangleIndexVertexArray(NULL),
TriangleInfoMap(NULL),
VertexList(NULL),
FaceList(NULL) {
gContactAddedCallback = CustomMaterialCallback;
// Load collision mesh file
_File MeshFile;
if(MeshFile.OpenForRead(Object.Template->CollisionFile.c_str())) {
// Read header
int VertCount = MeshFile.ReadInt();
int FaceCount = MeshFile.ReadInt();
// Allocate memory for lists
VertexList = new float[VertCount * 3];
FaceList = new int[FaceCount * 3];
// Read vertices
int VertexIndex = 0;
for(int i = 0; i < VertCount; i++) {
VertexList[VertexIndex++] = MeshFile.ReadFloat();
VertexList[VertexIndex++] = MeshFile.ReadFloat();
VertexList[VertexIndex++] = -MeshFile.ReadFloat();
}
// Read faces
int FaceIndex = 0;
for(int i = 0; i < FaceCount; i++) {
FaceList[FaceIndex+2] = MeshFile.ReadInt();
FaceList[FaceIndex+1] = MeshFile.ReadInt();
FaceList[FaceIndex+0] = MeshFile.ReadInt();
FaceIndex += 3;
}
// Create triangle array
TriangleIndexVertexArray = new btTriangleIndexVertexArray(FaceCount, FaceList, 3 * sizeof(int), VertCount * 3, VertexList, 3 * sizeof(float));
// Create bvh shape
btBvhTriangleMeshShape *Shape = new btBvhTriangleMeshShape(TriangleIndexVertexArray, true);
TriangleInfoMap = new btTriangleInfoMap();
btGenerateInternalEdgeInfo(Shape, TriangleInfoMap);
// Create physics body
CreateRigidBody(Object, Shape);
SetProperties(Object);
RigidBody->setCollisionFlags(RigidBody->getCollisionFlags() | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
MeshFile.Close();
}
}
// Constructor
_Player::_Player(const SpawnStruct &Object)
: _Object(),
Sound(NULL),
Camera(NULL),
Light(NULL),
JumpTimer(0.0f),
TorqueFactor(4.0f) {
// Graphics
Node = irrScene->addSphereSceneNode(Object.Template->Radius, 24);
Node->setMaterialTexture(0, irrDriver->getTexture("textures/player_outer0.png"));
Node->setMaterialType(EMT_TRANSPARENT_ADD_COLOR);
Node->setMaterialFlag(EMF_LIGHTING, false);
Node->setMaterialType(EMT_ONETEXTURE_BLEND);
Node->getMaterial(0).MaterialTypeParam = pack_textureBlendFunc(EBF_ONE, EBF_ONE);
// Emit Light
if(Object.Template->EmitLight) {
Light = irrScene->addLightSceneNode(0, vector3df(Object.Position[0], Object.Position[1], Object.Position[2]), video::SColorf(1.0f, 1.0f, 1.0f), 15.0f);
Light->getLightData().Attenuation.set(0.5f, 0.05f, 0.05f);
Light->getLightData().DiffuseColor.set(1.0f, 0.75f, 0.75f, 1.0f);
}
// Add glow
ISceneNode *InnerNode;
InnerNode = irrScene->addBillboardSceneNode(Node, dimension2df(1.5f, 1.5f));
InnerNode->setMaterialFlag(EMF_LIGHTING, false);
InnerNode->setMaterialFlag(EMF_ZBUFFER, false);
InnerNode->setMaterialTexture(0, irrDriver->getTexture("textures/player_glow0.png"));
InnerNode->setMaterialType(EMT_ONETEXTURE_BLEND);
InnerNode->getMaterial(0).MaterialTypeParam = pack_textureBlendFunc(EBF_ONE, EBF_ONE);
if(Physics.IsEnabled()) {
// Create shape
btSphereShape *Shape = new btSphereShape(Object.Template->Radius);
// Set up physics
CreateRigidBody(Object, Shape);
RigidBody->setSleepingThresholds(0.1f, 0.1f);
// Audio
Sound = new _AudioSource(Audio.GetBuffer("player.ogg"), true, 0.0, 0.50f);
Sound->SetPosition(Object.Position[0], Object.Position[1], Object.Position[2]);
Sound->Play();
}
SetProperties(Object);
Hookable = false;
if(CollisionCallback == "")
CollisionCallback = "OnHitPlayer";
}
void BulletDynamicsBody::Initialize( const Integration::DynamicsBodySettings& settings, Integration::DynamicsShape* shape,
Integration::DynamicsWorld& dynamicsWorld,
const Vector3& startPosition, const Quaternion& startRotation )
{
DEBUG_PRINTF("%s type:%d\n", __func__, settings.type );
mSettings = new Integration::DynamicsBodySettings( settings );
mWorld = static_cast< BulletDynamicsWorld* >( &dynamicsWorld );
if( Dali::DynamicsBodyConfig::RIGID == mSettings->type )
{
CreateRigidBody( settings, shape, startPosition, startRotation );
}
else
{
CreateSoftBody( settings, shape, startPosition, startRotation );
}
}
void CreateTetrahedraPrimitive(DemoEntityManager* const scene, int materialID)
{
dFloat mass = 5.0f;
dVector size (1.0f);
NewtonWorld* const world = scene->GetNewton();
NewtonCollision* const primitiveShape = CreateConvexCollision (world, dGetIdentityMatrix(), size, _SPHERE_PRIMITIVE, materialID);
//NewtonCollision* const primitiveShape = CreateConvexCollision (world, dGetIdentityMatrix(), size, _BOX_PRIMITIVE, materialID);
NewtonMesh* const skinMesh = NewtonMeshCreateFromCollision(primitiveShape);
dMatrix aligmentUV(dGetIdentityMatrix());
int material = LoadTexture("smilli.tga");
NewtonMeshApplySphericalMapping(skinMesh, material, &aligmentUV[0][0]);
// now now make an tetrahedra iso surface approximation of this mesh
NewtonMesh* const tetraIsoSurface = NewtonMeshCreateTetrahedraIsoSurface(skinMesh);
// calculate the linear blend weight for the tetrahedra mesh
NewtonCreateTetrahedraLinearBlendSkinWeightsChannel (tetraIsoSurface, skinMesh);
NewtonDestroyCollision(primitiveShape);
// make a deformable collision mesh
NewtonCollision* const deformableCollision = NewtonCreateDeformableSolid(world, tetraIsoSurface, materialID);
//create a rigid body with a deformable mesh
m_body = CreateRigidBody(scene, mass, deformableCollision);
// create the soft body mesh
//DemoMesh* const mesh = new TetrahedraSoftMesh(tetraIsoSurface, m_body);
DemoMesh* const mesh = new LinearBlendMeshTetra(scene, skinMesh, m_body);
SetMesh(mesh, dGetIdentityMatrix());
// do not forget to destroy this objects, else you get bad memory leaks.
mesh->Release ();
NewtonMeshDestroy(skinMesh);
NewtonDestroyCollision(deformableCollision);
NewtonMeshDestroy(tetraIsoSurface);
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
Entity* smilly;
Entity* frowny;
NewtonBody* floorBody;
NewtonBody* smillyBody;
NewtonBody* frownyBody;
NewtonCollision* shape;
// Create the material for this scene
CreateMateials (world, sceneManager);
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
// add scene collision from a level mesh
shape = CreateHeightFieldCollision (world, "h2.raw", 0);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonReleaseCollision (world, shape);
// make a visual mesh for the collision data
CreateHeightFieldMesh (shape, floor);
// set the matrix at the origin
dVector boxP0;
dVector boxP1;
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// place the origin of the visual mesh at the center of the height field
matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f);
matrix.m_posit.m_w = 1.0f;
floor->m_curPosition = matrix.m_posit;
floor->m_prevPosition = matrix.m_posit;
// relocate the body;
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// now we will use the properties of this body to set a proper world size.
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// add some extra padding
boxP0.m_x -= 50.0f;
boxP0.m_y -= 500.0f;
boxP0.m_z -= 50.0f;
boxP1.m_x += 50.0f;
boxP1.m_y += 500.0f;
boxP1.m_z += 50.0f;
// set the new world size
NewtonSetWorldSize (world, &boxP0[0], &boxP1[0]);
// assign an Material ID to this body
NewtonBodySetMaterialGroupID (floorBody, g_floorMaterial);
// add some visual entities.
dFloat y0 = FindFloor (world, 0.0f, 0.0f) + 10.0f;
for (int i = 0; i < 5; i ++) {
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = y0;
y0 += 2.0f;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, 0);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonReleaseCollision (world, shape);
// assign an Material ID to this body
NewtonBodySetMaterialGroupID (smillyBody, g_metalMaterial);
}
// add some visual entities.
y0 = FindFloor (world, 0.0f, 0.4f) + 10.5f;
for (int i = 0; i < 5; i ++) {
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = y0;
y0 += 2.0f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonReleaseCollision (world, shape);
// assign an Material ID to this body
NewtonBodySetMaterialGroupID (frownyBody, g_woodMaterial);
}
// set the Camera EyePoint close to the scene action
InitCamera (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f));
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
Entity* smilly;
Entity* frowny;
NewtonBody* floorBody;
NewtonBody* smillyBody;
NewtonBody* frownyBody;
NewtonCollision* shape;
////////////////////////////////////////////////////////////////////////////////
// STATIC BODY 1 - FLOOR
////////////////////////////////////////////////////////////////////////////////
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
floor->LoadMesh ("FloorBox.dat");
// add static floor Physics
shape = CreateNewtonBox (world, floor, 0);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonReleaseCollision (world, shape);
// set the Transformation Matrix for this rigid body
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// now we will use the properties of this body to set a proper world size.
dVector minBox;
dVector maxBox;
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &minBox[0], &maxBox[0]);
// add some extra padding
minBox.m_x -= 50.0f;
minBox.m_y -= 500.0f;
minBox.m_z -= 50.0f;
maxBox.m_x += 50.0f;
maxBox.m_y += 500.0f;
maxBox.m_z += 50.0f;
// set the new world size
NewtonSetWorldSize (world, &minBox[0], &maxBox[0]);
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// DYNAMIC BODY 1
////////////////////////////////////////////////////////////////////////////////
// add some visual entities.
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = 10.0f;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, 0);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonReleaseCollision (world, shape);
////////////////////////////////////////////////////////////////////////////////
// DYNAMIC BODY 2
////////////////////////////////////////////////////////////////////////////////
// add some visual entities.
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = 10.0f + 0.4f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonReleaseCollision (world, shape);
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
NewtonBody* floorBody;
NewtonCollision* shape;
/*
void* materialManager;
SoundManager* sndManager;
PhysicsMaterialInteration matInterations;
sndManager = sceneManager->GetSoundManager();
// Create the material for this scene, and attach it to the Newton World
materialManager = CreateMaterialManager (world, sndManager);
// add the Material table
matInterations.m_restitution = 0.6f;
matInterations.m_staticFriction = 0.6f;
matInterations.m_kineticFriction = 0.3f;
matInterations.m_scrapingSound = NULL;
matInterations.m_impactSound = sndManager->LoadSound ("metalMetal.wav");
AddMaterilInteraction (materialManager, m_metal, m_metal, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxBox.wav");
AddMaterilInteraction (materialManager, m_wood, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metalBox.wav");
AddMaterilInteraction (materialManager, m_metal, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass0.wav");
AddMaterilInteraction (materialManager, m_wood, m_grass, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxHit.wav");
AddMaterilInteraction (materialManager, m_wood, m_bricks, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass1.wav");
AddMaterilInteraction (materialManager, m_metal, m_grass, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metal.wav");
AddMaterilInteraction (materialManager, m_metal, m_bricks, &matInterations);
*/
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
int materialMap[] = {m_bricks, m_grass, m_wood, m_metal};
#ifdef USE_HEIGHT_FIELD_LEVEL
// add scene collision from a level m*esh
shape = CreateHeightFieldCollision (world, "h2.raw", materialMap);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// make a visual mesh for the collision data
CreateHeightFieldMesh (shape, floor);
// set the matrix at the origin
dVector boxP0;
dVector boxP1;
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// place the origin of the visual mesh at the center of the height field
matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f);
matrix.m_posit.m_w = 1.0f;
floor->m_curPosition = matrix.m_posit;
floor->m_prevPosition = matrix.m_posit;
// relocate the body;
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
#else
floor->LoadMesh ("LevelMesh.dat");
// add static floor Physics
shape = CreateMeshCollision (world, floor, materialMap);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// set the Transformation Matrix for this rigid body
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
#endif
// now we will use the properties of this body to set a proper world size.
dVector minBox;
dVector maxBox;
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &minBox[0], &maxBox[0]);
// add some extra padding
minBox.m_x -= 50.0f;
minBox.m_y -= 500.0f;
minBox.m_z -= 50.0f;
maxBox.m_x += 50.0f;
maxBox.m_y += 500.0f;
maxBox.m_z += 50.0f;
// set the new world size
NewtonSetWorldSize (world, &minBox[0], &maxBox[0]);
// Create a Body and attach a player controller joint
{
dFloat y0;
Entity* player;
NewtonBody* playerBody;
NewtonCollision* shape;
// find the a floor to place the player
y0 = FindFloor (world, 0.0f, 0.0f) + 1.0f;
// load the player mesh
player = sceneManager->CreateEntity();
player->LoadMesh ("gymnast.dat");
player->m_curPosition.m_y = y0;
player->m_prevPosition = player->m_curPosition;
// get the bounding Box of the player to get the collision shape dimensions
dVector minBox;
dVector maxBox;
player->GetBBox (minBox, maxBox);
// calculate player high and width
dFloat padding = 1.0f / 64.0f; // this si the default padding, for teh palye joint, we must subtract it from the shape
dFloat playerHigh = (maxBox.m_y - minBox.m_y) - padding;
dFloat playerRadius0 = (maxBox.m_z - minBox.m_z) * 0.5f;
dFloat playerRadius1 = (maxBox.m_x - minBox.m_x) * 0.5f;
dFloat playerRadius = (playerRadius0 > playerRadius1 ? playerRadius0 : playerRadius1) - padding;
// No we make and make a upright capsule for the collision mesh
dMatrix orientation;
orientation.m_front = dVector (0.0f, 1.0f, 0.0f, 0.0f); // this is the player up direction
orientation.m_up = dVector (1.0f, 0.0f, 0.0f, 0.0f); // this is the player front direction
orientation.m_right = orientation.m_front * orientation.m_up; // this is the player sideway direction
orientation.m_posit = dVector (0.0f, 0.0f, 0.0f, 1.0f);
// add a body with a box shape
//shape = CreateNewtonCapsule (world, player, playerHigh, playerRadius, m_wood, orientation);
shape = CreateNewtonCylinder (world, player, playerHigh, playerRadius, m_wood, orientation);
playerBody = CreateRigidBody (world, player, shape, 10.0f);
NewtonDestroyCollision(shape);
// make sure the player does not go to sleep
NewtonBodySetAutoSleep (playerBody, 0);
// now we will attach a player controller to the body
NewtonUserJoint* playerController;
// the player can take step up to 0.7 units;
dFloat maxStairStepFactor = 0.7f / playerHigh;
playerController = CreateCustomPlayerController (&orientation[0][0], playerBody, maxStairStepFactor, padding);
// set the Max Slope the player can climb to PLAYER_MAX_SLOPE degree
CustomPlayerControllerSetMaxSlope (playerController, PLAYER_MAX_SLOPE * 3.1416f / 180.0f);
// now we will append some application data for the application to control the player
PlayerController* userControl = (PlayerController*) malloc (sizeof (PlayerController));
userControl->m_isThirdView = 1;
userControl->m_point = dVector (0.0f, playerHigh, 0.0f,0.0f);
// set the user data for the application to control the player
CustomSetUserData (playerController, userControl);
// set the destruction call back so that the application can destroy local used data
CustomSetDestructorCallback (playerController, PlayerController::Destroy);
// set a call back to control the player
CustomSetSubmitContraintCallback (playerController, PlayerController::ApplyPlayerInput);
// we also need to set override the transform call back so the we can set the Camera
userControl->m_setTransformOriginal = NewtonBodyGetTransformCallback(playerBody);
NewtonBodySetTransformCallback (playerBody, PlayerController::SetTransform);
// we will need some ID to fin this joint in the transform Callback
CustomSetJointID (playerController, PLAYER_JOINT_ID);
}
/*
{
// add some visual entities.
dFloat y0;
y0 = FindFloor (world, 0.0f, 0.4f) + 10.5f;
for (int i = 0; i < 5; i ++) {
Entity* frowny;
NewtonBody* frownyBody;
NewtonCollision* shape;
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = y0;
y0 += 2.0f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, m_wood);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
}
}
*/
// set the Camera EyePoint close to the scene action
SetCameraEyePoint (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f));
}
CStdSerialize *RbClassFactory::CreateObject(std::string strClassType, std::string strObjectType, bool bThrowError)
{
CStdSerialize *lpObject=NULL;
strClassType = Std_ToUpper(Std_Trim(strClassType));
if(strClassType == "RIGIDBODY")
lpObject = CreateRigidBody(strObjectType, bThrowError);
else if(strClassType == "JOINT")
lpObject = CreateJoint(strObjectType, bThrowError);
else if(strClassType == "ORGANISM")
lpObject = CreateStructure(strObjectType, bThrowError);
else if(strClassType == "STRUCTURE")
lpObject = CreateStructure(strObjectType, bThrowError);
else if(strClassType == "SIMULATOR")
lpObject = CreateSimulator(strObjectType, bThrowError);
else if(strClassType == "KEYFRAME")
lpObject = CreateKeyFrame(strObjectType, bThrowError);
else if(strClassType == "DATACHART")
lpObject = CreateDataChart(strObjectType, bThrowError);
else if(strClassType == "DATACOLUMN")
lpObject = CreateDataColumn(strObjectType, bThrowError);
else if(strClassType == "EXTERNALSTIMULUS")
lpObject = CreateExternalStimulus(strObjectType, bThrowError);
else if(strClassType == "ADAPTER")
lpObject = CreateAdapter(strObjectType, bThrowError);
else if(strClassType == "GAIN")
lpObject = CreateGain(strObjectType, bThrowError);
else if(strClassType == "HUDITEM")
lpObject = CreateHudItem(strObjectType, bThrowError);
else if(strClassType == "HUD")
lpObject = CreateHud(strObjectType, bThrowError);
else if(strClassType == "MATERIAL")
lpObject = CreateMaterialItem(strObjectType, bThrowError);
else if(strClassType == "SIMULATIONWINDOW")
lpObject = CreateWindowItem(strObjectType, bThrowError);
else if(strClassType == "LIGHT")
lpObject = CreateLight(strObjectType, bThrowError);
else if(strClassType == "NEURALMODULE")
lpObject = CreateNeuralModule(strObjectType, bThrowError);
else if(strClassType == "CONSTRAINTRELAXATION")
lpObject = CreateConstraintRelaxation(strObjectType, bThrowError);
else if(strClassType == "CONSTRAINTFRICTION")
lpObject = CreateConstraintFriction(strObjectType, bThrowError);
else if(strClassType == "ROBOTINTERFACE")
lpObject = CreateRobotInterface(strObjectType, bThrowError);
else if(strClassType == "ROBOTIOCONTROL")
lpObject = CreateRobotIOControl(strObjectType, bThrowError);
else if(strClassType == "ROBOTPARTINTERFACE")
lpObject = CreateRobotPartInterface(strObjectType, bThrowError);
else if(strClassType == "REMOTECONTROLLINKAGE")
lpObject = CreateRemoteControlLinkage(strObjectType, bThrowError);
else
{
lpObject = NULL;
if(bThrowError)
THROW_PARAM_ERROR(Std_Err_lInvalidClassType, Std_Err_strInvalidClassType, "ClassType", strClassType);
}
return lpObject;
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
Entity* smilly;
Entity* frowny;
NewtonBody* floorBody;
NewtonBody* smillyBody;
NewtonBody* frownyBody;
NewtonCollision* shape;
// initialize the camera
InitCamera (dVector (-15.0f, 5.0f, 0.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f));
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
floor->LoadMesh ("FloorBox.dat");
// add static floor Physics
shape = CreateNewtonBox (world, floor, 0);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// set the Transformation Matrix for this rigid body
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// add some visual entities.
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = 10.0f;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, 0);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonDestroyCollision(shape);
// add some visual entities.
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = 10.0f + 0.4f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
// we will Link the Frowny Body to the world with Hinge regenerated from a Generic 6DOF joint.
matrix = GetIdentityMatrix();
matrix.m_posit = frowny->m_curPosition;
matrix.m_posit.m_z += 0.2f;
matrix.m_posit.m_y += 0.4f;
// specify the limits for defining a Hinge around the x axis
dVector minLinearLimits (0.0f, 0.0f, 0.0f, 0.0f);
dVector maxLinearLimits (0.0f, 0.0f, 0.0f, 0.0f);
dVector minAngulaLimits (-0.5f * 3.1416f, 0.0f, 0.0f, 0.0f);
dVector maxAngulaLimits ( 0.5f * 3.1416f, 0.0f, 0.0f, 0.0f);
NewtonUserJoint* frownyHinge;
// Create a 6DOF joint
frownyHinge = CreateCustomJoint6DOF (&matrix[0][0], &matrix[0][0], frownyBody, NULL);
// set the hinge Limits
CustomJoint6DOF_SetLinearLimits (frownyHinge, &minLinearLimits[0], &maxLinearLimits[0]);
CustomJoint6DOF_SetAngularLimits (frownyHinge, &minAngulaLimits[0], &maxAngulaLimits[0]);
// now we will link the body of Smilly and Frowny with a specialize Hinge Joint
NewtonUserJoint* smillyFrownyHinge;
matrix.m_posit = smilly->m_curPosition;
matrix.m_posit.m_z += 0.2f;
matrix.m_posit.m_y += 0.4f;
smillyFrownyHinge = CreateCustomHinge (&matrix[0][0], smillyBody, frownyBody);
HingeEnableLimits (smillyFrownyHinge, 1);
HingeSetLimits (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
// smillyFrownyHinge = CreateCustomBallAndSocket (&matrix[0][0], smillyBody, frownyBody);
// BallAndSocketSetConeAngle (smillyFrownyHinge, 0.5f * 3.1416f);
// BallAndSocketSetTwistAngle (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
// smillyFrownyHinge = CreateCustomSlider (&matrix[0][0], smillyBody, frownyBody);
// SliderEnableLimits (smillyFrownyHinge, 1);
// SliderSetLimis (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
{
// adding two Kinematic controlled object
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 4.0f;
frowny->m_curPosition.m_y = 7.0f;
frowny->m_prevPosition = frowny->m_curPosition;
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
FollowPath* path;
NewtonUserJoint* g_pathFollow;
path = (FollowPath*) malloc (sizeof (FollowPath));
NewtonBodyGetMatrix (frownyBody, &matrix[0][0]);
path->m_origin = matrix.m_posit;
path->m_angle = 0.0f;
path->radius = 3.0f;
g_pathFollow = CreateCustomKinematicController (frownyBody, &matrix.m_posit[0]);
CustomKinematicControllerSetPickMode (g_pathFollow, 1);
CustomKinematicControllerSetMaxAngularFriction (g_pathFollow, 200.0f);
CustomKinematicControllerSetMaxLinearFriction (g_pathFollow, 1000.0f);
CustomSetUserData(g_pathFollow, path);
CustomSetDestructorCallback(g_pathFollow, FollowPath::Destroy);
CustomSetSubmitContraintCallback (g_pathFollow, FollowPath::EvaluatePath);
matrix = path->BuildMatrix (0.0f);
NewtonBodySetMatrix(frownyBody, &matrix[0][0]);
}
{
// adding two Kinematic controlled object
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = -4.0f;
frowny->m_curPosition.m_y = 6.0f;
frowny->m_prevPosition = frowny->m_curPosition;
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
FollowPath* path;
NewtonUserJoint* g_pathFollow;
path = (FollowPath*) malloc (sizeof (FollowPath));
NewtonBodyGetMatrix (frownyBody, &matrix[0][0]);
path->m_origin = matrix.m_posit;
path->m_angle = 3.1416f;
path->radius = 3.0f;
g_pathFollow = CreateCustomKinematicController (frownyBody, &matrix.m_posit[0]);
CustomKinematicControllerSetPickMode (g_pathFollow, 1);
CustomKinematicControllerSetMaxAngularFriction (g_pathFollow, 200.0f);
CustomKinematicControllerSetMaxLinearFriction (g_pathFollow, 1000.0f);
CustomSetUserData(g_pathFollow, path);
CustomSetDestructorCallback(g_pathFollow, FollowPath::Destroy);
CustomSetSubmitContraintCallback (g_pathFollow, FollowPath::EvaluatePath);
matrix = path->BuildMatrix (0.0f);
NewtonBodySetMatrix(frownyBody, &matrix[0][0]);
}
}
World::World():
dynamicsWorld(0),
collisionShapes(),
overlappingPairCache(0),
dispatcher(0),
constraintSolver(0),
collisionConfiguration(0),
indexVertexArrays(0),
vertices(0),
clock(),
groundTexture(0),
screenAspect(1.f),
cameraHeight(4.f),
minCameraDistance(3.f),
maxCameraDistance(10.f),
cameraPosition(-100.f, 30.f, 100.f),
cameraType(CT_3RD),
idle(false)
{
shapeDrawer = new GL_ShapeDrawer();
shapeDrawer->enableTexture(true);
btCollisionShape* groundShape = new btBoxShape(btVector3(50,3,50));
collisionShapes.push_back(groundShape);
collisionConfiguration = new btDefaultCollisionConfiguration();
dispatcher = new btCollisionDispatcher(collisionConfiguration);
btVector3 worldMin(-1000,-1000,-1000);
btVector3 worldMax(1000,1000,1000);
overlappingPairCache = new btAxisSweep3(worldMin,worldMax);
constraintSolver = new btSequentialImpulseConstraintSolver();
dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, overlappingPairCache, constraintSolver, collisionConfiguration);
dynamicsWorld->setGravity(btVector3(0,-10,0));
btTransform tr;
tr.setIdentity();
//triangle mesh
int i;
const float TRIANGLE_SIZE=20.f;
//create a triangle-mesh ground
int vertStride = sizeof(btVector3);
int indexStride = 3*sizeof(int);
const int NUVERTS_X = 21;
const int NUVERTS_Y = 21;
const int totalVerts = NUVERTS_X*NUVERTS_Y;
const int totalTriangles = 2*(NUVERTS_X-1)*(NUVERTS_Y-1);
vertices = new btVector3[totalVerts];
int* gIndices = new int[totalTriangles*3];
//build terrain mesh
for ( i=0;i<NUVERTS_X;i++)
{
for (int j=0;j<NUVERTS_Y;j++)
{
float wl = .2f;
//height set to zero, but can also use curved landscape, just uncomment out the code
float height = 20.f*sinf(float(i)*wl)*cosf(float(j)*wl);
vertices[i+j*NUVERTS_X].setValue(
(i-NUVERTS_X*0.5f)*TRIANGLE_SIZE,
height,
(j-NUVERTS_Y*0.5f)*TRIANGLE_SIZE);
}
}
int index=0;
for ( i=0;i<NUVERTS_X-1;i++)
{
for (int j=0;j<NUVERTS_Y-1;j++)
{
gIndices[index++] = j*NUVERTS_X+i;
gIndices[index++] = j*NUVERTS_X+i+1;
gIndices[index++] = (j+1)*NUVERTS_X+i+1;
gIndices[index++] = j*NUVERTS_X+i;
gIndices[index++] = (j+1)*NUVERTS_X+i+1;
gIndices[index++] = (j+1)*NUVERTS_X+i;
}
}
indexVertexArrays = new btTriangleIndexVertexArray(totalTriangles,
gIndices,
indexStride,
totalVerts,(btScalar*) &vertices[0].x(),vertStride);
bool useQuantizedAabbCompression = true;
groundShape = new btBvhTriangleMeshShape(indexVertexArrays,useQuantizedAabbCompression);
tr.setOrigin(btVector3(0,-4.5f,0));
collisionShapes.push_back(groundShape);
//create ground object
groundRigidBody = CreateRigidBody(0,tr,groundShape);
dynamicsWorld->addRigidBody(groundRigidBody);
float wallLength = (NUVERTS_X-1)*TRIANGLE_SIZE;
float wallHeight = 40.f;
float wallWidth = 5.f;
btCollisionShape* wall = new btBoxShape(btVector3(wallLength/2, wallHeight/2, wallWidth/2));
collisionShapes.push_back(wall);
tr.setOrigin(btVector3(-TRIANGLE_SIZE/2.f, 0.f, wallLength/2-wallWidth/2-TRIANGLE_SIZE/2));
dynamicsWorld->addRigidBody(CreateRigidBody(0.f, tr, wall));
wall = new btBoxShape(btVector3(wallLength/2, wallHeight/2, wallWidth/2));
collisionShapes.push_back(wall);
tr.setOrigin(btVector3(-TRIANGLE_SIZE/2.f, 0.f, -wallLength/2-wallWidth/2-TRIANGLE_SIZE/2));
dynamicsWorld->addRigidBody(CreateRigidBody(0.f, tr, wall));
wall = new btBoxShape(btVector3(wallWidth/2, wallHeight/2, wallLength/2));
collisionShapes.push_back(wall);
tr.setOrigin(btVector3(wallLength/2-wallWidth/2-TRIANGLE_SIZE/2, 0.f, -TRIANGLE_SIZE/2.f));
dynamicsWorld->addRigidBody(CreateRigidBody(0.f, tr, wall));
wall = new btBoxShape(btVector3(wallWidth/2, wallHeight/2, wallLength/2));
collisionShapes.push_back(wall);
tr.setOrigin(btVector3(-wallLength/2-wallWidth/2-TRIANGLE_SIZE/2, 0.f, -TRIANGLE_SIZE/2.f));
dynamicsWorld->addRigidBody(CreateRigidBody(0.f, tr, wall));
//create vehicle
vehicle = new Vehicle(dynamicsWorld);
cameraDistance = 26.f;
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
NewtonCollision* shape;
NewtonBody* floorBody;
void* materialManager;
SoundManager* sndManager;
PhysicsMaterialInteration matInterations;
sndManager = sceneManager->GetSoundManager();
// Create the material for this scene, and attach it to the Newton World
materialManager = CreateMaterialManager (world, sndManager);
// add the Material table
matInterations.m_restitution = 0.6f;
matInterations.m_staticFriction = 0.6f;
matInterations.m_kineticFriction = 0.3f;
matInterations.m_scrapingSound = NULL;
matInterations.m_impactSound = sndManager->LoadSound ("metalMetal.wav");
AddMaterilInteraction (materialManager, m_metal, m_metal, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxBox.wav");
AddMaterilInteraction (materialManager, m_wood, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metalBox.wav");
AddMaterilInteraction (materialManager, m_metal, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass0.wav");
AddMaterilInteraction (materialManager, m_wood, m_grass, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxHit.wav");
AddMaterilInteraction (materialManager, m_wood, m_bricks, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass1.wav");
AddMaterilInteraction (materialManager, m_metal, m_grass, &matInterations);
AddMaterilInteraction (materialManager, m_grass, m_bricks, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metal.wav");
AddMaterilInteraction (materialManager, m_metal, m_bricks, &matInterations);
AddMaterilInteraction (materialManager, m_grass, m_grass, &matInterations);
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
floor->LoadMesh ("LevelMesh.dat");
// add static floor Physics
int materialMap[] = {m_bricks, m_grass, m_wood, m_metal};
shape = CreateMeshCollision (world, floor, materialMap);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonReleaseCollision (world, shape);
// set the Transformation Matrix for this rigid body
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// now we will use the properties of this body to set a proper world size.
dVector minBox;
dVector maxBox;
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &minBox[0], &maxBox[0]);
// add some extra padding
minBox.m_x -= 50.0f;
minBox.m_y -= 500.0f;
minBox.m_z -= 50.0f;
maxBox.m_x += 50.0f;
maxBox.m_y += 500.0f;
maxBox.m_z += 50.0f;
// set the new world size
NewtonSetWorldSize (world, &minBox[0], &maxBox[0]);
// add some visual entities.
dFloat y0 = FindFloor (world, 0.0f, 0.0f) + 10.0f;
for (int i = 0; i < 5; i ++) {
Entity* smilly;
NewtonBody* smillyBody;
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = y0;
y0 += 2.0f;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, m_metal);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonReleaseCollision (world, shape);
}
// add some visual entities.
y0 = FindFloor (world, 0.0f, 0.4f) + 10.5f;
for (int i = 0; i < 5; i ++) {
Entity* frowny;
NewtonBody* frownyBody;
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = y0;
y0 += 2.0f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, m_wood);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonReleaseCollision (world, shape);
}
y0 = FindFloor (world, 0.0f, 2.0f) + 10.5f;
for (int i = 0; i < 5; i ++) {
Entity* frowny;
NewtonBody* frownyBody;
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("dumb.dat");
frowny->m_curPosition.m_z = 2.0f;
frowny->m_curPosition.m_y = y0;
y0 += 2.0f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
int materialMap[] = {m_grass, m_wood, m_metal, m_metal};
shape = CreateNewtonCompoundFromEntitySubmesh (world, frowny, materialMap);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonReleaseCollision (world, shape);
}
// set the Camera EyePoint close to the scene action
InitCamera (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f));
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
NewtonBody* floorBody;
NewtonCollision* shape;
void* materialManager;
SoundManager* sndManager;
PhysicsMaterialInteration matInterations;
sndManager = sceneManager->GetSoundManager();
// Create the material for this scene, and attach it to the Newton World
materialManager = CreateMaterialManager (world, sndManager);
// add the Material table
matInterations.m_restitution = 0.6f;
matInterations.m_staticFriction = 0.6f;
matInterations.m_kineticFriction = 0.3f;
matInterations.m_scrapingSound = NULL;
matInterations.m_impactSound = sndManager->LoadSound ("metalMetal.wav");
AddMaterilInteraction (materialManager, m_metal, m_metal, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxBox.wav");
AddMaterilInteraction (materialManager, m_wood, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metalBox.wav");
AddMaterilInteraction (materialManager, m_metal, m_wood, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass0.wav");
AddMaterilInteraction (materialManager, m_wood, m_grass, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("boxHit.wav");
AddMaterilInteraction (materialManager, m_wood, m_bricks, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("grass1.wav");
AddMaterilInteraction (materialManager, m_metal, m_grass, &matInterations);
matInterations.m_impactSound = sndManager->LoadSound ("metal.wav");
AddMaterilInteraction (materialManager, m_metal, m_bricks, &matInterations);
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
// add scene collision from a level mesh
int materialMap[] = {m_bricks, m_grass, m_wood, m_metal};
shape = CreateHeightFieldCollision (world, "h2.raw", materialMap);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// make a visual mesh for the collision data
CreateHeightFieldMesh (shape, floor);
// set the matrix at the origin
dVector boxP0;
dVector boxP1;
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// place the origin of the visual mesh at the center of the height field
matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f);
matrix.m_posit.m_w = 1.0f;
floor->m_curPosition = matrix.m_posit;
floor->m_prevPosition = matrix.m_posit;
// relocate the body;
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
// now we will use the properties of this body to set a proper world size.
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// add some extra padding
boxP0.m_x -= 50.0f;
boxP0.m_y -= 500.0f;
boxP0.m_z -= 50.0f;
boxP1.m_x += 50.0f;
boxP1.m_y += 500.0f;
boxP1.m_z += 50.0f;
// set the new world size
NewtonSetWorldSize (world, &boxP0[0], &boxP1[0]);
// add some visual entities.
dFloat y0 = FindFloor (world, 0.0f, 0.0f) + 2.0f;
for (int i = 0; i < 1; i ++) {
Entity* carEnt;
NewtonBody* carBody;
NewtonUserJoint* carController;
carEnt = sceneManager->CreateEntity();
carEnt->LoadMesh ("porche.dat");
carEnt->m_curPosition.m_y = y0;
y0 += 2.0f;
carEnt->m_prevPosition = carEnt->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, carEnt, m_metal);
// the mass is the Car weight divide by the Gravity
carBody = CreateRigidBody (world, carEnt, shape, CAR_WEIGHT / 10.0f);
NewtonDestroyCollision(shape);
// Now create a RayCast Car for to control this body
carController = CreateRayCastCast (carBody, sceneManager, porcheTirePositions);
}
y0 = FindFloor (world, 4.0f, 0.0f) + 2.0f;
for (int i = 0; i < 1; i ++) {
Entity* carEnt;
NewtonBody* carBody;
NewtonUserJoint* carController;
carEnt = sceneManager->CreateEntity();
carEnt->LoadMesh ("cadillac.dat");
carEnt->m_curPosition.m_z = 4.0f;
carEnt->m_curPosition.m_y = y0;
y0 += 2.0f;
carEnt->m_prevPosition = carEnt->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, carEnt, m_metal);
// the mass is the Car weight divide by the Gravity
carBody = CreateRigidBody (world, carEnt, shape, CAR_WEIGHT / 10.0f);
NewtonDestroyCollision(shape);
// Now create a RayCast Car for to control this body
carController = CreateRayCastCast (carBody, sceneManager, cadillackirePositions);
}
// initialize the camera
InitCamera (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f));
}
void CcdChapter::CreateBullet()
{
m_pkCollisionConfiguration = new btDefaultCollisionConfiguration();
m_pkDispatcher = new btCollisionDispatcher(m_pkCollisionConfiguration);
m_pkBroadphase = new btDbvtBroadphase();
m_pkSolver = new btSequentialImpulseConstraintSolver();
m_pkDynamicsWorld = new btDiscreteDynamicsWorld(m_pkDispatcher, m_pkBroadphase, m_pkSolver, m_pkCollisionConfiguration);
m_pkDynamicsWorld->getSolverInfo().m_solverMode |= SOLVER_RANDMIZE_ORDER;
m_pkDynamicsWorld->getDispatchInfo().m_enableSPU = true;
m_pkDynamicsWorld->setGravity(btVector3(0, -10, 0));
gContactAddedCallback = contactAddedCallback;
// DebugDraw
m_pkDebugDraw = new BulletDebugDraw();
m_pkDebugDraw->setVisible(false);
m_pkDynamicsWorld->setDebugDrawer(m_pkDebugDraw);
m_pkDebugDraw->setDebugMode(BulletDebugDraw::DBG_DrawText | BulletDebugDraw::DBG_DrawContactPoints);
m_pkDebugNode = m_pkRootNode->createChildSceneNode();
m_pkDebugNode->attachObject(m_pkDebugDraw);
int i;
btTransform tr;
tr.setIdentity();
for(i=0; i<120; ++i)
{
if(i>0)
{
m_nShapeIndex[i] = 1;
}
else
m_nShapeIndex[i] = 0;
}
for(i=0; i<32760; ++i)
{
btCollisionShape *shape = m_CollisionShapes[m_nShapeIndex[i]];
shape->setMargin(0.05f);
bool isDyna = 1>0;
btTransform trans;
trans.setIdentity();
if(i>0)
{
int colsize = 10;
int row = (i*0.5f*2)/(colsize*2*0.5f);
int row2 = row;
int col = (i)%(colsize)-colsize/2;
if(col>3)
{
col = 11;
row2 |= 1;
}
btVector3 pos(col*2*0.5f + (row2%2)*0.5f, row*2*0.5f+0.5f+ -10.f, 0);
trans.setOrigin(pos);
}
else
{
trans.setOrigin(btVector3(0, -10.0f-0.5f, 0));
}
float mass = 1.0f;
if( !isDyna )
mass = 0.0f;
btRigidBody *body = CreateRigidBody(shape, isDyna, trans, mass);
body->setCcdMotionThreshold( 0.5f );
body->setCcdSweptSphereRadius( 0.2f * 0.5f );
}
}
The second part uses the bounding Box of the collision mesh to set the final size of the physics world. This is also an important step because in the Newton world the size of the world is finite. The consequence of not doing this is that when a body move to a position the is outside the default world size the physics silently stop working on that body.
The final line of function CreateScene, just repeat the same process of adding more physics bodies to the scene
*/
// add some visual entities.
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = 10.0f;
smilly->m_prevPosition = smilly->m_curPosition;
// add a body with a box shape
shape = CreateNewtonBox (world, smilly, 0);
smillyBody = CreateRigidBody (world, smilly, shape, 10.0f);
NewtonReleaseCollision (world, shape);
// add some visual entities.
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = 10.0f + 0.4f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonReleaseCollision (world, shape);
/*
void BuildClothPatch (DemoEntityManager* const scene, int size_x, int size_z)
{
NewtonWorld* const world = scene->GetNewton();
NewtonMesh* const clothPatch = CreateQuadClothPatch(scene, size_x, size_z);
// create the array of points;
int vertexCount = NewtonMeshGetVertexCount(clothPatch);
int stride = NewtonMeshGetVertexStrideInByte (clothPatch) / sizeof (dFloat64);
const dFloat64* const meshPoints = NewtonMeshGetVertexArray (clothPatch);
dVector* const points = new dVector[vertexCount];
for (int i =0; i < vertexCount; i ++ ) {
points[i].m_x = dFloat (meshPoints[i * stride + 0]);
points[i].m_y = dFloat (meshPoints[i * stride + 1]);
points[i].m_z = dFloat (meshPoints[i * stride + 2]);
points[i].m_w = 0.0f;
}
dFloat mass = 8.0f;
// set the particle masses
dFloat unitMass = mass / vertexCount;
dFloat* const clothMass = new dFloat[vertexCount];
for (int i =0; i < vertexCount; i ++ ) {
clothMass[i] = unitMass;
}
int linksCount = 0;
const int maxLinkCount = size_x * size_z * 16;
// create the structual constation array;
dFloat structuralSpring = dAbs(mass * DEMO_GRAVITY) / 0.01f;
dFloat structuralDamper = 30.0f;
int* const links = new int[2 * maxLinkCount];
dFloat* const spring = new dFloat[maxLinkCount];
dFloat* const damper = new dFloat[maxLinkCount];
for (void* edgeNode = NewtonMeshGetFirstEdge (clothPatch); edgeNode; edgeNode = NewtonMeshGetNextEdge (clothPatch, edgeNode)) {
int v0;
int v1;
NewtonMeshGetEdgeIndices (clothPatch, edgeNode, &v0, &v1);
links[linksCount * 2 + 0] = v0;
links[linksCount * 2 + 1] = v1;
spring[linksCount] = structuralSpring;
damper[linksCount] = structuralDamper;
linksCount ++;
dAssert (linksCount <= maxLinkCount);
}
// add shear constraints
dFloat shearSpring = structuralSpring;
dFloat shearDamper = structuralDamper;
for (void* faceNode = NewtonMeshGetFirstFace (clothPatch); faceNode; faceNode = NewtonMeshGetNextFace (clothPatch, faceNode)) {
if (!NewtonMeshIsFaceOpen(clothPatch, faceNode)) {
int face[8];
int indexCount = NewtonMeshGetFaceIndexCount (clothPatch, faceNode);
NewtonMeshGetFaceIndices (clothPatch, faceNode, face);
for (int i = 2; i < indexCount - 1; i ++) {
links[linksCount * 2 + 0] = face[0];
links[linksCount * 2 + 1] = face[i];
spring[linksCount] = shearSpring;
damper[linksCount] = shearDamper;
linksCount ++;
dAssert (linksCount <= maxLinkCount);
}
for (int i = 3; i < indexCount; i ++) {
links[linksCount * 2 + 0] = face[1];
links[linksCount * 2 + 1] = face[i];
spring[linksCount] = shearSpring;
damper[linksCount] = shearDamper;
linksCount ++;
dAssert (linksCount <= maxLinkCount);
}
}
}
//linksCount = 0;
NewtonCollision* const deformableCollision = NewtonCreateMassSpringDamperSystem(world, 0,
&points[0].m_x, vertexCount, sizeof (dVector), clothMass,
links, linksCount, spring, damper);
m_body = CreateRigidBody(scene, mass, deformableCollision);
DemoMesh* const mesh = new ClothPatchMesh (scene, clothPatch, m_body);
SetMesh(mesh, dGetIdentityMatrix());
// do not forget to destroy this objects, else you get bad memory leaks.
mesh->Release();
NewtonDestroyCollision(deformableCollision);
NewtonMeshDestroy(clothPatch);
delete[] links;
delete[] damper;
delete[] spring;
delete[] clothMass;
delete[] points;
}
NewtonBody* CPhysics::CreateSphere( NewtonWorld *world, CObject3D *object, float radius, float mass /*= 0.0f*/ )
{
NewtonCollision *collision = NewtonCreateSphere(world, radius, radius, radius, 0, NULL);
return CreateRigidBody(world, object, collision, mass);
}
