AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-06-07 08:33:29 +00:00
Code Issues Projects Releases Wiki Activity

Windows sync fixes for API changes

Browse Source
This commit is contained in:
Jack Andersen 2018-10-14 10:09:15 -10:00
parent aef455e1ab
commit 61a50aa57e
33 changed files with 767 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
hecl/CMakeLists.txt
View File

@ -40,17 +40,9 @@ foreach(name ${HECL_APPLICATION_PIPELINE_REPS})
set(HECL_APPLICATION_PIPELINE_REPS_NX_LOCAL "${HECL_APPLICATION_PIPELINE_REPS_NX_LOCAL}NX_PIPELINES_${name} \\\n") set(HECL_APPLICATION_PIPELINE_REPS_NX_LOCAL "${HECL_APPLICATION_PIPELINE_REPS_NX_LOCAL}NX_PIPELINES_${name} \\\n")
endforeach() endforeach()
unset(HECL_APPLICATION_STAGE_REPS_OPENGL_LOCAL) unset(HECL_APPLICATION_STAGE_REPS_LOCAL)
unset(HECL_APPLICATION_STAGE_REPS_VULKAN_LOCAL)
unset(HECL_APPLICATION_STAGE_REPS_D3D11_LOCAL)
unset(HECL_APPLICATION_STAGE_REPS_METAL_LOCAL)
unset(HECL_APPLICATION_STAGE_REPS_NX_LOCAL)
foreach(name ${HECL_APPLICATION_STAGE_REPS}) foreach(name ${HECL_APPLICATION_STAGE_REPS})
set(HECL_APPLICATION_STAGE_REPS_OPENGL_LOCAL "${HECL_APPLICATION_STAGE_REPS_OPENGL_LOCAL}OPENGL_STAGES_${name} \\\n") set(HECL_APPLICATION_STAGE_REPS_LOCAL "${HECL_APPLICATION_STAGE_REPS_LOCAL}STAGES_${name}(P, S) \\\n")
set(HECL_APPLICATION_STAGE_REPS_VULKAN_LOCAL "${HECL_APPLICATION_STAGE_REPS_VULKAN_LOCAL}VULKAN_STAGES_${name} \\\n")
set(HECL_APPLICATION_STAGE_REPS_D3D11_LOCAL "${HECL_APPLICATION_STAGE_REPS_D3D11_LOCAL}D3D11_STAGES_${name} \\\n")
set(HECL_APPLICATION_STAGE_REPS_METAL_LOCAL "${HECL_APPLICATION_STAGE_REPS_METAL_LOCAL}METAL_STAGES_${name} \\\n")
set(HECL_APPLICATION_STAGE_REPS_NX_LOCAL "${HECL_APPLICATION_STAGE_REPS_NX_LOCAL}NX_STAGES_${name} \\\n")
endforeach() endforeach()
configure_file(include/hecl/ApplicationReps.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/include/hecl/ApplicationReps.hpp @ONLY) configure_file(include/hecl/ApplicationReps.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/include/hecl/ApplicationReps.hpp @ONLY)

54
hecl/driver/ToolBase.hpp
View File

@ -59,9 +59,9 @@ protected:
if (!m_info.yes) if (!m_info.yes)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("\n" BLUE BOLD "Continue?" NORMAL " (Y/n) ")); hecl::Printf(_SYS_STR("\n" BLUE BOLD "Continue?" NORMAL " (Y/n) "));
else else
hecl::Printf(_S("\nContinue? (Y/n) ")); hecl::Printf(_SYS_STR("\nContinue? (Y/n) "));
fflush(stdout); fflush(stdout);
int ch; int ch;
@ -78,7 +78,7 @@ protected:
{ {
if (ch == 'n' || ch == 'N') if (ch == 'n' || ch == 'N')
{ {
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
return false; return false;
} }
if (ch == 'y' || ch == 'Y' || ch == '\r' || ch == '\n') if (ch == 'y' || ch == 'Y' || ch == '\r' || ch == '\n')
@ -88,7 +88,7 @@ protected:
tcsetattr(0, TCSANOW, &tioOld); tcsetattr(0, TCSANOW, &tioOld);
#endif #endif
} }
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
return true; return true;
} }
@ -130,7 +130,7 @@ private:
{ {
if (it >= string.end()) if (it >= string.end())
return; return;
if (*it == _S('\n')) if (*it == _SYS_STR('\n'))
{ {
counter = WRAP_INDENT; counter = WRAP_INDENT;
++it; ++it;
@ -138,17 +138,17 @@ private:
if (counter == WRAP_INDENT) if (counter == WRAP_INDENT)
{ {
for (int i=0 ; i<WRAP_INDENT ; ++i) for (int i=0 ; i<WRAP_INDENT ; ++i)
it = string.insert(it, _S(' ')) + 1; it = string.insert(it, _SYS_STR(' ')) + 1;
} }
if (it >= string.end()) if (it >= string.end())
return; return;
if (*it != _S('\n')) if (*it != _SYS_STR('\n'))
++it; ++it;
} }
/* check for whitespace */ /* check for whitespace */
if (isspace(*it)) if (isspace(*it))
{ {
*it = _S('\n'); *it = _SYS_STR('\n');
counter = WRAP_INDENT; counter = WRAP_INDENT;
++it; ++it;
} }
@ -161,9 +161,9 @@ private:
{ {
counter = WRAP_INDENT; counter = WRAP_INDENT;
if (k - string.begin() < v) if (k - string.begin() < v)
k = string.insert(it, _S('\n')); k = string.insert(it, _SYS_STR('\n'));
else else
*k = _S('\n'); *k = _SYS_STR('\n');
it = k + 1; it = k + 1;
break; break;
} }
@ -200,31 +200,31 @@ public:
void print(const hecl::SystemChar* str) void print(const hecl::SystemChar* str)
{ {
hecl::FPrintf(m_sout, _S("%s"), str); hecl::FPrintf(m_sout, _SYS_STR("%s"), str);
} }
void printBold(const hecl::SystemChar* str) void printBold(const hecl::SystemChar* str)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::FPrintf(m_sout, _S("" BOLD "%s" NORMAL ""), str); hecl::FPrintf(m_sout, _SYS_STR("" BOLD "%s" NORMAL ""), str);
else else
hecl::FPrintf(m_sout, _S("%s"), str); hecl::FPrintf(m_sout, _SYS_STR("%s"), str);
} }
void secHead(const hecl::SystemChar* headName) void secHead(const hecl::SystemChar* headName)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::FPrintf(m_sout, _S("" BOLD "%s" NORMAL "\n"), headName); hecl::FPrintf(m_sout, _SYS_STR("" BOLD "%s" NORMAL "\n"), headName);
else else
hecl::FPrintf(m_sout, _S("%s\n"), headName); hecl::FPrintf(m_sout, _SYS_STR("%s\n"), headName);
} }
void optionHead(const hecl::SystemChar* flag, const hecl::SystemChar* synopsis) void optionHead(const hecl::SystemChar* flag, const hecl::SystemChar* synopsis)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::FPrintf(m_sout, _S("" BOLD "%s" NORMAL " (%s)\n"), flag, synopsis); hecl::FPrintf(m_sout, _SYS_STR("" BOLD "%s" NORMAL " (%s)\n"), flag, synopsis);
else else
hecl::FPrintf(m_sout, _S("%s (%s)\n"), flag, synopsis); hecl::FPrintf(m_sout, _SYS_STR("%s (%s)\n"), flag, synopsis);
} }
void beginWrap() void beginWrap()
@ -240,17 +240,17 @@ public:
void wrapBold(const hecl::SystemChar* str) void wrapBold(const hecl::SystemChar* str)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
m_wrapBuffer += _S("" BOLD ""); m_wrapBuffer += _SYS_STR("" BOLD "");
m_wrapBuffer += str; m_wrapBuffer += str;
if (XTERM_COLOR) if (XTERM_COLOR)
m_wrapBuffer += _S("" NORMAL ""); m_wrapBuffer += _SYS_STR("" NORMAL "");
} }
void endWrap() void endWrap()
{ {
_wrapBuf(m_wrapBuffer); _wrapBuf(m_wrapBuffer);
m_wrapBuffer += _S('\n'); m_wrapBuffer += _SYS_STR('\n');
hecl::FPrintf(m_sout, _S("%s"), m_wrapBuffer.c_str()); hecl::FPrintf(m_sout, _SYS_STR("%s"), m_wrapBuffer.c_str());
m_wrapBuffer.clear(); m_wrapBuffer.clear();
} }
}; };
@ -259,17 +259,17 @@ static hecl::SystemString MakePathArgAbsolute(const hecl::SystemString& arg,
const hecl::SystemString& cwd) const hecl::SystemString& cwd)
{ {
#if _WIN32 #if _WIN32
if (arg.size() >= 2 && iswalpha(arg[0]) && arg[1] == _S(':')) if (arg.size() >= 2 && iswalpha(arg[0]) && arg[1] == _SYS_STR(':'))
return arg; return arg;
if (arg[0] == _S('\\') || arg[0] == _S('/')) if (arg[0] == _SYS_STR('\\') || arg[0] == _SYS_STR('/'))
return arg; return arg;
return cwd + _S('\\') + arg; return cwd + _SYS_STR('\\') + arg;
#else #else
if (arg[0] == _S('/') || arg[0] == _S('\\')) if (arg[0] == _SYS_STR('/') || arg[0] == _SYS_STR('\\'))
return arg; return arg;
if (cwd.back() == _S('/') || cwd.back() == _S('\\')) if (cwd.back() == _SYS_STR('/') || cwd.back() == _SYS_STR('\\'))
return cwd + arg; return cwd + arg;
return cwd + _S('/') + arg; return cwd + _SYS_STR('/') + arg;
#endif #endif
} }

106
hecl/driver/ToolCook.hpp
View File

@ -18,7 +18,7 @@ public:
{ {
/* Check for recursive flag */ /* Check for recursive flag */
for (hecl::SystemChar arg : info.flags) for (hecl::SystemChar arg : info.flags)
if (arg == _S('r')) if (arg == _SYS_STR('r'))
m_recursive = true; m_recursive = true;
/* Scan args */ /* Scan args */
@ -30,12 +30,12 @@ public:
{ {
if (arg.empty()) if (arg.empty())
continue; continue;
else if (!arg.compare(_S("--fast"))) else if (!arg.compare(_SYS_STR("--fast")))
{ {
m_fast = true; m_fast = true;
continue; continue;
} }
else if (arg.size() >= 8 && !arg.compare(0, 7, _S("--spec="))) else if (arg.size() >= 8 && !arg.compare(0, 7, _SYS_STR("--spec=")))
{ {
hecl::SystemString specName(arg.begin() + 7, arg.end()); hecl::SystemString specName(arg.begin() + 7, arg.end());
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
@ -50,7 +50,7 @@ public:
LogModule.report(logvisor::Fatal, "unable to find data spec '%s'", specName.c_str()); LogModule.report(logvisor::Fatal, "unable to find data spec '%s'", specName.c_str());
continue; continue;
} }
else if (arg.size() >= 2 && arg[0] == _S('-') && arg[1] == _S('-')) else if (arg.size() >= 2 && arg[0] == _SYS_STR('-') && arg[1] == _SYS_STR('-'))
continue; continue;
hecl::SystemString subPath; hecl::SystemString subPath;
@ -64,8 +64,8 @@ public:
} }
else if (m_fallbackProj->getProjectRootPath() != root) else if (m_fallbackProj->getProjectRootPath() != root)
LogModule.report(logvisor::Fatal, LogModule.report(logvisor::Fatal,
_S("hecl cook can only process multiple items in the same project; ") _SYS_STR("hecl cook can only process multiple items in the same project; ")
_S("'%s' and '%s' are different projects"), _SYS_STR("'%s' and '%s' are different projects"),
m_fallbackProj->getProjectRootPath().getAbsolutePath().data(), m_fallbackProj->getProjectRootPath().getAbsolutePath().data(),
root.getAbsolutePath().data()); root.getAbsolutePath().data());
m_selectedItems.emplace_back(*m_useProj, subPath); m_selectedItems.emplace_back(*m_useProj, subPath);
@ -81,87 +81,87 @@ public:
if (m_selectedItems.empty()) if (m_selectedItems.empty())
{ {
m_selectedItems.reserve(1); m_selectedItems.reserve(1);
m_selectedItems.push_back({hecl::ProjectPath(*m_useProj, _S(""))}); m_selectedItems.push_back({hecl::ProjectPath(*m_useProj, _SYS_STR(""))});
m_recursive = true; m_recursive = true;
} }
} }
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-cook - Cook objects within the project database\n")); help.wrap(_SYS_STR("hecl-cook - Cook objects within the project database\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl cook [-rf] [--fast] [--spec=<spec>] [<pathspec>...]\n")); help.wrap(_SYS_STR("hecl cook [-rf] [--fast] [--spec=<spec>] [<pathspec>...]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("This command initiates a cooking pass on the project database. Cooking ") help.wrap(_SYS_STR("This command initiates a cooking pass on the project database. Cooking ")
_S("is analogous to compiling in software development. The resulting object buffers ") _SYS_STR("is analogous to compiling in software development. The resulting object buffers ")
_S("are cached within the project database. HECL performs the following ") _SYS_STR("are cached within the project database. HECL performs the following ")
_S("tasks for each object during the cook process:\n\n")); _SYS_STR("tasks for each object during the cook process:\n\n"));
help.wrapBold(_S("- Object Gather: ")); help.wrapBold(_SYS_STR("- Object Gather: "));
help.wrap(_S("Files added with ")); help.wrap(_SYS_STR("Files added with "));
help.wrapBold(_S("hecl add")); help.wrapBold(_SYS_STR("hecl add"));
help.wrap(_S(" are queried for their dependent files (e.g. ")); help.wrap(_SYS_STR(" are queried for their dependent files (e.g. "));
help.wrapBold(_S(".blend")); help.wrapBold(_SYS_STR(".blend"));
help.wrap(_S(" files return any linked ")); help.wrap(_SYS_STR(" files return any linked "));
help.wrapBold(_S(".png")); help.wrapBold(_SYS_STR(".png"));
help.wrap(_S(" images). If the dependent files are unable to be found, the cook process aborts.\n\n")); help.wrap(_SYS_STR(" images). If the dependent files are unable to be found, the cook process aborts.\n\n"));
help.wrapBold(_S("- Modtime Comparison: ")); help.wrapBold(_SYS_STR("- Modtime Comparison: "));
help.wrap(_S("Files that have previously finished a cook pass are inspected for their time of ") help.wrap(_SYS_STR("Files that have previously finished a cook pass are inspected for their time of ")
_S("last modification. If the file hasn't changed since its previous cook-pass, the ") _SYS_STR("last modification. If the file hasn't changed since its previous cook-pass, the ")
_S("process is skipped. If the file has been moved or deleted, the object is automatically ") _SYS_STR("process is skipped. If the file has been moved or deleted, the object is automatically ")
_S("removed from the project database.\n\n")); _SYS_STR("removed from the project database.\n\n"));
help.wrapBold(_S("- Cook: ")); help.wrapBold(_SYS_STR("- Cook: "));
help.wrap(_S("A type-specific procedure compiles the file's contents into an efficient format ") help.wrap(_SYS_STR("A type-specific procedure compiles the file's contents into an efficient format ")
_S("for use by the runtime. A data-buffer is provided to HECL.\n\n")); _SYS_STR("for use by the runtime. A data-buffer is provided to HECL.\n\n"));
help.wrapBold(_S("- Hash and Compress: ")); help.wrapBold(_SYS_STR("- Hash and Compress: "));
help.wrap(_S("The data-buffer is hashed and compressed before being cached in the object database.\n\n")); help.wrap(_SYS_STR("The data-buffer is hashed and compressed before being cached in the object database.\n\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<pathspec>..."), _S("input file(s)")); help.optionHead(_SYS_STR("<pathspec>..."), _SYS_STR("input file(s)"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies working file(s) containing production data to be cooked by HECL. ") help.wrap(_SYS_STR("Specifies working file(s) containing production data to be cooked by HECL. ")
_S("Glob-strings may be specified (e.g. ")); _SYS_STR("Glob-strings may be specified (e.g. "));
help.wrapBold(_S("*.blend")); help.wrapBold(_SYS_STR("*.blend"));
help.wrap(_S(") to automatically cook all matching current-directory files in the project database. ") help.wrap(_SYS_STR(") to automatically cook all matching current-directory files in the project database. ")
_S("If no path specified, all files in the project database are cooked.\n")); _SYS_STR("If no path specified, all files in the project database are cooked.\n"));
help.endWrap(); help.endWrap();
help.optionHead(_S("-r"), _S("recursion")); help.optionHead(_SYS_STR("-r"), _SYS_STR("recursion"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Enables recursive file-matching for cooking entire directories of working files.\n")); help.wrap(_SYS_STR("Enables recursive file-matching for cooking entire directories of working files.\n"));
help.endWrap(); help.endWrap();
help.optionHead(_S("-f"), _S("force")); help.optionHead(_SYS_STR("-f"), _SYS_STR("force"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Forces cooking of all matched files, ignoring timestamp differences.\n")); help.wrap(_SYS_STR("Forces cooking of all matched files, ignoring timestamp differences.\n"));
help.endWrap(); help.endWrap();
help.optionHead(_S("--fast"), _S("fast cook")); help.optionHead(_SYS_STR("--fast"), _SYS_STR("fast cook"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Performs draft-optimization cooking for supported data types.\n")); help.wrap(_SYS_STR("Performs draft-optimization cooking for supported data types.\n"));
help.endWrap(); help.endWrap();
help.optionHead(_S("--spec=<spec>"), _S("data specification")); help.optionHead(_SYS_STR("--spec=<spec>"), _SYS_STR("data specification"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies a DataSpec to use when cooking. ") help.wrap(_SYS_STR("Specifies a DataSpec to use when cooking. ")
_S("This build of hecl supports the following values of <spec>:\n")); _SYS_STR("This build of hecl supports the following values of <spec>:\n"));
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
{ {
if (!spec->m_factory) if (!spec->m_factory)
continue; continue;
help.wrap(_S(" ")); help.wrap(_SYS_STR(" "));
help.wrapBold(spec->m_name.data()); help.wrapBold(spec->m_name.data());
help.wrap(_S("\n")); help.wrap(_SYS_STR("\n"));
} }
} }
hecl::SystemString toolName() const {return _S("cook");} hecl::SystemString toolName() const {return _SYS_STR("cook");}
int run() int run()
{ {

60
hecl/driver/ToolExtract.hpp
View File

@ -43,12 +43,12 @@ public:
{ {
/* Get name from input file and init project there */ /* Get name from input file and init project there */
hecl::SystemString baseFile = info.args.front(); hecl::SystemString baseFile = info.args.front();
size_t slashPos = baseFile.rfind(_S('/')); size_t slashPos = baseFile.rfind(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos) if (slashPos == hecl::SystemString::npos)
slashPos = baseFile.rfind(_S('\\')); slashPos = baseFile.rfind(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
baseFile.assign(baseFile.begin() + slashPos + 1, baseFile.end()); baseFile.assign(baseFile.begin() + slashPos + 1, baseFile.end());
size_t dotPos = baseFile.rfind(_S('.')); size_t dotPos = baseFile.rfind(_SYS_STR('.'));
if (dotPos != hecl::SystemString::npos) if (dotPos != hecl::SystemString::npos)
baseFile.assign(baseFile.begin(), baseFile.begin() + dotPos); baseFile.assign(baseFile.begin(), baseFile.begin() + dotPos);
@ -71,7 +71,7 @@ public:
m_fallbackProj.reset(new hecl::Database::Project(newProjRoot)); m_fallbackProj.reset(new hecl::Database::Project(newProjRoot));
if (logvisor::ErrorCount > ErrorRef) if (logvisor::ErrorCount > ErrorRef)
LogModule.report(logvisor::Fatal, "unable to init project at '%s'", rootDir.c_str()); LogModule.report(logvisor::Fatal, "unable to init project at '%s'", rootDir.c_str());
LogModule.report(logvisor::Info, _S("initialized project at '%s/.hecl'"), rootDir.c_str()); LogModule.report(logvisor::Info, _SYS_STR("initialized project at '%s/.hecl'"), rootDir.c_str());
m_useProj = m_fallbackProj.get(); m_useProj = m_fallbackProj.get();
} }
else else
@ -99,45 +99,45 @@ public:
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-extract - Extract objects from supported package/image formats\n")); help.wrap(_SYS_STR("hecl-extract - Extract objects from supported package/image formats\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl extract <packagefile> [<subnode>...]\n")); help.wrap(_SYS_STR("hecl extract <packagefile> [<subnode>...]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("This command recursively extracts all or part of a dataspec-supported ") help.wrap(_SYS_STR("This command recursively extracts all or part of a dataspec-supported ")
_S("package format. Each object is decoded to a working format and added to the project.\n\n")); _SYS_STR("package format. Each object is decoded to a working format and added to the project.\n\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<packagefile>[/<subnode>...]"), _S("input file")); help.optionHead(_SYS_STR("<packagefile>[/<subnode>...]"), _SYS_STR("input file"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies the package file or disc image to source data from. ") help.wrap(_SYS_STR("Specifies the package file or disc image to source data from. ")
_S("An optional subnode specifies a named hierarchical-node specific ") _SYS_STR("An optional subnode specifies a named hierarchical-node specific ")
_S("to the game architecture (levels/areas).")); _SYS_STR("to the game architecture (levels/areas)."));
help.endWrap(); help.endWrap();
} }
hecl::SystemString toolName() const {return _S("extract");} hecl::SystemString toolName() const {return _SYS_STR("extract");}
static void _recursivePrint(int level, hecl::Database::IDataSpec::ExtractReport& rep) static void _recursivePrint(int level, hecl::Database::IDataSpec::ExtractReport& rep)
{ {
for (int l=0 ; l<level ; ++l) for (int l=0 ; l<level ; ++l)
hecl::Printf(_S(" ")); hecl::Printf(_SYS_STR(" "));
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD "%s" NORMAL ""), rep.name.c_str()); hecl::Printf(_SYS_STR("" BOLD "%s" NORMAL ""), rep.name.c_str());
else else
hecl::Printf(_S("%s"), rep.name.c_str()); hecl::Printf(_SYS_STR("%s"), rep.name.c_str());
if (rep.desc.size()) if (rep.desc.size())
hecl::Printf(_S(" [%s]"), rep.desc.c_str()); hecl::Printf(_SYS_STR(" [%s]"), rep.desc.c_str());
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
for (hecl::Database::IDataSpec::ExtractReport& child : rep.childOpts) for (hecl::Database::IDataSpec::ExtractReport& child : rep.childOpts)
_recursivePrint(level + 1, child); _recursivePrint(level + 1, child);
} }
@ -147,21 +147,21 @@ public:
if (m_specPasses.empty()) if (m_specPasses.empty())
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" RED BOLD "NOTHING TO EXTRACT" NORMAL "\n")); hecl::Printf(_SYS_STR("" RED BOLD "NOTHING TO EXTRACT" NORMAL "\n"));
else else
hecl::Printf(_S("NOTHING TO EXTRACT\n")); hecl::Printf(_SYS_STR("NOTHING TO EXTRACT\n"));
return 1; return 1;
} }
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" GREEN BOLD "ABOUT TO EXTRACT:" NORMAL "\n")); hecl::Printf(_SYS_STR("" GREEN BOLD "ABOUT TO EXTRACT:" NORMAL "\n"));
else else
hecl::Printf(_S("ABOUT TO EXTRACT:\n")); hecl::Printf(_SYS_STR("ABOUT TO EXTRACT:\n"));
for (hecl::Database::IDataSpec::ExtractReport& rep : m_reps) for (hecl::Database::IDataSpec::ExtractReport& rep : m_reps)
{ {
_recursivePrint(0, rep); _recursivePrint(0, rep);
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
} }
fflush(stdout); fflush(stdout);
@ -170,12 +170,12 @@ public:
for (SpecExtractPass& ds : m_specPasses) for (SpecExtractPass& ds : m_specPasses)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" MAGENTA BOLD "Using DataSpec %s:" NORMAL "\n"), ds.m_entry->m_name.data()); hecl::Printf(_SYS_STR("" MAGENTA BOLD "Using DataSpec %s:" NORMAL "\n"), ds.m_entry->m_name.data());
else else
hecl::Printf(_S("Using DataSpec %s:\n"), ds.m_entry->m_name.data()); hecl::Printf(_SYS_STR("Using DataSpec %s:\n"), ds.m_entry->m_name.data());
ds.m_instance->doExtract(m_einfo, {true}); ds.m_instance->doExtract(m_einfo, {true});
hecl::Printf(_S("\n\n")); hecl::Printf(_SYS_STR("\n\n"));
} }
} }

