PxVehicleSuspWheelTire4.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_SUSP_WHEEL_TIRE4_H
#define PX_VEHICLE_SUSP_WHEEL_TIRE4_H
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxVec3.h"
#include "foundation/PxVec4.h"
#include "foundation/PxTransform.h"
#include "foundation/PxIO.h"
#include "geometry/PxGeometryHelpers.h"
#include "vehicle/PxVehicleComponents.h"
#include "PxVehicleSuspLimitConstraintShader.h"
#include "extensions/PxSceneQueryExt.h"
 
#if !PX_DOXYGEN
namespace physx
{
#endif
 
class PxMaterial;
class PxShape;
 
class PxVehicleWheels4SimData
{
//= 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;
 
    PxVehicleWheels4SimData();
 
    bool isValid(const PxU32 id) const;
 
    static void getBinaryMetaData(PxOutputStream& stream);
 
public:
 
    PX_FORCE_INLINE const PxVehicleSuspensionData&      getSuspensionData(const PxU32 id)           const {return mSuspensions[id];}
    PX_FORCE_INLINE const PxVehicleWheelData&           getWheelData(const PxU32 id)                const {return mWheels[id];}
    PX_FORCE_INLINE const PxVehicleTireData&            getTireData(const PxU32 id)                 const {return mTires[id];}
    PX_FORCE_INLINE const PxVec3&                       getSuspTravelDirection(const PxU32 id)      const {return mSuspDownwardTravelDirections[id];}
    PX_FORCE_INLINE const PxVec3&                       getSuspForceAppPointOffset(const PxU32 id)  const {return mSuspForceAppPointOffsets[id];}
    PX_FORCE_INLINE const PxVec3&                       getTireForceAppPointOffset(const PxU32 id)  const {return mTireForceAppPointOffsets[id];}
    PX_FORCE_INLINE const PxVec3&                       getWheelCentreOffset(const PxU32 id)        const {return mWheelCentreOffsets[id];}
    PX_FORCE_INLINE       PxI32                         getWheelShapeMapping(const PxU32 id)        const {return (PX_MAX_U8 != mWheelShapeMap[id]) ? mWheelShapeMap[id] : -1;}
    PX_FORCE_INLINE const PxFilterData&                 getSceneQueryFilterData(const PxU32 id)     const {return mSqFilterData[id];}
    PX_FORCE_INLINE const PxReal*                       getTireRestLoadsArray()                     const {return mTireRestLoads;}
    PX_FORCE_INLINE const PxReal*                       getRecipTireRestLoadsArray()                const {return mRecipTireRestLoads;}
 
                    void setSuspensionData              (const PxU32 id, const PxVehicleSuspensionData& susp);
                    void setWheelData                   (const PxU32 id, const PxVehicleWheelData& susp);
                    void setTireData                    (const PxU32 id, const PxVehicleTireData& tire);
                    void setSuspTravelDirection         (const PxU32 id, const PxVec3& dir);
                    void setSuspForceAppPointOffset     (const PxU32 id, const PxVec3& offset);
                    void setTireForceAppPointOffset     (const PxU32 id, const PxVec3& offset);
                    void setWheelCentreOffset           (const PxU32 id, const PxVec3& offset);
                    void setWheelShapeMapping           (const PxU32 id, const PxI32 shapeId);
                    void setSceneQueryFilterData        (const PxU32 id, const PxFilterData& sqFilterData);
 
private:
 
    PxVehicleSuspensionData         mSuspensions[4];
 
    PxVehicleWheelData              mWheels[4];
 
    PxVehicleTireData               mTires[4];
 
    PxVec3                          mSuspDownwardTravelDirections[4];
 
    PxVec3                          mSuspForceAppPointOffsets[4];   //Offset from cm
 
    PxVec3                          mTireForceAppPointOffsets[4];   //Offset from cm
 
    PxVec3                          mWheelCentreOffsets[4];         //Offset from cm
 
    PxReal                          mTireRestLoads[4];  
 
    PxReal                          mRecipTireRestLoads[4]; 
 
    PxFilterData                    mSqFilterData[4];
 
    PxU8                            mWheelShapeMap[4];
 
    PxU32                           mPad[3];
};
PX_COMPILE_TIME_ASSERT(0 == (sizeof(PxVehicleWheels4SimData) & 15));
 
class PxVehicleWheels4DynData
{
//= 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;
 
    PxVehicleWheels4DynData()
        :   mRaycastResults(NULL),
            mSweepResults(NULL)
    {
        setToRestState();
    }
    ~PxVehicleWheels4DynData()
    {
    }
 
    bool isValid() const {return true;}
 
    static void getBinaryMetaData(PxOutputStream& stream);
 
