#include "dl_factory.h" #include #include #ifndef DL_DISABLE_RENDER #include "dl_factory_imp.h" #include "io/dl_file.h" #include "system/dl_time.h" #include "vk/dl_vk.h" #include "dl_free_type.h" #include "io/dl_json.h" #include "system/dl_audio.h" #include "render/dl_render_def.h" #include "io/dl_input.h" #include "system/dl_engine.h" #include "system/dl_system.h" #include "io/dl_thread_task.h" #include "render/dl_particle.h" //#ifdef NDEBUG #define DL_2D_TEXTURE_USE_KTX //#endif namespace dl { Factory* g_factory; void Factory::LoadModel(std::string_view path_name, std::string_view name) { //-------------------------资源名字防止重复----------------------- std::string path_name_real; std::string res_name; if (!String::GetPathAndRes(_strPathModel, path_name, path_name_real, res_name, name)) return; auto iter = _imp->_mapName2Model.find(res_name); if (iter != _imp->_mapName2Model.end()) { log_warn("资源名字已经存在:{},id:{}", res_name, iter->second); return; } //-------------------------判断从文件还是从缓存读取----------------------- bool b_read_cache;// 是否从缓存读取 bool b_exist = File::IsExist(path_name_real);// 文件是否存在 ModelCache::Node* cache_node = _imp->_modelCache.Get(path_name_real);// 缓存是否存在 if(!b_exist && !cache_node) {// 不存在 log_err("加载模型失败(文件不存在,并且没有缓存文件):{}", path_name_real); return; } if (!b_exist && cache_node) {// 不存在,缓冲文件存在 b_read_cache = true; } else if (b_exist && cache_node) {// 都存在 // 检查是否需要更新 time_t t = File::GetLastWriteTime(path_name_real); if (cache_node->_t == t) b_read_cache = true; else { uint32_t crc32 = File::GetCrc32(path_name_real); if (crc32 == cache_node->_crc32) { b_read_cache = true; cache_node->_t = t; } else { cache_node->_crc32 = crc32; cache_node->_t = t; b_read_cache = false; } } } else {// 只文件存在 b_read_cache = false; cache_node = _imp->_modelCache.Add(path_name_real); if (!cache_node) { log_err("添加缓存文件失败:{}", path_name_real); return; } cache_node->_crc32 = File::GetCrc32(path_name_real); cache_node->_t = File::GetLastWriteTime(path_name_real); } FloatTime t0 = g_time->GetCurrent(); std::vector mul_model; if (b_read_cache) { // 加载所有子模型 for (std::string& str : cache_node->_allSub) { // 加载model_object ModelObject* model_object = new ModelObject; model_object->Load(str); // model_object -> model Model* model = g_vk->CreateModel(model_object); delete model_object; // 记录model mul_model.push_back(model); } if (mul_model.empty()) { log_err("模型加载失败(从缓存,没有sub):{}", res_name); return; } size_t id = g_vk->GetMulModelSize(); _imp->_mapName2Model[res_name] = id; g_vk->AddMulModel(mul_model); } else {// 从文件加载 std::vector mul_model_object = ModelObject::Create(path_name_real, res_name); if (mul_model_object.empty()) return; // 转换所有子模型 for (ModelObject* model_object : mul_model_object) { // model_object -> model Model* model = g_vk->CreateModel(model_object); // 记录model mul_model.push_back(model); } if (mul_model.empty()) { log_err("模型加载失败(从文件,没有sub):{}", path_name_real); return; } size_t id = g_vk->GetMulModelSize(); _imp->_mapName2Model[res_name] = id; g_vk->AddMulModel(mul_model); // 更新子模型 size_t i = 0; for (ModelObject* model_object : mul_model_object) {// 资源名+id // 文件名 std::string file_name = fmt::format("{}#{}", res_name, i); // model文件 const std::string PATH_CACHE = GetPathBinary3D(); std::string path_child = PATH_CACHE + file_name + ".model"; if (model_object->IsHaveTexture()) {// 存在贴图则转存 // tex文件路径 std::string path_tex = PATH_CACHE + "texture/" + file_name + "/"; File::CreateFolder(path_tex); // 复制贴图文件,并转换路径 model_object->ConvertTexturePath(path_tex); } model_object->SaveToFile(path_child); cache_node->_allSub.push_back(path_child); delete model_object; ++i; } } FloatTime t1 = g_time->GetCurrent(); log_msg("成功加载一个模型文件:{},子模型数量:{},从缓存:{},耗时:{}", res_name, mul_model.size(), b_read_cache, t1 - t0); } std::vector Factory::GetAllModel() { std::vector ret; for (auto& iter : _imp->_mapName2Model) ret.push_back(iter.first); return ret; } gcActor Factory::CreateActor(std::string_view name) { gcActor act = get_gc(); act->_idModel = _imp->_get_model_id(name); act->_trans = Transform::Create(); act->_color = nullptr; act->_modelAnimationInstance = _imp->_create_model_bone_animation(name); act->_rigidBody = nullptr; return act; } Camera* Factory::GetCamera() { return g_vk->GetCamera(); } size_t Factory::LoadSkybox(std::string_view path) { return g_vk->LoadSkybox(path); } void Factory::SetSkybox(size_t id) { g_vk->SetSkybox(id); } void Factory::SetDebugView3D(DebugView3D type) { g_vk->SetDebugView(type); } dl::DebugView3D Factory::GetDebugView3D() { return g_vk->GetDebugView(); } void Factory::UpdateDebugView() { // bool ctrl = g_input->KeyState(KeyCode::LEFT_CONTROL); bool alt = g_input->KeyState(KeyCode::LEFT_ALT); if (!ctrl && !alt) { if (g_input->KeyDown(KeyCode::KP_0)) SetDebugView3D((DebugView3D)0); else if (g_input->KeyDown(KeyCode::KP_1)) SetDebugView3D((DebugView3D)1); else if (g_input->KeyDown(KeyCode::KP_2)) SetDebugView3D((DebugView3D)2); else if (g_input->KeyDown(KeyCode::KP_3)) SetDebugView3D((DebugView3D)3); else if (g_input->KeyDown(KeyCode::KP_4)) SetDebugView3D((DebugView3D)4); else if (g_input->KeyDown(KeyCode::KP_5)) SetDebugView3D((DebugView3D)5); else if (g_input->KeyDown(KeyCode::KP_6)) SetDebugView3D((DebugView3D)6); else if (g_input->KeyDown(KeyCode::KP_7)) SetDebugView3D((DebugView3D)7); else if (g_input->KeyDown(KeyCode::KP_8)) SetDebugView3D((DebugView3D)8); else if (g_input->KeyDown(KeyCode::KP_9)) SetDebugView3D((DebugView3D)9); } else if (ctrl) { if (g_input->KeyDown(KeyCode::KP_0)) SetDebugView3D((DebugView3D)10); else if (g_input->KeyDown(KeyCode::KP_1)) SetDebugView3D((DebugView3D)11); else if (g_input->KeyDown(KeyCode::KP_2)) SetDebugView3D((DebugView3D)12); else if (g_input->KeyDown(KeyCode::KP_3)) SetDebugView3D((DebugView3D)13); else if (g_input->KeyDown(KeyCode::KP_4)) SetDebugView3D((DebugView3D)14); else if (g_input->KeyDown(KeyCode::KP_5)) SetDebugView3D((DebugView3D)15); else if (g_input->KeyDown(KeyCode::KP_6)) SetDebugView3D((DebugView3D)16); else if (g_input->KeyDown(KeyCode::KP_7)) SetDebugView3D((DebugView3D)17); else if (g_input->KeyDown(KeyCode::KP_8)) SetDebugView3D((DebugView3D)18); else if (g_input->KeyDown(KeyCode::KP_9)) SetDebugView3D((DebugView3D)19); } else if (alt) { if (g_input->KeyDown(KeyCode::KP_0)) SetDebugView3D((DebugView3D)20); else if (g_input->KeyDown(KeyCode::KP_1)) SetDebugView3D((DebugView3D)21); else if (g_input->KeyDown(KeyCode::KP_2)) SetDebugView3D((DebugView3D)22); else if (g_input->KeyDown(KeyCode::KP_3)) SetDebugView3D((DebugView3D)23); else if (g_input->KeyDown(KeyCode::KP_4)) SetDebugView3D((DebugView3D)24); else if (g_input->KeyDown(KeyCode::KP_5)) SetDebugView3D((DebugView3D)25); else if (g_input->KeyDown(KeyCode::KP_6)) SetDebugView3D((DebugView3D)26); else if (g_input->KeyDown(KeyCode::KP_7)) SetDebugView3D((DebugView3D)27); else if (g_input->KeyDown(KeyCode::KP_8)) SetDebugView3D((DebugView3D)28); else if (g_input->KeyDown(KeyCode::KP_9)) SetDebugView3D((DebugView3D)29); } } gcSprite Factory::CreateSpriteDefault(const Color& col /*= ColorDef::WHITE*/) { auto spr = get_gc(); bool b_solid = col[3] == 0.0f || col[3] == 1.0f; //等于0时,用户很有可能随后修改透明度 spr->_id = b_solid ? _imp->_idSolid : _imp->_idSolidTrans; spr->_quad = QUAD_DEFAULT_SPRITE; spr->_order = Z_DEFAULT; FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr->_id); assert(spr_info && "可能是忘了关闭发布模式"); for (int i = 0; i != 4; ++i) { spr->_col[i] = col; spr->_uv[i] = spr_info->_uv[i]; } spr->_sampler = _samplerNormal; #ifndef NDEBUG spr->_name = ":"; #endif return spr; } gcSprite Factory::CreateSprite(const SpriteID& spr_id) { FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err("获取SpriteInfo失败:{}", to_string(spr_id)); return g_factory->CreateSpriteDefault(); } auto spr = get_gc(); spr->SetColor(spr_info->_color); spr->_id = spr_id; // 如果旋转过 Size size = Align::GetSize(spr_info->_rect); if (spr_info->_bRightAngle) std::swap(size[0], size[1]); spr->_quad = createQuad(size, false) - spr_info->_anchor;//偏移锚点 spr->_order = Z_DEFAULT; for (int i = 0; i != 4; ++i) spr->_uv[i] = spr_info->_uv[i]; spr->_sampler = _samplerNormal; #ifndef NDEBUG spr->_name = GetSpriteName(spr_id); #endif return spr; } gcSprite Factory::CreateSprite(std::string_view name, size_t index /*= 0*/) { return CreateSprite(GetSpriteId(name, index)); } dl::gcSprite Factory::CreateSprite(size_t rt_id) { auto spr = get_gc(); spr->_id._tex = rt_id; spr->_id._rect = (size_t)-1; spr->_bRenderTarget = true; spr->_quad = createQuad(g_system->GetWindowSize(), false); spr->_order = Z_DEFAULT_RENDER_TARGET; for (int i = 0; i != 4; ++i) { spr->_col[i] = ColorDef::WHITE; } spr->_uv[0] = { 0.0f, 0.0f }; spr->_uv[1] = { 1.0f, 0.0f }; spr->_uv[2] = { 1.0f, 1.0f }; spr->_uv[3] = { 0.0f, 1.0f }; spr->_sampler = _samplerNormal; #ifndef NDEBUG spr->_name = fmt::format("RenderTarget: {}", rt_id); #endif return spr; } bool Factory::RegisterSprite(std::string_view name, size_t index, Image* img, const Position& anchor) { if (!img) { log_err("传入图像为空:{}", name); return false; } //--------------------记录Rect到Factory的_vecRectInfo---------------- auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); if (iter != _imp->_sprGroup._mapName2SpriteID.end()) { log_warn("精灵名字已存在:{}", name); return false; } // size_t id_tex; size_t id_rect; // 旋转精灵使w更大 bool right_angle = false; { Image img_r; if (img->GetHeight() > img->GetWidth()) { img_r = Image::RotateRightAngle1(*img); img = &img_r; right_angle = true; } if (!_imp->_reg_image(img, SIZE_BORDER_SPRITE, true, id_tex, id_rect)) { log_err0("注册图像失败!"); return false; } } // 创建 sprite_id std::vector& vec_spr_id = _imp->_sprGroup._mapName2SpriteID[std::string{ name }]; SpriteID& spr_id = Select::CreateIfEmpty(vec_spr_id, index); spr_id._tex = id_tex; spr_id._rect = id_rect; //{纹理id,区域id} -> { SpriteInfo } FactoryImp::SpriteInfo& info = Select::CreateIfEmpty( _imp->_sprGroup._allSpriteInfo, id_tex, id_rect); RectU rect = _imp->_get_rect(id_tex, id_rect, SIZE_BORDER_SPRITE); info._rect = rect; _imp->_rect_to_uv(rect, info._uv, right_angle); info._anchor = anchor; info._color = ColorDef::WHITE; info._bRightAngle = right_angle; return true; } bool Factory::UpdateSprite(std::string_view name, size_t index, Image* img, const Position& anchor /*= {}*/, bool mipmap) { if (!img) { log_err("传入图像为空:{}", name); return false; } // 返回已存在的 SpriteID spr_id; if (!GetSpriteId(name, index, spr_id)) { log_err("精灵不存在:{},{}", name, index); return false; } FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err("返回精灵信息失败:{}, {}", name, index); return false; } // 检查大小是否匹配 Size size_old = Align::GetSize(spr_info->_rect); if (spr_info->_bRightAngle) { std::swap(size_old.w, size_old.h); } if (img->GetSize() != size_old) { log_err("更新精灵失败,大小不匹配:{}, {}, {} -> {}", name, index, size_old, img->GetSize()); return false; } // 注册图像 Image img_r; if (spr_info->_bRightAngle) { img_r = Image::RotateRightAngle1(*img); img = &img_r; } if (!_imp->_update_image(img, SIZE_BORDER_SPRITE, spr_id._tex, spr_id._rect, mipmap)) { log_err0("注册图像失败!"); return false; } // 信息更新 spr_info->_anchor = anchor; return true; } bool Factory::HasSprite(std::string_view name) { auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); return iter != _imp->_sprGroup._mapName2SpriteID.end(); } std::vector Factory::CreateSpriteMulti(std::string_view name, size_t num /*= 0*/, size_t index /*= 0*/) { auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); if (iter == _imp->_sprGroup._mapName2SpriteID.end()) { log_warn("SpriteSheet不存在:{}", name); return {}; } std::vector& all_id = iter->second; if (num == 0) num = all_id.size(); std::vector ret; ret.resize(num); for (size_t i = 0; i < num; ++i) { ret[i] = CreateSprite(all_id[i]); } return ret; } gcSprite Factory::CloneSprite(gcSprite& spr) { auto ret = get_gc(*(spr.operator->())); // 如果是拥有Coor,则需要深拷贝 if (ret->_bOwnCoor) ret->_coor = spr->_coor->Clone(); ret->_reset_not_copy(); return ret; } std::vector Factory::GetFolderAllSpriteName(std::string_view folder_name) { std::vector ret; for (auto& iter : _imp->_sprGroup._mapName2SpriteID) { std::string_view name = iter.first; if (Sub::IsBegin(name, folder_name)) ret.push_back(std::string{ name }); } return ret; } size_t Factory::GetSpriteSheetNum(std::string_view name) { auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); if (iter == _imp->_sprGroup._mapName2SpriteID.end()) { log_warn("SpriteSheet不存在:{}", name); return 0; } return iter->second.size(); } SpriteID Factory::GetSpriteId(std::string_view name, size_t index) { auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); if (iter == _imp->_sprGroup._mapName2SpriteID.end()) { log_warn("SpriteSheet不存在:{}", name); return _imp->_idSolid; } std::vector& all_id = iter->second; if (index >= all_id.size()) { log_warn("下标越界:{},{}/{},", name, index, all_id.size()); return _imp->_idSolid; } return all_id[index]; } bool Factory::GetSpriteId(std::string_view name, size_t index, SpriteID& id) { auto iter = _imp->_sprGroup._mapName2SpriteID.find(std::string{ name }); if (iter == _imp->_sprGroup._mapName2SpriteID.end()) return false; std::vector& all_id = iter->second; if (index >= all_id.size()) return false; id = all_id[index]; return true; } Size Factory::GetSpriteTexSize(const SpriteID &spr_id) { FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err0("返回精灵信息失败!"); return toSizeNeg2Zero(SIZE_DEFAULT_SPRITE); } return Align::GetSize(spr_info->_rect); } dl::Quad Factory::GetSpriteQuad(const SpriteID& spr_id) { FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err0("返回精灵信息失败!"); return createQuad(toSizeNeg2Zero(SIZE_DEFAULT_SPRITE), false); } return createQuad(Align::GetSize(spr_info->_rect), false) - spr_info->_anchor; } std::string Factory::GetSpriteName(const SpriteID& spr_id) { for (auto& iter : _imp->_sprGroup._mapName2SpriteID) { for (SpriteID& iter1 : iter.second) { if (iter1._tex == spr_id._tex && iter1._rect == spr_id._rect) { return iter.first; } } } return "error"; } std::string Factory::GetSpriteNameIndex(const SpriteID& spr_id) { for (auto& iter : _imp->_sprGroup._mapName2SpriteID) { size_t i = 0; for (SpriteID& iter1 : iter.second) { if (iter1._tex == spr_id._tex && iter1._rect == spr_id._rect) { return iter.first + ',' + std::to_string(i); } ++i; } } return "error,0"; } Position Factory::GetSpriteAnchor(const SpriteID& spr_id) { FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err0("返回精灵信息失败!"); return {}; } return spr_info->_anchor; } dl::Color Factory::GetSpriteColor(const SpriteID& spr_id) { FactoryImp::SpriteInfo* spr_info = _imp->_get_sprite_info(spr_id); if (!spr_info) { log_err0("返回精灵信息失败!"); return {}; } return spr_info->_color; } dl::gcAnimation Factory::CreateAnimation(std::string_view name, std::string_view state, unsigned dir) { auto iter = _mapAnimationInfo.find(name); if (iter == _mapAnimationInfo.end()) { log_warn("创建精灵动画失败:{}:{}", name, state); return {}; } AnimationInfo& info = iter->second; auto iter1 = info._allAni.find(state); if (iter1 == info._allAni.end()) { log_warn("创建精灵动画失败:{},没有:{}", name, state); return {}; } AnimationInfo::Node& node = iter1->second; gcAnimation ret = get_gc(name, dir); if (info._type == "sheet") { std::string name_spr = name + "." + fmt::vformat(info._format, fmt::make_format_args(state)); unsigned count = node._count ? node._count : (unsigned)g_factory->GetSpriteSheetNum(name_spr); unsigned beg = node._beg + (count + node._skip) * dir; for (unsigned i = beg; i < beg + count; ++i) { gcSprite spr = g_factory->CreateSprite(name_spr, i); spr->DtQuadOffset(info._offset); ret->PushBack(spr); } ret->SetFrameTime(node._ftime); log_msg("创建动画:{}({}),{}", name, dir, ret->GetFrameCount()); } else if (info._type == "multi") { unsigned count = node._count; unsigned beg = node._beg + (count + node._skip) * dir; for (unsigned i = beg; i < beg + count; ++i) { std::string name_spr = name + "." + fmt::vformat(info._format, fmt::make_format_args(state, i)); gcSprite spr = g_factory->CreateSprite(name_spr, 0); spr->DtQuadOffset(info._offset); ret->PushBack(spr); } ret->SetFrameTime(node._ftime); //log_msg("创建动画:{}({}),{}", name, dir, ret->GetFrameCount()); } else if (info._type == "packed") { std::string name_spr = name + "." + "__packed"; unsigned count = node._count ? node._count : (unsigned)g_factory->GetSpriteSheetNum(name_spr); unsigned beg = node._beg + (count + node._skip) * dir; for (unsigned i = beg; i < beg + count; ++i) { gcSprite spr = g_factory->CreateSprite(name_spr, i); spr->DtQuadOffset(info._offset); ret->PushBack(spr); } ret->SetFrameTime(node._ftime); log_msg("创建动画:{}({}),{}", name, dir, ret->GetFrameCount()); } else assert(0); return ret; } dl::gcAnimation Factory::CloneAnimation(gcAnimation ani) { auto ret = get_gc(*(ani.operator->())); if (ani->_coor) ret->_coor = ani->_coor->Clone(); ret->_vecSpr.clear(); for (auto& iter : ani->_vecSpr) { gcSprite spr = g_factory->CloneSprite(iter); spr->SetCoor(ret->_coor); ret->_vecSpr.push_back(spr); } return ret; } dl::gcSprite Factory::RenderSprite(std::string_view name, size_t index) { gcSprite ret = CreateSprite(name, index); _vecSprite.push_back(ret); return ret; } dl::gcSprite Factory::RenderSpriteDefault() { gcSprite ret = CreateSpriteDefault(); _vecSprite.push_back(ret); return ret; } dl::gcText Factory::RenderText() { gcText ret = CreateTextDefault(); _vecText.push_back(ret); return ret; } dl::gcAnimation Factory::RenderAnimation(std::string_view name, std::string_view state, unsigned dir) { // todo animation不是一帧 gcAnimation ret = CreateAnimation(name, state, dir); ret->Render(); _vecAnimation.push_back(ret); return ret; } size_t Factory::LoadFont(std::string_view path_name) { return g_freetype->LoadFace(path_name); } size_t Factory::GetFontSize() { return g_freetype->GetFontSize(); } gcText Factory::CreateText(size_t font_id /*= 0*/, unsigned font_size, const Color& col, unsigned font_outline, const Color& col_outline, unsigned font_shadow, const Color& col_shadow) { auto txt = get_gc(); if (font_id >= g_freetype->GetFontSize()) { log_err0("字体id越界,将使用0号!"); assert(font_id); font_id = 0; } txt->_fontId = font_id; txt->_fontSize[TextParam::NORMAL] = font_size; txt->_fontSize[TextParam::OUTLINE] = font_outline; txt->_fontSize[TextParam::SHADOW] = font_shadow; txt->_fontSizeReal = txt->_fontSize; txt->_col[TextParam::NORMAL] = col; txt->_col[TextParam::OUTLINE] = col_outline; txt->_col[TextParam::SHADOW] = col_shadow; txt->_coor = Coor::Create(); return txt; } CharImage* Factory::GetChar(const CharInfo& info) { // 缓存工作由CreateSpriteChar完成 return g_freetype->GetChar(info); } float Factory::CreateSpriteChar(const CharInfo& info, gcSprite& spr, gcSprite& spr_outline) { auto fn_failed = [&]() { spr = CreateSpriteDefault(); spr->SetQuad(createQuad(info._size, false)); spr_outline = CreateSpriteDefault(); spr_outline->SetQuad(createQuad(info._size, false)); }; if (info._font >= g_freetype->GetFontSize()) { log_err("字体id不存在:{}", info._font); fn_failed(); return 0; } if (info._size == 0) { log_err0("字体大小不能为0!"); fn_failed(); return 0; } // 排除控制字符 if ((info._ch >= 0 && info._ch <= 31) || info._ch == 127) { fn_failed(); return 0; } FactoryImp::CharSprite& char_spr = _imp->_hashCharImage[info]; FactoryImp::CharSprite::Data& d0 = char_spr._data[0]; FactoryImp::CharSprite::Data& d1 = char_spr._data[1]; RectU rect0; RectU rect1; // 注册图像(普通和描边一起注册) if (d0._idTex == 0) { CharImage* char_img = g_freetype->GetChar(info); if (char_img == nullptr) { log_err0("GetChar失败!"); fn_failed(); return 0; } char_spr._advance = char_img->_advance; char_spr._anchor = { -char_img->_bearingX, char_img->_bearingY }; //0 if (!_imp->_reg_image(char_img->_image, SIZE_BORDER_FONT, true, d0._idTex, d0._idRect)) { delete char_img; log_err0("注册图像失败!"); fn_failed(); return 0; } rect0 = _imp->_get_rect(d0._idTex, d0._idRect, SIZE_BORDER_FONT); _imp->_rect_to_uv(rect0, d0._uv); //1 if (info._outline > 0) { if (!_imp->_reg_image(char_img->_imageOutline, SIZE_BORDER_FONT, true, d1._idTex, d1._idRect)) { delete char_img; log_err0("注册图像(描边)失败!"); fn_failed(); return 0; } rect1 = _imp->_get_rect(d1._idTex, d1._idRect, SIZE_BORDER_FONT); _imp->_rect_to_uv(rect1, d1._uv); } delete char_img; } else { rect0 = _imp->_get_rect(d0._idTex, d0._idRect, SIZE_BORDER_FONT); if (info._outline > 0) { rect1 = _imp->_get_rect(d1._idTex, d1._idRect, SIZE_BORDER_FONT); } } //0 spr = MemoryPool::GetGC(); spr->SetColor(ColorDef::WHITE); spr->_id = { d0._idTex, d0._idRect}; spr->_quad = createQuad(Align::GetSize(rect0), false) - char_spr._anchor;//偏移锚点 spr->_order = Z_DEFAULT; for (int i = 0; i != 4; ++i) spr->_uv[i] = d0._uv[i]; //1 if (info._outline > 0) { spr_outline = MemoryPool::GetGC(); spr_outline->SetColor(ColorDef::WHITE); spr_outline->_id = { d1._idTex, d1._idRect }; spr_outline->_quad = createQuad(Align::GetSize(rect1), false) - char_spr._anchor;//偏移锚点 spr_outline->_order = Z_DEFAULT; for (int i = 0; i != 4; ++i) spr_outline->_uv[i] = d1._uv[i]; } return char_spr._advance; } dl::Coor* Factory::GetRootCoor(size_t i) { return g_vk->GetRootCoor(i); } void Factory::AddColor(std::string_view name, const Color& col) { _hashTagColor[std::string{ name }] = col; } Color Factory::GetColor(std::string_view name) { if (name.size() == 10 && name[0] == '0' && name[1] == 'x') {//尝试十六进制 return createColor(name); } auto iter = _hashTagColor.find(std::string{ name }); if (iter == _hashTagColor.end()) { log_err("Tag颜色查找失败:{}", name); return ColorDef::WHITE; } else return iter->second; } std::optional Factory::GetColorCheck(std::string_view name) { auto iter = _hashTagColor.find(std::string{ name }); if (iter == _hashTagColor.end()) { return std::nullopt; } else return iter->second; } void Factory::ExportTexture2D() { g_vk->ExportTextureCanvas(_strPathTemp); } bool Factory::CompressMir2Res(std::string_view path) { if (!File::IsExist(path)) { log_err("目录不存在:{}", path); return false; } // 收集所有图片 std::vector all_image_path; File::GetPathContent(path, all_image_path, ".(png|PNG)$", false); // input struct ImageNode { Image* _img; int _index; // 旧index }; std::list all_image; for (auto& iter : all_image_path) { ImageNode node; node._img = Img::Create(iter); if (!node._img || node._img->size() <= 1) { delete node._img; log_msg("跳过图像:{}", iter); continue; } node._index = String::toInt(String::GetFileStem(iter), -1); if (node._index == -1) { delete node._img; log_msg("获取图标下标失败:{}", String::GetFileStem(iter)); continue; } all_image.push_back(node); } // output struct SrpiteOut { RectU _rect = {}; Point _anchor = {}; size_t _newIndex = -1; }; // 旧index -> Out std::unordered_map map_sprite_out; Image* img_big = Img::Create(SIZE_TEXTURE_2D_SIZE, ColorDef::NONE); // 合图 TexturePack::Static pack; pack.SetSize(SIZE_TEXTURE_2D_SIZE); // 获得大小 auto fn_get_size = [](const ImageNode& node) { return node._img->GetSize(); }; // 成功加入操作 size_t index = 0; auto fn_call_back = [&](const ImageNode& node, const PointU& lt) { RectU rect = createRectU(node._img->GetSize()); Img::AddRect(img_big, node._img, rect, lt); delete node._img; Align::OffsetRect(rect, lt); SrpiteOut out; out._rect = rect; out._newIndex = index++; map_sprite_out[node._index] = out; }; // 直到全部添加 pack.Calc(all_image, fn_get_size, fn_call_back); assert(all_image.empty()); Img::Save(img_big, path + "__packed.png"); delete img_big; // 精灵信息记录 if (File::IsExist(path + "Placements/")) { // 收集所有图片 std::vector all_txt_path; File::GetPathContent(path + "Placements/", all_txt_path, ".txt", false); for (auto& iter : all_txt_path) { std::string str = File::GetString(iter); Position pos = String::toPosition2(str, '\n'); int index = String::toInt(String::GetFileStem(iter), -1); auto iter1 = map_sprite_out.find(index); if (iter1 == map_sprite_out.end()) { log_warn("无效的旧下标:{}", index); continue; } iter1->second._anchor = toPoint(-pos); } } // 保存精灵信息 { json j; json j_arr = {}; for (auto& iter : map_sprite_out) { SrpiteOut& spr = iter.second; { json j_spr; j_spr["rect"] = spr._rect; j_spr["anchor"] = spr._anchor; j_arr[spr._newIndex] = j_spr; } } j["packed"] = j_arr; Json::SaveFile(j, path + "__packed.json"); } // 更新动画信息 { json j = Json::ParseFile(path + "__animation_old.json"); if (!j.is_null()) { AnimationInfo info = j; info._skip = 0; info._type = "packed"; info._format = ""; for (auto& iter : info._allAni) { AnimationInfo::Node& node = iter.second; node._skip = 0; auto iter1 = map_sprite_out.find(node._beg); if (iter1 == map_sprite_out.end()) { log_warn("无效的beg值:{}", node._beg); continue; } node._beg = (unsigned)iter1->second._newIndex; } j = info; Json::SaveFile(j, path + "__animation.json"); } } return true; } void Factory::_render_sprite(Sprite* spr) { const SpriteID& id = g_factory->GetImp()->_idTrans; VK::Canvas* canvas = nullptr; if (!spr->_bRenderTarget) canvas = g_vk->GetCanvasByTexture(spr->_id._tex); else canvas = g_vk->GetCanvasByRenderTarget(spr->_id._tex); assert(canvas); if (spr->_id._rect == -1 || !spr->IsColorOne() || (spr->_id._tex >= id._tex)) { //可能是半透明 canvas->_allSpriteTrans.push_back(spr); } else canvas->_allSprite.push_back(spr); } void Factory::_render_pickup() { if (g_input->KeyDown(KeyCode::DELETE)) log_pause0("拾取检测"); if (_bOrderPickupShow) { if (!_vecPickupSprite.empty()) { _vecPickupSprite.back()->RenderDebug(); } if (!_vecPickupText.empty()) { _vecPickupText.back()->RenderDebug(); } } } struct ColorTag { char _name[32]; uint32_t _color; }; //void Factory::LoadColorCsv(std::string_view name) //{ // assert(0); // /*std::vector all; // CsvFile::Deserialize(name, all); // // for (auto& iter : all) // { // AddColor(iter._name, ABGR::CreateColor(iter._color)); // }*/ //} void Factory::LoadColorJson(std::string_view path_name) { json j = Json::ParseFile(path_name); if (j.is_null()) return; for (auto& iter : j.items()) { std::string str; if (Json::Cast(iter.value(), str)) { AddColor(iter.key(), createColor(str)); } } } void Factory::SetOrderPickup(float order) { if (g_input->KeyState(KeyCode::RIGHT_CONTROL) && g_input->KeyDown(KeyCode::DELETE)) log_pause("当前拾取设置!"); _orderPickup = order; } void Factory::DeleteBinary(bool b_all, bool b_2d, bool b_3d) { if (!_bSetPath) { log_err0("尚未指定输出目录!"); return; } if (b_all) File::DeleteContent(GetPathBinary()); else { if (b_2d) File::DeleteContent(GetPathBinary2D()); if (b_3d) File::DeleteContent(GetPathBinary3D()); } } constexpr std::string_view NAME_CACHE_MODEL = "model.cache"; void Factory::_auto_render() { for (auto& iter : _vecSprite) iter->Render(); for (auto& iter : _vecText) iter->Render(); } void Factory::_clear_render() { _vecSprite.clear(); _vecText.clear(); _vecAnimation.clear(); } void Factory::_render_rt() { if(Engine::GetParamRef()._show3D) _sprRenderTarget0->Render(); } void Factory::_resize() { _sprRenderTarget0->SetQuad(createQuad(g_system->GetWindowSize(), false)); } void Factory::_init_path() { if (!_bSetPath) { SetPath( File::PathCurrent(), File::PathCurrent(), File::PathStorage(), File::PathTemp()); } // File::CreateFolder(File::PathCurrent()); // File::CreateFolder(File::PathStorage()); // File::CreateFolder(File::PathTemp()); // File::CreateFolder(File::PathPrivate()); File::CreateFolder(_mapPathImage[""]); File::CreateFolder(_strPathModel); File::CreateFolder(_strPathVoice); File::CreateFolder(_strPathBinary); File::CreateFolder(_strPathTemp); File::CreateFolder(GetPathBinary2D()); File::CreateFolder(GetPathBinary3D()); { File::SearchRule& rule = _ruleCheckImage; rule._vecFmt.push_back("jpg"); rule._vecFmt.push_back("jpeg"); rule._vecFmt.push_back("png"); rule._vecFmt.push_back("tag"); rule._vecFmt.push_back("bmp"); rule._vecFmt.push_back("gif"); rule._vecFmt.push_back("hdr"); rule._vecFmt.push_back("pic"); rule._vecFmt.push_back("json"); rule._vecFmt.push_back("txt"); rule._vecFilter.push_back("__animation.json"); rule._vecFilterFolder.push_back(".work"); } { File::SearchRule& rule = _ruleLoadImage; rule._vecFmt.push_back("jpg"); rule._vecFmt.push_back("jpeg"); rule._vecFmt.push_back("png"); rule._vecFmt.push_back("tag"); rule._vecFmt.push_back("bmp"); rule._vecFmt.push_back("gif"); rule._vecFmt.push_back("hdr"); rule._vecFmt.push_back("pic"); rule._vecFilterFolder.push_back(".work"); } // 因为每个模型单独存放,不会合并,所以算法不一样 // 针对每一个模型文件,缓存 效验值、中间文件路径 // 如果效验值不同,则生成中间文件,并更新效验值 _imp->_modelCache.Load(GetPathBinary3D() + NAME_CACHE_MODEL); // 合并大图纹理,生成Canvas _load_sprite(); } void Factory::_init_defualt_res() { // 先使用一下,保证gcSprite后于gcText析构 //gcSprite spr = CreateSpriteDefault(); //spr->SetColor(ColorDef::RED); _sprRenderTarget0 = CreateSprite(0); // 默认颜色 AddColor("red", ColorDef::RED); AddColor("green", ColorDef::GREEN); AddColor("blue", ColorDef::BLUE); AddColor("white", ColorDef::WHITE); AddColor("black", ColorDef::BLACK); AddColor("yellow", ColorDef::YELLOW); AddColor("purple", ColorDef::PURPLE); AddColor("cyan", ColorDef::CYAN); // 默认字体 LoadFont("dl/default.ttf"); // 默认模型 if (true) { //加载model_object ModelObject* model_object = new ModelObject; model_object->Load("dl/default.model"); //model_object -> model Model* model = g_vk->CreateModel(model_object); delete model_object; assert(model); size_t id = g_vk->GetMulModelSize(); _imp->_mapName2Model[":box"] = id; std::vector vec_model{ model }; g_vk->AddMulModel(vec_model); } // 默认粒子 g_particle->Load("dl/default_particle.json", ":"); } void FactoryImp::_rect_to_uv(const RectU& rect, UV* uv, bool right_angle) { using namespace Align; Position4 ltrb; for (int i = 0; i != 4; ++i) ltrb[i] = rect[i] / (Float)SIZE_TEXTURE_2D; if (!right_angle) { uv[(size_t)Corner::LT] = GetLT(ltrb); uv[(size_t)Corner::RT] = GetRT(ltrb); uv[(size_t)Corner::RB] = GetRB(ltrb); uv[(size_t)Corner::LB] = GetLB(ltrb); } else { uv[(size_t)Corner::LT] = GetRT(ltrb); uv[(size_t)Corner::RT] = GetRB(ltrb); uv[(size_t)Corner::RB] = GetLB(ltrb); uv[(size_t)Corner::LB] = GetLT(ltrb); } /*for (int i = 0; i != 4; ++i) uv[i][1] = 1.0f - uv[i][1];*/ } // //void to_json(json& j, const FactoryImp::SpriteInfo& info) //{ // j = json{ // {"rect", info._rect}, // {"uv", info._uv}, // {"color", info._color}, // {"anchor", info._anchor}, // {"right_angle", info._bRightAngle} // }; //} //void from_json(const json& j, FactoryImp::SpriteInfo& info) //{ // j.at("rect").get_to(info._rect); // j.at("uv").get_to(info._uv); // j.at("color").get_to(info._color); // j.at("anchor").get_to(info._anchor); // j.at("right_angle").get_to(info._bRightAngle); //} //void to_json(json& j, const SpriteID& id) //{ // j = json{ // {"tex", id._tex}, // {"rect", id._rect} // }; //} //void from_json(const json& j, SpriteID& id) //{ // j.at("tex").get_to(id._tex); // j.at("rect").get_to(id._rect); //} // //void to_json(json& j, const FactoryImp::SpriteGroup& group) //{ // j = json{ // {"id_trans", group._idTrans}, // {"sprite_info", group._allSpriteInfo}, // {"sprite_id", group._mapName2SpriteID}, // }; //} //void from_json(const json& j, FactoryImp::SpriteGroup& group) //{ // j.at("id_trans").get_to(group._idTrans); // j.at("sprite_info").get_to(group._allSpriteInfo); // j.at("sprite_id").get_to(group._mapName2SpriteID); //} ModelAnimationInstance* FactoryImp::_create_model_bone_animation(std::string_view name) { auto iter = _mapName2Model.find(std::string{ name }); if (iter == _mapName2Model.end()) { log_err("未知模型名称: {}", name); return nullptr; } // 现在只有一个model std::vector& mul_model = g_vk->GetMulModel(iter->second); // assert(mul_model.size() == 1); Model* model = mul_model[0]; // 存在骨骼动画,则生成实例 if (model->_allAnimation.empty()) { if(!model->_allSkin.empty()) log_warn("模型没有任何动画,但存在骨骼绑定:{}", name); return nullptr; } ModelAnimationInstance* ret = new ModelAnimationInstance; ret->_model = model; ret->_treeNode = model->_treeNode; ret->_treeNodeParent = model->_treeNodeParent; ret->UpdateNode(); //for (size_t i = 0; i < ret->_treeNode.size(); ++i) //{ // ret->_finalTrans[i] = Mat::CreateIdentity(); //} ret->_id = g_vk->GetUboBoneFree(); if (ret->_id == -1) { return nullptr; } g_vk->SetUboBoneUse(ret->_id); return ret; } constexpr PointU SPRITE_EXTEND_XY = { SIZE_BORDER_SPRITE, SIZE_BORDER_SPRITE }; constexpr Size SPRITE_EXTEND_SIZE = { SIZE_BORDER_SPRITE * 2, SIZE_BORDER_SPRITE * 2 }; bool FactoryImp::_reg_image(Image* image_src, unsigned border, bool border_fill, size_t& id_tex, size_t& id_rect) { RectU rect; // 包含border // 扩展图像 Size size = image_src->GetSize() + toLonger(border * 2); Image* image = Img::Create(size, ColorDef::NONE); Img::AddRect(image, image_src, createRectU(image_src->GetSize()), toLonger(border)); if (border_fill) Img::BuildBorder(image, border); bool b_add = false; for (size_t i = 0; i < _allTexPack.size(); ++i) { if (_allTexPack[i].Add(size, rect)) { b_add = true; id_tex = _numTexStatic + i; id_rect = _allTexRect[i].size(); _allTexRect[i].push_back(rect); break; } } if (!b_add) {//分配一个新的 TexPack tex_pack; tex_pack.Reset({ SIZE_TEXTURE_2D, SIZE_TEXTURE_2D }); if (!tex_pack.Add(size, rect)) { log_err0("注册图像失败!可能是图像太大。需要小于SIZE_TEXTURE_2D。"); return false; } id_tex = _numTexStatic + _allTexPack.size(); id_rect = 0; _allTexPack.push_back(tex_pack); _allTexRect.push_back({ rect }); std::array vec_image; unsigned size_big = SIZE_TEXTURE_2D; for (size_t i = 0; i < vec_image.size(); ++i) { vec_image[i] = Img::Create(toLonger(size_big), ColorDef::NONE); size_big >>= 1; assert(size_big); } g_vk->CreateCanvasImage(id_tex, vec_image); for (size_t i = 0; i < vec_image.size(); ++i) { delete vec_image[i]; } } Texture tex = g_vk->GetCanvasByTexture(id_tex)->_texture; g_vk->UpdateTexture2D(tex, Align::GetLT(rect), image, createRectU(image->GetSize())); delete image; return true; } bool FactoryImp::_update_image(Image* image_src, unsigned border, size_t id_tex, size_t id_rect, bool mipmap) { // 扩展图像 Size size = image_src->GetSize() + toLonger(border * 2); Image* image = Img::Create(size, ColorDef::NONE); Img::AddRect(image, image_src, createRectU(image_src->GetSize()), toLonger(border)); Img::BuildBorder(image, border); // 更新纹理 Texture tex = g_vk->GetCanvasByTexture(id_tex)->_texture; RectU rect = _get_rect_border(id_tex, id_rect); g_vk->UpdateTexture2D(tex, Align::GetLT(rect), image, createRectU(image->GetSize()), mipmap); delete image; return true; } void Factory::_save_cache() { if(!_imp->_modelCache.Empty()) _imp->_modelCache.Save(GetPathBinary3D() + NAME_CACHE_MODEL); } void Factory::_load_sprite() { assert(_bSetPath); // cache目录创建 const std::string PATH_CACHE = GetPathBinary2D(); File::CreateFolder(PATH_CACHE); #if DL_PLATFORM == DL_PLATFORM_ANDROID //_bUseBinary = true; // 提高加载速度 #endif // 如果文件没有修改(或发布模式),则尝试从out目录加载纹理 if (!_bUseBinary) { for (auto& iter : _mapPathImage) { std::string name = iter.first; std::string path = iter.second; std::string path_out = PATH_CACHE + name; if (!name.empty()) path_out += '/'; File::CreateFolder(path_out); if (File::CheckPathFileModified(path, _ruleCheckImage, path_out + "files.json", true)) { log_msg("开始读取2d资源从:{},并生成到:{} -> {}", path, path_out, name); _load_sprite_sub(path, name, path_out); } else { log_msg("跳过读取2d资源从:{},{} -> {}", path, path_out, name); } } } _load_sprite_binary(); _load_animation(); } void Factory::_load_sprite_binary() { const std::string PATH_CACHE = GetPathBinary2D(); _imp->_numTexStatic = 0; // 纹理id映射 std::unordered_map> map_tex_id; auto fn_load = [&](bool trans){ for (auto& iter : _mapPathImage) { std::string name = iter.first; std::string path = iter.second; std::string path_out = PATH_CACHE + name; if (!name.empty()) path_out += '/'; /*Json::DisableLog l; json j = Json::ParseFile(path_out + "sprite.json", true); if (j.is_null()) { log_err("从缓存目录读取2d资源失败:{}", path_out); continue; } FactoryImp::SpriteGroup spr_group; if (!Json::Get(j, spr_group)) { log_err("从缓存目录解析2d资源失败:{}", path_out); continue; }*/ StreamInput s; if (!s.LoadFromFile(path_out + "sprite.json", true)) { log_err("从缓存目录读取2d资源失败:{}", path_out); continue; } FactoryImp::SpriteGroup spr_group; s.Read(&spr_group._idTrans); s.Read(&spr_group._allSpriteInfo); s.Read(&spr_group._mapName2SpriteID); size_t i, tex_size; if (!trans) { i = 0; tex_size = spr_group._idTrans._tex; } else { i = spr_group._idTrans._tex; tex_size = spr_group._allSpriteInfo.size(); } #ifndef DL_2D_TEXTURE_USE_KTX for (; i < tex_size; ++i) { bool fail = false; std::array vec_image; for (size_t j = 0; j < vec_image.size(); ++j) { std::string tex_path = fmt::format("{}{}_{}.png", path_out, i, j); vec_image[j] = Img::Create(tex_path); if (vec_image[j] == nullptr) { log_err("纹理加载失败:{}", tex_path); fail = true; break; } } if (!fail) { map_tex_id[name][i] = _imp->_numTexStatic; log_msg("创建显存2d纹理:{},{}", _imp->_numTexStatic, path_out); // 创建纹理资源(创建Canvas,并创建纹理) g_vk->CreateCanvasImage(_imp->_numTexStatic++, vec_image); } for (size_t j = 0; j < vec_image.size(); ++j) { delete vec_image[j]; } } #else for (; i < tex_size; ++i) { std::string tex_path = fmt::format("{}{}_fast.ktx", path_out, i); std::string tex_path_full = fmt::format("{}{}.ktx", path_out, i); map_tex_id[name][i] = _imp->_numTexStatic; // 创建纹理资源(创建Canvas,并创建纹理) g_vk->CreateCanvasImageKtx(_imp->_numTexStatic++, tex_path, tex_path_full); } #endif if (trans) {// 第二步再统一生成 assert(map_tex_id.contains(name)); std::unordered_map map_id = map_tex_id[name]; // 生成全局名字,全局精灵id for (auto& iter : spr_group._mapName2SpriteID) { std::string spr_name = iter.first; std::vector& vec_spr_id = iter.second; if (!name.empty()) spr_name = name + '.' + spr_name; for (auto& iter1 : vec_spr_id) { SpriteID id; assert(map_id.contains(iter1._tex)); id._tex = map_id[iter1._tex]; id._rect = iter1._rect; _imp->_sprGroup._mapName2SpriteID[spr_name].push_back(id); // 特殊精灵处理 if (name.empty()) { if (spr_name == ":white") _imp->_idSolid = id; else if (spr_name == ":white_trans") _imp->_idSolidTrans = id; } } } // 生成全局精灵信息 for (size_t j = 0; j < spr_group._allSpriteInfo.size(); ++j) { std::vector& vec_info = spr_group._allSpriteInfo[j]; assert(map_id.contains(j)); size_t g_tex_id = map_id[j]; if (g_tex_id >= _imp->_sprGroup._allSpriteInfo.size()) _imp->_sprGroup._allSpriteInfo.resize(g_tex_id + 1); std::vector& vec_info_g = _imp->_sprGroup._allSpriteInfo[g_tex_id]; vec_info_g = vec_info; } } } }; fn_load(false); _imp->_idTrans._tex = _imp->_numTexStatic; fn_load(true); log_msg("从缓存目录读取所有2d资源完成:\n" "资源目录:{}\n" "图像路径数:{}\n" "纹理数:{}", PATH_CACHE, _mapPathImage.size(), _imp->_numTexStatic); } void Factory::_load_sprite_sub(std::string_view path, std::string_view name, std::string_view path_out) { // 遍历所有图像 std::vector mul_file; File::GetPathFileAll(path, mul_file, _ruleLoadImage); std::list list_sheet_node_normal; std::list list_sheet_node_trans; // 公共数据 struct SheetInfo { std::string _anchor; std::string _color; }; //double USE_TIME = 0; std::unordered_map map_sheet_info; for (std::string& path_name : mul_file) { log_info("开始加载图片:{}", path_name); // 0.image Image* image = Img::Create(path_name); if (!image) continue; // 划分为N个精灵 struct SheetNodeInfo { RectU _rect; std::string _anchor; std::string _color; }; SheetInfo sheet_info; std::vector vec_node; Size img_size = image->GetSize(); // 当前文件夹的精灵公共配置 { std::string path = File::GetFilePath(path_name); path += "__sprite.json"; // 避免重复解析文件 auto iter = map_sheet_info.find(path); if (iter == map_sheet_info.end()) { Json::DisableLog l; json j = Json::ParseFile(path); if (!j.is_null()) { Json::Get(j, "anchor", sheet_info._anchor);// 公共锚点 Json::Get(j, "color", sheet_info._color);// 公共颜色 } map_sheet_info[path] = sheet_info; } else sheet_info = iter->second; } // 不同meta处理 bool read_meta = false; if (!read_meta) { std::string file_name = String::GetFileStem(path_name); if (file_name == "__packed") { std::string meta_name = path_name; String::ReplaceExtension(meta_name, "json"); Json::DisableLog l; json j = Json::ParseFile(meta_name); if (!j.is_null()) { read_meta = true; json j_arr = {}; Json::Get(j, "packed", j_arr); for (auto& iter : j_arr) { SheetNodeInfo node; Point anchor; Json::Get(iter, "anchor", anchor); Json::Get(iter, "rect", node._rect); node._anchor = dl::to_string(anchor); vec_node.push_back(node); } } } } if(!read_meta) { // json meta std::string meta_name = path_name; String::ReplaceExtension(meta_name, "json"); Json::DisableLog l; json j = Json::ParseFile(meta_name); if (!j.is_null()) { read_meta = true; Json::Get(j, "anchor", sheet_info._anchor);// 公共锚点 Json::Get(j, "color", sheet_info._color);// 公共颜色 int split_mode = -1; if(split_mode == -1) { // 平均分割 Size split; if (Json::Get(j, "split", split)) {// 平均分割 split_mode = 0; // 单图大小 Size wh = img_size / split; // 子元素信息 for (unsigned y = 0; y < split.h; ++y) for (unsigned x = 0; x < split.w; ++x) { size_t index = (size_t)(y * split.w + x); SheetNodeInfo node; node._rect = createRectU(PointU{ x * wh[0], y * wh[1] }, wh); // 进一步获取独立信息 json j_spr; if (Json::Get(j, "sprite_" + to_string(index), j_spr)) { Json::Get(j_spr, "anchor", node._anchor);// 锚点 Json::Get(j_spr, "color", node._color);// 颜色 } vec_node.push_back(node); } } } if (split_mode == -1) { // 按x、y线分割 std::vector vec_split_x; std::vector vec_split_y; Json::Get(j, "split_x", vec_split_x); Json::Get(j, "split_y", vec_split_y); if (!vec_split_x.empty() || !vec_split_y.empty()) { std::vector vec_x; vec_x.push_back(0); vec_x.append_range(vec_split_x); vec_x.push_back(img_size.w); std::vector vec_y; vec_y.push_back(0); vec_y.append_range(vec_split_y); vec_y.push_back(img_size.h); size_t index = 0; for (unsigned j = 0; j < vec_y.size() - 1; ++j) { unsigned top = vec_y[j]; unsigned bottom = vec_y[j + 1]; for (unsigned i = 0; i < vec_x.size() - 1; ++i) { unsigned left = vec_x[i]; unsigned right = vec_x[i + 1]; SheetNodeInfo node; node._rect = { left, top, right, bottom }; // 进一步获取独立信息 json j_spr; if (Json::Get(j, "sprite_" + to_string(index), j_spr)) { Json::Get(j_spr, "anchor", node._anchor);// 锚点 Json::Get(j_spr, "color", node._color);// 颜色 } vec_node.push_back(node); ++index; } } } } } } if (!read_meta) { // Placements meta std::string meta_name = String::EraseFilename(std::string_view{ path_name }); meta_name = fmt::format("{}Placements/{}.txt", meta_name, String::GetFileStem(path_name)); std::string str = File::GetString(meta_name); if (!str.empty()) { read_meta = true; Position pos = String::toPosition2(str, '\n'); sheet_info._anchor = dl::to_string(-pos); } } // 如果没有配置、或只有一个精灵 if (vec_node.empty()) { SheetNodeInfo node; node._rect = createRectU(img_size); vec_node.push_back(node); } // 2.record for (size_t i = 0; i < vec_node.size(); ++i) { SheetNodeInfo& node = vec_node[i]; FactoryImp::SheetNode img_rect; img_rect._pathName = path_name; img_rect._rect = node._rect; img_rect._index = i; img_rect._color = ColorDef::WHITE; // 使用公共或独立锚点 if (!node._anchor.empty()) img_rect._anchor = Align::Anchor2Position(toPosition(Align::GetSize(node._rect)), node._anchor); else img_rect._anchor = Align::Anchor2Position(toPosition(Align::GetSize(node._rect)), sheet_info._anchor); // 使用公共或独立颜色 if (!node._color.empty()) img_rect._color = createColor(node._color); else img_rect._color = createColor(sheet_info._color); // 去透明空白部分 PointU lt = Align::GetLT(img_rect._rect); //double t0 = g_time->GetCurrent64(); Img::CalcLeastRect(image, img_rect._rect); //double t1 = g_time->GetCurrent64(); //USE_TIME += t1 - t0; // 更新锚点 img_rect._anchor -= toPosition(Align::GetLT(img_rect._rect) - lt); // 是否含有半透明颜色 bool is_have_translucent = Img::IsHaveTranslucent(image, img_rect._rect); if (is_have_translucent) list_sheet_node_trans.push_back(img_rect); else list_sheet_node_normal.push_back(img_rect); } delete image; } //log_test("拆切花费时间:{}", USE_TIME); log_msg("开始加载图片路径资源:{}\n" "非半透精灵:{}\n" "半透精灵:{}\n" "即将开始合并图集……", name, list_sheet_node_normal.size(), list_sheet_node_trans.size()); // 特殊精灵 添加到默认图集 if (name.empty()) { list_sheet_node_normal.push_back({ ":white", 0, createRectU(SIZE_SPRITE_DEFAULT), {}, ColorDef::WHITE }); list_sheet_node_trans.push_back({ ":white_trans", 0, createRectU(SIZE_SPRITE_DEFAULT), {}, ColorDef::WHITE }); } // 3.合并图集 TexturePack::Static pack; pack.SetSize(SIZE_TEXTURE_2D_SIZE); size_t pack_id = 0;//当前操作图集id // tex id -> nrit std::vector> all_snt; // 获得大小(扩展像素) auto fn_get_size = [](const FactoryImp::SheetNode& nri) { return Align::GetSize(nri._rect) + SPRITE_EXTEND_SIZE; }; // 成功加入操作 auto fn_call_back = [&](const FactoryImp::SheetNode& nri, const PointU& lt) { // rect未变,lt为扩展后位置 all_snt[pack_id].push_back({ nri, lt }); }; // 直到全部添加 while (!list_sheet_node_normal.empty()) { all_snt.push_back({}); pack.Calc(list_sheet_node_normal, fn_get_size, fn_call_back); ++pack_id; } // 记录id size_t tex_id_trans = pack_id; size_t rect_id_trans = 0; //直到全部添加 while (!list_sheet_node_trans.empty()) { all_snt.push_back({}); pack.Calc(list_sheet_node_trans, fn_get_size, fn_call_back); ++pack_id; } // 4.创建纹理、保存信息 // 多线程缩放图片 struct TaskResize { std::shared_ptr _img; Image* _imgBig; Size _size; RectU _rect; PointU _xy; }; MultiThreadTask mtt_resize; auto fn_resize = [](const TaskResize& task) { Image* img_scale = Img::Resize(task._img.get(), task._size); assert(img_scale); Img::AddRect(task._imgBig, img_scale, task._rect, task._xy); delete img_scale; //log_info("mtt resize: {}", mtt_resize.GetTaskNum()); }; mtt_resize.Init(fn_resize); // 多线程保存图片 struct TaskSave { #ifndef DL_2D_TEXTURE_USE_KTX Image* _img; #else std::array _vecImg; #endif std::string _pathName; }; MultiThreadTask mtt_save; auto fn_save = [&](TaskSave& task) { #ifndef DL_2D_TEXTURE_USE_KTX Img::Save(task._img, task._pathName); log_info("输出图像: {}", task._pathName); delete task._img; #else Img::SaveKtx(task._vecImg, task._pathName + ".ktx"); Img::SaveKtx(task._vecImg[2], task._pathName + "_fast.ktx"); log_info("输出图像: {}", task._pathName); for (auto& iter : task._vecImg) delete iter; #endif }; mtt_save.Init(fn_save); //------------------------------------------ FactoryImp::SpriteGroup group; size_t id_tex = 0; for (auto& iter : all_snt) { // 整个大图 包含mipmap std::array vec_image_big; unsigned size_big = SIZE_TEXTURE_2D; for (size_t i = 0; i < vec_image_big.size(); ++i) { vec_image_big[i] = Img::Create(toLonger(size_big), ColorDef::NONE); size_big >>= 1; assert(size_big); } size_t id_rect = 0; for (FactoryImp::SheetNodeTarget& snt : iter) { Image* p_image = nullptr; bool b_reg_special = false;//是否以特殊精灵创建 if (snt._sheetNode._pathName == ":white") {// 纯色精灵 p_image = Img::Create(SIZE_SPRITE_DEFAULT + SPRITE_EXTEND_SIZE, ColorDef::WHITE); b_reg_special = true; _imp->_idSolid = { id_tex, id_rect }; } else if (snt._sheetNode._pathName == ":white_trans") { p_image = Img::Create(SIZE_SPRITE_DEFAULT + SPRITE_EXTEND_SIZE, ColorDef::WHITE); b_reg_special = true; _imp->_idSolidTrans = { id_tex, id_rect }; } else { Image* image_src = Img::Create(snt._sheetNode._pathName); Size size = Align::GetSize(snt._sheetNode._rect) + SPRITE_EXTEND_SIZE; p_image = Img::Create(size, ColorDef::NONE); Img::AddRect(p_image, image_src, snt._sheetNode._rect, SPRITE_EXTEND_XY); Img::BuildBorder(p_image, SIZE_BORDER_SPRITE); delete image_src; } std::shared_ptr image{ p_image }; assert(p_image);// image现在为处理后的小图 // 加入到大图 constexpr unsigned EDGE = 1; Size image_size = image->GetSize(); RectU image_rect = createRectU(image->GetSize()); for (size_t i = 0; i < vec_image_big.size(); ++i) { if (i == 0) Img::AddRect(vec_image_big[i], image.get(), image_rect, snt._lt); else { Float scale = 1.0f / Math::Pow(2u, (unsigned)i); Size size = image_size / Math::Pow(2u, (unsigned)i); Every::ClampFloor(size, 1u); RectU rect = toSize(toPosition(image_rect) * scale); PointU lt = toSize(toPosition(snt._lt) * scale); TaskResize task; task._img = image; task._imgBig = vec_image_big[i]; task._rect = rect; task._size = size; task._xy = lt; //log_info("add task: {}, {}", rect, size); mtt_resize.AddTask(task); /*Image* img_scale = Img::Resize(image, size); assert(img_scale); Img::AddRect(vec_image_big[i], img_scale, rect, lt); delete img_scale;*/ } } //--------------------记录Rect到Factory的_vecRectInfo---------------- //名字转换 std::string name; if (!b_reg_special) {// 不是特殊精灵才生成资源名 name = String::GetResName(path, snt._sheetNode._pathName); } else name = snt._sheetNode._pathName; // 构建 name,index -> SpriteID std::vector& vec_spr_id = group._mapName2SpriteID[std::string{ name }]; if (snt._sheetNode._index >= vec_spr_id.size()) vec_spr_id.resize(snt._sheetNode._index + 1); SpriteID& spr_id = vec_spr_id[snt._sheetNode._index]; spr_id._tex = id_tex; spr_id._rect = id_rect; // 构建 SpriteID -> SpriteInfo if (id_tex >= group._allSpriteInfo.size()) group._allSpriteInfo.resize(id_tex + 1); std::vector& vec_info = group._allSpriteInfo[id_tex]; if (id_rect >= vec_info.size()) vec_info.resize(id_rect + 1); FactoryImp::SpriteInfo& info = vec_info[id_rect]; snt._lt += SPRITE_EXTEND_XY;// 还原到图像扩展之前位置 info._rect = createRectU(snt._lt, Align::GetSize(snt._sheetNode._rect)); _imp->_rect_to_uv(info._rect, info._uv); info._anchor = snt._sheetNode._anchor; info._color = snt._sheetNode._color; //delete image; ++id_rect; } mtt_resize.Wait(); #ifndef DL_2D_TEXTURE_USE_KTX for (size_t i = 0; i < vec_image_big.size(); ++i) { TaskSave task; task._img = vec_image_big[i]; task._pathName = fmt::format("{}{}_{}.png", path_out, id_tex, i); mtt_save.AddTask(task); } #else TaskSave task; task._vecImg = vec_image_big; task._pathName = fmt::format("{}{}", path_out, id_tex); mtt_save.AddTask(task); #endif ++id_tex; } mtt_save.Wait(); /*json j; j = group; Json::SaveFile(j, path_out + "sprite.json", true);*/ { StreamOutput s; s.Write(&group._idTrans); s.Write(&group._allSpriteInfo); s.Write(&group._mapName2SpriteID); s.Save(path_out + "sprite.json", true); } log_msg("合并图集并导出信息完成:{} -> {}", name, path_out); } void Factory::_load_animation() { // 动画加载 for (auto& iter : _mapPathImage) { std::string name = iter.first; std::string path = iter.second; // 遍历所有文件夹下的 __animation.json std::vector mul_file; File::GetPathFileAll(path, mul_file, "__animation.json"); for (std::string& path_name : mul_file) { log_info("开始加载动画:{}", path_name); json j = Json::ParseFile(path_name); if(j.is_null()) continue; std::string res_name; if (!name.empty()) { res_name = fmt::format("{}.{}", name, String::GetResName(path, path_name)); } else res_name = String::GetResName(path, path_name); String::EraseExtension(res_name); auto iter = _mapAnimationInfo.find(res_name); if (iter != _mapAnimationInfo.end()) { log_err("重复添加动画:{}", path_name); continue; } AnimationInfo info = j; _mapAnimationInfo[res_name] = info; log_info("加载动画成功:{}\n" "资源名:{}\n" "数量:{}", path_name, res_name, info._allAni.size()); } } } Factory::Factory() : _bSetPath{ false }, _bUseBinary{ false }, _bOrderPickupShow{ false }, _idTemp{ 0 }, _orderPickup{ 1.0f }, _samplerNormal{ Sprite::Sampler::NORMAL }, _samplerUI{ Sprite::Sampler::UI } { _imp = new FactoryImp; } Factory::~Factory() { _save_cache(); delete _imp; } } #endif