64
hecl/driver/ToolHelp.hpp
View File

@ -29,51 +29,51 @@ public:
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.printBold( help.printBold(
_S(" ___________ \n") _SYS_STR(" ___________ \n")
_S(" ,.-'\"...........``~., \n") _SYS_STR(" ,.-'\"...........``~., \n")
_S(" ,.-\".......................\"-., \n") _SYS_STR(" ,.-\".......................\"-., \n")
_S(" ,/..................................\":, \n") _SYS_STR(" ,/..................................\":, \n")
_S(" .,?........................................, \n") _SYS_STR(" .,?........................................, \n")
_S(" /...........................................,}\n") _SYS_STR(" /...........................................,}\n")
_S(" ./........................................,:`^`..}\n") _SYS_STR(" ./........................................,:`^`..}\n")
_S(" ./.......................................,:\"...../\n") _SYS_STR(" ./.......................................,:\"...../\n")
_S(" ?.....__..................................:`...../\n") _SYS_STR(" ?.....__..................................:`...../\n")
_S(" /__.(...\"~-,_...........................,:`....../\n") _SYS_STR(" /__.(...\"~-,_...........................,:`....../\n")
_S(" /(_....\"~,_....\"~,_.....................,:`...._/ \n") _SYS_STR(" /(_....\"~,_....\"~,_.....................,:`...._/ \n")
_S(" {.._$;_....\"=,_.....\"-,_......,.-~-,},.~\";/....} \n") _SYS_STR(" {.._$;_....\"=,_.....\"-,_......,.-~-,},.~\";/....} \n")
_S(" ((...*~_......\"=-._...\";,,./`........../\"..../ \n") _SYS_STR(" ((...*~_......\"=-._...\";,,./`........../\"..../ \n")
_S(" ,,,___.`~,......\"~.,....................`......}....../ \n") _SYS_STR(" ,,,___.`~,......\"~.,....................`......}....../ \n")
_S("............(....`=-,,...`.........................(...;_,,-\" \n") _SYS_STR("............(....`=-,,...`.........................(...;_,,-\" \n")
_S("............/.`~,......`-.................................../ \n") _SYS_STR("............/.`~,......`-.................................../ \n")
_S(".............`~.*-,.....................................|,./...,__ \n") _SYS_STR(".............`~.*-,.....................................|,./...,__ \n")
_S(",,_..........}.>-._...................................|.......`=~-, \n") _SYS_STR(",,_..........}.>-._...................................|.......`=~-, \n")
_S(".....`=~-,__......`,................................. \n") _SYS_STR(".....`=~-,__......`,................................. \n")
_S("...................`=~-,,.,........................... \n") _SYS_STR("...................`=~-,,.,........................... \n")
_S(".........................`:,,..........................`\n") _SYS_STR(".........................`:,,..........................`\n")
_S("...........................`=-,...............,%%`>--==`` \n") _SYS_STR("...........................`=-,...............,%%`>--==`` \n")
_S(".................................._.........._,-%%...` \n") _SYS_STR(".................................._.........._,-%%...` \n")
_S("...................................,\n")); _SYS_STR("...................................,\n"));
} }
static void ShowHelp(const hecl::SystemString& toolName) static void ShowHelp(const hecl::SystemString& toolName)
{ {
/* Select tool's help-text streamer */ /* Select tool's help-text streamer */
HelpOutput::HelpFunc helpFunc = NULL; HelpOutput::HelpFunc helpFunc = NULL;
if (toolName == _S("init")) if (toolName == _SYS_STR("init"))
helpFunc = ToolInit::Help; helpFunc = ToolInit::Help;
else if (toolName == _S("spec")) else if (toolName == _SYS_STR("spec"))
helpFunc = ToolSpec::Help; helpFunc = ToolSpec::Help;
else if (toolName == _S("extract")) else if (toolName == _SYS_STR("extract"))
helpFunc = ToolExtract::Help; helpFunc = ToolExtract::Help;
else if (toolName == _S("cook")) else if (toolName == _SYS_STR("cook"))
helpFunc = ToolCook::Help; helpFunc = ToolCook::Help;
else if (toolName == _S("package") || toolName == _S("pack")) else if (toolName == _SYS_STR("package") || toolName == _SYS_STR("pack"))
helpFunc = ToolPackage::Help; helpFunc = ToolPackage::Help;
else if (toolName == _S("help")) else if (toolName == _SYS_STR("help"))
helpFunc = ToolHelp::Help; helpFunc = ToolHelp::Help;
else else
{ {
LogModule.report(logvisor::Error, _S("unrecognized tool '%s' - can't help"), toolName.c_str()); LogModule.report(logvisor::Error, _SYS_STR("unrecognized tool '%s' - can't help"), toolName.c_str());
return; return;
} }
@ -81,7 +81,7 @@ public:
ho.go(); ho.go();
} }
hecl::SystemString toolName() const {return _S("help");} hecl::SystemString toolName() const {return _SYS_STR("help");}
int run() int run()
{ {

52
hecl/driver/ToolImage.hpp
View File

@ -57,69 +57,69 @@ public:
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-image - Generate GameCube/Wii disc image from packaged files\n")); help.wrap(_SYS_STR("hecl-image - Generate GameCube/Wii disc image from packaged files\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl image [<input-dir>]\n")); help.wrap(_SYS_STR("hecl image [<input-dir>]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("This command uses the current contents of `out` to generate a GameCube or ") help.wrap(_SYS_STR("This command uses the current contents of `out` to generate a GameCube or ")
_S("Wii disc image. `hecl package` must have been run previously to be effective.\n")); _SYS_STR("Wii disc image. `hecl package` must have been run previously to be effective.\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<input-dir>"), _S("input directory")); help.optionHead(_SYS_STR("<input-dir>"), _SYS_STR("input directory"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies a project subdirectory to root the resulting image from. ") help.wrap(_SYS_STR("Specifies a project subdirectory to root the resulting image from. ")
_S("Project must contain an out/sys and out/files directory to succeed.\n")); _SYS_STR("Project must contain an out/sys and out/files directory to succeed.\n"));
help.endWrap(); help.endWrap();
} }
hecl::SystemString toolName() const {return _S("image");} hecl::SystemString toolName() const {return _SYS_STR("image");}
int run() int run()
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" GREEN BOLD "ABOUT TO IMAGE:" NORMAL "\n")); hecl::Printf(_SYS_STR("" GREEN BOLD "ABOUT TO IMAGE:" NORMAL "\n"));
else else
hecl::Printf(_S("ABOUT TO IMAGE:\n")); hecl::Printf(_SYS_STR("ABOUT TO IMAGE:\n"));
hecl::Printf(_S(" %s\n"), m_useProj->getProjectRootPath().getAbsolutePath().data()); hecl::Printf(_SYS_STR(" %s\n"), m_useProj->getProjectRootPath().getAbsolutePath().data());
fflush(stdout); fflush(stdout);
if (continuePrompt()) if (continuePrompt())
{ {
hecl::ProjectPath outPath(m_useProj->getProjectWorkingPath(), _S("out")); hecl::ProjectPath outPath(m_useProj->getProjectWorkingPath(), _SYS_STR("out"));
if (!outPath.isDirectory()) if (!outPath.isDirectory())
{ {
LogModule.report(logvisor::Error, _S("%s is not a directory"), outPath.getAbsolutePath().data()); LogModule.report(logvisor::Error, _SYS_STR("%s is not a directory"), outPath.getAbsolutePath().data());
return 1; return 1;
} }
hecl::ProjectPath bootBinPath(outPath, _S("sys/boot.bin")); hecl::ProjectPath bootBinPath(outPath, _SYS_STR("sys/boot.bin"));
if (!bootBinPath.isFile()) if (!bootBinPath.isFile())
{ {
LogModule.report(logvisor::Error, _S("%s is not a file"), bootBinPath.getAbsolutePath().data()); LogModule.report(logvisor::Error, _SYS_STR("%s is not a file"), bootBinPath.getAbsolutePath().data());
return 1; return 1;
} }
athena::io::FileReader r(bootBinPath.getAbsolutePath()); athena::io::FileReader r(bootBinPath.getAbsolutePath());
if (r.hasError()) if (r.hasError())
{ {
LogModule.report(logvisor::Error, _S("unable to open %s"), bootBinPath.getAbsolutePath().data()); LogModule.report(logvisor::Error, _SYS_STR("unable to open %s"), bootBinPath.getAbsolutePath().data());
return 1; return 1;
} }
std::string id = r.readString(6); std::string id = r.readString(6);
r.close(); r.close();
hecl::SystemStringConv idView(id); hecl::SystemStringConv idView(id);
hecl::SystemString fileOut = hecl::SystemString(outPath.getAbsolutePath()) + _S('/') + idView.c_str(); hecl::SystemString fileOut = hecl::SystemString(outPath.getAbsolutePath()) + _SYS_STR('/') + idView.c_str();
hecl::MultiProgressPrinter printer(true); hecl::MultiProgressPrinter printer(true);
auto progFunc = [&printer](float totalProg, nod::SystemStringView fileName, size_t fileBytesXfered) auto progFunc = [&printer](float totalProg, nod::SystemStringView fileName, size_t fileBytesXfered)
{ {
@ -127,22 +127,22 @@ public:
}; };
if (id[0] == 'G') if (id[0] == 'G')
{ {
fileOut += _S(".gcm"); fileOut += _SYS_STR(".gcm");
if (nod::DiscBuilderGCN::CalculateTotalSizeRequired(outPath.getAbsolutePath()) == -1) if (nod::DiscBuilderGCN::CalculateTotalSizeRequired(outPath.getAbsolutePath()) == -1)
return 1; return 1;
LogModule.report(logvisor::Info, _S("Generating %s as GameCube image"), fileOut.c_str()); LogModule.report(logvisor::Info, _SYS_STR("Generating %s as GameCube image"), fileOut.c_str());
nod::DiscBuilderGCN db(fileOut, progFunc); nod::DiscBuilderGCN db(fileOut, progFunc);
if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success) if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success)
return 1; return 1;
} }
else else
{ {
fileOut += _S(".iso"); fileOut += _SYS_STR(".iso");
bool dualLayer; bool dualLayer;
if (nod::DiscBuilderWii::CalculateTotalSizeRequired(outPath.getAbsolutePath(), dualLayer) == -1) if (nod::DiscBuilderWii::CalculateTotalSizeRequired(outPath.getAbsolutePath(), dualLayer) == -1)
return 1; return 1;
LogModule.report(logvisor::Info, _S("Generating %s as %s-layer Wii image"), fileOut.c_str(), LogModule.report(logvisor::Info, _SYS_STR("Generating %s as %s-layer Wii image"), fileOut.c_str(),
dualLayer ? _S("dual") : _S("single")); dualLayer ? _SYS_STR("dual") : _SYS_STR("single"));
nod::DiscBuilderWii db(fileOut, dualLayer, progFunc); nod::DiscBuilderWii db(fileOut, dualLayer, progFunc);
if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success) if (db.buildFromDirectory(outPath.getAbsolutePath()) != nod::EBuildResult::Success)
return 1; return 1;

36
hecl/driver/ToolInit.hpp
View File

@ -22,20 +22,20 @@ public:
hecl::MakeDir(dir->c_str()); hecl::MakeDir(dir->c_str());
if (hecl::Stat(dir->c_str(), &theStat)) if (hecl::Stat(dir->c_str(), &theStat))
{ {
LogModule.report(logvisor::Fatal, _S("unable to stat '%s'"), dir->c_str()); LogModule.report(logvisor::Fatal, _SYS_STR("unable to stat '%s'"), dir->c_str());
return; return;
} }
} }
if (!S_ISDIR(theStat.st_mode)) if (!S_ISDIR(theStat.st_mode))
{ {
LogModule.report(logvisor::Fatal, _S("'%s' is not a directory"), dir->c_str()); LogModule.report(logvisor::Fatal, _SYS_STR("'%s' is not a directory"), dir->c_str());
return; return;
} }
hecl::SystemString testPath = *dir + _S("/.hecl/beacon"); hecl::SystemString testPath = *dir + _SYS_STR("/.hecl/beacon");
if (!hecl::Stat(testPath.c_str(), &theStat)) if (!hecl::Stat(testPath.c_str(), &theStat))
{ {
LogModule.report(logvisor::Fatal, _S("project already exists at '%s'"), dir->c_str()); LogModule.report(logvisor::Fatal, _SYS_STR("project already exists at '%s'"), dir->c_str());
return; return;
} }
@ -50,37 +50,37 @@ public:
hecl::Database::Project proj((hecl::ProjectRootPath(*m_dir))); hecl::Database::Project proj((hecl::ProjectRootPath(*m_dir)));
if (logvisor::ErrorCount > ErrorRef) if (logvisor::ErrorCount > ErrorRef)
return 1; return 1;
LogModule.report(logvisor::Info, _S("initialized project at '%s/.hecl'"), m_dir->c_str()); LogModule.report(logvisor::Info, _SYS_STR("initialized project at '%s/.hecl'"), m_dir->c_str());
return 0; return 0;
} }
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-init - Initialize a brand-new project database\n")); help.wrap(_SYS_STR("hecl-init - Initialize a brand-new project database\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl init [<dir>]\n")); help.wrap(_SYS_STR("hecl init [<dir>]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Creates a ")); help.wrap(_SYS_STR("Creates a "));
help.wrapBold(_S(".hecl")); help.wrapBold(_SYS_STR(".hecl"));
help.wrap(_S(" directory within the selected directory with an initialized database index. ") help.wrap(_SYS_STR(" directory within the selected directory with an initialized database index. ")
_S("This constitutes an empty HECL project, ready for making stuff!!\n")); _SYS_STR("This constitutes an empty HECL project, ready for making stuff!!\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<dir>"), _S("group directory path")); help.optionHead(_SYS_STR("<dir>"), _SYS_STR("group directory path"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Directory to create new project database in. If not specified, current directory is used.\n")); help.wrap(_SYS_STR("Directory to create new project database in. If not specified, current directory is used.\n"));
help.endWrap(); help.endWrap();
} }
hecl::SystemString toolName() const {return _S("init");} hecl::SystemString toolName() const {return _SYS_STR("init");}
}; };

72
hecl/driver/ToolPackage.hpp
View File

