ANCS fixes and cleanup

DataSpec/DNAMP1/ANCS.cpp

@@ -10,7 +10,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::read(A
     parmType = reader.readUint32();
     unk1 = reader.readUint32();
     unk2 = reader.readFloat();
-    switch(DataType(parmType))
+    switch (DataType(parmType))
     {
     case DataType::DTInt32:
         parmVals[0].int32 = reader.readInt32();
@@ -37,7 +37,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::write(
     writer.writeUint32(parmType);
     writer.writeUint32(unk1);
     writer.writeFloat(unk2);
-    switch(DataType(parmType))
+    switch (DataType(parmType))
     {
     case DataType::DTInt32:
         writer.writeInt32(parmVals[0].int32);
@@ -65,7 +65,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::fromYA
     unk1 = reader.readUint32("unk1");
     unk2 = reader.readFloat("unk2");
     reader.enterSubVector("parmVals");
-    switch(DataType(parmType))
+    switch (DataType(parmType))
     {
     case DataType::DTInt32:
         parmVals[0].int32 = reader.readInt32(nullptr);
@@ -95,7 +95,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::toYAML
     writer.writeUint32("unk1", unk1);
     writer.writeFloat("unk2", unk2);
     writer.enterSubVector("parmVals");
-    switch(DataType(parmType))
+    switch (DataType(parmType))
     {
     case DataType::DTInt32:
         writer.writeInt32(nullptr, parmVals[0].int32);
@@ -124,23 +124,18 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(Athena::io:
     atUint32 parmInfoCount = reader.readUint32();
     atUint32 animInfoCount = reader.readUint32();
 
-    parmInfos.reserve(parmInfoCount);
-    for (int i=0 ; i<parmInfoCount ; ++i)
-    {
-        parmInfos.emplace_back();
-        parmInfos.back().read(reader);
-    }
+    reader.enumerate(parmInfos, parmInfoCount);
 
+    animInfos.clear();
     animInfos.reserve(animInfoCount);
-    for (int i=0 ; i<animInfoCount ; ++i)
+    reader.enumerate<AnimInfo>(animInfos, animInfoCount,
+    [this, parmInfoCount](Athena::io::IStreamReader& reader, AnimInfo& ai)
     {
-        animInfos.emplace_back();
-        AnimInfo& ai = animInfos.back();
         ai.id = reader.readUint32();
         ai.parmVals.reserve(parmInfoCount);
         for (const ParmInfo& pi : parmInfos)
         {
-            switch(ParmInfo::DataType(pi.parmType))
+            switch (ParmInfo::DataType(pi.parmType))
             {
             case ParmInfo::DTInt32:
                 ai.parmVals.emplace_back(reader.readInt32());
@@ -158,7 +153,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(Athena::io:
             default: break;
             }
         }
-    }
+    });
 }
 
 void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::write(Athena::io::IStreamWriter& writer) const
@@ -179,7 +174,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::write(Athena::io
             ParmInfo::Parm pVal;
             if (it != ai.parmVals.end())
                 pVal = *it++;
-            switch(ParmInfo::DataType(pi.parmType))
+            switch (ParmInfo::DataType(pi.parmType))
             {
             case ParmInfo::DTInt32:
                 writer.writeInt32(pVal.int32);
@@ -206,28 +201,17 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::fromYAML(Athena:
     atUint32 parmInfoCount = reader.readUint32("parmInfoCount");
     atUint32 animInfoCount = reader.readUint32("animInfoCount");
 
-    parmInfos.reserve(parmInfoCount);
-    reader.enterSubVector("parmInfos");
-    for (int i=0 ; i<parmInfoCount ; ++i)
-    {
-        parmInfos.emplace_back();
-        parmInfos.back().fromYAML(reader);
-    }
-    reader.leaveSubVector();
+    reader.enumerate("parmInfos", parmInfos, parmInfoCount);
 
-    animInfos.reserve(animInfoCount);
-    reader.enterSubVector("animInfos");
-    for (int i=0 ; i<animInfoCount ; ++i)
+    reader.enumerate<AnimInfo>("animInfos", animInfos, animInfoCount,
+    [this, parmInfoCount](Athena::io::YAMLDocReader& reader, AnimInfo& ai)
     {
-        animInfos.emplace_back();
-        AnimInfo& ai = animInfos.back();
-        reader.enterSubRecord(nullptr);
         ai.id = reader.readUint32("id");
         ai.parmVals.reserve(parmInfoCount);
         reader.enterSubVector("parmVals");
         for (const ParmInfo& pi : parmInfos)
         {
-            switch(ParmInfo::DataType(pi.parmType))
+            switch (ParmInfo::DataType(pi.parmType))
             {
             case ParmInfo::DTInt32:
                 ai.parmVals.emplace_back(reader.readInt32(nullptr));
@@ -246,9 +230,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::fromYAML(Athena:
             }
         }
         reader.leaveSubVector();
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    });
 }
 
 void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::toYAML(Athena::io::YAMLDocWriter& writer) const
@@ -257,19 +239,11 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::toYAML(Athena::i
     writer.writeUint32("parmInfoCount", parmInfos.size());
     writer.writeUint32("animInfoCount", animInfos.size());
 
-    writer.enterSubVector("parmInfos");
-    for (const ParmInfo& pi : parmInfos)
-    {
-        writer.enterSubRecord(nullptr);
-        pi.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("parmInfos", parmInfos);
 
-    writer.enterSubVector("animInfos");
-    for (const AnimInfo& ai : animInfos)
+    writer.enumerate<AnimInfo>("animInfos", animInfos,
+    [this](Athena::io::YAMLDocWriter& writer, const AnimInfo& ai)
     {
-        writer.enterSubRecord("info");
         writer.writeUint32("id", ai.id);
         auto it = ai.parmVals.begin();
         writer.enterSubVector("parms");
@@ -278,7 +252,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::toYAML(Athena::i
             ParmInfo::Parm pVal;
             if (it != ai.parmVals.end())
                 pVal = *it++;
-            switch(ParmInfo::DataType(pi.parmType))
+            switch (ParmInfo::DataType(pi.parmType))
             {
             case ParmInfo::DTInt32:
                 writer.writeInt32(nullptr, pVal.int32);
@@ -297,9 +271,7 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::toYAML(Athena::i
             }
         }
         writer.leaveSubVector();
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    });
 }
 
 void ANCS::CharacterSet::CharacterInfo::read(Athena::io::IStreamReader& reader)
@@ -312,78 +284,45 @@ void ANCS::CharacterSet::CharacterInfo::read(Athena::io::IStreamReader& reader)
     cinf.read(reader);
 
     atUint32 animationCount = reader.readUint32();
-    animations.reserve(animationCount);
-    for (int i=0 ; i<animationCount ; ++i)
-    {
-        animations.emplace_back();
-        animations.back().read(reader);
-    }
+    reader.enumerate(animations, animationCount);
 
     pasDatabase.read(reader);
 
     atUint32 partCount = reader.readUint32();
-    partResData.part.clear();
-    partResData.part.reserve(partCount);
-    for (int i=0 ; i<partCount ; ++i)
-    {
-        partResData.part.emplace_back();
-        partResData.part.back().read(reader);
-    }
+    reader.enumerate(partResData.part, partCount);
 
     atUint32 swhcCount = reader.readUint32();
-    partResData.swhc.clear();
-    partResData.swhc.reserve(swhcCount);
-    for (int i=0 ; i<swhcCount ; ++i)
-    {
-        partResData.swhc.emplace_back();
-        partResData.swhc.back().read(reader);
-    }
+    reader.enumerate(partResData.swhc, swhcCount);
 
     atUint32 unkCount = reader.readUint32();
-    partResData.unk.clear();
-    partResData.unk.reserve(unkCount);
-    for (int i=0 ; i<unkCount ; ++i)
-    {
-        partResData.unk.emplace_back();
-        partResData.unk.back().read(reader);
-    }
+    reader.enumerate(partResData.unk, unkCount);
 
+    partResData.elsc.clear();
     if (sectionCount > 5)
     {
         atUint32 elscCount = reader.readUint32();
-        partResData.elsc.clear();
-        partResData.elsc.reserve(elscCount);
-        for (int i=0 ; i<elscCount ; ++i)
-        {
-            partResData.elsc.emplace_back();
-            partResData.elsc.back().read(reader);
-        }
+        reader.enumerate(partResData.elsc, elscCount);
     }
 
     unk1 = reader.readUint32();
+    if (sectionCount > 9)
+    {
+        unk2 = reader.readUint32();
+        unk3 = reader.readUint32();
+    }
 
     animAABBs.clear();
     if (sectionCount > 1)
     {
         atUint32 aabbCount = reader.readUint32();
-        animAABBs.reserve(aabbCount);
-        for (int i=0 ; i<aabbCount ; ++i)
-        {
-            animAABBs.emplace_back();
-            animAABBs.back().read(reader);
-        }
+        reader.enumerate(animAABBs, aabbCount);
     }
 
     effects.clear();
     if (sectionCount > 2)
     {
         atUint32 effectCount = reader.readUint32();
-        effects.reserve(effectCount);
-        for (int i=0 ; i<effectCount ; ++i)
-        {
-            effects.emplace_back();
-            effects.back().read(reader);
-        }
+        reader.enumerate(effects, effectCount);
     }
 
     if (sectionCount > 3)
@@ -396,9 +335,7 @@ void ANCS::CharacterSet::CharacterInfo::read(Athena::io::IStreamReader& reader)
     if (sectionCount > 4)
     {
         atUint32 aidxCount = reader.readUint32();
-        animIdxs.reserve(aidxCount);
-        for (int i=0 ; i<aidxCount ; ++i)
-            animIdxs.emplace_back(reader.readUint32());
+        reader.enumerate(animIdxs, aidxCount);
     }
 }
 
@@ -407,7 +344,9 @@ void ANCS::CharacterSet::CharacterInfo::write(Athena::io::IStreamWriter& writer)
     writer.writeUint32(idx);
 
     atUint16 sectionCount;
-    if (partResData.elsc.size())
+    if (unk2 || unk3)
+        sectionCount = 10;
+    else if (partResData.elsc.size())
         sectionCount = 6;
     else if (animIdxs.size())
         sectionCount = 5;
@@ -427,44 +366,42 @@ void ANCS::CharacterSet::CharacterInfo::write(Athena::io::IStreamWriter& writer)
     cinf.write(writer);
 
     writer.writeUint32(animations.size());
-    for (const Animation& anim : animations)
-        anim.write(writer);
+    writer.enumerate(animations);
 
     pasDatabase.write(writer);
 
     writer.writeUint32(partResData.part.size());
-    for (const UniqueID32& id : partResData.part)
-        id.write(writer);
+    writer.enumerate(partResData.part);
 
     writer.writeUint32(partResData.swhc.size());
-    for (const UniqueID32& id : partResData.swhc)
-        id.write(writer);
+    writer.enumerate(partResData.swhc);
 
     writer.writeUint32(partResData.unk.size());
-    for (const UniqueID32& id : partResData.unk)
-        id.write(writer);
+    writer.enumerate(partResData.unk);
 
     if (sectionCount > 5)
     {
         writer.writeUint32(partResData.elsc.size());
-        for (const UniqueID32& id : partResData.elsc)
-            id.write(writer);
+        writer.enumerate(partResData.elsc);
     }
 
     writer.writeUint32(unk1);
+    if (sectionCount > 9)
+    {
+        writer.writeUint32(unk2);
+        writer.writeUint32(unk3);
+    }
 
     if (sectionCount > 1)
     {
         writer.writeUint32(animAABBs.size());
-        for (const ActionAABB& aabb : animAABBs)
-            aabb.write(writer);
+        writer.enumerate(animAABBs);
     }
 
     if (sectionCount > 2)
     {
         writer.writeUint32(effects.size());
-        for (const Effect& effect : effects)
-            effect.write(writer);
+        writer.enumerate(effects);
     }
 
     if (sectionCount > 3)
@@ -486,140 +423,63 @@ void ANCS::CharacterSet::CharacterInfo::fromYAML(Athena::io::YAMLDocReader& read
     idx = reader.readUint32("idx");
     atUint16 sectionCount = reader.readUint16("sectionCount");
     name = reader.readString("name");
-    reader.enterSubRecord("cmdl");
-    cmdl.fromYAML(reader);
-    reader.leaveSubRecord();
-    reader.enterSubRecord("cskr");
-    cskr.fromYAML(reader);
-    reader.leaveSubRecord();
-    reader.enterSubRecord("cinf");
-    cinf.fromYAML(reader);
-    reader.leaveSubRecord();
+    reader.enumerate("cmdl", cmdl);
+    reader.enumerate("cskr", cskr);
+    reader.enumerate("cinf", cinf);
 
     atUint32 animationCount = reader.readUint32("animationCount");
-    animations.reserve(animationCount);
-    reader.enterSubVector("animations");
-    for (int i=0 ; i<animationCount ; ++i)
-    {
-        animations.emplace_back();
-        reader.enterSubRecord(nullptr);
-        animations.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("animations", animations, animationCount);
 
-    reader.enterSubRecord("pasDatabase");
-    pasDatabase.fromYAML(reader);
-    reader.leaveSubRecord();
+    reader.enumerate("pasDatabase", pasDatabase);
 
     atUint32 partCount = reader.readUint32("partCount");
-    partResData.part.clear();
-    partResData.part.reserve(partCount);
-    reader.enterSubVector("part");
-    for (int i=0 ; i<partCount ; ++i)
-    {
-        partResData.part.emplace_back();
-        reader.enterSubRecord(nullptr);
-        partResData.part.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("part", partResData.part, partCount);
 
     atUint32 swhcCount = reader.readUint32("swhcCount");
-    partResData.swhc.clear();
-    partResData.swhc.reserve(swhcCount);
-    reader.enterSubVector("swhc");
-    for (int i=0 ; i<swhcCount ; ++i)
-    {
-        partResData.swhc.emplace_back();
-        reader.enterSubRecord(nullptr);
-        partResData.swhc.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("swhc", partResData.swhc, swhcCount);
 
     atUint32 unkCount = reader.readUint32("unkCount");
-    partResData.unk.clear();
-    partResData.unk.reserve(unkCount);
-    reader.enterSubVector("unk");
-    for (int i=0 ; i<unkCount ; ++i)
-    {
-        partResData.unk.emplace_back();
-        reader.enterSubRecord(nullptr);
-        partResData.unk.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("unk", partResData.unk, unkCount);
 
+    partResData.elsc.clear();
     if (sectionCount > 5)
     {
         atUint32 elscCount = reader.readUint32("elscCount");
-        partResData.elsc.clear();
-        partResData.elsc.reserve(elscCount);
-        reader.enterSubVector("elsc");
-        for (int i=0 ; i<elscCount ; ++i)
-        {
-            partResData.elsc.emplace_back();
-            reader.enterSubRecord(nullptr);
-            partResData.elsc.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("elsc", partResData.elsc, elscCount);
     }
 
     unk1 = reader.readUint32("unk1");
+    if (sectionCount > 9)
+    {
+        unk2 = reader.readUint32("unk2");
+        unk3 = reader.readUint32("unk3");
+    }
 
     animAABBs.clear();
     if (sectionCount > 1)
     {
         atUint32 aabbCount = reader.readUint32("animAABBCount");
-        animAABBs.reserve(aabbCount);
-        reader.enterSubVector("animAABBs");
-        for (int i=0 ; i<aabbCount ; ++i)
-        {
-            animAABBs.emplace_back();
-            reader.enterSubRecord(nullptr);
-            animAABBs.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("part", animAABBs, aabbCount);
     }
 
     effects.clear();
     if (sectionCount > 2)
     {
         atUint32 effectCount = reader.readUint32("effectCount");
-        effects.reserve(effectCount);
-        reader.enterSubVector("effects");
-        for (int i=0 ; i<effectCount ; ++i)
-        {
-            effects.emplace_back();
-            reader.enterSubRecord(nullptr);
-            effects.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("effects", effects, effectCount);
     }
 
     if (sectionCount > 3)
     {
-        reader.enterSubRecord("cmdlOverride");
-        cmdlOverride.fromYAML(reader);
-        reader.leaveSubRecord();
-        reader.enterSubRecord("cskrOverride");
-        cskrOverride.fromYAML(reader);
-        reader.leaveSubRecord();
+        reader.enumerate("cmdlOverride", cmdlOverride);
+        reader.enumerate("cskrOverride", cskrOverride);
     }
 
     animIdxs.clear();
     if (sectionCount > 4)
     {
         atUint32 animIdxCount = reader.readUint32("animIdxCount");
-        animIdxs.reserve(animIdxCount);
-        reader.enterSubVector("animIdxs");
-        for (int i=0 ; i<animIdxCount ; ++i)
-            animIdxs.emplace_back(reader.readUint32(nullptr));
-        reader.leaveSubVector();
+        reader.enumerate("animIdxs", animIdxs, animIdxCount);
     }
 }
 
@@ -628,7 +488,9 @@ void ANCS::CharacterSet::CharacterInfo::toYAML(Athena::io::YAMLDocWriter& writer
     writer.writeUint32("idx", idx);
 
     atUint16 sectionCount;
-    if (partResData.elsc.size())
+    if (unk2 || unk3)
+        sectionCount = 10;
+    else if (partResData.elsc.size())
         sectionCount = 6;
     else if (animIdxs.size())
         sectionCount = 5;
@@ -643,118 +505,59 @@ void ANCS::CharacterSet::CharacterInfo::toYAML(Athena::io::YAMLDocWriter& writer
     writer.writeUint16("sectionCount", sectionCount);
 
     writer.writeString("name", name);
-    writer.enterSubRecord("cmdl");
-    cmdl.toYAML(writer);
-    writer.leaveSubRecord();
-    writer.enterSubRecord("cskr");
-    cskr.toYAML(writer);
-    writer.leaveSubRecord();
-    writer.enterSubRecord("cinf");
-    cinf.toYAML(writer);
-    writer.leaveSubRecord();
+    writer.enumerate("cmdl", cmdl);
+    writer.enumerate("cskr", cskr);
+    writer.enumerate("cinf", cinf);
 
     writer.writeUint32("animationCount", animations.size());
-    writer.enterSubVector("animations");
-    for (const Animation& anim : animations)
-    {
-        writer.enterSubRecord(nullptr);
-        anim.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("animations", animations);
 
-    writer.enterSubRecord("pasDatabase");
-    pasDatabase.toYAML(writer);
-    writer.leaveSubRecord();
+    writer.enumerate("pasDatabase", pasDatabase);
 
     writer.writeUint32("partCount", partResData.part.size());
-    writer.enterSubVector("part");
-    for (const UniqueID32& id : partResData.part)
-    {
-        writer.enterSubRecord(nullptr);
-        id.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("part", partResData.part);
 
     writer.writeUint32("swhcCount", partResData.swhc.size());
-    writer.enterSubVector("swhc");
-    for (const UniqueID32& id : partResData.swhc)
-    {
-        writer.enterSubRecord(nullptr);
-        id.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("swhc", partResData.swhc);
 
     writer.writeUint32("unkCount", partResData.unk.size());
-    writer.enterSubVector("unk");
-    for (const UniqueID32& id : partResData.unk)
-    {
-        writer.enterSubRecord(nullptr);
-        id.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("unk", partResData.unk);
 
     if (sectionCount > 5)
     {
         writer.writeUint32("elscCount", partResData.elsc.size());
-        writer.enterSubVector("elsc");
-        for (const UniqueID32& id : partResData.elsc)
-        {
-            writer.enterSubRecord(nullptr);
-            id.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("elsc", partResData.elsc);
     }
 
     writer.writeUint32("unk1", unk1);
+    if (sectionCount > 9)
+    {
+        writer.writeUint32("unk2", unk2);
+        writer.writeUint32("unk3", unk3);
+    }
 
     if (sectionCount > 1)
     {
         writer.writeUint32("animAABBCount", animAABBs.size());
-        writer.enterSubVector("animAABBs");
-        for (const ActionAABB& aabb : animAABBs)
-        {
-            writer.enterSubRecord(nullptr);
-            aabb.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("animAABBs", animAABBs);
     }
 
     if (sectionCount > 2)
     {
         writer.writeUint32("effectCount", effects.size());
-        writer.enterSubVector("effects");
-        for (const Effect& effect : effects)
-        {
-            writer.enterSubRecord(nullptr);
-            effect.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("effects", effects);
     }
 
     if (sectionCount > 3)
     {
-        writer.enterSubRecord("cmdlOverride");
-        cmdlOverride.toYAML(writer);
-        writer.leaveSubRecord();
-        writer.enterSubRecord("cskrOverride");
-        cskrOverride.toYAML(writer);
-        writer.leaveSubRecord();
+        writer.enumerate("cmdlOverride", cmdlOverride);
+        writer.enumerate("cskrOverride", cskrOverride);
     }
 
     if (sectionCount > 4)
     {
         writer.writeUint32("animIdxCount", animIdxs.size());
-        writer.enterSubVector("animIdxs");
-        for (atUint32 idx : animIdxs)
-            writer.writeUint32(nullptr, idx);
-        writer.leaveSubVector();
+        writer.enumerate("animIdxs", animIdxs);
     }
 }
 
@@ -833,6 +636,14 @@ void ANCS::AnimationSet::MetaAnimFactory::fromYAML(Athena::io::YAMLDocReader& re
 
 }
 
+void ANCS::AnimationSet::MetaAnimFactory::toYAML(Athena::io::YAMLDocWriter& writer) const
+{
+    if (!m_anim)
+        return;
+    writer.writeString("type", m_anim->m_typeStr);
+    m_anim->toYAML(writer);
+}
+
 void ANCS::AnimationSet::MetaTransFactory::read(Athena::io::IStreamReader& reader)
 {
     IMetaTrans::Type type(IMetaTrans::Type(reader.readUint32()));
@@ -905,67 +716,38 @@ void ANCS::AnimationSet::MetaTransFactory::toYAML(Athena::io::YAMLDocWriter& wri
     m_trans->toYAML(writer);
 }
 
-void ANCS::AnimationSet::MetaAnimFactory::toYAML(Athena::io::YAMLDocWriter& writer) const
-{
-    if (!m_anim)
-        return;
-    writer.writeString("type", m_anim->m_typeStr);
-    m_anim->toYAML(writer);
-}
-
 void ANCS::AnimationSet::read(Athena::io::IStreamReader& reader)
 {
     atUint16 sectionCount = reader.readUint16();
 
     atUint32 animationCount = reader.readUint32();
-    animations.reserve(animationCount);
-    for (int i=0 ; i<animationCount ; ++i)
-    {
-        animations.emplace_back();
-        animations.back().read(reader);
-    }
+    reader.enumerate(animations, animationCount);
 
     atUint32 transitionCount = reader.readUint32();
-    transitions.reserve(transitionCount);
-    for (int i=0 ; i<transitionCount ; ++i)
-    {
-        transitions.emplace_back();
-        transitions.back().read(reader);
-    }
+    reader.enumerate(transitions, transitionCount);
+    defaultTransition.read(reader);
 
+    additiveAnims.clear();
     if (sectionCount > 1)
     {
         atUint32 additiveAnimCount = reader.readUint32();
-        additiveAnims.reserve(additiveAnimCount);
-        for (int i=0 ; i<additiveAnimCount ; ++i)
-        {
-            additiveAnims.emplace_back();
-            additiveAnims.back().read(reader);
-        }
+        reader.enumerate(additiveAnims, additiveAnimCount);
         floatA = reader.readFloat();
         floatB = reader.readFloat();
     }
 
+    halfTransitions.clear();
     if (sectionCount > 2)
     {
         atUint32 halfTransitionCount = reader.readUint32();
-        halfTransitions.reserve(halfTransitionCount);
-        for (int i=0 ; i<halfTransitionCount ; ++i)
-        {
-            halfTransitions.emplace_back();
-            halfTransitions.back().read(reader);
-        }
+        reader.enumerate(halfTransitions, halfTransitionCount);
     }
 
+    animResources.clear();
     if (sectionCount > 3)
     {
         atUint32 animResourcesCount = reader.readUint32();
-        animResources.reserve(animResourcesCount);
-        for (int i=0 ; i<animResourcesCount ; ++i)
-        {
-            animResources.emplace_back();
-            animResources.back().read(reader);
-        }
+        reader.enumerate(animResources, animResourcesCount);
     }
 }
 
@@ -984,18 +766,16 @@ void ANCS::AnimationSet::write(Athena::io::IStreamWriter& writer) const
     writer.writeUint16(sectionCount);
 
     writer.writeUint32(animations.size());
-    for (const auto& anim : animations)
-        anim.write(writer);
+    writer.enumerate(animations);
 
     writer.writeUint32(transitions.size());
-    for (const auto& trans : transitions)
-        trans.write(writer);
+    writer.enumerate(transitions);
+    defaultTransition.write(writer);
 
     if (sectionCount > 1)
     {
         writer.writeUint32(additiveAnims.size());
-        for (const auto& aa : additiveAnims)
-            aa.write(writer);
+        writer.enumerate(additiveAnims);
         writer.writeFloat(floatA);
         writer.writeFloat(floatB);
     }
@@ -1003,15 +783,13 @@ void ANCS::AnimationSet::write(Athena::io::IStreamWriter& writer) const
     if (sectionCount > 2)
     {
         writer.writeUint32(halfTransitions.size());
-        for (const auto& ht : halfTransitions)
-            ht.write(writer);
+        writer.enumerate(halfTransitions);
     }
 
     if (sectionCount > 3)
     {
         writer.writeUint32(animResources.size());
-        for (const auto& ar : animResources)
-            ar.write(writer);
+        writer.enumerate(animResources);
     }
 }
 
@@ -1020,74 +798,33 @@ void ANCS::AnimationSet::fromYAML(Athena::io::YAMLDocReader& reader)
     atUint16 sectionCount = reader.readUint16("sectionCount");
 
     atUint32 animationCount = reader.readUint32("animationCount");
-    animations.reserve(animationCount);
-    reader.enterSubVector("animations");
-    for (int i=0 ; i<animationCount ; ++i)
-    {
-        animations.emplace_back();
-        reader.enterSubRecord(nullptr);
-        animations.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("animations", animations, animationCount);
 
     atUint32 transitionCount = reader.readUint32("transitionCount");
-    transitions.reserve(transitionCount);
-    reader.enterSubVector("transitions");
-    for (int i=0 ; i<transitionCount ; ++i)
-    {
-        transitions.emplace_back();
-        reader.enterSubRecord(nullptr);
-        transitions.back().fromYAML(reader);
-        reader.leaveSubRecord();
-    }
-    reader.leaveSubVector();
+    reader.enumerate("transitions", transitions, transitionCount);
+    reader.enumerate("defaultTransition", defaultTransition);
 
+    additiveAnims.clear();
     if (sectionCount > 1)
     {
         atUint32 additiveAnimCount = reader.readUint32("additiveAnimCount");
-        additiveAnims.reserve(additiveAnimCount);
-        reader.enterSubVector("additiveAnims");
-        for (int i=0 ; i<additiveAnimCount ; ++i)
-        {
-            additiveAnims.emplace_back();
-            reader.enterSubRecord(nullptr);
-            additiveAnims.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("additiveAnims", additiveAnims, additiveAnimCount);
         floatA = reader.readFloat("floatA");
         floatB = reader.readFloat("floatB");
     }
 
+    halfTransitions.clear();
     if (sectionCount > 2)
     {
         atUint32 halfTransitionCount = reader.readUint32("halfTransitionCount");
-        halfTransitions.reserve(halfTransitionCount);
-        reader.enterSubVector("halfTransitions");
-        for (int i=0 ; i<halfTransitionCount ; ++i)
-        {
-            halfTransitions.emplace_back();
-            reader.enterSubRecord(nullptr);
-            halfTransitions.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("halfTransitions", halfTransitions, halfTransitionCount);
     }
 
+    animResources.clear();
     if (sectionCount > 3)
     {
         atUint32 animResourcesCount = reader.readUint32("animResourcesCount");
-        animResources.reserve(animResourcesCount);
-        reader.enterSubVector("animResources");
-        for (int i=0 ; i<animResourcesCount ; ++i)
-        {
-            animResources.emplace_back();
-            reader.enterSubRecord(nullptr);
-            animResources.back().fromYAML(reader);
-            reader.leaveSubRecord();
-        }
-        reader.leaveSubVector();
+        reader.enumerate("animResources", animResources, animResourcesCount);
     }
 }
 
@@ -1106,36 +843,16 @@ void ANCS::AnimationSet::toYAML(Athena::io::YAMLDocWriter& writer) const
     writer.writeUint16("sectionCount", sectionCount);
 
     writer.writeUint32("animationCount", animations.size());
-    writer.enterSubVector("animations");
-    for (const auto& anim : animations)
-    {
-        writer.enterSubRecord(nullptr);
-        anim.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("animations", animations);
 
     writer.writeUint32("transitionCount", transitions.size());
-    writer.enterSubVector("transitions");
-    for (const auto& trans : transitions)
-    {
-        writer.enterSubRecord(nullptr);
-        trans.toYAML(writer);
-        writer.leaveSubRecord();
-    }
-    writer.leaveSubVector();
+    writer.enumerate("transitions", transitions);
+    writer.enumerate("defaultTransition", defaultTransition);
 
     if (sectionCount > 1)
     {
         writer.writeUint32("additiveAnimCount", additiveAnims.size());
-        writer.enterSubVector("additiveAnims");
-        for (const auto& aa : additiveAnims)
-        {
-            writer.enterSubRecord(nullptr);
-            aa.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("additiveAnims", additiveAnims);
         writer.writeFloat("floatA", floatA);
         writer.writeFloat("floatB", floatB);
     }
@@ -1143,27 +860,13 @@ void ANCS::AnimationSet::toYAML(Athena::io::YAMLDocWriter& writer) const
     if (sectionCount > 2)
     {
         writer.writeUint32("halfTransitionCount", halfTransitions.size());
-        writer.enterSubVector("halfTransitions");
-        for (const auto& ht : halfTransitions)
-        {
-            writer.enterSubRecord(nullptr);
-            ht.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("halfTransitions", halfTransitions);
     }
 
     if (sectionCount > 3)
     {
         writer.writeUint32("animResourcesCount", animResources.size());
-        writer.enterSubVector("animResources");
-        for (const auto& ar : animResources)
-        {
-            writer.enterSubRecord(nullptr);
-            ar.toYAML(writer);
-            writer.leaveSubRecord();
-        }
-        writer.leaveSubVector();
+        writer.enumerate("animResources", animResources);
     }
 }