dl_factory.h

浏览该文件的文档.

#pragma once
 
#ifndef DL_DISABLE_RENDER
#include <unordered_map>
#include <optional>
 
#include "dl_type.h"
#include "base/dl_color.h"
#include "io/dl_log.h"
#include "io/dl_file.h"
#include "render/dl_sprite.h"
#include "render/dl_actor.h"
#include "render/dl_font.h"
#include "render/dl_text.h"
#include "render/dl_animation_info.h"
#include "render/dl_animation.h"
 
namespace dl
{
 
constexpr Size SIZE_SPRITE_DEFAULT = { 32, 32 };
constexpr std::string_view STR_PATH_2D = "2d/";
constexpr std::string_view STR_PATH_3D = "3d/";
 
class FactoryImp;
class Camera;
class Factory
{
    friend class System;
    friend class Engine;
public:
    void SetPath(
        std::string_view path_image = "image/",
        std::string_view path_model = "model/",
        std::string_view path_binary = "binary/",
        std::string_view path_temp = "temp/")
    { 
        if (_bSetPath)
        {
            log_damage0("只能设置一次，在调用Start之前！");
            return;
        }
        _bSetPath = true;
        _mapPathImage[""] = path_image;
        _strPathModel = path_model;
        _strPathBinary = path_binary;
        _strPathTemp = path_temp;
    }

    void SetSpriteSampler(Sprite::Sampler sampler_normal, Sprite::Sampler sampler_ui)
    {
        _samplerNormal = sampler_normal;
        _samplerUI = sampler_ui;
    }

    Sprite::Sampler GetSpriteSampler(bool is_ui)
    {
        return is_ui ? _samplerUI : _samplerNormal;
    }

    void SetReleaseMode()
    {
        _bUseBinary = true;
    }

    void RegisterImagePath(std::string_view path, std::string_view name)
    {
        if (_bSetPath)
        {
            log_err("请在调用SetPath之前添加图像路径：{}，{}", path, name);
            return;
        }
        auto iter = _mapPathImage.find(name);
        if (iter != _mapPathImage.end())
        {
            log_err("重复添加图像路径：{}，{}", path, name);
            return;
        }
        _mapPathImage[std::string{ name }] = path;
    }

    void LoadModel(std::string_view path_name, std::string_view name = "");
 
    std::vector<std::string> GetAllModel();

    std::string GetPathImage()
    {
        return _mapPathImage[""];
    }

    std::string GetPathVoice()
    {
        return _strPathVoice;
    }

    std::string GetPathModel()
    {
        return _strPathModel;
    }

    std::string GetPathBinary()
    {
        return _strPathBinary;
    }

    std::string GetPathBinary3D()
    {
        return _strPathBinary + std::string{ STR_PATH_3D };
    }

    std::string GetPathBinary2D()
    {
        return _strPathBinary + std::string{ STR_PATH_2D };
    }

    std::string GetPathTemp()
    {
        return _strPathTemp;
    }

    std::string GetPathNameTemp(std::string_view str_fmt = "")
    {
        std::string ret = str_fmt.empty() ?
            fmt::format("{}{}", _strPathTemp, _idTemp) :
            fmt::format("{}{}.{}", _strPathTemp, _idTemp, str_fmt);
        ++_idTemp;
        return ret;
    }

    gcActor CreateActor(std::string_view name);
 
    gcActor CreateActorDefault()
    {
        return CreateActor(":box");
    }

    Camera* GetCamera();

    size_t LoadSkybox(std::string_view path);
    void SetSkybox(size_t id);

    void SetDebugView3D(DebugView3D type);
    DebugView3D GetDebugView3D();
 
    void UpdateDebugView();
    //-----------------------------Sprite------------------------------
    [[nodiscard]]
    gcSprite CreateSpriteDefault(const Color& col = ColorDef::WHITE);

    gcSprite CreateSprite(const SpriteID& spr_id);
    gcSprite CreateSprite(
        std::string_view name,
        std::size_t index = 0);
    gcSprite CreateSprite(size_t rt_id);
    gcSprite CreateSpriteRandom(std::string_view name)
    {
        // TODO：可优化性能
        return CreateSprite(name, Random::SizeT(0, GetSpriteSheetNum(name) - 1));
    }

