physxCAPI/physxCDLL/include/vehicle/PxVehicleWheels.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-2023 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_WHEELS_H
#define PX_VEHICLE_WHEELS_H

#include "foundation/PxSimpleTypes.h"
#include "vehicle/PxVehicleShaders.h"
#include "vehicle/PxVehicleComponents.h"
#include "common/PxBase.h"
#include "PxRigidDynamic.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

class PxVehicleWheels4SimData;
class PxVehicleWheels4DynData;
class PxVehicleTireForceCalculator;
class PxShape;
class PxPhysics;
class PxMaterial;

/**
\brief Flags to configure the vehicle wheel simulation.

@see PxVehicleWheelsSimData::setFlags(), PxVehicleWheelsSimData::getFlags()
*/
struct PX_DEPRECATED PxVehicleWheelsSimFlag
{
	enum Enum
	{
		/**
		\brief Limit the suspension expansion velocity.

		For extreme damping ratios, large damping forces might result in the vehicle sticking to the ground where
		one would rather expect to see the vehicle lift off. While it is highly recommended to use somewhat realistic 
		damping ratios, this flag can be used to limit the velocity of the suspension. In more detail, the simulation 
		will check whether the suspension can extend to the target length in the given simulation time step. If that 
		is the case, the suspension force will be computed as usual, else the force will be set to zero. Enabling 
		this feature gives a slightly more realisitic behavior at the potential cost of more easily losing control 
		when steering the vehicle.
		*/
		eLIMIT_SUSPENSION_EXPANSION_VELOCITY = (1 << 0),

		/**
		\brief Disable internal cylinder-plane intersection test.

		By default the internal code runs a post-process on sweep results, approximating the wheel shape with a
		cylinder and tweaking the sweep hit results accordingly. This can produce artefacts in certain cases, in
		particular when the swept shape is very different from a cylinder - e.g. with swept spheres. This flag
		tells the system to disable this internal test, and reuse the direct user-provided sweep results.

		The default code refines the sweep results in each substep. Enabling this flag makes the system partially
		reuse the same sweep results over each substep, which could potentially create other artefacts.
		*/
		eDISABLE_INTERNAL_CYLINDER_PLANE_INTERSECTION_TEST = (1 << 1),

		/**
		\brief Disable suspension force projection.

		By default the internal code modulates the suspension force with the contact normal, i.e. the more the contact
		normal is aligned with the suspension direction, the bigger the force. This can create issues when using a
		single blocking hit, whose unique contact normal sometimes does not accurately capture the reality of the
		surrounding geometry. For example it can weaken the suspension force too much, which visually makes the wheel
		move up and down against e.g. a kerb. Enabling this flag tells the system to disable the modulation of the
		suspension force by the contact normal.
		
		The rationale is that a real tire has a deformed contact patch containing multiple normals, and even if some
		of these normals are bent when colliding against a kerb, there would still be a large area of the contact patch
		touching the ground, and getting normals aligned with the suspension. This is difficult to capture with simple
		sweep results, especially with a single sweep hit whose normal is computed by a less than accurate algorithm
		like GJK. Using this flag shortcuts these issues, which can improves the behavior when driving over kerbs or
		small obstacles.
		*/
		eDISABLE_SUSPENSION_FORCE_PROJECTION = (1 << 2),

		/**
		\brief Disable check for sprung mass values summing up to chassis mass.

		Generally, the sum of the suspension sprung mass values should match the chassis mass. However, there can be
		scenarios where this is not necessarily desired. Taking a semi-trailer truck as an example, a large part of
		the trailer mass will rest on the tractor unit and not the trailer wheels. This flag allows the user to set
		the values as desired without error messages being sent.
		*/
		eDISABLE_SPRUNG_MASS_SUM_CHECK = (1 << 3)
	};
};

/**
\brief Collection of set bits defined in #PxVehicleWheelsSimFlag.

@see PxVehicleWheelsSimFlag
*/
typedef PxFlags<PxVehicleWheelsSimFlag::Enum, PxU32> PxVehicleWheelsSimFlags;
PX_FLAGS_OPERATORS(PxVehicleWheelsSimFlag::Enum, PxU32)

/**
\brief Data structure describing configuration data of a vehicle with up to 20 wheels.
*/

class PX_DEPRECATED PxVehicleWheelsSimData
{
//= 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 PxVehicleWheels;
	friend class PxVehicleNoDrive;
	friend class PxVehicleDrive4W;
	friend class PxVehicleDriveTank;
	friend class PxVehicleUpdate;

	/**
	\brief Allocate a PxVehicleWheelsSimData instance for with nbWheels.
	@see free
	*/
	static PxVehicleWheelsSimData* allocate(const PxU32 nbWheels);

