CharacterBody.hpp

#pragma once
#ifdef StevEngine_PHYSICS
#include "main/Component.hpp"
#include "physics/Layers.hpp"
#include "utilities/Vector3.hpp"
 
#include "Jolt/Physics/Character/CharacterVirtual.h"
 
#define CHARACTERBODY_TYPE "CharacterBody"
 
namespace StevEngine::Physics {
    struct CharacterSettings {
        float mass = 70;                            
        float maxStrength = 100;                 
        float predictiveContactDistance = 0.1f;        
        uint32_t maxCollisionIterations = 5;      
        uint32_t maxConstraintIterations = 15;       
        float minTimeRemaining = 1.0e-4f;           
        float collisionTolerance = 1.0e-3f;           
        float characterPadding = 0.02f;             
        uint32_t maxNumHits = 256;                    
        float hitReductionCosMaxAngle = 0.999f;      
        float penetrationRecoverySpeed = 1.0f;      
    };

    class CharacterBody : public Component {
        public:
            static const bool unique = true;          
            CharacterBody(CharacterSettings settings = {}, LayerID layer = LayerManager::DEFAULT);

            CharacterBody(Utilities::Stream& stream);
 
            Utilities::Vector3 velocity; 

            virtual std::string GetType() const { return CHARACTERBODY_TYPE; }

            virtual Utilities::Stream Export(Utilities::StreamType type) const;

            virtual void Start();

            virtual void Deactivate();

            virtual void Update(double deltaTime);

            void ExtendedUpdate(double deltaTime, JPH::CharacterVirtual::ExtendedUpdateSettings updateSettings = {});

            virtual ~CharacterBody();

            virtual bool RefreshShape();
 
        protected:
            JPH::CharacterVirtualSettings settings;     
            LayerID layer;                                 
 
            bool SetShape(JPH::Ref<JPH::Shape> shape, Utilities::Vector3 shapeOffset = 0);    
            JPH::Ref<JPH::Shape> GetShape() const { return shape; }                     
 
        private:
            JPH::CharacterVirtual* jphCharacter;        
            JPH::Ref<JPH::Shape> shape;                 
 
            // Jolt filters
            JPH::BodyFilter bodyFilter;
            JPH::ShapeFilter shapeFilter;
 
        // Function wrappers
        public:
            bool    IsSupported() const { return jphCharacter->IsSupported(); }; 
            bool    IsOnGround() const { return jphCharacter->GetGroundState() == JPH::CharacterBase::EGroundState::OnGround; }; 
            float   GetMass () const { return jphCharacter->GetMass(); }; 
            void    SetMass (float mass) { jphCharacter->SetMass(mass); settings.mMass = mass; }; 
            float   GetMaxStrength () const { return jphCharacter->GetMaxStrength(); }; 
            void    SetMaxStrength (float maxStrength) { jphCharacter->SetMaxStrength(maxStrength); settings.mMaxStrength = maxStrength; };
            float   GetPenetrationRecoverySpeed () const { return jphCharacter->GetPenetrationRecoverySpeed(); }; 
            void    SetPenetrationRecoverySpeed (float speed) { jphCharacter->SetPenetrationRecoverySpeed(speed); settings.mPenetrationRecoverySpeed = speed; }; 
            float   GetCharacterPadding () const  { return jphCharacter->GetCharacterPadding(); };
            uint    GetMaxNumHits () const  { return jphCharacter->GetMaxNumHits(); };
            void    SetMaxNumHits (uint maxHits) { jphCharacter->SetMaxNumHits(maxHits); settings.mMaxNumHits = maxHits; }; 
            float   GetHitReductionCosMaxAngle () const { return jphCharacter->GetHitReductionCosMaxAngle(); }; 
            void    SetHitReductionCosMaxAngle (float cosMaxAngle) { jphCharacter->SetHitReductionCosMaxAngle(cosMaxAngle); settings.mHitReductionCosMaxAngle = cosMaxAngle; }; 
            void    SetMaxSlopeAngle (float maxSlopeAngle) { jphCharacter->SetMaxSlopeAngle(maxSlopeAngle); settings.mMaxSlopeAngle = maxSlopeAngle; }; 
            bool    IsSlopeTooSteep (Utilities::Vector3 normal) const { return jphCharacter->IsSlopeTooSteep(normal); }; 
    };
}
#endif