btRaycastVehicle.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 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 RAYCASTVEHICLE_H
#define RAYCASTVEHICLE_H

#include "BulletDynamics/Dynamics/btRigidBody.h"
#include "BulletDynamics/ConstraintSolver/btTypedConstraint.h"
#include "btVehicleRaycaster.h"
class btDynamicsWorld;
#include "LinearMath/btAlignedObjectArray.h"
#include "btWheelInfo.h"
#include "BulletDynamics/Dynamics/btActionInterface.h"

class btVehicleTuning;

class btRaycastVehicle : public btActionInterface
{

        btAlignedObjectArray<btVector3> m_forwardWS;
        btAlignedObjectArray<btVector3> m_axle;
        btAlignedObjectArray<btScalar>  m_forwardImpulse;
        btAlignedObjectArray<btScalar>  m_sideImpulse;
    
        int m_userConstraintType;
        int m_userConstraintId;

public:
    class btVehicleTuning
        {
            public:

            btVehicleTuning()
                :m_suspensionStiffness(btScalar(5.88)),
                m_suspensionCompression(btScalar(0.83)),
                m_suspensionDamping(btScalar(0.88)),
                m_maxSuspensionTravelCm(btScalar(500.)),
                m_frictionSlip(btScalar(10.5)),
                m_maxSuspensionForce(btScalar(6000.))
            {
            }
            btScalar    m_suspensionStiffness;
            btScalar    m_suspensionCompression;
            btScalar    m_suspensionDamping;
            btScalar    m_maxSuspensionTravelCm;
            btScalar    m_frictionSlip;
            btScalar    m_maxSuspensionForce;

        };
private:

    btScalar    m_tau;
    btScalar    m_damping;
    btVehicleRaycaster* m_vehicleRaycaster;
    btScalar        m_pitchControl;
    btScalar    m_steeringValue; 
    btScalar m_currentVehicleSpeedKmHour;

    btRigidBody* m_chassisBody;

    int m_indexRightAxis;
    int m_indexUpAxis;
    int m_indexForwardAxis;

    void defaultInit(const btVehicleTuning& tuning);

public:

    //constructor to create a car from an existing rigidbody
    btRaycastVehicle(const btVehicleTuning& tuning,btRigidBody* chassis,    btVehicleRaycaster* raycaster );

    virtual ~btRaycastVehicle() ;


    virtual void updateAction( btCollisionWorld* collisionWorld, btScalar step)
    {
        (void) collisionWorld;
        updateVehicle(step);
    }
    

    void    debugDraw(btIDebugDraw* debugDrawer);
            
    const btTransform& getChassisWorldTransform() const;
    
    btScalar rayCast(btWheelInfo& wheel);

    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 );
    
//  void    setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth);

    btWheelInfo&    addWheel( const btVector3& connectionPointCS0, const btVector3& wheelDirectionCS0,const btVector3& wheelAxleCS,btScalar suspensionRestLength,btScalar wheelRadius,const btVehicleTuning& tuning, bool isFrontWheel);

    inline int      getNumWheels() const {
        return int (m_wheelInfo.size());
    }
    
    btAlignedObjectArray<btWheelInfo>   m_wheelInfo;


    const btWheelInfo&  getWheelInfo(int index) const;

    btWheelInfo&    getWheelInfo(int index);

    void    updateWheelTransformsWS(btWheelInfo& wheel , bool interpolatedTransform = true);

    
    void setBrake(btScalar brake,int wheelIndex);

    void    setPitchControl(btScalar pitch)
    {
        m_pitchControl = pitch;
    }
    
    void    updateSuspension(btScalar deltaTime);

    virtual void    updateFriction(btScalar timeStep);



    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;
    }

    
    btVector3 getForwardVector() const
    {
        const btTransform& chassisTrans = getChassisWorldTransform(); 

        btVector3 forwardW ( 
              chassisTrans.getBasis()[0][m_indexForwardAxis], 
              chassisTrans.getBasis()[1][m_indexForwardAxis], 
              chassisTrans.getBasis()[2][m_indexForwardAxis]); 

        return forwardW;
    }

    btScalar    getCurrentSpeedKmHour() const
    {
        return m_currentVehicleSpeedKmHour;
    }

    virtual void    setCoordinateSystem(int rightIndex,int upIndex,int forwardIndex)
    {
        m_indexRightAxis = rightIndex;
        m_indexUpAxis = upIndex;
        m_indexForwardAxis = forwardIndex;
    }


    int getUserConstraintType() const
    {
        return m_userConstraintType ;
    }

    void    setUserConstraintType(int userConstraintType)
    {
        m_userConstraintType = userConstraintType;
    };

    void    setUserConstraintId(int uid)
    {
        m_userConstraintId = uid;
    }

    int getUserConstraintId() const
    {
        return m_userConstraintId;
    }

};

class btDefaultVehicleRaycaster : public btVehicleRaycaster
{
    btDynamicsWorld*    m_dynamicsWorld;
public:
    btDefaultVehicleRaycaster(btDynamicsWorld* world)
        :m_dynamicsWorld(world)
    {
    }

    virtual void* castRay(const btVector3& from,const btVector3& to, btVehicleRaycasterResult& result);

};


#endif //RAYCASTVEHICLE_H