PhysicsBodyComponent.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Component/LogicComponent.h"
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <entt/entt.hpp>
#include <memory>
#include <vector>
#include <set>
 
namespace Engine::Core
{
    class PhysicsEngine;
}  // namespace Engine::Core
 
namespace Engine::Entities
{
    class Actor;
    class SceneNode;
}  // namespace Engine::Entities
 
class btRigidBody;
class btCompoundShape;
class btCollisionShape;
class btDiscreteDynamicsWorld;
 
namespace Engine::Components {
    class Collision;

    class PhysicsBody : public Logic {
    public:
        static constexpr bool IsUnique = true;
        static constexpr const char* ComponentName = "PhysicsBody";

        PhysicsBody(Entities::Scene* scene, entt::entity entity,
                             std::shared_ptr<Entities::SceneNode> sceneNode);
 
        ~PhysicsBody() override;
 
        void beginPlay() override;
        void endPlay() override;
        bool drawImGui() override;
 
        // =========================================================================
        // Physics Properties
        // =========================================================================

        void setMass(float mass);

        [[nodiscard]] float getMass() const { return mass_; }

        void setFriction(float friction);

        [[nodiscard]] float getFriction() const { return friction_; }

        void setRestitution(float restitution);

        [[nodiscard]] float getRestitution() const { return restitution_; }

        void setKinematic(bool kinematic);

        [[nodiscard]] bool isKinematic() const { return isKinematic_; }

        void setStatic(bool isStatic);

        [[nodiscard]] bool isStatic() const { return isStatic_; }
 
        // =========================================================================
        // Transform Control
        // =========================================================================

        void teleport(const glm::vec3& position);

        void teleport(const glm::vec3& position, const glm::quat& rotation);

        void setLinearVelocity(const glm::vec3& velocity);

        [[nodiscard]] glm::vec3 getLinearVelocity() const;

        void setAngularVelocity(const glm::vec3& velocity);

        [[nodiscard]] glm::vec3 getAngularVelocity() const;
 
        // =========================================================================
        // Collision Management (called by CollisionComponents)
        // =========================================================================

        void registerCollision(Components::Collision* collision);

        void unregisterCollision(Components::Collision* collision);

        void markShapeDirty();

        void rebuildIfDirty();

        [[nodiscard]] btRigidBody* getRigidBody() const { return rigidBody_; }

        [[nodiscard]] Entities::Actor* getHitActor() const;

        [[nodiscard]] btDiscreteDynamicsWorld* getDynamicsWorld() const;
 
        // =========================================================================
        // Collision Callbacks
        // =========================================================================

        void processCollisions();
 
        // =========================================================================
        // Debug Visualization
        // =========================================================================

        void debugDraw() const;
 
    private:
        void rebuildCollisionShape();
        void createRigidBody();
        void destroyRigidBody();
        void updateEcsComponent();
        [[nodiscard]] Core::PhysicsEngine * getPhysicsEngine() const;
 
        entt::entity entity_;
        std::weak_ptr<Entities::SceneNode> sceneNode_;
 
        std::vector<Components::Collision*> collisions_;
        btCompoundShape* compoundShape_ = nullptr;
        btRigidBody* rigidBody_ = nullptr;
 
        float mass_ = 1.0f;
        float friction_ = 0.5f;
        float restitution_ = 0.0f;
        bool isKinematic_ = false;
        bool isStatic_ = false;
        bool shapeDirty_ = true;
        bool isInitialized_ = false;
 
        // For collision callbacks - track previous frame's collisions
        std::set<Components::Collision*> previousCollisions_;
    };
 
}  // namespace EngineCore