mirror of https://github.com/AxioDL/metaforce.git
308 lines
8.0 KiB
C++
308 lines
8.0 KiB
C++
#if _WIN32
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#define WIN_PAUSE 1
|
|
#include <objbase.h>
|
|
#endif
|
|
|
|
#include <clocale>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <signal.h>
|
|
#include <regex>
|
|
#include <list>
|
|
#include "hecl/Database.hpp"
|
|
#include "../blender/BlenderConnection.hpp"
|
|
#include "logvisor/logvisor.hpp"
|
|
|
|
logvisor::Module LogModule("HECLDriver");
|
|
|
|
#include "ToolBase.hpp"
|
|
#include "ToolInit.hpp"
|
|
#include "ToolSpec.hpp"
|
|
#include "ToolExtract.hpp"
|
|
#include "ToolAdd.hpp"
|
|
#include "ToolRemove.hpp"
|
|
#include "ToolGroup.hpp"
|
|
#include "ToolCook.hpp"
|
|
#include "ToolClean.hpp"
|
|
#include "ToolPackage.hpp"
|
|
#include "ToolHelp.hpp"
|
|
|
|
/* Static reference to dataspec additions
|
|
* (used by MSVC to definitively link DataSpecs) */
|
|
#include "../DataSpecRegistry.hpp"
|
|
|
|
bool XTERM_COLOR = false;
|
|
|
|
|
|
/*
|
|
#define HECL_GIT 1234567
|
|
#define HECL_GIT_S "1234567"
|
|
#define HECL_BRANCH master
|
|
#define HECL_BRANCH_S "master"
|
|
*/
|
|
|
|
/* Main usage message */
|
|
static void printHelp(const hecl::SystemChar* pname)
|
|
{
|
|
if (XTERM_COLOR)
|
|
hecl::Printf(_S("" BOLD "HECL" NORMAL ""));
|
|
else
|
|
hecl::Printf(_S("HECL"));
|
|
#if HECL_GIT
|
|
hecl::Printf(_S(" Commit " HECL_GIT_S " " HECL_BRANCH_S "\nUsage: %s init|add|remove|group|cook|clean|package|help\n"), pname);
|
|
#elif HECL_VER
|
|
hecl::Printf(_S(" Version " HECL_VER_S "\nUsage: %s init|add|remove|group|cook|clean|package|help\n"), pname);
|
|
#else
|
|
hecl::Printf(_S("\nUsage: %s init|add|remove|group|cook|clean|package|help\n"), pname);
|
|
#endif
|
|
}
|
|
|
|
/* Regex patterns */
|
|
static const hecl::SystemRegex regOPEN(_S("-o([^\"]*|\\S*)"), std::regex::ECMAScript|std::regex::optimize);
|
|
|
|
/* SIGINT will gracefully close blender connections and delete blends in progress */
|
|
static void SIGINTHandler(int sig)
|
|
{
|
|
hecl::BlenderConnection::Shutdown();
|
|
exit(1);
|
|
}
|
|
|
|
/* SIGWINCH should do nothing */
|
|
static void SIGWINCHHandler(int sig) {}
|
|
|
|
static logvisor::Module AthenaLog("Athena");
|
|
static void AthenaExc(athena::error::Level level, const char* file,
|
|
const char*, int line, const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
AthenaLog.reportSource(logvisor::Level(level), file, line, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
#if HECL_UCS2
|
|
int wmain(int argc, const wchar_t** argv)
|
|
#else
|
|
int main(int argc, const char** argv)
|
|
#endif
|
|
{
|
|
#if _WIN32
|
|
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
|
|
#else
|
|
std::setlocale(LC_ALL, "en-US.UTF-8");
|
|
#endif
|
|
|
|
/* Xterm check */
|
|
#if _WIN32
|
|
const char* conemuANSI = getenv("ConEmuANSI");
|
|
if (conemuANSI && !strcmp(conemuANSI, "ON"))
|
|
XTERM_COLOR = true;
|
|
#else
|
|
const char* term = getenv("TERM");
|
|
if (term && !strncmp(term, "xterm", 5))
|
|
XTERM_COLOR = true;
|
|
signal(SIGWINCH, SIGWINCHHandler);
|
|
#endif
|
|
signal(SIGINT, SIGINTHandler);
|
|
|
|
logvisor::RegisterConsoleLogger();
|
|
atSetExceptionHandler(AthenaExc);
|
|
|
|
/* Basic usage check */
|
|
if (argc == 1)
|
|
{
|
|
printHelp(argv[0]);
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
return 0;
|
|
}
|
|
else if (argc == 0)
|
|
{
|
|
printHelp(_S("hecl"));
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* Prepare DataSpecs */
|
|
HECLRegisterDataSpecs();
|
|
|
|
/* Assemble common tool pass info */
|
|
ToolPassInfo info;
|
|
info.pname = argv[0];
|
|
hecl::SystemChar cwdbuf[1024];
|
|
if (hecl::Getcwd(cwdbuf, 1024))
|
|
{
|
|
info.cwd = cwdbuf;
|
|
if (info.cwd.size() && info.cwd.back() != _S('/') && info.cwd.back() != _S('\\'))
|
|
#if _WIN32
|
|
info.cwd += _S('\\');
|
|
#else
|
|
info.cwd += _S('/');
|
|
#endif
|
|
}
|
|
|
|
/* Concatenate args */
|
|
std::vector<hecl::SystemString> args;
|
|
args.reserve(argc-2);
|
|
for (int i=2 ; i<argc ; ++i)
|
|
args.push_back(hecl::SystemString(argv[i]));
|
|
|
|
if (!args.empty())
|
|
{
|
|
/* Extract output argument */
|
|
for (auto it = args.cbegin() ; it != args.cend() ;)
|
|
{
|
|
const hecl::SystemString& arg = *it;
|
|
hecl::SystemRegexMatch oMatch;
|
|
if (std::regex_search(arg, oMatch, regOPEN))
|
|
{
|
|
const hecl::SystemString& token = oMatch[1].str();
|
|
if (token.size())
|
|
{
|
|
if (info.output.empty())
|
|
info.output = oMatch[1].str();
|
|
it = args.erase(it);
|
|
}
|
|
else
|
|
{
|
|
it = args.erase(it);
|
|
if (it == args.end())
|
|
break;
|
|
if (info.output.empty())
|
|
info.output = *it;
|
|
it = args.erase(it);
|
|
}
|
|
continue;
|
|
}
|
|
++it;
|
|
}
|
|
|
|
/* Iterate flags */
|
|
for (auto it = args.cbegin() ; it != args.cend() ;)
|
|
{
|
|
const hecl::SystemString& arg = *it;
|
|
if (arg.size() < 2 || arg[0] != _S('-') || arg[1] == _S('-'))
|
|
{
|
|
++it;
|
|
continue;
|
|
}
|
|
|
|
for (auto chit = arg.cbegin() + 1 ; chit != arg.cend() ; ++chit)
|
|
{
|
|
if (*chit == _S('v'))
|
|
++info.verbosityLevel;
|
|
else if (*chit == _S('f'))
|
|
info.force = true;
|
|
else
|
|
info.flags.push_back(*chit);
|
|
}
|
|
|
|
it = args.erase(it);
|
|
}
|
|
|
|
/* Gather remaining args */
|
|
info.args.reserve(args.size());
|
|
for (const hecl::SystemString& arg : args)
|
|
info.args.push_back(arg);
|
|
}
|
|
|
|
/* Attempt to find hecl project */
|
|
hecl::ProjectRootPath rootPath = hecl::SearchForProject(info.cwd);
|
|
std::unique_ptr<hecl::Database::Project> project;
|
|
if (rootPath)
|
|
{
|
|
size_t ErrorRef = logvisor::ErrorCount;
|
|
hecl::Database::Project* newProj = new hecl::Database::Project(rootPath);
|
|
if (logvisor::ErrorCount > ErrorRef)
|
|
{
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
delete newProj;
|
|
return -1;
|
|
}
|
|
project.reset(newProj);
|
|
info.project = newProj;
|
|
}
|
|
|
|
/* Construct selected tool */
|
|
hecl::SystemString toolName(argv[1]);
|
|
hecl::ToLower(toolName);
|
|
std::unique_ptr<ToolBase> tool;
|
|
|
|
size_t ErrorRef = logvisor::ErrorCount;
|
|
if (toolName == _S("init"))
|
|
tool.reset(new ToolInit(info));
|
|
else if (toolName == _S("spec"))
|
|
tool.reset(new ToolSpec(info));
|
|
else if (toolName == _S("extract"))
|
|
tool.reset(new ToolExtract(info));
|
|
else if (toolName == _S("add"))
|
|
tool.reset(new ToolAdd(info));
|
|
else if (toolName == _S("remove") || toolName == _S("rm"))
|
|
tool.reset(new ToolRemove(info));
|
|
else if (toolName == _S("group"))
|
|
tool.reset(new ToolGroup(info));
|
|
else if (toolName == _S("cook"))
|
|
tool.reset(new ToolCook(info));
|
|
else if (toolName == _S("clean"))
|
|
tool.reset(new ToolClean(info));
|
|
else if (toolName == _S("package") || toolName == _S("pack"))
|
|
tool.reset(new ToolPackage(info));
|
|
else if (toolName == _S("help"))
|
|
tool.reset(new ToolHelp(info));
|
|
else
|
|
{
|
|
FILE* fp = hecl::Fopen(argv[1], _S("rb"));
|
|
if (!fp)
|
|
LogModule.report(logvisor::Error, _S("unrecognized tool '%s'"), toolName.c_str());
|
|
else
|
|
{
|
|
/* Shortcut-case: implicit extract */
|
|
fclose(fp);
|
|
info.args.insert(info.args.begin(), argv[1]);
|
|
tool.reset(new ToolExtract(info));
|
|
}
|
|
}
|
|
|
|
if (logvisor::ErrorCount > ErrorRef)
|
|
{
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
return -1;
|
|
}
|
|
|
|
if (info.verbosityLevel)
|
|
LogModule.report(logvisor::Info, _S("Constructed tool '%s' %d\n"),
|
|
tool->toolName().c_str(), info.verbosityLevel);
|
|
|
|
/* Run tool */
|
|
ErrorRef = logvisor::ErrorCount;
|
|
int retval = tool->run();
|
|
if (logvisor::ErrorCount > ErrorRef)
|
|
{
|
|
hecl::BlenderConnection::Shutdown();
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
return -1;
|
|
}
|
|
|
|
hecl::BlenderConnection::Shutdown();
|
|
#if WIN_PAUSE
|
|
system("PAUSE");
|
|
#endif
|
|
return retval;
|
|
}
|
|
|
|
|