True Axis Physics SDK 1.2.0.1 Beta Documentation
www.trueaxis.com

---

CarTemplate.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------
// File Name: CarTemplate.h
// Description:
//
// Copyright (C) 2004 - 2006 True Axis Pty Ltd, Australia. 
// All Rights Reserved.
//
// History:
//      Created File.
//---------------------------------------------------------------------------------


#ifndef TA_CARTEMPLATE_H
#define TA_CARTEMPLATE_H

#ifndef TA_REFCOUNT_H
#include "../Common/RefCount.h"
#endif // TA_REFCOUNT_H

#ifndef TA_VECTOR_H
#include "../Common/Vector.h"
#endif // TA_VECTOR_H

#ifndef TA_LIST_H
#include "../Common/List.h"
#endif // TA_LIST_H

#ifndef TA_ARRAY_H
#include "../Common/Array.h"
#endif // TA_ARRAY_H

#ifndef TA_PHYSICSCOMMON_H
#include "PhysicsCommon.h"
#endif // TA_PHYSICSCOMMON_H

TA_OBFUSCATION_SKIP_PASS_2

namespace TA
{

class CollisionObjectConvex;
class CollisionObjectCapsule;
class CollisionObjectCylinder;
class CollisionObjectSphere;
class CollisionObjectCombo;
class DynamicObjectCar;
class SurfaceAttribute;

class TAPHYSICS_CLASS CarTemplate : public RefCount
{
public:
    TA_OBFUSCATION_RESERVED_ON

    typedef float (TAC_CALL *FnTorqueCurve)(float fRadsPerSec);
    typedef float (TAC_CALL *FnSlipRatioToNormalisedTraction)(float fSlipRatio, const SurfaceAttribute& surfaceAttribute);
    typedef float (TAC_CALL *FnSlipAngleToLateralForce)(float fSlipAngle, float fLongitudinalSlipRatio, const SurfaceAttribute& surfaceAttribute);

    struct Wheel
    {
    public:
        Wheel();
        void Clear();

        void SetSuspensionTop(const Vec3& v3SuspensionTop);
        const Vec3& GetSuspensionTop() const;

        void SetSuspensionBottom(const Vec3& v3SuspensionBottom);
        const Vec3& GetSuspensionBottom() const;

        void SetRadius(float fRadius);
        float GetRadius() const;

        void SetInertia(float fInertia);
        float GetInertia() const;

        void SetBrakeTorque(float fBrakeTorque);
        float GetBrakeTorque() const;

        void SetRollResistance(float fRollResistance);
        float GetRollResistance() const;

        void SetSuspensionSpringConstant(float fSuspensionSpringConstant);
        float GetSuspensionSpringConstant() const;

        void SetSuspensionDampingConstant(float fSuspensionDampingConstant);
        float GetSuspensionDampingConstant() const;
        
        void SetSlipRatioToNormalisedTractionCallBack(FnSlipRatioToNormalisedTraction pCallBack);
        FnSlipRatioToNormalisedTraction GetSlipRatioToNormalisedTractionCallBack() const;
    
        void SetSlipAngleToLateralForceCallBack(FnSlipAngleToLateralForce pCallBack);
        FnSlipAngleToLateralForce GetSlipAngleToLateralForceCallBack() const;

        void SetSteeringFlag(bool bSteering);
        bool GetSteeringFlag() const;

        void SetDrivingFlag(bool bDriving);
        bool GetDrivingFlag() const;

        void SetHandBrakeFlag(bool bHandBrake);
        bool GetHandBrakeFlag() const;

        TA_OBFUSCATION_RESERVED_OFF
    private:

        Vec3 m_v3SuspensionTop;
        Vec3 m_v3SuspensionBottom;
        float m_fRadius;
        float m_fInertia;
        float m_fBrakeTorque;
        float m_fRollResistance;
        float m_fSuspensionSpringConstant;
        float m_fSuspensionDampingConstant;
        FnSlipRatioToNormalisedTraction m_pFnSlipRatioToNormalisedTraction;
        FnSlipAngleToLateralForce m_pFnSlipAngleToLateralForce;
        struct
        {
            bool bSteering      : 1;
            bool bDriving       : 1;
            bool bHandBrake     : 1;
        } m_flags;
    };
    TA_OBFUSCATION_RESERVED_ON

    void BeginInitialise();
    void EndInitialise();
    void Finalise();

    void AddCollisionObject(CollisionObjectConvex* pCollisionObject);
    void AddCollisionObject(CollisionObjectCapsule* pCollisionObject);
    void AddCollisionObject(CollisionObjectCylinder* pCollisionObject);
    void AddCollisionObject(CollisionObjectSphere* pCollisionObject);

    void AddWheel(const Wheel& wheel);

    void SetOrientation(const Vec3& v3Forward, const Vec3& v3Up);
    const Vec3& GetForward() const;
    const Vec3& GetUp() const;

    int GetNumGears() const;
    void SetNumGears(int nNumGears);
    void SetGearRatio(int nIndex, float fGearRatio);
    float GetGearRatio(int nIndex) const;

    void SetDifferentialRatio(float fDifferentialRatio);
    float GetDifferentialRatio() const;

    void SetMass(float fMass);
    float GetMass() const;

    void SetTransmissionEfficiency(float fTransmissionEfficiency);
    float GetTransmissionEfficiency() const;

    void SetTorqueMultiplier(float fTorqueMultiplier);
    float GetTorqueMultiplier() const;
    void SetTorqueCurve(FnTorqueCurve pFnTorqueCurve);

    void SetAirResistance(float fAirResistance);
    float GetAirResistance() const;

    void SetDownForce(float fDownForce);
    float GetDownForce() const;

    void SetAntiRollFudge(float fAntiRollFudge);
    float GetAntiRollFudge() const;

    static CarTemplate* TAC_CALL CreateNew();
    static float TAC_CALL StandardTorqueCurve(float fRadsPerSec);
    static float TAC_CALL StandardSlipRatioToNormalisedTraction(float fSlipRatio, const SurfaceAttribute& surfaceAttribute);
    static float TAC_CALL StandardSlipAngleToLateralForce(float fSlipAngle, float fLongitudinalSlipRatio, const SurfaceAttribute& surfaceAttribute);


protected:
    CarTemplate();
    ~CarTemplate();

    TA_OBFUSCATION_RESERVED_OFF

private:
    friend class DynamicObjectCar;

    bool m_bInitialising;
    CollisionObjectCombo* m_pCollisionObjectCombo;
    float m_fDifferentialRatio;
    float m_fMass;
    float m_fTransmissionEfficiency;
    float m_fTorqueMultiplier;
    FnTorqueCurve m_pFnTorqueCurve;
    float m_fAirResistance;
    float m_fDownForce;
    float m_fAntiRollFudge;
    List<Wheel> m_wheelList;
    Array<float> m_gearArray;
    Vec3 m_v3Forward;
    Vec3 m_v3Up;

    void Zero();
};

}

#include "CarTemplate.inl"

#endif // TA_CARTEMPLATE_H

---

© Copyright 2004-2006 TRUE AXIS PTY LTD Australia. All rights reserved.