AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-12-08 18:24:55 +00:00
Code Issues Projects Releases Wiki Activity

GameCube spec cook fixes

Browse Source
This commit is contained in:
Jack Andersen
2018-04-01 18:27:24 -10:00
parent 7a2fbfc582
commit 06d755cf4c
28 changed files with 402 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
DataSpec/DNAMP1/ANCS.cpp
View File

@@ -432,9 +432,9 @@ void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::Write>(athena::io::ISt
writer.writeUint16Big(sectionCount);
writer.writeString(name);
cmdl.UniqueID32::write(writer);
cskr.UniqueID32::write(writer);
cinf.UniqueID32::write(writer);
cmdl.write(writer);
cskr.write(writer);
cinf.write(writer);
writer.writeUint32Big(animations.size());
writer.enumerate(animations);
@@ -472,8 +472,8 @@ void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::Write>(athena::io::ISt
if (sectionCount > 3)
{
cmdlOverlay.UniqueID32::write(writer);
cskrOverlay.UniqueID32::write(writer);
cmdlOverlay.write(writer);
cskrOverlay.write(writer);
}
if (sectionCount > 4)
@@ -1157,8 +1157,8 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
ch.cmdl = UniqueID32{};
ch.cskr = UniqueID32{};
ch.cinf = UniqueID32{};
ch.cmdlOverlay = UniqueID32{};
ch.cskrOverlay = UniqueID32{};
ch.cmdlOverlay = UniqueID32Zero{};
ch.cskrOverlay = UniqueID32Zero{};
hecl::SystemStringConv chSysName(ch.name);
ch.cskr = inPath.ensureAuxInfo(hecl::SystemString(chSysName.sys_str()) + _S(".CSKR"));

4
DataSpec/DNAMP1/ANCS.hpp
View File

@@ -140,8 +140,8 @@ struct ANCS : BigDNA
};
std::vector<Effect> effects;
UniqueID32 cmdlOverlay;
UniqueID32 cskrOverlay;
UniqueID32Zero cmdlOverlay;
UniqueID32Zero cskrOverlay;
std::vector<atUint32> animIdxs;
};

4
DataSpec/DNAMP1/ANIM.hpp
View File

