font.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "glyph.h"
 
// External Includes
#include <nap/resource.h>
#include <rtti/factory.h>
#include <utility>
#include <utility/errorstate.h>
#include <rect.h>
 
// Forward Declares
namespace nap
{
    class FontService;
    class FontInstance;
    class GlyphCache;
}
 
 
namespace nap
{
    namespace font
    {
        inline constexpr float dpi = 96.0f;                     
    }
 
 
    struct NAPAPI FontProperties
    {
        FontProperties() = default;
 
        FontProperties(int size) : mSize(size) { }
 
        int mSize   = 12;           
    };
 
 
    // Font Resource
 
 
    class NAPAPI Font : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        Font(FontService& service);
 
        // Destructor
        virtual ~Font();
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        FontInstance& getFontInstance();
 
        const FontInstance& getFontInstance() const;
 
        FontProperties mProperties;                             
        std::string mFont;                                      
 
    private:
        FontService* mService = nullptr;                        
        std::unique_ptr<FontInstance> mInstance = nullptr;      
    };
 
    // Object creator used for constructing the the OSC receiver
    using FontObjectCreator = rtti::ObjectCreator<Font, FontService>;
 
 
    // Font Instance
 
 
    class NAPAPI FontInstance final
    {
        RTTI_ENABLE()
    public:
        FontInstance(FontService& service);
 
        ~FontInstance();
 
        FontInstance(const FontInstance& rhs) = delete;
        FontInstance& operator=(const FontInstance& rhs) = delete;
 
        bool create(const std::string& font, FontProperties& properties, utility::ErrorState& error);
 
        const FontProperties& getProperties() const;
 
        const std::string& getFont() const;
 
        bool isValid() const;
 
         nap::uint getGlyphIndex(nap::uint character) const;
 
        template<typename T>
        T* getOrCreateGlyphRepresentation(nap::uint index, float scale, utility::ErrorState& errorCode);
 
        IGlyphRepresentation* getOrCreateGlyphRepresentation(nap::uint index, float scale, const rtti::TypeInfo& type, utility::ErrorState& errorCode);
 
        const Glyph* getOrCreateGlyph(nap::uint index, float scale, utility::ErrorState& errorCode);
 
        void getBoundingBox(const std::string& text, float scale, math::Rect& outRect);
 
        int getCount();
 
    protected:
        void* getFace() const;
 
    private:
        bool loadGlyph(uint index);
 
        void* getGlyphHandle();
 
        void resetCache();
 
        GlyphCache* getOrCreateGlyphCache(nap::uint index, float scale, utility::ErrorState& errorCode);
 
 
        void* mFace = nullptr;                                          
        void* mFreetypeLib = nullptr;                                   
        FontProperties mProperties = { -1 };                            
        std::string mFont;                                              
        FontService* mService;                                          
 
        using GlyphCacheSet = std::vector<std::unique_ptr<GlyphCache>>; 
        using GlyphCacheMap = std::unordered_map<int, GlyphCacheSet>;   
        mutable GlyphCacheMap mGlyphs;                                  
    };
 
 
    // Glyph Cache
 
    class NAPAPI GlyphCache final
    {
        friend FontInstance;
    public:
        ~GlyphCache();
 
        // Copy is not allowed
        GlyphCache(const GlyphCache& other) = delete;
        GlyphCache& operator=(const GlyphCache&) = delete;
 
        // Move is not allowed
        GlyphCache(GlyphCache&& other) = delete;
        GlyphCache& operator=(GlyphCache&& other) = delete;
 
        IGlyphRepresentation* findRepresentation(const rtti::TypeInfo& type);
 
        template<typename T>
        T* findRepresentation();
 
        const Glyph& getGlyph() const                       { return *mGlyph; }
 
    protected:
        GlyphCache(std::unique_ptr<Glyph> parent) : 
            mGlyph(std::move(parent))                       { }
 
        void addRepresentation(std::unique_ptr<IGlyphRepresentation> representation);
 
    private:
        std::unique_ptr<Glyph> mGlyph = nullptr;            
        using GlyphRepresentationMap = std::unordered_map<rtti::TypeInfo, std::unique_ptr<IGlyphRepresentation>>;
        GlyphRepresentationMap mRepresentations;            
    };
 
 
    // Template definitions
 
    template<typename T>
    T* nap::FontInstance::getOrCreateGlyphRepresentation(nap::uint index, float scale, utility::ErrorState& errorCode)
    {
        IGlyphRepresentation* representation = this->getOrCreateGlyphRepresentation(index, scale, RTTI_OF(T), errorCode);
        return rtti_cast<T>(representation);
    }
 
 
    template<typename T>
    T* nap::GlyphCache::findRepresentation()
    {
        IGlyphRepresentation* presentation = findRepresentation(RTTI_OF(T));
        return rtti_cast<T>(presentation);
    }
}