	/**
	\brief Setup with mass information that can be applied to the default values of the suspensions, wheels, and tires
	set in their respective constructors.

	\param chassisMass is the mass of the chassis.

	\note This function assumes that the suspensions equally share the load of the chassis mass.  It also
	assumes that the suspension will have a particular natural frequency and damping ratio that is typical
	of a standard car.  If either of these assumptions is broken then each suspension will need to 
	be individually configured with custom strength, damping rate, and sprung mass.

	@see allocate
	*/
	void setChassisMass(const PxF32 chassisMass);

	/**
	\brief Free a PxVehicleWheelsSimData instance 
	@see allocate
	*/
	void free();

	/**
	\brief Copy wheel simulation data.
	\note The number of wheels on both instances of PxVehicleWheelsSimData must match.
	*/
	PxVehicleWheelsSimData& operator=(const PxVehicleWheelsSimData& src);

	/**
	\brief Copy the data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel.
	\param[in] src is the data to be copied.
	\param[in] srcWheel is the wheel whose data will be copied from src.
	\param[in] trgWheel is the wheel that will be assigned the copied data.
	*/
	void copy(const PxVehicleWheelsSimData& src, const PxU32 srcWheel, const PxU32 trgWheel);

	/**
	\brief Return the number of wheels 
	@see allocate
	*/
	PxU32 getNbWheels() const {return mNbActiveWheels;}

	/**
	\brief Return the suspension data of the idth wheel
	*/
	const PxVehicleSuspensionData& getSuspensionData(const PxU32 id) const;
		
	/**
	\brief Return the wheel data of the idth wheel
	*/
	const PxVehicleWheelData& getWheelData(const PxU32 id) const;

	/**
	\brief Return the tire data of the idth wheel
	*/
	const PxVehicleTireData& getTireData(const PxU32 id) const;
	
	/**
	\brief Return the direction of travel of the suspension of the idth wheel
	*/
	const PxVec3& getSuspTravelDirection(const PxU32 id) const;

	/**
	\brief Return the application point of the suspension force of the suspension of the idth wheel as an offset from the rigid body center of mass.
	\note Specified relative to the center of mass of the rigid body
	*/
	const PxVec3& getSuspForceAppPointOffset(const PxU32 id) const;

	/**
	\brief Return the application point of the tire force of the tire of the idth wheel as an offset from the rigid body center of mass.
	\note Specified relative to the centre of mass of the rigid body
	*/
	const PxVec3& getTireForceAppPointOffset(const PxU32 id) const;
		
	/**
	\brief Return the offset from the rigid body centre of mass to the centre of the idth wheel.
	*/
	const PxVec3& getWheelCentreOffset(const PxU32 id) const;	

	/**
	\brief Return the wheel mapping for the ith wheel.  
	
	\note The return value is the element in the array of 
	shapes of the vehicle's PxRigidDynamic that corresponds to the ith wheel.  A return value of -1 means
	that the wheel is not mapped to a PxShape.

	@see PxRigidActor.getShapes
	*/
	PxI32 getWheelShapeMapping(const PxU32 wheelId) const;

	/**
	\brief Return the scene query filter data used by the specified suspension line
	*/
	const PxFilterData& getSceneQueryFilterData(const PxU32 suspId) const;

	/**
	\brief Return the number of unique anti-roll bars that have been added with addAntiRollBarData
	@see PxVehicleWheelsSimData::addAntiRollBarData
	*/
	PxU32 getNbAntiRollBars() const 
	{
		return mNbActiveAntiRollBars;
	}

	/**
	\brief Return a specific anti-roll bar.
	\param antiRollId is the unique id of the anti-roll bar
	\note The return value of addAntiRollBarData is a unique id for that specific anti-roll bar 
	and can be used as input parameter for getAntiRollBarData in order to query the same anti-roll bar.  
	Alternatively, it is possible to iterate over all anti-roll bars by choosing antiRollId 
	in range (0, getNbAntiRollBars()).
	*/
	const PxVehicleAntiRollBarData& getAntiRollBarData(const PxU32 antiRollId) const;
	
	/**
	\brief Return the data that describes the filtering of the tire load to produce smoother handling at large time-steps.
	*/
	PX_FORCE_INLINE const PxVehicleTireLoadFilterData& getTireLoadFilterData() const 
	{
		return mNormalisedLoadFilter;
	}

	/**
	\brief Set the suspension data of the idth wheel
	\param[in] id is the wheel index.
	\param[in] susp is the suspension data to be applied.
	*/
	void setSuspensionData(const PxU32 id, const PxVehicleSuspensionData& susp);

