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

Massive template-based DNA refactor

This commit is contained in:
Jack Andersen 2018-02-21 21:24:51 -10:00
parent b405f33ded
commit e4ff23c279
265 changed files with 3993 additions and 5773 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
DataSpec/DNACommon/CMDL.cpp
View File

@ -1273,7 +1273,7 @@ bool WriteCMDL(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPath
mesh.colorLayerCount, mesh.uvLayerCount,
false, false, groupIdx);
endOff = targetMSet.materials.back().binarySize(endOff);
targetMSet.materials.back().binarySize(endOff);
targetMSet.head.addMaterialEndOff(endOff);
}
@ -1299,7 +1299,8 @@ bool WriteCMDL(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPath
for (const hecl::ProjectPath& path : texPaths)
targetMSet.head.addTexture(path);
size_t secSz = targetMSet.binarySize(0);
size_t secSz = 0;
targetMSet.binarySize(secSz);
size_t secSz32 = ROUND_UP_32(secSz);
head.secSizes.push_back(secSz32);
paddingSizes.push_back(secSz32 - secSz);
@ -1522,14 +1523,15 @@ bool WriteHMDLCMDL(const hecl::ProjectPath& outPath, const hecl::ProjectPath& in
{
std::string diagName = hecl::Format("%s:%s", inPath.getLastComponentUTF8().data(), mat.name.c_str());
targetMSet.materials.emplace_back(FE, diagName, mat, mat.iprops, texPaths);
endOff = targetMSet.materials.back().binarySize(endOff);
targetMSet.materials.back().binarySize(endOff);
targetMSet.head.addMaterialEndOff(endOff);
}
for (const hecl::ProjectPath& path : texPaths)
targetMSet.head.addTexture(path);
size_t secSz = targetMSet.binarySize(0);
size_t secSz = 0;
targetMSet.binarySize(secSz);
size_t secSz32 = ROUND_UP_32(secSz);
head.secSizes.push_back(secSz32);
paddingSizes.push_back(secSz32 - secSz);
@ -1539,7 +1541,8 @@ bool WriteHMDLCMDL(const hecl::ProjectPath& outPath, const hecl::ProjectPath& in
hecl::blender::HMDLBuffers bufs = mesh.getHMDLBuffers(false, poolSkinIndex);
/* Metadata */
size_t secSz = bufs.m_meta.binarySize(0);
size_t secSz = 0;
bufs.m_meta.binarySize(secSz);
size_t secSz32 = ROUND_UP_32(secSz);
if (secSz32 == 0)
secSz32 = 32;
@ -1720,7 +1723,7 @@ bool WriteHMDLMREASecs(std::vector<std::vector<uint8_t>>& secsOut, const hecl::P
std::string diagName = hecl::Format("%s:%s", inPath.getLastComponentUTF8().data(), mat.name.c_str());
matSet.materials.emplace_back(FE, diagName, mat, mat.iprops, texPaths);
endOff = matSet.materials.back().binarySize(endOff);
matSet.materials.back().binarySize(endOff);
matSet.head.addMaterialEndOff(endOff);
}
@ -1731,7 +1734,9 @@ bool WriteHMDLMREASecs(std::vector<std::vector<uint8_t>>& secsOut, const hecl::P
for (const hecl::ProjectPath& path : texPaths)
matSet.head.addTexture(path);
secsOut.emplace_back(matSet.binarySize(0), 0);
size_t secSz = 0;
matSet.binarySize(secSz);
secsOut.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secsOut.back().data(), secsOut.back().size());
matSet.write(w);
}
@ -1757,7 +1762,9 @@ bool WriteHMDLMREASecs(std::vector<std::vector<uint8_t>>& secsOut, const hecl::P
meshHeader.aabb[0] = aabb.min;
meshHeader.aabb[1] = aabb.max;
secsOut.emplace_back(meshHeader.binarySize(0), 0);
size_t secSz = 0;
meshHeader.binarySize(secSz);
secsOut.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secsOut.back().data(), secsOut.back().size());
meshHeader.write(w);
}
@ -1776,7 +1783,9 @@ bool WriteHMDLMREASecs(std::vector<std::vector<uint8_t>>& secsOut, const hecl::P
/* Metadata */
{
secsOut.emplace_back(bufs.m_meta.binarySize(0), 0);
size_t secSz = 0;
bufs.m_meta.binarySize(secSz);
secsOut.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secsOut.back().data(), secsOut.back().size());
bufs.m_meta.write(w);
}
@ -1823,7 +1832,9 @@ bool WriteHMDLMREASecs(std::vector<std::vector<uint8_t>>& secsOut, const hecl::P
header.aabb[0] = aabb.min;
header.aabb[1] = aabb.max;
secsOut.emplace_back(header.binarySize(0), 0);
size_t secSz = 0;
header.binarySize(secSz);
secsOut.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secsOut.back().data(), secsOut.back().size());
header.write(w);
}
@ -1836,7 +1847,8 @@ template bool WriteHMDLMREASecs<DNAMP1::HMDLMaterialSet, DNACMDL::SurfaceHeader_
(std::vector<std::vector<uint8_t>>& secsOut, const hecl::ProjectPath& inPath,
const std::vector<Mesh>& meshes, zeus::CAABox& fullAABB, std::vector<zeus::CAABox>& meshAABBs);
void SurfaceHeader_1::read(athena::io::IStreamReader& reader)
template <>
void SurfaceHeader_1::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
/* centroid */
centroid = reader.readVec3fBig();
@ -1867,7 +1879,8 @@ void SurfaceHeader_1::read(athena::io::IStreamReader& reader)
reader.seekAlign32();
}
void SurfaceHeader_1::write(athena::io::IStreamWriter& writer) const
template <>
void SurfaceHeader_1::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
/* centroid */
writer.writeVec3fBig(centroid);
@ -1895,15 +1908,16 @@ void SurfaceHeader_1::write(athena::io::IStreamWriter& writer) const
writer.seekAlign32();
}
size_t SurfaceHeader_1::binarySize(size_t __isz) const
template <>
void SurfaceHeader_1::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
__isz += (aabbSz ? 24 : 0);
__isz += 44;
__isz = (__isz + 31) & ~31;
return __isz;
s += (aabbSz ? 24 : 0);
s += 44;
s = (s + 31) & ~31;
}
void SurfaceHeader_2::read(athena::io::IStreamReader& reader)
template <>
void SurfaceHeader_2::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
/* centroid */
centroid = reader.readVec3fBig();
@ -1938,7 +1952,8 @@ void SurfaceHeader_2::read(athena::io::IStreamReader& reader)
reader.seekAlign32();
}
void SurfaceHeader_2::write(athena::io::IStreamWriter& writer) const
template <>
void SurfaceHeader_2::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
/* centroid */
writer.writeVec3fBig(centroid);
@ -1970,15 +1985,16 @@ void SurfaceHeader_2::write(athena::io::IStreamWriter& writer) const
writer.seekAlign32();
}
size_t SurfaceHeader_2::binarySize(size_t __isz) const
template <>
void SurfaceHeader_2::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
__isz += (aabbSz ? 24 : 0);
__isz += 48;
__isz = (__isz + 31) & ~31;
return __isz;
s += (aabbSz ? 24 : 0);
s += 48;
s = (s + 31) & ~31;
}
void SurfaceHeader_3::read(athena::io::IStreamReader& reader)
template <>
void SurfaceHeader_3::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
/* centroid */
centroid = reader.readVec3fBig();
@ -2015,7 +2031,8 @@ void SurfaceHeader_3::read(athena::io::IStreamReader& reader)
reader.seekAlign32();
}
void SurfaceHeader_3::write(athena::io::IStreamWriter& writer) const
template <>
void SurfaceHeader_3::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
/* centroid */
writer.writeVec3fBig(centroid);
@ -2049,12 +2066,12 @@ void SurfaceHeader_3::write(athena::io::IStreamWriter& writer) const
writer.seekAlign32();
}
size_t SurfaceHeader_3::binarySize(size_t __isz) const
template <>
void SurfaceHeader_3::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
__isz += (aabbSz ? 24 : 0);
__isz += 49;
__isz = (__isz + 31) & ~31;
return __isz;
s += (aabbSz ? 24 : 0);
s += 49;
s = (s + 31) & ~31;
}
}

10
DataSpec/DNACommon/CMDL.hpp
View File

@ -17,12 +17,12 @@ using Material = hecl::blender::Material;
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> magic;
Value<atUint32> version;
struct Flags : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> flags = 0;
bool shortNormals() const {return (flags & 0x2) != 0;}
void setShortNormals(bool val) {flags &= ~0x2; flags |= val << 1;}
@ -39,7 +39,7 @@ struct Header : BigDNA
struct SurfaceHeader_1 : BigDNA
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
Value<atVec3f> centroid;
Value<atUint32> matIdx = 0;
Value<atUint16> qDiv = 0x8000;
@ -57,7 +57,7 @@ struct SurfaceHeader_1 : BigDNA
struct SurfaceHeader_2 : BigDNA
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
Value<atVec3f> centroid;
Value<atUint32> matIdx = 0;
Value<atUint16> qDiv = 0x8000;
@ -77,7 +77,7 @@ struct SurfaceHeader_2 : BigDNA
struct SurfaceHeader_3 : BigDNA
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
Value<atVec3f> centroid;
Value<atUint32> matIdx = 0;
Value<atUint16> qDiv = 0x8000;

7
DataSpec/DNACommon/CMakeLists.txt
View File

@ -1,5 +1,8 @@
make_dnalist(liblist DNACommon
CMDL
FONT
DGRP
FSM2
MAPA
MAPU
EGMC
@ -27,8 +30,8 @@ set(DNACOMMON_SOURCES
WPSC.hpp WPSC.cpp
DPSC.hpp DPSC.cpp
ParticleCommon.cpp
FONT.hpp FONT.cpp
DGRP.hpp DGRP.cpp
FONT.cpp
DGRP.cpp
ATBL.hpp ATBL.cpp
DeafBabe.hpp DeafBabe.cpp
BabeDead.hpp BabeDead.cpp

31
DataSpec/DNACommon/CRSC.cpp
View File

@ -67,9 +67,14 @@ static const std::vector<FourCC> DecalTypes =
SBIG('CHDL'),SBIG('ENDL')
};
template <>
const char* CRSM<UniqueID32>::DNAType() { return "CRSM<UniqueID32>"; }
template <>
const char* CRSM<UniqueID64>::DNAType() { return "CRSM<UniqueID64>"; }
template <class IDType>
void CRSM<IDType>::read(athena::io::YAMLDocReader& r)
void CRSM<IDType>::_read(athena::io::YAMLDocReader& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
@ -117,7 +122,7 @@ void CRSM<IDType>::read(athena::io::YAMLDocReader& r)
}
template <class IDType>
void CRSM<IDType>::write(athena::io::YAMLDocWriter& w) const
void CRSM<IDType>::_write(athena::io::YAMLDocWriter& w) const
{
for (const auto& pair : x0_generators)
if (pair.second)
@ -140,13 +145,16 @@ void CRSM<IDType>::write(athena::io::YAMLDocWriter& w) const
}
template <class IDType>
size_t CRSM<IDType>::binarySize(size_t __isz) const
void CRSM<IDType>::_binarySize(size_t& __isz) const
{
__isz += 4;
for (const auto& pair : x0_generators)
{
if (pair.second)
__isz = pair.second.binarySize(__isz + 4);
{
__isz += 4;
pair.second.binarySize(__isz);
}
}
for (const auto& pair : x10_sfx)
{
@ -157,18 +165,20 @@ size_t CRSM<IDType>::binarySize(size_t __isz) const
for (const auto& pair : x20_decals)
{
if (pair.second)
__isz = pair.second.binarySize(__isz + 4);
{
__isz += 4;
pair.second.binarySize(__isz);
}
}
if (x30_RNGE != 50.f)
__isz += 12;
if (x34_FOFF != 0.2f)
__isz += 12;
return __isz;
}
template <class IDType>
void CRSM<IDType>::read(athena::io::IStreamReader &r)
void CRSM<IDType>::_read(athena::io::IStreamReader &r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -230,7 +240,7 @@ void CRSM<IDType>::read(athena::io::IStreamReader &r)
}
template <class IDType>
void CRSM<IDType>::write(athena::io::IStreamWriter& w) const
void CRSM<IDType>::_write(athena::io::IStreamWriter& w) const
{
w.writeBytes("CRSM", 4);
for (const auto& pair : x0_generators)
@ -273,6 +283,9 @@ void CRSM<IDType>::write(athena::io::IStreamWriter& w) const
w.writeBytes("_END", 4);
}
AT_SUBSPECIALIZE_DNA_YAML(CRSM<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(CRSM<UniqueID64>)
template <class IDType>
void CRSM<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
@ -302,7 +315,7 @@ bool ExtractCRSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
CRSM<IDType> crsm;
crsm.read(rs);
crsm.toYAMLStream(writer);
athena::io::ToYAMLStream(crsm, writer);
return true;
}
return false;

13
DataSpec/DNACommon/CRSC.hpp
View File

@ -9,23 +9,16 @@
namespace DataSpec::DNAParticle
{
template <class IDType>
struct CRSM : BigYAML
struct CRSM : BigDNA
{
static const char* DNAType() { return "CRSM"; }
const char* DNATypeV() const { return DNAType(); }
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
std::unordered_map<FourCC, ChildResourceFactory<IDType>> x0_generators;
std::unordered_map<FourCC, uint32_t> x10_sfx;
std::unordered_map<FourCC, ChildResourceFactory<IDType>> x20_decals;
float x30_RNGE;
float x34_FOFF;
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
size_t binarySize(size_t __isz) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
CRSM();
void gatherDependencies(std::vector<hecl::ProjectPath>&) const;

102
DataSpec/DNACommon/DGRP.cpp
View File

@ -5,105 +5,6 @@
namespace DataSpec::DNADGRP
{
template <class IDType>
void DGRP<IDType>::read(athena::io::IStreamReader& __dna_reader)
{
/* dependCount */
dependCount = __dna_reader.readUint32Big();
/* depends */
__dna_reader.enumerate(depends, dependCount);
}
template <class IDType>
void DGRP<IDType>::write(athena::io::IStreamWriter& __dna_writer) const
{
/* dependCount */
__dna_writer.writeUint32Big(dependCount);
/* depends */
__dna_writer.enumerate(depends);
}
template <class IDType>
void DGRP<IDType>::read(athena::io::YAMLDocReader& __dna_docin)
{
/* dependCount squelched */
/* depends */
dependCount = __dna_docin.enumerate("depends", depends);
}
template <class IDType>
void DGRP<IDType>::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* dependCount squelched */
/* depends */
__dna_docout.enumerate("depends", depends);
}
template <class IDType>
const char* DGRP<IDType>::DNAType()
{
return "urde::DGRP";
}
template <class IDType>
size_t DGRP<IDType>::binarySize(size_t __isz) const
{
__isz = __EnumerateSize(__isz, depends);
return __isz + 4;
}
template <class IDType>
void DGRP<IDType>::ObjectTag::read(athena::io::IStreamReader& __dna_reader)
{
/* type */
type.read(__dna_reader);
/* id */
id.read(__dna_reader);
}
template <class IDType>
void DGRP<IDType>::ObjectTag::write(athena::io::IStreamWriter& __dna_writer) const
{
/* type */
type.write(__dna_writer);
/* id */
id.write(__dna_writer);
}
template <class IDType>
void DGRP<IDType>::ObjectTag::read(athena::io::YAMLDocReader& __dna_docin)
{
/* type */
__dna_docin.enumerate("type", type);
/* id */
__dna_docin.enumerate("id", id);
}
template <class IDType>
void DGRP<IDType>::ObjectTag::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* type */
__dna_docout.enumerate("type", type);
/* id */
__dna_docout.enumerate("id", id);
}
template <class IDType>
const char* DGRP<IDType>::ObjectTag::DNAType()
{
return "urde::DGRP::ObjectTag";
}
template <class IDType>
size_t DGRP<IDType>::ObjectTag::binarySize(size_t __isz) const
{
__isz = type.binarySize(__isz);
__isz = id.binarySize(__isz);
return __isz;
}
template struct DGRP<UniqueID32>;
template struct DGRP<UniqueID64>;
template <class IDType>
bool ExtractDGRP(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
@ -113,7 +14,7 @@ bool ExtractDGRP(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
DGRP<IDType> dgrp;
dgrp.read(rs);
dgrp.toYAMLStream(writer);
athena::io::ToYAMLStream(dgrp, writer);
return true;
}
return false;
@ -136,4 +37,5 @@ bool WriteDGRP(const DGRP<IDType>& dgrp, const hecl::ProjectPath& outPath)
}
template bool WriteDGRP<UniqueID32>(const DGRP<UniqueID32>& dgrp, const hecl::ProjectPath& outPath);
template bool WriteDGRP<UniqueID64>(const DGRP<UniqueID64>& dgrp, const hecl::ProjectPath& outPath);
}

12
DataSpec/DNACommon/DGRP.hpp
View File

@ -6,14 +6,15 @@
namespace DataSpec::DNADGRP
{
template <class IDType>
struct DGRP : BigYAML
struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) DGRP : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> dependCount;
struct ObjectTag : BigYAML
struct ObjectTag : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
DNAFourCC type;
IDType id;
};
@ -21,10 +22,11 @@ struct DGRP : BigYAML
Vector<ObjectTag, DNA_COUNT(dependCount)> depends;
};
template <class IDType>
bool ExtractDGRP(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath);
template <class IDType>
bool WriteDGRP(const DGRP<IDType>& dgrp, const hecl::ProjectPath& outPath);
}
#endif // __COMMON_DGRP_HPP__

74
DataSpec/DNACommon/DNACommon.cpp
View File

