PxVehicleComponents.h

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2022 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
 
#ifndef PX_VEHICLE_COMPONENTS_H
#define PX_VEHICLE_COMPONENTS_H
 
#include "foundation/PxMemory.h"
#include "foundation/PxVec3.h"
#include "common/PxCoreUtilityTypes.h"
#include "vehicle/PxVehicleSDK.h"
#include "common/PxTypeInfo.h"
 
#if !PX_DOXYGEN
namespace physx
{
#endif
 
class PX_DEPRECATED PxVehicleChassisData
{
public:
 
    friend class PxVehicleDriveSimData4W;
 
    PxVehicleChassisData()
        :   mMOI(PxVec3(0,0,0)),
            mMass(1500),
            mCMOffset(PxVec3(0,0,0))
    {
    }
 
    PxVec3 mMOI;
 
    PxReal mMass;
 
    PxVec3 mCMOffset;
 
private:
 
    PxReal pad;
 
    bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleChassisData)& 0x0f));
 
class PX_DEPRECATED PxVehicleEngineData
{
public:
 
    friend class PxVehicleDriveSimData;
    
    enum
    {
        eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES = 8
    };
 
    PxVehicleEngineData()
        :   mMOI(1.0f),
            mPeakTorque(500.0f),
            mMaxOmega(600.0f),
            mDampingRateFullThrottle(0.15f),
            mDampingRateZeroThrottleClutchEngaged(2.0f),
            mDampingRateZeroThrottleClutchDisengaged(0.35f)
    {
        mTorqueCurve.addPair(0.0f, 0.8f);
        mTorqueCurve.addPair(0.33f, 1.0f);
        mTorqueCurve.addPair(1.0f, 0.8f);
 
        mRecipMOI=1.0f/mMOI;
        mRecipMaxOmega=1.0f/mMaxOmega;
    }
 
    PxFixedSizeLookupTable<eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES> mTorqueCurve;
 
    PxReal mMOI;
 
    PxReal mPeakTorque;
 
    PxReal mMaxOmega;
 
    PxReal mDampingRateFullThrottle;
 
 
    PxReal mDampingRateZeroThrottleClutchEngaged;
 
    PxReal mDampingRateZeroThrottleClutchDisengaged;
 
    PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
 
    PX_FORCE_INLINE PxReal getRecipMaxOmega() const {return mRecipMaxOmega;}
 
private:
 
    PxReal mRecipMOI;
 
    PxReal mRecipMaxOmega;
 
    bool isValid() const;
 
 
//serialization
public:
    PxVehicleEngineData(const PxEMPTY) : mTorqueCurve(PxEmpty) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleEngineData)& 0x0f));
 
class PX_DEPRECATED PxVehicleGearsData
{
public:
 
    friend class PxVehicleDriveSimData;
 
    enum Enum
    {
        eREVERSE=0,
        eNEUTRAL,
        eFIRST,
        eSECOND,
        eTHIRD,
        eFOURTH,
        eFIFTH,
        eSIXTH,
        eSEVENTH,
        eEIGHTH,
        eNINTH,
        eTENTH,
        eELEVENTH,
        eTWELFTH,
        eTHIRTEENTH,
        eFOURTEENTH,
        eFIFTEENTH,
        eSIXTEENTH,
        eSEVENTEENTH,
        eEIGHTEENTH,
        eNINETEENTH,
        eTWENTIETH,
        eTWENTYFIRST,
        eTWENTYSECOND,
        eTWENTYTHIRD,
        eTWENTYFOURTH,
        eTWENTYFIFTH,
        eTWENTYSIXTH,
        eTWENTYSEVENTH,
        eTWENTYEIGHTH,
        eTWENTYNINTH,
        eTHIRTIETH,
        eGEARSRATIO_COUNT
    };
 
    PxVehicleGearsData()
        :   mFinalRatio(4.0f),
            mNbRatios(7),
            mSwitchTime(0.5f)
    {
        mRatios[PxVehicleGearsData::eREVERSE]=-4.0f;
        mRatios[PxVehicleGearsData::eNEUTRAL]=0.0f;
        mRatios[PxVehicleGearsData::eFIRST]=4.0f;
        mRatios[PxVehicleGearsData::eSECOND]=2.0f;
        mRatios[PxVehicleGearsData::eTHIRD]=1.5f;
        mRatios[PxVehicleGearsData::eFOURTH]=1.1f;
        mRatios[PxVehicleGearsData::eFIFTH]=1.0f;
        
        for(PxU32 i = PxVehicleGearsData::eSIXTH; i < PxVehicleGearsData::eGEARSRATIO_COUNT; ++i)
            mRatios[i]=0.f;
    }
    
