---

       

---

PxVehicleComponents.h

Go to the documentation of this file.

//
// 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-2018 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_CORE_COMPONENTS_H
#define PX_VEHICLE_CORE_COMPONENTS_H

#include "foundation/PxMemory.h"
#include "foundation/PxVec3.h"
#include "common/PxCoreUtilityTypes.h"
#include "PxVehicleSDK.h"
#include "common/PxTypeInfo.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

class 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 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 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 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 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 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 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 PxVehicleClutchAccuracyMode
{
    enum Enum
    {
        eESTIMATE = 0,
        eBEST_POSSIBLE
    };
};

class 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 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 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 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 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 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 //PX_VEHICLE_CORE_COMPONENTS_H

---

Copyright © 2008-2018 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com