AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Windows fixes

This commit is contained in:
Jack Andersen 2018-10-14 10:16:21 -10:00
parent 1559163f98
commit 1851308021
68 changed files with 1343 additions and 968 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -7,3 +7,4 @@ docs/*
.idea/dictionaries .idea/dictionaries
.idea/workspace.xml .idea/workspace.xml
.idea/misc.xml .idea/misc.xml
Editor/platforms/win/urde.rc

9
CMakeLists.txt
View File

@ -62,9 +62,12 @@ if(MSVC)
endif() endif()
# Shaddup MSVC # Shaddup MSVC
add_definitions(-DUNICODE=1 -D_UNICODE=1 -D__SSE__=1 -D_CRT_SECURE_NO_WARNINGS=1 -DD_SCL_SECURE_NO_WARNINGS=1 add_definitions(-DUNICODE=1 -D_UNICODE=1 -D__SSE__=1
-D_SCL_SECURE_NO_DEPRECATE=1 -D_CRT_NONSTDC_NO_WARNINGS=1 /IGNORE:4221 /wd4018 /wd4800 /wd4005 /wd4311 -D_CRT_SECURE_NO_WARNINGS=1 -DD_SCL_SECURE_NO_WARNINGS=1
/wd4267 /wd4244 /wd4200 /wd4305 /wd4067 /wd4146 /wd4309 /wd4805 ${VS_DEFINES}) -D_SCL_SECURE_NO_DEPRECATE=1 -D_CRT_NONSTDC_NO_WARNINGS=1
/IGNORE:4221 /wd4018 /wd4800 /wd4005 /wd4311
/wd4267 /wd4244 /wd4200 /wd4305 /wd4067 /wd4146 /wd4309 /wd4805
-D_ENABLE_EXTENDED_ALIGNED_STORAGE=1 ${VS_DEFINES})
if(WINDOWS_STORE) if(WINDOWS_STORE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /AI\"$ENV{PROGRAMFILES\(X86\)}/Microsoft Visual Studio/2017/Community/Common7/IDE/VC/vcpackages\" /AI\"$ENV{PROGRAMFILES\(X86\)}/Windows Kits/10/UnionMetadata\"") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /AI\"$ENV{PROGRAMFILES\(X86\)}/Microsoft Visual Studio/2017/Community/Common7/IDE/VC/vcpackages\" /AI\"$ENV{PROGRAMFILES\(X86\)}/Windows Kits/10/UnionMetadata\"")

2
DataSpec/AssetNameMap.cpp
View File

@ -37,7 +37,7 @@ void LoadAssetMap(athena::io::MemoryReader& ar)
if (ar.length() >= 4) if (ar.length() >= 4)
ar.readBytesToBuf(&magic, 4); ar.readBytesToBuf(&magic, 4);
if (magic != FOURCC('AIDM')) if (magic != FOURCC('AIDM'))
Log.report(logvisor::Warning, _S("Unable to load asset map; Assets will not have proper filenames for most files.")); Log.report(logvisor::Warning, _SYS_STR("Unable to load asset map; Assets will not have proper filenames for most files."));
else else
{ {
uint32_t assetCount = ar.readUint32Big(); uint32_t assetCount = ar.readUint32Big();

2
DataSpec/DNACommon/MAPA.cpp
View File

@ -379,7 +379,7 @@ bool Cook(const hecl::blender::MapArea& mapaIn, const hecl::ProjectPath& out)
{ {
if (mapaIn.verts.size() >= 256) if (mapaIn.verts.size() >= 256)
{ {
Log.report(logvisor::Error, _S("MAPA %s vertex range exceeded [%d/%d]"), Log.report(logvisor::Error, _SYS_STR("MAPA %s vertex range exceeded [%d/%d]"),
out.getRelativePath().data(), mapaIn.verts.size(), 255); out.getRelativePath().data(), mapaIn.verts.size(), 255);
return false; return false;
} }

2
DataSpec/DNACommon/MAPU.cpp
View File

@ -125,7 +125,7 @@ bool MAPU::Cook(const hecl::blender::MapUniverse& mapuIn, const hecl::ProjectPat
mapu.worlds.emplace_back(); mapu.worlds.emplace_back();
MAPU::World& wldOut = mapu.worlds.back(); MAPU::World& wldOut = mapu.worlds.back();
wldOut.name = wld.name; wldOut.name = wld.name;
wldOut.mlvl = hecl::ProjectPath(wld.worldPath, _S("!world.*")); wldOut.mlvl = hecl::ProjectPath(wld.worldPath, _SYS_STR("!world.*"));
wldOut.transform.xf[0] = wld.xf.val[0]; wldOut.transform.xf[0] = wld.xf.val[0];
wldOut.transform.xf[1] = wld.xf.val[1]; wldOut.transform.xf[1] = wld.xf.val[1];
wldOut.transform.xf[2] = wld.xf.val[2]; wldOut.transform.xf[2] = wld.xf.val[2];

2
DataSpec/DNACommon/MLVL.cpp
View File

@ -16,7 +16,7 @@ bool ReadMLVLToBlender(hecl::blender::Connection& conn,
bool force, bool force,
std::function<void(const hecl::SystemChar*)> fileChanged) std::function<void(const hecl::SystemChar*)> fileChanged)
{ {
hecl::ProjectPath blendPath = outPath.getWithExtension(_S(".blend"), true); hecl::ProjectPath blendPath = outPath.getWithExtension(_SYS_STR(".blend"), true);
if (!force && blendPath.isFile()) if (!force && blendPath.isFile())
return true; return true;

6
DataSpec/DNACommon/OBBTreeBuilder.cpp
View File

@ -1,4 +1,4 @@
#include <athena/Types.hpp> #include "athena/Types.hpp"
#include "OBBTreeBuilder.hpp" #include "OBBTreeBuilder.hpp"
#include "zeus/CTransform.hpp" #include "zeus/CTransform.hpp"
#include "DataSpec/DNAMP1/DCLN.hpp" #include "DataSpec/DNAMP1/DCLN.hpp"
@ -48,7 +48,9 @@ static FittedOBB BuildFromCovarianceMatrix(gmm::dense_matrix<float>& C,
// extract the eigenvalues and eigenvectors from C // extract the eigenvalues and eigenvectors from C
gmm::dense_matrix<float> eigvec(3,3); gmm::dense_matrix<float> eigvec(3,3);
std::vector<float> eigval(3); std::vector<float> eigval(3);
gmm::symmetric_qr_algorithm(C, eigval, eigvec); using namespace gmm;
using MAT1 = gmm::dense_matrix<float>;
gmm::symmetric_qr_algorithm(C, eigval, eigvec, default_tol_for_qr);
// find the right, up and forward vectors from the eigenvectors // find the right, up and forward vectors from the eigenvectors
zeus::CVector3f r(eigvec(0,0), eigvec(1,0), eigvec(2,0)); zeus::CVector3f r(eigvec(0,0), eigvec(1,0), eigvec(2,0));

12
DataSpec/DNACommon/PAK.cpp
View File

@ -264,7 +264,7 @@ hecl::ProjectPath PAKRouter<BRIDGETYPE>::getCharacterWorking(const EntryType* en
if (entry->type == FOURCC('EVNT')) if (entry->type == FOURCC('EVNT'))
{ {
hecl::SystemStringConv wideStr(characterSearch->second.second); hecl::SystemStringConv wideStr(characterSearch->second.second);
return characterPath.getWithExtension((hecl::SystemString(_S(".")) + wideStr.c_str()).c_str(), true); return characterPath.getWithExtension((hecl::SystemString(_SYS_STR(".")) + wideStr.c_str()).c_str(), true);
} }
return characterPath.ensureAuxInfo(characterSearch->second.second); return characterPath.ensureAuxInfo(characterSearch->second.second);
} }
@ -299,7 +299,7 @@ hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const EntryType* entry,
if (extractor.fileExts[0] && !extractor.fileExts[1]) if (extractor.fileExts[0] && !extractor.fileExts[1])
entName += extractor.fileExts[0]; entName += extractor.fileExts[0];
else if (extractor.fileExts[0]) else if (extractor.fileExts[0])
entName += _S(".*"); entName += _SYS_STR(".*");
else if (hecl::ProjectPath chWork = getCharacterWorking(entry)) else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
return chWork; return chWork;
return hecl::ProjectPath(pakPath, entName).ensureAuxInfo(auxInfo); return hecl::ProjectPath(pakPath, entName).ensureAuxInfo(auxInfo);
@ -320,7 +320,7 @@ hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const EntryType* entry,
if (extractor.fileExts[0] && !extractor.fileExts[1]) if (extractor.fileExts[0] && !extractor.fileExts[1])
entName += extractor.fileExts[0]; entName += extractor.fileExts[0];
else if (extractor.fileExts[0]) else if (extractor.fileExts[0])
entName += _S(".*"); entName += _SYS_STR(".*");
else if (hecl::ProjectPath chWork = getCharacterWorking(entry)) else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
return chWork; return chWork;
if (bridge.getPAK().m_noShare) if (bridge.getPAK().m_noShare)
@ -347,7 +347,7 @@ hecl::ProjectPath PAKRouter<BRIDGETYPE>::getWorking(const EntryType* entry,
if (extractor.fileExts[0] && !extractor.fileExts[1]) if (extractor.fileExts[0] && !extractor.fileExts[1])
entName += extractor.fileExts[0]; entName += extractor.fileExts[0];
else if (extractor.fileExts[0]) else if (extractor.fileExts[0])
entName += _S(".*"); entName += _SYS_STR(".*");
else if (hecl::ProjectPath chWork = getCharacterWorking(entry)) else if (hecl::ProjectPath chWork = getCharacterWorking(entry))
return chWork; return chWork;
hecl::ProjectPath sharedPath(m_sharedWorking, entName); hecl::ProjectPath sharedPath(m_sharedWorking, entName);
@ -442,7 +442,7 @@ hecl::SystemString PAKRouter<BRIDGETYPE>::getResourceRelativePath(const EntryTyp
hecl::ProjectPath aPath = getWorking(&a, BRIDGETYPE::LookupExtractor(*node, *pak, a)); hecl::ProjectPath aPath = getWorking(&a, BRIDGETYPE::LookupExtractor(*node, *pak, a));
hecl::SystemString ret; hecl::SystemString ret;
for (int i=0 ; i<aPath.levelCount() ; ++i) for (int i=0 ; i<aPath.levelCount() ; ++i)
ret += _S("../"); ret += _SYS_STR("../");
hecl::ProjectPath bPath = getWorking(be, BRIDGETYPE::LookupExtractor(*node, *pak, *be)); hecl::ProjectPath bPath = getWorking(be, BRIDGETYPE::LookupExtractor(*node, *pak, *be));
ret += bPath.getRelativePath(); ret += bPath.getRelativePath();
return ret; return ret;
@ -543,7 +543,7 @@ bool PAKRouter<BRIDGETYPE>::extractResources(const BRIDGETYPE& pakBridge, bool f
{ {
cooked.makeDirChain(false); cooked.makeDirChain(false);
PAKEntryReadStream s = entryPtr->beginReadStream(*node); PAKEntryReadStream s = entryPtr->beginReadStream(*node);
FILE* fout = hecl::Fopen(cooked.getAbsolutePath().data(), _S("wb")); FILE* fout = hecl::Fopen(cooked.getAbsolutePath().data(), _SYS_STR("wb"));
fwrite(s.data(), 1, s.length(), fout); fwrite(s.data(), 1, s.length(), fout);
fclose(fout); fclose(fout);
} }

36
DataSpec/DNACommon/TXTR.cpp
View File

@ -1013,11 +1013,11 @@ bool TXTR::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
uint16_t height = rs.readUint16Big(); uint16_t height = rs.readUint16Big();
uint32_t numMips = rs.readUint32Big(); uint32_t numMips = rs.readUint32Big();
FILE* fp = hecl::Fopen(outPath.getAbsolutePath().data(), _S("wb")); FILE* fp = hecl::Fopen(outPath.getAbsolutePath().data(), _SYS_STR("wb"));
if (!fp) if (!fp)
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for writing"), _SYS_STR("Unable to open '%s' for writing"),
outPath.getAbsolutePath().data()); outPath.getAbsolutePath().data());
return false; return false;
} }
@ -1271,11 +1271,11 @@ static int GetNumPaletteEntriesForGCN(png_structp png, png_infop info)
bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath)
{ {
FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _S("rb")); FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _SYS_STR("rb"));
if (!inf) if (!inf)
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for reading"), _SYS_STR("Unable to open '%s' for reading"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
return false; return false;
} }
@ -1285,7 +1285,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
fread(header, 1, 8, inf); fread(header, 1, 8, inf);
if (png_sig_cmp((png_const_bytep)header, 0, 8)) if (png_sig_cmp((png_const_bytep)header, 0, 8))
{ {
Log.report(logvisor::Error, _S("invalid PNG signature in '%s'"), Log.report(logvisor::Error, _SYS_STR("invalid PNG signature in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
return false; return false;
@ -1310,7 +1310,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
if (setjmp(png_jmpbuf(pngRead))) if (setjmp(png_jmpbuf(pngRead)))
{ {
Log.report(logvisor::Error, _S("unable to initialize libpng I/O for '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to initialize libpng I/O for '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1356,7 +1356,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
if (bitDepth != 8) if (bitDepth != 8)
{ {
Log.report(logvisor::Error, _S("'%s' is not 8 bits-per-channel"), Log.report(logvisor::Error, _SYS_STR("'%s' is not 8 bits-per-channel"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1390,7 +1390,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
nComps = 1; nComps = 1;
break; break;
default: default:
Log.report(logvisor::Error, _S("unsupported color type in '%s'"), Log.report(logvisor::Error, _SYS_STR("unsupported color type in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1413,7 +1413,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
if (setjmp(png_jmpbuf(pngRead))) if (setjmp(png_jmpbuf(pngRead)))
{ {
Log.report(logvisor::Error, _S("unable to read image in '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to read image in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1629,7 +1629,7 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
if (outf.hasError()) if (outf.hasError())
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for writing"), _SYS_STR("Unable to open '%s' for writing"),
outPath.getAbsolutePath().data()); outPath.getAbsolutePath().data());
return false; return false;
} }
@ -1645,11 +1645,11 @@ bool TXTR::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPat
bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath)
{ {
FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _S("rb")); FILE* inf = hecl::Fopen(inPath.getAbsolutePath().data(), _SYS_STR("rb"));
if (!inf) if (!inf)
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for reading"), _SYS_STR("Unable to open '%s' for reading"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
return false; return false;
} }
@ -1659,7 +1659,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
fread(header, 1, 8, inf); fread(header, 1, 8, inf);
if (png_sig_cmp((png_const_bytep)header, 0, 8)) if (png_sig_cmp((png_const_bytep)header, 0, 8))
{ {
Log.report(logvisor::Error, _S("invalid PNG signature in '%s'"), Log.report(logvisor::Error, _SYS_STR("invalid PNG signature in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
return false; return false;
@ -1684,7 +1684,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
if (setjmp(png_jmpbuf(pngRead))) if (setjmp(png_jmpbuf(pngRead)))
{ {
Log.report(logvisor::Error, _S("unable to initialize libpng I/O for '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to initialize libpng I/O for '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1722,7 +1722,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
if (bitDepth != 8) if (bitDepth != 8)
{ {
Log.report(logvisor::Error, _S("'%s' is not 8 bits-per-channel"), Log.report(logvisor::Error, _SYS_STR("'%s' is not 8 bits-per-channel"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1754,7 +1754,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
paletteBuf = ReadPalette(pngRead, info, paletteSize); paletteBuf = ReadPalette(pngRead, info, paletteSize);
break; break;
default: default:
Log.report(logvisor::Error, _S("unsupported color type in '%s'"), Log.report(logvisor::Error, _SYS_STR("unsupported color type in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1775,7 +1775,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
if (setjmp(png_jmpbuf(pngRead))) if (setjmp(png_jmpbuf(pngRead)))
{ {
Log.report(logvisor::Error, _S("unable to read image in '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to read image in '%s'"),
inPath.getAbsolutePath().data()); inPath.getAbsolutePath().data());
fclose(inf); fclose(inf);
png_destroy_read_struct(&pngRead, &info, nullptr); png_destroy_read_struct(&pngRead, &info, nullptr);
@ -1908,7 +1908,7 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
if (outf.hasError()) if (outf.hasError())
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for writing"), _SYS_STR("Unable to open '%s' for writing"),
outPath.getAbsolutePath().data()); outPath.getAbsolutePath().data());
return false; return false;
} }

4
DataSpec/DNAMP1/AGSC.cpp
View File

@ -195,7 +195,7 @@ bool AGSC::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& dir)
/* Write out project/pool */ /* Write out project/pool */
{ {
auto projd = group.getProj().toYAML(); auto projd = group.getProj().toYAML();
athena::io::FileWriter fo(hecl::ProjectPath(dir, _S("!project.yaml")).getAbsolutePath()); athena::io::FileWriter fo(hecl::ProjectPath(dir, _SYS_STR("!project.yaml")).getAbsolutePath());
if (fo.hasError()) if (fo.hasError())
return false; return false;
fo.writeUBytes(projd.data(), projd.size()); fo.writeUBytes(projd.data(), projd.size());
@ -203,7 +203,7 @@ bool AGSC::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& dir)
{ {
auto poold = group.getPool().toYAML(); auto poold = group.getPool().toYAML();
athena::io::FileWriter fo(hecl::ProjectPath(dir, _S("!pool.yaml")).getAbsolutePath()); athena::io::FileWriter fo(hecl::ProjectPath(dir, _SYS_STR("!pool.yaml")).getAbsolutePath());
if (fo.hasError()) if (fo.hasError())
return false; return false;
fo.writeUBytes(poold.data(), poold.size()); fo.writeUBytes(poold.data(), poold.size());

84
DataSpec/DNAMP1/ANCS.cpp
View File

@ -1089,9 +1089,9 @@ bool ANCS::Extract(const SpecBase& dataSpec,
hecl::blender::Token& btok, hecl::blender::Token& btok,
std::function<void(const hecl::SystemChar*)> fileChanged) std::function<void(const hecl::SystemChar*)> fileChanged)
{ {
hecl::ProjectPath yamlPath = outPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = outPath.getWithExtension(_SYS_STR(".yaml"), true);
hecl::ProjectPath::Type yamlType = yamlPath.getPathType(); hecl::ProjectPath::Type yamlType = yamlPath.getPathType();
hecl::ProjectPath blendPath = outPath.getWithExtension(_S(".blend"), true); hecl::ProjectPath blendPath = outPath.getWithExtension(_SYS_STR(".blend"), true);
hecl::ProjectPath::Type blendType = blendPath.getPathType(); hecl::ProjectPath::Type blendType = blendPath.getPathType();
ANCS ancs; ANCS ancs;
@ -1123,9 +1123,9 @@ bool ANCS::Extract(const SpecBase& dataSpec,
if (res.second.evntId) if (res.second.evntId)
{ {
hecl::SystemStringConv sysStr(res.second.name); hecl::SystemStringConv sysStr(res.second.name);
hecl::ProjectPath evntYamlPath = outPath.getWithExtension((hecl::SystemString(_S(".")) + hecl::ProjectPath evntYamlPath = outPath.getWithExtension((hecl::SystemString(_SYS_STR(".")) +
sysStr.c_str() + sysStr.c_str() +
_S(".evnt.yaml")).c_str(), true); _SYS_STR(".evnt.yaml")).c_str(), true);
hecl::ProjectPath::Type evntYamlType = evntYamlPath.getPathType(); hecl::ProjectPath::Type evntYamlType = evntYamlPath.getPathType();
if (force || evntYamlType == hecl::ProjectPath::Type::None) if (force || evntYamlType == hecl::ProjectPath::Type::None)
@ -1148,26 +1148,26 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
const DNAANCS::Actor& actor) const DNAANCS::Actor& actor)
{ {
/* Search for yaml */ /* Search for yaml */
hecl::ProjectPath yamlPath = inPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = inPath.getWithExtension(_SYS_STR(".yaml"), true);
if (!yamlPath.isFile()) if (!yamlPath.isFile())
Log.report(logvisor::Fatal, _S("'%s' not found as file"), Log.report(logvisor::Fatal, _SYS_STR("'%s' not found as file"),
yamlPath.getRelativePath().data()); yamlPath.getRelativePath().data());
athena::io::FileReader reader(yamlPath.getAbsolutePath()); athena::io::FileReader reader(yamlPath.getAbsolutePath());
if (!reader.isOpen()) if (!reader.isOpen())
Log.report(logvisor::Fatal, _S("can't open '%s' for reading"), Log.report(logvisor::Fatal, _SYS_STR("can't open '%s' for reading"),
yamlPath.getRelativePath().data()); yamlPath.getRelativePath().data());
if (!athena::io::ValidateFromYAMLStream<ANCS>(reader)) if (!athena::io::ValidateFromYAMLStream<ANCS>(reader))
{ {
Log.report(logvisor::Fatal, _S("'%s' is not urde::DNAMP1::ANCS type"), Log.report(logvisor::Fatal, _SYS_STR("'%s' is not urde::DNAMP1::ANCS type"),
yamlPath.getRelativePath().data()); yamlPath.getRelativePath().data());
} }
athena::io::YAMLDocReader yamlReader; athena::io::YAMLDocReader yamlReader;
if (!yamlReader.parse(&reader)) if (!yamlReader.parse(&reader))
{ {
Log.report(logvisor::Fatal, _S("unable to parse '%s'"), Log.report(logvisor::Fatal, _SYS_STR("unable to parse '%s'"),
yamlPath.getRelativePath().data()); yamlPath.getRelativePath().data());
} }
ANCS ancs; ANCS ancs;
@ -1183,7 +1183,7 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
ch.cskrIce = UniqueID32Zero{}; ch.cskrIce = UniqueID32Zero{};
hecl::SystemStringConv chSysName(ch.name); hecl::SystemStringConv chSysName(ch.name);
ch.cskr = inPath.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _S(".CSKR")); ch.cskr = inPath.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _SYS_STR(".CSKR"));
int subtypeIdx = 0; int subtypeIdx = 0;
ch.animAABBs.clear(); ch.animAABBs.clear();
@ -1207,7 +1207,7 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
{ {
const DNAANCS::Armature& arm = actor.armatures[sub.armature]; const DNAANCS::Armature& arm = actor.armatures[sub.armature];
hecl::SystemStringConv armSysName(arm.name); hecl::SystemStringConv armSysName(arm.name);
ch.cinf = inPath.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _S(".CINF")); ch.cinf = inPath.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _SYS_STR(".CINF"));
ch.cmdl = sub.mesh; ch.cmdl = sub.mesh;
auto search = std::find_if(sub.overlayMeshes.cbegin(), sub.overlayMeshes.cend(), auto search = std::find_if(sub.overlayMeshes.cbegin(), sub.overlayMeshes.cend(),
[](const auto& p) { return p.first == "ICE"; }); [](const auto& p) { return p.first == "ICE"; });
@ -1215,8 +1215,8 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
{ {
hecl::SystemStringConv overlaySys(search->first); hecl::SystemStringConv overlaySys(search->first);
ch.cmdlIce = search->second; ch.cmdlIce = search->second;
ch.cskrIce = inPath.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _S('.') + ch.cskrIce = inPath.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _SYS_STR('.') +
overlaySys.c_str() + _S(".CSKR")); overlaySys.c_str() + _SYS_STR(".CSKR"));
} }
} }
@ -1235,7 +1235,7 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
ancs.enumeratePrimitives([&](AnimationSet::MetaAnimPrimitive& prim) -> bool ancs.enumeratePrimitives([&](AnimationSet::MetaAnimPrimitive& prim) -> bool
{ {
hecl::SystemStringConv sysStr(prim.animName); hecl::SystemStringConv sysStr(prim.animName);
hecl::ProjectPath pathOut = inPath.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S(".ANIM")); hecl::ProjectPath pathOut = inPath.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR(".ANIM"));
prim.animId = pathOut; prim.animId = pathOut;
return true; return true;
}); });
@ -1245,16 +1245,16 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
for (const DNAANCS::Action& act : actor.actions) for (const DNAANCS::Action& act : actor.actions)
{ {
hecl::SystemStringConv sysStr(act.name); hecl::SystemStringConv sysStr(act.name);
hecl::ProjectPath pathOut = inPath.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S(".ANIM")); hecl::ProjectPath pathOut = inPath.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR(".ANIM"));
ancs.animationSet.animResources.emplace_back(); ancs.animationSet.animResources.emplace_back();
ancs.animationSet.animResources.back().animId = pathOut; ancs.animationSet.animResources.back().animId = pathOut;
/* Check for associated EVNT YAML */ /* Check for associated EVNT YAML */
hecl::ProjectPath evntYamlPath = inPath.getWithExtension((hecl::SystemString(_S(".")) + hecl::ProjectPath evntYamlPath = inPath.getWithExtension((hecl::SystemString(_SYS_STR(".")) +
sysStr.c_str() + sysStr.c_str() +
_S(".evnt.yaml")).c_str(), true); _SYS_STR(".evnt.yaml")).c_str(), true);
evntYamlPath = evntYamlPath.ensureAuxInfo(_S("")); evntYamlPath = evntYamlPath.ensureAuxInfo(_SYS_STR(""));
if (evntYamlPath.isFile()) if (evntYamlPath.isFile())
ancs.animationSet.animResources.back().evntId = evntYamlPath; ancs.animationSet.animResources.back().evntId = evntYamlPath;
} }
@ -1299,7 +1299,7 @@ bool ANCS::CookCSKR(const hecl::ProjectPath& outPath,
hecl::SystemString subName(inPath.getAuxInfo().begin(), hecl::SystemString subName(inPath.getAuxInfo().begin(),
inPath.getAuxInfo().end() - 5); inPath.getAuxInfo().end() - 5);
hecl::SystemString overName; hecl::SystemString overName;
auto dotPos = subName.rfind(_S('.')); auto dotPos = subName.rfind(_SYS_STR('.'));
if (dotPos != hecl::SystemString::npos) if (dotPos != hecl::SystemString::npos)
{ {
overName = hecl::SystemString(subName.begin() + dotPos + 1, subName.end()); overName = hecl::SystemString(subName.begin() + dotPos + 1, subName.end());
@ -1316,7 +1316,7 @@ bool ANCS::CookCSKR(const hecl::ProjectPath& outPath,
} }
const DNAANCS::Actor::Subtype* subtype = nullptr; const DNAANCS::Actor::Subtype* subtype = nullptr;
if (subName != "ATTACH") if (subName != _SYS_STR("ATTACH"))
{ {
for (const DNAANCS::Actor::Subtype& sub : actor.subtypes) for (const DNAANCS::Actor::Subtype& sub : actor.subtypes)
{ {
@ -1327,11 +1327,11 @@ bool ANCS::CookCSKR(const hecl::ProjectPath& outPath,
} }
} }
if (!subtype) if (!subtype)
Log.report(logvisor::Fatal, _S("unable to find subtype '%s'"), subName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to find subtype '%s'"), subName.c_str());
} }
const hecl::ProjectPath* modelPath = nullptr; const hecl::ProjectPath* modelPath = nullptr;
if (subName == "ATTACH") if (subName == _SYS_STR("ATTACH"))
{ {
const DNAANCS::Actor::Attachment* attachment = nullptr; const DNAANCS::Actor::Attachment* attachment = nullptr;
for (const DNAANCS::Actor::Attachment& att : actor.attachments) for (const DNAANCS::Actor::Attachment& att : actor.attachments)
@ -1343,7 +1343,7 @@ bool ANCS::CookCSKR(const hecl::ProjectPath& outPath,
} }
} }
if (!attachment) if (!attachment)
Log.report(logvisor::Fatal, _S("unable to find attachment '%s'"), overName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to find attachment '%s'"), overName.c_str());
modelPath = &attachment->mesh; modelPath = &attachment->mesh;
} }
else if (overName.empty()) else if (overName.empty())
@ -1360,19 +1360,19 @@ bool ANCS::CookCSKR(const hecl::ProjectPath& outPath,
} }
} }
if (!modelPath) if (!modelPath)
Log.report(logvisor::Fatal, _S("unable to resolve model path of %s:%s"), subName.c_str(), overName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to resolve model path of %s:%s"), subName.c_str(), overName.c_str());
if (!modelPath->isFile()) if (!modelPath->isFile())
Log.report(logvisor::Fatal, _S("unable to resolve '%s'"), modelPath->getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to resolve '%s'"), modelPath->getRelativePath().data());
hecl::ProjectPath skinIntPath = modelPath->getCookedPath(SpecEntMP1).getWithExtension(_S(".skinint")); hecl::ProjectPath skinIntPath = modelPath->getCookedPath(SpecEntMP1).getWithExtension(_SYS_STR(".skinint"));
if (!skinIntPath.isFileOrGlob() || skinIntPath.getModtime() < modelPath->getModtime()) if (!skinIntPath.isFileOrGlob() || skinIntPath.getModtime() < modelPath->getModtime())
if (!modelCookFunc(*modelPath)) if (!modelCookFunc(*modelPath))
Log.report(logvisor::Fatal, _S("unable to cook '%s'"), modelPath->getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to cook '%s'"), modelPath->getRelativePath().data());
athena::io::FileReader skinIO(skinIntPath.getAbsolutePath(), 1024*32, false); athena::io::FileReader skinIO(skinIntPath.getAbsolutePath(), 1024*32, false);
if (skinIO.hasError()) if (skinIO.hasError())
Log.report(logvisor::Fatal, _S("unable to open '%s'"), skinIntPath.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to open '%s'"), skinIntPath.getRelativePath().data());
std::vector<std::string> boneNames; std::vector<std::string> boneNames;
uint32_t boneNameCount = skinIO.readUint32Big(); uint32_t boneNameCount = skinIO.readUint32Big();
@ -1437,7 +1437,7 @@ bool ANCS::CookCSKRPC(const hecl::ProjectPath& outPath,
hecl::SystemString subName(inPath.getAuxInfo().begin(), hecl::SystemString subName(inPath.getAuxInfo().begin(),
inPath.getAuxInfo().end() - 5); inPath.getAuxInfo().end() - 5);
hecl::SystemString overName; hecl::SystemString overName;
auto dotPos = subName.rfind(_S('.')); auto dotPos = subName.rfind(_SYS_STR('.'));
if (dotPos != hecl::SystemString::npos) if (dotPos != hecl::SystemString::npos)
{ {
overName = hecl::SystemString(subName.begin() + dotPos + 1, subName.end()); overName = hecl::SystemString(subName.begin() + dotPos + 1, subName.end());
@ -1454,7 +1454,7 @@ bool ANCS::CookCSKRPC(const hecl::ProjectPath& outPath,
} }
const DNAANCS::Actor::Subtype* subtype = nullptr; const DNAANCS::Actor::Subtype* subtype = nullptr;
if (subName != "ATTACH") if (subName != _SYS_STR("ATTACH"))
{ {
for (const DNAANCS::Actor::Subtype& sub : actor.subtypes) for (const DNAANCS::Actor::Subtype& sub : actor.subtypes)
{ {
@ -1465,11 +1465,11 @@ bool ANCS::CookCSKRPC(const hecl::ProjectPath& outPath,
} }
} }
if (!subtype) if (!subtype)
Log.report(logvisor::Fatal, _S("unable to find subtype '%s'"), subName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to find subtype '%s'"), subName.c_str());
} }
const hecl::ProjectPath* modelPath = nullptr; const hecl::ProjectPath* modelPath = nullptr;
if (subName == "ATTACH") if (subName == _SYS_STR("ATTACH"))
{ {
const DNAANCS::Actor::Attachment* attachment = nullptr; const DNAANCS::Actor::Attachment* attachment = nullptr;
for (const DNAANCS::Actor::Attachment& att : actor.attachments) for (const DNAANCS::Actor::Attachment& att : actor.attachments)
@ -1481,7 +1481,7 @@ bool ANCS::CookCSKRPC(const hecl::ProjectPath& outPath,
} }
} }
if (!attachment) if (!attachment)
Log.report(logvisor::Fatal, _S("unable to find attachment '%s'"), overName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to find attachment '%s'"), overName.c_str());
modelPath = &attachment->mesh; modelPath = &attachment->mesh;
} }
else if (overName.empty()) else if (overName.empty())
@ -1498,19 +1498,19 @@ bool ANCS::CookCSKRPC(const hecl::ProjectPath& outPath,
} }
} }
if (!modelPath) if (!modelPath)
Log.report(logvisor::Fatal, _S("unable to resolve model path of %s:%s"), subName.c_str(), overName.c_str()); Log.report(logvisor::Fatal, _SYS_STR("unable to resolve model path of %s:%s"), subName.c_str(), overName.c_str());
if (!modelPath->isFile()) if (!modelPath->isFile())
Log.report(logvisor::Fatal, _S("unable to resolve '%s'"), modelPath->getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to resolve '%s'"), modelPath->getRelativePath().data());
hecl::ProjectPath skinIntPath = modelPath->getCookedPath(SpecEntMP1PC).getWithExtension(_S(".skinint")); hecl::ProjectPath skinIntPath = modelPath->getCookedPath(SpecEntMP1PC).getWithExtension(_SYS_STR(".skinint"));
if (!skinIntPath.isFileOrGlob() || skinIntPath.getModtime() < modelPath->getModtime()) if (!skinIntPath.isFileOrGlob() || skinIntPath.getModtime() < modelPath->getModtime())
if (!modelCookFunc(*modelPath)) if (!modelCookFunc(*modelPath))
Log.report(logvisor::Fatal, _S("unable to cook '%s'"), modelPath->getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to cook '%s'"), modelPath->getRelativePath().data());
athena::io::FileReader skinIO(skinIntPath.getAbsolutePath(), 1024*32, false); athena::io::FileReader skinIO(skinIntPath.getAbsolutePath(), 1024*32, false);
if (skinIO.hasError()) if (skinIO.hasError())
Log.report(logvisor::Fatal, _S("unable to open '%s'"), skinIntPath.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to open '%s'"), skinIntPath.getRelativePath().data());
std::vector<std::vector<uint32_t>> skinBanks; std::vector<std::vector<uint32_t>> skinBanks;
uint32_t bankCount = skinIO.readUint32Big(); uint32_t bankCount = skinIO.readUint32Big();
@ -1605,7 +1605,7 @@ bool ANCS::CookANIM(const hecl::ProjectPath& outPath,
DNAANCS::Action action = ds.compileActionChannelsOnly(actNameView.str()); DNAANCS::Action action = ds.compileActionChannelsOnly(actNameView.str());
if (!actor.armatures.size()) if (!actor.armatures.size())
Log.report(logvisor::Fatal, _S("0 armatures in %s"), Log.report(logvisor::Fatal, _SYS_STR("0 armatures in %s"),
inPath.getRelativePath().data()); inPath.getRelativePath().data());
/* Build bone ID map */ /* Build bone ID map */
@ -1629,9 +1629,9 @@ bool ANCS::CookANIM(const hecl::ProjectPath& outPath,
ANIM anim(action, boneIdMap, *rigInv, pc); ANIM anim(action, boneIdMap, *rigInv, pc);
/* Check for associated EVNT YAML */ /* Check for associated EVNT YAML */
hecl::ProjectPath evntYamlPath = inPath.getWithExtension((hecl::SystemString(_S(".")) + actName + hecl::ProjectPath evntYamlPath = inPath.getWithExtension((hecl::SystemString(_SYS_STR(".")) + actName +
_S(".evnt.yaml")).c_str(), true); _SYS_STR(".evnt.yaml")).c_str(), true);
evntYamlPath = evntYamlPath.ensureAuxInfo(_S("")); evntYamlPath = evntYamlPath.ensureAuxInfo(_SYS_STR(""));
if (evntYamlPath.isFile()) if (evntYamlPath.isFile())
anim.m_anim->evnt = evntYamlPath; anim.m_anim->evnt = evntYamlPath;

10
DataSpec/DNAMP1/CMDL.cpp
View File

@ -36,14 +36,14 @@ bool CMDL::Extract(const SpecBase& dataSpec,
#if 0 #if 0
/* Cook and re-extract test */ /* Cook and re-extract test */
hecl::ProjectPath tempOut = outPath.getWithExtension(_S(".recook"), true); hecl::ProjectPath tempOut = outPath.getWithExtension(_SYS_STR(".recook"), true);
hecl::blender::Connection::DataStream ds = conn.beginData(); hecl::blender::Connection::DataStream ds = conn.beginData();
DNACMDL::Mesh mesh = ds.compileMesh(hecl::TopologyTriStrips, -1); DNACMDL::Mesh mesh = ds.compileMesh(hecl::TopologyTriStrips, -1);
ds.close(); ds.close();
DNACMDL::WriteCMDL<MaterialSet, DNACMDL::SurfaceHeader_1_2, 2>(tempOut, outPath, mesh); DNACMDL::WriteCMDL<MaterialSet, DNACMDL::SurfaceHeader_1_2, 2>(tempOut, outPath, mesh);
athena::io::FileReader reader(tempOut.getAbsolutePath()); athena::io::FileReader reader(tempOut.getAbsolutePath());
hecl::ProjectPath tempBlend = outPath.getWithExtension(_S(".recook.blend"), true); hecl::ProjectPath tempBlend = outPath.getWithExtension(_SYS_STR(".recook.blend"), true);
if (!conn.createBlend(tempBlend, hecl::blender::Connection::TypeMesh)) if (!conn.createBlend(tempBlend, hecl::blender::Connection::TypeMesh))
return false; return false;
DNACMDL::ReadCMDLToBlender<PAKRouter<PAKBridge>, MaterialSet, std::pair<CSKR*,CINF*>, DNACMDL::SurfaceHeader_1_2, 2> DNACMDL::ReadCMDLToBlender<PAKRouter<PAKBridge>, MaterialSet, std::pair<CSKR*,CINF*>, DNACMDL::SurfaceHeader_1_2, 2>
@ -51,7 +51,7 @@ bool CMDL::Extract(const SpecBase& dataSpec,
return conn.saveBlend(); return conn.saveBlend();
#elif 0 #elif 0
/* HMDL cook test */ /* HMDL cook test */
hecl::ProjectPath tempOut = outPath.getWithExtension(_S(".recook"), true); hecl::ProjectPath tempOut = outPath.getWithExtension(_SYS_STR(".recook"), true);
hecl::blender::Connection::DataStream ds = conn.beginData(); hecl::blender::Connection::DataStream ds = conn.beginData();
DNACMDL::Mesh mesh = ds.compileMesh(hecl::HMDLTopology::TriStrips, 16); DNACMDL::Mesh mesh = ds.compileMesh(hecl::HMDLTopology::TriStrips, 16);
ds.close(); ds.close();
@ -73,7 +73,7 @@ bool CMDL::Cook(const hecl::ProjectPath& outPath,
/* Output skinning intermediate */ /* Output skinning intermediate */
auto vertCountIt = skinMesh.contiguousSkinVertCounts.cbegin(); auto vertCountIt = skinMesh.contiguousSkinVertCounts.cbegin();
athena::io::FileWriter writer(outPath.getWithExtension(_S(".skinint")).getAbsolutePath()); athena::io::FileWriter writer(outPath.getWithExtension(_SYS_STR(".skinint")).getAbsolutePath());
writer.writeUint32Big(skinMesh.boneNames.size()); writer.writeUint32Big(skinMesh.boneNames.size());
for (const std::string& boneName : skinMesh.boneNames) for (const std::string& boneName : skinMesh.boneNames)
writer.writeString(boneName); writer.writeString(boneName);
@ -109,7 +109,7 @@ bool CMDL::HMDLCook(const hecl::ProjectPath& outPath,
return false; return false;
/* Output skinning intermediate */ /* Output skinning intermediate */
athena::io::FileWriter writer(outPath.getWithExtension(_S(".skinint")).getAbsolutePath()); athena::io::FileWriter writer(outPath.getWithExtension(_SYS_STR(".skinint")).getAbsolutePath());
writer.writeUint32Big(mesh.skinBanks.banks.size()); writer.writeUint32Big(mesh.skinBanks.banks.size());
for (const DNACMDL::Mesh::SkinBanks::Bank& sb : mesh.skinBanks.banks) for (const DNACMDL::Mesh::SkinBanks::Bank& sb : mesh.skinBanks.banks)
{ {

12
DataSpec/DNAMP1/CSNG.cpp
View File

@ -6,8 +6,8 @@ namespace DataSpec::DNAMP1
bool CSNG::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath) bool CSNG::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{ {
hecl::ProjectPath midPath = outPath.getWithExtension(_S(".mid"), true); hecl::ProjectPath midPath = outPath.getWithExtension(_SYS_STR(".mid"), true);
hecl::ProjectPath yamlPath = outPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = outPath.getWithExtension(_SYS_STR(".yaml"), true);
Header head; Header head;
head.read(rs); head.read(rs);
@ -38,9 +38,9 @@ bool CSNG::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
} }
/* Update !songs.yaml for Amuse editor */ /* Update !songs.yaml for Amuse editor */
hecl::ProjectPath audGrp(outPath.getParentPath().getParentPath(), _S("AudioGrp")); hecl::ProjectPath audGrp(outPath.getParentPath().getParentPath(), _SYS_STR("AudioGrp"));
audGrp.makeDirChain(true); audGrp.makeDirChain(true);
hecl::ProjectPath songsPath(audGrp, _S("!songs.yaml")); hecl::ProjectPath songsPath(audGrp, _SYS_STR("!songs.yaml"));
std::experimental::optional<athena::io::FileReader> r; std::experimental::optional<athena::io::FileReader> r;
if (songsPath.isFile()) if (songsPath.isFile())
r.emplace(songsPath.getAbsolutePath()); r.emplace(songsPath.getAbsolutePath());
@ -57,8 +57,8 @@ bool CSNG::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
bool CSNG::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath) bool CSNG::Cook(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outPath)
{ {
hecl::ProjectPath midPath = inPath.getWithExtension(_S(".mid"), true); hecl::ProjectPath midPath = inPath.getWithExtension(_SYS_STR(".mid"), true);
hecl::ProjectPath yamlPath = inPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = inPath.getWithExtension(_SYS_STR(".yaml"), true);
std::vector<uint8_t> sngData; std::vector<uint8_t> sngData;
{ {

2
DataSpec/DNAMP1/DCLN.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <athena/Types.hpp> #include "athena/Types.hpp"
#include "DataSpec/DNACommon/DeafBabe.hpp" #include "DataSpec/DNACommon/DeafBabe.hpp"
#include "DataSpec/DNACommon/PAK.hpp" #include "DataSpec/DNACommon/PAK.hpp"
#include "DataSpec/DNACommon/OBBTreeBuilder.hpp" #include "DataSpec/DNACommon/OBBTreeBuilder.hpp"

98
DataSpec/DNAMP1/DNAMP1.cpp
View File

@ -83,7 +83,7 @@ PAKBridge::PAKBridge(const nod::Node& node, bool doExtract)
STRG mlvlName; STRG mlvlName;
mlvlName.read(rs); mlvlName.read(rs);
if (m_levelString.size()) if (m_levelString.size())
m_levelString += _S(", "); m_levelString += _SYS_STR(", ");
m_levelString += mlvlName.getSystemString(FOURCC('ENGL'), 0); m_levelString += mlvlName.getSystemString(FOURCC('ENGL'), 0);
} }
} }
@ -94,8 +94,8 @@ static hecl::SystemString LayerName(std::string_view name)
{ {
hecl::SystemString ret(hecl::SystemStringConv(name).sys_str()); hecl::SystemString ret(hecl::SystemStringConv(name).sys_str());
for (auto& ch : ret) for (auto& ch : ret)
if (ch == _S('/') || ch == _S('\\')) if (ch == _SYS_STR('/') || ch == _SYS_STR('\\'))
ch = _S('-'); ch = _SYS_STR('-');
return ret; return ret;
} }
@ -162,10 +162,10 @@ void PAKBridge::build()
if (areaDeps.name.empty()) if (areaDeps.name.empty())
{ {
std::string idStr = area.areaMREAId.toString(); std::string idStr = area.areaMREAId.toString();
areaDeps.name = hecl::SystemString(_S("MREA_")) + hecl::SystemStringConv(idStr).c_str(); areaDeps.name = hecl::SystemString(_SYS_STR("MREA_")) + hecl::SystemStringConv(idStr).c_str();
} }
hecl::SystemChar num[16]; hecl::SystemChar num[16];
hecl::SNPrintf(num, 16, _S("%02u "), ai); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), ai);
areaDeps.name = num + areaDeps.name; areaDeps.name = num + areaDeps.name;
std::string lowerName(hecl::SystemUTF8Conv(areaDeps.name).str()); std::string lowerName(hecl::SystemUTF8Conv(areaDeps.name).str());
@ -191,7 +191,7 @@ void PAKBridge::build()
layer.active = layerFlags.flags >> (l-1) & 0x1; layer.active = layerFlags.flags >> (l-1) & 0x1;
layer.name = hecl::StringUtils::TrimWhitespace(layer.name); layer.name = hecl::StringUtils::TrimWhitespace(layer.name);
hecl::SNPrintf(num, 16, _S("%02u "), l-1); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), l-1);
layer.name = num + layer.name; layer.name = num + layer.name;
layer.resources.reserve(area.depLayers[l] - r); layer.resources.reserve(area.depLayers[l] - r);
@ -307,7 +307,7 @@ void PAKBridge::addMAPATransforms(PAKRouter<PAKBridge>& pakRouter,
hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath(); hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath();
if (mlvl.worldNameId) if (mlvl.worldNameId)
pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _S("!name.yaml")); pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _SYS_STR("!name.yaml"));
for (const MLVL::Area& area : mlvl.areas) for (const MLVL::Area& area : mlvl.areas)
{ {
@ -327,7 +327,7 @@ void PAKBridge::addMAPATransforms(PAKRouter<PAKBridge>& pakRouter,
hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath(); hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath();
if (area.areaNameId) if (area.areaNameId)
pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _S("!name.yaml")); pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _SYS_STR("!name.yaml"));
} }
if (mlvl.worldMap) if (mlvl.worldMap)
@ -365,57 +365,57 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const nod::Node& pakNode, con
switch (entry.type) switch (entry.type)
{ {
case SBIG('STRG'): case SBIG('STRG'):
return {STRG::Extract, {_S(".yaml")}}; return {STRG::Extract, {_SYS_STR(".yaml")}};
case SBIG('SCAN'): case SBIG('SCAN'):
return {SCAN::Extract, {_S(".yaml")}, 0, SCAN::Name}; return {SCAN::Extract, {_SYS_STR(".yaml")}, 0, SCAN::Name};
case SBIG('HINT'): case SBIG('HINT'):
return {HINT::Extract, {_S(".yaml")}}; return {HINT::Extract, {_SYS_STR(".yaml")}};
case SBIG('SAVW'): case SBIG('SAVW'):
return {SAVWCommon::ExtractSAVW<SAVW>, {_S(".yaml")}}; return {SAVWCommon::ExtractSAVW<SAVW>, {_SYS_STR(".yaml")}};
case SBIG('TXTR'): case SBIG('TXTR'):
return {TXTR::Extract, {_S(".png")}}; return {TXTR::Extract, {_SYS_STR(".png")}};
case SBIG('AFSM'): case SBIG('AFSM'):
return {AFSM::Extract, {_S(".yaml")}}; return {AFSM::Extract, {_SYS_STR(".yaml")}};
case SBIG('FRME'): case SBIG('FRME'):
return {FRME::Extract, {_S(".blend")}, 2}; return {FRME::Extract, {_SYS_STR(".blend")}, 2};
case SBIG('CMDL'): case SBIG('CMDL'):
return {CMDL::Extract, {_S(".blend")}, 1, CMDL::Name}; return {CMDL::Extract, {_SYS_STR(".blend")}, 1, CMDL::Name};
case SBIG('DCLN'): case SBIG('DCLN'):
return {DCLN::Extract, {_S(".blend")}}; return {DCLN::Extract, {_SYS_STR(".blend")}};
case SBIG('ANCS'): case SBIG('ANCS'):
return {ANCS::Extract, {_S(".yaml"), _S(".blend")}, 2}; return {ANCS::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 2};
case SBIG('MLVL'): case SBIG('MLVL'):
return {MLVL::Extract, {_S(".yaml"), _S(".blend")}, 3}; return {MLVL::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 3};
case SBIG('MREA'): case SBIG('MREA'):
return {MREA::Extract, {_S(".blend")}, 4, MREA::Name}; return {MREA::Extract, {_SYS_STR(".blend")}, 4, MREA::Name};
case SBIG('MAPA'): case SBIG('MAPA'):
return {MAPA::Extract, {_S(".blend")}, 4}; return {MAPA::Extract, {_SYS_STR(".blend")}, 4};
case SBIG('MAPU'): case SBIG('MAPU'):
return {MAPU::Extract, {_S(".blend")}, 5}; return {MAPU::Extract, {_SYS_STR(".blend")}, 5};
case SBIG('PATH'): case SBIG('PATH'):
return {PATH::Extract, {_S(".blend")}, 5}; return {PATH::Extract, {_SYS_STR(".blend")}, 5};
case SBIG('PART'): case SBIG('PART'):
return {DNAParticle::ExtractGPSM<UniqueID32>, {_S(".gpsm.yaml")}}; return {DNAParticle::ExtractGPSM<UniqueID32>, {_SYS_STR(".gpsm.yaml")}};
case SBIG('ELSC'): case SBIG('ELSC'):
return {DNAParticle::ExtractELSM<UniqueID32>, {_S(".elsm.yaml")}}; return {DNAParticle::ExtractELSM<UniqueID32>, {_SYS_STR(".elsm.yaml")}};
case SBIG('SWHC'): case SBIG('SWHC'):
return {DNAParticle::ExtractSWSH<UniqueID32>, {_S(".swsh.yaml")}}; return {DNAParticle::ExtractSWSH<UniqueID32>, {_SYS_STR(".swsh.yaml")}};
case SBIG('CRSC'): case SBIG('CRSC'):
return {DNAParticle::ExtractCRSM<UniqueID32>, {_S(".crsm.yaml")}}; return {DNAParticle::ExtractCRSM<UniqueID32>, {_SYS_STR(".crsm.yaml")}};
case SBIG('WPSC'): case SBIG('WPSC'):
return {DNAParticle::ExtractWPSM<UniqueID32>, {_S(".wpsm.yaml")}}; return {DNAParticle::ExtractWPSM<UniqueID32>, {_SYS_STR(".wpsm.yaml")}};
case SBIG('DPSC'): case SBIG('DPSC'):
return {DNAParticle::ExtractDPSM<UniqueID32>, {_S(".dpsm.yaml")}}; return {DNAParticle::ExtractDPSM<UniqueID32>, {_SYS_STR(".dpsm.yaml")}};
case SBIG('FONT'): case SBIG('FONT'):
return {DNAFont::ExtractFONT<UniqueID32>, {_S(".yaml")}}; return {DNAFont::ExtractFONT<UniqueID32>, {_SYS_STR(".yaml")}};
case SBIG('DGRP'): case SBIG('DGRP'):
return {DNADGRP::ExtractDGRP<UniqueID32>, {_S(".yaml")}}; return {DNADGRP::ExtractDGRP<UniqueID32>, {_SYS_STR(".yaml")}};
case SBIG('AGSC'): case SBIG('AGSC'):
return {AGSC::Extract, {}}; return {AGSC::Extract, {}};
case SBIG('CSNG'): case SBIG('CSNG'):
return {CSNG::Extract, {_S(".mid"), _S(".yaml")}}; return {CSNG::Extract, {_SYS_STR(".mid"), _SYS_STR(".yaml")}};
case SBIG('ATBL'): case SBIG('ATBL'):
return {DNAAudio::ATBL::Extract, {_S(".yaml")}}; return {DNAAudio::ATBL::Extract, {_SYS_STR(".yaml")}};
case SBIG('CTWK'): case SBIG('CTWK'):
case SBIG('DUMB'): case SBIG('DUMB'):
{ {
@ -424,37 +424,37 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const nod::Node& pakNode, con
if (named) if (named)
{ {
if (!name.compare("PlayerRes")) if (!name.compare("PlayerRes"))
return {ExtractTweak<CTweakPlayerRes>, {_S(".yaml")}}; return {ExtractTweak<CTweakPlayerRes>, {_SYS_STR(".yaml")}};
if (!name.compare("GunRes")) if (!name.compare("GunRes"))
return {ExtractTweak<CTweakGunRes>, {_S(".yaml")}}; return {ExtractTweak<CTweakGunRes>, {_SYS_STR(".yaml")}};
if (!name.compare("Player")) if (!name.compare("Player"))
return {ExtractTweak<CTweakPlayer>, {_S(".yaml")}}; return {ExtractTweak<CTweakPlayer>, {_SYS_STR(".yaml")}};
if (!name.compare("CameraBob")) if (!name.compare("CameraBob"))
return {ExtractTweak<CTweakCameraBob>, {_S(".yaml")}}; return {ExtractTweak<CTweakCameraBob>, {_SYS_STR(".yaml")}};
if (!name.compare("SlideShow")) if (!name.compare("SlideShow"))
return {ExtractTweak<CTweakSlideShow>, {_S(".yaml")}}; return {ExtractTweak<CTweakSlideShow>, {_SYS_STR(".yaml")}};
if (!name.compare("Game")) if (!name.compare("Game"))
return {ExtractTweak<CTweakGame>, {_S(".yaml")}}; return {ExtractTweak<CTweakGame>, {_SYS_STR(".yaml")}};
if (!name.compare("Targeting")) if (!name.compare("Targeting"))
return {ExtractTweak<CTweakTargeting>, {_S(".yaml")}}; return {ExtractTweak<CTweakTargeting>, {_SYS_STR(".yaml")}};
if (!name.compare("Gui")) if (!name.compare("Gui"))
return {ExtractTweak<CTweakGui>, {_S(".yaml")}}; return {ExtractTweak<CTweakGui>, {_SYS_STR(".yaml")}};
if (!name.compare("AutoMapper")) if (!name.compare("AutoMapper"))
return {ExtractTweak<CTweakAutoMapper>, {_S(".yaml")}}; return {ExtractTweak<CTweakAutoMapper>, {_SYS_STR(".yaml")}};
if (!name.compare("PlayerControls") || !name.compare("PlayerControls2")) if (!name.compare("PlayerControls") || !name.compare("PlayerControls2"))
return {ExtractTweak<CTweakPlayerControl>, {_S(".yaml")}}; return {ExtractTweak<CTweakPlayerControl>, {_SYS_STR(".yaml")}};
if (!name.compare("Ball")) if (!name.compare("Ball"))
return {ExtractTweak<CTweakBall>, {_S(".yaml")}}; return {ExtractTweak<CTweakBall>, {_SYS_STR(".yaml")}};
if (!name.compare("Particle")) if (!name.compare("Particle"))
return {ExtractTweak<CTweakParticle>, {_S(".yaml")}}; return {ExtractTweak<CTweakParticle>, {_SYS_STR(".yaml")}};
if (!name.compare("GuiColors")) if (!name.compare("GuiColors"))
return {ExtractTweak<CTweakGuiColors>, {_S(".yaml")}}; return {ExtractTweak<CTweakGuiColors>, {_SYS_STR(".yaml")}};
if (!name.compare("PlayerGun")) if (!name.compare("PlayerGun"))
return {ExtractTweak<CTweakPlayerGun>, {_S(".yaml")}}; return {ExtractTweak<CTweakPlayerGun>, {_SYS_STR(".yaml")}};
if (!name.compare("DUMB_MazeSeeds")) if (!name.compare("DUMB_MazeSeeds"))
return {ExtractTweak<MazeSeeds>, {_S(".yaml")}}; return {ExtractTweak<MazeSeeds>, {_SYS_STR(".yaml")}};
if (!name.compare("DUMB_SnowForces")) if (!name.compare("DUMB_SnowForces"))
return {ExtractTweak<SnowForces>, {_S(".yaml")}}; return {ExtractTweak<SnowForces>, {_SYS_STR(".yaml")}};
} }
break; break;
} }

8
DataSpec/DNAMP1/FRME.cpp
View File

@ -73,7 +73,7 @@ void FRME::Widget::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_read
case SBIG('TBGP'): widgetInfo.reset(new TBGPInfo); break; case SBIG('TBGP'): widgetInfo.reset(new TBGPInfo); break;
case SBIG('SLGP'): widgetInfo.reset(new SLGPInfo); break; case SBIG('SLGP'): widgetInfo.reset(new SLGPInfo); break;
default: default:
Log.report(logvisor::Fatal, _S("Unsupported FRME widget type %.8X"), type.toUint32()); Log.report(logvisor::Fatal, _SYS_STR("Unsupported FRME widget type %.8X"), type.toUint32());
} }
/* widgetInfo */ /* widgetInfo */
@ -159,7 +159,7 @@ void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader&
else if (projectionType == ProjectionType::Orthographic) else if (projectionType == ProjectionType::Orthographic)
projection.reset(new OrthographicProjection); projection.reset(new OrthographicProjection);
else else
Log.report(logvisor::Fatal, _S("Invalid CAMR projection mode! %i"), int(projectionType)); Log.report(logvisor::Fatal, _SYS_STR("Invalid CAMR projection mode! %i"), int(projectionType));
projection->read(__dna_reader); projection->read(__dna_reader);
} }
@ -168,9 +168,9 @@ template <>
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer) void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{ {
if (!projection) if (!projection)
Log.report(logvisor::Fatal, _S("Invalid CAMR projection object!")); Log.report(logvisor::Fatal, _SYS_STR("Invalid CAMR projection object!"));
if (projection->type != projectionType) if (projection->type != projectionType)
Log.report(logvisor::Fatal, _S("CAMR projection type does not match actual projection type!")); Log.report(logvisor::Fatal, _SYS_STR("CAMR projection type does not match actual projection type!"));
__dna_writer.writeUint32Big(atUint32(projectionType)); __dna_writer.writeUint32Big(atUint32(projectionType));
projection->write(__dna_writer); projection->write(__dna_writer);

44
DataSpec/DNAMP1/MLVL.cpp
View File

@ -31,13 +31,13 @@ bool MLVL::Extract(const SpecBase& dataSpec, PAKEntryReadStream& rs, const hecl:
{ {
hecl::ProjectPath areaDir = pakRouter.getWorking(area.areaMREAId).getParentPath(); hecl::ProjectPath areaDir = pakRouter.getWorking(area.areaMREAId).getParentPath();
{ {
athena::io::FileWriter fw(hecl::ProjectPath(areaDir, _S("!memoryid.yaml")).getAbsolutePath()); athena::io::FileWriter fw(hecl::ProjectPath(areaDir, _SYS_STR("!memoryid.yaml")).getAbsolutePath());
athena::io::YAMLDocWriter w(nullptr); athena::io::YAMLDocWriter w(nullptr);
w.writeUint32("memoryid", area.areaId); w.writeUint32("memoryid", area.areaId);
w.finish(&fw); w.finish(&fw);
} }
{ {
athena::io::FileWriter fw(hecl::ProjectPath(areaDir, _S("!memoryrelays.yaml")).getAbsolutePath()); athena::io::FileWriter fw(hecl::ProjectPath(areaDir, _SYS_STR("!memoryrelays.yaml")).getAbsolutePath());
athena::io::YAMLDocWriter w(nullptr); athena::io::YAMLDocWriter w(nullptr);
std::vector<atUint32> relayIds; std::vector<atUint32> relayIds;
@ -52,12 +52,12 @@ bool MLVL::Extract(const SpecBase& dataSpec, PAKEntryReadStream& rs, const hecl:
w.finish(&fw); w.finish(&fw);
} }
if (pakRouter.mreaHasDupeResources(area.areaMREAId)) if (pakRouter.mreaHasDupeResources(area.areaMREAId))
athena::io::FileWriter(hecl::ProjectPath(areaDir, _S("!duperes")).getAbsolutePath()); athena::io::FileWriter(hecl::ProjectPath(areaDir, _SYS_STR("!duperes")).getAbsolutePath());
areaIdx++; areaIdx++;
} }
athena::io::FileWriter writer(outPath.getWithExtension(_S(".yaml"), true).getAbsolutePath()); athena::io::FileWriter writer(outPath.getWithExtension(_SYS_STR(".yaml"), true).getAbsolutePath());
athena::io::ToYAMLStream(mlvl, writer, &MLVL::writeMeta); athena::io::ToYAMLStream(mlvl, writer, &MLVL::writeMeta);
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter, entry, force, fileChanged); return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter, entry, force, fileChanged);
@ -98,18 +98,18 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
hecl::blender::Token& btok) hecl::blender::Token& btok)
{ {
MLVL mlvl = {}; MLVL mlvl = {};
athena::io::FileReader reader(inPath.getWithExtension(_S(".yaml"), true).getAbsolutePath()); athena::io::FileReader reader(inPath.getWithExtension(_SYS_STR(".yaml"), true).getAbsolutePath());
athena::io::FromYAMLStream(mlvl, reader, &MLVL::readMeta); athena::io::FromYAMLStream(mlvl, reader, &MLVL::readMeta);
mlvl.magic = 0xDEAFBABE; mlvl.magic = 0xDEAFBABE;
mlvl.version = 0x11; mlvl.version = 0x11;
hecl::ProjectPath namePath(inPath.getParentPath(), _S("!name.yaml")); hecl::ProjectPath namePath(inPath.getParentPath(), _SYS_STR("!name.yaml"));
if (namePath.isFile()) if (namePath.isFile())
mlvl.worldNameId = namePath; mlvl.worldNameId = namePath;
hecl::ProjectPath globPath = inPath.getWithExtension(_S(".*"), true); hecl::ProjectPath globPath = inPath.getWithExtension(_SYS_STR(".*"), true);
hecl::ProjectPath savwPath = globPath.ensureAuxInfo(_S("SAVW")); hecl::ProjectPath savwPath = globPath.ensureAuxInfo(_SYS_STR("SAVW"));
mlvl.saveWorldId = savwPath; mlvl.saveWorldId = savwPath;
hecl::ProjectPath mapwPath = globPath.ensureAuxInfo(_S("MAPW")); hecl::ProjectPath mapwPath = globPath.ensureAuxInfo(_SYS_STR("MAPW"));
mlvl.worldMap = mapwPath; mlvl.worldMap = mapwPath;
size_t areaIdx = 0; size_t areaIdx = 0;
@ -119,13 +119,13 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
if (area.path.getPathType() != hecl::ProjectPath::Type::Directory) if (area.path.getPathType() != hecl::ProjectPath::Type::Directory)
continue; continue;
hecl::ProjectPath areaPath(area.path, _S("!area.blend")); hecl::ProjectPath areaPath(area.path, _SYS_STR("!area.blend"));
if (!areaPath.isFile()) if (!areaPath.isFile())
continue; continue;
Log.report(logvisor::Info, _S("Visiting %s"), area.path.getRelativePath().data()); Log.report(logvisor::Info, _SYS_STR("Visiting %s"), area.path.getRelativePath().data());
hecl::ProjectPath memRelayPath(area.path, _S("!memoryrelays.yaml")); hecl::ProjectPath memRelayPath(area.path, _SYS_STR("!memoryrelays.yaml"));
std::vector<atUint32> memRelays; std::vector<atUint32> memRelays;
@ -155,7 +155,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
else else
layerName = hecl::StringUtils::TrimWhitespace(hecl::SystemString(endCh)); layerName = hecl::StringUtils::TrimWhitespace(hecl::SystemString(endCh));
hecl::ProjectPath objectsPath(area.path, e.m_name + _S("/!objects.yaml")); hecl::ProjectPath objectsPath(area.path, e.m_name + _SYS_STR("/!objects.yaml"));
if (objectsPath.isNone()) if (objectsPath.isNone())
continue; continue;
@ -177,7 +177,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
layerResources.beginLayer(); layerResources.beginLayer();
/* Set active flag state */ /* Set active flag state */
hecl::ProjectPath defActivePath(area.path, e.m_name + _S("/!defaultactive")); hecl::ProjectPath defActivePath(area.path, e.m_name + _SYS_STR("/!defaultactive"));
bool active = defActivePath.isNone() ? false : true; bool active = defActivePath.isNone() ? false : true;
if (!areaInit) if (!areaInit)
@ -189,7 +189,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
mlvl.areas.emplace_back(); mlvl.areas.emplace_back();
MLVL::Area& areaOut = mlvl.areas.back(); MLVL::Area& areaOut = mlvl.areas.back();
hecl::ProjectPath namePath(area.path, _S("!name.yaml")); hecl::ProjectPath namePath(area.path, _SYS_STR("!name.yaml"));
if (namePath.isFile()) if (namePath.isFile())
areaOut.areaNameId = namePath; areaOut.areaNameId = namePath;
@ -201,7 +201,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
areaOut.areaMREAId = areaPath; areaOut.areaMREAId = areaPath;
areaOut.areaId = 0xffffffff; areaOut.areaId = 0xffffffff;
hecl::ProjectPath memIdPath(area.path, _S("!memoryid.yaml")); hecl::ProjectPath memIdPath(area.path, _SYS_STR("!memoryid.yaml"));
if (memIdPath.isFile()) if (memIdPath.isFile())
{ {
athena::io::FileReader fr(memIdPath.getAbsolutePath()); athena::io::FileReader fr(memIdPath.getAbsolutePath());
@ -316,7 +316,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
} }
if (!areaInit) if (!areaInit)
Log.report(logvisor::Info, _S("No layer directories for area %s"), area.path.getRelativePath().data()); Log.report(logvisor::Info, _SYS_STR("No layer directories for area %s"), area.path.getRelativePath().data());
/* Build deplist */ /* Build deplist */
MLVL::Area& areaOut = mlvl.areas.back(); MLVL::Area& areaOut = mlvl.areas.back();
@ -369,7 +369,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
} }
} }
hecl::ProjectPath pathPath(areaPath.getParentPath(), _S("!path.blend")); hecl::ProjectPath pathPath(areaPath.getParentPath(), _SYS_STR("!path.blend"));
urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath, btok); urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath, btok);
if (pathTag.id.IsValid()) if (pathTag.id.IsValid())
{ {
@ -416,7 +416,7 @@ bool MLVL::CookMAPW(const hecl::ProjectPath& outPath,
continue; continue;
/* Area map */ /* Area map */
hecl::ProjectPath mapPath(area.path, _S("/!map.blend")); hecl::ProjectPath mapPath(area.path, _SYS_STR("/!map.blend"));
if (mapPath.isFile()) if (mapPath.isFile())
mapaTags.push_back(g_curSpec->buildTagFromPath(mapPath, btok)); mapaTags.push_back(g_curSpec->buildTagFromPath(mapPath, btok));
} }
@ -451,11 +451,11 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath,
if (area.path.getPathType() != hecl::ProjectPath::Type::Directory) if (area.path.getPathType() != hecl::ProjectPath::Type::Directory)
continue; continue;
hecl::ProjectPath areaPath(area.path, _S("/!area.blend")); hecl::ProjectPath areaPath(area.path, _SYS_STR("/!area.blend"));
if (!areaPath.isFile()) if (!areaPath.isFile())
continue; continue;
hecl::ProjectPath memRelayPath(area.path, _S("/!memoryrelays.yaml")); hecl::ProjectPath memRelayPath(area.path, _SYS_STR("/!memoryrelays.yaml"));
std::vector<atUint32> memRelays; std::vector<atUint32> memRelays;
if (memRelayPath.isFile()) if (memRelayPath.isFile())
{ {
@ -478,7 +478,7 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath,
else else
layerName = hecl::StringUtils::TrimWhitespace(hecl::SystemString(endCh)); layerName = hecl::StringUtils::TrimWhitespace(hecl::SystemString(endCh));
hecl::ProjectPath objectsPath(area.path, e.m_name + _S("/!objects.yaml")); hecl::ProjectPath objectsPath(area.path, e.m_name + _SYS_STR("/!objects.yaml"));
if (objectsPath.isNone()) if (objectsPath.isNone())
continue; continue;

30
DataSpec/DNAMP1/MREA.cpp
View File

@ -323,7 +323,7 @@ bool MREA::Extract(const SpecBase& dataSpec,
{ {
rs.seek(secStart, athena::Begin); rs.seek(secStart, athena::Begin);
auto visiData = rs.readUBytes(head.secSizes[curSec]); auto visiData = rs.readUBytes(head.secSizes[curSec]);
athena::io::FileWriter visiOut(outPath.getWithExtension(_S(".visi"), true).getAbsolutePath()); athena::io::FileWriter visiOut(outPath.getWithExtension(_SYS_STR(".visi"), true).getAbsolutePath());
visiOut.writeUBytes(visiData.get(), head.secSizes[curSec]); visiOut.writeUBytes(visiData.get(), head.secSizes[curSec]);
rs.seek(secStart + 4, athena::Begin); rs.seek(secStart + 4, athena::Begin);
} }
@ -340,7 +340,7 @@ bool MREA::Extract(const SpecBase& dataSpec,
visiWriter.writeUint32(nullptr, entityId); visiWriter.writeUint32(nullptr, entityId);
} }
} }
hecl::ProjectPath visiMetadataPath(outPath.getParentPath(), _S("!visi.yaml")); hecl::ProjectPath visiMetadataPath(outPath.getParentPath(), _SYS_STR("!visi.yaml"));
athena::io::FileWriter visiMetadata(visiMetadataPath.getAbsolutePath()); athena::io::FileWriter visiMetadata(visiMetadataPath.getAbsolutePath());
visiWriter.finish(&visiMetadata); visiWriter.finish(&visiMetadata);
} }
@ -439,7 +439,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
false, false, true); false, false, true);
for (const hecl::DirectoryEnumerator::Entry& ent : dEnum) for (const hecl::DirectoryEnumerator::Entry& ent : dEnum)
{ {
hecl::ProjectPath layerScriptPath(areaDirPath, ent.m_name + _S("/!objects.yaml")); hecl::ProjectPath layerScriptPath(areaDirPath, ent.m_name + _SYS_STR("/!objects.yaml"));
if (layerScriptPath.isFile()) if (layerScriptPath.isFile())
layerScriptPaths.push_back(std::move(layerScriptPath)); layerScriptPaths.push_back(std::move(layerScriptPath));
} }
@ -523,7 +523,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
#if DUMP_OCTREE #if DUMP_OCTREE
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
if (!conn.createBlend(inPath.getWithExtension(_S(".octree.blend"), true), hecl::blender::BlendType::Area)) if (!conn.createBlend(inPath.getWithExtension(_SYS_STR(".octree.blend"), true), hecl::blender::BlendType::Area))
return false; return false;
/* Open Py Stream and read sections */ /* Open Py Stream and read sections */
@ -594,7 +594,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
#if DUMP_OCTREE #if DUMP_OCTREE
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
if (!conn.createBlend(inPath.getWithExtension(_S(".coctree.blend"), true), hecl::blender::BlendType::Area)) if (!conn.createBlend(inPath.getWithExtension(_SYS_STR(".coctree.blend"), true), hecl::blender::BlendType::Area))
return false; return false;
/* Open Py Stream and read sections */ /* Open Py Stream and read sections */
@ -666,7 +666,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
} }
/* VISI */ /* VISI */
hecl::ProjectPath visiMetadataPath(areaDirPath, _S("!visi.yaml")); hecl::ProjectPath visiMetadataPath(areaDirPath, _SYS_STR("!visi.yaml"));
bool visiGood = false; bool visiGood = false;
if (visiMetadataPath.isFile()) if (visiMetadataPath.isFile())
{ {
@ -698,7 +698,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
} }
// Check if pre-generated visi exists, recycle if able // Check if pre-generated visi exists, recycle if able
hecl::ProjectPath preVisiPath = inPath.getWithExtension(_S(".visi"), true); hecl::ProjectPath preVisiPath = inPath.getWithExtension(_SYS_STR(".visi"), true);
if (preVisiPath.getPathType() == hecl::ProjectPath::Type::File) if (preVisiPath.getPathType() == hecl::ProjectPath::Type::File)
{ {
athena::io::FileReader preVisiReader(preVisiPath.getAbsolutePath()); athena::io::FileReader preVisiReader(preVisiPath.getAbsolutePath());
@ -733,7 +733,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
#if !WINDOWS_STORE #if !WINDOWS_STORE
if (!visiGood) if (!visiGood)
{ {
hecl::ProjectPath visiIntOut = outPath.getWithExtension(_S(".visiint")); hecl::ProjectPath visiIntOut = outPath.getWithExtension(_SYS_STR(".visiint"));
athena::io::FileWriter w(visiIntOut.getAbsolutePath()); athena::io::FileWriter w(visiIntOut.getAbsolutePath());
w.writeUint32Big(meshes.size()); w.writeUint32Big(meshes.size());
for (const DNACMDL::Mesh& mesh : meshes) for (const DNACMDL::Mesh& mesh : meshes)
@ -775,17 +775,17 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
w.close(); w.close();
hecl::SystemString VisiGenPath = ExeDir + _S("/visigen"); hecl::SystemString VisiGenPath = ExeDir + _SYS_STR("/visigen");
#if _WIN32 #if _WIN32
VisiGenPath += _S(".exe"); VisiGenPath += _SYS_STR(".exe");
#endif #endif
hecl::SystemChar thrIdx[16]; hecl::SystemChar thrIdx[16];
hecl::SNPrintf(thrIdx, 16, _S("%d"), hecl::ClientProcess::GetThreadWorkerIdx()); hecl::SNPrintf(thrIdx, 16, _SYS_STR("%d"), hecl::ClientProcess::GetThreadWorkerIdx());
hecl::SystemChar parPid[32]; hecl::SystemChar parPid[32];
#if _WIN32 #if _WIN32
hecl::SNPrintf(parPid, 32, _S("%lluX"), reinterpret_cast<unsigned long long>(GetCurrentProcess())); hecl::SNPrintf(parPid, 32, _SYS_STR("%lluX"), reinterpret_cast<unsigned long long>(GetCurrentProcess()));
#else #else
hecl::SNPrintf(parPid, 32, _S("%lluX"), (unsigned long long)getpid()); hecl::SNPrintf(parPid, 32, _SYS_STR("%lluX"), (unsigned long long)getpid());
#endif #endif
const hecl::SystemChar* args[] = {VisiGenPath.c_str(), const hecl::SystemChar* args[] = {VisiGenPath.c_str(),
visiIntOut.getAbsolutePath().data(), visiIntOut.getAbsolutePath().data(),
@ -801,7 +801,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
} }
else else
{ {
Log.report(logvisor::Fatal, _S("Unable to launch %s"), VisiGenPath.c_str()); Log.report(logvisor::Fatal, _SYS_STR("Unable to launch %s"), VisiGenPath.c_str());
} }
} }
#endif #endif
@ -812,7 +812,7 @@ bool MREA::Cook(const hecl::ProjectPath& outPath,
/* PATH */ /* PATH */
{ {
hecl::ProjectPath pathPath(inPath.getParentPath(), _S("!path.blend")); hecl::ProjectPath pathPath(inPath.getParentPath(), _SYS_STR("!path.blend"));
UniqueID32 pathId = pathPath; UniqueID32 pathId = pathPath;
secs.emplace_back(4, 0); secs.emplace_back(4, 0);
athena::io::MemoryWriter w(secs.back().data(), secs.back().size()); athena::io::MemoryWriter w(secs.back().data(), secs.back().size());

10
DataSpec/DNAMP1/SCLY.cpp
View File

@ -51,10 +51,10 @@ void SCLY::exportToLayerDirectories(const PAK::Entry& entry, PAKRouter<PAKBridge
if (active) if (active)
{ {
hecl::ProjectPath activePath(layerPath, "!defaultactive"); hecl::ProjectPath activePath(layerPath, "!defaultactive");
fclose(hecl::Fopen(activePath.getAbsolutePath().data(), _S("wb"))); fclose(hecl::Fopen(activePath.getAbsolutePath().data(), _SYS_STR("wb")));
} }
hecl::ProjectPath yamlFile(layerPath, _S("!objects.yaml")); hecl::ProjectPath yamlFile(layerPath, _SYS_STR("!objects.yaml"));
if (force || yamlFile.isNone()) if (force || yamlFile.isNone())
{ {
athena::io::FileWriter writer(yamlFile.getAbsolutePath()); athena::io::FileWriter writer(yamlFile.getAbsolutePath());
@ -134,11 +134,11 @@ void SCLY::ScriptLayer::Enumerate<BigDNA::Read>(athena::io::IStreamReader& rs)
objects.push_back(std::move(obj)); objects.push_back(std::move(obj));
size_t actualLen = rs.position() - start; size_t actualLen = rs.position() - start;
if (actualLen != len) if (actualLen != len)
Log.report(logvisor::Fatal, _S("Error while reading object of type 0x%.2X, did not read the expected amount of data, read 0x%x, expected 0x%x"), (atUint32)type, actualLen, len); Log.report(logvisor::Fatal, _SYS_STR("Error while reading object of type 0x%.2X, did not read the expected amount of data, read 0x%x, expected 0x%x"), (atUint32)type, actualLen, len);
rs.seek(start + len, athena::Begin); rs.seek(start + len, athena::Begin);
} }
else else
Log.report(logvisor::Fatal, _S("Unable to find type 0x%X in object database"), (atUint32)type); Log.report(logvisor::Fatal, _SYS_STR("Unable to find type 0x%X in object database"), (atUint32)type);
} }
} }
@ -168,7 +168,7 @@ void SCLY::ScriptLayer::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& r
objects.push_back(std::move(obj)); objects.push_back(std::move(obj));
} }
else else
Log.report(logvisor::Fatal, _S("Unable to find type 0x%X in object database"), (atUint32)type); Log.report(logvisor::Fatal, _SYS_STR("Unable to find type 0x%X in object database"), (atUint32)type);
} }
} }
} }