    PxReal mRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
 
    PxReal mFinalRatio;
 
    PxU32 mNbRatios;
    
    PxReal mSwitchTime;
    
private:
 
    PxReal mPad;
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleGearsData(const PxEMPTY) {}
    PxReal getGearRatio(PxVehicleGearsData::Enum a)  const {return mRatios[a];}
    void setGearRatio(PxVehicleGearsData::Enum a, PxReal ratio)   { mRatios[a] = ratio;}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleGearsData)& 0x0f));
 
class PX_DEPRECATED PxVehicleAutoBoxData
{
public:
 
    friend class PxVehicleDriveSimData;
 
    PxVehicleAutoBoxData()
    {
        for(PxU32 i=0;i<PxVehicleGearsData::eGEARSRATIO_COUNT;i++)
        {
            mUpRatios[i]=0.65f;
            mDownRatios[i]=0.50f;
        }
        //Not sure how important this is but we want to kick out of neutral very quickly.
        mUpRatios[PxVehicleGearsData::eNEUTRAL]=0.15f;
        //Set the latency time in an unused element of one of the arrays.
        mDownRatios[PxVehicleGearsData::eREVERSE]=2.0f; 
    }
    
    PxReal mUpRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
 
    PxReal mDownRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
 
    void setLatency(const PxReal latency) 
    { 
        mDownRatios[PxVehicleGearsData::eREVERSE]=latency;
    }
 
    PxReal getLatency() const 
    { 
        return mDownRatios[PxVehicleGearsData::eREVERSE];
    }
 
private:
    bool isValid() const;
 
//serialization
public:
    PxVehicleAutoBoxData(const PxEMPTY) {}
    
    PxReal getUpRatios(PxVehicleGearsData::Enum a)  const {return mUpRatios[a];}
    void setUpRatios(PxVehicleGearsData::Enum a, PxReal ratio)   { mUpRatios[a] = ratio;}
 
    PxReal getDownRatios(PxVehicleGearsData::Enum a)  const {return mDownRatios[a];}
    void setDownRatios(PxVehicleGearsData::Enum a, PxReal ratio)   { mDownRatios[a] = ratio;}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAutoBoxData)& 0x0f));
 
class PX_DEPRECATED PxVehicleDifferential4WData
{
public:
 
    friend class PxVehicleDriveSimData4W;
 
    enum Enum
    {
        eDIFF_TYPE_LS_4WD,          //limited slip differential for car with 4 driven wheels
        eDIFF_TYPE_LS_FRONTWD,      //limited slip differential for car with front-wheel drive
        eDIFF_TYPE_LS_REARWD,       //limited slip differential for car with rear-wheel drive
        eDIFF_TYPE_OPEN_4WD,        //open differential for car with 4 driven wheels 
        eDIFF_TYPE_OPEN_FRONTWD,    //open differential for car with front-wheel drive
        eDIFF_TYPE_OPEN_REARWD,     //open differential for car with rear-wheel drive
        eMAX_NB_DIFF_TYPES
    };
 
    PxVehicleDifferential4WData()
        :   mFrontRearSplit(0.45f),
            mFrontLeftRightSplit(0.5f),
            mRearLeftRightSplit(0.5f),
            mCentreBias(1.3f),
            mFrontBias(1.3f),
            mRearBias(1.3f),
            mType(PxVehicleDifferential4WData::eDIFF_TYPE_LS_4WD)
    {
    }
 
    PxReal mFrontRearSplit;
 
    PxReal mFrontLeftRightSplit;
 
    PxReal mRearLeftRightSplit;
 
    PxReal mCentreBias;
 
    PxReal mFrontBias;
 
    PxReal mRearBias;
 
    PxVehicleDifferential4WData::Enum mType;
 
private:
 
    PxReal mPad[1];
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleDifferential4WData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferential4WData)& 0x0f));
 
class PX_DEPRECATED PxVehicleDifferentialNWData
{
public:
 
    friend class PxVehicleDriveSimDataNW;
    friend class PxVehicleUpdate;
 
    PxVehicleDifferentialNWData()
    {
        PxMemSet(mBitmapBuffer, 0, sizeof(PxU32) * (((PX_MAX_NB_WHEELS + 31) & ~31) >> 5));
        mNbDrivenWheels=0;
        mInvNbDrivenWheels=0.0f;
    }
 
    void setDrivenWheel(const PxU32 wheelId, const bool drivenState);
 
    bool getIsDrivenWheel(const PxU32 wheelId) const;
 
private:
 
