btKart.hpp

/*
 * Copyright (C) 2005-2015 Erwin Coumans http://continuousphysics.com/Bullet/
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies.
 * Erwin Coumans makes no representations about the suitability
 * of this software for any purpose.
 * It is provided "as is" without express or implied warranty.
*/
#ifndef BT_KART_HPP
#define BT_KART_HPP
 
#include "BulletDynamics/Dynamics/btRigidBody.h"
#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
#include "physics/btKartRaycast.hpp"
class btDynamicsWorld;
#include "LinearMath/btAlignedObjectArray.h"
#include "BulletDynamics/Vehicle/btWheelInfo.h"
#include "BulletDynamics/Dynamics/btActionInterface.h"
 
#include "config/stk_config.hpp"
 
class btVehicleTuning;
class Kart;
struct btWheelContactPoint;
 
class btKart : public btActionInterface
{
public:
    class btVehicleTuning
    {
    public:
 
        btVehicleTuning()
            :m_suspensionStiffness(btScalar(5.88)),
             m_suspensionCompression(btScalar(0.83)),
             m_suspensionDamping(btScalar(0.88)),
             m_maxSuspensionTravel(btScalar(5.)),
             m_frictionSlip(btScalar(10.5)),
             m_maxSuspensionForce(btScalar(6000.))
        {
        }   // btVehicleTuning
 
        btScalar    m_suspensionStiffness;
        btScalar    m_suspensionCompression;
        btScalar    m_suspensionDamping;
        btScalar    m_maxSuspensionTravel;
        btScalar    m_frictionSlip;
        btScalar    m_maxSuspensionForce;
 
    };   // class btVehicleTuning
 
private:
 
    btAlignedObjectArray<btVector3> m_forwardWS;
    btAlignedObjectArray<btVector3> m_axle;
    btAlignedObjectArray<btScalar>  m_forwardImpulse;
    btAlignedObjectArray<btScalar>  m_sideImpulse;
 
    int m_userConstraintType;
    int m_userConstraintId;
 
    static btRigidBody& getFixedBody();
    btScalar calcRollingFriction(btWheelContactPoint& contactPoint);
 
    btScalar            m_damping;
    btVehicleRaycaster *m_vehicleRaycaster;
 
    bool                m_allow_sliding;
 
    btVector3           m_additional_impulse;
 
    uint16_t            m_ticks_additional_impulse;
 
    float               m_additional_rotation;
 
    uint16_t            m_ticks_additional_rotation;
 
    btRigidBody        *m_chassisBody;
 
    btRigidBody         m_fixed_body;
 
    int                 m_num_wheels_on_ground;
 
    int                 m_indexRightAxis;
    int                 m_indexUpAxis;
    int                 m_indexForwardAxis;
 
    Kart               *m_kart;
 
    btScalar m_min_speed;
 
    btScalar m_max_speed;
 
    bool m_visual_wheels_touch_ground;
 
    btAlignedObjectArray<btWheelInfo> m_wheelInfo;
 
    void     defaultInit();
    btScalar rayCast(btWheelInfo& wheel, const btVector3& ray);
    void     updateWheelTransformsWS(btWheelInfo& wheel,
                                     btTransform chassis_trans,
                                     bool interpolatedTransform=true,
                                     float fraction = 1.0f);
 
public:
 
