documentation.HELP! NVIDIA PhysX SDK 3.4 API Documentation

NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxVehicleComponents.h Source File

NVIDIA PhysX SDK 3.4 API

previous page next page

---

       

---

PxVehicleComponents.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2008-2017 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-2017 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com

previous page start next page

Menu

• Homepage

Table of contents

• Main Page
• Class Hierarchy
• Compound List
• Compound Members
• PxPhysXConfig.h
• PxRigidActor.h
• Go to the source code of this file.
• PxRigidStatic
• More...
• Related Pages
• Modules
• Namespaces
• Class Index
• Files
• File Members
• Go to the graphical class hierarchy
• physx::PxBaseTask
• physx::PxLightCpuTask
• physx::PxTask
• physx::PxGpuTask
• physx::PxCpuDispatcher
• physx::PxGpuDispatcher
• physx::PxGpuTaskHint
• physx::PxProfilerCallback
• PxPvd
• physx::PxProfileScoped
• physx::PxTaskManager
• physx::PxTaskType
• Px1DConstraint
• Px1DConstraintFlag
• PxActiveTransform
• PxActorClientBehaviorFlag
• PxActorFlag
• PxActorShape
• PxQueryHit
• PxLocationHit
• PxRaycastHit
• PxSweepHit
• PxOverlapHit
• PxActorType
• PxActorTypeFlag
• PxAllocatorCallback
• PxDefaultAllocator
• PxArticulationDriveCache
• PxArticulationJointDriveType
• PxAssertHandler
• PxBase
• PxActor
• PxCloth
• PxParticleBase

Get in touch

Submit feedback about this site to:

• [email protected]

© documentation.help. Design: rehmann.co.