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

NVIDIA PhysX API

PxVehicleComponents.h

Go to the documentation of this file.
00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2017 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
00029 
00030 #ifndef PX_VEHICLE_CORE_COMPONENTS_H
00031 #define PX_VEHICLE_CORE_COMPONENTS_H
00032 
00036 #include "foundation/PxMemory.h"
00037 #include "foundation/PxVec3.h"
00038 #include "common/PxCoreUtilityTypes.h"
00039 #include "PxVehicleSDK.h"
00040 #include "common/PxTypeInfo.h"
00041 
00042 #if !PX_DOXYGEN
00043 namespace physx
00044 {
00045 #endif
00046 
00047 class PxVehicleChassisData
00048 {
00049 public:
00050 
00051     friend class PxVehicleDriveSimData4W;
00052 
00053     PxVehicleChassisData()
00054         :   mMOI(PxVec3(0,0,0)),
00055             mMass(1500),
00056             mCMOffset(PxVec3(0,0,0))
00057     {
00058     }
00059 
00065     PxVec3 mMOI;
00066 
00072     PxReal mMass;
00073 
00079     PxVec3 mCMOffset;
00080 
00081 private:
00082 
00083     PxReal pad;
00084 
00085     bool isValid() const;
00086 };
00087 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleChassisData)& 0x0f));
00088 
00089 class PxVehicleEngineData
00090 {
00091 public:
00092 
00093     friend class PxVehicleDriveSimData;
00094     
00095     enum
00096     {
00097         eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES = 8
00098     };
00099 
00100     PxVehicleEngineData()
00101         :   mMOI(1.0f),
00102             mPeakTorque(500.0f),
00103             mMaxOmega(600.0f),
00104             mDampingRateFullThrottle(0.15f),
00105             mDampingRateZeroThrottleClutchEngaged(2.0f),
00106             mDampingRateZeroThrottleClutchDisengaged(0.35f)
00107     {
00108         mTorqueCurve.addPair(0.0f, 0.8f);
00109         mTorqueCurve.addPair(0.33f, 1.0f);
00110         mTorqueCurve.addPair(1.0f, 0.8f);
00111 
00112         mRecipMOI=1.0f/mMOI;
00113         mRecipMaxOmega=1.0f/mMaxOmega;
00114     }
00115 
00121     PxFixedSizeLookupTable<eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES> mTorqueCurve;
00122 
00128     PxReal mMOI;
00129 
00139     PxReal mPeakTorque;
00140 
00148     PxReal mMaxOmega;
00149 
00165     PxReal mDampingRateFullThrottle;
00166 
00167 
00183     PxReal mDampingRateZeroThrottleClutchEngaged;
00184 
00200     PxReal mDampingRateZeroThrottleClutchDisengaged;
00201 
00205     PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
00206 
00210     PX_FORCE_INLINE PxReal getRecipMaxOmega() const {return mRecipMaxOmega;}
00211 
00212 private:
00213 
00221     PxReal mRecipMOI;
00222 
00230     PxReal mRecipMaxOmega;
00231 
00232     bool isValid() const;
00233 
00234 
00235 //serialization
00236 public:
00237     PxVehicleEngineData(const PxEMPTY) : mTorqueCurve(PxEmpty) {}
00238 //~serialization
00239 };
00240 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleEngineData)& 0x0f));
00241 
00242 class PxVehicleGearsData
00243 {
00244 public:
00245 
00246     friend class PxVehicleDriveSimData;
00247 
00248     enum Enum
00249     {
00250         eREVERSE=0,
00251         eNEUTRAL,
00252         eFIRST,
00253         eSECOND,
00254         eTHIRD,
00255         eFOURTH,
00256         eFIFTH,
00257         eSIXTH,
00258         eSEVENTH,
00259         eEIGHTH,
00260         eNINTH,
00261         eTENTH,
00262         eELEVENTH,
00263         eTWELFTH,
00264         eTHIRTEENTH,
00265         eFOURTEENTH,
00266         eFIFTEENTH,
00267         eSIXTEENTH,
00268         eSEVENTEENTH,
00269         eEIGHTEENTH,
00270         eNINETEENTH,
00271         eTWENTIETH,
00272         eTWENTYFIRST,
00273         eTWENTYSECOND,
00274         eTWENTYTHIRD,
00275         eTWENTYFOURTH,
00276         eTWENTYFIFTH,
00277         eTWENTYSIXTH,
00278         eTWENTYSEVENTH,
00279         eTWENTYEIGHTH,
00280         eTWENTYNINTH,
00281         eTHIRTIETH,
00282         eGEARSRATIO_COUNT
00283     };
00284 
00285     PxVehicleGearsData()
00286         :   mFinalRatio(4.0f),
00287             mNbRatios(7),
00288             mSwitchTime(0.5f)
00289     {
00290         mRatios[PxVehicleGearsData::eREVERSE]=-4.0f;
00291         mRatios[PxVehicleGearsData::eNEUTRAL]=0.0f;
00292         mRatios[PxVehicleGearsData::eFIRST]=4.0f;
00293         mRatios[PxVehicleGearsData::eSECOND]=2.0f;
00294         mRatios[PxVehicleGearsData::eTHIRD]=1.5f;
00295         mRatios[PxVehicleGearsData::eFOURTH]=1.1f;
00296         mRatios[PxVehicleGearsData::eFIFTH]=1.0f;
00297         
00298         for(PxU32 i = PxVehicleGearsData::eSIXTH; i < PxVehicleGearsData::eGEARSRATIO_COUNT; ++i)
00299             mRatios[i]=0.f;
00300     }
00301     
00307     PxReal mRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
00308 
00314     PxReal mFinalRatio;
00315 
00321     PxU32 mNbRatios;
00322     
00330     PxReal mSwitchTime;
00331     
00332 private:
00333 
00334     PxReal mPad;
00335 
00336     bool isValid() const;
00337 
00338 //serialization
00339 public:
00340     PxVehicleGearsData(const PxEMPTY) {}
00341     PxReal getGearRatio(PxVehicleGearsData::Enum a)  const {return mRatios[a];}
00342     void setGearRatio(PxVehicleGearsData::Enum a, PxReal ratio)   { mRatios[a] = ratio;}
00343 //~serialization
00344 };
00345 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleGearsData)& 0x0f));
00346 
00347 class PxVehicleAutoBoxData
00348 {
00349 public:
00350 
00351     friend class PxVehicleDriveSimData;
00352 
00353     PxVehicleAutoBoxData()
00354     {
00355         for(PxU32 i=0;i<PxVehicleGearsData::eGEARSRATIO_COUNT;i++)
00356         {
00357             mUpRatios[i]=0.65f;
00358             mDownRatios[i]=0.50f;
00359         }
00360         //Not sure how important this is but we want to kick out of neutral very quickly.
00361         mUpRatios[PxVehicleGearsData::eNEUTRAL]=0.15f;
00362         //Set the latency time in an unused element of one of the arrays.
00363         mDownRatios[PxVehicleGearsData::eREVERSE]=2.0f; 
00364     }
00365     
00374     PxReal mUpRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
00375 
00384     PxReal mDownRatios[PxVehicleGearsData::eGEARSRATIO_COUNT];
00385 
00397     void setLatency(const PxReal latency) 
00398     { 
00399         mDownRatios[PxVehicleGearsData::eREVERSE]=latency;
00400     }
00401 
00409     PxReal getLatency() const 
00410     { 
00411         return mDownRatios[PxVehicleGearsData::eREVERSE];
00412     }
00413 
00414 private:
00415     bool isValid() const;
00416 
00417 //serialization
00418 public:
00419     PxVehicleAutoBoxData(const PxEMPTY) {}
00420     
00421     PxReal getUpRatios(PxVehicleGearsData::Enum a)  const {return mUpRatios[a];}
00422     void setUpRatios(PxVehicleGearsData::Enum a, PxReal ratio)   { mUpRatios[a] = ratio;}
00423 
00424     PxReal getDownRatios(PxVehicleGearsData::Enum a)  const {return mDownRatios[a];}
00425     void setDownRatios(PxVehicleGearsData::Enum a, PxReal ratio)   { mDownRatios[a] = ratio;}
00426 //~serialization
00427 };
00428 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAutoBoxData)& 0x0f));
00429 
00430 class PxVehicleDifferential4WData
00431 {
00432 public:
00433 
00434     friend class PxVehicleDriveSimData4W;
00435 
00436     enum Enum
00437     {
00438         eDIFF_TYPE_LS_4WD,          //limited slip differential for car with 4 driven wheels
00439         eDIFF_TYPE_LS_FRONTWD,      //limited slip differential for car with front-wheel drive
00440         eDIFF_TYPE_LS_REARWD,       //limited slip differential for car with rear-wheel drive
00441         eDIFF_TYPE_OPEN_4WD,        //open differential for car with 4 driven wheels 
00442         eDIFF_TYPE_OPEN_FRONTWD,    //open differential for car with front-wheel drive
00443         eDIFF_TYPE_OPEN_REARWD,     //open differential for car with rear-wheel drive
00444         eMAX_NB_DIFF_TYPES
00445     };
00446 
00447     PxVehicleDifferential4WData()
00448         :   mFrontRearSplit(0.45f),
00449             mFrontLeftRightSplit(0.5f),
00450             mRearLeftRightSplit(0.5f),
00451             mCentreBias(1.3f),
00452             mFrontBias(1.3f),
00453             mRearBias(1.3f),
00454             mType(PxVehicleDifferential4WData::eDIFF_TYPE_LS_4WD)
00455     {
00456     }
00457 
00465     PxReal mFrontRearSplit;
00466 
00474     PxReal mFrontLeftRightSplit;
00475 
00483     PxReal mRearLeftRightSplit;
00484 
00493     PxReal mCentreBias;
00494 
00503     PxReal mFrontBias;
00504 
00513     PxReal mRearBias;
00514 
00520     PxVehicleDifferential4WData::Enum mType;
00521 
00522 private:
00523 
00524     PxReal mPad[1];
00525 
00526     bool isValid() const;
00527 
00528 //serialization
00529 public:
00530     PxVehicleDifferential4WData(const PxEMPTY) {}
00531 //~serialization
00532 };
00533 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferential4WData)& 0x0f));
00534 
00535 class PxVehicleDifferentialNWData
00536 {
00537 public:
00538 
00539     friend class PxVehicleDriveSimDataNW;
00540     friend class PxVehicleUpdate;
00541 
00542     PxVehicleDifferentialNWData()
00543     {
00544         PxMemSet(mBitmapBuffer, 0, sizeof(PxU32) * (((PX_MAX_NB_WHEELS + 31) & ~31) >> 5));
00545         mNbDrivenWheels=0;
00546         mInvNbDrivenWheels=0.0f;
00547     }
00548 
00556     void setDrivenWheel(const PxU32 wheelId, const bool drivenState);
00557 
00561     bool getIsDrivenWheel(const PxU32 wheelId) const;
00562 
00563 private:
00564 
00565     PxU32 mBitmapBuffer[((PX_MAX_NB_WHEELS + 31) & ~31) >> 5];
00566     PxU32 mNbDrivenWheels;
00567     PxReal mInvNbDrivenWheels;
00568     PxU32 mPad;
00569 
00570     bool isValid() const;
00571 
00572 //serialization
00573 public:
00574     PxVehicleDifferentialNWData(const PxEMPTY) {}
00575     PxU32 getDrivenWheelStatus() const;
00576     void setDrivenWheelStatus(PxU32 status);
00577 //~serialization
00578 };
00579 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDifferentialNWData)& 0x0f));
00580 
00581 
00582 class PxVehicleAckermannGeometryData
00583 {
00584 public:
00585 
00586     friend class PxVehicleDriveSimData4W;
00587 
00588     PxVehicleAckermannGeometryData()
00589         :   mAccuracy(1.0f),
00590             mFrontWidth(0.0f),      //Must be filled out 
00591             mRearWidth(0.0f),       //Must be filled out
00592             mAxleSeparation(0.0f)   //Must be filled out
00593     {
00594     }
00595 
00611     PxReal mAccuracy;
00612 
00620     PxReal mFrontWidth;     
00621 
00629     PxReal mRearWidth;      
00630 
00638     PxReal mAxleSeparation; 
00639 
00640 private:
00641 
00642     bool isValid() const;
00643 
00644 //serialization
00645 public:
00646     PxVehicleAckermannGeometryData(const PxEMPTY) {}
00647 //~serialization
00648 };
00649 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAckermannGeometryData)& 0x0f));
00650 
00655 struct PxVehicleClutchAccuracyMode
00656 {
00657     enum Enum
00658     {
00659         eESTIMATE = 0,
00660         eBEST_POSSIBLE
00661     };
00662 };
00663 
00664 class PxVehicleClutchData
00665 {
00666 public:
00667 
00668     friend class PxVehicleDriveSimData;
00669 
00670     PxVehicleClutchData()
00671         :   mStrength(10.0f),
00672             mAccuracyMode(PxVehicleClutchAccuracyMode::eBEST_POSSIBLE),
00673             mEstimateIterations(5)
00674     {
00675     }
00676 
00695     PxReal mStrength;
00696 
00711     PxVehicleClutchAccuracyMode::Enum mAccuracyMode;
00712 
00724     PxU32 mEstimateIterations;
00725 
00726 private:
00727 
00728     PxU8 mPad[4];
00729 
00730     bool isValid() const;
00731 
00732 //serialization
00733 public:
00734     PxVehicleClutchData(const PxEMPTY) {}
00735 //~serialization
00736 };
00737 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleClutchData)& 0x0f));
00738 
00739 
00762 class PxVehicleTireLoadFilterData
00763 {
00764 public:
00765 
00766     friend class PxVehicleWheelsSimData;
00767 
00768     PxVehicleTireLoadFilterData()
00769         :   mMinNormalisedLoad(0),
00770             mMinFilteredNormalisedLoad(0.2308f),
00771             mMaxNormalisedLoad(3.0f),
00772             mMaxFilteredNormalisedLoad(3.0f)
00773     {
00774         mDenominator=1.0f/(mMaxNormalisedLoad - mMinNormalisedLoad);
00775     }
00776 
00780     PxReal mMinNormalisedLoad; 
00781 
00785     PxReal mMinFilteredNormalisedLoad; 
00786 
00790     PxReal mMaxNormalisedLoad;
00791         
00795     PxReal mMaxFilteredNormalisedLoad;
00796 
00797     PX_FORCE_INLINE PxReal getDenominator() const {return mDenominator;}
00798 
00799 private:
00800 
00804     //1.0f/(mMaxNormalisedLoad-mMinNormalisedLoad) for quick calculations
00805     PxReal mDenominator;
00806 
00807     PxU32 mPad[3];
00808 
00809     bool isValid() const;
00810 
00811 //serialization
00812 public:
00813     PxVehicleTireLoadFilterData(const PxEMPTY) {}
00814 //~serialization
00815 };
00816 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireLoadFilterData)& 0x0f));
00817 
00818 class PxVehicleWheelData
00819 {
00820 public:
00821 
00822     friend class PxVehicleWheels4SimData;
00823 
00824     PxVehicleWheelData()
00825         :   mRadius(0.0f),              //Must be filled out
00826             mWidth(0.0f),
00827             mMass(20.0f),
00828             mMOI(0.0f),                 //Must be filled out
00829             mDampingRate(0.25f),
00830             mMaxBrakeTorque(1500.0f),
00831             mMaxHandBrakeTorque(0.0f),  
00832             mMaxSteer(0.0f),            
00833             mToeAngle(0.0f),
00834             mRecipRadius(0.0f),         //Must be filled out
00835             mRecipMOI(0.0f)             //Must be filled out
00836     {
00837     }
00838 
00846     PxReal mRadius;
00847 
00855     PxReal mWidth;
00856 
00864     PxReal mMass;
00865 
00873     PxReal mMOI;
00874 
00882     PxReal mDampingRate;
00883 
00891     PxReal mMaxBrakeTorque;
00892 
00900     PxReal mMaxHandBrakeTorque;
00901 
00909     PxReal mMaxSteer;
00910 
00918     PxReal mToeAngle;//in radians
00919 
00925     PX_FORCE_INLINE PxReal getRecipRadius() const {return mRecipRadius;}
00926 
00932     PX_FORCE_INLINE PxReal getRecipMOI() const {return mRecipMOI;}
00933 
00934 private:
00935 
00943     PxReal mRecipRadius;
00944 
00952     PxReal mRecipMOI;
00953 
00954     PxReal mPad[1];
00955 
00956     bool isValid() const;
00957 };
00958 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelData)& 0x0f));
00959 
00960 class PxVehicleSuspensionData
00961 {
00962 public:
00963 
00964     friend class PxVehicleWheels4SimData;
00965 
00966     PxVehicleSuspensionData()
00967         :   mSpringStrength(0.0f),
00968             mSpringDamperRate(0.0f),
00969             mMaxCompression(0.3f),
00970             mMaxDroop(0.1f),
00971             mSprungMass(0.0f),
00972             mCamberAtRest(0.0f),
00973             mCamberAtMaxCompression(0.0f),
00974             mCamberAtMaxDroop(0.0f),
00975             mRecipMaxCompression(1.0f),
00976             mRecipMaxDroop(1.0f)
00977     {
00978     }
00979     
00987     PxReal mSpringStrength;
00988 
00996     PxReal mSpringDamperRate;
00997 
01005     PxReal mMaxCompression;
01006 
01014     PxReal mMaxDroop;
01015 
01047     PxReal mSprungMass;
01048 
01057     PxReal mCamberAtRest;
01058 
01069     PxReal mCamberAtMaxCompression; 
01070 
01081     PxReal mCamberAtMaxDroop; 
01082 
01090     PX_FORCE_INLINE PxReal getRecipMaxCompression() const {return mRecipMaxCompression;}
01091 
01099     PX_FORCE_INLINE PxReal getRecipMaxDroop() const {return mRecipMaxDroop;}
01100 
01106     void setMassAndPreserveNaturalFrequency(const PxReal newSprungMass)
01107     {
01108         const PxF32 oldStrength = mSpringStrength;
01109         const PxF32 oldSprungMass = mSprungMass;
01110         const PxF32 newStrength = oldStrength * (newSprungMass / oldSprungMass);
01111         mSpringStrength = newStrength;
01112         mSprungMass = newSprungMass;
01113     }
01114 
01115 private:
01116 
01122     PxReal mRecipMaxCompression;
01123 
01129     PxReal mRecipMaxDroop;
01130 
01131     //padding
01132     PxReal mPad[2];
01133 
01134     bool isValid() const;
01135 };
01136 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleSuspensionData)& 0x0f));
01137 
01138 class PxVehicleAntiRollBarData
01139 {
01140 public:
01141 
01142     friend class PxVehicleWheelsSimData;
01143 
01144     PxVehicleAntiRollBarData()
01145         : mWheel0(0xffffffff),
01146           mWheel1(0xffffffff),
01147           mStiffness(0.0f)
01148     {
01149     }
01150 
01151     /*
01152     \brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
01153     */
01154     PxU32 mWheel0;
01155 
01156     /*
01157     \brief The anti-roll bar connects two wheels with indices mWheel0 and mWheel1
01158     */
01159     PxU32 mWheel1;
01160 
01161     /*
01162     \brief The stiffness of the anti-roll bar.
01163 
01164     \note Specified in kilograms per second-squared (kg s^-2).
01165 
01166     <b>Range:</b> [0, PX_MAX_F32)<br>
01167     */
01168     PxF32 mStiffness;
01169 
01170 private:
01171 
01172     PxF32 mPad[1];
01173 
01174     bool isValid() const;
01175 };
01176 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleAntiRollBarData)& 0x0f));
01177 
01178 class PxVehicleTireData
01179 {
01180 public:
01181     friend class PxVehicleWheels4SimData;
01182 
01183     PxVehicleTireData()
01184         :   mLatStiffX(2.0f),
01185             mLatStiffY(0.3125f*(180.0f / PxPi)),
01186             mLongitudinalStiffnessPerUnitGravity(1000.0f),
01187             mCamberStiffnessPerUnitGravity(0.1f*(180.0f / PxPi)),
01188             mType(0)
01189     {
01190         mFrictionVsSlipGraph[0][0]=0.0f;
01191         mFrictionVsSlipGraph[0][1]=1.0f;
01192         mFrictionVsSlipGraph[1][0]=0.1f;
01193         mFrictionVsSlipGraph[1][1]=1.0f;
01194         mFrictionVsSlipGraph[2][0]=1.0f;
01195         mFrictionVsSlipGraph[2][1]=1.0f;
01196 
01197         mRecipLongitudinalStiffnessPerUnitGravity=1.0f/mLongitudinalStiffnessPerUnitGravity;
01198 
01199         mFrictionVsSlipGraphRecipx1Minusx0=1.0f/(mFrictionVsSlipGraph[1][0]-mFrictionVsSlipGraph[0][0]);
01200         mFrictionVsSlipGraphRecipx2Minusx1=1.0f/(mFrictionVsSlipGraph[2][0]-mFrictionVsSlipGraph[1][0]);
01201     }
01202 
01210     PxReal mLatStiffX;
01211 
01227     PxReal mLatStiffY;
01228 
01240     PxReal mLongitudinalStiffnessPerUnitGravity;
01241 
01253     PxReal mCamberStiffnessPerUnitGravity;
01254 
01288     PxReal mFrictionVsSlipGraph[3][2];
01289 
01297     PxU32 mType;
01298 
01304     PX_FORCE_INLINE PxReal getRecipLongitudinalStiffnessPerUnitGravity() const {return mRecipLongitudinalStiffnessPerUnitGravity;}
01305 
01311     PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx1Minusx0() const {return mFrictionVsSlipGraphRecipx1Minusx0;}
01312 
01318     PX_FORCE_INLINE PxReal getFrictionVsSlipGraphRecipx2Minusx1() const {return mFrictionVsSlipGraphRecipx2Minusx1;}
01319 
01320 private:
01321 
01329     PxReal mRecipLongitudinalStiffnessPerUnitGravity;
01330 
01338     PxReal mFrictionVsSlipGraphRecipx1Minusx0;
01339 
01347     PxReal mFrictionVsSlipGraphRecipx2Minusx1;
01348 
01349     PxReal mPad[2];
01350 
01351     bool isValid() const;
01352 };
01353 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleTireData)& 0x0f));
01354 #if !PX_DOXYGEN
01355 } // namespace physx
01356 #endif
01357 
01359 #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