PyObject* Material::GetContactTangentDirections ( )
{
dFloat d0[3];
dFloat d1[3];
NewtonMaterialGetContactTangentDirections( m_material, d0, d1 );
PyObject* r = PyTuple_New( 6 );
PyTuple_SetItem( r, 0, PyFloat_FromDouble( d0[0] ) );
PyTuple_SetItem( r, 1, PyFloat_FromDouble( d0[1] ) );
PyTuple_SetItem( r, 2, PyFloat_FromDouble( d0[2] ) );
PyTuple_SetItem( r, 3, PyFloat_FromDouble( d1[0] ) );
PyTuple_SetItem( r, 4, PyFloat_FromDouble( d1[1] ) );
PyTuple_SetItem( r, 5, PyFloat_FromDouble( d1[2] ) );
return r;
}
static void RenderBodyContactsForces (NewtonBody* const body, dFloat scale)
{
dFloat mass;
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
NewtonBodyGetMassMatrix (body, &mass, &Ixx, &Iyy, &Izz);
//draw normal forces in term of acceleration.
//this mean that two bodies with same shape but different mass will display the same force
if (mass > 0.0f) {
scale = scale/mass;
for (NewtonJoint* joint = NewtonBodyGetFirstContactJoint(body); joint; joint = NewtonBodyGetNextContactJoint(body, joint)) {
if (NewtonJointIsActive (joint)) {
for (void* contact = NewtonContactJointGetFirstContact (joint); contact; contact = NewtonContactJointGetNextContact (joint, contact)) {
dVector point(0.0f);
dVector normal(0.0f);
dVector tangnetDir0(0.0f);
dVector tangnetDir1(0.0f);
dVector contactForce(0.0f);
NewtonMaterial* const material = NewtonContactGetMaterial (contact);
NewtonMaterialGetContactForce(material, body, &contactForce.m_x);
NewtonMaterialGetContactPositionAndNormal (material, body, &point.m_x, &normal.m_x);
dVector normalforce (normal.Scale (contactForce % normal));
dVector p0 (point);
dVector p1 (point + normalforce.Scale (scale));
glVertex3f (p0.m_x, p0.m_y, p0.m_z);
glVertex3f (p1.m_x, p1.m_y, p1.m_z);
// these are the components of the tangents forces at the contact point, the can be display at the contact position point.
NewtonMaterialGetContactTangentDirections(material, body, &tangnetDir0[0], &tangnetDir1[0]);
dVector tangentForce1 (tangnetDir0.Scale ((contactForce % tangnetDir0) * scale));
dVector tangentForce2 (tangnetDir1.Scale ((contactForce % tangnetDir1) * scale));
p1 = point + tangentForce1.Scale (scale);
glVertex3f(p0.m_x, p0.m_y, p0.m_z);
glVertex3f(p1.m_x, p1.m_y, p1.m_z);
p1 = point + tangentForce2.Scale (scale);
glVertex3f(p0.m_x, p0.m_y, p0.m_z);
glVertex3f(p1.m_x, p1.m_y, p1.m_z);
}
}
}
}
}
static void RenderBodyContactsAndTangentDiretions (NewtonBody* const body, dFloat length)
{
for (NewtonJoint* joint = NewtonBodyGetFirstContactJoint(body); joint; joint = NewtonBodyGetNextContactJoint(body, joint)) {
if (NewtonJointIsActive (joint)) {
for (void* contact = NewtonContactJointGetFirstContact (joint); contact; contact = NewtonContactJointGetNextContact (joint, contact)) {
dVector point(0.0f);
dVector normal(0.0f);
NewtonMaterial* const material = NewtonContactGetMaterial (contact);
NewtonMaterialGetContactPositionAndNormal (material, body, &point.m_x, &normal.m_x);
dVector tangentDir0(0.0f);
dVector tangentDir1(0.0f);
NewtonMaterialGetContactTangentDirections(material, body, &tangentDir0[0], &tangentDir1[0]);
// if we are display debug info we need to block other threads from writing the data at the same time
dVector p1 (point + normal.Scale (length));
dVector p0 (point);
glVertex3f (p0.m_x, p0.m_y, p0.m_z);
glVertex3f (p1.m_x, p1.m_y, p1.m_z);
}
}
}
}
void ContactCallback::getContactTangentDirections( Ogre::Vector3& dir0, Ogre::Vector3& dir1 ) const
{
NewtonMaterialGetContactTangentDirections( m_material, &dir0.x, &dir1.x );
}
void GenericContactProcess (const NewtonJoint* contactJoint, dFloat timestep, int threadIndex)
{
#if 0
dFloat speed0;
dFloat speed1;
SpecialEffectStruct* currectEffect;
// get the pointer to the special effect structure
currectEffect = (SpecialEffectStruct *)NewtonMaterialGetMaterialPairUserData (material);
// save the contact information
NewtonMaterialGetContactPositionAndNormal (material, &currectEffect->m_position.m_x, &currectEffect->m_normal.m_x);
NewtonMaterialGetContactTangentDirections (material, &currectEffect->m_tangentDir0.m_x, &currectEffect->m_tangentDir1.m_x);
// Get the maximum normal speed of this impact. this can be used for positioning collision sound
speed0 = NewtonMaterialGetContactNormalSpeed (material);
if (speed0 > currectEffect->m_contactMaxNormalSpeed) {
// save the position of the contact (for 3d sound of particles effects)
currectEffect->m_contactMaxNormalSpeed = speed0;
}
// get the maximum of the two sliding contact speed
speed0 = NewtonMaterialGetContactTangentSpeed (material, 0);
speed1 = NewtonMaterialGetContactTangentSpeed (material, 1);
if (speed1 > speed0) {
speed0 = speed1;
}
// Get the maximum tangent speed of this contact. this can be used for particles(sparks) of playing scratch sounds
if (speed0 > currectEffect->m_contactMaxTangentSpeed) {
// save the position of the contact (for 3d sound of particles effects)
currectEffect->m_contactMaxTangentSpeed = speed0;
}
#endif
// read the table direction
// dVector dir (tableDir);
// dVector updir (TableDir);
// NewtonBody* const body = NewtonJointGetBody0(contactJoint);
// for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
// dFloat speed;
// dVector point;
// dVector normal;
// dVector dir0;
// dVector dir1;
// dVector force;
// NewtonMaterial* material;
//
// material = NewtonContactGetMaterial (contact);
// NewtonMaterialGetContactPositionAndNormal (material, body, &point.m_x, &normal.m_x);
//
// // if the normal is vertical is large the say 40 degrees
// if (fabsf (normal % upDir) > 0.7f) {
// // rotate the normal to be aligned with the table direction
// NewtonMaterialContactRotateTangentDirections (material, dir);
// }
// }
NewtonBody* const body = NewtonJointGetBody0(contactJoint);
for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
dVector point;
dVector normal;
dVector dir0;
dVector dir1;
dVector force;
NewtonMaterial* const material = NewtonContactGetMaterial (contact);
NewtonMaterialGetContactForce (material, body, &force.m_x);
NewtonMaterialGetContactPositionAndNormal (material, body, &point.m_x, &normal.m_x);
NewtonMaterialGetContactTangentDirections (material, body, &dir0.m_x, &dir1.m_x);
//dFloat speed = NewtonMaterialGetContactNormalSpeed(material);
//speed = NewtonMaterialGetContactNormalSpeed(material);
// play sound base of the contact speed.
//
}
}
void ApplyTracktionForce (dFloat timestep, const NewtonBody* track)
{
dVector veloc;
dVector omega;
dMatrix matrix;
NewtonBodyGetOmega(m_body0, &omega[0]);
NewtonBodyGetVelocity(m_body0, &veloc[0]);
NewtonBodyGetMatrix (m_body0, &matrix[0][0]);
// itetate over the contact list and condition each contact direction anc contact acclerations
for (NewtonJoint* contactJoint = NewtonBodyGetFirstContactJoint (track); contactJoint; contactJoint = NewtonBodyGetNextContactJoint (track, contactJoint)) {
_ASSERTE ((NewtonJointGetBody0 (contactJoint) == track) || (NewtonJointGetBody1 (contactJoint) == track));
#ifdef REMOVE_REDUNDAT_CONTACT
int contactCount;
contactCount = NewtonContactJointGetContactCount(contactJoint);
if (contactCount > 2) {
// project the contact to the bounday of the conve hull o fteh trhread foot ptint
dFloat maxDist;
dFloat minDist;
void* minContact;
void* maxContact;
dMatrix matrix;
minContact = NULL;
maxContact = NULL;
NewtonBodyGetMatrix (track, &matrix[0][0]);
maxDist = -1.0e10f;
minDist = -1.0e10f;
//find the best two contacts and remove all others
for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
dFloat dist;
dVector point;
dVector normal;
NewtonMaterial* material;
material = NewtonContactGetMaterial (contact);
NewtonMaterialGetContactPositionAndNormal(material, &point[0], &normal[0]);
dist = matrix.m_front % point;
if (dist > maxDist) {
maxDist = dist;
maxContact = contact;
}
if (-dist > minDist) {
minDist = -dist;
minContact = contact;
}
}
// now delete all reduntact contacts
void* nextContact;
NewtonWorld* world;
world = NewtonBodyGetWorld (track);
NewtonWorldCriticalSectionLock(world);
for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = nextContact) {
nextContact = NewtonContactJointGetNextContact (contactJoint, contact);
if (!((contact == minContact) || (contact == maxContact))) {
NewtonContactJointRemoveContact (contactJoint, contact);
}
}
NewtonWorldCriticalSectionUnlock(world);
}
#endif
for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
dFloat speed;
dFloat accel;
dVector point;
dVector normal;
dVector dir0;
dVector dir1;
NewtonMaterial* material;
material = NewtonContactGetMaterial (contact);
NewtonMaterialContactRotateTangentDirections (material, &matrix.m_front[0]);
NewtonMaterialGetContactPositionAndNormal(material, &point[0], &normal[0]);
NewtonMaterialGetContactTangentDirections (material, &dir0[0], &dir1[0]);
dVector posit (point - matrix.m_posit);
veloc += omega * posit;
speed = veloc % dir0;
// accel = m_accel - 0.1f * speed + (((posit % m_matrix.m_right) > 0.0f) ? m_turnAccel : - m_turnAccel);
accel = m_veloc + (((posit % matrix.m_right) > 0.0f) ? m_turnVeloc : - m_turnVeloc);
accel = (accel - speed) * 0.5f / timestep;
// NewtonMaterialSetContactStaticFrictionCoef (material, 1.0f, 0);
// NewtonMaterialSetContactKineticFrictionCoef (material, 1.0f, 0);
NewtonMaterialSetContactFrictionCoef (material, 1.0f, 1.0f, 0);
// NewtonMaterialSetContactStaticFrictionCoef (material, 0.5f, 1);
// NewtonMaterialSetContactKineticFrictionCoef (material, 0.5f, 1);
NewtonMaterialSetContactFrictionCoef (material, 0.5f, 0.5f, 1);
NewtonMaterialSetContactTangentAcceleration (material, accel, 0);
}
// for debug purpose show the contact
ShowJointContacts (contactJoint);
}
}
static void DestroyThisBodyCallback (const NewtonBody* body, const NewtonJoint* contactJoint)
{
NewtonWorld* world;
NewtonMesh* topMesh;
NewtonMesh* bottomMesh;
NewtonMesh* effectMesh;
RenderPrimitive* srcPrimitive;
dMatrix matrix;
dFloat maxForce;
dVector point;
dVector dir0;
dVector dir1;
// Get the world;
world = NewtonBodyGetWorld (body);
// find a the strongest force
maxForce = 0.0f;
for (void* contact = NewtonContactJointGetFirstContact (contactJoint); contact; contact = NewtonContactJointGetNextContact (contactJoint, contact)) {
dVector force;
NewtonMaterial* material;
material = NewtonContactGetMaterial (contact);
NewtonMaterialGetContactForce (material, &force.m_x);
if (force.m_x > maxForce) {
dVector normal;
NewtonMaterialGetContactPositionAndNormal(material, &point[0], &normal[0]);
NewtonMaterialGetContactTangentDirections (material, &dir0[0], &dir0[0]);
}
}
// get the visual primitive
srcPrimitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
// get the effect mesh that is use to create the debris pieces
effectMesh = srcPrimitive->m_specialEffect;
// calculate the cut plane plane
NewtonBodyGetMatrix (body, &matrix[0][0]);
dMatrix clipMatrix (dgGrammSchmidt(dir0) *
dYawMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)) *
dRollMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)));
clipMatrix.m_posit = point;
clipMatrix.m_posit.m_w = 1.0f;
clipMatrix = clipMatrix * matrix.Inverse();
// break the mesh into two pieces
NewtonMeshClip (effectMesh, meshClipper, &clipMatrix[0][0], &topMesh, &bottomMesh);
if (topMesh && bottomMesh) {
dFloat volume;
NewtonMesh* meshPartA = NULL;
NewtonMesh* meshPartB = NULL;
volume = NewtonConvexCollisionCalculateVolume (NewtonBodyGetCollision(body));
// the clipper was able to make a cut now we can create new debris piece for replacement
dMatrix clipMatrix1 (dgGrammSchmidt(dir1) *
dYawMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)) *
dRollMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)));
NewtonMeshClip (bottomMesh, meshClipper, &clipMatrix1[0][0], &meshPartA, &meshPartB);
if (meshPartA && meshPartB) {
// creat another split (you can make as many depend of the FPS)
CreateDebriPiece (body, meshPartA, volume);
CreateDebriPiece (body, meshPartB, volume);
NewtonMeshDestroy(meshPartA);
NewtonMeshDestroy(meshPartB);
} else {
CreateDebriPiece (body, bottomMesh, volume);
}
NewtonMeshDestroy(bottomMesh);
dMatrix clipMatrix2 (dgGrammSchmidt(dir1) *
dYawMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)) *
dRollMatrix(30.0f * 3.1416f/180.0f * RandomVariable(1.0f)));
NewtonMeshClip (topMesh, meshClipper, &clipMatrix2[0][0], &meshPartA, &meshPartB);
if (meshPartA && meshPartB) {
// creat another split (you can make as many depend of the FPS)
CreateDebriPiece (body, meshPartA, volume);
CreateDebriPiece (body, meshPartB, volume);
NewtonMeshDestroy(meshPartA);
NewtonMeshDestroy(meshPartB);
} else {
CreateDebriPiece (body, topMesh, volume);
}
NewtonMeshDestroy(topMesh);
// remove the old visual from graphics world
SceneManager* system = (SceneManager*) NewtonWorldGetUserData(world);
delete srcPrimitive;
system->Remove(srcPrimitive);
// finally destroy this body;
NewtonDestroyBody(world, body);
}
}
virtual void getContactTangentDirections(Math::Vector3& _direction0, Math::Vector3& _direction1) const
{
NewtonMaterialGetContactTangentDirections(m_pMaterial, _direction0.m_array, _direction1.m_array);
}