NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxVehicleUtilControl.h Source 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-2016 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_CONTROL_H
+00031 #define PX_VEHICLE_CONTROL_H
+00032 
+00035 #include "vehicle/PxVehicleSDK.h"
+00036 #include "vehicle/PxVehicleDrive4W.h"
+00037 #include "vehicle/PxVehicleDriveNW.h"
+00038 #include "vehicle/PxVehicleDriveTank.h"
+00039 
+00040 
+00041 #if !PX_DOXYGEN
+00042 namespace physx
+00043 {
+00044 #endif
+00045 
+00046 #if PX_CHECKED
+00047     void testValidAnalogValue(const PxF32 actualValue, const PxF32 minVal, const PxF32 maxVal, const char* errorString);
+00048 #endif
+00049 
+00054 struct PxVehicleKeySmoothingData
+00055 {
+00056 public:
+00057 
+00061     PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
+00062 
+00066     PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
+00067 };
+00068 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleKeySmoothingData)& 0x0f));
+00069 
+00074 struct PxVehiclePadSmoothingData
+00075 {
+00076 public:
+00077 
+00081     PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
+00082 
+00086     PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
+00087 };
+00088 PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehiclePadSmoothingData)& 0x0f));
+00089 
+00094 class PxVehicleDrive4WRawInputData
+00095 {
+00096 public:
+00097 
+00098     PxVehicleDrive4WRawInputData()
+00099     {
+00100         for(PxU32 i=0;i<PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS;i++)
+00101         {
+00102             mRawDigitalInputs[i]=false;
+00103             mRawAnalogInputs[i]=0.0f;
+00104         }
+00105 
+00106         mGearUp = false;
+00107         mGearDown = false;
+00108     }
+00109 
+00110     virtual ~PxVehicleDrive4WRawInputData()
+00111     {
+00112     }
+00113 
+00118     void setDigitalAccel(const bool accelKeyPressed)            {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accelKeyPressed;}
+00119 
+00124     void setDigitalBrake(const bool brakeKeyPressed)            {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brakeKeyPressed;}
+00125 
+00130     void setDigitalHandbrake(const bool handbrakeKeyPressed)    {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrakeKeyPressed;}
+00131 
+00136     void setDigitalSteerLeft(const bool steerLeftKeyPressed)    {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT]=steerLeftKeyPressed;}
+00137 
+00142     void setDigitalSteerRight(const bool steerRightKeyPressed)  {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steerRightKeyPressed;}
+00143 
+00144 
+00149     bool getDigitalAccel() const                                {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}
+00150 
+00155     bool getDigitalBrake() const                                {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}
+00156 
+00161     bool getDigitalHandbrake() const                            {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}
+00162 
+00167     bool getDigitalSteerLeft() const                            {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT];}
+00168 
+00173     bool getDigitalSteerRight() const                           {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}
+00174 
+00175 
+00180     void setAnalogAccel(const PxReal accel)                     
+00181     {
+00182 #if PX_CHECKED
+00183         testValidAnalogValue(accel, 0.0f, 1.0f, "Analog accel must be in range (0,1)");
+00184 #endif
+00185         mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accel;
+00186     }
+00187 
+00192     void setAnalogBrake(const PxReal brake)                     
+00193     {
+00194 #if PX_CHECKED
+00195         testValidAnalogValue(brake, 0.0f, 1.0f, "Analog brake must be in range (0,1)");
+00196 #endif
+00197         mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brake;
+00198     }
+00199 
+00204     void setAnalogHandbrake(const PxReal handbrake)             
+00205     {
+00206 #if PX_CHECKED
+00207         testValidAnalogValue(handbrake, 0.0f, 1.0f, "Analog handbrake must be in range (0,1)");
+00208 #endif
+00209         mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrake;
+00210     }
+00211 
+00216     void setAnalogSteer(const PxReal steer)                     
+00217     {
+00218 #if PX_CHECKED
+00219         testValidAnalogValue(steer, -1.0f, 1.0f, "Analog steer must be in range (-1,1)");
+00220 #endif
+00221         mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steer;
+00222     }
+00223 
+00228     PxReal getAnalogAccel() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}
+00229 
+00234     PxReal getAnalogBrake() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}
+00235 
+00240     PxReal getAnalogHandbrake() const                           {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}
+00241 
+00245     PxReal getAnalogSteer() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}
+00246 
+00251     void setGearUp(const bool gearUpKeyPressed)                 {mGearUp=gearUpKeyPressed;}
+00252 
+00257     void setGearDown(const bool gearDownKeyPressed)             {mGearDown=gearDownKeyPressed;}
+00258 
+00263     bool getGearUp() const                                      {return mGearUp;}
+00264 
+00269     bool getGearDown() const                                    {return mGearDown;}
+00270 
+00271 private:
+00272 
+00273     bool mRawDigitalInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];
+00274     PxReal mRawAnalogInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];
+00275 
+00276     bool mGearUp;
+00277     bool mGearDown;
+00278 };
+00279 
+00290 void PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs
+00291     (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
+00292      const PxVehicleDrive4WRawInputData& rawInputData, 
+00293      const PxReal timestep, 
+00294      const bool isVehicleInAir, 
+00295      PxVehicleDrive4W& focusVehicle);
+00296 
+00307 void PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
+00308     (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
+00309      const PxVehicleDrive4WRawInputData& rawInputData, 
+00310      const PxReal timestep, 
+00311      const bool isVehicleInAir, 
+00312      PxVehicleDrive4W& focusVehicle);
+00313 
+00314 
+00319 class PxVehicleDriveNWRawInputData : public PxVehicleDrive4WRawInputData
+00320 {
+00321 public:
+00322 
+00323     PxVehicleDriveNWRawInputData() : PxVehicleDrive4WRawInputData(){}
+00324     ~PxVehicleDriveNWRawInputData(){}
+00325 };
+00326 
+00337 void PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs
+00338     (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
+00339      const PxVehicleDriveNWRawInputData& rawInputData, 
+00340      const PxReal timestep, 
+00341      const bool isVehicleInAir, 
+00342      PxVehicleDriveNW& focusVehicle);
+00343 
+00354 void PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
+00355     (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
+00356      const PxVehicleDriveNWRawInputData& rawInputData, 
+00357      const PxReal timestep, 
+00358      const bool isVehicleInAir, 
+00359      PxVehicleDriveNW& focusVehicle);
+00360 
+00361 
+00366 class PxVehicleDriveTankRawInputData
+00367 {
+00368 public:
+00369 
+00370     PxVehicleDriveTankRawInputData(const PxVehicleDriveTankControlModel::Enum mode)
+00371         : mMode(mode)
+00372     {
+00373         for(PxU32 i=0;i<PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS;i++)
+00374         {
+00375             mRawAnalogInputs[i]=0.0f;
+00376             mRawDigitalInputs[i]=false;
+00377         }
+00378 
+00379         mGearUp=false;
+00380         mGearDown=false;
+00381     }
+00382 
+00383     ~PxVehicleDriveTankRawInputData()
+00384     {
+00385     }
+00386 
+00391     PxVehicleDriveTankControlModel::Enum getDriveModel() const
+00392     {
+00393         return mMode;
+00394     }
+00395 
+00400     void setDigitalAccel(const bool b)                  {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=b;}
+00401 
+00406     void setDigitalLeftThrust(const bool b)             {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=b;}
+00407 
+00412     void setDigitalRightThrust(const bool b)            {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=b;}
+00413 
+00418     void setDigitalLeftBrake(const bool b)              {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=b;}
+00419 
+00424     void setDigitalRightBrake(const bool b)             {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=b;}
+00425 
+00430     bool getDigitalAccel() const                        {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];}
+00431 
+00436     bool getDigitalLeftThrust() const                   {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];}
+00437 
+00442     bool getDigitalRightThrust() const                  {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];}
+00443 
+00448     bool getDigitalLeftBrake() const                    {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];}
+00449 
+00454     bool getDigitalRightBrake() const                   {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];}
+00455 
+00456 
+00462     void setAnalogAccel(const PxF32 accel)                  
+00463     {
+00464 #if PX_CHECKED
+00465         testValidAnalogValue(accel, 0.0f, 1.0f, "Tank analog accel must be in range (-1,1)");
+00466 #endif
+00467         mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=accel;
+00468     }
+00469 
+00475     void setAnalogLeftThrust(const PxF32 leftThrust)            
+00476     {
+00477 #if PX_CHECKED
+00478         if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
+00479         {
+00480             testValidAnalogValue(leftThrust, -1.0f, 1.0f, "Tank left thrust must be in range (-1,1) in eSPECIAL mode.");
+00481         }
+00482         else
+00483         {
+00484             testValidAnalogValue(leftThrust, 0.0f, 1.0f, "Tank left thrust must be in range (0,1) in eSTANDARD mode.");
+00485         }
+00486 #endif
+00487         mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=leftThrust;
+00488     }
+00489 
+00495     void setAnalogRightThrust(const PxF32 rightThrust)          
+00496     {
+00497 #if PX_CHECKED
+00498         if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
+00499         {
+00500             testValidAnalogValue(rightThrust, -1.0f, 1.0f, "Tank right thrust must be in range (-1,1) in eSPECIAL mode.");
+00501         }
+00502         else
+00503         {
+00504             testValidAnalogValue(rightThrust, 0.0f, 1.0f, "Tank right thrust must be in range (0,1) in eSTANDARD mode.");
+00505         }
+00506 #endif
+00507         mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=rightThrust;
+00508     }
+00509 
+00515     void setAnalogLeftBrake(const PxF32 leftBrake)          
+00516     {
+00517 #if PX_CHECKED
+00518         testValidAnalogValue(leftBrake, 0.0f, 1.0f, "Tank left brake must be in range (0,1).");
+00519 #endif
+00520         mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=leftBrake;
+00521     }
+00522 
+00528     void setAnalogRightBrake(const PxF32 rightBrake)            
+00529     {
+00530 #if PX_CHECKED
+00531         testValidAnalogValue(rightBrake, 0.0f, 1.0f, "Tank right brake must be in range (0,1).");
+00532 #endif
+00533         mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=rightBrake;
+00534     }
+00535 
+00540     PxF32 getAnalogAccel() const                                
+00541     {
+00542         return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];
+00543     }
+00544 
+00549     PxF32 getAnalogLeftThrust() const                           
+00550     {
+00551         return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];
+00552     }
+00553 
+00558     PxF32 getAnalogRightThrust() const                      
+00559     {
+00560         return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];
+00561     }
+00562 
+00567     PxF32 getAnalogLeftBrake() const                            
+00568     {
+00569         return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];
+00570     }
+00571 
+00576     PxF32 getAnalogRightBrake() const                           
+00577     {
+00578         return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];
+00579     }
+00580 
+00585     void setGearUp(const bool gearUp)                   {mGearUp=gearUp;}
+00586 
+00591     void setGearDown(const bool gearDown)               {mGearDown=gearDown;}
+00592 
+00597     bool getGearUp() const                              {return mGearUp;}
+00598 
+00603     bool getGearDown() const                            {return mGearDown;}
+00604 
+00605 private:
+00606 
+00607     PxVehicleDriveTankControlModel::Enum mMode;
+00608 
+00609     PxReal mRawAnalogInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];
+00610     bool mRawDigitalInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];
+00611 
+00612     bool mGearUp;
+00613     bool mGearDown;
+00614 };
+00615 
+00624 void PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs
+00625 (const PxVehicleKeySmoothingData& keySmoothing, 
+00626  const PxVehicleDriveTankRawInputData& rawInputData, 
+00627  const PxReal timestep, 
+00628  PxVehicleDriveTank& focusVehicle);
+00629 
+00630 
+00639 void PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
+00640 (const PxVehiclePadSmoothingData& padSmoothing, 
+00641  const PxVehicleDriveTankRawInputData& rawInputData, 
+00642  const PxReal timestep, 
+00643  PxVehicleDriveTank& focusVehicle);
+00644 
+00645 
+00646 #if !PX_DOXYGEN
+00647 } // namespace physx
+00648 #endif
+00649 
+00651 #endif //PX_VEHICLE_CONTROL_H
+