2
DataSpec/DNAMP1/ScriptObjects/Actor.cpp
View File

@ -21,7 +21,7 @@ zeus::CAABox Actor::getVISIAABB(hecl::blender::Token& btok) const
{ {
hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath( hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(
animationParameters.animationCharacterSet); animationParameters.animationCharacterSet);
conn.openBlend(path.getWithExtension(_S(".blend"), true)); conn.openBlend(path.getWithExtension(_SYS_STR(".blend"), true));
hecl::blender::DataStream ds = conn.beginData(); hecl::blender::DataStream ds = conn.beginData();
auto aabb = ds.getMeshAABB(); auto aabb = ds.getMeshAABB();
aabbOut = zeus::CAABox(aabb.first, aabb.second); aabbOut = zeus::CAABox(aabb.first, aabb.second);

2
DataSpec/DNAMP1/ScriptObjects/DoorArea.cpp
View File

@ -13,7 +13,7 @@ zeus::CAABox DoorArea::getVISIAABB(hecl::blender::Token& btok) const
{ {
hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath( hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(
animationParameters.animationCharacterSet); animationParameters.animationCharacterSet);
conn.openBlend(path.getWithExtension(_S(".blend"), true)); conn.openBlend(path.getWithExtension(_SYS_STR(".blend"), true));
hecl::blender::DataStream ds = conn.beginData(); hecl::blender::DataStream ds = conn.beginData();
auto aabb = ds.getMeshAABB(); auto aabb = ds.getMeshAABB();
aabbOut = zeus::CAABox(aabb.first, aabb.second); aabbOut = zeus::CAABox(aabb.first, aabb.second);

2
DataSpec/DNAMP1/ScriptObjects/Platform.cpp
View File

@ -21,7 +21,7 @@ zeus::CAABox Platform::getVISIAABB(hecl::blender::Token& btok) const
{ {
hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath( hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(
animationParameters.animationCharacterSet); animationParameters.animationCharacterSet);
conn.openBlend(path.getWithExtension(_S(".blend"), true)); conn.openBlend(path.getWithExtension(_SYS_STR(".blend"), true));
hecl::blender::DataStream ds = conn.beginData(); hecl::blender::DataStream ds = conn.beginData();
auto aabb = ds.getMeshAABB(); auto aabb = ds.getMeshAABB();
aabbOut = zeus::CAABox(aabb.first, aabb.second); aabbOut = zeus::CAABox(aabb.first, aabb.second);

4
DataSpec/DNAMP2/AGSC.cpp
View File

@ -32,7 +32,7 @@ bool AGSC::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& dir)
/* Write out project/pool */ /* Write out project/pool */
{ {
auto projd = group.getProj().toYAML(); auto projd = group.getProj().toYAML();
athena::io::FileWriter fo(hecl::ProjectPath(dir, _S("!project.yaml")).getAbsolutePath()); athena::io::FileWriter fo(hecl::ProjectPath(dir, _SYS_STR("!project.yaml")).getAbsolutePath());
if (fo.hasError()) if (fo.hasError())
return false; return false;
fo.writeUBytes(projd.data(), projd.size()); fo.writeUBytes(projd.data(), projd.size());
@ -40,7 +40,7 @@ bool AGSC::Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& dir)
{ {
auto poold = group.getPool().toYAML(); auto poold = group.getPool().toYAML();
athena::io::FileWriter fo(hecl::ProjectPath(dir, _S("!pool.yaml")).getAbsolutePath()); athena::io::FileWriter fo(hecl::ProjectPath(dir, _SYS_STR("!pool.yaml")).getAbsolutePath());
if (fo.hasError()) if (fo.hasError())
return false; return false;
fo.writeUBytes(poold.data(), poold.size()); fo.writeUBytes(poold.data(), poold.size());

4
DataSpec/DNAMP2/ANCS.hpp
View File

@ -225,9 +225,9 @@ struct ANCS : BigDNA
hecl::blender::Token& btok, hecl::blender::Token& btok,
std::function<void(const hecl::SystemChar*)> fileChanged) std::function<void(const hecl::SystemChar*)> fileChanged)
{ {
hecl::ProjectPath yamlPath = outPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = outPath.getWithExtension(_SYS_STR(".yaml"), true);
hecl::ProjectPath::Type yamlType = yamlPath.getPathType(); hecl::ProjectPath::Type yamlType = yamlPath.getPathType();
hecl::ProjectPath blendPath = outPath.getWithExtension(_S(".blend"), true); hecl::ProjectPath blendPath = outPath.getWithExtension(_SYS_STR(".blend"), true);
hecl::ProjectPath::Type blendType = blendPath.getPathType(); hecl::ProjectPath::Type blendType = blendPath.getPathType();
if (force || if (force ||

48
DataSpec/DNAMP2/DNAMP2.cpp
View File

@ -55,7 +55,7 @@ PAKBridge::PAKBridge(const nod::Node& node,
STRG mlvlName; STRG mlvlName;
mlvlName.read(rs); mlvlName.read(rs);
if (m_levelString.size()) if (m_levelString.size())
m_levelString += _S(", "); m_levelString += _SYS_STR(", ");
m_levelString += mlvlName.getSystemString(FOURCC('ENGL'), 0); m_levelString += mlvlName.getSystemString(FOURCC('ENGL'), 0);
} }
} }
@ -66,8 +66,8 @@ static hecl::SystemString LayerName(std::string_view name)
{ {
hecl::SystemString ret(hecl::SystemStringConv(name).sys_str()); hecl::SystemString ret(hecl::SystemStringConv(name).sys_str());
for (auto& ch : ret) for (auto& ch : ret)
if (ch == _S('/') || ch == _S('\\')) if (ch == _SYS_STR('/') || ch == _SYS_STR('\\'))
ch = _S('-'); ch = _SYS_STR('-');
return ret; return ret;
} }
@ -128,11 +128,11 @@ void PAKBridge::build()
if (areaDeps.name.empty()) if (areaDeps.name.empty())
{ {
std::string idStr = area.areaMREAId.toString(); std::string idStr = area.areaMREAId.toString();
areaDeps.name = hecl::SystemString(_S("MREA_")) + hecl::SystemStringConv(idStr).c_str(); areaDeps.name = hecl::SystemString(_SYS_STR("MREA_")) + hecl::SystemStringConv(idStr).c_str();
} }
} }
hecl::SystemChar num[16]; hecl::SystemChar num[16];
hecl::SNPrintf(num, 16, _S("%02u "), ai); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), ai);
areaDeps.name = num + areaDeps.name; areaDeps.name = num + areaDeps.name;
areaDeps.layers.reserve(area.depLayerCount-1); areaDeps.layers.reserve(area.depLayerCount-1);
@ -144,7 +144,7 @@ void PAKBridge::build()
layer.name = LayerName(mlvl.layerNames[layerIdx++]); layer.name = LayerName(mlvl.layerNames[layerIdx++]);
layer.active = layerFlags.flags >> (l-1) & 0x1; layer.active = layerFlags.flags >> (l-1) & 0x1;
layer.name = hecl::StringUtils::TrimWhitespace(layer.name); layer.name = hecl::StringUtils::TrimWhitespace(layer.name);
hecl::SNPrintf(num, 16, _S("%02u "), l-1); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), l-1);
layer.name = num + layer.name; layer.name = num + layer.name;
layer.resources.reserve(area.depLayers[l] - r); layer.resources.reserve(area.depLayers[l] - r);
@ -211,13 +211,13 @@ void PAKBridge::addMAPATransforms(PAKRouter<PAKBridge>& pakRouter,
hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath(); hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath();
if (mlvl.worldNameId) if (mlvl.worldNameId)
pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _S("!name.yaml")); pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _SYS_STR("!name.yaml"));
for (const MLVL::Area& area : mlvl.areas) for (const MLVL::Area& area : mlvl.areas)
{ {
hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath(); hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath();
if (area.areaNameId) if (area.areaNameId)
pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _S("!name.yaml")); pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _SYS_STR("!name.yaml"));
} }
if (mlvl.worldMap) if (mlvl.worldMap)
@ -256,39 +256,39 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const nod::Node& pakNode, con
switch (entry.type) switch (entry.type)
{ {
case SBIG('HINT'): case SBIG('HINT'):
return {DNAMP1::HINT::Extract, {_S(".yaml")}}; return {DNAMP1::HINT::Extract, {_SYS_STR(".yaml")}};
case SBIG('STRG'): case SBIG('STRG'):
return {STRG::Extract, {_S(".yaml")}}; return {STRG::Extract, {_SYS_STR(".yaml")}};
case SBIG('TXTR'): case SBIG('TXTR'):
return {TXTR::Extract, {_S(".png")}}; return {TXTR::Extract, {_SYS_STR(".png")}};
case SBIG('AFSM'): case SBIG('AFSM'):
return {AFSM::Extract, {_S(".yaml")}}; return {AFSM::Extract, {_SYS_STR(".yaml")}};
case SBIG('SAVW'): case SBIG('SAVW'):
return {SAVWCommon::ExtractSAVW<SAVW>, {_S(".yaml")}}; return {SAVWCommon::ExtractSAVW<SAVW>, {_SYS_STR(".yaml")}};
case SBIG('CMDL'): case SBIG('CMDL'):
return {CMDL::Extract, {_S(".blend")}, 1}; return {CMDL::Extract, {_SYS_STR(".blend")}, 1};
case SBIG('ANCS'): case SBIG('ANCS'):
return {ANCS::Extract, {_S(".yaml"), _S(".blend")}, 2}; return {ANCS::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 2};
case SBIG('MLVL'): case SBIG('MLVL'):
return {MLVL::Extract, {_S(".yaml"), _S(".blend")}, 3}; return {MLVL::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 3};
case SBIG('MREA'): case SBIG('MREA'):
return {MREA::Extract, {_S(".blend")}, 4}; return {MREA::Extract, {_SYS_STR(".blend")}, 4};
case SBIG('MAPA'): case SBIG('MAPA'):
return {MAPA::Extract, {_S(".blend")}, 4}; return {MAPA::Extract, {_SYS_STR(".blend")}, 4};
case SBIG('MAPU'): case SBIG('MAPU'):
return {MAPU::Extract, {_S(".blend")}, 5}; return {MAPU::Extract, {_SYS_STR(".blend")}, 5};
case SBIG('FSM2'): case SBIG('FSM2'):
return {DNAFSM2::ExtractFSM2<UniqueID32>, {_S(".yaml")}}; return {DNAFSM2::ExtractFSM2<UniqueID32>, {_SYS_STR(".yaml")}};
case SBIG('FONT'): case SBIG('FONT'):
return {DNAFont::ExtractFONT<UniqueID32>, {_S(".yaml")}}; return {DNAFont::ExtractFONT<UniqueID32>, {_SYS_STR(".yaml")}};
case SBIG('DGRP'): case SBIG('DGRP'):
return {DNADGRP::ExtractDGRP<UniqueID32>, {_S(".yaml")}}; return {DNADGRP::ExtractDGRP<UniqueID32>, {_SYS_STR(".yaml")}};
case SBIG('AGSC'): case SBIG('AGSC'):
return {AGSC::Extract, {}}; return {AGSC::Extract, {}};
case SBIG('CSNG'): case SBIG('CSNG'):
return {DNAMP1::CSNG::Extract, {_S(".mid"), _S(".yaml")}}; return {DNAMP1::CSNG::Extract, {_SYS_STR(".mid"), _SYS_STR(".yaml")}};
case SBIG('ATBL'): case SBIG('ATBL'):
return {DNAAudio::ATBL::Extract, {_S(".yaml")}}; return {DNAAudio::ATBL::Extract, {_SYS_STR(".yaml")}};
} }
return {}; return {};
} }