@ -89,15 +89,19 @@ void UniqueIDBridge::setThreadProject(hecl::Database::Project& project)
}
/** PAK 32-bit Unique ID */
void UniqueID32::read(athena::io::IStreamReader& reader)
template <>
void UniqueID32::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{assign(reader.readUint32Big());}
void UniqueID32::write(athena::io::IStreamWriter& writer) const
template <>
void UniqueID32::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{writer.writeUint32Big(m_id);}
void UniqueID32::read(athena::io::YAMLDocReader& reader)
template <>
void UniqueID32::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& reader)
{
*this = UniqueIDBridge::MakePathFromString<UniqueID32>(reader.readString(nullptr));
}
void UniqueID32::write(athena::io::YAMLDocWriter& writer) const
template <>
void UniqueID32::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer)
{
if (!operator bool())
return;
@ -108,8 +112,9 @@ void UniqueID32::write(athena::io::YAMLDocWriter& writer) const
(std::string(path.getRelativePathUTF8()) + '|' + path.getAuxInfoUTF8().data()) :
path.getRelativePathUTF8());
}
size_t UniqueID32::binarySize(size_t __isz) const
{return __isz + 4;}
template <>
void UniqueID32::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{s += 4;}
std::string UniqueID32::toString() const
{
@ -137,24 +142,25 @@ AuxiliaryID32& AuxiliaryID32::operator=(const UniqueID32& id)
return *this;
}
void AuxiliaryID32::read(athena::io::IStreamReader& reader)
template <>
void AuxiliaryID32::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
assign(reader.readUint32Big());
m_baseId = *this;
}
void AuxiliaryID32::write(athena::io::IStreamWriter& writer) const
template <>
void AuxiliaryID32::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
writer.writeUint32Big(m_id);
}
void AuxiliaryID32::read(athena::io::YAMLDocReader& reader)
template <>
void AuxiliaryID32::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& reader)
{
hecl::ProjectPath readPath = UniqueIDBridge::MakePathFromString<UniqueID32>(reader.readString(nullptr));
*this = readPath.ensureAuxInfo(m_auxStr);
}
void AuxiliaryID32::write(athena::io::YAMLDocWriter& writer) const
template <>
void AuxiliaryID32::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer)
{
if (!operator bool())
return;
@ -171,15 +177,19 @@ void AuxiliaryID32::write(athena::io::YAMLDocWriter& writer) const
/** PAK 64-bit Unique ID */
void UniqueID64::read(athena::io::IStreamReader& reader)
template <>
void UniqueID64::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{assign(reader.readUint64Big());}
void UniqueID64::write(athena::io::IStreamWriter& writer) const
template <>
void UniqueID64::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{writer.writeUint64Big(m_id);}
void UniqueID64::read(athena::io::YAMLDocReader& reader)
template <>
void UniqueID64::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& reader)
{
*this = UniqueIDBridge::MakePathFromString<UniqueID64>(reader.readString(nullptr));
}
void UniqueID64::write(athena::io::YAMLDocWriter& writer) const
template <>
void UniqueID64::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer)
{
if (!operator bool())
return;
@ -187,11 +197,12 @@ void UniqueID64::write(athena::io::YAMLDocWriter& writer) const
if (!path)
return;
writer.writeString(nullptr, path.getAuxInfo().size() ?
(std::string(path.getRelativePathUTF8()) + '|' + path.getAuxInfoUTF8().data()) :
path.getRelativePathUTF8());
(std::string(path.getRelativePathUTF8()) + '|' + path.getAuxInfoUTF8().data()) :
path.getRelativePathUTF8());
}
size_t UniqueID64::binarySize(size_t __isz) const
{return __isz + 8;}
template <>
void UniqueID64::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{s += 8;}
std::string UniqueID64::toString() const
{
@ -201,21 +212,25 @@ std::string UniqueID64::toString() const
}
/** PAK 128-bit Unique ID */
void UniqueID128::read(athena::io::IStreamReader& reader)
template <>
void UniqueID128::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
m_id[0] = reader.readUint64Big();
m_id[1] = reader.readUint64Big();
}
void UniqueID128::write(athena::io::IStreamWriter& writer) const
template <>
void UniqueID128::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
writer.writeUint64Big(m_id[0]);
writer.writeUint64Big(m_id[1]);
}
void UniqueID128::read(athena::io::YAMLDocReader& reader)
template <>
void UniqueID128::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& reader)
{
*this = UniqueIDBridge::MakePathFromString<UniqueID128>(reader.readString(nullptr));
}
void UniqueID128::write(athena::io::YAMLDocWriter& writer) const
template <>
void UniqueID128::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer)
{
if (!operator bool())
return;
@ -223,11 +238,12 @@ void UniqueID128::write(athena::io::YAMLDocWriter& writer) const
if (!path)
return;
writer.writeString(nullptr, path.getAuxInfo().size() ?
(std::string(path.getRelativePathUTF8()) + '|' + path.getAuxInfoUTF8().data()) :
path.getRelativePathUTF8());
(std::string(path.getRelativePathUTF8()) + '|' + path.getAuxInfoUTF8().data()) :
path.getRelativePathUTF8());
}
size_t UniqueID128::binarySize(size_t __isz) const
{return __isz + 16;}
template <>
void UniqueID128::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{s += 16;}
std::string UniqueID128::toString() const
{

122
DataSpec/DNACommon/DNACommon.hpp
View File

@ -19,11 +19,12 @@ extern ThreadLocalPtr<class PAKRouterBase> g_PakRouter;
extern ThreadLocalPtr<hecl::blender::Token> g_ThreadBlenderToken;
/* This comes up a great deal */
typedef athena::io::DNA<athena::BigEndian> BigDNA;
typedef athena::io::DNAYaml<athena::BigEndian> BigYAML;
typedef athena::io::DNA<athena::Big> BigDNA;
typedef athena::io::DNAV<athena::Big> BigDNAV;
typedef athena::io::DNAVYaml<athena::Big> BigDNAVYaml;
/** FourCC with DNA read/write */
class DNAFourCC final : public BigYAML, public hecl::FourCC
class DNAFourCC final : public BigDNA, public hecl::FourCC
{
public:
DNAFourCC() : hecl::FourCC() {}
@ -33,55 +34,53 @@ public:
: hecl::FourCC(name) {}
DNAFourCC(uint32_t n)
: hecl::FourCC(n) {}
Delete expl;
void read(athena::io::IStreamReader& reader)
{reader.readUBytesToBuf(fcc, 4);}
void write(athena::io::IStreamWriter& writer) const
{writer.writeUBytes((atUint8*)fcc, 4);}
void read(athena::io::YAMLDocReader& reader)
{std::string rs = reader.readString(nullptr); strncpy(fcc, rs.c_str(), 4);}
void write(athena::io::YAMLDocWriter& writer) const
{writer.writeString(nullptr, std::string(fcc, 4));}
size_t binarySize(size_t __isz) const
{return __isz + 4;}
AT_DECL_EXPLICIT_DNA_YAML
};
template <> inline void DNAFourCC::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{ r.readUBytesToBuf(fcc, 4); }
template <> inline void DNAFourCC::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{ w.writeUBytes((atUint8*)fcc, 4); }
template <> inline void DNAFourCC::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{ std::string rs = r.readString(nullptr); strncpy(fcc, rs.c_str(), 4); }
template <> inline void DNAFourCC::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{ w.writeString(nullptr, std::string(fcc, 4)); }
template <> inline void DNAFourCC::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{ s += 4; }
class DNAColor final : public BigYAML, public zeus::CColor
class DNAColor final : public BigDNA, public zeus::CColor
{
public:
DNAColor() = default;
DNAColor(const zeus::CColor& color) : zeus::CColor(color) {}
Delete expl;
void read(athena::io::IStreamReader& reader)
{zeus::CColor::readRGBABig(reader);}
void write(athena::io::IStreamWriter& writer) const
{zeus::CColor::writeRGBABig(writer);}
void read(athena::io::YAMLDocReader& reader)
{
size_t count;
if (auto v = reader.enterSubVector(nullptr, count))
{
r = (count >= 1) ? reader.readFloat(nullptr) : 0.f;
g = (count >= 2) ? reader.readFloat(nullptr) : 0.f;
b = (count >= 3) ? reader.readFloat(nullptr) : 0.f;
a = (count >= 4) ? reader.readFloat(nullptr) : 0.f;
}
}
void write(athena::io::YAMLDocWriter& writer) const
{
if (auto v = writer.enterSubVector(nullptr))
{
writer.writeFloat(nullptr, r);
writer.writeFloat(nullptr, g);
writer.writeFloat(nullptr, b);
writer.writeFloat(nullptr, a);
}
}
size_t binarySize(size_t __isz) const
{return __isz + 16;}
AT_DECL_EXPLICIT_DNA_YAML
};
template <> inline void DNAColor::Enumerate<BigDNA::Read>(typename Read::StreamT& _r)
{ zeus::CColor::readRGBABig(_r); }
template <> inline void DNAColor::Enumerate<BigDNA::Write>(typename Write::StreamT& _w)
{ zeus::CColor::writeRGBABig(_w); }
template <> inline void DNAColor::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& _r)
{
size_t count;
if (auto v = _r.enterSubVector(nullptr, count))
{
r = (count >= 1) ? _r.readFloat(nullptr) : 0.f;
g = (count >= 2) ? _r.readFloat(nullptr) : 0.f;
b = (count >= 3) ? _r.readFloat(nullptr) : 0.f;
a = (count >= 4) ? _r.readFloat(nullptr) : 0.f;
}
}
template <> inline void DNAColor::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& _w)
{
if (auto v = _w.enterSubVector(nullptr))
{
_w.writeFloat(nullptr, r);
_w.writeFloat(nullptr, g);
_w.writeFloat(nullptr, b);
_w.writeFloat(nullptr, a);
}
}
template <> inline void DNAColor::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& _s)
{ _s += 16; }
using FourCC = hecl::FourCC;
class UniqueID32;
@ -136,19 +135,14 @@ public:
};
/** PAK 32-bit Unique ID */
class UniqueID32 : public BigYAML
class UniqueID32 : public BigDNA
{
protected:
uint32_t m_id = 0xffffffff;
public:
static UniqueID32 kInvalidId;
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
operator bool() const {return m_id != 0xffffffff && m_id != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
void assign(uint32_t id) { m_id = id ? id : 0xffffffff; }
UniqueID32& operator=(const hecl::ProjectPath& path)
@ -190,31 +184,24 @@ class AuxiliaryID32 : public UniqueID32
const hecl::SystemChar* m_addExtension;
UniqueID32 m_baseId;
public:
AT_DECL_DNA
Delete __d2;
AuxiliaryID32(const hecl::SystemChar* auxStr,
const hecl::SystemChar* addExtension=nullptr)
: m_auxStr(auxStr), m_addExtension(addExtension) {}
AuxiliaryID32& operator=(const hecl::ProjectPath& path);
AuxiliaryID32& operator=(const UniqueID32& id);
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
const UniqueID32& getBaseId() const {return m_baseId;}
};
/** PAK 64-bit Unique ID */
class UniqueID64 : public BigYAML
class UniqueID64 : public BigDNA
{
uint64_t m_id = 0xffffffffffffffff;
public:
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
operator bool() const {return m_id != 0xffffffffffffffff && m_id != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
void assign(uint64_t id) { m_id = id ? id : 0xffffffffffffffff; }
UniqueID64& operator=(const hecl::ProjectPath& path)
@ -258,7 +245,7 @@ public:
};
/** PAK 128-bit Unique ID */
class UniqueID128 : public BigYAML
class UniqueID128 : public BigDNA
{
union
{
@ -268,15 +255,10 @@ class UniqueID128 : public BigYAML
#endif
};
public:
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
UniqueID128() {m_id[0]=0xffffffffffffffff; m_id[1]=0xffffffffffffffff;}
operator bool() const
{return m_id[0] != 0xffffffffffffffff && m_id[0] != 0 && m_id[1] != 0xffffffffffffffff && m_id[1] != 0;}
void read(athena::io::IStreamReader& reader);
void write(athena::io::IStreamWriter& writer) const;
void read(athena::io::YAMLDocReader& reader);
void write(athena::io::YAMLDocWriter& writer) const;
size_t binarySize(size_t __isz) const;
UniqueID128& operator=(const hecl::ProjectPath& path)
{

100
DataSpec/DNACommon/DPSC.cpp
View File

@ -2,8 +2,15 @@
namespace DataSpec::DNAParticle
{
template <>
const char* DPSM<UniqueID32>::DNAType() { return "DPSM<UniqueID32>"; }
template <>
const char* DPSM<UniqueID64>::DNAType() { return "DPSM<UniqueID64>"; }
template <class IDType>
void DPSM<IDType>::read(athena::io::YAMLDocReader& r)
void DPSM<IDType>::_read(athena::io::YAMLDocReader& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
@ -69,7 +76,7 @@ void DPSM<IDType>::read(athena::io::YAMLDocReader& r)
}
template <class IDType>
void DPSM<IDType>::write(athena::io::YAMLDocWriter& w) const
void DPSM<IDType>::_write(athena::io::YAMLDocWriter& w) const
{
writeQuadDecalInfo(w, x0_quad, true);
writeQuadDecalInfo(w, x1c_quad, false);
@ -164,53 +171,88 @@ void DPSM<IDType>::writeQuadDecalInfo(athena::io::YAMLDocWriter& w,
}
template <class IDType>
size_t DPSM<IDType>::binarySize(size_t __isz) const
void DPSM<IDType>::_binarySize(size_t& s) const
{
__isz += 4;
__isz = getQuadDecalBinarySize(__isz, x0_quad);
__isz = getQuadDecalBinarySize(__isz, x1c_quad);
s += 4;
getQuadDecalBinarySize(s, x0_quad);
getQuadDecalBinarySize(s, x1c_quad);
if (x38_DMDL)
__isz = x38_DMDL.binarySize(__isz + 4);
{
s += 4;
x38_DMDL.binarySize(s);
}
if (x48_DLFT)
__isz = x48_DLFT.binarySize(__isz + 4);
{
s += 4;
x48_DLFT.binarySize(s);
}
if (x4c_DMOP)
__isz = x4c_DMOP.binarySize(__isz + 4);
{
s += 4;
x4c_DMOP.binarySize(s);
}
if (x50_DMRT)
__isz = x50_DMRT.binarySize(__isz + 4);
{
s += 4;
x50_DMRT.binarySize(s);
}
if (x54_DMSC)
__isz = x54_DMSC.binarySize(__isz + 4);
{
s += 4;
x54_DMSC.binarySize(s);
}
if (x58_DMCL)
__isz = x58_DMCL.binarySize(__isz + 4);
{
x58_DMCL.binarySize(s);
}
if (x5c_24_DMAB)
__isz += 9;
s += 9;
if (x5c_25_DMOO)
__isz += 9;
return __isz;
s += 9;
}
template <class IDType>
size_t DPSM<IDType>::getQuadDecalBinarySize(size_t __isz, const typename DPSM<IDType>::SQuadDescr& quad) const
void DPSM<IDType>::getQuadDecalBinarySize(size_t& s, const typename DPSM<IDType>::SQuadDescr& quad) const
{
if (quad.x0_LFT)
__isz = quad.x0_LFT.binarySize(__isz + 4);
{
s += 4;
quad.x0_LFT.binarySize(s);
}
if (quad.x4_SZE)
__isz = quad.x4_SZE.binarySize(__isz + 4);
{
s += 4;
quad.x4_SZE.binarySize(s);
}
if (quad.x8_ROT)
__isz = quad.x8_ROT.binarySize(__isz + 4);
{
s += 4;
quad.x8_ROT.binarySize(s);
}
if (quad.xc_OFF)
__isz = quad.xc_OFF.binarySize(__isz + 4);
{
s += 4;
quad.xc_OFF.binarySize(s);
}
if (quad.x10_CLR)
__isz = quad.x10_CLR.binarySize(__isz + 4);
{
s += 4;
quad.x10_CLR.binarySize(s);
}
if (quad.x14_TEX)
__isz = quad.x14_TEX.binarySize(__isz + 4);
{
s += 4;
quad.x14_TEX.binarySize(s);
}
if (quad.x18_ADD)
__isz = quad.x18_ADD.binarySize(__isz + 4);
return __isz;
{
s += 4;
quad.x18_ADD.binarySize(s);
}
}
template <class IDType>
void DPSM<IDType>::read(athena::io::IStreamReader& r)
void DPSM<IDType>::_read(athena::io::IStreamReader& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -280,7 +322,7 @@ void DPSM<IDType>::read(athena::io::IStreamReader& r)
}
template <class IDType>
void DPSM<IDType>::write(athena::io::IStreamWriter& w) const
void DPSM<IDType>::_write(athena::io::IStreamWriter& w) const
{
w.writeBytes("DPSM", 4);
writeQuadDecalInfo(w, x0_quad, true);
@ -373,6 +415,8 @@ void DPSM<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut)
g_curSpec->flattenDependencies(x38_DMDL.id, pathsOut);
}
AT_SUBSPECIALIZE_DNA_YAML(DPSM<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(DPSM<UniqueID64>)
template struct DPSM<UniqueID32>;
template struct DPSM<UniqueID64>;
@ -384,7 +428,7 @@ bool ExtractDPSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
DPSM<IDType> dpsm;
dpsm.read(rs);
dpsm.toYAMLStream(writer);
athena::io::ToYAMLStream(dpsm, writer);
return true;
}
return false;

13
DataSpec/DNACommon/DPSC.hpp
View File

@ -9,10 +9,10 @@ namespace DataSpec::DNAParticle
{
template <class IDType>
struct DPSM : BigYAML
struct DPSM : BigDNA
{
static const char* DNAType() { return "DPSM"; }
const char* DNATypeV() const { return DNAType(); }
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
struct SQuadDescr
{
@ -38,15 +38,10 @@ struct DPSM : BigYAML
struct { bool x5c_24_DMAB : 1; bool x5c_25_DMOO : 1;};
uint8_t dummy;
};
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
template <class Reader>
void readQuadDecalInfo(Reader& r, uint32_t clsId, SQuadDescr& quad);
void writeQuadDecalInfo(athena::io::YAMLDocWriter& w, const SQuadDescr& quad, bool first) const;
size_t binarySize(size_t __isz) const;
size_t getQuadDecalBinarySize(size_t __isz, const SQuadDescr& ) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
void getQuadDecalBinarySize(size_t& s, const SQuadDescr& desc) const;
void writeQuadDecalInfo(athena::io::IStreamWriter& w, const SQuadDescr& quad, bool first) const;
void gatherDependencies(std::vector<hecl::ProjectPath>&) const;

4
DataSpec/DNACommon/DeafBabe.cpp
View File

@ -114,7 +114,9 @@ static void PopulateAreaFields(DEAFBABE& db,
db.bspSize = octree.second;
db.unk1 = 0x1000000;
db.length = db.binarySize(0) - 8;
size_t dbSize = 0;
db.binarySize(dbSize);
db.length = dbSize - 8;
db.magic = 0xDEAFBABE;
db.version = 3;
db.aabb[0] = fullAABB.min;

4
DataSpec/DNACommon/EGMC.hpp
View File

@ -7,12 +7,12 @@ namespace DataSpec::DNACommon
{
struct EGMC : public BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> count;
struct Object : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> mesh;
Value<atUint32> instanceId;
};

450
DataSpec/DNACommon/ELSC.cpp
View File

@ -2,197 +2,9 @@
namespace DataSpec::DNAParticle
{
template <class IDType>
void ELSM<IDType>::read(athena::io::YAMLDocReader& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
if (elem.first.size() < 4)
{
LogModule.report(logvisor::Warning, "short FourCC in element '%s'", elem.first.c_str());
continue;
}
switch(*reinterpret_cast<const uint32_t*>(elem.first.data()))
{
case SBIG('LIFE'):
x0_LIFE.read(r);
break;
case SBIG('SLIF'):
x4_SLIF.read(r);
break;
case SBIG('GRAT'):
x8_GRAT.read(r);
break;
case SBIG('SCNT'):
xc_SCNT.read(r);
break;
case SBIG('SSEG'):
x10_SSEG.read(r);
break;
case SBIG('COLR'):
x14_COLR.read(r);
break;
case SBIG('IEMT'):
x18_IEMT.read(r);
break;
case SBIG('FEMT'):
x1c_FEMT.read(r);
break;
case SBIG('AMPL'):
x20_AMPL.read(r);
break;
case SBIG('AMPD'):
x24_AMPD.read(r);
break;
case SBIG('LWD1'):
x28_LWD1.read(r);
break;
case SBIG('LWD2'):
x2c_LWD2.read(r);
break;
case SBIG('LWD3'):
x30_LWD3.read(r);
break;
case SBIG('LCL1'):
x34_LCL1.read(r);
break;
case SBIG('LCL2'):
x38_LCL2.read(r);
break;
case SBIG('LCL3'):
x3c_LCL3.read(r);
break;
case SBIG('SSWH'):
x40_SSWH.read(r);
break;
case SBIG('GPSM'):
x50_GPSM.read(r);
break;
case SBIG('EPSM'):
x60_EPSM.read(r);
break;
case SBIG('ZERY'):
x70_ZERY.read(r);
break;
}
}
}
template <class IDType>
void ELSM<IDType>::write(athena::io::YAMLDocWriter& w) const
{
if (x0_LIFE)
if (auto rec = w.enterSubRecord("LIFE"))
x0_LIFE.write(w);
if (x4_SLIF)
if (auto rec = w.enterSubRecord("SLIF"))
x4_SLIF.write(w);
if (x8_GRAT)
if (auto rec = w.enterSubRecord("GRAT"))
x8_GRAT.write(w);
if (xc_SCNT)
if (auto rec = w.enterSubRecord("SCNT"))
xc_SCNT.write(w);
if (x10_SSEG)
if (auto rec = w.enterSubRecord("SSEG"))
x10_SSEG.write(w);
if (x14_COLR)
if (auto rec = w.enterSubRecord("COLR"))
x14_COLR.write(w);
if (x18_IEMT)
if (auto rec = w.enterSubRecord("IEMT"))
x18_IEMT.write(w);
if (x1c_FEMT)
if (auto rec = w.enterSubRecord("FEMT"))
x1c_FEMT.write(w);
if (x20_AMPL)
if (auto rec = w.enterSubRecord("AMPL"))
x20_AMPL.write(w);
if (x24_AMPD)
if (auto rec = w.enterSubRecord("AMPD"))
x24_AMPD.write(w);
if (x28_LWD1)
if (auto rec = w.enterSubRecord("LWD1"))
x28_LWD1.write(w);
if (x2c_LWD2)
if (auto rec = w.enterSubRecord("LWD2"))
x2c_LWD2.write(w);
if (x30_LWD3)
if (auto rec = w.enterSubRecord("LWD3"))
x30_LWD3.write(w);
if (x34_LCL1)
if (auto rec = w.enterSubRecord("LCL1"))
x34_LCL1.write(w);
if (x38_LCL2)
if (auto rec = w.enterSubRecord("LCL2"))
x38_LCL2.write(w);
if (x3c_LCL3)
if (auto rec = w.enterSubRecord("LCL3"))
x3c_LCL3.write(w);
if (x40_SSWH)
if (auto rec = w.enterSubRecord("SSWH"))
x40_SSWH.write(w);
if (x50_GPSM)
if (auto rec = w.enterSubRecord("GPSM"))
x50_GPSM.write(w);
if (x60_EPSM)
if (auto rec = w.enterSubRecord("EPSM"))
x60_EPSM.write(w);
if (x70_ZERY)
if (auto rec = w.enterSubRecord("ZERY"))
x70_ZERY.write(w);
}
template <class IDType>
size_t ELSM<IDType>::binarySize(size_t __isz) const
{
__isz += 4;
if (x0_LIFE)
__isz = x0_LIFE.binarySize(__isz + 4);
if (x4_SLIF)
__isz = x4_SLIF.binarySize(__isz + 4);
if (x8_GRAT)
__isz = x8_GRAT.binarySize(__isz + 4);
if (xc_SCNT)
__isz = xc_SCNT.binarySize(__isz + 4);
if (x10_SSEG)
__isz = x10_SSEG.binarySize(__isz + 4);
if (x14_COLR)
__isz = x14_COLR.binarySize(__isz + 4);
if (x18_IEMT)
__isz = x18_IEMT.binarySize(__isz + 4);
if (x1c_FEMT)
__isz = x1c_FEMT.binarySize(__isz + 4);
if (x20_AMPL)
__isz = x20_AMPL.binarySize(__isz + 4);
if (x24_AMPD)
__isz = x24_AMPD.binarySize(__isz + 4);
if (x28_LWD1)
__isz = x28_LWD1.binarySize(__isz + 4);
if (x2c_LWD2)
__isz = x2c_LWD2.binarySize(__isz + 4);
if (x30_LWD3)
__isz = x30_LWD3.binarySize(__isz + 4);
if (x34_LCL1)
__isz = x34_LCL1.binarySize(__isz + 4);
if (x38_LCL2)
__isz = x38_LCL2.binarySize(__isz + 4);
if (x3c_LCL3)
__isz = x3c_LCL3.binarySize(__isz + 4);
if (x40_SSWH)
__isz = x40_SSWH.binarySize(__isz + 4);
if (x50_GPSM)
__isz = x50_GPSM.binarySize(__isz + 4);
if (x60_EPSM)
__isz = x60_EPSM.binarySize(__isz + 4);
if (x70_ZERY)
__isz = x70_ZERY.binarySize(__isz + 4);
return __isz;
}
template <class IDType>
void ELSM<IDType>::read(athena::io::IStreamReader& r)
void ELSM<IDType>::_read(athena::io::IStreamReader& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -276,7 +88,7 @@ void ELSM<IDType>::read(athena::io::IStreamReader& r)
}
template <class IDType>
void ELSM<IDType>::write(athena::io::IStreamWriter& w) const
void ELSM<IDType>::_write(athena::io::IStreamWriter& w) const
{
w.writeBytes((atInt8*)"ELSM", 4);
if (x0_LIFE)
@ -382,6 +194,262 @@ void ELSM<IDType>::write(athena::io::IStreamWriter& w) const
w.writeBytes("_END", 4);
}
template <class IDType>
void ELSM<IDType>::_binarySize(size_t& s) const
{
s += 4;
if (x0_LIFE)
{
s += 4;
x0_LIFE.binarySize(s);
}
if (x4_SLIF)
{
s += 4;
x4_SLIF.binarySize(s);
}
if (x8_GRAT)
{
s += 4;
x8_GRAT.binarySize(s);
}
if (xc_SCNT)
{
s += 4;
xc_SCNT.binarySize(s);
}
if (x10_SSEG)
{
s += 4;
x10_SSEG.binarySize(s);
}
if (x14_COLR)
{
s += 4;
x14_COLR.binarySize(s);
}
if (x18_IEMT)
{
s += 4;
x18_IEMT.binarySize(s);
}
if (x1c_FEMT)
{
s += 4;
x1c_FEMT.binarySize(s);
}
if (x20_AMPL)
{
s += 4;
x20_AMPL.binarySize(s);
}
if (x24_AMPD)
{
s += 4;
x24_AMPD.binarySize(s);
}
if (x28_LWD1)
{
s += 4;
x28_LWD1.binarySize(s);
}
if (x2c_LWD2)
{
s += 4;
x2c_LWD2.binarySize(s);
}
if (x30_LWD3)
{
s += 4;
x30_LWD3.binarySize(s);
}
if (x34_LCL1)
{
s += 4;
x34_LCL1.binarySize(s);
}
if (x38_LCL2)
{
s += 4;
x38_LCL2.binarySize(s);
}
if (x3c_LCL3)
{
s += 4;
x3c_LCL3.binarySize(s);
}
if (x40_SSWH)
{
s += 4;
x40_SSWH.binarySize(s);
}
if (x50_GPSM)
{
s += 4;
x50_GPSM.binarySize(s);
}
if (x60_EPSM)
{
s += 4;
x60_EPSM.binarySize(s);
}
if (x70_ZERY)
{
s += 4;
x70_ZERY.binarySize(s);
}
}
template <class IDType>
void ELSM<IDType>::_read(athena::io::YAMLDocReader& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
if (elem.first.size() < 4)
{
LogModule.report(logvisor::Warning, "short FourCC in element '%s'", elem.first.c_str());
continue;
}
switch(*reinterpret_cast<const uint32_t*>(elem.first.data()))
{
case SBIG('LIFE'):
x0_LIFE.read(r);
break;
case SBIG('SLIF'):
x4_SLIF.read(r);
break;
case SBIG('GRAT'):
x8_GRAT.read(r);
break;
case SBIG('SCNT'):
xc_SCNT.read(r);
break;
case SBIG('SSEG'):
x10_SSEG.read(r);
break;
case SBIG('COLR'):
x14_COLR.read(r);
break;
case SBIG('IEMT'):
x18_IEMT.read(r);
break;
case SBIG('FEMT'):
x1c_FEMT.read(r);
break;
case SBIG('AMPL'):
x20_AMPL.read(r);
break;
case SBIG('AMPD'):
x24_AMPD.read(r);
break;
case SBIG('LWD1'):
x28_LWD1.read(r);
break;
case SBIG('LWD2'):
x2c_LWD2.read(r);
break;
case SBIG('LWD3'):
x30_LWD3.read(r);
break;
case SBIG('LCL1'):
x34_LCL1.read(r);
break;
case SBIG('LCL2'):
x38_LCL2.read(r);
break;
case SBIG('LCL3'):
x3c_LCL3.read(r);
break;
case SBIG('SSWH'):
x40_SSWH.read(r);
break;
case SBIG('GPSM'):
x50_GPSM.read(r);
break;
case SBIG('EPSM'):
x60_EPSM.read(r);
break;
case SBIG('ZERY'):
x70_ZERY.read(r);
break;
}
}
}
template <class IDType>
void ELSM<IDType>::_write(athena::io::YAMLDocWriter& w) const
{
if (x0_LIFE)
if (auto rec = w.enterSubRecord("LIFE"))
x0_LIFE.write(w);
if (x4_SLIF)
if (auto rec = w.enterSubRecord("SLIF"))
x4_SLIF.write(w);
if (x8_GRAT)
if (auto rec = w.enterSubRecord("GRAT"))
x8_GRAT.write(w);
if (xc_SCNT)
if (auto rec = w.enterSubRecord("SCNT"))
xc_SCNT.write(w);
if (x10_SSEG)
if (auto rec = w.enterSubRecord("SSEG"))
x10_SSEG.write(w);
if (x14_COLR)
if (auto rec = w.enterSubRecord("COLR"))
x14_COLR.write(w);
if (x18_IEMT)
if (auto rec = w.enterSubRecord("IEMT"))
x18_IEMT.write(w);
if (x1c_FEMT)
if (auto rec = w.enterSubRecord("FEMT"))
x1c_FEMT.write(w);
if (x20_AMPL)
if (auto rec = w.enterSubRecord("AMPL"))
x20_AMPL.write(w);
if (x24_AMPD)
if (auto rec = w.enterSubRecord("AMPD"))
x24_AMPD.write(w);
if (x28_LWD1)
if (auto rec = w.enterSubRecord("LWD1"))
x28_LWD1.write(w);
if (x2c_LWD2)
if (auto rec = w.enterSubRecord("LWD2"))
x2c_LWD2.write(w);
if (x30_LWD3)
if (auto rec = w.enterSubRecord("LWD3"))
x30_LWD3.write(w);
if (x34_LCL1)
if (auto rec = w.enterSubRecord("LCL1"))
x34_LCL1.write(w);
if (x38_LCL2)
if (auto rec = w.enterSubRecord("LCL2"))
x38_LCL2.write(w);
if (x3c_LCL3)
if (auto rec = w.enterSubRecord("LCL3"))
x3c_LCL3.write(w);
if (x40_SSWH)
if (auto rec = w.enterSubRecord("SSWH"))
x40_SSWH.write(w);
if (x50_GPSM)
if (auto rec = w.enterSubRecord("GPSM"))
x50_GPSM.write(w);
if (x60_EPSM)
if (auto rec = w.enterSubRecord("EPSM"))
x60_EPSM.write(w);
if (x70_ZERY)
if (auto rec = w.enterSubRecord("ZERY"))
x70_ZERY.write(w);
}
AT_SUBSPECIALIZE_DNA_YAML(ELSM<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(ELSM<UniqueID64>)
template <>
const char* ELSM<UniqueID32>::DNAType() { return "urde::ELSM<UniqueID32>"; }
template <>
const char* ELSM<UniqueID64>::DNAType() { return "urde::ELSM<UniqueID64>"; }
template <class IDType>
void ELSM<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
@ -401,7 +469,7 @@ bool ExtractELSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
ELSM<IDType> elsm;
elsm.read(rs);
elsm.toYAMLStream(writer);
athena::io::ToYAMLStream(elsm, writer);
return true;
}
return false;

12
DataSpec/DNACommon/ELSC.hpp
View File

@ -8,10 +8,10 @@
namespace DataSpec::DNAParticle
{
template <class IDType>
struct ELSM : BigYAML
struct ELSM : BigDNA
{
static const char* DNAType() { return "urde::ELSM"; }
const char* DNATypeV() const { return DNAType(); }
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
IntElementFactory x0_LIFE;
IntElementFactory x4_SLIF;
RealElementFactory x8_GRAT;
@ -33,12 +33,6 @@ struct ELSM : BigYAML
ChildResourceFactory<IDType> x60_EPSM;
BoolHelper x70_ZERY;
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
size_t binarySize(size_t __isz) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
void gatherDependencies(std::vector<hecl::ProjectPath>&) const;
};

370
DataSpec/DNACommon/FONT.cpp
View File

@ -4,66 +4,8 @@ namespace DataSpec::DNAFont
{
logvisor::Module LogModule("urde::DNAFont");
void GlyphRect::read(athena::io::IStreamReader& __dna_reader)
{
/* left */
left = __dna_reader.readFloatBig();
/* top */
top = __dna_reader.readFloatBig();
/* right */
right = __dna_reader.readFloatBig();
/* bottom */
bottom = __dna_reader.readFloatBig();
}
void GlyphRect::write(athena::io::IStreamWriter& __dna_writer) const
{
/* left */
__dna_writer.writeFloatBig(left);
/* top */
__dna_writer.writeFloatBig(top);
/* right */
__dna_writer.writeFloatBig(right);
/* bottom */
__dna_writer.writeFloatBig(bottom);
}
void GlyphRect::read(athena::io::YAMLDocReader& __dna_docin)
{
/* left */
left = __dna_docin.readFloat("left");
/* top */
top = __dna_docin.readFloat("top");
/* right */
right = __dna_docin.readFloat("right");
/* bottom */
bottom = __dna_docin.readFloat("bottom");
}
void GlyphRect::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* left */
__dna_docout.writeFloat("left", left);
/* top */
__dna_docout.writeFloat("top", top);
/* right */
__dna_docout.writeFloat("right", right);
/* bottom */
__dna_docout.writeFloat("bottom", bottom);
}
const char* GlyphRect::DNAType()
{
return "GlyphRect";
}
size_t GlyphRect::binarySize(size_t __isz) const
{
return __isz + 16;
}
template <class IDType>
void FONT<IDType>::read(athena::io::IStreamReader& __dna_reader)
void FONT<IDType>::_read(athena::io::IStreamReader& __dna_reader)
{
/* magic */
atUint32 magic;
@ -115,7 +57,7 @@ void FONT<IDType>::read(athena::io::IStreamReader& __dna_reader)
}
template <class IDType>
void FONT<IDType>::write(athena::io::IStreamWriter& __dna_writer) const
void FONT<IDType>::_write(athena::io::IStreamWriter& __dna_writer) const
{
/* magic */
__dna_writer.writeBytes((atInt8*)"FONT", 4);
@ -155,7 +97,7 @@ void FONT<IDType>::write(athena::io::IStreamWriter& __dna_writer) const
}
template <class IDType>
void FONT<IDType>::read(athena::io::YAMLDocReader& __dna_docin)
void FONT<IDType>::_read(athena::io::YAMLDocReader& __dna_docin)
{
/* version */
version = __dna_docin.readUint32("version");
@ -204,7 +146,7 @@ void FONT<IDType>::read(athena::io::YAMLDocReader& __dna_docin)
}
template <class IDType>
void FONT<IDType>::write(athena::io::YAMLDocWriter& __dna_docout) const
void FONT<IDType>::_write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* version */
__dna_docout.writeUint32("version", version);
@ -241,300 +183,32 @@ void FONT<IDType>::write(athena::io::YAMLDocWriter& __dna_docout) const
__dna_docout.enumerate("kerningInfo", kerningInfo);
}
template <class IDType>
const char* FONT<IDType>::DNAType()
template <>
const char* FONT<UniqueID32>::DNAType()
{
return "FONT";
return "FONT<UniqueID32>";
}
template <>
const char* FONT<UniqueID64>::DNAType()
{
return "FONT<UniqueID64>";
}
template <class IDType>
size_t FONT<IDType>::binarySize(size_t __isz) const
void FONT<IDType>::_binarySize(size_t& __isz) const
{
__isz += name.size() + 1;
__isz = textureId.binarySize(__isz);
textureId.binarySize(__isz);
for (const std::unique_ptr<IGlyph>& glyph : glyphs)
__isz = glyph->binarySize(__isz);
__isz = __EnumerateSize(__isz, kerningInfo);
return __isz + 46;
glyph->binarySize(__isz);
for (const KerningInfo& k : kerningInfo)
k.binarySize(__isz);
__isz += 46;
}
void IGlyph::read(athena::io::IStreamReader& __dna_reader)
{
/* m_character */
m_character = __dna_reader.readUint16Big();
/* m_glyphRect */
m_glyphRect.read(__dna_reader);
}
void IGlyph::write(athena::io::IStreamWriter& __dna_writer) const
{
/* m_character */
__dna_writer.writeUint16Big(m_character);
/* m_glyphRect */
m_glyphRect.write(__dna_writer);
}
void IGlyph::read(athena::io::YAMLDocReader& __dna_docin)
{
/* m_character */
m_character = __dna_docin.readUint16("m_character");
/* m_glyphRect */
__dna_docin.enumerate("m_glyphRect", m_glyphRect);
}
void IGlyph::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* m_character */
__dna_docout.writeUint16("m_character", m_character);
/* m_glyphRect */
__dna_docout.enumerate("m_glyphRect", m_glyphRect);
}
const char* IGlyph::DNAType()
{
return "FONT::IGlyph";
}
size_t IGlyph::binarySize(size_t __isz) const
{
__isz = m_glyphRect.binarySize(__isz);
return __isz + 2;
}
void GlyphMP1::read(athena::io::IStreamReader& __dna_reader)
{
IGlyph::read(__dna_reader);
/* m_leftPadding */
m_leftPadding = __dna_reader.readInt32Big();
/* m_advance */
m_advance = __dna_reader.readInt32Big();
/* m_rightPadding */
m_rightPadding = __dna_reader.readInt32Big();
/* m_width */
m_width = __dna_reader.readInt32Big();
/* m_height */
m_height = __dna_reader.readInt32Big();
/* m_baseline */
m_baseline = __dna_reader.readInt32Big();
/* m_kerningIndex */
m_kerningIndex = __dna_reader.readInt32Big();
}
void GlyphMP1::write(athena::io::IStreamWriter& __dna_writer) const
{
IGlyph::write(__dna_writer);
/* m_leftPadding */
__dna_writer.writeInt32Big(m_leftPadding);
/* m_advance */
__dna_writer.writeInt32Big(m_advance);
/* m_rightPadding */
__dna_writer.writeInt32Big(m_rightPadding);
/* m_width */
__dna_writer.writeInt32Big(m_width);
/* m_height */
__dna_writer.writeInt32Big(m_height);
/* m_baseline */
__dna_writer.writeInt32Big(m_baseline);
/* m_kerningIndex */
__dna_writer.writeInt32Big(m_kerningIndex);
}
void GlyphMP1::read(athena::io::YAMLDocReader& __dna_docin)
{
IGlyph::read(__dna_docin);
/* m_leftPadding */
m_leftPadding = __dna_docin.readInt32("m_leftPadding");
/* m_advance */
m_advance = __dna_docin.readInt32("m_advance");
/* m_rightPadding */
m_rightPadding = __dna_docin.readInt32("m_rightPadding");
/* m_width */
m_width = __dna_docin.readInt32("m_width");
/* m_height */
m_height = __dna_docin.readInt32("m_height");
/* m_baseline */
m_baseline = __dna_docin.readInt32("m_baseline");
/* m_kerningIndex */
m_kerningIndex = __dna_docin.readInt32("m_kerningIndex");
}
void GlyphMP1::write(athena::io::YAMLDocWriter& __dna_docout) const
{
IGlyph::write(__dna_docout);
/* m_leftPadding */
__dna_docout.writeInt32("m_leftPadding", m_leftPadding);
/* m_advance */
__dna_docout.writeInt32("m_advance", m_advance);
/* m_rightPadding */
__dna_docout.writeInt32("m_rightPadding", m_rightPadding);
/* m_width */
__dna_docout.writeInt32("m_width", m_width);
/* m_height */
__dna_docout.writeInt32("m_height", m_height);
/* m_baseline */
__dna_docout.writeInt32("m_baseline", m_baseline);
/* m_kerningIndex */
__dna_docout.writeInt32("m_kerningIndex", m_kerningIndex);
}
const char* GlyphMP1::DNAType()
{
return "GlyphMP1";
}
size_t GlyphMP1::binarySize(size_t __isz) const
{
__isz = IGlyph::binarySize(__isz);
return __isz + 28;
}
void GlyphMP2::read(athena::io::IStreamReader& __dna_reader)
{
IGlyph::read(__dna_reader);
/* m_layer */
m_layer = __dna_reader.readByte();
/* m_leftPadding */
m_leftPadding = __dna_reader.readByte();
/* m_advance */
m_advance = __dna_reader.readByte();
/* m_rightPadding */
m_rightPadding = __dna_reader.readByte();
/* m_width */
m_width = __dna_reader.readByte();
/* m_height */
m_height = __dna_reader.readByte();
/* m_baseline */
m_baseline = __dna_reader.readByte();
/* m_kerningIndex */
m_kerningIndex = __dna_reader.readInt16Big();
}
void GlyphMP2::write(athena::io::IStreamWriter& __dna_writer) const
{
IGlyph::write(__dna_writer);
/* m_layer */
__dna_writer.writeByte(m_layer);
/* m_leftPadding */
__dna_writer.writeByte(m_leftPadding);
/* m_advance */
__dna_writer.writeByte(m_advance);
/* m_rightPadding */
__dna_writer.writeByte(m_rightPadding);
/* m_width */
__dna_writer.writeByte(m_width);
/* m_height */
__dna_writer.writeByte(m_height);
/* m_baseline */
__dna_writer.writeByte(m_baseline);
/* m_kerningIndex */
__dna_writer.writeInt16Big(m_kerningIndex);
}
void GlyphMP2::read(athena::io::YAMLDocReader& __dna_docin)
{
IGlyph::read(__dna_docin);
/* m_layer */
m_layer = __dna_docin.readByte("m_layer");
/* m_leftPadding */
m_leftPadding = __dna_docin.readByte("m_leftPadding");
/* m_advance */
m_advance = __dna_docin.readByte("m_advance");
/* m_rightPadding */
m_rightPadding = __dna_docin.readByte("m_rightPadding");
/* m_width */
m_width = __dna_docin.readByte("m_width");
/* m_height */
m_height = __dna_docin.readByte("m_height");
/* m_baseline */
m_baseline = __dna_docin.readByte("m_baseline");
/* m_kerningIndex */
m_kerningIndex = __dna_docin.readInt16("m_kerningIndex");
}
void GlyphMP2::write(athena::io::YAMLDocWriter& __dna_docout) const
{
IGlyph::write(__dna_docout);
/* m_layer */
__dna_docout.writeByte("m_layer", m_layer);
/* m_leftPadding */
__dna_docout.writeByte("m_leftPadding", m_leftPadding);
/* m_advance */
__dna_docout.writeByte("m_advance", m_advance);
/* m_rightPadding */
__dna_docout.writeByte("m_rightPadding", m_rightPadding);
/* m_width */
__dna_docout.writeByte("m_width", m_width);
/* m_height */
__dna_docout.writeByte("m_height", m_height);
/* m_baseline */
__dna_docout.writeByte("m_baseline", m_baseline);
/* m_kerningIndex */
__dna_docout.writeInt16("m_kerningIndex", m_kerningIndex);
}
const char* GlyphMP2::DNAType()
{
return "GlyphMP2";
}
size_t GlyphMP2::binarySize(size_t __isz) const
{
__isz = IGlyph::binarySize(__isz);
return __isz + 9;
}
void KerningInfo::read(athena::io::IStreamReader& __dna_reader)
{
/* thisChar */
thisChar = __dna_reader.readUint16Big();
/* nextChar */
nextChar = __dna_reader.readUint16Big();
/* adjust */
adjust = __dna_reader.readInt32Big();
}
void KerningInfo::write(athena::io::IStreamWriter& __dna_writer) const
{
/* thisChar */
__dna_writer.writeUint16Big(thisChar);
/* nextChar */
__dna_writer.writeUint16Big(nextChar);
/* adjust */
__dna_writer.writeInt32Big(adjust);
}
void KerningInfo::read(athena::io::YAMLDocReader& __dna_docin)
{
/* thisChar */
thisChar = __dna_docin.readUint16("thisChar");
/* nextChar */
nextChar = __dna_docin.readUint16("nextChar");
/* adjust */
adjust = __dna_docin.readInt32("adjust");
}
void KerningInfo::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* thisChar */
__dna_docout.writeUint16("thisChar", thisChar);
/* nextChar */
__dna_docout.writeUint16("nextChar", nextChar);
/* adjust */
__dna_docout.writeInt32("adjust", adjust);
}
const char* KerningInfo::DNAType()
{
return "KerningInfo";
}
size_t KerningInfo::binarySize(size_t __isz) const
{
return __isz + 8;
}
template struct FONT<UniqueID32>;
template struct FONT<UniqueID64>;
AT_SUBSPECIALIZE_DNA_YAML(FONT<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(FONT<UniqueID64>)
template <class IDType>
bool ExtractFONT(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
@ -544,7 +218,7 @@ bool ExtractFONT(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
FONT<IDType> font;
font.read(rs);
font.toYAMLStream(writer);
athena::io::ToYAMLStream(font, writer);
return true;
}
return false;

23
DataSpec/DNACommon/FONT.hpp
View File

@ -6,17 +6,17 @@
namespace DataSpec::DNAFont
{
struct GlyphRect : BigYAML
struct GlyphRect : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<float> left;
Value<float> top;
Value<float> right;
Value<float> bottom;
};
struct IGlyph : BigYAML
struct IGlyph : BigDNAV
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint16> m_character;
GlyphRect m_glyphRect;
@ -39,7 +39,8 @@ struct IGlyph : BigYAML
struct GlyphMP1 : IGlyph
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atInt32> m_leftPadding;
Value<atInt32> m_advance;
Value<atInt32> m_rightPadding;
@ -59,7 +60,8 @@ struct GlyphMP1 : IGlyph
struct GlyphMP2 : IGlyph
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atInt8> m_layer;
Value<atInt8> m_leftPadding;
Value<atInt8> m_advance;
@ -79,18 +81,19 @@ struct GlyphMP2 : IGlyph
atInt32 kerningIndex() const { return m_kerningIndex; }
};
struct KerningInfo : BigYAML
struct KerningInfo : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint16> thisChar;
Value<atUint16> nextChar;
Value<atInt32> adjust;
};
template <class IDType>
struct FONT : BigYAML
struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FONT : BigDNA
{
DECL_YAML
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
Value<atUint32> version;
Value<atUint32> unknown1;
Value<atInt32> lineHeight;

969
DataSpec/DNACommon/FSM2.cpp
View File

@ -9,904 +9,10 @@ namespace DataSpec::DNAFSM2
logvisor::Module LogDNAFSM2("urde::DNAFSM2");
template <class IDType>
void FSM2<IDType>::Header::read(athena::io::IStreamReader& __dna_reader)
template <class Op>
void FSM2<IDType>::Enumerate(typename Op::StreamT& s)
{
/* magic */
magic.read(__dna_reader);
/* version */
version = __dna_reader.readUint32Big();
}
template <class IDType>
void FSM2<IDType>::Header::write(athena::io::IStreamWriter& __dna_writer) const
{
/* magic */
magic.write(__dna_writer);
/* version */
__dna_writer.writeUint32Big(version);
}
template <class IDType>
void FSM2<IDType>::Header::read(athena::io::YAMLDocReader& __dna_docin)
{
/* magic */
__dna_docin.enumerate("magic", magic);
/* version */
version = __dna_docin.readUint32("version");
}
template <class IDType>
void FSM2<IDType>::Header::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* magic */
__dna_docout.enumerate("magic", magic);
/* version */
__dna_docout.writeUint32("version", version);
}
template <class IDType>
const char* FSM2<IDType>::Header::DNAType()
{
return "FSM2::Header";
}
template <class IDType>
size_t FSM2<IDType>::Header::binarySize(size_t __isz) const
{
__isz = magic.binarySize(__isz);
return __isz + 4;
}
template <class IDType>
void FSM2<IDType>::CommonStruct::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown */
unknown = __dna_reader.readUint32Big();
}
template <class IDType>
void FSM2<IDType>::CommonStruct::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown */
__dna_writer.writeUint32Big(unknown);
}
template <class IDType>
void FSM2<IDType>::CommonStruct::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown */
unknown = __dna_docin.readUint32("unknown");
}
template <class IDType>
void FSM2<IDType>::CommonStruct::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown */
__dna_docout.writeUint32("unknown", unknown);
}
template <class IDType>
const char* FSM2<IDType>::CommonStruct::DNAType()
{
return "FSM2::CommonStruct";
}
template <class IDType>
size_t FSM2<IDType>::CommonStruct::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz += 4;
return __isz;
}
template <class IDType>
void FSM2<IDType>::FSMV1::read(athena::io::IStreamReader& __dna_reader)
{
/* stateCount */
stateCount = __dna_reader.readUint32Big();
/* unknown1Count */
unknown1Count = __dna_reader.readUint32Big();
/* unknown2Count */
unknown2Count = __dna_reader.readUint32Big();
/* unknown3Count */
unknown3Count = __dna_reader.readUint32Big();
/* states */
__dna_reader.enumerate(states, stateCount);
/* unknown1 */
__dna_reader.enumerate(unknown1, unknown1Count);
/* unknown2 */
__dna_reader.enumerate(unknown2, unknown2Count);
/* unknown3 */
__dna_reader.enumerate(unknown3, unknown3Count);
}
template <class IDType>
void FSM2<IDType>::FSMV1::write(athena::io::IStreamWriter& __dna_writer) const
{
/* stateCount */
__dna_writer.writeUint32Big(stateCount);
/* unknown1Count */
__dna_writer.writeUint32Big(unknown1Count);
/* unknown2Count */
__dna_writer.writeUint32Big(unknown2Count);
/* unknown3Count */
__dna_writer.writeUint32Big(unknown3Count);
/* states */
__dna_writer.enumerate(states);
/* unknown1 */
__dna_writer.enumerate(unknown1);
/* unknown2 */
__dna_writer.enumerate(unknown2);
/* unknown3 */
__dna_writer.enumerate(unknown3);
}
template <class IDType>
void FSM2<IDType>::FSMV1::read(athena::io::YAMLDocReader& __dna_docin)
{
/* states */
stateCount = __dna_docin.enumerate("states", states);
/* unknown1 */
unknown1Count = __dna_docin.enumerate("unknown1", unknown1);
/* unknown2 */
unknown2Count = __dna_docin.enumerate("unknown2", unknown2);
/* unknown3 */
unknown3Count = __dna_docin.enumerate("unknown3", unknown3);
}
template <class IDType>
void FSM2<IDType>::FSMV1::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* states */
__dna_docout.enumerate("states", states);
/* unknown1 */
__dna_docout.enumerate("unknown1", unknown1);
/* unknown2 */
__dna_docout.enumerate("unknown2", unknown2);
/* unknown3 */
__dna_docout.enumerate("unknown3", unknown3);
}
template <class IDType>
const char* FSM2<IDType>::FSMV1::DNAType()
{
return "FSM2::FSMV1";
}
template <class IDType>
size_t FSM2<IDType>::FSMV1::binarySize(size_t __isz) const
{
__isz = __EnumerateSize(__isz, states);
__isz = __EnumerateSize(__isz, unknown1);
__isz = __EnumerateSize(__isz, unknown2);
__isz = __EnumerateSize(__isz, unknown3);
return __isz + 16;
}
template <class IDType>
void FSM2<IDType>::FSMV1::State::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknownCount */
unknownCount = __dna_reader.readUint32Big();
/* unknown */
__dna_reader.enumerate(unknown, unknownCount);
}
template <class IDType>
void FSM2<IDType>::FSMV1::State::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknownCount */
__dna_writer.writeUint32Big(unknownCount);
/* unknown */
__dna_writer.enumerate(unknown);
}
template <class IDType>
void FSM2<IDType>::FSMV1::State::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknownCount squelched */
/* unknown */
unknownCount = __dna_docin.enumerate("unknown", unknown);
}
template <class IDType>
void FSM2<IDType>::FSMV1::State::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknownCount squelched */
/* unknown */
__dna_docout.enumerate("unknown", unknown);
}
template <class IDType>
const char* FSM2<IDType>::FSMV1::State::DNAType()
{
return "FSM2::FSMV1::State";
}
template <class IDType>
size_t FSM2<IDType>::FSMV1::State::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown);
return __isz + 4;
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown1::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown1 */
unknown1 = __dna_reader.readFloatBig();
/* unknown2Count */
unknown2Count = __dna_reader.readUint32Big();
/* unknown2 */
__dna_reader.enumerate(unknown2, unknown2Count);
/* unknown3 */
unknown3 = __dna_reader.readUByte();
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown1::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown1 */
__dna_writer.writeFloatBig(unknown1);
/* unknown2Count */
__dna_writer.writeUint32Big(unknown2Count);
/* unknown2 */
__dna_writer.enumerate(unknown2);
/* unknown3 */
__dna_writer.writeUByte(unknown3);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown1::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown1 */
unknown1 = __dna_docin.readFloat("unknown1");
/* unknown2Count squelched */
/* unknown2 */
unknown2Count = __dna_docin.enumerate("unknown2", unknown2);
/* unknown3 */
unknown3 = __dna_docin.readUByte("unknown3");
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown1::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown1 */
__dna_docout.writeFloat("unknown1", unknown1);
/* unknown2Count squelched */
/* unknown2 */
__dna_docout.enumerate("unknown2", unknown2);
/* unknown3 */
__dna_docout.writeUByte("unknown3", unknown3);
}
template <class IDType>
const char* FSM2<IDType>::FSMV1::Unknown1::DNAType()
{
return "FSM2::FSMV1::Unknown1";
}
template <class IDType>
size_t FSM2<IDType>::FSMV1::Unknown1::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown2);
return __isz + 9;
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown2::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknownCount */
unknownCount = __dna_reader.readUint32Big();
/* unknown */
__dna_reader.enumerate(unknown, unknownCount);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown2::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknownCount */
__dna_writer.writeUint32Big(unknownCount);
/* unknown */
__dna_writer.enumerate(unknown);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown2::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknownCount squelched */
/* unknown */
unknownCount = __dna_docin.enumerate("unknown", unknown);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown2::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknownCount squelched */
/* unknown */
__dna_docout.enumerate("unknown", unknown);
}
template <class IDType>
const char* FSM2<IDType>::FSMV1::Unknown2::DNAType()
{
return "FSM2::FSMV1::Unknown2";
}
template <class IDType>
size_t FSM2<IDType>::FSMV1::Unknown2::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown);
return __isz + 4;
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown3::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknownCount */
unknownCount = __dna_reader.readUint32Big();
/* unknown */
__dna_reader.enumerate(unknown, unknownCount);
/* fsmId */
fsmId.read(__dna_reader);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown3::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknownCount */
__dna_writer.writeUint32Big(unknownCount);
/* unknown */
__dna_writer.enumerate(unknown);
/* fsmId */
fsmId.write(__dna_writer);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown3::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknownCount squelched */
/* unknown */
unknownCount = __dna_docin.enumerate("unknown", unknown);
/* fsmId */
__dna_docin.enumerate("fsmId", fsmId);
}
template <class IDType>
void FSM2<IDType>::FSMV1::Unknown3::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknownCount squelched */
/* unknown */
__dna_docout.enumerate("unknown", unknown);
/* fsmId */
__dna_docout.enumerate("fsmId", fsmId);
}
template <class IDType>
const char* FSM2<IDType>::FSMV1::Unknown3::DNAType()
{
return "FSM2::FSMV1::Unknown3";
}
template <class IDType>
size_t FSM2<IDType>::FSMV1::Unknown3::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown);
__isz = fsmId.binarySize(__isz);
return __isz + 4;
}
template <class IDType>
void FSM2<IDType>::FSMV2::read(athena::io::IStreamReader& __dna_reader)
{
/* stateCount */
stateCount = __dna_reader.readUint32Big();
/* unknown1Count */
unknown1Count = __dna_reader.readUint32Big();
/* unknown2Count */
unknown2Count = __dna_reader.readUint32Big();
/* unknown3Count */
unknown3Count = __dna_reader.readUint32Big();
/* states */
__dna_reader.enumerate(states, stateCount);
/* unknown1 */
__dna_reader.enumerate(unknown1, unknown1Count);
/* unknown2 */
__dna_reader.enumerate(unknown2, unknown2Count);
/* unknown3 */
__dna_reader.enumerate(unknown3, unknown3Count);
}
template <class IDType>
void FSM2<IDType>::FSMV2::write(athena::io::IStreamWriter& __dna_writer) const
{
/* stateCount */
__dna_writer.writeUint32Big(stateCount);
/* unknown1Count */
__dna_writer.writeUint32Big(unknown1Count);
/* unknown2Count */
__dna_writer.writeUint32Big(unknown2Count);
/* unknown3Count */
__dna_writer.writeUint32Big(unknown3Count);
/* states */
__dna_writer.enumerate(states);
/* unknown1 */
__dna_writer.enumerate(unknown1);
/* unknown2 */
__dna_writer.enumerate(unknown2);
/* unknown3 */
__dna_writer.enumerate(unknown3);
}
template <class IDType>
void FSM2<IDType>::FSMV2::read(athena::io::YAMLDocReader& __dna_docin)
{
/* states */
stateCount = __dna_docin.enumerate("states", states);
/* unknown1 */
unknown1Count = __dna_docin.enumerate("unknown1", unknown1);
/* unknown2 */
unknown2Count = __dna_docin.enumerate("unknown2", unknown2);
/* unknown3 */
unknown3Count = __dna_docin.enumerate("unknown3", unknown3);
}
template <class IDType>
void FSM2<IDType>::FSMV2::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* states */
__dna_docout.enumerate("states", states);
/* unknown1 */
__dna_docout.enumerate("unknown1", unknown1);
/* unknown2 */
__dna_docout.enumerate("unknown2", unknown2);
/* unknown3 */
__dna_docout.enumerate("unknown3", unknown3);
}
template <class IDType>
const char* FSM2<IDType>::FSMV2::DNAType()
{
return "FSM2::FSMV2";
}
template <class IDType>
size_t FSM2<IDType>::FSMV2::binarySize(size_t __isz) const
{
__isz = __EnumerateSize(__isz, states);
__isz = __EnumerateSize(__isz, unknown1);
__isz = __EnumerateSize(__isz, unknown2);
__isz = __EnumerateSize(__isz, unknown3);
return __isz + 16;
}
template <class IDType>
void FSM2<IDType>::FSMV2::State::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown1 */
unknown1 = __dna_reader.readUint32Big();
/* unknown2 */
unknown2 = __dna_reader.readUint32Big();
/* unknown3 */
unknown3 = __dna_reader.readUint32Big();
/* unknown4 */
unknown4 = __dna_reader.readUint32Big();
/* unknown5Count */
unknown5Count = __dna_reader.readUint32Big();
/* unknown5 */
__dna_reader.enumerate(unknown5, unknown5Count);
}
template <class IDType>
void FSM2<IDType>::FSMV2::State::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown1 */
__dna_writer.writeUint32Big(unknown1);
/* unknown2 */
__dna_writer.writeUint32Big(unknown2);
/* unknown3 */
__dna_writer.writeUint32Big(unknown3);
/* unknown4 */
__dna_writer.writeUint32Big(unknown4);
/* unknown5Count */
__dna_writer.writeUint32Big(unknown5Count);
/* unknown5 */
__dna_writer.enumerate(unknown5);
}
template <class IDType>
void FSM2<IDType>::FSMV2::State::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown1 */
unknown1 = __dna_docin.readUint32("unknown1");
/* unknown2 */
unknown2 = __dna_docin.readUint32("unknown2");
/* unknown3 */
unknown3 = __dna_docin.readUint32("unknown3");
/* unknown4 */
unknown4 = __dna_docin.readUint32("unknown4");
/* unknown5Count squelched */
/* unknown5 */
unknown5Count = __dna_docin.enumerate("unknown5", unknown5);
}
template <class IDType>
void FSM2<IDType>::FSMV2::State::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown1 */
__dna_docout.writeUint32("unknown1", unknown1);
/* unknown2 */
__dna_docout.writeUint32("unknown2", unknown2);
/* unknown3 */
__dna_docout.writeUint32("unknown3", unknown3);
/* unknown4 */
__dna_docout.writeUint32("unknown4", unknown4);
/* unknown5Count squelched */
/* unknown5 */
__dna_docout.enumerate("unknown5", unknown5);
}
template <class IDType>
const char* FSM2<IDType>::FSMV2::State::DNAType()
{
return "FSM2::FSMV2::State";
}
template <class IDType>
size_t FSM2<IDType>::FSMV2::State::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown5);
return __isz + 20;
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown1::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown1 */
unknown1 = __dna_reader.readUint32Big();
/* unknown2 */
unknown2 = __dna_reader.readUint32Big();
/* unknown3 */
unknown3 = __dna_reader.readUint32Big();
/* unknown4 */
unknown4 = __dna_reader.readUint32Big();
/* unknown5 */
unknown5 = __dna_reader.readFloatBig();
/* unknown6Count */
unknown6Count = __dna_reader.readUint32Big();
/* unknown6 */
__dna_reader.enumerate(unknown6, unknown6Count);
/* unknown7 */
unknown7 = __dna_reader.readUByte();
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown1::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown1 */
__dna_writer.writeUint32Big(unknown1);
/* unknown2 */
__dna_writer.writeUint32Big(unknown2);
/* unknown3 */
__dna_writer.writeUint32Big(unknown3);
/* unknown4 */
__dna_writer.writeUint32Big(unknown4);
/* unknown5 */
__dna_writer.writeUint32Big(unknown5);
/* unknown6Count */
__dna_writer.writeFloatBig(unknown6Count);
/* unknown6 */
__dna_writer.enumerate(unknown6);
/* unknown6 */
__dna_writer.writeUByte(unknown7);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown1::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown1 */
unknown1 = __dna_docin.readUint32("unknown1");
/* unknown2 */
unknown2 = __dna_docin.readUint32("unknown2");
/* unknown3 */
unknown3 = __dna_docin.readUint32("unknown3");
/* unknown4 */
unknown4 = __dna_docin.readUint32("unknown4");
/* unknown5 */
unknown5 = __dna_docin.readFloat("unknown5");
/* unknown6Count squelched */
/* unknown6 */
unknown6Count = __dna_docin.enumerate("unknown6", unknown6);
/* unknown7 */
unknown7 = __dna_docin.readUByte("unknown7");
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown1::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown1 */
__dna_docout.writeUint32("unknown1", unknown1);
/* unknown2 */
__dna_docout.writeUint32("unknown2", unknown2);
/* unknown3 */
__dna_docout.writeUint32("unknown3", unknown3);
/* unknown4 */
__dna_docout.writeUint32("unknown4", unknown4);
/* unknown5 */
__dna_docout.writeFloat("unknown5", unknown5);
/* unknown6Count squelched */
/* unknown6 */
__dna_docout.enumerate("unknown6", unknown6);
/* unknown7 */
__dna_docout.writeUByte("unknown7", unknown7);
}
template <class IDType>
const char* FSM2<IDType>::FSMV2::Unknown1::DNAType()
{
return "FSM2::FSMV2::Unknown1";
}
template <class IDType>
size_t FSM2<IDType>::FSMV2::Unknown1::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown6);
return __isz + 25;
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown2::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown1 */
unknown1 = __dna_reader.readUint32Big();
/* unknown2 */
unknown2 = __dna_reader.readUint32Big();
/* unknown3 */
unknown3 = __dna_reader.readUint32Big();
/* unknown4 */
unknown4 = __dna_reader.readUint32Big();
/* unknown5Count */
unknown5Count = __dna_reader.readUint32Big();
/* unknown5 */
__dna_reader.enumerate(unknown5, unknown5Count);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown2::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown1 */
__dna_writer.writeUint32Big(unknown1);
/* unknown2 */
__dna_writer.writeUint32Big(unknown2);
/* unknown3 */
__dna_writer.writeUint32Big(unknown3);
/* unknown4 */
__dna_writer.writeUint32Big(unknown4);
/* unknown5Count */
__dna_writer.writeUint32Big(unknown5Count);
/* unknown5 */
__dna_writer.enumerate(unknown5);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown2::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown1 */
unknown1 = __dna_docin.readUint32("unknown1");
/* unknown2 */
unknown2 = __dna_docin.readUint32("unknown2");
/* unknown3 */
unknown3 = __dna_docin.readUint32("unknown3");
/* unknown4 */
unknown4 = __dna_docin.readUint32("unknown4");
/* unknown5Count squelched */
/* unknown5 */
unknown5Count = __dna_docin.enumerate("unknown5", unknown5);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown2::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown1 */
__dna_docout.writeUint32("unknown1", unknown1);
/* unknown2 */
__dna_docout.writeUint32("unknown2", unknown2);
/* unknown3 */
__dna_docout.writeUint32("unknown3", unknown3);
/* unknown4 */
__dna_docout.writeUint32("unknown4", unknown4);
/* unknown5Count squelched */
/* unknown5 */
__dna_docout.enumerate("unknown5", unknown5);
}
template <class IDType>
const char* FSM2<IDType>::FSMV2::Unknown2::DNAType()
{
return "FSM2::FSMV2::Unknown2";
}
template <class IDType>
size_t FSM2<IDType>::FSMV2::Unknown2::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown5);
return __isz + 20;
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown3::read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* unknown1 */
unknown1 = __dna_reader.readUint32Big();
/* unknown2 */
unknown2 = __dna_reader.readUint32Big();
/* unknown3 */
unknown3 = __dna_reader.readUint32Big();
/* unknown4 */
unknown4 = __dna_reader.readUint32Big();
/* unknown5Count */
unknown5Count = __dna_reader.readUint32Big();
/* unknown5 */
__dna_reader.enumerate(unknown5, unknown5Count);
/* fsmId */
fsmId.read(__dna_reader);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown3::write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* unknown1 */
__dna_writer.writeUint32Big(unknown1);
/* unknown2 */
__dna_writer.writeUint32Big(unknown2);
/* unknown3 */
__dna_writer.writeUint32Big(unknown3);
/* unknown4 */
__dna_writer.writeUint32Big(unknown4);
/* unknown5Count */
__dna_writer.writeUint32Big(unknown5Count);
/* unknown5 */
__dna_writer.enumerate(unknown5);
/* fsmId */
fsmId.write(__dna_writer);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown3::read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* unknown1 */
unknown1 = __dna_docin.readUint32("unknown1");
/* unknown2 */
unknown2 = __dna_docin.readUint32("unknown2");
/* unknown3 */
unknown3 = __dna_docin.readUint32("unknown3");
/* unknown4 */
unknown4 = __dna_docin.readUint32("unknown4");
/* unknown5Count squelched */
/* unknown5 */
unknown5Count = __dna_docin.enumerate("unknown5", unknown5);
/* fsmId */
__dna_docin.enumerate("fsmId", fsmId);
}
template <class IDType>
void FSM2<IDType>::FSMV2::Unknown3::write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* unknown1 */
__dna_docout.writeUint32("unknown1", unknown1);
/* unknown2 */
__dna_docout.writeUint32("unknown2", unknown2);
/* unknown3 */
__dna_docout.writeUint32("unknown3", unknown3);
/* unknown4 */
__dna_docout.writeUint32("unknown4", unknown4);
/* unknown5Count squelched */
/* unknown5 */
__dna_docout.enumerate("unknown5", unknown5);
/* fsmId */
__dna_docout.enumerate("fsmId", fsmId);
}
template <class IDType>
const char* FSM2<IDType>::FSMV2::Unknown3::DNAType()
{
return "FSM2::FSMV2::Unknown3";
}
template <class IDType>
size_t FSM2<IDType>::FSMV2::Unknown3::binarySize(size_t __isz) const
{
__isz += name.size() + 1;
__isz = __EnumerateSize(__isz, unknown5);
__isz = fsmId.binarySize(__isz);
return __isz + 20;
}
template <class IDType>
void FSM2<IDType>::read(athena::io::IStreamReader& in)
{
header.read(in);
Do<Op>({"header"}, header, s);
if (header.magic != SBIG('FSM2'))
{
LogDNAFSM2.report(logvisor::Fatal, "Invalid FSM2 magic '%.4s' expected 'FSM2'", header.magic.toString().c_str());
@ -914,67 +20,32 @@ void FSM2<IDType>::read(athena::io::IStreamReader& in)
}
if (header.version == 1)
detail.reset(new FSMV1);
{
if (!detail)
detail.reset(new FSMV1);
Do<Op>({"detail"}, static_cast<FSMV1&>(*detail), s);
}
else if (header.version == 2)
detail.reset(new FSMV2);
{
if (!detail)
detail.reset(new FSMV2);
Do<Op>({"detail"}, static_cast<FSMV2&>(*detail), s);
}
else
{
LogDNAFSM2.report(logvisor::Fatal, "Invalid FSM2 version '%i'", header.version);
return;
}
detail->read(in);
}
template <class IDType>
void FSM2<IDType>::write(athena::io::IStreamWriter& out) const
{
header.write(out);
detail->write(out);
}
AT_SPECIALIZE_DNA(FSM2<UniqueID32>)
AT_SPECIALIZE_DNA(FSM2<UniqueID64>)
template <class IDType>
void FSM2<IDType>::read(athena::io::YAMLDocReader& in)
{
header.read(in);
if (header.magic != SBIG('FSM2'))
{
LogDNAFSM2.report(logvisor::Fatal, "Invalid FSM2 magic '%.4s' expected 'FSM2'", header.magic.toString().c_str());
return;
}
template <>
const char* FSM2<UniqueID32>::DNAType() { return "urde::FSM2<UniqueID32>"; }
if (header.version == 1)
detail.reset(new FSMV1);
else if (header.version == 2)
detail.reset(new FSMV2);
else
{
LogDNAFSM2.report(logvisor::Fatal, "Invalid FSM2 version '%i'", header.version);
return;
}
detail->read(in);
}
template <class IDType>
void FSM2<IDType>::write(athena::io::YAMLDocWriter& out) const
{
header.write(out);
detail->write(out);
}
template <class IDType>
size_t FSM2<IDType>::binarySize(size_t __isz) const
{
__isz = header.binarySize(__isz);
return detail->binarySize(__isz);
}
template <class IDType>
const char* FSM2<IDType>::DNAType() { return "urde::FSM2"; }
template <class IDType>
const char* FSM2<IDType>::DNATypeV() const { return FSM2<IDType>::DNAType(); }
template <>
const char* FSM2<UniqueID64>::DNAType() { return "urde::FSM2<UniqueID64>"; }
template struct FSM2<UniqueID32>;
template struct FSM2<UniqueID64>;
@ -987,7 +58,7 @@ bool ExtractFSM2(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
FSM2<IDType> fsm2;
fsm2.read(rs);
fsm2.toYAMLStream(writer);
athena::io::ToYAMLStream(fsm2, writer);
return true;
}
return false;

