rigidbody.h

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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 2 of the License, or
    (at your option) any later version.

    Sheep 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 Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef SHEEP_DYNAMICS_RIGIDBODY_H
#define SHEEP_DYNAMICS_RIGIDBODY_H

#include "common/math/de.h"
#include "common/math/matrix3.h"
#include "common/math/quaternion.h"
#include "common/math/real.h"
#include "common/math/vector3.h"

#include <cassert>
#include <cmath>    // for fabs()

namespace sheep {

    class RigidBody {
    public:
        class StateVector {
        public:
            // Location of the center of mass.
            Vector3 m_x;    // world space

            // Orientation.
            Quaternion m_q; // world space

            // Linear momentum.
            Vector3 m_P;    // world space

            // Angular momentum.
            Vector3 m_L;    // world space

            inline StateVector();
            inline StateVector(const Vector3 &x, const Quaternion &q,
                const Vector3 &P, const Vector3 &L);

            inline StateVector operator+(const StateVector &s) const;
            inline StateVector operator*(Real r) const;
        };

        typedef IDE1Solver<StateVector> StateDESolver;

        RigidBody(Real mass, const Matrix3 &inertia);
        ~RigidBody();

        inline Real GetMass() const;

        inline const Matrix3 &GetInertiaTensor() const; // body space
        inline Matrix3 GetWorldInertiaTensor() const;   // world space

        // Body freezing mechanism. A frozen body will not be taken into account
        // by the world into which it is registered. Also, a frozen body will
        // always report null velocities.
        inline void Freeze();
        inline void Unfreeze();
        inline bool IsFrozen() const;

        inline void SetPosition(const Vector3 &x);  // world space
        inline const Vector3 &GetPosition() const;  // world space

        inline void SetOrientation(const Quaternion &q);    // world space
        inline const Quaternion &GetOrientation() const;    // world space

        inline void SetLinearVelocity(const Vector3 &v);    // world space
        inline Vector3 GetLinearVelocity() const;   // world space

        inline void SetAngularVelocity(const Vector3 &omega);   // world space
        inline Vector3 GetAngularVelocity() const;  // world space

        inline Real GetKineticEnergy() const;

        inline Vector3 TransformVectorToWorld(const Vector3 &v) const;  // v in body space, result in world space
        inline Vector3 TransformVectorToBody(const Vector3 &v) const;   // v in world space, result in body space
        inline Vector3 TransformPointToWorld(const Vector3 &p) const;   // p in body space, result in world space
        inline Vector3 TransformPointToBody(const Vector3 &p) const;    // p in world space, result in body space

        // Return the velocity of a given point on the body.
        inline Vector3 GetPointVelocity(const Vector3 &p) const;    // p in body space, result in world space

        // Apply a force to the body at the center of mass.
        inline void ApplyForce(const Vector3 &f);   // world space

        // Apply a force to the body at a given point.
        inline void ApplyForce(const Vector3 &f, const Vector3 &p); // f in world space, p in body space

        // Apply a torque around the center of mass.
        inline void ApplyTorque(const Vector3 &t);      // t in world space

        // Reset force and torque accumulators.
        inline void ZeroForce();
        inline void ZeroTorque();

        // Get back the total force and torque applied until yet.
        inline Vector3 GetTotalForce() const;   // world space
        inline Vector3 GetTotalTorque() const;  // world space

        // Apply a linear impulse (instantaneous change in linear velocity).
        inline void ApplyLinearImpulse(const Vector3 &j);   // world space

        // Apply an angular impulse (instantaneous change in angular velocity).
        inline void ApplyAngularImpulse(const Vector3 &j);  // world space

        // This is temporary, utility methods.
        inline void SetState(const StateVector &s);
        inline StateVector GetState() const;

        // This method will update the state of the body (the body
        // will move and/or rotate) even if the body is frozen.
        void EvolveOneStep(const StateDESolver &solver, Real t, Real h);

    private:
        // Mass. Constant over simulation.
        Real m_mass;

        // Inertia tensor. Constant over simulation.
        Matrix3 m_inertia;  // body space

        bool m_is_frozen;   // a frozen body can't move nor rotate

        StateVector m_state;

        class StateVectorDE : public IDE1<StateVector> {
            const RigidBody *m_parent;
        public:
            inline StateVectorDE(const RigidBody *parent);

            virtual StateVector GetDerivativeAt(const StateVector &x, Real t) const;
        };

        friend class StateVectorDE;

        // Differential equation of the body state.
        StateVectorDE *m_state_de;

        // Sum of the forces applied to the body, expressed at the center of mass.
        Vector3 m_total_force;  // world space

        // Sum of the torques applied to the body, expressed at the center of mass.
        Vector3 m_total_torque; // world space
    };

#include "rigidbody.inl"

}

#endif  // !SHEEP_DYNAMICS_RIGIDBODY_H

---