PxVehicleDrive.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_DRIVE_H
#define PX_VEHICLE_DRIVE_H

#include "vehicle/PxVehicleWheels.h"
#include "vehicle/PxVehicleComponents.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxVehicleDrivableSurfaceToTireFrictionPairs;
class PxShape;
class PxMaterial;
class PxRigidDynamic;

class PxVehicleDriveSimData
{
//= ATTENTION! =====================================================================================
// Changing the data layout of this class breaks the binary serialization format.  See comments for 
// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
// accordingly.
//==================================================================================================
public:

    friend class PxVehicleDriveTank;

    PX_FORCE_INLINE const PxVehicleEngineData& getEngineData() const 
    {
        return mEngine;
    }
    
    void setEngineData(const PxVehicleEngineData& engine);

    PX_FORCE_INLINE const PxVehicleGearsData& getGearsData() const 
    {
        return mGears;
    }
    
    void setGearsData(const PxVehicleGearsData& gears);

    PX_FORCE_INLINE const PxVehicleClutchData& getClutchData() const 
    {
        return mClutch;
    }
    
    void setClutchData(const PxVehicleClutchData& clutch);

    PX_FORCE_INLINE const PxVehicleAutoBoxData& getAutoBoxData() const 
    {
        return mAutoBox;
    }

    void setAutoBoxData(const PxVehicleAutoBoxData& autobox);

protected:
    /*
    \brief Engine simulation data
    @see setEngineData, getEngineData
    */
    PxVehicleEngineData             mEngine;

    /*
    \brief Gear simulation data
    @see setGearsData, getGearsData
    */
    PxVehicleGearsData              mGears;

    /*
    \brief Clutch simulation data
    @see setClutchData, getClutchData
    */
    PxVehicleClutchData             mClutch;

    /*
    \brief Autobox simulation data
    @see setAutoboxData, getAutoboxData
    */
    PxVehicleAutoBoxData            mAutoBox;

    bool isValid() const;


//serialization
public:
    PxVehicleDriveSimData() {}
    PxVehicleDriveSimData(const PxEMPTY) :  mEngine(PxEmpty), mGears(PxEmpty), mClutch(PxEmpty), mAutoBox(PxEmpty) {}
    static void getBinaryMetaData(PxOutputStream& stream);
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveSimData) & 15));


class PxVehicleDriveDynData
{
public:
    
    enum
    {
        eMAX_NB_ANALOG_INPUTS=16
    };

    friend class PxVehicleDrive;

    void setToRestState();

    void setAnalogInput(const PxU32 type, const PxReal analogVal);

    PxReal getAnalogInput(const PxU32 type) const;

    void setGearUp(const bool digitalVal) 
    {
        mGearUpPressed = digitalVal;
    }

    void setGearDown(const bool digitalVal) 
    {
        mGearDownPressed = digitalVal;
    }

    bool getGearUp() const 
    {
        return mGearUpPressed;
    }

    bool getGearDown() const 
    {
        return mGearDownPressed;
    }

    PX_FORCE_INLINE void setUseAutoGears(const bool useAutoGears)
    {
        mUseAutoGears=useAutoGears;
    }

    PX_FORCE_INLINE bool getUseAutoGears() const
    {
        return mUseAutoGears;
    }

    PX_FORCE_INLINE void toggleAutoGears() 
    {
        mUseAutoGears = !mUseAutoGears;
    }

    PX_FORCE_INLINE void setCurrentGear(PxU32 currentGear) 
    {
        mCurrentGear = currentGear;
    }

    PX_FORCE_INLINE PxU32 getCurrentGear() const
    {
        return mCurrentGear;
    }

    PX_FORCE_INLINE void setTargetGear(PxU32 targetGear) 
    {
        mTargetGear = targetGear;
    }

    PX_FORCE_INLINE PxU32 getTargetGear() const
    {
        return mTargetGear;
    }
    
    PX_FORCE_INLINE void startGearChange(const PxU32 targetGear)
    {
        mTargetGear=targetGear;
    }

    PX_FORCE_INLINE void forceGearChange(const PxU32 targetGear)
    {
        mTargetGear=targetGear;
        mCurrentGear=targetGear;
    }

    PX_FORCE_INLINE void setEngineRotationSpeed(const PxF32 speed)
    {
        mEnginespeed = speed;
    }

    PX_FORCE_INLINE PxReal getEngineRotationSpeed() const
    {
        return mEnginespeed;
    }

    PX_FORCE_INLINE PxReal getGearSwitchTime() const
    {
        return mGearSwitchTime;
    }

    PX_FORCE_INLINE PxReal getAutoBoxSwitchTime() const
    {
        return mAutoBoxSwitchTime;
    }

    PxReal mControlAnalogVals[eMAX_NB_ANALOG_INPUTS];

    bool mUseAutoGears;

    bool mGearUpPressed;

    bool mGearDownPressed;

    PxU32 mCurrentGear;

    PxU32 mTargetGear;

    PxReal mEnginespeed;

    PxReal mGearSwitchTime;

    PxReal mAutoBoxSwitchTime;

private:
    PxU32 mPad[2];

    bool isValid() const;

//serialization
public:
    PxVehicleDriveDynData();
    PxVehicleDriveDynData(const PxEMPTY)  {}
    PxU32 getNbAnalogInput() const { return eMAX_NB_ANALOG_INPUTS; }
    PX_FORCE_INLINE void setGearChange(const PxU32 gearChange) { mTargetGear= gearChange; }
    PX_FORCE_INLINE PxU32 getGearChange() const { return mTargetGear; }
    PX_FORCE_INLINE void setGearSwitchTime(const PxReal switchTime) { mGearSwitchTime = switchTime; }
    PX_FORCE_INLINE void setAutoBoxSwitchTime(const PxReal autoBoxSwitchTime) { mAutoBoxSwitchTime = autoBoxSwitchTime; }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDriveDynData) & 15));

class PxVehicleDrive : public PxVehicleWheels
{
//= ATTENTION! =====================================================================================
// Changing the data layout of this class breaks the binary serialization format.  See comments for 
// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
// accordingly.
//==================================================================================================
public:

    friend class PxVehicleUpdate;

    PxVehicleDriveDynData mDriveDynData;

protected:
    
    bool isValid() const;

    void setToRestState();

    static PxU32 computeByteSize(const PxU32 numWheels);
    static PxU8* patchupPointers(const PxU32 nbWheels, PxVehicleDrive* vehDrive, PxU8* ptr);
    virtual void init(const PxU32 numWheels);

    void free();

    void setup
        (PxPhysics* physics, PxRigidDynamic* vehActor, 
         const PxVehicleWheelsSimData& wheelsData,
         const PxU32 nbDrivenWheels, const PxU32 nbNonDrivenWheels);

//serialization
public:
    static void getBinaryMetaData(PxOutputStream& stream);
    PxVehicleDrive(PxBaseFlags baseFlags) : PxVehicleWheels(baseFlags), mDriveDynData(PxEmpty) {}
    virtual const char* getConcreteTypeName() const { return "PxVehicleDrive"; }
protected:
    PxVehicleDrive(PxType concreteType, PxBaseFlags baseFlags) : PxVehicleWheels(concreteType, baseFlags) {}    
    ~PxVehicleDrive() {}
    virtual bool isKindOf(const char* name) const { return !::strcmp("PxVehicleDrive", name) || PxBase::isKindOf(name); }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleDrive) & 15));

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif //PX_VEHICLE_DRIVE_H