60
DataSpec/DNACommon/FSM2.hpp
View File

@ -7,46 +7,47 @@
namespace DataSpec::DNAFSM2
{
struct IFSM : BigYAML
struct IFSM : BigDNAVYaml
{
Delete _d;
};
template <class IDType>
struct FSM2 : BigYAML
struct AT_SPECIALIZE_PARMS(DataSpec::UniqueID32, DataSpec::UniqueID64) FSM2 : BigDNA
{
struct Header : BigYAML
struct Header : BigDNA
{
DECL_YAML
DNAFourCC magic;
AT_DECL_DNA_YAML
DNAFourCC magic = FOURCC('FSM2');
Value<atUint32> version;
} header;
struct CommonStruct : BigYAML
struct CommonStruct : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknown;
};
struct FSMV1 : IFSM
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atUint32> stateCount;
Value<atUint32> unknown1Count;
Value<atUint32> unknown2Count;
Value<atUint32> unknown3Count;
struct State : BigYAML
struct State : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown;
};
struct Unknown1 : BigYAML
struct Unknown1 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<float> unknown1;
Value<atUint32> unknown2Count;
@ -54,17 +55,17 @@ struct FSM2 : BigYAML
Value<atUint8> unknown3;
};
struct Unknown2 : BigYAML
struct Unknown2 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown;
};
struct Unknown3 : BigYAML
struct Unknown3 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknownCount;
Vector<CommonStruct, DNA_COUNT(unknownCount)> unknown;
@ -79,14 +80,15 @@ struct FSM2 : BigYAML
struct FSMV2 : IFSM
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atUint32> stateCount;
Value<atUint32> unknown1Count;
Value<atUint32> unknown2Count;
Value<atUint32> unknown3Count;
struct State : BigYAML
struct State : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknown1;
Value<atUint32> unknown2;
@ -96,9 +98,9 @@ struct FSM2 : BigYAML
Vector<CommonStruct, DNA_COUNT(unknown5Count)> unknown5;
};
struct Unknown1 : BigYAML
struct Unknown1 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknown1;
Value<atUint32> unknown2;
@ -110,9 +112,9 @@ struct FSM2 : BigYAML
Value<atUint8> unknown7;
};
struct Unknown2 : BigYAML
struct Unknown2 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknown1;
Value<atUint32> unknown2;
@ -122,9 +124,9 @@ struct FSM2 : BigYAML
Vector<CommonStruct, DNA_COUNT(unknown5Count)> unknown5;
};
struct Unknown3 : BigYAML
struct Unknown3 : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unknown1;
Value<atUint32> unknown2;
@ -141,14 +143,8 @@ struct FSM2 : BigYAML
Vector<Unknown3, DNA_COUNT(unknown3Count)> unknown3;
};
void read(athena::io::IStreamReader& in);
void write(athena::io::IStreamWriter& out) const;
void read(athena::io::YAMLDocReader& in);
void write(athena::io::YAMLDocWriter& out) const;
std::unique_ptr<IFSM> detail;
size_t binarySize(size_t __isz) const;
static const char* DNAType();
const char* DNATypeV() const;
AT_DECL_EXPLICIT_DNA_YAML
};
template <class IDType>