    void setToRestState()
    {
        for(PxU32 i=0;i<4;i++)
        {
            mWheelSpeeds[i] = 0.0f;
            mCorrectedWheelSpeeds[i] = 0.0f;
            mWheelRotationAngles[i] = 0.0f;
            mTireLowForwardSpeedTimers[i] = 0.0f;
            mTireLowSideSpeedTimers[i] = 0.0f;
            mJounces[i] = PX_MAX_F32;
            mSteerAngles[i] = 0.0f;
            mVehicleConstraints->mData.mStickyTireForwardData.mActiveFlags[i] = false;
            mVehicleConstraints->mData.mStickyTireSideData.mActiveFlags[i] = false;
            mVehicleConstraints->mData.mSuspLimitData.mActiveFlags[i] = false;
        }
        PxMemZero(mQueryOrCachedHitResults, sizeof(SuspLineSweep));
 
        mRaycastResults = NULL;
        mSweepResults = NULL;
        mHasCachedRaycastHitPlane = false;
    }
 
    void setInternalDynamicsToZero()
    {
        for(PxU32 i=0;i<4;i++)
        {
            mWheelSpeeds[i] = 0.0f;
            mCorrectedWheelSpeeds[i] = 0.0f;
            mJounces[i] = PX_MAX_F32; //Ensure that the jounce speed is zero when the car wakes up again. 
            mSteerAngles[i] = 0.0f;
        }
    }
 
    void setTireContacts(const PxU32* cachedHitCounts, const PxPlane* cachedHitPlanes, const PxF32* cachedFrictionMultipliers, const PxTireContactIntersectionMethod::Enum* cachedQueryTypes)
    {
        mHasCachedRaycastHitPlane = true;
        mRaycastResults = NULL;
        mSweepResults = NULL;
 
        PxVehicleWheels4DynData::CachedSuspLineSceneQuerytHitResult* cachedRaycastHitResults =
            reinterpret_cast<PxVehicleWheels4DynData::CachedSuspLineSceneQuerytHitResult*>(mQueryOrCachedHitResults);
 
        for (PxU32 i = 0; i < 4; i++)
        {
            cachedRaycastHitResults->mCounts[i] = PxU16(cachedHitCounts[i]);
            cachedRaycastHitResults->mPlanes[i] = cachedHitPlanes[i];
            cachedRaycastHitResults->mDistances[i] = 1.0f;
            cachedRaycastHitResults->mFrictionMultipliers[i] = cachedFrictionMultipliers[i];
            cachedRaycastHitResults->mQueryTypes[i] = ((cachedQueryTypes[i] == PxTireContactIntersectionMethod::eRAY) ? 0 : 1);
        }
    }
 
    PxReal mWheelSpeeds[4];
 
    PxReal mCorrectedWheelSpeeds[4];
 
    PxReal mWheelRotationAngles[4];
 
    PxReal mTireLowForwardSpeedTimers[4];
 
    PxReal mTireLowSideSpeedTimers[4];
 
    PxReal mJounces[4];
 
    PxReal mSteerAngles[4];
 
    struct SuspLineSweep
    {
        PxGeometryHolder mGometries[4];
 
        PxTransform mStartPose[4];
 
        PxVec3 mDirs[4];
 
        PxReal mLengths[4];
    };
 
    struct SuspLineRaycast
    {
        PxVec3 mStarts[4];
 
        PxVec3 mDirs[4];
 
        PxReal mLengths[4];
 
        PxU32 mPad[16];
    };
 
    struct CachedSuspLineSceneQuerytHitResult
    {
        PxPlane mPlanes[4];
 
        PxF32 mFrictionMultipliers[4];
 
        PxF32 mDistances[4];
 
        PxU16 mCounts[4];
 
        PxU16 mQueryTypes[4];
 
        PxU32 mPad1[16];
    };
 
    PxU8 mQueryOrCachedHitResults[sizeof(SuspLineSweep)];
 
    void setVehicleConstraintShader(PxVehicleConstraintShader* shader) {mVehicleConstraints=shader;}
    PxVehicleConstraintShader& getVehicletConstraintShader() const {return *mVehicleConstraints;} 
 
private:
 
    //Susp limits and sticky tire friction for all wheels.
    PxVehicleConstraintShader* mVehicleConstraints;
 
public:
 
    const PxRaycastBuffer* mRaycastResults;
 
    const PxSweepBuffer* mSweepResults;
 
    bool mHasCachedRaycastHitPlane;
 
 
#if PX_P64_FAMILY
    PxU32 mPad[12];
#endif
};
PX_COMPILE_TIME_ASSERT(0==(sizeof(PxVehicleWheels4DynData) & 15));
PX_COMPILE_TIME_ASSERT((0 == (sizeof(PxVehicleWheels4DynData::SuspLineSweep) & 0x0f)));
PX_COMPILE_TIME_ASSERT(sizeof(PxVehicleWheels4DynData::SuspLineRaycast) <= sizeof(PxVehicleWheels4DynData::SuspLineSweep));
PX_COMPILE_TIME_ASSERT(sizeof(PxVehicleWheels4DynData::CachedSuspLineSceneQuerytHitResult) <= sizeof(PxVehicleWheels4DynData::SuspLineSweep));
 
#if !PX_DOXYGEN
} // namespace physx
#endif
 
#endif