dl_text.h

浏览该文件的文档.

#pragma once
 
#include "base/dl_color.h"
#include "base/dl_array_enum.h"
#include "render/dl_sprite.h"
 
namespace dl
{
enum class TextParam
{
    NORMAL,   
    OUTLINE,
    SHADOW,   
    MAX_NUM
};

struct TextNode
{
    char32_t _ch;
    gcSprite _spr;
    gcSprite _sprOutline;
    gcSprite _sprShadow;
    gcSprite _sprBg; // 默认没有
    Float _advance;
    Float _advance1;// 现在\t使用它作为真正长度，而advance为设置的宽度比如2.0
    
    Float _lineH;// 单行高度
    Float _ascent;// 基线之上的高度
    unsigned _shadow;
 
    Quad _quad[4];// 原始大小
    Position _xy;
 
    TextNode() :
        _advance1{ 0 },
        _shadow{ 0 },
        _xy{}
    {
    }
 
    void RecordQuad()
    {
        if (_spr)
            _quad[0] = _spr->GetQuad();
        if (_sprOutline)
            _quad[1] = _sprOutline->GetQuad();
        if (_sprShadow)
            _quad[2] = _sprShadow->GetQuad();
        if (_sprBg)
            _quad[3] = _sprBg->GetQuad();
    }
 
    void Set(Float x, Float y)
    {
        _xy = { x, y };
        if (_spr)
            _spr->SetQuad(_quad[0] + Position{ x, y });
        if (_sprOutline)
            _sprOutline->SetQuad(_quad[1] + Position{ x, y });
        if (_sprShadow)
            _sprShadow->SetQuad(_quad[2] + Position{ x + _shadow, y + _shadow });
        if (_sprBg)
            _sprBg->SetQuad(_quad[3] + Position{ x, y });
    }
 
    Position GetLeftTop()
    {
        return _xy + Position{ 0, -_ascent };
    }
    Position GetRightTop()
    {
        return _xy + Position{ _advance, -_ascent };
    }
    Position GetRightDown()
    {
        return _xy + Position{ _advance, _lineH - _ascent };
    }
};

class Text
{
    friend class Factory;
    friend class PoolList<Text>;
public:
    struct Layout
    {
        Align::Direction _alignHorizontalLine;
        float _maxW;               
        Float _lineSpacing;            
        bool _isCantFirstPunct;        
        bool _isWordInSingleLine;    
        Layout() :
            _alignHorizontalLine(Align::Direction::BACK),
            _maxW(0),
            _lineSpacing(1.0),
            _isCantFirstPunct(false),
            _isWordInSingleLine(false) {}
    };
 
 
        
    void Render();

    void SetFormat(bool open)
    { 
        if (open != _bFormat)
        {
            _bFormat = open;
            _refresh_string();
        }
    }

    void SetLayoutAlign(Align::Direction dir_h)
    {
        _layout._alignHorizontalLine = dir_h;
        _update_layout();
    }
 
 

    void SetPositionAlign(const Position& pos = {},
        const Align::Direction2& dir = Align::LT)
    {
        Position offset = -Align::Size2Anchor(toPosition(GetSize()), dir);
        _coor->SetPosition(pos + offset);
    }

    void SetCenter(const Position& pos = {});

    void SetMaxW(float w)
    {
        _layout._maxW = w;
        _update_layout();
    }

    void SetLineSpacing(Float k)
    {
        _layout._lineSpacing = k;
        _update_layout();
    }
 
    const Layout& GetLayout()
    {
        return _layout;
    }

    void SetOrder(float order);

    void SetColor(const Color& col, TextParam type = TextParam::NORMAL);

    bool SetString(std::string_view str);

    void SetFontId(std::size_t id);

    void SetFontSize(unsigned size);
        
    void SetOutline(unsigned outline, const Color& color = ColorDef::BLACK);

    void SetShadow(unsigned shadow, const Color& color = ColorDef::BLACK);

    void SetBackground(bool open, const Color& col = ColorDef::TEXT_BG);

    void SetBackground(Text* b)
    {
        if (b->_sprBg)
            SetBackground(true, b->_sprBg->GetColor());
        else
            SetBackground(false);
    }

    Coor* GetCoor() { return _coor; }
 
    float GetOrder() { return _order; }
 
    std::string GetString();
 
    Color GetColor(TextParam type = TextParam::NORMAL)
    {
        return _col[type];
    }

    Position GetSize();

    unsigned GetFontSize(TextParam type = TextParam::NORMAL)
    {
        return _fontSize[type];
    }

    void SetUI(bool ui) { _ui = ui; }

    bool IsPickup();

    size_t Pos2Index(const Position& pos);
    Position Index2Pos(size_t i);
    Position GetNodeSize(size_t i);
    unsigned GetNodeFontSize(size_t i);

    size_t Pos2IndexOutRange(const Position& pos);

    size_t Pos2CursorIndex(const Position& pos);
 
    void RenderDebug();
 
    ~Text();
private:
    Text();
 
    size_t _fontId;// 字体id
    ArrayEnum<unsigned, TextParam::MAX_NUM> _fontSize;// 设置字体大小
    ArrayEnum<unsigned, TextParam::MAX_NUM> _fontSizeReal;// 实际字体大小
    ArrayEnum<Color, TextParam::MAX_NUM> _col;// 字体颜色
    float _order;// 绘制顺序
 
    Layout _layout;// 布局
    Coor* _coor;// 坐标系
    std::vector<TextNode> _allNode;// 所有节点
    bool _bFormat;// 格式化
    bool _ui;   // 是否ui
 
 
    Position _areaSize;// 占地大小（自己坐标系）
    gcSprite _sprBg;// 背景精灵
 
    // 缓存参数
    std::string _str;
 
 
    void _update_order();
 
    void _update_spr_bg();
 
    void _refresh_string();
 

    void _update_layout();

    bool _is_char_can_first(char ch);
 
    // 计算scale
    bool _update_scale();
};
 
using gcText = GC<Text>;
}