WidgetComponent.h

#pragma once
 
#include "Engine/Component/LogicComponent.h"
#include "Engine/Asset/AssetHandles.h"
 
#include <array>
#include <cstdint>
#include <glm/vec3.hpp>
#include <limits>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Engine::Components
{
    class WidgetComponent : public Logic
    {
    public:
        struct Resolution
        {
            uint32_t width  = 1024;  
            uint32_t height = 512;   
        };
 
        struct WorldUiWindowStyle
        {
            float                rounding = 0.0f;
            float                borderSize = 0.0f;
            std::array<float, 4> backgroundColor{ 0.02f, 0.02f, 0.025f, 1.0f };
            std::array<float, 4> borderColor{ 1.0f };
        };
 
        static constexpr bool IsUnique = false;  

        explicit WidgetComponent( Entities::Scene * scene );
 
        void beginPlay() override;
        void endPlay() override;
 
        [[nodiscard]] std::string getComponentName() const override;

        [[nodiscard]] Resolution getRequestedResolution() const;

        void setRequestedResolution( uint32_t width, uint32_t height );

        void setPixelsPerMeter( float pixelsPerMeter );

        [[nodiscard]] glm::vec3 getPlaneScale() const;

        [[nodiscard]] bool isWorldUiActive() const;

        void setWorldUiActive( bool active );

        [[nodiscard]] uint32_t getWorldUiDescriptorIndex() const;

        void setWorldUiDescriptorIndex( uint32_t descriptorIndex );

        void clearWorldUiDescriptorIndex();
 
        void setWorldUiWindowStyle( WorldUiWindowStyle style );
        [[nodiscard]] const std::optional<WorldUiWindowStyle> & getWorldUiWindowStyle() const;

        virtual void drawRuntimeImGui();

        void requestWorldUiTexture( Assets::Texture2DHandle handle );

        [[nodiscard]] uint64_t getWorldUiTextureId( Assets::Texture2DHandle handle ) const;
 
        [[nodiscard]] const std::vector<Assets::Texture2DHandle> & getRequestedWorldUiTextures() const;
        void setWorldUiTextureId( Assets::Texture2DHandle handle, uint64_t textureId );

        void selectNextUpgrade();

        void selectPreviousUpgrade();

        void buySelectedUpgrade();
 
    private:
        Resolution resolution_{};
        float      pixelsPerMeter_ = 750.0f;
        bool       active_ = true;
        uint32_t   descriptorIndex_ = std::numeric_limits<uint32_t>::max();
        std::optional<WorldUiWindowStyle> worldUiWindowStyle_;
        std::vector<Assets::Texture2DHandle> requestedTextures_;
        std::unordered_map<uint32_t, uint64_t> worldUiTextureIds_;
 
        int selectedUpgrade_ = 0;
        int credits_         = 120;
        int purchaseCount_   = 0;
    };
}  // namespace Engine::Components