mirror of https://github.com/AxioDL/metaforce.git
578 lines
19 KiB
C++
578 lines
19 KiB
C++
#ifndef _DNAMP1_ANCS_HPP_
|
|
#define _DNAMP1_ANCS_HPP_
|
|
|
|
#include <map>
|
|
#include "../DNACommon/DNACommon.hpp"
|
|
#include "../DNACommon/ANCS.hpp"
|
|
#include "CMDLMaterials.hpp"
|
|
#include "CINF.hpp"
|
|
#include "CSKR.hpp"
|
|
#include "ANIM.hpp"
|
|
#include "EVNT.hpp"
|
|
#include "athena/FileReader.hpp"
|
|
|
|
namespace DataSpec::DNAMP1
|
|
{
|
|
|
|
struct ANCS : BigYAML
|
|
{
|
|
using CINFType = CINF;
|
|
using CSKRType = CSKR;
|
|
using ANIMType = ANIM;
|
|
|
|
DECL_YAML
|
|
Value<atUint16> version;
|
|
|
|
struct CharacterSet : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint16> version;
|
|
Value<atUint32> characterCount;
|
|
struct CharacterInfo : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
|
|
atUint32 idx;
|
|
std::string name;
|
|
UniqueID32 cmdl;
|
|
UniqueID32 cskr;
|
|
UniqueID32 cinf;
|
|
|
|
struct Animation : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint32> animIdx;
|
|
String<-1> strA;
|
|
String<-1> strB;
|
|
};
|
|
std::vector<Animation> animations;
|
|
|
|
struct PASDatabase : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint32> magic;
|
|
Value<atUint32> animStateCount;
|
|
Value<atUint32> defaultState;
|
|
struct AnimState : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
atUint32 id;
|
|
|
|
struct ParmInfo : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
enum class DataType
|
|
{
|
|
Int32 = 0,
|
|
UInt32 = 1,
|
|
Float = 2,
|
|
Bool = 3,
|
|
Enum = 4
|
|
};
|
|
union Parm
|
|
{
|
|
atInt32 int32;
|
|
atUint32 uint32;
|
|
float float32;
|
|
bool bool1;
|
|
Parm() : int32(0) {}
|
|
Parm(atInt32 val) : int32(val) {}
|
|
Parm(atUint32 val) : uint32(val) {}
|
|
Parm(float val) : float32(val) {}
|
|
Parm(bool val) : bool1(val) {}
|
|
};
|
|
|
|
atUint32 parmType;
|
|
atUint32 weightFunction;
|
|
float weight;
|
|
Parm range[2];
|
|
};
|
|
std::vector<ParmInfo> parmInfos;
|
|
|
|
struct AnimInfo
|
|
{
|
|
atUint32 id;
|
|
std::vector<ParmInfo::Parm> parmVals;
|
|
};
|
|
std::vector<AnimInfo> animInfos;
|
|
};
|
|
Vector<AnimState, DNA_COUNT(animStateCount)> animStates;
|
|
} pasDatabase;
|
|
|
|
struct ParticleResData
|
|
{
|
|
std::vector<UniqueID32> part;
|
|
std::vector<UniqueID32> swhc;
|
|
std::vector<UniqueID32> unk;
|
|
std::vector<UniqueID32> elsc;
|
|
} partResData;
|
|
|
|
atUint32 unk1 = 0;
|
|
|
|
struct ActionAABB : BigYAML
|
|
{
|
|
DECL_YAML
|
|
String<-1> name;
|
|
Value<atVec3f> aabb[2];
|
|
};
|
|
std::vector<ActionAABB> animAABBs;
|
|
|
|
struct Effect : BigYAML
|
|
{
|
|
DECL_YAML
|
|
String<-1> name;
|
|
Value<atUint32> compCount;
|
|
struct EffectComponent : BigYAML
|
|
{
|
|
DECL_YAML
|
|
String<-1> name;
|
|
DNAFourCC type;
|
|
UniqueID32 id;
|
|
String<-1> locator;
|
|
Value<float> scale;
|
|
Value<atUint32> parentMode;
|
|
Value<atUint32> flags;
|
|
};
|
|
Vector<EffectComponent, DNA_COUNT(compCount)> comps;
|
|
};
|
|
std::vector<Effect> effects;
|
|
|
|
UniqueID32 cmdlOverlay;
|
|
UniqueID32 cskrOverlay;
|
|
|
|
std::vector<atUint32> animIdxs;
|
|
};
|
|
Vector<CharacterInfo, DNA_COUNT(characterCount)> characters;
|
|
} characterSet;
|
|
|
|
struct AnimationSet : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
|
|
struct MetaAnimPrimitive;
|
|
struct IMetaAnim : BigYAML
|
|
{
|
|
Delete expl;
|
|
virtual ~IMetaAnim() {}
|
|
enum class Type
|
|
{
|
|
Primitive = 0,
|
|
Blend = 1,
|
|
PhaseBlend = 2,
|
|
Random = 3,
|
|
Sequence = 4
|
|
} m_type;
|
|
const char* m_typeStr;
|
|
IMetaAnim(Type type, const char* typeStr)
|
|
: m_type(type), m_typeStr(typeStr) {}
|
|
virtual void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)=0;
|
|
virtual bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)=0;
|
|
};
|
|
struct MetaAnimFactory : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
std::unique_ptr<IMetaAnim> m_anim;
|
|
};
|
|
struct MetaAnimPrimitive : IMetaAnim
|
|
{
|
|
Delete expl2;
|
|
|
|
MetaAnimPrimitive() : IMetaAnim(Type::Primitive, "Primitive") {}
|
|
|
|
UniqueID32 animId;
|
|
Value<atUint32> animIdx;
|
|
String<-1> animName;
|
|
Value<float> unk1;
|
|
Value<atUint32> unk2;
|
|
|
|
void read(athena::io::IStreamReader& __dna_reader)
|
|
{
|
|
/* animId */
|
|
animId.read(__dna_reader);
|
|
/* animIdx */
|
|
animIdx = __dna_reader.readUint32Big();
|
|
/* animName */
|
|
animName = __dna_reader.readString(-1);
|
|
/* unk1 */
|
|
unk1 = __dna_reader.readFloatBig();
|
|
/* unk2 */
|
|
unk2 = __dna_reader.readUint32Big();
|
|
}
|
|
|
|
void write(athena::io::IStreamWriter& __dna_writer) const
|
|
{
|
|
/* animId */
|
|
animId.write(__dna_writer);
|
|
/* animIdx */
|
|
__dna_writer.writeUint32Big(animIdx);
|
|
/* animName */
|
|
__dna_writer.writeString(animName, -1);
|
|
/* unk1 */
|
|
__dna_writer.writeFloatBig(unk1);
|
|
/* unk2 */
|
|
__dna_writer.writeUint32Big(unk2);
|
|
}
|
|
|
|
void read(athena::io::YAMLDocReader& __dna_docin)
|
|
{
|
|
/* animIdx */
|
|
animIdx = __dna_docin.readUint32("animIdx");
|
|
/* animName */
|
|
animName = __dna_docin.readString("animName");
|
|
/* unk1 */
|
|
unk1 = __dna_docin.readFloat("unk1");
|
|
/* unk2 */
|
|
unk2 = __dna_docin.readUint32("unk2");
|
|
}
|
|
|
|
void write(athena::io::YAMLDocWriter& __dna_docout) const
|
|
{
|
|
/* animIdx */
|
|
__dna_docout.writeUint32("animIdx", animIdx);
|
|
/* animName */
|
|
__dna_docout.writeString("animName", animName);
|
|
/* unk1 */
|
|
__dna_docout.writeFloat("unk1", unk1);
|
|
/* unk2 */
|
|
__dna_docout.writeUint32("unk2", unk2);
|
|
}
|
|
|
|
static const char* DNAType()
|
|
{
|
|
return "DataSpec::DNAMP1::ANCS::AnimationSet::MetaAnimPrimitive";
|
|
}
|
|
|
|
size_t binarySize(size_t __isz) const
|
|
{
|
|
__isz = animId.binarySize(__isz);
|
|
__isz += animName.size() + 1;
|
|
return __isz + 12;
|
|
}
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
out[animIdx] = {animName, animId, UniqueID32(), false};
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
return func(*this);
|
|
}
|
|
};
|
|
struct MetaAnimBlend : IMetaAnim
|
|
{
|
|
MetaAnimBlend()
|
|
: IMetaAnim(Type::Blend, "Blend") {}
|
|
DECL_YAML
|
|
MetaAnimFactory animA;
|
|
MetaAnimFactory animB;
|
|
Value<float> unkFloat;
|
|
Value<atUint8> unk;
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
animA.m_anim->gatherPrimitives(out);
|
|
animB.m_anim->gatherPrimitives(out);
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
if (!animA.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
if (!animB.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
struct MetaAnimPhaseBlend : IMetaAnim
|
|
{
|
|
MetaAnimPhaseBlend()
|
|
: IMetaAnim(Type::PhaseBlend, "PhaseBlend") {}
|
|
DECL_YAML
|
|
MetaAnimFactory animA;
|
|
MetaAnimFactory animB;
|
|
Value<float> unkFloat;
|
|
Value<atUint8> unk;
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
animA.m_anim->gatherPrimitives(out);
|
|
animB.m_anim->gatherPrimitives(out);
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
if (!animA.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
if (!animB.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
struct MetaAnimRandom : IMetaAnim
|
|
{
|
|
MetaAnimRandom() : IMetaAnim(Type::Random, "Random") {}
|
|
DECL_YAML
|
|
Value<atUint32> animCount;
|
|
struct Child : BigYAML
|
|
{
|
|
DECL_YAML
|
|
MetaAnimFactory anim;
|
|
Value<atUint32> probability;
|
|
};
|
|
Vector<Child, DNA_COUNT(animCount)> children;
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
for (const auto& child : children)
|
|
child.anim.m_anim->gatherPrimitives(out);
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
for (auto& child : children)
|
|
if (!child.anim.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
struct MetaAnimSequence : IMetaAnim
|
|
{
|
|
MetaAnimSequence() : IMetaAnim(Type::Sequence, "Sequence") {}
|
|
DECL_YAML
|
|
Value<atUint32> animCount;
|
|
Vector<MetaAnimFactory, DNA_COUNT(animCount)> children;
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
for (const auto& child : children)
|
|
child.m_anim->gatherPrimitives(out);
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
for (auto& child : children)
|
|
if (!child.m_anim->enumeratePrimitives(func))
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct Animation : BigYAML
|
|
{
|
|
DECL_YAML
|
|
String<-1> name;
|
|
MetaAnimFactory metaAnim;
|
|
};
|
|
std::vector<Animation> animations;
|
|
|
|
struct IMetaTrans : BigYAML
|
|
{
|
|
Delete expl;
|
|
virtual ~IMetaTrans() {}
|
|
enum class Type
|
|
{
|
|
MetaAnim = 0,
|
|
Trans = 1,
|
|
PhaseTrans = 2,
|
|
NoTrans = 3,
|
|
} m_type;
|
|
const char* m_typeStr;
|
|
IMetaTrans(Type type, const char* typeStr)
|
|
: m_type(type), m_typeStr(typeStr) {}
|
|
virtual void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out) {}
|
|
virtual bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func) {return true;}
|
|
};
|
|
struct MetaTransFactory : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Delete expl;
|
|
std::unique_ptr<IMetaTrans> m_trans;
|
|
};
|
|
struct MetaTransMetaAnim : IMetaTrans
|
|
{
|
|
MetaTransMetaAnim()
|
|
: IMetaTrans(Type::MetaAnim, "MetaAnim") {}
|
|
DECL_YAML
|
|
MetaAnimFactory anim;
|
|
|
|
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
|
|
{
|
|
anim.m_anim->gatherPrimitives(out);
|
|
}
|
|
|
|
bool enumeratePrimitives(const std::function<bool(MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
return anim.m_anim->enumeratePrimitives(func);
|
|
}
|
|
};
|
|
struct MetaTransTrans : IMetaTrans
|
|
{
|
|
MetaTransTrans()
|
|
: IMetaTrans(Type::Trans, "Trans") {}
|
|
DECL_YAML
|
|
Value<float> transDurTime;
|
|
Value<atUint32> transDurTimeMode;
|
|
Value<bool> unk2;
|
|
Value<bool> runA;
|
|
Value<atUint32> flags;
|
|
};
|
|
struct MetaTransPhaseTrans : IMetaTrans
|
|
{
|
|
MetaTransPhaseTrans()
|
|
: IMetaTrans(Type::PhaseTrans, "PhaseTrans") {}
|
|
DECL_YAML
|
|
Value<float> transDurTime;
|
|
Value<atUint32> transDurTimeMode;
|
|
Value<bool> unk2;
|
|
Value<bool> runA;
|
|
Value<atUint32> flags;
|
|
};
|
|
|
|
struct Transition : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint32> unk;
|
|
Value<atUint32> animIdxA;
|
|
Value<atUint32> animIdxB;
|
|
MetaTransFactory metaTrans;
|
|
};
|
|
std::vector<Transition> transitions;
|
|
MetaTransFactory defaultTransition;
|
|
|
|
struct AdditiveAnimationInfo : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint32> animIdx;
|
|
Value<float> unk1;
|
|
Value<float> unk2;
|
|
};
|
|
std::vector<AdditiveAnimationInfo> additiveAnims;
|
|
|
|
float floatA = 0.0;
|
|
float floatB = 0.0;
|
|
|
|
struct HalfTransition : BigYAML
|
|
{
|
|
DECL_YAML
|
|
Value<atUint32> animIdx;
|
|
MetaTransFactory metaTrans;
|
|
};
|
|
std::vector<HalfTransition> halfTransitions;
|
|
|
|
struct AnimationResources : BigYAML
|
|
{
|
|
DECL_YAML
|
|
UniqueID32 animId;
|
|
UniqueID32 evntId;
|
|
};
|
|
std::vector<AnimationResources> animResources;
|
|
} animationSet;
|
|
|
|
void getCharacterResInfo(std::vector<DNAANCS::CharacterResInfo<UniqueID32>>& out) const
|
|
{
|
|
out.clear();
|
|
out.reserve(characterSet.characters.size());
|
|
for (const CharacterSet::CharacterInfo& ci : characterSet.characters)
|
|
{
|
|
out.emplace_back();
|
|
DNAANCS::CharacterResInfo<UniqueID32>& chOut = out.back();
|
|
chOut.name = ci.name;
|
|
chOut.cmdl = ci.cmdl;
|
|
chOut.cskr = ci.cskr;
|
|
chOut.cinf = ci.cinf;
|
|
|
|
if (ci.cmdlOverlay)
|
|
chOut.overlays.emplace_back(FOURCC('OVER'), std::make_pair(ci.cmdlOverlay, ci.cskrOverlay));
|
|
}
|
|
}
|
|
|
|
void getAnimationResInfo(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out) const
|
|
{
|
|
out.clear();
|
|
for (const AnimationSet::Animation& ai : animationSet.animations)
|
|
if (AnimationSet::IMetaAnim* anim = ai.metaAnim.m_anim.get())
|
|
anim->gatherPrimitives(out);
|
|
for (const AnimationSet::Transition& ti : animationSet.transitions)
|
|
if (AnimationSet::IMetaTrans* trans = ti.metaTrans.m_trans.get())
|
|
trans->gatherPrimitives(out);
|
|
if (AnimationSet::IMetaTrans* trans = animationSet.defaultTransition.m_trans.get())
|
|
trans->gatherPrimitives(out);
|
|
for (auto& anim : out)
|
|
{
|
|
for (const AnimationSet::AnimationResources& res : animationSet.animResources)
|
|
{
|
|
if (res.animId == anim.second.animId)
|
|
{
|
|
anim.second.evntId = res.evntId;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void enumeratePrimitives(const std::function<bool(AnimationSet::MetaAnimPrimitive& prim)>& func)
|
|
{
|
|
for (const AnimationSet::Animation& ai : animationSet.animations)
|
|
if (AnimationSet::IMetaAnim* anim = ai.metaAnim.m_anim.get())
|
|
anim->enumeratePrimitives(func);
|
|
for (const AnimationSet::Transition& ti : animationSet.transitions)
|
|
if (AnimationSet::IMetaTrans* trans = ti.metaTrans.m_trans.get())
|
|
trans->enumeratePrimitives(func);
|
|
if (AnimationSet::IMetaTrans* trans = animationSet.defaultTransition.m_trans.get())
|
|
trans->enumeratePrimitives(func);
|
|
}
|
|
|
|
void gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
|
|
{
|
|
for (const CharacterSet::CharacterInfo& ci : characterSet.characters)
|
|
{
|
|
for (const auto& id : ci.partResData.part)
|
|
g_curSpec->flattenDependencies(id, pathsOut);
|
|
for (const auto& id : ci.partResData.swhc)
|
|
g_curSpec->flattenDependencies(id, pathsOut);
|
|
for (const auto& id : ci.partResData.unk)
|
|
g_curSpec->flattenDependencies(id, pathsOut);
|
|
for (const auto& id : ci.partResData.elsc)
|
|
g_curSpec->flattenDependencies(id, pathsOut);
|
|
}
|
|
}
|
|
|
|
static bool Extract(const SpecBase& dataSpec,
|
|
PAKEntryReadStream& rs,
|
|
const hecl::ProjectPath& outPath,
|
|
PAKRouter<PAKBridge>& pakRouter,
|
|
const PAK::Entry& entry,
|
|
bool force,
|
|
hecl::blender::Token& btok,
|
|
std::function<void(const hecl::SystemChar*)> fileChanged);
|
|
|
|
static bool Cook(const hecl::ProjectPath& outPath,
|
|
const hecl::ProjectPath& inPath,
|
|
const DNAANCS::Actor& actor);
|
|
|
|
static bool CookCINF(const hecl::ProjectPath& outPath,
|
|
const hecl::ProjectPath& inPath,
|
|
const DNAANCS::Actor& actor);
|
|
|
|
static bool CookCSKR(const hecl::ProjectPath& outPath,
|
|
const hecl::ProjectPath& inPath,
|
|
const DNAANCS::Actor& actor,
|
|
const std::function<bool(const hecl::ProjectPath& modelPath)>& modelCookFunc);
|
|
|
|
static bool CookANIM(const hecl::ProjectPath& outPath,
|
|
const hecl::ProjectPath& inPath,
|
|
const DNAANCS::Actor& actor,
|
|
hecl::blender::DataStream& ds,
|
|
bool pc);
|
|
};
|
|
|
|
}
|
|
|
|
#endif // _DNAMP1_ANCS_HPP_
|