TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-02 09:52:27 -04:00
Code Issues Packages Projects Releases Wiki Activity

Asserts, and reformat code

Browse Source
This commit is contained in:
rdb 2009-04-04 07:20:28 +00:00
parent 6bd15649f9
commit a5d774a1c3
3 changed files with 240 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
panda/src/ode/odeJoint.cxx
View File

@ -37,6 +37,7 @@ OdeJoint::
void OdeJoint::
destroy() {
nassertv(_id);
dJointDestroy(_id);
}
@ -50,6 +51,7 @@ destroy() {
////////////////////////////////////////////////////////////////////
void OdeJoint::
attach_bodies(const OdeBody &body1, const OdeBody &body2) {
nassertv(_id);
nassertv(body1.get_id() != 0 && body2.get_id() != 0);
dJointAttach(_id, body1.get_id(), body2.get_id());
}
@ -65,6 +67,7 @@ attach_bodies(const OdeBody &body1, const OdeBody &body2) {
////////////////////////////////////////////////////////////////////
void OdeJoint::
attach_body(const OdeBody &body, int index) {
nassertv(_id);
nassertv(body.get_id() != 0);
nassertv(index == 0 || index == 1);
if (index == 0) {
@ -76,6 +79,7 @@ attach_body(const OdeBody &body, int index) {
void OdeJoint::
detach() {
nassertv(_id);
dJointAttach(_id, 0, 0);
}

278
panda/src/ode/odeSpace.cxx
View File

@ -50,46 +50,55 @@ OdeSpace::
void OdeSpace::
destroy() {
nassertv(_id);
dSpaceDestroy(_id);
}
int OdeSpace::
query(const OdeGeom& geom) const {
nassertr(_id, 0);
return dSpaceQuery(_id, geom.get_id());
}
int OdeSpace::
query(const OdeSpace& space) const {
nassertr(_id, 0);
return dSpaceQuery(_id, (dGeomID)space.get_id());
}
void OdeSpace::
add(OdeSpace& space) {
nassertv(_id);
dSpaceAdd(_id, (dGeomID)space.get_id());
}
void OdeSpace::
remove(OdeSpace& space) {
nassertv(_id);
dSpaceRemove(_id, (dGeomID)space.get_id());
}
void OdeSpace::
add(OdeGeom& geom) {
nassertv(_id);
dSpaceAdd(_id, geom.get_id());
}
void OdeSpace::
remove(OdeGeom& geom) {
nassertv(_id);
dSpaceRemove(_id, geom.get_id());
}
void OdeSpace::
clean() {
nassertv(_id);
dSpaceClean(_id);
}
OdeGeom OdeSpace::
get_geom(int i) {
nassertr(_id, OdeGeom(0));
return OdeGeom(dSpaceGetGeom(_id, i));
}
@ -107,170 +116,160 @@ operator bool () const {
}
void OdeSpace::
set_auto_collide_world(OdeWorld &world)
{
my_world = &world;
set_auto_collide_world(OdeWorld &world) {
my_world = &world;
}
void OdeSpace::
set_auto_collide_joint_group(OdeJointGroup &joint_group)
{
_collide_joint_group = joint_group.get_id();
set_auto_collide_joint_group(OdeJointGroup &joint_group) {
_collide_joint_group = joint_group.get_id();
}
int OdeSpace::
auto_collide()
{
if (my_world == NULL) {
odespace_cat.error() << "No collide world has been set!\n";
return 0;
} else {
OdeSpace::contactCount = 0;
_collide_space = this;
_collide_world = my_world;
dSpaceCollide(_id, this, &auto_callback);
return OdeSpace::contactCount;
}
auto_collide() {
if (my_world == NULL) {
odespace_cat.error() << "No collide world has been set!\n";
return 0;
} else {
nassertr(_id, 0);
OdeSpace::contactCount = 0;
_collide_space = this;
_collide_world = my_world;
dSpaceCollide(_id, this, &auto_callback);
return OdeSpace::contactCount;
}
}
double OdeSpace::
get_contact_data(int data_index)
get_contact_data(int data_index) {
// get the contact data it looks like so [x1,y1,z1,x2,y2,z2... x64,y64,z64]
// use the return in from autoCollide to determine how much of the data is
// valid. The data would be more straight forward but the callbacks have to be
// static.
{
return OdeSpace::contact_data[data_index];
return OdeSpace::contact_data[data_index];
}
int OdeSpace::
get_contact_id(int data_index, int first)
get_contact_id(int data_index, int first) {
// get the contact data it looks like so [x1,y1,z1,x2,y2,z2... x64,y64,z64]
// use the return in from autoCollide to determine how much of the data is
// valid. The data would be more straight forward but the callbacks have to be
// static.
{
if (first == 0)
{
return OdeSpace::contact_ids[(data_index * 2) + 0];
}
else
{
return OdeSpace::contact_ids[(data_index * 2) + 1];
}
if (first == 0) {
return OdeSpace::contact_ids[(data_index * 2) + 0];
} else {
return OdeSpace::contact_ids[(data_index * 2) + 1];
}
}
void OdeSpace::
auto_callback(void *data, dGeomID o1, dGeomID o2)
auto_callback(void *data, dGeomID o1, dGeomID o2) {
// uses data stored on the world to resolve collisions so you don't have to use near_callbacks in python
{
int i;
static int autoCallbackCounter = 0;
dBodyID b1 = dGeomGetBody(o1);
dBodyID b2 = dGeomGetBody(o2);
int i;
static int autoCallbackCounter = 0;
dBodyID b1 = dGeomGetBody(o1);
dBodyID b2 = dGeomGetBody(o2);
dContact contact[OdeSpace::MAX_CONTACTS];
int surface1 = _collide_space->get_surface_type(o1);
int surface2 = _collide_space->get_surface_type(o2);
nassertv(_collide_world != NULL);
sSurfaceParams collide_params;
collide_params = _collide_world->get_surface(surface1, surface2);
for (i=0; i < OdeSpace::MAX_CONTACTS; i++)
{
contact[i].surface.mode = collide_params.colparams.mode;
contact[i].surface.mu = collide_params.colparams.mu;
contact[i].surface.mu2 = collide_params.colparams.mu2;
contact[i].surface.bounce = collide_params.colparams.bounce;
contact[i].surface.bounce_vel = collide_params.colparams.bounce_vel;
contact[i].surface.soft_cfm = collide_params.colparams.soft_cfm;
dContact contact[OdeSpace::MAX_CONTACTS];
int surface1 = _collide_space->get_surface_type(o1);
int surface2 = _collide_space->get_surface_type(o2);
nassertv(_collide_world != NULL);
sSurfaceParams collide_params;
collide_params = _collide_world->get_surface(surface1, surface2);
for (i=0; i < OdeSpace::MAX_CONTACTS; i++) {
contact[i].surface.mode = collide_params.colparams.mode;
contact[i].surface.mu = collide_params.colparams.mu;
contact[i].surface.mu2 = collide_params.colparams.mu2;
contact[i].surface.bounce = collide_params.colparams.bounce;
contact[i].surface.bounce_vel = collide_params.colparams.bounce_vel;
contact[i].surface.soft_cfm = collide_params.colparams.soft_cfm;
}
static int numc = 0;
numc = dCollide(o1, o2, OdeSpace::MAX_CONTACTS, &contact[0].geom, sizeof(dContact));
if (numc) {
if (odespace_cat.is_debug() && (autoCallbackCounter%30 == 0)) {
odespace_cat.debug() << autoCallbackCounter <<" collision between geoms " << o1 << " and " << o2 << "\n";
odespace_cat.debug() << "collision between body " << b1 << " and " << b2 << "\n";
odespace_cat.debug() << "surface1= "<< surface1 << " surface2=" << surface2 << "\n";
}
autoCallbackCounter += 1;
PT(OdeCollisionEntry) entry;
if (!_collide_space->_collision_event.empty()) {
entry = new OdeCollisionEntry;
entry->_geom1 = o1;
entry->_geom2 = o2;
entry->_body1 = b1;
entry->_body2 = b2;
entry->_num_points = numc;
entry->_points = new LPoint3f[numc];
}
static int numc = 0;
numc = dCollide(o1, o2, OdeSpace::MAX_CONTACTS, &contact[0].geom, sizeof(dContact));
if (numc)
{
if (odespace_cat.is_debug() && (autoCallbackCounter%30 == 0)) {
odespace_cat.debug() << autoCallbackCounter <<" collision between geoms " << o1 << " and " << o2 << "\n";
odespace_cat.debug() << "collision between body " << b1 << " and " << b2 << "\n";
odespace_cat.debug() << "surface1= "<< surface1 << " surface2=" << surface2 << "\n";
}
autoCallbackCounter += 1;
PT(OdeCollisionEntry) entry;
if (!_collide_space->_collision_event.empty()) {
entry = new OdeCollisionEntry;
entry->_geom1 = o1;
entry->_geom2 = o2;
entry->_body1 = b1;
entry->_body2 = b2;
entry->_num_points = numc;
entry->_points = new LPoint3f[numc];
}
for(i=0; i < numc; i++)
{
dJointID c = dJointCreateContact(_collide_world->get_id(), _collide_joint_group, contact + i);
if ((_collide_space->get_collide_id(o1) >= 0) && (_collide_space->get_collide_id(o2) >= 0))
{
dJointAttach(c, b1, b2);
}
if (!_collide_space->_collision_event.empty()) {
entry->_points[i][0] = contact[i].geom.pos[0];
entry->_points[i][1] = contact[i].geom.pos[1];
entry->_points[i][2] = contact[i].geom.pos[2];
}
// this creates contact position data for python. It is useful for debugging only 64 points are stored
if(contactCount < 64)
{
OdeSpace::contact_data[0 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[0];
OdeSpace::contact_data[1 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[1];
OdeSpace::contact_data[2 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[2];
OdeSpace::contact_ids[0 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o1);
OdeSpace::contact_ids[1 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o2);
OdeSpace::contactCount += 1;
}
}
_collide_world->set_dampen_on_bodies(b1, b2, collide_params.dampen);
if (!_collide_space->_collision_event.empty()) {
throw_event(_collide_space->_collision_event, EventParameter(entry));
}
for(i=0; i < numc; i++) {
dJointID c = dJointCreateContact(_collide_world->get_id(), _collide_joint_group, contact + i);
if ((_collide_space->get_collide_id(o1) >= 0) && (_collide_space->get_collide_id(o2) >= 0)) {
dJointAttach(c, b1, b2);
}
if (!_collide_space->_collision_event.empty()) {
entry->_points[i][0] = contact[i].geom.pos[0];
entry->_points[i][1] = contact[i].geom.pos[1];
entry->_points[i][2] = contact[i].geom.pos[2];
}
// this creates contact position data for python. It is useful for debugging only 64 points are stored
if(contactCount < 64) {
OdeSpace::contact_data[0 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[0];
OdeSpace::contact_data[1 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[1];
OdeSpace::contact_data[2 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[2];
OdeSpace::contact_ids[0 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o1);
OdeSpace::contact_ids[1 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o2);
OdeSpace::contactCount += 1;
}
}
_collide_world->set_dampen_on_bodies(b1, b2, collide_params.dampen);
if (!_collide_space->_collision_event.empty()) {
throw_event(_collide_space->_collision_event, EventParameter(entry));
}
}
}
#ifdef HAVE_PYTHON
int OdeSpace::
collide(PyObject* arg, PyObject* callback) {
nassertr(callback != NULL, -1);
if (!PyCallable_Check(callback)) {
PyErr_Format(PyExc_TypeError, "'%s' object is not callable", callback->ob_type->tp_name);
return -1;
} else {
OdeSpace::_python_callback = (PyObject*) callback;
Py_XINCREF(OdeSpace::_python_callback);
dSpaceCollide(_id, (void*) arg, &near_callback);
Py_XDECREF(OdeSpace::_python_callback);
return 0;
}
nassertr(callback != NULL, -1);
if (!PyCallable_Check(callback)) {
PyErr_Format(PyExc_TypeError, "'%s' object is not callable", callback->ob_type->tp_name);
return -1;
} else if (_id == NULL) {
// Well, while we're in the mood of python exceptions, let's make this one too.
PyErr_Format(PyExc_TypeError, "OdeSpace is not valid!");
return -1;
} else {
OdeSpace::_python_callback = (PyObject*) callback;
Py_XINCREF(OdeSpace::_python_callback);
dSpaceCollide(_id, (void*) arg, &near_callback);
Py_XDECREF(OdeSpace::_python_callback);
return 0;
}
}
void OdeSpace::
near_callback(void *data, dGeomID o1, dGeomID o2) {
odespace_cat.spam() << "near_callback called, data: " << data << ", dGeomID1: " << o1 << ", dGeomID2: " << o2 << "\n";
OdeGeom g1 (o1);
OdeGeom g2 (o2);
PyObject* p1 = DTool_CreatePyInstanceTyped(&g1, Dtool_OdeGeom, true, false, g1.get_type_index());
PyObject* p2 = DTool_CreatePyInstanceTyped(&g2, Dtool_OdeGeom, true, false, g2.get_type_index());
PyObject* result = PyEval_CallFunction(_python_callback, "OOO", (PyObject*) data, p1, p2);
if (!result) {
odespace_cat.error() << "An error occurred while calling python function!\n";
PyErr_Print();
}
odespace_cat.spam() << "near_callback called, data: " << data << ", dGeomID1: " << o1 << ", dGeomID2: " << o2 << "\n";
OdeGeom g1 (o1);
OdeGeom g2 (o2);
PyObject* p1 = DTool_CreatePyInstanceTyped(&g1, Dtool_OdeGeom, true, false, g1.get_type_index());
PyObject* p2 = DTool_CreatePyInstanceTyped(&g2, Dtool_OdeGeom, true, false, g2.get_type_index());
PyObject* result = PyEval_CallFunction(_python_callback, "OOO", (PyObject*) data, p1, p2);
if (!result) {
odespace_cat.error() << "An error occurred while calling python function!\n";
PyErr_Print();
}
}
#endif
@ -308,8 +307,7 @@ set_surface_type(OdeGeom& geom, int surfaceType){
}
int OdeSpace::
get_surface_type(dGeomID id)
{
get_surface_type(dGeomID id) {
GeomSurfaceMap::iterator iter = _geom_surface_map.find(id);
if (iter != _geom_surface_map.end()) {
// odespace_cat.debug() << "get_default_surface_type the geomId =" << id <<" surfaceType=" << iter->second << "\n";
@ -320,14 +318,14 @@ get_surface_type(dGeomID id)
}
int OdeSpace::
get_surface_type(OdeGeom& geom){
get_surface_type(OdeGeom& geom) {
dGeomID id = geom.get_id();
return get_surface_type(id);
}
int OdeSpace::
set_collide_id( int collide_id, dGeomID id){
set_collide_id( int collide_id, dGeomID id) {
_geom_collide_id_map[id]= collide_id;
//odespace_cat.debug() << "set_collide_id " << id << " " << _geom_collide_id_map[id] <<"\n";
@ -345,24 +343,20 @@ set_collide_id( int collide_id, dGeomID id){
}
int OdeSpace::
set_collide_id( OdeGeom& geom, int collide_id)
{
dGeomID id = geom.get_id();
return set_collide_id(collide_id, id);
set_collide_id( OdeGeom& geom, int collide_id) {
dGeomID id = geom.get_id();
return set_collide_id(collide_id, id);
}
int OdeSpace::
get_collide_id(OdeGeom& geom)
{
dGeomID id = geom.get_id();
return get_collide_id(id);
get_collide_id(OdeGeom& geom) {
dGeomID id = geom.get_id();
return get_collide_id(id);
}
int OdeSpace::
get_collide_id(dGeomID id)
{
get_collide_id(dGeomID id) {
/*
GeomCollideIdMap::iterator iter2 = _geom_collide_id_map.begin();
while (iter2 != _geom_collide_id_map.end()) {

223
panda/src/ode/odeWorld.cxx
View File

@ -39,162 +39,139 @@ OdeWorld::
void OdeWorld::
destroy() {
if(_num_surfaces > 0)
{
delete _surface_table;
if(_num_surfaces > 0) {
delete _surface_table;
}
nassertv(_id);
dWorldDestroy(_id);
}
/*
void OdeWorld::
assign_surface_body(OdeBody& body, int surface)
{
// odeworld_cat.debug() << "assign_surface_body body.Id =" << body.get_id() << " surface=" << surface << "\n";
_body_dampen_map[body.get_id()].surfaceType = surface;
_body_dampen_map[body.get_id()].dampen = 0.0f;
assign_surface_body(OdeBody& body, int surface) {
// odeworld_cat.debug() << "assign_surface_body body.Id =" << body.get_id() << " surface=" << surface << "\n";
_body_dampen_map[body.get_id()].surfaceType = surface;
_body_dampen_map[body.get_id()].dampen = 0.0f;
}
*/
void OdeWorld::
add_body_dampening(OdeBody& body, int surface)
{
_body_dampen_map[body.get_id()].dampen = 0.0f;
add_body_dampening(OdeBody& body, int surface) {
_body_dampen_map[body.get_id()].dampen = 0.0f;
}
void OdeWorld::
init_surface_table(PN_uint8 num_surfaces)
{
_surface_table = new sSurfaceParams[num_surfaces * num_surfaces];
//_dampen_table = new sSurfaceParams[num_surfaces * num_surfaces];
_num_surfaces = num_surfaces;
init_surface_table(PN_uint8 num_surfaces) {
_surface_table = new sSurfaceParams[num_surfaces * num_surfaces];
//_dampen_table = new sSurfaceParams[num_surfaces * num_surfaces];
_num_surfaces = num_surfaces;
}
void OdeWorld::
set_surface(int pos1, int pos2, sSurfaceParams& entry)
{
odeworld_cat.debug() << " pos1 " << pos1 << " pos2 " << pos2 << " num surfaces " << (int)_num_surfaces << " endline\n";
if((_num_surfaces <= pos1) || (_num_surfaces <= pos2))
{
odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
return;
}
int true_pos = (pos1 * _num_surfaces) + pos2;
_surface_table[true_pos].colparams.mode = entry.colparams.mode;
_surface_table[true_pos].colparams.mu = entry.colparams.mu;
_surface_table[true_pos].colparams.mu2 = entry.colparams.mu2;
_surface_table[true_pos].colparams.bounce = entry.colparams.bounce;
_surface_table[true_pos].colparams.bounce_vel = entry.colparams.bounce_vel;
_surface_table[true_pos].colparams.soft_cfm = entry.colparams.soft_cfm;
_surface_table[true_pos].colparams.motion1 = entry.colparams.motion1;
_surface_table[true_pos].colparams.motion2 = entry.colparams.motion2;
_surface_table[true_pos].colparams.slip1 = entry.colparams.slip1;
_surface_table[true_pos].colparams.slip2 = entry.colparams.slip2;
_surface_table[true_pos].dampen = entry.dampen;
set_surface(int pos1, int pos2, sSurfaceParams& entry) {
odeworld_cat.debug() << " pos1 " << pos1 << " pos2 " << pos2 << " num surfaces " << (int)_num_surfaces << " endline\n";
if((_num_surfaces <= pos1) || (_num_surfaces <= pos2)) {
odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
return;
}
int true_pos = (pos1 * _num_surfaces) + pos2;
_surface_table[true_pos].colparams.mode = entry.colparams.mode;
_surface_table[true_pos].colparams.mu = entry.colparams.mu;
_surface_table[true_pos].colparams.mu2 = entry.colparams.mu2;
_surface_table[true_pos].colparams.bounce = entry.colparams.bounce;
_surface_table[true_pos].colparams.bounce_vel = entry.colparams.bounce_vel;
_surface_table[true_pos].colparams.soft_cfm = entry.colparams.soft_cfm;
_surface_table[true_pos].colparams.motion1 = entry.colparams.motion1;
_surface_table[true_pos].colparams.motion2 = entry.colparams.motion2;
_surface_table[true_pos].colparams.slip1 = entry.colparams.slip1;
_surface_table[true_pos].colparams.slip2 = entry.colparams.slip2;
_surface_table[true_pos].dampen = entry.dampen;
}
sSurfaceParams& OdeWorld::
get_surface(PN_uint8 surface1, PN_uint8 surface2)
{
int true_pos = 0;
if(surface1 >= surface2)
{
true_pos = (surface1 * _num_surfaces) + surface2;
}
else
{
true_pos = (surface2 * _num_surfaces) + surface1;
}
if((_num_surfaces <= surface1) || (_num_surfaces <= surface2))
{
odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
//nassertr_always((_num_surfaces > surface1 && _num_surfaces > surface2), _surface_table[true_pos]);
}
return _surface_table[true_pos];
get_surface(PN_uint8 surface1, PN_uint8 surface2) {
int true_pos = 0;
if(surface1 >= surface2) {
true_pos = (surface1 * _num_surfaces) + surface2;
} else {
true_pos = (surface2 * _num_surfaces) + surface1;
}
if((_num_surfaces <= surface1) || (_num_surfaces <= surface2)) {
odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
//nassertr_always((_num_surfaces > surface1 && _num_surfaces > surface2), _surface_table[true_pos]);
}
return _surface_table[true_pos];
}
void OdeWorld::
set_surface_entry( PN_uint8 pos1, PN_uint8 pos2,
dReal mu,
dReal bounce,
dReal bounce_vel,
dReal soft_erp,
dReal soft_cfm,
dReal slip,
dReal dampen)
{
//todo: add mode
sSurfaceParams new_params;
int someMode = 0;
if (bounce > 0.0001)
{
someMode |= dContactBounce;
}
if (soft_erp > 0.0001)
{
someMode |= dContactSoftERP;
}
if (soft_cfm > 0.0001)
{
someMode |= dContactSoftCFM;
}
if (slip > 0.0001)
{
someMode = someMode | dContactSlip1 | dContactSlip2;
}
new_params.colparams.mode = dContactBounce | dContactSoftCFM | dContactApprox1;// | dContactSoftERP;
new_params.colparams.mu = mu;
new_params.colparams.mu2 = mu;
new_params.colparams.bounce = bounce;
new_params.colparams.bounce_vel = bounce_vel;
new_params.colparams.soft_erp = soft_erp;
new_params.colparams.soft_cfm = soft_cfm;
new_params.colparams.slip1 = slip;
new_params.colparams.slip2 = slip;
new_params.colparams.motion1 = 0.0;
new_params.colparams.motion2 = 0.0;
new_params.dampen = dampen;
//todo: a bit of wasted space here
set_surface_entry(PN_uint8 pos1, PN_uint8 pos2,
dReal mu,
dReal bounce,
dReal bounce_vel,
dReal soft_erp,
dReal soft_cfm,
dReal slip,
dReal dampen) {
//todo: add mode
sSurfaceParams new_params;
int someMode = 0;
if (bounce > 0.0001) {
someMode |= dContactBounce;
}
if (soft_erp > 0.0001) {
someMode |= dContactSoftERP;
}
if (soft_cfm > 0.0001) {
someMode |= dContactSoftCFM;
}
if (slip > 0.0001) {
someMode = someMode | dContactSlip1 | dContactSlip2;
}
new_params.colparams.mode = dContactBounce | dContactSoftCFM | dContactApprox1;// | dContactSoftERP;
new_params.colparams.mu = mu;
new_params.colparams.mu2 = mu;
new_params.colparams.bounce = bounce;
new_params.colparams.bounce_vel = bounce_vel;
new_params.colparams.soft_erp = soft_erp;
new_params.colparams.soft_cfm = soft_cfm;
new_params.colparams.slip1 = slip;
new_params.colparams.slip2 = slip;
new_params.colparams.motion1 = 0.0;
new_params.colparams.motion2 = 0.0;
new_params.dampen = dampen;
//todo: a bit of wasted space here
set_surface(pos1, pos2, new_params);
if(pos1 >= pos2) {
set_surface(pos1, pos2, new_params);
if(pos1 >= pos2)
{
set_surface(pos1, pos2, new_params);
}
else
{
set_surface(pos2, pos1, new_params);
}
} else {
set_surface(pos2, pos1, new_params);
}
}
void OdeWorld::
set_dampen_on_bodies(dBodyID id1, dBodyID id2,dReal damp)
{
if(_body_dampen_map[id1].dampen < damp)
{
_body_dampen_map[id1].dampen = damp;
}
if(_body_dampen_map[id2].dampen < damp)
{
_body_dampen_map[id2].dampen = damp;
}
set_dampen_on_bodies(dBodyID id1, dBodyID id2,dReal damp) {
if(_body_dampen_map[id1].dampen < damp) {
_body_dampen_map[id1].dampen = damp;
}
if(_body_dampen_map[id2].dampen < damp) {
_body_dampen_map[id2].dampen = damp;
}
}
float OdeWorld::
apply_dampening(float dt, OdeBody& body)
{
dBodyID bodyId = body.get_id();
dReal damp = _body_dampen_map[bodyId].dampen;
float dampening = 1.00 - (damp * dt);
body.set_angular_vel(body.get_angular_vel() * dampening);
body.set_linear_vel(body.get_linear_vel() * dampening);
_body_dampen_map[bodyId].dampen = 0.0;
return dampening;
apply_dampening(float dt, OdeBody& body) {
dBodyID bodyId = body.get_id();
dReal damp = _body_dampen_map[bodyId].dampen;
float dampening = 1.00 - (damp * dt);
body.set_angular_vel(body.get_angular_vel() * dampening);
body.set_linear_vel(body.get_linear_vel() * dampening);
_body_dampen_map[bodyId].dampen = 0.0;
return dampening;
}
OdeWorld::