ColorTransition.h

Go to the documentation of this file.

#pragma once
 
#include "../animation.h"
 
#include <d2d1.h>
#include <string>
 
#include "components/core/tick/tick.h"
#include <Strings/components/utils/math/math.h>
#include "components/diagnostics/logger/logger.h"
#include <Strings/components/classes/events/events.h>
 
#ifndef BLAM
#define BLAM
#endif
 
namespace Blam::Animation
{
    class ColorTransitionAnimation : public BlamEventListener
    {
    private:
        D2D1_COLOR_F evaluated_color; 
        
        D2D1_COLOR_F color_1; 
        D2D1_COLOR_F color_2; 
 
        float fade_duration = 1.0f;   
 
        int ticks_per_fade = 0; 
        int local_ticks = 0;    
        bool swap_fade_direction = false; 
        float elapsed_time = 0.0f; 
 
        bool loop = false;
        bool animation_done = false;
        bool is_started = false;
        bool pause = false;
 
        float GetIntermediaryColor(float subcolor1, float subcolor2)
        {
            float blend_amount = fabsf((subcolor1 - subcolor2) * elapsed_time);
 
            if (subcolor1 < subcolor2)
            {
                return subcolor2 - blend_amount;
            }
            else
            {
                return subcolor2 + blend_amount;
            }
        }
 
        void OnTickEvent(TickEvent* event)
        {
            if (!pause)
            {
                if (loop)
                {
                    local_ticks++;
 
                    if (local_ticks == ticks_per_fade)
                    {
                        swap_fade_direction = !swap_fade_direction;
                        local_ticks = 1;
                    }
 
                    elapsed_time = float(local_ticks) / float(ticks_per_fade);
 
                    if (swap_fade_direction)
                    {
                        evaluated_color.r = GetIntermediaryColor(color_1.r, color_2.r);
                        evaluated_color.g = GetIntermediaryColor(color_1.g, color_2.g);
                        evaluated_color.b = GetIntermediaryColor(color_1.b, color_2.b);
                        evaluated_color.a = GetIntermediaryColor(color_1.a, color_2.a);
                    }
                    else
                    {
                        evaluated_color.r = GetIntermediaryColor(color_2.r, color_1.r);
                        evaluated_color.g = GetIntermediaryColor(color_2.g, color_1.g);
                        evaluated_color.b = GetIntermediaryColor(color_2.b, color_1.b);
                        evaluated_color.a = GetIntermediaryColor(color_2.a, color_1.a);
                    }
                }
                else
                {
                    if (!animation_done)
                    {
                        local_ticks++;
 
                        elapsed_time = float(local_ticks) / float(ticks_per_fade);
 
                        evaluated_color.r = GetIntermediaryColor(color_1.r, color_2.r);
                        evaluated_color.g = GetIntermediaryColor(color_1.g, color_2.g);
                        evaluated_color.b = GetIntermediaryColor(color_1.b, color_2.b);
                        evaluated_color.a = GetIntermediaryColor(color_1.a, color_2.a);
 
                        if (evaluated_color.r == color_1.r && evaluated_color.g == color_1.g && evaluated_color.b == color_1.b && evaluated_color.a == color_1.a)
                        {
                            animation_done = true;
                        }
                    }
                    else
                    {
                        BlamStrings::Events::UnregisterListener(this);
                    }
                }
            }
        }
 
    public:
        void Initialize(D2D1_COLOR_F _c1, D2D1_COLOR_F _c2, float fade_duration, bool _loop)
        {
            float full_ticks_per_fade = Blam::Tick::MaxTicksPerSecond() * fade_duration;
 
            ticks_per_fade = full_ticks_per_fade;
 
            if (!BlamStrings::Utils::Math::FloatIsInteger(full_ticks_per_fade))
            {
                Blam::Logger::LogEvent("color transition animation was configured to use fade duration of " + std::to_string(fade_duration) +
                    ", which results in a tick per fade of " + std::to_string(full_ticks_per_fade) + " - the animation will not be properly fixed to a per-second timestep and "
                    + "this can cause unforeseen issues!", WSV_WARNING);
            }
 
            color_1 = _c1;
            color_2 = _c2;
 
            loop = _loop;
 
            evaluated_color = _c2;
        }
 
        void Start()
        {
            if (!is_started)
            {
                this->Subscribe(BlamEventType::Tick);
                BlamStrings::Events::RegisterListener(this, "color_transition_animation");
 
                is_started = true;
            }
        }
 
        D2D1_COLOR_F GetColor()
        {
            return evaluated_color;
        }
 
        bool HasStarted()
        {
            return is_started;
        }
 
        void Pause()
        {
            pause = true;
        }
 
        void Resume()
        {
            pause = false;
        }
    };
}