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>
 
class btRigidBody;
class btCompoundShape;
class btCollisionShape;
 
namespace EngineCore {
    class Scene;
    class SceneNode;
    class CollisionComponent;
    class PhysicsEngine;

    class PhysicsBodyComponent : public LogicComponent {
    public:
        static constexpr bool IsUnique = true;

        PhysicsBodyComponent(Scene* scene, entt::entity entity,
                             std::shared_ptr<SceneNode> sceneNode);
 
        ~PhysicsBodyComponent() override;
 
        void beginPlay() override;
        void endPlay() 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(CollisionComponent* collision);

        void unregisterCollision(CollisionComponent* collision);

        void markShapeDirty();

        void rebuildIfDirty();

        [[nodiscard]] btRigidBody* getRigidBody() const { return rigidBody_; }
 
        // =========================================================================
        // Collision Callbacks
        // =========================================================================

        void processCollisions();
 
    private:
        void rebuildCollisionShape();
        void createRigidBody();
        void destroyRigidBody();
        void updateEcsComponent();
        PhysicsEngine* getPhysicsEngine() const;
 
        entt::entity entity_;
        std::weak_ptr<SceneNode> sceneNode_;
 
        std::vector<CollisionComponent*> 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<CollisionComponent*> previousCollisions_;
    };
 
}  // namespace EngineCore