CinematicCameraSystem.cpp

#include "CinematicCameraSystem.h"
#include "Components/Core/TransformComponent.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <memory>
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("CinematicCameraSystem");
}
 
Cogs::Core::CinematicCameraSystem::~CinematicCameraSystem()
{
}
 
void Cogs::Core::CinematicCameraSystem::initialize(Context* /*context*/)
{
    ComponentSystemWithDataPool::initialize(context);
    easingFn = {
            &EasingFn::linear, 
            &EasingFn::quadraticIn,     &EasingFn::quadraticOut,     &EasingFn::quadraticInOut,
            &EasingFn::cubicIn,         &EasingFn::cubicOut,         &EasingFn::cubicInOut,
            &EasingFn::quarticIn,       &EasingFn::quarticOut,       &EasingFn::quarticInOut,
            &EasingFn::quinticIn,       &EasingFn::quinticOut,       &EasingFn::quinticInOut,
            &EasingFn::sinusoidalIn,    &EasingFn::sinusoidalOut,    &EasingFn::sinusoidalInOut,
            &EasingFn::exponentialIn,   &EasingFn::exponentialOut,   &EasingFn::exponentialInOut,
            &EasingFn::circularIn,      &EasingFn::circularOut,      &EasingFn::circularInOut,
            &EasingFn::elasticIn,       &EasingFn::elasticOut,       &EasingFn::elasticInOut,
            &EasingFn::backIn,          &EasingFn::backOut,          &EasingFn::backInOut,
            &EasingFn::bounceIn,        &EasingFn::bounceOut,        &EasingFn::bounceInOut };
}
 
void Cogs::Core::CinematicCameraSystem::update(Context* /*context*/)
{
    for (auto& cinematicCamComp : pool) 
    {
        // comtainers should be of equal length. see CinematicCameraComponent.h 65
        
        if (cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointRotation.size()
            || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointTimeToReach.size()
            || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointWaitingTime.size()
            || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointEasingMode.size())
        {
            LOG_ERROR(logger, "Mismatching size of component data arrays, cannot interpolate with incomplete data");
            return;
        }
 
        auto& compData = getData(&cinematicCamComp);
        auto transform = cinematicCamComp.getComponent<TransformComponent>();
 
        if (cinematicCamComp.hasChanged())
        {
            if (!compData.positionInterpolator && !compData.rotationInterpolator && transform != nullptr)
            {
                // Initialize interpolators by giving a ref to the scene camera.
                compData.positionInterpolator = std::make_unique<Cogs::Interpolator<glm::vec3>>(transform->position);
                compData.rotationInterpolator = std::make_unique<Cogs::Interpolator<glm::quat>>(transform->rotation);
            }
 
            if (cinematicCamComp.isCinematicPlaying)
            {
                triggerTargetPoint(cinematicCamComp, 0);
                compData.currentRunningID = 0;
            }
        }
 
        // Skip block if component does not need to interpolate or is finished doing so
        if (cinematicCamComp.isCinematicPlaying)
        {
            if (compData.timer.elapsedSeconds() >= 
                cinematicCamComp.interestPointTimeToReach[compData.currentRunningID] + cinematicCamComp.interestPointWaitingTime[compData.currentRunningID])
            {
                compData.timer.stop();
 
                // Try to set a 'next' point, set camera angles and return if not available.
                if (!triggerTargetPoint(cinematicCamComp, ++(compData.currentRunningID)))
                {
                    return;
                }
            }
 
            // Keep interpolating the camera.
            compData.positionInterpolator->process();
            compData.rotationInterpolator->process();
            if(transform != nullptr)
                transform->setChanged();
        }
    }
}
 
void Cogs::Core::CinematicCameraSystem::cleanup(Context* /*context*/)
{
    for (auto& cinematicCamComp : pool)
    {
        auto& compData = getData(&cinematicCamComp);
        if (compData.positionInterpolator) compData.positionInterpolator = nullptr;
        if (compData.rotationInterpolator) compData.rotationInterpolator = nullptr;
    }
}
 