@@ -24,7 +24,7 @@ struct ANIM : BigDNA
std::vector<DNAANIM::Channel> channels;
std::vector<std::vector<DNAANIM::Value>> chanKeys;
float mainInterval = 0.0;
UniqueID32 evnt;
UniqueID32Zero evnt;
bool looping = false;
void sendANIMToBlender(hecl::blender::PyOutStream&, const DNAANIM::RigInverter<CINF>& rig) const;
@@ -59,7 +59,7 @@ struct ANIM : BigDNA
{
AT_DECL_DNA
Value<atUint32> scratchSize;
UniqueID32 evnt;
UniqueID32Zero evnt;
Value<atUint32> unk0 = 1;
Value<float> duration;
Value<float> interval;

2
DataSpec/DNAMP1/CMDL.cpp
View File

@@ -65,7 +65,7 @@ bool CMDL::Cook(const hecl::ProjectPath& outPath,
const hecl::ProjectPath& inPath,
const DNACMDL::Mesh& mesh)
{
if (mesh.skins.size())
if (!mesh.skins.empty())
{
DNACMDL::Mesh skinMesh = mesh.getContiguousSkinningVersion();
if (!DNACMDL::WriteCMDL<MaterialSet, DNACMDL::SurfaceHeader_1, 2>(outPath, inPath, skinMesh))

44
DataSpec/DNAMP1/CMDLMaterials.cpp
View File

@@ -933,8 +933,11 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
int uvCount,
bool lightmapUVs,
bool matrixSkinning,
atUint32 setIdxIn)
std::unordered_map<uint64_t, int>& uniqueMap)
{
XXH64_state_t xxHash;
XXH64_reset(&xxHash, 0);
if (gx.m_kcolorCount)
{
flags.setKonstValuesEnabled(true);
@@ -1010,6 +1013,8 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
}
flags.setTextureSlots(texFlags);
XXH64_update(&xxHash, &flags.flags, sizeof(flags.flags));
vaFlags.setPosition(GX::INDEX16);
vaFlags.setNormal(GX::INDEX16);
@@ -1052,17 +1057,27 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
vaFlags.setTex6MatIdx(GX::DIRECT);
}
groupIdx = setIdxIn;
XXH64_update(&xxHash, &vaFlags.vaFlags, sizeof(vaFlags.vaFlags));
XXH64_update(&xxHash, &gx.m_kcolorCount, sizeof(gx.m_kcolorCount));
for (unsigned i=0 ; i<gx.m_kcolorCount ; ++i)
{
konstColors.emplace_back(gx.m_kcolors[i]);
XXH64_update(&xxHash, &gx.m_kcolors[i].num, sizeof(gx.m_kcolors[i].num));
}
blendDstFac = BlendFactor(gx.m_blendDst);
XXH64_update(&xxHash, &gx.m_blendDst, sizeof(gx.m_blendDst));
blendSrcFac = BlendFactor(gx.m_blendSrc);
XXH64_update(&xxHash, &gx.m_blendSrc, sizeof(gx.m_blendSrc));
if (flags.samusReflectionIndirectTexture())
{
indTexSlot.push_back(textureIdxs.size());
XXH64_update(&xxHash, &indTexSlot.back(), sizeof(indTexSlot.back()));
}
colorChannelCount = 1;
XXH64_update(&xxHash, &colorChannelCount, sizeof(colorChannelCount));
colorChannels.emplace_back();
ColorChannel& ch = colorChannels.back();
for (unsigned i=0 ; i<gx.m_tevCount ; ++i)
@@ -1074,6 +1089,8 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
stage.m_alpha[c] == hecl::Backend::GX::CA_RASA)
{
ch.setLighting(true);
uint8_t one = 1;
XXH64_update(&xxHash, &one, sizeof(one));
break;
}
if (ch.lighting())
@@ -1083,6 +1100,7 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
ch.setAttenuationFn(GX::AF_SPOT);
tevStageCount = gx.m_tevCount;
XXH64_update(&xxHash, &tevStageCount, sizeof(tevStageCount));
tevStages.reserve(gx.m_tevCount);
for (unsigned i=0 ; i<gx.m_tevCount ; ++i)
{
@@ -1110,9 +1128,18 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
target.setAlphaOpOutReg(stage.m_aRegOut);
target.setKColorIn(stage.m_kColor);
target.setKAlphaIn(stage.m_kAlpha);
XXH64_update(&xxHash, &target.ciFlags, sizeof(target.ciFlags));
XXH64_update(&xxHash, &target.aiFlags, sizeof(target.aiFlags));
XXH64_update(&xxHash, &target.ccFlags, sizeof(target.ccFlags));
XXH64_update(&xxHash, &target.acFlags, sizeof(target.acFlags));
XXH64_update(&xxHash, &target.kaInput, sizeof(target.kaInput));
XXH64_update(&xxHash, &target.kcInput, sizeof(target.kcInput));
XXH64_update(&xxHash, &target.rascInput, sizeof(target.rascInput));
}
tcgCount = gx.m_tcgCount;
XXH64_update(&xxHash, &tcgCount, sizeof(tcgCount));
for (unsigned i=0 ; i<gx.m_tcgCount ; ++i)
{
const hecl::Backend::GX::TexCoordGen& tcg = gx.m_tcgs[i];
@@ -1123,6 +1150,8 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
target.setMtx(tcg.m_mtx);
target.setNormalize(tcg.m_norm);
target.setPostMtx(tcg.m_pmtx);
XXH64_update(&xxHash, &target.flags, sizeof(target.flags));
}
uvAnimsSize = 4;
@@ -1140,6 +1169,8 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
found = true;
++uvAnimsCount;
uvAnims.emplace_back(tcg.m_gameFunction, tcg.m_gameArgs);
XXH64_update(&xxHash, tcg.m_gameFunction.data(), sizeof(tcg.m_gameFunction.size()));
XXH64_update(&xxHash, &tcg.m_gameArgs, sizeof(tcg.m_gameArgs));
size_t tmpUvAnimsSize = uvAnimsSize;
uvAnims.back().binarySize(tmpUvAnimsSize);
uvAnimsSize = tmpUvAnimsSize;
@@ -1149,6 +1180,15 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
if (!found)
break;
}
XXH64_update(&xxHash, &uvAnimsSize, sizeof(uvAnimsSize));
XXH64_update(&xxHash, &uvAnimsCount, sizeof(uvAnimsCount));
uint64_t hash = XXH64_digest(&xxHash);
auto hashSearch = uniqueMap.find(hash);
if (hashSearch == uniqueMap.end())
hashSearch = uniqueMap.insert(std::make_pair(hash, uniqueMap.size())).first;
uniqueIdx = hashSearch->second;
}
HMDLMaterialSet::Material::Material(hecl::Frontend::Frontend& FE,

4
DataSpec/DNAMP1/CMDLMaterials.hpp
View File

@@ -130,7 +130,7 @@ struct MaterialSet : BigDNA
}
} vaFlags;
const VAFlags& getVAFlags() const {return vaFlags;}
Value<atUint32> groupIdx;
Value<atUint32> uniqueIdx;
Vector<atUint32, AT_DNA_COUNT(flags.konstValuesEnabled())> konstCount;
Vector<GX::Color, AT_DNA_COUNT(flags.konstValuesEnabled() ? konstCount[0] : 0)> konstColors;
@@ -291,7 +291,7 @@ struct MaterialSet : BigDNA
int uvCount,
bool lightmapUVs,
bool matrixSkinning,
atUint32 grpIdx);
std::unordered_map<uint64_t, int>& uniqueMap);
};
Vector<Material, AT_DNA_COUNT(head.materialCount)> materials;

