PxVehicleUtilControl.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-2021 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_CONTROL_H
#define PX_VEHICLE_CONTROL_H

#include "vehicle/PxVehicleSDK.h"
#include "vehicle/PxVehicleDrive4W.h"
#include "vehicle/PxVehicleDriveNW.h"
#include "vehicle/PxVehicleDriveTank.h"


#if !PX_DOXYGEN
namespace physx
{
#endif

#if PX_CHECKED
    void testValidAnalogValue(const PxF32 actualValue, const PxF32 minVal, const PxF32 maxVal, const char* errorString);
#endif

struct PxVehicleKeySmoothingData
{
public:

    PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];

    PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleKeySmoothingData)& 0x0f));

struct PxVehiclePadSmoothingData
{
public:

    PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];

    PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehiclePadSmoothingData)& 0x0f));

class PxVehicleDrive4WRawInputData
{
public:

    PxVehicleDrive4WRawInputData()
    {
        for(PxU32 i=0;i<PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS;i++)
        {
            mRawDigitalInputs[i]=false;
            mRawAnalogInputs[i]=0.0f;
        }

        mGearUp = false;
        mGearDown = false;
    }

    virtual ~PxVehicleDrive4WRawInputData()
    {
    }

    void setDigitalAccel(const bool accelKeyPressed)            {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accelKeyPressed;}

    void setDigitalBrake(const bool brakeKeyPressed)            {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brakeKeyPressed;}

    void setDigitalHandbrake(const bool handbrakeKeyPressed)    {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrakeKeyPressed;}

    void setDigitalSteerLeft(const bool steerLeftKeyPressed)    {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT]=steerLeftKeyPressed;}

    void setDigitalSteerRight(const bool steerRightKeyPressed)  {mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steerRightKeyPressed;}


    bool getDigitalAccel() const                                {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}

    bool getDigitalBrake() const                                {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}

    bool getDigitalHandbrake() const                            {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}

    bool getDigitalSteerLeft() const                            {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_LEFT];}

    bool getDigitalSteerRight() const                           {return mRawDigitalInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}


    void setAnalogAccel(const PxReal accel)                     
    {
#if PX_CHECKED
        testValidAnalogValue(accel, 0.0f, 1.0f, "Analog accel must be in range (0,1)");
#endif
        mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL]=accel;
    }

    void setAnalogBrake(const PxReal brake)                     
    {
#if PX_CHECKED
        testValidAnalogValue(brake, 0.0f, 1.0f, "Analog brake must be in range (0,1)");
#endif
        mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE]=brake;
    }

    void setAnalogHandbrake(const PxReal handbrake)             
    {
#if PX_CHECKED
        testValidAnalogValue(handbrake, 0.0f, 1.0f, "Analog handbrake must be in range (0,1)");
#endif
        mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE]=handbrake;
    }

    void setAnalogSteer(const PxReal steer)                     
    {
#if PX_CHECKED
        testValidAnalogValue(steer, -1.0f, 1.0f, "Analog steer must be in range (-1,1)");
#endif
        mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT]=steer;
    }

    PxReal getAnalogAccel() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_ACCEL];}

    PxReal getAnalogBrake() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_BRAKE];}

    PxReal getAnalogHandbrake() const                           {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_HANDBRAKE];}

    PxReal getAnalogSteer() const                               {return mRawAnalogInputs[PxVehicleDrive4WControl::eANALOG_INPUT_STEER_RIGHT];}

    void setGearUp(const bool gearUpKeyPressed)                 {mGearUp=gearUpKeyPressed;}

    void setGearDown(const bool gearDownKeyPressed)             {mGearDown=gearDownKeyPressed;}

    bool getGearUp() const                                      {return mGearUp;}

    bool getGearDown() const                                    {return mGearDown;}

private:

    bool mRawDigitalInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];
    PxReal mRawAnalogInputs[PxVehicleDrive4WControl::eMAX_NB_DRIVE4W_ANALOG_INPUTS];

    bool mGearUp;
    bool mGearDown;
};

void PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs
    (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDrive4WRawInputData& rawInputData, 
     const PxReal timestep, 
     const bool isVehicleInAir, 
     PxVehicleDrive4W& focusVehicle);

void PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
    (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDrive4WRawInputData& rawInputData, 
     const PxReal timestep, 
     const bool isVehicleInAir, 
     PxVehicleDrive4W& focusVehicle);


class PxVehicleDriveNWRawInputData : public PxVehicleDrive4WRawInputData
{
public:

    PxVehicleDriveNWRawInputData() : PxVehicleDrive4WRawInputData(){}
    ~PxVehicleDriveNWRawInputData(){}
};

void PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs
    (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDriveNWRawInputData& rawInputData, 
     const PxReal timestep, 
     const bool isVehicleInAir, 
     PxVehicleDriveNW& focusVehicle);

void PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
    (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDriveNWRawInputData& rawInputData, 
     const PxReal timestep, 
     const bool isVehicleInAir, 
     PxVehicleDriveNW& focusVehicle);


class PxVehicleDriveTankRawInputData
{
public:

    PxVehicleDriveTankRawInputData(const PxVehicleDriveTankControlModel::Enum mode)
        : mMode(mode)
    {
        for(PxU32 i=0;i<PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS;i++)
        {
            mRawAnalogInputs[i]=0.0f;
            mRawDigitalInputs[i]=false;
        }

        mGearUp=false;
        mGearDown=false;
    }

    ~PxVehicleDriveTankRawInputData()
    {
    }

    PxVehicleDriveTankControlModel::Enum getDriveModel() const
    {
        return mMode;
    }

    void setDigitalAccel(const bool b)                  {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=b;}

    void setDigitalLeftThrust(const bool b)             {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=b;}

    void setDigitalRightThrust(const bool b)            {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=b;}

    void setDigitalLeftBrake(const bool b)              {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=b;}

    void setDigitalRightBrake(const bool b)             {mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=b;}

    bool getDigitalAccel() const                        {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];}

    bool getDigitalLeftThrust() const                   {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];}

    bool getDigitalRightThrust() const                  {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];}

    bool getDigitalLeftBrake() const                    {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];}

    bool getDigitalRightBrake() const                   {return mRawDigitalInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];}


    void setAnalogAccel(const PxF32 accel)                  
    {
#if PX_CHECKED
        testValidAnalogValue(accel, 0.0f, 1.0f, "Tank analog accel must be in range (-1,1)");
#endif
        mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL]=accel;
    }

    void setAnalogLeftThrust(const PxF32 leftThrust)            
    {
#if PX_CHECKED
        if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
        {
            testValidAnalogValue(leftThrust, -1.0f, 1.0f, "Tank left thrust must be in range (-1,1) in eSPECIAL mode.");
        }
        else
        {
            testValidAnalogValue(leftThrust, 0.0f, 1.0f, "Tank left thrust must be in range (0,1) in eSTANDARD mode.");
        }
#endif
        mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT]=leftThrust;
    }

    void setAnalogRightThrust(const PxF32 rightThrust)          
    {
#if PX_CHECKED
        if(mMode == PxVehicleDriveTankControlModel::eSPECIAL)
        {
            testValidAnalogValue(rightThrust, -1.0f, 1.0f, "Tank right thrust must be in range (-1,1) in eSPECIAL mode.");
        }
        else
        {
            testValidAnalogValue(rightThrust, 0.0f, 1.0f, "Tank right thrust must be in range (0,1) in eSTANDARD mode.");
        }
#endif
        mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT]=rightThrust;
    }

    void setAnalogLeftBrake(const PxF32 leftBrake)          
    {
#if PX_CHECKED
        testValidAnalogValue(leftBrake, 0.0f, 1.0f, "Tank left brake must be in range (0,1).");
#endif
        mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT]=leftBrake;
    }

    void setAnalogRightBrake(const PxF32 rightBrake)            
    {
#if PX_CHECKED
        testValidAnalogValue(rightBrake, 0.0f, 1.0f, "Tank right brake must be in range (0,1).");
#endif
        mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT]=rightBrake;
    }

    PxF32 getAnalogAccel() const                                
    {
        return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_ACCEL];
    }

    PxF32 getAnalogLeftThrust() const                           
    {
        return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_LEFT];
    }

    PxF32 getAnalogRightThrust() const                      
    {
        return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_THRUST_RIGHT];
    }

    PxF32 getAnalogLeftBrake() const                            
    {
        return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_LEFT];
    }

    PxF32 getAnalogRightBrake() const                           
    {
        return mRawAnalogInputs[PxVehicleDriveTankControl::eANALOG_INPUT_BRAKE_RIGHT];
    }

    void setGearUp(const bool gearUp)                   {mGearUp=gearUp;}

    void setGearDown(const bool gearDown)               {mGearDown=gearDown;}

    bool getGearUp() const                              {return mGearUp;}

    bool getGearDown() const                            {return mGearDown;}

private:

    PxVehicleDriveTankControlModel::Enum mMode;

    PxReal mRawAnalogInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];
    bool mRawDigitalInputs[PxVehicleDriveTankControl::eMAX_NB_DRIVETANK_ANALOG_INPUTS];

    bool mGearUp;
    bool mGearDown;
};

void PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs
(const PxVehicleKeySmoothingData& keySmoothing, 
 const PxVehicleDriveTankRawInputData& rawInputData, 
 const PxReal timestep, 
 PxVehicleDriveTank& focusVehicle);


void PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
(const PxVehiclePadSmoothingData& padSmoothing, 
 const PxVehicleDriveTankRawInputData& rawInputData, 
 const PxReal timestep, 
 PxVehicleDriveTank& focusVehicle);


#if !PX_DOXYGEN
} // namespace physx
#endif

#endif //PX_VEHICLE_CONTROL_H