30
DataSpec/DNACommon/MAPA.cpp
View File

@ -14,7 +14,8 @@ namespace DataSpec::DNAMAPA
static logvisor::Module Log("DNAMAPA");
void MAPA::read(athena::io::IStreamReader& __dna_reader)
template <>
void MAPA::Enumerate<BigDNA::Read>(typename Read::StreamT& __dna_reader)
{
/* magic */
magic = __dna_reader.readUint32Big();
@ -58,7 +59,8 @@ void MAPA::read(athena::io::IStreamReader& __dna_reader)
__dna_reader.enumerate(surfaces, header->surfaceCount());
}
void MAPA::write(athena::io::IStreamWriter& __dna_writer) const
template <>
void MAPA::Enumerate<BigDNA::Write>(typename Write::StreamT& __dna_writer)
{
/* magic */
__dna_writer.writeUint32Big(magic);
@ -77,17 +79,20 @@ void MAPA::write(athena::io::IStreamWriter& __dna_writer) const
__dna_writer.enumerate(surfaces);
}
size_t MAPA::binarySize(size_t __isz) const
template <>
void MAPA::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
__isz = header->binarySize(__isz);
header->binarySize(s);
for (const std::unique_ptr<IMappableObject>& mo : mappableObjects)
__isz = mo->binarySize(__isz);
mo->binarySize(s);
__isz += vertices.size() * 12;
__isz = __EnumerateSize(__isz, surfaceHeaders);
__isz = __EnumerateSize(__isz, surfaces);
return __isz + 8;
s += vertices.size() * 12;
for (const SurfaceHeader& sh : surfaceHeaders)
sh.binarySize(s);
for (const Surface& su : surfaces)
su.binarySize(s);
s += 8;
}
static const char* RetroMapVisModes[] =
@ -417,7 +422,7 @@ bool Cook(const hecl::blender::MapArea& mapaIn, const hecl::ProjectPath& out)
size_t offsetCur = 0;
for (const auto& mo : mapa.mappableObjects)
offsetCur = mo->binarySize(offsetCur);
mo->binarySize(offsetCur);
offsetCur += mapa.vertices.size() * 12;
offsetCur += mapaIn.surfaces.size() * 32;
@ -458,11 +463,12 @@ bool Cook(const hecl::blender::MapArea& mapaIn, const hecl::ProjectPath& out)
surfHead.normal = surfIn.normal.val;
surfHead.centroid = surfIn.centerOfMass;
surfHead.polyOff = offsetCur;
offsetCur = prim.binarySize(offsetCur + 4);
offsetCur += 4;
prim.binarySize(offsetCur);
surfHead.edgeOff = offsetCur;
offsetCur += 4;
for (const auto& border : surf.borders)
offsetCur = border.binarySize(offsetCur);
border.binarySize(offsetCur);
}
athena::io::FileWriter f(out.getAbsolutePath());

38
DataSpec/DNACommon/MAPA.hpp
View File

@ -9,10 +9,10 @@ namespace DataSpec::DNAMAPA
{
struct MAPA : BigDNA
{
Delete _d;
AT_DECL_EXPLICIT_DNA
Value<atUint32> magic;
Value<atUint32> version;
struct IMAPAHeader : BigDNA
struct IMAPAHeader : BigDNAV
{
Delete _d;
virtual atUint32 visMode() const=0;
@ -23,7 +23,8 @@ struct MAPA : BigDNA
struct HeaderMP1 : IMAPAHeader
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
Value<atUint32> unknown1 = 0;
Value<atUint32> mapVisMode = 0;
Value<atVec3f> boundingBox[2] = {};
@ -38,7 +39,8 @@ struct MAPA : BigDNA
struct HeaderMP2 : IMAPAHeader
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
Value<atUint32> unknown1 = 0;
Value<atUint32> mapVisMode = 0;
Value<atVec3f> boundingBox[2] = {};
@ -56,7 +58,8 @@ struct MAPA : BigDNA
struct HeaderMP3 : IMAPAHeader
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
Value<atUint32> unknown1 = 0;
Value<atUint32> mapVisMode = 0;
Value<atVec3f> boundingBox[2] = {};
@ -77,13 +80,9 @@ struct MAPA : BigDNA
};
void read(athena::io::IStreamReader& __dna_reader);
void write(athena::io::IStreamWriter& __dna_writer) const;
size_t binarySize(size_t __isz) const;
std::unique_ptr<IMAPAHeader> header;
struct IMappableObject : BigDNA
struct IMappableObject : BigDNAV
{
Delete _d;
enum class Type : atUint32
@ -111,24 +110,24 @@ struct MAPA : BigDNA
SaveStation = 34,
MissileStation = 37
};
virtual ~IMappableObject() {}
};
struct MappableObjectMP1_2 : IMappableObject
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
Value<Type> type;
Value<atUint32> visMode;
Value<atUint32> sclyId;
Value<atInt32> seek1 = -1;
Value<atVec4f> transformMtx[3];
Value<atInt32> seek2[4] = {-1, -1, -1, -1};
virtual ~MappableObjectMP1_2() {}
};
struct MappableObjectMP3 : IMappableObject
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
Value<Type> type;
Value<atUint32> visMode;
Value<atUint32> sclyId;
@ -136,7 +135,6 @@ struct MAPA : BigDNA
Value<atInt32> seek1 = -1;
Value<atVec4f> transformMtx[3];
Value<atInt32> seek2[4] = {-1, -1, -1, -1};
virtual ~MappableObjectMP3() {}
};
std::vector<std::unique_ptr<IMappableObject>> mappableObjects;
@ -144,7 +142,7 @@ struct MAPA : BigDNA
struct SurfaceHeader : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atVec3f> normal;
Value<atVec3f> centroid;
Value<atUint32> polyOff;
@ -155,11 +153,11 @@ struct MAPA : BigDNA
struct Surface : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> primitiveCount;
struct Primitive : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> type;
Value<atUint32> indexCount;
Vector<atUint8, DNA_COUNT(indexCount)> indices;
@ -169,7 +167,7 @@ struct MAPA : BigDNA
Value<atUint32> borderCount;
struct Border : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> indexCount;
Vector<atUint8, DNA_COUNT(indexCount)> indices;
Align<4> align;
@ -178,8 +176,6 @@ struct MAPA : BigDNA
};
Vector<Surface, DNA_COUNT(header->surfaceCount())> surfaces;
};
template <typename PAKRouter>

6
DataSpec/DNACommon/MAPU.hpp
View File

@ -7,19 +7,19 @@ namespace DataSpec::DNAMAPU
{
struct MAPU : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<uint32_t> magic;
Value<uint32_t> version;
UniqueID32 hexMapa;
Value<uint32_t> worldCount;
struct Transform : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atVec4f> xf[3];
};
struct World : BigDNA
{
DECL_DNA
AT_DECL_DNA
String<-1> name;
UniqueID32 mlvl;
Transform transform;

375
DataSpec/DNACommon/PART.cpp
View File

@ -3,8 +3,14 @@
namespace DataSpec::DNAParticle
{
template <>
const char* GPSM<UniqueID32>::DNAType() {return "GPSM<UniqueID32>";}
template <>
const char* GPSM<UniqueID64>::DNAType() {return "GPSM<UniqueID64>";}
template <class IDType>
void GPSM<IDType>::read(athena::io::YAMLDocReader& r)
void GPSM<IDType>::_read(typename ReadYaml::StreamT& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
@ -266,7 +272,7 @@ void GPSM<IDType>::read(athena::io::YAMLDocReader& r)
}
template <class IDType>
void GPSM<IDType>::write(athena::io::YAMLDocWriter& w) const
void GPSM<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (x0_PSIV)
if (auto rec = w.enterSubRecord("PSIV"))
@ -496,176 +502,364 @@ void GPSM<IDType>::write(athena::io::YAMLDocWriter& w) const
}
template <class IDType>
size_t GPSM<IDType>::binarySize(size_t __isz) const
void GPSM<IDType>::_binarySize(typename BinarySize::StreamT& s) const
{
__isz += 4;
s += 4;
if (x0_PSIV)
__isz = x0_PSIV.binarySize(__isz + 4);
{
s += 4;
x0_PSIV.binarySize(s);
}
if (x4_PSVM)
__isz = x4_PSVM.binarySize(__isz + 4);
{
s += 4;
x4_PSVM.binarySize(s);
}
if (x8_PSOV)
__isz = x8_PSOV.binarySize(__isz + 4);
{
s += 4;
x8_PSOV.binarySize(s);
}
if (xc_PSLT)
__isz = xc_PSLT.binarySize(__isz + 4);
{
s += 4;
xc_PSLT.binarySize(s);
}
if (x10_PSWT)
__isz = x10_PSWT.binarySize(__isz + 4);
{
s += 4;
x10_PSWT.binarySize(s);
}
if (x14_PSTS)
__isz = x14_PSTS.binarySize(__isz + 4);
{
s += 4;
x14_PSTS.binarySize(s);
}
if (x18_POFS)
__isz = x18_POFS.binarySize(__isz + 4);
{
s += 4;
x18_POFS.binarySize(s);
}
if (x1c_SEED)
__isz = x1c_SEED.binarySize(__isz + 4);
{
s += 4;
x1c_SEED.binarySize(s);
}
if (x20_LENG)
__isz = x20_LENG.binarySize(__isz + 4);
{
s += 4;
x20_LENG.binarySize(s);
}
if (x24_WIDT)
__isz = x24_WIDT.binarySize(__isz + 4);
{
s += 4;
x24_WIDT.binarySize(s);
}
if (x28_MAXP)
__isz = x28_MAXP.binarySize(__isz + 4);
{
s += 4;
x28_MAXP.binarySize(s);
}
if (x2c_GRTE)
__isz = x2c_GRTE.binarySize(__isz + 4);
{
s += 4;
x2c_GRTE.binarySize(s);
}
if (x30_COLR)
__isz = x30_COLR.binarySize(__isz + 4);
{
s += 4;
x30_COLR.binarySize(s);
}
if (x34_LTME)
__isz = x34_LTME.binarySize(__isz + 4);
{
s += 4;
x34_LTME.binarySize(s);
}
if (x38_ILOC)
__isz = x38_ILOC.binarySize(__isz + 4);
{
s += 4;
x38_ILOC.binarySize(s);
}
if (x3c_IVEC)
__isz = x3c_IVEC.binarySize(__isz + 4);
{
s += 4;
x3c_IVEC.binarySize(s);
}
if (x40_EMTR)
__isz = x40_EMTR.binarySize(__isz + 4);
{
s += 4;
x40_EMTR.binarySize(s);
}
if (x44_24_LINE)
__isz += 9;
s += 9;
if (x44_25_FXLL)
__isz += 9;
s += 9;
if (x44_26_AAPH)
__isz += 9;
s += 9;
if (x44_27_ZBUF)
__isz += 9;
s += 9;
if (x44_28_SORT)
__isz += 9;
s += 9;
if (x44_29_LIT_)
__isz += 9;
s += 9;
if (x44_30_MBLR)
__isz += 9;
s += 9;
if (x44_31_PMAB)
__isz += 9;
s += 9;
if (x45_24_PMUS)
__isz += 9;
s += 9;
if (!x45_25_PMOO)
__isz += 9;
s += 9;
if (x45_26_VMD1)
__isz += 9;
s += 9;
if (x45_27_VMD2)
__isz += 9;
s += 9;
if (x45_28_VMD3)
__isz += 9;
s += 9;
if (x45_29_VMD4)
__isz += 9;
s += 9;
if (x45_30_CIND)
__isz += 9;
s += 9;
if (x45_31_OPTS)
__isz += 9;
s += 9;
if (x30_30_ORNT)
__isz += 9;
s += 9;
if (x30_31_RSOP)
__isz += 9;
s += 9;
if (x48_MBSP)
__isz = x48_MBSP.binarySize(__isz + 4);
{
s += 4;
x48_MBSP.binarySize(s);
}
if (x4c_SIZE)
__isz = x4c_SIZE.binarySize(__isz + 4);
{
s += 4;
x4c_SIZE.binarySize(s);
}
if (x50_ROTA)
__isz = x50_ROTA.binarySize(__isz + 4);
{
s += 4;
x50_ROTA.binarySize(s);
}
if (x54_TEXR)
__isz = x54_TEXR.binarySize(__isz + 4);
{
s += 4;
x54_TEXR.binarySize(s);
}
if (x58_TIND)
__isz = x58_TIND.binarySize(__isz + 4);
{
s += 4;
x58_TIND.binarySize(s);
}
if (x5c_PMDL)
__isz = x5c_PMDL.binarySize(__isz + 4);
{
s += 4;
x5c_PMDL.binarySize(s);
}
if (x6c_PMOP)
__isz = x6c_PMOP.binarySize(__isz + 4);
{
s += 4;
x6c_PMOP.binarySize(s);
}
if (x70_PMRT)
__isz = x70_PMRT.binarySize(__isz + 4);
{
s += 4;
x70_PMRT.binarySize(s);
}
if (x74_PMSC)
__isz = x74_PMSC.binarySize(__isz + 4);
{
s += 4;
x74_PMSC.binarySize(s);
}
if (x78_PMCL)
__isz = x78_PMCL.binarySize(__isz + 4);
{
s += 4;
x78_PMCL.binarySize(s);
}
if (x7c_VEL1)
__isz = x7c_VEL1.binarySize(__isz + 4);
{
s += 4;
x7c_VEL1.binarySize(s);
}
if (x80_VEL2)
__isz = x80_VEL2.binarySize(__isz + 4);
{
s += 4;
x80_VEL2.binarySize(s);
}
if (x84_VEL3)
__isz = x84_VEL3.binarySize(__isz + 4);
{
s += 4;
x84_VEL3.binarySize(s);
}
if (x88_VEL4)
__isz = x88_VEL4.binarySize(__isz + 4);
{
s += 4;
x88_VEL4.binarySize(s);
}
if (x8c_ICTS)
__isz = x8c_ICTS.binarySize(__isz + 4);
{
s += 4;
x8c_ICTS.binarySize(s);
}
if (x9c_NCSY)
__isz = x9c_NCSY.binarySize(__isz + 4);
{
s += 4;
x9c_NCSY.binarySize(s);
}
if (xa0_CSSD)
__isz = xa0_CSSD.binarySize(__isz + 4);
{
s += 4;
xa0_CSSD.binarySize(s);
}
if (xa4_IDTS)
__isz = xa4_IDTS.binarySize(__isz + 4);
{
s += 4;
xa4_IDTS.binarySize(s);
}
if (xb4_NDSY)
__isz = xb4_NDSY.binarySize(__isz + 4);
{
s += 4;
xb4_NDSY.binarySize(s);
}
if (xb8_IITS)
__isz = xb8_IITS.binarySize(__isz + 4);
{
s += 4;
xb8_IITS.binarySize(s);
}
if (xc8_PISY)
__isz = xc8_PISY.binarySize(__isz + 4);
{
s += 4;
xc8_PISY.binarySize(s);
}
if (xcc_SISY)
__isz = xcc_SISY.binarySize(__isz + 4);
{
s += 4;
xcc_SISY.binarySize(s);
}
if (xd0_KSSM)
__isz = xd0_KSSM.binarySize(__isz + 4);
{
s += 4;
xd0_KSSM.binarySize(s);
}
if (xd4_SSWH)
__isz = xd4_SSWH.binarySize(__isz + 4);
{
s += 4;
xd4_SSWH.binarySize(s);
}
if (xd8_SELC)
__isz = xd8_SELC.binarySize(__isz + 4);
{
s += 4;
xd8_SELC.binarySize(s);
}
if (xe4_SSSD)
__isz = xe4_SSSD.binarySize(__isz + 4);
{
s += 4;
xe4_SSSD.binarySize(s);
}
if (xe8_SSPO)
__isz = xe8_SSPO.binarySize(__isz + 4);
{
s += 4;
xe8_SSPO.binarySize(s);
}
if (xf8_SESD)
__isz = xf8_SESD.binarySize(__isz + 4);
{
s += 4;
xf8_SESD.binarySize(s);
}
if (xfc_SEPO)
__isz = xfc_SEPO.binarySize(__isz + 4);
{
s += 4;
xfc_SEPO.binarySize(s);
}
if (xec_PMLC)
__isz = xec_PMLC.binarySize(__isz + 4);
{
s += 4;
xec_PMLC.binarySize(s);
}
if (x100_LTYP)
__isz = x100_LTYP.binarySize(__isz + 4);
{
s += 4;
x100_LTYP.binarySize(s);
}
if (x104_LCLR)
__isz = x104_LCLR.binarySize(__isz + 4);
{
s += 4;
x104_LCLR.binarySize(s);
}
if (x108_LINT)
__isz = x108_LINT.binarySize(__isz + 4);
{
s += 4;
x108_LINT.binarySize(s);
}
if (x10c_LOFF)
__isz = x10c_LOFF.binarySize(__isz + 4);
{
s += 4;
x10c_LOFF.binarySize(s);
}
if (x110_LDIR)
__isz = x110_LDIR.binarySize(__isz + 4);
{
s += 4;
x110_LDIR.binarySize(s);
}
if (x114_LFOT)
__isz = x114_LFOT.binarySize(__isz + 4);
{
s += 4;
x114_LFOT.binarySize(s);
}
if (x118_LFOR)
__isz = x118_LFOR.binarySize(__isz + 4);
{
s += 4;
x118_LFOR.binarySize(s);
}
if (x11c_LSLA)
__isz = x11c_LSLA.binarySize(__isz + 4);
{
s += 4;
x11c_LSLA.binarySize(s);
}
if (x10c_ADV1)
__isz = x10c_ADV1.binarySize(__isz + 4);
{
s += 4;
x10c_ADV1.binarySize(s);
}
if (x110_ADV2)
__isz = x110_ADV2.binarySize(__isz + 4);
{
s += 4;
x110_ADV2.binarySize(s);
}
if (x114_ADV3)
__isz = x114_ADV3.binarySize(__isz + 4);
{
s += 4;
x114_ADV3.binarySize(s);
}
if (x118_ADV4)
__isz = x118_ADV4.binarySize(__isz + 4);
{
s += 4;
x118_ADV4.binarySize(s);
}
if (x11c_ADV5)
__isz = x11c_ADV5.binarySize(__isz + 4);
{
s += 4;
x11c_ADV5.binarySize(s);
}
if (x120_ADV6)
__isz = x120_ADV6.binarySize(__isz + 4);
{
s += 4;
x120_ADV6.binarySize(s);
}
if (x124_ADV7)
__isz = x124_ADV7.binarySize(__isz + 4);
{
s += 4;
x124_ADV7.binarySize(s);
}
if (x128_ADV8)
__isz = x128_ADV8.binarySize(__isz + 4);
return __isz;
{
s += 4;
x128_ADV8.binarySize(s);
}
}
template <class IDType>
void GPSM<IDType>::read(athena::io::IStreamReader& r)
void GPSM<IDType>::_read(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -949,7 +1143,7 @@ void GPSM<IDType>::read(athena::io::IStreamReader& r)
}
template <class IDType>
void GPSM<IDType>::write(athena::io::IStreamWriter& w) const
void GPSM<IDType>::_write(typename Write::StreamT& w) const
{
w.writeBytes((atInt8*)"GPSM", 4);
if (x0_PSIV)
@ -1342,6 +1536,9 @@ void GPSM<IDType>::write(athena::io::IStreamWriter& w) const
w.writeBytes("_END", 4);
}
AT_SUBSPECIALIZE_DNA_YAML(GPSM<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(GPSM<UniqueID64>)
template <class IDType>
void GPSM<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
@ -1370,7 +1567,7 @@ bool ExtractGPSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
GPSM<IDType> gpsm;
gpsm.read(rs);
gpsm.toYAMLStream(writer);
athena::io::ToYAMLStream(gpsm, writer);
return true;
}
return false;

13
DataSpec/DNACommon/PART.hpp
View File

@ -9,11 +9,10 @@ namespace DataSpec::DNAParticle
{
template <class IDType>
struct GPSM : BigYAML
struct GPSM : BigDNA
{
static const char* DNAType() {return "GPSM";}
const char* DNATypeV() const {return DNAType();}
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
VectorElementFactory x0_PSIV;
ModVectorElementFactory x4_PSVM;
VectorElementFactory x8_PSOV;
@ -105,12 +104,6 @@ struct GPSM : BigYAML
x45_25_PMOO = true;
}
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
size_t binarySize(size_t __isz) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
void gatherDependencies(std::vector<hecl::ProjectPath>&) const;
};

761
DataSpec/DNACommon/ParticleCommon.cpp
View File

@ -4,7 +4,180 @@ namespace DataSpec::DNAParticle
{
logvisor::Module LogModule("urde::DNAParticle");
void RealElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void REConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
val = r.readFloat(nullptr);
}
template <>
void REConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
w.writeFloat(nullptr, val);
}
template <>
void REConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
}
template <>
void REConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
val = r.readFloatBig();
}
template <>
void REConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
w.writeFloatBig(val);
}
template <>
void IEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
val = r.readUint32(nullptr);
}
template <>
void IEConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
w.writeUint32(nullptr, val);
}
template <>
void IEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
}
template <>
void IEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
val = r.readUint32Big();
}
template <>
void IEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
w.writeUint32Big(val);
}
template <>
void VEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
size_t elemCount;
if (auto v = r.enterSubVector(nullptr, elemCount))
{
for (int i=0 ; i<3 && i<elemCount ; ++i)
{
if (auto rec = r.enterSubRecord(nullptr))
comps[i].read(r);
}
}
}
template <>
void VEConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (auto v = w.enterSubVector(nullptr))
for (int i=0 ; i<3 ; ++i)
if (auto rec = w.enterSubRecord(nullptr))
comps[i].write(w);
}
template <>
void VEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
comps[0].binarySize(s);
comps[1].binarySize(s);
comps[2].binarySize(s);
}
template <>
void VEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
comps[0].read(r);
comps[1].read(r);
comps[2].read(r);
}
template <>
void VEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
comps[0].write(w);
comps[1].write(w);
comps[2].write(w);
}
template <>
void CEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
for (int i=0 ; i<4 ; ++i)
if (auto rec = r.enterSubRecord(nullptr))
comps[i].read(r);
}
template <>
void CEConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (auto v = w.enterSubVector(nullptr))
for (int i=0 ; i<4 ; ++i)
if (auto rec = w.enterSubRecord(nullptr))
comps[i].write(w);
}
template <>
void CEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
comps[0].binarySize(s);
comps[1].binarySize(s);
comps[2].binarySize(s);
comps[3].binarySize(s);
}
template <>
void CEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
comps[0].read(r);
comps[1].read(r);
comps[2].read(r);
comps[3].read(r);
}
template <>
void CEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
comps[0].write(w);
comps[1].write(w);
comps[2].write(w);
comps[3].write(w);
}
template <>
void MVEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
for (int i=0 ; i<3 ; ++i)
if (auto rec = r.enterSubRecord(nullptr))
comps[i].read(r);
}
template <>
void MVEConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (auto v = w.enterSubVector(nullptr))
for (int i=0 ; i<3 ; ++i)
if (auto rec = w.enterSubRecord(nullptr))
comps[i].write(w);
}
template <>
void MVEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
comps[0].binarySize(s);
comps[1].binarySize(s);
comps[2].binarySize(s);
}
template <>
void MVEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
comps[0].read(r);
comps[1].read(r);
comps[2].read(r);
}
template <>
void MVEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
comps[0].write(w);
comps[1].write(w);
comps[2].write(w);
}
template <>
void RealElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -127,22 +300,24 @@ void RealElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void RealElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void RealElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t RealElementFactory::binarySize(size_t __isz) const
template <>
void RealElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void RealElementFactory::read(athena::io::IStreamReader& r)
template <>
void RealElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -259,7 +434,8 @@ void RealElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void RealElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void RealElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -271,7 +447,8 @@ void RealElementFactory::write(athena::io::IStreamWriter& w) const
}
void IntElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void IntElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -346,22 +523,24 @@ void IntElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void IntElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void IntElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t IntElementFactory::binarySize(size_t __isz) const
template <>
void IntElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void IntElementFactory::read(athena::io::IStreamReader& r)
template <>
void IntElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -430,7 +609,8 @@ void IntElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void IntElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void IntElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -441,7 +621,8 @@ void IntElementFactory::write(athena::io::IStreamWriter& w) const
w.writeBytes((atInt8*)"NONE", 4);
}
void VectorElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void VectorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -516,22 +697,24 @@ void VectorElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void VectorElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void VectorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t VectorElementFactory::binarySize(size_t __isz) const
template <>
void VectorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void VectorElementFactory::read(athena::io::IStreamReader& r)
template <>
void VectorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -600,7 +783,8 @@ void VectorElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void VectorElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void VectorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -612,7 +796,8 @@ void VectorElementFactory::write(athena::io::IStreamWriter& w) const
}
void ColorElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void ColorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -654,22 +839,24 @@ void ColorElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void ColorElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void ColorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t ColorElementFactory::binarySize(size_t __isz) const
template <>
void ColorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void ColorElementFactory::read(athena::io::IStreamReader& r)
template <>
void ColorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -705,7 +892,8 @@ void ColorElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void ColorElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void ColorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -717,7 +905,8 @@ void ColorElementFactory::write(athena::io::IStreamWriter& w) const
}
void ModVectorElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void ModVectorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -776,22 +965,24 @@ void ModVectorElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void ModVectorElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void ModVectorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t ModVectorElementFactory::binarySize(size_t __isz) const
template <>
void ModVectorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void ModVectorElementFactory::read(athena::io::IStreamReader& r)
template <>
void ModVectorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -844,7 +1035,8 @@ void ModVectorElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void ModVectorElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void ModVectorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -856,7 +1048,8 @@ void ModVectorElementFactory::write(athena::io::IStreamWriter& w) const
}
void EmitterElementFactory::read(athena::io::YAMLDocReader& r)
template <>
void EmitterElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty())
@ -891,22 +1084,24 @@ void EmitterElementFactory::read(athena::io::YAMLDocReader& r)
m_elem->read(r);
}
void EmitterElementFactory::write(athena::io::YAMLDocWriter& w) const
template <>
void EmitterElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
size_t EmitterElementFactory::binarySize(size_t __isz) const
template <>
void EmitterElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
if (m_elem)
return m_elem->binarySize(__isz + 4);
else
return __isz + 4;
m_elem->binarySize(s);
}
void EmitterElementFactory::read(athena::io::IStreamReader& r)
template <>
void EmitterElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -935,7 +1130,8 @@ void EmitterElementFactory::read(athena::io::IStreamReader& r)
m_elem->read(r);
}
void EmitterElementFactory::write(athena::io::IStreamWriter& w) const
template <>
void EmitterElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
if (m_elem)
{
@ -946,4 +1142,473 @@ void EmitterElementFactory::write(athena::io::IStreamWriter& w) const
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void BoolHelper::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
value = r.readBool(nullptr);
}
template <>
void BoolHelper::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
w.writeBool(nullptr, value);
}
template <>
void BoolHelper::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 5;
}
template <>
void BoolHelper::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
value = r.readBool();
else
value = false;
}
template <>
void BoolHelper::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
w.writeBytes((atInt8*)"CNST", 4);
w.writeBool(value);
}
template <>
void EESimpleEmitterTR::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
position.m_elem.reset();
velocity.m_elem.reset();
if (auto rec = r.enterSubRecord("ILOC"))
position.read(r);
if (auto rec = r.enterSubRecord("IVEC"))
velocity.read(r);
}
template <>
void EESimpleEmitterTR::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
if (auto rec = w.enterSubRecord("ILOC"))
position.write(w);
if (auto rec = w.enterSubRecord("IVEC"))
velocity.write(w);
}
template <>
void EESimpleEmitterTR::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 8;
position.binarySize(s);
velocity.binarySize(s);
}
template <>
void EESimpleEmitterTR::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
position.m_elem.reset();
velocity.m_elem.reset();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('ILOC'))
{
position.read(r);
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('IVEC'))
velocity.read(r);
}
}
template <>
void EESimpleEmitterTR::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
w.writeBytes((atInt8*)"ILOC", 4);
position.write(w);
w.writeBytes((atInt8*)"IVEC", 4);
velocity.write(w);
}
template <class IDType>
void UVEConstant<IDType>::_read(typename ReadYaml::StreamT& r)
{
tex.clear();
if (auto rec = r.enterSubRecord("tex"))
tex.read(r);
}
template <class IDType>
void UVEConstant<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (auto rec = w.enterSubRecord("tex"))
tex.write(w);
}
template <class IDType>
void UVEConstant<IDType>::_binarySize(typename BinarySize::StreamT& _s) const
{
_s += 4;
tex.binarySize(_s);
}
template <class IDType>
void UVEConstant<IDType>::_read(typename Read::StreamT& r)
{
tex.clear();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
tex.read(r);
}
template <class IDType>
void UVEConstant<IDType>::_write(typename Write::StreamT& w) const
{
w.writeBytes((atInt8*)"CNST", 4);
tex.write(w);
}
AT_SUBSPECIALIZE_DNA_YAML(UVEConstant<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVEConstant<UniqueID64>)
template struct UVEConstant<UniqueID32>;
template struct UVEConstant<UniqueID64>;
template <class IDType>
void UVEAnimTexture<IDType>::_read(typename ReadYaml::StreamT& r)
{
tex.clear();
if (auto rec = r.enterSubRecord("tex"))
tex.read(r);
if (auto rec = r.enterSubRecord("tileW"))
tileW.read(r);
if (auto rec = r.enterSubRecord("tileH"))
tileH.read(r);
if (auto rec = r.enterSubRecord("strideW"))
strideW.read(r);
if (auto rec = r.enterSubRecord("strideH"))
strideH.read(r);
if (auto rec = r.enterSubRecord("cycleFrames"))
cycleFrames.read(r);
if (auto rec = r.enterSubRecord("loop"))
loop = r.readBool(nullptr);
}
template <class IDType>
void UVEAnimTexture<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (auto rec = w.enterSubRecord("tex"))
tex.write(w);
if (auto rec = w.enterSubRecord("tileW"))
tileW.write(w);
if (auto rec = w.enterSubRecord("tileH"))
tileH.write(w);
if (auto rec = w.enterSubRecord("strideW"))
strideW.write(w);
if (auto rec = w.enterSubRecord("strideH"))
strideH.write(w);
if (auto rec = w.enterSubRecord("cycleFrames"))
cycleFrames.write(w);
w.writeBool("loop", loop);
}
template <class IDType>
void UVEAnimTexture<IDType>::_binarySize(typename BinarySize::StreamT& _s) const
{
_s += 9;
tex.binarySize(_s);
tileW.binarySize(_s);
tileH.binarySize(_s);
strideW.binarySize(_s);
strideH.binarySize(_s);
cycleFrames.binarySize(_s);
}
template <class IDType>
void UVEAnimTexture<IDType>::_read(typename Read::StreamT& r)
{
tex.clear();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
tex.read(r);
tileW.read(r);
tileH.read(r);
strideW.read(r);
strideH.read(r);
cycleFrames.read(r);
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
loop = r.readBool();
}
template <class IDType>
void UVEAnimTexture<IDType>::_write(typename Write::StreamT& w) const
{
w.writeBytes((atInt8*)"CNST", 4);
tex.write(w);
tileW.write(w);
tileH.write(w);
strideW.write(w);
strideH.write(w);
cycleFrames.write(w);
w.writeBytes((atInt8*)"CNST", 4);
w.writeBool(loop);
}
AT_SUBSPECIALIZE_DNA_YAML(UVEAnimTexture<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVEAnimTexture<UniqueID64>)
template struct UVEAnimTexture<UniqueID32>;
template struct UVEAnimTexture<UniqueID64>;
template <class IDType>
void UVElementFactory<IDType>::_read(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
switch (clsId)
{
case SBIG('CNST'):
m_elem.reset(new struct UVEConstant<IDType>);
break;
case SBIG('ATEX'):
m_elem.reset(new struct UVEAnimTexture<IDType>);
break;
default:
m_elem.reset();
return;
}
m_elem->read(r);
}
template <class IDType>
void UVElementFactory<IDType>::_write(typename Write::StreamT& w) const
{
if (m_elem)
{
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
}
else
w.writeBytes((atInt8*)"NONE", 4);
}
template <class IDType>
void UVElementFactory<IDType>::_read(typename ReadYaml::StreamT& r)
{
if (auto rec = r.enterSubRecord("CNST"))
{
m_elem.reset(new struct UVEConstant<IDType>);
m_elem->read(r);
}
else if (auto rec = r.enterSubRecord("ATEX"))
{
m_elem.reset(new struct UVEAnimTexture<IDType>);
m_elem->read(r);
}
else
m_elem.reset();
}
template <class IDType>
void UVElementFactory<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <class IDType>
void UVElementFactory<IDType>::_binarySize(typename BinarySize::StreamT& _s) const
{
if (m_elem)
m_elem->binarySize(_s);
_s += 4;
}
AT_SUBSPECIALIZE_DNA_YAML(UVElementFactory<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVElementFactory<UniqueID64>)
template struct UVElementFactory<UniqueID32>;
template struct UVElementFactory<UniqueID64>;
template <class IDType>
template <class Op>
void SpawnSystemKeyframeData<IDType>::SpawnSystemKeyframeInfo::Enumerate(typename Op::StreamT& s)
{
Do<Op>({"id"}, id, s);
Do<Op>({"a"}, a, s);
Do<Op>({"b"}, b, s);
Do<Op>({"c"}, c, s);
}
template <class IDType>
void SpawnSystemKeyframeData<IDType>::_read(typename ReadYaml::StreamT& r)
{
if (auto rec = r.enterSubRecord("a"))
a = r.readUint32(nullptr);
if (auto rec = r.enterSubRecord("b"))
b = r.readUint32(nullptr);
if (auto rec = r.enterSubRecord("endFrame"))
endFrame = r.readUint32(nullptr);
if (auto rec = r.enterSubRecord("d"))
d = r.readUint32(nullptr);
spawns.clear();
size_t spawnCount;
if (auto v = r.enterSubVector("spawns", spawnCount))
{
spawns.reserve(spawnCount);
for (const auto& child : r.getCurNode()->m_seqChildren)
{
if (auto rec = r.enterSubRecord(nullptr))
{
spawns.emplace_back();
spawns.back().first = r.readUint32("startFrame");
size_t systemCount;
if (auto v = r.enterSubVector("systems", systemCount))
{
spawns.back().second.reserve(systemCount);
for (const auto& in : r.getCurNode()->m_seqChildren)
{
spawns.back().second.emplace_back();
SpawnSystemKeyframeInfo& info = spawns.back().second.back();
if (auto rec = r.enterSubRecord(nullptr))
info.read(r);
}
}
}
}
}
}
template <class IDType>
void SpawnSystemKeyframeData<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (spawns.empty())
return;
w.writeUint32("a", a);
w.writeUint32("b", b);
w.writeUint32("endFrame", endFrame);
w.writeUint32("d", d);
if (auto v = w.enterSubVector("spawns"))
{
for (const auto& spawn : spawns)
{
if (auto rec = w.enterSubRecord(nullptr))
{
w.writeUint32("startFrame", spawn.first);
if (auto v = w.enterSubVector("systems"))
for (const auto& info : spawn.second)
if (auto rec = w.enterSubRecord(nullptr))
info.write(w);
}
}
}
}
template <class IDType>
void SpawnSystemKeyframeData<IDType>::_binarySize(typename BinarySize::StreamT& s) const
{
s += 20;
for (const auto& spawn : spawns)
{
s += 8;
for (const auto& info : spawn.second)
info.binarySize(s);
}
}
template <class IDType>
void SpawnSystemKeyframeData<IDType>::_read(typename Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId != SBIG('CNST'))
return;
a = r.readUint32Big();
b = r.readUint32Big();
endFrame = r.readUint32Big();
d = r.readUint32Big();
uint32_t count = r.readUint32Big();
spawns.clear();
spawns.reserve(count);
for (size_t i=0 ; i<count ; ++i)
{
spawns.emplace_back();
spawns.back().first = r.readUint32Big();
uint32_t infoCount = r.readUint32Big();
spawns.back().second.reserve(infoCount);
for (size_t j=0 ; j<infoCount ; ++j)
{
spawns.back().second.emplace_back();
spawns.back().second.back().read(r);
}
}
}
template <class IDType>
void SpawnSystemKeyframeData<IDType>::_write(typename Write::StreamT& w) const
{
if (spawns.empty())
{
w.writeBytes((atInt8*)"NONE", 4);
return;
}
w.writeBytes((atInt8*)"CNST", 4);
w.writeUint32Big(a);
w.writeUint32Big(b);
w.writeUint32Big(endFrame);
w.writeUint32Big(d);
w.writeUint32Big(spawns.size());
for (const auto& spawn : spawns)
{
w.writeUint32Big(spawn.first);
w.writeUint32Big(spawn.second.size());
for (const auto& info : spawn.second)
info.write(w);
}
}
AT_SUBSPECIALIZE_DNA_YAML(SpawnSystemKeyframeData<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(SpawnSystemKeyframeData<UniqueID64>)
template struct SpawnSystemKeyframeData<UniqueID32>;
template struct SpawnSystemKeyframeData<UniqueID64>;
template <class IDType>
void ChildResourceFactory<IDType>::_read(typename ReadYaml::StreamT& r)
{
id.clear();
if (auto rec = r.enterSubRecord("CNST"))
id.read(r);
}
template <class IDType>
void ChildResourceFactory<IDType>::_write(typename WriteYaml::StreamT& w) const
{
if (id)
if (auto rec = w.enterSubRecord("CNST"))
id.write(w);
}
template <class IDType>
void ChildResourceFactory<IDType>::_binarySize(typename BinarySize::StreamT& s) const
{
if (id)
id.binarySize(s);
s += 4;
}
template <class IDType>
void ChildResourceFactory<IDType>::_read(typename Read::StreamT& r)
{
id.clear();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
id.read(r);
}
template <class IDType>
void ChildResourceFactory<IDType>::_write(typename Write::StreamT& w) const
{
if (id)
{
w.writeBytes((atInt8*)"CNST", 4);
id.write(w);
}
else
w.writeBytes((atInt8*)"NONE", 4);
}
AT_SUBSPECIALIZE_DNA_YAML(ChildResourceFactory<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(ChildResourceFactory<UniqueID64>)
template struct ChildResourceFactory<UniqueID32>;
template struct ChildResourceFactory<UniqueID64>;
}

849
DataSpec/DNACommon/ParticleCommon.hpp
View File

File diff suppressed because it is too large Load Diff

14
DataSpec/DNACommon/SAVWCommon.hpp
View File

@ -15,26 +15,26 @@ enum class EScanCategory
Artifact
};
struct Header : BigYAML
struct Header : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> magic;
Value<atUint32> version;
Value<atUint32> areaCount;
};
struct EnvironmentVariable : BigYAML
struct EnvironmentVariable : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> unk1;
Value<atUint32> unk2;
Value<atUint32> unk3;
};
struct Layer : BigYAML
struct Layer : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> areaId;
Value<atUint32> layer;
};
@ -45,7 +45,7 @@ static bool ExtractSAVW(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath
SAVW savw;
savw.read(rs);
athena::io::FileWriter writer(outPath.getAbsolutePath());
savw.toYAMLStream(writer);
athena::io::ToYAMLStream(savw, writer);
return true;
}