@ -23,13 +23,13 @@ class ToolPackage final : public ToolBase
void CheckFile(const hecl::ProjectPath& path) void CheckFile(const hecl::ProjectPath& path)
{ {
if (!hecl::StrCmp(path.getLastComponent().data(), _S("!world.blend"))) if (!hecl::StrCmp(path.getLastComponent().data(), _SYS_STR("!world.blend")))
AddSelectedItem(path); AddSelectedItem(path);
#if RUNTIME_ORIGINAL_IDS #if RUNTIME_ORIGINAL_IDS
else if (!hecl::StrCmp(path.getLastComponent().data(), _S("!original_ids.yaml"))) else if (!hecl::StrCmp(path.getLastComponent().data(), _SYS_STR("!original_ids.yaml")))
{ {
auto pathComps = path.getPathComponents(); auto pathComps = path.getPathComponents();
if (pathComps.size() == 2 && pathComps[0] != _S("out")) if (pathComps.size() == 2 && pathComps[0] != _SYS_STR("out"))
AddSelectedItem(path); AddSelectedItem(path);
} }
#endif #endif
@ -60,8 +60,8 @@ class ToolPackage final : public ToolBase
if (checkGeneral && origSize == m_selectedItems.size()) if (checkGeneral && origSize == m_selectedItems.size())
{ {
auto pathComps = path.getPathComponents(); auto pathComps = path.getPathComponents();
if (pathComps.size() == 2 && pathComps[0] != _S("out") && if (pathComps.size() == 2 && pathComps[0] != _SYS_STR("out") &&
pathComps[1] != _S("Shared") && pathComps[0].find(_S(".app")) == hecl::SystemString::npos) pathComps[1] != _SYS_STR("Shared") && pathComps[0].find(_SYS_STR(".app")) == hecl::SystemString::npos)
AddSelectedItem(path); AddSelectedItem(path);
} }
} }
@ -82,12 +82,12 @@ public:
{ {
if (arg.empty()) if (arg.empty())
continue; continue;
else if (!arg.compare(_S("--fast"))) else if (!arg.compare(_SYS_STR("--fast")))
{ {
m_fast = true; m_fast = true;
continue; continue;
} }
else if (arg.size() >= 8 && !arg.compare(0, 7, _S("--spec="))) else if (arg.size() >= 8 && !arg.compare(0, 7, _SYS_STR("--spec=")))
{ {
hecl::SystemString specName(arg.begin() + 7, arg.end()); hecl::SystemString specName(arg.begin() + 7, arg.end());
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
@ -102,7 +102,7 @@ public:
LogModule.report(logvisor::Fatal, "unable to find data spec '%s'", specName.c_str()); LogModule.report(logvisor::Fatal, "unable to find data spec '%s'", specName.c_str());
continue; continue;
} }
else if (arg.size() >= 2 && arg[0] == _S('-') && arg[1] == _S('-')) else if (arg.size() >= 2 && arg[0] == _SYS_STR('-') && arg[1] == _SYS_STR('-'))
continue; continue;
hecl::SystemString subPath; hecl::SystemString subPath;
@ -117,8 +117,8 @@ public:
} }
else if (m_fallbackProj->getProjectRootPath() != root) else if (m_fallbackProj->getProjectRootPath() != root)
LogModule.report(logvisor::Fatal, LogModule.report(logvisor::Fatal,
_S("hecl package can only process multiple items in the same project; ") _SYS_STR("hecl package can only process multiple items in the same project; ")
_S("'%s' and '%s' are different projects"), _SYS_STR("'%s' and '%s' are different projects"),
m_fallbackProj->getProjectRootPath().getAbsolutePath().data(), m_fallbackProj->getProjectRootPath().getAbsolutePath().data(),
root.getAbsolutePath().data()); root.getAbsolutePath().data());
@ -133,64 +133,64 @@ public:
/* Default case: recursive at root */ /* Default case: recursive at root */
if (m_selectedItems.empty()) if (m_selectedItems.empty())
FindSelectedItems({*m_useProj, _S("")}, true); FindSelectedItems({*m_useProj, _SYS_STR("")}, true);
} }
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-pack\n") help.wrap(_SYS_STR("hecl-pack\n")
_S("hecl-package - Package objects within the project database\n")); _SYS_STR("hecl-package - Package objects within the project database\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl package [--spec=<spec>] [<input-dir>]\n")); help.wrap(_SYS_STR("hecl package [--spec=<spec>] [<input-dir>]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("This command initiates a packaging pass on the project database. Packaging ") help.wrap(_SYS_STR("This command initiates a packaging pass on the project database. Packaging ")
_S("is analogous to linking in software development. All objects necessary to ") _SYS_STR("is analogous to linking in software development. All objects necessary to ")
_S("generate a complete package are gathered, grouped, and indexed within a .upak file.\n")); _SYS_STR("generate a complete package are gathered, grouped, and indexed within a .upak file.\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("--spec=<spec>"), _S("data specification")); help.optionHead(_SYS_STR("--spec=<spec>"), _SYS_STR("data specification"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies a DataSpec to use when cooking and generating the package. ") help.wrap(_SYS_STR("Specifies a DataSpec to use when cooking and generating the package. ")
_S("This build of hecl supports the following values of <spec>:\n")); _SYS_STR("This build of hecl supports the following values of <spec>:\n"));
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
{ {
if (!spec->m_factory) if (!spec->m_factory)
continue; continue;
help.wrap(_S(" ")); help.wrap(_SYS_STR(" "));
help.wrapBold(spec->m_name.data()); help.wrapBold(spec->m_name.data());
help.wrap(_S("\n")); help.wrap(_SYS_STR("\n"));
} }
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<input-dir>"), _S("input directory")); help.optionHead(_SYS_STR("<input-dir>"), _SYS_STR("input directory"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies a project subdirectory to root the resulting package from. ") help.wrap(_SYS_STR("Specifies a project subdirectory to root the resulting package from. ")
_S("If any dependent files fall outside this subdirectory, they will be implicitly ") _SYS_STR("If any dependent files fall outside this subdirectory, they will be implicitly ")
_S("gathered and packaged.\n")); _SYS_STR("gathered and packaged.\n"));
help.endWrap(); help.endWrap();
} }
hecl::SystemString toolName() const {return _S("package");} hecl::SystemString toolName() const {return _SYS_STR("package");}
int run() int run()
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" GREEN BOLD "ABOUT TO PACKAGE:" NORMAL "\n")); hecl::Printf(_SYS_STR("" GREEN BOLD "ABOUT TO PACKAGE:" NORMAL "\n"));
else else
hecl::Printf(_S("ABOUT TO PACKAGE:\n")); hecl::Printf(_SYS_STR("ABOUT TO PACKAGE:\n"));
for (auto& item : m_selectedItems) for (auto& item : m_selectedItems)
hecl::Printf(_S(" %s\n"), item.getRelativePath().data()); hecl::Printf(_SYS_STR(" %s\n"), item.getRelativePath().data());
fflush(stdout); fflush(stdout);
if (continuePrompt()) if (continuePrompt())
@ -200,7 +200,7 @@ public:
for (const hecl::ProjectPath& path : m_selectedItems) for (const hecl::ProjectPath& path : m_selectedItems)
{ {
if (!m_useProj->packagePath(path, printer, m_fast, m_spec, &cp)) if (!m_useProj->packagePath(path, printer, m_fast, m_spec, &cp))
LogModule.report(logvisor::Error, _S("Unable to package %s"), path.getAbsolutePath().data()); LogModule.report(logvisor::Error, _SYS_STR("Unable to package %s"), path.getAbsolutePath().data());
} }
cp.waitUntilComplete(); cp.waitUntilComplete();
} }

46
hecl/driver/ToolSpec.hpp
View File

@ -27,9 +27,9 @@ public:
hecl::SystemString firstArg = info.args.front(); hecl::SystemString firstArg = info.args.front();
hecl::ToLower(firstArg); hecl::ToLower(firstArg);
if (!firstArg.compare(_S("enable"))) if (!firstArg.compare(_SYS_STR("enable")))
mode = MENABLE; mode = MENABLE;
else if (!firstArg.compare(_S("disable"))) else if (!firstArg.compare(_SYS_STR("disable")))
mode = MDISABLE; mode = MDISABLE;
else else
return; return;
@ -54,38 +54,38 @@ public:
} }
if (!found) if (!found)
LogModule.report(logvisor::Fatal, LogModule.report(logvisor::Fatal,
_S("'%s' is not found in the dataspec registry"), _SYS_STR("'%s' is not found in the dataspec registry"),
it->c_str()); it->c_str());
} }
} }
static void Help(HelpOutput& help) static void Help(HelpOutput& help)
{ {
help.secHead(_S("NAME")); help.secHead(_SYS_STR("NAME"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl-spec - Configure target data options\n")); help.wrap(_SYS_STR("hecl-spec - Configure target data options\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("SYNOPSIS")); help.secHead(_SYS_STR("SYNOPSIS"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("hecl spec [enable|disable] [<specname>...]\n")); help.wrap(_SYS_STR("hecl spec [enable|disable] [<specname>...]\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("DESCRIPTION")); help.secHead(_SYS_STR("DESCRIPTION"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("This command configures the HECL project with the user's preferred target DataSpecs.\n\n") help.wrap(_SYS_STR("This command configures the HECL project with the user's preferred target DataSpecs.\n\n")
_S("Providing enable/disable argument will bulk-set the enable status of the provided spec(s)") _SYS_STR("Providing enable/disable argument will bulk-set the enable status of the provided spec(s)")
_S("list. If enable/disable is not provided, a list of supported DataSpecs is printed.\n\n")); _SYS_STR("list. If enable/disable is not provided, a list of supported DataSpecs is printed.\n\n"));
help.endWrap(); help.endWrap();
help.secHead(_S("OPTIONS")); help.secHead(_SYS_STR("OPTIONS"));
help.optionHead(_S("<specname>..."), _S("DataSpec name(s)")); help.optionHead(_SYS_STR("<specname>..."), _SYS_STR("DataSpec name(s)"));
help.beginWrap(); help.beginWrap();
help.wrap(_S("Specifies platform-names to enable/disable")); help.wrap(_SYS_STR("Specifies platform-names to enable/disable"));
help.endWrap(); help.endWrap();
} }
hecl::SystemString toolName() const {return _S("spec");} hecl::SystemString toolName() const {return _SYS_STR("spec");}
int run() int run()
{ {
@ -94,10 +94,10 @@ public:
for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY) for (const hecl::Database::DataSpecEntry* spec : hecl::Database::DATA_SPEC_REGISTRY)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD CYAN "%s" NORMAL "\n"), spec->m_name.data()); hecl::Printf(_SYS_STR("" BOLD CYAN "%s" NORMAL "\n"), spec->m_name.data());
else else
hecl::Printf(_S("%s\n"), spec->m_name.data()); hecl::Printf(_SYS_STR("%s\n"), spec->m_name.data());
hecl::Printf(_S(" %s\n"), spec->m_desc.data()); hecl::Printf(_SYS_STR(" %s\n"), spec->m_desc.data());
} }
return 0; return 0;
} }
@ -108,17 +108,17 @@ public:
for (auto& spec : specs) for (auto& spec : specs)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD CYAN "%s" NORMAL ""), spec.spec.m_name.data()); hecl::Printf(_SYS_STR("" BOLD CYAN "%s" NORMAL ""), spec.spec.m_name.data());
else else
hecl::Printf(_S("%s"), spec.spec.m_name.data()); hecl::Printf(_SYS_STR("%s"), spec.spec.m_name.data());
if (spec.active) if (spec.active)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S(" " BOLD GREEN "[ENABLED]" NORMAL "")); hecl::Printf(_SYS_STR(" " BOLD GREEN "[ENABLED]" NORMAL ""));
else else
hecl::Printf(_S(" [ENABLED]")); hecl::Printf(_SYS_STR(" [ENABLED]"));
} }
hecl::Printf(_S("\n %s\n"), spec.spec.m_desc.data()); hecl::Printf(_SYS_STR("\n %s\n"), spec.spec.m_desc.data());
} }
return 0; return 0;
} }

56
hecl/driver/main.cpp
View File

@ -47,25 +47,25 @@ bool XTERM_COLOR = false;
static void printHelp(const hecl::SystemChar* pname) static void printHelp(const hecl::SystemChar* pname)
{ {
if (XTERM_COLOR) if (XTERM_COLOR)
hecl::Printf(_S("" BOLD "HECL" NORMAL "")); hecl::Printf(_SYS_STR("" BOLD "HECL" NORMAL ""));
else else
hecl::Printf(_S("HECL")); hecl::Printf(_SYS_STR("HECL"));
#if HECL_HAS_NOD #if HECL_HAS_NOD
# define TOOL_LIST "extract|init|cook|package|image|help" # define TOOL_LIST "extract|init|cook|package|image|help"
#else #else
# define TOOL_LIST "extract|init|cook|package|help" # define TOOL_LIST "extract|init|cook|package|help"
#endif #endif
#if HECL_GIT #if HECL_GIT
hecl::Printf(_S(" Commit " HECL_GIT_S " " HECL_BRANCH_S "\nUsage: %s " TOOL_LIST "\n"), pname); hecl::Printf(_SYS_STR(" Commit " HECL_GIT_S " " HECL_BRANCH_S "\nUsage: %s " TOOL_LIST "\n"), pname);
#elif HECL_VER #elif HECL_VER
hecl::Printf(_S(" Version " HECL_VER_S "\nUsage: %s " TOOL_LIST "\n"), pname); hecl::Printf(_SYS_STR(" Version " HECL_VER_S "\nUsage: %s " TOOL_LIST "\n"), pname);
#else #else
hecl::Printf(_S("\nUsage: %s " TOOL_LIST "\n"), pname); hecl::Printf(_SYS_STR("\nUsage: %s " TOOL_LIST "\n"), pname);
#endif #endif
} }
/* Regex patterns */ /* Regex patterns */
static const hecl::SystemRegex regOPEN(_S("-o([^\"]*|\\S*)"), std::regex::ECMAScript|std::regex::optimize); static const hecl::SystemRegex regOPEN(_SYS_STR("-o([^\"]*|\\S*)"), std::regex::ECMAScript|std::regex::optimize);
static ToolBase* ToolPtr = nullptr; static ToolBase* ToolPtr = nullptr;
@ -100,7 +100,7 @@ static void SIGWINCHHandler(int sig) {}
int main(int argc, const char** argv) int main(int argc, const char** argv)
#endif #endif
{ {
if (argc > 1 && !hecl::StrCmp(argv[1], _S("--dlpackage"))) if (argc > 1 && !hecl::StrCmp(argv[1], _SYS_STR("--dlpackage")))
{ {
printf("%s\n", HECL_DLPACKAGE); printf("%s\n", HECL_DLPACKAGE);
return 100; return 100;
@ -140,7 +140,7 @@ int main(int argc, const char** argv)
} }
else if (argc == 0) else if (argc == 0)
{ {
printHelp(_S("hecl")); printHelp(_SYS_STR("hecl"));
#if WIN_PAUSE #if WIN_PAUSE
system("PAUSE"); system("PAUSE");
#endif #endif
@ -156,17 +156,17 @@ int main(int argc, const char** argv)
if (hecl::Getcwd(cwdbuf, 1024)) if (hecl::Getcwd(cwdbuf, 1024))
{ {
info.cwd = cwdbuf; info.cwd = cwdbuf;
if (info.cwd.size() && info.cwd.back() != _S('/') && info.cwd.back() != _S('\\')) if (info.cwd.size() && info.cwd.back() != _SYS_STR('/') && info.cwd.back() != _SYS_STR('\\'))
#if _WIN32 #if _WIN32
info.cwd += _S('\\'); info.cwd += _SYS_STR('\\');
#else #else
info.cwd += _S('/'); info.cwd += _SYS_STR('/');
#endif #endif
if (hecl::PathRelative(argv[0])) if (hecl::PathRelative(argv[0]))
ExeDir = hecl::SystemString(cwdbuf) + _S('/'); ExeDir = hecl::SystemString(cwdbuf) + _SYS_STR('/');
hecl::SystemString Argv0(argv[0]); hecl::SystemString Argv0(argv[0]);
hecl::SystemString::size_type lastIdx = Argv0.find_last_of(_S("/\\")); hecl::SystemString::size_type lastIdx = Argv0.find_last_of(_SYS_STR("/\\"));
if (lastIdx != hecl::SystemString::npos) if (lastIdx != hecl::SystemString::npos)
ExeDir.insert(ExeDir.end(), Argv0.begin(), Argv0.begin() + lastIdx); ExeDir.insert(ExeDir.end(), Argv0.begin(), Argv0.begin() + lastIdx);
} }
@ -211,7 +211,7 @@ int main(int argc, const char** argv)
for (auto it = args.cbegin() ; it != args.cend() ;) for (auto it = args.cbegin() ; it != args.cend() ;)
{ {
const hecl::SystemString& arg = *it; const hecl::SystemString& arg = *it;
if (arg.size() < 2 || arg[0] != _S('-') || arg[1] == _S('-')) if (arg.size() < 2 || arg[0] != _SYS_STR('-') || arg[1] == _SYS_STR('-'))
{ {
++it; ++it;
continue; continue;
@ -219,13 +219,13 @@ int main(int argc, const char** argv)
for (auto chit = arg.cbegin() + 1 ; chit != arg.cend() ; ++chit) for (auto chit = arg.cbegin() + 1 ; chit != arg.cend() ; ++chit)
{ {
if (*chit == _S('v')) if (*chit == _SYS_STR('v'))
++info.verbosityLevel; ++info.verbosityLevel;
else if (*chit == _S('f')) else if (*chit == _SYS_STR('f'))
info.force = true; info.force = true;
else if (*chit == _S('y')) else if (*chit == _SYS_STR('y'))
info.yes = true; info.yes = true;
else if (*chit == _S('g')) else if (*chit == _SYS_STR('g'))
info.gui = true; info.gui = true;
else else
info.flags.push_back(*chit); info.flags.push_back(*chit);
@ -265,27 +265,27 @@ int main(int argc, const char** argv)
std::unique_ptr<ToolBase> tool; std::unique_ptr<ToolBase> tool;
size_t ErrorRef = logvisor::ErrorCount; size_t ErrorRef = logvisor::ErrorCount;
if (toolName == _S("init")) if (toolName == _SYS_STR("init"))
tool.reset(new ToolInit(info)); tool.reset(new ToolInit(info));
else if (toolName == _S("spec")) else if (toolName == _SYS_STR("spec"))
tool.reset(new ToolSpec(info)); tool.reset(new ToolSpec(info));
else if (toolName == _S("extract")) else if (toolName == _SYS_STR("extract"))
tool.reset(new ToolExtract(info)); tool.reset(new ToolExtract(info));
else if (toolName == _S("cook")) else if (toolName == _SYS_STR("cook"))
tool.reset(new ToolCook(info)); tool.reset(new ToolCook(info));
else if (toolName == _S("package") || toolName == _S("pack")) else if (toolName == _SYS_STR("package") || toolName == _SYS_STR("pack"))
tool.reset(new ToolPackage(info)); tool.reset(new ToolPackage(info));
#if HECL_HAS_NOD #if HECL_HAS_NOD
else if (toolName == _S("image")) else if (toolName == _SYS_STR("image"))
tool.reset(new ToolImage(info)); tool.reset(new ToolImage(info));
#endif #endif
else if (toolName == _S("help")) else if (toolName == _SYS_STR("help"))
tool.reset(new ToolHelp(info)); tool.reset(new ToolHelp(info));
else else
{ {
FILE* fp = hecl::Fopen(argv[1], _S("rb")); FILE* fp = hecl::Fopen(argv[1], _SYS_STR("rb"));
if (!fp) if (!fp)
LogModule.report(logvisor::Error, _S("unrecognized tool '%s'"), toolName.c_str()); LogModule.report(logvisor::Error, _SYS_STR("unrecognized tool '%s'"), toolName.c_str());
else else
{ {
/* Shortcut-case: implicit extract */ /* Shortcut-case: implicit extract */
@ -304,7 +304,7 @@ int main(int argc, const char** argv)
} }
if (info.verbosityLevel) if (info.verbosityLevel)
LogModule.report(logvisor::Info, _S("Constructed tool '%s' %d\n"), LogModule.report(logvisor::Info, _SYS_STR("Constructed tool '%s' %d\n"),
tool->toolName().c_str(), info.verbosityLevel); tool->toolName().c_str(), info.verbosityLevel);
/* Run tool */ /* Run tool */

2
hecl/extern/boo vendored

@ -1 +1 @@
Subproject commit f917d154b2ff38a5cbeea8c536c91e7813be060d Subproject commit 592ffa1372a363cc8a5a3c64fee5f4b1f76eb079

23
hecl/include/hecl/ApplicationReps.hpp.in
View File

@ -12,24 +12,5 @@ T<P, hecl::PipelineStage::Evaluation>,
#define HECL_APPLICATION_PIPELINE_REPS_UNIVERSAL \ #define HECL_APPLICATION_PIPELINE_REPS_UNIVERSAL \
@HECL_APPLICATION_PIPELINE_REPS_UNIVERSAL_LOCAL@ @HECL_APPLICATION_PIPELINE_REPS_UNIVERSAL_LOCAL@
#define HECL_APPLICATION_PIPELINE_REPS_OPENGL \ #define HECL_APPLICATION_STAGE_REPS(P, S) \
@HECL_APPLICATION_PIPELINE_REPS_OPENGL_LOCAL@ @HECL_APPLICATION_STAGE_REPS_LOCAL@
#define HECL_APPLICATION_PIPELINE_REPS_VULKAN \
@HECL_APPLICATION_PIPELINE_REPS_VULKAN_LOCAL@
#define HECL_APPLICATION_PIPELINE_REPS_D3D11 \
@HECL_APPLICATION_PIPELINE_REPS_D3D11_LOCAL@
#define HECL_APPLICATION_PIPELINE_REPS_METAL \
@HECL_APPLICATION_PIPELINE_REPS_METAL_LOCAL@
#define HECL_APPLICATION_PIPELINE_REPS_NX \
@HECL_APPLICATION_PIPELINE_REPS_NX_LOCAL@
#define HECL_APPLICATION_STAGE_REPS_OPENGL \
@HECL_APPLICATION_STAGE_REPS_OPENGL_LOCAL@
#define HECL_APPLICATION_STAGE_REPS_VULKAN \
@HECL_APPLICATION_STAGE_REPS_VULKAN_LOCAL@
#define HECL_APPLICATION_STAGE_REPS_D3D11 \
@HECL_APPLICATION_STAGE_REPS_D3D11_LOCAL@
#define HECL_APPLICATION_STAGE_REPS_METAL \
@HECL_APPLICATION_STAGE_REPS_METAL_LOCAL@
#define HECL_APPLICATION_STAGE_REPS_NX \
@HECL_APPLICATION_STAGE_REPS_NX_LOCAL@

13
hecl/include/hecl/Compilers.hpp
View File

@ -17,48 +17,37 @@ struct OpenGL { static constexpr PlatformEnum Enum = PlatformEnum::OpenGL; stati
using Context = boo::GLDataFactory::Context; using Context = boo::GLDataFactory::Context;
#endif #endif
}; };
inline const char* OpenGL::Name = "OpenGL";
struct D3D11 { static constexpr PlatformEnum Enum = PlatformEnum::D3D11; static const char* Name; struct D3D11 { static constexpr PlatformEnum Enum = PlatformEnum::D3D11; static const char* Name;
#if _WIN32 #if _WIN32
using Context = boo::D3DDataFactory::Context; using Context = boo::D3D11DataFactory::Context;
#endif #endif
}; };
inline const char* D3D11::Name = "D3D11";
struct Metal { static constexpr PlatformEnum Enum = PlatformEnum::Metal; static const char* Name; struct Metal { static constexpr PlatformEnum Enum = PlatformEnum::Metal; static const char* Name;
#if BOO_HAS_METAL #if BOO_HAS_METAL
using Context = boo::MetalDataFactory::Context; using Context = boo::MetalDataFactory::Context;
#endif #endif
}; };
inline const char* Metal::Name = "Metal";
struct Vulkan { static constexpr PlatformEnum Enum = PlatformEnum::Vulkan; static const char* Name; struct Vulkan { static constexpr PlatformEnum Enum = PlatformEnum::Vulkan; static const char* Name;
#if BOO_HAS_VULKAN #if BOO_HAS_VULKAN
using Context = boo::VulkanDataFactory::Context; using Context = boo::VulkanDataFactory::Context;
#endif #endif
}; };
inline const char* Vulkan::Name = "Vulkan";
struct NX { static constexpr PlatformEnum Enum = PlatformEnum::NX; static const char* Name; struct NX { static constexpr PlatformEnum Enum = PlatformEnum::NX; static const char* Name;
#if BOO_HAS_NX #if BOO_HAS_NX
using Context = boo::NXDataFactory::Context; using Context = boo::NXDataFactory::Context;
#endif #endif
}; };
inline const char* NX::Name = "NX";
} }
namespace PipelineStage namespace PipelineStage
{ {
using StageEnum = boo::PipelineStage; using StageEnum = boo::PipelineStage;
struct Null { static constexpr StageEnum Enum = StageEnum::Null; static const char* Name; }; struct Null { static constexpr StageEnum Enum = StageEnum::Null; static const char* Name; };
inline const char* Null::Name = "Null";
struct Vertex { static constexpr StageEnum Enum = StageEnum::Vertex; static const char* Name; }; struct Vertex { static constexpr StageEnum Enum = StageEnum::Vertex; static const char* Name; };
inline const char* Vertex::Name = "Vertex";
struct Fragment { static constexpr StageEnum Enum = StageEnum::Fragment; static const char* Name; }; struct Fragment { static constexpr StageEnum Enum = StageEnum::Fragment; static const char* Name; };
inline const char* Fragment::Name = "Fragment";
struct Geometry { static constexpr StageEnum Enum = StageEnum::Geometry; static const char* Name; }; struct Geometry { static constexpr StageEnum Enum = StageEnum::Geometry; static const char* Name; };
inline const char* Geometry::Name = "Geometry";
struct Control { static constexpr StageEnum Enum = StageEnum::Control; static const char* Name; }; struct Control { static constexpr StageEnum Enum = StageEnum::Control; static const char* Name; };
inline const char* Control::Name = "Control";
struct Evaluation { static constexpr StageEnum Enum = StageEnum::Evaluation; static const char* Name; }; struct Evaluation { static constexpr StageEnum Enum = StageEnum::Evaluation; static const char* Name; };
inline const char* Evaluation::Name = "Evaluation";
} }
template<typename P, typename S> template<typename P, typename S>

2
hecl/include/hecl/Database.hpp
View File

@ -282,7 +282,7 @@ public:
FILE* m_lockedFile = NULL; FILE* m_lockedFile = NULL;
public: public:
ConfigFile(const Project& project, SystemStringView name, ConfigFile(const Project& project, SystemStringView name,
SystemStringView subdir=_S("/.hecl/")); SystemStringView subdir=_SYS_STR("/.hecl/"));
std::vector<std::string>& lockAndRead(); std::vector<std::string>& lockAndRead();
void addLine(std::string_view line); void addLine(std::string_view line);
void removeLine(std::string_view refLine); void removeLine(std::string_view refLine);

169
hecl/include/hecl/Pipeline.hpp
View File

@ -160,72 +160,125 @@ public:
}; };
#endif #endif
#define STAGE_COLLECTION_SPECIALIZATIONS(T, P) StageCollection<T<P, PipelineStage::Null>>,
template<typename... Args> struct pack {}; template<typename... Args> struct pack {};
struct null_t {}; struct null_t {};
template<typename P> struct TypeDB {}; template<typename P> struct ShaderDB {};
template<> struct TypeDB<PlatformType::OpenGL>
{ #define STAGE_COLLECTION_SPECIALIZATIONS(T, P) StageCollection<T<P, PipelineStage::Null>>,
using PipelineTypes = pack< #define PIPELINE_RUNTIME_SPECIALIZATIONS(P) \
HECLBackend<P>, \
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, P) \
STAGE_COLLECTION_SPECIALIZATIONS(StageBinary, P) \
STAGE_COLLECTION_SPECIALIZATIONS(StageRuntimeObject, P) \
FinalPipeline<P>,
#define PIPELINE_OFFLINE_SPECIALIZATIONS(P) \
HECLBackend<P>, \
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, P)
#define STAGE_RUNTIME_SPECIALIZATIONS(P, S) \
StageBinary<P, S>, \
HECL_APPLICATION_STAGE_REPS(P, S) \
StageRuntimeObject<P, S>,
#define STAGE_OFFLINE_SPECIALIZATIONS(P, S) \
HECL_APPLICATION_STAGE_REPS(P, S)
#define SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, S) \
template<> struct ShaderDB<P>::StageDB<S> \
{ \
using StageTypes = pack< \
STAGE_RUNTIME_SPECIALIZATIONS(P, S) \
null_t \
>; \
};
#define SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, S) \
template<> struct ShaderDB<P>::StageDB<S> \
{ \
using StageTypes = pack< \
null_t \
>; \
};
#define SPECIALIZE_OFFLINE_STAGE(P, S) \
template<> struct ShaderDB<P>::StageDB<S> \
{ \
using StageTypes = pack< \
STAGE_OFFLINE_SPECIALIZATIONS(P, S) \
null_t \
>; \
};
#define SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(P) \
template<> struct ShaderDB<P> \
{ \
using PipelineTypes = pack< \
PIPELINE_RUNTIME_SPECIALIZATIONS(P) \
null_t \
>; \
template<typename S> struct StageDB {}; \
}; \
SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, hecl::PipelineStage::Vertex) \
SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, hecl::PipelineStage::Fragment) \
SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, hecl::PipelineStage::Geometry) \
SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, hecl::PipelineStage::Control) \
SPECIALIZE_RUNTIME_AVAILABLE_STAGE(P, hecl::PipelineStage::Evaluation)
#define SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(P) \
template<> struct ShaderDB<P> \
{ \
using PipelineTypes = pack< \
null_t \
>; \
template<typename S> struct StageDB {}; \
}; \
SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, hecl::PipelineStage::Vertex) \
SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, hecl::PipelineStage::Fragment) \
SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, hecl::PipelineStage::Geometry) \
SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, hecl::PipelineStage::Control) \
SPECIALIZE_RUNTIME_UNAVAILABLE_STAGE(P, hecl::PipelineStage::Evaluation)
#define SPECIALIZE_OFFLINE_PLATFORM(P) \
template<> struct ShaderDB<P> \
{ \
using PipelineTypes = pack< \
PIPELINE_OFFLINE_SPECIALIZATIONS(P) \
null_t \
>; \
template<typename S> struct StageDB {}; \
}; \
SPECIALIZE_OFFLINE_STAGE(P, hecl::PipelineStage::Vertex) \
SPECIALIZE_OFFLINE_STAGE(P, hecl::PipelineStage::Fragment) \
SPECIALIZE_OFFLINE_STAGE(P, hecl::PipelineStage::Geometry) \
SPECIALIZE_OFFLINE_STAGE(P, hecl::PipelineStage::Control) \
SPECIALIZE_OFFLINE_STAGE(P, hecl::PipelineStage::Evaluation)
#if HECL_RUNTIME #if HECL_RUNTIME
#if BOO_HAS_GL #if BOO_HAS_GL
HECLBackend<PlatformType::OpenGL>, SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(hecl::PlatformType::OpenGL)
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, PlatformType::OpenGL)
STAGE_COLLECTION_SPECIALIZATIONS(StageBinary, PlatformType::OpenGL)
STAGE_COLLECTION_SPECIALIZATIONS(StageRuntimeObject, PlatformType::OpenGL)
FinalPipeline<PlatformType::OpenGL>,
#endif
#else #else
HECLBackend<PlatformType::OpenGL>, SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(hecl::PlatformType::OpenGL)
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, PlatformType::OpenGL)
#endif #endif
null_t
>;
using StageTypes = pack<
#if HECL_RUNTIME
#if BOO_HAS_GL
STAGE_SPECIALIZATIONS(StageBinary, PlatformType::OpenGL)
HECL_APPLICATION_STAGE_REPS_OPENGL
STAGE_SPECIALIZATIONS(StageRuntimeObject, PlatformType::OpenGL)
#endif
#else
HECL_APPLICATION_STAGE_REPS_OPENGL
#endif
null_t
>;
};
template<> struct TypeDB<PlatformType::Vulkan>
{
using PipelineTypes = pack<
#if HECL_RUNTIME
#if BOO_HAS_VULKAN #if BOO_HAS_VULKAN
HECLBackend<PlatformType::Vulkan>, SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(hecl::PlatformType::Vulkan)
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, PlatformType::Vulkan) #else
STAGE_COLLECTION_SPECIALIZATIONS(StageBinary, PlatformType::Vulkan) SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(hecl::PlatformType::Vulkan)
STAGE_COLLECTION_SPECIALIZATIONS(StageRuntimeObject, PlatformType::Vulkan) #endif
FinalPipeline<PlatformType::Vulkan>, #if _WIN32
SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(hecl::PlatformType::D3D11)
#else
SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(hecl::PlatformType::D3D11)
#endif
#if BOO_HAS_METAL
SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(hecl::PlatformType::Metal)
#else
SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(hecl::PlatformType::Metal)
#endif
#if BOO_HAS_NX
SPECIALIZE_RUNTIME_AVAILABLE_PLATFORM(hecl::PlatformType::NX)
#else
SPECIALIZE_RUNTIME_UNAVAILABLE_PLATFORM(hecl::PlatformType::NX)
#endif #endif
#else #else
HECLBackend<PlatformType::Vulkan>, SPECIALIZE_OFFLINE_PLATFORM(hecl::PlatformType::OpenGL)
STAGE_COLLECTION_SPECIALIZATIONS(StageSourceText, PlatformType::Vulkan) SPECIALIZE_OFFLINE_PLATFORM(hecl::PlatformType::Vulkan)
STAGE_COLLECTION_SPECIALIZATIONS(StageBinary, PlatformType::Vulkan) SPECIALIZE_OFFLINE_PLATFORM(hecl::PlatformType::D3D11)
SPECIALIZE_OFFLINE_PLATFORM(hecl::PlatformType::Metal)
SPECIALIZE_OFFLINE_PLATFORM(hecl::PlatformType::NX)
#endif #endif
null_t
>;
using StageTypes = pack<
#if HECL_RUNTIME
#if BOO_HAS_VULKAN
STAGE_SPECIALIZATIONS(StageBinary, PlatformType::Vulkan)
HECL_APPLICATION_STAGE_REPS_VULKAN
STAGE_SPECIALIZATIONS(StageRuntimeObject, PlatformType::Vulkan)
#endif
#else
HECL_APPLICATION_STAGE_REPS_VULKAN
#endif
null_t
>;
};
class ShaderCacheZipStream; class ShaderCacheZipStream;
@ -293,7 +346,7 @@ class StageConverter
} }
#endif #endif
using StageTypes = typename TypeDB<P>::StageTypes; using StageTypes = typename ShaderDB<P>::template StageDB<S>::StageTypes;
template <typename ToTp, typename FromTp> template <typename ToTp, typename FromTp>
static constexpr bool is_stage_constructible_v = static constexpr bool is_stage_constructible_v =
@ -427,7 +480,7 @@ class PipelineConverter : public PipelineConverterBase
StageConverter<P, PipelineStage::Control> m_controlConverter; StageConverter<P, PipelineStage::Control> m_controlConverter;
StageConverter<P, PipelineStage::Evaluation> m_evaluationConverter; StageConverter<P, PipelineStage::Evaluation> m_evaluationConverter;
using PipelineTypes = typename TypeDB<P>::PipelineTypes; using PipelineTypes = typename ShaderDB<P>::PipelineTypes;
template <typename ToTp, typename FromTp> template <typename ToTp, typename FromTp>
static constexpr bool is_pipeline_constructible_v = static constexpr bool is_pipeline_constructible_v =

