2015-11-27 22:21:19 +00:00
|
|
|
#if _WIN32
|
|
|
|
#define _CRT_RAND_S
|
|
|
|
#include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
|
2015-07-01 23:50:39 +00:00
|
|
|
#include "SpecBase.hpp"
|
2015-08-04 21:35:41 +00:00
|
|
|
#include "Blender/BlenderSupport.hpp"
|
2016-09-18 23:47:48 +00:00
|
|
|
#include "hecl/Blender/BlenderConnection.hpp"
|
2015-11-10 02:07:15 +00:00
|
|
|
#include "DNACommon/DNACommon.hpp"
|
2016-03-27 20:43:04 +00:00
|
|
|
#include "DNACommon/TXTR.hpp"
|
2015-07-01 23:50:39 +00:00
|
|
|
|
2015-11-22 05:16:40 +00:00
|
|
|
#include <time.h>
|
|
|
|
|
2016-02-13 09:02:47 +00:00
|
|
|
namespace DataSpec
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
|
|
|
|
2016-03-04 23:04:53 +00:00
|
|
|
static logvisor::Module Log("urde::SpecBase");
|
2015-08-04 21:35:41 +00:00
|
|
|
|
2016-03-04 23:04:53 +00:00
|
|
|
static const hecl::SystemChar* MomErr[] =
|
2015-11-22 05:16:40 +00:00
|
|
|
{
|
|
|
|
_S("Your metroid is in another castle"),
|
|
|
|
_S("HECL is experiencing a PTSD attack"),
|
|
|
|
_S("Unable to freeze metroids"),
|
|
|
|
_S("Ridley ate your homework"),
|
2017-02-05 06:20:31 +00:00
|
|
|
_S("Expected 0 maternal symbolisms, found 2147483647"),
|
2015-11-22 05:16:40 +00:00
|
|
|
_S("Contradictive narratives unsupported"),
|
|
|
|
_S("Wiimote profile \"NES + Zapper\" not recognized"),
|
|
|
|
_S("Unable to find Waldo"),
|
2016-02-20 08:53:06 +00:00
|
|
|
_S("Expected Ridley, found furby"),
|
|
|
|
_S("Adam has not authorized this, please do not bug the developers"),
|
2016-03-21 05:02:56 +00:00
|
|
|
_S("Lady returned objection"),
|
|
|
|
_S("Unterminated plot thread 'Deleter' detected")
|
2015-11-22 05:16:40 +00:00
|
|
|
};
|
|
|
|
|
2016-03-21 05:02:56 +00:00
|
|
|
constexpr uint32_t MomErrCount = std::extent<decltype(MomErr)>::value;
|
2016-03-28 22:39:56 +00:00
|
|
|
SpecBase::SpecBase(const hecl::Database::DataSpecEntry* specEntry, hecl::Database::Project& project, bool pc)
|
|
|
|
: hecl::Database::IDataSpec(specEntry), m_project(project), m_pc(pc),
|
2016-04-02 08:42:00 +00:00
|
|
|
m_masterShader(project.getProjectWorkingPath(), ".hecl/RetroMasterShader.blend")
|
|
|
|
{
|
2016-07-07 04:23:36 +00:00
|
|
|
DataSpec::UniqueIDBridge::setThreadProject(m_project);
|
2016-04-02 08:42:00 +00:00
|
|
|
}
|
2015-11-10 02:07:15 +00:00
|
|
|
|
2016-04-15 03:26:01 +00:00
|
|
|
static const hecl::SystemString regNONE = _S("");
|
|
|
|
static const hecl::SystemString regE = _S("NTSC");
|
|
|
|
static const hecl::SystemString regJ = _S("NTSC-J");
|
|
|
|
static const hecl::SystemString regP = _S("PAL");
|
|
|
|
|
2016-07-07 04:23:36 +00:00
|
|
|
void SpecBase::setThreadProject()
|
|
|
|
{
|
|
|
|
UniqueIDBridge::setThreadProject(m_project);
|
|
|
|
}
|
|
|
|
|
2015-10-04 05:08:56 +00:00
|
|
|
bool SpecBase::canExtract(const ExtractPassInfo& info, std::vector<ExtractReport>& reps)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2016-03-04 23:04:53 +00:00
|
|
|
m_disc = nod::OpenDiscFromImage(info.srcpath.c_str(), m_isWii);
|
2015-07-16 01:57:34 +00:00
|
|
|
if (!m_disc)
|
2015-07-02 20:41:40 +00:00
|
|
|
return false;
|
2016-01-20 03:18:30 +00:00
|
|
|
const char* gameID = m_disc->getHeader().m_gameID;
|
2015-07-02 20:41:40 +00:00
|
|
|
|
2015-11-22 05:16:40 +00:00
|
|
|
if (!memcmp(gameID, "R3O", 3))
|
|
|
|
{
|
|
|
|
unsigned int t = time(nullptr);
|
2015-11-27 22:21:19 +00:00
|
|
|
#if _WIN32
|
|
|
|
rand_s(&t);
|
2016-02-20 08:53:06 +00:00
|
|
|
int r = t % MomErrCount;
|
2015-11-27 22:21:19 +00:00
|
|
|
#else
|
2016-02-20 08:53:06 +00:00
|
|
|
int r = rand_r(&t) % MomErrCount;
|
2015-11-27 22:21:19 +00:00
|
|
|
#endif
|
2016-03-04 23:04:53 +00:00
|
|
|
Log.report(logvisor::Fatal, MomErr[r]);
|
2015-11-22 05:16:40 +00:00
|
|
|
}
|
|
|
|
|
2015-07-18 04:33:38 +00:00
|
|
|
m_standalone = true;
|
|
|
|
if (m_isWii && !memcmp(gameID, "R3M", 3))
|
|
|
|
m_standalone = false;
|
2015-07-01 23:50:39 +00:00
|
|
|
|
2015-07-18 04:33:38 +00:00
|
|
|
if (m_standalone && !checkStandaloneID(gameID))
|
2015-07-10 05:28:08 +00:00
|
|
|
return false;
|
|
|
|
|
2016-01-20 03:18:30 +00:00
|
|
|
char region = m_disc->getHeader().m_gameID[3];
|
2016-03-04 23:04:53 +00:00
|
|
|
const hecl::SystemString* regstr = ®NONE;
|
2015-07-12 18:07:58 +00:00
|
|
|
switch (region)
|
|
|
|
{
|
|
|
|
case 'E':
|
|
|
|
regstr = ®E;
|
|
|
|
break;
|
|
|
|
case 'J':
|
|
|
|
regstr = ®J;
|
|
|
|
break;
|
|
|
|
case 'P':
|
|
|
|
regstr = ®P;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-07-18 04:33:38 +00:00
|
|
|
if (m_standalone)
|
2015-08-05 21:46:07 +00:00
|
|
|
return checkFromStandaloneDisc(*m_disc, *regstr, info.extractArgs, reps);
|
2015-07-10 05:28:08 +00:00
|
|
|
else
|
2015-08-05 21:46:07 +00:00
|
|
|
return checkFromTrilogyDisc(*m_disc, *regstr, info.extractArgs, reps);
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2015-09-30 06:23:40 +00:00
|
|
|
void SpecBase::doExtract(const ExtractPassInfo& info, FProgress progress)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2016-04-10 04:49:02 +00:00
|
|
|
DataSpec::g_curSpec.reset(this);
|
2015-08-05 21:46:07 +00:00
|
|
|
if (!Blender::BuildMasterShader(m_masterShader))
|
2016-03-04 23:04:53 +00:00
|
|
|
Log.report(logvisor::Fatal, "Unable to build master shader blend");
|
2015-07-18 04:33:38 +00:00
|
|
|
if (m_isWii)
|
|
|
|
{
|
2016-03-01 20:29:18 +00:00
|
|
|
/* Extract root files for repacking later */
|
2016-03-05 00:03:41 +00:00
|
|
|
hecl::ProjectPath outDir(m_project.getProjectWorkingPath(), _S("out"));
|
2017-01-17 01:23:19 +00:00
|
|
|
outDir.makeDirChain(true);
|
2016-03-04 23:04:53 +00:00
|
|
|
nod::ExtractionContext ctx = {true, info.force, nullptr};
|
2015-09-29 03:49:31 +00:00
|
|
|
|
2015-07-18 04:33:38 +00:00
|
|
|
if (!m_standalone)
|
|
|
|
{
|
2015-09-02 22:00:40 +00:00
|
|
|
progress(_S("Trilogy Files"), _S(""), 1, 0.0);
|
2016-03-04 23:04:53 +00:00
|
|
|
nod::Partition* data = m_disc->getDataPartition();
|
|
|
|
const nod::Node& root = data->getFSTRoot();
|
|
|
|
for (const nod::Node& child : root)
|
|
|
|
if (child.getKind() == nod::Node::Kind::File)
|
2016-03-01 20:29:18 +00:00
|
|
|
child.extractToDirectory(outDir.getAbsolutePath(), ctx);
|
2015-09-02 22:00:40 +00:00
|
|
|
progress(_S("Trilogy Files"), _S(""), 1, 1.0);
|
2015-07-18 04:33:38 +00:00
|
|
|
}
|
|
|
|
}
|
2015-08-05 21:46:07 +00:00
|
|
|
extractFromDisc(*m_disc, info.force, progress);
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2016-09-18 23:47:48 +00:00
|
|
|
static bool IsPathAudioGroup(const hecl::ProjectPath& path)
|
|
|
|
{
|
|
|
|
if (path.getPathType() != hecl::ProjectPath::Type::Glob ||
|
|
|
|
!path.getWithExtension(_S(".pool"), true).isFile() ||
|
|
|
|
!path.getWithExtension(_S(".proj"), true).isFile() ||
|
|
|
|
!path.getWithExtension(_S(".sdir"), true).isFile() ||
|
|
|
|
!path.getWithExtension(_S(".samp"), true).isFile())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool IsPathSong(const hecl::ProjectPath& path)
|
|
|
|
{
|
|
|
|
if (path.getPathType() != hecl::ProjectPath::Type::Glob ||
|
|
|
|
!path.getWithExtension(_S(".mid"), true).isFile() ||
|
|
|
|
!path.getWithExtension(_S(".yaml"), true).isFile())
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-03-28 22:39:56 +00:00
|
|
|
bool SpecBase::canCook(const hecl::ProjectPath& path, hecl::BlenderToken& btok)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2015-10-04 05:08:56 +00:00
|
|
|
if (!checkPathPrefix(path))
|
|
|
|
return false;
|
2016-09-23 18:56:42 +00:00
|
|
|
|
|
|
|
hecl::ProjectPath asBlend;
|
|
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Glob)
|
|
|
|
asBlend = path.getWithExtension(_S(".blend"), true);
|
|
|
|
else
|
|
|
|
asBlend = path;
|
|
|
|
|
|
|
|
if (hecl::IsPathBlend(asBlend))
|
2015-10-01 00:40:21 +00:00
|
|
|
{
|
2016-03-28 22:39:56 +00:00
|
|
|
hecl::BlenderConnection& conn = btok.getBlenderConnection();
|
2016-09-23 18:56:42 +00:00
|
|
|
if (!conn.openBlend(asBlend))
|
2015-10-01 00:40:21 +00:00
|
|
|
return false;
|
2016-03-04 23:04:53 +00:00
|
|
|
if (conn.getBlendType() != hecl::BlenderConnection::BlendType::None)
|
2015-10-01 00:40:21 +00:00
|
|
|
return true;
|
|
|
|
}
|
2016-03-04 23:04:53 +00:00
|
|
|
else if (hecl::IsPathPNG(path))
|
2015-10-01 00:40:21 +00:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2016-03-04 23:04:53 +00:00
|
|
|
else if (hecl::IsPathYAML(path))
|
2015-10-01 00:40:21 +00:00
|
|
|
{
|
2016-08-22 03:47:48 +00:00
|
|
|
athena::io::FileReader reader(path.getAbsolutePath());
|
|
|
|
bool retval = validateYAMLDNAType(reader);
|
2015-10-01 00:40:21 +00:00
|
|
|
return retval;
|
|
|
|
}
|
2016-09-18 23:47:48 +00:00
|
|
|
else if (IsPathAudioGroup(path))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else if (IsPathSong(path))
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2015-07-22 19:05:18 +00:00
|
|
|
return false;
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2016-03-27 20:43:04 +00:00
|
|
|
const hecl::Database::DataSpecEntry* SpecBase::overrideDataSpec(const hecl::ProjectPath& path,
|
2016-03-28 22:39:56 +00:00
|
|
|
const hecl::Database::DataSpecEntry* oldEntry,
|
2016-10-01 23:20:20 +00:00
|
|
|
hecl::BlenderToken& btok) const
|
2016-03-27 20:43:04 +00:00
|
|
|
{
|
|
|
|
if (!checkPathPrefix(path))
|
|
|
|
return nullptr;
|
2016-09-23 18:56:42 +00:00
|
|
|
|
|
|
|
hecl::ProjectPath asBlend;
|
|
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Glob)
|
|
|
|
asBlend = path.getWithExtension(_S(".blend"), true);
|
|
|
|
else
|
|
|
|
asBlend = path;
|
|
|
|
|
|
|
|
if (hecl::IsPathBlend(asBlend))
|
2016-03-27 20:43:04 +00:00
|
|
|
{
|
2016-09-04 22:47:48 +00:00
|
|
|
if (hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".CSKR")) ||
|
|
|
|
hecl::StringUtils::EndsWith(path.getAuxInfo(), _S(".ANIM")))
|
2016-08-31 23:31:12 +00:00
|
|
|
return oldEntry;
|
|
|
|
|
2016-03-28 22:39:56 +00:00
|
|
|
hecl::BlenderConnection& conn = btok.getBlenderConnection();
|
2016-09-23 18:56:42 +00:00
|
|
|
if (!conn.openBlend(asBlend))
|
2016-03-27 20:43:04 +00:00
|
|
|
{
|
|
|
|
Log.report(logvisor::Error, _S("unable to cook '%s'"),
|
|
|
|
path.getAbsolutePath().c_str());
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
hecl::BlenderConnection::BlendType type = conn.getBlendType();
|
|
|
|
if (type == hecl::BlenderConnection::BlendType::Mesh ||
|
|
|
|
type == hecl::BlenderConnection::BlendType::Area)
|
|
|
|
return oldEntry;
|
|
|
|
}
|
|
|
|
else if (hecl::IsPathPNG(path))
|
|
|
|
{
|
|
|
|
return oldEntry;
|
|
|
|
}
|
2017-01-17 01:23:19 +00:00
|
|
|
return &getOriginalSpec();
|
2016-03-27 20:43:04 +00:00
|
|
|
}
|
|
|
|
|
2016-03-04 23:04:53 +00:00
|
|
|
void SpecBase::doCook(const hecl::ProjectPath& path, const hecl::ProjectPath& cookedPath,
|
2016-03-28 22:39:56 +00:00
|
|
|
bool fast, hecl::BlenderToken& btok, FCookProgress progress)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2016-12-25 01:36:42 +00:00
|
|
|
cookedPath.makeDirChain(false);
|
2016-04-10 04:49:02 +00:00
|
|
|
DataSpec::g_curSpec.reset(this);
|
2016-09-23 18:56:42 +00:00
|
|
|
|
|
|
|
hecl::ProjectPath asBlend;
|
|
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Glob)
|
|
|
|
asBlend = path.getWithExtension(_S(".blend"), true);
|
|
|
|
else
|
|
|
|
asBlend = path;
|
|
|
|
|
|
|
|
if (hecl::IsPathBlend(asBlend))
|
2015-10-04 05:08:56 +00:00
|
|
|
{
|
2016-03-28 22:39:56 +00:00
|
|
|
hecl::BlenderConnection& conn = btok.getBlenderConnection();
|
2016-09-23 18:56:42 +00:00
|
|
|
if (!conn.openBlend(asBlend))
|
2015-10-04 05:08:56 +00:00
|
|
|
return;
|
2015-10-07 01:17:17 +00:00
|
|
|
switch (conn.getBlendType())
|
|
|
|
{
|
2016-03-04 23:04:53 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::Mesh:
|
2015-10-04 05:08:56 +00:00
|
|
|
{
|
2016-03-04 23:04:53 +00:00
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
2016-04-10 04:49:02 +00:00
|
|
|
cookMesh(cookedPath, path, ds, fast, btok, progress);
|
2015-10-07 01:17:17 +00:00
|
|
|
break;
|
2015-10-04 05:08:56 +00:00
|
|
|
}
|
2016-03-04 23:04:53 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::Actor:
|
2015-10-07 01:17:17 +00:00
|
|
|
{
|
2016-03-04 23:04:53 +00:00
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
2016-04-10 04:49:02 +00:00
|
|
|
cookActor(cookedPath, path, ds, fast, btok, progress);
|
2015-10-07 01:17:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2016-03-04 23:04:53 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::Area:
|
2015-10-07 01:17:17 +00:00
|
|
|
{
|
2016-03-04 23:04:53 +00:00
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
2016-04-10 04:49:02 +00:00
|
|
|
cookArea(cookedPath, path, ds, fast, btok, progress);
|
2015-10-07 01:17:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2016-09-30 22:43:19 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::World:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
cookWorld(cookedPath, path, ds, fast, btok, progress);
|
|
|
|
break;
|
|
|
|
}
|
2017-01-17 01:23:19 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::Frame:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
cookGuiFrame(cookedPath, path, ds, btok, progress);
|
|
|
|
break;
|
|
|
|
}
|
2017-03-20 05:09:53 +00:00
|
|
|
case hecl::BlenderConnection::BlendType::MapArea:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
cookMapArea(cookedPath, path, ds, btok, progress);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case hecl::BlenderConnection::BlendType::MapUniverse:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
cookMapUniverse(cookedPath, path, ds, btok, progress);
|
|
|
|
break;
|
|
|
|
}
|
2015-10-07 01:17:17 +00:00
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
2016-03-27 20:43:04 +00:00
|
|
|
else if (hecl::IsPathPNG(path))
|
|
|
|
{
|
|
|
|
if (m_pc)
|
|
|
|
TXTR::CookPC(path, cookedPath);
|
|
|
|
else
|
|
|
|
TXTR::Cook(path, cookedPath);
|
|
|
|
}
|
2016-03-04 23:04:53 +00:00
|
|
|
else if (hecl::IsPathYAML(path))
|
2015-10-07 01:17:17 +00:00
|
|
|
{
|
2016-08-22 03:47:48 +00:00
|
|
|
athena::io::FileReader reader(path.getAbsolutePath());
|
|
|
|
cookYAML(cookedPath, path, reader, progress);
|
2015-10-04 05:08:56 +00:00
|
|
|
}
|
2016-09-18 23:47:48 +00:00
|
|
|
else if (IsPathAudioGroup(path))
|
|
|
|
{
|
|
|
|
cookAudioGroup(cookedPath, path, progress);
|
|
|
|
}
|
|
|
|
else if (IsPathSong(path))
|
|
|
|
{
|
|
|
|
cookSong(cookedPath, path, progress);
|
|
|
|
}
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2016-10-02 22:41:36 +00:00
|
|
|
void SpecBase::flattenDependencies(const hecl::ProjectPath& path,
|
|
|
|
std::vector<hecl::ProjectPath>& pathsOut,
|
|
|
|
hecl::BlenderToken& btok)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2016-10-02 22:41:36 +00:00
|
|
|
DataSpec::g_curSpec.reset(this);
|
|
|
|
|
|
|
|
hecl::ProjectPath asBlend;
|
|
|
|
if (path.getPathType() == hecl::ProjectPath::Type::Glob)
|
|
|
|
asBlend = path.getWithExtension(_S(".blend"), true);
|
|
|
|
else
|
|
|
|
asBlend = path;
|
|
|
|
|
|
|
|
if (hecl::IsPathBlend(asBlend))
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection& conn = btok.getBlenderConnection();
|
|
|
|
if (!conn.openBlend(asBlend))
|
|
|
|
return;
|
|
|
|
switch (conn.getBlendType())
|
|
|
|
{
|
|
|
|
case hecl::BlenderConnection::BlendType::Mesh:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
std::vector<hecl::ProjectPath> texs = ds.getTextures();
|
|
|
|
for (const hecl::ProjectPath& tex : texs)
|
|
|
|
pathsOut.push_back(tex);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case hecl::BlenderConnection::BlendType::Actor:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
2016-10-08 03:41:08 +00:00
|
|
|
hecl::BlenderConnection::DataStream::Actor actor = ds.compileActorCharacterOnly();
|
2016-10-02 22:41:36 +00:00
|
|
|
for (auto& sub : actor.subtypes)
|
|
|
|
{
|
|
|
|
if (sub.armature >= 0)
|
|
|
|
{
|
|
|
|
pathsOut.push_back(sub.mesh);
|
|
|
|
|
|
|
|
hecl::SystemStringView chSysName(sub.name);
|
|
|
|
pathsOut.push_back(path.ensureAuxInfo(chSysName.sys_str() + _S(".CSKR")));
|
|
|
|
|
|
|
|
const auto& arm = actor.armatures[sub.armature];
|
|
|
|
hecl::SystemStringView armSysName(arm.name);
|
|
|
|
pathsOut.push_back(path.ensureAuxInfo(armSysName.sys_str() + _S(".CINF")));
|
|
|
|
if (sub.overlayMeshes.size())
|
|
|
|
{
|
|
|
|
pathsOut.push_back(sub.overlayMeshes[0].second);
|
|
|
|
pathsOut.push_back(path.ensureAuxInfo(chSysName.sys_str() + _S(".over.CSKR")));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case hecl::BlenderConnection::BlendType::Area:
|
|
|
|
{
|
|
|
|
hecl::BlenderConnection::DataStream ds = conn.beginData();
|
|
|
|
std::vector<hecl::ProjectPath> texs = ds.getTextures();
|
|
|
|
for (const hecl::ProjectPath& tex : texs)
|
|
|
|
pathsOut.push_back(tex);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (hecl::IsPathYAML(path))
|
|
|
|
{
|
|
|
|
athena::io::FileReader reader(path.getAbsolutePath());
|
|
|
|
flattenDependenciesYAML(reader, pathsOut);
|
|
|
|
}
|
|
|
|
|
|
|
|
pathsOut.push_back(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
void SpecBase::flattenDependencies(const UniqueID32& id, std::vector<hecl::ProjectPath>& pathsOut)
|
|
|
|
{
|
|
|
|
hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(id);
|
|
|
|
if (path)
|
2016-12-25 01:36:42 +00:00
|
|
|
flattenDependencies(path, pathsOut, *g_ThreadBlenderToken.get());
|
2016-10-02 22:41:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void SpecBase::flattenDependencies(const UniqueID64& id, std::vector<hecl::ProjectPath>& pathsOut)
|
|
|
|
{
|
|
|
|
hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(id);
|
|
|
|
if (path)
|
2016-12-25 01:36:42 +00:00
|
|
|
flattenDependencies(path, pathsOut, *g_ThreadBlenderToken.get());
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2016-10-02 22:41:36 +00:00
|
|
|
bool SpecBase::canPackage(const PackagePassInfo& info)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
2016-10-02 22:41:36 +00:00
|
|
|
return false;
|
2015-07-01 23:50:39 +00:00
|
|
|
}
|
|
|
|
|
2015-08-05 21:46:07 +00:00
|
|
|
void SpecBase::doPackage(const PackagePassInfo& info)
|
2015-07-01 23:50:39 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|