	/**
	\brief Set the wheel data of the idth wheel
	\param[in] id is the wheel index.
	\param[in] wheel is the wheel data to be applied.
	*/
	void setWheelData(const PxU32 id, const PxVehicleWheelData& wheel);

	/**
	\brief Set the tire data of the idth wheel
	\param[in] id is the wheel index.
	\param[in] tire is the tire data to be applied.
	*/
	void setTireData(const PxU32 id, const PxVehicleTireData& tire);

	/**
	\brief Set the direction of travel of the suspension of the idth wheel
	\param[in] id is the wheel index
	\param[in] dir is the suspension travel direction to be applied.
	*/
	void setSuspTravelDirection(const PxU32 id, const PxVec3& dir);
	
	/**
	\brief Set the application point of the suspension force of the suspension of the idth wheel.
	\param[in] id is the wheel index
	\param[in] offset is the offset from the rigid body center of mass to the application point of the suspension force.
	\note Specified relative to the centre of mass of the rigid body
	*/
	void setSuspForceAppPointOffset(const PxU32 id, const PxVec3& offset);									
	
	/**
	\brief Set the application point of the tire force of the tire of the idth wheel.
	\param[in] id is the wheel index
	\param[in] offset is the offset from the rigid body center of mass to the application point of the tire force.
	\note Specified relative to the centre of mass of the rigid body
	*/
	void setTireForceAppPointOffset(const PxU32 id, const PxVec3& offset);

	/**
	\brief Set the offset from the rigid body centre of mass to the centre of the idth wheel.
	\param[in] id is the wheel index
	\param[in] offset is the offset from the rigid body center of mass to the center of the wheel at rest.
	\note Specified relative to the centre of mass of the rigid body
	*/
	void setWheelCentreOffset(const PxU32 id, const PxVec3& offset);	

	/**
	\brief Set mapping between wheel id and position of corresponding wheel shape in the list of actor shapes.
	
	\note This mapping is used to pose the correct wheel shapes with the latest wheel rotation angle, steer angle, and suspension travel
	while allowing arbitrary ordering of the wheel shapes in the actor's list of shapes.
	
	\note Use setWheelShapeMapping(i,-1) to register that there is no wheel shape corresponding to the ith wheel
	
	\note Set setWheelShapeMapping(i,k) to register that the ith wheel corresponds to the kth shape in the actor's list of shapes.
	
	\note The default values correspond to setWheelShapeMapping(i,i) for all wheels.
	
	\note Calling this function will also pose the relevant PxShape at the rest position of the wheel.

	\param wheelId is the wheel index

	\param shapeId is the shape index.
	
	@see PxVehicleUpdates, PxVehicleDrive4W::setup, PxVehicleDriveTank::setup, PxVehicleNoDrive::setup, setSceneQueryFilterData, PxRigidActor::getShapes
	*/
	void setWheelShapeMapping(const PxU32 wheelId, const PxI32 shapeId);

	/**
	\brief Set the scene query filter data that will be used for raycasts along the travel
	direction of the specified suspension. The default value is PxFilterData(0,0,0,0)
	\param suspId is the wheel index
	\param sqFilterData is the raycast filter data for the suspension raycast.
	@see setWheelShapeMapping
	*/
	void setSceneQueryFilterData(const PxU32 suspId, const PxFilterData& sqFilterData);

	/**
	\brief Set the data that describes the filtering of the tire load to produce smoother handling at large timesteps.
	\param tireLoadFilter is the smoothing function data.
	*/
	void setTireLoadFilterData(const PxVehicleTireLoadFilterData& tireLoadFilter);

	/**
	\brief Set the anti-roll suspension for a pair of wheels.

	\param antiRoll is the anti-roll suspension.

	\note If an anti-roll bar has already been set for the same logical wheel pair 
	(independent of wheel index order specified by PxVehicleAntiRollBar.mWheel0 and PxVehicleAntiRollBar.mWheel0) 
	then the existing anti-roll bar is updated with a new stiffness parameter antiRoll.mStiffness.  

	\note If the wheel pair specified by antiRoll does not yet have an anti-roll bar then antiRoll is added to 
	a list of anti-roll bars for the vehicle.

	\return If antiRoll represents a new wheel pair then a unique id is assigned to the anti-roll bar and returned. 
	If antiRoll represents an existing wheel pair then the unique id of the existing anti-roll bar is returned.
	The return value is always in range (0, getNbAntiRollBars()).

	\note The return value can be used to query the anti-roll bar with getAntiRollBarData(id).

	\note The number of possible anti-roll bars is limited to half the wheel count.

	\note An existing anti-roll bar can be disabled by calling antiRoll.mStiffness to zero.

	@see PxVehicleWheelsSimData::getAntiRollBarData, PxVehicleAntiRollBarData
	*/
	PxU32 addAntiRollBarData(const PxVehicleAntiRollBarData& antiRoll);

