metaforce/DataSpec/DNACommon/ParticleCommon.cpp

1520 lines
39 KiB
C++
Raw Normal View History

2016-02-02 04:29:58 +00:00
#include "ParticleCommon.hpp"
2018-12-08 05:30:43 +00:00
namespace DataSpec::DNAParticle {
2016-03-04 23:04:53 +00:00
logvisor::Module LogModule("urde::DNAParticle");
2016-02-02 04:29:58 +00:00
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void REConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
val = r.readFloat(nullptr);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void REConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
w.writeFloat(nullptr, val);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void REConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void REConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
val = r.readFloatBig();
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void REConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
w.writeFloatBig(val);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void IEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
val = r.readUint32(nullptr);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void IEConstant::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
w.writeUint32(nullptr, val);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void IEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void IEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
val = r.readUint32Big();
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void IEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
w.writeUint32Big(val);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void VEConstant::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
size_t elemCount;
if (auto v = r.enterSubVector(nullptr, elemCount)) {
for (size_t i = 0; i < 3 && i < elemCount; ++i) {
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord(nullptr))
comps[i].read(r);
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
}
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void VEConstant::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
comps[0].binarySize(s);
comps[1].binarySize(s);
comps[2].binarySize(s);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void VEConstant::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
comps[0].read(r);
comps[1].read(r);
comps[2].read(r);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void VEConstant::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
comps[0].write(w);
comps[1].write(w);
comps[2].write(w);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('LFTW'):
m_elem.reset(new struct RELifetimeTween);
break;
case SBIG('CNST'):
m_elem.reset(new struct REConstant);
break;
case SBIG('CHAN'):
m_elem.reset(new struct RETimeChain);
break;
case SBIG('ADD_'):
m_elem.reset(new struct REAdd);
break;
case SBIG('CLMP'):
m_elem.reset(new struct REClamp);
break;
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct REKeyframeEmitter);
break;
case SBIG('IRND'):
m_elem.reset(new struct REInitialRandom);
break;
case SBIG('RAND'):
m_elem.reset(new struct RERandom);
break;
case SBIG('MULT'):
m_elem.reset(new struct REMultiply);
break;
case SBIG('PULS'):
m_elem.reset(new struct REPulse);
break;
case SBIG('SCAL'):
m_elem.reset(new struct RETimeScale);
break;
case SBIG('RLPT'):
m_elem.reset(new struct RELifetimePercent);
break;
case SBIG('SINE'):
m_elem.reset(new struct RESineWave);
break;
case SBIG('ISWT'):
m_elem.reset(new struct REInitialSwitch);
break;
case SBIG('CLTN'):
m_elem.reset(new struct RECompareLessThan);
break;
case SBIG('CEQL'):
m_elem.reset(new struct RECompareEquals);
break;
case SBIG('PAP1'):
m_elem.reset(new struct REParticleAdvanceParam1);
break;
case SBIG('PAP2'):
m_elem.reset(new struct REParticleAdvanceParam2);
break;
case SBIG('PAP3'):
m_elem.reset(new struct REParticleAdvanceParam3);
break;
case SBIG('PAP4'):
m_elem.reset(new struct REParticleAdvanceParam4);
break;
case SBIG('PAP5'):
m_elem.reset(new struct REParticleAdvanceParam5);
break;
case SBIG('PAP6'):
m_elem.reset(new struct REParticleAdvanceParam6);
break;
case SBIG('PAP7'):
m_elem.reset(new struct REParticleAdvanceParam7);
break;
case SBIG('PAP8'):
m_elem.reset(new struct REParticleAdvanceParam8);
break;
case SBIG('PSLL'):
m_elem.reset(new struct REParticleSizeOrLineLength);
break;
case SBIG('PRLW'):
m_elem.reset(new struct REParticleRotationOrLineWidth);
break;
case SBIG('SUB_'):
m_elem.reset(new struct RESubtract);
break;
case SBIG('VMAG'):
m_elem.reset(new struct REVectorMagnitude);
break;
case SBIG('VXTR'):
m_elem.reset(new struct REVectorXToReal);
break;
case SBIG('VYTR'):
m_elem.reset(new struct REVectorYToReal);
break;
case SBIG('VZTR'):
m_elem.reset(new struct REVectorZToReal);
break;
case SBIG('CEXT'):
m_elem.reset(new struct RECEXT);
break;
case SBIG('ITRL'):
m_elem.reset(new struct REIntTimesReal);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
2016-02-02 04:29:58 +00:00
m_elem->read(r);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void RealElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <>
void RealElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
}
template <>
void RealElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('LFTW'):
m_elem.reset(new struct RELifetimeTween);
break;
case SBIG('CNST'):
m_elem.reset(new struct REConstant);
break;
case SBIG('CHAN'):
m_elem.reset(new struct RETimeChain);
break;
case SBIG('ADD_'):
m_elem.reset(new struct REAdd);
break;
case SBIG('CLMP'):
m_elem.reset(new struct REClamp);
break;
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct REKeyframeEmitter);
break;
case SBIG('IRND'):
m_elem.reset(new struct REInitialRandom);
break;
case SBIG('RAND'):
m_elem.reset(new struct RERandom);
break;
case SBIG('MULT'):
m_elem.reset(new struct REMultiply);
break;
case SBIG('PULS'):
m_elem.reset(new struct REPulse);
break;
case SBIG('SCAL'):
m_elem.reset(new struct RETimeScale);
break;
case SBIG('RLPT'):
m_elem.reset(new struct RELifetimePercent);
break;
case SBIG('SINE'):
m_elem.reset(new struct RESineWave);
break;
case SBIG('ISWT'):
m_elem.reset(new struct REInitialSwitch);
break;
case SBIG('CLTN'):
m_elem.reset(new struct RECompareLessThan);
break;
case SBIG('CEQL'):
m_elem.reset(new struct RECompareEquals);
break;
case SBIG('PAP1'):
m_elem.reset(new struct REParticleAdvanceParam1);
break;
case SBIG('PAP2'):
m_elem.reset(new struct REParticleAdvanceParam2);
break;
case SBIG('PAP3'):
m_elem.reset(new struct REParticleAdvanceParam3);
break;
case SBIG('PAP4'):
m_elem.reset(new struct REParticleAdvanceParam4);
break;
case SBIG('PAP5'):
m_elem.reset(new struct REParticleAdvanceParam5);
break;
case SBIG('PAP6'):
m_elem.reset(new struct REParticleAdvanceParam6);
break;
case SBIG('PAP7'):
m_elem.reset(new struct REParticleAdvanceParam7);
break;
case SBIG('PAP8'):
m_elem.reset(new struct REParticleAdvanceParam8);
break;
case SBIG('PSLL'):
m_elem.reset(new struct REParticleSizeOrLineLength);
break;
case SBIG('PRLW'):
m_elem.reset(new struct REParticleRotationOrLineWidth);
break;
case SBIG('SUB_'):
m_elem.reset(new struct RESubtract);
break;
case SBIG('VMAG'):
m_elem.reset(new struct REVectorMagnitude);
break;
case SBIG('VXTR'):
m_elem.reset(new struct REVectorXToReal);
break;
case SBIG('VYTR'):
m_elem.reset(new struct REVectorYToReal);
break;
case SBIG('VZTR'):
m_elem.reset(new struct REVectorZToReal);
break;
case SBIG('CEXT'):
m_elem.reset(new struct RECEXT);
break;
case SBIG('ITRL'):
m_elem.reset(new struct REIntTimesReal);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown RealElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
}
template <>
void RealElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void IntElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct IEKeyframeEmitter);
break;
case SBIG('DETH'):
m_elem.reset(new struct IEDeath);
break;
case SBIG('CLMP'):
m_elem.reset(new struct IEClamp);
break;
case SBIG('CHAN'):
m_elem.reset(new struct IETimeChain);
break;
case SBIG('ADD_'):
m_elem.reset(new struct IEAdd);
break;
case SBIG('CNST'):
m_elem.reset(new struct IEConstant);
break;
case SBIG('IMPL'):
m_elem.reset(new struct IEImpulse);
break;
case SBIG('ILPT'):
m_elem.reset(new struct IELifetimePercent);
break;
case SBIG('IRND'):
m_elem.reset(new struct IEInitialRandom);
break;
case SBIG('PULS'):
m_elem.reset(new struct IEPulse);
break;
case SBIG('MULT'):
m_elem.reset(new struct IEMultiply);
break;
case SBIG('SPAH'):
m_elem.reset(new struct IESampleAndHold);
break;
case SBIG('RAND'):
m_elem.reset(new struct IERandom);
break;
case SBIG('TSCL'):
m_elem.reset(new struct IETimeScale);
break;
case SBIG('GTCP'):
m_elem.reset(new struct IEGTCP);
break;
case SBIG('MODU'):
m_elem.reset(new struct IEModulo);
break;
case SBIG('SUB_'):
m_elem.reset(new struct IESubtract);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
2016-02-02 04:29:58 +00:00
m_elem->read(r);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void IntElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <>
void IntElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
}
template <>
void IntElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct IEKeyframeEmitter);
break;
case SBIG('DETH'):
m_elem.reset(new struct IEDeath);
break;
case SBIG('CLMP'):
m_elem.reset(new struct IEClamp);
break;
case SBIG('CHAN'):
m_elem.reset(new struct IETimeChain);
break;
case SBIG('ADD_'):
m_elem.reset(new struct IEAdd);
break;
case SBIG('CNST'):
m_elem.reset(new struct IEConstant);
break;
case SBIG('IMPL'):
m_elem.reset(new struct IEImpulse);
break;
case SBIG('ILPT'):
m_elem.reset(new struct IELifetimePercent);
break;
case SBIG('IRND'):
m_elem.reset(new struct IEInitialRandom);
break;
case SBIG('PULS'):
m_elem.reset(new struct IEPulse);
break;
case SBIG('MULT'):
m_elem.reset(new struct IEMultiply);
break;
case SBIG('SPAH'):
m_elem.reset(new struct IESampleAndHold);
break;
case SBIG('RAND'):
m_elem.reset(new struct IERandom);
break;
case SBIG('TSCL'):
m_elem.reset(new struct IETimeScale);
break;
case SBIG('GTCP'):
m_elem.reset(new struct IEGTCP);
break;
case SBIG('MODU'):
m_elem.reset(new struct IEModulo);
break;
case SBIG('SUB_'):
m_elem.reset(new struct IESubtract);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown IntElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
}
template <>
void IntElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void VectorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('CONE'):
m_elem.reset(new struct VECone);
break;
case SBIG('CHAN'):
m_elem.reset(new struct VETimeChain);
break;
case SBIG('ANGC'):
m_elem.reset(new struct VEAngleCone);
break;
case SBIG('ADD_'):
m_elem.reset(new struct VEAdd);
break;
case SBIG('CCLU'):
m_elem.reset(new struct VECircleCluster);
break;
case SBIG('CNST'):
m_elem.reset(new struct VEConstant);
break;
case SBIG('CIRC'):
m_elem.reset(new struct VECircle);
break;
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct VEKeyframeEmitter);
break;
case SBIG('MULT'):
m_elem.reset(new struct VEMultiply);
break;
case SBIG('RTOV'):
m_elem.reset(new struct VERealToVector);
break;
case SBIG('PULS'):
m_elem.reset(new struct VEPulse);
break;
case SBIG('PVEL'):
m_elem.reset(new struct VEParticleVelocity);
break;
case SBIG('SPOS'):
m_elem.reset(new struct VESPOS);
break;
case SBIG('PLCO'):
m_elem.reset(new struct VEPLCO);
break;
case SBIG('PLOC'):
m_elem.reset(new struct VEPLOC);
break;
case SBIG('PSOR'):
m_elem.reset(new struct VEPSOR);
break;
case SBIG('PSOF'):
m_elem.reset(new struct VEPSOF);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
2016-02-02 08:22:01 +00:00
m_elem->read(r);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void VectorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <>
void VectorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
}
template <>
void VectorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('CONE'):
m_elem.reset(new struct VECone);
break;
case SBIG('CHAN'):
m_elem.reset(new struct VETimeChain);
break;
case SBIG('ANGC'):
m_elem.reset(new struct VEAngleCone);
break;
case SBIG('ADD_'):
m_elem.reset(new struct VEAdd);
break;
case SBIG('CCLU'):
m_elem.reset(new struct VECircleCluster);
break;
case SBIG('CNST'):
m_elem.reset(new struct VEConstant);
break;
case SBIG('CIRC'):
m_elem.reset(new struct VECircle);
break;
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct VEKeyframeEmitter);
break;
case SBIG('MULT'):
m_elem.reset(new struct VEMultiply);
break;
case SBIG('RTOV'):
m_elem.reset(new struct VERealToVector);
break;
case SBIG('PULS'):
m_elem.reset(new struct VEPulse);
break;
case SBIG('PVEL'):
m_elem.reset(new struct VEParticleVelocity);
break;
case SBIG('SPOS'):
m_elem.reset(new struct VESPOS);
break;
case SBIG('PLCO'):
m_elem.reset(new struct VEPLCO);
break;
case SBIG('PLOC'):
m_elem.reset(new struct VEPLOC);
break;
case SBIG('PSOR'):
m_elem.reset(new struct VEPSOR);
break;
case SBIG('PSOF'):
m_elem.reset(new struct VEPSOF);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown VectorElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
}
template <>
void VectorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void ColorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct CEKeyframeEmitter);
break;
case SBIG('CNST'):
m_elem.reset(new struct CEConstant);
break;
case SBIG('CHAN'):
m_elem.reset(new struct CETimeChain);
break;
case SBIG('CFDE'):
m_elem.reset(new struct CEFadeEnd);
break;
case SBIG('FADE'):
m_elem.reset(new struct CEFade);
break;
case SBIG('PULS'):
m_elem.reset(new struct CEPulse);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
2016-02-02 08:22:01 +00:00
m_elem->read(r);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void ColorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <>
void ColorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
}
template <>
void ColorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('KEYE'):
case SBIG('KEYP'):
m_elem.reset(new struct CEKeyframeEmitter);
break;
case SBIG('CNST'):
m_elem.reset(new struct CEConstant);
break;
case SBIG('CHAN'):
m_elem.reset(new struct CETimeChain);
break;
case SBIG('CFDE'):
m_elem.reset(new struct CEFadeEnd);
break;
case SBIG('FADE'):
m_elem.reset(new struct CEFade);
break;
case SBIG('PULS'):
m_elem.reset(new struct CEPulse);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown ColorElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
}
template <>
void ColorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void ModVectorElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('IMPL'):
m_elem.reset(new struct MVEImplosion);
break;
case SBIG('EMPL'):
m_elem.reset(new struct MVEExponentialImplosion);
break;
case SBIG('CHAN'):
m_elem.reset(new struct MVETimeChain);
break;
case SBIG('BNCE'):
m_elem.reset(new struct MVEBounce);
break;
case SBIG('CNST'):
m_elem.reset(new struct MVEConstant);
break;
case SBIG('GRAV'):
m_elem.reset(new struct MVEGravity);
break;
case SBIG('EXPL'):
m_elem.reset(new struct MVEExplode);
break;
case SBIG('SPOS'):
m_elem.reset(new struct MVESetPosition);
break;
case SBIG('LMPL'):
m_elem.reset(new struct MVELinearImplosion);
break;
case SBIG('PULS'):
m_elem.reset(new struct MVEPulse);
break;
case SBIG('WIND'):
m_elem.reset(new struct MVEWind);
break;
case SBIG('SWRL'):
m_elem.reset(new struct MVESwirl);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
m_elem->read(r);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void ModVectorElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
}
template <>
void ModVectorElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
}
template <>
void ModVectorElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('IMPL'):
m_elem.reset(new struct MVEImplosion);
break;
case SBIG('EMPL'):
m_elem.reset(new struct MVEExponentialImplosion);
break;
case SBIG('CHAN'):
m_elem.reset(new struct MVETimeChain);
break;
case SBIG('BNCE'):
m_elem.reset(new struct MVEBounce);
break;
case SBIG('CNST'):
m_elem.reset(new struct MVEConstant);
break;
case SBIG('GRAV'):
m_elem.reset(new struct MVEGravity);
break;
case SBIG('EXPL'):
m_elem.reset(new struct MVEExplode);
break;
case SBIG('SPOS'):
m_elem.reset(new struct MVESetPosition);
break;
case SBIG('LMPL'):
m_elem.reset(new struct MVELinearImplosion);
break;
case SBIG('PULS'):
m_elem.reset(new struct MVEPulse);
break;
case SBIG('WIND'):
m_elem.reset(new struct MVEWind);
break;
case SBIG('SWRL'):
m_elem.reset(new struct MVESwirl);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown ModVectorElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
}
template <>
void ModVectorElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
}
template <>
void EmitterElementFactory::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
const auto& mapChildren = r.getCurNode()->m_mapChildren;
if (mapChildren.empty()) {
m_elem.reset();
return;
}
const auto& elem = mapChildren[0];
if (elem.first.size() < 4)
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("short FourCC in element '{}'"), elem.first);
2018-12-08 05:30:43 +00:00
switch (*reinterpret_cast<const uint32_t*>(elem.first.data())) {
case SBIG('SETR'):
m_elem.reset(new struct EESimpleEmitterTR);
break;
case SBIG('SEMR'):
m_elem.reset(new struct EESimpleEmitter);
break;
case SBIG('SPHE'):
m_elem.reset(new struct VESphere);
break;
case SBIG('ASPH'):
m_elem.reset(new struct VEAngleSphere);
break;
default:
m_elem.reset();
return;
}
if (auto rec = r.enterSubRecord(elem.first.c_str()))
m_elem->read(r);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void EmitterElementFactory::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void EmitterElementFactory::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 4;
if (m_elem)
m_elem->binarySize(s);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void EmitterElementFactory::Enumerate<BigDNA::Read>(typename Read::StreamT& r) {
2019-07-20 04:27:21 +00:00
DNAFourCC clsId;
clsId.read(r);
switch (clsId.toUint32()) {
2018-12-08 05:30:43 +00:00
case SBIG('SETR'):
m_elem.reset(new struct EESimpleEmitterTR);
break;
case SBIG('SEMR'):
m_elem.reset(new struct EESimpleEmitter);
break;
case SBIG('SPHE'):
m_elem.reset(new struct VESphere);
break;
case SBIG('ASPH'):
m_elem.reset(new struct VEAngleSphere);
break;
case SBIG('NONE'):
m_elem.reset();
return;
default:
m_elem.reset();
2019-07-20 04:27:21 +00:00
LogModule.report(logvisor::Fatal, fmt("Unknown EmitterElement class {} @{}"), clsId, r.position());
2018-12-08 05:30:43 +00:00
return;
}
m_elem->read(r);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void EmitterElementFactory::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
if (m_elem) {
w.writeBytes((atInt8*)m_elem->ClassID(), 4);
m_elem->write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
2016-02-02 08:22:01 +00:00
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void BoolHelper::Enumerate<BigDNA::ReadYaml>(typename ReadYaml::StreamT& r) {
value = r.readBool(nullptr);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void BoolHelper::Enumerate<BigDNA::WriteYaml>(typename WriteYaml::StreamT& w) {
w.writeBool(nullptr, value);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void BoolHelper::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 5;
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
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;
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
void BoolHelper::Enumerate<BigDNA::Write>(typename Write::StreamT& w) {
w.writeBytes((atInt8*)"CNST", 4);
w.writeBool(value);
}
2018-02-22 07:24:51 +00:00
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
void EESimpleEmitterTR::Enumerate<BigDNA::BinarySize>(typename BinarySize::StreamT& s) {
s += 8;
position.binarySize(s);
velocity.binarySize(s);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
r.readBytesToBuf(&clsId, 4);
2018-12-08 05:30:43 +00:00
if (clsId == SBIG('IVEC'))
velocity.read(r);
}
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
const char* UVEConstant<UniqueID32>::DNAType() {
return "UVEConstant<UniqueID32>";
2018-02-22 07:24:51 +00:00
}
template <>
2018-12-08 05:30:43 +00:00
const char* UVEConstant<UniqueID64>::DNAType() {
return "UVEConstant<UniqueID64>";
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEConstant<IDType>::_read(typename ReadYaml::StreamT& r) {
tex.clear();
if (auto rec = r.enterSubRecord("tex"))
tex.read(r);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEConstant<IDType>::_write(typename WriteYaml::StreamT& w) const {
if (auto rec = w.enterSubRecord("tex"))
tex.write(w);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEConstant<IDType>::_binarySize(typename BinarySize::StreamT& _s) const {
_s += 4;
tex.binarySize(_s);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEConstant<IDType>::_read(typename Read::StreamT& r) {
tex.clear();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
tex.read(r);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEConstant<IDType>::_write(typename Write::StreamT& w) const {
w.writeBytes((atInt8*)"CNST", 4);
tex.write(w);
2018-02-22 07:24:51 +00:00
}
AT_SUBSPECIALIZE_DNA_YAML(UVEConstant<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVEConstant<UniqueID64>)
template struct UVEConstant<UniqueID32>;
template struct UVEConstant<UniqueID64>;
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* UVEAnimTexture<UniqueID32>::DNAType() {
return "UVEAnimTexture<UniqueID32>";
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
template <>
const char* UVEAnimTexture<UniqueID64>::DNAType() {
return "UVEAnimTexture<UniqueID64>";
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
2018-02-22 07:24:51 +00:00
template <class IDType>
2018-12-08 05:30:43 +00:00
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"))
2018-02-22 07:24:51 +00:00
tileW.read(r);
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord("tileH"))
2018-02-22 07:24:51 +00:00
tileH.read(r);
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord("strideW"))
2018-02-22 07:24:51 +00:00
strideW.read(r);
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord("strideH"))
2018-02-22 07:24:51 +00:00
strideH.read(r);
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord("cycleFrames"))
2018-02-22 07:24:51 +00:00
cycleFrames.read(r);
2018-12-08 05:30:43 +00:00
if (auto rec = r.enterSubRecord("loop"))
loop = r.readBool(nullptr);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVEAnimTexture<IDType>::_write(typename WriteYaml::StreamT& w) const {
if (auto rec = w.enterSubRecord("tex"))
2018-02-22 07:24:51 +00:00
tex.write(w);
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("tileW"))
2018-02-22 07:24:51 +00:00
tileW.write(w);
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("tileH"))
2018-02-22 07:24:51 +00:00
tileH.write(w);
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("strideW"))
2018-02-22 07:24:51 +00:00
strideW.write(w);
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("strideH"))
2018-02-22 07:24:51 +00:00
strideH.write(w);
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("cycleFrames"))
2018-02-22 07:24:51 +00:00
cycleFrames.write(w);
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
AT_SUBSPECIALIZE_DNA_YAML(UVEAnimTexture<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVEAnimTexture<UniqueID64>)
template struct UVEAnimTexture<UniqueID32>;
template struct UVEAnimTexture<UniqueID64>;
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* UVElementFactory<UniqueID32>::DNAType() {
return "UVElementFactory<UniqueID32>";
}
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* UVElementFactory<UniqueID64>::DNAType() {
return "UVElementFactory<UniqueID64>";
}
2018-03-23 21:56:17 +00:00
2018-02-22 07:24:51 +00:00
template <class IDType>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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();
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVElementFactory<IDType>::_write(typename WriteYaml::StreamT& w) const {
if (m_elem)
if (auto rec = w.enterSubRecord(m_elem->ClassID()))
m_elem->write(w);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void UVElementFactory<IDType>::_binarySize(typename BinarySize::StreamT& _s) const {
if (m_elem)
m_elem->binarySize(_s);
_s += 4;
2018-02-22 07:24:51 +00:00
}
AT_SUBSPECIALIZE_DNA_YAML(UVElementFactory<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(UVElementFactory<UniqueID64>)
template struct UVElementFactory<UniqueID32>;
template struct UVElementFactory<UniqueID64>;
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* SpawnSystemKeyframeData<UniqueID32>::SpawnSystemKeyframeInfo::DNAType() {
return "SpawnSystemKeyframeData<UniqueID32>::SpawnSystemKeyframeInfo";
}
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* SpawnSystemKeyframeData<UniqueID64>::SpawnSystemKeyframeInfo::DNAType() {
return "SpawnSystemKeyframeData<UniqueID64>::SpawnSystemKeyframeInfo";
}
2018-03-23 21:56:17 +00:00
2018-02-22 07:24:51 +00:00
template <class IDType>
template <class Op>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* SpawnSystemKeyframeData<UniqueID32>::DNAType() {
return "SpawnSystemKeyframeData<UniqueID32>";
}
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* SpawnSystemKeyframeData<UniqueID64>::DNAType() {
return "SpawnSystemKeyframeData<UniqueID64>";
}
2018-03-23 21:56:17 +00:00
2018-02-22 07:24:51 +00:00
template <class IDType>
2018-12-08 05:30:43 +00:00
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) {
(void)child;
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) {
(void)in;
spawns.back().second.emplace_back();
SpawnSystemKeyframeInfo& info = spawns.back().second.back();
2018-02-22 07:24:51 +00:00
if (auto rec = r.enterSubRecord(nullptr))
2018-12-08 05:30:43 +00:00
info.read(r);
}
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
}
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
}
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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)
2018-02-22 07:24:51 +00:00
if (auto rec = w.enterSubRecord(nullptr))
2018-12-08 05:30:43 +00:00
info.write(w);
}
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
}
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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);
}
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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);
2018-02-22 07:24:51 +00:00
}
2018-12-08 05:30:43 +00:00
}
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
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);
}
2018-02-22 07:24:51 +00:00
}
AT_SUBSPECIALIZE_DNA_YAML(SpawnSystemKeyframeData<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(SpawnSystemKeyframeData<UniqueID64>)
template struct SpawnSystemKeyframeData<UniqueID32>;
template struct SpawnSystemKeyframeData<UniqueID64>;
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* ChildResourceFactory<UniqueID32>::DNAType() {
return "ChildResourceFactory<UniqueID32>";
}
2018-03-23 21:56:17 +00:00
template <>
2018-12-08 05:30:43 +00:00
const char* ChildResourceFactory<UniqueID64>::DNAType() {
return "ChildResourceFactory<UniqueID64>";
}
2018-03-23 21:56:17 +00:00
2018-02-22 07:24:51 +00:00
template <class IDType>
2018-12-08 05:30:43 +00:00
void ChildResourceFactory<IDType>::_read(typename ReadYaml::StreamT& r) {
id.clear();
if (auto rec = r.enterSubRecord("CNST"))
id.read(r);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void ChildResourceFactory<IDType>::_write(typename WriteYaml::StreamT& w) const {
2019-07-20 04:27:21 +00:00
if (id.isValid())
2018-12-08 05:30:43 +00:00
if (auto rec = w.enterSubRecord("CNST"))
id.write(w);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void ChildResourceFactory<IDType>::_binarySize(typename BinarySize::StreamT& s) const {
2019-07-20 04:27:21 +00:00
if (id.isValid())
2018-12-08 05:30:43 +00:00
id.binarySize(s);
s += 4;
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void ChildResourceFactory<IDType>::_read(typename Read::StreamT& r) {
id.clear();
uint32_t clsId;
r.readBytesToBuf(&clsId, 4);
if (clsId == SBIG('CNST'))
id.read(r);
2018-02-22 07:24:51 +00:00
}
template <class IDType>
2018-12-08 05:30:43 +00:00
void ChildResourceFactory<IDType>::_write(typename Write::StreamT& w) const {
2019-07-20 04:27:21 +00:00
if (id.isValid()) {
2018-12-08 05:30:43 +00:00
w.writeBytes((atInt8*)"CNST", 4);
id.write(w);
} else
w.writeBytes((atInt8*)"NONE", 4);
2018-02-22 07:24:51 +00:00
}
AT_SUBSPECIALIZE_DNA_YAML(ChildResourceFactory<UniqueID32>)
AT_SUBSPECIALIZE_DNA_YAML(ChildResourceFactory<UniqueID64>)
template struct ChildResourceFactory<UniqueID32>;
template struct ChildResourceFactory<UniqueID64>;
2018-12-08 05:30:43 +00:00
} // namespace DataSpec::DNAParticle