PxVehicleUtilControl.h

// 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-2022 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_UTIL_CONTROL_H
#define PX_VEHICLE_UTIL_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 PX_DEPRECATED PxVehicleSteerFilter
{
    PxVehicleSteerFilter(float sharpness=0.0f) : mSharpness(sharpness), mFilteredMaxSteer(0.0f) {}
 
    static PX_FORCE_INLINE float feedbackFilter(float val, float& memory, float sharpness)
    {
                if(sharpness<0.0f)  sharpness = 0.0f;
        else    if(sharpness>1.0f)  sharpness = 1.0f;
        return memory = val * sharpness + memory * (1.0f - sharpness);
    }
 
    PX_FORCE_INLINE float   computeMaxSteer(const bool isVehicleInAir, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
                                            const PxF32 vzAbs, const PxF32 timestep)    const
    {
        const PxF32 targetMaxSteer = (isVehicleInAir ? 1.0f : steerVsForwardSpeedTable.getYVal(vzAbs));
        if(mSharpness==0.0f)
            return targetMaxSteer;
        else
            return feedbackFilter(targetMaxSteer, mFilteredMaxSteer, mSharpness*timestep);
    }
 
    PxReal          mSharpness;
    mutable PxReal  mFilteredMaxSteer;
};
 
struct PX_DEPRECATED PxVehicleKeySmoothingData
{
    PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
 
    PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleKeySmoothingData)& 0x0f));
 
struct PX_DEPRECATED PxVehiclePadSmoothingData
{
    PxReal mRiseRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
 
    PxReal mFallRates[PxVehicleDriveDynData::eMAX_NB_ANALOG_INPUTS];
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehiclePadSmoothingData)& 0x0f));
 
class PX_DEPRECATED 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;
};
 
PX_DEPRECATED void PxVehicleDrive4WSmoothDigitalRawInputsAndSetAnalogInputs
    (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDrive4WRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir, 
     PxVehicleDrive4W& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
     const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
 
PX_DEPRECATED void PxVehicleDrive4WSmoothAnalogRawInputsAndSetAnalogInputs
    (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDrive4WRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir, 
     PxVehicleDrive4W& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
     const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
 
 
class PX_DEPRECATED PxVehicleDriveNWRawInputData : public PxVehicleDrive4WRawInputData
{
public:
 
    PxVehicleDriveNWRawInputData() : PxVehicleDrive4WRawInputData(){}
    ~PxVehicleDriveNWRawInputData(){}
};
 
PX_DEPRECATED void PxVehicleDriveNWSmoothDigitalRawInputsAndSetAnalogInputs
    (const PxVehicleKeySmoothingData& keySmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDriveNWRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir, 
     PxVehicleDriveNW& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
     const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
 
PX_DEPRECATED void PxVehicleDriveNWSmoothAnalogRawInputsAndSetAnalogInputs
    (const PxVehiclePadSmoothingData& padSmoothing, const PxFixedSizeLookupTable<8>& steerVsForwardSpeedTable,
     const PxVehicleDriveNWRawInputData& rawInputData, const PxReal timestep, const bool isVehicleInAir, 
     PxVehicleDriveNW& focusVehicle, const PxVehicleSteerFilter& steerFilter = PxVehicleSteerFilter(),
     const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis);
 
 
class PX_DEPRECATED 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;
};
 
PX_DEPRECATED void PxVehicleDriveTankSmoothDigitalRawInputsAndSetAnalogInputs
(const PxVehicleKeySmoothingData& keySmoothing, 
 const PxVehicleDriveTankRawInputData& rawInputData, 
 const PxReal timestep, 
 PxVehicleDriveTank& focusVehicle);
 
 
PX_DEPRECATED void PxVehicleDriveTankSmoothAnalogRawInputsAndSetAnalogInputs
(const PxVehiclePadSmoothingData& padSmoothing, 
 const PxVehicleDriveTankRawInputData& rawInputData, 
 const PxReal timestep, 
 PxVehicleDriveTank& focusVehicle);
 
 
#if !PX_DOXYGEN
} // namespace physx
#endif
 
#endif