void Cogs::Core::CinematicCameraSystem::addInterestPoint(const CinematicCameraComponent& targetComp)
{
    for (auto& cinematicCamComp : pool)
    {
        // Make sure we are operating over the desired component
        if (std::addressof(targetComp) == std::addressof(cinematicCamComp))
        {
            auto transform = cinematicCamComp.getComponent<TransformComponent>();
            if (transform != nullptr)
            {
                cinematicCamComp.interestPointPosition.push_back(transform->position);
                cinematicCamComp.interestPointRotation.push_back(transform->rotation);
                cinematicCamComp.interestPointTimeToReach.push_back(3.f);
                cinematicCamComp.interestPointWaitingTime.push_back(3.f);
                cinematicCamComp.interestPointEasingMode.push_back(CameraEasingMode::Linear);
            }
            return;
        }
    }
}
 
void Cogs::Core::CinematicCameraSystem::addInterestPoint(const CinematicCameraComponent& targetComp, glm::vec3& pos, glm::quat& rot, float time, float waitTime, CameraEasingMode mode)
{
    for (auto& cinematicCamComp : pool)
    {
        // Make sure we are operating over the desired component
        if (std::addressof(targetComp) == std::addressof(cinematicCamComp))
        {
            cinematicCamComp.interestPointPosition.push_back(pos);
            cinematicCamComp.interestPointRotation.push_back(rot);
            cinematicCamComp.interestPointTimeToReach.push_back(time);
            cinematicCamComp.interestPointWaitingTime.push_back(waitTime);
            cinematicCamComp.interestPointEasingMode.push_back(mode);
            return;
        }
    }
}
 
void Cogs::Core::CinematicCameraSystem::playCameraSequence(const CinematicCameraComponent& targetComp)
{
    for (auto& cinematicCamComp : pool)
    {
        // Make sure we are operating over the desired component
        if (std::addressof(targetComp) == std::addressof(cinematicCamComp))
        {
            auto& compData = getData(&cinematicCamComp);
 
            //Skip if there are no points to run
            if (cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointRotation.size()
                || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointTimeToReach.size()
                || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointWaitingTime.size()
                || cinematicCamComp.interestPointPosition.size() != cinematicCamComp.interestPointEasingMode.size())
            {
                LOG_ERROR(logger, "Mismatching size of component data arrays, cannot interpolate with incomplete data");
                return;
            }
 
            
            // Set initial conditions
            {
                cinematicCamComp.isCinematicPlaying = true;
                triggerTargetPoint(targetComp, 0);
                compData.currentRunningID = 0;
            }
        }
    }
 
}
 
bool Cogs::Core::CinematicCameraSystem::triggerTargetPoint(const CinematicCameraComponent& targetComp, const short& id)
{
    // It is assumed that the arrays are of equal length (ALWAYS)
    // All codepaths should assert equal lenghts before reaching this method.
    for (auto& cinematicCamComp : pool)
    {
        // Make sure we are operating over the desired component
        if (std::addressof(targetComp) == std::addressof(cinematicCamComp))
        {
            auto& compData = getData(&cinematicCamComp);
            if (id < cinematicCamComp.interestPointPosition.size())
            {
                // TODO: Find a better way of reflecting EasingFn
                compData.positionInterpolator->setTarget(cinematicCamComp.interestPointPosition[id], easingFn[(size_t)cinematicCamComp.interestPointEasingMode[id]], cinematicCamComp.interestPointTimeToReach[id]);
                compData.rotationInterpolator->setTarget(cinematicCamComp.interestPointRotation[id], easingFn[(size_t)cinematicCamComp.interestPointEasingMode[id]], cinematicCamComp.interestPointTimeToReach[id]);
 
                // start processing first iteration
                compData.positionInterpolator->process();
                compData.rotationInterpolator->process();
                compData.timer.start();
 
                return true;
            }
            else
            {
                if (cinematicCamComp.loop)
                {
                    playCameraSequence(cinematicCamComp);
                    return true;
                }
                else
                {
                    // There are no more points to be processed, stop sequence
                    cinematicCamComp.isCinematicPlaying = false;
                    compData.currentRunningID = -1;
                    cinematicCamComp.setChanged();
                    return false;
                }
            }
        }
    }
    return false;
}