C_ftFont.hpp

/*
 * Copyright 2024 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_GRAPHIC_C_FONT_HPP_INCLUDED
#define _FGE_GRAPHIC_C_FONT_HPP_INCLUDED
 
/*
 * Original from : https://github.com/SFML/SFML
 * Copyright (C) 2007-2022 Laurent Gomila
 *
 * Altered/Modified by Guillaume Guillet
 */
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/C_rect.hpp"
#include "FastEngine/graphic/C_glyph.hpp"
#include "FastEngine/graphic/C_surface.hpp"
#include "FastEngine/vulkan/C_textureImage.hpp"
#include <filesystem>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace fge
{
 
using CharacterSize = uint16_t;
 
class FGE_API FreeTypeFont
{
public:
    struct Info
    {
        std::string family;
    };
 
    FreeTypeFont();
    FreeTypeFont(FreeTypeFont const& r) = delete;
    ~FreeTypeFont();
 
    FreeTypeFont& operator=(FreeTypeFont const& r) = delete;
 
    bool loadFromFile(std::filesystem::path const& filePath);
    bool loadFromMemory(void const* data, std::size_t size);
 
    Info const& getInfo() const;
 
    Glyph const&
    getGlyph(uint32_t codePoint, fge::CharacterSize characterSize, bool bold, float outlineThickness = 0) const;
    bool hasGlyph(uint32_t codePoint) const;
 
    float getKerning(uint32_t first, uint32_t second, fge::CharacterSize characterSize, bool bold = false) const;
    float getLineSpacing(fge::CharacterSize characterSize) const;
    float getUnderlinePosition(fge::CharacterSize characterSize) const;
    float getUnderlineThickness(fge::CharacterSize characterSize) const;
 
    fge::vulkan::TextureImage const& getTexture(fge::CharacterSize characterSize) const;
 
    void setSmooth(bool smooth);
    bool isSmooth() const;
 
    [[nodiscard]] std::vector<long> getAvailableSize() const;
 
private:
    struct Row
    {
        Row(unsigned int rowTop, unsigned int rowHeight) :
                _width(0),
                _top(rowTop),
                _height(rowHeight)
        {}
 
        unsigned int _width;  
        unsigned int _top;    
        unsigned int _height; 
    };
 
    using GlyphTable = std::unordered_map<uint64_t, Glyph>; 
 
    struct Page
    {
        explicit Page(bool smooth);
 
        GlyphTable _glyphs;                 
        fge::vulkan::TextureImage _texture; 
        unsigned int _nextRow;              
        std::vector<Row> _rows;             
    };
 
    using PageTable =
            std::unordered_map<fge::CharacterSize, Page>; 
 
    void cleanup();
 
    Page& loadPage(fge::CharacterSize characterSize) const;
    Glyph loadGlyph(uint32_t codePoint, fge::CharacterSize characterSize, bool bold, float outlineThickness) const;
 
    fge::RectInt findGlyphRect(Page& page, unsigned int width, unsigned int height) const;
 
    bool setCurrentSize(fge::CharacterSize characterSize) const;
 
    void* g_face;      
    void* g_streamRec; 
    void* g_stroker;   
    bool g_isSmooth;   
    Info g_info;       
    mutable PageTable g_pages;            
    mutable fge::Surface g_surfaceBuffer; 
};
 
} // namespace fge
 
#endif // _FGE_GRAPHIC_C_FONT_HPP_INCLUDED