3
hecl/include/hecl/PipelineBase.hpp
View File

@ -189,6 +189,7 @@ public:
} }
#if 0
#define _STAGEOBJECT_PROTOTYPE_DECLARATIONS(T, P) \ #define _STAGEOBJECT_PROTOTYPE_DECLARATIONS(T, P) \
template <> const hecl::StageBinary<P, hecl::PipelineStage::Vertex> \ template <> const hecl::StageBinary<P, hecl::PipelineStage::Vertex> \
T<P, hecl::PipelineStage::Vertex>::Prototype; \ T<P, hecl::PipelineStage::Vertex>::Prototype; \
@ -200,6 +201,8 @@ template <> const hecl::StageBinary<P, hecl::PipelineStage::Control> \
T<P, hecl::PipelineStage::Control>::Prototype; \ T<P, hecl::PipelineStage::Control>::Prototype; \
template <> const hecl::StageBinary<P, hecl::PipelineStage::Evaluation> \ template <> const hecl::StageBinary<P, hecl::PipelineStage::Evaluation> \
T<P, hecl::PipelineStage::Evaluation>::Prototype; T<P, hecl::PipelineStage::Evaluation>::Prototype;
#endif
#define _STAGEOBJECT_PROTOTYPE_DECLARATIONS(T, P)
#define STAGEOBJECT_PROTOTYPE_DECLARATIONS(T) \ #define STAGEOBJECT_PROTOTYPE_DECLARATIONS(T) \
_STAGEOBJECT_PROTOTYPE_DECLARATIONS(T, hecl::PlatformType::OpenGL) \ _STAGEOBJECT_PROTOTYPE_DECLARATIONS(T, hecl::PlatformType::OpenGL) \

8
hecl/include/hecl/SystemChar.hpp
View File

@ -34,8 +34,8 @@ static inline void ToLower(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), towlower);} {std::transform(str.begin(), str.end(), str.begin(), towlower);}
static inline void ToUpper(SystemString& str) static inline void ToUpper(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), towupper);} {std::transform(str.begin(), str.end(), str.begin(), towupper);}
#ifndef _S #ifndef _SYS_STR
#define _S(val) L ## val #define _SYS_STR(val) L ## val
#endif #endif
#ifndef FMT_CSTR_SYS #ifndef FMT_CSTR_SYS
#define FMT_CSTR_SYS "S" #define FMT_CSTR_SYS "S"
@ -50,8 +50,8 @@ static inline void ToLower(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), tolower);} {std::transform(str.begin(), str.end(), str.begin(), tolower);}
static inline void ToUpper(SystemString& str) static inline void ToUpper(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), toupper);} {std::transform(str.begin(), str.end(), str.begin(), toupper);}
#ifndef _S #ifndef _SYS_STR
#define _S(val) val #define _SYS_STR(val) val
#endif #endif
#ifndef FMT_CSTR_SYS #ifndef FMT_CSTR_SYS
#define FMT_CSTR_SYS "s" #define FMT_CSTR_SYS "s"

48
hecl/include/hecl/hecl.hpp
View File

