CharacterBase.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/Core/Reference.h>
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Physics/Body/BodyID.h>
#include <Jolt/Physics/Collision/Shape/Shape.h>
#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
#include <Jolt/Physics/Collision/PhysicsMaterial.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;
class StateRecorder;
 
class JPH_EXPORT CharacterBaseSettings : public RefTarget<CharacterBaseSettings>
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                        CharacterBaseSettings() = default;
                                        CharacterBaseSettings(const CharacterBaseSettings &inSettings) = default;
    CharacterBaseSettings &             operator = (const CharacterBaseSettings &inSettings) = default;
 
    virtual                             ~CharacterBaseSettings() = default;
 
    Vec3                                mUp = Vec3::sAxisY();
 
    Plane                               mSupportingVolume { Vec3::sAxisY(), -1.0e10f };
 
    float                               mMaxSlopeAngle = DegreesToRadians(50.0f);
 
    RefConst<Shape>                     mShape;
};
 
class JPH_EXPORT CharacterBase : public RefTarget<CharacterBase>, public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
                                        CharacterBase(const CharacterBaseSettings *inSettings, PhysicsSystem *inSystem);
 
    virtual                             ~CharacterBase() = default;
 
    void                                SetMaxSlopeAngle(float inMaxSlopeAngle)                 { mCosMaxSlopeAngle = Cos(inMaxSlopeAngle); }
    float                               GetCosMaxSlopeAngle() const                             { return mCosMaxSlopeAngle; }
 
    void                                SetUp(Vec3Arg inUp)                                     { mUp = inUp; }
    Vec3                                GetUp() const                                           { return mUp; }
 
    bool                                IsSlopeTooSteep(Vec3Arg inNormal) const
    {
        // If cos max slope angle is close to one the system is turned off,
        // otherwise check the angle between the up and normal vector
        return mCosMaxSlopeAngle < cNoMaxSlopeAngle && inNormal.Dot(mUp) < mCosMaxSlopeAngle;
    }
 
    const Shape *                       GetShape() const                                        { return mShape; }
 
    enum class EGroundState
    {
        OnGround,                       
        OnSteepGround,                  
        NotSupported,                   
        InAir,                          
    };
 
    static const char *                 sToString(EGroundState inState);
 
 
    EGroundState                        GetGroundState() const                                  { return mGroundState; }
 
    bool                                IsSupported() const                                     { return mGroundState == EGroundState::OnGround || mGroundState == EGroundState::OnSteepGround; }
 
    RVec3                               GetGroundPosition() const                               { return mGroundPosition; }
 
    Vec3                                GetGroundNormal() const                                 { return mGroundNormal; }
 
    Vec3                                GetGroundVelocity() const                               { return mGroundVelocity; }
 
    const PhysicsMaterial *             GetGroundMaterial() const                               { return mGroundMaterial; }
 
    BodyID                              GetGroundBodyID() const                                 { return mGroundBodyID; }
 
    SubShapeID                          GetGroundSubShapeID() const                             { return mGroundBodySubShapeID; }
 
    uint64                              GetGroundUserData() const                               { return mGroundUserData; }
 
    // Saving / restoring state for replay
    virtual void                        SaveState(StateRecorder &inStream) const;
    virtual void                        RestoreState(StateRecorder &inStream);
 
protected:
    // Cached physics system
    PhysicsSystem *                     mSystem;
 
    // The shape that the body currently has
    RefConst<Shape>                     mShape;
 
    // The character's world space up axis
    Vec3                                mUp;
 
    // Every contact behind this plane can support the character
    Plane                               mSupportingVolume;
 
    // Beyond this value there is no max slope
    static constexpr float              cNoMaxSlopeAngle = 0.9999f;
 
    // Cosine of the maximum angle of slope that character can still walk on
    float                               mCosMaxSlopeAngle;
 
    // Ground properties
    EGroundState                        mGroundState = EGroundState::InAir;
    BodyID                              mGroundBodyID;
    SubShapeID                          mGroundBodySubShapeID;
    RVec3                               mGroundPosition = RVec3::sZero();
    Vec3                                mGroundNormal = Vec3::sZero();
    Vec3                                mGroundVelocity = Vec3::sZero();
    RefConst<PhysicsMaterial>           mGroundMaterial = PhysicsMaterial::sDefault;
    uint64                              mGroundUserData = 0;
};
 
JPH_NAMESPACE_END