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

atdna fixes

This commit is contained in:
Phillip Stephens 2019-08-26 20:02:31 -07:00
parent 27a47fad5a
commit 3ca09f60db
Signed by: Antidote
GPG Key ID: F8BEE4C83DACA60D
14 changed files with 162 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
DataSpec/DNACommon/FSM2.cpp
View File

@ -14,7 +14,7 @@ logvisor::Module LogDNAFSM2("urde::DNAFSM2");
template <class IDType> template <class IDType>
template <class Op> template <class Op>
void FSM2<IDType>::Enumerate(typename Op::StreamT& s) { void FSM2<IDType>::Enumerate(typename Op::StreamT& s) {
Do<Op>({"header"}, header, s); Do<Op>(athena::io::PropId{"header"}, header, s);
if (header.magic != SBIG('FSM2')) { if (header.magic != SBIG('FSM2')) {
LogDNAFSM2.report(logvisor::Fatal, fmt("Invalid FSM2 magic '{}' expected 'FSM2'"), header.magic); LogDNAFSM2.report(logvisor::Fatal, fmt("Invalid FSM2 magic '{}' expected 'FSM2'"), header.magic);
return; return;
@ -23,11 +23,11 @@ void FSM2<IDType>::Enumerate(typename Op::StreamT& s) {
if (header.version == 1) { if (header.version == 1) {
if (!detail) if (!detail)
detail.reset(new FSMV1); detail.reset(new FSMV1);
Do<Op>({"detail"}, static_cast<FSMV1&>(*detail), s); Do<Op>(athena::io::PropId{"detail"}, static_cast<FSMV1&>(*detail), s);
} else if (header.version == 2) { } else if (header.version == 2) {
if (!detail) if (!detail)
detail.reset(new FSMV2); detail.reset(new FSMV2);
Do<Op>({"detail"}, static_cast<FSMV2&>(*detail), s); Do<Op>(athena::io::PropId{"detail"}, static_cast<FSMV2&>(*detail), s);
} else { } else {
LogDNAFSM2.report(logvisor::Fatal, fmt("Invalid FSM2 version '{}'"), header.version); LogDNAFSM2.report(logvisor::Fatal, fmt("Invalid FSM2 version '{}'"), header.version);
return; return;

8
DataSpec/DNACommon/ParticleCommon.cpp
View File

@ -1329,10 +1329,10 @@ const char* SpawnSystemKeyframeData<UniqueID64>::SpawnSystemKeyframeInfo::DNATyp
template <class IDType> template <class IDType>
template <class Op> template <class Op>
void SpawnSystemKeyframeData<IDType>::SpawnSystemKeyframeInfo::Enumerate(typename Op::StreamT& s) { void SpawnSystemKeyframeData<IDType>::SpawnSystemKeyframeInfo::Enumerate(typename Op::StreamT& s) {
Do<Op>({"id"}, id, s); Do<Op>(athena::io::PropId{"id"}, id, s);
Do<Op>({"a"}, a, s); Do<Op>(athena::io::PropId{"a"}, a, s);
Do<Op>({"b"}, b, s); Do<Op>(athena::io::PropId{"b"}, b, s);
Do<Op>({"c"}, c, s); Do<Op>(athena::io::PropId{"c"}, c, s);
} }
template <> template <>

20
DataSpec/DNACommon/TXTR.cpp
View File

@ -1587,9 +1587,9 @@ bool TXTR::CookPC(const hecl::ProjectPath& inPath, const hecl::ProjectPath& outP
template <class Op> template <class Op>
void DataSpec::TXTR::PaletteMeta::Enumerate(typename Op::StreamT& s) { void DataSpec::TXTR::PaletteMeta::Enumerate(typename Op::StreamT& s) {
Do<Op>({"format"}, format, s); Do<Op>(athena::io::PropId{"format"}, format, s);
Do<Op>({"elementCount"}, elementCount, s); Do<Op>(athena::io::PropId{"elementCount"}, elementCount, s);
Do<Op>({"dolphinHash"}, dolphinHash, s); Do<Op>(athena::io::PropId{"dolphinHash"}, dolphinHash, s);
} }
AT_SPECIALIZE_DNA_YAML(DataSpec::TXTR::PaletteMeta) AT_SPECIALIZE_DNA_YAML(DataSpec::TXTR::PaletteMeta)
@ -1600,14 +1600,14 @@ const char* DataSpec::TXTR::PaletteMeta::DNAType() {
template <class Op> template <class Op>
void DataSpec::TXTR::Meta::Enumerate(typename Op::StreamT& s) { void DataSpec::TXTR::Meta::Enumerate(typename Op::StreamT& s) {
Do<Op>({"format"}, format, s); Do<Op>(athena::io::PropId{"format"}, format, s);
Do<Op>({"mips"}, mips, s); Do<Op>(athena::io::PropId{"mips"}, mips, s);
Do<Op>({"width"}, width, s); Do<Op>(athena::io::PropId{"width"}, width, s);
Do<Op>({"height"}, height, s); Do<Op>(athena::io::PropId{"height"}, height, s);
Do<Op>({"dolphinHash"}, dolphinHash, s); Do<Op>(athena::io::PropId{"dolphinHash"}, dolphinHash, s);
Do<Op>({"hasPalette"}, hasPalette, s); Do<Op>(athena::io::PropId{"hasPalette"}, hasPalette, s);
if (hasPalette) if (hasPalette)
Do<Op>({"palette"}, palette, s); Do<Op>(athena::io::PropId{"palette"}, palette, s);
} }
AT_SPECIALIZE_DNA_YAML(DataSpec::TXTR::Meta) AT_SPECIALIZE_DNA_YAML(DataSpec::TXTR::Meta)

10
DataSpec/DNAMP1/CMDLMaterials.cpp
View File

@ -1070,14 +1070,14 @@ AT_SPECIALIZE_DNA(MaterialSet::Material::UVAnimation)
template <class Op> template <class Op>
void HMDLMaterialSet::Material::PASS::Enumerate(typename Op::StreamT& s) { void HMDLMaterialSet::Material::PASS::Enumerate(typename Op::StreamT& s) {
Do<Op>({"type"}, type, s); Do<Op>(athena::io::PropId{"type"}, type, s);
Do<Op>({"texId"}, texId, s); Do<Op>(athena::io::PropId{"texId"}, texId, s);
Do<Op>({"source"}, source, s); Do<Op>(athena::io::PropId{"source"}, source, s);
Do<Op>({"uvAnimType"}, uvAnimType, s); Do<Op>(athena::io::PropId{"uvAnimType"}, uvAnimType, s);
size_t uvParmCount = uvAnimParamsCount(); size_t uvParmCount = uvAnimParamsCount();
for (size_t i = 0; i < uvParmCount; ++i) for (size_t i = 0; i < uvParmCount; ++i)
Do<Op>({}, uvAnimParms[i], s); Do<Op>({}, uvAnimParms[i], s);
Do<Op>({"alpha"}, alpha, s); Do<Op>(athena::io::PropId{"alpha"}, alpha, s);
} }
AT_SPECIALIZE_DNA(HMDLMaterialSet::Material::PASS) AT_SPECIALIZE_DNA(HMDLMaterialSet::Material::PASS)

16
DataSpec/DNAMP1/DCLN.hpp
View File

@ -93,22 +93,22 @@ struct DCLN : BigDNA {
template <class Op> template <class Op>
void DCLN::Collision::Node::Enumerate(typename Op::StreamT& s) { void DCLN::Collision::Node::Enumerate(typename Op::StreamT& s) {
Do<Op>({"xf[0]"}, xf[0], s); Do<Op>(athena::io::PropId{"xf[0]"}, xf[0], s);
Do<Op>({"xf[1]"}, xf[1], s); Do<Op>(athena::io::PropId{"xf[1]"}, xf[1], s);
Do<Op>({"xf[2]"}, xf[2], s); Do<Op>(athena::io::PropId{"xf[2]"}, xf[2], s);
Do<Op>({"halfExtent"}, halfExtent, s); Do<Op>(athena::io::PropId{"halfExtent"}, halfExtent, s);
Do<Op>({"isLeaf"}, isLeaf, s); Do<Op>(athena::io::PropId{"isLeaf"}, isLeaf, s);
if (isLeaf) { if (isLeaf) {
if (!leafData) if (!leafData)
leafData.reset(new LeafData); leafData.reset(new LeafData);
Do<Op>({"leafData"}, *leafData, s); Do<Op>(athena::io::PropId{"leafData"}, *leafData, s);
} else { } else {
if (!left) if (!left)
left.reset(new Node); left.reset(new Node);
Do<Op>({"left"}, *left, s); Do<Op>(athena::io::PropId{"left"}, *left, s);
if (!right) if (!right)
right.reset(new Node); right.reset(new Node);
Do<Op>({"right"}, *right, s); Do<Op>(athena::io::PropId{"right"}, *right, s);
} }
} }

18
DataSpec/DNAMP1/EVNT.cpp
View File

@ -4,20 +4,20 @@ namespace DataSpec::DNAMP1 {
template <class Op> template <class Op>
void EVNT::Enumerate(typename Op::StreamT& s) { void EVNT::Enumerate(typename Op::StreamT& s) {
Do<Op>({"version"}, version, s); Do<Op>(athena::io::PropId{"version"}, version, s);
DoSize<Op>({"boolPOICount"}, boolPOICount, s); DoSize<Op>(athena::io::PropId{"boolPOICount"}, boolPOICount, s);
Do<Op>({"boolPOINodes"}, boolPOINodes, boolPOICount, s); Do<Op>(athena::io::PropId{"boolPOINodes"}, boolPOINodes, boolPOICount, s);
DoSize<Op>({"int32POICount"}, int32POICount, s); DoSize<Op>(athena::io::PropId{"int32POICount"}, int32POICount, s);
Do<Op>({"int32POINodes"}, int32POINodes, int32POICount, s); Do<Op>(athena::io::PropId{"int32POINodes"}, int32POINodes, int32POICount, s);
DoSize<Op>({"particlePOICount"}, particlePOICount, s); DoSize<Op>(athena::io::PropId{"particlePOICount"}, particlePOICount, s);
Do<Op>({"particlePOINodes"}, particlePOINodes, particlePOICount, s); Do<Op>(athena::io::PropId{"particlePOINodes"}, particlePOINodes, particlePOICount, s);
if (version == 2) { if (version == 2) {
DoSize<Op>({"soundPOICount"}, soundPOICount, s); DoSize<Op>(athena::io::PropId{"soundPOICount"}, soundPOICount, s);
Do<Op>({"soundPOINodes"}, soundPOINodes, soundPOICount, s); Do<Op>(athena::io::PropId{"soundPOINodes"}, soundPOINodes, soundPOICount, s);
} }
} }

28
DataSpec/DNAMP1/FRME.cpp
View File

@ -251,21 +251,21 @@ void FRME::Widget::LITEInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz) {
template <class Op> template <class Op>
void FRME::Widget::TXPNInfo::Enumerate(typename Op::StreamT& s) { void FRME::Widget::TXPNInfo::Enumerate(typename Op::StreamT& s) {
Do<Op>({"xDim"}, xDim, s); Do<Op>(athena::io::PropId{"xDim"}, xDim, s);
Do<Op>({"zDim"}, zDim, s); Do<Op>(athena::io::PropId{"zDim"}, zDim, s);
Do<Op>({"scaleCenter"}, scaleCenter, s); Do<Op>(athena::io::PropId{"scaleCenter"}, scaleCenter, s);
Do<Op>({"font"}, font, s); Do<Op>(athena::io::PropId{"font"}, font, s);
Do<Op>({"wordWrap"}, wordWrap, s); Do<Op>(athena::io::PropId{"wordWrap"}, wordWrap, s);
Do<Op>({"horizontal"}, horizontal, s); Do<Op>(athena::io::PropId{"horizontal"}, horizontal, s);
Do<Op>({"justification"}, justification, s); Do<Op>(athena::io::PropId{"justification"}, justification, s);
Do<Op>({"verticalJustification"}, verticalJustification, s); Do<Op>(athena::io::PropId{"verticalJustification"}, verticalJustification, s);
Do<Op>({"fillColor"}, fillColor, s); Do<Op>(athena::io::PropId{"fillColor"}, fillColor, s);
Do<Op>({"outlineColor"}, outlineColor, s); Do<Op>(athena::io::PropId{"outlineColor"}, outlineColor, s);
Do<Op>({"blockExtent"}, blockExtent, s); Do<Op>(athena::io::PropId{"blockExtent"}, blockExtent, s);
if (version == 1) { if (version == 1) {
Do<Op>({"jpnFont"}, jpnFont, s); Do<Op>(athena::io::PropId{"jpnFont"}, jpnFont, s);
Do<Op>({"jpnPointScale[0]"}, jpnPointScale[0], s); Do<Op>(athena::io::PropId{"jpnPointScale[0]"}, jpnPointScale[0], s);
Do<Op>({"jpnPointScale[1]"}, jpnPointScale[1], s); Do<Op>(athena::io::PropId{"jpnPointScale[1]"}, jpnPointScale[1], s);
} }
} }

4
DataSpec/DNAMP1/SCLY.cpp
View File

@ -77,7 +77,7 @@ void SCLY::ScriptLayer::nameIDs(PAKRouter<PAKBridge>& pakRouter) const {
template <> template <>
void SCLY::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& docin) { void SCLY::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& docin) {
Do<BigDNA::ReadYaml>({"fourCC"}, fourCC, docin); Do<BigDNA::ReadYaml>(athena::io::PropId{"fourCC"}, fourCC, docin);
version = docin.readUint32("version"); version = docin.readUint32("version");
layerCount = docin.enumerate("layerSizes", layerSizes); layerCount = docin.enumerate("layerSizes", layerSizes);
docin.enumerate("layers", layers); docin.enumerate("layers", layers);
@ -85,7 +85,7 @@ void SCLY::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& docin) {
template <> template <>
void SCLY::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& docout) { void SCLY::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& docout) {
Do<BigDNA::WriteYaml>({"fourCC"}, fourCC, docout); Do<BigDNA::WriteYaml>(athena::io::PropId{"fourCC"}, fourCC, docout);
docout.writeUint32("version", version); docout.writeUint32("version", version);
docout.enumerate("layerSizes", layerSizes); docout.enumerate("layerSizes", layerSizes);
docout.enumerate("layers", layers); docout.enumerate("layers", layers);

32
DataSpec/DNAMP1/ScriptObjects/Oculus.cpp
View File

@ -5,23 +5,23 @@ namespace DataSpec::DNAMP1 {
template <class Op> template <class Op>
void Oculus::Enumerate(typename Op::StreamT& s) { void Oculus::Enumerate(typename Op::StreamT& s) {
IScriptObject::Enumerate<Op>(s); IScriptObject::Enumerate<Op>(s);
Do<Op>({"name"}, name, s); Do<Op>(athena::io::PropId{"name"}, name, s);
Do<Op>({"location"}, location, s); Do<Op>(athena::io::PropId{"location"}, location, s);
Do<Op>({"orientation"}, orientation, s); Do<Op>(athena::io::PropId{"orientation"}, orientation, s);
Do<Op>({"scale"}, scale, s); Do<Op>(athena::io::PropId{"scale"}, scale, s);
Do<Op>({"patternedInfo"}, patternedInfo, s); Do<Op>(athena::io::PropId{"patternedInfo"}, patternedInfo, s);
Do<Op>({"actorParameters"}, actorParameters, s); Do<Op>(athena::io::PropId{"actorParameters"}, actorParameters, s);
Do<Op>({"unknown1"}, unknown1, s); Do<Op>(athena::io::PropId{"unknown1"}, unknown1, s);
Do<Op>({"unknown2"}, unknown2, s); Do<Op>(athena::io::PropId{"unknown2"}, unknown2, s);
Do<Op>({"unknown3"}, unknown3, s); Do<Op>(athena::io::PropId{"unknown3"}, unknown3, s);
Do<Op>({"unknown4"}, unknown4, s); Do<Op>(athena::io::PropId{"unknown4"}, unknown4, s);
Do<Op>({"unknown5"}, unknown5, s); Do<Op>(athena::io::PropId{"unknown5"}, unknown5, s);
Do<Op>({"unknown6"}, unknown6, s); Do<Op>(athena::io::PropId{"unknown6"}, unknown6, s);
Do<Op>({"damageVulnerabilty"}, damageVulnerabilty, s); Do<Op>(athena::io::PropId{"damageVulnerabilty"}, damageVulnerabilty, s);
Do<Op>({"unknown7"}, unknown7, s); Do<Op>(athena::io::PropId{"unknown7"}, unknown7, s);
Do<Op>({"damageInfo"}, damageInfo, s); Do<Op>(athena::io::PropId{"damageInfo"}, damageInfo, s);
if (propertyCount == 16) if (propertyCount == 16)
Do<Op>({"unknown8"}, unknown8, s); Do<Op>(athena::io::PropId{"unknown8"}, unknown8, s);
else else
unknown8 = 0.f; unknown8 = 0.f;
} }

100
DataSpec/DNAMP1/ScriptObjects/Ridley.cpp
View File

@ -5,60 +5,60 @@ namespace DataSpec::DNAMP1 {
template <class Op> template <class Op>
void Ridley::Enumerate(typename Op::StreamT& s) { void Ridley::Enumerate(typename Op::StreamT& s) {
IScriptObject::Enumerate<Op>(s); IScriptObject::Enumerate<Op>(s);
Do<Op>({"name"}, name, s); Do<Op>(athena::io::PropId{"name"}, name, s);
Do<Op>({"location"}, location, s); Do<Op>(athena::io::PropId{"location"}, location, s);
Do<Op>({"orientation"}, orientation, s); Do<Op>(athena::io::PropId{"orientation"}, orientation, s);
Do<Op>({"scale"}, scale, s); Do<Op>(athena::io::PropId{"scale"}, scale, s);
Do<Op>({"patternedInfo"}, patternedInfo, s); Do<Op>(athena::io::PropId{"patternedInfo"}, patternedInfo, s);
Do<Op>({"actorParameters"}, actorParameters, s); Do<Op>(athena::io::PropId{"actorParameters"}, actorParameters, s);
Do<Op>({"model1"}, model1, s); Do<Op>(athena::io::PropId{"model1"}, model1, s);
Do<Op>({"model2"}, model2, s); Do<Op>(athena::io::PropId{"model2"}, model2, s);
if (propertyCount == 48) { if (propertyCount == 48) {
Do<Op>({"model3"}, model3, s); Do<Op>(athena::io::PropId{"model3"}, model3, s);
Do<Op>({"model4"}, model4, s); Do<Op>(athena::io::PropId{"model4"}, model4, s);
Do<Op>({"model5"}, model5, s); Do<Op>(athena::io::PropId{"model5"}, model5, s);
Do<Op>({"model6"}, model6, s); Do<Op>(athena::io::PropId{"model6"}, model6, s);
Do<Op>({"model7"}, model7, s); Do<Op>(athena::io::PropId{"model7"}, model7, s);
Do<Op>({"model8"}, model8, s); Do<Op>(athena::io::PropId{"model8"}, model8, s);
Do<Op>({"model9"}, model9, s); Do<Op>(athena::io::PropId{"model9"}, model9, s);
Do<Op>({"model10"}, model10, s); Do<Op>(athena::io::PropId{"model10"}, model10, s);
Do<Op>({"model11"}, model11, s); Do<Op>(athena::io::PropId{"model11"}, model11, s);
Do<Op>({"model12"}, model12, s); Do<Op>(athena::io::PropId{"model12"}, model12, s);
} }
Do<Op>({"particle"}, particle, s); Do<Op>(athena::io::PropId{"particle"}, particle, s);
Do<Op>({"unknown1"}, unknown1, s); Do<Op>(athena::io::PropId{"unknown1"}, unknown1, s);
Do<Op>({"unknown2"}, unknown2, s); Do<Op>(athena::io::PropId{"unknown2"}, unknown2, s);
Do<Op>({"unknown3"}, unknown3, s); Do<Op>(athena::io::PropId{"unknown3"}, unknown3, s);
Do<Op>({"unknown4"}, unknown4, s); Do<Op>(athena::io::PropId{"unknown4"}, unknown4, s);
Do<Op>({"wpsc1"}, wpsc1, s); Do<Op>(athena::io::PropId{"wpsc1"}, wpsc1, s);
Do<Op>({"damageInfo1"}, damageInfo1, s); Do<Op>(athena::io::PropId{"damageInfo1"}, damageInfo1, s);
Do<Op>({"ridleyStruct1"}, ridleyStruct1, s); Do<Op>(athena::io::PropId{"ridleyStruct1"}, ridleyStruct1, s);
Do<Op>({"soundID1"}, soundID1, s); Do<Op>(athena::io::PropId{"soundID1"}, soundID1, s);
Do<Op>({"wpsc2"}, wpsc2, s); Do<Op>(athena::io::PropId{"wpsc2"}, wpsc2, s);
if (propertyCount == 40) if (propertyCount == 40)
Do<Op>({"wpsc3"}, wpsc3, s); Do<Op>(athena::io::PropId{"wpsc3"}, wpsc3, s);
Do<Op>({"damageInfo2"}, damageInfo2, s); Do<Op>(athena::io::PropId{"damageInfo2"}, damageInfo2, s);
Do<Op>({"ridleyStruct2_1"}, ridleyStruct2_1, s); Do<Op>(athena::io::PropId{"ridleyStruct2_1"}, ridleyStruct2_1, s);
Do<Op>({"wpsc4"}, wpsc4, s); Do<Op>(athena::io::PropId{"wpsc4"}, wpsc4, s);
Do<Op>({"damageInfo3"}, damageInfo3, s); Do<Op>(athena::io::PropId{"damageInfo3"}, damageInfo3, s);
Do<Op>({"ridleyStruct2_2"}, ridleyStruct2_2, s); Do<Op>(athena::io::PropId{"ridleyStruct2_2"}, ridleyStruct2_2, s);
Do<Op>({"soundID2"}, soundID2, s); Do<Op>(athena::io::PropId{"soundID2"}, soundID2, s);
Do<Op>({"damageInfo4"}, damageInfo4, s); Do<Op>(athena::io::PropId{"damageInfo4"}, damageInfo4, s);
Do<Op>({"ridleyStruct2_3"}, ridleyStruct2_3, s); Do<Op>(athena::io::PropId{"ridleyStruct2_3"}, ridleyStruct2_3, s);
Do<Op>({"unknown5"}, unknown5, s); Do<Op>(athena::io::PropId{"unknown5"}, unknown5, s);
Do<Op>({"unknown6"}, unknown6, s); Do<Op>(athena::io::PropId{"unknown6"}, unknown6, s);
Do<Op>({"damageInfo5"}, damageInfo5, s); Do<Op>(athena::io::PropId{"damageInfo5"}, damageInfo5, s);
Do<Op>({"unknown7"}, unknown7, s); Do<Op>(athena::io::PropId{"unknown7"}, unknown7, s);
Do<Op>({"damageInfo6"}, damageInfo6, s); Do<Op>(athena::io::PropId{"damageInfo6"}, damageInfo6, s);
Do<Op>({"unknown8"}, unknown8, s); Do<Op>(athena::io::PropId{"unknown8"}, unknown8, s);
Do<Op>({"damageInfo7"}, damageInfo7, s); Do<Op>(athena::io::PropId{"damageInfo7"}, damageInfo7, s);
Do<Op>({"unknown9"}, unknown9, s); Do<Op>(athena::io::PropId{"unknown9"}, unknown9, s);
Do<Op>({"elsc"}, elsc, s); Do<Op>(athena::io::PropId{"elsc"}, elsc, s);
Do<Op>({"unknown10"}, unknown10, s); Do<Op>(athena::io::PropId{"unknown10"}, unknown10, s);
Do<Op>({"soundID3"}, soundID3, s); Do<Op>(athena::io::PropId{"soundID3"}, soundID3, s);
Do<Op>({"damageInfo8"}, damageInfo8, s); Do<Op>(athena::io::PropId{"damageInfo8"}, damageInfo8, s);
if (propertyCount == 40) if (propertyCount == 40)
Do<Op>({"damageInfo9"}, damageInfo9, s); Do<Op>(athena::io::PropId{"damageInfo9"}, damageInfo9, s);
} }
const char* Ridley::DNAType() { return "urde::DNAMP1::Ridley"; } const char* Ridley::DNAType() { return "urde::DNAMP1::Ridley"; }

52
DataSpec/DNAMP1/ScriptObjects/WorldTeleporter.cpp
View File

@ -5,34 +5,34 @@ namespace DataSpec::DNAMP1 {
template <class Op> template <class Op>
void WorldTeleporter::Enumerate(typename Op::StreamT& s) { void WorldTeleporter::Enumerate(typename Op::StreamT& s) {
IScriptObject::Enumerate<Op>(s); IScriptObject::Enumerate<Op>(s);
Do<Op>({"name"}, name, s); Do<Op>(athena::io::PropId{"name"}, name, s);
Do<Op>({"active"}, active, s); Do<Op>(athena::io::PropId{"active"}, active, s);
Do<Op>({"mlvl"}, mlvl, s); Do<Op>(athena::io::PropId{"mlvl"}, mlvl, s);
Do<Op>({"mrea"}, mrea, s); Do<Op>(athena::io::PropId{"mrea"}, mrea, s);
Do<Op>({"animationParameters"}, animationParameters, s); Do<Op>(athena::io::PropId{"animationParameters"}, animationParameters, s);
Do<Op>({"playerScale"}, playerScale, s); Do<Op>(athena::io::PropId{"playerScale"}, playerScale, s);
Do<Op>({"platformModel"}, platformModel, s); Do<Op>(athena::io::PropId{"platformModel"}, platformModel, s);
Do<Op>({"platformScale"}, platformScale, s); Do<Op>(athena::io::PropId{"platformScale"}, platformScale, s);
Do<Op>({"blackgroundModel"}, backgroundModel, s); Do<Op>(athena::io::PropId{"blackgroundModel"}, backgroundModel, s);
Do<Op>({"backgroundScale"}, backgroundScale, s); Do<Op>(athena::io::PropId{"backgroundScale"}, backgroundScale, s);
Do<Op>({"upElevator"}, upElevator, s); Do<Op>(athena::io::PropId{"upElevator"}, upElevator, s);
Do<Op>({"elevatorSound"}, elevatorSound, s); Do<Op>(athena::io::PropId{"elevatorSound"}, elevatorSound, s);
Do<Op>({"volume"}, volume, s); Do<Op>(athena::io::PropId{"volume"}, volume, s);
Do<Op>({"panning"}, panning, s); Do<Op>(athena::io::PropId{"panning"}, panning, s);
Do<Op>({"showText"}, showText, s); Do<Op>(athena::io::PropId{"showText"}, showText, s);
Do<Op>({"font"}, font, s); Do<Op>(athena::io::PropId{"font"}, font, s);
Do<Op>({"strg"}, strg, s); Do<Op>(athena::io::PropId{"strg"}, strg, s);
Do<Op>({"fadeWhite"}, fadeWhite, s); Do<Op>(athena::io::PropId{"fadeWhite"}, fadeWhite, s);
Do<Op>({"charFadeInTime"}, charFadeInTime, s); Do<Op>(athena::io::PropId{"charFadeInTime"}, charFadeInTime, s);
Do<Op>({"charsPerSecond"}, charsPerSecond, s); Do<Op>(athena::io::PropId{"charsPerSecond"}, charsPerSecond, s);
Do<Op>({"showDelay"}, showDelay, s); Do<Op>(athena::io::PropId{"showDelay"}, showDelay, s);
if (propertyCount == 26) { if (propertyCount == 26) {
Do<Op>({"audioStream"}, audioStream, s); Do<Op>(athena::io::PropId{"audioStream"}, audioStream, s);
Do<Op>({"unknown13"}, unknown13, s); Do<Op>(athena::io::PropId{"unknown13"}, unknown13, s);
Do<Op>({"unknown14"}, unknown14, s); Do<Op>(athena::io::PropId{"unknown14"}, unknown14, s);
Do<Op>({"unknown15"}, unknown15, s); Do<Op>(athena::io::PropId{"unknown15"}, unknown15, s);
Do<Op>({"unknown16"}, unknown16, s); Do<Op>(athena::io::PropId{"unknown16"}, unknown16, s);
} else { } else {
unknown13 = false; unknown13 = false;
unknown14 = 0.0; unknown14 = 0.0;

18
DataSpec/DNAMP2/ANCS.cpp
View File

@ -525,17 +525,17 @@ const char* ANCS::AnimationSet::DNAType() { return "urde::DNAMP2::ANCS::Animatio
template <class Op> template <class Op>
void ANCS::AnimationSet::EVNT::Enumerate(typename Op::StreamT& s) { void ANCS::AnimationSet::EVNT::Enumerate(typename Op::StreamT& s) {
Do<Op>({"version"}, version, s); Do<Op>(athena::io::PropId{"version"}, version, s);
DoSize<Op>({"loopEventCount"}, loopEventCount, s); DoSize<Op>(athena::io::PropId{"loopEventCount"}, loopEventCount, s);
Do<Op>({"loopEvents"}, loopEvents, loopEventCount, s); Do<Op>(athena::io::PropId{"loopEvents"}, loopEvents, loopEventCount, s);
if (version == 2) { if (version == 2) {
DoSize<Op>({"uevtEventCount"}, uevtEventCount, s); DoSize<Op>(athena::io::PropId{"uevtEventCount"}, uevtEventCount, s);
Do<Op>({"uevtEvents"}, uevtEvents, uevtEventCount, s); Do<Op>(athena::io::PropId{"uevtEvents"}, uevtEvents, uevtEventCount, s);
} }
DoSize<Op>({"effectEventCount"}, effectEventCount, s); DoSize<Op>(athena::io::PropId{"effectEventCount"}, effectEventCount, s);
Do<Op>({"effectEvents"}, effectEvents, effectEventCount, s); Do<Op>(athena::io::PropId{"effectEvents"}, effectEvents, effectEventCount, s);
DoSize<Op>({"sfxEventCount"}, sfxEventCount, s); DoSize<Op>(athena::io::PropId{"sfxEventCount"}, sfxEventCount, s);
Do<Op>({"sfxEvents"}, sfxEvents, sfxEventCount, s); Do<Op>(athena::io::PropId{"sfxEvents"}, sfxEvents, sfxEventCount, s);
} }
AT_SPECIALIZE_DNA(ANCS::AnimationSet::EVNT) AT_SPECIALIZE_DNA(ANCS::AnimationSet::EVNT)

10
DataSpec/DNAMP3/CAUD.cpp
View File

@ -4,12 +4,12 @@ namespace DataSpec::DNAMP3 {
template <class Op> template <class Op>
void CAUD::CSMPInfo::UnknownStruct2::UnknownQuad::Enumerate(typename Op::StreamT& s) { void CAUD::CSMPInfo::UnknownStruct2::UnknownQuad::Enumerate(typename Op::StreamT& s) {
Do<Op>({"unknown1"}, unknown1, s); Do<Op>(athena::io::PropId{"unknown1"}, unknown1, s);
Do<Op>({"unknown2"}, unknown2, s); Do<Op>(athena::io::PropId{"unknown2"}, unknown2, s);
Do<Op>({"unknown3"}, unknown3, s); Do<Op>(athena::io::PropId{"unknown3"}, unknown3, s);
Do<Op>({"unknown4"}, unknown4, s); Do<Op>(athena::io::PropId{"unknown4"}, unknown4, s);
if (unknown4 == 5) if (unknown4 == 5)
Do<Op>({"unknown5"}, unknown5, s); Do<Op>(athena::io::PropId{"unknown5"}, unknown5, s);
} }
AT_SPECIALIZE_DNA_YAML(CAUD::CSMPInfo::UnknownStruct2::UnknownQuad) AT_SPECIALIZE_DNA_YAML(CAUD::CSMPInfo::UnknownStruct2::UnknownQuad)

2
amuse

@ -1 +1 @@
Subproject commit 80da83eb161c3c2493da522d44580a65eda38ed3 Subproject commit 107ddeb5a9dfe3e336c26c285ce0be0b8f0ebd2c