Actor.cpp

Go to the documentation of this file.

#include "Engine/Entity/Actor.h"
 
#include "Engine/Component/SceneComponent.h"
#include "Engine/Core/Engine.h"
#include "Engine/Entity/Scene.h"
#include "Engine/Logging/FunctionNotImplemented.h"
#include "Engine/Logging/TracyMacros.hpp"
 
#include <GLFW/glfw3.h>
#include <plog/Log.h>
 
namespace EngineCore {
    Actor::Actor(std::shared_ptr<SceneNode> sceneNode, Scene* owningScene) : Entity(), sceneNode(sceneNode), owningScene(owningScene) {
        Engine* enginePtr = EngineManager::getInstance().getEngineModule();
    }
 
    Actor::~Actor() {
    }
 
    void Actor::beginPlay() {
        PLOGI << "Begin play";
        // Initialize all components
        for (auto& component : components) {
            component->beginPlay();
        }
    }
 
    void Actor::tick(double deltaTime) {
        Entity::tick(deltaTime);
 
        // Tick components
        for (auto& component : components) {
            if (component->canTick()) {
                component->tick(deltaTime);
            }
        }
    }
 
    void Actor::endPlay() {
        for (auto& component : components) {
            component->endPlay();
        }
 
        if (sceneNode.has_value())
        {
            Ecs::RegistryManager::get().destroy( data );
        }
    }
 
    glm::vec3 Actor::getActorLocation() const {
        TRACY_ZONE_SCOPED_FUNCTION;
        if (sceneNode.has_value()) {
            return Ecs::TransformOperators::getPosition( sceneNode.value()->getWorldMatrix() );
        }
        return glm::vec3(0.0f);
    }
 
    glm::vec3 Actor::getActorRotation() const {
        if (sceneNode.has_value()) {
            return Ecs::TransformOperators::getRotationEuler( sceneNode.value()->getWorldMatrix() );
        }
        return glm::vec3(0.0f);
    }
 
    glm::vec3 Actor::getActorScale() const {
        if (sceneNode.has_value()) {
            return Ecs::TransformOperators::getScale( sceneNode.value()->getWorldMatrix() );
        }
        return glm::vec3(0.0f);
    }
 
    void Actor::setActorLocation(const glm::vec3 newLocation) {
        if (sceneNode.has_value()) {
            sceneNode.value()->setWorldPosition(newLocation);
        }
    }
 
    void Actor::setActorRotation(glm::vec3 newRotation) {
        if (sceneNode.has_value()) {
            sceneNode.value()->setWorldRotation(newRotation);
        }
    }
 
    void Actor::rotateActor(glm::vec3 deltaRotation) {
        if (sceneNode.has_value()) {
            sceneNode.value()->rotateWorld(deltaRotation);
        }
    }
 
    void Actor::setActorScale(glm::vec3 newScale) {
        if (sceneNode.has_value()) {
            sceneNode.value()->setWorldScale(newScale);
        }
    }
 
    glm::mat4 Actor::getWorldTransform() const {
        if (sceneNode.has_value()) {
            return sceneNode.value()->getWorldMatrix();
        }
        return glm::mat4(1.0f);
    }
 
    MeshComponent * Actor::registerMeshComponent(MeshComponent* meshComponent) {
        const auto managedMeshComponent = owningScene->getSceneManager()->registerGameObject(meshComponent);
        meshComponents.push_back(meshComponent);
        return managedMeshComponent;
    }
 
    void Actor::unregisterMeshComponent(MeshComponent *meshComponent) {
        meshComponents.erase(std::ranges::find(meshComponents, meshComponent));
        delete meshComponent;
        meshComponent = nullptr;
    }
 
    std::vector<MeshComponent *> Actor::getMeshComponents() const {
        return meshComponents;
    }
 
    void Actor::initComponents() {
        FUNCTION_NOT_IMPLEMENTED_F
    }
 
    void Actor::cleanupComponents() {
        TRACY_ZONE_SCOPED_NAMED("Cleaning Mesh Components");
        for (auto& component : components) {
            component->endPlay();
        }
        components.clear();
    }
 
    Scene* Actor::getOwningScene() const {
        return owningScene;
    }
 
    std::shared_ptr<SceneNode> Actor::getSceneNode() const
    {
        return sceneNode.value();
    }
} // namespace EngineCore