@ -206,7 +206,7 @@ static inline void MakeDir(const wchar_t* dir)
HRESULT err; HRESULT err;
if (!CreateDirectoryW(dir, NULL)) if (!CreateDirectoryW(dir, NULL))
if ((err = GetLastError()) != ERROR_ALREADY_EXISTS) if ((err = GetLastError()) != ERROR_ALREADY_EXISTS)
LogModule.report(logvisor::Fatal, _S("MakeDir(%s)"), dir); LogModule.report(logvisor::Fatal, _SYS_STR("MakeDir(%s)"), dir);
} }
#endif #endif
@ -239,12 +239,12 @@ SystemString GetcwdStr();
static inline bool IsAbsolute(SystemStringView path) static inline bool IsAbsolute(SystemStringView path)
{ {
#if _WIN32 #if _WIN32
if (path.size() && (path[0] == _S('\\') || path[0] == _S('/'))) if (path.size() && (path[0] == _SYS_STR('\\') || path[0] == _SYS_STR('/')))
return true; return true;
if (path.size() >= 2 && iswalpha(path[0]) && path[1] == _S(':')) if (path.size() >= 2 && iswalpha(path[0]) && path[1] == _SYS_STR(':'))
return true; return true;
#else #else
if (path.size() && path[0] == _S('/')) if (path.size() && path[0] == _SYS_STR('/'))
return true; return true;
#endif #endif
return false; return false;
@ -447,11 +447,11 @@ static inline bool CheckFreeSpace(const SystemChar* path, size_t reqSz)
wchar_t* end; wchar_t* end;
DWORD ret = GetFullPathNameW(path, 1024, buf, &end); DWORD ret = GetFullPathNameW(path, 1024, buf, &end);
if (!ret || ret > 1024) if (!ret || ret > 1024)
LogModule.report(logvisor::Fatal, _S("GetFullPathNameW %s"), path); LogModule.report(logvisor::Fatal, _SYS_STR("GetFullPathNameW %s"), path);
if (end) if (end)
end[0] = L'\0'; end[0] = L'\0';
if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr)) if (!GetDiskFreeSpaceExW(buf, &freeBytes, nullptr, nullptr))
LogModule.report(logvisor::Fatal, _S("GetDiskFreeSpaceExW %s: %d"), path, GetLastError()); LogModule.report(logvisor::Fatal, _SYS_STR("GetDiskFreeSpaceExW %s: %d"), path, GetLastError());
return reqSz < freeBytes.QuadPart; return reqSz < freeBytes.QuadPart;
#else #else
struct statvfs svfs; struct statvfs svfs;
@ -682,12 +682,12 @@ public:
{ {
SystemString absPathForward(absPath); SystemString absPathForward(absPath);
for (SystemChar& ch : absPathForward) for (SystemChar& ch : absPathForward)
if (ch == _S('\\')) if (ch == _SYS_STR('\\'))
ch = _S('/'); ch = _SYS_STR('/');
if (!absPathForward.compare(0, m_projRoot.size(), m_projRoot)) if (!absPathForward.compare(0, m_projRoot.size(), m_projRoot))
{ {
auto beginIt = absPathForward.cbegin() + m_projRoot.size(); auto beginIt = absPathForward.cbegin() + m_projRoot.size();
while (*beginIt == _S('/')) while (*beginIt == _SYS_STR('/'))
++beginIt; ++beginIt;
return SystemString(beginIt, absPathForward.cend()); return SystemString(beginIt, absPathForward.cend());
} }
@ -719,7 +719,7 @@ public:
*/ */
SystemStringView getLastComponent() const SystemStringView getLastComponent() const
{ {
size_t pos = m_projRoot.rfind(_S('/')); size_t pos = m_projRoot.rfind(_SYS_STR('/'));
if (pos == SystemString::npos) if (pos == SystemString::npos)
return {}; return {};
return {m_projRoot.c_str() + pos + 1, size_t(m_projRoot.size() - pos - 1)}; return {m_projRoot.c_str() + pos + 1, size_t(m_projRoot.size() - pos - 1)};
@ -850,7 +850,7 @@ public:
{ {
if (m_relPath.size()) if (m_relPath.size())
return m_relPath; return m_relPath;
static const SystemString dot = _S("."); static const SystemString dot = _SYS_STR(".");
return dot; return dot;
} }
@ -869,11 +869,11 @@ public:
*/ */
ProjectPath getParentPath() const ProjectPath getParentPath() const
{ {
if (m_relPath == _S(".")) if (m_relPath == _SYS_STR("."))
LogModule.report(logvisor::Fatal, "attempted to resolve parent of root project path"); LogModule.report(logvisor::Fatal, "attempted to resolve parent of root project path");
size_t pos = m_relPath.rfind(_S('/')); size_t pos = m_relPath.rfind(_SYS_STR('/'));
if (pos == SystemString::npos) if (pos == SystemString::npos)
return ProjectPath(*m_proj, _S("")); return ProjectPath(*m_proj, _SYS_STR(""));
return ProjectPath(*m_proj, SystemString(m_relPath.begin(), m_relPath.begin() + pos)); return ProjectPath(*m_proj, SystemString(m_relPath.begin(), m_relPath.begin() + pos));
} }
@ -883,14 +883,14 @@ public:
*/ */
SystemStringView getLastComponent() const SystemStringView getLastComponent() const
{ {
size_t pos = m_relPath.rfind(_S('/')); size_t pos = m_relPath.rfind(_SYS_STR('/'));
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_relPath; return m_relPath;
return {m_relPath.c_str() + pos + 1, m_relPath.size() - pos - 1}; return {m_relPath.c_str() + pos + 1, m_relPath.size() - pos - 1};
} }
std::string_view getLastComponentUTF8() const std::string_view getLastComponentUTF8() const
{ {
size_t pos = m_relPath.rfind(_S('/')); size_t pos = m_relPath.rfind(_SYS_STR('/'));
#if HECL_UCS2 #if HECL_UCS2
if (pos == SystemString::npos) if (pos == SystemString::npos)
return m_utf8RelPath; return m_utf8RelPath;
@ -913,7 +913,7 @@ public:
const SystemChar* lastComp = end; const SystemChar* lastComp = end;
while (lastComp != lastCompOrig.data()) while (lastComp != lastCompOrig.data())
{ {
if (*lastComp == _S('.')) if (*lastComp == _SYS_STR('.'))
return {lastComp + 1, size_t(end - lastComp - 1)}; return {lastComp + 1, size_t(end - lastComp - 1)};
--lastComp; --lastComp;
} }
@ -930,15 +930,15 @@ public:
if (m_relPath.empty()) if (m_relPath.empty())
return ret; return ret;
auto it = m_relPath.cbegin(); auto it = m_relPath.cbegin();
if (*it == _S('/')) if (*it == _SYS_STR('/'))
{ {
ret.push_back(_S("/")); ret.push_back(_SYS_STR("/"));
++it; ++it;
} }
hecl::SystemString comp; hecl::SystemString comp;
for (; it != m_relPath.cend() ; ++it) for (; it != m_relPath.cend() ; ++it)
{ {
if (*it == _S('/')) if (*it == _SYS_STR('/'))
{ {
if (comp.empty()) if (comp.empty())
continue; continue;
@ -1036,13 +1036,13 @@ public:
if (auxStr.empty()) if (auxStr.empty())
return ProjectPath(getProject(), getRelativePath()); return ProjectPath(getProject(), getRelativePath());
else else
return ProjectPath(getProject(), SystemString(getRelativePath()) + _S('|') + auxStr.data()); return ProjectPath(getProject(), SystemString(getRelativePath()) + _SYS_STR('|') + auxStr.data());
} }
#if HECL_UCS2 #if HECL_UCS2
ProjectPath ensureAuxInfo(std::string_view auxStr) const ProjectPath ensureAuxInfo(std::string_view auxStr) const
{ {
return ProjectPath(getProject(), SystemString(getRelativePath()) + _S('|') + UTF8ToWide(auxStr)); return ProjectPath(getProject(), SystemString(getRelativePath()) + _SYS_STR('|') + UTF8ToWide(auxStr));
} }
#endif #endif
@ -1135,7 +1135,7 @@ public:
{ {
size_t count = 0; size_t count = 0;
for (SystemChar ch : m_relPath) for (SystemChar ch : m_relPath)
if (ch == _S('/') || ch == _S('\\')) if (ch == _SYS_STR('/') || ch == _SYS_STR('\\'))
++count; ++count;
return count; return count;
} }
@ -1159,7 +1159,7 @@ public:
auto end = comps.cend(); auto end = comps.cend();
if (end != comps.cbegin() && !includeLastComp) if (end != comps.cbegin() && !includeLastComp)
--end; --end;
ProjectPath compPath(*m_proj, _S(".")); ProjectPath compPath(*m_proj, _SYS_STR("."));
for (auto it=comps.cbegin() ; it != end ; ++it) for (auto it=comps.cbegin() ; it != end ; ++it)
{ {
compPath = ProjectPath(compPath, *it); compPath = ProjectPath(compPath, *it);

80
hecl/lib/Blender/Connection.cpp
View File

@ -63,18 +63,18 @@ extern "C" size_t HECL_STARTUP_SZ;
static void InstallBlendershell(const SystemChar* path) static void InstallBlendershell(const SystemChar* path)
{ {
FILE* fp = hecl::Fopen(path, _S("w")); FILE* fp = hecl::Fopen(path, _SYS_STR("w"));
if (!fp) if (!fp)
BlenderLog.report(logvisor::Fatal, _S("unable to open %s for writing"), path); BlenderLog.report(logvisor::Fatal, _SYS_STR("unable to open %s for writing"), path);
fwrite(HECL_BLENDERSHELL, 1, HECL_BLENDERSHELL_SZ, fp); fwrite(HECL_BLENDERSHELL, 1, HECL_BLENDERSHELL_SZ, fp);
fclose(fp); fclose(fp);
} }
static void InstallAddon(const SystemChar* path) static void InstallAddon(const SystemChar* path)
{ {
FILE* fp = hecl::Fopen(path, _S("wb")); FILE* fp = hecl::Fopen(path, _SYS_STR("wb"));
if (!fp) if (!fp)
BlenderLog.report(logvisor::Fatal, _S("Unable to install blender addon at '%s'"), path); BlenderLog.report(logvisor::Fatal, _SYS_STR("Unable to install blender addon at '%s'"), path);
fwrite(HECL_ADDON, 1, HECL_ADDON_SZ, fp); fwrite(HECL_ADDON, 1, HECL_ADDON_SZ, fp);
fclose(fp); fclose(fp);
} }
@ -235,7 +235,7 @@ void Connection::_closePipe()
void Connection::_blenderDied() void Connection::_blenderDied()
{ {
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
FILE* errFp = hecl::Fopen(m_errPath.c_str(), _S("r")); FILE* errFp = hecl::Fopen(m_errPath.c_str(), _SYS_STR("r"));
if (errFp) if (errFp)
{ {
fseek(errFp, 0, SEEK_END); fseek(errFp, 0, SEEK_END);
@ -278,10 +278,10 @@ Connection::Connection(int verbosityLevel)
#endif #endif
hecl::SystemString blenderShellPath(TMPDIR); hecl::SystemString blenderShellPath(TMPDIR);
blenderShellPath += _S("/hecl_blendershell.py"); blenderShellPath += _SYS_STR("/hecl_blendershell.py");
hecl::SystemString blenderAddonPath(TMPDIR); hecl::SystemString blenderAddonPath(TMPDIR);
blenderAddonPath += _S("/hecl_blenderaddon.zip"); blenderAddonPath += _SYS_STR("/hecl_blenderaddon.zip");
m_startupBlend += "/hecl_startup.blend"; m_startupBlend += "/hecl_startup.blend";
bool FalseCmp = false; bool FalseCmp = false;
@ -344,10 +344,10 @@ Connection::Connection(int verbosityLevel)
if (!blenderBin || !RegFileExists(blenderBin)) if (!blenderBin || !RegFileExists(blenderBin))
{ {
/* Environment not set; try steam */ /* Environment not set; try steam */
steamBlender = hecl::FindCommonSteamApp(_S("Blender")); steamBlender = hecl::FindCommonSteamApp(_SYS_STR("Blender"));
if (steamBlender.size()) if (steamBlender.size())
{ {
steamBlender += _S("\\blender.exe"); steamBlender += _SYS_STR("\\blender.exe");
blenderBin = steamBlender.c_str(); blenderBin = steamBlender.c_str();
} }
@ -469,7 +469,7 @@ Connection::Connection(int verbosityLevel)
} }
/* Try steam */ /* Try steam */
steamBlender = hecl::FindCommonSteamApp(_S("Blender")); steamBlender = hecl::FindCommonSteamApp(_SYS_STR("Blender"));
if (steamBlender.size()) if (steamBlender.size())
{ {
#ifdef __APPLE__ #ifdef __APPLE__
@ -511,10 +511,10 @@ Connection::Connection(int verbosityLevel)
/* Stash error path and unlink existing file */ /* Stash error path and unlink existing file */
#if _WIN32 #if _WIN32
m_errPath = hecl::SystemString(TMPDIR) + hecl::SysFormat(_S("/hecl_%016llX.derp"), m_errPath = hecl::SystemString(TMPDIR) + hecl::SysFormat(_SYS_STR("/hecl_%016llX.derp"),
(unsigned long long)m_pinfo.dwProcessId); (unsigned long long)m_pinfo.dwProcessId);
#else #else
m_errPath = hecl::SystemString(TMPDIR) + hecl::SysFormat(_S("/hecl_%016llX.derp"), m_errPath = hecl::SystemString(TMPDIR) + hecl::SysFormat(_SYS_STR("/hecl_%016llX.derp"),
(unsigned long long)m_blenderProc); (unsigned long long)m_blenderProc);
#endif #endif
hecl::Unlink(m_errPath.c_str()); hecl::Unlink(m_errPath.c_str());
@ -532,10 +532,10 @@ Connection::Connection(int verbosityLevel)
{ {
_closePipe(); _closePipe();
if (blenderBin) if (blenderBin)
BlenderLog.report(logvisor::Fatal, _S("Unable to find blender at '%s' or '%s'"), BlenderLog.report(logvisor::Fatal, _SYS_STR("Unable to find blender at '%s' or '%s'"),
blenderBin, DEFAULT_BLENDER_BIN); blenderBin, DEFAULT_BLENDER_BIN);
else else
BlenderLog.report(logvisor::Fatal, _S("Unable to find blender at '%s'"), BlenderLog.report(logvisor::Fatal, _SYS_STR("Unable to find blender at '%s'"),
DEFAULT_BLENDER_BIN); DEFAULT_BLENDER_BIN);
} }
else if (!strcmp(lineBuf, "NOADDON")) else if (!strcmp(lineBuf, "NOADDON"))
@ -544,14 +544,14 @@ Connection::Connection(int verbosityLevel)
InstallAddon(blenderAddonPath.c_str()); InstallAddon(blenderAddonPath.c_str());
++installAttempt; ++installAttempt;
if (installAttempt >= 2) if (installAttempt >= 2)
BlenderLog.report(logvisor::Fatal, _S("unable to install blender addon using '%s'"), BlenderLog.report(logvisor::Fatal, _SYS_STR("unable to install blender addon using '%s'"),
blenderAddonPath.c_str()); blenderAddonPath.c_str());
continue; continue;
} }
else if (!strcmp(lineBuf, "ADDONINSTALLED")) else if (!strcmp(lineBuf, "ADDONINSTALLED"))
{ {
_closePipe(); _closePipe();
blenderAddonPath = _S("SKIPINSTALL"); blenderAddonPath = _SYS_STR("SKIPINSTALL");
continue; continue;
} }
else if (strcmp(lineBuf, "READY")) else if (strcmp(lineBuf, "READY"))
@ -715,7 +715,7 @@ void Connection::deleteBlend()
if (m_loadedBlend) if (m_loadedBlend)
{ {
hecl::Unlink(m_loadedBlend.getAbsolutePath().data()); hecl::Unlink(m_loadedBlend.getAbsolutePath().data());
BlenderLog.report(logvisor::Info, _S("Deleted '%s'"), m_loadedBlend.getAbsolutePath().data()); BlenderLog.report(logvisor::Info, _SYS_STR("Deleted '%s'"), m_loadedBlend.getAbsolutePath().data());
m_loadedBlend = ProjectPath(); m_loadedBlend = ProjectPath();
} }
} }
@ -1833,7 +1833,7 @@ std::pair<atVec3f, atVec3f> DataStream::getMeshAABB()
{ {
if (m_parent->m_loadedType != BlendType::Mesh && if (m_parent->m_loadedType != BlendType::Mesh &&
m_parent->m_loadedType != BlendType::Actor) m_parent->m_loadedType != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH or ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a MESH or ACTOR blend"),
m_parent->m_loadedBlend.getAbsolutePath().data()); m_parent->m_loadedBlend.getAbsolutePath().data());
m_parent->_writeStr("MESHAABB"); m_parent->_writeStr("MESHAABB");
@ -1856,7 +1856,7 @@ const char* DataStream::MeshOutputModeString(HMDLTopology topology)
Mesh DataStream::compileMesh(HMDLTopology topology, int skinSlotCount, Mesh::SurfProgFunc surfProg) Mesh DataStream::compileMesh(HMDLTopology topology, int skinSlotCount, Mesh::SurfProgFunc surfProg)
{ {
if (m_parent->getBlendType() != BlendType::Mesh) if (m_parent->getBlendType() != BlendType::Mesh)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MESH blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a MESH blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -1876,7 +1876,7 @@ Mesh DataStream::compileMesh(std::string_view name, HMDLTopology topology,
int skinSlotCount, bool useLuv, Mesh::SurfProgFunc surfProg) int skinSlotCount, bool useLuv, Mesh::SurfProgFunc surfProg)
{ {
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -1895,7 +1895,7 @@ Mesh DataStream::compileMesh(std::string_view name, HMDLTopology topology,
ColMesh DataStream::compileColMesh(std::string_view name) ColMesh DataStream::compileColMesh(std::string_view name)
{ {
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -1913,7 +1913,7 @@ ColMesh DataStream::compileColMesh(std::string_view name)
std::vector<ColMesh> DataStream::compileColMeshes() std::vector<ColMesh> DataStream::compileColMeshes()
{ {
if (m_parent->getBlendType() != BlendType::ColMesh) if (m_parent->getBlendType() != BlendType::ColMesh)
BlenderLog.report(logvisor::Fatal, _S("%s is not a CMESH blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a CMESH blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -1941,7 +1941,7 @@ Mesh DataStream::compileAllMeshes(HMDLTopology topology, int skinSlotCount,
float maxOctantLength, Mesh::SurfProgFunc surfProg) float maxOctantLength, Mesh::SurfProgFunc surfProg)
{ {
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -1961,7 +1961,7 @@ Mesh DataStream::compileAllMeshes(HMDLTopology topology, int skinSlotCount,
std::vector<Light> DataStream::compileLights() std::vector<Light> DataStream::compileLights()
{ {
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("LIGHTCOMPILEALL"); m_parent->_writeStr("LIGHTCOMPILEALL");
@ -1986,7 +1986,7 @@ std::vector<Light> DataStream::compileLights()
PathMesh DataStream::compilePathMesh() PathMesh DataStream::compilePathMesh()
{ {
if (m_parent->getBlendType() != BlendType::PathMesh) if (m_parent->getBlendType() != BlendType::PathMesh)
BlenderLog.report(logvisor::Fatal, _S("%s is not a PATH blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a PATH blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("MESHCOMPILEPATH"); m_parent->_writeStr("MESHCOMPILEPATH");
@ -2003,7 +2003,7 @@ std::vector<uint8_t> DataStream::compileGuiFrame(int version)
{ {
std::vector<uint8_t> ret; std::vector<uint8_t> ret;
if (m_parent->getBlendType() != BlendType::Frame) if (m_parent->getBlendType() != BlendType::Frame)
BlenderLog.report(logvisor::Fatal, _S("%s is not a FRAME blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a FRAME blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[512]; char req[512];
@ -2074,7 +2074,7 @@ std::vector<ProjectPath> DataStream::getTextures()
Actor DataStream::compileActor() Actor DataStream::compileActor()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("ACTORCOMPILE"); m_parent->_writeStr("ACTORCOMPILE");
@ -2090,7 +2090,7 @@ Actor DataStream::compileActor()
Actor DataStream::compileActorCharacterOnly() Actor DataStream::compileActorCharacterOnly()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("ACTORCOMPILECHARACTERONLY"); m_parent->_writeStr("ACTORCOMPILECHARACTERONLY");
@ -2106,7 +2106,7 @@ Actor DataStream::compileActorCharacterOnly()
Action DataStream::compileActionChannelsOnly(std::string_view name) Action DataStream::compileActionChannelsOnly(std::string_view name)
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -2124,7 +2124,7 @@ Action DataStream::compileActionChannelsOnly(std::string_view name)
World DataStream::compileWorld() World DataStream::compileWorld()
{ {
if (m_parent->getBlendType() != BlendType::World) if (m_parent->getBlendType() != BlendType::World)
BlenderLog.report(logvisor::Fatal, _S("%s is not an WORLD blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an WORLD blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("WORLDCOMPILE"); m_parent->_writeStr("WORLDCOMPILE");
@ -2140,7 +2140,7 @@ World DataStream::compileWorld()
std::vector<std::string> DataStream::getArmatureNames() std::vector<std::string> DataStream::getArmatureNames()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("GETARMATURENAMES"); m_parent->_writeStr("GETARMATURENAMES");
@ -2171,7 +2171,7 @@ std::vector<std::string> DataStream::getArmatureNames()
std::vector<std::string> DataStream::getSubtypeNames() std::vector<std::string> DataStream::getSubtypeNames()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("GETSUBTYPENAMES"); m_parent->_writeStr("GETSUBTYPENAMES");
@ -2202,7 +2202,7 @@ std::vector<std::string> DataStream::getSubtypeNames()
std::vector<std::string> DataStream::getActionNames() std::vector<std::string> DataStream::getActionNames()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("GETACTIONNAMES"); m_parent->_writeStr("GETACTIONNAMES");
@ -2233,7 +2233,7 @@ std::vector<std::string> DataStream::getActionNames()
std::vector<std::string> DataStream::getSubtypeOverlayNames(std::string_view name) std::vector<std::string> DataStream::getSubtypeOverlayNames(std::string_view name)
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -2266,7 +2266,7 @@ std::vector<std::string> DataStream::getSubtypeOverlayNames(std::string_view nam
std::vector<std::string> DataStream::getAttachmentNames() std::vector<std::string> DataStream::getAttachmentNames()
{ {
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("GETATTACHMENTNAMES"); m_parent->_writeStr("GETATTACHMENTNAMES");
@ -2301,7 +2301,7 @@ DataStream::getBoneMatrices(std::string_view name)
return {}; return {};
if (m_parent->getBlendType() != BlendType::Actor) if (m_parent->getBlendType() != BlendType::Actor)
BlenderLog.report(logvisor::Fatal, _S("%s is not an ACTOR blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an ACTOR blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[128]; char req[128];
@ -2351,7 +2351,7 @@ bool DataStream::renderPvs(std::string_view path, const atVec3f& location)
return false; return false;
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[256]; char req[256];
@ -2374,7 +2374,7 @@ bool DataStream::renderPvsLight(std::string_view path, std::string_view lightNam
return false; return false;
if (m_parent->getBlendType() != BlendType::Area) if (m_parent->getBlendType() != BlendType::Area)
BlenderLog.report(logvisor::Fatal, _S("%s is not an AREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not an AREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
char req[256]; char req[256];
@ -2393,7 +2393,7 @@ bool DataStream::renderPvsLight(std::string_view path, std::string_view lightNam
MapArea DataStream::compileMapArea() MapArea DataStream::compileMapArea()
{ {
if (m_parent->getBlendType() != BlendType::MapArea) if (m_parent->getBlendType() != BlendType::MapArea)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPAREA blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a MAPAREA blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("MAPAREACOMPILE"); m_parent->_writeStr("MAPAREACOMPILE");
@ -2410,7 +2410,7 @@ MapArea DataStream::compileMapArea()
MapUniverse DataStream::compileMapUniverse() MapUniverse DataStream::compileMapUniverse()
{ {
if (m_parent->getBlendType() != BlendType::MapUniverse) if (m_parent->getBlendType() != BlendType::MapUniverse)
BlenderLog.report(logvisor::Fatal, _S("%s is not a MAPUNIVERSE blend"), BlenderLog.report(logvisor::Fatal, _SYS_STR("%s is not a MAPUNIVERSE blend"),
m_parent->getBlendPath().getAbsolutePath().data()); m_parent->getBlendPath().getAbsolutePath().data());
m_parent->_writeStr("MAPUNIVERSECOMPILE"); m_parent->_writeStr("MAPUNIVERSECOMPILE");

2
hecl/lib/CMakeLists.txt
View File

@ -86,7 +86,7 @@ add_library(hecl-light
${COMMON_SOURCES} ${COMMON_SOURCES}
${HECL_HEADERS} ${HECL_HEADERS}
${PLAT_SRCS}) ${PLAT_SRCS})
add_library(hecl-compilers Compilers.cpp) add_library(hecl-compilers Compilers.cpp WideStringConvert.cpp)
add_dependencies(hecl-full ${HECL_APPLICATION_REPS_TARGETS_LIST}) add_dependencies(hecl-full ${HECL_APPLICATION_REPS_TARGETS_LIST})
add_dependencies(hecl-light ${HECL_APPLICATION_REPS_TARGETS_LIST}) add_dependencies(hecl-light ${HECL_APPLICATION_REPS_TARGETS_LIST})

18
hecl/lib/CVarManager.cpp
View File

@ -96,16 +96,16 @@ void CVarManager::deserialize(CVar* cvar)
return; return;
#if _WIN32 #if _WIN32
hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toWideLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _SYS_STR('/') + com_configfile->toWideLiteral();
#else #else
hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _SYS_STR('/') + com_configfile->toLiteral();
#endif #endif
hecl::Sstat st; hecl::Sstat st;
if (m_useBinary) if (m_useBinary)
{ {
CVarContainer container; CVarContainer container;
filename += _S(".bin"); filename += _SYS_STR(".bin");
if (hecl::Stat(filename.c_str(), &st) || !S_ISREG(st.st_mode)) if (hecl::Stat(filename.c_str(), &st) || !S_ISREG(st.st_mode))
return; return;
athena::io::FileReader reader(filename); athena::io::FileReader reader(filename);
@ -134,7 +134,7 @@ void CVarManager::deserialize(CVar* cvar)
} }
else else
{ {
filename += _S(".yaml"); filename += _SYS_STR(".yaml");
if (hecl::Stat(filename.c_str(), &st) || !S_ISREG(st.st_mode)) if (hecl::Stat(filename.c_str(), &st) || !S_ISREG(st.st_mode))
return; return;
athena::io::FileReader reader(filename); athena::io::FileReader reader(filename);
@ -168,9 +168,9 @@ void CVarManager::deserialize(CVar* cvar)
void CVarManager::serialize() void CVarManager::serialize()
{ {
#if _WIN32 #if _WIN32
hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toWideLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _SYS_STR('/') + com_configfile->toWideLiteral();
#else #else
hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _S('/') + com_configfile->toLiteral(); hecl::SystemString filename = hecl::SystemString(m_store.getStoreRoot()) + _SYS_STR('/') + com_configfile->toLiteral();
#endif #endif
if (m_useBinary) if (m_useBinary)
@ -182,14 +182,14 @@ void CVarManager::serialize()
container.cvars.push_back(*pair.second); container.cvars.push_back(*pair.second);
container.cvarCount = atUint32(container.cvars.size()); container.cvarCount = atUint32(container.cvars.size());
filename += _S(".bin"); filename += _SYS_STR(".bin");
athena::io::FileWriter writer(filename); athena::io::FileWriter writer(filename);
if (writer.isOpen()) if (writer.isOpen())
container.write(writer); container.write(writer);
} }
else else
{ {
filename += _S(".yaml"); filename += _SYS_STR(".yaml");
athena::io::FileReader r(filename); athena::io::FileReader r(filename);
athena::io::YAMLDocWriter docWriter(nullptr, r.isOpen() ? &r : nullptr); athena::io::YAMLDocWriter docWriter(nullptr, r.isOpen() ? &r : nullptr);
@ -303,7 +303,7 @@ void CVarManager::parseCommandLine(const std::vector<SystemString>& args)
athena::utility::tolower(developerName); athena::utility::tolower(developerName);
for (const SystemString& arg : args) for (const SystemString& arg : args)
{ {
if (arg[0] == _S('+')) if (arg[0] == _SYS_STR('+'))
{ {
std::string tmp = SystemUTF8Conv(arg).c_str(); std::string tmp = SystemUTF8Conv(arg).c_str();

16
hecl/lib/ClientProcess.cpp
View File

@ -35,7 +35,7 @@ void ClientProcess::BufferTransaction::run(blender::Token& btok)
athena::io::FileReader r(m_path.getAbsolutePath(), 32 * 1024, false); athena::io::FileReader r(m_path.getAbsolutePath(), 32 * 1024, false);
if (r.hasError()) if (r.hasError())
{ {
CP_Log.report(logvisor::Fatal, _S("unable to background-buffer '%s'"), CP_Log.report(logvisor::Fatal, _SYS_STR("unable to background-buffer '%s'"),
m_path.getAbsolutePath().data()); m_path.getAbsolutePath().data());
return; return;
} }
@ -164,7 +164,7 @@ bool ClientProcess::syncCook(const hecl::ProjectPath& path, Database::IDataSpec*
{ {
hecl::ProjectPath cooked = path.getCookedPath(*specEnt); hecl::ProjectPath cooked = path.getCookedPath(*specEnt);
if (fast) if (fast)
cooked = cooked.getWithExtension(_S(".fast")); cooked = cooked.getWithExtension(_SYS_STR(".fast"));
cooked.makeDirChain(false); cooked.makeDirChain(false);
if (force || cooked.getPathType() == ProjectPath::Type::None || if (force || cooked.getPathType() == ProjectPath::Type::None ||
path.getModtime() > cooked.getModtime()) path.getModtime() > cooked.getModtime())
@ -173,19 +173,19 @@ bool ClientProcess::syncCook(const hecl::ProjectPath& path, Database::IDataSpec*
{ {
hecl::SystemString str; hecl::SystemString str;
if (path.getAuxInfo().empty()) if (path.getAuxInfo().empty())
str = hecl::SysFormat(_S("Cooking %s"), path.getRelativePath().data()); str = hecl::SysFormat(_SYS_STR("Cooking %s"), path.getRelativePath().data());
else else
str = hecl::SysFormat(_S("Cooking %s|%s"), path.getRelativePath().data(), path.getAuxInfo().data()); str = hecl::SysFormat(_SYS_STR("Cooking %s|%s"), path.getRelativePath().data(), path.getAuxInfo().data());
m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx()); m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx());
m_progPrinter->flush(); m_progPrinter->flush();
} }
else else
{ {
if (path.getAuxInfo().empty()) if (path.getAuxInfo().empty())
LogModule.report(logvisor::Info, _S("Cooking %s"), LogModule.report(logvisor::Info, _SYS_STR("Cooking %s"),
path.getRelativePath().data()); path.getRelativePath().data());
else else
LogModule.report(logvisor::Info, _S("Cooking %s|%s"), LogModule.report(logvisor::Info, _SYS_STR("Cooking %s|%s"),
path.getRelativePath().data(), path.getRelativePath().data(),
path.getAuxInfo().data()); path.getAuxInfo().data());
} }
@ -194,9 +194,9 @@ bool ClientProcess::syncCook(const hecl::ProjectPath& path, Database::IDataSpec*
{ {
hecl::SystemString str; hecl::SystemString str;
if (path.getAuxInfo().empty()) if (path.getAuxInfo().empty())
str = hecl::SysFormat(_S("Cooked %s"), path.getRelativePath().data()); str = hecl::SysFormat(_SYS_STR("Cooked %s"), path.getRelativePath().data());
else else
str = hecl::SysFormat(_S("Cooked %s|%s"), path.getRelativePath().data(), path.getAuxInfo().data()); str = hecl::SysFormat(_SYS_STR("Cooked %s|%s"), path.getRelativePath().data(), path.getAuxInfo().data());
m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx()); m_progPrinter->print(str.c_str(), nullptr, -1.f, hecl::ClientProcess::GetThreadWorkerIdx());
m_progPrinter->flush(); m_progPrinter->flush();
} }

88
hecl/lib/Compilers.cpp
View File

@ -7,11 +7,34 @@
#include <SPIRV/GlslangToSpv.h> #include <SPIRV/GlslangToSpv.h>
#include <SPIRV/disassemble.h> #include <SPIRV/disassemble.h>
#endif #endif
#if _WIN32
#include <d3dcompiler.h>
extern pD3DCompile D3DCompilePROC;
#endif
namespace hecl namespace hecl
{ {
logvisor::Module Log("hecl::Compilers"); logvisor::Module Log("hecl::Compilers");
namespace PlatformType
{
const char* OpenGL::Name = "OpenGL";
const char* Vulkan::Name = "Vulkan";
const char* D3D11::Name = "D3D11";
const char* Metal::Name = "Metal";
const char* NX::Name = "NX";
}
namespace PipelineStage
{
const char* Null::Name = "Null";
const char* Vertex::Name = "Vertex";
const char* Fragment::Name = "Fragment";
const char* Geometry::Name = "Geometry";
const char* Control::Name = "Control";
const char* Evaluation::Name = "Evaluation";
}
template<typename P> struct ShaderCompiler {}; template<typename P> struct ShaderCompiler {};
template<> struct ShaderCompiler<PlatformType::OpenGL> template<> struct ShaderCompiler<PlatformType::OpenGL>
@ -71,6 +94,43 @@ template<> struct ShaderCompiler<PlatformType::Vulkan>
} }
}; };
#if _WIN32
static const char* D3DShaderTypes[] =
{
nullptr,
"vs_5_0",
"ps_5_0",
"gs_5_0",
"hs_5_0",
"ds_5_0"
};
template<> struct ShaderCompiler<PlatformType::D3D11>
{
#if _DEBUG && 0
#define BOO_D3DCOMPILE_FLAG D3DCOMPILE_DEBUG | D3DCOMPILE_OPTIMIZATION_LEVEL0
#else
#define BOO_D3DCOMPILE_FLAG D3DCOMPILE_OPTIMIZATION_LEVEL3
#endif
template<typename S>
static std::pair<std::shared_ptr<uint8_t[]>, size_t> Compile(std::string_view text)
{
ComPtr<ID3DBlob> errBlob;
ComPtr<ID3DBlob> blobOut;
if (FAILED(D3DCompilePROC(text.data(), text.size(), "Boo HLSL Source", nullptr, nullptr, "main",
D3DShaderTypes[int(S::Enum)], BOO_D3DCOMPILE_FLAG, 0, &blobOut, &errBlob)))
{
printf("%s\n", text.data());
Log.report(logvisor::Fatal, "error compiling shader: %s", errBlob->GetBufferPointer());
return {};
}
std::pair<std::shared_ptr<uint8_t[]>, size_t> ret(new uint8_t[blobOut->GetBufferSize()], blobOut->GetBufferSize());
memcpy(ret.first.get(), blobOut->GetBufferPointer(), blobOut->GetBufferSize());
return ret;
}
};
#endif
#if HECL_NOUVEAU_NX
template<> struct ShaderCompiler<PlatformType::NX> template<> struct ShaderCompiler<PlatformType::NX>
{ {
template<typename S> template<typename S>
@ -84,6 +144,7 @@ template<> struct ShaderCompiler<PlatformType::NX>
return ret; return ret;
} }
}; };
#endif
template<typename P, typename S> template<typename P, typename S>
std::pair<std::shared_ptr<uint8_t[]>, size_t> CompileShader(std::string_view text) std::pair<std::shared_ptr<uint8_t[]>, size_t> CompileShader(std::string_view text)
@ -108,33 +169,6 @@ SPECIALIZE_COMPILE_SHADER(PlatformType::Metal)
SPECIALIZE_COMPILE_SHADER(PlatformType::NX) SPECIALIZE_COMPILE_SHADER(PlatformType::NX)
#endif #endif
#if _WIN32
static const char* ShaderTypes[] =
{
"vs_5_0",
"ps_5_0",
"gs_5_0",
"hs_5_0",
"ds_5_0"
};
template<>
std::vector<uint8_t> CompileShader<PlatformType::D3D11>(std::string_view text, PipelineStage stage)
{
ComPtr<ID3DBlob> errBlob;
ComPtr<ID3DBlob> blobOut;
if (FAILED(D3DCompilePROC(text.data(), text.size(), "Boo HLSL Source", nullptr, nullptr, "main",
ShaderTypes[int(stage)], BOO_D3DCOMPILE_FLAG, 0, &blobOut, &errBlob)))
{
printf("%s\n", source);
Log.report(logvisor::Fatal, "error compiling shader: %s", errBlob->GetBufferPointer());
return {};
}
std::vector<uint8_t> ret(blobOut.GetBufferSize());
memcpy(ret.data(), blobOut.GetBufferPointer(), blobOut.GetBufferSize());
return ret;
};
#endif
#if BOO_HAS_METAL #if BOO_HAS_METAL
static int HasMetalCompiler = -1; static int HasMetalCompiler = -1;

86
hecl/lib/MultiProgressPrinter.cpp
View File

@ -36,24 +36,24 @@ void MultiProgressPrinter::ThreadStat::print(const TermInfo& tinfo) const
if (submessageLen) if (submessageLen)
{ {
if (messageLen > half-submessageLen-1) if (messageLen > half-submessageLen-1)
hecl::Printf(_S(" %.*s... %s "), half-submessageLen-4, m_message.c_str(), m_submessage.c_str()); hecl::Printf(_SYS_STR(" %.*s... %s "), half-submessageLen-4, m_message.c_str(), m_submessage.c_str());
else else
{ {
hecl::Printf(_S(" %s"), m_message.c_str()); hecl::Printf(_SYS_STR(" %s"), m_message.c_str());
for (int i=half-messageLen-submessageLen-1 ; i>=0 ; --i) for (int i=half-messageLen-submessageLen-1 ; i>=0 ; --i)
hecl::Printf(_S(" ")); hecl::Printf(_SYS_STR(" "));
hecl::Printf(_S("%s "), m_submessage.c_str()); hecl::Printf(_SYS_STR("%s "), m_submessage.c_str());
} }
} }
else else
{ {
if (messageLen > half) if (messageLen > half)
hecl::Printf(_S(" %.*s... "), half-3, m_message.c_str()); hecl::Printf(_SYS_STR(" %.*s... "), half-3, m_message.c_str());
else else
{ {
hecl::Printf(_S(" %s"), m_message.c_str()); hecl::Printf(_SYS_STR(" %s"), m_message.c_str());
for (int i=half-messageLen ; i>=0 ; --i) for (int i=half-messageLen ; i>=0 ; --i)
hecl::Printf(_S(" ")); hecl::Printf(_SYS_STR(" "));
} }
} }
@ -66,24 +66,24 @@ void MultiProgressPrinter::ThreadStat::print(const TermInfo& tinfo) const
if (tinfo.xtermColor) if (tinfo.xtermColor)
{ {
hecl::Printf(_S("" BOLD "%3d%% ["), iFactor); hecl::Printf(_SYS_STR("" BOLD "%3d%% ["), iFactor);
for (int b=0 ; b<filled ; ++b) for (int b=0 ; b<filled ; ++b)
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]" NORMAL "")); hecl::Printf(_SYS_STR("]" NORMAL ""));
} }
else else
{ {
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(tinfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); SetConsoleTextAttribute(tinfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE);
#endif #endif
hecl::Printf(_S("%3d%% ["), iFactor); hecl::Printf(_SYS_STR("%3d%% ["), iFactor);
for (int b=0 ; b<filled ; ++b) for (int b=0 ; b<filled ; ++b)
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]")); hecl::Printf(_SYS_STR("]"));
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(tinfo.console, FOREGROUND_WHITE); SetConsoleTextAttribute(tinfo.console, FOREGROUND_WHITE);
#endif #endif
@ -108,26 +108,26 @@ void MultiProgressPrinter::DrawIndeterminateBar()
if (m_termInfo.xtermColor) if (m_termInfo.xtermColor)
{ {
hecl::Printf(_S("" BOLD " [")); hecl::Printf(_SYS_STR("" BOLD " ["));
for (int b=0 ; b<pre ; ++b) for (int b=0 ; b<pre ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]" NORMAL "")); hecl::Printf(_SYS_STR("]" NORMAL ""));
} }
else else
{ {
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE);
#endif #endif
hecl::Printf(_S(" [")); hecl::Printf(_SYS_STR(" ["));
for (int b=0 ; b<pre ; ++b) for (int b=0 ; b<pre ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]")); hecl::Printf(_SYS_STR("]"));
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE); SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE);
#endif #endif
@ -140,7 +140,7 @@ void MultiProgressPrinter::MoveCursorUp(int n)
{ {
if (m_termInfo.xtermColor) if (m_termInfo.xtermColor)
{ {
hecl::Printf(_S("" PREV_LINE ""), n); hecl::Printf(_SYS_STR("" PREV_LINE ""), n);
} }
#if _WIN32 #if _WIN32
else else
@ -155,7 +155,7 @@ void MultiProgressPrinter::MoveCursorUp(int n)
} }
else else
{ {
hecl::Printf(_S("\r")); hecl::Printf(_SYS_STR("\r"));
} }
} }
@ -175,7 +175,7 @@ void MultiProgressPrinter::DoPrint()
SetConsoleCursorInfo(m_termInfo.console, &cursorInfo); SetConsoleCursorInfo(m_termInfo.console, &cursorInfo);
#endif #endif
if (m_termInfo.xtermColor) if (m_termInfo.xtermColor)
hecl::Printf(_S("" HIDE_CURSOR "")); hecl::Printf(_SYS_STR("" HIDE_CURSOR ""));
if (m_dirty) if (m_dirty)
{ {
@ -190,7 +190,7 @@ void MultiProgressPrinter::DoPrint()
if (stat.m_active) if (stat.m_active)
{ {
stat.print(m_termInfo); stat.print(m_termInfo);
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
++m_curThreadLines; ++m_curThreadLines;
} }
} }
@ -202,7 +202,7 @@ void MultiProgressPrinter::DoPrint()
) )
{ {
DrawIndeterminateBar(); DrawIndeterminateBar();
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
++m_curProgLines; ++m_curProgLines;
} }
else if (m_mainFactor >= 0.f) else if (m_mainFactor >= 0.f)
@ -217,30 +217,30 @@ void MultiProgressPrinter::DoPrint()
if (m_termInfo.xtermColor) if (m_termInfo.xtermColor)
{ {
hecl::Printf(_S("" BOLD " %3d%% ["), iFactor); hecl::Printf(_SYS_STR("" BOLD " %3d%% ["), iFactor);
for (int b=0 ; b<filled ; ++b) for (int b=0 ; b<filled ; ++b)
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]" NORMAL "")); hecl::Printf(_SYS_STR("]" NORMAL ""));
} }
else else
{ {
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE); SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_INTENSITY | FOREGROUND_WHITE);
#endif #endif
hecl::Printf(_S(" %3d%% ["), iFactor); hecl::Printf(_SYS_STR(" %3d%% ["), iFactor);
for (int b=0 ; b<filled ; ++b) for (int b=0 ; b<filled ; ++b)
hecl::Printf(_S("#")); hecl::Printf(_SYS_STR("#"));
for (int b=0 ; b<rem ; ++b) for (int b=0 ; b<rem ; ++b)
hecl::Printf(_S("-")); hecl::Printf(_SYS_STR("-"));
hecl::Printf(_S("]")); hecl::Printf(_SYS_STR("]"));
#if _WIN32 #if _WIN32
SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE); SetConsoleTextAttribute(m_termInfo.console, FOREGROUND_WHITE);
#endif #endif
} }
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
++m_curProgLines; ++m_curProgLines;
} }
} }
@ -248,7 +248,7 @@ void MultiProgressPrinter::DoPrint()
{ {
const ThreadStat& stat = m_threadStats[m_latestThread]; const ThreadStat& stat = m_threadStats[m_latestThread];
stat.print(m_termInfo); stat.print(m_termInfo);
hecl::Printf(_S("\r")); hecl::Printf(_SYS_STR("\r"));
} }
m_dirty = false; m_dirty = false;
} }
@ -262,12 +262,12 @@ void MultiProgressPrinter::DoPrint()
MoveCursorUp(m_curProgLines); MoveCursorUp(m_curProgLines);
m_curProgLines = 0; m_curProgLines = 0;
DrawIndeterminateBar(); DrawIndeterminateBar();
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
++m_curProgLines; ++m_curProgLines;
} }
if (m_termInfo.xtermColor) if (m_termInfo.xtermColor)
hecl::Printf(_S("" SHOW_CURSOR "")); hecl::Printf(_SYS_STR("" SHOW_CURSOR ""));
fflush(stdout); fflush(stdout);
#if _WIN32 #if _WIN32
@ -380,7 +380,7 @@ void MultiProgressPrinter::startNewLine() const
m_curThreadLines = 0; m_curThreadLines = 0;
m_mainFactor = -1.f; m_mainFactor = -1.f;
auto logLk = logvisor::LockLog(); auto logLk = logvisor::LockLog();
hecl::Printf(_S("\n")); hecl::Printf(_SYS_STR("\n"));
} }
void MultiProgressPrinter::flush() const void MultiProgressPrinter::flush() const

48
hecl/lib/Project.cpp
View File

@ -55,7 +55,7 @@ std::vector<std::string>& Project::ConfigFile::lockAndRead()
if (m_lockedFile) if (m_lockedFile)
return m_lines; return m_lines;
m_lockedFile = hecl::Fopen(m_filepath.c_str(), _S("a+"), FileLockType::Write); m_lockedFile = hecl::Fopen(m_filepath.c_str(), _SYS_STR("a+"), FileLockType::Write);
hecl::FSeek(m_lockedFile, 0, SEEK_SET); hecl::FSeek(m_lockedFile, 0, SEEK_SET);
std::string mainString; std::string mainString;
@ -153,8 +153,8 @@ bool Project::ConfigFile::unlockAndCommit()
return false; return false;
} }
SystemString newPath = m_filepath + _S(".part"); SystemString newPath = m_filepath + _SYS_STR(".part");
FILE* newFile = hecl::Fopen(newPath.c_str(), _S("w"), FileLockType::Write); FILE* newFile = hecl::Fopen(newPath.c_str(), _SYS_STR("w"), FileLockType::Write);
bool fail = false; bool fail = false;
for (const std::string& line : m_lines) for (const std::string& line : m_lines)
{ {
@ -200,24 +200,24 @@ bool Project::ConfigFile::unlockAndCommit()
Project::Project(const ProjectRootPath& rootPath) Project::Project(const ProjectRootPath& rootPath)
: m_rootPath(rootPath), : m_rootPath(rootPath),
m_workRoot(*this, _S("")), m_workRoot(*this, _SYS_STR("")),
m_dotPath(m_workRoot, _S(".hecl")), m_dotPath(m_workRoot, _SYS_STR(".hecl")),
m_cookedRoot(m_dotPath, _S("cooked")), m_cookedRoot(m_dotPath, _SYS_STR("cooked")),
m_specs(*this, _S("specs")), m_specs(*this, _SYS_STR("specs")),
m_paths(*this, _S("paths")), m_paths(*this, _SYS_STR("paths")),
m_groups(*this, _S("groups")) m_groups(*this, _SYS_STR("groups"))
{ {
/* Stat for existing project directory (must already exist) */ /* Stat for existing project directory (must already exist) */
Sstat myStat; Sstat myStat;
if (hecl::Stat(m_rootPath.getAbsolutePath().data(), &myStat)) if (hecl::Stat(m_rootPath.getAbsolutePath().data(), &myStat))
{ {
LogModule.report(logvisor::Error, _S("unable to stat %s"), m_rootPath.getAbsolutePath().data()); LogModule.report(logvisor::Error, _SYS_STR("unable to stat %s"), m_rootPath.getAbsolutePath().data());
return; return;
} }
if (!S_ISDIR(myStat.st_mode)) if (!S_ISDIR(myStat.st_mode))
{ {
LogModule.report(logvisor::Error, _S("provided path must be a directory; '%s' isn't"), LogModule.report(logvisor::Error, _SYS_STR("provided path must be a directory; '%s' isn't"),
m_rootPath.getAbsolutePath().data()); m_rootPath.getAbsolutePath().data());
return; return;
} }
@ -227,8 +227,8 @@ Project::Project(const ProjectRootPath& rootPath)
m_cookedRoot.makeDir(); m_cookedRoot.makeDir();
/* Ensure beacon is valid or created */ /* Ensure beacon is valid or created */
ProjectPath beaconPath(m_dotPath, _S("beacon")); ProjectPath beaconPath(m_dotPath, _SYS_STR("beacon"));
FILE* bf = hecl::Fopen(beaconPath.getAbsolutePath().data(), _S("a+b")); FILE* bf = hecl::Fopen(beaconPath.getAbsolutePath().data(), _SYS_STR("a+b"));
struct BeaconStruct struct BeaconStruct
{ {
hecl::FourCC magic; hecl::FourCC magic;
@ -320,7 +320,7 @@ void Project::rescanDataSpecs()
{ {
hecl::SystemString specStr(spec->m_name); hecl::SystemString specStr(spec->m_name);
SystemUTF8Conv specUTF8(specStr); SystemUTF8Conv specUTF8(specStr);
m_compiledSpecs.push_back({*spec, ProjectPath(m_cookedRoot, hecl::SystemString(spec->m_name) + _S(".spec")), m_compiledSpecs.push_back({*spec, ProjectPath(m_cookedRoot, hecl::SystemString(spec->m_name) + _SYS_STR(".spec")),
m_specs.checkForLine(specUTF8.str())}); m_specs.checkForLine(specUTF8.str())});
} }
m_specs.unlockAndDiscard(); m_specs.unlockAndDiscard();
@ -365,19 +365,19 @@ public:
void reportFile(const DataSpecEntry* specEnt) void reportFile(const DataSpecEntry* specEnt)
{ {
SystemString submsg(m_file); SystemString submsg(m_file);
submsg += _S(" ("); submsg += _SYS_STR(" (");
submsg += specEnt->m_name.data(); submsg += specEnt->m_name.data();
submsg += _S(')'); submsg += _SYS_STR(')');
m_progPrinter.print(m_dir, submsg.c_str(), m_prog); m_progPrinter.print(m_dir, submsg.c_str(), m_prog);
} }
void reportFile(const DataSpecEntry* specEnt, const SystemChar* extra) void reportFile(const DataSpecEntry* specEnt, const SystemChar* extra)
{ {
SystemString submsg(m_file); SystemString submsg(m_file);
submsg += _S(" ("); submsg += _SYS_STR(" (");
submsg += specEnt->m_name.data(); submsg += specEnt->m_name.data();
submsg += _S(", "); submsg += _SYS_STR(", ");
submsg += extra; submsg += extra;
submsg += _S(')'); submsg += _SYS_STR(')');
m_progPrinter.print(m_dir, submsg.c_str(), m_prog); m_progPrinter.print(m_dir, submsg.c_str(), m_prog);
} }
void reportDirComplete() void reportDirComplete()
@ -406,7 +406,7 @@ static void VisitFile(const ProjectPath& path, bool force, bool fast,
continue; continue;
ProjectPath cooked = path.getCookedPath(*override); ProjectPath cooked = path.getCookedPath(*override);
if (fast) if (fast)
cooked = cooked.getWithExtension(_S(".fast")); cooked = cooked.getWithExtension(_SYS_STR(".fast"));
if (force || cooked.getPathType() == ProjectPath::Type::None || if (force || cooked.getPathType() == ProjectPath::Type::None ||
path.getModtime() > cooked.getModtime()) path.getModtime() > cooked.getModtime())
{ {
@ -427,11 +427,11 @@ static void VisitDirectory(const ProjectPath& dir,
std::vector<std::unique_ptr<IDataSpec>>& specInsts, std::vector<std::unique_ptr<IDataSpec>>& specInsts,
CookProgress& progress, ClientProcess* cp, int cookPass) CookProgress& progress, ClientProcess* cp, int cookPass)
{ {
if (dir.getLastComponent().size() > 1 && dir.getLastComponent()[0] == _S('.')) if (dir.getLastComponent().size() > 1 && dir.getLastComponent()[0] == _SYS_STR('.'))
return; return;
if (hecl::ProjectPath(dir, _S("!project.yaml")).isFile() && if (hecl::ProjectPath(dir, _SYS_STR("!project.yaml")).isFile() &&
hecl::ProjectPath(dir, _S("!pool.yaml")).isFile()) hecl::ProjectPath(dir, _SYS_STR("!pool.yaml")).isFile())
{ {
/* Handle AudioGroup case */ /* Handle AudioGroup case */
VisitFile(dir, force, fast, specInsts, progress, cp, cookPass); VisitFile(dir, force, fast, specInsts, progress, cp, cookPass);
@ -540,7 +540,7 @@ bool Project::packagePath(const ProjectPath& path, const hecl::MultiProgressPrin
{ {
if (spec.active && spec.spec.m_factory) if (spec.active && spec.spec.m_factory)
{ {
if (hecl::StringUtils::EndsWith(spec.spec.m_name, _S("-PC"))) if (hecl::StringUtils::EndsWith(spec.spec.m_name, _SYS_STR("-PC")))
{ {
foundPC = true; foundPC = true;
specEntry = &spec.spec; specEntry = &spec.spec;

60
hecl/lib/ProjectPath.cpp
View File

@ -4,8 +4,8 @@
namespace hecl namespace hecl
{ {
static const SystemRegex regPATHCOMP(_S("[/\\\\]*([^/\\\\]+)"), SystemRegex::ECMAScript|SystemRegex::optimize); static const SystemRegex regPATHCOMP(_SYS_STR("[/\\\\]*([^/\\\\]+)"), SystemRegex::ECMAScript|SystemRegex::optimize);
static const SystemRegex regDRIVELETTER(_S("^([^/]*)/"), SystemRegex::ECMAScript|SystemRegex::optimize); static const SystemRegex regDRIVELETTER(_SYS_STR("^([^/]*)/"), SystemRegex::ECMAScript|SystemRegex::optimize);
static SystemString CanonRelPath(SystemStringView path) static SystemString CanonRelPath(SystemStringView path)
{ {
@ -17,15 +17,15 @@ static SystemString CanonRelPath(SystemStringView path)
for (; std::regex_search(in, matches, regPATHCOMP) ; in = matches.suffix().str()) for (; std::regex_search(in, matches, regPATHCOMP) ; in = matches.suffix().str())
{ {
hecl::SystemRegexMatch::const_reference match = matches[1]; hecl::SystemRegexMatch::const_reference match = matches[1];
if (!match.compare(_S("."))) if (!match.compare(_SYS_STR(".")))
continue; continue;
else if (!match.compare(_S(".."))) else if (!match.compare(_SYS_STR("..")))
{ {
if (comps.empty()) if (comps.empty())
{ {
/* Unable to resolve outside project */ /* Unable to resolve outside project */
LogModule.report(logvisor::Fatal, _S("Unable to resolve outside project root in %s"), path.data()); LogModule.report(logvisor::Fatal, _SYS_STR("Unable to resolve outside project root in %s"), path.data());
return _S("."); return _SYS_STR(".");
} }
comps.pop_back(); comps.pop_back();
continue; continue;
@ -42,13 +42,13 @@ static SystemString CanonRelPath(SystemStringView path)
{ {
if ((*it).size()) if ((*it).size())
{ {
retval += _S('/'); retval += _SYS_STR('/');
retval += *it; retval += *it;
} }
} }
return retval; return retval;
} }
return _S("."); return _SYS_STR(".");
} }
static SystemString CanonRelPath(SystemStringView path, const ProjectRootPath& projectRoot) static SystemString CanonRelPath(SystemStringView path, const ProjectRootPath& projectRoot)
@ -64,7 +64,7 @@ void ProjectPath::assign(Database::Project& project, SystemStringView path)
m_proj = &project; m_proj = &project;
SystemString usePath; SystemString usePath;
size_t pipeFind = path.rfind(_S('|')); size_t pipeFind = path.rfind(_SYS_STR('|'));
if (pipeFind != SystemString::npos) if (pipeFind != SystemString::npos)
{ {
m_auxInfo.assign(path.cbegin() + pipeFind + 1, path.cend()); m_auxInfo.assign(path.cbegin() + pipeFind + 1, path.cend());
@ -74,7 +74,7 @@ void ProjectPath::assign(Database::Project& project, SystemStringView path)
usePath = path; usePath = path;
m_relPath = CanonRelPath(usePath, project.getProjectRootPath()); m_relPath = CanonRelPath(usePath, project.getProjectRootPath());
m_absPath = SystemString(project.getProjectRootPath().getAbsolutePath()) + _S('/') + m_relPath; m_absPath = SystemString(project.getProjectRootPath().getAbsolutePath()) + _SYS_STR('/') + m_relPath;
SanitizePath(m_relPath); SanitizePath(m_relPath);
SanitizePath(m_absPath); SanitizePath(m_absPath);
@ -94,7 +94,7 @@ void ProjectPath::assign(const ProjectPath& parentPath, SystemStringView path)
m_proj = parentPath.m_proj; m_proj = parentPath.m_proj;
SystemString usePath; SystemString usePath;
size_t pipeFind = path.rfind(_S('|')); size_t pipeFind = path.rfind(_SYS_STR('|'));
if (pipeFind != SystemString::npos) if (pipeFind != SystemString::npos)
{ {
m_auxInfo.assign(path.cbegin() + pipeFind + 1, path.cend()); m_auxInfo.assign(path.cbegin() + pipeFind + 1, path.cend());
@ -103,8 +103,8 @@ void ProjectPath::assign(const ProjectPath& parentPath, SystemStringView path)
else else
usePath = path; usePath = path;
m_relPath = CanonRelPath(parentPath.m_relPath + _S('/') + usePath); m_relPath = CanonRelPath(parentPath.m_relPath + _SYS_STR('/') + usePath);
m_absPath = SystemString(m_proj->getProjectRootPath().getAbsolutePath()) + _S('/') + m_relPath; m_absPath = SystemString(m_proj->getProjectRootPath().getAbsolutePath()) + _SYS_STR('/') + m_relPath;
SanitizePath(m_relPath); SanitizePath(m_relPath);
SanitizePath(m_absPath); SanitizePath(m_absPath);
@ -130,12 +130,12 @@ ProjectPath ProjectPath::getWithExtension(const SystemChar* ext, bool replace) c
auto absIt = pp.m_absPath.end(); auto absIt = pp.m_absPath.end();
if (absIt != pp.m_absPath.begin()) if (absIt != pp.m_absPath.begin())
--absIt; --absIt;
while (relIt != pp.m_relPath.begin() && *relIt != _S('.') && *relIt != _S('/')) while (relIt != pp.m_relPath.begin() && *relIt != _SYS_STR('.') && *relIt != _SYS_STR('/'))
{ {
--relIt; --relIt;
--absIt; --absIt;
} }
if (*relIt == _S('.') && relIt != pp.m_relPath.begin()) if (*relIt == _SYS_STR('.') && relIt != pp.m_relPath.begin())
{ {
pp.m_relPath.resize(relIt - pp.m_relPath.begin()); pp.m_relPath.resize(relIt - pp.m_relPath.begin());
pp.m_absPath.resize(absIt - pp.m_absPath.begin()); pp.m_absPath.resize(absIt - pp.m_absPath.begin());
@ -157,14 +157,14 @@ ProjectPath ProjectPath::getCookedPath(const Database::DataSpecEntry& spec) cons
ProjectPath ret(m_proj->getProjectCookedPath(spec), woExt.getRelativePath()); ProjectPath ret(m_proj->getProjectCookedPath(spec), woExt.getRelativePath());
if (getAuxInfo().size()) if (getAuxInfo().size())
return ret.getWithExtension((SystemString(_S(".")) + getAuxInfo().data()).c_str()); return ret.getWithExtension((SystemString(_SYS_STR(".")) + getAuxInfo().data()).c_str());
else else
return ret; return ret;
} }
ProjectPath::Type ProjectPath::getPathType() const ProjectPath::Type ProjectPath::getPathType() const
{ {
if (m_absPath.find(_S('*')) != SystemString::npos) if (m_absPath.find(_SYS_STR('*')) != SystemString::npos)
return Type::Glob; return Type::Glob;
Sstat theStat; Sstat theStat;
if (hecl::Stat(m_absPath.c_str(), &theStat)) if (hecl::Stat(m_absPath.c_str(), &theStat))
@ -180,7 +180,7 @@ Time ProjectPath::getModtime() const
{ {
Sstat theStat; Sstat theStat;
time_t latestTime = 0; time_t latestTime = 0;
if (m_absPath.find(_S('*')) != SystemString::npos) if (m_absPath.find(_SYS_STR('*')) != SystemString::npos)
{ {
std::vector<ProjectPath> globResults; std::vector<ProjectPath> globResults;
getGlobResults(globResults); getGlobResults(globResults);
@ -215,7 +215,7 @@ Time ProjectPath::getModtime() const
return Time(latestTime); return Time(latestTime);
} }
} }
LogModule.report(logvisor::Fatal, _S("invalid path type for computing modtime in '%s'"), m_absPath.c_str()); LogModule.report(logvisor::Fatal, _SYS_STR("invalid path type for computing modtime in '%s'"), m_absPath.c_str());
return Time(); return Time();
} }
@ -230,11 +230,11 @@ static void _recursiveGlob(Database::Project& proj,
return; return;
const SystemString& comp = matches[1]; const SystemString& comp = matches[1];
if (comp.find(_S('*')) == SystemString::npos) if (comp.find(_SYS_STR('*')) == SystemString::npos)
{ {
SystemString nextItStr = itStr; SystemString nextItStr = itStr;
if (needSlash) if (needSlash)
nextItStr += _S('/'); nextItStr += _SYS_STR('/');
nextItStr += comp; nextItStr += comp;
hecl::Sstat theStat; hecl::Sstat theStat;
@ -291,7 +291,7 @@ hecl::DirectoryEnumerator ProjectPath::enumerateDir() const
void ProjectPath::getGlobResults(std::vector<ProjectPath>& outPaths) const void ProjectPath::getGlobResults(std::vector<ProjectPath>& outPaths) const
{ {
auto rootPath = m_proj->getProjectRootPath().getAbsolutePath(); auto rootPath = m_proj->getProjectRootPath().getAbsolutePath();
_recursiveGlob(*m_proj, outPaths, m_relPath, rootPath.data(), rootPath.back() != _S('/')); _recursiveGlob(*m_proj, outPaths, m_relPath, rootPath.data(), rootPath.back() != _SYS_STR('/'));
} }
ProjectRootPath SearchForProject(SystemStringView path) ProjectRootPath SearchForProject(SystemStringView path)
@ -302,13 +302,13 @@ ProjectRootPath SearchForProject(SystemStringView path)
while (begin != end) while (begin != end)
{ {
SystemString testPath(begin, end); SystemString testPath(begin, end);
SystemString testIndexPath = testPath + _S("/.hecl/beacon"); SystemString testIndexPath = testPath + _SYS_STR("/.hecl/beacon");
Sstat theStat; Sstat theStat;
if (!hecl::Stat(testIndexPath.c_str(), &theStat)) if (!hecl::Stat(testIndexPath.c_str(), &theStat))
{ {
if (S_ISREG(theStat.st_mode)) if (S_ISREG(theStat.st_mode))
{ {
FILE* fp = hecl::Fopen(testIndexPath.c_str(), _S("rb")); FILE* fp = hecl::Fopen(testIndexPath.c_str(), _SYS_STR("rb"));
if (!fp) if (!fp)
continue; continue;
char magic[4]; char magic[4];
@ -323,7 +323,7 @@ ProjectRootPath SearchForProject(SystemStringView path)
} }
} }
while (begin != end && *(end-1) != _S('/') && *(end-1) != _S('\\')) while (begin != end && *(end-1) != _SYS_STR('/') && *(end-1) != _SYS_STR('\\'))
--end; --end;
if (begin != end) if (begin != end)
--end; --end;
@ -339,13 +339,13 @@ ProjectRootPath SearchForProject(SystemStringView path, SystemString& subpathOut
while (begin != end) while (begin != end)
{ {
SystemString testPath(begin, end); SystemString testPath(begin, end);
SystemString testIndexPath = testPath + _S("/.hecl/beacon"); SystemString testIndexPath = testPath + _SYS_STR("/.hecl/beacon");
Sstat theStat; Sstat theStat;
if (!hecl::Stat(testIndexPath.c_str(), &theStat)) if (!hecl::Stat(testIndexPath.c_str(), &theStat))
{ {
if (S_ISREG(theStat.st_mode)) if (S_ISREG(theStat.st_mode))
{ {
FILE* fp = hecl::Fopen(testIndexPath.c_str(), _S("rb")); FILE* fp = hecl::Fopen(testIndexPath.c_str(), _SYS_STR("rb"));
if (!fp) if (!fp)
continue; continue;
char magic[4]; char magic[4];
@ -357,16 +357,16 @@ ProjectRootPath SearchForProject(SystemStringView path, SystemString& subpathOut
continue; continue;
ProjectRootPath newRootPath = ProjectRootPath(testPath); ProjectRootPath newRootPath = ProjectRootPath(testPath);
auto origEnd = testRoot.getAbsolutePath().end(); auto origEnd = testRoot.getAbsolutePath().end();
while (end != origEnd && *end != _S('/') && *end != _S('\\')) while (end != origEnd && *end != _SYS_STR('/') && *end != _SYS_STR('\\'))
++end; ++end;
if (end != origEnd && (*end == _S('/') || *end == _S('\\'))) if (end != origEnd && (*end == _SYS_STR('/') || *end == _SYS_STR('\\')))
++end; ++end;
subpathOut.assign(end, origEnd); subpathOut.assign(end, origEnd);
return newRootPath; return newRootPath;
} }
} }
while (begin != end && *(end-1) != _S('/') && *(end-1) != _S('\\')) while (begin != end && *(end-1) != _SYS_STR('/') && *(end-1) != _SYS_STR('\\'))
--end; --end;
if (begin != end) if (begin != end)
--end; --end;

6
hecl/lib/Runtime/FileStoreManager.cpp
View File

@ -19,17 +19,17 @@ FileStoreManager::FileStoreManager(SystemStringView domain)
#if !WINDOWS_STORE #if !WINDOWS_STORE
WCHAR home[MAX_PATH]; WCHAR home[MAX_PATH];
if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, home))) if (!SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, home)))
Log.report(logvisor::Fatal, _S("unable to locate profile for file store")); Log.report(logvisor::Fatal, _SYS_STR("unable to locate profile for file store"));
SystemString path(home); SystemString path(home);
#else #else
StorageFolder^ cacheFolder = ApplicationData::Current->LocalCacheFolder; StorageFolder^ cacheFolder = ApplicationData::Current->LocalCacheFolder;
SystemString path(cacheFolder->Path->Data()); SystemString path(cacheFolder->Path->Data());
#endif #endif
path += _S("/.heclrun"); path += _SYS_STR("/.heclrun");
hecl::MakeDir(path.c_str()); hecl::MakeDir(path.c_str());
path += _S('/'); path += _SYS_STR('/');
path += domain.data(); path += domain.data();
hecl::MakeDir(path.c_str()); hecl::MakeDir(path.c_str());

16
hecl/lib/SteamFinder.cpp
View File

@ -23,16 +23,16 @@ hecl::SystemString FindCommonSteamApp(const hecl::SystemChar* name)
#if !WINDOWS_STORE #if !WINDOWS_STORE
HKEY hkey; HKEY hkey;
hecl::SystemChar _steamInstallDir[MAX_PATH] = {0}; hecl::SystemChar _steamInstallDir[MAX_PATH] = {0};
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _S("Software\\Valve\\Steam"), if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _SYS_STR("Software\\Valve\\Steam"),
0, KEY_QUERY_VALUE, &hkey) != ERROR_SUCCESS) 0, KEY_QUERY_VALUE, &hkey) != ERROR_SUCCESS)
{ {
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _S("Software\\Valve\\Steam"), if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _SYS_STR("Software\\Valve\\Steam"),
0, KEY_QUERY_VALUE | KEY_WOW64_32KEY, &hkey) != ERROR_SUCCESS) 0, KEY_QUERY_VALUE | KEY_WOW64_32KEY, &hkey) != ERROR_SUCCESS)
return {}; return {};
} }
DWORD size = MAX_PATH; DWORD size = MAX_PATH;
if (RegQueryValueEx(hkey, _S("InstallPath"), nullptr, nullptr, if (RegQueryValueEx(hkey, _SYS_STR("InstallPath"), nullptr, nullptr,
(LPBYTE)_steamInstallDir, &size) == ERROR_SUCCESS) (LPBYTE)_steamInstallDir, &size) == ERROR_SUCCESS)
steamInstallDir = _steamInstallDir; steamInstallDir = _steamInstallDir;
RegCloseKey(hkey); RegCloseKey(hkey);
@ -62,17 +62,17 @@ hecl::SystemString FindCommonSteamApp(const hecl::SystemChar* name)
#endif #endif
hecl::SystemString appPath = hecl::SystemString(_S("common")) + PATH_SEP + name; hecl::SystemString appPath = hecl::SystemString(_SYS_STR("common")) + PATH_SEP + name;
/* Try main steam install directory first */ /* Try main steam install directory first */
hecl::SystemString steamAppsMain = steamInstallDir + PATH_SEP + _S("steamapps"); hecl::SystemString steamAppsMain = steamInstallDir + PATH_SEP + _SYS_STR("steamapps");
hecl::SystemString mainAppPath = steamAppsMain + PATH_SEP + appPath; hecl::SystemString mainAppPath = steamAppsMain + PATH_SEP + appPath;
if (!hecl::Stat(mainAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode)) if (!hecl::Stat(mainAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode))
return mainAppPath; return mainAppPath;
/* Iterate alternate steam install dirs */ /* Iterate alternate steam install dirs */
hecl::SystemString libraryFoldersVdfPath = steamAppsMain + PATH_SEP + _S("libraryfolders.vdf"); hecl::SystemString libraryFoldersVdfPath = steamAppsMain + PATH_SEP + _SYS_STR("libraryfolders.vdf");
FILE* fp = hecl::Fopen(libraryFoldersVdfPath.c_str(), _S("r")); FILE* fp = hecl::Fopen(libraryFoldersVdfPath.c_str(), _SYS_STR("r"));
if (!fp) if (!fp)
return {}; return {};
hecl::FSeek(fp, 0, SEEK_END); hecl::FSeek(fp, 0, SEEK_END);
@ -100,7 +100,7 @@ hecl::SystemString FindCommonSteamApp(const hecl::SystemChar* name)
std::string match = dirMatch[1].str(); std::string match = dirMatch[1].str();
hecl::SystemStringConv otherInstallDir(match); hecl::SystemStringConv otherInstallDir(match);
hecl::SystemString otherAppPath = hecl::SystemString(otherInstallDir.sys_str()) + PATH_SEP + hecl::SystemString otherAppPath = hecl::SystemString(otherInstallDir.sys_str()) + PATH_SEP +
_S("steamapps") + PATH_SEP + appPath; _SYS_STR("steamapps") + PATH_SEP + appPath;
if (!hecl::Stat(otherAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode)) if (!hecl::Stat(otherAppPath.c_str(), &theStat) && S_ISDIR(theStat.st_mode))
return otherAppPath; return otherAppPath;
begin = dirMatch.suffix().first; begin = dirMatch.suffix().first;

34
hecl/lib/hecl.cpp
View File

@ -215,7 +215,7 @@ void ResourceLock::ClearThreadRes()
bool IsPathPNG(const hecl::ProjectPath& path) bool IsPathPNG(const hecl::ProjectPath& path)
{ {
FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb")); FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _SYS_STR("rb"));
if (!fp) if (!fp)
return false; return false;
uint32_t buf = 0; uint32_t buf = 0;
@ -234,9 +234,9 @@ bool IsPathPNG(const hecl::ProjectPath& path)
bool IsPathBlend(const hecl::ProjectPath& path) bool IsPathBlend(const hecl::ProjectPath& path)
{ {
auto lastCompExt = path.getLastComponentExt(); auto lastCompExt = path.getLastComponentExt();
if (lastCompExt.empty() || hecl::StrCmp(lastCompExt.data(), _S("blend"))) if (lastCompExt.empty() || hecl::StrCmp(lastCompExt.data(), _SYS_STR("blend")))
return false; return false;
FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("rb")); FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _SYS_STR("rb"));
if (!fp) if (!fp)
return false; return false;
uint32_t buf = 0; uint32_t buf = 0;
@ -254,13 +254,13 @@ bool IsPathBlend(const hecl::ProjectPath& path)
bool IsPathYAML(const hecl::ProjectPath& path) bool IsPathYAML(const hecl::ProjectPath& path)
{ {
if (!hecl::StrCmp(path.getLastComponent().data(), _S("!catalog.yaml"))) if (!hecl::StrCmp(path.getLastComponent().data(), _SYS_STR("!catalog.yaml")))
return false; /* !catalog.yaml is exempt from general use */ return false; /* !catalog.yaml is exempt from general use */
auto lastCompExt = path.getLastComponentExt(); auto lastCompExt = path.getLastComponentExt();
if (lastCompExt.empty()) if (lastCompExt.empty())
return false; return false;
if (!hecl::StrCmp(lastCompExt.data(), _S("yaml")) || if (!hecl::StrCmp(lastCompExt.data(), _SYS_STR("yaml")) ||
!hecl::StrCmp(lastCompExt.data(), _S("yml"))) !hecl::StrCmp(lastCompExt.data(), _SYS_STR("yml")))
return true; return true;
return false; return false;
} }
@ -274,7 +274,7 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
#if _WIN32 #if _WIN32
hecl::SystemString wc(path); hecl::SystemString wc(path);
wc += _S("/*"); wc += _SYS_STR("/*");
WIN32_FIND_DATAW d; WIN32_FIND_DATAW d;
HANDLE dir = FindFirstFileW(wc.c_str(), &d); HANDLE dir = FindFirstFileW(wc.c_str(), &d);
if (dir == INVALID_HANDLE_VALUE) if (dir == INVALID_HANDLE_VALUE)
@ -284,12 +284,12 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
case Mode::Native: case Mode::Native:
do do
{ {
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S(".."))) if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
continue; continue;
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
continue; continue;
hecl::SystemString fp(path); hecl::SystemString fp(path);
fp += _S('/'); fp += _SYS_STR('/');
fp += d.cFileName; fp += d.cFileName;
hecl::Sstat st; hecl::Sstat st;
if (hecl::Stat(fp.c_str(), &st)) if (hecl::Stat(fp.c_str(), &st))
@ -313,12 +313,12 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort; std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
do do
{ {
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S(".."))) if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
continue; continue;
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
continue; continue;
hecl::SystemString fp(path); hecl::SystemString fp(path);
fp +=_S('/'); fp +=_SYS_STR('/');
fp += d.cFileName; fp += d.cFileName;
hecl::Sstat st; hecl::Sstat st;
if (hecl::Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode)) if (hecl::Stat(fp.c_str(), &st) || !S_ISDIR(st.st_mode))
@ -348,12 +348,12 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
std::multimap<size_t, Entry> sort; std::multimap<size_t, Entry> sort;
do do
{ {
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S(".."))) if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
continue; continue;
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
continue; continue;
hecl::SystemString fp(path); hecl::SystemString fp(path);
fp += _S('/'); fp += _SYS_STR('/');
fp += d.cFileName; fp += d.cFileName;
hecl::Sstat st; hecl::Sstat st;
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode)) if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
@ -373,12 +373,12 @@ hecl::DirectoryEnumerator::DirectoryEnumerator(SystemStringView path, Mode mode,
std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort; std::map<hecl::SystemString, Entry, CaseInsensitiveCompare> sort;
do do
{ {
if (!wcscmp(d.cFileName, _S(".")) || !wcscmp(d.cFileName, _S(".."))) if (!wcscmp(d.cFileName, _SYS_STR(".")) || !wcscmp(d.cFileName, _SYS_STR("..")))
continue; continue;
if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0)) if (noHidden && (d.cFileName[0] == L'.' || (d.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0))
continue; continue;
hecl::SystemString fp(path); hecl::SystemString fp(path);
fp += _S('/'); fp += _SYS_STR('/');
fp += d.cFileName; fp += d.cFileName;
hecl::Sstat st; hecl::Sstat st;
if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode)) if (hecl::Stat(fp.c_str(), &st) || !S_ISREG(st.st_mode))
@ -847,9 +847,9 @@ int RunProcess(const SystemChar* path, const SystemChar* const args[])
const SystemChar* const* arg = &args[1]; const SystemChar* const* arg = &args[1];
while (*arg) while (*arg)
{ {
cmdLine += _S(" \""); cmdLine += _SYS_STR(" \"");
cmdLine += *arg++; cmdLine += *arg++;
cmdLine += _S('"'); cmdLine += _SYS_STR('"');
} }
STARTUPINFO sinfo = {sizeof(STARTUPINFO)}; STARTUPINFO sinfo = {sizeof(STARTUPINFO)};

51
hecl/shaderc/main.cpp
View File

@ -7,6 +7,37 @@
static logvisor::Module Log("shaderc"); static logvisor::Module Log("shaderc");
#if _WIN32 #if _WIN32
#include <d3dcompiler.h>
extern pD3DCompile D3DCompilePROC;
pD3DCompile D3DCompilePROC = nullptr;
static bool FindBestD3DCompile()
{
HMODULE d3dCompilelib = LoadLibraryW(L"D3DCompiler_47.dll");
if (!d3dCompilelib)
{
d3dCompilelib = LoadLibraryW(L"D3DCompiler_46.dll");
if (!d3dCompilelib)
{
d3dCompilelib = LoadLibraryW(L"D3DCompiler_45.dll");
if (!d3dCompilelib)
{
d3dCompilelib = LoadLibraryW(L"D3DCompiler_44.dll");
if (!d3dCompilelib)
{
d3dCompilelib = LoadLibraryW(L"D3DCompiler_43.dll");
}
}
}
}
if (d3dCompilelib)
{
D3DCompilePROC = (pD3DCompile)GetProcAddress(d3dCompilelib, "D3DCompile");
return D3DCompilePROC != nullptr;
}
return false;
}
int wmain(int argc, const hecl::SystemChar** argv) int wmain(int argc, const hecl::SystemChar** argv)
#else #else
int main(int argc, const hecl::SystemChar** argv) int main(int argc, const hecl::SystemChar** argv)
@ -15,6 +46,14 @@ int main(int argc, const hecl::SystemChar** argv)
logvisor::RegisterConsoleLogger(); logvisor::RegisterConsoleLogger();
logvisor::RegisterStandardExceptions(); logvisor::RegisterStandardExceptions();
#if _WIN32
if (!FindBestD3DCompile())
{
Log.report(logvisor::Info, "Unable to find D3DCompiler dll");
return 1;
}
#endif
if (argc == 1) if (argc == 1)
{ {
Log.report(logvisor::Info, "Usage: shaderc -o <out-base> [-D definevar=defineval]... <in-files>..."); Log.report(logvisor::Info, "Usage: shaderc -o <out-base> [-D definevar=defineval]... <in-files>...");
@ -63,7 +102,7 @@ int main(int argc, const hecl::SystemChar** argv)
} }
hecl::SystemUTF8Conv conv(define); hecl::SystemUTF8Conv conv(define);
const char* defineU8 = conv.c_str(); const char* defineU8 = conv.c_str();
if (char* equals = strchr(defineU8, '=')) if (const char* equals = strchr(defineU8, '='))
c.addDefine(std::string(defineU8, equals - defineU8), equals + 1); c.addDefine(std::string(defineU8, equals - defineU8), equals + 1);
else else
c.addDefine(defineU8, ""); c.addDefine(defineU8, "");
@ -87,7 +126,7 @@ int main(int argc, const hecl::SystemChar** argv)
} }
hecl::SystemStringView baseName; hecl::SystemStringView baseName;
auto slashPos = outPath.find_last_of("/\\"); auto slashPos = outPath.find_last_of(_SYS_STR("/\\"));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
baseName = outPath.data() + slashPos + 1; baseName = outPath.data() + slashPos + 1;
else else
@ -105,22 +144,22 @@ int main(int argc, const hecl::SystemChar** argv)
return 1; return 1;
{ {
hecl::SystemString headerPath = outPath + _S(".hpp"); hecl::SystemString headerPath = outPath + _SYS_STR(".hpp");
athena::io::FileWriter w(headerPath); athena::io::FileWriter w(headerPath);
if (w.hasError()) if (w.hasError())
{ {
Log.report(logvisor::Error, _S("Error opening '%s' for writing"), headerPath.c_str()); Log.report(logvisor::Error, _SYS_STR("Error opening '%s' for writing"), headerPath.c_str());
return 1; return 1;
} }
w.writeBytes(ret.first.data(), ret.first.size()); w.writeBytes(ret.first.data(), ret.first.size());
} }
{ {
hecl::SystemString impPath = outPath + _S(".cpp"); hecl::SystemString impPath = outPath + _SYS_STR(".cpp");
athena::io::FileWriter w(impPath); athena::io::FileWriter w(impPath);
if (w.hasError()) if (w.hasError())
{ {
Log.report(logvisor::Error, _S("Error opening '%s' for writing"), impPath.c_str()); Log.report(logvisor::Error, _SYS_STR("Error opening '%s' for writing"), impPath.c_str());
return 1; return 1;
} }
w.writeBytes(ret.second.data(), ret.second.size()); w.writeBytes(ret.second.data(), ret.second.size());

64
hecl/shaderc/shaderc.cpp
View File

@ -7,6 +7,7 @@
#include <regex> #include <regex>
#include <unordered_map> #include <unordered_map>
#include <set> #include <set>
#include <bitset>
using namespace std::literals; using namespace std::literals;
@ -238,24 +239,24 @@ bool Compiler::includeFile(SystemStringView file, std::string& out, int depth)
{ {
if (depth > 32) if (depth > 32)
{ {
Log.report(logvisor::Error, _S("Too many levels of includes (>32) at '%s'"), file.data()); Log.report(logvisor::Error, _SYS_STR("Too many levels of includes (>32) at '%s'"), file.data());
return false; return false;
} }
const std::string* data = getFileContents(file); const std::string* data = getFileContents(file);
if (!data) if (!data)
{ {
Log.report(logvisor::Error, _S("Unable to access '%s'"), file.data()); Log.report(logvisor::Error, _SYS_STR("Unable to access '%s'"), file.data());
return false; return false;
} }
const std::string& sdata = *data; const std::string& sdata = *data;
SystemString directory; SystemString directory;
auto slashPos = file.find_last_of("/\\"); auto slashPos = file.find_last_of(_SYS_STR("/\\"));
if (slashPos != SystemString::npos) if (slashPos != SystemString::npos)
directory = SystemString(file.begin(), file.begin() + slashPos); directory = SystemString(file.begin(), file.begin() + slashPos);
else else
directory = _S("."); directory = _SYS_STR(".");
auto begin = sdata.cbegin(); auto begin = sdata.cbegin();
auto end = sdata.cend(); auto end = sdata.cend();
@ -274,13 +275,13 @@ bool Compiler::includeFile(SystemStringView file, std::string& out, int depth)
std::string path = subMatch[1].str(); std::string path = subMatch[1].str();
if (path.empty()) if (path.empty())
{ {
Log.report(logvisor::Error, _S("Empty path provided to include in '%s'"), file.data()); Log.report(logvisor::Error, _SYS_STR("Empty path provided to include in '%s'"), file.data());
return false; return false;
} }
hecl::SystemString pathStr(hecl::SystemStringConv(path).sys_str()); hecl::SystemString pathStr(hecl::SystemStringConv(path).sys_str());
if (!hecl::IsAbsolute(pathStr)) if (!hecl::IsAbsolute(pathStr))
pathStr = directory + _S('/') + pathStr; pathStr = directory + _SYS_STR('/') + pathStr;
if (!includeFile(pathStr, out, depth + 1)) if (!includeFile(pathStr, out, depth + 1))
return false; return false;
} }
@ -871,58 +872,15 @@ bool Compiler::compileFile(SystemStringView file, std::string_view baseName, std
} }
out.first += "\n"; out.first += "\n";
out.first += "#define OPENGL_STAGES_"; out.first += "#define STAGES_";
out.first += baseName; out.first += baseName;
out.first += "(P, S)";
for (const auto& shader : shaderStageUses) for (const auto& shader : shaderStageUses)
{ {
out.first += " \\\n"; out.first += " \\\n";
out.first += "STAGE_SPECIALIZATIONS(::StageObject_"; out.first += "::StageObject_";
out.first += shader.first; out.first += shader.first;
out.first += ", hecl::PlatformType::OpenGL)"; out.first += "<P, S>,";
}
out.first += "\n";
out.first += "#define VULKAN_STAGES_";
out.first += baseName;
for (const auto& shader : shaderStageUses)
{
out.first += " \\\n";
out.first += "STAGE_SPECIALIZATIONS(::StageObject_";
out.first += shader.first;
out.first += ", hecl::PlatformType::Vulkan)";
}
out.first += "\n";
out.first += "#define D3D11_STAGES_";
out.first += baseName;
for (const auto& shader : shaderStageUses)
{
out.first += " \\\n";
out.first += "STAGE_SPECIALIZATIONS(::StageObject_";
out.first += shader.first;
out.first += ", hecl::PlatformType::D3D11)";
}
out.first += "\n";
out.first += "#define METAL_STAGES_";
out.first += baseName;
for (const auto& shader : shaderStageUses)
{
out.first += " \\\n";
out.first += "STAGE_SPECIALIZATIONS(::StageObject_";
out.first += shader.first;
out.first += ", hecl::PlatformType::Metal)";
}
out.first += "\n";
out.first += "#define NX_STAGES_";
out.first += baseName;
for (const auto& shader : shaderStageUses)
{
out.first += " \\\n";
out.first += "STAGE_SPECIALIZATIONS(::StageObject_";
out.first += shader.first;
out.first += ", hecl::PlatformType::NX)";
} }
out.first += "\n"; out.first += "\n";

11
hecl/test/main.cpp
View File

@ -60,7 +60,7 @@ struct HECLApplicationCallback : boo::IApplicationCallback
bool m_running = true; bool m_running = true;
HECLApplicationCallback() HECLApplicationCallback()
: m_fileStoreMgr(_S("heclTest")), : m_fileStoreMgr(_SYS_STR("heclTest")),
m_cvarManager(m_fileStoreMgr), m_cvarManager(m_fileStoreMgr),
m_console(&m_cvarManager) m_console(&m_cvarManager)
{ {
@ -75,7 +75,7 @@ struct HECLApplicationCallback : boo::IApplicationCallback
hecl::VerbosityLevel = 2; hecl::VerbosityLevel = 2;
/* Setup boo window */ /* Setup boo window */
m_mainWindow = app->newWindow(_S("HECL Test")); m_mainWindow = app->newWindow(_SYS_STR("HECL Test"));
m_mainWindow->setCallback(&m_windowCb); m_mainWindow->setCallback(&m_windowCb);
boo::ObjToken<boo::ITextureR> renderTex; boo::ObjToken<boo::ITextureR> renderTex;
@ -130,7 +130,8 @@ struct HECLApplicationCallback : boo::IApplicationCallback
hecl::Backend::ShaderTag testShaderTag(testShader, 0, 1, 0, 0, boo::Primitive::TriStrips, hecl::Backend::ShaderTag testShaderTag(testShader, 0, 1, 0, 0, boo::Primitive::TriStrips,
hecl::Backend::ReflectionType::None, false, false, false); hecl::Backend::ReflectionType::None, false, false, false);
hecl::Frontend::Frontend FE; hecl::Frontend::Frontend FE;
hecl::HECLIR irObj(FE.compileSource(testShader, "booTest"), testShaderTag, 0); hecl::Frontend::IR ir = FE.compileSource(testShader, "booTest");
hecl::HECLIR irObj(ir, testShaderTag, 0);
gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx)
{ {
@ -277,7 +278,7 @@ int main(int argc, const boo::SystemChar** argv)
logvisor::RegisterConsoleLogger(); logvisor::RegisterConsoleLogger();
HECLApplicationCallback appCb; HECLApplicationCallback appCb;
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto, int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto,
appCb, _S("heclTest"), _S("HECL Test"), argc, argv); appCb, _SYS_STR("heclTest"), _SYS_STR("HECL Test"), argc, argv);
printf("IM DYING!!\n"); printf("IM DYING!!\n");
return ret; return ret;
} }
@ -291,7 +292,7 @@ int WINAPIV main(Platform::Array<Platform::String^>^ params)
logvisor::RegisterConsoleLogger(); logvisor::RegisterConsoleLogger();
HECLApplicationCallback appCb; HECLApplicationCallback appCb;
boo::ViewProvider^ viewProvider = boo::ViewProvider^ viewProvider =
ref new boo::ViewProvider(appCb, _S("heclTest"), _S("HECL Test"), _S("heclTest"), params, false); ref new boo::ViewProvider(appCb, _SYS_STR("heclTest"), _SYS_STR("HECL Test"), _SYS_STR("heclTest"), params, false);
CoreApplication::Run(viewProvider); CoreApplication::Run(viewProvider);
return 0; return 0;
} }

35
hecl/test/test.shader
View File

@ -1,3 +1,5 @@
#shader test
#culling none #culling none
#attribute position3 #attribute position3
#attribute normal3 #attribute normal3
@ -23,3 +25,36 @@ void main()
{ {
out_frag = texture(texs[0], out_uv); out_frag = texture(texs[0], out_uv);
} }
#vertex hlsl
struct VertData
{
float3 in_pos : POSITION;
float3 in_norm : NORMAL;
float2 in_uv : UV;
};
struct VertToFrag
{
float4 position : SV_Position;
float2 out_uv : UV;
};
VertToFrag main(in VertData v)
{
VertToFrag ret;
ret.position = float4(v.in_pos, 1.0);
ret.out_uv = v.in_uv;
return ret;
}
#fragment hlsl
struct VertToFrag
{
float4 position : SV_Position;
float2 out_uv : UV;
};
Texture2D texs : register(t0);
SamplerState samp : register(s0);
float4 main(in VertToFrag vtf) : SV_Target0
{
return texs.Sample(samp, vtf.out_uv);
}