	/**
	\brief Disable a wheel so that zero suspension forces and zero tire forces are applied to the rigid body from this wheel.

	\note If the vehicle has a differential (PxVehicleNW/PxVehicle4W) then the differential (PxVehicleDifferentialNWData/PxVehicleDifferential4WData)
	needs to be configured so that no drive torque is delivered to the disabled wheel.
	
	\note If the vehicle is of type PxVehicleNoDrive then zero drive torque must be applied to the disabled wheel.
	
	\note For tanks (PxVehicleDriveTank) any drive torque that could be delivered to the wheel through the tank differential will be 
	re-directed to the remaining enabled wheels.

	@see enableWheel
	@see PxVehicleDifferentialNWData::setDrivenWheel
	@see PxVehicleDifferential4WData::mFrontLeftRightSplit, PxVehicleDifferential4WData::mRearLeftRightSplit, PxVehicleDifferential4WData::mType
	@see PxVehicleNoDrive::setDriveTorque
	@see PxVehicle4WEnable3WTadpoleMode, PxVehicle4WEnable3WDeltaMode

	\note If a PxShape is associated with the disabled wheel then the association must be broken by calling setWheelShapeMapping(wheelId, -1). 
	@see setWheelShapeMapping

	\note A wheel that is disabled must also simultaneously be given zero wheel rotation speed.
	@see PxVehicleWheelsDynData::setWheelRotationSpeed

	\note Care must be taken with the sprung mass supported by the remaining enabled wheels.  Depending on the desired effect, the mass of the rigid body 
	might need to be distributed among the remaining enabled wheels and suspensions.

	\param[in] wheel is the wheel index.
	*/
	void disableWheel(const PxU32 wheel);

	/**
	\brief Enable a wheel so that suspension forces and tire forces are applied to the rigid body.
	All wheels are enabled by default and remain enabled until they are disabled.
	\param[in] wheel is the wheel index.
	@see disableWheel
	*/
	void enableWheel(const PxU32 wheel);

	/**
	\brief Test if a wheel has been disabled.
	\param[in] wheel is the wheel index.
	*/
	bool getIsWheelDisabled(const PxU32 wheel) const;

	/**
	\brief Set the number of vehicle sub-steps that will be performed when the vehicle's longitudinal 
	speed is below and above a threshold longitudinal speed.
	
	\note More sub-steps provides better stability but with greater computational cost.
	
	\note Typically, vehicles require more sub-steps at very low forward speeds.
	
	\note The threshold longitudinal speed has a default value that is the equivalent of 5 metres per second after accounting for 
	the length scale set in PxTolerancesScale.  

	\note The sub-step count below the threshold longitudinal speed has a default of 3.
	
	\note The sub-step count above the threshold longitudinal speed has a default of 1.
	
	\note Each sub-step has time advancement equal to the time-step passed to PxVehicleUpdates divided by the number of required sub-steps.
	
	\note The contact planes of the most recent suspension line raycast are reused across all sub-steps.
	
	\note Each sub-step computes tire and suspension forces and then advances a velocity, angular velocity and transform.
	
	\note At the end of all sub-steps the vehicle actor is given the velocity and angular velocity that would move the actor from its start transform prior
	to the first sub-step to the transform computed at the end of the last substep, assuming it doesn't collide with anything along the way in the next PhysX SDK update.
	
	\note The global pose of the actor is left unchanged throughout the sub-steps.

	\param[in] thresholdLongitudinalSpeed is a threshold speed that is used to categorize vehicle speed as low speed or high speed.
	\param[in] lowForwardSpeedSubStepCount is the number of sub-steps performed in PxVehicleUpates for vehicles that have longitudinal speed lower than thresholdLongitudinalSpeed.
	\param[in] highForwardSpeedSubStepCount is the number of sub-steps performed in PxVehicleUpdates for vehicles that have longitudinal speed graeter than thresholdLongitudinalSpeed.
	*/
	void setSubStepCount(const PxReal thresholdLongitudinalSpeed, const PxU32 lowForwardSpeedSubStepCount, const PxU32 highForwardSpeedSubStepCount);

