tb_text.hpp

 
#ifndef TurtleBrains_Text_hpp
#define TurtleBrains_Text_hpp
 
#include <turtle_brains/graphics/tb_graphic.hpp>
#include <turtle_brains/graphics/tb_color.hpp>
#include <turtle_brains/graphics/tb_texture_manager.hpp> //for PixelSpace definition.
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_string.hpp>
 
// 2025-03-19: This was first enabled on 2025-03-19 and has not been disabled since ...
//   When this is eventually removed, also remove any reference to the colorMatrix (and I think even colorTint) in the
//   basic shader for TurtleBrains as they were for text support without a branch, changing single-channel texture into
//   argb like values for the shader to manipulate.
//#define TURTLEBRAINS_SDF_FONTS
//#define tb_silently_fail_without_sdf_fonts
 
namespace TurtleBrains::Graphics
{
    namespace Implementation
    {
        struct TextData;
    };
 
    // 2025-11-22: This could be a TypedInteger, but that would require the callsite to specify FontSize() and would
    //   slow the developer down slightly. Say from a project it would create a line like;
    //
    //   tbGraphics::Text myText("Hello World!", tbGraphics::FontSize(32)); vs
    //   tbGraphics::Text myText("Hello World!", 32);
    //
    //enum class FontSizeType : uint16_t { };
    //using FontSize = tbCore::TypedInteger<FontSizeType>;
    using FontSize = tbCore::uint16;
 
    class Text : public Graphic, public tbCore::Noncopyable
    {
    public:
        static FontSize DefaultFontSize(void);
 
        static const String& DefaultFontFile(void);
 
        explicit Text(const String& text = tb_string(""), const FontSize pointSize = DefaultFontSize(),
            const String& fontFilepath = DefaultFontFile());
 
        virtual ~Text(void);
 
        static void SetLineHeightForFont(const String& fontFilepath, const float multiplier);
 
        String GetText(void) const { return mTextString; }
 
        String GetFont(void) const { return mTextFont; }
 
        FontSize GetPointSize(void) const { return mTextSize; }
 
        enum class BaselineFrom { Top, Center, Bottom };
 
        float Unstable_GetBaseline(const BaselineFrom from = BaselineFrom::Top) const;
        float Unstable_GetScaledBaseline(const BaselineFrom from = BaselineFrom::Top) const;
 
        void SetText(const String& text, const tbGraphics::AnchorLocation& alignment,
            const FontSize pointSize, const String& fontFilepath);
 
        void SetText(const String& text, const FontSize pointSize, const String& fontFilepath);
 
        void SetText(const String& text, const FontSize pointSize);
 
        void SetText(const String& text);
 
        void SetAlignment(const AnchorLocation& alignment);
 
        virtual void SetColor(const Color& newColor) override;
 
        void SetColor(const Color& topColor, const Color& bottomColor);
 
        const Color& GetOutlineColor(void) const;
        void SetOutlineColor(const Color& outlineColor);
        float GetOutlineThickness(void) const;
        void SetOutlineThickness(const float thickness);
        const Color& GetShadowColor(void) const;
        void SetShadowColor(const Color& shadowColor);
        Math::Vector2 GetShadowOffset(void) const;
        void SetShadowOffset(const Math::Vector2& shadowOffset);
        void SetShadowOffset(const float offsetX, const float offsetY);
 
        virtual PixelSpace GetPixelWidth(void) const override;
 
        virtual PixelSpace GetPixelHeight(void) const override;
 
        static void CreateGraphicsContext(void);
        static void DestroyGraphicsContext(void);
 
    protected:
        virtual void OnRender(void) const override;
 
    private:
        Implementation::TextData* mTextData;
        String mTextFont;
        String mTextString;
        AnchorLocation mAlignment;
 
        tbGraphics::Color mBottomColor;
 
        tbGraphics::Color mOutlineColor;
        tbGraphics::Color mShadowColor;
        tbMath::Vector4 mShaderParams; //x,y is shadowOffset, z is outlineThickness, w is edgeThreshold.
 
        FontSize mTextSize;
        bool mIsSDF;
    };
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_Text_hpp */