    PxU32 mBitmapBuffer[((PX_MAX_NB_WHEELS + 31) & ~31) >> 5];
    PxU32 mNbDrivenWheels;
    PxReal mInvNbDrivenWheels;
    PxU32 mPad;
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleDifferentialNWData(const PxEMPTY) {}
    PxU32 getDrivenWheelStatus() const;
    void setDrivenWheelStatus(PxU32 status);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferentialNWData)& 0x0f));
 
 
class PX_DEPRECATED PxVehicleAckermannGeometryData
{
public:
 
    friend class PxVehicleDriveSimData4W;
 
    PxVehicleAckermannGeometryData()
        :   mAccuracy(1.0f),
            mFrontWidth(0.0f),      //Must be filled out 
            mRearWidth(0.0f),       //Must be filled out
            mAxleSeparation(0.0f)   //Must be filled out
    {
    }
 
    PxReal mAccuracy;
 
    PxReal mFrontWidth;     
 
    PxReal mRearWidth;      
 
    PxReal mAxleSeparation; 
 
private:
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleAckermannGeometryData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAckermannGeometryData)& 0x0f));
 
struct PX_DEPRECATED PxVehicleClutchAccuracyMode
{
    enum Enum
    {
        eESTIMATE = 0,
        eBEST_POSSIBLE
    };
};
 
class PX_DEPRECATED PxVehicleClutchData
{
public:
 
    friend class PxVehicleDriveSimData;
 
    PxVehicleClutchData()
        :   mStrength(10.0f),
            mAccuracyMode(PxVehicleClutchAccuracyMode::eBEST_POSSIBLE),
            mEstimateIterations(5)
    {
    }
 
    PxReal mStrength;
 
    PxVehicleClutchAccuracyMode::Enum mAccuracyMode;
 
    PxU32 mEstimateIterations;
 
private:
 
    PxU8 mPad[4];
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleClutchData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleClutchData)& 0x0f));
 
 
class PX_DEPRECATED PxVehicleTireLoadFilterData
{
public:
 
    friend class PxVehicleWheelsSimData;
 
    PxVehicleTireLoadFilterData()
        :   mMinNormalisedLoad(0),
            mMinFilteredNormalisedLoad(0.2308f),
            mMaxNormalisedLoad(3.0f),
            mMaxFilteredNormalisedLoad(3.0f)
    {
        mDenominator=1.0f/(mMaxNormalisedLoad - mMinNormalisedLoad);
    }
 
    PxReal mMinNormalisedLoad; 
 
    PxReal mMinFilteredNormalisedLoad; 
 
    PxReal mMaxNormalisedLoad;
        
    PxReal mMaxFilteredNormalisedLoad;
 
    PX_FORCE_INLINE PxReal getDenominator() const {return mDenominator;}
 
private:
 
    //1.0f/(mMaxNormalisedLoad-mMinNormalisedLoad) for quick calculations
    PxReal mDenominator;
 
    PxU32 mPad[3];
 
    bool isValid() const;
 
//serialization
public:
    PxVehicleTireLoadFilterData(const PxEMPTY) {}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireLoadFilterData)& 0x0f));
 
class PX_DEPRECATED PxVehicleWheelData
{
public:
 
    friend class PxVehicleWheels4SimData;
 
    PxVehicleWheelData()
        :   mRadius(0.0f),              //Must be filled out
            mWidth(0.0f),
            mMass(20.0f),
            mMOI(0.0f),                 //Must be filled out
            mDampingRate(0.25f),
            mMaxBrakeTorque(1500.0f),
            mMaxHandBrakeTorque(0.0f),  
            mMaxSteer(0.0f),            
            mToeAngle(0.0f),
            mRecipRadius(0.0f),         //Must be filled out
            mRecipMOI(0.0f)             //Must be filled out
    {
    }
 
    PxReal mRadius;
 
    PxReal mWidth;
 
    PxReal mMass;
 
    PxReal mMOI;
 
    PxReal mDampingRate;
 
    PxReal mMaxBrakeTorque;
 
    PxReal mMaxHandBrakeTorque;
 
    PxReal mMaxSteer;
 
    PxReal mToeAngle;//in radians
 
    PX_FORCE_INLINE PxReal getRecipRadius() const {return mRecipRadius;}
 
    PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
 
private:
 
    PxReal mRecipRadius;
 
    PxReal mRecipMOI;
 
    PxReal mPad[1];
 
    bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelData)& 0x0f));
 
class PX_DEPRECATED PxVehicleSuspensionData
{
public:
 
    friend class PxVehicleWheels4SimData;
 
    PxVehicleSuspensionData()
        :   mSpringStrength(0.0f),
            mSpringDamperRate(0.0f),
            mMaxCompression(0.3f),
            mMaxDroop(0.1f),
            mSprungMass(0.0f),
            mCamberAtRest(0.0f),
            mCamberAtMaxCompression(0.0f),
            mCamberAtMaxDroop(0.0f),
            mRecipMaxCompression(1.0f),
            mRecipMaxDroop(1.0f)
    {
    }
    