                       btKart(btRigidBody* chassis,
                              btVehicleRaycaster* raycaster,
                              Kart *kart);
     virtual          ~btKart();
    void               reset();
    void               debugDraw(btIDebugDraw* debugDrawer);
    const btTransform& getChassisWorldTransform() const;
    btScalar           rayCast(unsigned int index, float fraction=1.0f);
    virtual void       updateVehicle(btScalar step);
    void               resetSuspension();
    btScalar           getSteeringValue(int wheel) const;
    void               setSteeringValue(btScalar steering,int wheel);
    void               applyEngineForce(btScalar force, int wheel);
    const btTransform& getWheelTransformWS( int wheelIndex ) const;
    void               updateWheelTransform(int wheelIndex,
                                            bool interpolatedTransform=true);
    btWheelInfo&       addWheel(const btVector3& connectionPointCS0,
                                const btVector3& wheelDirectionCS0,
                                const btVector3& wheelAxleCS,
                                btScalar suspensionRestLength,
                                btScalar wheelRadius,
                                const btVehicleTuning& tuning,
                                bool isFrontWheel);
    const btWheelInfo& getWheelInfo(int index) const;
    btWheelInfo&       getWheelInfo(int index);
    void               updateAllWheelTransformsWS();
    void               setAllBrakes(btScalar brake);
    void               updateSuspension(btScalar deltaTime);
    virtual void       updateFriction(btScalar timeStep);
    void               setSliding(bool active);
    void               instantSpeedIncreaseTo(btScalar speed);
    void               adjustSpeed(btScalar min_speed, btScalar max_speed);
    void               updateAllWheelPositions();
    void               getVisualContactPoint(const btTransform& chassis_trans,
                                             btVector3 *left, btVector3 *right);
        // ------------------------------------------------------------------------
    bool visualWheelsTouchGround() const
    {
        return m_visual_wheels_touch_ground;
    }   // visualWheelsTouchGround
    // ------------------------------------------------------------------------
    virtual void updateAction(btCollisionWorld* collisionWorld,
                              btScalar step)
    {
        (void) collisionWorld;
        updateVehicle(step);
    }   // updateAction
    // ------------------------------------------------------------------------
    inline int getNumWheels() const { return int(m_wheelInfo.size());}
    // ------------------------------------------------------------------------
    inline btRigidBody* getRigidBody() { return m_chassisBody; }
    // ------------------------------------------------------------------------
    const btRigidBody* getRigidBody() const { return m_chassisBody; }
    // ------------------------------------------------------------------------
    inline int getRightAxis() const { return m_indexRightAxis; }
    // ------------------------------------------------------------------------
    inline int getUpAxis() const { return m_indexUpAxis; }
    // ------------------------------------------------------------------------
    inline int getForwardAxis() const { return m_indexForwardAxis; }
    // ------------------------------------------------------------------------
    int getUserConstraintType() const { return m_userConstraintType ; }
    // ------------------------------------------------------------------------
    void setUserConstraintType(int userConstraintType)
    {
        m_userConstraintType = userConstraintType;
    }   // setUserConstraintType
    // ------------------------------------------------------------------------
    void setUserConstraintId(int uid) { m_userConstraintId = uid; }
    // ------------------------------------------------------------------------
    int getUserConstraintId() const { return m_userConstraintId; }
    // ------------------------------------------------------------------------
    unsigned int getNumWheelsOnGround() const {return m_num_wheels_on_ground;}
    // ------------------------------------------------------------------------
    void setTimedCentralImpulse(uint16_t t, const btVector3 &imp,
                                bool rewind = false)
    {
        // Only add impulse if no other impulse is active.
        if (m_ticks_additional_impulse > 0 && !rewind) return;
        m_additional_impulse      = imp;
        m_ticks_additional_impulse = t;
    }   // setTimedImpulse
    // ------------------------------------------------------------------------
    uint16_t getCentralImpulseTicks() const
                                         { return m_ticks_additional_impulse; }
    // ------------------------------------------------------------------------
    const btVector3& getAdditionalImpulse() const
                                               { return m_additional_impulse; }
    // ------------------------------------------------------------------------
    void setTimedRotation(uint16_t t, float rot_in_y_axis)
    {
        if (t > 0)
        {
            m_additional_rotation =
                rot_in_y_axis / (stk_config->ticks2Time(t));
        }
        m_ticks_additional_rotation = t;
    }   // setTimedTorque
    // ------------------------------------------------------------------------
    float getTimedRotation() const            { return m_additional_rotation; }
    // ------------------------------------------------------------------------
    uint16_t getTimedRotationTicks() const
                                        { return m_ticks_additional_rotation; }
    // ------------------------------------------------------------------------
    void setMaxSpeed(float new_max_speed) 
    {
        // Only change m_max_speed if it has not been set (<0), or
        // the new value is smaller than the current maximum. For example,
        // overworld will set the max_speed to 0 in case of teleporting to
        // a bubble, but set it again later (based on zipper etc activated).
        // We need to make sure that the 0 is maintained.
        if(m_max_speed <0 || m_max_speed > new_max_speed)
            m_max_speed = new_max_speed;
    }   // setMaxSpeed
    // ------------------------------------------------------------------------
    virtual void resetMaxSpeed() { m_max_speed = -1.0f; m_min_speed = 0.0f; }
    // ------------------------------------------------------------------------
    void setMinSpeed(float s)
    {
        if(s > m_min_speed) m_min_speed = s; 
    }
    // ------------------------------------------------------------------------
    btScalar getMinSpeed() const { return m_min_speed; }
};   // class btKart
 
#endif //BT_KART_HPP