Commit 5dd72b97 authored by Jack Andersen's avatar Jack Andersen
Browse files

Less resource-intensive particle metaclass system

parent 8e33cb82
......@@ -8,8 +8,8 @@
namespace DataSpec::DNAParticle {
template struct CPImpl<_CRSM<UniqueID32>>;
template struct CPImpl<_CRSM<UniqueID64>>;
template struct PPImpl<_CRSM<UniqueID32>>;
template struct PPImpl<_CRSM<UniqueID64>>;
AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_CRSM<UniqueID32>>)
AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_CRSM<UniqueID64>>)
......
This diff is collapsed.
......@@ -7,8 +7,8 @@
namespace DataSpec::DNAParticle {
template struct DPImpl<_DPSM<UniqueID32>>;
template struct DPImpl<_DPSM<UniqueID64>>;
template struct PPImpl<_DPSM<UniqueID32>>;
template struct PPImpl<_DPSM<UniqueID64>>;
AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_DPSM<UniqueID32>>)
AT_SUBSPECIALIZE_DNA_YAML(PPImpl<_DPSM<UniqueID64>>)
......
......@@ -19,169 +19,89 @@ class ProjectPath;
namespace DataSpec::DNAParticle {
class DPUtils {
template<std::size_t _Idx, typename _Key, typename _Tuple>
struct _Match;
template<std::size_t _Idx, typename _Key, typename _First, typename... _Rest>
struct _Match<_Idx, _Key, std::tuple<_First, _Rest...>>
: _Match<_Idx + 1, _Key, std::tuple<_Rest...>> {};
template<std::size_t _Idx, typename _First, typename... _Rest>
struct _Match<_Idx, typename _First::FourCC, std::tuple<_First, _Rest...>>
{ using Type = _First; static constexpr bool IsDP = _First::IsDP; };
template<bool _IsCP, std::size_t _Idx, typename _Element, typename _ExistingTuple>
struct _AppendElement;
template<std::size_t _Idx, typename _Element, typename... _Existing>
struct _AppendElement<true, _Idx, _Element, std::tuple<_Existing...>> {
using Tuple = typename _Element::template Expand<_Idx, _Existing...>::Tuple;
};
template<std::size_t _Idx, typename _Element, typename... _Existing>
struct _AppendElement<false, _Idx, _Element, std::tuple<_Existing...>> {
using Tuple = std::tuple<_Existing..., _Element>;
template <class IDType>
struct _DPSM {
static constexpr ParticleType Type = ParticleType::DPSM;
struct SQuadDescr {
IntElementFactory x0_LFT;
RealElementFactory x4_SZE;
RealElementFactory x8_ROT;
VectorElementFactory xc_OFF;
ColorElementFactory x10_CLR;
UVElementFactory<IDType> x14_TEX;
bool x18_ADD = false;
};
template<std::size_t _Idx, typename _OutTuple, typename _Tuple>
struct _ExpandTuple { using Tuple = _OutTuple; };
template<std::size_t _Idx, typename _OutTuple, typename _First, typename... _Rest>
struct _ExpandTuple<_Idx, _OutTuple, std::tuple<_First, _Rest...>>
: _ExpandTuple<_Idx + 1, typename _AppendElement<_First::IsDP, _Idx, _First, _OutTuple>::Tuple,
std::tuple<_Rest...>> {};
public:
template<auto _Key, typename _Props>
using GetElement = _Match<0, std::integral_constant<decltype(_Key), _Key>, typename _Props::PropsTuple>;
template<typename _PropsTuple>
using ExpandTuple = _ExpandTuple<0, std::tuple<>, _PropsTuple>;
template<auto _Key, typename _Props>
static constexpr decltype(auto) GetQuad(_Props& p, std::size_t idx) {
using Elem = typename GetElement<_Key, _Props>::Type;
static_assert(Elem::IsDP, "GetQuad may only be used to look up quad properties");
if constexpr (Elem::IsDP) {
if (idx)
return PPUtils::Get<Elem::Type::FCC2::value>(p);
else
return PPUtils::Get<Elem::Type::FCC1::value>(p);
}
SQuadDescr x0_quad;
SQuadDescr x1c_quad;
ChildResourceFactory<IDType> x38_DMDL;
IntElementFactory x48_DLFT;
VectorElementFactory x4c_DMOP;
VectorElementFactory x50_DMRT;
VectorElementFactory x54_DMSC;
ColorElementFactory x58_DMCL;
bool x5c_24_DMAB = false;
bool x5c_25_DMOO = false;
template<typename _Func>
void constexpr Enumerate(_Func f) {
f(FOURCC('1LFT'), x0_quad.x0_LFT);
f(FOURCC('1SZE'), x0_quad.x4_SZE);
f(FOURCC('1ROT'), x0_quad.x8_ROT);
f(FOURCC('1OFF'), x0_quad.xc_OFF);
f(FOURCC('1CLR'), x0_quad.x10_CLR);
f(FOURCC('1TEX'), x0_quad.x14_TEX);
f(FOURCC('1ADD'), x0_quad.x18_ADD);
f(FOURCC('2LFT'), x1c_quad.x0_LFT);
f(FOURCC('2SZE'), x1c_quad.x4_SZE);
f(FOURCC('2ROT'), x1c_quad.x8_ROT);
f(FOURCC('2OFF'), x1c_quad.xc_OFF);
f(FOURCC('2CLR'), x1c_quad.x10_CLR);
f(FOURCC('2TEX'), x1c_quad.x14_TEX);
f(FOURCC('2ADD'), x1c_quad.x18_ADD);
f(FOURCC('DMDL'), x38_DMDL);
f(FOURCC('DLFT'), x48_DLFT);
f(FOURCC('DMOP'), x4c_DMOP);
f(FOURCC('DMRT'), x50_DMRT);
f(FOURCC('DMSC'), x54_DMSC);
f(FOURCC('DMCL'), x58_DMCL);
f(FOURCC('DMAB'), x5c_24_DMAB);
f(FOURCC('DMOO'), x5c_25_DMOO);
}
};
template <auto _FCC, auto _FCC1, auto _FCC2, typename _Type>
struct DPS {
static constexpr bool IsBool = false;
static constexpr bool IsDP = true;
using FourCC = std::integral_constant<decltype(_FCC), _FCC>;
using FCC1 = std::integral_constant<decltype(_FCC1), _FCC1>;
using FCC2 = std::integral_constant<decltype(_FCC2), _FCC2>;
struct _ExpandDone {
template<std::size_t Index, typename... Existing>
using Tuple = std::tuple<Existing...>;
};
template<typename FCC, typename Next>
struct _Expand {
template<std::size_t Index, typename... Existing>
using Tuple =
std::conditional_t<FCC::value != typename FCC::value_type(0),
typename Next::template Tuple<Index, Existing..., PP<FCC::value, _Type>>,
typename Next::template Tuple<Index, Existing...>>;
};
template<std::size_t Index, typename... Existing>
struct Expand {
using Tuple = typename _Expand<FCC1, _Expand<FCC2, _ExpandDone>>::template Tuple<Index, Existing...>;
};
};
template <ParticleType _Type, typename _PropsTuple, auto... _SortedTypes>
struct DPSet : _PPSet<typename DPUtils::ExpandTuple<_PropsTuple>::Tuple, _SortedTypes...> {
static constexpr ParticleType Type = _Type;
using Self = DPSet<_Type, _PropsTuple, _SortedTypes...>;
using Base = _PPSet<typename DPUtils::ExpandTuple<_PropsTuple>::Tuple, _SortedTypes...>;
using RawPropsTuple = _PropsTuple;
typename Base::PropsTuple m_props;
typename Base::PropsBitset m_boolProps;
DPSet() {
std::apply([&](auto&&... p) {
([&](auto&& p) {
using Tp = std::decay_t<decltype(p)>;
if constexpr (Tp::IsBool)
if constexpr (Tp::DefaultBool::value)
m_boolProps[PPUtils::GetStoreIndex<Tp, Base>::Index] = true;
}(p), ...);
}, m_props);
template<typename _Func>
bool constexpr Lookup(FourCC fcc, _Func f) {
switch (fcc.toUint32()) {
case SBIG('1LFT'): f(x0_quad.x0_LFT); return true;
case SBIG('1SZE'): f(x0_quad.x4_SZE); return true;
case SBIG('1ROT'): f(x0_quad.x8_ROT); return true;
case SBIG('1OFF'): f(x0_quad.xc_OFF); return true;
case SBIG('1CLR'): f(x0_quad.x10_CLR); return true;
case SBIG('1TEX'): f(x0_quad.x14_TEX); return true;
case SBIG('1ADD'): f(x0_quad.x18_ADD); return true;
case SBIG('2LFT'): f(x1c_quad.x0_LFT); return true;
case SBIG('2SZE'): f(x1c_quad.x4_SZE); return true;
case SBIG('2ROT'): f(x1c_quad.x8_ROT); return true;
case SBIG('2OFF'): f(x1c_quad.xc_OFF); return true;
case SBIG('2CLR'): f(x1c_quad.x10_CLR); return true;
case SBIG('2TEX'): f(x1c_quad.x14_TEX); return true;
case SBIG('2ADD'): f(x1c_quad.x18_ADD); return true;
case SBIG('DMDL'): f(x38_DMDL); return true;
case SBIG('DLFT'): f(x48_DLFT); return true;
case SBIG('DMOP'): f(x4c_DMOP); return true;
case SBIG('DMRT'): f(x50_DMRT); return true;
case SBIG('DMSC'): f(x54_DMSC); return true;
case SBIG('DMCL'): f(x58_DMCL); return true;
default: return false;
}
}
};
template <typename _Basis>
struct DPImpl : PPImpl<_Basis> {
using Base = PPImpl<_Basis>;
using EDP = typename _Basis::EDP;
template<EDP _Key>
decltype(auto) getQuad(std::size_t idx) { return DPUtils::GetQuad<_Key>(Base::m_props, idx); }
};
template <class IDType>
struct _DPSM {
enum EPP : uint32_t {
_1LFT = SBIG('1LFT'), // x0
_1SZE = SBIG('1SZE'), // x4
_1ROT = SBIG('1ROT'), // x8
_1OFF = SBIG('1OFF'), // xc
_1CLR = SBIG('1CLR'), // x10
_1TEX = SBIG('1TEX'), // x14
_1ADD = SBIG('1ADD'), // x18
_2LFT = SBIG('2LFT'), // x1c
_2SZE = SBIG('2SZE'), // x20
_2ROT = SBIG('2ROT'), // x24
_2OFF = SBIG('2OFF'), // x28
_2CLR = SBIG('2CLR'), // x2c
_2TEX = SBIG('2TEX'), // x30
_2ADD = SBIG('2ADD'), // x34
DMDL = SBIG('DMDL'), // x38
DLFT = SBIG('DLFT'), // x48
DMOP = SBIG('DMOP'), // x4c
DMRT = SBIG('DMRT'), // x50
DMSC = SBIG('DMSC'), // x54
DMCL = SBIG('DMCL'), // x58
DMAB = SBIG('DMAB'), // x5c_24
DMOO = SBIG('DMOO'), // x5c_25
};
enum EDP : uint32_t {
LFT = SBIG(' LFT'), // x0
SZE = SBIG(' SZE'), // x4
ROT = SBIG(' ROT'), // x8
OFF = SBIG(' OFF'), // xc
CLR = SBIG(' CLR'), // x10
TEX = SBIG(' TEX'), // x14
ADD = SBIG(' ADD'), // x18
};
using Properties = DPSet<
ParticleType::DPSM,
std::tuple<
DPS<LFT, _1LFT, _2LFT, IntElementFactory>,
DPS<SZE, _1SZE, _2SZE, RealElementFactory>,
DPS<ROT, _1ROT, _2ROT, RealElementFactory>,
DPS<OFF, _1OFF, _2OFF, VectorElementFactory>,
DPS<CLR, _1CLR, _2CLR, ColorElementFactory>,
DPS<TEX, _1TEX, _2TEX, UVElementFactory<IDType>>,
DPS<ADD, _1ADD, _2ADD, bool>,
PP<DMDL, ChildResourceFactory<IDType>>,
PP<DLFT, IntElementFactory>,
PP<DMOP, VectorElementFactory>,
PP<DMRT, VectorElementFactory>,
PP<DMSC, VectorElementFactory>,
PP<DMCL, ColorElementFactory>,
PP<DMAB, bool>,
PP<DMOO, bool>>,
_1ADD, _1CLR, _1LFT, _1OFF, _1ROT, _1SZE, _1TEX, _2ADD, _2CLR, _2LFT, _2OFF, _2ROT, _2SZE, _2TEX, DLFT,
DMAB, DMCL, DMDL, DMOO, DMOP, DMRT, DMSC>;
};
extern template struct PPImpl<_DPSM<UniqueID32>>;
extern template struct PPImpl<_DPSM<UniqueID64>>;
template <class IDType>
using DPSM = DPImpl<_DPSM<IDType>>;
using DPSM = PPImpl<_DPSM<IDType>>;
template <class IDType>
bool ExtractDPSM(PAKEntryReadStream& rs, const hecl::ProjectPath& outPath);
......
......@@ -15,55 +15,82 @@ namespace DataSpec::DNAParticle {
template <class IDType>
struct _ELSM {
enum EPP : uint32_t {
LIFE = SBIG('LIFE'), // x0
SLIF = SBIG('SLIF'), // x4
GRAT = SBIG('GRAT'), // x8
SCNT = SBIG('SCNT'), // xc
SSEG = SBIG('SSEG'), // x10
COLR = SBIG('COLR'), // x14
IEMT = SBIG('IEMT'), // x18
FEMT = SBIG('FEMT'), // x1c
AMPL = SBIG('AMPL'), // x20
AMPD = SBIG('AMPD'), // x24
LWD1 = SBIG('LWD1'), // x28
LWD2 = SBIG('LWD2'), // x2c
LWD3 = SBIG('LWD3'), // x30
LCL1 = SBIG('LCL1'), // x34
LCL2 = SBIG('LCL2'), // x38
LCL3 = SBIG('LCL3'), // x3c
SSWH = SBIG('SSWH'), // x40
GPSM = SBIG('GPSM'), // x50
EPSM = SBIG('EPSM'), // x60
ZERY = SBIG('ZERY'), // x70
};
using Properties = PPSet<
ParticleType::ELSM,
std::tuple<
PP<LIFE, IntElementFactory>,
PP<SLIF, IntElementFactory>,
PP<GRAT, RealElementFactory>,
PP<SCNT, IntElementFactory>,
PP<SSEG, IntElementFactory>,
PP<COLR, ColorElementFactory>,
PP<IEMT, EmitterElementFactory>,
PP<FEMT, EmitterElementFactory>,
PP<AMPL, RealElementFactory>,
PP<AMPD, RealElementFactory>,
PP<LWD1, RealElementFactory>,
PP<LWD2, RealElementFactory>,
PP<LWD3, RealElementFactory>,
PP<LCL1, ColorElementFactory>,
PP<LCL2, ColorElementFactory>,
PP<LCL3, ColorElementFactory>,
PP<SSWH, ChildResourceFactory<IDType>>,
PP<GPSM, ChildResourceFactory<IDType>>,
PP<EPSM, ChildResourceFactory<IDType>>,
PP<ZERY, bool>>,
AMPD, AMPL, COLR, EPSM, FEMT, GPSM, GRAT, IEMT, LCL1, LCL2, LCL3, LIFE, LWD1, LWD2, LWD3, SCNT, SLIF, SSEG,
SSWH, ZERY>;
};
static constexpr ParticleType Type = ParticleType::ELSM;
IntElementFactory x0_LIFE;
IntElementFactory x4_SLIF;
RealElementFactory x8_GRAT;
IntElementFactory xc_SCNT;
IntElementFactory x10_SSEG;
ColorElementFactory x14_COLR;
EmitterElementFactory x18_IEMT;
EmitterElementFactory x1c_FEMT;
RealElementFactory x20_AMPL;
RealElementFactory x24_AMPD;
RealElementFactory x28_LWD1;
RealElementFactory x2c_LWD2;
RealElementFactory x30_LWD3;
ColorElementFactory x34_LCL1;
ColorElementFactory x38_LCL2;
ColorElementFactory x3c_LCL3;
ChildResourceFactory<IDType> x40_SSWH;
ChildResourceFactory<IDType> x50_GPSM;
ChildResourceFactory<IDType> x60_EPSM;
bool x70_ZERY = false;
template<typename _Func>
void constexpr Enumerate(_Func f) {
f(FOURCC('LIFE'), x0_LIFE);
f(FOURCC('SLIF'), x4_SLIF);
f(FOURCC('GRAT'), x8_GRAT);
f(FOURCC('SCNT'), xc_SCNT);
f(FOURCC('SSEG'), x10_SSEG);
f(FOURCC('COLR'), x14_COLR);
f(FOURCC('IEMT'), x18_IEMT);
f(FOURCC('FEMT'), x1c_FEMT);
f(FOURCC('AMPL'), x20_AMPL);
f(FOURCC('AMPD'), x24_AMPD);
f(FOURCC('LWD1'), x28_LWD1);
f(FOURCC('LWD2'), x2c_LWD2);
f(FOURCC('LWD3'), x30_LWD3);
f(FOURCC('LCL1'), x34_LCL1);
f(FOURCC('LCL2'), x38_LCL2);
f(FOURCC('LCL3'), x3c_LCL3);
f(FOURCC('SSWH'), x40_SSWH);
f(FOURCC('GPSM'), x50_GPSM);
f(FOURCC('EPSM'), x60_EPSM);
f(FOURCC('ZERY'), x70_ZERY);
}
template<typename _Func>
bool constexpr Lookup(FourCC fcc, _Func f) {
switch (fcc.toUint32()) {
case SBIG('LIFE'): f(x0_LIFE); return true;
case SBIG('SLIF'): f(x4_SLIF); return true;
case SBIG('GRAT'): f(x8_GRAT); return true;
case SBIG('SCNT'): f(xc_SCNT); return true;
case SBIG('SSEG'): f(x10_SSEG); return true;
case SBIG('COLR'): f(x14_COLR); return true;
case SBIG('IEMT'): f(x18_IEMT); return true;
case SBIG('FEMT'): f(x1c_FEMT); return true;
case SBIG('AMPL'): f(x20_AMPL); return true;
case SBIG('AMPD'): f(x24_AMPD); return true;
case SBIG('LWD1'): f(x28_LWD1); return true;
case SBIG('LWD2'): f(x2c_LWD2); return true;
case SBIG('LWD3'): f(x30_LWD3); return true;
case SBIG('LCL1'): f(x34_LCL1); return true;
case SBIG('LCL2'): f(x38_LCL2); return true;
case SBIG('LCL3'): f(x3c_LCL3); return true;
case SBIG('SSWH'): f(x40_SSWH); return true;
case SBIG('GPSM'): f(x50_GPSM); return true;
case SBIG('EPSM'): f(x60_EPSM); return true;
case SBIG('ZERY'): f(x70_ZERY); return true;
default: return false;
}
}
};
extern template struct PPImpl<_ELSM<UniqueID32>>;
extern template struct PPImpl<_ELSM<UniqueID64>>;
template <class IDType>
using ELSM = PPImpl<_ELSM<IDType>>;
......
......@@ -18,180 +18,269 @@ namespace DataSpec::DNAParticle {
template <class IDType>
struct _GPSM {
enum EPP : uint32_t {
PSIV = SBIG('PSIV'), // x0
PSVM = SBIG('PSVM'), // x4
PSOV = SBIG('PSOV'), // x8
PSLT = SBIG('PSLT'), // xc
PSWT = SBIG('PSWT'), // x10
PSTS = SBIG('PSTS'), // x14
POFS = SBIG('POFS'), // x18
SEED = SBIG('SEED'), // x1c
LENG = SBIG('LENG'), // x20
WIDT = SBIG('WIDT'), // x24
MAXP = SBIG('MAXP'), // x28
GRTE = SBIG('GRTE'), // x2c
COLR = SBIG('COLR'), // x30
LTME = SBIG('LTME'), // x34
ILOC = SBIG('ILOC'), // x38
IVEC = SBIG('IVEC'), // x3c
EMTR = SBIG('EMTR'), // x40
SORT = SBIG('SORT'), // x44_28
MBLR = SBIG('MBLR'), // x44_30
LINE = SBIG('LINE'), // x44_24
LIT_ = SBIG('LIT_'), // x44_29
AAPH = SBIG('AAPH'), // x44_26
ZBUF = SBIG('ZBUF'), // x44_27
FXLL = SBIG('FXLL'), // x44_25
PMAB = SBIG('PMAB'), // x44_31
VMD4 = SBIG('VMD4'), // x45_29
VMD3 = SBIG('VMD3'), // x45_28
VMD2 = SBIG('VMD2'), // x45_27
VMD1 = SBIG('VMD1'), // x45_26
OPTS = SBIG('OPTS'), // x45_31
PMUS = SBIG('PMUS'), // x45_24
PMOO = SBIG('PMOO'), // x45_25
CIND = SBIG('CIND'), // x45_30
MBSP = SBIG('MBSP'), // x48
SIZE = SBIG('SIZE'), // x4c
ROTA = SBIG('ROTA'), // x50
TEXR = SBIG('TEXR'), // x54
TIND = SBIG('TIND'), // x58
PMDL = SBIG('PMDL'), // x5c
PMOP = SBIG('PMOP'), // x6c
PMRT = SBIG('PMRT'), // x70
PMSC = SBIG('PMSC'), // x74
PMCL = SBIG('PMCL'), // x78
VEL1 = SBIG('VEL1'), // x7c
VEL2 = SBIG('VEL2'), // x80
VEL3 = SBIG('VEL3'), // x84
VEL4 = SBIG('VEL4'), // x88
ICTS = SBIG('ICTS'), // x8c
NCSY = SBIG('NCSY'), // x9c
CSSD = SBIG('CSSD'), // xa0
IDTS = SBIG('IDTS'), // xa4
NDSY = SBIG('NDSY'), // xb4
IITS = SBIG('IITS'), // xb8
PISY = SBIG('PISY'), // xc8
SISY = SBIG('SISY'), // xcc
KSSM = SBIG('KSSM'), // xd0
SSWH = SBIG('SSWH'), // xd4
SSSD = SBIG('SSSD'), // xe4
SSPO = SBIG('SSPO'), // xe8
SESD = SBIG('SESD'), // xf8
SEPO = SBIG('SEPO'), // xfc
PMLC = SBIG('PMLC'), // xec
LTYP = SBIG('LTYP'), // x100
LCLR = SBIG('LCLR'), // x104
LINT = SBIG('LINT'), // x108
LOFF = SBIG('LOFF'), // x10c
LDIR = SBIG('LDIR'), // x110
LFOT = SBIG('LFOT'), // x114
LFOR = SBIG('LFOR'), // x118
LSLA = SBIG('LSLA'), // x11c
SELC = SBIG('SELC'), // xd8
ORNT = SBIG('ORNT'), // x30_30
RSOP = SBIG('RSOP'), // x30_31
ADV1 = SBIG('ADV1'), // x10c
ADV2 = SBIG('ADV2'), // x110
ADV3 = SBIG('ADV3'), // x114
ADV4 = SBIG('ADV4'), // x118
ADV5 = SBIG('ADV5'), // x11c
ADV6 = SBIG('ADV6'), // x120
ADV7 = SBIG('ADV7'), // x124
ADV8 = SBIG('ADV8'), // x128
};
using Properties = PPSet<
ParticleType::GPSM,
std::tuple<
PP<PSIV, VectorElementFactory>,
PP<PSVM, ModVectorElementFactory>,
PP<PSOV, VectorElementFactory>,
PP<PSLT, IntElementFactory>,
PP<PSWT, IntElementFactory>,
PP<PSTS, RealElementFactory>,
PP<POFS, VectorElementFactory>,
PP<SEED, IntElementFactory>,
PP<LENG, RealElementFactory>,
PP<WIDT, RealElementFactory>,
PP<MAXP, IntElementFactory>,
PP<GRTE, RealElementFactory>,
PP<COLR, ColorElementFactory>,
PP<LTME, IntElementFactory>,
PP<ILOC, VectorElementFactory>,
PP<IVEC, VectorElementFactory>,
PP<EMTR, EmitterElementFactory>,
PP<SORT, bool>,
PP<MBLR, bool>,
PP<LINE, bool>,
PP<LIT_, bool>,
PP<AAPH, bool>,
PP<ZBUF, bool>,
PP<FXLL, bool>,
PP<PMAB, bool>,
PP<VMD4, bool>,
PP<VMD3, bool>,
PP<VMD2, bool>,
PP<VMD1, bool>,
PP<OPTS, bool>,
PP<PMUS, bool>,
PP<PMOO, bool, true>,
PP<CIND, bool>,
PP<MBSP, IntElementFactory>,
PP<SIZE, RealElementFactory>,
PP<ROTA, RealElementFactory>,
PP<TEXR, UVElementFactory<IDType>>,
PP<TIND, UVElementFactory<IDType>>,
PP<PMDL, ChildResourceFactory<IDType>>,
PP<PMOP, VectorElementFactory>,
PP<PMRT, VectorElementFactory>,
PP<PMSC, VectorElementFactory>,
PP<PMCL, ColorElementFactory>,
PP<VEL1, ModVectorElementFactory>,
PP<VEL2, ModVectorElementFactory>,
PP<VEL3, ModVectorElementFactory>,
PP<VEL4, ModVectorElementFactory>,
PP<ICTS, ChildResourceFactory<IDType>>,
PP<NCSY, IntElementFactory>,
PP<CSSD, IntElementFactory>,
PP<IDTS, ChildResourceFactory<IDType>>,
PP<NDSY, IntElementFactory>,
PP<IITS, ChildResourceFactory<IDType>>,
PP<PISY, IntElementFactory>,
PP<SISY, IntElementFactory>,
PP<KSSM, SpawnSystemKeyframeData<IDType>>,
PP<SSWH, ChildResourceFactory<IDType>>,
PP<SSSD, IntElementFactory>,
PP<SSPO, VectorElementFactory>,
PP<SESD, IntElementFactory>,
PP<SEPO, VectorElementFactory>,
PP<PMLC, ChildResourceFactory<IDType>>,
PP<LTYP, IntElementFactory>,
PP<LCLR, ColorElementFactory>,
PP<LINT, RealElementFactory>,
PP<LOFF, VectorElementFactory>,
PP<LDIR, VectorElementFactory>,
PP<LFOT, IntElementFactory>,
PP<LFOR, RealElementFactory>,
PP<LSLA, RealElementFactory>,
PP<SELC, ChildResourceFactory<IDType>>,
PP<ORNT, bool>,
PP<RSOP, bool>,
PP<ADV1, RealElementFactory>,
PP<ADV2, RealElementFactory>,
PP<ADV3, RealElementFactory>,
PP<ADV4, RealElementFactory>,
PP<ADV5, RealElementFactory>,
PP<ADV6, RealElementFactory>,
PP<ADV7, RealElementFactory>,
PP<ADV8, RealElementFactory>>,
AAPH, ADV1, ADV2, ADV3, ADV4, ADV5, ADV6, ADV7, ADV8, CIND, COLR, CSSD, EMTR, FXLL, GRTE, ICTS, IDTS, IITS, ILOC,