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

Added support for parsing MP2 particles

This commit is contained in:
parax0 2016-08-15 00:40:13 -06:00
parent 8f2b39469a
commit bc35e15a6a
3 changed files with 475 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
src/Core/Resource/Factory/CUnsupportedParticleLoader.cpp
View File

@ -14,6 +14,7 @@ bool CUnsupportedParticleLoader::ParseParticleParameter(IInputStream& rPART)
case kGenAAPH:
case kGenCIND:
case kGenFXLL:
case kGenINDM:
case kGenLINE:
case kGenLIT_:
case kGenMBLR:
@ -22,16 +23,23 @@ bool CUnsupportedParticleLoader::ParseParticleParameter(IInputStream& rPART)
case kGenPMAB:
case kGenPMOO:
case kGenPMUS:
case kGenRDOP:
case kGenRSOP:
case kGenSORT:
case kGenVMD1:
case kGenVMD2:
case kGenVMD3:
case kGenVMD4:
case kGenVMPC:
case kGenZBUF:
ParseBoolFunction(rPART);
break;
// Bitfield
case kGenDFLG:
ParseBitfieldFunction(rPART);
break;
// Int
case kGenCSSD:
case kGenLFOT:
@ -49,6 +57,7 @@ bool CUnsupportedParticleLoader::ParseParticleParameter(IInputStream& rPART)
case kGenSESD:
case kGenSISY:
case kGenSSSD:
case kGenXTAD:
ParseIntFunction(rPART);
break;
@ -61,6 +70,8 @@ bool CUnsupportedParticleLoader::ParseParticleParameter(IInputStream& rPART)
case kGenADV6:
case kGenADV7:
case kGenADV8:
case kGenADV9:
case kGenFXBR:
case kGenGRTE:
case kGenLENG:
case kGenLFOR:
@ -74,17 +85,22 @@ bool CUnsupportedParticleLoader::ParseParticleParameter(IInputStream& rPART)
break;
// Vector
case kGenFXBO:
case kGenILOC:
case kGenIVEC:
case kGenLDIR:
case kGenLOFF:
case kGenPMOP:
case kGenPMOV:
case kGenPMRT:
case kGenPMSC:
case kGenPOFS:
case kGenPSOV:
case kGenSEPO:
case kGenSSPO:
case kGenVAV1:
case kGenVAV2:
case kGenVAV3:
ParseVectorFunction(rPART);
break;
@ -151,6 +167,10 @@ bool CUnsupportedParticleLoader::ParseElectricParameter(IInputStream& rELSC)
ParseBoolFunction(rELSC);
break;
case kElecDFLG:
ParseBitfieldFunction(rELSC);
break;
case kElecLIFE:
case kElecSCNT:
case kElecSLIF:
@ -174,6 +194,10 @@ bool CUnsupportedParticleLoader::ParseElectricParameter(IInputStream& rELSC)
ParseColorFunction(rELSC);
break;
case kElecTEXR:
ParseUVFunction(rELSC);
break;
case kElecFEMT:
case kElecIEMT:
ParseEmitterFunction(rELSC);
@ -194,6 +218,84 @@ bool CUnsupportedParticleLoader::ParseElectricParameter(IInputStream& rELSC)
return true;
}
bool CUnsupportedParticleLoader::ParseSortedParameter(IInputStream& rSRSC)
{
u32 ParamOffset = rSRSC.Tell();
CFourCC Param = rSRSC.ReadLong();
if (Param == kParamEND) return false;
if (Param == "SPWN")
ParseSpawnSystemKeyframeData(rSRSC);
else
{
Log::FileError(rSRSC.GetSourceString(), ParamOffset, "Unknown SRSC parameter: " + Param.ToString());
DEBUG_BREAK;
return false;
}
return true;
}
bool CUnsupportedParticleLoader::ParseSpawnParameter(IInputStream& rSPSC)
{
u32 ParamOffset = rSPSC.Tell();
CFourCC Param = rSPSC.ReadLong();
if (Param == kParamEND) return false;
switch (Param.ToLong())
{
case kSpawnDEOL:
case kSpawnFRCO:
case kSpawnIGGT:
case kSpawnIGLT:
case kSpawnVMD1:
case kSpawnVMD2:
ParseBoolFunction(rSPSC);
break;
case kSpawnGIVL:
case kSpawnPSLT:
ParseIntFunction(rSPSC);
break;
case kSpawnVBLN:
ParseFloatFunction(rSPSC);
break;
case kSpawnFROV:
case kSpawnGORN:
case kSpawnGTRN:
case kSpawnIVEC:
case kSpawnLSCL:
case kSpawnORNT:
case kSpawnSCLE:
case kSpawnTRNL:
ParseVectorFunction(rSPSC);
break;
case kSpawnVLM1:
case kSpawnVLM2:
ParseModVectorFunction(rSPSC);
break;
case kSpawnPCOL:
ParseColorFunction(rSPSC);
break;
case kSpawnSPWN:
ParseSpawnSystemKeyframeData(rSPSC);
break;
default:
Log::FileError(rSPSC.GetSourceString(), ParamOffset, "Unknown SPSC parameter: " + Param.ToString());
DEBUG_BREAK;
return false;
}
return true;
}
bool CUnsupportedParticleLoader::ParseSwooshParameter(IInputStream& rSWHC)
{
u32 ParamOffset = rSWHC.Tell();
@ -203,6 +305,7 @@ bool CUnsupportedParticleLoader::ParseSwooshParameter(IInputStream& rSWHC)
switch (Param.ToLong())
{
case kSwooshAALP:
case kSwooshCLTX:
case kSwooshCRND:
case kSwooshCROS:
case kSwooshLLRD:
@ -216,6 +319,10 @@ bool CUnsupportedParticleLoader::ParseSwooshParameter(IInputStream& rSWHC)
ParseBoolFunction(rSWHC);
break;
case kSwooshDFLG:
ParseBitfieldFunction(rSWHC);
break;
case kSwooshLENG:
case kSwooshPSLT:
case kSwooshSIDE:
@ -270,15 +377,8 @@ bool CUnsupportedParticleLoader::ParseDecalParameter(IInputStream& rDPSC)
{
case kDecal1ADD:
case kDecal2ADD:
case kDecal1OFF:
case kDecal2OFF:
case kDecalDMAB:
case kDecalDMCL:
case kDecalDMDL:
case kDecalDMOO:
case kDecalDMOP:
case kDecalDMRT:
case kDecalDMSC:
ParseBoolFunction(rDPSC);
break;
@ -295,14 +395,26 @@ bool CUnsupportedParticleLoader::ParseDecalParameter(IInputStream& rDPSC)
ParseFloatFunction(rDPSC);
break;
case kDecal1OFF:
case kDecal2OFF:
case kDecalDMOP:
case kDecalDMRT:
case kDecalDMSC:
ParseVectorFunction(rDPSC);
break;
case kDecal1CLR:
case kDecal2CLR:
case kDecalDMCL:
ParseColorFunction(rDPSC);
break;
case kDecal1TEX:
case kDecal2TEX:
if (rDPSC.ReadLong() == kFuncNONE) break;
ParseUVFunction(rDPSC);
break;
case kDecalDMDL:
ParseAssetFunction(rDPSC);
break;
@ -329,12 +441,23 @@ bool CUnsupportedParticleLoader::ParseWeaponParameter(IInputStream& rWPSC)
case kWeaponAS11:
case kWeaponAS12:
case kWeaponAS13:
case kWeaponBHBT:
case kWeaponDP1C:
case kWeaponDP2C:
case kWeaponEELT:
case kWeaponEWTR:
case kWeaponF60H:
case kWeaponFC60:
case kWeaponHOMG:
case kWeaponLWTR:
case kWeaponNDTT:
case kWeaponRB1A:
case kWeaponRB2A:
case kWeaponRTLA:
case kWeaponRWPE:
case kWeaponSPS1:
case kWeaponSPS2:
case kWeaponSVBD:
case kWeaponSWTR:
case kWeaponVMD2:
ParseBoolFunction(rWPSC);
@ -345,17 +468,27 @@ bool CUnsupportedParticleLoader::ParseWeaponParameter(IInputStream& rWPSC)
ParseIntFunction(rWPSC);
break;
case kWeaponB1RT:
case kWeaponB1SE:
case kWeaponB2RT:
case kWeaponB2SE:
case kWeaponFOFF:
case kWeaponRNGE:
case kWeaponTLEN:
case kWeaponTRAT:
case kWeaponTSZE:
ParseFloatFunction(rWPSC);
break;
case kWeaponB1PO:
case kWeaponB2PO:
case kWeaponIORN:
case kWeaponIVEC:
case kWeaponOFST:
case kWeaponPOFS:
case kWeaponPSCL:
case kWeaponPSOV:
case kWeaponTLPO:
ParseVectorFunction(rWPSC);
break;
@ -363,10 +496,20 @@ bool CUnsupportedParticleLoader::ParseWeaponParameter(IInputStream& rWPSC)
ParseModVectorFunction(rWPSC);
break;
case kWeaponB1CL:
case kWeaponB2CL:
case kWeaponPCOL:
case kWeaponTECL:
case kWeaponTSCL:
ParseColorFunction(rWPSC);
break;
case kWeaponB1TX:
case kWeaponB2TX:
case kWeaponTTEX:
ParseUVFunction(rWPSC);
break;
case kWeaponAPSM:
case kWeaponAPS1:
case kWeaponAPS2:
@ -424,6 +567,7 @@ bool CUnsupportedParticleLoader::ParseCollisionResponseParameter(IInputStream& r
case kColi4DRN:
case kColi5DRN:
case kColi6DRN:
case kColi6GRN:
case kColi2MUD:
case kColi2SAN:
case kColiBHFX:
@ -434,11 +578,8 @@ bool CUnsupportedParticleLoader::ParseCollisionResponseParameter(IInputStream& r
case kColiDSFX:
case kColiDSHX:
case kColiGOFX:
case kColiGOOO:
case kColiGRAS:
case kColiGRFX:
case kColiHBFX:
case kColiICEE:
case kColiICFX:
case kColiMSFX:
case kColiPBHX:
@ -457,8 +598,15 @@ bool CUnsupportedParticleLoader::ParseCollisionResponseParameter(IInputStream& r
ParseFloatFunction(rCRSC);
break;
case kColi1LAV:
case kColi3LAV:
case kColi1MUD:
case kColi3MUD:
case kColi1SAN:
case kColi3SAN:
case kColiCHDL:
case kColiCODL:
case kColiCRTS:
case kColiDCHR:
case kColiDDCL:
case kColiDEFS:
@ -466,11 +614,17 @@ bool CUnsupportedParticleLoader::ParseCollisionResponseParameter(IInputStream& r
case kColiDESH:
case kColiENDL:
case kColiGODL:
case kColiGOOO:
case kColiGRAS:
case kColiGRDL:
case kColiICDL:
case kColiICEE:
case kColiMEDL:
case kColiMTLS:
case kColiTALP:
case kColiWATR:
case kColiWODL:
case kColiWODS:
case kColiWTDL:
ParseAssetFunction(rCRSC);
break;
@ -506,6 +660,12 @@ void CUnsupportedParticleLoader::ParseBoolFunction(IInputStream& rFile)
}
}
void CUnsupportedParticleLoader::ParseBitfieldFunction(IInputStream& rFile)
{
// todo: probably not the correct way to do this...
rFile.Seek(0x10, SEEK_CUR);
}
void CUnsupportedParticleLoader::ParseIntFunction(IInputStream& rFile)
{
u32 FuncOffset = rFile.Tell();
@ -517,16 +677,21 @@ void CUnsupportedParticleLoader::ParseIntFunction(IInputStream& rFile)
case kIntGAPC:
case kIntGEMT:
case kIntGTCP:
case kIntPCRT:
case kIntPDET:
break;
case kIntILPT:
case kIntIMPL:
case kIntKPIN:
ParseIntFunction(rFile);
break;
case kIntADD_:
case kIntDETH:
case kIntDIVD:
case kIntIRND:
case kIntISWT:
case kIntMODU:
case kIntMULT:
case kIntRAND:
@ -558,14 +723,20 @@ void CUnsupportedParticleLoader::ParseIntFunction(IInputStream& rFile)
}
case kIntKEYE:
case kIntKEYF:
case kIntKEYP:
ParseKeyframeEmitterData(rFile, 0x4);
ParseKeyframeEmitterData(rFile, Func, 0x4);
break;
case kIntTSCL:
ParseFloatFunction(rFile);
break;
case kIntRTOI:
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
break;
default:
Log::FileError(rFile.GetSourceString(), FuncOffset, "Unknown int function: " + Func.ToString());
DEBUG_BREAK;
@ -581,6 +752,7 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
switch (Func.ToLong())
{
case kFuncNONE:
case kFloatGTCP:
case kFloatPAP1:
case kFloatPAP2:
case kFloatPAP3:
@ -589,10 +761,13 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
case kFloatPAP6:
case kFloatPAP7:
case kFloatPAP8:
case kFloatPAP9:
case kFloatPRLW:
case kFloatPSLL:
break;
case kFloatKPIN:
case kFloatPRN1:
case kFloatRLPT:
case kFloatSCAL:
ParseFloatFunction(rFile);
@ -603,6 +778,7 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
case kFloatISWT:
case kFloatLFTW:
case kFloatMULT:
case kFloatPRN2:
case kFloatRAND:
case kFloatSUB_:
ParseFloatFunction(rFile);
@ -618,6 +794,7 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
break;
case kFloatCEXT:
case kFloatOCSP:
ParseIntFunction(rFile);
break;
@ -664,8 +841,9 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
break;
case kFloatKEYE:
case kFloatKEYF:
case kFloatKEYP:
ParseKeyframeEmitterData(rFile, 0x4);
ParseKeyframeEmitterData(rFile, Func, 0x4);
break;
case kFloatPULS:
@ -675,6 +853,7 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
ParseFloatFunction(rFile);
break;
case kFloatPRN3:
case kFloatVMAG:
case kFloatVXTR:
case kFloatVYTR:
@ -682,6 +861,48 @@ void CUnsupportedParticleLoader::ParseFloatFunction(IInputStream& rFile)
ParseVectorFunction(rFile);
break;
case kFloatPNO1:
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseIntFunction(rFile);
break;
case kFloatPNO2:
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseIntFunction(rFile);
break;
case kFloatPNO3:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseIntFunction(rFile);
break;
case kFloatPNO4:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseIntFunction(rFile);
break;
case kFloatPRN4:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
break;
case kFloatTOCS:
ParseBoolFunction(rFile);
ParseIntFunction(rFile);
ParseIntFunction(rFile);
ParseIntFunction(rFile);
break;
default:
Log::FileError(rFile.GetSourceString(), FuncOffset, "Unknown float function: " + Func.ToString());
DEBUG_BREAK;
@ -697,6 +918,7 @@ void CUnsupportedParticleLoader::ParseVectorFunction(IInputStream& rFile)
switch (Func.ToLong())
{
case kVectorADD_:
case kVectorISWT:
case kVectorMULT:
case kVectorSUB_:
ParseVectorFunction(rFile);
@ -748,13 +970,29 @@ void CUnsupportedParticleLoader::ParseVectorFunction(IInputStream& rFile)
break;
case kVectorKEYE:
case kVectorKEYF:
case kVectorKEYP:
ParseKeyframeEmitterData(rFile, 0xC);
ParseKeyframeEmitterData(rFile, Func, 0xC);
break;
case kVectorKPIN:
case kVectorNORM:
ParseVectorFunction(rFile);
break;
case kFuncNONE:
case kVectorPAP1:
case kVectorPAP2:
case kVectorPAP3:
case kVectorPENV:
case kVectorPETR:
case kVectorPEVL:
case kVectorPINV:
case kVectorPITR:
case kVectorPIVL:
case kVectorPLCO:
case kVectorPLOC:
case kVectorPNCV:
case kVectorPSOF:
case kVectorPSOU:
case kVectorPSOR:
@ -769,6 +1007,7 @@ void CUnsupportedParticleLoader::ParseVectorFunction(IInputStream& rFile)
ParseVectorFunction(rFile);
break;
case kVectorRNDV:
case kVectorRTOV:
ParseFloatFunction(rFile);
break;
@ -798,6 +1037,12 @@ void CUnsupportedParticleLoader::ParseModVectorFunction(IInputStream& rFile)
ParseBoolFunction(rFile);
break;
case kModVectorBOXV:
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
ParseModVectorFunction(rFile);
break;
case kModVectorCHAN:
ParseModVectorFunction(rFile);
ParseModVectorFunction(rFile);
@ -837,6 +1082,12 @@ void CUnsupportedParticleLoader::ParseModVectorFunction(IInputStream& rFile)
ParseFloatFunction(rFile);
break;
case kModVectorSPHV:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseModVectorFunction(rFile);
break;
case kModVectorSWRL:
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
@ -889,9 +1140,25 @@ void CUnsupportedParticleLoader::ParseColorFunction(IInputStream& rFile)
ParseFloatFunction(rFile);
break;
case kColorISWT:
case kColorMULT:
ParseColorFunction(rFile);
ParseColorFunction(rFile);
break;
case kColorKEYE:
case kColorKEYF:
case kColorKEYP:
ParseKeyframeEmitterData(rFile, 0x10);
ParseKeyframeEmitterData(rFile, Func, 0x10);
break;
case kColorKPIN:
ParseColorFunction(rFile);
break;
case kColorMDAO:
ParseColorFunction(rFile);
ParseFloatFunction(rFile);
break;
case kFuncNONE:
@ -905,6 +1172,11 @@ void CUnsupportedParticleLoader::ParseColorFunction(IInputStream& rFile)
ParseColorFunction(rFile);
break;
case kColorVRTC:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
break;
default:
Log::FileError(rFile.GetSourceString(), FuncOffset, "Unknown color function: " + Func.ToString());
DEBUG_BREAK;
@ -953,9 +1225,31 @@ void CUnsupportedParticleLoader::ParseEmitterFunction(IInputStream& rFile)
case kFuncNONE:
break;
case kEmitterSETR:
ParseParticleParameter(rFile);
ParseParticleParameter(rFile);
case kEmitterASPH:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
break;
case kEmitterELPS:
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseBoolFunction(rFile);
break;
case kEmitterPLNE:
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
break;
case kEmitterSEMR:
@ -963,20 +1257,15 @@ void CUnsupportedParticleLoader::ParseEmitterFunction(IInputStream& rFile)
ParseVectorFunction(rFile);
break;
case kEmitterSPHE:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
case kEmitterSETR:
ParseParticleParameter(rFile);
ParseParticleParameter(rFile);
break;
case kEmitterASPH:
case kEmitterSPHE:
ParseVectorFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
ParseFloatFunction(rFile);
break;
default:
@ -1029,17 +1318,27 @@ void CUnsupportedParticleLoader::ParseSpawnSystemKeyframeData(IInputStream& rFil
}
}
void CUnsupportedParticleLoader::ParseKeyframeEmitterData(IInputStream& rFile, u32 ElemSize)
void CUnsupportedParticleLoader::ParseKeyframeEmitterData(IInputStream& rFile, const CFourCC& rkFunc, u32 ElemSize)
{
rFile.Seek(0x12, SEEK_CUR); // Skip unneeded values
// Skip unneeded values
if (rkFunc == "KEYE" || rkFunc == "KEYP")
rFile.Seek(0x12, SEEK_CUR);
else if (rkFunc == "KEYF")
rFile.Seek(0x1A, SEEK_CUR);
u32 KeyCount = rFile.ReadLong();
rFile.Seek(KeyCount * ElemSize, SEEK_CUR);
if (rkFunc == "KEYF")
ParseFloatFunction(rFile);
}
// ************ STATIC ************
enum {
kGPSM = FOURCC_CONSTEXPR('G', 'P', 'S', 'M'),
kELSM = FOURCC_CONSTEXPR('E', 'L', 'S', 'M'),
kSRSM = FOURCC_CONSTEXPR('S', 'R', 'S', 'M'),
kSPSM = FOURCC_CONSTEXPR('S', 'P', 'S', 'M'),
kSWSH = FOURCC_CONSTEXPR('S', 'W', 'S', 'H'),
kDPSM = FOURCC_CONSTEXPR('D', 'P', 'S', 'M'),
kWPSM = FOURCC_CONSTEXPR('W', 'P', 'S', 'M'),
@ -1062,6 +1361,8 @@ CDependencyGroup* CUnsupportedParticleLoader::LoadParticle(IInputStream& rFile,
{
case kGPSM: ShouldContinue = Loader.ParseParticleParameter(rFile); break;
case kELSM: ShouldContinue = Loader.ParseElectricParameter(rFile); break;
case kSRSM: ShouldContinue = Loader.ParseSortedParameter(rFile); break;
case kSPSM: ShouldContinue = Loader.ParseSpawnParameter(rFile); break;
case kSWSH: ShouldContinue = Loader.ParseSwooshParameter(rFile); break;
case kDPSM: ShouldContinue = Loader.ParseDecalParameter(rFile); break;
case kWPSM: ShouldContinue = Loader.ParseWeaponParameter(rFile); break;

5
src/Core/Resource/Factory/CUnsupportedParticleLoader.h
View File

@ -14,6 +14,8 @@ class CUnsupportedParticleLoader
// Format-Specific Parameter Loading
bool ParseParticleParameter(IInputStream& rPART);
bool ParseElectricParameter(IInputStream& rELSC);
bool ParseSortedParameter(IInputStream& rSRSC);
bool ParseSpawnParameter(IInputStream& rSPSC);
bool ParseSwooshParameter(IInputStream& rSWHC);
bool ParseDecalParameter(IInputStream& rDPSC);
bool ParseWeaponParameter(IInputStream& rWPSC);
@ -21,6 +23,7 @@ class CUnsupportedParticleLoader
// Function Loading
void ParseBoolFunction(IInputStream& rFile);
void ParseBitfieldFunction(IInputStream& rFile);
void ParseIntFunction(IInputStream& rFile);
void ParseFloatFunction(IInputStream& rFile);
void ParseVectorFunction(IInputStream& rFile);
@ -30,7 +33,7 @@ class CUnsupportedParticleLoader
void ParseEmitterFunction(IInputStream& rFile);
void ParseAssetFunction(IInputStream& rFile);
void ParseSpawnSystemKeyframeData(IInputStream& rFile);
void ParseKeyframeEmitterData(IInputStream& rFile, u32 ElemSize);
void ParseKeyframeEmitterData(IInputStream& rFile, const CFourCC& rkFunc, u32 ElemSize);
public:
static CDependencyGroup* LoadParticle(IInputStream& rPART, CResourceEntry *pEntry);

155
src/Core/Resource/ParticleParameters.h
View File

@ -24,23 +24,28 @@ PARAM(Gen, ADV5, 'A','D','V','5') // Float
PARAM(Gen, ADV6, 'A','D','V','6') // Float
PARAM(Gen, ADV7, 'A','D','V','7') // Float
PARAM(Gen, ADV8, 'A','D','V','8') // Float
PARAM(Gen, ADV9, 'A','D','V','9') // Float
PARAM(Gen, CIND, 'C', 'I', 'N', 'D') // Bool
PARAM(Gen, COLR, 'C', 'O', 'L', 'R') // Color
PARAM(Gen, CSSD, 'C', 'S', 'S', 'D') // Int
PARAM(Gen, DFLG, 'D', 'F', 'L', 'G') // Bitfield
PARAM(Gen, EMTR, 'E', 'M', 'T', 'R') // Emitter
PARAM(Gen, FXBO, 'F', 'X', 'B', 'O') // Vector
PARAM(Gen, FXBR, 'F', 'X', 'B', 'R') // Float
PARAM(Gen, FXLL, 'F', 'X', 'L', 'L') // Bool
PARAM(Gen, GRTE, 'G', 'R', 'T', 'E') // Float
PARAM(Gen, ICTS, 'I', 'C', 'T', 'S') // Asset (PART)
PARAM(Gen, IDTS, 'I', 'D', 'T', 'S') // Asset (PART)
PARAM(Gen, IITS, 'I', 'I', 'T', 'S') // Asset (PART)
PARAM(Gen, ILOC, 'I', 'L', 'O', 'C') // Vector
PARAM(Gen, INDM, 'I', 'N', 'D', 'M') // Bool
PARAM(Gen, IVEC, 'I', 'V', 'E', 'C') // Vector
PARAM(Gen, KSSM, 'K', 'S', 'S', 'M') // SpawnSystemKeyframeData
PARAM(Gen, LCLR, 'L', 'C', 'L', 'R') // Color
PARAM(Gen, LDIR, 'L', 'D', 'I', 'R') // Vector
PARAM(Gen, LENG, 'L', 'E', 'N', 'G') // Float
PARAM(Gen, LFOT, 'L', 'F', 'O', 'T') // Int
PARAM(Gen, LFOR, 'L', 'F', 'O', 'R') // Float
PARAM(Gen, LFOT, 'L', 'F', 'O', 'T') // Int
PARAM(Gen, LINE, 'L', 'I', 'N', 'E') // Bool
PARAM(Gen, LINT, 'L', 'I', 'N', 'T') // Float
PARAM(Gen, LIT_, 'L', 'I', 'T', '_') // Bool
@ -57,10 +62,11 @@ PARAM(Gen, OPTS, 'O', 'P', 'T', 'S') // Bool
PARAM(Gen, ORNT, 'O', 'R', 'N', 'T') // Bool
PARAM(Gen, PISY, 'P', 'I', 'S', 'Y') // Int
PARAM(Gen, PMAB, 'P', 'M', 'A', 'B') // Bool
PARAM(Gen, PMCL, 'P', 'M', 'C', 'L') // Color
PARAM(Gen, PMDL, 'P', 'M', 'D', 'L') // Asset (CMDL)
PARAM(Gen, PMOO, 'P', 'M', 'O', 'O') // Bool
PARAM(Gen, PMCL, 'P', 'M', 'C', 'L') // Color
PARAM(Gen, PMOP, 'P', 'M', 'O', 'P') // Vector
PARAM(Gen, PMOV, 'P', 'M', 'O', 'V') // Vector
PARAM(Gen, PMRT, 'P', 'M', 'R', 'T') // Vector
PARAM(Gen, PMSC, 'P', 'M', 'S', 'C') // Vector
PARAM(Gen, PMUS, 'P', 'M', 'U', 'S') // Bool
@ -69,8 +75,9 @@ PARAM(Gen, PSIV, 'P', 'S', 'I', 'V') // Int
PARAM(Gen, PSLT, 'P', 'S', 'L', 'T') // Int
PARAM(Gen, PSOV, 'P', 'S', 'O', 'V') // Vector
PARAM(Gen, PSTS, 'P', 'S', 'T', 'S') // Float
PARAM(Gen, PSWT, 'P', 'S', 'W', 'T') // Int
PARAM(Gen, PSVM, 'P', 'S', 'V', 'M') // Mod Vector
PARAM(Gen, PSWT, 'P', 'S', 'W', 'T') // Int
PARAM(Gen, RDOP, 'R', 'D', 'O', 'P') // Bool
PARAM(Gen, ROTA, 'R', 'O', 'T', 'A') // Float
PARAM(Gen, RSOP, 'R', 'S', 'O', 'P') // Bool
PARAM(Gen, SEED, 'S', 'E', 'E', 'D') // Int
@ -85,6 +92,9 @@ PARAM(Gen, SSSD, 'S', 'S', 'S', 'D') // Int
PARAM(Gen, SSWH, 'S', 'S', 'W', 'H') // Asset (SWHC)
PARAM(Gen, TEXR, 'T', 'E', 'X', 'R') // UV
PARAM(Gen, TIND, 'T', 'I', 'N', 'D') // UV
PARAM(Gen, VAV1, 'V', 'A', 'V', '1') // Vector
PARAM(Gen, VAV2, 'V', 'A', 'V', '2') // Vector
PARAM(Gen, VAV3, 'V', 'A', 'V', '3') // Vector
PARAM(Gen, VEL1, 'V', 'E', 'L', '1') // Mod Vector
PARAM(Gen, VEL2, 'V', 'E', 'L', '2') // Mod Vector
PARAM(Gen, VEL3, 'V', 'E', 'L', '3') // Mod Vector
@ -93,12 +103,15 @@ PARAM(Gen, VMD1, 'V', 'M', 'D', '1') // Bool
PARAM(Gen, VMD2, 'V', 'M', 'D', '2') // Bool
PARAM(Gen, VMD3, 'V', 'M', 'D', '3') // Bool
PARAM(Gen, VMD4, 'V', 'M', 'D', '4') // Bool
PARAM(Gen, VMPC, 'V', 'M', 'P', 'C') // Bool
PARAM(Gen, WIDT, 'W', 'I', 'D', 'T') // Float
PARAM(Gen, XTAD, 'X', 'T', 'A', 'D') // Int
PARAM(Gen, ZBUF, 'Z', 'B', 'U', 'F') // Bool
// Parameters (ELSC)
PARAM(Elec, AMPD, 'A', 'M', 'P', 'D') // Float
PARAM(Elec, AMPL, 'A', 'M', 'P', 'L') // Bool
PARAM(Elec, COLR, 'C', 'O', 'L', 'R') // Color
PARAM(Elec, DFLG, 'D', 'F', 'L', 'G') // Bitfield
PARAM(Elec, EPSM, 'E', 'P', 'S', 'M') // Asset (PART)
PARAM(Elec, FEMT, 'F', 'E', 'M', 'T') // Emitter
PARAM(Elec, GPSM, 'G', 'P', 'S', 'M') // Asset (PART)
@ -115,12 +128,39 @@ PARAM(Elec, SCNT, 'S', 'C', 'N', 'T') // Int
PARAM(Elec, SLIF, 'S', 'L', 'I', 'F') // Int
PARAM(Elec, SSEG, 'S', 'S', 'E', 'G') // Int
PARAM(Elec, SSWH, 'S', 'S', 'W', 'H') // Asset (SWHC)
PARAM(Elec, TEXR, 'T', 'E', 'X', 'R') // UV
PARAM(Elec, ZERY, 'Z', 'E', 'R', 'Y') // Bool
// Parameters (SRSC)
PARAM(Sorted, SPWN, 'S', 'P', 'W', 'N') // SpawnSystemKeyframeData
// Parameters (SPSC)
PARAM(Spawn, DEOL, 'D', 'E', 'O', 'L') // Bool
PARAM(Spawn, FRCO, 'F', 'R', 'C', 'O') // Bool
PARAM(Spawn, FROV, 'F', 'R', 'O', 'V') // Vector
PARAM(Spawn, GIVL, 'G', 'I', 'V', 'L') // Int
PARAM(Spawn, GORN, 'G', 'O', 'R', 'N') // Vector
PARAM(Spawn, GTRN, 'G', 'T', 'R', 'N') // Vector
PARAM(Spawn, IGGT, 'I', 'G', 'G', 'T') // Bool
PARAM(Spawn, IGLT, 'I', 'G', 'L', 'T') // Bool
PARAM(Spawn, IVEC, 'I', 'V', 'E', 'C') // Vector
PARAM(Spawn, LSCL, 'L', 'S', 'C', 'L') // Vector
PARAM(Spawn, ORNT, 'O', 'R', 'N', 'T') // Vector
PARAM(Spawn, PCOL, 'P', 'C', 'O', 'L') // Color
PARAM(Spawn, PSLT, 'P', 'S', 'L', 'T') // Int
PARAM(Spawn, SCLE, 'S', 'C', 'L', 'E') // Vector
PARAM(Spawn, SPWN, 'S', 'P', 'W', 'N') // SpawnSystemKeyframeData
PARAM(Spawn, TRNL, 'T', 'R', 'N', 'L') // Vector
PARAM(Spawn, VBLN, 'V', 'B', 'L', 'N') // Float
PARAM(Spawn, VLM1, 'V', 'L', 'M', '1') // ModVector
PARAM(Spawn, VLM2, 'V', 'L', 'M', '2') // ModVector
PARAM(Spawn, VMD1, 'V', 'M', 'D', '1') // Bool
PARAM(Spawn, VMD2, 'V', 'M', 'D', '2') // Bool
// Parameters (SWHC)
PARAM(Swoosh, AALP, 'A', 'A', 'L', 'P') // Bool
PARAM(Swoosh, COLR, 'C', 'O', 'L', 'R') // Color
PARAM(Swoosh, CLTX, 'C', 'L', 'T', 'X') // Bool
PARAM(Swoosh, CRND, 'C', 'R', 'N', 'D') // Bool
PARAM(Swoosh, CROS, 'C', 'R', 'O', 'S') // Bool
PARAM(Swoosh, DFLG, 'D', 'F', 'L', 'G') // Bitfield
PARAM(Swoosh, IROT, 'I', 'R', 'O', 'T') // Float
PARAM(Swoosh, IVEL, 'I', 'V', 'E', 'L') // Vector
PARAM(Swoosh, LENG, 'L', 'E', 'N', 'G') // Int
@ -162,12 +202,12 @@ PARAM(Decal, 1LFT, '1', 'L', 'F', 'T') // Int
PARAM(Decal, 2LFT, '2', 'L', 'F', 'T') // Int
PARAM(Decal, DLFT, 'D', 'L', 'F', 'T') // Int
PARAM(Decal, DMAB, 'D', 'M', 'A', 'B') // Bool
PARAM(Decal, DMCL, 'D', 'M', 'C', 'L') // Bool
PARAM(Decal, DMDL, 'D', 'M', 'D', 'L') // Bool
PARAM(Decal, DMCL, 'D', 'M', 'C', 'L') // Color
PARAM(Decal, DMDL, 'D', 'M', 'D', 'L') // Asset (CMDL)
PARAM(Decal, DMOO, 'D', 'M', 'O', 'O') // Bool
PARAM(Decal, DMOP, 'D', 'M', 'O', 'P') // Bool
PARAM(Decal, DMRT, 'D', 'M', 'R', 'T') // Bool
PARAM(Decal, DMSC, 'D', 'M', 'S', 'C') // Bool
PARAM(Decal, DMOP, 'D', 'M', 'O', 'P') // Vector
PARAM(Decal, DMRT, 'D', 'M', 'R', 'T') // Vector
PARAM(Decal, DMSC, 'D', 'M', 'S', 'C') // Vector
// Parameters (WPSC)
PARAM(Weapon, APSM, 'A', 'P', 'S', 'M') // Asset (PART)
PARAM(Weapon, APSO, 'A', 'P', 'S', 'O') // Bool
@ -181,13 +221,30 @@ PARAM(Weapon, ASW2, 'A', 'S', 'W', '2') // Asset (SWHC)
PARAM(Weapon, AS12, 'A', 'S', '1', '2') // Bool
PARAM(Weapon, ASW3, 'A', 'S', 'W', '3') // Asset (SWHC)
PARAM(Weapon, AS13, 'A', 'S', '1', '3') // Bool
PARAM(Weapon, B1CL, 'B', '1', 'C', 'L') // Color
PARAM(Weapon, B1PO, 'B', '1', 'P', 'O') // Vector
PARAM(Weapon, B1RT, 'B', '1', 'R', 'T') // Float
PARAM(Weapon, B1SE, 'B', '1', 'S', 'E') // Float
PARAM(Weapon, B1TX, 'B', '1', 'T', 'X') // UV
PARAM(Weapon, B2CL, 'B', '2', 'C', 'L') // Color
PARAM(Weapon, B2PO, 'B', '2', 'P', 'O') // Vector
PARAM(Weapon, B2RT, 'B', '2', 'R', 'T') // Float
PARAM(Weapon, B2SE, 'B', '2', 'S', 'E') // Float
PARAM(Weapon, B2TX, 'B', '2', 'T', 'X') // UV
PARAM(Weapon, BHBT, 'B', 'H', 'B', 'T') // Bool
PARAM(Weapon, COLR, 'C', 'O', 'L', 'R') // Asset (CRSC)
PARAM(Weapon, DP1C, 'D', 'P', '1', 'C') // Bool
PARAM(Weapon, DP2C, 'D', 'P', '2', 'C') // Bool
PARAM(Weapon, EELT, 'E', 'E', 'L', 'T') // Bool
PARAM(Weapon, EWTR, 'E', 'W', 'T', 'R') // Bool
PARAM(Weapon, F60H, 'F', '6', '0', 'H') // Bool
PARAM(Weapon, FC60, 'F', 'C', '6', '0') // Bool
PARAM(Weapon, FOFF, 'F', 'O', 'F', 'F') // Float
PARAM(Weapon, HOMG, 'H', 'O', 'M', 'G') // Bool
PARAM(Weapon, IORN, 'I', 'O', 'R', 'N') // Vector
PARAM(Weapon, IVEC, 'I', 'V', 'E', 'C') // Vector
PARAM(Weapon, LWTR, 'L', 'W', 'T', 'R') // Bool
PARAM(Weapon, NDTT, 'N', 'D', 'T', 'T') // Bool
PARAM(Weapon, OFST, 'O', 'F', 'S', 'T') // Vector
PARAM(Weapon, OHEF, 'O', 'H', 'E', 'F') // Asset (CMDL)
PARAM(Weapon, PCOL, 'P', 'C', 'O', 'L') // Color
@ -197,11 +254,22 @@ PARAM(Weapon, PSCL, 'P', 'S', 'C', 'L') // Vector
PARAM(Weapon, PSLT, 'P', 'S', 'L', 'T') // Int
PARAM(Weapon, PSOV, 'P', 'S', 'O', 'V') // Float
PARAM(Weapon, PSVM, 'P', 'S', 'V', 'M') // Vector
PARAM(Weapon, RB1A, 'R', 'B', '1', 'A') // Bool
PARAM(Weapon, RB2A, 'R', 'B', '2', 'A') // Boo
PARAM(Weapon, RNGE, 'R', 'N', 'G', 'E') // Float
PARAM(Weapon, RTLA, 'R', 'T', 'L', 'A') // Bool
PARAM(Weapon, RWPE, 'R', 'W', 'P', 'E') // Bool
PARAM(Weapon, SPS1, 'S', 'P', 'S', '1') // Bool
PARAM(Weapon, SPS2, 'S', 'P', 'S', '2') // Bool
PARAM(Weapon, SVBD, 'S', 'V', 'B', 'D') // Bool
PARAM(Weapon, SWTR, 'S', 'W', 'T', 'R') // Bool
PARAM(Weapon, TECL, 'T', 'E', 'C', 'L') // Color
PARAM(Weapon, TLEN, 'T', 'L', 'E', 'N') // Float
PARAM(Weapon, TLPO, 'T', 'L', 'P', 'O') // Vector
PARAM(Weapon, TRAT, 'T', 'R', 'A', 'T') // Float
PARAM(Weapon, TSCL, 'T', 'S', 'C', 'L') // Color
PARAM(Weapon, TSZE, 'T', 'S', 'Z', 'E') // Float
PARAM(Weapon, TTEX, 'T', 'T', 'E', 'X') // UV
PARAM(Weapon, VMD2, 'V', 'M', 'D', '2') // Bool
// Parameters (CRSC)
PARAM(Coli, 1ATA, '1', 'A', 'T', 'A') // Int
@ -224,12 +292,20 @@ PARAM(Coli, 3DRN, '3', 'D', 'R', 'N') // Int
PARAM(Coli, 4DRN, '4', 'D', 'R', 'N') // Int
PARAM(Coli, 5DRN, '5', 'D', 'R', 'N') // Int
PARAM(Coli, 6DRN, '6', 'D', 'R', 'N') // Int
PARAM(Coli, 6GRN, '6', 'G', 'R', 'N') // Int
PARAM(Coli, 1LAV, '1', 'L', 'A', 'V') // Asset (PART)
PARAM(Coli, 3LAV, '3', 'L', 'A', 'V') // Asset (DPSC)
PARAM(Coli, 1MUD, '1', 'M', 'U', 'D') // Asset (PART)
PARAM(Coli, 2MUD, '2', 'M', 'U', 'D') // Int
PARAM(Coli, 3MUD, '3', 'M', 'U', 'D') // Asset (DPSC)
PARAM(Coli, 1SAN, '1', 'S', 'A', 'N') // Asset (PART)
PARAM(Coli, 2SAN, '2', 'S', 'A', 'N') // Int
PARAM(Coli, 3SAN, '3', 'S', 'A', 'N') // Asset (DPSC)
PARAM(Coli, BHFX, 'B', 'H', 'F', 'X') // Int
PARAM(Coli, CHDL, 'C', 'H', 'D', 'L') // Asset (DPSC)
PARAM(Coli, CHFX, 'C', 'H', 'F', 'X') // Int
PARAM(Coli, CODL, 'C', 'O', 'D', 'L') // Asset (DPSC)
PARAM(Coli, CRTS, 'C', 'R', 'T', 'S') // Asset (PART)
PARAM(Coli, CSFX, 'C', 'S', 'F', 'X') // Int
PARAM(Coli, CZFX, 'C', 'Z', 'F', 'X') // Int
PARAM(Coli, DCHR, 'D', 'C', 'H', 'R') // Asset (PART)
@ -244,16 +320,17 @@ PARAM(Coli, ENDL, 'E', 'N', 'D', 'L') // Asset (DPSC)
PARAM(Coli, FOFF, 'F', 'O', 'F', 'F') // Float
PARAM(Coli, GODL, 'G', 'O', 'D', 'L') // Asset (DPSC)
PARAM(Coli, GOFX, 'G', 'O', 'F', 'X') // Int
PARAM(Coli, GOOO, 'G', 'O', 'O', 'O') // Int
PARAM(Coli, GRAS, 'G', 'R', 'A', 'S') // Int
PARAM(Coli, GOOO, 'G', 'O', 'O', 'O') // Asset (PART)
PARAM(Coli, GRAS, 'G', 'R', 'A', 'S') // Asset (PART)
PARAM(Coli, GRDL, 'G', 'R', 'D', 'L') // Asset (DPSC)
PARAM(Coli, GRFX, 'G', 'R', 'F', 'X') // Int
PARAM(Coli, HBFX, 'H', 'B', 'F', 'X') // Int
PARAM(Coli, ICDL, 'I', 'C', 'D', 'L') // Asset (DPSC)
PARAM(Coli, ICEE, 'I', 'C', 'E', 'E') // Int
PARAM(Coli, ICFX, 'I', 'C', 'F', 'X') // Int
PARAM(Coli, ICFX, 'I', 'C', 'F', 'X') // Asset (PART)
PARAM(Coli, MEDL, 'M', 'E', 'D', 'L') // Asset (DPSC)
PARAM(Coli, MSFX, 'M', 'S', 'F', 'X') // Int
PARAM(Coli, MTLS, 'M', 'T', 'L', 'S') // Asset (PART)
PARAM(Coli, PBOS, 'P', 'B', 'O', 'S') // Int
PARAM(Coli, PBHX, 'P', 'B', 'H', 'X') // Int
PARAM(Coli, PBSX, 'P', 'B', 'S', 'X') // Int
@ -262,7 +339,9 @@ PARAM(Coli, SHFX, 'S', 'H', 'F', 'X') // Int
PARAM(Coli, TAFX, 'T', 'A', 'F', 'X') // Int
PARAM(Coli, TALP, 'T', 'A', 'L', 'P') // Asset (PART)
PARAM(Coli, TASP, 'T', 'A', 'S', 'P') // Int
PARAM(Coli, WATR, 'W', 'A', 'T', 'R') // Asset (PART)
PARAM(Coli, WODL, 'W', 'O', 'D', 'L') // Asset (DPSC)
PARAM(Coli, WODS, 'W', 'O', 'D', 'S') // Asset (PART)
PARAM(Coli, WSFX, 'W', 'S', 'F', 'X') // Int
PARAM(Coli, WTDL, 'W', 'T', 'D', 'L') // Asset (DPSC)
PARAM(Coli, WTFX, 'W', 'T', 'F', 'X') // Int
@ -281,24 +360,33 @@ FUNCS_BEGIN
FUNC(Func, NONE, 'N', 'O', 'N', 'E')
// Bool Functions
FUNC(Bool, CNST, 'C','N','S','T') // Bool
// Bitfield Functions
FUNC(Bitfield, BITF, 'B', 'I', 'T', 'F') // Bitfield
// Int Functions
FUNC(Int, ADD_, 'A', 'D', 'D', '_') // Int, Int
FUNC(Int, CHAN, 'C', 'H', 'A', 'N') // Int, Int, Int
FUNC(Int, CLMP, 'C', 'L', 'M', 'P') // Int, Int, Int
FUNC(Int, CNST, 'C', 'N', 'S', 'T') // Int
FUNC(Int, DETH, 'D', 'E', 'T', 'H') // Int, Int
FUNC(Int, DIVD, 'D', 'I', 'V', 'D') // Int, Int
FUNC(Int, GAPC, 'G', 'A', 'P', 'C') // N/A
FUNC(Int, GEMT, 'G', 'E', 'M', 'T') // N/A
FUNC(Int, GTCP, 'G', 'T', 'C', 'P') // N/A
FUNC(Int, ILPT, 'I', 'L', 'P', 'T') // Int
FUNC(Int, IMPL, 'I', 'M', 'P', 'L') // Int
FUNC(Int, IRND, 'I', 'R', 'N', 'D') // Int, Int
FUNC(Int, ISWT, 'I', 'S', 'W', 'T') // Int, Int
FUNC(Int, KEYE, 'K', 'E', 'Y', 'E') // KeyframeEmitterData
FUNC(Int, KEYF, 'K', 'E', 'Y', 'F') // KeyframeEmitterData
FUNC(Int, KEYP, 'K', 'E', 'Y', 'P') // KeyframeEmitterData
FUNC(Int, KPIN, 'K', 'P', 'I', 'N') // Int
FUNC(Int, MODU, 'M', 'O', 'D', 'U') // Int, Int
FUNC(Int, MULT, 'M', 'U', 'L', 'T') // Int, Int
FUNC(Int, PCRT, 'P', 'C', 'R', 'T') // N/A
FUNC(Int, PDET, 'P', 'D', 'E', 'T') // N/A
FUNC(Int, PULS, 'P', 'U', 'L', 'S') // Int, Int, Int, Int
FUNC(Int, RAND, 'R', 'A', 'N', 'D') // Int, Int
FUNC(Int, RTOI, 'R', 'T', 'O', 'I') // Float, Float
FUNC(Int, SPAH, 'S', 'P', 'A', 'H') // Int, Int, Int
FUNC(Int, SUB_, 'S', 'U', 'B', '_') // Int, Int
FUNC(Int, TSCL, 'T', 'S', 'C', 'L') // Float
@ -316,13 +404,17 @@ FUNC(Float, GTCR, 'G', 'T', 'C', 'R') // Color
FUNC(Float, GTCG, 'G', 'T', 'C', 'G') // Color
FUNC(Float, GTCB, 'G', 'T', 'C', 'B') // Color
FUNC(Float, GTCA, 'G', 'T', 'C', 'A') // Color
FUNC(Float, GTCP, 'G', 'T', 'C', 'P') // N/A
FUNC(Float, IRND, 'I', 'R', 'N', 'D') // Float, Float
FUNC(Float, ISWT, 'I', 'S', 'W', 'T') // Float, Float
FUNC(Float, ITRL, 'I', 'T', 'R', 'L') // Int, Float
FUNC(Float, KEYE, 'K', 'E', 'Y', 'E') // KeyframeEmitterData
FUNC(Float, KEYF, 'K', 'E', 'Y', 'F') // KeyframeEmitterData
FUNC(Float, KEYP, 'K', 'E', 'Y', 'P') // KeyframeEmitterData
FUNC(Float, KPIN, 'K', 'P', 'I', 'N') // Float
FUNC(Float, LFTW, 'L', 'F', 'T', 'W') // Float, Float
FUNC(Float, MULT, 'M', 'U', 'L', 'T') // Float, Float
FUNC(Float, OCSP, 'O', 'C', 'S', 'P') // Int
FUNC(Float, PAP1, 'P', 'A', 'P', '1') // N/A
FUNC(Float, PAP2, 'P', 'A', 'P', '2') // N/A
FUNC(Float, PAP3, 'P', 'A', 'P', '3') // N/A
@ -331,6 +423,15 @@ FUNC(Float, PAP5, 'P', 'A', 'P', '5') // N/A
FUNC(Float, PAP6, 'P', 'A', 'P', '6') // N/A
FUNC(Float, PAP7, 'P', 'A', 'P', '7') // N/A
FUNC(Float, PAP8, 'P', 'A', 'P', '8') // N/A
FUNC(Float, PAP9, 'P', 'A', 'P', '9') // N/A
FUNC(Float, PNO1, 'P', 'N', 'O', '1') // Float, Float, Float, Int
FUNC(Float, PNO2, 'P', 'N', 'O', '2') // Float, Float, Float, Float, Int
FUNC(Float, PNO3, 'P', 'N', 'O', '3') // Vector, Float, Float, Int
FUNC(Float, PNO4, 'P', 'N', 'O', '4') // Vector, Float, Float, Float, Int
FUNC(Float, PRN1, 'P', 'R', 'N', '1') // Float
FUNC(Float, PRN2, 'P', 'R', 'N', '2') // Float, Float
FUNC(Float, PRN3, 'P', 'R', 'N', '3') // Vector
FUNC(Float, PRN4, 'P', 'R', 'N', '4') // Vector, Float
FUNC(Float, PRLW, 'P', 'R', 'L', 'W') // N/A
FUNC(Float, PSLL, 'P', 'S', 'L', 'L') // N/A
FUNC(Float, PULS, 'P', 'U', 'L', 'S') // Int, Int, Float, Float
@ -339,6 +440,7 @@ FUNC(Float, RLPT, 'R', 'L', 'P', 'T') // Float
FUNC(Float, SCAL, 'S', 'C', 'A', 'L') // Float
FUNC(Float, SINE, 'S', 'I', 'N', 'E') // Float, Float, Float
FUNC(Float, SUB_, 'S', 'U', 'B', '_') // Float, Float
FUNC(Float, TOCS, 'T', 'O', 'C', 'S') // Bool, Int, Int, Int
FUNC(Float, VMAG, 'V', 'M', 'A', 'G') // Vector
FUNC(Float, VXTR, 'V', 'X', 'T', 'R') // Vector
FUNC(Float, VYTR, 'V', 'Y', 'T', 'R') // Vector
@ -352,9 +454,23 @@ FUNC(Vector, CIRC, 'C', 'I', 'R', 'C') // Vector, Vector, Float, Float, Float
FUNC(Vector, CNST, 'C', 'N', 'S', 'T') // Float, Float, Float
FUNC(Vector, CONE, 'C', 'O', 'N', 'E') // Vector, Float
FUNC(Vector, CTVC, 'C', 'T', 'V', 'C') // Color
FUNC(Vector, ISWT, 'I', 'S', 'W', 'T') // Vector, Vector
FUNC(Vector, KEYE, 'K', 'E', 'Y', 'E') // KeyframeEmitterData
FUNC(Vector, KEYF, 'K', 'E', 'Y', 'F') // KeyframeEmitterData
FUNC(Vector, KEYP, 'K', 'E', 'Y', 'P') // KeyframeEmitterData
FUNC(Vector, KPIN, 'K', 'P', 'I', 'N') // Vector
FUNC(Vector, MULT, 'M', 'U', 'L', 'T') // Vector, Vector
FUNC(Vector, NORM, 'N', 'O', 'R', 'M') // Vector
FUNC(Vector, PAP1, 'P', 'A', 'P', '1') // N/A
FUNC(Vector, PAP2, 'P', 'A', 'P', '2') // N/A
FUNC(Vector, PAP3, 'P', 'A', 'P', '3') // N/A
FUNC(Vector, PENV, 'P', 'E', 'N', 'V') // N/A
FUNC(Vector, PETR, 'P', 'E', 'T', 'R') // N/A
FUNC(Vector, PEVL, 'P', 'E', 'V', 'L') // N/A
FUNC(Vector, PINV, 'P', 'I', 'N', 'V') // N/A
FUNC(Vector, PITR, 'P', 'I', 'T', 'R') // N/A
FUNC(Vector, PIVL, 'P', 'I', 'V', 'L') // N/A
FUNC(Vector, PNCV, 'P', 'N', 'C', 'V') // N/A
FUNC(Vector, PLCO, 'P', 'L', 'C', 'O') // N/A
FUNC(Vector, PLOC, 'P', 'L', 'O', 'C') // N/A
FUNC(Vector, PSOF, 'P', 'S', 'O', 'F') // N/A
@ -363,10 +479,12 @@ FUNC(Vector, PSOR, 'P', 'S', 'O', 'R') // N/A
FUNC(Vector, PSTR, 'P', 'S', 'T', 'R') // N/A
FUNC(Vector, PULS, 'P', 'U', 'L', 'S') // Int, Int, Vector, Vector
FUNC(Vector, PVEL, 'P', 'V', 'E', 'L') // N/A
FUNC(Vector, RNDV, 'R', 'N', 'D', 'V') // Float
FUNC(Vector, RTOV, 'R', 'T', 'O', 'V') // Float
FUNC(Vector, SUB_, 'S', 'U', 'B', '_') // Vector, Vector
// Mod Vector Functions
FUNC(ModVector, BNCE, 'B', 'N', 'C', 'E') // Vector, Vector, Float, Float, Bool
FUNC(ModVector, BOXV, 'B', 'O', 'X', 'V') // Vector, Vector, ModVector
FUNC(ModVector, CHAN, 'C', 'H', 'A', 'N') // ModVector, ModVector, Int
FUNC(ModVector, CNST, 'C', 'N', 'S', 'T') // Float, Float, Float
FUNC(ModVector, EMPL, 'E', 'M', 'P', 'L') // Vector, Float, Float, Float, Bool
@ -375,6 +493,7 @@ FUNC(ModVector, GRAV, 'G', 'R', 'A', 'V') // Vector
FUNC(ModVector, IMPL, 'I', 'M', 'P', 'L') // Vector, Float, Float, Float, Bool
FUNC(ModVector, LMPL, 'L', 'M', 'P', 'L') // Vector, Float, Float, Float, Bool
FUNC(ModVector, PULS, 'P', 'U', 'L', 'S') // Int, Int, ModVector, ModVector
FUNC(ModVector, SPHV, 'S', 'P', 'H', 'V') // Vector, Float, ModVector
FUNC(ModVector, SPOS, 'S', 'P', 'O', 'S') // Vector
FUNC(ModVector, SWRL, 'S', 'W', 'R', 'L') // Vector, Vector, Float, Float
FUNC(ModVector, WIND, 'W', 'I', 'N', 'D') // Vector, Float
@ -383,20 +502,28 @@ FUNC(Color, CFDE, 'C', 'F', 'D', 'E') // Color, Color, Float, Float
FUNC(Color, CHAN, 'C', 'H', 'A', 'N') // Color, Color, Int
FUNC(Color, CNST, 'C', 'N', 'S', 'T') // Float, Float, Float, Float
FUNC(Color, FADE, 'F', 'A', 'D', 'E') // Color, Color, Float
FUNC(Color, ISWT, 'I', 'S', 'W', 'T') // Color, Color
FUNC(Color, KEYE, 'K', 'E', 'Y', 'E') // KeyframeEmitterData
FUNC(Color, KEYF, 'K', 'E', 'Y', 'F') // KeyframeEmitterData
FUNC(Color, KEYP, 'K', 'E', 'Y', 'P') // KeyframeEmitterData
FUNC(Color, KPIN, 'K', 'P', 'I', 'N') // Color
FUNC(Color, MDAO, 'M', 'D', 'A', 'O') // Color, Float
FUNC(Color, MULT, 'M', 'U', 'L', 'T') // Color, Color
FUNC(Color, PCOL, 'P', 'C', 'O', 'L') // N/A
FUNC(Color, PULS, 'P', 'U', 'L', 'S') // Int, Int, Color, Color
FUNC(Color, VRTC, 'V', 'R', 'T', 'C') // Vector, Float
// UV Functions
FUNC(UV, CNST, 'C', 'N', 'S', 'T') // Asset (TXTR)
FUNC(UV, ATEX, 'A', 'T', 'E', 'X') // Asset (TXTR), Int, Int, Int, Int, Int, Bool
// Asset Functions
FUNC(Asset, CNST, 'C', 'N', 'S', 'T') // Asset ID
// Emitter Functions
FUNC(Emitter, SETR, 'S', 'E', 'T', 'R') // Vector, Vector
FUNC(Emitter, SEMR, 'S', 'E', 'M', 'R') // Vector, Vector
FUNC(Emitter, SPHE, 'S', 'P', 'H', 'E') // Vector, Float, Float
FUNC(Emitter, ASPH, 'A', 'S', 'P', 'H') // Vector, Float, Float, Float, Float, Float, Float
FUNC(Emitter, ELPS, 'E', 'L', 'P', 'S') // Vector, Vector, Vector, Float, Bool
FUNC(Emitter, PLNE, 'P', 'L', 'N', 'E') // Vector, Vector, Vector, Float, Float, Float
FUNC(Emitter, SEMR, 'S', 'E', 'M', 'R') // Vector, Vector
FUNC(Emitter, SETR, 'S', 'E', 'T', 'R') // Vector, Vector
FUNC(Emitter, SPHE, 'S', 'P', 'H', 'E') // Vector, Float, Float
FUNCS_END
#undef FUNCS_BEGIN