2
DataSpec/DNAMP2/MLVL.hpp
View File

@ -102,7 +102,7 @@ struct MLVL : BigDNA
{ {
MLVL mlvl; MLVL mlvl;
mlvl.read(rs); mlvl.read(rs);
athena::io::FileWriter writer(outPath.getWithExtension(_S(".yaml"), true).getAbsolutePath()); athena::io::FileWriter writer(outPath.getWithExtension(_SYS_STR(".yaml"), true).getAbsolutePath());
athena::io::ToYAMLStream(mlvl, writer); athena::io::ToYAMLStream(mlvl, writer);
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter, return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter,

2
DataSpec/DNAMP2/MREA.cpp
View File

@ -182,7 +182,7 @@ bool MREA::Extract(const SpecBase& dataSpec,
/* MREA decompression stream */ /* MREA decompression stream */
StreamReader drs(rs, head.compressedBlockCount); StreamReader drs(rs, head.compressedBlockCount);
hecl::ProjectPath decompPath = outPath.getCookedPath(SpecEntMP2ORIG).getWithExtension(_S(".decomp")); hecl::ProjectPath decompPath = outPath.getCookedPath(SpecEntMP2ORIG).getWithExtension(_SYS_STR(".decomp"));
decompPath.makeDirChain(false); decompPath.makeDirChain(false);
athena::io::FileWriter mreaDecompOut(decompPath.getAbsolutePath()); athena::io::FileWriter mreaDecompOut(decompPath.getAbsolutePath());
head.write(mreaDecompOut); head.write(mreaDecompOut);

4
DataSpec/DNAMP3/CHAR.hpp
View File

@ -316,9 +316,9 @@ struct CHAR : BigDNA
hecl::blender::Token& btok, hecl::blender::Token& btok,
std::function<void(const hecl::SystemChar*)> fileChanged) std::function<void(const hecl::SystemChar*)> fileChanged)
{ {
hecl::ProjectPath yamlPath = outPath.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = outPath.getWithExtension(_SYS_STR(".yaml"), true);
hecl::ProjectPath::Type yamlType = yamlPath.getPathType(); hecl::ProjectPath::Type yamlType = yamlPath.getPathType();
hecl::ProjectPath blendPath = outPath.getWithExtension(_S(".blend"), true); hecl::ProjectPath blendPath = outPath.getWithExtension(_SYS_STR(".blend"), true);
hecl::ProjectPath::Type blendType = blendPath.getPathType(); hecl::ProjectPath::Type blendType = blendPath.getPathType();
if (force || if (force ||

42
DataSpec/DNAMP3/DNAMP3.cpp
View File

@ -61,7 +61,7 @@ PAKBridge::PAKBridge(const nod::Node& node,
for (const hecl::SystemString& str : uniq) for (const hecl::SystemString& str : uniq)
{ {
if (comma) if (comma)
m_levelString += _S(", "); m_levelString += _SYS_STR(", ");
comma = true; comma = true;
m_levelString += str; m_levelString += str;
} }
@ -71,8 +71,8 @@ static hecl::SystemString LayerName(std::string_view name)
{ {
hecl::SystemString ret(hecl::SystemStringConv(name).sys_str()); hecl::SystemString ret(hecl::SystemStringConv(name).sys_str());
for (auto& ch : ret) for (auto& ch : ret)
if (ch == _S('/') || ch == _S('\\')) if (ch == _SYS_STR('/') || ch == _SYS_STR('\\'))
ch = _S('-'); ch = _SYS_STR('-');
return ret; return ret;
} }
@ -133,11 +133,11 @@ void PAKBridge::build()
if (areaDeps.name.empty()) if (areaDeps.name.empty())
{ {
std::string idStr = area.areaMREAId.toString(); std::string idStr = area.areaMREAId.toString();
areaDeps.name = hecl::SystemString(_S("MREA_")) + hecl::SystemStringConv(idStr).c_str(); areaDeps.name = hecl::SystemString(_SYS_STR("MREA_")) + hecl::SystemStringConv(idStr).c_str();
} }
} }
hecl::SystemChar num[16]; hecl::SystemChar num[16];
hecl::SNPrintf(num, 16, _S("%02u "), ai); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), ai);
areaDeps.name = num + areaDeps.name; areaDeps.name = num + areaDeps.name;
const MLVL::LayerFlags& layerFlags = *layerFlagsIt++; const MLVL::LayerFlags& layerFlags = *layerFlagsIt++;
@ -151,7 +151,7 @@ void PAKBridge::build()
layer.name = LayerName(mlvl.layerNames[layerIdx++]); layer.name = LayerName(mlvl.layerNames[layerIdx++]);
layer.active = layerFlags.flags >> (l-1) & 0x1; layer.active = layerFlags.flags >> (l-1) & 0x1;
layer.name = hecl::StringUtils::TrimWhitespace(layer.name); layer.name = hecl::StringUtils::TrimWhitespace(layer.name);
hecl::SNPrintf(num, 16, _S("%02u "), l-1); hecl::SNPrintf(num, 16, _SYS_STR("%02u "), l-1);
layer.name = num + layer.name; layer.name = num + layer.name;
} }
} }
@ -221,13 +221,13 @@ void PAKBridge::addMAPATransforms(PAKRouter<PAKBridge>& pakRouter,
hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath(); hecl::ProjectPath mlvlDirPath = pakRouter.getWorking(&entry.second).getParentPath();
if (mlvl.worldNameId) if (mlvl.worldNameId)
pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _S("!name.yaml")); pathOverrides[mlvl.worldNameId] = hecl::ProjectPath(mlvlDirPath, _SYS_STR("!name.yaml"));
for (const MLVL::Area& area : mlvl.areas) for (const MLVL::Area& area : mlvl.areas)
{ {
hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath(); hecl::ProjectPath areaDirPath = pakRouter.getWorking(area.areaMREAId).getParentPath();
if (area.areaNameId) if (area.areaNameId)
pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _S("!name.yaml")); pathOverrides[area.areaNameId] = hecl::ProjectPath(areaDirPath, _SYS_STR("!name.yaml"));
} }
if (mlvl.worldMap) if (mlvl.worldMap)
@ -265,31 +265,31 @@ ResExtractor<PAKBridge> PAKBridge::LookupExtractor(const nod::Node& pakNode, con
switch (entry.type) switch (entry.type)
{ {
// case SBIG('CAUD'): // case SBIG('CAUD'):
// return {CAUD::Extract, {_S(".yaml")}}; // return {CAUD::Extract, {_SYS_STR(".yaml")}};
case SBIG('STRG'): case SBIG('STRG'):
return {STRG::Extract, {_S(".yaml")}}; return {STRG::Extract, {_SYS_STR(".yaml")}};
case SBIG('TXTR'): case SBIG('TXTR'):
return {TXTR::Extract, {_S(".png")}}; return {TXTR::Extract, {_SYS_STR(".png")}};
case SBIG('SAVW'): case SBIG('SAVW'):
return {SAVWCommon::ExtractSAVW<SAVW>, {_S(".yaml")}}; return {SAVWCommon::ExtractSAVW<SAVW>, {_SYS_STR(".yaml")}};
case SBIG('HINT'): case SBIG('HINT'):
return {HINT::Extract, {_S(".yaml")}}; return {HINT::Extract, {_SYS_STR(".yaml")}};
case SBIG('CMDL'): case SBIG('CMDL'):
return {CMDL::Extract, {_S(".blend")}, 1}; return {CMDL::Extract, {_SYS_STR(".blend")}, 1};
case SBIG('CHAR'): case SBIG('CHAR'):
return {CHAR::Extract, {_S(".yaml"), _S(".blend")}, 2}; return {CHAR::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 2};
case SBIG('MLVL'): case SBIG('MLVL'):
return {MLVL::Extract, {_S(".yaml"), _S(".blend")}, 3}; return {MLVL::Extract, {_SYS_STR(".yaml"), _SYS_STR(".blend")}, 3};
case SBIG('MREA'): case SBIG('MREA'):
return {MREA::Extract, {_S(".blend")}, 4}; return {MREA::Extract, {_SYS_STR(".blend")}, 4};
case SBIG('MAPA'): case SBIG('MAPA'):
return {MAPA::Extract, {_S(".blend")}, 4}; return {MAPA::Extract, {_SYS_STR(".blend")}, 4};
case SBIG('FSM2'): case SBIG('FSM2'):
return {DNAFSM2::ExtractFSM2<UniqueID64>, {_S(".yaml")}}; return {DNAFSM2::ExtractFSM2<UniqueID64>, {_SYS_STR(".yaml")}};
case SBIG('FONT'): case SBIG('FONT'):
return {DNAFont::ExtractFONT<UniqueID64>, {_S(".yaml")}}; return {DNAFont::ExtractFONT<UniqueID64>, {_SYS_STR(".yaml")}};
case SBIG('DGRP'): case SBIG('DGRP'):
return {DNADGRP::ExtractDGRP<UniqueID64>, {_S(".yaml")}}; return {DNADGRP::ExtractDGRP<UniqueID64>, {_SYS_STR(".yaml")}};
} }
return {}; return {};
} }

2
DataSpec/DNAMP3/MLVL.hpp
View File

