PxVehicleDrive.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
// 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"

#ifndef PX_DOXYGEN
namespace physx
{
#endif

struct PxFilterData;
class PxGeometry;
class PxPhysics;
class PxBatchQuery;
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 nbWheels4);

    static PxU8* patchupPointers(PxVehicleDrive* vehDrive, PxU8* ptr, const PxU32 nbWheels4, const PxU32 nbWheels);

    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));

#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif //PX_VEHICLE_DRIVE_H