PhysicsManager.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
// clang-format off
#include <Jolt/Jolt.h>
// clang-format on
 
#include "utils/ContactListenerImpl.hpp"
 
#include <Jolt/Core/Factory.h>
#include <Jolt/Core/JobSystemThreadPool.h>
#include <Jolt/Core/TempAllocator.h>
#include <Jolt/Physics/Body/BodyActivationListener.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseLayer.h>
#include <Jolt/Physics/PhysicsSettings.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/RegisterTypes.h>
 
namespace Physics::Resource {
class PhysicsManager {
  public:
    PhysicsManager();

    ~PhysicsManager() = default;

    void Init(Engine::Core &core);

    inline JPH::PhysicsSystem &GetPhysicsSystem() { return *_physicsSystem; }
    inline const JPH::PhysicsSystem &GetPhysicsSystem() const { return *_physicsSystem; }

    inline JPH::BodyInterface &GetBodyInterface() { return _physicsSystem->GetBodyInterface(); }

    inline JPH::TempAllocator *GetTempAllocator() { return _tempAllocator.get(); }

    inline JPH::JobSystem *GetJobSystem() { return _jobSystem.get(); }

    inline int GetCollisionSteps() { return _collisionSteps; }

    inline void SetCollisionSteps(int steps) { _collisionSteps = steps; }

    inline std::shared_ptr<Utils::ContactListenerImpl> GetContactListener()
    {
        if (_contactListener == nullptr)
        {
            return nullptr;
        }
 
        return std::dynamic_pointer_cast<Utils::ContactListenerImpl>(_contactListener);
    }

    inline bool IsPhysicsActivated() const { return _shouldUpdatePhysics; }

    inline void ActivatePhysics() { _shouldUpdatePhysics = true; }

    inline void DeactivatePhysics() { _shouldUpdatePhysics = false; }
 
  private:
    std::shared_ptr<JPH::Factory> _factory;
    std::shared_ptr<JPH::PhysicsSystem> _physicsSystem;
 
    std::shared_ptr<JPH::BroadPhaseLayerInterface> _broadPhaseLayerInterface;
    std::shared_ptr<JPH::ObjectVsBroadPhaseLayerFilter> _objectVsBroadPhaseLayerFilter;
    std::shared_ptr<JPH::ObjectLayerPairFilter> _objectLayerPairFilter;
    std::shared_ptr<JPH::TempAllocator> _tempAllocator;
    std::shared_ptr<JPH::JobSystem> _jobSystem;
    std::shared_ptr<JPH::ContactListener> _contactListener;
 
    bool _shouldUpdatePhysics = true;
 
    int _collisionSteps = 1;
};
} // namespace Physics::Resource