physical_object.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_PHYSICAL_OBJECT_HPP
#define HEADER_PHYSICAL_OBJECT_HPP
 
#include <string>
 
#include "btBulletDynamicsCommon.h"
 
#include "network/rewinder.hpp"
#include "network/smooth_network_body.hpp"
#include "physics/user_pointer.hpp"
#include "utils/vec3.hpp"
 
class Material;
class TrackObject;
class XMLNode;
 
class PhysicalObject : public Rewinder,
                       public SmoothNetworkBody
{
public:
    enum BodyTypes {MP_NONE,
                    MP_CONE_Y, MP_CONE_X, MP_CONE_Z,
                    MP_CYLINDER_Y, MP_CYLINDER_X, MP_CYLINDER_Z,
                    MP_BOX, MP_SPHERE, MP_EXACT};
 
    class Settings
    {
    public:
        std::string               m_id;
        float                     m_mass;
        float                     m_radius;
        float                     m_height;
        PhysicalObject::BodyTypes m_body_type;
        float                     m_restitution;
        float                     m_friction;
        Vec3                      m_linear_factor;
        Vec3                      m_angular_factor;
        float                     m_linear_damping;
        float                     m_angular_damping;
 
        bool                      m_crash_reset;
        bool                      m_knock_kart;
        bool                      m_flatten_kart;
        bool                      m_reset_when_too_low;
        float                     m_reset_height;
        std::string               m_on_kart_collision;
        std::string               m_on_item_collision;
    private:
        void init();
    public:
        Settings(BodyTypes type, float radius, float mass);
        Settings(const XMLNode &xml_node);
    };   // Settings
 
private:
 
    core::vector3df       m_init_xyz;
 
    core::vector3df       m_init_hpr;
 
    core::vector3df       m_init_scale;
 
    TrackObject          *m_object;
 
    BodyTypes             m_body_type;
 
    btCollisionShape     *m_shape;
 
    std::string           m_id;
 
    btRigidBody          *m_body;
 
    btDefaultMotionState *m_motion_state;
 
    float                 m_mass;
 
    bool                  m_body_added;
 
    UserPointer           m_user_pointer;
 
    btTransform           m_init_pos;
 
    btTransform           m_current_transform;
 
    Vec3                  m_graphical_offset;
 
    float                 m_radius;
 
    bool                  m_crash_reset;
 
    bool                  m_explode_kart;
 
    bool                  m_flatten_kart;
 
    bool                  m_reset_when_too_low;
 
    float                 m_reset_height;
    std::string           m_on_kart_collision;
    std::string           m_on_item_collision;
    bool                  m_is_dynamic;
 
    TriangleMesh         *m_triangle_mesh;
 
    /* Last transform and velocities recieved or saved for networking */
    btTransform           m_last_transform;
    Vec3                  m_last_lv;
    Vec3                  m_last_av;
 
    /* Used to determine if local state should be used, which is true
     * when the object is not moving */
    bool                  m_no_server_state;
 
    void copyFromMainProcess(TrackObject* track_obj);
public:
                    PhysicalObject(bool is_dynamic, const Settings& settings,
                                   TrackObject* object);
 
    static std::shared_ptr<PhysicalObject> fromXML
        (bool is_dynamic, const XMLNode &node, TrackObject* object);
 
    virtual     ~PhysicalObject ();
    virtual void reset          ();
    virtual void handleExplosion(const Vec3& pos, bool directHit);
    void         update         (float dt);
    void         updateGraphics (float dt);
    void         init           (const Settings &settings);
    void         move           (const Vec3& xyz, const core::vector3df& hpr);
    void         hit            (const Material *m, const Vec3 &normal);
    bool         isSoccerBall   () const;
    bool castRay(const btVector3 &from,
                 const btVector3 &to, btVector3 *hit_point,
                 const Material **material, btVector3 *normal,
                 bool interpolate_normal) const;
 
    // ------------------------------------------------------------------------
    bool isDynamic() const { return m_is_dynamic; }
    // ------------------------------------------------------------------------
    std::string getID()          { return m_id; }
    // ------------------------------------------------------------------------
    btDefaultMotionState* getMotionState() const { return m_motion_state; }
    // ------------------------------------------------------------------------
    btRigidBody* getBody() const  { return m_body; }
    // ------------------------------------------------------------------------
    bool isCrashReset() const { return m_crash_reset; }
    // ------------------------------------------------------------------------
    bool isExplodeKartObject () const { return m_explode_kart; }
    // ------------------------------------------------------------------------
    void setInteraction(std::string interaction);
    // ------------------------------------------------------------------------
    void removeBody();
    // ------------------------------------------------------------------------
    void addBody();
    // ------------------------------------------------------------------------
    float getRadius() const { return m_radius; }
    // ------------------------------------------------------------------------
    const std::string& getOnKartCollisionFunction() const { return m_on_kart_collision; }
    // ------------------------------------------------------------------------
    const std::string& getOnItemCollisionFunction() const { return m_on_item_collision; }
    // ------------------------------------------------------------------------
    TrackObject* getTrackObject() { return m_object; }
 
    // Methods usable by scripts
 
    bool isFlattenKartObject() const { return m_flatten_kart; }
    void disable(void *memory)
    {
        ((PhysicalObject*)(memory))->removeBody();
    }
 
    //enables track object passed from the script
    void enable(void *memory)
    {
        ((PhysicalObject*)(memory))->addBody();
    }
    void addForRewind();
    virtual void saveTransform();
    virtual void computeError();
    virtual BareNetworkString* saveState(std::vector<std::string>* ru);
    virtual void undoEvent(BareNetworkString *buffer) {}
    virtual void rewindToEvent(BareNetworkString *buffer) {}
    virtual void restoreState(BareNetworkString *buffer, int count);
    virtual void undoState(BareNetworkString *buffer) {}
    virtual std::function<void()> getLocalStateRestoreFunction();
    bool hasTriangleMesh() const { return m_triangle_mesh != NULL; }
    void joinToMainTrack();
    std::shared_ptr<PhysicalObject> clone(TrackObject* track_obj)
    {
        PhysicalObject* obj = new PhysicalObject(*this);
        obj->copyFromMainProcess(track_obj);
        return std::shared_ptr<PhysicalObject>(obj);
    }
};  // PhysicalObject
 
#endif
/* EOF */