Bitmap.hpp

#pragma once
 
#include <glm/vec2.hpp>
 
#include <cstdint>
#include <filesystem>
#include <string>
#include <vector>
 
namespace PixelBullet
{
    class VirtualPath;
 
    class Bitmap
    {
    public:
        Bitmap() = default;
 
        explicit Bitmap(const VirtualPath& assetPath)
        {
            Load(assetPath);
        }
 
        Bitmap(const glm::uvec2& size, uint32_t bytesPerPixel = 4)
            : m_Size(size)
            , m_BytesPerPixel(bytesPerPixel)
        {
            m_Data.resize(CalculateLength(size, bytesPerPixel));
        }
 
        Bitmap(const std::vector<uint8_t>& data, const glm::uvec2& size, uint32_t bytesPerPixel = 4)
            : m_Data(data)
            , m_Size(size)
            , m_BytesPerPixel(bytesPerPixel)
        {
        }
 
        ~Bitmap() = default;
 
        bool Load(const VirtualPath& assetPath);
 
        bool Write(const VirtualPath& assetPath) const;
 
        explicit operator bool() const noexcept
        {
            return !m_Data.empty();
        }
 
        uint32_t GetLength() const;
 
        void Clear();
 
        // Accessors.
        const std::string& GetFilename() const
        {
            return m_Filename;
        }
        void SetFilename(const std::string& f)
        {
            m_Filename = f;
        }
 
        const std::vector<uint8_t>& GetData() const
        {
            return m_Data;
        }
        std::vector<uint8_t>& GetData()
        {
            return m_Data;
        }
        void SetData(const std::vector<uint8_t>& d)
        {
            m_Data = d;
        }
        void SetData(std::vector<uint8_t>&& d)
        {
            m_Data = std::move(d);
        }
 
        const glm::uvec2& GetSize() const
        {
            return m_Size;
        }
        void SetSize(const glm::uvec2& s)
        {
            m_Size = s;
        }
 
        uint32_t GetBytesPerPixel() const
        {
            return m_BytesPerPixel;
        }
        void SetBytesPerPixel(uint32_t bpp)
        {
            m_BytesPerPixel = bpp;
        }
 
    private:
        static uint32_t CalculateLength(const glm::uvec2& size, uint32_t bytesPerPixel);
 
    private:
        std::string m_Filename;       
        std::vector<uint8_t> m_Data;  
        glm::uvec2 m_Size{ 0, 0 };    
        uint32_t m_BytesPerPixel = 0; 
    };
} // namespace PixelBullet