Wheel.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Body/Body.h>
#include <Jolt/Physics/Constraints/ConstraintPart/AxisConstraintPart.h>
#include <Jolt/ObjectStream/SerializableObject.h>
#include <Jolt/Core/StreamIn.h>
#include <Jolt/Core/StreamOut.h>
 
JPH_NAMESPACE_BEGIN
 
class VehicleConstraint;
 
class JPH_EXPORT WheelSettings : public SerializableObject, public RefTarget<WheelSettings>
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, WheelSettings)
 
public:
    virtual void            SaveBinaryState(StreamOut &inStream) const;
 
    virtual void            RestoreBinaryState(StreamIn &inStream);
 
    Vec3                    mPosition { 0, 0, 0 };                      
    Vec3                    mSuspensionForcePoint { 0, 0, 0 };          
    Vec3                    mSuspensionDirection { 0, -1, 0 };          
    Vec3                    mSteeringAxis { 0, 1, 0 };                  
    Vec3                    mWheelUp { 0, 1, 0 };                       
    Vec3                    mWheelForward { 0, 0, 1 };                  
    float                   mSuspensionMinLength = 0.3f;                
    float                   mSuspensionMaxLength = 0.5f;                
    float                   mSuspensionPreloadLength = 0.0f;            
    SpringSettings          mSuspensionSpring { ESpringMode::FrequencyAndDamping, 1.5f, 0.5f }; 
    float                   mRadius = 0.3f;                             
    float                   mWidth = 0.1f;                              
    bool                    mEnableSuspensionForcePoint = false;        
};
 
class JPH_EXPORT Wheel : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                Wheel(const WheelSettings &inSettings);
    virtual                 ~Wheel() = default;
 
    const WheelSettings *   GetSettings() const                         { return mSettings; }
 
    float                   GetAngularVelocity() const                  { return mAngularVelocity; }
 
    void                    SetAngularVelocity(float inVel)             { mAngularVelocity = inVel; }
 
    float                   GetRotationAngle() const                    { return mAngle; }
 
    void                    SetRotationAngle(float inAngle)             { mAngle = inAngle; }
 
    float                   GetSteerAngle() const                       { return mSteerAngle; }
 
    void                    SetSteerAngle(float inAngle)                { mSteerAngle = inAngle; }
 
    inline bool             HasContact() const                          { return !mContactBodyID.IsInvalid(); }
 
    BodyID                  GetContactBodyID() const                    { return mContactBodyID; }
 
    SubShapeID              GetContactSubShapeID() const                { return mContactSubShapeID; }
 
    RVec3                   GetContactPosition() const                  { JPH_ASSERT(HasContact()); return mContactPosition; }
 
    Vec3                    GetContactPointVelocity() const             { JPH_ASSERT(HasContact()); return mContactPointVelocity; }
 
    Vec3                    GetContactNormal() const                    { JPH_ASSERT(HasContact()); return mContactNormal; }
 
    Vec3                    GetContactLongitudinal() const              { JPH_ASSERT(HasContact()); return mContactLongitudinal; }
 
    Vec3                    GetContactLateral() const                   { JPH_ASSERT(HasContact()); return mContactLateral; }
 
    float                   GetSuspensionLength() const                 { return mSuspensionLength; }
 
    bool                    HasHitHardPoint() const                     { return mSuspensionMaxUpPart.IsActive(); }
 
    float                   GetSuspensionLambda() const                 { return mSuspensionPart.GetTotalLambda() + mSuspensionMaxUpPart.GetTotalLambda(); }
 
    float                   GetLongitudinalLambda() const               { return mLongitudinalPart.GetTotalLambda(); }
 
    float                   GetLateralLambda() const                    { return mLateralPart.GetTotalLambda(); }
 
    bool                    SolveLongitudinalConstraintPart(const VehicleConstraint &inConstraint, float inMinImpulse, float inMaxImpulse);
 
    bool                    SolveLateralConstraintPart(const VehicleConstraint &inConstraint, float inMinImpulse, float inMaxImpulse);
 
protected:
    friend class VehicleConstraint;
 
    RefConst<WheelSettings> mSettings;                                  
    BodyID                  mContactBodyID;                             
    SubShapeID              mContactSubShapeID;                         
    Body *                  mContactBody = nullptr;                     
    float                   mSuspensionLength;                          
    RVec3                   mContactPosition;                           
    Vec3                    mContactPointVelocity;                      
    Vec3                    mContactNormal;                             
    Vec3                    mContactLongitudinal;                       
    Vec3                    mContactLateral;                            
    Real                    mAxlePlaneConstant;                         
    float                   mAntiRollBarImpulse = 0.0f;                 
 
    float                   mSteerAngle = 0.0f;                         
    float                   mAngularVelocity = 0.0f;                    
    float                   mAngle = 0.0f;                              
 
    AxisConstraintPart      mSuspensionPart;                            
    AxisConstraintPart      mSuspensionMaxUpPart;                       
    AxisConstraintPart      mLongitudinalPart;                          
    AxisConstraintPart      mLateralPart;                               
};
 
using Wheels = Array<Wheel *>;
 
JPH_NAMESPACE_END