PhysicsEngine.h

Go to the documentation of this file.

#pragma once
 
#include <btBulletDynamicsCommon.h>
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
namespace Engine
{
    namespace Components
    {
        class PhysicsBody;
    }
 
    namespace Physics
    {
        struct RaycastHit
        {
            glm::vec3                point{ 0.0f };

            glm::vec3                normal{ 0.0f };

            float                    fraction = 0.0f;

            float                    distance = 0.0f;

            const btCollisionObject* collisionObject = nullptr;

            [[nodiscard]] Components::PhysicsBody* getPhysicsBody() const;
        };

        struct RigidBodyCreateInfo
        {
            glm::mat4 transform {1.0f};
            float mass = 1.0f;
            btCollisionShape* shape = nullptr;
            float friction = 0.5f;
            float restitution = 0.0f;
        };
    }
 
    namespace Core
    {
        class PhysicsEngine
        {
        public:
            PhysicsEngine();
            ~PhysicsEngine();

            void onPhysicsComponentDestroyed( entt::registry & registry, entt::entity entity );

            void update(float deltaTimeSeconds);

            [[nodiscard]] btDiscreteDynamicsWorld * getDynamicsWorld() const;

            [[nodiscard]] bool raycastClosest(
                const glm::vec3& origin,
                const glm::vec3& direction,
                float maxDistance,
                Physics::RaycastHit& outHit
            ) const;

            [[nodiscard]] bool sphereSweepClosest(
                const glm::vec3& from,
                const glm::vec3& to,
                float radius,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            [[nodiscard]] bool sphereClosest(
                const glm::vec3& position,
                float radius,
                Physics::RaycastHit& outHit,
                const btCollisionObject* ignoredObject = nullptr
            ) const;

            static btCollisionShape * createBoxShape(const glm::vec3& halfExtents);
            static btCollisionShape * createSphereShape(float radius);
            static btCollisionShape * createCapsuleShape(float radius, float height);
            static btCollisionShape * createPlaneShape(const glm::vec3& surfaceNormal, float distanceFromOrigin);

            static btCollisionShape * createConvexHullShape(const std::vector<glm::vec3>& vertices);

            static btCollisionShape * createTriangleMeshShape(
                const std::vector<glm::vec3>& vertices,
                const std::vector<uint32_t>& indices,
                btTriangleMesh*& triangleMeshOut);

            static btCompoundShape * createCompoundShape();

            [[nodiscard]] btRigidBody * createRigidBody( const Physics::RigidBodyCreateInfo & info ) const;

            void removeRigidBody(btRigidBody* body ) const;

            void debugDrawAll() const;
 
        private:
            btBroadphaseInterface* broadphase;
            btCollisionConfiguration* collisionConfiguration;
            btCollisionDispatcher* dispatcher;
            btConstraintSolver* solver;
            btDiscreteDynamicsWorld* dynamicsWorld;
        };
    }
}