	/**
	\brief Set the minimum denominator used in the longitudinal slip calculation.

	\note The longitudinal slip has a theoretical value of (w*r - vz)/|vz|, where w is the angular speed of the wheel; r is the radius of the wheel; 
	and vz is the component of rigid body velocity (computed at the wheel base) that lies along the longitudinal wheel direction. The term |vz|
	normalizes the slip, while preserving the sign of the longitudinal tire slip.   The difficulty here is that when |vz| approaches zero the 
	longitudinal slip approaches infinity. A solution to this problem is to replace the denominator (|vz|) with a value that never falls below a chosen threshold. 
	The longitudinal slip is then calculated with (w*r - vz)/PxMax(|vz|, minLongSlipDenominator).

	\note The default value is the equivalent of 4 metres per second after accounting for the length scale set in PxTolerancesScale.  

	\note Adjust this value upwards if a vehicle has difficulty coming to rest.

	\note Decreasing the timestep (or increasing the number of sub-steps at low longitudinal speed with setSubStepCount) should allow stable stable 
	behavior with smaller values of minLongSlipDenominator.
	*/
	void setMinLongSlipDenominator(const PxReal minLongSlipDenominator);

	/**
	\brief Set the vehicle wheel simulation flags.

	\param[in] flags The flags to set (see #PxVehicleWheelsSimFlags).

	<b>Default:</b> no flag set

	@see PxVehicleWheelsSimFlag
	*/
	void setFlags(PxVehicleWheelsSimFlags flags);

	/**
	\brief Return the vehicle wheel simulation flags.

	\return The values of the flags.

	@see PxVehicleWheelsSimFlag
	*/
	PxVehicleWheelsSimFlags getFlags() const;

private:

	/**
	\brief Graph to filter normalised load
	@see setTireLoadFilterData, getTireLoadFilterData
	*/
	PxVehicleTireLoadFilterData mNormalisedLoadFilter;

	/**
	\brief Wheels data organised in blocks of 4 wheels.
	*/
	PxVehicleWheels4SimData* mWheels4SimData;

	/**
	\brief Number of blocks of 4 wheels.
	*/
	PxU32 mNbWheels4;

	/**
	\brief Number of actual wheels (<=(mNbWheels4*4))
	*/
	PxU32 mNbActiveWheels;

	/**
	\brief Anti-roll bars
	*/
	PxVehicleAntiRollBarData* mAntiRollBars;

	/**
	\brief 2 anti-rollbars allocated for each block of 4 wheels.
	*/
	PxU32 mNbAntiRollBars4;

	/**
	\brief Number of active anti-roll bars.
	*/
	PxU32 mNbActiveAntiRollBars;

	/**
	\brief Which of the mNbActiveWheels are active or disabled?
	The default is that all mNbActiveWheels wheels are active.
	*/
	PxU32 mActiveWheelsBitmapBuffer[((PX_MAX_NB_WHEELS + 31) & ~31) >> 5];

	/**
	\brief Threshold longitudinal speed used to decide whether to use 
	mLowForwardSpeedSubStepCount or mHighForwardSpeedSubStepCount as the 
	number of sub-steps that will be peformed.
	*/
	PxF32 mThresholdLongitudinalSpeed;

	/**
	\brief Number of sub-steps that will be performed if the longitudinal speed
	of the vehicle is smaller than mThresholdLongitudinalSpeed.
	*/
	PxU32 mLowForwardSpeedSubStepCount;

	/**
	\brief Number of sub-steps that will be performed if the longitudinal speed
	of the vehicle is greater than or equal to mThresholdLongitudinalSpeed.
	*/
	PxU32 mHighForwardSpeedSubStepCount;

	/**
	\brief Minimum long slip denominator
	*/
	PxF32 mMinLongSlipDenominator;

	/**
	\brief The vehicle wheel simulation flags.

	@see PxVehicleWheelsSimFlags
	*/
	PxU32 mFlags;

#if PX_P64_FAMILY
	PxU32 mPad[1];
#endif

	/**
	\brief Test if wheel simulation data has been setup with legal values.
	*/
	bool isValid() const;

