Text.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_TEXT_HPP
#define DONUT_GRAPHICS_TEXT_HPP
 
#include <donut/math.hpp>
 
#include <cstddef>     // std::size_t
#include <limits>      // std::numeric_limits
#include <span>        // std::span
#include <string_view> // std::string_view, std::u8string_view
#include <vector>      // std::vector
 
namespace donut::graphics {
 
class Font; // Forward declaration, to avoid including Font.hpp.
 
class Text {
public:
    struct ShapedGlyph {
        Font* font;         
        vec2 shapedOffset;  
        vec2 shapedSize;    
        u32 characterSize;  
        char32_t codePoint; 
    };
 
    struct ShapedGlyphInfo {
        vec2 shapedOffset;           
        vec2 shapedAdvance;          
        std::size_t shapedLineIndex; 
        std::size_t stringOffset;    
    };
 
    struct ShapedLineInfo {
        vec2 shapedOffset;             
        vec2 shapedSize;               
        std::size_t shapedGlyphOffset; 
        std::size_t stringOffset;      
    };
 
    struct ShapeResult {
        std::size_t shapedGlyphOffset;
 
        std::size_t shapedLineOffset;
    };
 
    Text() noexcept = default;
 
    Text(Font& font, u32 characterSize, std::u8string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f}) {
        shape(font, characterSize, string, offset, scale);
    }
 
    Text(Font& font, u32 characterSize, std::string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f}) {
        shape(font, characterSize, string, offset, scale);
    }
 
    void clear() noexcept {
        shapedGlyphs.clear();
        shapedGlyphsInfo.clear();
        shapedLinesInfo.clear();
        minExtent = {std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity()};
        maxExtent = {-std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()};
    }
 
    ShapeResult shape(Font& font, u32 characterSize, std::u8string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f});
 
    ShapeResult shape(Font& font, u32 characterSize, std::string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f}) {
        static_assert(sizeof(char) == sizeof(char8_t));
        static_assert(alignof(char) == alignof(char8_t));
        return shape(font, characterSize, std::u8string_view{reinterpret_cast<const char8_t*>(string.data()), string.size()}, offset, scale);
    }
 
    ShapeResult reshape(Font& font, u32 characterSize, std::string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f}) {
        clear();
        return shape(font, characterSize, string, offset, scale);
    }
 
    ShapeResult reshape(Font& font, u32 characterSize, std::u8string_view string, vec2 offset = {0.0f, 0.0f}, vec2 scale = {1.0f, 1.0f}) {
        clear();
        return shape(font, characterSize, string, offset, scale);
    }
 
    [[nodiscard]] std::span<const ShapedGlyph> getShapedGlyphs() const noexcept {
        return shapedGlyphs;
    }
 
    [[nodiscard]] std::span<const ShapedGlyphInfo> getShapedGlyphsInfo() const noexcept {
        return shapedGlyphsInfo;
    }
 
    [[nodiscard]] std::span<const ShapedLineInfo> getShapedLinesInfo() const noexcept {
        return shapedLinesInfo;
    }
 
    [[nodiscard]] vec2 getMinExtent() const noexcept {
        return minExtent;
    }
 
    [[nodiscard]] vec2 getMaxExtent() const noexcept {
        return maxExtent;
    }
 
private:
    std::vector<ShapedGlyph> shapedGlyphs{};
    std::vector<ShapedGlyphInfo> shapedGlyphsInfo{};
    std::vector<ShapedLineInfo> shapedLinesInfo{};
    vec2 minExtent{std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity()};
    vec2 maxExtent{-std::numeric_limits<float>::infinity(), -std::numeric_limits<float>::infinity()};
};
 
} // namespace donut::graphics
 
#endif