4
DataSpec/DNACommon/STRG.hpp
View File

@ -10,9 +10,9 @@
namespace DataSpec
{
struct ISTRG : BigYAML
struct ISTRG : BigDNAVYaml
{
virtual ~ISTRG() {}
virtual ~ISTRG() = default;
virtual size_t count() const=0;
virtual std::string getUTF8(const FourCC& lang, size_t idx) const=0;

132
DataSpec/DNACommon/SWHC.cpp
View File

@ -3,8 +3,14 @@
namespace DataSpec::DNAParticle
{
template <>
const char* SWSH<UniqueID32>::DNAType() { return "SWSH<UniqueID32>"; }
template <>
const char* SWSH<UniqueID64>::DNAType() { return "SWSH<UniqueID64>"; }
template <class IDType>
void SWSH<IDType>::read(athena::io::YAMLDocReader& r)
void SWSH<IDType>::_read(typename BigDNA::ReadYaml::StreamT& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
@ -108,7 +114,7 @@ void SWSH<IDType>::read(athena::io::YAMLDocReader& r)
}
template <class IDType>
void SWSH<IDType>::write(athena::io::YAMLDocWriter& w) const
void SWSH<IDType>::_write(typename BigDNA::WriteYaml::StreamT& w) const
{
if (x0_PSLT)
if (auto rec = w.enterSubRecord("PSLT"))
@ -188,71 +194,120 @@ void SWSH<IDType>::write(athena::io::YAMLDocWriter& w) const
template <class IDType>
size_t SWSH<IDType>::binarySize(size_t __isz) const
void SWSH<IDType>::_binarySize(typename BigDNA::BinarySize::StreamT& s) const
{
__isz += 4;
s += 4;
if (x0_PSLT)
__isz = x0_PSLT.binarySize(__isz + 4);
{
s += 4;
x0_PSLT.binarySize(s);
}
if (x4_TIME)
__isz = x4_TIME.binarySize(__isz + 4);
{
s += 4;
x4_TIME.binarySize(s);
}
if (x8_LRAD)
__isz = x8_LRAD.binarySize(__isz + 4);
{
s += 4;
x8_LRAD.binarySize(s);
}
if (xc_RRAD)
__isz = xc_RRAD.binarySize(__isz + 4);
{
s += 4;
xc_RRAD.binarySize(s);
}
if (x10_LENG)
__isz = x10_LENG.binarySize(__isz + 4);
{
s += 4;
x10_LENG.binarySize(s);
}
if (x14_COLR)
__isz = x14_COLR.binarySize(__isz + 4);
{
s += 4;
x14_COLR.binarySize(s);
}
if (x18_SIDE)
__isz = x18_SIDE.binarySize(__isz + 4);
{
s += 4;
x18_SIDE.binarySize(s);
}
if (x1c_IROT)
__isz = x1c_IROT.binarySize(__isz + 4);
{
s += 4;
x1c_IROT.binarySize(s);
}
if (x20_ROTM)
__isz = x20_ROTM.binarySize(__isz + 4);
{
s += 4;
x20_ROTM.binarySize(s);
}
if (x24_POFS)
__isz = x24_POFS.binarySize(__isz + 4);
{
s += 4;
x24_POFS.binarySize(s);
}
if (x28_IVEL)
__isz = x28_IVEL.binarySize(__isz + 4);
{
s += 4;
x28_IVEL.binarySize(s);
}
if (x2c_NPOS)
__isz = x2c_NPOS.binarySize(__isz + 4);
{
s += 4;
x2c_NPOS.binarySize(s);
}
if (x30_VELM)
__isz = x30_VELM.binarySize(__isz + 4);
{
s += 4;
x30_VELM.binarySize(s);
}
if (x34_VLM2)
__isz = x34_VLM2.binarySize(__isz + 4);
{
s += 4;
x34_VLM2.binarySize(s);
}
if (x38_SPLN)
__isz = x38_SPLN.binarySize(__isz + 4);
{
s += 4;
x38_SPLN.binarySize(s);
}
if (x3c_TEXR)
__isz = x3c_TEXR.binarySize(__isz + 4);
{
s += 4;
x3c_TEXR.binarySize(s);
}
if (x40_TSPN)
__isz = x40_TSPN.binarySize(__isz + 4);
{
s += 4;
x40_TSPN.binarySize(s);
}
if (x44_24_LLRD)
__isz += 9;
s += 9;
if (!x44_25_CROS)
__isz += 9;
s += 9;
if (x44_26_VLS1)
__isz += 9;
s += 9;
if (x44_27_VLS2)
__isz += 9;
s += 9;
if (x44_28_SROT)
__isz += 9;
s += 9;
if (x44_29_WIRE)
__isz += 9;
s += 9;
if (x44_30_TEXW)
__isz += 9;
s += 9;
if (x44_31_AALP)
__isz += 9;
s += 9;
if (x45_24_ZBUF)
__isz += 9;
s += 9;
if (x45_25_ORNT)
__isz += 9;
s += 9;
if (x45_26_CRND)
__isz += 9;
return __isz;
s += 9;
}
template <class IDType>
void SWSH<IDType>::read(athena::io::IStreamReader& r)
void SWSH<IDType>::_read(typename BigDNA::Read::StreamT& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -371,7 +426,7 @@ void SWSH<IDType>::read(athena::io::IStreamReader& r)
}
template <class IDType>
void SWSH<IDType>::write(athena::io::IStreamWriter& w) const
void SWSH<IDType>::_write(typename BigDNA::Write::StreamT& w) const
{
w.writeBytes((atInt8*)"SWSH", 4);
if (x0_PSLT)
@ -485,6 +540,9 @@ void SWSH<IDType>::write(athena::io::IStreamWriter& w) const
w.writeBytes("_END", 4);
}
AT_SUBSPECIALIZE_DNA_YAML(SWSH<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(SWSH<UniqueID64>)
template <class IDType>
void SWSH<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
@ -503,7 +561,7 @@ bool ExtractSWSH(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
SWSH<IDType> swsh;
swsh.read(rs);
swsh.toYAMLStream(writer);
athena::io::ToYAMLStream(swsh, writer);
return true;
}
return false;

13
DataSpec/DNACommon/SWHC.hpp
View File

@ -9,10 +9,10 @@ namespace DataSpec::DNAParticle
{
template <class IDType>
struct SWSH : public BigYAML
struct SWSH : public BigDNA
{
static const char* DNAType() { return "SWSH"; }
const char* DNATypeV() const { return DNAType(); }
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
IntElementFactory x0_PSLT;
RealElementFactory x4_TIME;
@ -42,13 +42,6 @@ struct SWSH : public BigYAML
uint16_t dummy = 0;
};
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
size_t binarySize(size_t __isz) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
SWSH()
{
x44_25_CROS = true;

2
DataSpec/DNACommon/Tweaks/ITweak.hpp
View File

@ -9,7 +9,7 @@ class CVarManager;
}
namespace DataSpec
{
struct ITweak : BigYAML
struct ITweak : BigDNA
{
virtual void initCVars(hecl::CVarManager*) {}

14
DataSpec/DNACommon/Tweaks/ITweakPlayerGun.hpp
View File

@ -7,9 +7,9 @@
namespace DataSpec
{
/* Same as CDamageInfo */
struct SShotParam : BigYAML
struct SShotParam : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atInt32> weaponType = -1;
bool charged : 1;
bool combo : 1;
@ -24,19 +24,19 @@ struct SShotParam : BigYAML
struct SComboShotParam : SShotParam
{
DECL_YAML
AT_DECL_DNA_YAML
SComboShotParam() { combo = true; }
};
struct SChargedShotParam : SShotParam
{
DECL_YAML
AT_DECL_DNA_YAML
SChargedShotParam() { charged = true; }
};
struct SWeaponInfo : BigYAML
struct SWeaponInfo : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<float> x0_coolDown = 0.1f;
SShotParam x4_normal;
SChargedShotParam x20_charged;
@ -44,7 +44,7 @@ struct SWeaponInfo : BigYAML
struct ITweakPlayerGun : ITweak
{
DECL_YAML
AT_DECL_DNA_YAML
virtual float GetUpLookAngle() const = 0;
virtual float GetDownLookAngle() const = 0;
virtual float GetVerticalSpread() const = 0;

2
DataSpec/DNACommon/Tweaks/TweakWriter.hpp
View File

@ -28,7 +28,7 @@ bool ExtractTweak(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
T tweak;
tweak.read(rs);
tweak.toYAMLStream(writer);
athena::io::ToYAMLStream(tweak, writer);
return true;
}
return false;

187
DataSpec/DNACommon/WPSC.cpp
View File

@ -4,7 +4,7 @@ namespace DataSpec::DNAParticle
{
template <class IDType>
void WPSM<IDType>::read(athena::io::YAMLDocReader& r)
void WPSM<IDType>::_read(athena::io::YAMLDocReader& r)
{
for (const auto& elem : r.getCurNode()->m_mapChildren)
{
@ -126,7 +126,7 @@ void WPSM<IDType>::read(athena::io::YAMLDocReader& r)
}
template <class IDType>
void WPSM<IDType>::write(athena::io::YAMLDocWriter& w) const
void WPSM<IDType>::_write(athena::io::YAMLDocWriter& w) const
{
if (x0_IORN)
if (auto rec = w.enterSubRecord("IORN"))
@ -232,82 +232,180 @@ void WPSM<IDType>::write(athena::io::YAMLDocWriter& w) const
}
template <class IDType>
size_t WPSM<IDType>::binarySize(size_t __isz) const
void WPSM<IDType>::_binarySize(size_t& __isz) const
{
__isz += 4;
if (x0_IORN)
__isz = x0_IORN.binarySize(__isz + 4);
{
__isz += 4;
x0_IORN.binarySize(__isz);
}
if (x4_IVEC)
__isz = x4_IVEC.binarySize(__isz + 4);
{
__isz += 4;
x4_IVEC.binarySize(__isz);
}
if (x8_PSOV)
__isz = x8_PSOV.binarySize(__isz + 4);
{
__isz += 4;
x8_PSOV.binarySize(__isz);
}
if (xc_PSVM)
__isz = xc_PSVM.binarySize(__isz + 4);
{
__isz += 4;
xc_PSVM.binarySize(__isz);
}
if (x10_VMD2)
__isz = x10_VMD2.binarySize(__isz + 4);
{
__isz += 4;
x10_VMD2.binarySize(__isz);
}
if (x14_PSLT)
__isz = x14_PSLT.binarySize(__isz + 4);
{
__isz += 4;
x14_PSLT.binarySize(__isz);
}
if (x18_PSCL)
__isz = x18_PSCL.binarySize(__isz + 4);
{
__isz += 4;
x18_PSCL.binarySize(__isz);
}
if (x1c_PCOL)
__isz = x1c_PCOL.binarySize(__isz + 4);
{
__isz += 4;
x1c_PCOL.binarySize(__isz);
}
if (x20_POFS)
__isz = x20_POFS.binarySize(__isz + 4);
{
__isz += 4;
x20_POFS.binarySize(__isz);
}
if (x24_OFST)
__isz = x24_OFST.binarySize(__isz + 4);
{
__isz += 4;
x24_OFST.binarySize(__isz);
}
if (x28_APSO)
__isz = x28_APSO.binarySize(__isz + 4);
{
__isz += 4;
x28_APSO.binarySize(__isz);
}
if (x29_HOMG)
__isz = x29_HOMG.binarySize(__isz + 4);
{
__isz += 4;
x29_HOMG.binarySize(__isz);
}
if (x2a_AP11)
__isz = x2a_AP11.binarySize(__isz + 4);
{
__isz += 4;
x2a_AP11.binarySize(__isz);
}
if (x2b_AP21)
__isz = x2b_AP21.binarySize(__isz + 4);
{
__isz += 4;
x2b_AP21.binarySize(__isz);
}
if (x2c_AS11)
__isz = x2c_AS11.binarySize(__isz + 4);
{
__isz += 4;
x2c_AS11.binarySize(__isz);
}
if (x2d_AS12)
__isz = x2d_AS12.binarySize(__isz + 4);
{
__isz += 4;
x2d_AS12.binarySize(__isz);
}
if (x2e_AS13)
__isz = x2e_AS13.binarySize(__isz + 4);
{
__isz += 4;
x2e_AS13.binarySize(__isz);
}
if (x30_TRAT)
__isz = x30_TRAT.binarySize(__isz + 4);
{
__isz += 4;
x30_TRAT.binarySize(__isz);
}
if (x34_APSM)
__isz = x34_APSM.binarySize(__isz + 4);
{
__isz += 4;
x34_APSM.binarySize(__isz);
}
if (x44_APS2)
__isz = x44_APS2.binarySize(__isz + 4);
{
__isz += 4;
x44_APS2.binarySize(__isz);
}
if (x54_ASW1)
__isz = x54_ASW1.binarySize(__isz + 4);
{
__isz += 4;
x54_ASW1.binarySize(__isz);
}
if (x64_ASW2)
__isz = x64_ASW2.binarySize(__isz + 4);
{
__isz += 4;
x64_ASW2.binarySize(__isz);
}
if (x74_ASW3)
__isz = x74_ASW3.binarySize(__isz + 4);
{
__isz += 4;
x74_ASW3.binarySize(__isz);
}
if (x84_OHEF)
__isz = x84_OHEF.binarySize(__isz + 4);
{
__isz += 4;
x84_OHEF.binarySize(__isz);
}
if (x94_COLR)
__isz = x94_COLR.binarySize(__isz + 4);
{
__isz += 4;
x94_COLR.binarySize(__isz);
}
if (!xa4_EWTR)
__isz = xa4_EWTR.binarySize(__isz + 4);
{
__isz += 4;
xa4_EWTR.binarySize(__isz);
}
if (!xa5_LWTR)
__isz = xa5_LWTR.binarySize(__isz + 4);
{
__isz += 4;
xa5_LWTR.binarySize(__isz);
}
if (!xa6_SWTR)
__isz = xa6_SWTR.binarySize(__isz + 4);
{
__isz += 4;
xa6_SWTR.binarySize(__isz);
}
if (xa8_PJFX != ~0)
__isz += 12;
if (xac_RNGE)
__isz = xac_RNGE.binarySize(__isz + 4);
{
__isz += 4;
xac_RNGE.binarySize(__isz);
}
if (xb0_FOFF)
__isz = xb0_FOFF.binarySize(__isz + 4);
{
__isz += 4;
xb0_FOFF.binarySize(__isz);
}
if (xunk_FC60)
__isz = xunk_FC60.binarySize(__isz + 4);
{
__isz += 4;
xunk_FC60.binarySize(__isz);
}
if (xunk_SPS1)
__isz = xunk_SPS1.binarySize(__isz + 4);
{
__isz += 4;
xunk_SPS1.binarySize(__isz);
}
if (xunk_SPS2)
__isz = xunk_SPS2.binarySize(__isz + 4);
return __isz;
{
__isz += 4;
xunk_SPS2.binarySize(__isz);
}
}
template <class IDType>
void WPSM<IDType>::read(athena::io::IStreamReader& r)
void WPSM<IDType>::_read(athena::io::IStreamReader& r)
{
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
@ -441,7 +539,7 @@ void WPSM<IDType>::read(athena::io::IStreamReader& r)
}
template <class IDType>
void WPSM<IDType>::write(athena::io::IStreamWriter &w) const
void WPSM<IDType>::_write(athena::io::IStreamWriter &w) const
{
w.writeBytes("WPSM", 4);
if (x0_IORN)
@ -618,6 +716,15 @@ void WPSM<IDType>::write(athena::io::IStreamWriter &w) const
w.writeBytes("_END", 4);
}
AT_SUBSPECIALIZE_DNA_YAML(WPSM<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(WPSM<UniqueID64>)
template <>
const char* WPSM<UniqueID32>::DNAType() { return "WPSM<UniqueID32>"; }
template <>
const char* WPSM<UniqueID64>::DNAType() { return "WPSM<UniqueID64>"; }
template <class IDType>
void WPSM<IDType>::gatherDependencies(std::vector<hecl::ProjectPath>& pathsOut) const
{
@ -641,7 +748,7 @@ bool ExtractWPSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
WPSM<IDType> wpsm;
wpsm.read(rs);
wpsm.toYAMLStream(writer);
athena::io::ToYAMLStream(wpsm, writer);
return true;
}
return false;

12
DataSpec/DNACommon/WPSC.hpp
View File

@ -8,10 +8,10 @@
namespace DataSpec::DNAParticle
{
template <class IDType>
struct WPSM : BigYAML
struct WPSM : BigDNA
{
static const char* DNAType() { return "WPSM"; }
const char* DNATypeV() const { return DNAType(); }
AT_DECL_EXPLICIT_DNA_YAML
AT_SUBDECL_DNA
VectorElementFactory x0_IORN;
VectorElementFactory x4_IVEC;
VectorElementFactory x8_PSOV;
@ -47,12 +47,6 @@ struct WPSM : BigYAML
BoolHelper xunk_SPS1;
BoolHelper xunk_SPS2;
void read(athena::io::YAMLDocReader& r);
void write(athena::io::YAMLDocWriter& w) const;
size_t binarySize(size_t __isz) const;
void read(athena::io::IStreamReader& r);
void write(athena::io::IStreamWriter& w) const;
WPSM()
{
xa4_EWTR = true; xa5_LWTR = true; xa6_SWTR = true;

127
DataSpec/DNAMP1/AFSM.cpp Normal file
View File

@ -0,0 +1,127 @@
#include "AFSM.hpp"
namespace DataSpec::DNAMP1
{
template <>
void AFSM::State::Transition::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
triggerCount = r.readUint32Big();
int i = 0;
r.enumerate<Trigger>(triggers, triggerCount,
[&](athena::io::IStreamReader& in, Trigger& tr){
tr.first = i == 0;
tr.read(in);
i++;
});
}
template <>
void AFSM::State::Transition::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
w.writeInt32Big(triggerCount);
w.enumerate(triggers);
}
template <>
void AFSM::State::Transition::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
int i = 0;
/* triggers */
triggerCount = r.enumerate<Trigger>("triggers", triggers,
[&](athena::io::YAMLDocReader& in, Trigger& tr){
tr.first = i == 0;
tr.read(in);
i++;
});
}
template <>
void AFSM::State::Transition::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
/* triggers */
w.enumerate("triggers", triggers);
}
template <>
void AFSM::State::Transition::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
for (const Trigger& trig : triggers)
trig.binarySize(s);
}
const char* AFSM::State::Transition::DNAType()
{
return "urde::DNAMP1::AFSM::Transition";
}
template <>
void AFSM::State::Transition::Trigger::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* parameter */
parameter = __dna_reader.readFloatBig();
if (first)
{
/* targetState */
targetState = __dna_reader.readUint32Big();
}
}
template <>
void AFSM::State::Transition::Trigger::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{
/* name */
__dna_writer.writeString(name, -1);
/* parameter */
__dna_writer.writeFloatBig(parameter);
if (first)
{
/* targetState */
__dna_writer.writeUint32Big(targetState);
}
}
template <>
void AFSM::State::Transition::Trigger::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* parameter */
parameter = __dna_docin.readFloat("parameter");
if (first)
{
/* targetState */
targetState = __dna_docin.readUint32("targetState");
}
}
template <>
void AFSM::State::Transition::Trigger::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& __dna_docout)
{
/* name */
__dna_docout.writeString("name", name);
/* parameter */
__dna_docout.writeFloat("parameter", parameter);
if (first)
{
/* targetState */
__dna_docout.writeUint32("targetState", targetState);
}
}
template <>
void AFSM::State::Transition::Trigger::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += name.size() + 1;
__isz += (first ? 8 : 4);
}
const char* AFSM::State::Transition::Trigger::DNAType()
{
return "urde::DNAMP1::AFSM::State::Transition::Trigger";
}
}

134
DataSpec/DNAMP1/AFSM.hpp
View File

@ -7,150 +7,34 @@
namespace DataSpec::DNAMP1
{
struct AFSM : public BigYAML
struct AFSM : public BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> stateCount;
Vector<String<-1>, DNA_COUNT(stateCount)> stateNames;
Value<atUint32> triggerCount;
struct State : public BigYAML
struct State : public BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> transitionCount;
struct Transition : public BigYAML
struct Transition : public BigDNA
{
Delete _d;
AT_DECL_EXPLICIT_DNA_YAML
Value<atUint32> triggerCount;
struct Trigger : public BigYAML
struct Trigger : public BigDNA
{
Delete _d;
AT_DECL_EXPLICIT_DNA_YAML
bool first = false;
String<-1> name;
Value<float> parameter;
Value<atUint32> targetState;
void read(athena::io::IStreamReader& __dna_reader)
{
/* name */
name = __dna_reader.readString(-1);
/* parameter */
parameter = __dna_reader.readFloatBig();
if (first)
{
/* targetState */
targetState = __dna_reader.readUint32Big();
}
}
void write(athena::io::IStreamWriter& __dna_writer) const
{
/* name */
__dna_writer.writeString(name, -1);
/* parameter */
__dna_writer.writeFloatBig(parameter);
if (first)
{
/* targetState */
__dna_writer.writeUint32Big(targetState);
}
}
void read(athena::io::YAMLDocReader& __dna_docin)
{
/* name */
name = __dna_docin.readString("name");
/* parameter */
parameter = __dna_docin.readFloat("parameter");
if (first)
{
/* targetState */
targetState = __dna_docin.readUint32("targetState");
}
}
void write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* name */
__dna_docout.writeString("name", name);
/* parameter */
__dna_docout.writeFloat("parameter", parameter);
if (first)
{
/* targetState */
__dna_docout.writeUint32("targetState", targetState);
}
}
static const char* DNAType()
{
return "urde::DNAMP1::AFSM::Transition::Trigger";
}
size_t binarySize(size_t __isz) const
{
__isz += name.size() + 1;
return __isz + (first ? 8 : 4);
}
};
Vector<Trigger, DNA_COUNT(triggerCount)> triggers;
void read(athena::io::IStreamReader& __dna_reader)
{
/* triggerCount */
triggerCount = __dna_reader.readUint32Big();
int i = 0;
/* triggers */
__dna_reader.enumerate<Trigger>(triggers, triggerCount,
[&](athena::io::IStreamReader& in, Trigger& tr){
tr.first = i == 0;
tr.read(in);
i++;
});
}
void write(athena::io::IStreamWriter& __dna_writer) const
{
/* triggerCount */
__dna_writer.writeInt32Big(triggerCount);
/* triggers */
__dna_writer.enumerate(triggers);
}
void read(athena::io::YAMLDocReader& __dna_docin)
{
int i = 0;
/* triggers */
triggerCount = __dna_docin.enumerate<Trigger>("triggers", triggers,
[&](athena::io::YAMLDocReader& in, Trigger& tr){
tr.first = i == 0;
tr.read(in);
i++;
});
}
void write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* triggers */
__dna_docout.enumerate("triggers", triggers);
}
static const char* DNAType()
{
return "urde::DNAMP1::AFSM::Transition";
}
size_t binarySize(size_t __isz) const
{
__isz = __EnumerateSize(__isz, triggers);
return __isz + 4;
}
};
Vector<Transition, DNA_COUNT(transitionCount)> transitions;
};
Vector<State, DNA_COUNT(stateCount)> states;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
@ -158,7 +42,7 @@ struct AFSM : public BigYAML
AFSM afsm;
afsm.read(rs);
athena::io::FileWriter writer(outPath.getAbsolutePath());
afsm.toYAMLStream(writer);
athena::io::ToYAMLStream(afsm, writer);
return true;
}
};

2
DataSpec/DNAMP1/AGSC.hpp
View File

@ -11,7 +11,7 @@ class AGSC
{
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
String<-1> audioDir;
String<-1> groupName;
};

165
DataSpec/DNAMP1/ANCS.cpp
View File

@ -9,7 +9,9 @@ extern hecl::Database::DataSpecEntry SpecEntMP1PC;
namespace DNAMP1
{
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::read(athena::io::IStreamReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumerate<BigDNA::Read>
(athena::io::IStreamReader& reader)
{
parmType = reader.readUint32Big();
weightFunction = reader.readUint32Big();
@ -36,7 +38,9 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::read(a
}
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumerate<BigDNA::Write>
(athena::io::IStreamWriter& writer)
{
writer.writeUint32Big(parmType);
writer.writeUint32Big(weightFunction);
@ -63,7 +67,8 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::write(
}
}
size_t ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::binarySize(size_t __isz) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 12;
switch (DataType(parmType))
@ -78,10 +83,11 @@ size_t ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::bina
__isz += 2;
break;
}
return __isz;
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumerate<BigDNA::ReadYaml>
(athena::io::YAMLDocReader& reader)
{
parmType = reader.readUint32("parmType");
weightFunction = reader.readUint32("weightFunction");
@ -113,7 +119,9 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::read(a
}
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo::Enumerate<BigDNA::WriteYaml>
(athena::io::YAMLDocWriter& writer)
{
writer.writeUint32("parmType", parmType);
writer.writeUint32("weightFunction", weightFunction);
@ -148,7 +156,9 @@ const char* ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo:
return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::ParmInfo";
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(athena::io::IStreamReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA::Read>
(athena::io::IStreamReader& reader)
{
id = reader.readUint32Big();
atUint32 parmInfoCount = reader.readUint32Big();
@ -186,7 +196,9 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(athena::io:
});
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA::Write>
(athena::io::IStreamWriter& writer)
{
writer.writeUint32Big(id);
writer.writeUint32Big(parmInfos.size());
@ -225,10 +237,12 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::write(athena::io
}
}
size_t ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::binarySize(size_t __isz) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 12;
__isz = __EnumerateSize(__isz, parmInfos);
for (const ParmInfo& pi : parmInfos)
pi.binarySize(__isz);
__isz += animInfos.size() * 4;
for (const ParmInfo& pi : parmInfos)
@ -247,11 +261,11 @@ size_t ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::binarySize(siz
default: break;
}
}
return __isz;
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA::ReadYaml>
(athena::io::YAMLDocReader& reader)
{
id = reader.readUint32("id");
@ -289,7 +303,9 @@ void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::read(athena::io:
});
}
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::Enumerate<BigDNA::WriteYaml>
(athena::io::YAMLDocWriter& writer)
{
writer.writeUint32("id", id);
@ -334,7 +350,8 @@ const char* ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState::DNAType()
return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo::PASDatabase::AnimState";
}
void ANCS::CharacterSet::CharacterInfo::read(athena::io::IStreamReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
idx = reader.readUint32Big();
atUint16 sectionCount = reader.readUint16Big();
@ -394,7 +411,8 @@ void ANCS::CharacterSet::CharacterInfo::read(athena::io::IStreamReader& reader)
}
}
void ANCS::CharacterSet::CharacterInfo::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
writer.writeUint32Big(idx);
@ -466,7 +484,8 @@ void ANCS::CharacterSet::CharacterInfo::write(athena::io::IStreamWriter& writer)
}
}
size_t ANCS::CharacterSet::CharacterInfo::binarySize(size_t __isz) const
template <>
void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 6;
@ -488,23 +507,28 @@ size_t ANCS::CharacterSet::CharacterInfo::binarySize(size_t __isz) const
__isz += 12;
__isz += 4;
__isz = __EnumerateSize(__isz, animations);
for (const Animation& a : animations)
a.binarySize(__isz);
__isz = pasDatabase.binarySize(__isz);
pasDatabase.binarySize(__isz);
__isz += 4;
__isz = __EnumerateSize(__isz, partResData.part);
for (const UniqueID32& id : partResData.part)
id.binarySize(__isz);
__isz += 4;
__isz = __EnumerateSize(__isz, partResData.swhc);
for (const UniqueID32& id : partResData.swhc)
id.binarySize(__isz);
__isz += 4;
__isz = __EnumerateSize(__isz, partResData.unk);
for (const UniqueID32& id : partResData.unk)
id.binarySize(__isz);
if (sectionCount > 5)
{
__isz += 4;
__isz = __EnumerateSize(__isz, partResData.elsc);
for (const UniqueID32& id : partResData.elsc)
id.binarySize(__isz);
}
__isz += 4;
@ -512,13 +536,15 @@ size_t ANCS::CharacterSet::CharacterInfo::binarySize(size_t __isz) const
if (sectionCount > 1)
{
__isz += 4;
__isz = __EnumerateSize(__isz, animAABBs);
for (const ActionAABB& aabb : animAABBs)
aabb.binarySize(__isz);
}
if (sectionCount > 2)
{
__isz += 4;
__isz = __EnumerateSize(__isz, effects);
for (const Effect& e : effects)
e.binarySize(__isz);
}
if (sectionCount > 3)
@ -526,11 +552,10 @@ size_t ANCS::CharacterSet::CharacterInfo::binarySize(size_t __isz) const
if (sectionCount > 4)
__isz += 4 + animIdxs.size() * 4;
return __isz;
}
void ANCS::CharacterSet::CharacterInfo::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& reader)
{
idx = reader.readUint32("idx");
atUint16 sectionCount = reader.readUint16("sectionCount");
@ -579,7 +604,8 @@ void ANCS::CharacterSet::CharacterInfo::read(athena::io::YAMLDocReader& reader)
}
}
void ANCS::CharacterSet::CharacterInfo::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::CharacterSet::CharacterInfo::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer)
{
writer.writeUint32("idx", idx);
@ -644,7 +670,8 @@ const char* ANCS::CharacterSet::CharacterInfo::DNAType()
return "urde::DNAMP1::ANCS::CharacterSet::CharacterInfo";
}
void ANCS::AnimationSet::MetaAnimFactory::read(athena::io::IStreamReader& reader)
template <>
void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
IMetaAnim::Type type(IMetaAnim::Type(reader.readUint32Big()));
switch (type)
@ -675,7 +702,8 @@ void ANCS::AnimationSet::MetaAnimFactory::read(athena::io::IStreamReader& reader
}
}
void ANCS::AnimationSet::MetaAnimFactory::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
if (!m_anim)
return;
@ -683,14 +711,17 @@ void ANCS::AnimationSet::MetaAnimFactory::write(athena::io::IStreamWriter& write
m_anim->write(writer);
}
size_t ANCS::AnimationSet::MetaAnimFactory::binarySize(size_t __isz) const
template <>
void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
if (!m_anim)
return __isz;
return m_anim->binarySize(__isz + 4);
return;
__isz += 4;
m_anim->binarySize(__isz);
}
void ANCS::AnimationSet::MetaAnimFactory::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& reader)
{
std::string type = reader.readString("type");
std::transform(type.begin(), type.end(), type.begin(), tolower);
@ -723,10 +754,10 @@ void ANCS::AnimationSet::MetaAnimFactory::read(athena::io::YAMLDocReader& reader
{
m_anim.reset(nullptr);
}
}
void ANCS::AnimationSet::MetaAnimFactory::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::AnimationSet::MetaAnimFactory::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer)
{
if (!m_anim)
return;
@ -739,7 +770,8 @@ const char* ANCS::AnimationSet::MetaAnimFactory::DNAType()
return "urde::DNAMP1::ANCS::AnimationSet::MetaAnimFactory";
}
void ANCS::AnimationSet::MetaTransFactory::read(athena::io::IStreamReader& reader)
template <>
void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
IMetaTrans::Type type(IMetaTrans::Type(reader.readUint32Big()));
switch (type)
@ -763,7 +795,8 @@ void ANCS::AnimationSet::MetaTransFactory::read(athena::io::IStreamReader& reade
}
}
void ANCS::AnimationSet::MetaTransFactory::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
if (!m_trans)
{
@ -774,14 +807,17 @@ void ANCS::AnimationSet::MetaTransFactory::write(athena::io::IStreamWriter& writ
m_trans->write(writer);
}
size_t ANCS::AnimationSet::MetaTransFactory::binarySize(size_t __isz) const
template <>
void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 4;
if (!m_trans)
return __isz + 4;
return m_trans->binarySize(__isz + 4);
return;
m_trans->binarySize(__isz);
}
void ANCS::AnimationSet::MetaTransFactory::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& reader)
{
std::string type = reader.readString("type");
std::transform(type.begin(), type.end(), type.begin(), tolower);
@ -807,7 +843,8 @@ void ANCS::AnimationSet::MetaTransFactory::read(athena::io::YAMLDocReader& reade
}
void ANCS::AnimationSet::MetaTransFactory::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::AnimationSet::MetaTransFactory::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer)
{
if (!m_trans)
{
@ -823,7 +860,8 @@ const char* ANCS::AnimationSet::MetaTransFactory::DNAType()
return "urde::DNAMP1::ANCS::AnimationSet::MetaTransFactory";
}
void ANCS::AnimationSet::read(athena::io::IStreamReader& reader)
template <>
void ANCS::AnimationSet::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
atUint16 sectionCount = reader.readUint16Big();
@ -858,7 +896,8 @@ void ANCS::AnimationSet::read(athena::io::IStreamReader& reader)
}
}
void ANCS::AnimationSet::write(athena::io::IStreamWriter& writer) const
template <>
void ANCS::AnimationSet::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
atUint16 sectionCount;
if (animResources.size())
@ -900,7 +939,8 @@ void ANCS::AnimationSet::write(athena::io::IStreamWriter& writer) const
}
}
size_t ANCS::AnimationSet::binarySize(size_t __isz) const
template <>
void ANCS::AnimationSet::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
atUint16 sectionCount;
if (animResources.size())
@ -913,35 +953,39 @@ size_t ANCS::AnimationSet::binarySize(size_t __isz) const
sectionCount = 1;
__isz += 6;
__isz = __EnumerateSize(__isz, animations);
for (const Animation& a : animations)
a.binarySize(__isz);
__isz += 4;
__isz = __EnumerateSize(__isz, transitions);
__isz = defaultTransition.binarySize(__isz);
for (const Transition& t : transitions)
t.binarySize(__isz);
defaultTransition.binarySize(__isz);
if (sectionCount > 1)
{
__isz += 4;
__isz = __EnumerateSize(__isz, additiveAnims);
for (const AdditiveAnimationInfo& aa : additiveAnims)
aa.binarySize(__isz);
__isz += 8;
}
if (sectionCount > 2)
{
__isz += 4;
__isz = __EnumerateSize(__isz, halfTransitions);
for (const HalfTransition& ht : halfTransitions)
ht.binarySize(__isz);
}
if (sectionCount > 3)
{
__isz += 4;
__isz = __EnumerateSize(__isz, animResources);
for (const AnimationResources& ar : animResources)
ar.binarySize(__isz);
}
return __isz;
}
void ANCS::AnimationSet::read(athena::io::YAMLDocReader& reader)
template <>
void ANCS::AnimationSet::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& reader)
{
atUint16 sectionCount = reader.readUint16("sectionCount");
@ -971,7 +1015,8 @@ void ANCS::AnimationSet::read(athena::io::YAMLDocReader& reader)
}
}
void ANCS::AnimationSet::write(athena::io::YAMLDocWriter& writer) const
template <>
void ANCS::AnimationSet::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& writer)
{
atUint16 sectionCount;
if (animResources.size())
@ -1037,7 +1082,7 @@ bool ANCS::Extract(const SpecBase& dataSpec,
if (force || yamlType == hecl::ProjectPath::Type::None)
{
athena::io::FileWriter writer(yamlPath.getAbsolutePath());
ancs.toYAMLStream(writer);
athena::io::ToYAMLStream(ancs, writer);
}
if (force || blendType == hecl::ProjectPath::Type::None)
@ -1067,7 +1112,7 @@ bool ANCS::Extract(const SpecBase& dataSpec,
if (pakRouter.lookupAndReadDNA(res.second.evntId, evnt, true))
{
athena::io::FileWriter writer(evntYamlPath.getAbsolutePath());
evnt.toYAMLStream(writer);
athena::io::ToYAMLStream(evnt, writer);
}
}
}
@ -1091,7 +1136,7 @@ bool ANCS::Cook(const hecl::ProjectPath& outPath,
Log.report(logvisor::Fatal, _S("can't open '%s' for reading"),
yamlPath.getRelativePath().data());
if (!BigYAML::ValidateFromYAMLStream<ANCS>(reader))
if (!athena::io::ValidateFromYAMLStream<ANCS>(reader))
{
Log.report(logvisor::Fatal, _S("'%s' is not urde::DNAMP1::ANCS type"),
yamlPath.getRelativePath().data());

172
DataSpec/DNAMP1/ANCS.hpp
View File

@ -14,23 +14,23 @@
namespace DataSpec::DNAMP1
{
struct ANCS : BigYAML
struct ANCS : BigDNA
{
using CINFType = CINF;
using CSKRType = CSKR;
using ANIMType = ANIM;
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint16> version;
struct CharacterSet : BigYAML
struct CharacterSet : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint16> version;
Value<atUint32> characterCount;
struct CharacterInfo : BigYAML
struct CharacterInfo : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Delete expl;
atUint32 idx;
@ -39,30 +39,30 @@ struct ANCS : BigYAML
UniqueID32 cskr;
UniqueID32 cinf;
struct Animation : BigYAML
struct Animation : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> animIdx;
String<-1> strA;
String<-1> strB;
};
std::vector<Animation> animations;
struct PASDatabase : BigYAML
struct PASDatabase : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> magic;
Value<atUint32> animStateCount;
Value<atUint32> defaultState;
struct AnimState : BigYAML
struct AnimState : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Delete expl;
atUint32 id;
struct ParmInfo : BigYAML
struct ParmInfo : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Delete expl;
enum class DataType
{
@ -112,22 +112,22 @@ struct ANCS : BigYAML
atUint32 unk1 = 0;
struct ActionAABB : BigYAML
struct ActionAABB : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atVec3f> aabb[2];
};
std::vector<ActionAABB> animAABBs;
struct Effect : BigYAML
struct Effect : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<atUint32> compCount;
struct EffectComponent : BigYAML
struct EffectComponent : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
DNAFourCC type;
UniqueID32 id;
@ -148,16 +148,15 @@ struct ANCS : BigYAML
Vector<CharacterInfo, DNA_COUNT(characterCount)> characters;
} characterSet;
struct AnimationSet : BigYAML
struct AnimationSet : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Delete expl;
struct MetaAnimPrimitive;
struct IMetaAnim : BigYAML
struct IMetaAnim : BigDNAVYaml
{
Delete expl;
virtual ~IMetaAnim() {}
enum class Type
{
Primitive = 0,
@ -172,16 +171,15 @@ struct ANCS : BigYAML
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
struct MetaAnimFactory : BigDNA
{
DECL_YAML
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
std::unique_ptr<IMetaAnim> m_anim;
};
struct MetaAnimPrimitive : IMetaAnim
{
Delete expl2;
AT_DECL_DNA_YAML
AT_DECL_DNAV
MetaAnimPrimitive() : IMetaAnim(Type::Primitive, "Primitive") {}
UniqueID32 animId;
@ -190,70 +188,6 @@ struct ANCS : BigYAML
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};
@ -268,7 +202,8 @@ struct ANCS : BigYAML
{
MetaAnimBlend()
: IMetaAnim(Type::Blend, "Blend") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
MetaAnimFactory animA;
MetaAnimFactory animB;
Value<float> unkFloat;
@ -293,7 +228,8 @@ struct ANCS : BigYAML
{
MetaAnimPhaseBlend()
: IMetaAnim(Type::PhaseBlend, "PhaseBlend") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
MetaAnimFactory animA;
MetaAnimFactory animB;
Value<float> unkFloat;
@ -317,11 +253,12 @@ struct ANCS : BigYAML
struct MetaAnimRandom : IMetaAnim
{
MetaAnimRandom() : IMetaAnim(Type::Random, "Random") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atUint32> animCount;
struct Child : BigYAML
struct Child : BigDNA
{
DECL_YAML
AT_DECL_DNA
MetaAnimFactory anim;
Value<atUint32> probability;
};
@ -344,7 +281,8 @@ struct ANCS : BigYAML
struct MetaAnimSequence : IMetaAnim
{
MetaAnimSequence() : IMetaAnim(Type::Sequence, "Sequence") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<atUint32> animCount;
Vector<MetaAnimFactory, DNA_COUNT(animCount)> children;
@ -363,18 +301,17 @@ struct ANCS : BigYAML
}
};
struct Animation : BigYAML
struct Animation : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
MetaAnimFactory metaAnim;
};
std::vector<Animation> animations;
struct IMetaTrans : BigYAML
struct IMetaTrans : BigDNAVYaml
{
Delete expl;
virtual ~IMetaTrans() {}
enum class Type
{
MetaAnim = 0,
@ -388,9 +325,9 @@ struct ANCS : BigYAML
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
struct MetaTransFactory : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Delete expl;
std::unique_ptr<IMetaTrans> m_trans;
};
@ -398,7 +335,8 @@ struct ANCS : BigYAML
{
MetaTransMetaAnim()
: IMetaTrans(Type::MetaAnim, "MetaAnim") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
MetaAnimFactory anim;
void gatherPrimitives(std::map<atUint32, DNAANCS::AnimationResInfo<UniqueID32>>& out)
@ -415,7 +353,8 @@ struct ANCS : BigYAML
{
MetaTransTrans()
: IMetaTrans(Type::Trans, "Trans") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<float> transDurTime;
Value<atUint32> transDurTimeMode;
Value<bool> unk2;
@ -426,7 +365,8 @@ struct ANCS : BigYAML
{
MetaTransPhaseTrans()
: IMetaTrans(Type::PhaseTrans, "PhaseTrans") {}
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
Value<float> transDurTime;
Value<atUint32> transDurTimeMode;
Value<bool> unk2;
@ -434,9 +374,9 @@ struct ANCS : BigYAML
Value<atUint32> flags;
};
struct Transition : BigYAML
struct Transition : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> unk;
Value<atUint32> animIdxA;
Value<atUint32> animIdxB;
@ -445,9 +385,9 @@ struct ANCS : BigYAML
std::vector<Transition> transitions;
MetaTransFactory defaultTransition;
struct AdditiveAnimationInfo : BigYAML
struct AdditiveAnimationInfo : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> animIdx;
Value<float> unk1;
Value<float> unk2;
@ -457,17 +397,17 @@ struct ANCS : BigYAML
float floatA = 0.0;
float floatB = 0.0;
struct HalfTransition : BigYAML
struct HalfTransition : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> animIdx;
MetaTransFactory metaTrans;
};
std::vector<HalfTransition> halfTransitions;
struct AnimationResources : BigYAML
struct AnimationResources : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
UniqueID32 animId;
UniqueID32 evntId;
};

76
DataSpec/DNAMP1/ANIM.cpp
View File

@ -94,7 +94,48 @@ void ANIM::IANIM::sendANIMToBlender(hecl::blender::PyOutStream& os, const DNAANI
}
}
void ANIM::ANIM0::read(athena::io::IStreamReader& reader)
template <>
void ANIM::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
atUint32 version = reader.readUint32Big();
switch (version)
{
case 0:
m_anim.reset(new struct ANIM0);
m_anim->read(reader);
break;
case 2:
m_anim.reset(new struct ANIM2(false));
m_anim->read(reader);
break;
case 3:
m_anim.reset(new struct ANIM2(true));
m_anim->read(reader);
break;
default:
Log.report(logvisor::Error, "unrecognized ANIM version");
break;
}
}
template <>
void ANIM::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
writer.writeUint32Big(m_anim->m_version);
m_anim->write(writer);
}
template <>
void ANIM::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
s += 4;
m_anim->binarySize(s);
}
const char* ANIM::ANIM0::DNAType() { return "ANIM0"; }
template <>
void ANIM::ANIM0::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
Header head;
head.read(reader);
@ -164,7 +205,8 @@ void ANIM::ANIM0::read(athena::io::IStreamReader& reader)
evnt.read(reader);
}
void ANIM::ANIM0::write(athena::io::IStreamWriter& writer) const
template <>
void ANIM::ANIM0::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
Header head;
head.unk0 = 0;
@ -242,7 +284,8 @@ void ANIM::ANIM0::write(athena::io::IStreamWriter& writer) const
evnt.write(writer);
}
size_t ANIM::ANIM0::binarySize(size_t __isz) const
template <>
void ANIM::ANIM0::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
Header head;
@ -250,7 +293,7 @@ size_t ANIM::ANIM0::binarySize(size_t __isz) const
for (const std::pair<atUint32, bool>& bone : bones)
maxId = std::max(maxId, bone.first);
__isz = head.binarySize(__isz);
head.binarySize(__isz);
__isz += maxId + 1;
__isz += bones.size() + 4;
@ -262,10 +305,13 @@ size_t ANIM::ANIM0::binarySize(size_t __isz) const
__isz += head.keyCount * 12;
}
return __isz + 4;
__isz += 4;
}
void ANIM::ANIM2::read(athena::io::IStreamReader& reader)
const char* ANIM::ANIM2::DNAType() { return "ANIM2"; }
template <>
void ANIM::ANIM2::Enumerate<BigDNA::Read>(athena::io::IStreamReader& reader)
{
Header head;
head.read(reader);
@ -374,7 +420,8 @@ void ANIM::ANIM2::read(athena::io::IStreamReader& reader)
chanKeys = bsReader.read(bsData.get(), keyframeCount, channels, head.rotDiv, head.translationMult, 0.f);
}
void ANIM::ANIM2::write(athena::io::IStreamWriter& writer) const
template <>
void ANIM::ANIM2::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& writer)
{
Header head;
head.evnt = evnt;
@ -408,7 +455,11 @@ void ANIM::ANIM2::write(athena::io::IStreamWriter& writer) const
head.rotDiv, head.translationMult, scaleMult, bsSize);
/* Tally up buffer size */
head.scratchSize = head.binarySize(0) + keyBmp.binarySize(0) + bsSize;
size_t scratchSize = 0;
head.binarySize(scratchSize);
keyBmp.binarySize(scratchSize);
scratchSize += bsSize;
head.scratchSize = scratchSize;
if (m_version == 3)
{
for (const std::pair<atUint32, bool>& bone : bones)
@ -492,7 +543,8 @@ void ANIM::ANIM2::write(athena::io::IStreamWriter& writer) const
writer.writeUBytes(bsData.get(), bsSize);
}
size_t ANIM::ANIM2::binarySize(size_t __isz) const
template <>
void ANIM::ANIM2::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
Header head;
@ -500,8 +552,8 @@ size_t ANIM::ANIM2::binarySize(size_t __isz) const
for (atUint32 frame : frames)
keyBmp.setBit(frame);
__isz = head.binarySize(__isz);
__isz = keyBmp.binarySize(__isz);
head.binarySize(__isz);
keyBmp.binarySize(__isz);
__isz += 8;
if (m_version == 3)
{
@ -522,7 +574,7 @@ size_t ANIM::ANIM2::binarySize(size_t __isz) const
}
}
return __isz + DNAANIM::ComputeBitstreamSize(frames.size(), channels);
__isz += DNAANIM::ComputeBitstreamSize(frames.size(), channels);
}
ANIM::ANIM(const BlenderAction& act,

47
DataSpec/DNAMP1/ANIM.hpp
View File

@ -11,9 +11,9 @@ namespace DataSpec::DNAMP1
struct ANIM : BigDNA
{
Delete expl;
AT_DECL_EXPLICIT_DNA
struct IANIM : BigDNA
struct IANIM : BigDNAV
{
Delete expl;
atUint32 m_version;
@ -32,12 +32,13 @@ struct ANIM : BigDNA
struct ANIM0 : IANIM
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
AT_DECL_DNAV
ANIM0() : IANIM(0) {}
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<float> duration;
Value<atUint32> unk0;
Value<float> interval;
@ -50,12 +51,13 @@ struct ANIM : BigDNA
struct ANIM2 : IANIM
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
AT_DECL_DNAV
ANIM2(bool pc) : IANIM(pc ? 3 : 2) {}
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> scratchSize;
UniqueID32 evnt;
Value<atUint32> unk0 = 1;
@ -194,39 +196,6 @@ struct ANIM : BigDNA
};
std::unique_ptr<IANIM> m_anim;
void read(athena::io::IStreamReader& reader)
{
atUint32 version = reader.readUint32Big();
switch (version)
{
case 0:
m_anim.reset(new struct ANIM0);
m_anim->read(reader);
break;
case 2:
m_anim.reset(new struct ANIM2(false));
m_anim->read(reader);
break;
case 3:
m_anim.reset(new struct ANIM2(true));
m_anim->read(reader);
break;
default:
Log.report(logvisor::Error, "unrecognized ANIM version");
break;
}
}
void write(athena::io::IStreamWriter& writer) const
{
writer.writeUint32Big(m_anim->m_version);
m_anim->write(writer);
}
size_t binarySize(size_t __isz) const
{
return m_anim->binarySize(__isz + 4);
}
void sendANIMToBlender(hecl::blender::PyOutStream& os, const DNAANIM::RigInverter<CINF>& rig, bool) const
{

6
DataSpec/DNAMP1/CINF.hpp
View File

@ -9,11 +9,11 @@ namespace DataSpec::DNAMP1
struct CINF : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> boneCount;
struct Bone : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> id;
Value<atUint32> parentId;
Value<atVec3f> origin;
@ -28,7 +28,7 @@ struct CINF : BigDNA
Value<atUint32> nameCount;
struct Name : BigDNA
{
DECL_DNA
AT_DECL_DNA
String<-1> name;
Value<atUint32> boneId;
};

38
DataSpec/DNAMP1/CMDLMaterials.cpp
View File

@ -1140,7 +1140,9 @@ MaterialSet::Material::Material(const hecl::Backend::GX& gx,
found = true;
++uvAnimsCount;
uvAnims.emplace_back(tcg.m_gameFunction, tcg.m_gameArgs);
uvAnimsSize = uvAnims.back().binarySize(uvAnimsSize);
size_t tmpUvAnimsSize = uvAnimsSize;
uvAnims.back().binarySize(tmpUvAnimsSize);
uvAnimsSize = tmpUvAnimsSize;
break;
}
}
@ -1233,7 +1235,9 @@ HMDLMaterialSet::Material::Material(hecl::Frontend::Frontend& FE,
++uvAnimsCount;
uvAnims.emplace_back(sourceInst.m_call.m_name, gameArgs);
uvAnimsSize = uvAnims.back().binarySize(uvAnimsSize);
size_t tmpUvAnimsSize = uvAnimsSize;
uvAnims.back().binarySize(tmpUvAnimsSize);
uvAnimsSize = tmpUvAnimsSize;
}
}
@ -1296,6 +1300,36 @@ MaterialSet::Material::UVAnimation::UVAnimation(const std::string& gameFunction,
Log.report(logvisor::Fatal, "unsupported UV anim '%s'", gameFunction.c_str());
}
template <class Op>
void MaterialSet::Material::UVAnimation::Enumerate(typename Op::StreamT& s)
{
Do<Op>({}, mode, s);
switch (mode)
{
case Mode::MvInvNoTranslation:
case Mode::MvInv:
case Mode::Model:
break;
case Mode::Scroll:
case Mode::HStrip:
case Mode::VStrip:
for (int i=0 ; i<4 ; ++i)
Do<Op>({}, vals[i], s);
break;
case Mode::Rotation:
case Mode::CylinderEnvironment:
for (int i=0 ; i<2 ; ++i)
Do<Op>({}, vals[i], s);
break;
case Mode::Eight:
for (int i=0 ; i<9 ; ++i)
Do<Op>({}, vals[i], s);
break;
}
}
AT_SPECIALIZE_DNA(MaterialSet::Material::UVAnimation)
}
namespace DataSpec::DNAMP2

