joints.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_JOINTS_H
#define SHEEP_DYNAMICS_JOINTS_H

#include "common/math/findroot.h"
#include "common/math/matrix.h"
#include "common/math/real.h"
#include "common/math/vector.h"
#include "common/math/vector3.h"
#include "common/misc/htmlstream.h"
#include "engine/dynamics/rigidbody.h"

#include <cassert>
#include <list>

namespace sheep {

    //!\todo Rename as IJoint.
    class Joint {
    public:
        Joint(int dimension, int body_count);
        virtual ~Joint();

        inline int GetDimension() const;
        inline int GetBodyCount() const;

        inline RigidBody *GetBody(int n);

        inline Matrix *GetJ(const RigidBody *body) const;
        inline Vector *GetC() const;

        virtual void Update() = 0;

        virtual Real GetError() = 0;
        virtual void CorrectError() = 0;

    protected:
        int m_dimension;
        int m_body_count;

        RigidBody **m_bodies;

        Matrix **m_j;
        Matrix *m_zero;
        Vector *m_c;
    };

    class SphericalJoint : public Joint {
    public:
        // 'anchor1' and 'anchor2' are expressed in body space.
        SphericalJoint(RigidBody *body0, const Vector3 &anchor0,
            RigidBody *body1, const Vector3 &anchor1);

        virtual void Update();

        virtual Real GetError();
        virtual void CorrectError();

    private:
        Vector3 m_anchor0, m_anchor1;   // body space
    };

    //!\todo Modify to allow use of any piecewise curve.
    class FixedPathJoint : public Joint {
    public:
        // 'anchor' is expressed in body space. 'ccp' stands for
        // "Curve Control Points". Control points are expressed in
        // world space.
        FixedPathJoint(RigidBody *body, const Vector3 &anchor,
            const Vector3 *ccp, int nccp);
        inline virtual ~FixedPathJoint();

        virtual void Update();

        virtual Real GetError();
        virtual void CorrectError();

    private:
        Vector3 m_anchor;   // body space

        Vector3 *m_ccp;     // world space
        int m_nccp;

        class DistanceFunction : public Function1 { // actually, derivative of the distance function
        public:
            DistanceFunction(const Vector3 *q, const Vector3 &p);

            virtual Real EvaluateAt(Real x) const;

        private:
            Vector3 m_a, m_b, m_c, m_d;
            Vector3 m_p;
        };

        void project_on_curve(const Vector3 &p, int *seg, Real *t) const;
    };

    class JointManager {
    public:
        JointManager();

        void Insert(Joint *joint);
        void Remove(Joint *joint);

        void Setup();

        void ApplyContraints();

    private:
        HTMLStream *debug;

        typedef std::list<Joint *> joint_list;
        typedef std::list<RigidBody *> rigidbody_list;

        joint_list m_joints;

        rigidbody_list m_bodies;

        Matrix *m_invm;
        Matrix *m_j;
        Vector *m_c;
        Vector *m_fext;

        Matrix *m_a;
        Vector *m_b;
        Vector *m_lambda;
        Vector *m_f;
    };

#include "joints.inl"

}

#endif  // !SHEEP_DYNAMICS_JOINTS_H

---