physics.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2006-2015 Joerg Henrichs
//
//  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.
//
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HEADER_PHYSICS_HPP
#define HEADER_PHYSICS_HPP

#include <set>
#include <vector>

#include "btBulletDynamicsCommon.h"

#include "physics/irr_debug_drawer.hpp"
#include "physics/stk_dynamics_world.hpp"
#include "physics/user_pointer.hpp"
#include "utils/singleton.hpp"

class AbstractKart;
class STKDynamicsWorld;
class Vec3;

class Physics : public btSequentialImpulseConstraintSolver
              , public AbstractSingleton<Physics>
{
private:
    class CollisionPair
    {
    private:
        const UserPointer *m_up[2];

        Vec3               m_contact_point[2];
    public:
        CollisionPair(const UserPointer *a, const btVector3 &contact_point_a,
                      const UserPointer *b, const btVector3 &contact_point_b)
        {
            if(a->is(UserPointer::UP_KART) &&
               b->is(UserPointer::UP_KART) && a>b) {
                m_up[0]=b; m_contact_point[0] = contact_point_b;
                m_up[1]=a; m_contact_point[1] = contact_point_a;
            } else {
                m_up[0]=a; m_contact_point[0] = contact_point_a;
                m_up[1]=b; m_contact_point[1] = contact_point_b;
            }
        };  //    CollisionPair
        // --------------------------------------------------------------------
        bool operator==(const CollisionPair &p)
        {
            return (p.m_up[0]==m_up[0] && p.m_up[1]==m_up[1]);
        }   // operator==
        // --------------------------------------------------------------------
        const UserPointer *getUserPointer(unsigned int n) const
        {
            assert(n<=1);
            return m_up[n];
        }   // getUserPointer
        // --------------------------------------------------------------------
        const Vec3 &getContactPointCS(unsigned int n) const
        {
            assert(n>=0 && n<=1);
            return m_contact_point[n];
        }   // getContactPointCS
    };  // CollisionPair

    // ========================================================================
    // This class is the list of collision objects, where each collision
    // pair is stored as most once.
    class CollisionList : public std::vector<CollisionPair>
    {
    private:
        void push_back(CollisionPair p) {
            // only add a pair if it's not already in there
            for(iterator i=begin(); i!=end(); i++) {
                if((*i)==p) return;
            }
            std::vector<CollisionPair>::push_back(p);
        };  // push_back
    public:
        void push_back(const UserPointer *a, const btVector3 &contact_point_a,
                       const UserPointer *b, const btVector3 &contact_point_b)
        {
            push_back(CollisionPair(a, contact_point_a, b, contact_point_b));
        }
    };  // CollisionList
    // ========================================================================

    bool               m_physics_loop_active;

    std::vector<const AbstractKart*> m_karts_to_delete;

    STKDynamicsWorld                *m_dynamics_world;

    IrrDebugDrawer                  *m_debug_drawer;

    btCollisionDispatcher           *m_dispatcher;
    btBroadphaseInterface           *m_axis_sweep;
    btDefaultCollisionConfiguration *m_collision_conf;
    CollisionList                    m_all_collisions;

    static Physics                  *m_physics;

             Physics();
    virtual ~Physics();

    // Give the singleton access to the constructor
    friend class AbstractSingleton<Physics>;

public:
    void  init             (const Vec3 &min_world, const Vec3 &max_world);
    void  addKart          (const AbstractKart *k);
    void  addBody          (btRigidBody* b) {m_dynamics_world->addRigidBody(b);}
    void  removeKart       (const AbstractKart *k);
    void  removeBody       (btRigidBody* b) {m_dynamics_world->removeRigidBody(b);}
    void  KartKartCollision(AbstractKart *ka, const Vec3 &contact_point_a,
                            AbstractKart *kb, const Vec3 &contact_point_b);
    void  update           (int ticks);
    void  draw             ();
    STKDynamicsWorld*
          getPhysicsWorld  () const {return m_dynamics_world;}
    void  nextDebugMode    () {m_debug_drawer->nextDebugMode(); }
    void  setDebugMode(IrrDebugDrawer::DebugModeType mode) { m_debug_drawer->setDebugMode(mode); }
    bool  isDebug() const     {return m_debug_drawer->debugEnabled(); }
    IrrDebugDrawer* getDebugDrawer() { return m_debug_drawer; }
    virtual btScalar solveGroup(btCollisionObject** bodies, int numBodies,
                                btPersistentManifold** manifold,int numManifolds,
                                btTypedConstraint** constraints,int numConstraints,
                                const btContactSolverInfo& info,
                                btIDebugDraw* debugDrawer, btStackAlloc* stackAlloc,
                                btDispatcher* dispatcher);
};

#endif // HEADER_PHYSICS_HPP