tick_counter.hpp

Go to the documentation of this file.

#pragma once
 
#include <sstream>
#include <iomanip>
#include <random>
#include <thread>
 
#include "../../render_stack.h"
#include "components/settings/config/config.h"
#include "components/3rdparty/imgui/imgui.h"
#include "components/core/events/events.h"
#include "components/core/events/events/TickEvent.hpp"
#include <Strings/components/utils/converters/converters.h>
 
namespace BlamRendering::RenderStack
{
    class TickCounter : public StackObjectBase, public Blam::Events::EventListener
    {
    private:
        BitmapText* tick_display;
        BitmapText* tick_display_2;
        int counter = 0;
        
        std::thread incremeneter_thread;
        bool stop_thread = false;
        bool thread_stopped = false;
 
    public:
        void increment()
        {
            while (!stop_thread)
            {
                counter++;
            }
 
            thread_stopped = true;
        }
 
        TickCounter()
        {
            type_label = STACKTYPE_STATS;
 
            x = 50;
            y = 820;
 
            {
                tick_display = new BitmapText();
 
                tick_display->font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
                tick_display->use_shadow = true;
                tick_display->color = D2D1::ColorF(1, 1, 1, 1);
 
                tick_display->SetTranslation(x, y);
            }
            
 
            {
                tick_display_2 = new BitmapText();
 
                tick_display_2->font_id = Blam::Config::GetConfig()->GetString("ui_default_font");
                tick_display_2->use_shadow = true;
                tick_display_2->color = D2D1::ColorF(1, 1, 1, 1);
 
                tick_display_2->SetTranslation(x, y + 15);
            }
 
            Subscribe(EventType::Tick);
 
            Blam::Events::RegisterListener(this);
 
            incremeneter_thread = std::thread(&BlamRendering::RenderStack::TickCounter::increment, this);
            incremeneter_thread.detach();
        }
 
        ~TickCounter()
        {
            stop_thread = true;
 
            while (!thread_stopped)
            {
                // Wait for thread to finish
            }
 
            delete tick_display;
            delete this;
        }
 
        void Draw()
        {
            tick_display->SetTranslation(x, y);
            tick_display_2->SetTranslation(x, y + 15);
 
 
            tick_display->visible = visible;
 
            if (visible)
            {
                std::string new_text = BlamStrings::Converters::BytesToString((void*)counter, sizeof(counter));
 
                if (new_text.length() < 8)
                {
                    while (new_text.length() != 8)
                    {
                        new_text.insert(new_text.begin(), '0');
                    }
                }
 
                tick_display->text = new_text;
                tick_display_2->text = new_text;
            }
 
            tick_display->Draw();
            tick_display_2->Draw();
        }
 
        void ShowImPropertyEditor()
        {
 
        }
 
        void onTickEvent(Blam::Events::TickEvent* event)
        {
            counter++;
        }
    };
}