From bc35e15a6ab5fd17f7ebb41bfc76c173773da882 Mon Sep 17 00:00:00 2001
From: parax0 <parax0@github.com>
Date: Mon, 15 Aug 2016 00:40:13 -0600
Subject: [PATCH] Added support for parsing MP2 particles

---
 .../Factory/CUnsupportedParticleLoader.cpp    | 359 ++++++++++++++++--
 .../Factory/CUnsupportedParticleLoader.h      |   5 +-
 src/Core/Resource/ParticleParameters.h        | 155 +++++++-
 3 files changed, 475 insertions(+), 44 deletions(-)

diff --git a/src/Core/Resource/Factory/CUnsupportedParticleLoader.cpp b/src/Core/Resource/Factory/CUnsupportedParticleLoader.cpp
index 26d673ec..0de09d2e 100644
--- a/src/Core/Resource/Factory/CUnsupportedParticleLoader.cpp
+++ b/src/Core/Resource/Factory/CUnsupportedParticleLoader.cpp
@@ -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;
diff --git a/src/Core/Resource/Factory/CUnsupportedParticleLoader.h b/src/Core/Resource/Factory/CUnsupportedParticleLoader.h
index 4abe9b69..7e9ddcce 100644
--- a/src/Core/Resource/Factory/CUnsupportedParticleLoader.h
+++ b/src/Core/Resource/Factory/CUnsupportedParticleLoader.h
@@ -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);
diff --git a/src/Core/Resource/ParticleParameters.h b/src/Core/Resource/ParticleParameters.h
index 104f4b72..ce9d7d77 100644
--- a/src/Core/Resource/ParticleParameters.h
+++ b/src/Core/Resource/ParticleParameters.h
@@ -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