	/**
	\brief see PxVehicleWheels::allocate
	*/
	static PxU32 computeByteSize(const PxU32 numWheels);
	static PxU8* patchUpPointers(const PxU32 numWheels, PxVehicleWheelsSimData* simData, PxU8* ptrIn);
	PxVehicleWheelsSimData(const PxU32 numWheels);

//serialization
public:
	PxVehicleWheelsSimData(const PxEMPTY) : mNormalisedLoadFilter(PxEmpty) {}
	static void getBinaryMetaData(PxOutputStream& stream);
	PxU32 getNbWheels4() const { return mNbWheels4; }	
	PxU32 getNbSuspensionData() const { return mNbActiveWheels; }
	PxU32 getNbWheelData() const {	return mNbActiveWheels; }	
	PxU32 getNbSuspTravelDirection() const	{ return mNbActiveWheels; }
	PxU32 getNbTireData() const	{ return mNbActiveWheels;	}	
	PxU32 getNbSuspForceAppPointOffset() const	{ return mNbActiveWheels;	}
	PxU32 getNbTireForceAppPointOffset() const	{ return mNbActiveWheels;	}
	PxU32 getNbWheelCentreOffset() const { return mNbActiveWheels;	}
	PxU32 getNbWheelShapeMapping() const { return mNbActiveWheels; }
	PxU32 getNbSceneQueryFilterData() const { return mNbActiveWheels; }
	PxF32 getMinLongSlipDenominator() const {return mMinLongSlipDenominator;}
	void setThresholdLongSpeed(const PxF32 f) {mThresholdLongitudinalSpeed = f;}
	PxF32 getThresholdLongSpeed() const {return mThresholdLongitudinalSpeed;}
	void setLowForwardSpeedSubStepCount(const PxU32 f) {mLowForwardSpeedSubStepCount = f;}
	PxU32 getLowForwardSpeedSubStepCount() const {return mLowForwardSpeedSubStepCount;}
	void setHighForwardSpeedSubStepCount(const PxU32 f) {mHighForwardSpeedSubStepCount = f;}
	PxU32 getHighForwardSpeedSubStepCount() const {return mHighForwardSpeedSubStepCount;}
	void setWheelEnabledState(const PxU32 wheel, const bool state) {if(state) {enableWheel(wheel);} else {disableWheel(wheel);}}
	bool getWheelEnabledState(const PxU32 wheel) const {return !getIsWheelDisabled(wheel);}
	PxU32 getNbWheelEnabledState() const {return mNbActiveWheels;}
	PxU32 getNbAntiRollBars4() const { return mNbAntiRollBars4; }	
	PxU32 getNbAntiRollBarData() const {return mNbActiveAntiRollBars;}
	void setAntiRollBarData(const PxU32 id, const PxVehicleAntiRollBarData& antiRoll);
	PxVehicleWheelsSimData(){}
	~PxVehicleWheelsSimData(){}
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelsSimData) & 15));


/**
\brief Description of the per wheel intersection method to be used by PxVehicleWheelsDynData::setTireContacts()
*/
struct PX_DEPRECATED PxTireContactIntersectionMethod
{
	enum Enum
	{
		eRAY = 0,
		eCYLINDER
	};
};

/**
\brief Data structure with instanced dynamics data for wheels
*/
class PX_DEPRECATED PxVehicleWheelsDynData
{
//= 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 PxVehicleWheels;
	friend class PxVehicleDrive4W;
	friend class PxVehicleDriveTank;
	friend class PxVehicleUpdate;

	PxVehicleWheelsDynData(){}
	~PxVehicleWheelsDynData(){}

	/**
	\brief Set all wheels to their rest state.
	@see setup
	*/
	void setToRestState();

	/**
	\brief Set the tire force shader function
	\param[in] tireForceShaderFn is the shader function that will be used to compute tire forces.
	*/
	void setTireForceShaderFunction(PxVehicleComputeTireForce tireForceShaderFn);

	/**
	\brief Set the tire force shader data for a specific tire
	\param[in] tireId is the wheel index
	\param[in] tireForceShaderData is the data describing the tire.
	*/
	void setTireForceShaderData(const PxU32 tireId, const void* tireForceShaderData);

	/**
	\brief Get the tire force shader data for a specific tire
	*/
	const void* getTireForceShaderData(const PxU32 tireId) const;

	/**
	\brief Set the wheel rotation speed (radians per second) about the rolling axis for the specified wheel.
	\param[in] wheelIdx is the wheel index
	\param[in] speed is the rotation speed to be applied to the wheel.
	*/
	void setWheelRotationSpeed(const PxU32 wheelIdx, const PxReal speed);

	/**
	\brief Return the rotation speed about the rolling axis of a specified wheel .
	*/
	PxReal getWheelRotationSpeed(const PxU32 wheelIdx) const;
	
	/**
	\brief Set the wheel rotation angle (radians) about the rolling axis of the specified wheel.
	\param[in] wheelIdx is the wheel index
	\param[in] angle is the rotation angle to be applied to the wheel.
	*/
	void setWheelRotationAngle(const PxU32 wheelIdx, const PxReal angle);

	/**
	\brief Return the rotation angle about the rolling axis for the specified wheel.
	*/
	PxReal getWheelRotationAngle(const PxU32 wheelIdx) const;

	/**
	\brief Set the user data pointer for the specified wheel
	It has a default value of NULL.
	\param[in] tireIdx is the wheel index
	\param[in] userData is the data to be associated with the wheel.
	*/
	void setUserData(const PxU32 tireIdx, void* userData);

	/**
	\brief Get the user data pointer that was set for the specified wheel
	*/
	void* getUserData(const PxU32 tireIdx) const;

