Discrete Collision Detection

Post Reply
jayasimha
Posts: 4
Joined: Fri Dec 30, 2016 6:18 am

Discrete Collision Detection

Post by jayasimha »

Hi

i am added two Entities to collision world, one is static and another one is dynamic object.i am using performDiscreteCollisionDetection() collision detection.

i created a pThread,inside i am continuously calling "_collisionWorld->performDiscreteCollisionDetection();" for Collision Detection.before collision "performDiscreteCollisionDetection()" is not taking more time to perform it's action but if once it is collide the function "performDiscreteCollisionDetection()" is taking mode Time to come out of that function. due to this it is unable to detect collision in next frame.

my question is Why "performDiscreteCollisionDetection()" is taking more time to Come out this Function after Collision detected?

this is my complete code

#include <btBulletCollisionCommon.h>
#include <osgbCollision/CollisionShapes.h>
#include <osgbCollision/Utils.h>

#include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <osgGA/TrackballManipulator>

#include <osg/Matrix>
#include <osg/MatrixTransform>

#include "pthread.h"

using namespace osg;
using namespace std;

float pos1 = 1000, pos2 = -1000, pos3 = 1000;

btCollisionWorld* _collisionWorld;
std::vector<btCollisionObject*> _collisionObj;
std::vector<std::string> _collisionObjNm;

void detectCollision();

pthread_t thread;

void* updateCollisionWorld(void *data)
{
while (1)
{
_collisionWorld->performDiscreteCollisionDetection();
}
}

bool addObjectToCollisionWorld(osg::Node* node, osg::Matrix transMatrix, string name, __int8 objType)
{
if (objType == 0)
{
btCollisionObject* collisionObj = new btCollisionObject();
collisionObj->setCollisionShape(osgbCollision::btTriMeshCollisionShapeFromOSG(node));
collisionObj->setCollisionFlags(btCollisionObject::CF_STATIC_OBJECT);
collisionObj->setWorldTransform(osgbCollision::asBtTransform(transMatrix));
_collisionObj.push_back(collisionObj);
_collisionWorld->addCollisionObject(_collisionObj[_collisionObj.size() - 1]);
_collisionObjNm.push_back(name);

return true;
}
else if (objType == 1)
{
osg::Matrix matrix;
btVector3 min, max;
btCollisionObject* collisionObj = new btCollisionObject();
collisionObj->setCollisionShape(osgbCollision::btConvexHullCollisionShapeFromOSG(node));
collisionObj->setCollisionFlags(btCollisionObject::CF_KINEMATIC_OBJECT);
collisionObj->setWorldTransform(osgbCollision::asBtTransform(transMatrix));
collisionObj->setActivationState(DISABLE_DEACTIVATION); ///never deactivate the collision Object
_collisionObj.push_back(collisionObj);
_collisionWorld->addCollisionObject(_collisionObj[_collisionObj.size() - 1]);
_collisionObjNm.push_back(name);
return true;
}

return false;
}


// init Collision World
btCollisionWorld* initCollision()
{
btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);

btVector3 worldAabbMin(-10000, -10000, -10000);
btVector3 worldAabbMax(10000, 10000, 10000);
btBroadphaseInterface* inter = new btAxisSweep3(worldAabbMin, worldAabbMax, 1000);

btCollisionWorld* collisionWorld = new btCollisionWorld(dispatcher, inter, collisionConfiguration);

return(collisionWorld);
}

void detectCollision()
{
unsigned int numManifolds = _collisionWorld->getDispatcher()->getNumManifolds();
btPersistentManifold** point = _collisionWorld->getDispatcher()->getInternalManifoldPointer();

for (unsigned int i = 0; i < numManifolds; i++)
{
btPersistentManifold* contactManifold = _collisionWorld->getDispatcher()->getManifoldByIndexInternal(i);
unsigned int numContacts = contactManifold->getNumContacts();
btCollisionObject* obA = (btCollisionObject*)(contactManifold->getBody0());
btCollisionObject* obB = (btCollisionObject*)(contactManifold->getBody1());
string name1("null"), name2("null");
if (numContacts)
{
for (int i = 0; i < _collisionObj.size(); i++)
{
if (name1 != "null" && name2 != "null") break;
if (obA == _collisionObj) { name1 = _collisionObjNm; }
if (obB == _collisionObj) { name2 = _collisionObjNm; }

}
std::cout << name1 << "is Collide With" << name2 << std::endl;
for (unsigned int j = 0; j < numContacts; j++)
{
btManifoldPoint& pt = contactManifold->getContactPoint(j);

}
}
}
}

int main()
{
_collisionWorld = initCollision();

ref_ptr<Node> node1 = osgDB::readNodeFile("Aircraft/Airplane EG-JJY N220114.3DS");
ref_ptr<Node> node2 = osgDB::readNodeFile("Aircraft/Airplane EG-JJY N220114.3DS");
ref_ptr<Node> node3 = osgDB::readNodeFile("Aircraft/Airplane EG-JJY N220114.3DS");
ref_ptr<Node> node4 = osgDB::readNodeFile("Aircraft/Airplane EG-JJY N220114.3DS");

ref_ptr<MatrixTransform> mxTrns1 = new MatrixTransform;
mxTrns1->addChild(node1.get());
mxTrns1->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(90.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(1000, 0, 0));
addObjectToCollisionWorld(node1, mxTrns1->getMatrix(), "Right Aircraft", 1);

ref_ptr<MatrixTransform> mxTrns2 = new MatrixTransform;
mxTrns2->addChild(node2.get());
mxTrns2->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(270.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(-1000, 0, 0));
addObjectToCollisionWorld(node2, mxTrns2->getMatrix(), "Left Aircraft", 1);

ref_ptr<MatrixTransform> mxTrns3 = new MatrixTransform;
mxTrns3->addChild(node3.get());
mxTrns3->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(180.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(0, 1000, 0));
addObjectToCollisionWorld(node3, mxTrns3->getMatrix(), "Back Aircraft", 1);

osg::Matrixd mx;
addObjectToCollisionWorld(node4, mx, "Center Aircraft", 0);


ref_ptr<Group> root = new Group();
root->addChild(mxTrns1.get());
root->addChild(mxTrns2.get());
root->addChild(mxTrns3.get());
root->addChild(node4.get());

osgViewer::Viewer viewer;
viewer.setSceneData(root.get());
viewer.setUpViewOnSingleScreen(1);
viewer.setCameraManipulator(new osgGA::TrackballManipulator());

pthread_create(&thread, NULL, updateCollisionWorld, NULL);

while (!viewer.done())
{
if (pos1 && pos2 && pos3)
{
pos1 -= 1;
pos2 += 1;
pos3 -= 1;
}

mxTrns1->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(90.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(pos1, 0, 0));

mxTrns2->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(270.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(pos2, 0, 0));

mxTrns3->setMatrix(Matrixd::rotate(Quat(DegreesToRadians(180.0), osg::Vec3(0, 0, 1))) * Matrixd::translate(0, pos3, 0));

_collisionObj[0]->setWorldTransform(osgbCollision::asBtTransform(mxTrns1->getMatrix()));
_collisionObj[1]->setWorldTransform(osgbCollision::asBtTransform(mxTrns2->getMatrix()));
_collisionObj[2]->setWorldTransform(osgbCollision::asBtTransform(mxTrns3->getMatrix()));


detectCollision();

viewer.frame();
}
}
Post Reply