PhysicsEngine.cpp

Go to the documentation of this file.

#include "Engine/Ecs/EcsData.h"
#include "Engine/Ecs/RegistryManager.h"
#include "Engine/Logging/TracyMacros.hpp"
#include "Engine/Math/Converter.h"
#include "glm/gtc/type_ptr.inl"
 
#include <Engine/Physics/PhysicsEngine.h>
 
namespace EngineCore
{
    PhysicsEngine::PhysicsEngine()
    {
        broadphase             = new btDbvtBroadphase();
        collisionConfiguration = new btDefaultCollisionConfiguration();
        dispatcher             = new btCollisionDispatcher( collisionConfiguration );
        solver                 = new btSequentialImpulseConstraintSolver();
        dynamicsWorld = new btDiscreteDynamicsWorld( dispatcher, broadphase, solver, collisionConfiguration );
        dynamicsWorld->setGravity( btVector3( 0.0f, -9.81f, 0.0f ) );
 
        auto& registry = Ecs::RegistryManager::get();
        registry.on_destroy<Ecs::SimulatesPhysics>(  ).connect<&PhysicsEngine::onPhysicsComponentDestroyed>(this);
    }
 
    PhysicsEngine::~PhysicsEngine()
    {
        for ( int i = 0; i < dynamicsWorld->getNumCollisionObjects(); i++ )
        {
            btCollisionObject * object = dynamicsWorld->getCollisionObjectArray()[i];
            if ( object != nullptr )
            {
                btRigidBody * body = btRigidBody::upcast( object );
                if ( body && body->getMotionState() )
                {
                    delete body->getMotionState();
                }
                dynamicsWorld->removeCollisionObject( object );
                delete object;
            }
        }
 
        delete dynamicsWorld;
        delete solver;
        delete dispatcher;
        delete collisionConfiguration;
        delete broadphase;
    }
 
    void PhysicsEngine::onPhysicsComponentDestroyed(entt::registry& registry, entt::entity entity)
    {
        auto& physics = registry.get<Ecs::SimulatesPhysics>(entity); // still valid in on_destroy
        if (physics.rigidBody)
        {
            dynamicsWorld->removeRigidBody(physics.rigidBody);
            delete physics.rigidBody->getMotionState();
            delete physics.rigidBody;
        }
 
        if (physics.collisionShape)
        {
            delete physics.collisionShape;
        }
    }
 
    void PhysicsEngine::update( float deltaTimeSeconds )
    {
        TRACY_ZONE_SCOPED_NAMED( "Physics Tick" );
        dynamicsWorld->stepSimulation( deltaTimeSeconds, 10, 1.0f/120.0f);
    }
 
    btDiscreteDynamicsWorld * PhysicsEngine::getDynamicsWorld() const
    {
        return dynamicsWorld;
    }
 
    btCollisionShape * PhysicsEngine::createBoxShape( const glm::vec3 & halfExtents )
    {
        return new btBoxShape(bt::getVec3( halfExtents ));
    }
 
    btCollisionShape * PhysicsEngine::createSphereShape( float radius )
    {
        return new btSphereShape( radius );
    }
 
    btCollisionShape * PhysicsEngine::createCapsuleShape( float radius, float height )
    {
        return new btCapsuleShape( radius, height );
    }
 
    btCollisionShape * PhysicsEngine::createPlaneShape( const glm::vec3 & surfaceNormal, float distanceFromOrigin )
    {
        return new btStaticPlaneShape(bt::getVec3(surfaceNormal), distanceFromOrigin);
    }
 
    btRigidBody * PhysicsEngine::createRigidBody( const RigidBodyCreateInfo & info ) const
    {
        btTransform startTransform;
        startTransform.setIdentity();
        startTransform.setFromOpenGLMatrix(glm::value_ptr(info.transform));
 
        btVector3 localInertia(0, 0, 0);
        if (info.mass != 0.0f)
        {
            info.shape->calculateLocalInertia(info.mass, localInertia);
        }
 
        auto* motionState = new btDefaultMotionState(startTransform);
        btRigidBody::btRigidBodyConstructionInfo rbInfo(info.mass, motionState, info.shape, localInertia);
        rbInfo.m_friction = info.friction;
        rbInfo.m_restitution = info.restitution;
 
        auto* body = new btRigidBody(rbInfo);
        dynamicsWorld->addRigidBody(body);
 
        return body;
    }
 
    void PhysicsEngine::removeRigidBody( btRigidBody * body ) const
    {
        if (body)
        {
            dynamicsWorld->removeRigidBody(body);
            if (body->getMotionState())
            {
                delete body->getMotionState();
            }
            delete body;
        }
    }
}  // namespace EngineCore