	/**
	\brief Copy the dynamics data of a single wheel unit (wheel, suspension, tire) from srcWheel of src to trgWheel.
	\param[in] src is the data to be copied.
	\param[in] srcWheel is the wheel whose data will be copied from src.
	\param[in] trgWheel is the wheel that will be assigned the copied data.
	*/
	void copy(const PxVehicleWheelsDynData& src, const PxU32 srcWheel, const PxU32 trgWheel);

	/**
	\brief Directly set tire contact plane and friction for all tires on the vehicle as an alternative to using PxVehicleSuspensionSweeps() or PxVehicleSuspensionRaycasts().
	\param[in] nbHits is an array describing whether each tire has a contact plane or not. Each element of the array is either 0 (no contact) or 1 (contact).
	\param[in] contactPlanes is an array of contact planes describing the contact plane per tire.  
	\param[in] contactFrictions is the friction value of each tire contact with the drivable surface.
	\param[in] intersectionMethods describes how each tire will individually interact with its contact plane in order to compute the spring 
	compression that places the tire on the contact plane. A value of eCYLINDER will compute the spring compression by intersecting the wheel's 
	cylindrical shape with the contact plane. A value of eRAY will compute the spring compression by casting a ray through the wheel center
	and along the suspension direction until it hits the contact plane. 
	\param[in] nbWheels is the length of the arrays nbContacts, contactPlanes, contactFrictions and intersectionMethods.
	\note Each contact plane (n, d) obeys the rule that all points P on the plane satisfy n.dot(P) + d = 0.0.
	\note The contact planes specified by setTireContacts() will persist as driving surfaces until either the next call to setTireContacts() or the next call to 
	\note The friction values are scaled by PxVehicleTireData::mFrictionVsSlipGraph before being applied to the tire.
	\note The vehicle model assumes that the tire contacts are with static objects.
	PxVehicleSuspensionSweeps() or PxVehicleSuspensionRaycasts().
	*/
	void setTireContacts(const PxU32* nbHits, const PxPlane* contactPlanes, const PxReal* contactFrictions, const PxTireContactIntersectionMethod::Enum* intersectionMethods, const PxU32 nbWheels);

private:

    /**
	\brief Dynamics data arranged in blocks of 4 wheels.
	*/
	PxVehicleWheels4DynData* mWheels4DynData;

	/**
	\brief Test if wheel dynamics data have legal values.
	*/
	bool isValid() const;

	/**
	\brief Shader data and function for tire force calculations.
	*/
	PxVehicleTireForceCalculator* mTireForceCalculators;
	
	/**
	\brief A userData pointer can be stored for each wheel.
	@see setUserData, getUserData
	*/
	void** mUserDatas;

	/**
	\brief Number of blocks of 4 wheels.
	*/
	PxU32 mNbWheels4;

	/**
	\brief Number of wheels (mNbActiveWheels <= (mNbWheels4*4))
	*/
	PxU32 mNbActiveWheels;

	PxU32 mPad[3];

	/**
	\brief see PxVehicleWheels::allocate
	*/
	static PxU32 computeByteSize(const PxU32 numWheels);
	static PxU8* patchUpPointers(const PxU32 numWheels, PxVehicleWheelsDynData* dynData, PxU8* ptr);
	PxVehicleWheelsDynData(const PxU32 numWheels);

//serialization
public:
	static void getBinaryMetaData(PxOutputStream& stream);	
	PxU32 getNbWheelRotationSpeed() const {	return mNbActiveWheels; }
	PxU32 getNbWheelRotationAngle() const {	return mNbActiveWheels; }	
	PxVehicleWheels4DynData* getWheel4DynData() const { return mWheels4DynData; }
//~serialization

	/**
	\brief Retrieve the number of PxConstraint objects associated with the vehicle.

	You can use #getConstraints() to retrieve the constraint pointers.

	\return Number of constraints associated with this vehicle.

	@see PxConstraint getConstraints()
	*/
	PxU32 getNbConstraints() const { return mNbWheels4; }

	/**
	\brief Retrieve all the PxConstraint objects associated with the vehicle.

	There is one PxConstraint per block of 4 wheels. The count can be extracted through #getNbConstraints()

	\param[out] userBuffer The buffer to store the constraint pointers.
	\param[in] bufferSize Size of provided user buffer.
	\param[in] startIndex Index of first constraint pointer to be retrieved
	\return Number of constraint pointers written to the buffer.

	@see PxConstraint getNbConstraints()
	*/
	PxU32 getConstraints(PxConstraint** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const;
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheelsDynData) & 15));