    bool RegisterSprite(std::string_view name, size_t index, Image* img, const Position& anchor = {});
    bool UpdateSprite(std::string_view name, size_t index, Image* img, const Position& anchor = {});
    bool HasSprite(std::string_view name);
    std::vector<gcSprite> CreateSpriteMulti(
        std::string_view name,
        std::size_t num = 0,
        std::size_t index = 0);

    gcSprite CloneSprite(gcSprite& spr);
    gcSprite CloneSprite(const gcSprite& spr)
    {
        return CloneSprite(const_cast<gcSprite&>(spr));
    }

    std::vector<std::string> GetFolderAllSpriteName(std::string_view folder_name);
    size_t GetSpriteSheetNum(std::string_view name);
    SpriteID GetSpriteId(std::string_view name, size_t index);
    bool GetSpriteId(std::string_view name, size_t index, SpriteID& id);
    Size GetSpriteTexSize(const SpriteID& spr_id);
    Size GetSpriteTexSize(gcSprite& spr) { return GetSpriteTexSize(spr->GetID()); }
    Quad GetSpriteQuad(const SpriteID& spr_id);
    Quad GetSpriteQuad(gcSprite& spr) { return GetSpriteQuad(spr->GetID()); }
    std::string GetSpriteName(const SpriteID& spr_id);
    std::string GetSpriteName(gcSprite& spr) { return GetSpriteName(spr->GetID()); }
    std::string GetSpriteNameIndex(const SpriteID& spr_id);
    std::string GetSpriteNameIndex(gcSprite& spr) { return GetSpriteNameIndex(spr->GetID()); }
    Position GetSpriteAnchor(const SpriteID& spr_id);
    Position GetSpriteAnchor(gcSprite& spr) { return GetSpriteAnchor(spr->GetID()); }
    Color GetSpriteColor(const SpriteID& spr_id);
    Color GetSpriteColor(gcSprite& spr) { return GetSpriteColor(spr->GetID()); }

    gcAnimation CreateAnimation(std::string_view name, std::string_view state, unsigned dir = 0);
    gcAnimation CloneAnimation(gcAnimation ani);
 
    //------------------------Render--------------------------
    gcSprite RenderSprite(std::string_view name, size_t index = 0);
    gcSprite RenderSpriteDefault();
    gcText RenderText();
    gcAnimation RenderAnimation(std::string_view name, std::string_view state, unsigned dir = 0);
 
    //------------------------Font--------------------------
    size_t LoadFont(std::string_view path_name);
    size_t GetFontSize();
    CharImage* GetChar(const CharInfo& info);

    float CreateSpriteChar(const CharInfo& info, gcSprite& spr, gcSprite& spr_outline);
 
    float CreateSpriteChar(const CharInfo& info, gcSprite& spr)
    {
        gcSprite spr_outline;
        return CreateSpriteChar(info, spr, spr_outline);
    }

    gcText CreateText(
        size_t font_id = 0, unsigned font_size = 16, const Color& col = ColorDef::WHITE,
        unsigned font_outline = 0, const Color& col_outline = ColorDef::BLACK,
        unsigned font_shadow = 0, const Color& col_shadow = ColorDef::BLACK);
 
    gcText CreateTextDefault()
    {
        gcText ret = CreateText(0, 16, ColorDef::WHITE);
        ret->SetString("Default");
        return ret;
    }

    gcText CloneText(gcText txt, bool copy_str = true)
    {
        gcText ret = CreateText(
            txt->_fontId, txt->_fontSize[0], txt->_col[0],
            txt->_fontSize[1], txt->_col[1],
            txt->_fontSize[2], txt->_col[2]);
        ret->GetCoor()->SetParent(txt->GetCoor()->GetParent());
        ret->_layout = txt->_layout;
        ret->_order = txt->_order;
        ret->_bFormat = txt->_bFormat;
        ret->SetBackground(txt.GetPointer());
        if (copy_str)
            ret->SetString(txt->GetString());
        return ret;
    }