61
DataSpec/DNAMP1/MLVL.cpp
View File

@@ -79,24 +79,24 @@ struct LayerResources
{
BulkResources& bulkResources;
std::unordered_map<hecl::Hash, std::pair<size_t, size_t>> addedPaths;
std::vector<std::vector<hecl::ProjectPath>> layerPaths;
std::vector<std::vector<std::pair<hecl::ProjectPath, bool>>> layerPaths;
std::unordered_set<hecl::Hash> addedSharedPaths;
std::vector<hecl::ProjectPath> sharedPaths;
std::vector<std::pair<hecl::ProjectPath, bool>> sharedPaths;
LayerResources(BulkResources& bulkResources) : bulkResources(bulkResources) {}
void beginLayer()
{
layerPaths.resize(layerPaths.size() + 1);
}
void addSharedPath(const hecl::ProjectPath& path)
void addSharedPath(const hecl::ProjectPath& path, bool lazy)
{
auto search = addedSharedPaths.find(path.hash());
if (search == addedSharedPaths.cend())
{
sharedPaths.push_back(path);
sharedPaths.emplace_back(path, lazy);
addedSharedPaths.insert(path.hash());
}
}
void addPath(const hecl::ProjectPath& path)
void addPath(const hecl::ProjectPath& path, bool lazy)
{
auto search = addedPaths.find(path.hash());
if (search != addedPaths.cend())
@@ -105,22 +105,22 @@ struct LayerResources
return;
else
{
hecl::ProjectPath& toMove = layerPaths[search->second.first][search->second.second];
addSharedPath(toMove);
toMove.clear();
auto& toMove = layerPaths[search->second.first][search->second.second];
addSharedPath(toMove.first, toMove.second);
toMove.first.clear();
}
}
else
{
layerPaths.back().push_back(path);
layerPaths.back().emplace_back(path, lazy);
addedPaths.insert(std::make_pair(path.hash(),
std::make_pair(layerPaths.size() - 1, layerPaths.back().size() - 1)));
}
}
void addBulkPath(const hecl::ProjectPath& path, size_t areaIdx)
void addBulkPath(const hecl::ProjectPath& path, size_t areaIdx, bool lazy)
{
if (bulkResources.addBulkPath(path, areaIdx))
addPath(path);
addPath(path, lazy);
}
};
@@ -293,7 +293,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
{
g_ThreadBlenderToken.reset(&btok);
std::vector<hecl::ProjectPath> depPaths;
std::vector<hecl::ProjectPath> bulkPaths;
std::vector<hecl::ProjectPath> lazyPaths;
for (std::unique_ptr<IScriptObject>& obj : layer.objects)
{
if (obj->type == int(urde::EScriptObjectType::MemoryRelay))
@@ -325,14 +325,14 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
}
obj->gatherDependencies(depPaths);
obj->gatherBulkDependencies(bulkPaths);
obj->gatherLazyDependencies(lazyPaths);
}
/* Cull duplicate paths and add typed hash to list */
for (const hecl::ProjectPath& path : depPaths)
layerResources.addBulkPath(path, areaIdx);
for (const hecl::ProjectPath& path : bulkPaths)
layerResources.addBulkPath(path, areaIdx);
layerResources.addBulkPath(path, areaIdx, false);
for (const hecl::ProjectPath& path : lazyPaths)
layerResources.addBulkPath(path, areaIdx, true);
}
hecl::SystemUTF8Conv layerU8(layerName);
@@ -349,16 +349,22 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
/* Build deplist */
MLVL::Area& areaOut = mlvl.areas.back();
for (const std::vector<hecl::ProjectPath>& layer : layerResources.layerPaths)
for (const std::vector<std::pair<hecl::ProjectPath, bool>>& layer : layerResources.layerPaths)
{
areaOut.depLayers.push_back(areaOut.deps.size());
for (const hecl::ProjectPath& path : layer)
for (const std::pair<hecl::ProjectPath, bool>& path : layer)
{
if (path)
if (path.first)
{
urde::SObjectTag tag = g_curSpec->buildTagFromPath(path, btok);
urde::SObjectTag tag = g_curSpec->buildTagFromPath(path.first, btok);
if (tag.id.IsValid())
{
if (path.second)
areaOut.lazyDeps.emplace_back(tag.id.Value(), tag.type);
else
areaOut.lazyDeps.emplace_back(0, FOURCC('NONE'));
areaOut.deps.emplace_back(tag.id.Value(), tag.type);
}
}
}
}
@@ -377,19 +383,28 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
ds.close();
for (const hecl::ProjectPath& path : texs)
layerResources.addSharedPath(path);
layerResources.addSharedPath(path, false);
for (const hecl::ProjectPath& path : layerResources.sharedPaths)
for (const std::pair<hecl::ProjectPath, bool>& path : layerResources.sharedPaths)
{
urde::SObjectTag tag = g_curSpec->buildTagFromPath(path, btok);
urde::SObjectTag tag = g_curSpec->buildTagFromPath(path.first, btok);
if (tag.id.IsValid())
{
if (path.second)
areaOut.lazyDeps.emplace_back(tag.id.Value(), tag.type);
else
areaOut.lazyDeps.emplace_back(0, FOURCC('NONE'));
areaOut.deps.emplace_back(tag.id.Value(), tag.type);
}
}
hecl::ProjectPath pathPath(areaPath.getParentPath(), _S("!path.blend"));
urde::SObjectTag pathTag = g_curSpec->buildTagFromPath(pathPath, btok);
if (pathTag.id.IsValid())
{
areaOut.deps.emplace_back(pathTag.id.Value(), pathTag.type);
areaOut.lazyDeps.emplace_back(0, FOURCC('NONE'));
}
}
++areaIdx;

