dl_sprite.h

浏览该文件的文档.

#pragma once
 
#include "dl_type.h"
#include "memory/dl_memory_pool.h"
#include "math/dl_coor.h"
#include "math/dl_math.h"
#include "math/dl_align.h"
 
namespace dl
{
// 基础绘图优先显示
constexpr float Z_DEFAULT = 0.0f;
// 窗口order范围
constexpr float Z_DEFAULT_WIDNOW_MIN = 0.10f;
constexpr float Z_DEFAULT_WIDNOW_MAX = 0.50f;
// ui单独
constexpr float Z_DEFAULT_UI = 0.55f;
// ui系统
constexpr float Z_DEFAULT_PANEL = 0.60f;
// 用户
constexpr float Z_DEFAULT_GAME = 0.75f;
// 背景
constexpr float Z_DEFAULT_BG = 0.98f;
// RenderTarget
constexpr float Z_DEFAULT_RENDER_TARGET = 0.99f;
 
 
constexpr Float LENGTH_NORMAL = 32.0f;
constexpr Position POS_ZERO = { 0, 0 };
constexpr Position POS_NORMAL = { LENGTH_NORMAL ,LENGTH_NORMAL };
constexpr Quad QUAD_DEFAULT_SPRITE = createQuad(POS_ZERO, POS_NORMAL);
constexpr Position SIZE_DEFAULT_SPRITE = { LENGTH_NORMAL, LENGTH_NORMAL };
 
using UV = Array<float, 2>;
struct SpriteID
{
    std::size_t _tex;   
    std::size_t _rect; 
    SpriteID() :
        _tex{},
        _rect{}
    {}
    SpriteID(std::size_t tex, std::size_t rect) :
        _tex{ tex },
        _rect{ rect }
    {}
};
 
inline std::string to_string(const SpriteID& id)
{
    return fmt::format("tex: {}, rect: {}", id._tex, id._rect);
}

class Sprite
{
    friend class VK;
    friend class Factory;
    friend class PoolList<Sprite>;
public:
    enum class Sampler
    {
        NORMAL, // 线性采样（写实画风使用）
        PIXEL, // 点采样（像素风使用）
        UI,       // 线性采样、无mipmap
    };
    enum class Blend
    {
        NORMAL,
        EFFECT,
        GRAY
    };

    void Render();
 
    float GetOrder() const { return _order; }
    Quad GetQuad() const { return _quad; }
    Coor* GetCoor() const { return _coor; }
    SpriteID GetID() const {return _id;}
    void SetOrder(float order);
 
    void SetQuad(const Quad& quad);
    void SetQuadOrigin();

    void DtQuadOffset(const Position& offset)
    {
        _quad += offset;
    }
    void DtQuadRotate(float rotate);
    void DtQuadScale(const Position& scale);
    void DtQuadScale(float scale)
    {
        DtQuadScale({scale, scale});
    }

    void SetQuad(QuadParam& param);
    
    void SetColor(const Color& col);
    void SetColor(const Color& col, size_t index);
    void SetCoor(Coor* coor, bool own = false)
    { 
        _coor = coor;
        _bOwnCoor = own;
    }

    void CreateCoor()
    {
        if(!_coor)
        {
            SetCoor(Coor::Create(), true);
        }
        else
        {
            if(_bOwnCoor)
            {
                log_warn("已经具有Coor！");
                return;
            }
            SetCoor(Coor::Create(_coor), true);
        }
    }

    void DeleteCoor()
    {
        if (!_bOwnCoor)
            return;
        delete _coor;
        _coor = nullptr;
        _bOwnCoor = false;
    }

    void SetSampler(Sampler type)
    {
        _sampler = type;
    }

    void SetBlend(Blend type)
    {
        _blend = type;
    }

    void SetUI(bool ui, bool change_sampler = true);

    void SetClip(Rect* rect)
    {
        _scissorRect = rect;
    }

    void SetBright(float bright)
    {
        _bright = bright;
    }

    void SetUV(size_t index, const UV& uv);
 
    UV GetUV(size_t index);

    bool IsColorOne();

    bool IsPickup();
 

    Position GetSize() { return Math::GetQuadSize(_quad); }

    Position GetAnchor() { return -_quad.Get((size_t)Align::Corner::LT); }

    Color GetColor(size_t i = 0)
    {
        return _col[i];
    }

    bool IsOwnCoor() { return _bOwnCoor; }
        
    Coor* AddCoor()
    {
        if (IsOwnCoor())
            return _coor;
        else
        {//为精灵添加一个独立的Coor
            Coor* coor = Coor::Create(_coor);
            SetCoor(coor, true);
            return coor;
        }
    }
 
    void RenderDebug();
 
    ~Sprite();
private:
    Sprite() :
        _coor(nullptr),
        _viewport(nullptr),
        _scissorRect(nullptr),
        _sampler{ Sampler::NORMAL },
        _blend{ Blend::NORMAL },
        _bright{ 1.0f },
        _ui(false),
        _bRenderTarget{ false }, 
        _bOwnCoor{ false },
        _bRoundPixel{ true },
        _bRender{}
    {}
 
    Quad _quad; // 64byte
    std::array<Color, 4> _col;// 64byte
    std::array<Position, 4> _uv;// 32byte
 
    // 默认没有，可以直接指向rootCoor，不拥有资源
    Coor* _coor;
    Position4* _viewport;
    Rect* _scissorRect;
    Sampler _sampler;
    Blend _blend;
    float _bright; // 亮度
    float _order;// 与z等价
 
    //id
    SpriteID _id;// _rect为纹理区域，-1代表失效（手动指定uv的情况）
 
    bool _bRenderTarget;
    bool _ui;// 影响isPickup，防止穿透
    bool _bOwnCoor;// 拥有coor，为真时析构会delete coor
    bool _bRoundPixel;// 像素取整
 
    // -------------------------temp 不复制的属性----------------------
    bool _bRender;// 此帧已绘制
 
#ifndef NDEBUG
    std::string _name;
    bool _bDelete = false;
#endif // NDEBUG
 
 
    void _reset_not_copy()
    {
        _bRender = false;
#ifndef NDEBUG
        _bDelete = false;
#endif // NDEBUG
    }
};
 
using gcSprite = GC<Sprite>;
 

class SpriteSheet
{
public:
    SpriteSheet();
 
    gcSprite operator[](size_t index);
 
    const gcSprite Get(size_t index) const;
    Coor* GetCoor() { return _coor; }
    unsigned GetFPS() { return _fps; }
 
    void PushBack(gcSprite spr);
    void SetCoor(Coor* coor, bool own = false);
    void SetOrder(float order);
    void SetFPS(unsigned fps) { _fps = fps; }

    void RenderFrame(size_t index);

    void Render(Float dt);
 
    void Clear() { _allSprite.clear(); }
 
    ~SpriteSheet();
private:
    Coor* _coor;
    bool _bOwnCoor;
    std::vector<gcSprite>  _allSprite;
    Float _t;
    unsigned _fps;
};
}