From 6a8714c1f3ba50a02d2e8ba83728ee8c123fa745 Mon Sep 17 00:00:00 2001 From: Jack Andersen Date: Sat, 11 Apr 2020 12:48:11 -1000 Subject: [PATCH] Update fmtlib --- hecl/driver/ToolBase.hpp | 24 ++-- hecl/driver/ToolCook.hpp | 6 +- hecl/driver/ToolExtract.hpp | 34 ++--- hecl/driver/ToolHelp.hpp | 4 +- hecl/driver/ToolImage.hpp | 20 +-- hecl/driver/ToolInit.hpp | 8 +- hecl/driver/ToolPackage.hpp | 16 +-- hecl/driver/ToolSpec.hpp | 22 +-- hecl/driver/main.cpp | 16 +-- hecl/extern/athena | 2 +- hecl/extern/boo | 2 +- hecl/include/hecl/Blender/Connection.hpp | 8 +- hecl/include/hecl/Database.hpp | 4 +- hecl/include/hecl/hecl.hpp | 20 +-- hecl/lib/Blender/Connection.cpp | 168 +++++++++++------------ hecl/lib/Blender/MeshOptimizer.cpp | 8 +- hecl/lib/CVar.cpp | 18 +-- hecl/lib/CVarManager.cpp | 16 +-- hecl/lib/ClientProcess.cpp | 16 +-- hecl/lib/Compilers.cpp | 26 ++-- hecl/lib/Console.cpp | 40 +++--- hecl/lib/HumanizeNumber.cpp | 8 +- hecl/lib/MultiProgressPrinter.cpp | 86 ++++++------ hecl/lib/Project.cpp | 18 +-- hecl/lib/ProjectPath.cpp | 4 +- hecl/lib/Runtime/FileStoreManager.cpp | 10 +- hecl/lib/Runtime/HMDL_RT.cpp | 2 +- hecl/lib/WideStringConvert.cpp | 8 +- hecl/lib/hecl.cpp | 20 +-- hecl/shaderc/main.cpp | 18 +-- hecl/shaderc/shaderc.cpp | 71 +++++----- 31 files changed, 362 insertions(+), 361 deletions(-) diff --git a/hecl/driver/ToolBase.hpp b/hecl/driver/ToolBase.hpp index 9f690dcb8..dc028ee0a 100644 --- a/hecl/driver/ToolBase.hpp +++ b/hecl/driver/ToolBase.hpp @@ -55,9 +55,9 @@ protected: bool continuePrompt() { if (!m_info.yes) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("\n" BLUE BOLD "Continue?" NORMAL " (Y/n) "))); + fmt::print(FMT_STRING(_SYS_STR("\n" BLUE BOLD "Continue?" NORMAL " (Y/n) "))); else - fmt::print(fmt(_SYS_STR("\nContinue? (Y/n) "))); + fmt::print(FMT_STRING(_SYS_STR("\nContinue? (Y/n) "))); fflush(stdout); int ch; @@ -73,7 +73,7 @@ protected: #endif { if (ch == 'n' || ch == 'N') { - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); return false; } if (ch == 'y' || ch == 'Y' || ch == '\r' || ch == '\n') @@ -83,7 +83,7 @@ protected: tcsetattr(0, TCSANOW, &tioOld); #endif } - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); return true; } @@ -175,27 +175,27 @@ public: #endif } - void print(const hecl::SystemChar* str) { fmt::print(m_sout, fmt(_SYS_STR("{}")), str); } + void print(const hecl::SystemChar* str) { fmt::print(m_sout, FMT_STRING(_SYS_STR("{}")), str); } void printBold(const hecl::SystemChar* str) { if (XTERM_COLOR) - fmt::print(m_sout, fmt(_SYS_STR("" BOLD "{}" NORMAL "")), str); + fmt::print(m_sout, FMT_STRING(_SYS_STR("" BOLD "{}" NORMAL "")), str); else - fmt::print(m_sout, fmt(_SYS_STR("{}")), str); + fmt::print(m_sout, FMT_STRING(_SYS_STR("{}")), str); } void secHead(const hecl::SystemChar* headName) { if (XTERM_COLOR) - fmt::print(m_sout, fmt(_SYS_STR("" BOLD "{}" NORMAL "\n")), headName); + fmt::print(m_sout, FMT_STRING(_SYS_STR("" BOLD "{}" NORMAL "\n")), headName); else - fmt::print(m_sout, fmt(_SYS_STR("{}\n")), headName); + fmt::print(m_sout, FMT_STRING(_SYS_STR("{}\n")), headName); } void optionHead(const hecl::SystemChar* flag, const hecl::SystemChar* synopsis) { if (XTERM_COLOR) - fmt::print(m_sout, fmt(_SYS_STR("" BOLD "{}" NORMAL " ({})\n")), flag, synopsis); + fmt::print(m_sout, FMT_STRING(_SYS_STR("" BOLD "{}" NORMAL " ({})\n")), flag, synopsis); else - fmt::print(m_sout, fmt(_SYS_STR("{} ({})\n")), flag, synopsis); + fmt::print(m_sout, FMT_STRING(_SYS_STR("{} ({})\n")), flag, synopsis); } void beginWrap() { m_wrapBuffer.clear(); } @@ -213,7 +213,7 @@ public: void endWrap() { _wrapBuf(m_wrapBuffer); m_wrapBuffer += _SYS_STR('\n'); - fmt::print(m_sout, fmt(_SYS_STR("{}")), m_wrapBuffer); + fmt::print(m_sout, FMT_STRING(_SYS_STR("{}")), m_wrapBuffer); m_wrapBuffer.clear(); } }; diff --git a/hecl/driver/ToolCook.hpp b/hecl/driver/ToolCook.hpp index 6996572dc..3bedd07e8 100644 --- a/hecl/driver/ToolCook.hpp +++ b/hecl/driver/ToolCook.hpp @@ -38,7 +38,7 @@ public: } } if (!m_spec) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("unable to find data spec '{}'")), specName); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to find data spec '{}'")), specName); continue; } else if (arg.size() >= 2 && arg[0] == _SYS_STR('-') && arg[1] == _SYS_STR('-')) continue; @@ -51,7 +51,7 @@ public: m_useProj = m_fallbackProj.get(); } else if (m_fallbackProj->getProjectRootPath() != root) LogModule.report(logvisor::Fatal, - fmt(_SYS_STR("hecl cook can only process multiple items in the same project; ") + FMT_STRING(_SYS_STR("hecl cook can only process multiple items in the same project; ") _SYS_STR("'{}' and '{}' are different projects")), m_fallbackProj->getProjectRootPath().getAbsolutePath(), root.getAbsolutePath()); @@ -61,7 +61,7 @@ public: } if (!m_useProj) LogModule.report(logvisor::Fatal, - fmt("hecl cook must be ran within a project directory or " + FMT_STRING("hecl cook must be ran within a project directory or " "provided a path within a project")); /* Default case: recursive at root */ diff --git a/hecl/driver/ToolExtract.hpp b/hecl/driver/ToolExtract.hpp index 8aaf8cb99..4b62ff3e5 100644 --- a/hecl/driver/ToolExtract.hpp +++ b/hecl/driver/ToolExtract.hpp @@ -29,7 +29,7 @@ class ToolExtract final : public ToolBase { public: explicit ToolExtract(const ToolPassInfo& info) : ToolBase(info) { if (!m_info.args.size()) - LogModule.report(logvisor::Fatal, fmt("hecl extract needs a source path as its first argument")); + LogModule.report(logvisor::Fatal, FMT_STRING("hecl extract needs a source path as its first argument")); if (!info.project) { hecl::SystemString rootDir; @@ -47,7 +47,7 @@ public: baseFile.assign(baseFile.begin(), baseFile.begin() + dotPos); if (baseFile.empty()) - LogModule.report(logvisor::Fatal, fmt("hecl extract must be ran within a project directory")); + LogModule.report(logvisor::Fatal, FMT_STRING("hecl extract must be ran within a project directory")); rootDir = info.cwd + baseFile; } else { @@ -62,8 +62,8 @@ public: newProjRoot.makeDir(); m_fallbackProj.reset(new hecl::Database::Project(newProjRoot)); if (logvisor::ErrorCount > ErrorRef) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("unable to init project at '{}'")), rootDir); - LogModule.report(logvisor::Info, fmt(_SYS_STR("initialized project at '{}/.hecl'")), rootDir); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to init project at '{}'")), rootDir); + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("initialized project at '{}/.hecl'")), rootDir); m_useProj = m_fallbackProj.get(); } else m_useProj = info.project; @@ -116,15 +116,15 @@ public: static void _recursivePrint(int level, hecl::Database::IDataSpec::ExtractReport& rep) { for (int l = 0; l < level; ++l) - fmt::print(fmt(_SYS_STR(" "))); + fmt::print(FMT_STRING(_SYS_STR(" "))); if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" BOLD "{}" NORMAL "")), rep.name); + fmt::print(FMT_STRING(_SYS_STR("" BOLD "{}" NORMAL "")), rep.name); else - fmt::print(fmt(_SYS_STR("{}")), rep.name); + fmt::print(FMT_STRING(_SYS_STR("{}")), rep.name); if (rep.desc.size()) - fmt::print(fmt(_SYS_STR(" [{}]")), rep.desc); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR(" [{}]")), rep.desc); + fmt::print(FMT_STRING(_SYS_STR("\n"))); for (hecl::Database::IDataSpec::ExtractReport& child : rep.childOpts) _recursivePrint(level + 1, child); } @@ -132,32 +132,32 @@ public: int run() override { if (m_specPasses.empty()) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" RED BOLD "NOTHING TO EXTRACT" NORMAL "\n"))); + fmt::print(FMT_STRING(_SYS_STR("" RED BOLD "NOTHING TO EXTRACT" NORMAL "\n"))); else - fmt::print(fmt(_SYS_STR("NOTHING TO EXTRACT\n"))); + fmt::print(FMT_STRING(_SYS_STR("NOTHING TO EXTRACT\n"))); return 1; } if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" GREEN BOLD "ABOUT TO EXTRACT:" NORMAL "\n"))); + fmt::print(FMT_STRING(_SYS_STR("" GREEN BOLD "ABOUT TO EXTRACT:" NORMAL "\n"))); else - fmt::print(fmt(_SYS_STR("ABOUT TO EXTRACT:\n"))); + fmt::print(FMT_STRING(_SYS_STR("ABOUT TO EXTRACT:\n"))); for (hecl::Database::IDataSpec::ExtractReport& rep : m_reps) { _recursivePrint(0, rep); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); } fflush(stdout); if (continuePrompt()) { for (SpecExtractPass& ds : m_specPasses) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" MAGENTA BOLD "Using DataSpec {}:" NORMAL "\n")), ds.m_entry->m_name); + fmt::print(FMT_STRING(_SYS_STR("" MAGENTA BOLD "Using DataSpec {}:" NORMAL "\n")), ds.m_entry->m_name); else - fmt::print(fmt(_SYS_STR("Using DataSpec {}:\n")), ds.m_entry->m_name); + fmt::print(FMT_STRING(_SYS_STR("Using DataSpec {}:\n")), ds.m_entry->m_name); ds.m_instance->doExtract(m_einfo, {true}); - fmt::print(fmt(_SYS_STR("\n\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n\n"))); } } diff --git a/hecl/driver/ToolHelp.hpp b/hecl/driver/ToolHelp.hpp index 0f36895eb..04a558a27 100644 --- a/hecl/driver/ToolHelp.hpp +++ b/hecl/driver/ToolHelp.hpp @@ -9,7 +9,7 @@ class ToolHelp final : public ToolBase { public: explicit ToolHelp(const ToolPassInfo& info) : ToolBase(info) { if (m_info.args.empty()) { - LogModule.report(logvisor::Error, fmt("help requires a tool name argument")); + LogModule.report(logvisor::Error, FMT_STRING("help requires a tool name argument")); return; } m_good = true; @@ -63,7 +63,7 @@ public: else if (toolName == _SYS_STR("help")) helpFunc = ToolHelp::Help; else { - LogModule.report(logvisor::Error, fmt(_SYS_STR("unrecognized tool '{}' - can't help")), toolName); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unrecognized tool '{}' - can't help")), toolName); return; } diff --git a/hecl/driver/ToolImage.hpp b/hecl/driver/ToolImage.hpp index 99ed91ecf..7e1b9cac5 100644 --- a/hecl/driver/ToolImage.hpp +++ b/hecl/driver/ToolImage.hpp @@ -17,7 +17,7 @@ class ToolImage final : public ToolBase { public: explicit ToolImage(const ToolPassInfo& info) : ToolBase(info), m_useProj(info.project) { if (!info.project) - LogModule.report(logvisor::Fatal, fmt("hecl image must be ran within a project directory")); + LogModule.report(logvisor::Fatal, FMT_STRING("hecl image must be ran within a project directory")); /* Scan args */ if (info.args.size()) { @@ -40,7 +40,7 @@ public: } if (!m_useProj) LogModule.report(logvisor::Fatal, - fmt("hecl image must be ran within a project directory or " + FMT_STRING("hecl image must be ran within a project directory or " "provided a path within a project")); } @@ -75,29 +75,29 @@ public: int run() override { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" GREEN BOLD "ABOUT TO IMAGE:" NORMAL "\n"))); + fmt::print(FMT_STRING(_SYS_STR("" GREEN BOLD "ABOUT TO IMAGE:" NORMAL "\n"))); else - fmt::print(fmt(_SYS_STR("ABOUT TO IMAGE:\n"))); + fmt::print(FMT_STRING(_SYS_STR("ABOUT TO IMAGE:\n"))); - fmt::print(fmt(_SYS_STR(" {}\n")), m_useProj->getProjectRootPath().getAbsolutePath()); + fmt::print(FMT_STRING(_SYS_STR(" {}\n")), m_useProj->getProjectRootPath().getAbsolutePath()); fflush(stdout); if (continuePrompt()) { hecl::ProjectPath outPath(m_useProj->getProjectWorkingPath(), _SYS_STR("out")); if (!outPath.isDirectory()) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("{} is not a directory")), outPath.getAbsolutePath()); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("{} is not a directory")), outPath.getAbsolutePath()); return 1; } hecl::ProjectPath bootBinPath(outPath, _SYS_STR("sys/boot.bin")); if (!bootBinPath.isFile()) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("{} is not a file")), bootBinPath.getAbsolutePath()); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("{} is not a file")), bootBinPath.getAbsolutePath()); return 1; } athena::io::FileReader r(bootBinPath.getAbsolutePath()); if (r.hasError()) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to open {}")), bootBinPath.getAbsolutePath()); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to open {}")), bootBinPath.getAbsolutePath()); return 1; } std::string id = r.readString(6); @@ -113,7 +113,7 @@ public: fileOut += _SYS_STR(".gcm"); if (nod::DiscBuilderGCN::CalculateTotalSizeRequired(outPath.getAbsolutePath()) == UINT64_MAX) return 1; - LogModule.report(logvisor::Info, fmt(_SYS_STR("Generating {} as GameCube image")), fileOut); + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Generating {} as GameCube image")), fileOut); nod::DiscBuilderGCN db(fileOut, progFunc); if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success) return 1; @@ -122,7 +122,7 @@ public: bool dualLayer; if (nod::DiscBuilderWii::CalculateTotalSizeRequired(outPath.getAbsolutePath(), dualLayer) == UINT64_MAX) return 1; - LogModule.report(logvisor::Info, fmt(_SYS_STR("Generating {} as {}-layer Wii image")), fileOut, + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Generating {} as {}-layer Wii image")), fileOut, dualLayer ? _SYS_STR("dual") : _SYS_STR("single")); nod::DiscBuilderWii db(fileOut, dualLayer, progFunc); if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success) diff --git a/hecl/driver/ToolInit.hpp b/hecl/driver/ToolInit.hpp index a454a7fa5..ed2758f26 100644 --- a/hecl/driver/ToolInit.hpp +++ b/hecl/driver/ToolInit.hpp @@ -18,18 +18,18 @@ public: if (hecl::Stat(dir->c_str(), &theStat)) { hecl::MakeDir(dir->c_str()); if (hecl::Stat(dir->c_str(), &theStat)) { - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("unable to stat '{}'")), *dir); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to stat '{}'")), *dir); return; } } if (!S_ISDIR(theStat.st_mode)) { - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("'{}' is not a directory")), *dir); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("'{}' is not a directory")), *dir); return; } hecl::SystemString testPath = *dir + _SYS_STR("/.hecl/beacon"); if (!hecl::Stat(testPath.c_str(), &theStat)) { - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("project already exists at '{}'")), *dir); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("project already exists at '{}'")), *dir); return; } @@ -43,7 +43,7 @@ public: hecl::Database::Project proj((hecl::ProjectRootPath(*m_dir))); if (logvisor::ErrorCount > ErrorRef) return 1; - LogModule.report(logvisor::Info, fmt(_SYS_STR("initialized project at '{}/.hecl'")), *m_dir); + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("initialized project at '{}/.hecl'")), *m_dir); return 0; } diff --git a/hecl/driver/ToolPackage.hpp b/hecl/driver/ToolPackage.hpp index 3efe19dea..6f68936d4 100644 --- a/hecl/driver/ToolPackage.hpp +++ b/hecl/driver/ToolPackage.hpp @@ -56,7 +56,7 @@ class ToolPackage final : public ToolBase { public: explicit ToolPackage(const ToolPassInfo& info) : ToolBase(info), m_useProj(info.project) { if (!info.project) - LogModule.report(logvisor::Fatal, fmt("hecl package must be ran within a project directory")); + LogModule.report(logvisor::Fatal, FMT_STRING("hecl package must be ran within a project directory")); /* Scan args */ if (info.args.size()) { @@ -77,7 +77,7 @@ public: } } if (!m_spec) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("unable to find data spec '{}'")), specName); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to find data spec '{}'")), specName); continue; } else if (arg.size() >= 2 && arg[0] == _SYS_STR('-') && arg[1] == _SYS_STR('-')) continue; @@ -91,7 +91,7 @@ public: m_useProj = m_fallbackProj.get(); } else if (m_fallbackProj->getProjectRootPath() != root) LogModule.report(logvisor::Fatal, - fmt(_SYS_STR("hecl package can only process multiple items in the same project; ") + FMT_STRING(_SYS_STR("hecl package can only process multiple items in the same project; ") _SYS_STR("'{}' and '{}' are different projects")), m_fallbackProj->getProjectRootPath().getAbsolutePath(), root.getAbsolutePath()); @@ -102,7 +102,7 @@ public: } if (!m_useProj) LogModule.report(logvisor::Fatal, - fmt("hecl package must be ran within a project directory or " + FMT_STRING("hecl package must be ran within a project directory or " "provided a path within a project")); /* Default case: recursive at root */ @@ -155,12 +155,12 @@ public: int run() override { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" GREEN BOLD "ABOUT TO PACKAGE:" NORMAL "\n"))); + fmt::print(FMT_STRING(_SYS_STR("" GREEN BOLD "ABOUT TO PACKAGE:" NORMAL "\n"))); else - fmt::print(fmt(_SYS_STR("ABOUT TO PACKAGE:\n"))); + fmt::print(FMT_STRING(_SYS_STR("ABOUT TO PACKAGE:\n"))); for (auto& item : m_selectedItems) - fmt::print(fmt(_SYS_STR(" {}\n")), item.getRelativePath()); + fmt::print(FMT_STRING(_SYS_STR(" {}\n")), item.getRelativePath()); fflush(stdout); if (continuePrompt()) { @@ -168,7 +168,7 @@ public: hecl::ClientProcess cp(&printer); for (const hecl::ProjectPath& path : m_selectedItems) { if (!m_useProj->packagePath(path, printer, m_fast, m_spec, &cp)) - LogModule.report(logvisor::Error, fmt(_SYS_STR("Unable to package {}")), path.getAbsolutePath()); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to package {}")), path.getAbsolutePath()); } cp.waitUntilComplete(); } diff --git a/hecl/driver/ToolSpec.hpp b/hecl/driver/ToolSpec.hpp index 549c34377..35b1b63d5 100644 --- a/hecl/driver/ToolSpec.hpp +++ b/hecl/driver/ToolSpec.hpp @@ -13,7 +13,7 @@ public: return; if (!info.project) - LogModule.report(logvisor::Fatal, fmt("hecl spec must be ran within a project directory")); + LogModule.report(logvisor::Fatal, FMT_STRING("hecl spec must be ran within a project directory")); const auto& specs = info.project->getDataSpecs(); hecl::SystemString firstArg = info.args.front(); @@ -27,7 +27,7 @@ public: return; if (info.args.size() < 2) - LogModule.report(logvisor::Fatal, fmt("Speclist argument required")); + LogModule.report(logvisor::Fatal, FMT_STRING("Speclist argument required")); auto it = info.args.begin(); ++it; @@ -41,7 +41,7 @@ public: } } if (!found) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("'{}' is not found in the dataspec registry")), *it); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("'{}' is not found in the dataspec registry")), *it); } } @@ -77,10 +77,10 @@ public: if (!m_info.project) { for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" BOLD CYAN "{}" NORMAL "\n")), spec->m_name); + fmt::print(FMT_STRING(_SYS_STR("" BOLD CYAN "{}" NORMAL "\n")), spec->m_name); else - fmt::print(fmt(_SYS_STR("{}\n")), spec->m_name); - fmt::print(fmt(_SYS_STR(" {}\n")), spec->m_desc); + fmt::print(FMT_STRING(_SYS_STR("{}\n")), spec->m_name); + fmt::print(FMT_STRING(_SYS_STR(" {}\n")), spec->m_desc); } return 0; } @@ -89,16 +89,16 @@ public: if (mode == MLIST) { for (auto& spec : specs) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" BOLD CYAN "{}" NORMAL "")), spec.spec.m_name); + fmt::print(FMT_STRING(_SYS_STR("" BOLD CYAN "{}" NORMAL "")), spec.spec.m_name); else - fmt::print(fmt(_SYS_STR("{}")), spec.spec.m_name); + fmt::print(FMT_STRING(_SYS_STR("{}")), spec.spec.m_name); if (spec.active) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR(" " BOLD GREEN "[ENABLED]" NORMAL ""))); + fmt::print(FMT_STRING(_SYS_STR(" " BOLD GREEN "[ENABLED]" NORMAL ""))); else - fmt::print(fmt(_SYS_STR(" [ENABLED]"))); + fmt::print(FMT_STRING(_SYS_STR(" [ENABLED]"))); } - fmt::print(fmt(_SYS_STR("\n {}\n")), spec.spec.m_desc); + fmt::print(FMT_STRING(_SYS_STR("\n {}\n")), spec.spec.m_desc); } return 0; } diff --git a/hecl/driver/main.cpp b/hecl/driver/main.cpp index bb62898fb..bfc856e7c 100644 --- a/hecl/driver/main.cpp +++ b/hecl/driver/main.cpp @@ -46,20 +46,20 @@ bool XTERM_COLOR = false; /* Main usage message */ static void printHelp(const hecl::SystemChar* pname) { if (XTERM_COLOR) - fmt::print(fmt(_SYS_STR("" BOLD "HECL" NORMAL ""))); + fmt::print(FMT_STRING(_SYS_STR("" BOLD "HECL" NORMAL ""))); else - fmt::print(fmt(_SYS_STR("HECL"))); + fmt::print(FMT_STRING(_SYS_STR("HECL"))); #if HECL_HAS_NOD #define TOOL_LIST "extract|init|cook|package|image|installaddon|help" #else #define TOOL_LIST "extract|init|cook|package|installaddon|help" #endif #if HECL_GIT - fmt::print(fmt(_SYS_STR(" Commit " HECL_GIT_S " " HECL_BRANCH_S "\nUsage: {} " TOOL_LIST "\n")), pname); + fmt::print(FMT_STRING(_SYS_STR(" Commit " HECL_GIT_S " " HECL_BRANCH_S "\nUsage: {} " TOOL_LIST "\n")), pname); #elif HECL_VER - fmt::print(fmt(_SYS_STR(" Version " HECL_VER_S "\nUsage: {} " TOOL_LIST "\n")), pname); + fmt::print(FMT_STRING(_SYS_STR(" Version " HECL_VER_S "\nUsage: {} " TOOL_LIST "\n")), pname); #else - fmt::print(fmt(_SYS_STR("\nUsage: {} " TOOL_LIST "\n")), pname); + fmt::print(FMT_STRING(_SYS_STR("\nUsage: {} " TOOL_LIST "\n")), pname); #endif } @@ -262,7 +262,7 @@ static std::unique_ptr MakeSelectedTool(hecl::SystemString toolName, T auto fp = hecl::FopenUnique(toolName.c_str(), _SYS_STR("rb")); if (fp == nullptr) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("unrecognized tool '{}'")), toolNameLower); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unrecognized tool '{}'")), toolNameLower); return nullptr; } fp.reset(); @@ -281,7 +281,7 @@ int main(int argc, const char** argv) #endif { if (argc > 1 && !hecl::StrCmp(argv[1], _SYS_STR("--dlpackage"))) { - fmt::print(fmt("{}\n"), HECL_DLPACKAGE); + fmt::print(FMT_STRING("{}\n"), HECL_DLPACKAGE); return 100; } @@ -345,7 +345,7 @@ int main(int argc, const char** argv) return 1; } if (info.verbosityLevel) { - LogModule.report(logvisor::Info, fmt(_SYS_STR("Constructed tool '{}' {}\n")), tool->toolName(), + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Constructed tool '{}' {}\n")), tool->toolName(), info.verbosityLevel); } diff --git a/hecl/extern/athena b/hecl/extern/athena index ebda6add2..30fe23721 160000 --- a/hecl/extern/athena +++ b/hecl/extern/athena @@ -1 +1 @@ -Subproject commit ebda6add23ff8e0560e5eb080752b35fb84af5dc +Subproject commit 30fe237210e3f2cb74f3989ff2e8b8a41b5a6db5 diff --git a/hecl/extern/boo b/hecl/extern/boo index de8511969..c36895a10 160000 --- a/hecl/extern/boo +++ b/hecl/extern/boo @@ -1 +1 @@ -Subproject commit de85119690a57b13d1258d20bc93fb54601c648c +Subproject commit c36895a109b37df558ba3a14cf054a2b30008bec diff --git a/hecl/include/hecl/Blender/Connection.hpp b/hecl/include/hecl/Blender/Connection.hpp index 451b9af46..f207816f4 100644 --- a/hecl/include/hecl/Blender/Connection.hpp +++ b/hecl/include/hecl/Blender/Connection.hpp @@ -805,7 +805,7 @@ class Connection { char readBuf[16]; _readStr(readBuf, 16); if (status != readBuf) - BlenderLog.report(logvisor::Fatal, fmt("{}: {}: {}"), m_loadedBlend.getRelativePathUTF8(), action, readBuf); + BlenderLog.report(logvisor::Fatal, FMT_STRING("{}: {}: {}"), m_loadedBlend.getRelativePathUTF8(), action, readBuf); } void _checkReady(std::string_view action) { _checkStatus(action, "READY"sv); } void _checkDone(std::string_view action) { _checkStatus(action, "DONE"sv); } @@ -835,14 +835,14 @@ public: PyOutStream beginPythonOut(bool deleteOnError = false) { bool expect = false; if (!m_lock.compare_exchange_strong(expect, true)) - BlenderLog.report(logvisor::Fatal, fmt("lock already held for blender::Connection::beginPythonOut()")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("lock already held for blender::Connection::beginPythonOut()")); return PyOutStream(this, deleteOnError); } DataStream beginData() { bool expect = false; if (!m_lock.compare_exchange_strong(expect, true)) - BlenderLog.report(logvisor::Fatal, fmt("lock already held for blender::Connection::beginDataIn()")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("lock already held for blender::Connection::beginDataIn()")); return DataStream(this); } @@ -860,7 +860,7 @@ public: template void PyOutStream::format(const S& format, Args&&... args) { if (!m_parent || !m_parent->m_lock) - BlenderLog.report(logvisor::Fatal, fmt("lock not held for PyOutStream::format()")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("lock not held for PyOutStream::format()")); fmt::print(*this, format, std::forward(args)...); } diff --git a/hecl/include/hecl/Database.hpp b/hecl/include/hecl/Database.hpp index e61d33377..1b6c426fe 100644 --- a/hecl/include/hecl/Database.hpp +++ b/hecl/include/hecl/Database.hpp @@ -85,14 +85,14 @@ public: virtual bool canExtract([[maybe_unused]] const ExtractPassInfo& info, [[maybe_unused]] std::vector& reps) { - LogModule.report(logvisor::Error, fmt("not implemented")); + LogModule.report(logvisor::Error, FMT_STRING("not implemented")); return false; } virtual void doExtract([[maybe_unused]] const ExtractPassInfo& info, [[maybe_unused]] const MultiProgressPrinter& progress) {} virtual bool canCook([[maybe_unused]] const ProjectPath& path, [[maybe_unused]] blender::Token& btok) { - LogModule.report(logvisor::Error, fmt("not implemented")); + LogModule.report(logvisor::Error, FMT_STRING("not implemented")); return false; } virtual const DataSpecEntry* overrideDataSpec([[maybe_unused]] const ProjectPath& path, diff --git a/hecl/include/hecl/hecl.hpp b/hecl/include/hecl/hecl.hpp index 44fd9598c..a9cb23ec8 100644 --- a/hecl/include/hecl/hecl.hpp +++ b/hecl/include/hecl/hecl.hpp @@ -195,11 +195,11 @@ inline void MakeDir(const char* dir) { HRESULT err; if (!CreateDirectoryA(dir, NULL)) if ((err = GetLastError()) != ERROR_ALREADY_EXISTS) - LogModule.report(logvisor::Fatal, fmt("MakeDir({})"), dir); + LogModule.report(logvisor::Fatal, FMT_STRING("MakeDir({})"), dir); #else if (mkdir(dir, 0755)) if (errno != EEXIST) - LogModule.report(logvisor::Fatal, fmt("MakeDir({}): {}"), dir, strerror(errno)); + LogModule.report(logvisor::Fatal, FMT_STRING("MakeDir({}): {}"), dir, strerror(errno)); #endif } @@ -208,7 +208,7 @@ inline void MakeDir(const wchar_t* dir) { HRESULT err; if (!CreateDirectoryW(dir, NULL)) if ((err = GetLastError()) != ERROR_ALREADY_EXISTS) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("MakeDir({})")), dir); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("MakeDir({})")), dir); } #endif @@ -274,7 +274,7 @@ inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType &ov); #else if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB)) - LogModule.report(logvisor::Error, fmt("flock {}: {}"), path, strerror(errno)); + LogModule.report(logvisor::Error, FMT_STRING("flock {}: {}"), path, strerror(errno)); #endif } @@ -376,16 +376,16 @@ inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz) { wchar_t* end; DWORD ret = GetFullPathNameW(path, 1024, buf, &end); if (!ret || ret > 1024) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("GetFullPathNameW {}")), path); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("GetFullPathNameW {}")), path); if (end) end[0] = L'\0'; if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr)) - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError()); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("GetDiskFreeSpaceExW {}: {}")), path, GetLastError()); return reqSz < freeBytes.QuadPart; #else struct statvfs svfs; if (statvfs(path, &svfs)) - LogModule.report(logvisor::Fatal, fmt("statvfs {}: {}"), path, strerror(errno)); + LogModule.report(logvisor::Fatal, FMT_STRING("statvfs {}: {}"), path, strerror(errno)); return reqSz < svfs.f_frsize * svfs.f_bavail; #endif } @@ -611,7 +611,7 @@ public: return SystemString(beginIt, absPathForward.cend()); } } - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("unable to resolve '{}' as project relative '{}'")), absPath, + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to resolve '{}' as project relative '{}'")), absPath, m_projRoot); return SystemString(); } @@ -784,7 +784,7 @@ public: */ ProjectPath getParentPath() const { if (m_relPath == _SYS_STR(".")) - LogModule.report(logvisor::Fatal, fmt("attempted to resolve parent of root project path")); + LogModule.report(logvisor::Fatal, FMT_STRING("attempted to resolve parent of root project path")); size_t pos = m_relPath.rfind(_SYS_STR('/')); if (pos == SystemString::npos) return ProjectPath(*m_proj, _SYS_STR("")); @@ -1083,7 +1083,7 @@ public: */ Database::Project& getProject() const { if (!m_proj) - LogModule.report(logvisor::Fatal, fmt("ProjectPath::getProject() called on unqualified path")); + LogModule.report(logvisor::Fatal, FMT_STRING("ProjectPath::getProject() called on unqualified path")); return *m_proj; } diff --git a/hecl/lib/Blender/Connection.cpp b/hecl/lib/Blender/Connection.cpp index bcd71fb78..3e2d89dcc 100644 --- a/hecl/lib/Blender/Connection.cpp +++ b/hecl/lib/Blender/Connection.cpp @@ -70,7 +70,7 @@ static void InstallBlendershell(const SystemChar* path) { auto fp = hecl::FopenUnique(path, _SYS_STR("w")); if (fp == nullptr) { - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("unable to open {} for writing")), path); + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to open {} for writing")), path); } std::fwrite(HECL_BLENDERSHELL, 1, HECL_BLENDERSHELL_SZ, fp.get()); @@ -80,7 +80,7 @@ static void InstallAddon(const SystemChar* path) { auto fp = hecl::FopenUnique(path, _SYS_STR("wb")); if (fp == nullptr) { - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("Unable to install blender addon at '{}'")), path); + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to install blender addon at '{}'")), path); } std::fwrite(HECL_ADDON, 1, HECL_ADDON_SZ, fp.get()); @@ -128,20 +128,20 @@ uint32_t Connection::_readStr(char* buf, uint32_t bufSz) { uint32_t readLen; int ret = Read(m_readpipe[0], &readLen, sizeof(readLen)); if (ret < 4) { - BlenderLog.report(logvisor::Error, fmt("Pipe error {} {}"), ret, strerror(errno)); + BlenderLog.report(logvisor::Error, FMT_STRING("Pipe error {} {}"), ret, strerror(errno)); _blenderDied(); return 0; } if (readLen >= bufSz) { - BlenderLog.report(logvisor::Fatal, fmt("Pipe buffer overrun [{}/{}]"), readLen, bufSz); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Pipe buffer overrun [{}/{}]"), readLen, bufSz); *buf = '\0'; return 0; } ret = Read(m_readpipe[0], buf, readLen); if (ret < 0) { - BlenderLog.report(logvisor::Fatal, fmt("{}"), strerror(errno)); + BlenderLog.report(logvisor::Fatal, FMT_STRING("{}"), strerror(errno)); return 0; } @@ -266,11 +266,11 @@ void Connection::_blenderDied() { std::fseek(errFp.get(), 0, SEEK_SET); const auto buf = std::make_unique(len + 1); std::fread(buf.get(), 1, len, errFp.get()); - BlenderLog.report(logvisor::Fatal, fmt("\n{:.{}s}"), buf.get(), len); + BlenderLog.report(logvisor::Fatal, FMT_STRING("\n{:.{}s}"), buf.get(), len); } } - BlenderLog.report(logvisor::Fatal, fmt("Blender Exception")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Blender Exception")); } static std::atomic_bool BlenderFirstInit(false); @@ -287,7 +287,7 @@ static bool RegFileExists(const hecl::SystemChar* path) { Connection::Connection(int verbosityLevel) { #if !WINDOWS_STORE if (hecl::VerbosityLevel >= 1) - BlenderLog.report(logvisor::Info, fmt("Establishing BlenderConnection...")); + BlenderLog.report(logvisor::Info, FMT_STRING("Establishing BlenderConnection...")); /* Put hecl_blendershell.py in temp dir */ const SystemChar* TMPDIR = GetTmpDir(); @@ -321,20 +321,20 @@ Connection::Connection(int verbosityLevel) { SECURITY_ATTRIBUTES sattrs = {sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE}; HANDLE consoleOutReadTmp, consoleOutWrite, consoleErrWrite, consoleOutRead; if (!CreatePipe(&consoleOutReadTmp, &consoleOutWrite, &sattrs, 1024)) - BlenderLog.report(logvisor::Fatal, fmt("Error with CreatePipe")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Error with CreatePipe")); if (!DuplicateHandle(GetCurrentProcess(), consoleOutWrite, GetCurrentProcess(), &consoleErrWrite, 0, TRUE, DUPLICATE_SAME_ACCESS)) - BlenderLog.report(logvisor::Fatal, fmt("Error with DuplicateHandle")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Error with DuplicateHandle")); if (!DuplicateHandle(GetCurrentProcess(), consoleOutReadTmp, GetCurrentProcess(), &consoleOutRead, // Address of new handle. 0, FALSE, // Make it uninheritable. DUPLICATE_SAME_ACCESS)) - BlenderLog.report(logvisor::Fatal, fmt("Error with DupliateHandle")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Error with DupliateHandle")); if (!CloseHandle(consoleOutReadTmp)) - BlenderLog.report(logvisor::Fatal, fmt("Error with CloseHandle")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Error with CloseHandle")); #else pipe(m_readpipe.data()); pipe(m_writepipe.data()); @@ -365,15 +365,15 @@ Connection::Connection(int verbosityLevel) { /* No steam; try default */ wchar_t progFiles[256]; if (!GetEnvironmentVariableW(L"ProgramFiles", progFiles, 256)) - BlenderLog.report(logvisor::Fatal, fmt(L"unable to determine 'Program Files' path")); - blenderBinBuf = fmt::format(fmt(L"{}\\Blender Foundation\\Blender\\blender.exe"), progFiles); + BlenderLog.report(logvisor::Fatal, FMT_STRING(L"unable to determine 'Program Files' path")); + blenderBinBuf = fmt::format(FMT_STRING(L"{}\\Blender Foundation\\Blender\\blender.exe"), progFiles); blenderBin = blenderBinBuf.c_str(); if (!RegFileExists(blenderBin)) - BlenderLog.report(logvisor::Fatal, fmt(L"unable to find blender.exe")); + BlenderLog.report(logvisor::Fatal, FMT_STRING(L"unable to find blender.exe")); } } - std::wstring cmdLine = fmt::format(fmt(L" --background -P \"{}\" -- {} {} {} \"{}\""), blenderShellPath, + std::wstring cmdLine = fmt::format(FMT_STRING(L" --background -P \"{}\" -- {} {} {} \"{}\""), blenderShellPath, uintptr_t(writehandle), uintptr_t(readhandle), verbosityLevel, blenderAddonPath); STARTUPINFO sinfo = {sizeof(STARTUPINFO)}; @@ -395,7 +395,7 @@ Connection::Connection(int verbosityLevel) { FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, nullptr); - BlenderLog.report(logvisor::Fatal, fmt(L"unable to launch blender from {}: {}"), blenderBin, messageBuffer); + BlenderLog.report(logvisor::Fatal, FMT_STRING(L"unable to launch blender from {}: {}"), blenderBin, messageBuffer); } close(m_writepipe[0]); @@ -417,13 +417,13 @@ Connection::Connection(int verbosityLevel) { if (err == ERROR_BROKEN_PIPE) break; // pipe done - normal exit path. else - BlenderLog.report(logvisor::Error, fmt("Error with ReadFile: {:08X}"), err); // Something bad happened. + BlenderLog.report(logvisor::Error, FMT_STRING("Error with ReadFile: {:08X}"), err); // Something bad happened. } // Display the character read on the screen. auto lk = logvisor::LockLog(); if (!WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), lpBuffer, nBytesRead, &nCharsWritten, nullptr)) { - // BlenderLog.report(logvisor::Error, fmt("Error with WriteConsole: %08X"), GetLastError()); + // BlenderLog.report(logvisor::Error, FMT_STRING("Error with WriteConsole: %08X"), GetLastError()); } } @@ -449,16 +449,16 @@ Connection::Connection(int verbosityLevel) { } std::string errbuf; - std::string readfds = fmt::format(fmt("{}"), m_writepipe[0]); - std::string writefds = fmt::format(fmt("{}"), m_readpipe[1]); - std::string vLevel = fmt::format(fmt("{}"), verbosityLevel); + std::string readfds = fmt::format(FMT_STRING("{}"), m_writepipe[0]); + std::string writefds = fmt::format(FMT_STRING("{}"), m_readpipe[1]); + std::string vLevel = fmt::format(FMT_STRING("{}"), verbosityLevel); /* Try user-specified blender first */ if (blenderBin) { execlp(blenderBin, blenderBin, "--background", "-P", blenderShellPath.c_str(), "--", readfds.c_str(), writefds.c_str(), vLevel.c_str(), blenderAddonPath.c_str(), nullptr); if (errno != ENOENT) { - errbuf = fmt::format(fmt("NOLAUNCH {}"), strerror(errno)); + errbuf = fmt::format(FMT_STRING("NOLAUNCH {}"), strerror(errno)); _writeStr(errbuf.c_str(), errbuf.size(), m_readpipe[1]); exit(1); } @@ -476,7 +476,7 @@ Connection::Connection(int verbosityLevel) { execlp(blenderBin, blenderBin, "--background", "-P", blenderShellPath.c_str(), "--", readfds.c_str(), writefds.c_str(), vLevel.c_str(), blenderAddonPath.c_str(), nullptr); if (errno != ENOENT) { - errbuf = fmt::format(fmt("NOLAUNCH {}"), strerror(errno)); + errbuf = fmt::format(FMT_STRING("NOLAUNCH {}"), strerror(errno)); _writeStr(errbuf.c_str(), errbuf.size(), m_readpipe[1]); exit(1); } @@ -486,7 +486,7 @@ Connection::Connection(int verbosityLevel) { execlp(DEFAULT_BLENDER_BIN, DEFAULT_BLENDER_BIN, "--background", "-P", blenderShellPath.c_str(), "--", readfds.c_str(), writefds.c_str(), vLevel.c_str(), blenderAddonPath.c_str(), nullptr); if (errno != ENOENT) { - errbuf = fmt::format(fmt("NOLAUNCH {}"), strerror(errno)); + errbuf = fmt::format(FMT_STRING("NOLAUNCH {}"), strerror(errno)); _writeStr(errbuf.c_str(), errbuf.size(), m_readpipe[1]); exit(1); } @@ -503,10 +503,10 @@ Connection::Connection(int verbosityLevel) { /* Stash error path and unlink existing file */ #if _WIN32 m_errPath = hecl::SystemString(TMPDIR) + - fmt::format(fmt(_SYS_STR("/hecl_{:016X}.derp")), (unsigned long long)m_pinfo.dwProcessId); + fmt::format(FMT_STRING(_SYS_STR("/hecl_{:016X}.derp")), (unsigned long long)m_pinfo.dwProcessId); #else m_errPath = hecl::SystemString(TMPDIR) + - fmt::format(fmt(_SYS_STR("/hecl_{:016X}.derp")), (unsigned long long)m_blenderProc); + fmt::format(FMT_STRING(_SYS_STR("/hecl_{:016X}.derp")), (unsigned long long)m_blenderProc); #endif hecl::Unlink(m_errPath.c_str()); @@ -515,28 +515,28 @@ Connection::Connection(int verbosityLevel) { if (!lineStr.compare(0, 8, "NOLAUNCH")) { _closePipe(); - BlenderLog.report(logvisor::Fatal, fmt("Unable to launch blender: {}"), lineStr.c_str() + 9); + BlenderLog.report(logvisor::Fatal, FMT_STRING("Unable to launch blender: {}"), lineStr.c_str() + 9); } else if (!lineStr.compare(0, 9, "NOBLENDER")) { _closePipe(); #if _WIN32 - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("Unable to find blender at '{}'")), blenderBin); + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to find blender at '{}'")), blenderBin); #else if (blenderBin) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("Unable to find blender at '{}' or '{}'")), blenderBin, + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to find blender at '{}' or '{}'")), blenderBin, DEFAULT_BLENDER_BIN); else - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("Unable to find blender at '{}'")), DEFAULT_BLENDER_BIN); + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to find blender at '{}'")), DEFAULT_BLENDER_BIN); #endif } else if (lineStr == "NOT281") { _closePipe(); - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("Installed blender version must be >= 2.81"))); + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Installed blender version must be >= 2.81"))); } else if (lineStr == "NOADDON") { _closePipe(); if (blenderAddonPath != _SYS_STR("SKIPINSTALL")) InstallAddon(blenderAddonPath.c_str()); ++installAttempt; if (installAttempt >= 2) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("unable to install blender addon using '{}'")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to install blender addon using '{}'")), blenderAddonPath.c_str()); #ifndef _WIN32 waitpid(pid, nullptr, 0); @@ -551,14 +551,14 @@ Connection::Connection(int verbosityLevel) { continue; } else if (lineStr != "READY") { _closePipe(); - BlenderLog.report(logvisor::Fatal, fmt("read '{}' from blender; expected 'READY'"), lineStr); + BlenderLog.report(logvisor::Fatal, FMT_STRING("read '{}' from blender; expected 'READY'"), lineStr); } _writeStr("ACK"); break; } #else - BlenderLog.report(logvisor::Fatal, fmt("BlenderConnection not available on UWP")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("BlenderConnection not available on UWP")); #endif } @@ -585,7 +585,7 @@ bool PyOutStream::StreamBuf::sendLine(std::string_view line) { PyOutStream::StreamBuf::int_type PyOutStream::StreamBuf::overflow(int_type ch) { if (!m_parent.m_parent || !m_parent.m_parent->m_lock) - BlenderLog.report(logvisor::Fatal, fmt("lock not held for PyOutStream writing")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("lock not held for PyOutStream writing")); if (ch != traits_type::eof() && ch != '\n' && ch != '\0') { m_lineBuf += char_type(ch); return ch; @@ -597,7 +597,7 @@ PyOutStream::StreamBuf::int_type PyOutStream::StreamBuf::overflow(int_type ch) { std::streamsize PyOutStream::StreamBuf::xsputn(const char_type* __first, std::streamsize __n) { if (!m_parent.m_parent || !m_parent.m_parent->m_lock) - BlenderLog.report(logvisor::Fatal, fmt("lock not held for PyOutStream writing")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("lock not held for PyOutStream writing")); const char_type* __last = __first + __n; const char_type* __s = __first; for (const char_type* __e = __first; __e != __last; ++__e) { @@ -630,10 +630,10 @@ constexpr std::array BlendTypeStrs{ bool Connection::createBlend(const ProjectPath& path, BlendType type) { if (m_lock) { - BlenderLog.report(logvisor::Fatal, fmt("BlenderConnection::createBlend() musn't be called with stream active")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("BlenderConnection::createBlend() musn't be called with stream active")); return false; } - _writeStr(fmt::format(fmt("CREATE \"{}\" {}"), path.getAbsolutePathUTF8(), BlendTypeStrs[int(type)])); + _writeStr(fmt::format(FMT_STRING("CREATE \"{}\" {}"), path.getAbsolutePathUTF8(), BlendTypeStrs[int(type)])); if (_isFinished()) { /* Delete immediately in case save doesn't occur */ hecl::Unlink(path.getAbsolutePath().data()); @@ -646,12 +646,12 @@ bool Connection::createBlend(const ProjectPath& path, BlendType type) { bool Connection::openBlend(const ProjectPath& path, bool force) { if (m_lock) { - BlenderLog.report(logvisor::Fatal, fmt("BlenderConnection::openBlend() musn't be called with stream active")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("BlenderConnection::openBlend() musn't be called with stream active")); return false; } if (!force && path == m_loadedBlend) return true; - _writeStr(fmt::format(fmt("OPEN \"{}\""), path.getAbsolutePathUTF8())); + _writeStr(fmt::format(FMT_STRING("OPEN \"{}\""), path.getAbsolutePathUTF8())); if (_isFinished()) { m_loadedBlend = path; _writeStr("GETTYPE"); @@ -678,7 +678,7 @@ bool Connection::openBlend(const ProjectPath& path, bool force) { bool Connection::saveBlend() { if (m_lock) { - BlenderLog.report(logvisor::Fatal, fmt("BlenderConnection::saveBlend() musn't be called with stream active")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("BlenderConnection::saveBlend() musn't be called with stream active")); return false; } _writeStr("SAVE"); @@ -688,7 +688,7 @@ bool Connection::saveBlend() { void Connection::deleteBlend() { if (m_loadedBlend) { hecl::Unlink(m_loadedBlend.getAbsolutePath().data()); - BlenderLog.report(logvisor::Info, fmt(_SYS_STR("Deleted '{}'")), m_loadedBlend.getAbsolutePath()); + BlenderLog.report(logvisor::Info, FMT_STRING(_SYS_STR("Deleted '{}'")), m_loadedBlend.getAbsolutePath()); m_loadedBlend = ProjectPath(); } } @@ -710,7 +710,7 @@ void PyOutStream::close() { } void PyOutStream::linkBlend(std::string_view target, std::string_view objName, bool link) { - format(fmt("if '{}' not in bpy.data.scenes:\n" + format(FMT_STRING("if '{}' not in bpy.data.scenes:\n" " with bpy.data.libraries.load('''{}''', link={}, relative=True) as (data_from, data_to):\n" " data_to.scenes = data_from.scenes\n" " obj_scene = None\n" @@ -731,7 +731,7 @@ void PyOutStream::linkBlend(std::string_view target, std::string_view objName, b } void PyOutStream::linkArmature(std::string_view target, std::string_view armName) { - format(fmt("target_arm_name = '{}'\n" + format(FMT_STRING("target_arm_name = '{}'\n" "if target_arm_name not in bpy.data.armatures:\n" " with bpy.data.libraries.load('''{}''', link=True, relative=True) as (data_from, data_to):\n" " if target_arm_name not in data_from.armatures:\n" @@ -745,7 +745,7 @@ void PyOutStream::linkArmature(std::string_view target, std::string_view armName } void PyOutStream::linkMesh(std::string_view target, std::string_view meshName) { - format(fmt("target_mesh_name = '{}'\n" + format(FMT_STRING("target_mesh_name = '{}'\n" "if target_mesh_name not in bpy.data.objects:\n" " with bpy.data.libraries.load('''{}''', link=True, relative=True) as (data_from, data_to):\n" " if target_mesh_name not in data_from.objects:\n" @@ -758,7 +758,7 @@ void PyOutStream::linkMesh(std::string_view target, std::string_view meshName) { void PyOutStream::linkBackground(std::string_view target, std::string_view sceneName) { if (sceneName.empty()) { - format(fmt("with bpy.data.libraries.load('''{}''', link=True, relative=True) as (data_from, data_to):\n" + format(FMT_STRING("with bpy.data.libraries.load('''{}''', link=True, relative=True) as (data_from, data_to):\n" " data_to.scenes = data_from.scenes\n" "obj_scene = None\n" "for scene in data_to.scenes:\n" @@ -770,7 +770,7 @@ void PyOutStream::linkBackground(std::string_view target, std::string_view scene "bpy.context.scene.background_set = obj_scene\n"), target, target); } else { - format(fmt("if '{}' not in bpy.data.scenes:\n" + format(FMT_STRING("if '{}' not in bpy.data.scenes:\n" " with bpy.data.libraries.load('''{}''', link=True, relative=True) as (data_from, data_to):\n" " data_to.scenes = data_from.scenes\n" " obj_scene = None\n" @@ -789,7 +789,7 @@ void PyOutStream::linkBackground(std::string_view target, std::string_view scene void PyOutStream::AABBToBMesh(const atVec3f& min, const atVec3f& max) { athena::simd_floats minf(min.simd); athena::simd_floats maxf(max.simd); - format(fmt("bm = bmesh.new()\n" + format(FMT_STRING("bm = bmesh.new()\n" "bm.verts.new(({},{},{}))\n" "bm.verts.new(({},{},{}))\n" "bm.verts.new(({},{},{}))\n" @@ -852,7 +852,7 @@ ANIMOutStream::~ANIMOutStream() { void ANIMOutStream::changeCurve(CurveType type, unsigned crvIdx, unsigned keyCount) { if (m_curCount != m_totalCount) - BlenderLog.report(logvisor::Fatal, fmt("incomplete ANIMOutStream for change")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("incomplete ANIMOutStream for change")); m_curCount = 0; m_totalCount = keyCount; char tp = char(type); @@ -867,7 +867,7 @@ void ANIMOutStream::changeCurve(CurveType type, unsigned crvIdx, unsigned keyCou void ANIMOutStream::write(unsigned frame, float val) { if (!m_inCurve) - BlenderLog.report(logvisor::Fatal, fmt("changeCurve not called before write")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("changeCurve not called before write")); if (m_curCount < m_totalCount) { struct { uint32_t frm; @@ -876,7 +876,7 @@ void ANIMOutStream::write(unsigned frame, float val) { m_parent->_writeBuf(reinterpret_cast(&key), 8); ++m_curCount; } else - BlenderLog.report(logvisor::Fatal, fmt("ANIMOutStream keyCount overflow")); + BlenderLog.report(logvisor::Fatal, FMT_STRING("ANIMOutStream keyCount overflow")); } Mesh::SkinBind::SkinBind(Connection& conn) { @@ -1331,7 +1331,7 @@ std::vector DataStream::getLightList() { std::pair DataStream::getMeshAABB() { if (m_parent->m_loadedType != BlendType::Mesh && m_parent->m_loadedType != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a MESH or ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a MESH or ACTOR blend")), m_parent->m_loadedBlend.getAbsolutePath()); m_parent->_writeStr("MESHAABB"); @@ -1349,7 +1349,7 @@ const char* DataStream::MeshOutputModeString(HMDLTopology topology) { Mesh DataStream::compileMesh(HMDLTopology topology, int skinSlotCount) { if (m_parent->getBlendType() != BlendType::Mesh) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a MESH blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a MESH blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("MESHCOMPILE"); @@ -1360,10 +1360,10 @@ Mesh DataStream::compileMesh(HMDLTopology topology, int skinSlotCount) { Mesh DataStream::compileMesh(std::string_view name, HMDLTopology topology, int skinSlotCount, bool useLuv) { if (m_parent->getBlendType() != BlendType::Area) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an AREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an AREA blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("MESHCOMPILENAME {} {}"), name, int(useLuv))); + m_parent->_writeStr(fmt::format(FMT_STRING("MESHCOMPILENAME {} {}"), name, int(useLuv))); m_parent->_checkOk("unable to cook mesh"sv); return Mesh(*m_parent, topology, skinSlotCount, useLuv); @@ -1371,10 +1371,10 @@ Mesh DataStream::compileMesh(std::string_view name, HMDLTopology topology, int s ColMesh DataStream::compileColMesh(std::string_view name) { if (m_parent->getBlendType() != BlendType::Area) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an AREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an AREA blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("MESHCOMPILENAMECOLLISION {}"), name)); + m_parent->_writeStr(fmt::format(FMT_STRING("MESHCOMPILENAMECOLLISION {}"), name)); m_parent->_checkOk("unable to cook collision mesh"sv); return ColMesh(*m_parent); @@ -1382,7 +1382,7 @@ ColMesh DataStream::compileColMesh(std::string_view name) { std::vector DataStream::compileColMeshes() { if (m_parent->getBlendType() != BlendType::ColMesh) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a CMESH blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a CMESH blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("MESHCOMPILECOLLISIONALL"); @@ -1395,7 +1395,7 @@ std::vector DataStream::compileColMeshes() { std::vector DataStream::compileLights() { if (m_parent->getBlendType() != BlendType::Area) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an AREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an AREA blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("LIGHTCOMPILEALL"); @@ -1408,7 +1408,7 @@ std::vector DataStream::compileLights() { PathMesh DataStream::compilePathMesh() { if (m_parent->getBlendType() != BlendType::PathMesh) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a PATH blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a PATH blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("MESHCOMPILEPATH"); @@ -1419,10 +1419,10 @@ PathMesh DataStream::compilePathMesh() { std::vector DataStream::compileGuiFrame(int version) { if (m_parent->getBlendType() != BlendType::Frame) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a FRAME blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a FRAME blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("FRAMECOMPILE {}"), version)); + m_parent->_writeStr(fmt::format(FMT_STRING("FRAMECOMPILE {}"), version)); m_parent->_checkOk("unable to compile frame"sv); while (true) { @@ -1439,7 +1439,7 @@ std::vector DataStream::compileGuiFrame(int version) { relative = proj.getProjectRootPath().getProjectRelativeFromAbsolute(absolute.sys_str()); hecl::ProjectPath path(proj.getProjectWorkingPath(), relative); - m_parent->_writeStr(fmt::format(fmt("{:08X}"), path.parsedHash32())); + m_parent->_writeStr(fmt::format(FMT_STRING("{:08X}"), path.parsedHash32())); } std::vector ret; @@ -1461,7 +1461,7 @@ std::vector DataStream::getTextures() { Actor DataStream::compileActor() { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("ACTORCOMPILE"); @@ -1472,7 +1472,7 @@ Actor DataStream::compileActor() { Actor DataStream::compileActorCharacterOnly() { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("ACTORCOMPILECHARACTERONLY"); @@ -1483,7 +1483,7 @@ Actor DataStream::compileActorCharacterOnly() { Armature DataStream::compileArmature() { if (m_parent->getBlendType() != BlendType::Armature) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ARMATURE blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ARMATURE blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("ARMATURECOMPILE"); @@ -1494,10 +1494,10 @@ Armature DataStream::compileArmature() { Action DataStream::compileActionChannelsOnly(std::string_view name) { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("ACTIONCOMPILECHANNELSONLY {}"), name)); + m_parent->_writeStr(fmt::format(FMT_STRING("ACTIONCOMPILECHANNELSONLY {}"), name)); m_parent->_checkOk("unable to compile action"sv); return Action(*m_parent); @@ -1505,7 +1505,7 @@ Action DataStream::compileActionChannelsOnly(std::string_view name) { World DataStream::compileWorld() { if (m_parent->getBlendType() != BlendType::World) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an WORLD blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an WORLD blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("WORLDCOMPILE"); @@ -1516,7 +1516,7 @@ World DataStream::compileWorld() { std::vector> DataStream::getSubtypeNames() { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("GETSUBTYPENAMES"); @@ -1534,7 +1534,7 @@ std::vector> DataStream::getSubtypeNames() { std::vector> DataStream::getActionNames() { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("GETACTIONNAMES"); @@ -1552,10 +1552,10 @@ std::vector> DataStream::getActionNames() { std::vector> DataStream::getSubtypeOverlayNames(std::string_view name) { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("GETSUBTYPEOVERLAYNAMES {}"), name)); + m_parent->_writeStr(fmt::format(FMT_STRING("GETSUBTYPEOVERLAYNAMES {}"), name)); m_parent->_checkOk("unable to get subtype overlays of actor"sv); std::vector> ret; @@ -1570,7 +1570,7 @@ std::vector> DataStream::getSubtypeOverlayNa std::vector> DataStream::getAttachmentNames() { if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("GETATTACHMENTNAMES"); @@ -1591,10 +1591,10 @@ std::unordered_map DataStream::getBoneMatrices(std::strin return {}; if (m_parent->getBlendType() != BlendType::Actor) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an ACTOR blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an ACTOR blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("GETBONEMATRICES {}"), name)); + m_parent->_writeStr(fmt::format(FMT_STRING("GETBONEMATRICES {}"), name)); m_parent->_checkOk("unable to get matrices of armature"sv); std::unordered_map ret; @@ -1626,11 +1626,11 @@ bool DataStream::renderPvs(std::string_view path, const atVec3f& location) { return false; if (m_parent->getBlendType() != BlendType::Area) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an AREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an AREA blend")), m_parent->getBlendPath().getAbsolutePath()); athena::simd_floats f(location.simd); - m_parent->_writeStr(fmt::format(fmt("RENDERPVS {} {} {} {}"), path, f[0], f[1], f[2])); + m_parent->_writeStr(fmt::format(FMT_STRING("RENDERPVS {} {} {} {}"), path, f[0], f[1], f[2])); m_parent->_checkOk("unable to render PVS"sv); return true; @@ -1641,10 +1641,10 @@ bool DataStream::renderPvsLight(std::string_view path, std::string_view lightNam return false; if (m_parent->getBlendType() != BlendType::Area) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not an AREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not an AREA blend")), m_parent->getBlendPath().getAbsolutePath()); - m_parent->_writeStr(fmt::format(fmt("RENDERPVSLIGHT {} {}"), path, lightName)); + m_parent->_writeStr(fmt::format(FMT_STRING("RENDERPVSLIGHT {} {}"), path, lightName)); m_parent->_checkOk("unable to render PVS light"sv); return true; @@ -1652,7 +1652,7 @@ bool DataStream::renderPvsLight(std::string_view path, std::string_view lightNam MapArea DataStream::compileMapArea() { if (m_parent->getBlendType() != BlendType::MapArea) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a MAPAREA blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a MAPAREA blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("MAPAREACOMPILE"); @@ -1663,7 +1663,7 @@ MapArea DataStream::compileMapArea() { MapUniverse DataStream::compileMapUniverse() { if (m_parent->getBlendType() != BlendType::MapUniverse) - BlenderLog.report(logvisor::Fatal, fmt(_SYS_STR("{} is not a MAPUNIVERSE blend")), + BlenderLog.report(logvisor::Fatal, FMT_STRING(_SYS_STR("{} is not a MAPUNIVERSE blend")), m_parent->getBlendPath().getAbsolutePath()); m_parent->_writeStr("MAPUNIVERSECOMPILE"); @@ -1711,7 +1711,7 @@ void Token::shutdown() { m_conn->quitBlender(); m_conn.reset(); if (hecl::VerbosityLevel >= 1) - BlenderLog.report(logvisor::Info, fmt("Blender Shutdown Successful")); + BlenderLog.report(logvisor::Info, FMT_STRING("Blender Shutdown Successful")); } } diff --git a/hecl/lib/Blender/MeshOptimizer.cpp b/hecl/lib/Blender/MeshOptimizer.cpp index 899dececb..4ab894f1e 100644 --- a/hecl/lib/Blender/MeshOptimizer.cpp +++ b/hecl/lib/Blender/MeshOptimizer.cpp @@ -50,7 +50,7 @@ MeshOptimizer::Vertex::Vertex(Connection& conn) { uint32_t skin_count; conn._readValue(skin_count); if (skin_count > MaxSkinEntries) - Log.report(logvisor::Fatal, fmt("Skin entry overflow {}/{}"), skin_count, MaxSkinEntries); + Log.report(logvisor::Fatal, FMT_STRING("Skin entry overflow {}/{}"), skin_count, MaxSkinEntries); for (uint32_t i = 0; i < skin_count; ++i) skin_ents[i] = Mesh::SkinBind(conn); } @@ -76,7 +76,7 @@ MeshOptimizer::Edge::Edge(Connection& conn) { uint32_t face_count; conn._readValue(face_count); if (face_count > MaxLinkFaces) - Log.report(logvisor::Fatal, fmt("Face overflow {}/{}"), face_count, MaxLinkFaces); + Log.report(logvisor::Fatal, FMT_STRING("Face overflow {}/{}"), face_count, MaxLinkFaces); for (uint32_t i = 0; i < face_count; ++i) conn._readValue(link_faces[i]); conn._readValue(is_contiguous); @@ -384,10 +384,10 @@ MeshOptimizer::MeshOptimizer(Connection& conn, const std::vector& mate : materials(materials), use_luvs(use_luvs) { conn._readValue(color_count); if (color_count > MaxColorLayers) - Log.report(logvisor::Fatal, fmt("Color layer overflow {}/{}"), color_count, MaxColorLayers); + Log.report(logvisor::Fatal, FMT_STRING("Color layer overflow {}/{}"), color_count, MaxColorLayers); conn._readValue(uv_count); if (uv_count > MaxUVLayers) - Log.report(logvisor::Fatal, fmt("UV layer overflow {}/{}"), uv_count, MaxUVLayers); + Log.report(logvisor::Fatal, FMT_STRING("UV layer overflow {}/{}"), uv_count, MaxUVLayers); /* Simultaneously load topology objects and build unique mapping indices */ diff --git a/hecl/lib/CVar.cpp b/hecl/lib/CVar.cpp index 6380bacae..6105cfeef 100644 --- a/hecl/lib/CVar.cpp +++ b/hecl/lib/CVar.cpp @@ -279,7 +279,7 @@ bool CVar::fromVec2f(const atVec2f& val) { return false; athena::simd_floats f(val.simd); - m_value.assign(fmt::format(fmt("{} {}"), f[0], f[1])); + m_value.assign(fmt::format(FMT_STRING("{} {}"), f[0], f[1])); m_flags |= EFlags::Modified; return true; } @@ -289,7 +289,7 @@ bool CVar::fromVec2d(const atVec2d& val) { return false; athena::simd_doubles f(val.simd); - m_value.assign(fmt::format(fmt("{} {}"), f[0], f[1])); + m_value.assign(fmt::format(FMT_STRING("{} {}"), f[0], f[1])); m_flags |= EFlags::Modified; return true; } @@ -299,7 +299,7 @@ bool CVar::fromVec3f(const atVec3f& val) { return false; athena::simd_floats f(val.simd); - m_value.assign(fmt::format(fmt("{} {} {}"), f[0], f[1], f[2])); + m_value.assign(fmt::format(FMT_STRING("{} {} {}"), f[0], f[1], f[2])); m_flags |= EFlags::Modified; return true; } @@ -309,7 +309,7 @@ bool CVar::fromVec3d(const atVec3d& val) { return false; athena::simd_doubles f(val.simd); - m_value.assign(fmt::format(fmt("{} {} {}"), f[0], f[1], f[2])); + m_value.assign(fmt::format(FMT_STRING("{} {} {}"), f[0], f[1], f[2])); m_flags |= EFlags::Modified; return true; } @@ -319,7 +319,7 @@ bool CVar::fromVec4f(const atVec4f& val) { return false; athena::simd_floats f(val.simd); - m_value.assign(fmt::format(fmt("{} {} {} {}"), f[0], f[1], f[2], f[3])); + m_value.assign(fmt::format(FMT_STRING("{} {} {} {}"), f[0], f[1], f[2], f[3])); m_flags |= EFlags::Modified; return true; } @@ -329,7 +329,7 @@ bool CVar::fromVec4d(const atVec4d& val) { return false; athena::simd_doubles f(val.simd); - m_value.assign(fmt::format(fmt("{} {} {} {}"), f[0], f[1], f[2], f[3])); + m_value.assign(fmt::format(FMT_STRING("{} {} {} {}"), f[0], f[1], f[2], f[3])); m_flags |= EFlags::Modified; return true; } @@ -338,7 +338,7 @@ bool CVar::fromReal(double val) { if (!safeToModify(EType::Real)) return false; - m_value.assign(fmt::format(fmt("{}"), val)); + m_value.assign(fmt::format(FMT_STRING("{}"), val)); setModified(); return true; } @@ -369,7 +369,7 @@ bool CVar::fromInteger(int32_t val) { return false; // Properly format based on signedness - m_value = fmt::format(fmt("{}"), (m_type == EType::Signed ? val : static_cast(val))); + m_value = fmt::format(FMT_STRING("{}"), (m_type == EType::Signed ? val : static_cast(val))); setModified(); return true; } @@ -387,7 +387,7 @@ bool CVar::fromInteger(uint32_t val) { return false; // Properly format based on signedness - m_value = fmt::format(fmt("{}"), (m_type == EType::Unsigned ? val : static_cast(val))); + m_value = fmt::format(FMT_STRING("{}"), (m_type == EType::Unsigned ? val : static_cast(val))); setModified(); return true; } diff --git a/hecl/lib/CVarManager.cpp b/hecl/lib/CVarManager.cpp index 977f76e8a..860abcd37 100644 --- a/hecl/lib/CVarManager.cpp +++ b/hecl/lib/CVarManager.cpp @@ -205,13 +205,13 @@ CVarManager* CVarManager::instance() { return m_instance; } void CVarManager::list(Console* con, const std::vector& /*args*/) { for (const auto& cvar : m_cvars) { if (!cvar.second->isHidden()) - con->report(Console::Level::Info, fmt("{}: {}"), cvar.second->name(), cvar.second->help()); + con->report(Console::Level::Info, FMT_STRING("{}: {}"), cvar.second->name(), cvar.second->help()); } } void CVarManager::setCVar(Console* con, const std::vector& args) { if (args.size() < 2) { - con->report(Console::Level::Info, fmt("Usage setCvar ")); + con->report(Console::Level::Info, FMT_STRING("Usage setCvar ")); return; } @@ -219,7 +219,7 @@ void CVarManager::setCVar(Console* con, const std::vector& args) { athena::utility::tolower(cvName); const auto iter = m_cvars.find(cvName); if (iter == m_cvars.end()) { - con->report(Console::Level::Error, fmt("CVar '{}' does not exist"), args[0]); + con->report(Console::Level::Error, FMT_STRING("CVar '{}' does not exist"), args[0]); return; } @@ -235,14 +235,14 @@ void CVarManager::setCVar(Console* con, const std::vector& args) { return; if (!cv->fromLiteralToType(value)) - con->report(Console::Level::Warning, fmt("Unable to set cvar '{}' to value '{}'"), cv->name(), value); + con->report(Console::Level::Warning, FMT_STRING("Unable to set cvar '{}' to value '{}'"), cv->name(), value); else - con->report(Console::Level::Info, fmt("Set '{}' from '{}' to '{}'"), cv->name(), oldVal, value); + con->report(Console::Level::Info, FMT_STRING("Set '{}' from '{}' to '{}'"), cv->name(), oldVal, value); } void CVarManager::getCVar(Console* con, const std::vector& args) { if (args.empty()) { - con->report(Console::Level::Info, fmt("Usage getCVar ")); + con->report(Console::Level::Info, FMT_STRING("Usage getCVar ")); return; } @@ -250,12 +250,12 @@ void CVarManager::getCVar(Console* con, const std::vector& args) { athena::utility::tolower(cvName); const auto iter = m_cvars.find(cvName); if (iter == m_cvars.end()) { - con->report(Console::Level::Error, fmt("CVar '{}' does not exist"), args[0]); + con->report(Console::Level::Error, FMT_STRING("CVar '{}' does not exist"), args[0]); return; } const auto& cv = iter->second; - con->report(Console::Level::Info, fmt("'{}' = '{}'"), cv->name(), cv->value()); + con->report(Console::Level::Info, FMT_STRING("'{}' = '{}'"), cv->name(), cv->value()); } void CVarManager::setDeveloperMode(bool v, bool setDeserialized) { diff --git a/hecl/lib/ClientProcess.cpp b/hecl/lib/ClientProcess.cpp index 5f2dcac16..89cf13058 100644 --- a/hecl/lib/ClientProcess.cpp +++ b/hecl/lib/ClientProcess.cpp @@ -64,7 +64,7 @@ static int GetCPUCount() { void ClientProcess::BufferTransaction::run(blender::Token& btok) { athena::io::FileReader r(m_path.getAbsolutePath(), 32 * 1024, false); if (r.hasError()) { - CP_Log.report(logvisor::Fatal, fmt(_SYS_STR("unable to background-buffer '{}'")), m_path.getAbsolutePath()); + CP_Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to background-buffer '{}'")), m_path.getAbsolutePath()); return; } if (m_offset) @@ -94,7 +94,7 @@ ClientProcess::Worker::Worker(ClientProcess& proc, int idx) : m_proc(proc), m_id void ClientProcess::Worker::proc() { ClientProcess::ThreadWorker.reset(this); - std::string thrName = fmt::format(fmt("HECL Worker {}"), m_idx); + std::string thrName = fmt::format(FMT_STRING("HECL Worker {}"), m_idx); logvisor::RegisterThreadName(thrName.c_str()); std::unique_lock lk{m_proc.m_mutex}; @@ -180,24 +180,24 @@ bool ClientProcess::syncCook(const hecl::ProjectPath& path, Database::IDataSpec* if (m_progPrinter) { hecl::SystemString str; if (path.getAuxInfo().empty()) - str = fmt::format(fmt(_SYS_STR("Cooking {}")), path.getRelativePath()); + str = fmt::format(FMT_STRING(_SYS_STR("Cooking {}")), path.getRelativePath()); else - str = fmt::format(fmt(_SYS_STR("Cooking {}|{}")), path.getRelativePath(), path.getAuxInfo()); + str = fmt::format(FMT_STRING(_SYS_STR("Cooking {}|{}")), path.getRelativePath(), path.getAuxInfo()); m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx()); m_progPrinter->flush(); } else { if (path.getAuxInfo().empty()) - LogModule.report(logvisor::Info, fmt(_SYS_STR("Cooking {}")), path.getRelativePath()); + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Cooking {}")), path.getRelativePath()); else - LogModule.report(logvisor::Info, fmt(_SYS_STR("Cooking {}|{}")), path.getRelativePath(), path.getAuxInfo()); + LogModule.report(logvisor::Info, FMT_STRING(_SYS_STR("Cooking {}|{}")), path.getRelativePath(), path.getAuxInfo()); } spec->doCook(path, cooked, false, btok, [](const SystemChar*) {}); if (m_progPrinter) { hecl::SystemString str; if (path.getAuxInfo().empty()) - str = fmt::format(fmt(_SYS_STR("Cooked {}")), path.getRelativePath()); + str = fmt::format(FMT_STRING(_SYS_STR("Cooked {}")), path.getRelativePath()); else - str = fmt::format(fmt(_SYS_STR("Cooked {}|{}")), path.getRelativePath(), path.getAuxInfo()); + str = fmt::format(FMT_STRING(_SYS_STR("Cooked {}|{}")), path.getRelativePath(), path.getAuxInfo()); m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx()); m_progPrinter->flush(); } diff --git a/hecl/lib/Compilers.cpp b/hecl/lib/Compilers.cpp index 61a507a5d..b994e7f51 100644 --- a/hecl/lib/Compilers.cpp +++ b/hecl/lib/Compilers.cpp @@ -54,15 +54,15 @@ struct ShaderCompiler { const char* strings[] = {"#version 330\n", BOO_GLSL_BINDING_HEAD, text.data()}; shader.setStrings(strings, 3); if (!shader.parse(&glslang::DefaultTBuiltInResource, 110, false, messages)) { - fmt::print(fmt("{}\n"), text); - Log.report(logvisor::Fatal, fmt("unable to compile shader\n{}"), shader.getInfoLog()); + fmt::print(FMT_STRING("{}\n"), text); + Log.report(logvisor::Fatal, FMT_STRING("unable to compile shader\n{}"), shader.getInfoLog()); return {}; } glslang::TProgram prog; prog.addShader(&shader); if (!prog.link(messages)) { - Log.report(logvisor::Fatal, fmt("unable to link shader program\n{}"), prog.getInfoLog()); + Log.report(logvisor::Fatal, FMT_STRING("unable to link shader program\n{}"), prog.getInfoLog()); return {}; } @@ -89,8 +89,8 @@ struct ShaderCompiler { ComPtr blobOut; if (FAILED(D3DCompilePROC(text.data(), text.size(), "Boo HLSL Source", nullptr, nullptr, "main", D3DShaderTypes[int(S::Enum)], BOO_D3DCOMPILE_FLAG, 0, &blobOut, &errBlob))) { - fmt::print(fmt("{}\n"), text); - Log.report(logvisor::Fatal, fmt("error compiling shader: {}"), (char*)errBlob->GetBufferPointer()); + fmt::print(FMT_STRING("{}\n"), text); + Log.report(logvisor::Fatal, FMT_STRING("error compiling shader: {}"), (char*)errBlob->GetBufferPointer()); return {}; } std::pair ret(MakeStageBinaryData(blobOut->GetBufferSize()), blobOut->GetBufferSize()); @@ -152,7 +152,7 @@ struct ShaderCompiler { pid_t pid = getpid(); const char* tmpdir = getenv("TMPDIR"); - std::string libFile = fmt::format(fmt("{}boo_metal_shader{}.metallib"), tmpdir, pid); + std::string libFile = fmt::format(FMT_STRING("{}boo_metal_shader{}.metallib"), tmpdir, pid); /* Pipe source write to compiler */ pid_t compilerPid = fork(); @@ -171,7 +171,7 @@ struct ShaderCompiler { "-gline-tables-only", "-MO", #endif "-", nullptr); - fmt::print(stderr, fmt("execlp fail {}\n"), strerror(errno)); + fmt::print(stderr, FMT_STRING("execlp fail {}\n"), strerror(errno)); exit(1); } close(compilerIn[0]); @@ -187,7 +187,7 @@ struct ShaderCompiler { /* metallib doesn't like outputting to a pipe, so temp file will have to do */ execlp("xcrun", "xcrun", "-sdk", "macosx", "metallib", "-", "-o", libFile.c_str(), nullptr); - fmt::print(stderr, fmt("execlp fail {}\n"), strerror(errno)); + fmt::print(stderr, FMT_STRING("execlp fail {}\n"), strerror(errno)); exit(1); } close(compilerOut[0]); @@ -198,7 +198,7 @@ struct ShaderCompiler { while (inRem) { ssize_t writeRes = write(compilerIn[1], inPtr, inRem); if (writeRes < 0) { - fmt::print(stderr, fmt("write fail {}\n"), strerror(errno)); + fmt::print(stderr, FMT_STRING("write fail {}\n"), strerror(errno)); break; } inPtr += writeRes; @@ -211,24 +211,24 @@ struct ShaderCompiler { while (waitpid(compilerPid, &compilerStat, 0) < 0) { if (errno == EINTR) continue; - Log.report(logvisor::Fatal, fmt("waitpid fail {}"), strerror(errno)); + Log.report(logvisor::Fatal, FMT_STRING("waitpid fail {}"), strerror(errno)); return {}; } if (WEXITSTATUS(compilerStat)) { - Log.report(logvisor::Fatal, fmt("compile fail")); + Log.report(logvisor::Fatal, FMT_STRING("compile fail")); return {}; } while (waitpid(linkerPid, &linkerStat, 0) < 0) { if (errno == EINTR) continue; - Log.report(logvisor::Fatal, fmt("waitpid fail {}"), strerror(errno)); + Log.report(logvisor::Fatal, FMT_STRING("waitpid fail {}"), strerror(errno)); return {}; } if (WEXITSTATUS(linkerStat)) { - Log.report(logvisor::Fatal, fmt("link fail")); + Log.report(logvisor::Fatal, FMT_STRING("link fail")); return {}; } diff --git a/hecl/lib/Console.cpp b/hecl/lib/Console.cpp index 40d04bf99..61992b560 100644 --- a/hecl/lib/Console.cpp +++ b/hecl/lib/Console.cpp @@ -109,7 +109,7 @@ void Console::executeString(const std::string& str) { if (isInLiteral) { if ((curLiteral.back() != '\'' && curLiteral.back() != '"') || depth > 1) { - report(Level::Warning, fmt("Unterminated string literal")); + report(Level::Warning, FMT_STRING("Unterminated string literal")); return; } args.push_back(std::move(curLiteral)); @@ -123,12 +123,12 @@ void Console::executeString(const std::string& str) { if (const auto iter = m_commands.find(lowComName); iter != m_commands.end()) { const SConsoleCommand& cmd = iter->second; if (bool(cmd.m_flags & SConsoleCommand::ECommandFlags::Developer) && !com_developer->toBoolean()) { - report(Level::Error, fmt("This command can only be executed in developer mode"), commandName); + report(Level::Error, FMT_STRING("This command can only be executed in developer mode"), commandName); return; } if (bool(cmd.m_flags & SConsoleCommand::ECommandFlags::Cheat) && !com_enableCheats->toBoolean()) { - report(Level::Error, fmt("This command can only be executed with cheats enabled"), commandName); + report(Level::Error, FMT_STRING("This command can only be executed with cheats enabled"), commandName); return; } cmd.m_func(this, args); @@ -139,32 +139,32 @@ void Console::executeString(const std::string& str) { else m_cvarMgr->getCVar(this, args); } else { - report(Level::Error, fmt("'{}' is not a valid command or variable!"), commandName); + report(Level::Error, FMT_STRING("'{}' is not a valid command or variable!"), commandName); } } } void Console::help(Console* /*con*/, const std::vector& args) { if (args.empty()) { - report(Level::Info, fmt("Expected usage: help ")); + report(Level::Info, FMT_STRING("Expected usage: help ")); return; } std::string cmd = args.front(); athena::utility::tolower(cmd); auto it = m_commands.find(cmd); if (it == m_commands.end()) { - report(Level::Error, fmt("No such command '{}'"), args.front()); + report(Level::Error, FMT_STRING("No such command '{}'"), args.front()); return; } - report(Level::Info, fmt("{}: {}"), it->second.m_displayName, it->second.m_helpString); + report(Level::Info, FMT_STRING("{}: {}"), it->second.m_displayName, it->second.m_helpString); if (!it->second.m_usage.empty()) - report(Level::Info, fmt("Usage: {} {}"), it->second.m_displayName, it->second.m_usage); + report(Level::Info, FMT_STRING("Usage: {} {}"), it->second.m_displayName, it->second.m_usage); } void Console::listCommands(Console* /*con*/, const std::vector& /*args*/) { for (const auto& comPair : m_commands) - report(Level::Info, fmt("'{}': {}"), comPair.second.m_displayName, comPair.second.m_helpString); + report(Level::Info, FMT_STRING("'{}': {}"), comPair.second.m_displayName, comPair.second.m_helpString); } bool Console::commandExists(std::string_view cmd) const { @@ -180,7 +180,7 @@ void Console::vreport(Level level, fmt::string_view fmt, fmt::format_args args) for (std::string& line : lines) { m_log.emplace_back(std::move(line), level); } - fmt::print(fmt("{}\n"), tmp); + fmt::print(FMT_STRING("{}\n"), tmp); } void Console::init(boo::IWindow* window) { @@ -197,7 +197,7 @@ void Console::proc() { } if (m_state == State::Opened) { - fmt::print(fmt("\r{} "), m_commandString); + fmt::print(FMT_STRING("\r{} "), m_commandString); fflush(stdout); } else if (m_state == State::Opening) m_state = State::Opened; @@ -301,7 +301,7 @@ void Console::handleSpecialKeyDown(boo::ESpecialKey sp, boo::EModifierKey mod, b break; } case boo::ESpecialKey::Enter: { - fmt::print(fmt("\n")); + fmt::print(FMT_STRING("\n")); executeString(m_commandString); m_cursorPosition = -1; m_commandHistory.insert(m_commandHistory.begin(), m_commandString); @@ -388,7 +388,7 @@ void Console::LogVisorAdapter::report(const char* modName, logvisor::Level sever auto tmp = fmt::internal::vformat(format, args); std::vector lines = athena::utility::split(tmp, '\n'); for (const std::string& line : lines) { - auto v = fmt::format(fmt("[{}] {}"), modName, line); + auto v = fmt::format(FMT_STRING("[{}] {}"), modName, line); m_con->m_log.emplace_back(std::move(v), Console::Level(severity)); } } @@ -398,7 +398,7 @@ void Console::LogVisorAdapter::report(const char* modName, logvisor::Level sever auto tmp = fmt::internal::vformat(format, args); std::vector lines = athena::utility::split(athena::utility::wideToUtf8(tmp), '\n'); for (const std::string& line : lines) { - auto v = fmt::format(fmt("[{}] {}"), modName, line); + auto v = fmt::format(FMT_STRING("[{}] {}"), modName, line); m_con->m_log.emplace_back(std::move(v), Console::Level(severity)); } } @@ -406,7 +406,7 @@ void Console::LogVisorAdapter::report(const char* modName, logvisor::Level sever void Console::LogVisorAdapter::reportSource(const char* modName, logvisor::Level severity, const char* file, unsigned linenum, fmt::string_view format, fmt::format_args args) { auto tmp = fmt::internal::vformat(format, args); - auto v = fmt::format(fmt("[{}] {} {}:{}"), modName, tmp, file, linenum); + auto v = fmt::format(FMT_STRING("[{}] {} {}:{}"), modName, tmp, file, linenum); m_con->m_log.emplace_back(std::move(v), Console::Level(severity)); } @@ -415,7 +415,7 @@ void Console::LogVisorAdapter::reportSource(const char* modName, logvisor::Level auto tmp = fmt::internal::vformat(format, args); std::vector lines = athena::utility::split(athena::utility::wideToUtf8(tmp), '\n'); for (const std::string& line : lines) { - auto v = fmt::format(fmt("[{}] {} {}:{}"), modName, line, file, linenum); + auto v = fmt::format(FMT_STRING("[{}] {} {}:{}"), modName, line, file, linenum); m_con->m_log.emplace_back(std::move(v), Console::Level(severity)); } } @@ -424,16 +424,16 @@ void Console::dumpLog() { for (const auto& l : m_log) { switch (l.second) { case Level::Info: - fmt::print(fmt("{}\n"), l.first); + fmt::print(FMT_STRING("{}\n"), l.first); break; case Level::Warning: - fmt::print(fmt("[Warning] {}\n"), l.first); + fmt::print(FMT_STRING("[Warning] {}\n"), l.first); break; case Level::Error: - fmt::print(fmt("[ Error ] {}\n"), l.first); + fmt::print(FMT_STRING("[ Error ] {}\n"), l.first); break; case Level::Fatal: - fmt::print(fmt("[ Fatal ] {}\n"), l.first); + fmt::print(FMT_STRING("[ Fatal ] {}\n"), l.first); break; } } diff --git a/hecl/lib/HumanizeNumber.cpp b/hecl/lib/HumanizeNumber.cpp index 7a3b75905..3764cedcc 100644 --- a/hecl/lib/HumanizeNumber.cpp +++ b/hecl/lib/HumanizeNumber.cpp @@ -48,7 +48,7 @@ std::string HumanizeNumber(int64_t quotient, size_t len, const char* suffix, int if (suffix == nullptr) suffix = ""; if ((flags & HNFlags::Divisor1000) != HNFlags::None && (flags & HNFlags::IECPrefixes) != HNFlags::None) - Log.report(logvisor::Fatal, fmt("invalid flags combo")); + Log.report(logvisor::Fatal, FMT_STRING("invalid flags combo")); /* setup parameters */ remainder = 0; @@ -109,7 +109,7 @@ std::string HumanizeNumber(int64_t quotient, size_t len, const char* suffix, int /* Check if enough room for `x y' + suffix */ if (len < baselen) - Log.report(logvisor::Fatal, fmt("buffer size {} insufficient for minimum size {}"), len, baselen); + Log.report(logvisor::Fatal, FMT_STRING("buffer size {} insufficient for minimum size {}"), len, baselen); len += 1; if ((scale & int(HNScale::AutoScale)) != 0) { @@ -142,9 +142,9 @@ std::string HumanizeNumber(int64_t quotient, size_t len, const char* suffix, int (flags & HNFlags::Decimal) != HNFlags::None) { s1 = (int)quotient + ((remainder * 10 + divisor / 2) / divisor / 10); s2 = ((remainder * 10 + divisor / 2) / divisor) % 10; - return fmt::format(fmt("{}{}{}{}{}{}"), sign * s1, localeconv()->decimal_point, s2, sep, SCALE2PREFIX(i), suffix); + return fmt::format(FMT_STRING("{}{}{}{}{}{}"), sign * s1, localeconv()->decimal_point, s2, sep, SCALE2PREFIX(i), suffix); } else - return fmt::format(fmt("{}{}{}{}"), sign * (quotient + (remainder + divisor / 2) / divisor), sep, + return fmt::format(FMT_STRING("{}{}{}{}"), sign * (quotient + (remainder + divisor / 2) / divisor), sep, SCALE2PREFIX(i), suffix); } diff --git a/hecl/lib/MultiProgressPrinter.cpp b/hecl/lib/MultiProgressPrinter.cpp index fadcf7fa6..211e37de1 100644 --- a/hecl/lib/MultiProgressPrinter.cpp +++ b/hecl/lib/MultiProgressPrinter.cpp @@ -38,20 +38,20 @@ void MultiProgressPrinter::ThreadStat::print(const TermInfo& tinfo) const { if (submessageLen) { if (messageLen > half - submessageLen - 1) - fmt::print(fmt(_SYS_STR(" {:.{}}... {} ")), m_message, half - submessageLen - 4, m_submessage); + fmt::print(FMT_STRING(_SYS_STR(" {:.{}}... {} ")), m_message, half - submessageLen - 4, m_submessage); else { - fmt::print(fmt(_SYS_STR(" {}")), m_message); + fmt::print(FMT_STRING(_SYS_STR(" {}")), m_message); for (int i = half - messageLen - submessageLen - 1; i >= 0; --i) - fmt::print(fmt(_SYS_STR(" "))); - fmt::print(fmt(_SYS_STR("{} ")), m_submessage); + fmt::print(FMT_STRING(_SYS_STR(" "))); + fmt::print(FMT_STRING(_SYS_STR("{} ")), m_submessage); } } else { if (messageLen > half) - fmt::print(fmt(_SYS_STR(" {:.{}}... ")), m_message, half - 3); + fmt::print(FMT_STRING(_SYS_STR(" {:.{}}... ")), m_message, half - 3); else { - fmt::print(fmt(_SYS_STR(" {}")), m_message); + fmt::print(FMT_STRING(_SYS_STR(" {}")), m_message); for (int i = half - messageLen; i >= 0; --i) - fmt::print(fmt(_SYS_STR(" "))); + fmt::print(FMT_STRING(_SYS_STR(" "))); } } @@ -62,22 +62,22 @@ void MultiProgressPrinter::ThreadStat::print(const TermInfo& tinfo) const { int rem = nblocks - filled; if (tinfo.xtermColor) { - fmt::print(fmt(_SYS_STR("" BOLD "{:3d}% [")), iFactor); + fmt::print(FMT_STRING(_SYS_STR("" BOLD "{:3d}% [")), iFactor); for (int b = 0; b < filled; ++b) - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]" NORMAL ""))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]" NORMAL ""))); } else { #if _WIN32 SetConsoleTextAttribute(tinfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); #endif - fmt::print(fmt(_SYS_STR("{:3d}% [")), iFactor); + fmt::print(FMT_STRING(_SYS_STR("{:3d}% [")), iFactor); for (int b = 0; b < filled; ++b) - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]"))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]"))); #if _WIN32 SetConsoleTextAttribute(tinfo.console, FOREGROUND_WHITE); #endif @@ -100,24 +100,24 @@ void MultiProgressPrinter::DrawIndeterminateBar() { int rem = blocks - pre - 1; if (m_termInfo.xtermColor) { - fmt::print(fmt(_SYS_STR("" BOLD " ["))); + fmt::print(FMT_STRING(_SYS_STR("" BOLD " ["))); for (int b = 0; b < pre; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]" NORMAL ""))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]" NORMAL ""))); } else { #if _WIN32 SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); #endif - fmt::print(fmt(_SYS_STR(" ["))); + fmt::print(FMT_STRING(_SYS_STR(" ["))); for (int b = 0; b < pre; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]"))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]"))); #if _WIN32 SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE); #endif @@ -127,7 +127,7 @@ void MultiProgressPrinter::DrawIndeterminateBar() { void MultiProgressPrinter::MoveCursorUp(int n) { if (n) { if (m_termInfo.xtermColor) { - fmt::print(fmt(_SYS_STR("" PREV_LINE "")), n); + fmt::print(FMT_STRING(_SYS_STR("" PREV_LINE "")), n); } #if _WIN32 else { @@ -139,7 +139,7 @@ void MultiProgressPrinter::MoveCursorUp(int n) { } #endif } else { - fmt::print(fmt(_SYS_STR("\r"))); + fmt::print(FMT_STRING(_SYS_STR("\r"))); } } @@ -157,7 +157,7 @@ void MultiProgressPrinter::DoPrint() { SetConsoleCursorInfo(m_termInfo.console, &cursorInfo); #endif if (m_termInfo.xtermColor) - fmt::print(fmt(_SYS_STR("" HIDE_CURSOR ""))); + fmt::print(FMT_STRING(_SYS_STR("" HIDE_CURSOR ""))); if (m_dirty) { m_termInfo.width = (hecl::GuiMode ? 120 : std::max(80, hecl::ConsoleWidth(&m_termInfo.truncate))); @@ -168,7 +168,7 @@ void MultiProgressPrinter::DoPrint() { for (const ThreadStat& stat : m_threadStats) { if (stat.m_active) { stat.print(m_termInfo); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); ++m_curThreadLines; } } @@ -179,7 +179,7 @@ void MultiProgressPrinter::DoPrint() { #endif ) { DrawIndeterminateBar(); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); ++m_curProgLines; } else if (m_mainFactor >= 0.f) { float factor = std::max(0.0f, std::min(1.0f, m_mainFactor)); @@ -191,34 +191,34 @@ void MultiProgressPrinter::DoPrint() { int rem = blocks - filled; if (m_termInfo.xtermColor) { - fmt::print(fmt(_SYS_STR("" BOLD " {:3d}% [")), iFactor); + fmt::print(FMT_STRING(_SYS_STR("" BOLD " {:3d}% [")), iFactor); for (int b = 0; b < filled; ++b) - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]" NORMAL ""))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]" NORMAL ""))); } else { #if _WIN32 SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); #endif - fmt::print(fmt(_SYS_STR(" {:3d}% [")), iFactor); + fmt::print(FMT_STRING(_SYS_STR(" {:3d}% [")), iFactor); for (int b = 0; b < filled; ++b) - fmt::print(fmt(_SYS_STR("#"))); + fmt::print(FMT_STRING(_SYS_STR("#"))); for (int b = 0; b < rem; ++b) - fmt::print(fmt(_SYS_STR("-"))); - fmt::print(fmt(_SYS_STR("]"))); + fmt::print(FMT_STRING(_SYS_STR("-"))); + fmt::print(FMT_STRING(_SYS_STR("]"))); #if _WIN32 SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE); #endif } - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); ++m_curProgLines; } } else if (m_latestThread != -1) { const ThreadStat& stat = m_threadStats[m_latestThread]; stat.print(m_termInfo); - fmt::print(fmt(_SYS_STR("\r"))); + fmt::print(FMT_STRING(_SYS_STR("\r"))); } m_dirty = false; } else if (m_mainIndeterminate @@ -230,12 +230,12 @@ void MultiProgressPrinter::DoPrint() { MoveCursorUp(m_curProgLines); m_curProgLines = 0; DrawIndeterminateBar(); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); ++m_curProgLines; } if (m_termInfo.xtermColor) - fmt::print(fmt(_SYS_STR("" SHOW_CURSOR ""))); + fmt::print(FMT_STRING(_SYS_STR("" SHOW_CURSOR ""))); fflush(stdout); #if _WIN32 @@ -354,7 +354,7 @@ void MultiProgressPrinter::startNewLine() const { m_curThreadLines = 0; m_mainFactor = -1.f; auto logLk = logvisor::LockLog(); - fmt::print(fmt(_SYS_STR("\n"))); + fmt::print(FMT_STRING(_SYS_STR("\n"))); } void MultiProgressPrinter::flush() const { diff --git a/hecl/lib/Project.cpp b/hecl/lib/Project.cpp index 0fd76e060..99625fbf9 100644 --- a/hecl/lib/Project.cpp +++ b/hecl/lib/Project.cpp @@ -94,7 +94,7 @@ void Project::ConfigFile::addLine(std::string_view line) { void Project::ConfigFile::removeLine(std::string_view refLine) { if (!m_lockedFile) { - LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, fmt("Project::ConfigFile::lockAndRead not yet called")); + LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, FMT_STRING("Project::ConfigFile::lockAndRead not yet called")); return; } @@ -109,7 +109,7 @@ void Project::ConfigFile::removeLine(std::string_view refLine) { bool Project::ConfigFile::checkForLine(std::string_view refLine) const { if (!m_lockedFile) { - LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, fmt("Project::ConfigFile::lockAndRead not yet called")); + LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, FMT_STRING("Project::ConfigFile::lockAndRead not yet called")); return false; } @@ -118,7 +118,7 @@ bool Project::ConfigFile::checkForLine(std::string_view refLine) const { void Project::ConfigFile::unlockAndDiscard() { if (m_lockedFile == nullptr) { - LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, fmt("Project::ConfigFile::lockAndRead not yet called")); + LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, FMT_STRING("Project::ConfigFile::lockAndRead not yet called")); return; } @@ -128,7 +128,7 @@ void Project::ConfigFile::unlockAndDiscard() { bool Project::ConfigFile::unlockAndCommit() { if (!m_lockedFile) { - LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, fmt("Project::ConfigFile::lockAndRead not yet called")); + LogModule.reportSource(logvisor::Fatal, __FILE__, __LINE__, FMT_STRING("Project::ConfigFile::lockAndRead not yet called")); return false; } @@ -181,12 +181,12 @@ Project::Project(const ProjectRootPath& rootPath) /* Stat for existing project directory (must already exist) */ Sstat myStat; if (hecl::Stat(m_rootPath.getAbsolutePath().data(), &myStat)) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("unable to stat {}")), m_rootPath.getAbsolutePath()); + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("unable to stat {}")), m_rootPath.getAbsolutePath()); return; } if (!S_ISDIR(myStat.st_mode)) { - LogModule.report(logvisor::Error, fmt(_SYS_STR("provided path must be a directory; '{}' isn't")), + LogModule.report(logvisor::Error, FMT_STRING(_SYS_STR("provided path must be a directory; '{}' isn't")), m_rootPath.getAbsolutePath()); return; } @@ -212,7 +212,7 @@ Project::Project(const ProjectRootPath& rootPath) bf.reset(); if (beacon.magic != HECLfcc || SBig(beacon.version) != DATA_VERSION) { - LogModule.report(logvisor::Fatal, fmt("incompatible project version")); + LogModule.report(logvisor::Fatal, FMT_STRING("incompatible project version")); return; } @@ -225,7 +225,7 @@ const ProjectPath& Project::getProjectCookedPath(const DataSpecEntry& spec) cons for (const ProjectDataSpec& sp : m_compiledSpecs) if (&sp.spec == &spec) return sp.cookedPath; - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("Unable to find spec '{}'")), spec.m_name); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to find spec '{}'")), spec.m_name); return m_cookedRoot; } @@ -469,7 +469,7 @@ bool Project::packagePath(const ProjectPath& path, const hecl::MultiProgressPrin } if (!specEntry) - LogModule.report(logvisor::Fatal, fmt("No matching DataSpec")); + LogModule.report(logvisor::Fatal, FMT_STRING("No matching DataSpec")); if (!m_lastPackageSpec || m_lastPackageSpec->getDataSpecEntry() != specEntry) m_lastPackageSpec = specEntry->m_factory(*this, DataSpecTool::Package); diff --git a/hecl/lib/ProjectPath.cpp b/hecl/lib/ProjectPath.cpp index b17334cf4..08f3e656f 100644 --- a/hecl/lib/ProjectPath.cpp +++ b/hecl/lib/ProjectPath.cpp @@ -21,7 +21,7 @@ static SystemString CanonRelPath(SystemStringView path) { else if (match == _SYS_STR("..")) { if (comps.empty()) { /* Unable to resolve outside project */ - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("Unable to resolve outside project root in {}")), path); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("Unable to resolve outside project root in {}")), path); return _SYS_STR("."); } comps.pop_back(); @@ -184,7 +184,7 @@ Time ProjectPath::getModtime() const { return Time(latestTime); } } - LogModule.report(logvisor::Fatal, fmt(_SYS_STR("invalid path type for computing modtime in '{}'")), m_absPath); + LogModule.report(logvisor::Fatal, FMT_STRING(_SYS_STR("invalid path type for computing modtime in '{}'")), m_absPath); return Time(); } diff --git a/hecl/lib/Runtime/FileStoreManager.cpp b/hecl/lib/Runtime/FileStoreManager.cpp index 78a3971c2..dd4048412 100644 --- a/hecl/lib/Runtime/FileStoreManager.cpp +++ b/hecl/lib/Runtime/FileStoreManager.cpp @@ -20,7 +20,7 @@ FileStoreManager::FileStoreManager(SystemStringView domain) : m_domain(domain) { #if !WINDOWS_STORE WCHAR home[MAX_PATH]; if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, home))) - Log.report(logvisor::Fatal, fmt(_SYS_STR("unable to locate profile for file store"))); + Log.report(logvisor::Fatal, FMT_STRING(_SYS_STR("unable to locate profile for file store"))); SystemString path(home); #else @@ -40,22 +40,22 @@ FileStoreManager::FileStoreManager(SystemStringView domain) : m_domain(domain) { std::string path; if (xdg_data_home) { if (xdg_data_home[0] != '/') - Log.report(logvisor::Fatal, fmt("invalid $XDG_DATA_HOME for file store (must be absolute)")); + Log.report(logvisor::Fatal, FMT_STRING("invalid $XDG_DATA_HOME for file store (must be absolute)")); path = xdg_data_home; } else { const char* home = getenv("HOME"); if (!home) - Log.report(logvisor::Fatal, fmt("unable to locate $HOME for file store")); + Log.report(logvisor::Fatal, FMT_STRING("unable to locate $HOME for file store")); path = home; path += "/.local/share"; } path += "/hecl"; if (mkdir(path.c_str(), 0755) && errno != EEXIST) - Log.report(logvisor::Fatal, fmt("unable to mkdir at {}"), path); + Log.report(logvisor::Fatal, FMT_STRING("unable to mkdir at {}"), path); path += '/'; path += domain.data(); if (mkdir(path.c_str(), 0755) && errno != EEXIST) - Log.report(logvisor::Fatal, fmt("unable to mkdir at {}"), path); + Log.report(logvisor::Fatal, FMT_STRING("unable to mkdir at {}"), path); m_storeRoot = path; #endif } diff --git a/hecl/lib/Runtime/HMDL_RT.cpp b/hecl/lib/Runtime/HMDL_RT.cpp index d70c72135..6e3a4c469 100644 --- a/hecl/lib/Runtime/HMDL_RT.cpp +++ b/hecl/lib/Runtime/HMDL_RT.cpp @@ -15,7 +15,7 @@ HMDLData::HMDLData(boo::IGraphicsDataFactory::Context& ctx, const void* metaData meta.read(r); } if (meta.magic != 'TACO') - HMDL_Log.report(logvisor::Fatal, fmt("invalid HMDL magic")); + HMDL_Log.report(logvisor::Fatal, FMT_STRING("invalid HMDL magic")); m_vbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, vbo, meta.vertStride, meta.vertCount); m_ibo = ctx.newStaticBuffer(boo::BufferUse::Index, ibo, 4, meta.indexCount); diff --git a/hecl/lib/WideStringConvert.cpp b/hecl/lib/WideStringConvert.cpp index 987b65a09..ee932b583 100644 --- a/hecl/lib/WideStringConvert.cpp +++ b/hecl/lib/WideStringConvert.cpp @@ -11,7 +11,7 @@ std::string WideToUTF8(std::wstring_view src) { utf8proc_uint8_t mb[4]; utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb); if (c < 0) { - Log.report(logvisor::Warning, fmt("invalid UTF-8 character while encoding")); + Log.report(logvisor::Warning, FMT_STRING("invalid UTF-8 character while encoding")); return retval; } retval.append(reinterpret_cast(mb), c); @@ -26,7 +26,7 @@ std::string Char16ToUTF8(std::u16string_view src) { utf8proc_uint8_t mb[4]; utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb); if (c < 0) { - Log.report(logvisor::Warning, fmt("invalid UTF-8 character while encoding")); + Log.report(logvisor::Warning, FMT_STRING("invalid UTF-8 character while encoding")); return retval; } retval.append(reinterpret_cast(mb), c); @@ -42,7 +42,7 @@ std::wstring UTF8ToWide(std::string_view src) { utf8proc_int32_t wc; utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc); if (len < 0) { - Log.report(logvisor::Warning, fmt("invalid UTF-8 character while decoding")); + Log.report(logvisor::Warning, FMT_STRING("invalid UTF-8 character while decoding")); return retval; } buf += len; @@ -59,7 +59,7 @@ std::u16string UTF8ToChar16(std::string_view src) { utf8proc_int32_t wc; utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc); if (len < 0) { - Log.report(logvisor::Warning, fmt("invalid UTF-8 character while decoding")); + Log.report(logvisor::Warning, FMT_STRING("invalid UTF-8 character while decoding")); return retval; } buf += len; diff --git a/hecl/lib/hecl.cpp b/hecl/lib/hecl.cpp index 4a7927994..20b2cf066 100644 --- a/hecl/lib/hecl.cpp +++ b/hecl/lib/hecl.cpp @@ -107,7 +107,7 @@ SystemString GetcwdStr() { } if (errno != ERANGE) { // It's not ERANGE, so we don't know how to handle it - LogModule.report(logvisor::Fatal, fmt("Cannot determine the current path.")); + LogModule.report(logvisor::Fatal, FMT_STRING("Cannot determine the current path.")); // Of course you may choose a different error reporting method } // Ok, the stack buffer isn't long enough; fallback to heap allocation @@ -121,11 +121,11 @@ SystemString GetcwdStr() { } if (errno != ERANGE) { // It's not ERANGE, so we don't know how to handle it - LogModule.report(logvisor::Fatal, fmt("Cannot determine the current path.")); + LogModule.report(logvisor::Fatal, FMT_STRING("Cannot determine the current path.")); // Of course you may choose a different error reporting method } } - LogModule.report(logvisor::Fatal, fmt("Cannot determine the current path; the path is apparently unreasonably long")); + LogModule.report(logvisor::Fatal, FMT_STRING("Cannot determine the current path; the path is apparently unreasonably long")); return SystemString(); } @@ -141,7 +141,7 @@ bool ResourceLock::InProgress(const ProjectPath& path) { bool ResourceLock::SetThreadRes(const ProjectPath& path) { std::unique_lock lk{PathsMutex}; if (PathsInProgress.find(std::this_thread::get_id()) != PathsInProgress.cend()) { - LogModule.report(logvisor::Fatal, fmt("multiple resource locks on thread")); + LogModule.report(logvisor::Fatal, FMT_STRING("multiple resource locks on thread")); } const bool isInProgress = std::any_of(PathsInProgress.cbegin(), PathsInProgress.cend(), @@ -713,14 +713,14 @@ int RunProcess(const SystemChar* path, const SystemChar* const args[]) { HANDLE consoleOutReadTmp = INVALID_HANDLE_VALUE; HANDLE consoleOutWrite = INVALID_HANDLE_VALUE; if (!CreatePipe(&consoleOutReadTmp, &consoleOutWrite, &sattrs, 0)) { - LogModule.report(logvisor::Fatal, fmt("Error with CreatePipe")); + LogModule.report(logvisor::Fatal, FMT_STRING("Error with CreatePipe")); return -1; } HANDLE consoleErrWrite = INVALID_HANDLE_VALUE; if (!DuplicateHandle(GetCurrentProcess(), consoleOutWrite, GetCurrentProcess(), &consoleErrWrite, 0, TRUE, DUPLICATE_SAME_ACCESS)) { - LogModule.report(logvisor::Fatal, fmt("Error with DuplicateHandle")); + LogModule.report(logvisor::Fatal, FMT_STRING("Error with DuplicateHandle")); CloseHandle(consoleOutReadTmp); CloseHandle(consoleOutWrite); return -1; @@ -731,7 +731,7 @@ int RunProcess(const SystemChar* path, const SystemChar* const args[]) { &consoleOutRead, // Address of new handle. 0, FALSE, // Make it uninheritable. DUPLICATE_SAME_ACCESS)) { - LogModule.report(logvisor::Fatal, fmt("Error with DuplicateHandle")); + LogModule.report(logvisor::Fatal, FMT_STRING("Error with DuplicateHandle")); CloseHandle(consoleOutReadTmp); CloseHandle(consoleOutWrite); CloseHandle(consoleErrWrite); @@ -762,7 +762,7 @@ int RunProcess(const SystemChar* path, const SystemChar* const args[]) { LPWSTR messageBuffer = nullptr; FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&messageBuffer, 0, nullptr); - LogModule.report(logvisor::Error, fmt(L"unable to launch process from {}: {}"), path, messageBuffer); + LogModule.report(logvisor::Error, FMT_STRING(L"unable to launch process from {}: {}"), path, messageBuffer); LocalFree(messageBuffer); CloseHandle(nulHandle); @@ -788,13 +788,13 @@ int RunProcess(const SystemChar* path, const SystemChar* const args[]) { if (err == ERROR_BROKEN_PIPE) break; // pipe done - normal exit path. else - LogModule.report(logvisor::Error, fmt("Error with ReadFile: {:08X}"), err); // Something bad happened. + LogModule.report(logvisor::Error, FMT_STRING("Error with ReadFile: {:08X}"), err); // Something bad happened. } // Display the character read on the screen. auto lk = logvisor::LockLog(); if (!WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), lpBuffer, nBytesRead, &nCharsWritten, nullptr)) { - // LogModule.report(logvisor::Error, fmt("Error with WriteConsole: {:08X}"), GetLastError()); + // LogModule.report(logvisor::Error, FMT_STRING("Error with WriteConsole: {:08X}"), GetLastError()); } } diff --git a/hecl/shaderc/main.cpp b/hecl/shaderc/main.cpp index 28e476757..e8d44eac6 100644 --- a/hecl/shaderc/main.cpp +++ b/hecl/shaderc/main.cpp @@ -43,13 +43,13 @@ int main(int argc, const hecl::SystemChar** argv) #if _WIN32 if (!FindBestD3DCompile()) { - Log.report(logvisor::Info, fmt("Unable to find D3DCompiler dll")); + Log.report(logvisor::Info, FMT_STRING("Unable to find D3DCompiler dll")); return 1; } #endif if (argc == 1) { - Log.report(logvisor::Info, fmt("Usage: shaderc -o [-D definevar=defineval]... ...")); + Log.report(logvisor::Info, FMT_STRING("Usage: shaderc -o [-D definevar=defineval]... ...")); return 0; } @@ -64,7 +64,7 @@ int main(int argc, const hecl::SystemChar** argv) ++i; outPath = argv[i]; } else { - Log.report(logvisor::Error, fmt("Invalid -o argument")); + Log.report(logvisor::Error, FMT_STRING("Invalid -o argument")); return 1; } } else if (argv[i][1] == 'D') { @@ -75,7 +75,7 @@ int main(int argc, const hecl::SystemChar** argv) ++i; define = argv[i]; } else { - Log.report(logvisor::Error, fmt("Invalid -D argument")); + Log.report(logvisor::Error, FMT_STRING("Invalid -D argument")); return 1; } hecl::SystemUTF8Conv conv(define); @@ -85,7 +85,7 @@ int main(int argc, const hecl::SystemChar** argv) else c.addDefine(defineU8, ""); } else { - Log.report(logvisor::Error, fmt(_SYS_STR("Unrecognized flag option '{:c}'")), argv[i][1]); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Unrecognized flag option '{:c}'")), argv[i][1]); return 1; } } else { @@ -94,7 +94,7 @@ int main(int argc, const hecl::SystemChar** argv) } if (outPath.empty()) { - Log.report(logvisor::Error, fmt("-o option is required")); + Log.report(logvisor::Error, FMT_STRING("-o option is required")); return 1; } @@ -106,7 +106,7 @@ int main(int argc, const hecl::SystemChar** argv) baseName = outPath; if (!glslang::InitializeProcess()) { - Log.report(logvisor::Error, fmt("Unable to initialize glslang")); + Log.report(logvisor::Error, FMT_STRING("Unable to initialize glslang")); return 1; } @@ -119,7 +119,7 @@ int main(int argc, const hecl::SystemChar** argv) hecl::SystemString headerPath = outPath + _SYS_STR(".hpp"); athena::io::FileWriter w(headerPath); if (w.hasError()) { - Log.report(logvisor::Error, fmt(_SYS_STR("Error opening '{}' for writing")), headerPath); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Error opening '{}' for writing")), headerPath); return 1; } std::string header = ret.first.str(); @@ -130,7 +130,7 @@ int main(int argc, const hecl::SystemChar** argv) hecl::SystemString impPath = outPath + _SYS_STR(".cpp"); athena::io::FileWriter w(impPath); if (w.hasError()) { - Log.report(logvisor::Error, fmt(_SYS_STR("Error opening '{}' for writing")), impPath); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Error opening '{}' for writing")), impPath); return 1; } std::string source = ret.second.str(); diff --git a/hecl/shaderc/shaderc.cpp b/hecl/shaderc/shaderc.cpp index dd38c9371..74b0b58ad 100644 --- a/hecl/shaderc/shaderc.cpp +++ b/hecl/shaderc/shaderc.cpp @@ -29,6 +29,7 @@ static const char* StageNames[] = { }; const std::string* Compiler::getFileContents(SystemStringView path) { + // TODO: Heterogeneous lookup when C++20 available auto search = m_fileContents.find(path.data()); if (search == m_fileContents.end()) { athena::io::FileReader r(path); @@ -48,7 +49,7 @@ void Compiler::addInputFile(SystemStringView file) { void Compiler::addDefine(std::string_view var, std::string_view val) { m_defines[var.data()] = val; } -constexpr auto ShaderHeaderTemplate = fmt( +constexpr auto ShaderHeaderTemplate = FMT_STRING( "class Shader_{} : public hecl::GeneralShader\n" "{{\n" "public:\n" @@ -61,7 +62,7 @@ constexpr auto ShaderHeaderTemplate = fmt( " static constexpr uint64_t StageHash();\n" "}};\n\n"); -constexpr auto StageObjectHeaderTemplate = fmt( +constexpr auto StageObjectHeaderTemplate = FMT_STRING( "template\n" "class StageObject_{} : public hecl::StageBinary\n" "{{\n" @@ -72,7 +73,7 @@ constexpr auto StageObjectHeaderTemplate = fmt( "}};\n" "STAGEOBJECT_PROTOTYPE_DECLARATIONS(StageObject_{})\n\n"); -constexpr auto StageObjectImplTemplate = fmt( +constexpr auto StageObjectImplTemplate = FMT_STRING( "template<>\n" "const hecl::StageBinary\n" "StageObject_{}::Prototype = \n" @@ -95,11 +96,11 @@ struct CompileStageAction { if (data.second == 0) return false; - fmt::print(out, fmt("static const uint8_t {}_{}_{}_data[] = {{\n"), name, P::Name, S::Name); + fmt::print(out, FMT_STRING("static const uint8_t {}_{}_{}_data[] = {{\n"), name, P::Name, S::Name); for (size_t i = 0; i < data.second;) { out << " "; for (int j = 0; j < 10 && i < data.second; ++i, ++j) - fmt::print(out, fmt("0x{:02X}, "), data.first.get()[i]); + fmt::print(out, FMT_STRING("0x{:02X}, "), data.first.get()[i]); out << "\n"; } out << "};\n\n"; @@ -127,7 +128,7 @@ bool Compiler::StageAction(StageType type, const std::string& name, const std::s default: break; } - Log.report(logvisor::Error, fmt("Unknown stage type")); + Log.report(logvisor::Error, FMT_STRING("Unknown stage type")); return false; } @@ -172,7 +173,7 @@ bool Compiler::StageAction(const std::string& platforms, StageType type, const s return false; #endif } else { - Log.report(logvisor::Error, fmt("Unknown platform '{}'"), plat); + Log.report(logvisor::Error, FMT_STRING("Unknown platform '{}'"), plat); return false; } begin = match.suffix().first; @@ -208,13 +209,13 @@ static const std::regex regEvaluation(R"(#\s*evaluation\s+(.*))", RegexFlags); bool Compiler::includeFile(SystemStringView file, std::string& out, int depth) { if (depth > 32) { - Log.report(logvisor::Error, fmt(_SYS_STR("Too many levels of includes (>32) at '{}'")), file); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Too many levels of includes (>32) at '{}'")), file); return false; } const std::string* data = getFileContents(file); if (!data) { - Log.report(logvisor::Error, fmt(_SYS_STR("Unable to access '{}'")), file); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Unable to access '{}'")), file); return false; } const std::string& sdata = *data; @@ -240,7 +241,7 @@ bool Compiler::includeFile(SystemStringView file, std::string& out, int depth) { if (std::regex_search(begin, nextBegin, subMatch, regInclude)) { std::string path = subMatch[1].str(); if (path.empty()) { - Log.report(logvisor::Error, fmt(_SYS_STR("Empty path provided to include in '{}'")), file); + Log.report(logvisor::Error, FMT_STRING(_SYS_STR("Empty path provided to include in '{}'")), file); return false; } @@ -319,7 +320,7 @@ inline bool StrToBlendFactor(std::string str, boo::BlendFactor& fac) { else if (str == "subtract") fac = boo::BlendFactor::Subtract; else { - Log.report(logvisor::Error, fmt("Unrecognized blend mode '{}'"), str); + Log.report(logvisor::Error, FMT_STRING("Unrecognized blend mode '{}'"), str); return false; } return true; @@ -346,7 +347,7 @@ inline bool StrToPrimitive(std::string str, boo::Primitive& prim) { else if (str == "patches") prim = boo::Primitive::Patches; else { - Log.report(logvisor::Error, fmt("Unrecognized primitive '{}'"), str); + Log.report(logvisor::Error, FMT_STRING("Unrecognized primitive '{}'"), str); return false; } return true; @@ -381,7 +382,7 @@ inline bool StrToZTest(std::string str, boo::ZTest& ztest) { else if (str == "equal") ztest = boo::ZTest::Equal; else { - Log.report(logvisor::Error, fmt("Unrecognized ztest '{}'"), str); + Log.report(logvisor::Error, FMT_STRING("Unrecognized ztest '{}'"), str); return false; } return true; @@ -408,7 +409,7 @@ inline bool StrToCullMode(std::string str, boo::CullMode& cull) { else if (str == "frontface") cull = boo::CullMode::Frontface; else { - Log.report(logvisor::Error, fmt("Unrecognized cull mode '{}'"), str); + Log.report(logvisor::Error, FMT_STRING("Unrecognized cull mode '{}'"), str); return false; } return true; @@ -425,7 +426,7 @@ inline bool StrToBool(std::string str, bool& b) { else if (str == "false") b = false; else { - Log.report(logvisor::Error, fmt("Unrecognized bool '{}'"), str); + Log.report(logvisor::Error, FMT_STRING("Unrecognized bool '{}'"), str); return false; } return true; @@ -469,7 +470,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, return true; if (shaderName.empty()) { - Log.report(logvisor::Error, fmt("`#shader ` must be issued before stages")); + Log.report(logvisor::Error, FMT_STRING("`#shader ` must be issued before stages")); return false; } std::string stage(stageBegin, stageEnd); @@ -533,48 +534,48 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, shaderBase.clear(); } - fmt::print(out.second, fmt("static const boo::VertexElementDescriptor {}_vtxfmtelems[] = {{\n"), shaderName); + fmt::print(out.second, FMT_STRING("static const boo::VertexElementDescriptor {}_vtxfmtelems[] = {{\n"), shaderName); for (const auto& attr : shaderAttributes) { switch (attr.first & boo::VertexSemantic::SemanticMask) { case boo::VertexSemantic::Position3: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Position3{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Position3{}, {}}},\n")); break; case boo::VertexSemantic::Position4: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Position4{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Position4{}, {}}},\n")); break; case boo::VertexSemantic::Normal3: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Normal3{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Normal3{}, {}}},\n")); break; case boo::VertexSemantic::Normal4: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Normal4{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Normal4{}, {}}},\n")); break; case boo::VertexSemantic::Color: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Color{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Color{}, {}}},\n")); break; case boo::VertexSemantic::ColorUNorm: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::ColorUNorm{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::ColorUNorm{}, {}}},\n")); break; case boo::VertexSemantic::UV2: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::UV2{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::UV2{}, {}}},\n")); break; case boo::VertexSemantic::UV4: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::UV4{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::UV4{}, {}}},\n")); break; case boo::VertexSemantic::Weight: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::Weight{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::Weight{}, {}}},\n")); break; case boo::VertexSemantic::ModelView: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::ModelView{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::ModelView{}, {}}},\n")); break; default: - SemanticOut(out.second, attr, fmt("{{boo::VertexSemantic::None{}, {}}},\n")); + SemanticOut(out.second, attr, FMT_STRING("{{boo::VertexSemantic::None{}, {}}},\n")); break; } } out.second << "};\n"; - fmt::print(out.second, fmt("const boo::VertexFormatInfo Shader_{}::VtxFmt = {{ {}_vtxfmtelems }};\n\n"), + fmt::print(out.second, FMT_STRING("const boo::VertexFormatInfo Shader_{}::VtxFmt = {{ {}_vtxfmtelems }};\n\n"), shaderName, shaderName); - fmt::print(out.second, fmt("const boo::AdditionalPipelineInfo Shader_{}::PipelineInfo = {{\n"), shaderName); + fmt::print(out.second, FMT_STRING("const boo::AdditionalPipelineInfo Shader_{}::PipelineInfo = {{\n"), shaderName); out.second << BlendFactorToStr(shaderInfo.srcFac); out.second << ", "; out.second << BlendFactorToStr(shaderInfo.dstFac); @@ -591,7 +592,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, out.second << ", "; out.second << CullModeToStr(shaderInfo.culling); out.second << ", "; - fmt::print(out.second, fmt("{}, "), shaderInfo.patchSize); + fmt::print(out.second, FMT_STRING("{}, "), shaderInfo.patchSize); out.second << BoolToStr(shaderInfo.overwriteAlpha); out.second << ", "; out.second << BoolToStr(shaderInfo.depthAttachment); @@ -631,7 +632,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, else if (semantic == "modelview") shaderAttributes.push_back(std::make_pair(boo::VertexSemantic::ModelView | orsem, idxNum)); else { - Log.report(logvisor::Error, fmt("Unrecognized vertex semantic '{}'"), semantic); + Log.report(logvisor::Error, FMT_STRING("Unrecognized vertex semantic '{}'"), semantic); return false; } return true; @@ -729,7 +730,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, char* endptr; shaderInfo.patchSize = uint32_t(strtoul(str.c_str(), &endptr, 0)); if (endptr == str.c_str()) { - Log.report(logvisor::Error, fmt("Non-unsigned-integer value for #patchsize directive")); + Log.report(logvisor::Error, FMT_STRING("Non-unsigned-integer value for #patchsize directive")); return false; } } else if (std::regex_search(begin, nextBegin, subMatch, regOverwriteAlpha)) { @@ -767,7 +768,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, if (shader.second.stageHashes[i]) { out.first << "template <> constexpr uint64_t Shader_"; out.first << shader.first; - fmt::print(out.first, fmt("::StageHash<{}>() {{ return 0x{:016X}; }}\n"), + fmt::print(out.first, FMT_STRING("::StageHash<{}>() {{ return 0x{:016X}; }}\n"), StageNames[i], shader.second.stageHashes[i]); } } @@ -800,7 +801,7 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, bool Compiler::compile(std::string_view baseName, std::pair& out) { out.first << "#pragma once\n" "#include \"hecl/PipelineBase.hpp\"\n\n"; - fmt::print(out.second, fmt("#include \"{}.hpp\"\n\n"), baseName); + fmt::print(out.second, FMT_STRING("#include \"{}.hpp\"\n\n"), baseName); for (const auto& file : m_inputFiles) if (!compileFile(file, baseName, out))