114
DataSpec/DNAMP1/CMDLMaterials.hpp
View File

@ -13,10 +13,10 @@ struct MaterialSet : BigDNA
{
static constexpr bool OneSection() {return false;}
DECL_DNA
AT_DECL_DNA
struct MaterialSetHead : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> textureCount = 0;
Vector<UniqueID32, DNA_COUNT(textureCount)> textureIDs;
Value<atUint32> materialCount = 0;
@ -28,10 +28,10 @@ struct MaterialSet : BigDNA
struct Material : BigDNA
{
DECL_DNA
AT_DECL_DNA
struct Flags : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> flags = 0;
bool konstValuesEnabled() const {return (flags & 0x8) != 0;}
void setKonstValuesEnabled(bool enabled) {flags &= ~0x8; flags |= atUint32(enabled) << 3;}
@ -62,7 +62,7 @@ struct MaterialSet : BigDNA
Vector<atUint32, DNA_COUNT(textureCount)> textureIdxs;
struct VAFlags : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> vaFlags = 0;
GX::AttrType position() const {return GX::AttrType(vaFlags & 0x3);}
void setPosition(GX::AttrType val) {vaFlags &= ~0x3; vaFlags |= atUint32(val);}
@ -143,7 +143,7 @@ struct MaterialSet : BigDNA
Value<atUint32> colorChannelCount = 0;
struct ColorChannel : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> flags = 0;
bool lighting() const {return (flags & 0x1) != 0;}
void setLighting(bool enabled) {flags &= ~0x1; flags |= atUint32(enabled);}
@ -163,7 +163,7 @@ struct MaterialSet : BigDNA
Value<atUint32> tevStageCount = 0;
struct TEVStage : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> ciFlags = 0;
Value<atUint32> aiFlags = 0;
Value<atUint32> ccFlags = 0;
@ -221,7 +221,7 @@ struct MaterialSet : BigDNA
Vector<TEVStage, DNA_COUNT(tevStageCount)> tevStages;
struct TEVStageTexInfo : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint16> pad = 0;
Value<atUint8> texSlot = 0xff;
Value<atUint8> tcgSlot = 0xff;
@ -231,7 +231,7 @@ struct MaterialSet : BigDNA
Value<atUint32> tcgCount = 0;
struct TexCoordGen : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> flags = 0;
GX::TexGenType type() const {return GX::TexGenType(flags & 0xf);}
@ -251,7 +251,7 @@ struct MaterialSet : BigDNA
Value<atUint32> uvAnimsCount = 0;
struct UVAnimation : BigDNA
{
Delete expl;
AT_DECL_EXPLICIT_DNA
enum class Mode
{
MvInvNoTranslation,
@ -265,96 +265,6 @@ struct MaterialSet : BigDNA
Eight
} mode;
float vals[9];
void read(athena::io::IStreamReader& reader)
{
mode = Mode(reader.readUint32Big());
switch (mode)
{
case Mode::MvInvNoTranslation:
case Mode::MvInv:
case Mode::Model:
break;
case Mode::Scroll:
case Mode::HStrip:
case Mode::VStrip:
vals[0] = reader.readFloatBig();
vals[1] = reader.readFloatBig();
vals[2] = reader.readFloatBig();
vals[3] = reader.readFloatBig();
break;
case Mode::Rotation:
case Mode::CylinderEnvironment:
vals[0] = reader.readFloatBig();
vals[1] = reader.readFloatBig();
break;
case Mode::Eight:
vals[0] = reader.readFloatBig();
vals[1] = reader.readFloatBig();
vals[2] = reader.readFloatBig();
vals[3] = reader.readFloatBig();
vals[4] = reader.readFloatBig();
vals[5] = reader.readFloatBig();
vals[6] = reader.readFloatBig();
vals[7] = reader.readFloatBig();
vals[8] = reader.readFloatBig();
break;
}
}
void write(athena::io::IStreamWriter& writer) const
{
writer.writeUint32Big(atUint32(mode));
switch (mode)
{
case Mode::MvInvNoTranslation:
case Mode::MvInv:
case Mode::Model:
break;
case Mode::Scroll:
case Mode::HStrip:
case Mode::VStrip:
writer.writeFloatBig(vals[0]);
writer.writeFloatBig(vals[1]);
writer.writeFloatBig(vals[2]);
writer.writeFloatBig(vals[3]);
break;
case Mode::Rotation:
case Mode::CylinderEnvironment:
writer.writeFloatBig(vals[0]);
writer.writeFloatBig(vals[1]);
break;
case Mode::Eight:
writer.writeFloatBig(vals[0]);
writer.writeFloatBig(vals[1]);
writer.writeFloatBig(vals[2]);
writer.writeFloatBig(vals[3]);
writer.writeFloatBig(vals[4]);
writer.writeFloatBig(vals[5]);
writer.writeFloatBig(vals[6]);
writer.writeFloatBig(vals[7]);
writer.writeFloatBig(vals[8]);
break;
}
}
size_t binarySize(size_t __isz) const
{
switch (mode)
{
case Mode::MvInvNoTranslation:
case Mode::MvInv:
case Mode::Model:
return __isz + 4;
case Mode::Scroll:
case Mode::HStrip:
case Mode::VStrip:
return __isz + 20;
case Mode::Rotation:
case Mode::CylinderEnvironment:
return __isz + 12;
case Mode::Eight:
return __isz + 40;
}
return __isz + 4;
}
UVAnimation() = default;
UVAnimation(const std::string& gameFunction,
@ -447,12 +357,12 @@ struct HMDLMaterialSet : BigDNA
{
static constexpr bool OneSection() {return false;}
DECL_DNA
AT_DECL_DNA
MaterialSet::MaterialSetHead head;
struct Material : BigDNA
{
DECL_DNA
AT_DECL_DNA
MaterialSet::Material::Flags flags;
Value<atUint32> textureCount = 0;

2
DataSpec/DNAMP1/CMakeLists.txt
View File

@ -39,6 +39,7 @@ make_dnalist(liblist DNAMP1
set(DNAMP1_SOURCES
DNAMP1.hpp DNAMP1.cpp
AFSM.cpp
PAK.cpp
MLVL.cpp
STRG.hpp STRG.cpp
@ -57,6 +58,7 @@ set(DNAMP1_SOURCES
MREA.cpp
SCLY.hpp SCLY.cpp
FRME.cpp
SCAN.cpp
DeafBabe.cpp
Tweaks/CTweakPlayer.cpp
Tweaks/CTweakTargeting.cpp

6
DataSpec/DNAMP1/CSKR.hpp
View File

@ -9,15 +9,15 @@ namespace DataSpec::DNAMP1
struct CSKR : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> skinningRuleCount;
struct SkinningRule : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> weightCount;
struct Weight : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> boneId;
Value<float> weight;
};

2
DataSpec/DNAMP1/CSNG.hpp
View File

@ -11,7 +11,7 @@ class CSNG
{
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> magic = 0x2;
Value<atUint32> midiSetupId;
Value<atUint32> songGroupId;

27
DataSpec/DNAMP1/DCLN.cpp
View File

@ -30,6 +30,33 @@ void DCLN::Collision::NodesendToBlender(hecl::blender::PyOutStream& os) const
}
#endif
template <class Op>
void DCLN::Collision::Node::Enumerate(typename Op::StreamT& s)
{
Do<Op>({"xf[0]"}, xf[0], s);
Do<Op>({"xf[1]"}, xf[1], s);
Do<Op>({"xf[2]"}, xf[2], s);
Do<Op>({"halfExtent"}, halfExtent, s);
Do<Op>({"isLeaf"}, isLeaf, s);
if (isLeaf)
{
if (!leafData)
leafData.reset(new LeafData);
Do<Op>({"leafData"}, *leafData, s);
}
else
{
if (!left)
left.reset(new Node);
Do<Op>({"left"}, *left, s);
if (!right)
right.reset(new Node);
Do<Op>({"right"}, *right, s);
}
}
AT_SPECIALIZE_DNA(DCLN::Collision::Node)
void DCLN::sendToBlender(hecl::blender::Connection& conn, std::string_view entryName)
{
/* Open Py Stream and read sections */

58
DataSpec/DNAMP1/DCLN.hpp
View File

@ -17,7 +17,7 @@ struct DCLN : BigDNA
{
using Mesh = hecl::blender::ColMesh;
DECL_DNA
AT_DECL_DNA
Value<atUint32> colCount;
struct Collision : BigDNA
{
@ -25,7 +25,7 @@ struct DCLN : BigDNA
using Edge = DeafBabe::Edge;
using Triangle = DeafBabe::Triangle;
DECL_DNA
AT_DECL_DNA
Value<atUint32> magic;
Value<atUint32> version;
Value<atUint32> memSize;
@ -46,11 +46,11 @@ struct DCLN : BigDNA
struct Node : BigDNA
{
Delete _d;
AT_DECL_EXPLICIT_DNA
struct LeafData : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> triangleIndexCount;
Vector<atUint16, DNA_COUNT(triangleIndexCount)> triangleIndices;
size_t getMemoryUsage() const { return (((triangleIndices.size() * 2) + 16) + 3) & ~3; }
@ -63,56 +63,6 @@ struct DCLN : BigDNA
std::unique_ptr<Node> left;
std::unique_ptr<Node> right;
void read(athena::io::IStreamReader & __dna_reader)
{
xf[0] = __dna_reader.readVec4fBig();
xf[1] = __dna_reader.readVec4fBig();
xf[2] = __dna_reader.readVec4fBig();
halfExtent = __dna_reader.readVec3fBig();
isLeaf = __dna_reader.readBool();
if (isLeaf)
{
leafData.reset(new LeafData);
leafData->read(__dna_reader);
}
else
{
left.reset(new Node);
left->read(__dna_reader);
right.reset(new Node);
right->read(__dna_reader);
}
}
void write(athena::io::IStreamWriter & __dna_writer) const
{
__dna_writer.writeVec4fBig(xf[0]);
__dna_writer.writeVec4fBig(xf[1]);
__dna_writer.writeVec4fBig(xf[2]);
__dna_writer.writeVec3fBig(halfExtent);
__dna_writer.writeBool(isLeaf);
if (isLeaf && leafData)
leafData->write(__dna_writer);
else if (!isLeaf && left && right)
{
left->write(__dna_writer);
right->write(__dna_writer);
}
}
size_t binarySize(size_t __isz) const
{
__isz += 61;
if (isLeaf && leafData)
__isz = leafData->binarySize(__isz);
else if (!isLeaf && left && right)
{
__isz = left->binarySize(__isz);
__isz = right->binarySize(__isz);
}
return __isz;
}
size_t getMemoryUsage() const
{
size_t ret = 80;

8
DataSpec/DNAMP1/DeafBabe.hpp
View File

@ -8,12 +8,12 @@ namespace DataSpec::DNAMP1
struct DeafBabe : BigDNA
{
DECL_DNA
AT_DECL_DNA
using BspNodeType = DataSpec::BspNodeType;
struct Material : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> material = 0;
bool unknown() const { return material & 1; }
void setUnknown(bool v) { material &= ~1; material |= int(v); }
@ -107,13 +107,13 @@ struct DeafBabe : BigDNA
struct Edge : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint16> verts[2];
};
struct Triangle : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint16> edges[3];
};

86
DataSpec/DNAMP1/EVNT.cpp
View File

@ -3,94 +3,32 @@
namespace DataSpec::DNAMP1
{
void EVNT::read(athena::io::IStreamReader& reader)
template <class Op>
void EVNT::Enumerate(typename Op::StreamT& s)
{
version = reader.readUint32Big();
Do<Op>({"version"}, version, s);
atUint32 loopCount = reader.readUint32Big();
reader.enumerate(boolPOINodes, loopCount);
DoSize<Op>({"boolPOICount"}, boolPOICount, s);
Do<Op>({"boolPOINodes"}, boolPOINodes, boolPOICount, s);
int32POINodes.clear();
atUint32 uevtCount = reader.readUint32Big();
reader.enumerate(int32POINodes, uevtCount);
DoSize<Op>({"int32POICount"}, int32POICount, s);
Do<Op>({"int32POINodes"}, int32POINodes, int32POICount, s);
atUint32 effectCount = reader.readUint32Big();
reader.enumerate(particlePOINodes, effectCount);
DoSize<Op>({"particlePOICount"}, particlePOICount, s);
Do<Op>({"particlePOINodes"}, particlePOINodes, particlePOICount, s);
if (version == 2)
{
atUint32 sfxCount = reader.readUint32Big();
reader.enumerate(soundPOINodes, sfxCount);
DoSize<Op>({"soundPOICount"}, soundPOICount, s);
Do<Op>({"particlePOINodes"}, soundPOINodes, soundPOICount, s);
}
}
void EVNT::write(athena::io::IStreamWriter& writer) const
{
writer.writeUint32Big(version);
writer.writeUint32Big(boolPOINodes.size());
writer.enumerate(boolPOINodes);
writer.writeUint32Big(int32POINodes.size());
writer.enumerate(int32POINodes);
writer.writeUint32Big(particlePOINodes.size());
writer.enumerate(particlePOINodes);
if (version == 2)
{
writer.writeUint32Big(soundPOINodes.size());
writer.enumerate(soundPOINodes);
}
}
void EVNT::read(athena::io::YAMLDocReader& reader)
{
version = reader.readUint32("version");
reader.enumerate("boolPOINodes", boolPOINodes);
int32POINodes.clear();
reader.enumerate("int32POINodes", int32POINodes);
reader.enumerate("particlePOINodes", particlePOINodes);
if (version == 2)
{
reader.enumerate("soundPOINodes", soundPOINodes);
}
}
void EVNT::write(athena::io::YAMLDocWriter& writer) const
{
writer.writeUint32("version", version);
writer.enumerate("boolPOINodes", boolPOINodes);
writer.enumerate("int32POINodes", int32POINodes);
writer.enumerate("particlePOINodes", particlePOINodes);
if (version == 2)
{
writer.enumerate("soundPOINodes", soundPOINodes);
}
}
AT_SPECIALIZE_DNA_YAML(EVNT)
const char* EVNT::DNAType()
{
return "urde::DNAMP1::EVNT";
}
size_t EVNT::binarySize(size_t __isz) const
{
__isz = __EnumerateSize(__isz, boolPOINodes);
__isz = __EnumerateSize(__isz, int32POINodes);
__isz = __EnumerateSize(__isz, particlePOINodes);
if (version == 2)
__isz = __EnumerateSize(__isz, soundPOINodes);
return __isz + (version == 2 ? 20 : 16);
}
}

37
DataSpec/DNAMP1/EVNT.hpp
View File

@ -7,19 +7,18 @@
namespace DataSpec::DNAMP1
{
struct EVNT : BigYAML
struct EVNT : BigDNA
{
DECL_YAML
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
Value<atUint32> version;
struct POINode : BigYAML
struct POINode : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint16> unk0;
String<-1> name;
Value<atUint16> type;
struct CharAnimTime : BigYAML
struct CharAnimTime : BigDNA
{
enum class Type : atUint32
{
@ -30,7 +29,7 @@ struct EVNT : BigYAML
Infinity
};
DECL_YAML
AT_DECL_DNA_YAML
Value<float> time;
Value<Type> type;
};
@ -45,22 +44,24 @@ struct EVNT : BigYAML
struct BoolPOINode : POINode
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint8> value;
};
std::vector<BoolPOINode> boolPOINodes;
Value<atUint32> boolPOICount;
Vector<BoolPOINode, DNA_COUNT(boolPOICount)> boolPOINodes;
struct Int32POINode : POINode
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> value;
String<-1> locator;
};
std::vector<Int32POINode> int32POINodes;
Value<atUint32> int32POICount;
Vector<Int32POINode, DNA_COUNT(int32POICount)> int32POINodes;
struct ParticlePOINode : POINode
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> duration;
DNAFourCC ptype;
UniqueID32 id;
@ -68,23 +69,25 @@ struct EVNT : BigYAML
Value<float> scale;
Value<atUint32> parentMode;
};
std::vector<ParticlePOINode> particlePOINodes;
Value<atUint32> particlePOICount;
Vector<ParticlePOINode, DNA_COUNT(particlePOICount)> particlePOINodes;
struct SoundPOINode : POINode
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> soundId;
Value<float> falloff;
Value<float> maxDist;
};
std::vector<SoundPOINode> soundPOINodes;
Value<atUint32> soundPOICount;
Vector<SoundPOINode, DNA_COUNT(soundPOICount)> soundPOINodes;
static bool Extract(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath)
{
EVNT evnt;
evnt.read(rs);
athena::io::FileWriter writer(outPath.getAbsolutePath());
evnt.toYAMLStream(writer);
athena::io::ToYAMLStream(evnt, writer);
return true;
}
@ -92,7 +95,7 @@ struct EVNT : BigYAML
{
EVNT evnt;
athena::io::FileReader reader(inPath.getAbsolutePath());
evnt.fromYAMLStream(reader);
athena::io::FromYAMLStream(evnt, reader);
athena::io::FileWriter ws(outPath.getAbsolutePath());
evnt.write(ws);
return true;

151
DataSpec/DNAMP1/FRME.cpp
View File

@ -4,7 +4,9 @@
namespace DataSpec::DNAMP1
{
void FRME::read(athena::io::IStreamReader& __dna_reader)
template <>
void FRME::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader)
{
/* version */
version = __dna_reader.readUint32Big();
@ -23,7 +25,8 @@ void FRME::read(athena::io::IStreamReader& __dna_reader)
});
}
void FRME::write(athena::io::IStreamWriter& __dna_writer) const
template <>
void FRME::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{
/* version */
__dna_writer.writeUint32Big(version);
@ -39,13 +42,16 @@ void FRME::write(athena::io::IStreamWriter& __dna_writer) const
__dna_writer.enumerate(widgets);
}
size_t FRME::binarySize(size_t __isz) const
template <>
void FRME::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz = __EnumerateSize(__isz, widgets);
return __isz + 20;
for (const Widget& w : widgets)
w.binarySize(__isz);
__isz += 20;
}
void FRME::Widget::read(athena::io::IStreamReader& __dna_reader)
template <>
void FRME::Widget::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader)
{
/* type */
type.read(__dna_reader);
@ -96,7 +102,8 @@ void FRME::Widget::read(athena::io::IStreamReader& __dna_reader)
unk2 = __dna_reader.readInt16Big();
}
void FRME::Widget::write(athena::io::IStreamWriter& __dna_writer) const
template <>
void FRME::Widget::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{
/* type */
DNAFourCC _type = widgetInfo ? widgetInfo->fourcc() : FOURCC('BWIG');
@ -131,18 +138,20 @@ void FRME::Widget::write(athena::io::IStreamWriter& __dna_writer) const
__dna_writer.writeInt16Big(unk2);
}
size_t FRME::Widget::binarySize(size_t __isz) const
template <>
void FRME::Widget::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz = type.binarySize(__isz);
__isz = header.binarySize(__isz);
type.binarySize(__isz);
header.binarySize(__isz);
if (widgetInfo)
__isz = widgetInfo->binarySize(__isz);
widgetInfo->binarySize(__isz);
if (isWorker)
__isz += 4;
return __isz + 67;
__isz += 67;
}
void FRME::Widget::CAMRInfo::read(athena::io::IStreamReader& __dna_reader)
template <>
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader)
{
projectionType = ProjectionType(__dna_reader.readUint32Big());
if (projectionType == ProjectionType::Perspective)
@ -155,7 +164,8 @@ void FRME::Widget::CAMRInfo::read(athena::io::IStreamReader& __dna_reader)
projection->read(__dna_reader);
}
void FRME::Widget::CAMRInfo::write(athena::io::IStreamWriter& __dna_writer) const
template <>
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{
if (!projection)
Log.report(logvisor::Fatal, _S("Invalid CAMR projection object!"));
@ -166,15 +176,16 @@ void FRME::Widget::CAMRInfo::write(athena::io::IStreamWriter& __dna_writer) cons
projection->write(__dna_writer);
}
size_t FRME::Widget::CAMRInfo::binarySize(size_t __isz) const
template <>
void FRME::Widget::CAMRInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz = projection->binarySize(__isz);
return __isz + 4;
projection->binarySize(__isz);
__isz += 4;
}
void FRME::Widget::LITEInfo::read(athena::io::IStreamReader& __dna_reader)
template <>
void FRME::Widget::LITEInfo::Enumerate<BigDNA::Read>(athena::io::IStreamReader& __dna_reader)
{
IWidgetInfo::read(__dna_reader);
/* type */
type = ELightType(__dna_reader.readUint32Big());
/* distC */
@ -197,9 +208,9 @@ void FRME::Widget::LITEInfo::read(athena::io::IStreamReader& __dna_reader)
cutoff = __dna_reader.readFloatBig();
}
void FRME::Widget::LITEInfo::write(athena::io::IStreamWriter& __dna_writer) const
template <>
void FRME::Widget::LITEInfo::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& __dna_writer)
{
IWidgetInfo::write(__dna_writer);
/* type */
__dna_writer.writeUint32Big(atUint32(type));
/* distC */
@ -222,93 +233,35 @@ void FRME::Widget::LITEInfo::write(athena::io::IStreamWriter& __dna_writer) cons
__dna_writer.writeFloatBig(cutoff);
}
size_t FRME::Widget::LITEInfo::binarySize(size_t __isz) const
template <>
void FRME::Widget::LITEInfo::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz = IWidgetInfo::binarySize(__isz);
return __isz + ((type == ELightType::Spot) ? 36 : 32);
__isz += ((type == ELightType::Spot) ? 36 : 32);
}
void FRME::Widget::TXPNInfo::read(athena::io::IStreamReader& __dna_reader)
template <class Op>
void FRME::Widget::TXPNInfo::Enumerate(typename Op::StreamT& s)
{
IWidgetInfo::read(__dna_reader);
/* xDim */
xDim = __dna_reader.readFloatBig();
/* zDim */
zDim = __dna_reader.readFloatBig();
/* scaleCenter */
scaleCenter = __dna_reader.readVec3fBig();
/* font */
font.read(__dna_reader);
/* unk1 */
wordWrap = __dna_reader.readBool();
/* unk2 */
horizontal = __dna_reader.readBool();
/* justification */
justification = Justification(__dna_reader.readUint32Big());
/* verticalJustification */
verticalJustification = VerticalJustification(__dna_reader.readUint32Big());
/* fillColor */
fillColor = __dna_reader.readVec4fBig();
/* outlineColor */
outlineColor = __dna_reader.readVec4fBig();
/* pointScale */
blockExtent = __dna_reader.readVec2fBig();
Do<Op>({"xDim"}, xDim, s);
Do<Op>({"zDim"}, zDim, s);
Do<Op>({"scaleCenter"}, scaleCenter, s);
Do<Op>({"font"}, font, s);
Do<Op>({"wordWrap"}, wordWrap, s);
Do<Op>({"horizontal"}, horizontal, s);
Do<Op>({"justification"}, justification, s);
Do<Op>({"verticalJustification"}, verticalJustification, s);
Do<Op>({"fillColor"}, fillColor, s);
Do<Op>({"outlineColor"}, outlineColor, s);
Do<Op>({"blockExtent"}, blockExtent, s);
if (version == 1)
{
/* jpnFont */
jpnFont.read(__dna_reader);
/* jpnPointScale[0] */
jpnPointScale[0] = __dna_reader.readInt32Big();
/* jpnPointScale[0] */
jpnPointScale[1] = __dna_reader.readInt32Big();
Do<Op>({"jpnFont"}, jpnFont, s);
Do<Op>({"jpnPointScale[0]"}, jpnPointScale[0], s);
Do<Op>({"jpnPointScale[1]"}, jpnPointScale[1], s);
}
}
void FRME::Widget::TXPNInfo::write(athena::io::IStreamWriter& __dna_writer) const
{
IWidgetInfo::write(__dna_writer);
/* xDim */
__dna_writer.writeFloatBig(xDim);
/* zDim */
__dna_writer.writeFloatBig(zDim);
/* scaleCenter */
__dna_writer.writeVec3fBig(scaleCenter);
/* font */
font.write(__dna_writer);
/* unk1 */
__dna_writer.writeBool(wordWrap);
/* unk2 */
__dna_writer.writeBool(horizontal);
/* justification */
__dna_writer.writeUint32Big(atUint32(justification));
/* verticalJustification */
__dna_writer.writeUint32Big(atUint32(verticalJustification));
/* fillColor */
__dna_writer.writeVec4fBig(fillColor);
/* outlineColor */
__dna_writer.writeVec4fBig(outlineColor);
/* pointScale */
__dna_writer.writeVec2fBig(blockExtent);
if (version == 1)
{
/* jpnFont */
jpnFont.write(__dna_writer);
/* jpnPointScale[0] */
__dna_writer.writeInt32Big(jpnPointScale[0]);
/* jpnPointScale[1] */
__dna_writer.writeInt32Big(jpnPointScale[1]);
}
}
size_t FRME::Widget::TXPNInfo::binarySize(size_t __isz) const
{
__isz = IWidgetInfo::binarySize(__isz);
__isz = font.binarySize(__isz);
if (version == 1)
__isz = jpnFont.binarySize(__isz);
return __isz + (version == 1 ? 78 : 66);
}
AT_SPECIALIZE_DNA(FRME::Widget::TXPNInfo)
bool FRME::Extract(const SpecBase &dataSpec,
PAKEntryReadStream &rs,

62
DataSpec/DNAMP1/FRME.hpp
View File

@ -4,12 +4,13 @@
#include "../DNACommon/DNACommon.hpp"
#include "DNAMP1.hpp"
#include <athena/FileWriter.hpp>
#include "athena/DNAOp.hpp"
namespace DataSpec::DNAMP1
{
struct FRME : BigDNA
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
Value<atUint32> version;
Value<atUint32> unk1;
Value<atUint32> modelCount; // Matches MODL widgets
@ -18,12 +19,12 @@ struct FRME : BigDNA
struct Widget : BigDNA
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
FRME* owner;
DNAFourCC type;
struct WidgetHeader : BigDNA
{
DECL_DNA
AT_DECL_DNA
String<-1> name;
String<-1> parent;
Value<bool> useAnimController;
@ -34,12 +35,9 @@ struct FRME : BigDNA
Value<atUint32> modelDrawFlags;
} header;
struct IWidgetInfo : BigDNA
struct IWidgetInfo : BigDNAV
{
Delete _d;
virtual void read(athena::io::IStreamReader&) {}
void write(athena::io::IStreamWriter&) const {}
size_t binarySize(size_t __isz) const { return __isz; }
Delete _dBase;
virtual FourCC fourcc() const=0;
};
@ -54,19 +52,22 @@ struct FRME : BigDNA
struct BWIGInfo : IWidgetInfo
{
Delete _d2;
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::BWIG"; }
FourCC fourcc() const { return FOURCC('BWIG'); }
};
struct HWIGInfo : IWidgetInfo
{
Delete _d2;
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::HWIG"; }
FourCC fourcc() const { return FOURCC('HWIG'); }
};
struct CAMRInfo : IWidgetInfo
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
const char* DNATypeV() const { return "FRME::CAMR"; }
enum class ProjectionType
{
Perspective,
@ -74,7 +75,7 @@ struct FRME : BigDNA
};
Value<ProjectionType> projectionType;
struct IProjection : BigDNA
struct IProjection : BigDNAV
{
Delete _d;
const ProjectionType type;
@ -83,7 +84,8 @@ struct FRME : BigDNA
struct PerspectiveProjection : IProjection
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
PerspectiveProjection() : IProjection(ProjectionType::Perspective) {}
Value<float> fov;
Value<float> aspect;
@ -93,7 +95,8 @@ struct FRME : BigDNA
struct OrthographicProjection : IProjection
{
DECL_DNA
AT_DECL_DNA
AT_DECL_DNAV
OrthographicProjection() : IProjection(ProjectionType::Orthographic) {}
Value<float> left;
Value<float> right;
@ -109,7 +112,8 @@ struct FRME : BigDNA
struct MODLInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::MODL"; }
UniqueID32 model;
enum class BlendMode
{
@ -127,7 +131,8 @@ struct FRME : BigDNA
struct LITEInfo : IWidgetInfo
{
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
const char* DNATypeV() const { return "FRME::LITE"; }
enum class ELightType : atUint32
{
Spot = 0,
@ -152,7 +157,8 @@ struct FRME : BigDNA
struct ENRGInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::ENRG"; }
UniqueID32 texture;
FourCC fourcc() const { return FOURCC('ENRG'); }
@ -160,7 +166,8 @@ struct FRME : BigDNA
struct METRInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::METR"; }
Value<bool> unk1;
Value<bool> noRoundUp;
Value<atUint32> maxCapacity;
@ -171,7 +178,8 @@ struct FRME : BigDNA
struct GRUPInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::GRUP"; }
Value<atInt16> defaultWorker;
Value<bool> unk3;
@ -180,7 +188,8 @@ struct FRME : BigDNA
struct TBGPInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::TBGP"; }
Value<atUint16> elementCount;
Value<atUint16> unk2;
Value<atUint32> unkEnum;
@ -202,7 +211,8 @@ struct FRME : BigDNA
struct SLGPInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::SLGP"; }
Value<float> min;
Value<float> max;
Value<float> cur;
@ -213,7 +223,8 @@ struct FRME : BigDNA
struct PANEInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::PANE"; }
Value<float> xDim;
Value<float> zDim;
Value<atVec3f> scaleCenter;
@ -223,6 +234,7 @@ struct FRME : BigDNA
struct TXPNInfo : IWidgetInfo
{
const char* DNATypeV() const { return "FRME::TXPN"; }
enum class Justification : atUint32
{
Left = 0,
@ -251,7 +263,8 @@ struct FRME : BigDNA
RightMono
};
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
atUint32 version = 0;
TXPNInfo() {}
TXPNInfo(atUint32 version)
@ -277,7 +290,8 @@ struct FRME : BigDNA
struct IMGPInfo : IWidgetInfo
{
DECL_DNA
AT_DECL_DNA
const char* DNATypeV() const { return "FRME::IMGP"; }
UniqueID32 texture;
Value<atUint32> unk1;
Value<atUint32> unk2;

16
DataSpec/DNAMP1/HINT.hpp
View File

@ -6,23 +6,23 @@
namespace DataSpec::DNAMP1
{
struct HINT : BigYAML
struct HINT : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> magic;
Value<atUint32> version;
struct Hint : BigYAML
struct Hint : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
String<-1> name;
Value<float> immediateTime;
Value<float> normalTime;
UniqueID32 stringID;
Value<atUint32> textPageCount;
struct Location : BigYAML
struct Location : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
UniqueID32 worldAssetID;
UniqueID32 areaAssetID;
Value<atUint32> areaID;
@ -41,7 +41,7 @@ struct HINT : BigYAML
HINT hint;
hint.read(rs);
athena::io::FileWriter writer(outPath.getAbsolutePath());
hint.toYAMLStream(writer);
athena::io::ToYAMLStream(hint, writer);
return true;
}
@ -49,7 +49,7 @@ struct HINT : BigYAML
{
HINT hint;
athena::io::FileReader reader(inPath.getAbsolutePath());
hint.fromYAMLStream(reader);
athena::io::FromYAMLStream(hint, reader);
athena::io::FileWriter ws(outPath.getAbsolutePath());
hint.write(ws);
return true;

8
DataSpec/DNAMP1/MLVL.cpp
View File

@ -55,7 +55,7 @@ bool MLVL::Extract(const SpecBase& dataSpec, PAKEntryReadStream& rs, const hecl:
}
athena::io::FileWriter writer(outPath.getWithExtension(_S(".yaml"), true).getAbsolutePath());
mlvl.toYAMLStream(writer, static_cast<YAMLWriteMemberFn>(&MLVL::writeMeta));
athena::io::ToYAMLStream(mlvl, writer, &MLVL::writeMeta);
hecl::blender::Connection& conn = btok.getBlenderConnection();
return DNAMLVL::ReadMLVLToBlender(conn, mlvl, outPath, pakRouter, entry, force, fileChanged);
}
@ -65,7 +65,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
{
MLVL mlvl = {};
athena::io::FileReader reader(inPath.getWithExtension(_S(".yaml"), true).getAbsolutePath());
mlvl.fromYAMLStream(reader, static_cast<YAMLReadMemberFn>(&MLVL::readMeta));
athena::io::FromYAMLStream(mlvl, reader, &MLVL::readMeta);
mlvl.magic = 0xDEAFBABE;
mlvl.version = 0x11;
@ -129,7 +129,7 @@ bool MLVL::Cook(const hecl::ProjectPath& outPath, const hecl::ProjectPath& inPat
athena::io::FileReader freader(objectsPath.getAbsolutePath());
if (!freader.isOpen())
continue;
if (!BigYAML::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
if (!athena::io::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
continue;
athena::io::YAMLDocReader reader;
@ -432,7 +432,7 @@ bool MLVL::CookSAVW(const hecl::ProjectPath& outPath,
athena::io::FileReader freader(objectsPath.getAbsolutePath());
if (!freader.isOpen())
continue;
if (!BigYAML::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
if (!athena::io::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
continue;
athena::io::YAMLDocReader reader;

32
DataSpec/DNAMP1/MLVL.hpp
View File

@ -8,9 +8,9 @@
namespace DataSpec::DNAMP1
{
struct MLVL : BigYAML
struct MLVL : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> magic;
Value<atUint32> version;
UniqueID32 worldNameId;
@ -18,9 +18,9 @@ struct MLVL : BigYAML
UniqueID32 worldSkyboxId;
Value<atUint32> memRelayLinkCount;
struct MemRelayLink : BigYAML
struct MemRelayLink : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> memRelayId;
Value<atUint32> targetId;
Value<atUint16> msg;
@ -30,9 +30,9 @@ struct MLVL : BigYAML
Value<atUint32> areaCount;
Value<atUint32> unknown1;
struct Area : BigYAML
struct Area : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
UniqueID32 areaNameId;
Value<atVec4f> transformMtx[3];
Value<atVec3f> aabb[2];
@ -44,9 +44,9 @@ struct MLVL : BigYAML
Value<atUint32> padding;
Value<atUint32> depCount;
struct Dependency : BigYAML
struct Dependency : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
UniqueID32 id;
DNAFourCC type;
@ -60,13 +60,13 @@ struct MLVL : BigYAML
Vector<atUint32, DNA_COUNT(depLayerCount)> depLayers;
Value<atUint32> dockCount;
struct Dock : BigYAML
struct Dock : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> endpointCount;
struct Endpoint : BigYAML
struct Endpoint : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> areaIdx;
Value<atUint32> dockIdx;
};
@ -96,9 +96,9 @@ struct MLVL : BigYAML
Value<atUint32> unknown3;
Value<atUint32> audioGroupCount;
struct AudioGroup : BigYAML
struct AudioGroup : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> groupId;
UniqueID32 agscId;
};
@ -106,9 +106,9 @@ struct MLVL : BigYAML
String<-1> unkString;
Value<atUint32> layerFlagCount;
struct LayerFlags : BigYAML
struct LayerFlags : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> layerCount;
Value<atUint64> flags;
};

18
DataSpec/DNAMP1/MREA.cpp
View File

@ -459,7 +459,9 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
/* Header section */
{
secs.emplace_back(head.binarySize(0), 0);
size_t secSz = 0;
head.binarySize(secSz);
secs.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secs.back().data(), secs.back().size());
head.write(w);
int i = w.position();
@ -530,7 +532,7 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
athena::io::FileReader freader(layer.getAbsolutePath());
if (!freader.isOpen())
continue;
if (!BigYAML::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
if (!athena::io::ValidateFromYAMLStream<DNAMP1::SCLY::ScriptLayer>(freader))
continue;
athena::io::YAMLDocReader reader;
@ -539,11 +541,15 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
sclyData.layers.emplace_back();
sclyData.layers.back().read(reader);
sclyData.layerSizes.push_back(sclyData.layers.back().binarySize(0));
size_t layerSize = 0;
sclyData.layers.back().binarySize(layerSize);
sclyData.layerSizes.push_back(layerSize);
}
sclyData.layerCount = sclyData.layers.size();
secs.emplace_back(sclyData.binarySize(0), 0);
size_t secSz = 0;
sclyData.binarySize(secSz);
secs.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secs.back().data(), secs.back().size());
sclyData.write(w);
}
@ -577,7 +583,9 @@ bool MREA::PCCook(const hecl::ProjectPath& outPath,
conn.saveBlend();
#endif
secs.emplace_back(collision.binarySize(0), 0);
size_t secSz = 0;
collision.binarySize(secSz);
secs.emplace_back(secSz, 0);
athena::io::MemoryWriter w(secs.back().data(), secs.back().size());
collision.write(w);
}

8
DataSpec/DNAMP1/MREA.hpp
View File

@ -12,7 +12,7 @@ struct MREA
{
struct Header : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> magic;
Value<atUint32> version;
Value<atVec4f> localToWorldMtx[3];
@ -31,10 +31,10 @@ struct MREA
struct MeshHeader : BigDNA
{
DECL_DNA
AT_DECL_DNA
struct VisorFlags : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> flags;
enum class ThermalLevel
{
@ -70,7 +70,7 @@ struct MREA
struct BabeDeadLight : BigDNA
{
DECL_DNA
AT_DECL_DNA
enum class LightType : atUint32
{
LocalAmbient,

4
DataSpec/DNAMP1/MazeSeeds.hpp
View File

@ -7,9 +7,9 @@
namespace DataSpec::DNAMP1
{
struct MazeSeeds : BigYAML
struct MazeSeeds : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> seeds[300];
};
}

17
DataSpec/DNAMP1/PAK.cpp
View File

@ -6,7 +6,8 @@
namespace DataSpec::DNAMP1
{
void PAK::read(athena::io::IStreamReader& reader)
template <>
void PAK::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
atUint32 version = reader.readUint32Big();
if (version != 0x00030005)
@ -48,7 +49,8 @@ void PAK::read(athena::io::IStreamReader& reader)
m_nameMap[entry.name] = entry.id;
}
void PAK::write(athena::io::IStreamWriter& writer) const
template <>
void PAK::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
writer.writeUint32Big(0x00030005);
writer.writeUint32Big(0);
@ -71,16 +73,15 @@ void PAK::write(athena::io::IStreamWriter& writer) const
}
}
size_t PAK::binarySize(size_t __isz) const
template <>
void PAK::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
__isz += 12;
s += 12;
for (const NameEntry& entry : m_nameEntries)
__isz += 12 + entry.name.size();
s += 12 + entry.name.size();
__isz += m_entries.size() * 20 + 4;
return __isz;
s += m_entries.size() * 20 + 4;
}
std::unique_ptr<atUint8[]>

6
DataSpec/DNAMP1/PAK.hpp
View File

@ -14,11 +14,11 @@ struct PAK : BigDNA
bool m_useLzo;
bool m_noShare;
PAK(bool useLzo, bool noShare) : m_useLzo(useLzo), m_noShare(noShare) {}
DECL_EXPLICIT_DNA
AT_DECL_EXPLICIT_DNA
struct NameEntry : BigDNA
{
DECL_DNA
AT_DECL_DNA
DNAFourCC type;
UniqueID32 id;
Value<atUint32> nameLen;
@ -27,7 +27,7 @@ struct PAK : BigDNA
struct Entry : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> compressed;
DNAFourCC type;
UniqueID32 id;

10
DataSpec/DNAMP1/PATH.hpp
View File

@ -7,12 +7,12 @@ namespace DataSpec
{
struct PATH : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> version;
struct Node : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atVec3f> position;
Value<atVec3f> normal;
};
@ -21,7 +21,7 @@ struct PATH : BigDNA
struct Link : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> nodeIdx;
Value<atUint32> regionIdx;
Value<float> width2d;
@ -32,7 +32,7 @@ struct PATH : BigDNA
struct Region : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> nodeCount;
Value<atUint32> nodeStart;
Value<atUint32> linkCount;
@ -57,7 +57,7 @@ struct PATH : BigDNA
struct OctreeNode : BigDNA
{
DECL_DNA
AT_DECL_DNA
Value<atUint32> isLeaf;
Value<atVec3f> points[3];
Value<atUint32> children[8];

8
DataSpec/DNAMP1/SAVW.hpp
View File

@ -6,9 +6,9 @@
namespace DataSpec::DNAMP1
{
struct Scan : BigYAML
struct Scan : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
UniqueID32 scanId;
Value<SAVWCommon::EScanCategory> category;
@ -16,9 +16,9 @@ struct Scan : BigYAML
Scan(const UniqueID32& id) : scanId(id), category(SAVWCommon::EScanCategory::None) {}
};
struct SAVW : BigYAML
struct SAVW : BigDNA
{
DECL_YAML
AT_DECL_DNA_YAML
SAVWCommon::Header header;
Value<atUint32> skippableCutsceneCount;
Vector<atUint32, DNA_COUNT(skippableCutsceneCount)> skippableCutscenes;

81
DataSpec/DNAMP1/SCAN.cpp Normal file
View File

@ -0,0 +1,81 @@
#include "SCAN.hpp"
namespace DataSpec::DNAMP1
{
static const std::vector<std::string> PaneNames =
{
"imagepane_pane0", "imagepane_pane1", "imagepane_pane2", "imagepane_pane3", "imagepane_pane01",
"imagepane_pane12", "imagepane_pane23", "imagepane_pane012", "imagepane_pane123", "imagepane_pane0123",
"imagepane_pane4", "imagepane_pane5", "imagepane_pane6", "imagepane_pane7", "imagepane_pane45",
"imagepane_pane56", "imagepane_pane67", "imagepane_pane456", "imagepane_pane567", "imagepane_pane4567"
};
template <>
void SCAN::Texture::Enumerate<BigDNA::Read>(typename Read::StreamT& r)
{
texture.read(r);
appearanceRange = r.readFloatBig();
position = Position(r.readUint32Big());
width = r.readUint32Big();
height = r.readUint32Big();
interval = r.readFloatBig();
fadeDuration = r.readFloatBig();
}
template <>
void SCAN::Texture::Enumerate<BigDNA::Write>(typename Write::StreamT& w)
{
texture.write(w);
w.writeFloatBig(appearanceRange);
w.writeUint32Big(atUint32(position));
w.writeUint32Big(width);
w.writeUint32Big(height);
w.writeFloatBig(interval);
w.writeFloatBig(fadeDuration);
}
template <>
void SCAN::Texture::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r)
{
r.enumerate("texture", texture);
appearanceRange = r.readFloat("appearanceRange");
std::string tmp = r.readString("position");
auto idx = std::find(PaneNames.begin(), PaneNames.end(), tmp);
if (idx != PaneNames.end())
position = Position(idx - PaneNames.begin());
else
position = Position::Invalid;
width = r.readUint32("width");
height = r.readUint32("height");
interval = r.readFloat("interval");
fadeDuration = r.readFloat("fadeDuration");
}
template <>
void SCAN::Texture::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w)
{
w.enumerate("texture", texture);
w.writeFloat("appearanceRange", appearanceRange);
if (position != Position::Invalid)
w.writeString("position", PaneNames.at(atUint32(position)));
else
w.writeString("position", "undefined");
w.writeUint32("width", width);
w.writeUint32("height", height);
w.writeFloat("interval", interval);
w.writeFloat("fadeDuration", fadeDuration);
}
const char* SCAN::Texture::DNAType() { return "urde::DNAMP1::SCAN::Texture"; }
template <>
void SCAN::Texture::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s)
{
texture.binarySize(s);
s += 24;
}
}

111
DataSpec/DNAMP1/SCAN.hpp
View File

@ -7,17 +7,9 @@
namespace DataSpec::DNAMP1
{
static const std::vector<std::string> PaneNames =
struct SCAN : BigDNA
{
"imagepane_pane0", "imagepane_pane1", "imagepane_pane2", "imagepane_pane3", "imagepane_pane01",
"imagepane_pane12", "imagepane_pane23", "imagepane_pane012", "imagepane_pane123", "imagepane_pane0123",
"imagepane_pane4", "imagepane_pane5", "imagepane_pane6", "imagepane_pane7", "imagepane_pane45",
"imagepane_pane56", "imagepane_pane67", "imagepane_pane456", "imagepane_pane567", "imagepane_pane4567"
};
struct SCAN : BigYAML
{
DECL_YAML
AT_DECL_DNA_YAML
Value<atUint32> version;
Value<atUint32> magic;
UniqueID32 frame;
@ -40,9 +32,9 @@ struct SCAN : BigYAML
Value<bool> isImportant;
struct Texture : BigYAML
struct Texture : BigDNA
{
Delete __delete;
AT_DECL_EXPLICIT_DNA_YAML
UniqueID32 texture;
Value<float> appearanceRange;
enum class Position : atInt32
@ -56,96 +48,6 @@ struct SCAN : BigYAML
Value<atUint32> height; // height of animation cell
Value<float> interval; // 0.0 - 1.0
Value<float> fadeDuration; // 0.0 - 1.0
void read(athena::io::IStreamReader& __dna_reader)
{
/* texture */
texture.read(__dna_reader);
/* appearanceRange */
appearanceRange = __dna_reader.readFloatBig();
/* position */
position = Position(__dna_reader.readUint32Big());
/* width */
width = __dna_reader.readUint32Big();
/* height */
height = __dna_reader.readUint32Big();
/* interval */
interval = __dna_reader.readFloatBig();
/* fadeDuration */
fadeDuration = __dna_reader.readFloatBig();
}
void write(athena::io::IStreamWriter& __dna_writer) const
{
/* texture */
texture.write(__dna_writer);
/* appearanceRange */
__dna_writer.writeFloatBig(appearanceRange);
/* position */
__dna_writer.writeUint32Big(atUint32(position));
/* width */
__dna_writer.writeUint32Big(width);
/* height */
__dna_writer.writeUint32Big(height);
/* interval */
__dna_writer.writeFloatBig(interval);
/* fadeDuration */
__dna_writer.writeFloatBig(fadeDuration);
}
void read(athena::io::YAMLDocReader& __dna_docin)
{
/* texture */
__dna_docin.enumerate("texture", texture);
/* appearanceRange */
appearanceRange = __dna_docin.readFloat("appearanceRange");
/* position */
std::string tmp = __dna_docin.readString("position");
auto idx = std::find(PaneNames.begin(), PaneNames.end(), tmp);
if (idx != PaneNames.end())
position = Position(idx - PaneNames.begin());
else
position = Position::Invalid;
/* width */
width = __dna_docin.readUint32("width");
/* height */
height = __dna_docin.readUint32("height");
/* interval */
interval = __dna_docin.readFloat("interval");
/* fadeDuration */
fadeDuration = __dna_docin.readFloat("fadeDuration");
}
void write(athena::io::YAMLDocWriter& __dna_docout) const
{
/* texture */
__dna_docout.enumerate("texture", texture);
/* appearanceRange */
__dna_docout.writeFloat("appearanceRange", appearanceRange);
/* position */
if (position != Position::Invalid)
__dna_docout.writeString("position", PaneNames.at(atUint32(position)));
else
__dna_docout.writeString("position", "undefined");
/* width */
__dna_docout.writeUint32("width", width);
/* height */
__dna_docout.writeUint32("height", height);
/* interval */
__dna_docout.writeFloat("interval", interval);
/* fadeDuration */
__dna_docout.writeFloat("fadeDuration", fadeDuration);
}
const char* DNAType() { return "urde::DNAMP1::SCAN::Texture"; }
size_t binarySize(size_t __isz) const
{
__isz = texture.binarySize(__isz);
return __isz + 24;
}
};
Texture textures[4];
@ -155,7 +57,7 @@ struct SCAN : BigYAML
SCAN scan;
scan.read(rs);
athena::io::FileWriter writer(outPath.getAbsolutePath());
scan.toYAMLStream(writer);
athena::io::ToYAMLStream(scan, writer);
return true;
}
@ -172,7 +74,7 @@ struct SCAN : BigYAML
athena::io::FileReader reader(inPath.getAbsolutePath());
if (reader.hasError())
return Category::None;
if (!scan.fromYAMLStream(reader))
if (!athena::io::FromYAMLStream(scan, reader))
return Category::None;
return scan.category;
}
@ -208,6 +110,7 @@ struct SCAN : BigYAML
g_curSpec->flattenDependencies(textures[i].texture, pathsOut);
}
};
}
#endif

41
DataSpec/DNAMP1/SCLY.cpp
View File

@ -4,7 +4,8 @@
namespace DataSpec::DNAMP1
{
void SCLY::read(athena::io::IStreamReader& rs)
template <>
void SCLY::Enumerate<BigDNA::Read>(athena::io::IStreamReader& rs)
{
fourCC = rs.readUint32Little();
version = rs.readUint32Big();
@ -18,7 +19,8 @@ void SCLY::read(athena::io::IStreamReader& rs)
});
}
void SCLY::write(athena::io::IStreamWriter& ws) const
template <>
void SCLY::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& ws)
{
ws.writeUint32Big(fourCC);
ws.writeUint32Big(version);
@ -27,11 +29,13 @@ void SCLY::write(athena::io::IStreamWriter& ws) const
ws.enumerate(layers);
}
size_t SCLY::binarySize(size_t __isz) const
template <>
void SCLY::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 12;
__isz += layerSizes.size() * 4;
return __EnumerateSize(__isz, layers);
for (const ScriptLayer& layer : layers)
layer.binarySize(__isz);
}
void SCLY::exportToLayerDirectories(const PAK::Entry& entry, PAKRouter<PAKBridge>& pakRouter, bool force) const
@ -53,7 +57,7 @@ void SCLY::exportToLayerDirectories(const PAK::Entry& entry, PAKRouter<PAKBridge
if (force || yamlFile.isNone())
{
athena::io::FileWriter writer(yamlFile.getAbsolutePath());
layers[i].toYAMLStream(writer);
athena::io::ToYAMLStream(layers[i], writer);
}
}
}
@ -84,7 +88,8 @@ void SCLY::ScriptLayer::nameIDs(PAKRouter<PAKBridge>& pakRouter) const
obj->nameIDs(pakRouter);
}
void SCLY::read(athena::io::YAMLDocReader& docin)
template <>
void SCLY::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& docin)
{
fourCC = docin.readUint32("fourCC");
version = docin.readUint32("version");
@ -92,7 +97,8 @@ void SCLY::read(athena::io::YAMLDocReader& docin)
docin.enumerate("layers", layers);
}
void SCLY::write(athena::io::YAMLDocWriter& docout) const
template <>
void SCLY::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& docout)
{
docout.writeUint32("fourCC", fourCC);
docout.writeUint32("version", version);
@ -105,7 +111,8 @@ const char* SCLY::DNAType()
return "urde::DNAMP1::SCLY";
}
void SCLY::ScriptLayer::read(athena::io::IStreamReader& rs)
template <>
void SCLY::ScriptLayer::Enumerate<BigDNA::Read>(athena::io::IStreamReader& rs)
{
unknown = rs.readUByte();
objectCount = rs.readUint32Big();
@ -136,7 +143,8 @@ void SCLY::ScriptLayer::read(athena::io::IStreamReader& rs)
}
}
void SCLY::ScriptLayer::read(athena::io::YAMLDocReader& rs)
template <>
void SCLY::ScriptLayer::Enumerate<BigDNA::ReadYaml>(athena::io::YAMLDocReader& rs)
{
unknown = rs.readUByte("unknown");
size_t objCount;
@ -169,14 +177,16 @@ void SCLY::ScriptLayer::read(athena::io::YAMLDocReader& rs)
objectCount = 0;
}
void SCLY::ScriptLayer::write(athena::io::IStreamWriter& ws) const
template <>
void SCLY::ScriptLayer::Enumerate<BigDNA::Write>(athena::io::IStreamWriter& ws)
{
ws.writeUByte(unknown);
ws.writeUint32Big(objectCount);
for (const std::unique_ptr<IScriptObject>& obj : objects)
{
ws.writeByte(obj->type);
atUint32 expLen = obj->binarySize(0);
size_t expLen = 0;
obj->binarySize(expLen);
ws.writeUint32Big(expLen);
auto start = ws.position();
obj->write(ws);
@ -186,18 +196,19 @@ void SCLY::ScriptLayer::write(athena::io::IStreamWriter& ws) const
}
}
size_t SCLY::ScriptLayer::binarySize(size_t __isz) const
template <>
void SCLY::ScriptLayer::Enumerate<BigDNA::BinarySize>(size_t& __isz)
{
__isz += 5;
for (const std::unique_ptr<IScriptObject>& obj : objects)
{
__isz += 5;
__isz = obj->binarySize(__isz);
obj->binarySize(__isz);
}
return __isz;
}
void SCLY::ScriptLayer::write(athena::io::YAMLDocWriter& ws) const
template <>
void SCLY::ScriptLayer::Enumerate<BigDNA::WriteYaml>(athena::io::YAMLDocWriter& ws)
{
ws.writeUByte("unknown", unknown);
if (auto v = ws.enterSubVector("objects"))

17
DataSpec/DNAMP1/SCLY.hpp
View File

@ -7,36 +7,27 @@
namespace DataSpec::DNAMP1
{
struct SCLY : BigYAML
struct SCLY : BigDNA
{
DECL_EXPLICIT_YAML
Delete _d;
AT_DECL_EXPLICIT_DNA_YAML
Value<FourCC> fourCC;
Value<atUint32> version;
Value<atUint32> layerCount;
Vector<atUint32, DNA_COUNT(layerCount)> layerSizes;
struct ScriptLayer : BigYAML
struct ScriptLayer : BigDNA
{
DECL_EXPLICIT_YAML
Delete _d;
AT_DECL_EXPLICIT_DNA_YAML
Value<atUint8> unknown;
Value<atUint32> objectCount;
Vector<std::unique_ptr<IScriptObject>, DNA_COUNT(objectCount)> objects;
void read(athena::io::IStreamReader &rs);
void write(athena::io::IStreamWriter &ws) const;
size_t binarySize(size_t __isz) const;
void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const;
void nameIDs(PAKRouter<PAKBridge>& pakRouter) const;
};
Vector<ScriptLayer, DNA_COUNT(layerCount)> layers;
void read(athena::io::IStreamReader &rs);
void write(athena::io::IStreamWriter &ws) const;
size_t binarySize(size_t __isz) const;
void exportToLayerDirectories(const PAK::Entry &, PAKRouter<PAKBridge>&, bool) const;
void addCMDLRigPairs(PAKRouter<PAKBridge>& pakRouter,
std::unordered_map<UniqueID32, std::pair<UniqueID32, UniqueID32>>& addTo) const;

27
DataSpec/DNAMP1/STRG.cpp
View File

@ -393,7 +393,8 @@ void STRG::_read(athena::io::IStreamReader& reader)
langMap.emplace(item.first, &item.second);
}
void STRG::read(athena::io::IStreamReader& reader)
template <>
void STRG::Enumerate<BigDNA::Read>(typename Read::StreamT& reader)
{
atUint32 magic = reader.readUint32Big();
if (magic != 0x87654321)
@ -406,7 +407,8 @@ void STRG::read(athena::io::IStreamReader& reader)
_read(reader);
}
void STRG::write(athena::io::IStreamWriter& writer) const
template <>
void STRG::Enumerate<BigDNA::Write>(typename Write::StreamT& writer)
{
writer.writeUint32Big(0x87654321);
writer.writeUint32Big(0);
@ -475,29 +477,29 @@ void STRG::write(athena::io::IStreamWriter& writer) const
}
}
size_t STRG::binarySize(size_t __isz) const
template <>
void STRG::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& _s)
{
__isz += 16;
__isz += langs.size() * 12;
_s += 16;
_s += langs.size() * 12;
size_t strCount = STRG::count();
__isz += langs.size() * strCount * 4;
_s += langs.size() * strCount * 4;
for (const std::pair<FourCC, std::vector<std::u16string>>& lang : langs)
{
atUint32 langStrCount = lang.second.size();
for (atUint32 s = 0; s < strCount; ++s)
{
if (s < langStrCount)
__isz += (CookString(lang.second[s]).size() + 1) * 2;
_s += (CookString(lang.second[s]).size() + 1) * 2;
else
__isz += 1;
_s += 1;
}
}
return __isz;
}
void STRG::read(athena::io::YAMLDocReader& reader)
template <>
void STRG::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& reader)
{
const athena::io::YAMLNode* root = reader.getRootNode();
@ -557,7 +559,8 @@ void STRG::read(athena::io::YAMLDocReader& reader)
langMap.emplace(item.first, &item.second);
}
void STRG::write(athena::io::YAMLDocWriter& writer) const
template <>
void STRG::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& writer)
{
for (const auto& lang : langs)
{

8
DataSpec/DNAMP1/STRG.hpp
View File

@ -11,8 +11,8 @@ namespace DataSpec::DNAMP1
struct STRG : ISTRG
{
DECL_YAML
Delete expl;
AT_DECL_EXPLICIT_DNA_YAML
AT_DECL_DNAV
void _read(athena::io::IStreamReader& reader);
std::vector<std::pair<FourCC, std::vector<std::u16string>>> langs;
std::unordered_map<FourCC, std::vector<std::u16string>*> langMap;
@ -61,7 +61,7 @@ struct STRG : ISTRG
STRG strg;
strg.read(rs);
athena::io::TransactionalFileWriter writer(outPath.getAbsolutePath());
strg.toYAMLStream(writer);
athena::io::ToYAMLStream(strg, writer);
return true;
}
@ -69,7 +69,7 @@ struct STRG : ISTRG
{
STRG strg;
athena::io::FileReader reader(inPath.getAbsolutePath());
strg.fromYAMLStream(reader);
athena::io::FromYAMLStream(strg, reader);
athena::io::TransactionalFileWriter ws(outPath.getAbsolutePath());
strg.write(ws);
return true;

3
DataSpec/DNAMP1/ScriptObjects/AIJumpPoint.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct AIJumpPoint : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/AIKeyframe.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
struct AIKeyframe : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atUint32> unknown1;
Value<bool> unknown2;

3
DataSpec/DNAMP1/ScriptObjects/Actor.hpp
View File

@ -8,7 +8,8 @@ namespace DataSpec::DNAMP1
{
struct Actor : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name SO_NAME_SPECPROP();
Value<atVec3f> location SO_LOCATION_SPECPROP();
Value<atVec3f> orientation SO_ORIENTATION_SPECPROP();

3
DataSpec/DNAMP1/ScriptObjects/ActorContraption.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ActorContraption : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/ActorKeyframe.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ActorKeyframe : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atUint32> animationId;
Value<bool> unknown1;

3
DataSpec/DNAMP1/ScriptObjects/ActorRotate.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ActorRotate : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> rotationOffset;
Value<float> timeScale;

3
DataSpec/DNAMP1/ScriptObjects/AmbientAI.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct AmbientAI : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/AreaAttributes.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct AreaAttributes : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
enum class EWeatherType : atUint32
{
None,

3
DataSpec/DNAMP1/ScriptObjects/AtomicAlpha.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct AtomicAlpha : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/AtomicBeta.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct AtomicBeta : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/Babygoth.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct Babygoth : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/BallTrigger.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct BallTrigger : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> volume;

3
DataSpec/DNAMP1/ScriptObjects/Beetle.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct Beetle : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atUint32> unknown1;
Value<atVec3f> location;

3
DataSpec/DNAMP1/ScriptObjects/BloodFlower.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct BloodFlower : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/Burrower.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct Burrower : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

6
DataSpec/DNAMP1/ScriptObjects/CMakeLists.txt
View File

@ -134,7 +134,11 @@ set(ScriptObjectsMP1_SOURCES
Parameters.cpp
Actor.cpp
Platform.cpp
DoorArea.cpp)
DoorArea.cpp
Oculus.cpp
Ridley.cpp
Water.cpp
WorldTeleporter.cpp)
dataspec_add_list(DNAMP1/ScriptObjects ScriptObjectsMP1_SOURCES)
list(APPEND ScriptObjectsMP1_SOURCES ${liblist})

3
DataSpec/DNAMP1/ScriptObjects/Camera.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct Camera : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/CameraBlurKeyframe.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraBlurKeyframe : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<bool> active;
Value<atUint32> btype;

3
DataSpec/DNAMP1/ScriptObjects/CameraFilterKeyframe.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraFilterKeyframe : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<bool> active;
Value<atUint32> ftype;

15
DataSpec/DNAMP1/ScriptObjects/CameraHint.hpp
View File

@ -9,16 +9,17 @@ namespace DataSpec::DNAMP1
{
struct CameraHint : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;
Value<bool> active;
Value<atUint32> priority;
Value<atUint32> behaviour;
struct CameraHintParameters : BigYAML
struct CameraHintParameters : BigDNA
{
DECL_YAML
AT_DECL_DNA
Value<atUint32> propertyCount;
Value<bool> calculateCamPos; // 0x1
Value<bool> chaseAllowed; // 0x2
@ -44,15 +45,15 @@ struct CameraHint : IScriptObject
Value<bool> unknown22; // 0x200000
} cameraHintParameters;
struct BoolFloat : BigYAML
struct BoolFloat : BigDNA
{
DECL_YAML
AT_DECL_DNA
Value<bool> active;
Value<float> value;
} minDist, maxDist, backwardsDist; // 0x400000, 0x800000, 0x1000000
struct BoolVec3f : BigYAML
struct BoolVec3f : BigDNA
{
DECL_YAML
AT_DECL_DNA
Value<bool> active;
Value<atVec3f> value;
} lookAtOffset, chaseLookAtOffset; // 0x2000000, 0x4000000

3
DataSpec/DNAMP1/ScriptObjects/CameraHintTrigger.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraHintTrigger : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/CameraPitchVolume.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraPitchVolume : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/CameraShaker.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraShaker : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<float> xMag;
Value<float> xB;

3
DataSpec/DNAMP1/ScriptObjects/CameraWaypoint.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CameraWaypoint : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/ChozoGhost.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ChozoGhost : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

3
DataSpec/DNAMP1/ScriptObjects/ColorModulate.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ColorModulate : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec4f> unknown1;
Value<atVec4f> unknown2;

3
DataSpec/DNAMP1/ScriptObjects/ControllerAction.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct ControllerAction : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<bool> active;
Value<atUint32> command;

3
DataSpec/DNAMP1/ScriptObjects/Counter.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct Counter : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atUint32> startValue; // needs verification
Value<atUint32> maxValue;

3
DataSpec/DNAMP1/ScriptObjects/CoverPoint.hpp
View File

@ -9,7 +9,8 @@ namespace DataSpec::DNAMP1
{
struct CoverPoint : IScriptObject
{
DECL_YAML
AT_DECL_DNA_YAML
AT_DECL_DNAV
String<-1> name;
Value<atVec3f> location;
Value<atVec3f> orientation;

Some files were not shown because too many files have changed in this diff Show More