CollisionComponent.cpp

Go to the documentation of this file.

#include "Engine/Component/Collision/CollisionComponent.h"
#include "Engine/Component/PhysicsBodyComponent.h"
#include "Engine/Entity/Entity.h"
 
#include <btBulletDynamicsCommon.h>
#include <glm/gtc/matrix_transform.hpp>
 
namespace EngineCore {
 
    CollisionComponent::CollisionComponent(Scene* scene, entt::entity entity)
        : LogicComponent(scene)
        , entity_(entity)
    {
    }
 
    CollisionComponent::~CollisionComponent() {
        destroyShape();
    }
 
    void CollisionComponent::beginPlay() {
        LogicComponent::beginPlay();
 
        // Create the shape
        if (!shape_) {
            shape_ = createShape();
        }
 
        // Register with PhysicsBodyComponent
        registerWithBody();
    }
 
    void CollisionComponent::endPlay() {
        unregisterFromBody();
        destroyShape();
        LogicComponent::endPlay();
    }
 
    void CollisionComponent::destroyShape() {
        if (shape_) {
            delete shape_;
            shape_ = nullptr;
        }
    }
 
    void CollisionComponent::markDirty() {
        isDirty_ = true;
    }
 
    void CollisionComponent::rebuild() {
        if (!isDirty_) return;
 
        // Recreate the shape
        destroyShape();
        shape_ = createShape();
        isDirty_ = false;
 
        // Notify body component to rebuild its compound shape
        if (bodyComponent_) {
            bodyComponent_->markShapeDirty();
            bodyComponent_->rebuildIfDirty();
        }
    }
 
    void CollisionComponent::setLocalOffset(const glm::vec3& offset) {
        localOffset_ = offset;
        if (bodyComponent_) {
            bodyComponent_->markShapeDirty();
        }
    }
 
    void CollisionComponent::setLocalRotation(const glm::quat& rotation) {
        localRotation_ = rotation;
        if (bodyComponent_) {
            bodyComponent_->markShapeDirty();
        }
    }
 
    glm::mat4 CollisionComponent::getLocalTransform() const {
        glm::mat4 transform = glm::mat4(1.0f);
        transform = glm::translate(transform, localOffset_);
        transform *= glm::mat4_cast(localRotation_);
        return transform;
    }
 
    void CollisionComponent::setIsTrigger(bool trigger) {
        isTrigger_ = trigger;
        // Note: Trigger mode is applied at the rigid body level
        // The PhysicsBodyComponent will handle this during shape rebuild
        if (bodyComponent_) {
            bodyComponent_->markShapeDirty();
        }
    }
 
    void CollisionComponent::onCollisionBegin(CollisionComponent* other) {
        // Default implementation does nothing
        // Override in derived classes to handle collision events
    }
 
    void CollisionComponent::onCollisionEnd(CollisionComponent* other) {
        // Default implementation does nothing
    }
 
    void CollisionComponent::onCollisionStay(CollisionComponent* other) {
        // Default implementation does nothing
    }
 
    void CollisionComponent::registerWithBody() {
        Entity* owner = getOwningEntity();
        if (!owner) return;
 
        // Try to find an existing PhysicsBodyComponent
        bodyComponent_ = owner->getComponent<PhysicsBodyComponent>();
        if (bodyComponent_) {
            bodyComponent_->registerCollision(this);
        }
        // If no body component exists, we'll be registered when one is added
        // (PhysicsBodyComponent::beginPlay scans for existing collisions)
    }
 
    void CollisionComponent::unregisterFromBody() {
        if (bodyComponent_) {
            bodyComponent_->unregisterCollision(this);
            bodyComponent_ = nullptr;
        }
    }
 
}  // namespace EngineCore