Body.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/Physics/Body.h>
#include <PVLE/Physics/World.h>
#include <PVLE/Physics/Joint.h>
#include <PVLE/Physics/Visitor.h>
#include <PVLE/Util/Assert.h>

namespace Physics {

Mass::Mass(EDirectInit init_mode, dReal value, const osg::Vec3 & size) : idBody(0) {
    if (init_mode == BOX) setBox(value, size);
    else if (init_mode == BOX_TOTAL) setBoxTotal(value, size);
    else THROW_TRACED_EXCEPTION("Bad argument (illegal mode)");
}
Mass::Mass(EDirectInit init_mode, dReal value, dReal radius) : idBody(0) {
    if (init_mode == SPHERE) setSphere(value, radius);
    else if (init_mode == SPHERE_TOTAL) setSphereTotal(value, radius);
    else THROW_TRACED_EXCEPTION("Bad argument (illegal mode)");
}
Mass::Mass(EDirectInit init_mode, dReal value, EAxis axis, dReal radius, dReal length) : idBody(0) {
    if (init_mode == CAPSULE) setCapsule(value, axis, radius, length);
    else if (init_mode == CAPSULE_TOTAL) setCapsuleTotal(value, axis, radius, length);
    else if (init_mode == CYLINDER) setCylinder(value, axis, radius, length);
    else if (init_mode == CYLINDER_TOTAL) setCylinderTotal(value, axis, radius, length);
    else THROW_TRACED_EXCEPTION("Bad argument (illegal mode)");
}

// --------------------------------------------------------------------------------


Body::Body(const World * pWorld) : pWorld(pWorld), allowCollideWithJointBodies(false), windFactor(1) {
    ASSERT(pWorld);
    id = dBodyCreate(pWorld->id);
    dBodySetData(id, this);     // Back reference

    dBodySetFiniteRotationMode(id, 0);
    setInfluencedByGravity(true);

    // Mass
    massData.idBody = id;
    massData.setSphere(1, 1);       // Default mass
}

Body::Body(const Body & v) : pWorld(v.pWorld), allowCollideWithJointBodies(v.allowCollideWithJointBodies), massData(v.massData), windFactor(1) {
    id = dBodyCreate(pWorld->id);
    dBodySetData(id, this);     // Back reference

    if (dBodyIsEnabled(v)) dBodyEnable(*this); else dBodyDisable(*this);
    dBodySetAutoDisableFlag(*this, dBodyGetAutoDisableFlag(v));
    dBodySetAutoDisableLinearThreshold(*this, dBodyGetAutoDisableLinearThreshold(v));
    dBodySetAutoDisableAngularThreshold(*this, dBodyGetAutoDisableAngularThreshold(v));
    dBodySetAutoDisableSteps(*this, dBodyGetAutoDisableSteps(v));
    dBodySetAutoDisableTime(*this, dBodyGetAutoDisableTime(v));
    dBodySetAutoDisableAverageSamplesCount(*this, dBodyGetAutoDisableAverageSamplesCount(v));

    dBodySetFiniteRotationMode(*this, dBodyGetFiniteRotationMode(v));
    dVector3 finiteRotAxis;
    dBodyGetFiniteRotationAxis(v, finiteRotAxis);
	::dBodySetFiniteRotationAxis(*this, finiteRotAxis[0], finiteRotAxis[1], finiteRotAxis[2]);

    setInfluencedByGravity(v.isInfluencedByGravity());

    // Do not duplicate joints (this is not the job of that class) !
    //UINT nbJoints = v.getNbJoints();
    //if (nbJoints != 0) {
    //  // Find if joints exist (except contacts joints)
    //  for(UINT i=0; i<nbJoints; ++i) {
    //      if (v.getJoint(i)->getType() != Joint::CONTACT) THROW_TRACED_EXCEPTION("Body with joints (contacts joints ignored) ! Dupliaction not implemented");
    //  }
    //}

    // Positions
    const dReal * pos = dBodyGetPosition(v);
	::dBodySetPosition(*this, pos[0], pos[1], pos[2]);
    dQuaternion rot;
    dBodyCopyQuaternion(v, rot);
	::dBodySetQuaternion(*this, rot);
    // Velocities
    const dReal * vel = dBodyGetLinearVel(v);
	::dBodySetLinearVel(*this, vel[0], vel[1], vel[2]);
    const dReal * avel = dBodyGetAngularVel(v);
	::dBodySetAngularVel(*this, avel[0], avel[1], avel[2]);
    // Forces
    const dReal * force = dBodyGetForce(v);
	::dBodySetForce(*this, force[0], force[1], force[2]);
    const dReal * torque = dBodyGetTorque(v);
	::dBodySetTorque(*this, torque[0], torque[1], torque[2]);

    // Mass
    massData.idBody = id;
    massData = v.massData;      // Default mass
}

Joint * Body::getJoint(UINT index) {
    dJointID jId = dBodyGetJoint(id, index);
    return jId ? static_cast<Joint *>(dJointGetData(jId)) : NULL;
}

const Joint * Body::getJoint(UINT index) const {
    dJointID jId = dBodyGetJoint(id, index);
    return jId ? static_cast<Joint *>(dJointGetData(jId)) : NULL;
}


#ifdef ENABLE_PHYSICS_EXTRA_WRAPPING
bool Body::isConnectedTo(Body * pBody) const { return dAreConnected(id, pBody->id) !=0; }
#endif
bool Body::isConnectedToExcludingContact(Body * pBody) const { return dAreConnectedExcluding(id, pBody->id, Joint::CONTACT) !=0; }

void Body::accept(Visitor & v) { v.apply(*this); }
void Body::traverse(Visitor & v) {
    UINT nbJoints = dBodyGetNumJoints(id);
    for(UINT i=0, iEnd=nbJoints; i<iEnd; ++i) v.apply(*getJoint(i));
}

}   // namespace Physics

---