@ -91,7 +91,7 @@ struct MLVL : BigDNA
{ {
MLVL mlvl; MLVL mlvl;
mlvl.read(rs); mlvl.read(rs);
athena::io::FileWriter writer(outPath.getWithExtension(_S(".yaml"), true).getAbsolutePath()); athena::io::FileWriter writer(outPath.getWithExtension(_SYS_STR(".yaml"), true).getAbsolutePath());
athena::io::ToYAMLStream(mlvl, writer); athena::io::ToYAMLStream(mlvl, writer);
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter, return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter,

2
DataSpec/DNAMP3/MREA.cpp
View File

@ -92,7 +92,7 @@ bool MREA::Extract(const SpecBase& dataSpec,
/* MREA decompression stream */ /* MREA decompression stream */
StreamReader drs(rs, head.compressedBlockCount, head.secIndexCount); StreamReader drs(rs, head.compressedBlockCount, head.secIndexCount);
hecl::ProjectPath decompPath = outPath.getCookedPath(SpecEntMP3ORIG).getWithExtension(_S(".decomp")); hecl::ProjectPath decompPath = outPath.getCookedPath(SpecEntMP3ORIG).getWithExtension(_SYS_STR(".decomp"));
decompPath.makeDirChain(false); decompPath.makeDirChain(false);
athena::io::FileWriter mreaDecompOut(decompPath.getAbsolutePath()); athena::io::FileWriter mreaDecompOut(decompPath.getAbsolutePath());
head.write(mreaDecompOut); head.write(mreaDecompOut);

166
DataSpec/SpecBase.cpp
View File

@ -24,18 +24,18 @@ static logvisor::Module Log("urde::SpecBase");
static const hecl::SystemChar* MomErr[] = static const hecl::SystemChar* MomErr[] =
{ {
_S("Your metroid is in another castle"), _SYS_STR("Your metroid is in another castle"),
_S("HECL is experiencing a PTSD attack"), _SYS_STR("HECL is experiencing a PTSD attack"),
_S("Unable to freeze metroids"), _SYS_STR("Unable to freeze metroids"),
_S("Ridley ate your homework"), _SYS_STR("Ridley ate your homework"),
_S("Expected 0 maternal symbolisms, found 2147483647"), _SYS_STR("Expected 0 maternal symbolisms, found 2147483647"),
_S("Contradictive narratives unsupported"), _SYS_STR("Contradictive narratives unsupported"),
_S("Wiimote profile \"NES + Zapper\" not recognized"), _SYS_STR("Wiimote profile \"NES + Zapper\" not recognized"),
_S("Unable to find Waldo"), _SYS_STR("Unable to find Waldo"),
_S("Expected Ridley, found furby"), _SYS_STR("Expected Ridley, found furby"),
_S("Adam has not authorized this, please do not bug the developers"), _SYS_STR("Adam has not authorized this, please do not bug the developers"),
_S("Lady returned objection"), _SYS_STR("Lady returned objection"),
_S("Unterminated plot thread 'Deleter' detected") _SYS_STR("Unterminated plot thread 'Deleter' detected")
}; };
constexpr uint32_t MomErrCount = std::extent<decltype(MomErr)>::value; constexpr uint32_t MomErrCount = std::extent<decltype(MomErr)>::value;
@ -53,10 +53,10 @@ SpecBase::~SpecBase()
cancelBackgroundIndex(); cancelBackgroundIndex();
} }
static const hecl::SystemString regNONE = _S(""); static const hecl::SystemString regNONE = _SYS_STR("");
static const hecl::SystemString regE = _S("NTSC"); static const hecl::SystemString regE = _SYS_STR("NTSC");
static const hecl::SystemString regJ = _S("NTSC-J"); static const hecl::SystemString regJ = _SYS_STR("NTSC-J");
static const hecl::SystemString regP = _S("PAL"); static const hecl::SystemString regP = _SYS_STR("PAL");
void SpecBase::setThreadProject() void SpecBase::setThreadProject()
{ {
@ -98,7 +98,7 @@ IDRestorer<IDType>::IDRestorer(const hecl::ProjectPath& yamlPath, const hecl::Da
return a.first < b.first; return a.first < b.first;
}); });
Log.report(logvisor::Info, _S("Loaded Original IDs '%s'"), yamlPath.getRelativePath().data()); Log.report(logvisor::Info, _SYS_STR("Loaded Original IDs '%s'"), yamlPath.getRelativePath().data());
} }
template <typename IDType> template <typename IDType>
@ -180,19 +180,19 @@ void SpecBase::doExtract(const ExtractPassInfo& info, const hecl::MultiProgressP
if (m_isWii) if (m_isWii)
{ {
/* Extract root files for repacking later */ /* Extract root files for repacking later */
hecl::ProjectPath outDir(m_project.getProjectWorkingPath(), _S("out")); hecl::ProjectPath outDir(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outDir.makeDirChain(true); outDir.makeDirChain(true);
nod::ExtractionContext ctx = {info.force, nullptr}; nod::ExtractionContext ctx = {info.force, nullptr};
if (!m_standalone) if (!m_standalone)
{ {
progress.print(_S("Trilogy Files"), _S(""), 0.0); progress.print(_SYS_STR("Trilogy Files"), _SYS_STR(""), 0.0);
nod::IPartition* data = m_disc->getDataPartition(); nod::IPartition* data = m_disc->getDataPartition();
const nod::Node& root = data->getFSTRoot(); const nod::Node& root = data->getFSTRoot();
for (const nod::Node& child : root) for (const nod::Node& child : root)
if (child.getKind() == nod::Node::Kind::File) if (child.getKind() == nod::Node::Kind::File)
child.extractToDirectory(outDir.getAbsolutePath(), ctx); child.extractToDirectory(outDir.getAbsolutePath(), ctx);
progress.print(_S("Trilogy Files"), _S(""), 1.0); progress.print(_SYS_STR("Trilogy Files"), _SYS_STR(""), 1.0);
} }
} }
extractFromDisc(*m_disc, info.force, progress); extractFromDisc(*m_disc, info.force, progress);
@ -201,19 +201,19 @@ void SpecBase::doExtract(const ExtractPassInfo& info, const hecl::MultiProgressP
static bool IsPathAudioGroup(const hecl::ProjectPath& path) static bool IsPathAudioGroup(const hecl::ProjectPath& path)
{ {
return (path.getPathType() == hecl::ProjectPath::Type::Directory && return (path.getPathType() == hecl::ProjectPath::Type::Directory &&
hecl::ProjectPath(path, _S("!project.yaml")).isFile() && hecl::ProjectPath(path, _SYS_STR("!project.yaml")).isFile() &&
hecl::ProjectPath(path, _S("!pool.yaml")).isFile()); hecl::ProjectPath(path, _SYS_STR("!pool.yaml")).isFile());
} }
static bool IsPathSong(const hecl::ProjectPath& path) static bool IsPathSong(const hecl::ProjectPath& path)
{ {
if (path.getPathType() != hecl::ProjectPath::Type::Glob || if (path.getPathType() != hecl::ProjectPath::Type::Glob ||
!path.getWithExtension(_S(".mid"), true).isFile() || !path.getWithExtension(_SYS_STR(".mid"), true).isFile() ||
!path.getWithExtension(_S(".yaml"), true).isFile()) !path.getWithExtension(_SYS_STR(".yaml"), true).isFile())
{ {
if (path.isFile() && if (path.isFile() &&
!hecl::StrCmp(_S("mid"), path.getLastComponentExt().data()) && !hecl::StrCmp(_SYS_STR("mid"), path.getLastComponentExt().data()) &&
path.getWithExtension(_S(".yaml"), true).isFile()) path.getWithExtension(_SYS_STR(".yaml"), true).isFile())
return true; return true;
return false; return false;
} }
@ -227,7 +227,7 @@ bool SpecBase::canCook(const hecl::ProjectPath& path, hecl::blender::Token& btok
hecl::ProjectPath asBlend; hecl::ProjectPath asBlend;
if (path.getPathType() == hecl::ProjectPath::Type::Glob) if (path.getPathType() == hecl::ProjectPath::Type::Glob)
asBlend = path.getWithExtension(_S(".blend"), true); asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
else else
asBlend = path; asBlend = path;
@ -278,20 +278,20 @@ const hecl::Database::DataSpecEntry* SpecBase::overrideDataSpec(const hecl::Proj
hecl::ProjectPath asBlend; hecl::ProjectPath asBlend;
if (path.getPathType() == hecl::ProjectPath::Type::Glob) if (path.getPathType() == hecl::ProjectPath::Type::Glob)
asBlend = path.getWithExtension(_S(".blend"), true); asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
else else
asBlend = path; asBlend = path;
if (hecl::IsPathBlend(asBlend)) if (hecl::IsPathBlend(asBlend))
{ {
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CSKR")) || if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CSKR")) ||
hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".ANIM"))) hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".ANIM")))
return oldEntry; return oldEntry;
hecl::blender::Connection& conn = btok.getBlenderConnection(); hecl::blender::Connection& conn = btok.getBlenderConnection();
if (!conn.openBlend(asBlend)) if (!conn.openBlend(asBlend))
{ {
Log.report(logvisor::Error, _S("unable to cook '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to cook '%s'"),
path.getAbsolutePath().data()); path.getAbsolutePath().data());
return nullptr; return nullptr;
} }
@ -315,7 +315,7 @@ void SpecBase::doCook(const hecl::ProjectPath& path, const hecl::ProjectPath& co
hecl::ProjectPath asBlend; hecl::ProjectPath asBlend;
if (path.getPathType() == hecl::ProjectPath::Type::Glob) if (path.getPathType() == hecl::ProjectPath::Type::Glob)
asBlend = path.getWithExtension(_S(".blend"), true); asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
else else
asBlend = path; asBlend = path;
@ -425,7 +425,7 @@ void SpecBase::flattenDependenciesBlend(const hecl::ProjectPath& in,
} }
case hecl::blender::BlendType::Actor: case hecl::blender::BlendType::Actor:
{ {
hecl::ProjectPath asGlob = in.getWithExtension(_S(".*"), true); hecl::ProjectPath asGlob = in.getWithExtension(_SYS_STR(".*"), true);
hecl::blender::DataStream ds = conn.beginData(); hecl::blender::DataStream ds = conn.beginData();
hecl::blender::Actor actor = ds.compileActorCharacterOnly(); hecl::blender::Actor actor = ds.compileActorCharacterOnly();
auto actNames = ds.getActionNames(); auto actNames = ds.getActionNames();
@ -442,11 +442,11 @@ void SpecBase::flattenDependenciesBlend(const hecl::ProjectPath& in,
} }
hecl::SystemStringConv chSysName(sub.name); hecl::SystemStringConv chSysName(sub.name);
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _S(".CSKR"))); pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _SYS_STR(".CSKR")));
const auto& arm = actor.armatures[sub.armature]; const auto& arm = actor.armatures[sub.armature];
hecl::SystemStringConv armSysName(arm.name); hecl::SystemStringConv armSysName(arm.name);
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _S(".CINF"))); pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _SYS_STR(".CINF")));
for (const auto& overlay : sub.overlayMeshes) for (const auto& overlay : sub.overlayMeshes)
{ {
hecl::SystemStringConv ovelaySys(overlay.first); hecl::SystemStringConv ovelaySys(overlay.first);
@ -455,8 +455,8 @@ void SpecBase::flattenDependenciesBlend(const hecl::ProjectPath& in,
flattenDependenciesBlend(overlay.second, pathsOut, btok); flattenDependenciesBlend(overlay.second, pathsOut, btok);
pathsOut.push_back(overlay.second); pathsOut.push_back(overlay.second);
} }
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _S('.') + pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _SYS_STR('.') +
ovelaySys.c_str() + _S(".CSKR"))); ovelaySys.c_str() + _SYS_STR(".CSKR")));
} }
} }
}; };
@ -475,28 +475,28 @@ void SpecBase::flattenDependenciesBlend(const hecl::ProjectPath& in,
} }
hecl::SystemStringConv chSysName(att.name); hecl::SystemStringConv chSysName(att.name);
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(_S("ATTACH.")) + pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(_SYS_STR("ATTACH.")) +
chSysName.c_str() + _S(".CSKR"))); chSysName.c_str() + _SYS_STR(".CSKR")));
if (att.armature >= 0) if (att.armature >= 0)
{ {
const auto& arm = actor.armatures[att.armature]; const auto& arm = actor.armatures[att.armature];
hecl::SystemStringConv armSysName(arm.name); hecl::SystemStringConv armSysName(arm.name);
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _S(".CINF"))); pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(armSysName.sys_str()) + _SYS_STR(".CINF")));
} }
} }
for (const auto& act : actNames) for (const auto& act : actNames)
{ {
hecl::SystemStringConv actSysName(act); hecl::SystemStringConv actSysName(act);
pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(actSysName.sys_str()) + _S(".ANIM"))); pathsOut.push_back(asGlob.ensureAuxInfo(hecl::SystemString(actSysName.sys_str()) + _SYS_STR(".ANIM")));
hecl::ProjectPath evntPath = asGlob.ensureAuxInfo({}).getWithExtension( hecl::ProjectPath evntPath = asGlob.ensureAuxInfo(hecl::SystemStringView{}).getWithExtension(
hecl::SysFormat(_S(".%s.evnt.yaml"), actSysName.c_str()).c_str(), true); hecl::SysFormat(_SYS_STR(".%s.evnt.yaml"), actSysName.c_str()).c_str(), true);
if (evntPath.isFile()) if (evntPath.isFile())
pathsOut.push_back(evntPath); pathsOut.push_back(evntPath);
} }
hecl::ProjectPath yamlPath = asGlob.getWithExtension(_S(".yaml"), true); hecl::ProjectPath yamlPath = asGlob.getWithExtension(_SYS_STR(".yaml"), true);
if (yamlPath.isFile()) if (yamlPath.isFile())
{ {
athena::io::FileReader reader(yamlPath.getAbsolutePath()); athena::io::FileReader reader(yamlPath.getAbsolutePath());
@ -528,7 +528,7 @@ void SpecBase::flattenDependencies(const hecl::ProjectPath& path,
hecl::ProjectPath asBlend; hecl::ProjectPath asBlend;
if (path.getPathType() == hecl::ProjectPath::Type::Glob) if (path.getPathType() == hecl::ProjectPath::Type::Glob)
asBlend = path.getWithExtension(_S(".blend"), true); asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
else else
asBlend = path; asBlend = path;
@ -579,8 +579,8 @@ void SpecBase::recursiveBuildResourceList(std::vector<urde::SObjectTag>& listOut
hecl::ProjectPath childPath(path, ent.m_name); hecl::ProjectPath childPath(path, ent.m_name);
if (ent.m_isDir) if (ent.m_isDir)
{ {
if (hecl::ProjectPath(childPath, _S("!project.yaml")).isFile() && if (hecl::ProjectPath(childPath, _SYS_STR("!project.yaml")).isFile() &&
hecl::ProjectPath(childPath, _S("!pool.yaml")).isFile()) hecl::ProjectPath(childPath, _SYS_STR("!pool.yaml")).isFile())
{ {
/* Handle AudioGroup case */ /* Handle AudioGroup case */
if (urde::SObjectTag tag = tagFromPath(childPath, btok)) if (urde::SObjectTag tag = tagFromPath(childPath, btok))
@ -624,7 +624,7 @@ void SpecBase::copyBuildListData(std::vector<std::tuple<size_t, size_t, bool>>&
int loadIdx = 0; int loadIdx = 0;
for (const auto& tag : buildList) for (const auto& tag : buildList)
{ {
hecl::SystemString str = hecl::SysFormat(_S("Copying %.4") FMT_CSTR_SYS " %08X", hecl::SystemString str = hecl::SysFormat(_SYS_STR("Copying %.4") FMT_CSTR_SYS " %08X",
tag.type.getChars(), (unsigned int)tag.id.Value()); tag.type.getChars(), (unsigned int)tag.id.Value());
progress.print(str.c_str(), nullptr, ++loadIdx / float(buildList.size())); progress.print(str.c_str(), nullptr, ++loadIdx / float(buildList.size()));
@ -635,7 +635,7 @@ void SpecBase::copyBuildListData(std::vector<std::tuple<size_t, size_t, bool>>&
{ {
auto search = mlvlData.find(tag.id); auto search = mlvlData.find(tag.id);
if (search == mlvlData.end()) if (search == mlvlData.end())
Log.report(logvisor::Fatal, _S("Unable to find MLVL %08X"), tag.id.Value()); Log.report(logvisor::Fatal, _SYS_STR("Unable to find MLVL %08X"), tag.id.Value());
std::get<0>(thisIdx) = pakOut.position(); std::get<0>(thisIdx) = pakOut.position();
std::get<1>(thisIdx) = ROUND_UP_32(search->second.size()); std::get<1>(thisIdx) = ROUND_UP_32(search->second.size());
@ -651,7 +651,7 @@ void SpecBase::copyBuildListData(std::vector<std::tuple<size_t, size_t, bool>>&
hecl::ProjectPath cooked = getCookedPath(path, true); hecl::ProjectPath cooked = getCookedPath(path, true);
athena::io::FileReader r(cooked.getAbsolutePath()); athena::io::FileReader r(cooked.getAbsolutePath());
if (r.hasError()) if (r.hasError())
Log.report(logvisor::Fatal, _S("Unable to open resource %s"), cooked.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("Unable to open resource %s"), cooked.getRelativePath().data());
atUint64 size = r.length(); atUint64 size = r.length();
auto data = r.readUBytes(size); auto data = r.readUBytes(size);
auto compData = compressPakData(tag, data.get(), size); auto compData = compressPakData(tag, data.get(), size);
@ -688,16 +688,16 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
waitForIndexComplete(); waitForIndexComplete();
/* Name pak based on root-relative components */ /* Name pak based on root-relative components */
auto components = path.getWithExtension(_S(""), true).getPathComponents(); auto components = path.getWithExtension(_SYS_STR(""), true).getPathComponents();
if (components.size() <= 1) if (components.size() <= 1)
return; return;
hecl::ProjectPath outPath; hecl::ProjectPath outPath;
if (hecl::ProjectPath(m_project.getProjectWorkingPath(), _S("out/files/") + components[0]).isDirectory()) if (hecl::ProjectPath(m_project.getProjectWorkingPath(), _SYS_STR("out/files/") + components[0]).isDirectory())
outPath.assign(m_project.getProjectWorkingPath(), outPath.assign(m_project.getProjectWorkingPath(),
_S("out/files/") + components[0] + _S("/") + components[1] + entry->m_pakExt.data()); _SYS_STR("out/files/") + components[0] + _SYS_STR("/") + components[1] + entry->m_pakExt.data());
else else
outPath.assign(m_project.getProjectWorkingPath(), outPath.assign(m_project.getProjectWorkingPath(),
_S("out/files/") + components[1] + entry->m_pakExt.data()); _SYS_STR("out/files/") + components[1] + entry->m_pakExt.data());
outPath.makeDirChain(false); outPath.makeDirChain(false);
/* Output file */ /* Output file */
@ -707,7 +707,7 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
std::unordered_map<urde::CAssetId, std::vector<uint8_t>> mlvlData; std::unordered_map<urde::CAssetId, std::vector<uint8_t>> mlvlData;
if (path.getPathType() == hecl::ProjectPath::Type::File && if (path.getPathType() == hecl::ProjectPath::Type::File &&
!hecl::StrCmp(path.getLastComponent().data(), _S("!world.blend"))) /* World PAK */ !hecl::StrCmp(path.getLastComponent().data(), _SYS_STR("!world.blend"))) /* World PAK */
{ {
/* Force-cook MLVL and write resource list structure */ /* Force-cook MLVL and write resource list structure */
m_project.cookPath(path, progress, false, true, fast, entry, cp); m_project.cookPath(path, progress, false, true, fast, entry, cp);
@ -779,7 +779,7 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
/* Async cook resource list if using ClientProcess */ /* Async cook resource list if using ClientProcess */
if (cp) if (cp)
{ {
Log.report(logvisor::Info, _S("Validating resources")); Log.report(logvisor::Info, _SYS_STR("Validating resources"));
progress.setMainIndeterminate(true); progress.setMainIndeterminate(true);
for (int i=0 ; i<entry->m_numCookPasses ; ++i) for (int i=0 ; i<entry->m_numCookPasses ; ++i)
{ {
@ -794,7 +794,7 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
hecl::ProjectPath depPath = pathFromTag(tag); hecl::ProjectPath depPath = pathFromTag(tag);
if (!depPath) if (!depPath)
{ {
Log.report(logvisor::Fatal, _S("Unable to resolve %.4s %08X"), Log.report(logvisor::Fatal, _SYS_STR("Unable to resolve %.4s %08X"),
tag.type.getChars(), tag.id.Value()); tag.type.getChars(), tag.id.Value());
} }
m_project.cookPath(depPath, progress, false, false, fast, entry, cp, i); m_project.cookPath(depPath, progress, false, false, fast, entry, cp, i);
@ -807,7 +807,7 @@ void SpecBase::doPackage(const hecl::ProjectPath& path, const hecl::Database::Da
/* Write resource data and build file index */ /* Write resource data and build file index */
std::vector<std::tuple<size_t, size_t, bool>> fileIndex; std::vector<std::tuple<size_t, size_t, bool>> fileIndex;
Log.report(logvisor::Info, _S("Copying data into %s"), outPath.getRelativePath().data()); Log.report(logvisor::Info, _SYS_STR("Copying data into %s"), outPath.getRelativePath().data());
copyBuildListData(fileIndex, buildList, entry, fast, progress, pakOut, mlvlData); copyBuildListData(fileIndex, buildList, entry, fast, progress, pakOut, mlvlData);
/* Write file index */ /* Write file index */
@ -848,20 +848,20 @@ static inline uint8_t Convert4To8(uint8_t v)
void SpecBase::extractRandomStaticEntropy(const uint8_t* buf, const hecl::ProjectPath& noAramPath) void SpecBase::extractRandomStaticEntropy(const uint8_t* buf, const hecl::ProjectPath& noAramPath)
{ {
hecl::ProjectPath entropyPath(noAramPath, _S("RandomStaticEntropy.png")); hecl::ProjectPath entropyPath(noAramPath, _SYS_STR("RandomStaticEntropy.png"));
hecl::ProjectPath catalogPath(noAramPath, _S("!catalog.yaml")); hecl::ProjectPath catalogPath(noAramPath, _SYS_STR("!catalog.yaml"));
if (FILE* fp = hecl::Fopen(catalogPath.getAbsolutePath().data(), _S("a"))) if (FILE* fp = hecl::Fopen(catalogPath.getAbsolutePath().data(), _SYS_STR("a")))
{ {
fprintf(fp, "RandomStaticEntropy: %s\n", entropyPath.getRelativePathUTF8().data()); fprintf(fp, "RandomStaticEntropy: %s\n", entropyPath.getRelativePathUTF8().data());
fclose(fp); fclose(fp);
} }
FILE* fp = hecl::Fopen(entropyPath.getAbsolutePath().data(), _S("wb")); FILE* fp = hecl::Fopen(entropyPath.getAbsolutePath().data(), _SYS_STR("wb"));
if (!fp) if (!fp)
{ {
Log.report(logvisor::Error, Log.report(logvisor::Error,
_S("Unable to open '%s' for writing"), _SYS_STR("Unable to open '%s' for writing"),
entropyPath.getAbsolutePath().data()); entropyPath.getAbsolutePath().data());
return; return;
} }
@ -1130,7 +1130,7 @@ void SpecBase::backgroundIndexRecursiveCatalogs(const hecl::ProjectPath& dir,
continue; continue;
/* Read catalog.yaml for .pak directory if exists */ /* Read catalog.yaml for .pak directory if exists */
if (level == 1 && !ent.m_name.compare(_S("!catalog.yaml"))) if (level == 1 && !ent.m_name.compare(_SYS_STR("!catalog.yaml")))
{ {
readCatalog(path, nameWriter); readCatalog(path, nameWriter);
continue; continue;
@ -1160,7 +1160,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
return true; return true;
/* Try as glob */ /* Try as glob */
hecl::ProjectPath asGlob = path.getWithExtension(_S(".*"), true); hecl::ProjectPath asGlob = path.getWithExtension(_SYS_STR(".*"), true);
if (m_pathToTag.find(asGlob.hash()) != m_pathToTag.cend()) if (m_pathToTag.find(asGlob.hash()) != m_pathToTag.cend())
return true; return true;
@ -1190,7 +1190,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
for (const std::string& arm : armatureNames) for (const std::string& arm : armatureNames)
{ {
hecl::SystemStringConv sysStr(arm); hecl::SystemStringConv sysStr(arm);
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S(".CINF")); hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR(".CINF"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1203,7 +1203,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
for (const std::string& sub : subtypeNames) for (const std::string& sub : subtypeNames)
{ {
hecl::SystemStringConv sysStr(sub); hecl::SystemStringConv sysStr(sub);
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S(".CSKR")); hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR(".CSKR"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1216,8 +1216,8 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
for (const auto& overlay : overlayNames) for (const auto& overlay : overlayNames)
{ {
hecl::SystemStringConv overlaySys(overlay); hecl::SystemStringConv overlaySys(overlay);
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S('.') + hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR('.') +
overlaySys.c_str() + _S(".CSKR")); overlaySys.c_str() + _SYS_STR(".CSKR"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1232,8 +1232,8 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
for (const auto& attachment : attachmentNames) for (const auto& attachment : attachmentNames)
{ {
hecl::SystemStringConv attachmentSys(attachment); hecl::SystemStringConv attachmentSys(attachment);
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(_S("ATTACH.")) + hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(_SYS_STR("ATTACH.")) +
attachmentSys.c_str() + _S(".CSKR")); attachmentSys.c_str() + _SYS_STR(".CSKR"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1246,7 +1246,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
for (const std::string& act : actionNames) for (const std::string& act : actionNames)
{ {
hecl::SystemStringConv sysStr(act); hecl::SystemStringConv sysStr(act);
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _S(".ANIM")); hecl::ProjectPath subPath = asGlob.ensureAuxInfo(hecl::SystemString(sysStr.sys_str()) + _SYS_STR(".ANIM"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1262,7 +1262,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
pathTag = {SBIG('MLVL'), asGlob.hash().val32()}; pathTag = {SBIG('MLVL'), asGlob.hash().val32()};
useGlob = true; useGlob = true;
hecl::ProjectPath subPath = asGlob.ensureAuxInfo(_S("MAPW")); hecl::ProjectPath subPath = asGlob.ensureAuxInfo(_SYS_STR("MAPW"));
urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender); urde::SObjectTag pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1271,7 +1271,7 @@ bool SpecBase::addFileToIndex(const hecl::ProjectPath& path,
DumpCacheAdd(pathTag, subPath); DumpCacheAdd(pathTag, subPath);
#endif #endif
subPath = asGlob.ensureAuxInfo(_S("SAVW")); subPath = asGlob.ensureAuxInfo(_SYS_STR("SAVW"));
pathTag = buildTagFromPath(subPath, m_backgroundBlender); pathTag = buildTagFromPath(subPath, m_backgroundBlender);
m_tagToPath[pathTag] = subPath; m_tagToPath[pathTag] = subPath;
m_pathToTag[subPath.hash()] = pathTag; m_pathToTag[subPath.hash()] = pathTag;
@ -1333,7 +1333,7 @@ void SpecBase::backgroundIndexRecursiveProc(const hecl::ProjectPath& dir,
continue; continue;
/* Read catalog.yaml for .pak directory if exists */ /* Read catalog.yaml for .pak directory if exists */
if (level == 1 && !ent.m_name.compare(_S("!catalog.yaml"))) if (level == 1 && !ent.m_name.compare(_SYS_STR("!catalog.yaml")))
{ {
readCatalog(path, nameWriter); readCatalog(path, nameWriter);
continue; continue;
@ -1349,8 +1349,8 @@ void SpecBase::backgroundIndexProc()
{ {
logvisor::RegisterThreadName("Resource Index"); logvisor::RegisterThreadName("Resource Index");
hecl::ProjectPath tagCachePath(m_project.getProjectCookedPath(getOriginalSpec()), _S("tag_cache.yaml")); hecl::ProjectPath tagCachePath(m_project.getProjectCookedPath(getOriginalSpec()), _SYS_STR("tag_cache.yaml"));
hecl::ProjectPath nameCachePath(m_project.getProjectCookedPath(getOriginalSpec()), _S("name_cache.yaml")); hecl::ProjectPath nameCachePath(m_project.getProjectCookedPath(getOriginalSpec()), _SYS_STR("name_cache.yaml"));
hecl::ProjectPath specRoot(m_project.getProjectWorkingPath(), getOriginalSpec().m_name); hecl::ProjectPath specRoot(m_project.getProjectWorkingPath(), getOriginalSpec().m_name);
/* Cache will be overwritten with validated entries afterwards */ /* Cache will be overwritten with validated entries afterwards */
@ -1363,7 +1363,7 @@ void SpecBase::backgroundIndexProc()
athena::io::FileReader reader(tagCachePath.getAbsolutePath()); athena::io::FileReader reader(tagCachePath.getAbsolutePath());
if (reader.isOpen()) if (reader.isOpen())
{ {
Log.report(logvisor::Info, _S("Cache index of '%s' loading"), getOriginalSpec().m_name.data()); Log.report(logvisor::Info, _SYS_STR("Cache index of '%s' loading"), getOriginalSpec().m_name.data());
athena::io::YAMLDocReader cacheReader; athena::io::YAMLDocReader cacheReader;
if (cacheReader.parse(&reader)) if (cacheReader.parse(&reader))
{ {
@ -1397,13 +1397,13 @@ void SpecBase::backgroundIndexProc()
} }
fprintf(stderr, "\r %" PRISize " / %" PRISize "\n", loadIdx, tagCount); fprintf(stderr, "\r %" PRISize " / %" PRISize "\n", loadIdx, tagCount);
} }
Log.report(logvisor::Info, _S("Cache index of '%s' loaded; %d tags"), Log.report(logvisor::Info, _SYS_STR("Cache index of '%s' loaded; %d tags"),
getOriginalSpec().m_name.data(), m_tagToPath.size()); getOriginalSpec().m_name.data(), m_tagToPath.size());
if (nameCachePath.isFile()) if (nameCachePath.isFile())
{ {
/* Read in name cache */ /* Read in name cache */
Log.report(logvisor::Info, _S("Name index of '%s' loading"), getOriginalSpec().m_name.data()); Log.report(logvisor::Info, _SYS_STR("Name index of '%s' loading"), getOriginalSpec().m_name.data());
athena::io::FileReader nreader(nameCachePath.getAbsolutePath()); athena::io::FileReader nreader(nameCachePath.getAbsolutePath());
athena::io::YAMLDocReader nameReader; athena::io::YAMLDocReader nameReader;
if (nameReader.parse(&nreader)) if (nameReader.parse(&nreader))
@ -1425,7 +1425,7 @@ void SpecBase::backgroundIndexProc()
} }
} }
} }
Log.report(logvisor::Info, _S("Name index of '%s' loaded; %d names"), Log.report(logvisor::Info, _SYS_STR("Name index of '%s' loaded; %d names"),
getOriginalSpec().m_name.data(), m_catalogNameToTag.size()); getOriginalSpec().m_name.data(), m_catalogNameToTag.size());
} }
} }
@ -1440,7 +1440,7 @@ void SpecBase::backgroundIndexProc()
m_catalogTagToNames[oidsTag].insert("MP1OriginalIDs"); m_catalogTagToNames[oidsTag].insert("MP1OriginalIDs");
} }
Log.report(logvisor::Info, _S("Background index of '%s' started"), getOriginalSpec().m_name.data()); Log.report(logvisor::Info, _SYS_STR("Background index of '%s' started"), getOriginalSpec().m_name.data());
backgroundIndexRecursiveProc(specRoot, cacheWriter, nameWriter, 0); backgroundIndexRecursiveProc(specRoot, cacheWriter, nameWriter, 0);
tagCachePath.makeDirChain(false); tagCachePath.makeDirChain(false);
@ -1451,7 +1451,7 @@ void SpecBase::backgroundIndexProc()
nameWriter.finish(&nwriter); nameWriter.finish(&nwriter);
m_backgroundBlender.shutdown(); m_backgroundBlender.shutdown();
Log.report(logvisor::Info, _S("Background index of '%s' complete; %d tags, %d names"), Log.report(logvisor::Info, _SYS_STR("Background index of '%s' complete; %d tags, %d names"),
getOriginalSpec().m_name.data(), m_tagToPath.size(), m_catalogNameToTag.size()); getOriginalSpec().m_name.data(), m_tagToPath.size(), m_catalogNameToTag.size());
m_backgroundRunning = false; m_backgroundRunning = false;
} }

138
DataSpec/SpecMP1.cpp
View File

@ -192,8 +192,8 @@ struct SpecMP1 : SpecBase
SpecMP1(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc) SpecMP1(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
: SpecBase(specEntry, project, pc) : SpecBase(specEntry, project, pc)
, m_workPath(project.getProjectWorkingPath(), _S("MP1")) , m_workPath(project.getProjectWorkingPath(), _SYS_STR("MP1"))
, m_cookPath(project.getProjectCookedPath(SpecEntMP1), _S("MP1")) , m_cookPath(project.getProjectCookedPath(SpecEntMP1), _SYS_STR("MP1"))
, m_pakRouter(*this, m_workPath, m_cookPath) , m_pakRouter(*this, m_workPath, m_cookPath)
, m_idRestorer({project.getProjectWorkingPath(), "MP1/!original_ids.yaml"}, project) , m_idRestorer({project.getProjectWorkingPath(), "MP1/!original_ids.yaml"}, project)
{ {
@ -289,13 +289,13 @@ struct SpecMP1 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP1"); rep.name = _SYS_STR("MP1");
rep.desc = _S("Metroid Prime ") + regstr; rep.desc = _SYS_STR("Metroid Prime ") + regstr;
if (buildInfo) if (buildInfo)
{ {
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
} }
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
@ -317,13 +317,13 @@ struct SpecMP1 : SpecBase
{ {
hecl::SystemString lowerArg = arg; hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg); hecl::ToLower(lowerArg);
if (!lowerArg.compare(0, 3, _S("mp1"))) if (!lowerArg.compare(0, 3, _SYS_STR("mp1")))
{ {
doExtract = true; doExtract = true;
mp1args.reserve(args.size()); mp1args.reserve(args.size());
size_t slashPos = arg.find(_S('/')); size_t slashPos = arg.find(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos) if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_S('\\')); slashPos = arg.find(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
mp1args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end())); mp1args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
} }
@ -351,13 +351,13 @@ struct SpecMP1 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP1"); rep.name = _SYS_STR("MP1");
rep.desc = _S("Metroid Prime ") + regstr; rep.desc = _SYS_STR("Metroid Prime ") + regstr;
if (buildInfo) if (buildInfo)
{ {
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
} }
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
@ -375,37 +375,37 @@ struct SpecMP1 : SpecBase
bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress) bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress)
{ {
m_project.enableDataSpecs({_S("MP1-PC")}); m_project.enableDataSpecs({_SYS_STR("MP1-PC")});
nod::ExtractionContext ctx = {force, nullptr}; nod::ExtractionContext ctx = {force, nullptr};
m_workPath.makeDir(); m_workPath.makeDir();
progress.startNewLine(); progress.startNewLine();
progress.print(_S("Indexing PAKs"), _S(""), 0.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
m_pakRouter.build(m_paks, [&progress](float factor) { progress.print(_S("Indexing PAKs"), _S(""), factor); }); m_pakRouter.build(m_paks, [&progress](float factor) { progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor); });
progress.print(_S("Indexing PAKs"), _S(""), 1.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _S("out")); hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outPath.makeDir(); outPath.makeDir();
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx); disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
hecl::ProjectPath mp1OutPath(outPath, m_standalone ? _S("files") : _S("files/MP1")); hecl::ProjectPath mp1OutPath(outPath, m_standalone ? _SYS_STR("files") : _SYS_STR("files/MP1"));
mp1OutPath.makeDirChain(true); mp1OutPath.makeDirChain(true);
/* Extract non-pak files */ /* Extract non-pak files */
progress.startNewLine(); progress.startNewLine();
progress.print(_S("MP1 Root"), _S(""), 0.0); progress.print(_SYS_STR("MP1 Root"), _SYS_STR(""), 0.0);
int prog = 0; int prog = 0;
ctx.progressCB = [&](std::string_view name, float) { ctx.progressCB = [&](std::string_view name, float) {
hecl::SystemStringConv nameView(name); hecl::SystemStringConv nameView(name);
progress.print(_S("MP1 Root"), nameView.c_str(), prog / (float)m_nonPaks.size()); progress.print(_SYS_STR("MP1 Root"), nameView.c_str(), prog / (float)m_nonPaks.size());
}; };
for (const nod::Node* node : m_nonPaks) for (const nod::Node* node : m_nonPaks)
{ {
node->extractToDirectory(mp1OutPath.getAbsolutePath(), ctx); node->extractToDirectory(mp1OutPath.getAbsolutePath(), ctx);
prog++; prog++;
} }
progress.print(_S("MP1 Root"), _S(""), 1.0); progress.print(_SYS_STR("MP1 Root"), _SYS_STR(""), 1.0);
/* Extract unique resources */ /* Extract unique resources */
hecl::ClientProcess process; hecl::ClientProcess process;
@ -445,7 +445,7 @@ struct SpecMP1 : SpecBase
process.waitUntilComplete(); process.waitUntilComplete();
/* Extract part of .dol for RandomStatic entropy */ /* Extract part of .dol for RandomStatic entropy */
hecl::ProjectPath noAramPath(m_project.getProjectWorkingPath(), _S("MP1/NoARAM")); hecl::ProjectPath noAramPath(m_project.getProjectWorkingPath(), _SYS_STR("MP1/NoARAM"));
extractRandomStaticEntropy(m_dolBuf.get() + 0x4f60, noAramPath); extractRandomStaticEntropy(m_dolBuf.get() + 0x4f60, noAramPath);
/* Generate original ID mapping for MLVL and SCAN entries - marks complete project */ /* Generate original ID mapping for MLVL and SCAN entries - marks complete project */
@ -462,7 +462,7 @@ struct SpecMP1 : SpecBase
bool checkPathPrefix(const hecl::ProjectPath& path) const bool checkPathPrefix(const hecl::ProjectPath& path) const
{ {
return path.getRelativePath().compare(0, 4, _S("MP1/")) == 0; return path.getRelativePath().compare(0, 4, _SYS_STR("MP1/")) == 0;
} }
bool validateYAMLDNAType(athena::io::IStreamReader& fp) const bool validateYAMLDNAType(athena::io::IStreamReader& fp) const
@ -540,20 +540,20 @@ struct SpecMP1 : SpecBase
urde::SObjectTag buildTagFromPath(const hecl::ProjectPath& path, hecl::blender::Token& btok) const urde::SObjectTag buildTagFromPath(const hecl::ProjectPath& path, hecl::blender::Token& btok) const
{ {
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CINF"))) if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CINF")))
return {SBIG('CINF'), path.hash().val32()}; return {SBIG('CINF'), path.hash().val32()};
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CSKR"))) else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CSKR")))
return {SBIG('CSKR'), path.hash().val32()}; return {SBIG('CSKR'), path.hash().val32()};
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".ANIM"))) else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".ANIM")))
return {SBIG('ANIM'), path.hash().val32()}; return {SBIG('ANIM'), path.hash().val32()};
else if (const hecl::SystemChar* ext = path.getLastComponentExt().data()) else if (const hecl::SystemChar* ext = path.getLastComponentExt().data())
{ {
if (ext[0] == _S('*') || !hecl::StrCmp(ext, _S("mid"))) if (ext[0] == _SYS_STR('*') || !hecl::StrCmp(ext, _SYS_STR("mid")))
{ {
if (path.getWithExtension(_S(".mid"), true).isFile() && if (path.getWithExtension(_SYS_STR(".mid"), true).isFile() &&
path.getWithExtension(_S(".yaml"), true).isFile()) path.getWithExtension(_SYS_STR(".yaml"), true).isFile())
{ {
hecl::ProjectPath glob = path.getWithExtension(_S(".*"), true); hecl::ProjectPath glob = path.getWithExtension(_SYS_STR(".*"), true);
return {SBIG('CSNG'), glob.hash().val32()}; return {SBIG('CSNG'), glob.hash().val32()};
} }
} }
@ -561,14 +561,14 @@ struct SpecMP1 : SpecBase
if (path.getPathType() == hecl::ProjectPath::Type::Directory) if (path.getPathType() == hecl::ProjectPath::Type::Directory)
{ {
if (hecl::ProjectPath(path, _S("!project.yaml")).isFile() && if (hecl::ProjectPath(path, _SYS_STR("!project.yaml")).isFile() &&
hecl::ProjectPath(path, _S("!pool.yaml")).isFile()) hecl::ProjectPath(path, _SYS_STR("!pool.yaml")).isFile())
return {SBIG('AGSC'), path.hash().val32()}; return {SBIG('AGSC'), path.hash().val32()};
} }
hecl::ProjectPath asBlend; hecl::ProjectPath asBlend;
if (path.getPathType() == hecl::ProjectPath::Type::Glob) if (path.getPathType() == hecl::ProjectPath::Type::Glob)
asBlend = path.getWithExtension(_S(".blend"), true); asBlend = path.getWithExtension(_SYS_STR(".blend"), true);
else else
asBlend = path; asBlend = path;
@ -589,26 +589,26 @@ struct SpecMP1 : SpecBase
case hecl::blender::BlendType::Actor: case hecl::blender::BlendType::Actor:
if (path.getAuxInfo().size()) if (path.getAuxInfo().size())
{ {
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CINF"))) if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CINF")))
return {SBIG('CINF'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('CINF'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CSKR"))) else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".CSKR")))
return {SBIG('CSKR'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('CSKR'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".ANIM"))) else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR(".ANIM")))
return {SBIG('ANIM'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('ANIM'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
} }
return {SBIG('ANCS'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('ANCS'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
case hecl::blender::BlendType::Area: case hecl::blender::BlendType::Area:
return {SBIG('MREA'), path.hash().val32()}; return {SBIG('MREA'), path.hash().val32()};
case hecl::blender::BlendType::World: case hecl::blender::BlendType::World:
{ {
if (path.getAuxInfo().size()) if (path.getAuxInfo().size())
{ {
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S("MAPW"))) if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR("MAPW")))
return {SBIG('MAPW'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('MAPW'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S("SAVW"))) else if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _SYS_STR("SAVW")))
return {SBIG('SAVW'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('SAVW'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
} }
return {SBIG('MLVL'), path.getWithExtension(_S(".*"), true).hash().val32()}; return {SBIG('MLVL'), path.getWithExtension(_SYS_STR(".*"), true).hash().val32()};
} }
case hecl::blender::BlendType::MapArea: case hecl::blender::BlendType::MapArea:
return {SBIG('MAPA'), path.hash().val32()}; return {SBIG('MAPA'), path.hash().val32()};
@ -626,7 +626,7 @@ struct SpecMP1 : SpecBase
} }
else if (hecl::IsPathYAML(path)) else if (hecl::IsPathYAML(path))
{ {
FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _S("r")); FILE* fp = hecl::Fopen(path.getAbsolutePath().data(), _SYS_STR("r"));
if (!fp) if (!fp)
return {}; return {};
@ -764,7 +764,7 @@ struct SpecMP1 : SpecBase
{ {
Mesh mesh = Mesh mesh =
ds.compileMesh(fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, m_pc ? 16 : -1, ds.compileMesh(fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, m_pc ? 16 : -1,
[&progress](int surfCount) { progress(hecl::SysFormat(_S("%d"), surfCount).c_str()); }); [&progress](int surfCount) { progress(hecl::SysFormat(_SYS_STR("%d"), surfCount).c_str()); });
if (m_pc) if (m_pc)
DNAMP1::CMDL::HMDLCook(out, in, mesh); DNAMP1::CMDL::HMDLCook(out, in, mesh);
@ -791,12 +791,12 @@ struct SpecMP1 : SpecBase
void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast, void cookActor(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) hecl::blender::Token& btok, FCookProgress progress)
{ {
if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S(".CINF"))) if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR(".CINF")))
{ {
Actor actor = ds.compileActorCharacterOnly(); Actor actor = ds.compileActorCharacterOnly();
DNAMP1::ANCS::CookCINF(out, in, actor); DNAMP1::ANCS::CookCINF(out, in, actor);
} }
else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S(".CSKR"))) else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR(".CSKR")))
{ {
Actor actor = ds.compileActorCharacterOnly(); Actor actor = ds.compileActorCharacterOnly();
ds.close(); ds.close();
@ -817,7 +817,7 @@ struct SpecMP1 : SpecBase
}); });
} }
} }
else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S(".ANIM"))) else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR(".ANIM")))
{ {
Actor actor = ds.compileActorCharacterOnly(); Actor actor = ds.compileActorCharacterOnly();
DNAMP1::ANCS::CookANIM(out, in, actor, ds, m_pc); DNAMP1::ANCS::CookANIM(out, in, actor, ds, m_pc);
@ -841,7 +841,7 @@ struct SpecMP1 : SpecBase
{ {
if (ent2.m_isDir) if (ent2.m_isDir)
{ {
hecl::ProjectPath wldPath(pakPath, ent2.m_name + _S("/!world.blend")); hecl::ProjectPath wldPath(pakPath, ent2.m_name + _SYS_STR("/!world.blend"));
if (wldPath.isFile()) if (wldPath.isFile())
{ {
if (!conn.openBlend(wldPath)) if (!conn.openBlend(wldPath))
@ -872,16 +872,16 @@ struct SpecMP1 : SpecBase
if (!mesh.compare("CMESH")) if (!mesh.compare("CMESH"))
{ {
colMesh = ds.compileColMesh(mesh); colMesh = ds.compileColMesh(mesh);
progress(_S("Collision Mesh")); progress(_SYS_STR("Collision Mesh"));
continue; continue;
} }
meshCompiles.push_back(ds.compileMesh( meshCompiles.push_back(ds.compileMesh(
mesh, fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, -1, !m_pc, mesh, fast ? hecl::HMDLTopology::Triangles : hecl::HMDLTopology::TriStrips, -1, !m_pc,
[&](int surfCount) { progress(hecl::SysFormat(_S("%s %d"), meshSys.c_str(), surfCount).c_str()); })); [&](int surfCount) { progress(hecl::SysFormat(_SYS_STR("%s %d"), meshSys.c_str(), surfCount).c_str()); }));
} }
if (!colMesh) if (!colMesh)
Log.report(logvisor::Fatal, _S("unable to find mesh named 'CMESH' in %s"), in.getAbsolutePath().data()); Log.report(logvisor::Fatal, _SYS_STR("unable to find mesh named 'CMESH' in %s"), in.getAbsolutePath().data());
std::vector<Light> lights = ds.compileLights(); std::vector<Light> lights = ds.compileLights();
@ -900,13 +900,13 @@ struct SpecMP1 : SpecBase
void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast, void cookWorld(const hecl::ProjectPath& out, const hecl::ProjectPath& in, BlendStream& ds, bool fast,
hecl::blender::Token& btok, FCookProgress progress) hecl::blender::Token& btok, FCookProgress progress)
{ {
if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S("MAPW"))) if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR("MAPW")))
{ {
hecl::blender::World world = ds.compileWorld(); hecl::blender::World world = ds.compileWorld();
ds.close(); ds.close();
DNAMP1::MLVL::CookMAPW(out, world, btok); DNAMP1::MLVL::CookMAPW(out, world, btok);
} }
else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _S("SAVW"))) else if (hecl::StringUtils::EndsWith(in.getAuxInfo(), _SYS_STR("SAVW")))
{ {
hecl::blender::World world = ds.compileWorld(); hecl::blender::World world = ds.compileWorld();
ds.close(); ds.close();
@ -1125,7 +1125,7 @@ struct SpecMP1 : SpecBase
OriginalIDs::Cook(in, out); OriginalIDs::Cook(in, out);
} }
} }
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void flattenDependenciesYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut) void flattenDependenciesYAML(athena::io::IStreamReader& fin, std::vector<hecl::ProjectPath>& pathsOut)
@ -1243,7 +1243,7 @@ struct SpecMP1 : SpecBase
{ {
athena::io::FileReader r(worldPathCooked.getAbsolutePath()); athena::io::FileReader r(worldPathCooked.getAbsolutePath());
if (r.hasError()) if (r.hasError())
Log.report(logvisor::Fatal, _S("Unable to open world %s"), worldPathCooked.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("Unable to open world %s"), worldPathCooked.getRelativePath().data());
mlvl.read(r); mlvl.read(r);
} }
@ -1262,7 +1262,7 @@ struct SpecMP1 : SpecBase
} }
listOut.reserve(count); listOut.reserve(count);
urde::SObjectTag worldTag = tagFromPath(worldPath.getWithExtension(_S(".*"), true), btok); urde::SObjectTag worldTag = tagFromPath(worldPath.getWithExtension(_SYS_STR(".*"), true), btok);
w.writeUint32Big(m_pc ? 0x80030005 : 0x00030005); w.writeUint32Big(m_pc ? 0x80030005 : 0x00030005);
w.writeUint32Big(0); w.writeUint32Big(0);
@ -1283,7 +1283,7 @@ struct SpecMP1 : SpecBase
bool dupeRes = false; bool dupeRes = false;
if (hecl::ProjectPath areaDir = pathFromTag(areaTag).getParentPath()) if (hecl::ProjectPath areaDir = pathFromTag(areaTag).getParentPath())
dupeRes = hecl::ProjectPath(areaDir, _S("!duperes")).isFile(); dupeRes = hecl::ProjectPath(areaDir, _SYS_STR("!duperes")).isFile();
urde::SObjectTag nameTag(FOURCC('STRG'), originalToNew(area.areaNameId)); urde::SObjectTag nameTag(FOURCC('STRG'), originalToNew(area.areaNameId));
if (nameTag) if (nameTag)
@ -1350,10 +1350,10 @@ struct SpecMP1 : SpecBase
{ {
athena::io::FileReader r(mapCookedPath.getAbsolutePath()); athena::io::FileReader r(mapCookedPath.getAbsolutePath());
if (r.hasError()) if (r.hasError())
Log.report(logvisor::Fatal, _S("Unable to open %s"), mapCookedPath.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("Unable to open %s"), mapCookedPath.getRelativePath().data());
if (r.readUint32Big() != 0xDEADF00D) if (r.readUint32Big() != 0xDEADF00D)
Log.report(logvisor::Fatal, _S("Corrupt MAPW %s"), mapCookedPath.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("Corrupt MAPW %s"), mapCookedPath.getRelativePath().data());
r.readUint32Big(); r.readUint32Big();
atUint32 mapaCount = r.readUint32Big(); atUint32 mapaCount = r.readUint32Big();
for (int i=0 ; i<mapaCount ; ++i) for (int i=0 ; i<mapaCount ; ++i)
@ -1380,7 +1380,7 @@ struct SpecMP1 : SpecBase
{ {
urde::SObjectTag texTag = tagFromPath(tex, btok); urde::SObjectTag texTag = tagFromPath(tex, btok);
if (!texTag) if (!texTag)
Log.report(logvisor::Fatal, _S("Unable to resolve %s"), tex.getRelativePath().data()); Log.report(logvisor::Fatal, _SYS_STR("Unable to resolve %s"), tex.getRelativePath().data());
listOut.push_back(texTag); listOut.push_back(texTag);
} }
} }
@ -1505,13 +1505,13 @@ struct SpecMP1 : SpecBase
void cookAudioGroup(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) void cookAudioGroup(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress)
{ {
DNAMP1::AGSC::Cook(in, out); DNAMP1::AGSC::Cook(in, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress) void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in, FCookProgress progress)
{ {
DNAMP1::CSNG::Cook(in, out); DNAMP1::CSNG::Cook(in, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
@ -1521,7 +1521,7 @@ struct SpecMP1 : SpecBase
hecl::blender::MapArea mapa = ds.compileMapArea(); hecl::blender::MapArea mapa = ds.compileMapArea();
ds.close(); ds.close();
DNAMP1::MAPA::Cook(mapa, out); DNAMP1::MAPA::Cook(mapa, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
@ -1531,18 +1531,18 @@ struct SpecMP1 : SpecBase
hecl::blender::MapUniverse mapu = ds.compileMapUniverse(); hecl::blender::MapUniverse mapu = ds.compileMapUniverse();
ds.close(); ds.close();
DNAMAPU::MAPU::Cook(mapu, out); DNAMAPU::MAPU::Cook(mapu, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
}; };
hecl::Database::DataSpecEntry SpecEntMP1 = { hecl::Database::DataSpecEntry SpecEntMP1 = {
_S("MP1"sv), _S("Data specification for original Metroid Prime engine"sv), _S(".pak"sv), 2, _SYS_STR("MP1"sv), _SYS_STR("Data specification for original Metroid Prime engine"sv), _SYS_STR(".pak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool) -> std::unique_ptr<hecl::Database::IDataSpec> { [](hecl::Database::Project& project, hecl::Database::DataSpecTool) -> std::unique_ptr<hecl::Database::IDataSpec> {
return std::make_unique<SpecMP1>(&SpecEntMP1, project, false); return std::make_unique<SpecMP1>(&SpecEntMP1, project, false);
}}; }};
hecl::Database::DataSpecEntry SpecEntMP1PC = { hecl::Database::DataSpecEntry SpecEntMP1PC = {
_S("MP1-PC"sv), _S("Data specification for PC-optimized Metroid Prime engine"sv), _S(".upak"sv), 2, _SYS_STR("MP1-PC"sv), _SYS_STR("Data specification for PC-optimized Metroid Prime engine"sv), _SYS_STR(".upak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool tool) -> std::unique_ptr<hecl::Database::IDataSpec> { [](hecl::Database::Project& project, hecl::Database::DataSpecTool tool) -> std::unique_ptr<hecl::Database::IDataSpec> {
if (tool != hecl::Database::DataSpecTool::Extract) if (tool != hecl::Database::DataSpecTool::Extract)
return std::make_unique<SpecMP1>(&SpecEntMP1PC, project, true); return std::make_unique<SpecMP1>(&SpecEntMP1PC, project, true);
@ -1550,5 +1550,5 @@ hecl::Database::DataSpecEntry SpecEntMP1PC = {
}}; }};
hecl::Database::DataSpecEntry SpecEntMP1ORIG = { hecl::Database::DataSpecEntry SpecEntMP1ORIG = {
_S("MP1-ORIG"sv), _S("Data specification for unmodified Metroid Prime resources"sv), {}, 2, {}}; _SYS_STR("MP1-ORIG"sv), _SYS_STR("Data specification for unmodified Metroid Prime resources"sv), {}, 2, {}};
} }

60
DataSpec/SpecMP2.cpp
View File

@ -153,8 +153,8 @@ struct SpecMP2 : SpecBase
SpecMP2(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc) SpecMP2(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
: SpecBase(specEntry, project, pc), : SpecBase(specEntry, project, pc),
m_workPath(project.getProjectWorkingPath(), _S("MP2")), m_workPath(project.getProjectWorkingPath(), _SYS_STR("MP2")),
m_cookPath(project.getProjectCookedPath(SpecEntMP2), _S("MP2")), m_cookPath(project.getProjectCookedPath(SpecEntMP2), _SYS_STR("MP2")),
m_pakRouter(*this, m_workPath, m_cookPath), m_pakRouter(*this, m_workPath, m_cookPath),
m_idRestorer({project.getProjectWorkingPath(), "MP2/!original_ids.yaml"}, project) m_idRestorer({project.getProjectWorkingPath(), "MP2/!original_ids.yaml"}, project)
{ {
@ -252,11 +252,11 @@ struct SpecMP2 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP2"); rep.name = _SYS_STR("MP2");
rep.desc = _S("Metroid Prime 2 ") + regstr; rep.desc = _SYS_STR("Metroid Prime 2 ") + regstr;
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
nod::Node& root = partition->getFSTRoot(); nod::Node& root = partition->getFSTRoot();
@ -279,13 +279,13 @@ struct SpecMP2 : SpecBase
{ {
hecl::SystemString lowerArg = arg; hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg); hecl::ToLower(lowerArg);
if (!lowerArg.compare(0, 3, _S("mp2"))) if (!lowerArg.compare(0, 3, _SYS_STR("mp2")))
{ {
doExtract = true; doExtract = true;
mp2args.reserve(args.size()); mp2args.reserve(args.size());
size_t slashPos = arg.find(_S('/')); size_t slashPos = arg.find(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos) if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_S('\\')); slashPos = arg.find(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
mp2args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end())); mp2args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
} }
@ -313,13 +313,13 @@ struct SpecMP2 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP2"); rep.name = _SYS_STR("MP2");
rep.desc = _S("Metroid Prime 2 ") + regstr; rep.desc = _SYS_STR("Metroid Prime 2 ") + regstr;
if (buildInfo) if (buildInfo)
{ {
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
} }
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
@ -342,32 +342,32 @@ struct SpecMP2 : SpecBase
m_workPath.makeDir(); m_workPath.makeDir();
progress.startNewLine(); progress.startNewLine();
progress.print(_S("Indexing PAKs"), _S(""), 0.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
m_pakRouter.build(m_paks, [&progress](float factor) m_pakRouter.build(m_paks, [&progress](float factor)
{ {
progress.print(_S("Indexing PAKs"), _S(""), factor); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor);
}); });
progress.print(_S("Indexing PAKs"), _S(""), 1.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _S("out")); hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outPath.makeDir(); outPath.makeDir();
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx); disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
hecl::ProjectPath mp2OutPath(outPath, m_standalone ? _S("files") : _S("files/MP2")); hecl::ProjectPath mp2OutPath(outPath, m_standalone ? _SYS_STR("files") : _SYS_STR("files/MP2"));
mp2OutPath.makeDirChain(true); mp2OutPath.makeDirChain(true);
progress.startNewLine(); progress.startNewLine();
progress.print(_S("MP2 Root"), _S(""), 0.0); progress.print(_SYS_STR("MP2 Root"), _SYS_STR(""), 0.0);
int prog = 0; int prog = 0;
ctx.progressCB = [&prog, &progress](std::string_view name, float) { ctx.progressCB = [&prog, &progress](std::string_view name, float) {
hecl::SystemStringConv nameView(name); hecl::SystemStringConv nameView(name);
progress.print(_S("MP2 Root"), nameView.c_str(), prog); progress.print(_SYS_STR("MP2 Root"), nameView.c_str(), prog);
}; };
for (const nod::Node* node : m_nonPaks) for (const nod::Node* node : m_nonPaks)
{ {
node->extractToDirectory(mp2OutPath.getAbsolutePath(), ctx); node->extractToDirectory(mp2OutPath.getAbsolutePath(), ctx);
prog++; prog++;
} }
progress.print(_S("MP2 Root"), _S(""), 1.0); progress.print(_SYS_STR("MP2 Root"), _SYS_STR(""), 1.0);
hecl::ClientProcess process; hecl::ClientProcess process;
progress.startNewLine(); progress.startNewLine();
@ -417,7 +417,7 @@ struct SpecMP2 : SpecBase
bool checkPathPrefix(const hecl::ProjectPath& path) const bool checkPathPrefix(const hecl::ProjectPath& path) const
{ {
return path.getRelativePath().compare(0, 4, _S("MP2/")) == 0; return path.getRelativePath().compare(0, 4, _SYS_STR("MP2/")) == 0;
} }
bool validateYAMLDNAType(athena::io::IStreamReader& fp) const bool validateYAMLDNAType(athena::io::IStreamReader& fp) const
@ -500,14 +500,14 @@ struct SpecMP2 : SpecBase
FCookProgress progress) FCookProgress progress)
{ {
DNAMP2::AGSC::Cook(in, out); DNAMP2::AGSC::Cook(in, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookSong(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
FCookProgress progress) FCookProgress progress)
{ {
DNAMP1::CSNG::Cook(in, out); DNAMP1::CSNG::Cook(in, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookMapArea(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
@ -517,7 +517,7 @@ struct SpecMP2 : SpecBase
hecl::blender::MapArea mapa = ds.compileMapArea(); hecl::blender::MapArea mapa = ds.compileMapArea();
ds.close(); ds.close();
DNAMP2::MAPA::Cook(mapa, out); DNAMP2::MAPA::Cook(mapa, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
@ -527,7 +527,7 @@ struct SpecMP2 : SpecBase
hecl::blender::MapUniverse mapu = ds.compileMapUniverse(); hecl::blender::MapUniverse mapu = ds.compileMapUniverse();
ds.close(); ds.close();
DNAMAPU::MAPU::Cook(mapu, out); DNAMAPU::MAPU::Cook(mapu, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
UniqueID32 newToOriginal(urde::CAssetId id) const UniqueID32 newToOriginal(urde::CAssetId id) const
@ -547,16 +547,16 @@ struct SpecMP2 : SpecBase
hecl::Database::DataSpecEntry SpecEntMP2 hecl::Database::DataSpecEntry SpecEntMP2
( (
_S("MP2"sv), _SYS_STR("MP2"sv),
_S("Data specification for original Metroid Prime 2 engine"sv), _S(".pak"sv), 2, _SYS_STR("Data specification for original Metroid Prime 2 engine"sv), _SYS_STR(".pak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool) [](hecl::Database::Project& project, hecl::Database::DataSpecTool)
-> std::unique_ptr<hecl::Database::IDataSpec> {return std::make_unique<SpecMP2>(&SpecEntMP2, project, false);} -> std::unique_ptr<hecl::Database::IDataSpec> {return std::make_unique<SpecMP2>(&SpecEntMP2, project, false);}
); );
hecl::Database::DataSpecEntry SpecEntMP2PC = hecl::Database::DataSpecEntry SpecEntMP2PC =
{ {
_S("MP2-PC"sv), _SYS_STR("MP2-PC"sv),
_S("Data specification for PC-optimized Metroid Prime 2 engine"sv), _S(".upak"sv), 2, _SYS_STR("Data specification for PC-optimized Metroid Prime 2 engine"sv), _SYS_STR(".upak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool tool) [](hecl::Database::Project& project, hecl::Database::DataSpecTool tool)
-> std::unique_ptr<hecl::Database::IDataSpec> -> std::unique_ptr<hecl::Database::IDataSpec>
{ {
@ -568,8 +568,8 @@ hecl::Database::DataSpecEntry SpecEntMP2PC =
hecl::Database::DataSpecEntry SpecEntMP2ORIG = hecl::Database::DataSpecEntry SpecEntMP2ORIG =
{ {
_S("MP2-ORIG"sv), _SYS_STR("MP2-ORIG"sv),
_S("Data specification for unmodified Metroid Prime 2 resources"sv), _SYS_STR("Data specification for unmodified Metroid Prime 2 resources"sv),
{}, 2, {} {}, 2, {}
}; };

92
DataSpec/SpecMP3.cpp
View File

@ -146,11 +146,11 @@ struct SpecMP3 : SpecBase
SpecMP3(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc) SpecMP3(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
: SpecBase(specEntry, project, pc), : SpecBase(specEntry, project, pc),
m_workPath(project.getProjectWorkingPath(), _S("MP3")), m_workPath(project.getProjectWorkingPath(), _SYS_STR("MP3")),
m_cookPath(project.getProjectCookedPath(SpecEntMP3), _S("MP3")), m_cookPath(project.getProjectCookedPath(SpecEntMP3), _SYS_STR("MP3")),
m_pakRouter(*this, m_workPath, m_cookPath), m_pakRouter(*this, m_workPath, m_cookPath),
m_feWorkPath(project.getProjectWorkingPath(), _S("fe")), m_feWorkPath(project.getProjectWorkingPath(), _SYS_STR("fe")),
m_feCookPath(project.getProjectCookedPath(SpecEntMP3), _S("fe")), m_feCookPath(project.getProjectCookedPath(SpecEntMP3), _SYS_STR("fe")),
m_fePakRouter(*this, m_feWorkPath, m_feCookPath), m_fePakRouter(*this, m_feWorkPath, m_feCookPath),
m_idRestorer({project.getProjectWorkingPath(), "MP3/!original_ids.yaml"}, project) m_idRestorer({project.getProjectWorkingPath(), "MP3/!original_ids.yaml"}, project)
{ {
@ -261,13 +261,13 @@ struct SpecMP3 : SpecBase
else if (!item.first.compare("Metroid6.pak")) else if (!item.first.compare("Metroid6.pak"))
{ {
/* Phaaze doesn't have a world name D: */ /* Phaaze doesn't have a world name D: */
childRep.desc = _S("Phaaze"); childRep.desc = _SYS_STR("Phaaze");
continue; continue;
} }
else if (!item.first.compare("Metroid8.pak")) else if (!item.first.compare("Metroid8.pak"))
{ {
/* Space world is misnamed */ /* Space world is misnamed */
childRep.desc = _S("Space"); childRep.desc = _SYS_STR("Space");
continue; continue;
} }
childRep.desc = item.second->getLevelString(); childRep.desc = item.second->getLevelString();
@ -293,11 +293,11 @@ struct SpecMP3 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP3"); rep.name = _SYS_STR("MP3");
rep.desc = _S("Metroid Prime 3 ") + regstr; rep.desc = _SYS_STR("Metroid Prime 3 ") + regstr;
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
nod::Node& root = partition->getFSTRoot(); nod::Node& root = partition->getFSTRoot();
@ -320,13 +320,13 @@ struct SpecMP3 : SpecBase
{ {
hecl::SystemString lowerArg = arg; hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg); hecl::ToLower(lowerArg);
if (!lowerArg.compare(0, 3, _S("mp3"))) if (!lowerArg.compare(0, 3, _SYS_STR("mp3")))
{ {
doMP3 = true; doMP3 = true;
mp3args.reserve(args.size()); mp3args.reserve(args.size());
size_t slashPos = arg.find(_S('/')); size_t slashPos = arg.find(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos) if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_S('\\')); slashPos = arg.find(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
mp3args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end())); mp3args.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
} }
@ -336,13 +336,13 @@ struct SpecMP3 : SpecBase
{ {
hecl::SystemString lowerArg = arg; hecl::SystemString lowerArg = arg;
hecl::ToLower(lowerArg); hecl::ToLower(lowerArg);
if (!lowerArg.compare(0, 2, _S("fe"))) if (!lowerArg.compare(0, 2, _SYS_STR("fe")))
{ {
doMPTFE = true; doMPTFE = true;
feargs.reserve(args.size()); feargs.reserve(args.size());
size_t slashPos = arg.find(_S('/')); size_t slashPos = arg.find(_SYS_STR('/'));
if (slashPos == hecl::SystemString::npos) if (slashPos == hecl::SystemString::npos)
slashPos = arg.find(_S('\\')); slashPos = arg.find(_SYS_STR('\\'));
if (slashPos != hecl::SystemString::npos) if (slashPos != hecl::SystemString::npos)
feargs.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end())); feargs.emplace_back(hecl::SystemString(arg.begin() + slashPos + 1, arg.end()));
} }
@ -389,12 +389,12 @@ struct SpecMP3 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("MP3"); rep.name = _SYS_STR("MP3");
rep.desc = _S("Metroid Prime 3 ") + regstr; rep.desc = _SYS_STR("Metroid Prime 3 ") + regstr;
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
@ -424,13 +424,13 @@ struct SpecMP3 : SpecBase
/* Root Report */ /* Root Report */
reps.emplace_back(); reps.emplace_back();
ExtractReport& rep = reps.back(); ExtractReport& rep = reps.back();
rep.name = _S("fe"); rep.name = _SYS_STR("fe");
rep.desc = _S("Metroid Prime Trilogy Frontend ") + regstr; rep.desc = _SYS_STR("Metroid Prime Trilogy Frontend ") + regstr;
if (buildInfo) if (buildInfo)
{ {
std::string buildStr(buildInfo); std::string buildStr(buildInfo);
hecl::SystemStringConv buildView(buildStr); hecl::SystemStringConv buildView(buildStr);
rep.desc += _S(" (") + buildView + _S(")"); rep.desc += _SYS_STR(" (") + buildView + _SYS_STR(")");
} }
/* Iterate PAKs and build level options */ /* Iterate PAKs and build level options */
@ -449,7 +449,7 @@ struct SpecMP3 : SpecBase
bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress) bool extractFromDisc(nod::DiscBase& disc, bool force, const hecl::MultiProgressPrinter& progress)
{ {
hecl::SystemString currentTarget = _S(""); hecl::SystemString currentTarget = _SYS_STR("");
size_t nodeCount = 0; size_t nodeCount = 0;
int prog = 0; int prog = 0;
nod::ExtractionContext ctx = {force, nod::ExtractionContext ctx = {force,
@ -463,22 +463,22 @@ struct SpecMP3 : SpecBase
m_workPath.makeDir(); m_workPath.makeDir();
progress.startNewLine(); progress.startNewLine();
progress.print(_S("Indexing PAKs"), _S(""), 0.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
m_pakRouter.build(m_paks, [&progress](float factor) m_pakRouter.build(m_paks, [&progress](float factor)
{ {
progress.print(_S("Indexing PAKs"), _S(""), factor); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor);
}); });
progress.print(_S("Indexing PAKs"), _S(""), 1.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
progress.startNewLine(); progress.startNewLine();
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _S("out")); hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outPath.makeDir(); outPath.makeDir();
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx); disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
hecl::ProjectPath mp3OutPath(outPath, m_standalone ? _S("files") : _S("files/MP3")); hecl::ProjectPath mp3OutPath(outPath, m_standalone ? _SYS_STR("files") : _SYS_STR("files/MP3"));
mp3OutPath.makeDirChain(true); mp3OutPath.makeDirChain(true);
currentTarget = _S("MP3 Root"); currentTarget = _SYS_STR("MP3 Root");
progress.print(currentTarget.c_str(), _S(""), 0.0); progress.print(currentTarget.c_str(), _SYS_STR(""), 0.0);
prog = 0; prog = 0;
nodeCount = m_nonPaks.size(); nodeCount = m_nonPaks.size();
@ -490,7 +490,7 @@ struct SpecMP3 : SpecBase
} }
ctx.progressCB = nullptr; ctx.progressCB = nullptr;
progress.print(currentTarget.c_str(), _S(""), 1.0); progress.print(currentTarget.c_str(), _SYS_STR(""), 1.0);
progress.startNewLine(); progress.startNewLine();
hecl::ClientProcess process; hecl::ClientProcess process;
@ -525,22 +525,22 @@ struct SpecMP3 : SpecBase
m_feWorkPath.makeDir(); m_feWorkPath.makeDir();
progress.startNewLine(); progress.startNewLine();
progress.print(_S("Indexing PAKs"), _S(""), 0.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 0.0);
m_fePakRouter.build(m_fePaks, [&progress](float factor) m_fePakRouter.build(m_fePaks, [&progress](float factor)
{ {
progress.print(_S("Indexing PAKs"), _S(""), factor); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), factor);
}); });
progress.print(_S("Indexing PAKs"), _S(""), 1.0); progress.print(_SYS_STR("Indexing PAKs"), _SYS_STR(""), 1.0);
progress.startNewLine(); progress.startNewLine();
hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _S("out")); hecl::ProjectPath outPath(m_project.getProjectWorkingPath(), _SYS_STR("out"));
outPath.makeDir(); outPath.makeDir();
disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx); disc.getDataPartition()->extractSysFiles(outPath.getAbsolutePath(), ctx);
hecl::ProjectPath feOutPath(outPath, m_standalone ? _S("files") : _S("files/fe")); hecl::ProjectPath feOutPath(outPath, m_standalone ? _SYS_STR("files") : _SYS_STR("files/fe"));
feOutPath.makeDirChain(true); feOutPath.makeDirChain(true);
currentTarget = _S("fe Root"); currentTarget = _SYS_STR("fe Root");
progress.print(currentTarget.c_str(), _S(""), 0.0); progress.print(currentTarget.c_str(), _SYS_STR(""), 0.0);
prog = 0; prog = 0;
nodeCount = m_feNonPaks.size(); nodeCount = m_feNonPaks.size();
@ -550,7 +550,7 @@ struct SpecMP3 : SpecBase
node->extractToDirectory(feOutPath.getAbsolutePath(), ctx); node->extractToDirectory(feOutPath.getAbsolutePath(), ctx);
prog++; prog++;
} }
progress.print(currentTarget.c_str(), _S(""), 1.0); progress.print(currentTarget.c_str(), _SYS_STR(""), 1.0);
progress.startNewLine(); progress.startNewLine();
hecl::ClientProcess process; hecl::ClientProcess process;
@ -596,7 +596,7 @@ struct SpecMP3 : SpecBase
bool checkPathPrefix(const hecl::ProjectPath& path) const bool checkPathPrefix(const hecl::ProjectPath& path) const
{ {
return path.getRelativePath().compare(0, 4, _S("MP3/")) == 0; return path.getRelativePath().compare(0, 4, _SYS_STR("MP3/")) == 0;
} }
bool validateYAMLDNAType(athena::io::IStreamReader& fp) const bool validateYAMLDNAType(athena::io::IStreamReader& fp) const
@ -687,7 +687,7 @@ struct SpecMP3 : SpecBase
hecl::blender::MapArea mapa = ds.compileMapArea(); hecl::blender::MapArea mapa = ds.compileMapArea();
ds.close(); ds.close();
DNAMP3::MAPA::Cook(mapa, out); DNAMP3::MAPA::Cook(mapa, out);
progress(_S("Done")); progress(_SYS_STR("Done"));
} }
void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in, void cookMapUniverse(const hecl::ProjectPath& out, const hecl::ProjectPath& in,
@ -714,16 +714,16 @@ struct SpecMP3 : SpecBase
hecl::Database::DataSpecEntry SpecEntMP3 hecl::Database::DataSpecEntry SpecEntMP3
( (
_S("MP3"sv), _SYS_STR("MP3"sv),
_S("Data specification for original Metroid Prime 3 engine"sv), _S(".pak"sv), 2, _SYS_STR("Data specification for original Metroid Prime 3 engine"sv), _SYS_STR(".pak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool) [](hecl::Database::Project& project, hecl::Database::DataSpecTool)
-> std::unique_ptr<hecl::Database::IDataSpec> {return std::make_unique<SpecMP3>(&SpecEntMP3, project, false);} -> std::unique_ptr<hecl::Database::IDataSpec> {return std::make_unique<SpecMP3>(&SpecEntMP3, project, false);}
); );
hecl::Database::DataSpecEntry SpecEntMP3PC = hecl::Database::DataSpecEntry SpecEntMP3PC =
{ {
_S("MP3-PC"sv), _SYS_STR("MP3-PC"sv),
_S("Data specification for PC-optimized Metroid Prime 3 engine"sv), _S(".upak"sv), 2, _SYS_STR("Data specification for PC-optimized Metroid Prime 3 engine"sv), _SYS_STR(".upak"sv), 2,
[](hecl::Database::Project& project, hecl::Database::DataSpecTool tool) [](hecl::Database::Project& project, hecl::Database::DataSpecTool tool)
-> std::unique_ptr<hecl::Database::IDataSpec> -> std::unique_ptr<hecl::Database::IDataSpec>
{ {
@ -735,8 +735,8 @@ hecl::Database::DataSpecEntry SpecEntMP3PC =
hecl::Database::DataSpecEntry SpecEntMP3ORIG = hecl::Database::DataSpecEntry SpecEntMP3ORIG =
{ {
_S("MP3-ORIG"sv), _SYS_STR("MP3-ORIG"sv),
_S("Data specification for unmodified Metroid Prime 3 resources"sv), _SYS_STR("Data specification for unmodified Metroid Prime 3 resources"sv),
{}, 2, {} {}, 2, {}
}; };

16
Editor/ProjectManager.cpp
View File

@ -56,7 +56,7 @@ bool ProjectManager::newProject(hecl::SystemStringView path)
hecl::ProjectRootPath projPath = hecl::SearchForProject(path); hecl::ProjectRootPath projPath = hecl::SearchForProject(path);
if (projPath) if (projPath)
{ {
Log.report(logvisor::Warning, _S("project already exists at '%s'"), path.data()); Log.report(logvisor::Warning, _SYS_STR("project already exists at '%s'"), path.data());
return false; return false;
} }
@ -73,7 +73,7 @@ bool ProjectManager::newProject(hecl::SystemStringView path)
saveProject(); saveProject();
hecl::SystemString windowTitle(m_proj->getProjectRootPath().getLastComponent()); hecl::SystemString windowTitle(m_proj->getProjectRootPath().getLastComponent());
windowTitle += _S(" - URDE [") + hecl::SystemString(m_vm.platformName()) + _S("]"); windowTitle += _SYS_STR(" - URDE [") + hecl::SystemString(m_vm.platformName()) + _SYS_STR("]");
m_vm.m_mainWindow->setTitle(windowTitle.c_str()); m_vm.m_mainWindow->setTitle(windowTitle.c_str());
m_vm.DismissSplash(); m_vm.DismissSplash();
m_vm.FadeInEditors(); m_vm.FadeInEditors();
@ -87,7 +87,7 @@ bool ProjectManager::openProject(hecl::SystemStringView path)
hecl::ProjectRootPath projPath = hecl::SearchForProject(path, subPath); hecl::ProjectRootPath projPath = hecl::SearchForProject(path, subPath);
if (!projPath) if (!projPath)
{ {
Log.report(logvisor::Warning, _S("project doesn't exist at '%s'"), path.data()); Log.report(logvisor::Warning, _SYS_STR("project doesn't exist at '%s'"), path.data());
return false; return false;
} }
@ -98,7 +98,7 @@ bool ProjectManager::openProject(hecl::SystemStringView path)
return false; return false;
} }
hecl::ProjectPath urdeSpacesPath(*m_proj, _S(".hecl/urde_spaces.yaml")); hecl::ProjectPath urdeSpacesPath(*m_proj, _SYS_STR(".hecl/urde_spaces.yaml"));
athena::io::FileReader reader(urdeSpacesPath.getAbsolutePath()); athena::io::FileReader reader(urdeSpacesPath.getAbsolutePath());
bool needsSave = false; bool needsSave = false;
@ -132,7 +132,7 @@ makeProj:
else else
m_vm.SetupEditorView(); m_vm.SetupEditorView();
bool doRun = hecl::StringUtils::BeginsWith(subPath, _S("out")); bool doRun = hecl::StringUtils::BeginsWith(subPath, _SYS_STR("out"));
if (doRun) if (doRun)
{ {
m_mainMP1.emplace(nullptr, nullptr, m_vm.m_mainBooFactory, m_mainMP1.emplace(nullptr, nullptr, m_vm.m_mainBooFactory,
@ -145,7 +145,7 @@ makeProj:
{ {
hecl::SystemString windowTitle(m_proj->getProjectRootPath().getLastComponent()); hecl::SystemString windowTitle(m_proj->getProjectRootPath().getLastComponent());
windowTitle += _S(" - URDE [") + hecl::SystemString(m_vm.platformName()) + _S("]"); windowTitle += _SYS_STR(" - URDE [") + hecl::SystemString(m_vm.platformName()) + _SYS_STR("]");
m_vm.m_mainWindow->setTitle(windowTitle.c_str()); m_vm.m_mainWindow->setTitle(windowTitle.c_str());
} }
m_vm.DismissSplash(); m_vm.DismissSplash();
@ -164,7 +164,7 @@ bool ProjectManager::saveProject()
if (!m_proj) if (!m_proj)
return false; return false;
hecl::ProjectPath oldSpacesPath(*m_proj, _S(".hecl/~urde_spaces.yaml")); hecl::ProjectPath oldSpacesPath(*m_proj, _SYS_STR(".hecl/~urde_spaces.yaml"));
athena::io::FileWriter writer(oldSpacesPath.getAbsolutePath()); athena::io::FileWriter writer(oldSpacesPath.getAbsolutePath());
if (!writer.isOpen()) if (!writer.isOpen())
return false; return false;
@ -174,7 +174,7 @@ bool ProjectManager::saveProject()
if (!w.finish(&writer)) if (!w.finish(&writer))
return false; return false;
hecl::ProjectPath newSpacesPath(*m_proj, _S(".hecl/urde_spaces.yaml")); hecl::ProjectPath newSpacesPath(*m_proj, _SYS_STR(".hecl/urde_spaces.yaml"));
hecl::Unlink(newSpacesPath.getAbsolutePath().data()); hecl::Unlink(newSpacesPath.getAbsolutePath().data());
hecl::Rename(oldSpacesPath.getAbsolutePath().data(), hecl::Rename(oldSpacesPath.getAbsolutePath().data(),

18
Editor/ProjectResourceFactoryBase.cpp
View File

@ -23,7 +23,7 @@ void ProjectResourceFactoryBase::BeginBackgroundIndex
bool ProjectResourceFactoryBase::SyncCook(const hecl::ProjectPath& working) bool ProjectResourceFactoryBase::SyncCook(const hecl::ProjectPath& working)
{ {
Log.report(logvisor::Warning, _S("sync-cooking %s"), working.getRelativePath().data()); Log.report(logvisor::Warning, _SYS_STR("sync-cooking %s"), working.getRelativePath().data());
return m_clientProc.syncCook(working, m_cookSpec.get(), hecl::blender::SharedBlenderToken, return m_clientProc.syncCook(working, m_cookSpec.get(), hecl::blender::SharedBlenderToken,
false, false); false, false);
} }
@ -66,7 +66,7 @@ void ProjectResourceFactoryBase::AsyncTask::EnsurePath(const urde::SObjectTag& t
/* Ensure requested resource is on the filesystem */ /* Ensure requested resource is on the filesystem */
if (!path.isFileOrGlob()) if (!path.isFileOrGlob())
{ {
Log.report(logvisor::Error, _S("unable to find resource path '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to find resource path '%s'"),
path.getRelativePath().data()); path.getRelativePath().data());
m_failed = true; m_failed = true;
return; return;
@ -83,7 +83,7 @@ void ProjectResourceFactoryBase::AsyncTask::EnsurePath(const urde::SObjectTag& t
urde::SObjectTag verifyTag = m_parent.TagFromPath(path, hecl::blender::SharedBlenderToken); urde::SObjectTag verifyTag = m_parent.TagFromPath(path, hecl::blender::SharedBlenderToken);
if (verifyTag.type != tag.type) if (verifyTag.type != tag.type)
{ {
Log.report(logvisor::Error, _S("%s: expected type '%.4s', found '%.4s'"), Log.report(logvisor::Error, _SYS_STR("%s: expected type '%.4s', found '%.4s'"),
path.getRelativePath().data(), path.getRelativePath().data(),
tag.type.getChars(), verifyTag.type.getChars()); tag.type.getChars(), verifyTag.type.getChars());
m_failed = true; m_failed = true;
@ -114,7 +114,7 @@ void ProjectResourceFactoryBase::AsyncTask::CookComplete()
athena::io::FileReader fr(m_cookedPath.getAbsolutePath(), 32 * 1024, false); athena::io::FileReader fr(m_cookedPath.getAbsolutePath(), 32 * 1024, false);
if (fr.hasError()) if (fr.hasError())
{ {
Log.report(logvisor::Error, _S("unable to open cooked resource path '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to open cooked resource path '%s'"),
m_cookedPath.getAbsolutePath().data()); m_cookedPath.getAbsolutePath().data());
m_failed = true; m_failed = true;
return; return;
@ -218,7 +218,7 @@ ProjectResourceFactoryBase::PrepForReadSync(const SObjectTag& tag,
/* Ensure requested resource is on the filesystem */ /* Ensure requested resource is on the filesystem */
if (!path.isFileOrGlob()) if (!path.isFileOrGlob())
{ {
Log.report(logvisor::Error, _S("unable to find resource path '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to find resource path '%s'"),
path.getAbsolutePath().data()); path.getAbsolutePath().data());
return false; return false;
} }
@ -234,7 +234,7 @@ ProjectResourceFactoryBase::PrepForReadSync(const SObjectTag& tag,
urde::SObjectTag verifyTag = TagFromPath(path, hecl::blender::SharedBlenderToken); urde::SObjectTag verifyTag = TagFromPath(path, hecl::blender::SharedBlenderToken);
if (verifyTag.type != tag.type) if (verifyTag.type != tag.type)
{ {
Log.report(logvisor::Error, _S("%s: expected type '%.4s', found '%.4s'"), Log.report(logvisor::Error, _SYS_STR("%s: expected type '%.4s', found '%.4s'"),
path.getRelativePath().data(), path.getRelativePath().data(),
tag.type.getChars(), verifyTag.type.getChars()); tag.type.getChars(), verifyTag.type.getChars());
return false; return false;
@ -250,7 +250,7 @@ ProjectResourceFactoryBase::PrepForReadSync(const SObjectTag& tag,
/* Do a blocking cook here */ /* Do a blocking cook here */
if (!SyncCook(path)) if (!SyncCook(path))
{ {
Log.report(logvisor::Error, _S("unable to cook resource path '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to cook resource path '%s'"),
path.getAbsolutePath().data()); path.getAbsolutePath().data());
return false; return false;
} }
@ -261,7 +261,7 @@ ProjectResourceFactoryBase::PrepForReadSync(const SObjectTag& tag,
fr.emplace(cooked.getAbsolutePath(), 32 * 1024, false); fr.emplace(cooked.getAbsolutePath(), 32 * 1024, false);
if (fr->hasError()) if (fr->hasError())
{ {
Log.report(logvisor::Error, _S("unable to open cooked resource path '%s'"), Log.report(logvisor::Error, _SYS_STR("unable to open cooked resource path '%s'"),
cooked.getAbsolutePath().data()); cooked.getAbsolutePath().data());
return false; return false;
} }
@ -491,7 +491,7 @@ bool ProjectResourceFactoryBase::AsyncPumpTask(ItType& it)
{ {
if (!static_cast<DataSpec::SpecBase&>(*m_cookSpec).backgroundIndexRunning()) if (!static_cast<DataSpec::SpecBase&>(*m_cookSpec).backgroundIndexRunning())
{ {
Log.report(logvisor::Error, _S("unable to find async load resource (%.4s, %08X)"), Log.report(logvisor::Error, _SYS_STR("unable to find async load resource (%.4s, %08X)"),
task.x0_tag.type.getChars(), task.x0_tag.id); task.x0_tag.type.getChars(), task.x0_tag.id);
it = _RemoveTask(it); it = _RemoveTask(it);
} }

4
Editor/ResourceBrowser.cpp
View File

@ -44,8 +44,8 @@ void ResourceBrowser::pathButtonActivated(size_t idx)
for (const hecl::SystemString& d : m_comps) for (const hecl::SystemString& d : m_comps)
{ {
if (needSlash) if (needSlash)
dir += _S('/'); dir += _SYS_STR('/');
if (d.compare(_S("/"))) if (d.compare(_SYS_STR("/")))
needSlash = true; needSlash = true;
dir += d; dir += d;
if (++i > idx) if (++i > idx)

6
Editor/SplashScreen.cpp
View File

@ -76,19 +76,19 @@ void SplashScreen::think()
if (m_newProjBind.m_deferPath.size()) if (m_newProjBind.m_deferPath.size())
{ {
Log.report(logvisor::Info, _S("Making project '%s'"), m_newProjBind.m_deferPath.c_str()); Log.report(logvisor::Info, _SYS_STR("Making project '%s'"), m_newProjBind.m_deferPath.c_str());
m_vm.projectManager().newProject(m_newProjBind.m_deferPath); m_vm.projectManager().newProject(m_newProjBind.m_deferPath);
m_newProjBind.m_deferPath.clear(); m_newProjBind.m_deferPath.clear();
} }
else if (m_openProjBind.m_deferPath.size()) else if (m_openProjBind.m_deferPath.size())
{ {
Log.report(logvisor::Info, _S("Opening project '%s'"), m_openProjBind.m_deferPath.c_str()); Log.report(logvisor::Info, _SYS_STR("Opening project '%s'"), m_openProjBind.m_deferPath.c_str());
m_vm.projectManager().openProject(m_openProjBind.m_deferPath); m_vm.projectManager().openProject(m_openProjBind.m_deferPath);
m_openProjBind.m_deferPath.clear(); m_openProjBind.m_deferPath.clear();
} }
else if (m_extractProjBind.m_deferPath.size()) else if (m_extractProjBind.m_deferPath.size())
{ {
Log.report(logvisor::Info, _S("Extracting game '%s'"), m_extractProjBind.m_deferPath.c_str()); Log.report(logvisor::Info, _SYS_STR("Extracting game '%s'"), m_extractProjBind.m_deferPath.c_str());
m_vm.projectManager().extractGame(m_extractProjBind.m_deferPath); m_vm.projectManager().extractGame(m_extractProjBind.m_deferPath);
m_extractProjBind.m_deferPath.clear(); m_extractProjBind.m_deferPath.clear();
} }

26
Editor/ViewManager.cpp
View File

@ -170,7 +170,7 @@ void ViewManager::RootSpaceViewBuilt(specter::View* view)
void ViewManager::ProjectChanged(hecl::Database::Project& proj) void ViewManager::ProjectChanged(hecl::Database::Project& proj)
{ {
CDvdFile::Shutdown(); CDvdFile::Shutdown();
CDvdFile::Initialize(hecl::ProjectPath(proj.getProjectWorkingPath(), _S("out/files"))); CDvdFile::Initialize(hecl::ProjectPath(proj.getProjectWorkingPath(), _SYS_STR("out/files")));
} }
void ViewManager::SetupEditorView() void ViewManager::SetupEditorView()
@ -212,14 +212,14 @@ ViewManager::ViewManager(hecl::Runtime::FileStoreManager& fileMgr, hecl::CVarMan
, m_projManager(*this) , m_projManager(*this)
, m_fontCache(fileMgr) , m_fontCache(fileMgr)
, m_translator(urde::SystemLocaleOrEnglish()) , m_translator(urde::SystemLocaleOrEnglish())
, m_recentProjectsPath(hecl::SysFormat(_S("%s/recent_projects.txt"), fileMgr.getStoreRoot().data())) , m_recentProjectsPath(hecl::SysFormat(_SYS_STR("%s/recent_projects.txt"), fileMgr.getStoreRoot().data()))
, m_recentFilesPath(hecl::SysFormat(_S("%s/recent_files.txt"), fileMgr.getStoreRoot().data())) , m_recentFilesPath(hecl::SysFormat(_SYS_STR("%s/recent_files.txt"), fileMgr.getStoreRoot().data()))
{ {
Space::SpaceMenuNode::InitializeStrings(*this); Space::SpaceMenuNode::InitializeStrings(*this);
char path[2048]; char path[2048];
hecl::Sstat theStat; hecl::Sstat theStat;
FILE* fp = hecl::Fopen(m_recentProjectsPath.c_str(), _S("r"), hecl::FileLockType::Read); FILE* fp = hecl::Fopen(m_recentProjectsPath.c_str(), _SYS_STR("r"), hecl::FileLockType::Read);
if (fp) if (fp)
{ {
while (fgets(path, 2048, fp)) while (fgets(path, 2048, fp))
@ -233,7 +233,7 @@ ViewManager::ViewManager(hecl::Runtime::FileStoreManager& fileMgr, hecl::CVarMan
fclose(fp); fclose(fp);
} }
fp = hecl::Fopen(m_recentFilesPath.c_str(), _S("r"), hecl::FileLockType::Read); fp = hecl::Fopen(m_recentFilesPath.c_str(), _SYS_STR("r"), hecl::FileLockType::Read);
if (fp) if (fp)
{ {
while (fgets(path, 2048, fp)) while (fgets(path, 2048, fp))
@ -258,7 +258,7 @@ void ViewManager::pushRecentProject(hecl::SystemStringView path)
return; return;
} }
m_recentProjects.emplace_back(path); m_recentProjects.emplace_back(path);
FILE* fp = hecl::Fopen(m_recentProjectsPath.c_str(), _S("w"), hecl::FileLockType::Write); FILE* fp = hecl::Fopen(m_recentProjectsPath.c_str(), _SYS_STR("w"), hecl::FileLockType::Write);
if (fp) if (fp)
{ {
for (hecl::SystemString& pPath : m_recentProjects) for (hecl::SystemString& pPath : m_recentProjects)
@ -275,7 +275,7 @@ void ViewManager::pushRecentFile(hecl::SystemStringView path)
return; return;
} }
m_recentFiles.emplace_back(path); m_recentFiles.emplace_back(path);
FILE* fp = hecl::Fopen(m_recentFilesPath.c_str(), _S("w"), hecl::FileLockType::Write); FILE* fp = hecl::Fopen(m_recentFilesPath.c_str(), _SYS_STR("w"), hecl::FileLockType::Write);
if (fp) if (fp)
{ {
for (hecl::SystemString& pPath : m_recentFiles) for (hecl::SystemString& pPath : m_recentFiles)
@ -286,7 +286,7 @@ void ViewManager::pushRecentFile(hecl::SystemStringView path)
void ViewManager::init(boo::IApplication* app) void ViewManager::init(boo::IApplication* app)
{ {
m_mainWindow = app->newWindow(_S("URDE")); m_mainWindow = app->newWindow(_SYS_STR("URDE"));
m_mainWindow->showWindow(); m_mainWindow->showWindow();
m_mainWindow->setWaitCursor(true); m_mainWindow->setWaitCursor(true);
@ -296,7 +296,7 @@ void ViewManager::init(boo::IApplication* app)
m_pipelineConv = hecl::NewPipelineConverter(m_mainBooFactory); m_pipelineConv = hecl::NewPipelineConverter(m_mainBooFactory);
hecl::conv = m_pipelineConv.get(); hecl::conv = m_pipelineConv.get();
m_mainPlatformName = m_mainBooFactory->platformName(); m_mainPlatformName = m_mainBooFactory->platformName();
m_mainWindow->setTitle(_S("URDE [") + hecl::SystemString(m_mainPlatformName) + _S("]")); m_mainWindow->setTitle(_SYS_STR("URDE [") + hecl::SystemString(m_mainPlatformName) + _SYS_STR("]"));
m_mainCommandQueue = m_mainWindow->getCommandQueue(); m_mainCommandQueue = m_mainWindow->getCommandQueue();
m_viewResources.init(m_mainBooFactory, &m_fontCache, &m_themeData, pixelFactor); m_viewResources.init(m_mainBooFactory, &m_fontCache, &m_themeData, pixelFactor);
InitializeIcons(m_viewResources); InitializeIcons(m_viewResources);
@ -316,9 +316,9 @@ void ViewManager::init(boo::IApplication* app)
{ {
if (m_deferedProject.empty() && hecl::SearchForProject(arg)) if (m_deferedProject.empty() && hecl::SearchForProject(arg))
m_deferedProject = arg; m_deferedProject = arg;
if (arg == _S("--no-shader-warmup")) if (arg == _SYS_STR("--no-shader-warmup"))
m_noShaderWarmup = true; m_noShaderWarmup = true;
else if (arg == _S("--no-sound")) else if (arg == _SYS_STR("--no-sound"))
m_voiceEngine->setVolume(0.f); m_voiceEngine->setVolume(0.f);
} }
@ -329,8 +329,8 @@ void ViewManager::init(boo::IApplication* app)
{ {
hecl::SystemString rootPath(root.getAbsolutePath()); hecl::SystemString rootPath(root.getAbsolutePath());
hecl::Sstat theStat; hecl::Sstat theStat;
if (!hecl::Stat((rootPath + _S("/out/files/Metroid1.upak")).c_str(), &theStat) && S_ISREG(theStat.st_mode)) if (!hecl::Stat((rootPath + _SYS_STR("/out/files/Metroid1.upak")).c_str(), &theStat) && S_ISREG(theStat.st_mode))
m_deferedProject = rootPath + _S("/out"); m_deferedProject = rootPath + _SYS_STR("/out");
} }
} }
} }

40
Editor/main.cpp
View File

@ -28,29 +28,29 @@ static hecl::SystemString CPUFeatureString(const zeus::CPUInfo& cpuInf)
auto AddFeature = [&features](const hecl::SystemChar* str) auto AddFeature = [&features](const hecl::SystemChar* str)
{ {
if (!features.empty()) if (!features.empty())
features += _S(", "); features += _SYS_STR(", ");
features += str; features += str;
}; };
if (cpuInf.AESNI) if (cpuInf.AESNI)
AddFeature(_S("AES-NI")); AddFeature(_SYS_STR("AES-NI"));
if (cpuInf.SSE1) if (cpuInf.SSE1)
AddFeature(_S("SSE")); AddFeature(_SYS_STR("SSE"));
if (cpuInf.SSE2) if (cpuInf.SSE2)
AddFeature(_S("SSE2")); AddFeature(_SYS_STR("SSE2"));
if (cpuInf.SSE3) if (cpuInf.SSE3)
AddFeature(_S("SSE3")); AddFeature(_SYS_STR("SSE3"));
if (cpuInf.SSSE3) if (cpuInf.SSSE3)
AddFeature(_S("SSSE3")); AddFeature(_SYS_STR("SSSE3"));
if (cpuInf.SSE4a) if (cpuInf.SSE4a)
AddFeature(_S("SSE4a")); AddFeature(_SYS_STR("SSE4a"));
if (cpuInf.SSE41) if (cpuInf.SSE41)
AddFeature(_S("SSE4.1")); AddFeature(_SYS_STR("SSE4.1"));
if (cpuInf.SSE42) if (cpuInf.SSE42)
AddFeature(_S("SSE4.2")); AddFeature(_SYS_STR("SSE4.2"));
if (cpuInf.AVX) if (cpuInf.AVX)
AddFeature(_S("AVX")); AddFeature(_SYS_STR("AVX"));
if (cpuInf.AVX2) if (cpuInf.AVX2)
AddFeature(_S("AVX2")); AddFeature(_SYS_STR("AVX2"));
return features; return features;
} }
@ -64,7 +64,7 @@ struct Application : boo::IApplicationCallback
std::atomic_bool m_running = {true}; std::atomic_bool m_running = {true};
Application() : Application() :
m_fileMgr(_S("urde")), m_fileMgr(_SYS_STR("urde")),
m_cvarManager(m_fileMgr), m_cvarManager(m_fileMgr),
m_cvarCommons(m_cvarManager) m_cvarCommons(m_cvarManager)
{ {
@ -111,7 +111,7 @@ struct Application : boo::IApplicationCallback
createGlobalCVars(); createGlobalCVars();
for (const boo::SystemString& arg : app->getArgs()) for (const boo::SystemString& arg : app->getArgs())
{ {
if (arg.find(_S("--verbosity=")) == 0 || arg.find(_S("-v=")) == 0) if (arg.find(_SYS_STR("--verbosity=")) == 0 || arg.find(_SYS_STR("-v=")) == 0)
{ {
hecl::SystemUTF8Conv utf8Arg(arg.substr(arg.find_last_of('=') + 1)); hecl::SystemUTF8Conv utf8Arg(arg.substr(arg.find_last_of('=') + 1));
hecl::VerbosityLevel = atoi(utf8Arg.c_str()); hecl::VerbosityLevel = atoi(utf8Arg.c_str());
@ -124,7 +124,7 @@ struct Application : boo::IApplicationCallback
const zeus::CPUInfo& cpuInf = zeus::cpuFeatures(); const zeus::CPUInfo& cpuInf = zeus::cpuFeatures();
Log.report(logvisor::Info, "CPU Name: %s", cpuInf.cpuBrand); Log.report(logvisor::Info, "CPU Name: %s", cpuInf.cpuBrand);
Log.report(logvisor::Info, "CPU Vendor: %s", cpuInf.cpuVendor); Log.report(logvisor::Info, "CPU Vendor: %s", cpuInf.cpuVendor);
Log.report(logvisor::Info, _S("CPU Features: %s"), CPUFeatureString(cpuInf).c_str()); Log.report(logvisor::Info, _SYS_STR("CPU Features: %s"), CPUFeatureString(cpuInf).c_str());
} }
std::string getGraphicsApi() const std::string getGraphicsApi() const
@ -192,7 +192,7 @@ static void SetupBasics(bool logging)
static bool IsClientLoggingEnabled(int argc, const boo::SystemChar** argv) static bool IsClientLoggingEnabled(int argc, const boo::SystemChar** argv)
{ {
for (int i = 1; i < argc; ++i) for (int i = 1; i < argc; ++i)
if (!hecl::StrNCmp(argv[i], _S("-l"), 2)) if (!hecl::StrNCmp(argv[i], _SYS_STR("-l"), 2))
return true; return true;
return false; return false;
} }
@ -204,7 +204,7 @@ int wmain(int argc, const boo::SystemChar** argv)
int main(int argc, const boo::SystemChar** argv) int main(int argc, const boo::SystemChar** 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", URDE_DLPACKAGE); printf("%s\n", URDE_DLPACKAGE);
return 100; return 100;
@ -215,16 +215,16 @@ int main(int argc, const boo::SystemChar** argv)
if (hecl::SystemChar* cwd = hecl::Getcwd(CwdBuf, 1024)) if (hecl::SystemChar* cwd = hecl::Getcwd(CwdBuf, 1024))
{ {
if (hecl::PathRelative(argv[0])) if (hecl::PathRelative(argv[0]))
ExeDir = hecl::SystemString(cwd) + _S('/'); ExeDir = hecl::SystemString(cwd) + _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);
} }
urde::Application appCb; urde::Application appCb;
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto, int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto,
appCb, _S("urde"), _S("URDE"), argc, argv, appCb.getGraphicsApi(), appCb, _SYS_STR("urde"), _SYS_STR("URDE"), argc, argv, appCb.getGraphicsApi(),
appCb.getSamples(), appCb.getAnisotropy(), appCb.getDeepColor(), false); appCb.getSamples(), appCb.getAnisotropy(), appCb.getDeepColor(), false);
//printf("IM DYING!!\n"); //printf("IM DYING!!\n");
return ret; return ret;
@ -240,7 +240,7 @@ int WINAPIV main(Platform::Array<Platform::String^>^ params)
{ {
SetupBasics(false); SetupBasics(false);
urde::Application appCb; urde::Application appCb;
auto viewProvider = ref new boo::ViewProvider(appCb, _S("urde"), _S("URDE"), _S("urde"), params, false); auto viewProvider = ref new boo::ViewProvider(appCb, _SYS_STR("urde"), _SYS_STR("URDE"), _SYS_STR("urde"), params, false);
CoreApplication::Run(viewProvider); CoreApplication::Run(viewProvider);
return 0; return 0;
} }

2
Runtime/CGameAllocator.cpp
View File

@ -48,7 +48,7 @@ void CGameAllocator::Free(u8* ptr)
SChunkDescription* info = reinterpret_cast<SChunkDescription*>(ptr - sizeof(SChunkDescription)); SChunkDescription* info = reinterpret_cast<SChunkDescription*>(ptr - sizeof(SChunkDescription));
if (info->magic != 0xE8E8E8E8 || info->sentinal != 0xEFEFEFEF) if (info->magic != 0xE8E8E8E8 || info->sentinal != 0xEFEFEFEF)
{ {
AllocLog.report(logvisor::Fatal, _S("Invalid chunk description, memory corruption!")); AllocLog.report(logvisor::Fatal, _SYS_STR("Invalid chunk description, memory corruption!"));
return; return;
} }

24
Runtime/CMemoryCardSysWin.cpp
View File

@ -24,11 +24,11 @@ kabufuda::SystemString CMemoryCardSys::ResolveDolphinCardPath(kabufuda::ECardSlo
/* Check our registry keys */ /* Check our registry keys */
HKEY hkey; HKEY hkey;
kabufuda::SystemChar configPath[MAX_PATH] = {0}; kabufuda::SystemChar configPath[MAX_PATH] = {0};
if (RegOpenKeyEx(HKEY_CURRENT_USER, _S("Software\\Dolphin Emulator"), 0, KEY_QUERY_VALUE, if (RegOpenKeyEx(HKEY_CURRENT_USER, _SYS_STR("Software\\Dolphin Emulator"), 0, KEY_QUERY_VALUE,
&hkey) == ERROR_SUCCESS) &hkey) == ERROR_SUCCESS)
{ {
DWORD size = MAX_PATH; DWORD size = MAX_PATH;
if (RegQueryValueEx(hkey, _S("UserConfigPath"), nullptr, nullptr, (LPBYTE)configPath, if (RegQueryValueEx(hkey, _SYS_STR("UserConfigPath"), nullptr, nullptr, (LPBYTE)configPath,
&size) != ERROR_SUCCESS) &size) != ERROR_SUCCESS)
configPath[0] = 0; configPath[0] = 0;
RegCloseKey(hkey); RegCloseKey(hkey);
@ -43,7 +43,7 @@ kabufuda::SystemString CMemoryCardSys::ResolveDolphinCardPath(kabufuda::ECardSlo
if (configPath[0]) /* Case 1 */ if (configPath[0]) /* Case 1 */
path = configPath; path = configPath;
else if (my_documents_found) /* Case 2 */ else if (my_documents_found) /* Case 2 */
path = kabufuda::SystemString(my_documents) + _S("/Dolphin Emulator"); path = kabufuda::SystemString(my_documents) + _SYS_STR("/Dolphin Emulator");
else /* Unable to find */ else /* Unable to find */
return {}; return {};
#else #else
@ -51,8 +51,8 @@ kabufuda::SystemString CMemoryCardSys::ResolveDolphinCardPath(kabufuda::ECardSlo
kabufuda::SystemString path(localFolder->Path->Data()); kabufuda::SystemString path(localFolder->Path->Data());
#endif #endif
path += hecl::SysFormat(_S("/GC/MemoryCard%c.USA.raw"), path += hecl::SysFormat(_SYS_STR("/GC/MemoryCard%c.USA.raw"),
slot == kabufuda::ECardSlot::SlotA ? _S('A') : _S('B')); slot == kabufuda::ECardSlot::SlotA ? _SYS_STR('A') : _SYS_STR('B'));
hecl::Sstat theStat; hecl::Sstat theStat;
if (hecl::Stat(path.c_str(), &theStat) || !S_ISREG(theStat.st_mode)) if (hecl::Stat(path.c_str(), &theStat) || !S_ISREG(theStat.st_mode))
@ -74,11 +74,11 @@ kabufuda::SystemString CMemoryCardSys::_CreateDolphinCard(kabufuda::ECardSlot sl
/* Check our registry keys */ /* Check our registry keys */
HKEY hkey; HKEY hkey;
kabufuda::SystemChar configPath[MAX_PATH] = {0}; kabufuda::SystemChar configPath[MAX_PATH] = {0};
if (RegOpenKeyEx(HKEY_CURRENT_USER, _S("Software\\Dolphin Emulator"), 0, KEY_QUERY_VALUE, if (RegOpenKeyEx(HKEY_CURRENT_USER, _SYS_STR("Software\\Dolphin Emulator"), 0, KEY_QUERY_VALUE,
&hkey) == ERROR_SUCCESS) &hkey) == ERROR_SUCCESS)
{ {
DWORD size = MAX_PATH; DWORD size = MAX_PATH;
if (RegQueryValueEx(hkey, _S("UserConfigPath"), nullptr, nullptr, (LPBYTE)configPath, if (RegQueryValueEx(hkey, _SYS_STR("UserConfigPath"), nullptr, nullptr, (LPBYTE)configPath,
&size) != ERROR_SUCCESS) &size) != ERROR_SUCCESS)
configPath[0] = 0; configPath[0] = 0;
RegCloseKey(hkey); RegCloseKey(hkey);
@ -93,7 +93,7 @@ kabufuda::SystemString CMemoryCardSys::_CreateDolphinCard(kabufuda::ECardSlot sl
if (configPath[0]) /* Case 1 */ if (configPath[0]) /* Case 1 */
path = configPath; path = configPath;
else if (my_documents_found) /* Case 2 */ else if (my_documents_found) /* Case 2 */
path = kabufuda::SystemString(my_documents) + _S("/Dolphin Emulator"); path = kabufuda::SystemString(my_documents) + _SYS_STR("/Dolphin Emulator");
else /* Unable to find */ else /* Unable to find */
return {}; return {};
#else #else
@ -101,13 +101,13 @@ kabufuda::SystemString CMemoryCardSys::_CreateDolphinCard(kabufuda::ECardSlot sl
kabufuda::SystemString path(localFolder->Path->Data()); kabufuda::SystemString path(localFolder->Path->Data());
#endif #endif
path += _S("/GC"); path += _SYS_STR("/GC");
if (hecl::RecursiveMakeDir(path.c_str()) < 0) if (hecl::RecursiveMakeDir(path.c_str()) < 0)
return {}; return {};
path += hecl::SysFormat(_S("/MemoryCard%c.USA.raw"), path += hecl::SysFormat(_SYS_STR("/MemoryCard%c.USA.raw"),
slot == kabufuda::ECardSlot::SlotA ? _S('A') : _S('B')); slot == kabufuda::ECardSlot::SlotA ? _SYS_STR('A') : _SYS_STR('B'));
FILE* fp = hecl::Fopen(path.c_str(), _S("wb")); FILE* fp = hecl::Fopen(path.c_str(), _SYS_STR("wb"));
if (!fp) if (!fp)
return {}; return {};
fclose(fp); fclose(fp);

4
Runtime/Graphics/CLineRenderer.cpp
View File

@ -30,7 +30,7 @@ CLineRenderer::CLineRenderer(boo::IGraphicsDataFactory::Context& ctx,
{ {
if (maxVerts < 2) if (maxVerts < 2)
{ {
LineRendererLog.report(logvisor::Fatal, _S("maxVerts < 2, maxVerts = %i"), maxVerts); LineRendererLog.report(logvisor::Fatal, _SYS_STR("maxVerts < 2, maxVerts = %i"), maxVerts);
return; return;
} }
m_textured = texture; m_textured = texture;
@ -66,7 +66,7 @@ CLineRenderer::CLineRenderer(EPrimitiveMode mode, u32 maxVerts,
{ {
if (maxVerts < 2) if (maxVerts < 2)
{ {
LineRendererLog.report(logvisor::Fatal, _S("maxVerts < 2, maxVerts = %i"), maxVerts); LineRendererLog.report(logvisor::Fatal, _SYS_STR("maxVerts < 2, maxVerts = %i"), maxVerts);
return; return;
} }
m_textured = texture; m_textured = texture;

6
Runtime/Graphics/Shaders/CFluidPlaneShader.hpp
View File

@ -128,11 +128,11 @@ private:
BindingPair BuildBinding(boo::GLDataFactory::Context& ctx, const ShaderPair& pipeline); BindingPair BuildBinding(boo::GLDataFactory::Context& ctx, const ShaderPair& pipeline);
#endif #endif
#if _WIN32 #if _WIN32
static ShaderPair BuildShader(boo::D3DDataFactory::Context& ctx, static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx,
const SFluidPlaneShaderInfo& info); const SFluidPlaneShaderInfo& info);
static ShaderPair BuildShader(boo::D3DDataFactory::Context& ctx, static ShaderPair BuildShader(boo::D3D11DataFactory::Context& ctx,
const SFluidPlaneDoorShaderInfo& info); const SFluidPlaneDoorShaderInfo& info);
BindingPair BuildBinding(boo::D3DDataFactory::Context& ctx, const ShaderPair& pipeline); BindingPair BuildBinding(boo::D3D11DataFactory::Context& ctx, const ShaderPair& pipeline);
#endif #endif
#if BOO_HAS_METAL #if BOO_HAS_METAL
static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx, static ShaderPair BuildShader(boo::MetalDataFactory::Context& ctx,

2
Runtime/Graphics/Shaders/CModelShaders.cpp
View File

@ -204,7 +204,7 @@ CModelShaders::ShaderPipelines CModelShaders::BuildExtendedShader(const hecl::Ba
return search->second; return search->second;
ShaderPipelines& newPipelines = g_ShaderPipelines[tag.val64()]; ShaderPipelines& newPipelines = g_ShaderPipelines[tag.val64()];
newPipelines = std::make_shared<ShaderPipelinesData>(); newPipelines = std::make_shared<ShaderPipelinesData>();
int idx = 0; size_t idx = 0;
for (const auto& ext : g_ExtensionSlots) for (const auto& ext : g_ExtensionSlots)
(*newPipelines)[idx++] = hecl::conv->convert(hecl::HECLIR(ir, tag, ext)); (*newPipelines)[idx++] = hecl::conv->convert(hecl::HECLIR(ir, tag, ext));
return newPipelines; return newPipelines;

1
Runtime/Graphics/Shaders/CModelShaders.hpp
View File

@ -6,6 +6,7 @@
#include "zeus/CVector3f.hpp" #include "zeus/CVector3f.hpp"
#include "zeus/CColor.hpp" #include "zeus/CColor.hpp"
#include "Graphics/CGraphics.hpp" #include "Graphics/CGraphics.hpp"
#include <array>
#define URDE_MAX_LIGHTS 8 #define URDE_MAX_LIGHTS 8

2
Runtime/MP1/MP1.cpp
View File

@ -896,7 +896,7 @@ boo::IWindow* CMain::GetMainWindow() const
int CMain::appMain(boo::IApplication* app) int CMain::appMain(boo::IApplication* app)
{ {
zeus::detectCPU(); zeus::detectCPU();
mainWindow = app->newWindow(_S("Metroid Prime 1 Reimplementation vZygote"), 1); mainWindow = app->newWindow(_SYS_STR("Metroid Prime 1 Reimplementation vZygote"), 1);
mainWindow->showWindow(); mainWindow->showWindow();
TOneStatic<CGameGlobalObjects> globalObjs; TOneStatic<CGameGlobalObjects> globalObjs;
InitializeSubsystems(); InitializeSubsystems();

20
Shaders/shader_CFluidPlaneShader.hpp
View File

@ -63,7 +63,7 @@ public:
PipelineInfo({in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::SrcAlpha, PipelineInfo({in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::SrcAlpha,
in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::InvSrcAlpha, in.m_additive ? boo::BlendFactor::One : boo::BlendFactor::InvSrcAlpha,
boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false, boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false,
boo::CullMode::None, tessellation ? 1 : 0}), boo::CullMode::None, tessellation ? 1u : 0u}),
HasTessellation(tessellation) {} HasTessellation(tessellation) {}
const boo::VertexFormatInfo VtxFmt; const boo::VertexFormatInfo VtxFmt;
@ -114,18 +114,6 @@ public:
#define UNIVERSAL_PIPELINES_shader_CFluidPlaneShader \ #define UNIVERSAL_PIPELINES_shader_CFluidPlaneShader \
::Shader_CFluidPlaneShader \ ::Shader_CFluidPlaneShader \
::Shader_CFluidPlaneDoorShader ::Shader_CFluidPlaneDoorShader
#define OPENGL_STAGES_shader_CFluidPlaneShader \ #define STAGES_shader_CFluidPlaneShader(P, S) \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneShader, hecl::PlatformType::OpenGL) \ ::StageObject_CFluidPlaneShader<P, S>, \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneDoorShader, hecl::PlatformType::OpenGL) ::StageObject_CFluidPlaneDoorShader<P, S>,
#define VULKAN_STAGES_shader_CFluidPlaneShader \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneShader, hecl::PlatformType::Vulkan) \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneDoorShader, hecl::PlatformType::Vulkan)
#define D3D11_STAGES_shader_CFluidPlaneShader \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneShader, hecl::PlatformType::D3D11) \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneDoorShader, hecl::PlatformType::D3D11)
#define METAL_STAGES_shader_CFluidPlaneShader \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneShader, hecl::PlatformType::Metal) \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneDoorShader, hecl::PlatformType::Metal)
#define NX_STAGES_shader_CFluidPlaneShader \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneShader, hecl::PlatformType::NX) \
STAGE_SPECIALIZATIONS(::StageObject_CFluidPlaneDoorShader, hecl::PlatformType::NX)

111
Shaders/shader_CFluidPlaneShaderHLSL.cpp
View File

@ -668,57 +668,21 @@ static std::string _BuildVS(const SFluidPlaneShaderInfo& info, bool tessellation
return ret; return ret;
} }
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::OpenGL, hecl::PipelineStage::Vertex>::BuildShader std::string StageObject_CFluidPlaneShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Vertex>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return _BuildVS(in, tessellation);
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Vulkan, hecl::PipelineStage::Vertex>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return _BuildVS(in, tessellation);
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::NX, hecl::PipelineStage::Vertex>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneShaderInfo& in, bool tessellation)
{ {
return _BuildVS(in, tessellation); return _BuildVS(in, tessellation);
} }
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::OpenGL, hecl::PipelineStage::Fragment>::BuildShader std::string StageObject_CFluidPlaneShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Fragment>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return _BuildFS(in);
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Vulkan, hecl::PipelineStage::Fragment>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return _BuildFS(in);
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::NX, hecl::PipelineStage::Fragment>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneShaderInfo& in, bool tessellation)
{ {
return _BuildFS(in); return _BuildFS(in);
} }
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::OpenGL, hecl::PipelineStage::Control>::BuildShader std::string StageObject_CFluidPlaneShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Control>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return TessCS;
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Vulkan, hecl::PipelineStage::Control>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation)
{
return TessCS;
}
template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::NX, hecl::PipelineStage::Control>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneShaderInfo& in, bool tessellation)
{ {
return TessCS; return TessCS;
@ -752,20 +716,75 @@ static std::string BuildES(const SFluidPlaneShaderInfo& info)
return ret; return ret;
} }
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::OpenGL, hecl::PipelineStage::Evaluation>::BuildShader std::string StageObject_CFluidPlaneShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Evaluation>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneShaderInfo& in, bool tessellation)
{ {
return BuildES(in); return BuildES(in);
} }
static std::string _BuildVS(const SFluidPlaneDoorShaderInfo& info)
{
char *finalVSs;
asprintf(&finalVSs, VS, "");
std::string ret(finalVSs);
free(finalVSs);
return ret;
}
static std::string _BuildFS(const SFluidPlaneDoorShaderInfo& info)
{
int nextTex = 0;
std::string textures;
std::string combiner;
if (info.m_hasPatternTex1)
{
textures += hecl::Format("Texture2D patternTex1 : register(t%d);\n", nextTex++);
}
if (info.m_hasPatternTex2)
{
textures += hecl::Format("Texture2D patternTex2 : register(t%d);\n", nextTex++);
}
if (info.m_hasColorTex)
{
textures += hecl::Format("Texture2D colorTex : register(t%d);\n", nextTex++);
}
// Tex0 * kColor0 * Tex1 + Tex2
if (info.m_hasPatternTex1 && info.m_hasPatternTex2)
{
combiner += " colorOut = patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 *\n"
" patternTex2.Sample(samp, vtf.uvs[1]);\n";
}
else
{
combiner += " colorOut = float4(0.0);\n";
}
if (info.m_hasColorTex)
{
combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]);\n";
}
combiner += " colorOut.a = kColor0.a;\n";
char *finalFSs;
asprintf(&finalFSs, FSDoor, textures.c_str(), combiner.c_str());
std::string ret(finalFSs);
free(finalFSs);
return ret;
}
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::Vulkan, hecl::PipelineStage::Evaluation>::BuildShader std::string StageObject_CFluidPlaneDoorShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Vertex>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneDoorShaderInfo& in)
{ {
return BuildES(in); return _BuildVS(in);
} }
template <> template <>
std::string StageObject_CFluidPlaneShader<hecl::PlatformType::NX, hecl::PipelineStage::Evaluation>::BuildShader std::string StageObject_CFluidPlaneDoorShader<hecl::PlatformType::D3D11, hecl::PipelineStage::Fragment>::BuildShader
(const SFluidPlaneShaderInfo& in, bool tessellation) (const SFluidPlaneDoorShaderInfo& in)
{ {
return BuildES(in); return _BuildFS(in);
} }

2
amuse

@ -1 +1 @@
Subproject commit dbd48a39cc4eb746bde103e2721d5054d11c4c30 Subproject commit 885a2d2154a9ddc00b878b9707d8ad01817ea4e7

26
assetnameparser/main.cpp
View File

@ -154,15 +154,15 @@ enum class FileLockType
#if IS_UCS2 #if IS_UCS2
typedef wchar_t SystemChar; typedef wchar_t SystemChar;
typedef std::wstring SystemString; typedef std::wstring SystemString;
#ifndef _S #ifndef _SYS_STR
#define _S(val) L##val #define _SYS_STR(val) L##val
#endif #endif
typedef struct _stat Sstat; typedef struct _stat Sstat;
#else #else
typedef char SystemChar; typedef char SystemChar;
typedef std::string SystemString; typedef std::string SystemString;
#ifndef _S #ifndef _SYS_STR
#define _S(val) val #define _SYS_STR(val) val
#endif #endif
typedef struct stat Sstat; typedef struct stat Sstat;
#endif #endif
@ -205,7 +205,7 @@ int main(int argc, const char* argv[])
logvisor::RegisterConsoleLogger(); logvisor::RegisterConsoleLogger();
if (argc < 3) if (argc < 3)
{ {
Log.report(logvisor::Error, _S("Usage: %s <input> <output>"), argv[0]); Log.report(logvisor::Error, _SYS_STR("Usage: %s <input> <output>"), argv[0]);
return 1; return 1;
} }
@ -214,20 +214,20 @@ int main(int argc, const char* argv[])
tinyxml2::XMLDocument doc; tinyxml2::XMLDocument doc;
std::vector<SAsset> assets; std::vector<SAsset> assets;
FILE* docF = Fopen(inPath.c_str(), _S("rb")); FILE* docF = Fopen(inPath.c_str(), _SYS_STR("rb"));
if (!doc.LoadFile(docF)) if (!doc.LoadFile(docF))
{ {
const tinyxml2::XMLElement* elm = doc.RootElement(); const tinyxml2::XMLElement* elm = doc.RootElement();
if (strcmp(elm->Name(), "AssetNameMap")) if (strcmp(elm->Name(), "AssetNameMap"))
{ {
Log.report(logvisor::Fatal, _S("Invalid database supplied")); Log.report(logvisor::Fatal, _SYS_STR("Invalid database supplied"));
return 1; return 1;
} }
elm = elm->FirstChildElement("AssetNameMap"); elm = elm->FirstChildElement("AssetNameMap");
if (elm == nullptr) if (elm == nullptr)
{ {
Log.report(logvisor::Fatal, _S("Malformed AssetName database")); Log.report(logvisor::Fatal, _SYS_STR("Malformed AssetName database"));
return 1; return 1;
} }
@ -240,7 +240,7 @@ int main(int argc, const char* argv[])
if (!keyElm || !valueElm) if (!keyElm || !valueElm)
{ {
Log.report(logvisor::Fatal, _S("Malformed Asset entry, [Key,Value] required")); Log.report(logvisor::Fatal, _SYS_STR("Malformed Asset entry, [Key,Value] required"));
return 0; return 0;
} }
@ -250,7 +250,7 @@ int main(int argc, const char* argv[])
if (!nameElm || !dirElm || ! typeElm) if (!nameElm || !dirElm || ! typeElm)
{ {
Log.report(logvisor::Fatal, _S("Malformed Value entry, [Name,Directory,Type] required")); Log.report(logvisor::Fatal, _SYS_STR("Malformed Value entry, [Name,Directory,Type] required"));
return 0; return 0;
} }
assets.emplace_back(); assets.emplace_back();
@ -262,10 +262,10 @@ int main(int argc, const char* argv[])
elm = elm->NextSiblingElement("Asset"); elm = elm->NextSiblingElement("Asset");
} }
FILE* f = Fopen(outPath.c_str(), _S("wb")); FILE* f = Fopen(outPath.c_str(), _SYS_STR("wb"));
if (!f) if (!f)
{ {
Log.report(logvisor::Fatal, _S("Unable to open destination")); Log.report(logvisor::Fatal, _SYS_STR("Unable to open destination"));
return 0; return 0;
} }
@ -294,6 +294,6 @@ int main(int argc, const char* argv[])
if (docF) if (docF)
fclose(docF); fclose(docF);
Log.report(logvisor::Fatal, _S("failed to load")); Log.report(logvisor::Fatal, _SYS_STR("failed to load"));
return 1; return 1;
} }

7
gmm/gmm_arch_config.h Normal file
View File

@ -0,0 +1,7 @@
# ifndef _SRC_GMM_GMM_ARCH_CONFIG_H
#define _SRC_GMM_GMM_ARCH_CONFIG_H 1
// enable the following line for OpenMP support
// #define GMM_HAVE_OPENMP
//
/* once: _SRC_GMM_GMM_ARCH_CONFIG_H */
#endif

64
gmm/gmm_blas.h
View File

@ -651,6 +651,38 @@ namespace gmm {
return res; return res;
} }
/** 1-distance between two vectors */
template <typename V1, typename V2> inline
typename number_traits<typename linalg_traits<V1>::value_type>
::magnitude_type
vect_dist1(const V1 &v1, const V2 &v2) { // not fully optimized
typedef typename linalg_traits<V1>::value_type T;
typedef typename number_traits<T>::magnitude_type R;
auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1);
auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2);
size_type k1(0), k2(0);
R res(0);
while (it1 != ite1 && it2 != ite2) {
size_type i1 = index_of_it(it1, k1,
typename linalg_traits<V1>::storage_type());
size_type i2 = index_of_it(it2, k2,
typename linalg_traits<V2>::storage_type());
if (i1 == i2) {
res += gmm::abs(*it2 - *it1); ++it1; ++k1; ++it2; ++k2;
}
else if (i1 < i2) {
res += gmm::abs(*it1); ++it1; ++k1;
}
else {
res += gmm::abs(*it2); ++it2; ++k2;
}
}
while (it1 != ite1) { res += gmm::abs(*it1); ++it1; }
while (it2 != ite2) { res += gmm::abs(*it2); ++it2; }
return res;
}
/* ******************************************************************** */ /* ******************************************************************** */
/* vector Infinity norm */ /* vector Infinity norm */
/* ******************************************************************** */ /* ******************************************************************** */
@ -666,6 +698,38 @@ namespace gmm {
return res; return res;
} }
/** Infinity distance between two vectors */
template <typename V1, typename V2> inline
typename number_traits<typename linalg_traits<V1>::value_type>
::magnitude_type
vect_distinf(const V1 &v1, const V2 &v2) { // not fully optimized
typedef typename linalg_traits<V1>::value_type T;
typedef typename number_traits<T>::magnitude_type R;
auto it1 = vect_const_begin(v1), ite1 = vect_const_end(v1);
auto it2 = vect_const_begin(v2), ite2 = vect_const_end(v2);
size_type k1(0), k2(0);
R res(0);
while (it1 != ite1 && it2 != ite2) {
size_type i1 = index_of_it(it1, k1,
typename linalg_traits<V1>::storage_type());
size_type i2 = index_of_it(it2, k2,
typename linalg_traits<V2>::storage_type());
if (i1 == i2) {
res = std::max(res, gmm::abs(*it2 - *it1)); ++it1; ++k1; ++it2; ++k2;
}
else if (i1 < i2) {
res = std::max(res, gmm::abs(*it1)); ++it1; ++k1;
}
else {
res = std::max(res, gmm::abs(*it2)); ++it2; ++k2;
}
}
while (it1 != ite1) { res = std::max(res, gmm::abs(*it1)); ++it1; }
while (it2 != ite2) { res = std::max(res, gmm::abs(*it2)); ++it2; }
return res;
}
/* ******************************************************************** */ /* ******************************************************************** */
/* matrix norm1 */ /* matrix norm1 */
/* ******************************************************************** */ /* ******************************************************************** */

72
gmm/gmm_blas_interface.h
View File

@ -151,13 +151,13 @@ namespace gmm {
/* BLAS functions used. */ /* BLAS functions used. */
/* ********************************************************************* */ /* ********************************************************************* */
extern "C" { extern "C" {
void daxpy_(const int *n, const double *alpha, const double *x, void daxpy_(const long *n, const double *alpha, const double *x,
const int *incx, double *y, const int *incy); const long *incx, double *y, const long *incy);
void dgemm_(const char *tA, const char *tB, const int *m, void dgemm_(const char *tA, const char *tB, const long *m,
const int *n, const int *k, const double *alpha, const long *n, const long *k, const double *alpha,
const double *A, const int *ldA, const double *B, const double *A, const long *ldA, const double *B,
const int *ldB, const double *beta, double *C, const long *ldB, const double *beta, double *C,
const int *ldC); const long *ldC);
void sgemm_(...); void cgemm_(...); void zgemm_(...); void sgemm_(...); void cgemm_(...); void zgemm_(...);
void sgemv_(...); void dgemv_(...); void cgemv_(...); void zgemv_(...); void sgemv_(...); void dgemv_(...); void cgemv_(...); void zgemv_(...);
void strsv_(...); void dtrsv_(...); void ctrsv_(...); void ztrsv_(...); void strsv_(...); void dtrsv_(...); void ctrsv_(...); void ztrsv_(...);
@ -180,7 +180,7 @@ namespace gmm {
inline number_traits<base_type >::magnitude_type \ inline number_traits<base_type >::magnitude_type \
vect_norm2(param1(base_type)) { \ vect_norm2(param1(base_type)) { \
GMMLAPACK_TRACE("nrm2_interface"); \ GMMLAPACK_TRACE("nrm2_interface"); \
int inc(1), n(int(vect_size(x))); trans1(base_type); \ long inc(1), n(long(vect_size(x))); trans1(base_type); \
return blas_name(&n, &x[0], &inc); \ return blas_name(&n, &x[0], &inc); \
} }
@ -200,7 +200,7 @@ namespace gmm {
blas_name, base_type) \ blas_name, base_type) \
inline base_type vect_sp(param1(base_type), param2(base_type)) { \ inline base_type vect_sp(param1(base_type), param2(base_type)) { \
GMMLAPACK_TRACE("dot_interface"); \ GMMLAPACK_TRACE("dot_interface"); \
trans1(base_type); trans2(base_type); int inc(1), n(int(vect_size(y)));\ trans1(base_type); trans2(base_type); long inc(1), n(long(vect_size(y)));\
return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \ return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \
} }
@ -267,7 +267,7 @@ namespace gmm {
blas_name, base_type) \ blas_name, base_type) \
inline base_type vect_hp(param1(base_type), param2(base_type)) { \ inline base_type vect_hp(param1(base_type), param2(base_type)) { \
GMMLAPACK_TRACE("dotc_interface"); \ GMMLAPACK_TRACE("dotc_interface"); \
trans1(base_type); trans2(base_type); int inc(1), n(int(vect_size(y)));\ trans1(base_type); trans2(base_type); long inc(1), n(long(vect_size(y)));\
return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \ return mult1 mult2 blas_name(&n, &x[0], &inc, &y[0], &inc); \
} }
@ -332,7 +332,7 @@ namespace gmm {
# define axpy_interface(param1, trans1, blas_name, base_type) \ # define axpy_interface(param1, trans1, blas_name, base_type) \
inline void add(param1(base_type), std::vector<base_type > &y) { \ inline void add(param1(base_type), std::vector<base_type > &y) { \
GMMLAPACK_TRACE("axpy_interface"); \ GMMLAPACK_TRACE("axpy_interface"); \
int inc(1), n(int(vect_size(y))); trans1(base_type); \ long inc(1), n(long(vect_size(y))); trans1(base_type); \
if (n == 0) return; \ if (n == 0) return; \
blas_name(&n, &a, &x[0], &inc, &y[0], &inc); \ blas_name(&n, &a, &x[0], &inc, &y[0], &inc); \
} }
@ -367,7 +367,7 @@ namespace gmm {
std::vector<base_type > &z, orien) { \ std::vector<base_type > &z, orien) { \
GMMLAPACK_TRACE("gemv_interface"); \ GMMLAPACK_TRACE("gemv_interface"); \
trans1(base_type); trans2(base_type); base_type beta(1); \ trans1(base_type); trans2(base_type); base_type beta(1); \
int m(int(mat_nrows(A))), lda(m), n(int(mat_ncols(A))), inc(1); \ long m(long(mat_nrows(A))), lda(m), n(long(mat_ncols(A))), inc(1); \
if (m && n) blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, \ if (m && n) blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, \
&beta, &z[0], &inc); \ &beta, &z[0], &inc); \
else gmm::clear(z); \ else gmm::clear(z); \
@ -489,7 +489,7 @@ namespace gmm {
std::vector<base_type > &z, orien) { \ std::vector<base_type > &z, orien) { \
GMMLAPACK_TRACE("gemv_interface2"); \ GMMLAPACK_TRACE("gemv_interface2"); \
trans1(base_type); trans2(base_type); base_type beta(0); \ trans1(base_type); trans2(base_type); base_type beta(0); \
int m(int(mat_nrows(A))), lda(m), n(int(mat_ncols(A))), inc(1); \ long m(long(mat_nrows(A))), lda(m), n(long(mat_ncols(A))), inc(1); \
if (m && n) \ if (m && n) \
blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, &beta, \ blas_name(&t, &m, &n, &alpha, &A(0,0), &lda, &x[0], &inc, &beta, \
&z[0], &inc); \ &z[0], &inc); \
@ -586,8 +586,8 @@ namespace gmm {
const std::vector<base_type > &V, \ const std::vector<base_type > &V, \
const std::vector<base_type > &W) { \ const std::vector<base_type > &W) { \
GMMLAPACK_TRACE("ger_interface"); \ GMMLAPACK_TRACE("ger_interface"); \
int m(int(mat_nrows(A))), lda = m, n(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, n(long(mat_ncols(A))); \
int incx = 1, incy = 1; \ long incx = 1, incy = 1; \
base_type alpha(1); \ base_type alpha(1); \
if (m && n) \ if (m && n) \
blas_name(&m, &n, &alpha, &V[0], &incx, &W[0], &incy, &A(0,0), &lda);\ blas_name(&m, &n, &alpha, &V[0], &incx, &W[0], &incy, &A(0,0), &lda);\
@ -604,8 +604,8 @@ namespace gmm {
const std::vector<base_type > &W) { \ const std::vector<base_type > &W) { \
GMMLAPACK_TRACE("ger_interface"); \ GMMLAPACK_TRACE("ger_interface"); \
gemv_trans2_s(base_type); \ gemv_trans2_s(base_type); \
int m(int(mat_nrows(A))), lda = m, n(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, n(long(mat_ncols(A))); \
int incx = 1, incy = 1; \ long incx = 1, incy = 1; \
if (m && n) \ if (m && n) \
blas_name(&m, &n, &alpha, &x[0], &incx, &W[0], &incy, &A(0,0), &lda);\ blas_name(&m, &n, &alpha, &x[0], &incx, &W[0], &incy, &A(0,0), &lda);\
} }
@ -621,8 +621,8 @@ namespace gmm {
gemv_p2_s(base_type)) { \ gemv_p2_s(base_type)) { \
GMMLAPACK_TRACE("ger_interface"); \ GMMLAPACK_TRACE("ger_interface"); \
gemv_trans2_s(base_type); \ gemv_trans2_s(base_type); \
int m(int(mat_nrows(A))), lda = m, n(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, n(long(mat_ncols(A))); \
int incx = 1, incy = 1; \ long incx = 1, incy = 1; \
base_type al2 = gmm::conj(alpha); \ base_type al2 = gmm::conj(alpha); \
if (m && n) \ if (m && n) \
blas_name(&m, &n, &al2, &V[0], &incx, &x[0], &incy, &A(0,0), &lda); \ blas_name(&m, &n, &al2, &V[0], &incx, &x[0], &incy, &A(0,0), &lda); \
@ -643,9 +643,9 @@ namespace gmm {
dense_matrix<base_type > &C, c_mult) { \ dense_matrix<base_type > &C, c_mult) { \
GMMLAPACK_TRACE("gemm_interface_nn"); \ GMMLAPACK_TRACE("gemm_interface_nn"); \
const char t = 'N'; \ const char t = 'N'; \
int m(int(mat_nrows(A))), lda = m, k(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, k(long(mat_ncols(A))); \
int n(int(mat_ncols(B))); \ long n(long(mat_ncols(B))); \
int ldb = k, ldc = m; \ long ldb = k, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &t, &m, &n, &k, &alpha, \ blas_name(&t, &t, &m, &n, &k, &alpha, \
@ -671,8 +671,8 @@ namespace gmm {
dense_matrix<base_type > &A \ dense_matrix<base_type > &A \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(A_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(A_))); \
const char t = 'T', u = 'N'; \ const char t = 'T', u = 'N'; \
int m(int(mat_ncols(A))), k(int(mat_nrows(A))), n(int(mat_ncols(B))); \ long m(long(mat_ncols(A))), k(long(mat_nrows(A))), n(long(mat_ncols(B))); \
int lda = k, ldb = k, ldc = m; \ long lda = k, ldb = k, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -701,9 +701,9 @@ namespace gmm {
dense_matrix<base_type > &B \ dense_matrix<base_type > &B \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \
const char t = 'N', u = 'T'; \ const char t = 'N', u = 'T'; \
int m(int(mat_nrows(A))), lda = m, k(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, k(long(mat_ncols(A))); \
int n(int(mat_nrows(B))); \ long n(long(mat_nrows(B))); \
int ldb = n, ldc = m; \ long ldb = n, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -735,8 +735,8 @@ namespace gmm {
dense_matrix<base_type > &B \ dense_matrix<base_type > &B \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \
const char t = 'T', u = 'T'; \ const char t = 'T', u = 'T'; \
int m(int(mat_ncols(A))), k(int(mat_nrows(A))), n(int(mat_nrows(B))); \ long m(long(mat_ncols(A))), k(long(mat_nrows(A))), n(long(mat_nrows(B))); \
int lda = k, ldb = n, ldc = m; \ long lda = k, ldb = n, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -775,8 +775,8 @@ namespace gmm {
dense_matrix<base_type > &A \ dense_matrix<base_type > &A \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(A_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(A_))); \
const char t = 'C', u = 'N'; \ const char t = 'C', u = 'N'; \
int m(int(mat_ncols(A))), k(int(mat_nrows(A))), n(int(mat_ncols(B))); \ long m(long(mat_ncols(A))), k(long(mat_nrows(A))), n(long(mat_ncols(B))); \
int lda = k, ldb = k, ldc = m; \ long lda = k, ldb = k, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -801,8 +801,8 @@ namespace gmm {
dense_matrix<base_type > &B \ dense_matrix<base_type > &B \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \
const char t = 'N', u = 'C'; \ const char t = 'N', u = 'C'; \
int m(int(mat_nrows(A))), lda = m, k(int(mat_ncols(A))); \ long m(long(mat_nrows(A))), lda = m, k(long(mat_ncols(A))); \
int n(int(mat_nrows(B))), ldb = n, ldc = m; \ long n(long(mat_nrows(B))), ldb = n, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -830,8 +830,8 @@ namespace gmm {
dense_matrix<base_type > &B \ dense_matrix<base_type > &B \
= const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \ = const_cast<dense_matrix<base_type > &>(*(linalg_origin(B_))); \
const char t = 'C', u = 'C'; \ const char t = 'C', u = 'C'; \
int m(int(mat_ncols(A))), k(int(mat_nrows(A))), lda = k; \ long m(long(mat_ncols(A))), k(long(mat_nrows(A))), lda = k; \
int n(int(mat_nrows(B))), ldb = n, ldc = m; \ long n(long(mat_nrows(B))), ldb = n, ldc = m; \
base_type alpha(1), beta(0); \ base_type alpha(1), beta(0); \
if (m && k && n) \ if (m && k && n) \
blas_name(&t, &u, &m, &n, &k, &alpha, \ blas_name(&t, &u, &m, &n, &k, &alpha, \
@ -853,7 +853,7 @@ namespace gmm {
size_type k, bool is_unit) { \ size_type k, bool is_unit) { \
GMMLAPACK_TRACE("trsv_interface"); \ GMMLAPACK_TRACE("trsv_interface"); \
loru; trans1(base_type); char d = is_unit ? 'U' : 'N'; \ loru; trans1(base_type); char d = is_unit ? 'U' : 'N'; \
int lda(int(mat_nrows(A))), inc(1), n = int(k); \ long lda(long(mat_nrows(A))), inc(1), n = long(k); \
if (lda) blas_name(&l, &t, &d, &n, &A(0,0), &lda, &x[0], &inc); \ if (lda) blas_name(&l, &t, &d, &n, &A(0,0), &lda, &x[0], &inc); \
} }

15
gmm/gmm_def.h
View File

@ -923,22 +923,21 @@ namespace gmm {
template <typename IT, typename ORG, typename VECT> inline template <typename IT, typename ORG, typename VECT> inline
void set_to_end(IT &, ORG, const VECT *, linalg_const) { } void set_to_end(IT &, ORG, const VECT *, linalg_const) { }
template <typename IT, typename ORG, typename VECT> inline template <typename IT, typename ORG, typename VECT> inline
void set_to_begin(IT &, ORG, VECT *v, linalg_modifiable) void set_to_begin(IT &, ORG, VECT *v, linalg_modifiable)
{ GMM_ASSERT3(!is_sparse(*v), "internal_error"); v = 0; } { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; }
template <typename IT, typename ORG, typename VECT> inline template <typename IT, typename ORG, typename VECT> inline
void set_to_begin(IT &, ORG, const VECT *v, linalg_modifiable) void set_to_begin(IT &, ORG, const VECT *v, linalg_modifiable)
{ GMM_ASSERT3(!is_sparse(*v), "internal_error"); v = 0; } { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; }
template <typename IT, typename ORG, typename VECT> inline template <typename IT, typename ORG, typename VECT> inline
void set_to_end(IT &, ORG, VECT *v, linalg_modifiable) void set_to_end(IT &, ORG, VECT *v, linalg_modifiable)
{ GMM_ASSERT3(!is_sparse(*v), "internal_error"); v = 0; } { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; }
template <typename IT, typename ORG, typename VECT> inline template <typename IT, typename ORG, typename VECT> inline
void set_to_end(IT &, ORG, const VECT *v, linalg_modifiable) void set_to_end(IT &, ORG, const VECT *v, linalg_modifiable)
{ GMM_ASSERT3(!is_sparse(*v), "internal_error"); v = 0; } { GMM_ASSERT3(!is_sparse(*v), "internal_error"); (void)v; }
/* ******************************************************************** */ /* ******************************************************************** */
/* General index for certain algorithms. */ /* General index for certain algorithms. */
@ -966,7 +965,7 @@ namespace gmm {
tol = numeric_limits<T>::epsilon(); tol = numeric_limits<T>::epsilon();
else { else {
int i=int(sizeof(T)/4); while(i-- > 0) tol*=T(1E-8); int i=int(sizeof(T)/4); while(i-- > 0) tol*=T(1E-8);
GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/ GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/
<< " has no numeric_limits defined !!\n" << " has no numeric_limits defined !!\n"
<< "Taking " << tol << " as default tolerance"); << "Taking " << tol << " as default tolerance");
} }
@ -984,7 +983,7 @@ namespace gmm {
mi = std::numeric_limits<T>::min(); mi = std::numeric_limits<T>::min();
else { else {
mi = T(0); mi = T(0);
GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/ GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/
<< " has no numeric_limits defined !!\n" << " has no numeric_limits defined !!\n"
<< "Taking 0 as default minimum"); << "Taking 0 as default minimum");
} }
@ -1002,7 +1001,7 @@ namespace gmm {
mi = std::numeric_limits<T>::max(); mi = std::numeric_limits<T>::max();
else { else {
mi = T(1); mi = T(1);
GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/ GMM_WARNING1("The numeric type " /*<< typeid(T).name()*/
<< " has no numeric_limits defined !!\n" << " has no numeric_limits defined !!\n"
<< "Taking 1 as default maximum !"); << "Taking 1 as default maximum !");
} }

66
gmm/gmm_dense_lu.h
View File

@ -70,10 +70,50 @@
#define GMM_DENSE_LU_H #define GMM_DENSE_LU_H
#include "gmm_dense_Householder.h" #include "gmm_dense_Householder.h"
#include "gmm_opt.h"
namespace gmm { namespace gmm {
/* ********************************************************************** */
/* IPVT structure. */
/* ********************************************************************** */
// For compatibility with lapack version with 64 or 32 bit integer.
// Should be replaced by std::vector<size_type> if 32 bit integer version
// of lapack is not used anymore (and lapack_ipvt_int set to size_type)
// Do not use iterators of this interface container
class lapack_ipvt : public std::vector<size_type> {
bool is_int64;
size_type &operator[](size_type i)
{ return std::vector<size_type>::operator[](i); }
size_type operator[] (size_type i) const
{ return std::vector<size_type>::operator[](i); }
void begin(void) const {}
void begin(void) {}
void end(void) const {}
void end(void) {}
public:
void set_to_int32() { is_int64 = false; }
const size_type *pfirst() const
{ return &(*(std::vector<size_type>::begin())); }
size_type *pfirst() { return &(*(std::vector<size_type>::begin())); }
lapack_ipvt(size_type n) : std::vector<size_type>(n), is_int64(true) {}
size_type get(size_type i) const {
const size_type *p = pfirst();
return is_int64 ? p[i] : size_type(((const int *)(p))[i]);
}
void set(size_type i, size_type val) {
size_type *p = pfirst();
if (is_int64) p[i] = val; else ((int *)(p))[i] = int(val);
}
};
}
#include "gmm_opt.h"
namespace gmm {
/** LU Factorization of a general (dense) matrix (real or complex). /** LU Factorization of a general (dense) matrix (real or complex).
@ -85,24 +125,23 @@ namespace gmm {
The pivot indices in ipvt are indexed starting from 1 The pivot indices in ipvt are indexed starting from 1
so that this is compatible with LAPACK (Fortran). so that this is compatible with LAPACK (Fortran).
*/ */
template <typename DenseMatrix, typename Pvector> template <typename DenseMatrix>
size_type lu_factor(DenseMatrix& A, Pvector& ipvt) { size_type lu_factor(DenseMatrix& A, lapack_ipvt& ipvt) {
typedef typename linalg_traits<DenseMatrix>::value_type T; typedef typename linalg_traits<DenseMatrix>::value_type T;
typedef typename linalg_traits<Pvector>::value_type int_T;
typedef typename number_traits<T>::magnitude_type R; typedef typename number_traits<T>::magnitude_type R;
size_type info(0), i, j, jp, M(mat_nrows(A)), N(mat_ncols(A)); size_type info(0), i, j, jp, M(mat_nrows(A)), N(mat_ncols(A));
size_type NN = std::min(M, N); size_type NN = std::min(M, N);
std::vector<T> c(M), r(N); std::vector<T> c(M), r(N);
GMM_ASSERT2(ipvt.size()+1 >= NN, "IPVT too small"); GMM_ASSERT2(ipvt.size()+1 >= NN, "IPVT too small");
for (i = 0; i+1 < NN; ++i) ipvt[i] = int_T(i); for (i = 0; i+1 < NN; ++i) ipvt.set(i, i);
if (M || N) { if (M || N) {
for (j = 0; j+1 < NN; ++j) { for (j = 0; j+1 < NN; ++j) {
R max = gmm::abs(A(j,j)); jp = j; R max = gmm::abs(A(j,j)); jp = j;
for (i = j+1; i < M; ++i) /* find pivot. */ for (i = j+1; i < M; ++i) /* find pivot. */
if (gmm::abs(A(i,j)) > max) { jp = i; max = gmm::abs(A(i,j)); } if (gmm::abs(A(i,j)) > max) { jp = i; max = gmm::abs(A(i,j)); }
ipvt[j] = int_T(jp + 1); ipvt.set(j, jp + 1);
if (max == R(0)) { info = j + 1; break; } if (max == R(0)) { info = j + 1; break; }
if (jp != j) for (i = 0; i < N; ++i) std::swap(A(jp, i), A(j, i)); if (jp != j) for (i = 0; i < N; ++i) std::swap(A(jp, i), A(j, i));
@ -112,7 +151,7 @@ namespace gmm {
rank_one_update(sub_matrix(A, sub_interval(j+1, M-j-1), rank_one_update(sub_matrix(A, sub_interval(j+1, M-j-1),
sub_interval(j+1, N-j-1)), c, conjugated(r)); sub_interval(j+1, N-j-1)), c, conjugated(r));
} }
ipvt[NN-1] = int_T(NN); ipvt.set(NN-1, NN);
} }
return info; return info;
} }
@ -126,7 +165,7 @@ namespace gmm {
typedef typename linalg_traits<DenseMatrix>::value_type T; typedef typename linalg_traits<DenseMatrix>::value_type T;
copy(b, x); copy(b, x);
for(size_type i = 0; i < pvector.size(); ++i) { for(size_type i = 0; i < pvector.size(); ++i) {
size_type perm = pvector[i]-1; // permutations stored in 1's offset size_type perm = pvector.get(i)-1; // permutations stored in 1's offset
if(i != perm) { T aux = x[i]; x[i] = x[perm]; x[perm] = aux; } if(i != perm) { T aux = x[i]; x[i] = x[perm]; x[perm] = aux; }
} }
/* solve Ax = b -> LUx = b -> Ux = L^-1 b. */ /* solve Ax = b -> LUx = b -> Ux = L^-1 b. */
@ -138,7 +177,7 @@ namespace gmm {
void lu_solve(const DenseMatrix &A, VectorX &x, const VectorB &b) { void lu_solve(const DenseMatrix &A, VectorX &x, const VectorB &b) {
typedef typename linalg_traits<DenseMatrix>::value_type T; typedef typename linalg_traits<DenseMatrix>::value_type T;
dense_matrix<T> B(mat_nrows(A), mat_ncols(A)); dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
std::vector<int> ipvt(mat_nrows(A)); lapack_ipvt ipvt(mat_nrows(A));
gmm::copy(A, B); gmm::copy(A, B);
size_type info = lu_factor(B, ipvt); size_type info = lu_factor(B, ipvt);
GMM_ASSERT1(!info, "Singular system, pivot = " << info); GMM_ASSERT1(!info, "Singular system, pivot = " << info);
@ -154,10 +193,9 @@ namespace gmm {
lower_tri_solve(transposed(LU), x, false); lower_tri_solve(transposed(LU), x, false);
upper_tri_solve(transposed(LU), x, true); upper_tri_solve(transposed(LU), x, true);
for(size_type i = pvector.size(); i > 0; --i) { for(size_type i = pvector.size(); i > 0; --i) {
size_type perm = pvector[i-1]-1; // permutations stored in 1's offset size_type perm = pvector.get(i-1)-1; // permutations stored in 1's offset
if(i-1 != perm) { T aux = x[i-1]; x[i-1] = x[perm]; x[perm] = aux; } if(i-1 != perm) { T aux = x[i-1]; x[i-1] = x[perm]; x[perm] = aux; }
} }
} }
@ -212,7 +250,7 @@ namespace gmm {
typedef typename linalg_traits<DenseMatrix>::value_type T; typedef typename linalg_traits<DenseMatrix>::value_type T;
DenseMatrix& A = const_cast<DenseMatrix&>(A_); DenseMatrix& A = const_cast<DenseMatrix&>(A_);
dense_matrix<T> B(mat_nrows(A), mat_ncols(A)); dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
std::vector<int> ipvt(mat_nrows(A)); lapack_ipvt ipvt(mat_nrows(A));
gmm::copy(A, B); gmm::copy(A, B);
size_type info = lu_factor(B, ipvt); size_type info = lu_factor(B, ipvt);
if (doassert) GMM_ASSERT1(!info, "Non invertible matrix, pivot = "<<info); if (doassert) GMM_ASSERT1(!info, "Non invertible matrix, pivot = "<<info);
@ -229,7 +267,7 @@ namespace gmm {
for (size_type j = 0; j < std::min(mat_nrows(LU), mat_ncols(LU)); ++j) for (size_type j = 0; j < std::min(mat_nrows(LU), mat_ncols(LU)); ++j)
det *= LU(j,j); det *= LU(j,j);
for(size_type i = 0; i < pvector.size(); ++i) for(size_type i = 0; i < pvector.size(); ++i)
if (i != size_type(pvector[i]-1)) { det = -det; } if (i != size_type(pvector.get(i)-1)) { det = -det; }
return det; return det;
} }
@ -238,7 +276,7 @@ namespace gmm {
lu_det(const DenseMatrix& A) { lu_det(const DenseMatrix& A) {
typedef typename linalg_traits<DenseMatrix>::value_type T; typedef typename linalg_traits<DenseMatrix>::value_type T;
dense_matrix<T> B(mat_nrows(A), mat_ncols(A)); dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
std::vector<int> ipvt(mat_nrows(A)); lapack_ipvt ipvt(mat_nrows(A));
gmm::copy(A, B); gmm::copy(A, B);
lu_factor(B, ipvt); lu_factor(B, ipvt);
return lu_det(B, ipvt); return lu_det(B, ipvt);

2
gmm/gmm_domain_decomp.h
View File

@ -81,7 +81,7 @@ namespace gmm {
std::vector<size_type> ns(dim), na(dim), nu(dim); std::vector<size_type> ns(dim), na(dim), nu(dim);
for (size_type i = 0; i < nbpts; ++i) { for (size_type i = 0; i < nbpts; ++i) {
for (int k = 0; k < dim; ++k) { for (int k = 0; k < dim; ++k) {
double a = (pts[i][k] - pmin[k]) / msize; register double a = (pts[i][k] - pmin[k]) / msize;
ns[k] = size_type(a) - 1; na[k] = 0; ns[k] = size_type(a) - 1; na[k] = 0;
pts1[k] = int(a + overlap); pts2[k] = int(ceil(a-1.0-overlap)); pts1[k] = int(a + overlap); pts2[k] = int(ceil(a-1.0-overlap));
} }

356
gmm/gmm_except.h
View File

@ -29,7 +29,7 @@
===========================================================================*/ ===========================================================================*/
/** @file gmm_except.h /** @file gmm_except.h
@author Yves Renard <Yves.Renard@insa-lyon.fr> @author Yves Renard <Yves.Renard@insa-lyon.fr>
@author Julien Pommier <Julien.Pommier@insa-toulouse.fr> @author Julien Pommier <Julien.Pommier@insa-toulouse.fr>
@date September 01, 2002. @date September 01, 2002.
@ -39,28 +39,39 @@
#ifndef GMM_EXCEPT_H__ #ifndef GMM_EXCEPT_H__
#define GMM_EXCEPT_H__ #define GMM_EXCEPT_H__
#include <sstream>
#include "gmm_std.h" #include "gmm_std.h"
#include "gmm_feedback_management.h"
//provides external implementation of gmm_exception and logging. //provides external implementation of gmm_exception and logging.
#ifndef EXTERNAL_EXCEPT_
namespace gmm { namespace gmm {
/* *********************************************************************** */ /* *********************************************************************** */
/* GetFEM++ generic errors. */ /* GetFEM++ generic errors. */
/* *********************************************************************** */ /* *********************************************************************** */
// std logic_error with error level information
class gmm_error: public std::logic_error { class gmm_error: public std::logic_error {
public: public:
gmm_error(const std::string& what_arg): std::logic_error (what_arg) {} gmm_error(const std::string& what_arg, int errorLevel = 1):
std::logic_error (what_arg), errorLevel_(errorLevel) {}
int errLevel() {return errorLevel_;}
private:
int errorLevel_;
}; };
#ifdef GETFEM_HAVE_PRETTY_FUNCTION #ifdef GETFEM_HAVE_PRETTY_FUNCTION
# define GMM_PRETTY_FUNCTION __PRETTY_FUNCTION__ # define GMM_PRETTY_FUNCTION __PRETTY_FUNCTION__
#elif _MSC_VER
# define GMM_PRETTY_FUNCTION __FUNCTION__
#else #else
# define GMM_PRETTY_FUNCTION "" # define GMM_PRETTY_FUNCTION ""
#endif #endif
// Errors : GMM_THROW should not be used on its own. // Errors : GMM_THROW should not be used on its own.
// GMM_ASSERT1 : Non-maskable errors. Typically for in/ouput and // GMM_ASSERT1 : Non-maskable errors. Typically for in/ouput and
// when the test do not significantly reduces the performance. // when the test do not significantly reduces the performance.
@ -72,19 +83,29 @@ namespace gmm {
// __EXCEPTIONS is defined by gcc, _CPPUNWIND is defined by visual c++ // __EXCEPTIONS is defined by gcc, _CPPUNWIND is defined by visual c++
#if defined(__EXCEPTIONS) || defined(_CPPUNWIND) #if defined(__EXCEPTIONS) || defined(_CPPUNWIND)
inline void short_error_throw(const char *file, int line, const char *func, inline void short_error_throw(const char *file, int line, const char *func,
const char *errormsg) { const char *errormsg) {
std::stringstream msg__; std::stringstream msg__;
msg__ << "Error in " << file << ", line " << line << " " << func msg__ << "Error in " << file << ", line " << line << " " << func
<< ": \n" << errormsg << std::ends; << ": \n" << errormsg << std::ends;
throw gmm::gmm_error(msg__.str()); throw gmm::gmm_error(msg__.str());
} }
# define GMM_THROW_(type, errormsg) { \ # define GMM_THROW_(type, errormsg) { \
std::stringstream msg__; \ std::stringstream msg__; \
msg__ << "Error in " << __FILE__ << ", line " \ msg__ << "Error in " << __FILE__ << ", line " \
<< __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \
<< errormsg << std::ends; \ << errormsg << std::ends; \
throw (type)(msg__.str()); \ throw (type)(msg__.str()); \
} }
# define GMM_THROW_AT_LEVEL(errormsg, level) \
{ \
std::stringstream msg; \
msg << "Error in " << __FILE__ << ", line " \
<< __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \
<< errormsg << std::ends; \
throw gmm::gmm_error(msg.str(), level); \
}
#else #else
#ifndef _MSC_VER #ifndef _MSC_VER
# define abort_no_return() ::abort() # define abort_no_return() ::abort()
@ -94,57 +115,69 @@ namespace gmm {
#endif #endif
inline void short_error_throw(const char *file, int line, const char *func, inline void short_error_throw(const char *file, int line, const char *func,
const char *errormsg) { const char *errormsg) {
std::stringstream msg__; std::stringstream msg__;
msg__ << "Error in " << file << ", line " << line << " " << func msg__ << "Error in " << file << ", line " << line << " " << func
<< ": \n" << errormsg << std::ends; << ": \n" << errormsg << std::ends;
std::cerr << msg__.str() << std::endl; std::cerr << msg__.str() << std::endl;
abort_no_return(); abort_no_return();
} }
# define GMM_THROW_(type, errormsg) { \ # define GMM_THROW_(type, errormsg) { \
std::stringstream msg__; \ std::stringstream msg__; \
msg__ << "Error in " << __FILE__ << ", line " \ msg__ << "Error in " << __FILE__ << ", line " \
<< __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \ << __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \
<< errormsg; \ << errormsg; \
std::cerr << msg__.str() << std::endl; \ std::cerr << msg__.str() << std::endl; \
abort_no_return(); \ abort_no_return(); \
}
# define GMM_THROW_AT_LEVEL(errormsg, level) \
{ \
std::stringstream msg__; \
msg__ << "Error in " << __FILE__ << ", line " \
<< __LINE__ << " " << GMM_PRETTY_FUNCTION << ": \n" \
<< errormsg << " at level " << level; \
std::cerr << msg__.str() << std::endl; \
abort_no_return(); \
} }
#endif #endif
# define GMM_ASSERT1(test, errormsg) \
{ if (!(test)) GMM_THROW_(gmm::gmm_error, errormsg); }
inline void GMM_THROW() {} inline void GMM_THROW() {}
#define GMM_THROW(a, b) { GMM_THROW_(a,b); gmm::GMM_THROW(); } #define GMM_THROW(a, b) { GMM_THROW_(a,b); gmm::GMM_THROW(); }
# define GMM_THROW_DEFAULT(errormsg) GMM_THROW_AT_LEVEL(errormsg, 1)
// This allows not to compile some assertions
#ifndef GMM_ASSERT_LEVEL
#if defined(NDEBUG) #if defined(NDEBUG)
# define GMM_ASSERT_LEVEL 1
#elif defined(DEBUG_MODE)
# define GMM_ASSERT_LEVEL 3
#else
# define GMM_ASSERT_LEVEL 2
#endif
#endif
# define GMM_ASSERT1(test, errormsg) { if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 1); }
#if GMM_ASSERT_LEVEL < 2
# define GMM_ASSERT2(test, errormsg) {} # define GMM_ASSERT2(test, errormsg) {}
# define GMM_ASSERT3(test, errormsg) {} # define GMM_ASSERT3(test, errormsg) {}
#elif !defined(GMM_FULL_NDEBUG) #elif GMM_ASSERT_LEVEL < 3
# define GMM_ASSERT2(test, errormsg) \ # define GMM_ASSERT2(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 2); }
{ if (!(test)) GMM_THROW_(gmm::gmm_error, errormsg); } # define GMM_ASSERT3(test, errormsg){}
# define GMM_ASSERT3(test, errormsg) \
{ if (!(test)) GMM_THROW_(gmm::gmm_error, errormsg); }
#else #else
# define GMM_ASSERT2(test, errormsg) \ # define GMM_ASSERT2(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 2); }
{ if (!(test)) GMM_THROW_(gmm::gmm_error, errormsg); } # define GMM_ASSERT3(test, errormsg){ if (!(test)) GMM_THROW_AT_LEVEL(errormsg, 3); }
# define GMM_ASSERT3(test, errormsg)
#endif #endif
/* *********************************************************************** */ /* *********************************************************************** */
/* GetFEM++ warnings. */ /* GetFEM++ warnings. */
/* *********************************************************************** */ /* *********************************************************************** */
// This allows to dynamically hide warnings
struct warning_level {
static int level(int l = -2)
{ static int level_ = 3; return (l != -2) ? (level_ = l) : level_; }
};
inline void set_warning_level(int l) { warning_level::level(std::max(0,l)); }
inline int get_warning_level(void) { return warning_level::level(-2); }
// This allows not to compile some Warnings // This allows not to compile some Warnings
#ifndef GMM_WARNING_LEVEL #ifndef GMM_WARNING_LEVEL
# define GMM_WARNING_LEVEL 4 # define GMM_WARNING_LEVEL 4
@ -156,55 +189,48 @@ namespace gmm {
// 3 remark // 3 remark
// 4 ignored by default. // 4 ignored by default.
#define GMM_WARNING_MSG(level_, thestr) { \ #define GMM_WARNING_MSG(level_, thestr) { \
std::stringstream msg__; \ std::stringstream msg__; \
msg__ << "Level " << level_ << " Warning in " << __FILE__ << ", line " \ msg__ << "Level " << level_ << " Warning in " << __FILE__ << ", line " \
<< __LINE__ << ": " << thestr; \ << __LINE__ << ": " << thestr; \
std::cerr << msg__.str() << std::endl; \ gmm::feedback_manager::manage()->send(msg__.str(), gmm::FeedbackType::WARNING, level_); \
} }
#define GMM_WARNING0(thestr) GMM_WARNING_MSG(0, thestr) #define GMM_WARNING0(thestr) GMM_WARNING_MSG(0, thestr)
#if GMM_WARNING_LEVEL > 0 #if GMM_WARNING_LEVEL > 0
# define GMM_WARNING1(thestr) \ # define GMM_WARNING1(thestr) \
{ if (1 <= gmm::warning_level::level()) GMM_WARNING_MSG(1, thestr) } { if (1 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(1, thestr) }
#else #else
# define GMM_WARNING1(thestr) {} # define GMM_WARNING1(thestr) {}
#endif #endif
#if GMM_WARNING_LEVEL > 1 #if GMM_WARNING_LEVEL > 1
# define GMM_WARNING2(thestr) \ # define GMM_WARNING2(thestr) \
{ if (2 <= gmm::warning_level::level()) GMM_WARNING_MSG(2, thestr) } { if (2 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(2, thestr) }
#else #else
# define GMM_WARNING2(thestr) {} # define GMM_WARNING2(thestr) {}
#endif #endif
#if GMM_WARNING_LEVEL > 2 #if GMM_WARNING_LEVEL > 2
# define GMM_WARNING3(thestr) \ # define GMM_WARNING3(thestr) \
{ if (3 <= gmm::warning_level::level()) GMM_WARNING_MSG(3, thestr) } { if (3 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(3, thestr) }
#else #else
# define GMM_WARNING3(thestr) {} # define GMM_WARNING3(thestr) {}
#endif #endif
#if GMM_WARNING_LEVEL > 3 #if GMM_WARNING_LEVEL > 3
# define GMM_WARNING4(thestr) \ # define GMM_WARNING4(thestr) \
{ if (4 <= gmm::warning_level::level()) GMM_WARNING_MSG(4, thestr) } { if (4 <= gmm::feedback_manager::warning_level()) GMM_WARNING_MSG(4, thestr) }
#else #else
# define GMM_WARNING4(thestr) {} # define GMM_WARNING4(thestr) {}
#endif #endif
/* *********************************************************************** */ /* *********************************************************************** */
/* GetFEM++ traces. */ /* GetFEM++ traces. */
/* *********************************************************************** */ /* *********************************************************************** */
// This allows to dynamically hide traces
struct traces_level {
static int level(int l = -2)
{ static int level_ = 3; return (l != -2) ? (level_ = l) : level_; }
};
inline void set_traces_level(int l) { traces_level::level(std::max(0,l)); }
// This allow not too compile some Warnings // This allow not too compile some Warnings
#ifndef GMM_TRACES_LEVEL #ifndef GMM_TRACES_LEVEL
# define GMM_TRACES_LEVEL 4 # define GMM_TRACES_LEVEL 4
@ -217,112 +243,164 @@ namespace gmm {
// 4 Susceptible to occur very often (>1000). // 4 Susceptible to occur very often (>1000).
#define GMM_TRACE_MSG_MPI // for Parallelized version #define GMM_TRACE_MSG_MPI // for Parallelized version
#define GMM_TRACE_MSG(level_, thestr) { \ #define GMM_TRACE_MSG(level_, thestr) { \
GMM_TRACE_MSG_MPI { \ GMM_TRACE_MSG_MPI { \
std::stringstream msg__; \ std::stringstream msg__; \
msg__ << "Trace " << level_ << " in " << __FILE__ << ", line " \ msg__ << "Trace " << level_ << " in " << __FILE__ << ", line " \
<< __LINE__ << ": " << thestr; \ << __LINE__ << ": " << thestr; \
std::cout << msg__.str() << std::endl; \ gmm::feedback_manager::send(msg__.str(), gmm::FeedbackType::TRACE, level_); \
} \ } \
} }
#define GMM_TRACE_SIMPLE_MSG(level_, thestr) { \
GMM_TRACE_MSG_MPI { \
std::stringstream msg__; \
msg__ << "Trace " << level_ << ": " << thestr; \
gmm::feedback_manager::send(msg__.str(), gmm::FeedbackType::TRACE, level_); \
} \
}
#define GMM_TRACE0(thestr) GMM_TRACE_MSG(0, thestr) #define GMM_TRACE0(thestr) GMM_TRACE_MSG(0, thestr)
#define GMM_SIMPLE_TRACE0(thestr) GMM_TRACE_MSG_SIMPLE(0, thestr)
#if GMM_TRACES_LEVEL > 0 #if GMM_TRACES_LEVEL > 0
# define GMM_TRACE1(thestr) \ # define GMM_TRACE1(thestr) \
{ if (1 <= gmm::traces_level::level()) GMM_TRACE_MSG(1, thestr) } { if (1 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(1, thestr) }
# define GMM_SIMPLE_TRACE1(thestr) \
{ if (1 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(1, thestr) }
#else #else
# define GMM_TRACE1(thestr) {} # define GMM_TRACE1(thestr) {}
# define GMM_SIMPLE_TRACE1(thestr) {}
#endif #endif
#if GMM_TRACES_LEVEL > 1 #if GMM_TRACES_LEVEL > 1
# define GMM_TRACE2(thestr) \ # define GMM_TRACE2(thestr) \
{ if (2 <= gmm::traces_level::level()) GMM_TRACE_MSG(2, thestr) } { if (2 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(2, thestr) }
# define GMM_SIMPLE_TRACE2(thestr) \
{ if (2 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(2, thestr) }
#else #else
# define GMM_TRACE2(thestr) {} # define GMM_TRACE2(thestr) {}
# define GMM_SIMPLE_TRACE2(thestr) {}
#endif #endif
#if GMM_TRACES_LEVEL > 2 #if GMM_TRACES_LEVEL > 2
# define GMM_TRACE3(thestr) \ # define GMM_TRACE3(thestr) \
{ if (3 <= gmm::traces_level::level()) GMM_TRACE_MSG(3, thestr) } { if (3 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(3, thestr) }
# define GMM_SIMPLE_TRACE3(thestr) \
{ if (3 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(3, thestr) }
#else #else
# define GMM_TRACE3(thestr) {} # define GMM_TRACE3(thestr) {}
# define GMM_SIMPLE_TRACE3(thestr) {}
#endif #endif
#if GMM_TRACES_LEVEL > 3 #if GMM_TRACES_LEVEL > 3
# define GMM_TRACE4(thestr) \ # define GMM_TRACE4(thestr) \
{ if (4 <= gmm::traces_level::level()) GMM_TRACE_MSG(4, thestr) } { if (4 <= gmm::feedback_manager::traces_level()) GMM_TRACE_MSG(4, thestr) }
# define GMM_SIMPLE_TRACE4(thestr) \
{ if (4 <= gmm::feedback_manager::traces_level()) GMM_TRACE_SIMPLE_MSG(4, thestr) }
#else #else
# define GMM_TRACE4(thestr) {} # define GMM_TRACE4(thestr) {}
# define GMM_SIMPLE_TRACE4(thestr) {}
#endif #endif
#define GMM_STANDARD_CATCH_ERROR \
/* ********************************************************************* */ catch(gmm::gmm_error e) \
/* Definitions for compatibility with old versions. */ { \
/* ********************************************************************* */ std::stringstream strStream; \
strStream << "============================================\n"; \
#define GMM_STANDARD_CATCH_ERROR catch(std::logic_error e) \ strStream << "| A GMM error has been detected !!! |\n"; \
{ \ strStream << "============================================\n"; \
std::cerr << "============================================\n"; \ strStream << e.what() << std::endl << std::endl; \
std::cerr << "| An error has been detected !!! |\n"; \ gmm::feedback_manager::send(strStream.str(), \
std::cerr << "============================================\n"; \ gmm::FeedbackType::ASSERT, e.errLevel()); \
std::cerr << e.what() << std::endl << std::endl; \ gmm::feedback_manager::terminating_action(); \
exit(1); \ } \
} \ catch(std::logic_error e) \
catch(const std::runtime_error &e) \ { \
{ \ std::stringstream strStream; \
std::cerr << "============================================\n"; \ strStream << "============================================\n"; \
std::cerr << "| An error has been detected !!! |\n"; \ strStream << "| An error has been detected !!! |\n"; \
std::cerr << "============================================\n"; \ strStream << "============================================\n"; \
std::cerr << e.what() << std::endl << std::endl; \ strStream << e.what() << std::endl << std::endl; \
exit(1); \ gmm::feedback_manager::send(strStream.str(), \
} \ gmm::FeedbackType::ASSERT, 0); \
catch(const std::bad_alloc &) { \ gmm::feedback_manager::terminating_action(); \
std::cerr << "============================================\n"; \ } \
std::cerr << "| A bad allocation has been detected !!! |\n"; \ catch(std::runtime_error e) \
std::cerr << "============================================\n"; \ { \
exit(1); \ std::stringstream strStream; \
} \ strStream << "============================================\n"; \
catch(const std::bad_typeid &) { \ strStream << "| A runtime error has been detected !!! |\n"; \
std::cerr << "============================================\n"; \ strStream << "============================================\n"; \
std::cerr << "| A bad typeid has been detected !!! |\n"; \ strStream << e.what() << std::endl << std::endl; \
std::cerr << "============================================\n"; \ gmm::feedback_manager::send(strStream.str(), \
exit(1); \ gmm::FeedbackType::ASSERT, 0); \
} \ gmm::feedback_manager::terminating_action(); \
catch(const std::bad_exception &) { \ } \
std::cerr << "============================================\n"; \ catch(std::bad_alloc) \
std::cerr << "| A bad exception has been detected !!! |\n"; \ { \
std::cerr << "============================================\n"; \ std::stringstream strStream; \
exit(1); \ strStream << "============================================\n"; \
} \ strStream << "| A bad allocation has been detected !!! |\n"; \
catch(const std::bad_cast &) { \ strStream << "============================================\n"; \
std::cerr << "============================================\n"; \ gmm::feedback_manager::send(strStream.str(), \
std::cerr << "| A bad cast has been detected !!! |\n"; \ gmm::FeedbackType::ASSERT, 0); \
std::cerr << "============================================\n"; \ gmm::feedback_manager::terminating_action(); \
exit(1); \ } \
} \ catch(std::bad_typeid) \
catch(...) { \ { \
std::cerr << "============================================\n"; \ std::stringstream strStream; \
std::cerr << "| An unknown error has been detected !!! |\n"; \ strStream << "============================================\n"; \
std::cerr << "============================================\n"; \ strStream << "| A bad typeid has been detected !!! |\n"; \
exit(1); \ strStream << "============================================\n"; \
gmm::feedback_manager::send(strStream.str(), \
gmm::FeedbackType::ASSERT, 0); \
gmm::feedback_manager::terminating_action(); \
} \
catch(std::bad_exception) \
{ \
std::stringstream strStream; \
strStream << "============================================\n"; \
strStream << "| A bad exception has been detected !!! |\n"; \
strStream << "============================================\n"; \
gmm::feedback_manager::send(strStream.str(), \
gmm::FeedbackType::ASSERT, 0); \
gmm::feedback_manager::terminating_action(); \
} \
catch(std::bad_cast) \
{ \
std::stringstream strStream; \
strStream << "============================================\n"; \
strStream << "| A bad_cast has been detected !!! |\n"; \
strStream << "============================================\n"; \
gmm::feedback_manager::send(strStream.str(), \
gmm::FeedbackType::ASSERT, 0); \
gmm::feedback_manager::terminating_action(); \
} \
catch(...) \
{ \
std::stringstream strStream; \
strStream << "============================================\n"; \
strStream << "| An unknown error has been detected !!! |\n"; \
strStream << "============================================\n"; \
gmm::feedback_manager::send(strStream.str(), \
gmm::FeedbackType::ASSERT, 0); \
gmm::feedback_manager::terminating_action(); \
} }
// catch(ios_base::failure) { // catch(ios_base::failure) {
// std::cerr << "============================================\n"; // std::cerr << "============================================\n";
// std::cerr << "| A ios_base::failure has been detected !!!|\n"; // std::cerr << "| A ios_base::failure has been detected !!!|\n";
// std::cerr << "============================================\n"; // std::cerr << "============================================\n";
// exit(1); // exit(1);
// } // }
#if defined(__GNUC__) && (__GNUC__ > 3) #if defined(__GNUC__) && (__GNUC__ > 3)
# define GMM_SET_EXCEPTION_DEBUG \ # define GMM_SET_EXCEPTION_DEBUG \
std::set_terminate(__gnu_cxx::__verbose_terminate_handler); std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
#else #else
# define GMM_SET_EXCEPTION_DEBUG # define GMM_SET_EXCEPTION_DEBUG
#endif #endif
} } // namespace gmm
#else
#include <external_except.h>
#endif /* EXTERNAL_EXCEPT_*/
#endif /* GMM_EXCEPT_H__ */ #endif /* GMM_EXCEPT_H__ */

174
gmm/gmm_feedback_management.h Normal file
View File

@ -0,0 +1,174 @@
/* -*- c++ -*- (enables emacs c++ mode) */
/*===========================================================================
Copyright (C) 2002-2017 Yves Renard
This file is a part of GetFEM++
GetFEM++ is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 3 of the License, or
(at your option) any later version along with the GCC Runtime Library
Exception either version 3.1 or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License and GCC Runtime Library Exception for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
As a special exception, you may use this file as it is a part of a free
software library without restriction. Specifically, if other files
instantiate templates or use macros or inline functions from this file,
or you compile this file and link it with other files to produce an
executable, this file does not by itself cause the resulting executable
to be covered by the GNU Lesser General Public License. This exception
does not however invalidate any other reasons why the executable file
might be covered by the GNU Lesser General Public License.
===========================================================================*/
/** @file gmm_feedback_management.h
@date July 03, 2017.
@brief Support for run time management of trace, warning and assert
feedback.
*/
#ifndef GMM_FEEDBACK_MANAGEMENT_H__
#define GMM_FEEDBACK_MANAGEMENT_H__
#include <iostream>
#include <string>
#include <memory>
namespace gmm {
/* *********************************************************************** */
/* GetFEM++ warnings. */
/* *********************************************************************** */
// This allows to dynamically hide warnings
struct warning_level {
static int level(int l = -2)
{ static int level_ = 3; return (l != -2) ? (level_ = l) : level_; }
};
inline void set_warning_level(int l) { warning_level::level(l>0 ? l : 0); }
inline int get_warning_level(void) { return warning_level::level(-2); }
/* *********************************************************************** */
/* GetFEM++ traces. */
/* *********************************************************************** */
// This allows to dynamically hide traces
struct traces_level {
static int level(int l = -2)
{ static int level_ = 3; return (l != -2) ? (level_ = l) : level_; }
};
inline void set_traces_level(int l) { traces_level::level(l>0 ? l : 0); }
inline int get_traces_level(void) { return traces_level::level(); }
/* *********************************************************************** */
/* GetFEM++ feedback management */
/* *********************************************************************** */
enum class FeedbackType {
TRACE = 0,
WARNING,
ASSERT
};
// Abstract class providing feedback management interface.
// The interface consist of three functions:
// * for sending feedback message
// * for getting traces level
// * for getting warning level
// * for action to be done after feedback is handled
struct base_feedback_handler {
virtual ~base_feedback_handler() = default;
virtual void send(const std::string &message, FeedbackType messageType, size_t level) = 0;
virtual size_t traces_level() { return get_traces_level(); }
virtual size_t warning_level() { return get_warning_level(); }
virtual void terminating_action() = 0;
};
// Provides the default implementation of feedback handling.
struct default_feedback_handler final : public base_feedback_handler {
void send(const std::string &message, FeedbackType, size_t) override {
std::cerr << message << std::endl;
}
void terminating_action() override {
std::exit(1);
}
};
// This class acts as a run-time dispatcher for sending feedback
// messages and getting trace and warning levels.
class feedback_manager {
public:
// Management actions
enum Action {
SET, // Sets the feedback handler, releasing the one previously set.
GET, // Returns currently managed handler (it is still managed).
REPLACE, // Replace manager with a new one, stop managing the old one
// and returns it unmanaged to the caller. The caller is
// then responsible for managing the memory of the handler.
};
// Steals the pointer to a messenger object that provides
// feedback handling implementation.
//
// Example:
// feedback_manager::manage(new default_feedback_handler);
//
static base_feedback_handler* manage(enum Action action=GET, base_feedback_handler *pHandler=nullptr);
static void send(const std::string &message, FeedbackType type, size_t level);
static size_t traces_level();
static size_t warning_level();
// Action to be taken when feedback handling is done
static void terminating_action();
};
// Depending on action either gets, sets or replaces feedback handler. Setting handler to null resets
// it to gmm::default_feedback_handler.
inline base_feedback_handler* feedback_manager::manage(enum Action action, base_feedback_handler *pHandler) {
static std::unique_ptr<base_feedback_handler> pHandler_ =
std::move(std::unique_ptr<base_feedback_handler>(new default_feedback_handler));
base_feedback_handler *rethandler = nullptr;
switch(action) {
case SET:
pHandler_.reset(pHandler != nullptr ? pHandler : new default_feedback_handler);
rethandler = pHandler_.get();
break;
case GET:
rethandler = pHandler_.get();
break;
case REPLACE:
rethandler = pHandler_.release();
pHandler_.reset(pHandler != nullptr ? pHandler : new default_feedback_handler);
break;
}
return rethandler;
}
inline void feedback_manager::send(const std::string &message, FeedbackType type, size_t level) {
feedback_manager::manage()->send(message, type, level);
}
inline void feedback_manager::terminating_action() {
feedback_manager::manage()->terminating_action();
}
inline size_t feedback_manager::traces_level() {
return feedback_manager::manage()->traces_level();
}
inline size_t feedback_manager::warning_level() {
return feedback_manager::manage()->warning_level();
}
} // namespace gmm
#endif /* GMM_FEEDBACK_MANAGEMENT_H__ */

211
gmm/gmm_lapack_interface.h
View File

@ -47,42 +47,42 @@
namespace gmm { namespace gmm {
/* ********************************************************************* */ /* ********************************************************************** */
/* Operations interfaced for T = float, double, std::complex<float> */ /* Operations interfaced for T = float, double, std::complex<float> */
/* or std::complex<double> : */ /* or std::complex<double> : */
/* */ /* */
/* lu_factor(dense_matrix<T>, std::vector<int>) */ /* lu_factor(dense_matrix<T>, std::vector<long>) */
/* lu_solve(dense_matrix<T>, std::vector<T>, std::vector<T>) */ /* lu_solve(dense_matrix<T>, std::vector<T>, std::vector<T>) */
/* lu_solve(dense_matrix<T>, std::vector<int>, std::vector<T>, */ /* lu_solve(dense_matrix<T>, std::vector<long>, std::vector<T>, */
/* std::vector<T>) */ /* std::vector<T>) */
/* lu_solve_transposed(dense_matrix<T>, std::vector<int>, std::vector<T>,*/ /* lu_solve_transposed(dense_matrix<T>, std::vector<long>, std::vector<T>,*/
/* std::vector<T>) */ /* std::vector<T>) */
/* lu_inverse(dense_matrix<T>) */ /* lu_inverse(dense_matrix<T>) */
/* lu_inverse(dense_matrix<T>, std::vector<int>, dense_matrix<T>) */ /* lu_inverse(dense_matrix<T>, std::vector<long>, dense_matrix<T>) */
/* */ /* */
/* qr_factor(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>) */ /* qr_factor(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>) */
/* */ /* */
/* implicit_qr_algorithm(dense_matrix<T>, std::vector<T>) */ /* implicit_qr_algorithm(dense_matrix<T>, std::vector<T>) */
/* implicit_qr_algorithm(dense_matrix<T>, std::vector<T>, */ /* implicit_qr_algorithm(dense_matrix<T>, std::vector<T>, */
/* dense_matrix<T>) */ /* dense_matrix<T>) */
/* implicit_qr_algorithm(dense_matrix<T>, std::vector<std::complex<T> >) */ /* implicit_qr_algorithm(dense_matrix<T>, std::vector<std::complex<T> >) */
/* implicit_qr_algorithm(dense_matrix<T>, std::vector<std::complex<T> >, */ /* implicit_qr_algorithm(dense_matrix<T>, std::vector<std::complex<T> >, */
/* dense_matrix<T>) */ /* dense_matrix<T>) */
/* */ /* */
/* geev_interface_right */ /* geev_interface_right */
/* geev_interface_left */ /* geev_interface_left */
/* */ /* */
/* schur(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>) */ /* schur(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>) */
/* */ /* */
/* svd(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>, std::vector<T>)*/ /* svd(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>, std::vector<T>) */
/* svd(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>, */ /* svd(dense_matrix<T>, dense_matrix<T>, dense_matrix<T>, */
/* std::vector<std::complex<T> >) */ /* std::vector<std::complex<T> >) */
/* */ /* */
/* ********************************************************************* */ /* ********************************************************************** */
/* ********************************************************************* */ /* ********************************************************************** */
/* LAPACK functions used. */ /* LAPACK functions used. */
/* ********************************************************************* */ /* ********************************************************************** */
extern "C" { extern "C" {
void sgetrf_(...); void dgetrf_(...); void cgetrf_(...); void zgetrf_(...); void sgetrf_(...); void dgetrf_(...); void cgetrf_(...); void zgetrf_(...);
@ -96,17 +96,20 @@ namespace gmm {
void sgeesx_(...); void dgeesx_(...); void cgeesx_(...); void zgeesx_(...); void sgeesx_(...); void dgeesx_(...); void cgeesx_(...); void zgeesx_(...);
void sgesvd_(...); void dgesvd_(...); void cgesvd_(...); void zgesvd_(...); void sgesvd_(...); void dgesvd_(...); void cgesvd_(...); void zgesvd_(...);
} }
/* ********************************************************************* */ /* ********************************************************************** */
/* LU decomposition. */ /* LU decomposition. */
/* ********************************************************************* */ /* ********************************************************************** */
# define getrf_interface(lapack_name, base_type) inline \ # define getrf_interface(lapack_name, base_type) inline \
size_type lu_factor(dense_matrix<base_type > &A, std::vector<int> &ipvt){\ size_type lu_factor(dense_matrix<base_type > &A, lapack_ipvt &ipvt){ \
GMMLAPACK_TRACE("getrf_interface"); \ GMMLAPACK_TRACE("getrf_interface"); \
int m = int(mat_nrows(A)), n = int(mat_ncols(A)), lda(m), info(0); \ long m = long(mat_nrows(A)), n = long(mat_ncols(A)), lda(m), info(-1L); \
if (m && n) lapack_name(&m, &n, &A(0,0), &lda, &ipvt[0], &info); \ if (m && n) lapack_name(&m, &n, &A(0,0), &lda, ipvt.pfirst(), &info); \
return size_type(info); \ if ((info & 0xFFFFFFFF00000000L) && !(info & 0x00000000FFFFFFFFL)) \
/* For compatibility with lapack version with 32 bit integer. */ \
ipvt.set_to_int32(); \
return size_type(int(info & 0x00000000FFFFFFFFL)); \
} }
getrf_interface(sgetrf_, BLAS_S) getrf_interface(sgetrf_, BLAS_S)
@ -120,13 +123,13 @@ namespace gmm {
# define getrs_interface(f_name, trans1, lapack_name, base_type) inline \ # define getrs_interface(f_name, trans1, lapack_name, base_type) inline \
void f_name(const dense_matrix<base_type > &A, \ void f_name(const dense_matrix<base_type > &A, \
const std::vector<int> &ipvt, std::vector<base_type > &x, \ const lapack_ipvt &ipvt, std::vector<base_type > &x, \
const std::vector<base_type > &b) { \ const std::vector<base_type > &b) { \
GMMLAPACK_TRACE("getrs_interface"); \ GMMLAPACK_TRACE("getrs_interface"); \
int n = int(mat_nrows(A)), info, nrhs(1); \ long n = long(mat_nrows(A)), info(0), nrhs(1); \
gmm::copy(b, x); trans1; \ gmm::copy(b, x); trans1; \
if (n) \ if (n) \
lapack_name(&t, &n, &nrhs, &(A(0,0)),&n,&ipvt[0], &x[0], &n, &info); \ lapack_name(&t,&n,&nrhs,&(A(0,0)),&n,ipvt.pfirst(),&x[0],&n,&info); \
} }
# define getrs_trans_n const char t = 'N' # define getrs_trans_n const char t = 'N'
@ -147,14 +150,17 @@ namespace gmm {
# define getri_interface(lapack_name, base_type) inline \ # define getri_interface(lapack_name, base_type) inline \
void lu_inverse(const dense_matrix<base_type > &LU, \ void lu_inverse(const dense_matrix<base_type > &LU, \
std::vector<int> &ipvt, const dense_matrix<base_type > &A_) { \ const lapack_ipvt &ipvt, const dense_matrix<base_type > &A_) { \
GMMLAPACK_TRACE("getri_interface"); \ GMMLAPACK_TRACE("getri_interface"); \
dense_matrix<base_type> &A \ dense_matrix<base_type >& \
= const_cast<dense_matrix<base_type > &>(A_); \ A = const_cast<dense_matrix<base_type > &>(A_); \
int n = int(mat_nrows(A)), info, lwork(10000); base_type work[10000]; \ long n = int(mat_nrows(A)), info(0), lwork(-1); base_type work1; \
if (n) { \ if (n) { \
std::copy(LU.begin(), LU.end(), A.begin()); \ gmm::copy(LU, A); \
lapack_name(&n, &A(0,0), &n, &ipvt[0], &work[0], &lwork, &info); \ lapack_name(&n, &A(0,0), &n, ipvt.pfirst(), &work1, &lwork, &info); \
lwork = int(gmm::real(work1)); \
std::vector<base_type > work(lwork); \
lapack_name(&n, &A(0,0), &n, ipvt.pfirst(), &work[0], &lwork,&info); \
} \ } \
} }
@ -163,20 +169,19 @@ namespace gmm {
getri_interface(cgetri_, BLAS_C) getri_interface(cgetri_, BLAS_C)
getri_interface(zgetri_, BLAS_Z) getri_interface(zgetri_, BLAS_Z)
/* ********************************************************************** */
/* ********************************************************************* */ /* QR factorization. */
/* QR factorization. */ /* ********************************************************************** */
/* ********************************************************************* */
# define geqrf_interface(lapack_name1, base_type) inline \ # define geqrf_interface(lapack_name1, base_type) inline \
void qr_factor(dense_matrix<base_type > &A){ \ void qr_factor(dense_matrix<base_type > &A){ \
GMMLAPACK_TRACE("geqrf_interface"); \ GMMLAPACK_TRACE("geqrf_interface"); \
int m = int(mat_nrows(A)), n = int(mat_ncols(A)), info, lwork(-1); \ long m = long(mat_nrows(A)), n=long(mat_ncols(A)), info(0), lwork(-1); \
base_type work1; \ base_type work1; \
if (m && n) { \ if (m && n) { \
std::vector<base_type > tau(n); \ std::vector<base_type > tau(n); \
lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work1 , &lwork, &info); \ lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work1 , &lwork, &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work[0], &lwork, &info); \ lapack_name1(&m, &n, &A(0,0), &m, &tau[0], &work[0], &lwork, &info); \
GMM_ASSERT1(!info, "QR factorization failed"); \ GMM_ASSERT1(!info, "QR factorization failed"); \
@ -194,19 +199,19 @@ namespace gmm {
void qr_factor(const dense_matrix<base_type > &A, \ void qr_factor(const dense_matrix<base_type > &A, \
dense_matrix<base_type > &Q, dense_matrix<base_type > &R) { \ dense_matrix<base_type > &Q, dense_matrix<base_type > &R) { \
GMMLAPACK_TRACE("geqrf_interface2"); \ GMMLAPACK_TRACE("geqrf_interface2"); \
int m = int(mat_nrows(A)), n = int(mat_ncols(A)), info, lwork(-1); \ long m = long(mat_nrows(A)), n=long(mat_ncols(A)), info(0), lwork(-1); \
base_type work1; \ base_type work1; \
if (m && n) { \ if (m && n) { \
std::copy(A.begin(), A.end(), Q.begin()); \ std::copy(A.begin(), A.end(), Q.begin()); \
std::vector<base_type > tau(n); \ std::vector<base_type > tau(n); \
lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work1 , &lwork, &info); \ lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work1 , &lwork, &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work[0], &lwork, &info); \ lapack_name1(&m, &n, &Q(0,0), &m, &tau[0], &work[0], &lwork, &info); \
GMM_ASSERT1(!info, "QR factorization failed"); \ GMM_ASSERT1(!info, "QR factorization failed"); \
base_type *p = &R(0,0), *q = &Q(0,0); \ base_type *p = &R(0,0), *q = &Q(0,0); \
for (int j = 0; j < n; ++j, q += m-n) \ for (long j = 0; j < n; ++j, q += m-n) \
for (int i = 0; i < n; ++i, ++p, ++q) \ for (long i = 0; i < n; ++i, ++p, ++q) \
*p = (j < i) ? base_type(0) : *q; \ *p = (j < i) ? base_type(0) : *q; \
lapack_name2(&m, &n, &n, &Q(0,0), &m,&tau[0],&work[0],&lwork,&info); \ lapack_name2(&m, &n, &n, &Q(0,0), &m,&tau[0],&work[0],&lwork,&info); \
} \ } \
@ -218,9 +223,9 @@ namespace gmm {
geqrf_interface2(cgeqrf_, cungqr_, BLAS_C) geqrf_interface2(cgeqrf_, cungqr_, BLAS_C)
geqrf_interface2(zgeqrf_, zungqr_, BLAS_Z) geqrf_interface2(zgeqrf_, zungqr_, BLAS_Z)
/* ********************************************************************* */ /* ********************************************************************** */
/* QR algorithm for eigenvalues search. */ /* QR algorithm for eigenvalues search. */
/* ********************************************************************* */ /* ********************************************************************** */
# define gees_interface(lapack_name, base_type) \ # define gees_interface(lapack_name, base_type) \
template <typename VECT> inline void implicit_qr_algorithm( \ template <typename VECT> inline void implicit_qr_algorithm( \
@ -229,14 +234,14 @@ namespace gmm {
double tol=gmm::default_tol(base_type()), bool compvect = true) { \ double tol=gmm::default_tol(base_type()), bool compvect = true) { \
GMMLAPACK_TRACE("gees_interface"); \ GMMLAPACK_TRACE("gees_interface"); \
typedef bool (*L_fp)(...); L_fp p = 0; \ typedef bool (*L_fp)(...); L_fp p = 0; \
int n = int(mat_nrows(A)), info, lwork(-1), sdim; base_type work1; \ long n=long(mat_nrows(A)), info(0), lwork(-1), sdim; base_type work1; \
if (!n) return; \ if (!n) return; \
dense_matrix<base_type > H(n,n); gmm::copy(A, H); \ dense_matrix<base_type > H(n,n); gmm::copy(A, H); \
char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \ char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \
std::vector<double> rwork(n), eigv1(n), eigv2(n); \ std::vector<double> rwork(n), eigv1(n), eigv2(n); \
lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \ lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \
&eigv2[0], &Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \ &eigv2[0], &Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \ lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigv1[0], \
&eigv2[0], &Q(0,0), &n, &work[0], &lwork, &rwork[0],&info);\ &eigv2[0], &Q(0,0), &n, &work[0], &lwork, &rwork[0],&info);\
@ -251,14 +256,14 @@ namespace gmm {
double tol=gmm::default_tol(base_type()), bool compvect = true) { \ double tol=gmm::default_tol(base_type()), bool compvect = true) { \
GMMLAPACK_TRACE("gees_interface2"); \ GMMLAPACK_TRACE("gees_interface2"); \
typedef bool (*L_fp)(...); L_fp p = 0; \ typedef bool (*L_fp)(...); L_fp p = 0; \
int n = int(mat_nrows(A)), info, lwork(-1), sdim; base_type work1; \ long n=long(mat_nrows(A)), info(0), lwork(-1), sdim; base_type work1; \
if (!n) return; \ if (!n) return; \
dense_matrix<base_type > H(n,n); gmm::copy(A, H); \ dense_matrix<base_type > H(n,n); gmm::copy(A, H); \
char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \ char jobvs = (compvect ? 'V' : 'N'), sort = 'N'; \
std::vector<double> rwork(n), eigvv(n*2); \ std::vector<double> rwork(n), eigvv(n*2); \
lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \ lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \
&Q(0,0), &n, &work1, &lwork, &rwork[0], &rwork[0], &info); \ &Q(0,0), &n, &work1, &lwork, &rwork[0], &rwork[0], &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \ lapack_name(&jobvs, &sort, p, &n, &H(0,0), &n, &sdim, &eigvv[0], \
&Q(0,0), &n, &work[0], &lwork, &rwork[0], &rwork[0],&info);\ &Q(0,0), &n, &work[0], &lwork, &rwork[0], &rwork[0],&info);\
@ -276,18 +281,18 @@ namespace gmm {
# define jobv_left char jobvl = 'V', jobvr = 'N'; # define jobv_left char jobvl = 'V', jobvr = 'N';
# define geev_interface(lapack_name, base_type, side) \ # define geev_interface(lapack_name, base_type, side) \
template <typename VECT> inline void geev_interface_ ## side( \ template <typename VECT> inline void geev_interface_ ## side( \
const dense_matrix<base_type > &A, const VECT &eigval_, \ const dense_matrix<base_type > &A, const VECT &eigval_, \
dense_matrix<base_type > &Q) { \ dense_matrix<base_type > &Q) { \
GMMLAPACK_TRACE("geev_interface"); \ GMMLAPACK_TRACE("geev_interface"); \
int n = int(mat_nrows(A)), info, lwork(-1); base_type work1; \ long n = long(mat_nrows(A)), info(0), lwork(-1); base_type work1; \
if (!n) return; \ if (!n) return; \
dense_matrix<base_type > H(n,n); gmm::copy(A, H); \ dense_matrix<base_type > H(n,n); gmm::copy(A, H); \
jobv_ ## side \ jobv_ ## side \
std::vector<base_type > eigvr(n), eigvi(n); \ std::vector<base_type > eigvr(n), eigvi(n); \
lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \ lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \
&Q(0,0), &n, &Q(0,0), &n, &work1, &lwork, &info); \ &Q(0,0), &n, &Q(0,0), &n, &work1, &lwork, &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \ lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigvr[0], &eigvi[0], \
&Q(0,0), &n, &Q(0,0), &n, &work[0], &lwork, &info); \ &Q(0,0), &n, &Q(0,0), &n, &work[0], &lwork, &info); \
@ -301,7 +306,7 @@ namespace gmm {
const dense_matrix<base_type > &A, const VECT &eigval_, \ const dense_matrix<base_type > &A, const VECT &eigval_, \
dense_matrix<base_type > &Q) { \ dense_matrix<base_type > &Q) { \
GMMLAPACK_TRACE("geev_interface"); \ GMMLAPACK_TRACE("geev_interface"); \
int n = int(mat_nrows(A)), info, lwork(-1); base_type work1; \ long n = long(mat_nrows(A)), info(0), lwork(-1); base_type work1; \
if (!n) return; \ if (!n) return; \
dense_matrix<base_type > H(n,n); gmm::copy(A, H); \ dense_matrix<base_type > H(n,n); gmm::copy(A, H); \
jobv_ ## side \ jobv_ ## side \
@ -309,7 +314,7 @@ namespace gmm {
std::vector<base_type> eigv(n); \ std::vector<base_type> eigv(n); \
lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \ lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \
&Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \ &Q(0,0), &n, &work1, &lwork, &rwork[0], &info); \
lwork = int(gmm::real(work1)); \ lwork = long(gmm::real(work1)); \
std::vector<base_type > work(lwork); \ std::vector<base_type > work(lwork); \
lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \ lapack_name(&jobvl, &jobvr, &n, &H(0,0), &n, &eigv[0], &Q(0,0), &n, \
&Q(0,0), &n, &work[0], &lwork, &rwork[0], &info); \ &Q(0,0), &n, &work[0], &lwork, &rwork[0], &info); \
@ -328,32 +333,32 @@ namespace gmm {
geev_interface2(zgeev_, BLAS_Z, left) geev_interface2(zgeev_, BLAS_Z, left)
/* ********************************************************************* */ /* ********************************************************************** */
/* SCHUR algorithm: */ /* SCHUR algorithm: */
/* A = Q*S*(Q^T), with Q orthogonal and S upper quasi-triangula */ /* A = Q*S*(Q^T), with Q orthogonal and S upper quasi-triangula */
/* ********************************************************************* */ /* ********************************************************************** */
# define geesx_interface(lapack_name, base_type) inline \ # define geesx_interface(lapack_name, base_type) inline \
void schur(dense_matrix<base_type> &A, \ void schur(dense_matrix<base_type> &A, \
dense_matrix<base_type> &S, \ dense_matrix<base_type> &S, \
dense_matrix<base_type> &Q) { \ dense_matrix<base_type> &Q) { \
GMMLAPACK_TRACE("geesx_interface"); \ GMMLAPACK_TRACE("geesx_interface"); \
int m = int(mat_nrows(A)), n = int(mat_ncols(A)); \ long m = long(mat_nrows(A)), n = long(mat_ncols(A)); \
GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \ GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \
char jobvs = 'V', sort = 'N', sense = 'N'; \ char jobvs = 'V', sort = 'N', sense = 'N'; \
bool select = false; \ bool select = false; \
int lwork = 8*n, sdim = 0, liwork = 1; \ long lwork = 8*n, sdim = 0, liwork = 1; \
std::vector<base_type> work(lwork), wr(n), wi(n); \ std::vector<base_type> work(lwork), wr(n), wi(n); \
std::vector<int> iwork(liwork); \ std::vector<long> iwork(liwork); \
std::vector<int> bwork(1); \ std::vector<long> bwork(1); \
resize(S, n, n); copy(A, S); \ resize(S, n, n); copy(A, S); \
resize(Q, n, n); \ resize(Q, n, n); \
base_type rconde(0), rcondv(0); \ base_type rconde(0), rcondv(0); \
int info = -1; \ long info(0); \
lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \ lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \
&sdim, &wr[0], &wi[0], &Q(0,0), &n, &rconde, &rcondv, \ &sdim, &wr[0], &wi[0], &Q(0,0), &n, &rconde, &rcondv, \
&work[0], &lwork, &iwork[0], &liwork, &bwork[0], &info);\ &work[0], &lwork, &iwork[0], &liwork, &bwork[0], &info);\
GMM_ASSERT1(!info, "SCHUR algorithm failed"); \ GMM_ASSERT1(!info, "SCHUR algorithm failed"); \
} }
# define geesx_interface2(lapack_name, base_type) inline \ # define geesx_interface2(lapack_name, base_type) inline \
@ -361,18 +366,18 @@ namespace gmm {
dense_matrix<base_type> &S, \ dense_matrix<base_type> &S, \
dense_matrix<base_type> &Q) { \ dense_matrix<base_type> &Q) { \
GMMLAPACK_TRACE("geesx_interface"); \ GMMLAPACK_TRACE("geesx_interface"); \
int m = int(mat_nrows(A)), n = int(mat_ncols(A)); \ long m = long(mat_nrows(A)), n = long(mat_ncols(A)); \
GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \ GMM_ASSERT1(m == n, "Schur decomposition requires square matrix"); \
char jobvs = 'V', sort = 'N', sense = 'N'; \ char jobvs = 'V', sort = 'N', sense = 'N'; \
bool select = false; \ bool select = false; \
int lwork = 8*n, sdim = 0; \ long lwork = 8*n, sdim = 0; \
std::vector<base_type::value_type> rwork(lwork); \ std::vector<base_type::value_type> rwork(lwork); \
std::vector<base_type> work(lwork), w(n); \ std::vector<base_type> work(lwork), w(n); \
std::vector<int> bwork(1); \ std::vector<long> bwork(1); \
resize(S, n, n); copy(A, S); \ resize(S, n, n); copy(A, S); \
resize(Q, n, n); \ resize(Q, n, n); \
base_type rconde(0), rcondv(0); \ base_type rconde(0), rcondv(0); \
int info = -1; \ long info(0); \
lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \ lapack_name(&jobvs, &sort, &select, &sense, &n, &S(0,0), &n, \
&sdim, &w[0], &Q(0,0), &n, &rconde, &rcondv, \ &sdim, &w[0], &Q(0,0), &n, &rconde, &rcondv, \
&work[0], &lwork, &rwork[0], &bwork[0], &info); \ &work[0], &lwork, &rwork[0], &bwork[0], &info); \
@ -391,10 +396,10 @@ namespace gmm {
} }
/* ********************************************************************* */ /* ********************************************************************** */
/* Interface to SVD. Does not correspond to a Gmm++ functionnality. */ /* Interface to SVD. Does not correspond to a Gmm++ functionnality. */
/* Author : Sebastian Nowozin <sebastian.nowozin@tuebingen.mpg.de> */ /* Author : Sebastian Nowozin <sebastian.nowozin@tuebingen.mpg.de> */
/* ********************************************************************* */ /* ********************************************************************** */
# define gesvd_interface(lapack_name, base_type) inline \ # define gesvd_interface(lapack_name, base_type) inline \
void svd(dense_matrix<base_type> &X, \ void svd(dense_matrix<base_type> &X, \
@ -402,15 +407,15 @@ namespace gmm {
dense_matrix<base_type> &Vtransposed, \ dense_matrix<base_type> &Vtransposed, \
std::vector<base_type> &sigma) { \ std::vector<base_type> &sigma) { \
GMMLAPACK_TRACE("gesvd_interface"); \ GMMLAPACK_TRACE("gesvd_interface"); \
int m = int(mat_nrows(X)), n = int(mat_ncols(X)); \ long m = long(mat_nrows(X)), n = long(mat_ncols(X)); \
int mn_min = m < n ? m : n; \ long mn_min = m < n ? m : n; \
sigma.resize(mn_min); \ sigma.resize(mn_min); \
std::vector<base_type> work(15 * mn_min); \ std::vector<base_type> work(15 * mn_min); \
int lwork = int(work.size()); \ long lwork = long(work.size()); \
resize(U, m, m); \ resize(U, m, m); \
resize(Vtransposed, n, n); \ resize(Vtransposed, n, n); \
char job = 'A'; \ char job = 'A'; \
int info = -1; \ long info(0); \
lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \ lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \
&m, &Vtransposed(0,0), &n, &work[0], &lwork, &info); \ &m, &Vtransposed(0,0), &n, &work[0], &lwork, &info); \
} }
@ -421,16 +426,16 @@ namespace gmm {
dense_matrix<base_type> &Vtransposed, \ dense_matrix<base_type> &Vtransposed, \
std::vector<base_type2> &sigma) { \ std::vector<base_type2> &sigma) { \
GMMLAPACK_TRACE("gesvd_interface"); \ GMMLAPACK_TRACE("gesvd_interface"); \
int m = int(mat_nrows(X)), n = int(mat_ncols(X)); \ long m = long(mat_nrows(X)), n = long(mat_ncols(X)); \
int mn_min = m < n ? m : n; \ long mn_min = m < n ? m : n; \
sigma.resize(mn_min); \ sigma.resize(mn_min); \
std::vector<base_type> work(15 * mn_min); \ std::vector<base_type> work(15 * mn_min); \
std::vector<base_type2> rwork(5 * mn_min); \ std::vector<base_type2> rwork(5 * mn_min); \
int lwork = int(work.size()); \ long lwork = long(work.size()); \
resize(U, m, m); \ resize(U, m, m); \
resize(Vtransposed, n, n); \ resize(Vtransposed, n, n); \
char job = 'A'; \ char job = 'A'; \
int info = -1; \ long info(0); \
lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \ lapack_name(&job, &job, &m, &n, &X(0,0), &m, &sigma[0], &U(0,0), \
&m, &Vtransposed(0,0), &n, &work[0], &lwork, \ &m, &Vtransposed(0,0), &n, &work[0], &lwork, \
&rwork[0], &info); \ &rwork[0], &info); \

63
gmm/gmm_opt.h
View File

@ -37,6 +37,8 @@
#ifndef GMM_OPT_H__ #ifndef GMM_OPT_H__
#define GMM_OPT_H__ #define GMM_OPT_H__
#include <gmm/gmm_dense_lu.h>
namespace gmm { namespace gmm {
/* ********************************************************************* */ /* ********************************************************************* */
@ -58,7 +60,7 @@ namespace gmm {
default : default :
{ {
dense_matrix<T> B(mat_nrows(A), mat_ncols(A)); dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
std::vector<size_type> ipvt(mat_nrows(A)); lapack_ipvt ipvt(mat_nrows(A));
gmm::copy(A, B); gmm::copy(A, B);
lu_factor(B, ipvt); lu_factor(B, ipvt);
return lu_det(B, ipvt); return lu_det(B, ipvt);
@ -69,13 +71,13 @@ namespace gmm {
} }
template <typename T> T lu_inverse(const dense_matrix<T> &A_, bool doassert = true) { template <typename T> T lu_inverse(const dense_matrix<T> &A_,
bool doassert = true) {
dense_matrix<T>& A = const_cast<dense_matrix<T> &>(A_); dense_matrix<T>& A = const_cast<dense_matrix<T> &>(A_);
size_type N = mat_nrows(A); size_type N = mat_nrows(A);
T det(1); T det(1);
if (N) { if (N) {
T *p = &(A(0,0)); T *p = &(A(0,0));
if (N <= 2) {
switch (N) { switch (N) {
case 1 : { case 1 : {
det = *p; det = *p;
@ -90,34 +92,35 @@ namespace gmm {
std::swap(*p, *(p+3)); std::swap(*p, *(p+3));
*p++ /= det; *p++ /= -det; *p++ /= -det; *p++ /= det; *p++ /= det; *p++ /= -det; *p++ /= -det; *p++ /= det;
} break; } break;
// case 3 : { // not stable for nearly singular matrices case 3 : { // not stable for nearly singular matrices
// T a, b, c, d, e, f, g, h, i; T a, b, c, d, e, f, g, h, i;
// a = (*(p+4)) * (*(p+8)) - (*(p+5)) * (*(p+7)); a = (*(p+4)) * (*(p+8)) - (*(p+5)) * (*(p+7));
// b = - (*(p+1)) * (*(p+8)) + (*(p+2)) * (*(p+7)); b = - (*(p+1)) * (*(p+8)) + (*(p+2)) * (*(p+7));
// c = (*(p+1)) * (*(p+5)) - (*(p+2)) * (*(p+4)); c = (*(p+1)) * (*(p+5)) - (*(p+2)) * (*(p+4));
// d = - (*(p+3)) * (*(p+8)) + (*(p+5)) * (*(p+6)); d = - (*(p+3)) * (*(p+8)) + (*(p+5)) * (*(p+6));
// e = (*(p+0)) * (*(p+8)) - (*(p+2)) * (*(p+6)); e = (*(p+0)) * (*(p+8)) - (*(p+2)) * (*(p+6));
// f = - (*(p+0)) * (*(p+5)) + (*(p+2)) * (*(p+3)); f = - (*(p+0)) * (*(p+5)) + (*(p+2)) * (*(p+3));
// g = (*(p+3)) * (*(p+7)) - (*(p+4)) * (*(p+6)); g = (*(p+3)) * (*(p+7)) - (*(p+4)) * (*(p+6));
// h = - (*(p+0)) * (*(p+7)) + (*(p+1)) * (*(p+6)); h = - (*(p+0)) * (*(p+7)) + (*(p+1)) * (*(p+6));
// i = (*(p+0)) * (*(p+4)) - (*(p+1)) * (*(p+3)); i = (*(p+0)) * (*(p+4)) - (*(p+1)) * (*(p+3));
// det = (*p) * a + (*(p+1)) * d + (*(p+2)) * g; det = (*p) * a + (*(p+1)) * d + (*(p+2)) * g;
// GMM_ASSERT1(det!=T(0), "non invertible matrix"); if (std::abs(det) > 1e-5) {
// *p++ = a / det; *p++ = b / det; *p++ = c / det; *p++ = a / det; *p++ = b / det; *p++ = c / det;
// *p++ = d / det; *p++ = e / det; *p++ = f / det; *p++ = d / det; *p++ = e / det; *p++ = f / det;
// *p++ = g / det; *p++ = h / det; *p++ = i / det; *p++ = g / det; *p++ = h / det; *p++ = i / det;
// } break; break;
}
}
default : {
dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
lapack_ipvt ipvt(mat_nrows(A));
gmm::copy(A, B);
size_type info = lu_factor(B, ipvt);
GMM_ASSERT1(!info, "non invertible matrix");
lu_inverse(B, ipvt, A);
return lu_det(B, ipvt);
}
} }
}
else {
dense_matrix<T> B(mat_nrows(A), mat_ncols(A));
std::vector<int> ipvt(mat_nrows(A));
gmm::copy(A, B);
size_type info = lu_factor(B, ipvt);
GMM_ASSERT1(!info, "non invertible matrix");
lu_inverse(B, ipvt, A);
return lu_det(B, ipvt);
}
} }
return det; return det;
} }

15
gmm/gmm_std.h
View File

@ -38,8 +38,6 @@
#ifndef GMM_STD_H__ #ifndef GMM_STD_H__
#define GMM_STD_H__ #define GMM_STD_H__
//#include <getfem/getfem_arch_config.h>
#ifndef __USE_STD_IOSTREAM #ifndef __USE_STD_IOSTREAM
# define __USE_STD_IOSTREAM # define __USE_STD_IOSTREAM
#endif #endif
@ -83,13 +81,6 @@ inline void GMM_NOPERATION_(int) { }
/* Compilers detection. */ /* Compilers detection. */
/* ********************************************************************** */ /* ********************************************************************** */
/* for sun CC 5.0 ...
#if defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500
# include <stdcomp.h>
# undef _RWSTD_NO_CLASS_PARTIAL_SPEC
# undef _RWSTD_NO_NAMESPACE
#endif
*/
/* for VISUAL C++ ... /* for VISUAL C++ ...
#if defined(_MSC_VER) // && !defined(__MWERKS__) #if defined(_MSC_VER) // && !defined(__MWERKS__)
#define _GETFEM_MSVCPP_ _MSC_VER #define _GETFEM_MSVCPP_ _MSC_VER
@ -133,6 +124,8 @@ inline void GMM_NOPERATION_(int) { }
#include <array> #include <array>
#include <locale.h> #include <locale.h>
#include <gmm/gmm_arch_config.h>
namespace std { namespace std {
#if defined(__GNUC__) && (__cplusplus <= 201103L) #if defined(__GNUC__) && (__cplusplus <= 201103L)
template<typename _Tp> template<typename _Tp>
@ -181,7 +174,7 @@ namespace std {
#ifdef GETFEM_HAVE_OPENMP #ifdef GMM_HAVE_OPENMP
#include <omp.h> #include <omp.h>
/**number of OpenMP threads*/ /**number of OpenMP threads*/
@ -222,7 +215,7 @@ namespace gmm {
} }
}; };
#else #else
/**this is the above solutions for linux, but I still needs to be tested.*/ /**this is the above solutions for linux, but it still needs to be tested.*/
//class standard_locale { //class standard_locale {
// locale_t oldloc; // locale_t oldloc;
// locale_t temploc; // locale_t temploc;

2
hecl

@ -1 +1 @@
Subproject commit 62e5d91fe64ecbdd7417c126b0134f266b900c4f Subproject commit 012d0a4514fb7b0716ca873b888db651b80f770d

2
hecl-gui

@ -1 +1 @@
Subproject commit 670633992e5f3ebc63b4b8953536ff97082bb56f Subproject commit f5ab863cf18a0024237b8c5274a17bd5631f21b6

2
kabufuda

@ -1 +1 @@
Subproject commit e84546be2dcf64c628971cdda601c35cc07b14d1 Subproject commit bd1c3e99f2690f2b7e9543a053661f17dacfd757

2
nod

@ -1 +1 @@
Subproject commit e964a013fe26ff097c4b69b9f607b015505dee0e Subproject commit f87b286ff3c1f46b4294f15fdc6e849cc4f4d296

2
specter

@ -1 +1 @@
Subproject commit e7cf4931c734caceeae07f013ba049d5ec887396 Subproject commit 472852162e34e55a1087ffbd743ccf1885fdc16e