    PxReal mSpringStrength;
 
    PxReal mSpringDamperRate;
 
    PxReal mMaxCompression;
 
    PxReal mMaxDroop;
 
    PxReal mSprungMass;
 
    PxReal mCamberAtRest;
 
    PxReal mCamberAtMaxCompression; 
 
    PxReal mCamberAtMaxDroop; 
 
    PX_FORCE_INLINE PxReal getRecipMaxCompression() const {return mRecipMaxCompression;}
 
    PX_FORCE_INLINE PxReal getRecipMaxDroop() const {return mRecipMaxDroop;}
 
    void setMassAndPreserveNaturalFrequency(const PxReal newSprungMass)
    {
        const PxF32 oldStrength = mSpringStrength;
        const PxF32 oldSprungMass = mSprungMass;
        const PxF32 newStrength = oldStrength * (newSprungMass / oldSprungMass);
        mSpringStrength = newStrength;
        mSprungMass = newSprungMass;
    }
 
private:
 
    PxReal mRecipMaxCompression;
 
    PxReal mRecipMaxDroop;
 
    //padding
    PxReal mPad[2];
 
    bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleSuspensionData)& 0x0f));
 
class PX_DEPRECATED PxVehicleAntiRollBarData
{
public:
 
    friend class PxVehicleWheelsSimData;
 
    PxVehicleAntiRollBarData()
        : mWheel0(0xffffffff),
          mWheel1(0xffffffff),
          mStiffness(0.0f)
    {
    }
 
    /*
    \brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
    */
    PxU32 mWheel0;
 
    /*
    \brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
    */
    PxU32 mWheel1;
 
    /*
    \brief The stiffness of the anti-roll bar.
 
    \note Specified in kilograms per second-squared (kg s^-2).
 
    <b>Range:</b> [0, PX_MAX_F32)<br>
    */
    PxF32 mStiffness;
 
private:
 
    PxF32 mPad[1];
 
    bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAntiRollBarData)& 0x0f));
 
class PX_DEPRECATED PxVehicleTireData
{
public:
    friend class PxVehicleWheels4SimData;
 
    PxVehicleTireData()
        :   mLatStiffX(2.0f),
            mLatStiffY(0.3125f*(180.0f / PxPi)),
            mLongitudinalStiffnessPerUnitGravity(1000.0f),
            mCamberStiffnessPerUnitGravity(0.1f*(180.0f / PxPi)),
            mType(0)
    {
        mFrictionVsSlipGraph[0][0]=0.0f;
        mFrictionVsSlipGraph[0][1]=1.0f;
        mFrictionVsSlipGraph[1][0]=0.1f;
        mFrictionVsSlipGraph[1][1]=1.0f;
        mFrictionVsSlipGraph[2][0]=1.0f;
        mFrictionVsSlipGraph[2][1]=1.0f;
 
        mRecipLongitudinalStiffnessPerUnitGravity=1.0f/mLongitudinalStiffnessPerUnitGravity;
 
        mFrictionVsSlipGraphRecipx1Minusx0=1.0f/(mFrictionVsSlipGraph[1][0]-mFrictionVsSlipGraph[0][0]);
        mFrictionVsSlipGraphRecipx2Minusx1=1.0f/(mFrictionVsSlipGraph[2][0]-mFrictionVsSlipGraph[1][0]);
    }
 
    PxReal mLatStiffX;
 
    PxReal mLatStiffY;
 
    PxReal mLongitudinalStiffnessPerUnitGravity;
 
    PxReal mCamberStiffnessPerUnitGravity;
 
    PxReal mFrictionVsSlipGraph[3][2];
 
    PxU32 mType;
 
    PX_FORCE_INLINE PxReal getRecipLongitudinalStiffnessPerUnitGravity() const {return mRecipLongitudinalStiffnessPerUnitGravity;}
 
    PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx1Minusx0() const {return mFrictionVsSlipGraphRecipx1Minusx0;}
 
    PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx2Minusx1() const {return mFrictionVsSlipGraphRecipx2Minusx1;}
 
private:
 
    PxReal mRecipLongitudinalStiffnessPerUnitGravity;
 
    PxReal mFrictionVsSlipGraphRecipx1Minusx0;
 
    PxReal mFrictionVsSlipGraphRecipx2Minusx1;
 
    PxReal mPad[2];
 
    bool isValid() const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireData)& 0x0f));
#if !PX_DOXYGEN
} // namespace physx
#endif
 
#endif