10
DataSpec/DNAMP1/MLVL.hpp
View File

@@ -41,9 +41,7 @@ struct MLVL : BigDNA
Value<atUint32> attachedAreaCount;
Vector<atUint16, AT_DNA_COUNT(attachedAreaCount)> attachedAreas;
Value<atUint32> padding;
Value<atUint32> depCount;
struct Dependency : BigDNA
{
AT_DECL_DNA_YAML
@@ -52,8 +50,13 @@ struct MLVL : BigDNA
Dependency() = default;
Dependency(const UniqueID32& idin, const hecl::FourCC& fcc)
: id(idin), type(fcc) {}
: id(idin), type(fcc) {}
};
Value<atUint32> lazyDepCount;
Vector<Dependency, AT_DNA_COUNT(lazyDepCount)> lazyDeps;
Value<atUint32> depCount;
Vector<Dependency, AT_DNA_COUNT(depCount)> deps;
Value<atUint32> depLayerCount;
@@ -85,6 +88,7 @@ struct MLVL : BigDNA
{
MLVL::Area& areaLast = areas.back();
areaLast.attachedAreaCount = areaLast.attachedAreas.size();
areaLast.lazyDepCount = areaLast.lazyDeps.size();
areaLast.depCount = areaLast.deps.size();
areaLast.depLayerCount = areaLast.depLayers.size();
areaLast.dockCount = areaLast.docks.size();

6
DataSpec/DNAMP1/ScriptObjects/DoorArea.hpp
View File

@@ -39,13 +39,9 @@ struct DoorArea : IScriptObject
}
void gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
actorParameters.depIDs(pathsOut);
}
void gatherBulkDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
animationParameters.depANCS(pathsOut);
actorParameters.depIDs(pathsOut);
}
void gatherScans(std::vector<Scan>& scansOut) const

2
DataSpec/DNAMP1/ScriptObjects/IScriptObject.hpp
View File

@@ -45,7 +45,7 @@ struct IScriptObject : BigDNAVYaml
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>&) const {}
virtual void nameIDs(PAKRouter<PAKBridge>& pakRouter) const {}
virtual void gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const {}
virtual void gatherBulkDependencies(std::vector<hecl::ProjectPath>& pathsOut) const {}
virtual void gatherLazyDependencies(std::vector<hecl::ProjectPath>& pathsOut) const {}
virtual void gatherScans(std::vector<Scan>& scansOut) const {}
virtual zeus::CAABox getVISIAABB(hecl::blender::Token& btok) const { return {}; }
};

2
DataSpec/DNAMP1/ScriptObjects/PlayerActor.hpp
View File

@@ -55,7 +55,7 @@ struct PlayerActor : IScriptObject
actorParameters.depIDs(pathsOut);
}
void gatherBulkDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
void gatherLazyDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
animationParameters.depANCSAll(pathsOut);
}