    Coor* GetRootCoor(size_t i);
    //----------------------Color-----------------------------
    void AddColor(std::string_view name, const Color& col);

    Color GetColor(std::string_view name);

    std::optional<Color> GetColorCheck(std::string_view name);

    void LoadColorJson(std::string_view path_name);
 
 
    //-----------------------Other----------------------------
    void SetOrderPickup(float order);
    float GetOrderPickup() { return _orderPickup; }
 
    void SetOrderPickupShow(bool show) { _bOrderPickupShow = show; }
    bool GetOrderPickupShow() { return _bOrderPickupShow; }

    void DeleteBinary(bool b_all, bool b_2d, bool b_3d);
    void ExportTexture2D();

    bool CompressMir2Res(std::string_view path);
 
    FactoryImp* GetImp() { return _imp; }
 
    void _render_sprite(Sprite* spr);
 
    void _add_pickup_sprite(Sprite* spr)
    {
        _vecPickupSprite.push_back(spr);
    }
    void _add_pickup_text(Text* txt)
    {
        _vecPickupText.push_back(txt);
    }
    void _clear_pickup()
    {
        SetOrderPickup(1.0f);
        _vecPickupSprite.clear();
        _vecPickupText.clear();
    }
    void _render_pickup();
private:
    Factory();
    ~Factory();
 
    FactoryImp* _imp;
 
    // 图像路径 name -> path
    std::unordered_map<std::string, std::string, string_hash, std::equal_to<>> _mapPathImage;
    std::string _strPathModel;  //模型 根目录
    std::string _strPathVoice;  //音频 根目录
    std::string _strPathBinary; //输出 根目录
    std::string _strPathTemp;   //临时 根目录
    bool _bSetPath;
    bool _bUseBinary;           // 是否使用输出目录
    bool _bOrderPickupShow;     // 拾取检测调试绘图
    std::size_t _idTemp;        //临时文件使用id
 
    float _orderPickup;         // ui精灵拾取order
    Sprite::Sampler _samplerNormal;  // 精灵默认的采样方法
    Sprite::Sampler _samplerUI;  // ui精灵默认的采用方法
 
 
    //颜色tag
    std::unordered_map<std::string, Color> _hashTagColor;
 
    // 拾取检测
    std::vector<Sprite*> _vecPickupSprite;
    std::vector<Text*> _vecPickupText;
 
    // 加载图像规则
    File::SearchRule _ruleCheckImage;
    File::SearchRule _ruleLoadImage;
 
    // 动画信息
    std::unordered_map<std::string, AnimationInfo, string_hash, std::equal_to<>> _mapAnimationInfo;
 
    // Render接口绘制的资源（保留一帧）
    std::vector<gcSprite> _vecSprite;
    std::vector<gcText> _vecText;
    std::vector<gcAnimation> _vecAnimation;
    // 默认RenderTarget精灵
    gcSprite _sprRenderTarget0;
 
    void _auto_render();
    void _clear_render();
 
    void _render_rt();
    void _resize();
 
    //init之前会调用一次
    void _init_path();
    void _init_defualt_res();//初始化默认资源
    //init之后，程序结束均调用一次
    void _save_cache();
 
    // 加载精灵
    void _load_sprite();
    void _load_animation();
    // 从缓存加载
    void _load_sprite_binary();
    // 加载子目录
    void _load_sprite_sub(std::string_view path, std::string_view name, std::string_view path_out);
 
    // 精灵加载方法
    // 1.SetPath 设置默认的精灵图像路径 
    // 2.RegisterImagePath 设置额外的精灵图像路径
    // 3.进入Start游戏循环后，遍历所有目录，生成到binary/2d，每一个目录单独一个文件夹
    // 4.每一份都有 files.json、sprite.json 两个文件
    // 5.files.json记录文件改动，若文件变化，则重新生成此目录到binary
    // 6.sprite.json记录此目录的所有精灵
    // 7.最后合并所有精灵到_sprGroup
    // 8.发布版本只需要执行第1、2、7步
 
};
 
extern Factory* g_factory;
 
}
#endif