/**
\brief Data structure with instanced dynamics data and configuration data of a vehicle with just wheels
@see PxVehicleDrive, PxVehicleDrive4W, PxVehicleDriveTank
*/
class PX_DEPRECATED PxVehicleWheels : public PxBase
{
//= 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;
	friend class PxVehicleConstraintShader;

	/**
	\brief Return the type of vehicle 
	@see PxVehicleTypes
	*/
	PX_FORCE_INLINE PxU32 getVehicleType() const {return mType;}

	/**
	\brief Get non-const ptr to PxRigidDynamic instance that is the vehicle's physx representation
	*/
	PX_FORCE_INLINE PxRigidDynamic* getRigidDynamicActor() {return mActor;}

	/**
	\brief Get const ptr to PxRigidDynamic instance that is the vehicle's physx representation
	*/
	PX_FORCE_INLINE const PxRigidDynamic* getRigidDynamicActor() const {return mActor;}
	
	/**
	\brief Compute the rigid body velocity component along the forward vector of the rigid body transform.

	\param[in] forwardAxis The axis denoting the local space forward direction of the vehicle.

	@see PxVehicleSetBasisVectors
	*/
	PxReal computeForwardSpeed(const PxVec3& forwardAxis = PxVehicleGetDefaultContext().forwardAxis) const;

	/**
	\brief Compute the rigid body velocity component along the right vector of the rigid body transform.

	\param[in] sideAxis The axis denoting the local space side direction of the vehicle.

	@see PxVehicleSetBasisVectors
	*/
	PxReal computeSidewaysSpeed(const PxVec3& sideAxis = PxVehicleGetDefaultContext().sideAxis) const;

	/**
	\brief Data describing the setup of all the wheels/suspensions/tires.
	*/
	PxVehicleWheelsSimData mWheelsSimData;

	/**
	\brief Data describing the dynamic state of all wheels/suspension/tires.
	*/
	PxVehicleWheelsDynData mWheelsDynData;	

protected:

	/**
	\brief Set all wheels to their rest state
	*/
	void setToRestState();

	/**
	\brief Test that all configuration and instanced dynamics data is valid.
	*/
	bool isValid() const;

	/**
	@see PxVehicleDrive4W::allocate, PxVehicleDriveTank::allocate
	*/
	static PxU32 computeByteSize(const PxU32 nbWheels);
	static PxU8* patchupPointers(const PxU32 nbWheels, PxVehicleWheels* vehWheels, PxU8* ptr);
	virtual void init(const PxU32 numWheels);

	/**
	\brief Deallocate a PxVehicleWheels instance.
	@see PxVehicleDrive4W::free, PxVehicleDriveTank::free
	*/
	void free();

	/*
	\brief Deferred deletion.
	*/
	void onConstraintRelease();

	/**
	@see PxVehicleDrive4W::setup, PxVehicleDriveTank::setup
	*/
	void setup
		(PxPhysics* physics, PxRigidDynamic* vehActor, 
		 const PxVehicleWheelsSimData& wheelsData,
		 const PxU32 nbDrivenWheels, const PxU32 nbNonDrivenWheels);
	
	/**
	\brief The rigid body actor that represents the vehicle in the PhysX SDK.
	*/
	PxRigidDynamic* mActor;

private:

	/**
	\brief Count the number of constraint connectors that have hit their callback when deleting a vehicle.
	Can only delete the vehicle's memory when all constraint connectors have hit their callback.
	*/
	PxU32 mNbNonDrivenWheels;
	
	PxU8 mOnConstraintReleaseCounter;

protected:

	/**
	\brief Vehicle type (eVehicleDriveTypes)
	*/
	PxU8 mType;
		
#if PX_P64_FAMILY
	PxU8 mPad0[14];
#else
	PxU8 mPad0[8];
#endif

//serialization
public:
	virtual		void			requiresObjects(PxProcessPxBaseCallback& c);
	virtual		const char*		getConcreteTypeName() const				{	return "PxVehicleWheels"; }
	virtual		bool			isKindOf(const char* name)	const		{	return !::strcmp("PxVehicleWheels", name) || PxBase::isKindOf(name); }
	virtual		void			preExportDataReset() {}
	virtual		void			exportExtraData(PxSerializationContext&);	
				void			importExtraData(PxDeserializationContext&);
				void			resolveReferences(PxDeserializationContext&);
	static		void			getBinaryMetaData(PxOutputStream& stream);
	PX_FORCE_INLINE PxU32 getNbNonDrivenWheels() const { return mNbNonDrivenWheels; }
	PxVehicleWheels(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
	PxVehicleWheels(PxBaseFlags baseFlags) : PxBase(baseFlags), mWheelsSimData(PxEmpty) {}
	virtual ~PxVehicleWheels() {}
	virtual void release() { free(); }
//~serialization
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheels) & 15));

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif