TextureAtlas.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_GRAPHICS_TEXTUREATLAS_HPP_
#define GALAXY_GRAPHICS_TEXTUREATLAS_HPP_
 
#include <span>
#include <string_view>
 
#include <robin_hood.h>
 
#include "galaxy/components/Transform.hpp"
#include "galaxy/graphics/RenderTexture.hpp"
#include "galaxy/graphics/TexelRegion.hpp"
#include "galaxy/graphics/VertexArray.hpp"
#include "galaxy/math/RectPack.hpp"
 
namespace galaxy
{
    namespace resource
    {
        class TextureAtlas final
        {
        public:
            struct Sheet final
            {
                math::RectPack m_packer;
 
                graphics::RenderTexture m_render_texture;
            };
 
            struct Info final
            {
                math::iRect m_region;
 
                graphics::TexelRegion m_texel_region;
 
                int m_index = 0;
 
                int m_handle = 0;
 
                int m_sheet_width = 0;
 
                int m_sheet_height = 0;
            };
 
            TextureAtlas();
 
            virtual ~TextureAtlas();
 
            void add(const std::string& file);
 
            void add_from_vfs();
 
            void save();
 
            void clear();
 
            [[nodiscard]]
            bool contains(const std::string& key);
 
            [[nodiscard]]
            meta::optional_ref<Info> query(const std::string& key);
 
            template<meta::is_arithmetic Type>
            [[nodiscard]]
            static float map_x_texel(const Type x, const Type width);
 
            template<meta::is_arithmetic Type>
            [[nodiscard]]
            static float map_y_texel(const Type y, const Type height);
 
            [[nodiscard]]
            meta::vector<std::string> keys();
 
        private:
            TextureAtlas(TextureAtlas&&) = delete;
 
            TextureAtlas& operator=(TextureAtlas&&) = delete;
 
            TextureAtlas(const TextureAtlas&) = delete;
 
            TextureAtlas& operator=(const TextureAtlas&) = delete;
 
            void init();
 
        private:
            int m_max_bindings;
 
            int m_size;
 
            meta::vector<std::unique_ptr<Sheet>> m_sheets;
 
            robin_hood::unordered_flat_map<std::string, Info> m_data;
 
            graphics::VertexArray m_vao;
 
            components::Transform m_transform;
        };
 
        template<meta::is_arithmetic Type>
        inline float TextureAtlas::map_x_texel(const Type x, const Type width)
        {
            if constexpr (std::is_floating_point<Type>::value)
            {
                return x / width;
            }
            else
            {
                return static_cast<float>(x) / static_cast<float>(width);
            }
        }
 
        template<meta::is_arithmetic Type>
        inline float TextureAtlas::map_y_texel(const Type y, const Type height)
        {
            if constexpr (std::is_floating_point<Type>::value)
            {
                return y / height;
            }
            else
            {
                return static_cast<float>(y) / static_cast<float>(height);
            }
        }
    } // namespace resource
} // namespace galaxy
 
#endif