diff --git a/Runtime/CLight.cpp b/Runtime/CLight.cpp
new file mode 100644
index 000000000..e69de29bb
diff --git a/Runtime/CLight.hpp b/Runtime/CLight.hpp
new file mode 100644
index 000000000..e337ecf15
--- /dev/null
+++ b/Runtime/CLight.hpp
@@ -0,0 +1,31 @@
+#ifndef __RETRO_CLIGHT_HPP__
+#define __RETRO_CLIGHT_HPP__
+
+namespace Retro
+{
+
+enum class ELightType
+{
+    LocalAmbient,
+    Directional,
+    Custom,
+    Spot,
+    Spot2,
+    LocalAmbient2
+};
+enum class EFalloffType
+{
+    Constant,
+    Linear,
+    Quadratic
+};
+
+class CLight
+{
+public:
+
+};
+
+}
+
+#endif // __RETRO_CLIGHT_HPP__
diff --git a/Runtime/CMakeLists.txt b/Runtime/CMakeLists.txt
index ccf6ea0f9..8ecbbf2da 100644
--- a/Runtime/CMakeLists.txt
+++ b/Runtime/CMakeLists.txt
@@ -59,6 +59,7 @@ add_library(RuntimeCommon
             CStringExtras.hpp
             CCallStack.hpp
             CTexture.hpp CTexture.cpp
+            CLight.hpp CLight.cpp
             IOStreams.hpp IOStreams.cpp
             CMainFlowBase.hpp CMainFlowBase.cpp
             CMFGameBase.hpp
diff --git a/Runtime/CToken.hpp b/Runtime/CToken.hpp
index f01080c98..2044a3a92 100644
--- a/Runtime/CToken.hpp
+++ b/Runtime/CToken.hpp
@@ -241,6 +241,7 @@ class TLockedToken : public TToken<T>
 {
     T* m_obj;
 public:
+    TLockedToken() {m_obj = nullptr;}
     TLockedToken(const CToken& other) : TToken<T>(other) {m_obj = TToken<T>::GetObj();}
     TLockedToken(CToken&& other) : TToken<T>(std::move(other)) {m_obj = TToken<T>::GetObj();}
     T* GetObj() {return m_obj;}
diff --git a/Runtime/MP1/CMakeLists.txt b/Runtime/MP1/CMakeLists.txt
index 99dcef9e5..546bd732a 100644
--- a/Runtime/MP1/CMakeLists.txt
+++ b/Runtime/MP1/CMakeLists.txt
@@ -11,6 +11,7 @@ add_executable(mp1
 target_link_libraries(mp1
                       RuntimeCommonCharacter
                       RuntimeCommonInput
+                      RuntimeCommonParticle
                       RuntimeCommon
                       DNAMP1
                       DNACommon
diff --git a/Runtime/Particle/CColorElement.cpp b/Runtime/Particle/CColorElement.cpp
index 460d9bf14..aca779059 100644
--- a/Runtime/Particle/CColorElement.cpp
+++ b/Runtime/Particle/CColorElement.cpp
@@ -25,7 +25,7 @@ bool CCEKeyframeEmitter::GetValue(int frame, Zeus::CColor& valOut) const
 {
     if (!x4_percent)
     {
-        int emitterTime = CParticleGlobals::g_emitterTimeInt;
+        int emitterTime = CParticleGlobals::g_EmitterTime;
         int calcKey = emitterTime;
         if (xc_loop)
         {
@@ -47,8 +47,8 @@ bool CCEKeyframeEmitter::GetValue(int frame, Zeus::CColor& valOut) const
     }
     else
     {
-        int ltPerc = CParticleGlobals::g_particleLifetimePercentTweenInt;
-        float ltPercRem = CParticleGlobals::g_particleLifetimePercentTweenIntFloatRem;
+        int ltPerc = CParticleGlobals::g_ParticleLifetimePercentage;
+        float ltPercRem = CParticleGlobals::g_ParticleLifetimePercentageRemainder;
         if (ltPerc == 100)
             valOut = x18_keys[100];
         else
diff --git a/Runtime/Particle/CElementGen.cpp b/Runtime/Particle/CElementGen.cpp
index 3f3229468..21c31210d 100644
--- a/Runtime/Particle/CElementGen.cpp
+++ b/Runtime/Particle/CElementGen.cpp
@@ -1,15 +1,405 @@
 #include "CElementGen.hpp"
 #include "CGenDescription.hpp"
+#include "CLight.hpp"
+#include "CParticleGlobals.hpp"
 
 namespace Retro
 {
+static LogVisor::LogModule Log("Retro::CElementGen");
+
+static bool s_inCreateNewParticles = false;
+
+int CElementGen::g_ParticleAliveCount;
+int CElementGen::g_ParticleSystemAliveCount;
+static rstl::reserved_vector<CElementGen::CParticle, 2560> g_StaticParticleList;
+void CElementGen::Initialize()
+{
+    g_ParticleAliveCount = 0;
+    g_ParticleSystemAliveCount = 0;
+
+    CParticle baseParticle;
+    std::uninitialized_fill_n(g_StaticParticleList.begin(), 2560, baseParticle);
+}
 
 CElementGen::CElementGen(const TToken<CGenDescription>& gen,
                          EModelOrientationType orientType,
                          EOptionalSystemFlags flags)
-: x1c_genDesc(gen), x28_orientType(orientType)
+: x1c_genDesc(gen), x28_orientType(orientType),
+  x226((flags & EOptionalSystemFlags::Two) != EOptionalSystemFlags::None), x230(x74)
 {
+    CIntElement* pmedElem = x1c_genDesc.GetObj()->x1c_PMED.get();
+    if (pmedElem)
+    {
+        int pmedVal;
+        pmedElem->GetValue(x50_curFrame, pmedVal);
+        x74 = pmedVal;
+    }
+    x230.SetSeed(x74);
+    ++g_ParticleSystemAliveCount;
+    x224_25_LIT_ = x1c_genDesc.GetObj()->x44_29_LIT_;
+    x224_26_AAPH = x1c_genDesc.GetObj()->x44_26_AAPH;
+    x224_27_ZBUF = x1c_genDesc.GetObj()->x44_27_ZBUF;
+    x224_29_MBLR = x1c_genDesc.GetObj()->x44_30_MBLR;
 
+    CIntElement* mbspElem = x1c_genDesc.GetObj()->x48_MBSP.get();
+    if (mbspElem)
+        mbspElem->GetValue(x50_curFrame, x228_MBSP);
+
+    x224_30_VMD1 = x1c_genDesc.GetObj()->x45_26_VMD1;
+    x224_31_VMD2 = x1c_genDesc.GetObj()->x45_27_VMD2;
+    x225_24_VMD2 = x1c_genDesc.GetObj()->x45_28_VMD3;
+    x225_25_VMD2 = x1c_genDesc.GetObj()->x45_29_VMD4;
+
+    CIntElement* cssdElem = x1c_genDesc.GetObj()->xa0_CSSD.get();
+    if (cssdElem)
+        cssdElem->GetValue(0, x244_CSSD);
+
+    SChildGeneratorDesc& idts = x1c_genDesc.GetObj()->xa4_IDTS;
+    if (idts.m_found)
+    {
+        int ndsyVal = 1;
+        CIntElement* ndsyElem = x1c_genDesc.GetObj()->xb4_NDSY.get();
+        if (ndsyElem)
+            ndsyElem->GetValue(0, ndsyVal);
+        x248_children.reserve(ndsyVal + x248_children.size());
+        for (int i=0 ; i<ndsyVal ; ++i)
+        {
+            CGenDescription* chDesc = x1c_genDesc.GetObj()->xa4_IDTS.m_gen.GetObj();
+            if (x226 && chDesc->x45_31_OPTS)
+                break;
+            x248_children.emplace_back(new CElementGen(x1c_genDesc.GetObj()->xa4_IDTS.m_gen,
+                                                       EModelOrientationType::Normal,
+                                                       x226 ? EOptionalSystemFlags::Two : EOptionalSystemFlags::One));
+        }
+    }
+
+    CIntElement* pisyElem = x1c_genDesc.GetObj()->xc8_PISY.get();
+    if (pisyElem)
+    {
+        pisyElem->GetValue(0, x25c_PISY);
+        if (x25c_PISY <= 0)
+            x25c_PISY = 1;
+    }
+
+    CIntElement* sisyElem = x1c_genDesc.GetObj()->xcc_SISY.get();
+    if (sisyElem)
+        pisyElem->GetValue(0, x258_SISY);
+
+    CIntElement* sssdElem = x1c_genDesc.GetObj()->xe4_SSSD.get();
+    if (sssdElem)
+        sssdElem->GetValue(0, x270_SSSD);
+
+    CVectorElement* sspoElem = x1c_genDesc.GetObj()->xe8_SSPO.get();
+    if (sspoElem)
+        sspoElem->GetValue(0, x274_SSPO);
+
+    CIntElement* sesdElem = x1c_genDesc.GetObj()->xf8_SESD.get();
+    if (sesdElem)
+        sesdElem->GetValue(0, x290_SESD);
+
+    CVectorElement* sepoElem = x1c_genDesc.GetObj()->xfc_SEPO.get();
+    if (sepoElem)
+        sepoElem->GetValue(0, x294_SEPO);
+
+    CIntElement* psltElem = x1c_genDesc.GetObj()->xc_PSLT.get();
+    if (psltElem)
+        psltElem->GetValue(0, x214_PSLT);
+
+    CVectorElement* psivElem = x1c_genDesc.GetObj()->x0_PSIV.get();
+    if (psivElem)
+        psivElem->GetValue(0, x218_PSIV);
+
+    CIntElement* maxpElem = x1c_genDesc.GetObj()->x28_MAXP.get();
+    if (maxpElem)
+        maxpElem->GetValue(x50_curFrame, x70_MAXP);
+
+    x2c_particleLists.reserve(std::min(256, x70_MAXP));
+    if (x28_orientType == EModelOrientationType::One)
+    {
+        x3c_parentMatrices.insert(x3c_parentMatrices.end(), x70_MAXP,
+                                  Zeus::CMatrix3f::skIdentityMatrix3f);
+    }
+
+    x225_26_LINE = x1c_genDesc.GetObj()->x44_24_LINE;
+    x225_27_FXLL = x1c_genDesc.GetObj()->x44_25_FXLL;
+
+    CRealElement* widtElem = x1c_genDesc.GetObj()->x24_WIDT.get();
+    if (widtElem)
+        widtElem->GetValue(x50_curFrame, x94_WIDT);
+
+    CIntElement* ltypElem = x1c_genDesc.GetObj()->x100_LTYP.get();
+    if (ltypElem)
+    {
+        int ltyp;
+        ltypElem->GetValue(x50_curFrame, ltyp);
+        switch (ELightType(ltyp))
+        {
+        case ELightType::LocalAmbient:
+        default:
+            x2dc_lightType = ELightType::LocalAmbient;
+            break;
+        case ELightType::Directional:
+            x2dc_lightType = ELightType::Directional;
+            break;
+        case ELightType::Custom:
+            x2dc_lightType = ELightType::Custom;
+            break;
+        case ELightType::Spot:
+            x2dc_lightType = ELightType::Spot;
+            break;
+        }
+    }
+
+    CIntElement* lfotElem = x1c_genDesc.GetObj()->x114_LFOT.get();
+    if (lfotElem)
+    {
+        int lfot;
+        lfotElem->GetValue(x50_curFrame, lfot);
+        switch (EFalloffType(lfot))
+        {
+        case EFalloffType::Constant:
+            x300_falloffType = EFalloffType::Constant;
+            break;
+        case EFalloffType::Linear:
+        default:
+            x300_falloffType = EFalloffType::Linear;
+            break;
+        case EFalloffType::Quadratic:
+            x300_falloffType = EFalloffType::Quadratic;
+            break;
+        }
+    }
+}
+
+CElementGen::~CElementGen()
+{
+    --g_ParticleSystemAliveCount;
+}
+
+CElementGen::CParticleListItem::CParticleListItem()
+{
+    ++g_ParticleAliveCount;
+}
+
+CElementGen::CParticleListItem::~CParticleListItem()
+{
+    --g_ParticleAliveCount;
+}
+
+void CElementGen::Update(double t)
+{
+    CIntElement* pswtElem = x1c_genDesc.GetObj()->x10_PSWT.get();
+    if (pswtElem && !x225_28_warmedUp)
+    {
+        int pswt = 0;
+        pswtElem->GetValue(x50_curFrame, pswt);
+        if (pswt > 32)
+        {
+            Log.report(LogVisor::Info,
+                       "Running warmup on particle system 0x%08x for %d ticks.",
+                       x1c_genDesc.GetObj(), pswt);
+            InternalUpdate(pswt / 60.0);
+            x225_28_warmedUp = true;
+        }
+    }
+    InternalUpdate(t);
+}
+
+bool CElementGen::InternalUpdate(double dt)
+{
+    CGlobalRandom gr(x230);
+
+    double dt1 = 1 / 60.0;
+    if (fabs(dt - 1 / 60.0) >= 1 / 60000.0)
+        dt1 = dt;
+    double t = x50_curFrame / 60.0;
+    CParticleGlobals::SetEmitterTime(x50_curFrame);
+
+    CRealElement* pstsElem = x1c_genDesc.GetObj()->x14_PSTS.get();
+    if (pstsElem)
+    {
+        float psts;
+        pstsElem->GetValue(x50_curFrame, psts);
+        double dt1Scaled = psts * dt1;
+        dt1 = std::max(0.0, dt1Scaled);
+    }
+
+    x58_curSeconds += dt1;
+
+    if (x224_29_MBLR && dt > 0.0)
+    {
+        CIntElement* mbspElem = x1c_genDesc.GetObj()->x48_MBSP.get();
+        if (mbspElem)
+            mbspElem->GetValue(x50_curFrame, x228_MBSP);
+    }
+
+    int frameUpdateCount = 0;
+    while (t < x58_curSeconds && fabs(t - x58_curSeconds) >= 1 / 60000.0)
+    {
+        x2a8.splat(FLT_MAX);
+        x2b4.splat(FLT_MIN);
+        x2c0 = 0.f;
+        float grte = 0.f;
+        CParticleGlobals::SetEmitterTime(x50_curFrame);
+        CRealElement* grteElem = x1c_genDesc.GetObj()->x2c_GRTE.get();
+        if (grteElem->GetValue(x50_curFrame, grte))
+        {
+            x2c_particleLists.clear();
+            return true;
+        }
+
+        grte = std::max(0.f, grte * x78_generatorRate);
+        x6c += grte;
+        int x6c_floor = floorf(x6c);
+        x6c = x6c - x6c_floor;
+
+        if (x50_curFrame < x214_PSLT)
+        {
+            if (!x68_particleEmission)
+                x6c_floor = 0;
+        }
+        else
+            x6c_floor = 0;
+
+        CIntElement* maxpElem = x1c_genDesc.GetObj()->x28_MAXP.get();
+        if (maxpElem)
+            maxpElem->GetValue(x50_curFrame, x70_MAXP);
+
+        UpdateExistingParticles();
+
+        CParticleGlobals::SetParticleLifetime(x214_PSLT);
+        bool oldBoolVal = s_inCreateNewParticles;
+        s_inCreateNewParticles = true;
+        CreateNewParticles(x6c_floor);
+        s_inCreateNewParticles = oldBoolVal;
+
+        UpdatePSTranslationAndOrientation();
+        UpdateChildParticleSystems(1 / 60.0);
+
+        if (x2dc_lightType != ELightType::LocalAmbient)
+            UpdateLightParameters();
+
+        ++frameUpdateCount;
+        ++x50_curFrame;
+        t += 1 / 60.0;
+    }
+
+    UpdateChildParticleSystems(frameUpdateCount * (-1 / 60.0) - dt1);
+    if (fabs(t - x58_curSeconds) < 1 / 60000.0)
+        x58_curSeconds = t;
+
+    BuildParticleSystemBounds();
+    x224_24 = false;
+
+    double passedTime = t - x58_curSeconds;
+    x60 = 1.0 - passedTime * 60.0;
+
+    return false;
+}
+
+void CElementGen::UpdateExistingParticles()
+{
+    CParticleGlobals::SetEmitterTime(x50_curFrame);
+}
+
+void CElementGen::CreateNewParticles(int)
+{
+}
+
+void CElementGen::UpdatePSTranslationAndOrientation()
+{
+}
+
+void CElementGen::UpdateChildParticleSystems(double dt)
+{
+}
+
+void CElementGen::UpdateLightParameters()
+{
+}
+
+void CElementGen::BuildParticleSystemBounds()
+{
+}
+
+void CElementGen::Render()
+{
+}
+
+void CElementGen::SetOrientation(const Zeus::CTransform&)
+{
+}
+
+void CElementGen::SetTranslation(const Zeus::CVector3f&)
+{
+}
+
+void CElementGen::SetGlobalOrientation(const Zeus::CTransform&)
+{
+}
+
+void CElementGen::SetGlobalTranslation(const Zeus::CVector3f&)
+{
+}
+
+void CElementGen::SetGlobalScale(const Zeus::CVector3f&)
+{
+}
+
+void CElementGen::SetLocalScale(const Zeus::CVector3f&)
+{
+}
+
+void CElementGen::SetParticleEmission(bool)
+{
+}
+
+void CElementGen::SetModulationColor(const Zeus::CColor&)
+{
+}
+
+const Zeus::CTransform& CElementGen::GetOrientation() const
+{
+}
+
+const Zeus::CVector3f& CElementGen::GetTranslation() const
+{
+}
+
+const Zeus::CVector3f& CElementGen::GetGlobalScale() const
+{
+}
+
+const Zeus::CColor& CElementGen::GetModulationColor() const
+{
+}
+
+bool CElementGen::IsSystemDeletable() const
+{
+}
+
+Zeus::CAABox CElementGen::GetBounds() const
+{
+}
+
+u32 CElementGen::GetParticleCount() const
+{
+}
+
+bool CElementGen::SystemHasLight() const
+{
+}
+
+CLight CElementGen::GetLight() const
+{
+}
+
+void CElementGen::DestroyParticles()
+{
+}
+
+void CElementGen::AddModifier(CWarp*)
+{
 }
 
 }
diff --git a/Runtime/Particle/CElementGen.hpp b/Runtime/Particle/CElementGen.hpp
index 9acc9e2b4..72428a6ba 100644
--- a/Runtime/Particle/CElementGen.hpp
+++ b/Runtime/Particle/CElementGen.hpp
@@ -3,9 +3,12 @@
 
 #include "../RetroTypes.hpp"
 #include "CTransform.hpp"
+#include "CVector3f.hpp"
 #include "CColor.hpp"
 #include "CAABox.hpp"
 #include "CToken.hpp"
+#include "CLight.hpp"
+#include "CRandom16.hpp"
 
 namespace Retro
 {
@@ -18,48 +21,120 @@ class CElementGen
 public:
     enum class EModelOrientationType
     {
+        Normal,
+        One
     };
     enum class EOptionalSystemFlags
+    {
+        None,
+        One,
+        Two
+    };
+    class CParticleListItem
+    {
+    public:
+        CParticleListItem();
+        ~CParticleListItem();
+    };
+    class CParticle
     {
     };
 private:
     TLockedToken<CGenDescription> x1c_genDesc;
     EModelOrientationType x28_orientType;
-    u32 x30 = 0;
-    u32 x34 = 0;
-    u32 x38 = 0;
-    u32 x40 = 0;
-    u32 x44 = 0;
-    u32 x48 = 0;
+    std::vector<CParticleListItem> x2c_particleLists;
+    std::vector<Zeus::CMatrix3f> x3c_parentMatrices;
     u32 x4c = 0;
-    u32 x50 = 0;
-    float x58 = 0.f;
+    u32 x50_curFrame = 0;
+    double x58_curSeconds = 0.f;
+    float x60;
     u32 x64 = -1;
     bool x68_particleEmission = true;
     float x6c = 0.f;
-    u32 x70 = 0;
+    int x70_MAXP = 0;
     u16 x74 = 99;
     float x78_generatorRate = 1.f;
     float x7c = 0.f;
     float x80 = 0.f;
     float x84 = 0.f;
-    float x88 = 0.f;
-    float x8c = 0.f;
-    float x90 = 0.f;
-    float x94 = 0.f;
+    Zeus::CVector3f x88_globalTranslation;
+    float x94_WIDT = 0.f;
     float x98 = 0.f;
     float x9c = 0.f;
     float xa0 = 1.f;
     float xa4 = 1.f;
     float xa8 = 1.f;
     Zeus::CTransform xac = Zeus::CTransform::Identity();
-    Zeus::CVector3f x88_globalTranslation;
-    Zeus::CTransform x1d8_globalOrientation;
-    std::vector<CElementGen> x240_children;
-    std::vector<CElementGen> x254_children;
+    Zeus::CTransform xdc = Zeus::CTransform::Identity();
+    float x10c = 1.f;
+    float x110 = 1.f;
+    float x114 = 1.f;
+    Zeus::CTransform x118 = Zeus::CTransform::Identity();
+    Zeus::CTransform x148 = Zeus::CTransform::Identity();
+    Zeus::CTransform x178 = Zeus::CTransform::Identity();
+    Zeus::CTransform x1a8 = Zeus::CTransform::Identity();
+    Zeus::CTransform x1d8_globalOrientation = Zeus::CTransform::Identity();
+    u32 x208 = 0;
+    u32 x20c = 0;
+    u32 x210 = 0;
+    int x214_PSLT = 0x7fffff;
+    Zeus::CVector3f x218_PSIV;
+    bool x224_24 = false;
+    bool x224_25_LIT_;
+    bool x224_26_AAPH;
+    bool x224_27_ZBUF;
+    bool x224_28 = true;
+    bool x224_29_MBLR;
+    bool x224_30_VMD1;
+    bool x224_31_VMD2;
+    bool x225_24_VMD2;
+    bool x225_25_VMD2;
+    bool x225_26_LINE;
+    bool x225_27_FXLL;
+    bool x225_28_warmedUp = false;
+    bool x225_29 = false;
+    bool x226;
+    int x228_MBSP;
+    bool x22c = false;
+    CRandom16 x230;
+    std::vector<std::unique_ptr<CElementGen>> x234_children;
+    int x244_CSSD = 0;
+    std::vector<std::unique_ptr<CElementGen>> x248_children;
+    int x258_SISY = 16;
+    int x25c_PISY = 16;
+    u32 x264 = 0;
+    u32 x268 = 0;
+    u32 x26c = 0;
+    int x270_SSSD = 0;
+    Zeus::CVector3f x274_SSPO;
+    u32 x284 = 0;
+    u32 x288 = 0;
+    u32 x28c = 0;
+    int x290_SESD = 0;
+    Zeus::CVector3f x294_SEPO;
+    float x2a0 = 0.f;
+    float x2a4 = 0.f;
+    Zeus::CVector3f x2a8;
+    Zeus::CVector3f x2b4;
+    float x2c0 = 0.f;
+    Zeus::CAABox x2c4 = Zeus::CAABox::skInvertedBox;
+    ELightType x2dc_lightType;
+    Zeus::CColor x2e0 = Zeus::CColor::skWhite;
+    float x2e4 = 1.f;
+    float x2e8 = 0.f;
+    float x2ec = 0.f;
+    float x2f0 = 0.f;
+    float x2f4 = 1.f;
+    float x2f8 = 0.f;
+    float x2fc = 0.f;
+    EFalloffType x300_falloffType = EFalloffType::Linear;
+    float x304 = 1.f;
+    float x308 = 45.f;
+    u32 x30c = -1;
+
 public:
     CElementGen(const TToken<CGenDescription>& gen, EModelOrientationType orientType, EOptionalSystemFlags flags);
-    virtual ~CElementGen() = default;
+    virtual ~CElementGen();
 
     virtual const Zeus::CVector3f& GetGlobalTranslation() const
     { return x88_globalTranslation; }
@@ -75,19 +150,26 @@ public:
         else
             x78_generatorRate = 0.0f;
 
-        for (CElementGen& child : x240_children)
-            child.SetGeneratorRateScalar(x78_generatorRate);
+        for (std::unique_ptr<CElementGen>& child : x234_children)
+            child->SetGeneratorRateScalar(x78_generatorRate);
 
-        for (CElementGen& child : x254_children)
-            child.SetGeneratorRateScalar(x78_generatorRate);
+        for (std::unique_ptr<CElementGen>& child : x248_children)
+            child->SetGeneratorRateScalar(x78_generatorRate);
     }
 
-    static void Initialize()
-    {
-    }
+    static int g_ParticleAliveCount;
+    static int g_ParticleSystemAliveCount;
+    static void Initialize();
+
+    void UpdateExistingParticles();
+    void CreateNewParticles(int);
+    void UpdatePSTranslationAndOrientation();
+    void UpdateChildParticleSystems(double);
+    void UpdateLightParameters();
     void BuildParticleSystemBounds();
 
     virtual void Update(double);
+    bool InternalUpdate(double);
     virtual void Render();
     virtual void SetOrientation(const Zeus::CTransform&);
     virtual void SetTranslation(const Zeus::CVector3f&);
@@ -109,6 +191,7 @@ public:
     virtual void DestroyParticles();
     virtual void AddModifier(CWarp*);
 };
+ENABLE_BITWISE_ENUM(CElementGen::EOptionalSystemFlags)
 
 }
 
diff --git a/Runtime/Particle/CIntElement.cpp b/Runtime/Particle/CIntElement.cpp
index 5888fbf8a..d7223a6cd 100644
--- a/Runtime/Particle/CIntElement.cpp
+++ b/Runtime/Particle/CIntElement.cpp
@@ -24,7 +24,7 @@ bool CIEKeyframeEmitter::GetValue(int frame, int& valOut) const
 {
     if (!x4_percent)
     {
-        int emitterTime = CParticleGlobals::g_emitterTimeInt;
+        int emitterTime = CParticleGlobals::g_EmitterTime;
         int calcKey = emitterTime;
         if (xc_loop)
         {
@@ -46,8 +46,8 @@ bool CIEKeyframeEmitter::GetValue(int frame, int& valOut) const
     }
     else
     {
-        int ltPerc = CParticleGlobals::g_particleLifetimePercentTweenInt;
-        float ltPercRem = CParticleGlobals::g_particleLifetimePercentTweenIntFloatRem;
+        int ltPerc = CParticleGlobals::g_ParticleLifetimePercentage;
+        float ltPercRem = CParticleGlobals::g_ParticleLifetimePercentageRemainder;
         if (ltPerc == 100)
             valOut = x18_keys[100];
         else
@@ -117,7 +117,7 @@ bool CIELifetimePercent::GetValue(int frame, int& valOut) const
     int a;
     x4_percentVal->GetValue(frame, a);
     a = std::max(0, a);
-    valOut = (a / 100.0f) * CParticleGlobals::g_particleLifetimeFloat;
+    valOut = (a / 100.0f) * CParticleGlobals::g_ParticleLifetimeReal;
     return false;
 }
 
diff --git a/Runtime/Particle/CParticleDataFactory.hpp b/Runtime/Particle/CParticleDataFactory.hpp
index 764fd905b..45d06f618 100644
--- a/Runtime/Particle/CParticleDataFactory.hpp
+++ b/Runtime/Particle/CParticleDataFactory.hpp
@@ -24,25 +24,25 @@ class CIntElement;
 
 struct SParticleModel
 {
-    TToken<CModel> m_model;
+    TLockedToken<CModel> m_model;
     bool m_found = false;
 };
 
 struct SChildGeneratorDesc
 {
-    TToken<CGenDescription> m_gen;
+    TLockedToken<CGenDescription> m_gen;
     bool m_found = false;
 };
 
 struct SSwooshGeneratorDesc
 {
-    TToken<CSwooshDescription> m_swoosh;
+    TLockedToken<CSwooshDescription> m_swoosh;
     bool m_found = false;
 };
 
 struct SElectricGeneratorDesc
 {
-    TToken<CElectricDescription> m_electric;
+    TLockedToken<CElectricDescription> m_electric;
     bool m_found = false;
 };
 
diff --git a/Runtime/Particle/CParticleGlobals.cpp b/Runtime/Particle/CParticleGlobals.cpp
index 73d011221..46acd01ca 100644
--- a/Runtime/Particle/CParticleGlobals.cpp
+++ b/Runtime/Particle/CParticleGlobals.cpp
@@ -3,15 +3,15 @@
 namespace Retro
 {
 
-int CParticleGlobals::g_emitterTimeInt = 0;
-float CParticleGlobals::g_emitterTimeFloat = 0.0;
+int CParticleGlobals::g_EmitterTime = 0;
+float CParticleGlobals::g_EmitterTimeReal = 0.0;
 
-int CParticleGlobals::g_particleLifetimeInt = 0;
-float CParticleGlobals::g_particleLifetimeFloat = 0.0;
+int CParticleGlobals::g_ParticleLifetime = 0;
+float CParticleGlobals::g_ParticleLifetimeReal = 0.0;
 
-int CParticleGlobals::g_particleLifetimePercentTweenInt = 0;
-float CParticleGlobals::g_particleLifetimePercentTweenFloat = 0.0;
-float CParticleGlobals::g_particleLifetimePercentTweenIntFloatRem = 0.0;
+int CParticleGlobals::g_ParticleLifetimePercentage = 0;
+float CParticleGlobals::g_ParticleLifetimePercentageReal = 0.0;
+float CParticleGlobals::g_ParticleLifetimePercentageRemainder = 0.0;
 
 float* CParticleGlobals::g_papValues = nullptr;
 CParticleGlobals::SParticleMetrics* CParticleGlobals::g_particleMetrics = nullptr;
diff --git a/Runtime/Particle/CParticleGlobals.hpp b/Runtime/Particle/CParticleGlobals.hpp
index 9fd94ed08..e78ef9e26 100644
--- a/Runtime/Particle/CParticleGlobals.hpp
+++ b/Runtime/Particle/CParticleGlobals.hpp
@@ -9,31 +9,31 @@ namespace Retro
 class CParticleGlobals
 {
 public:
-    static int g_emitterTimeInt;
-    static float g_emitterTimeFloat;
+    static int g_EmitterTime;
+    static float g_EmitterTimeReal;
     static void SetEmitterTime(int frame)
     {
-        g_emitterTimeInt = frame;
-        g_emitterTimeFloat = frame;
+        g_EmitterTime = frame;
+        g_EmitterTimeReal = frame;
     }
 
-    static int g_particleLifetimeInt;
-    static float g_particleLifetimeFloat;
+    static int g_ParticleLifetime;
+    static float g_ParticleLifetimeReal;
     static void SetParticleLifetime(int frame)
     {
-        g_particleLifetimeInt = frame;
-        g_particleLifetimeFloat = frame;
+        g_ParticleLifetime = frame;
+        g_ParticleLifetimeReal = frame;
     }
 
-    static int g_particleLifetimePercentTweenInt;
-    static float g_particleLifetimePercentTweenFloat;
-    static float g_particleLifetimePercentTweenIntFloatRem;
+    static int g_ParticleLifetimePercentage;
+    static float g_ParticleLifetimePercentageReal;
+    static float g_ParticleLifetimePercentageRemainder;
     static void UpdateParticleLifetimeTweenValues(int frame)
     {
-        float lt = g_particleLifetimeInt != 0.0f ? g_particleLifetimeInt : 1.0f;
-        g_particleLifetimePercentTweenFloat = 100.0f * frame / lt;
-        g_particleLifetimePercentTweenInt = g_particleLifetimePercentTweenFloat;
-        g_particleLifetimePercentTweenIntFloatRem = g_particleLifetimePercentTweenFloat - g_particleLifetimePercentTweenInt;
+        float lt = g_ParticleLifetime != 0.0f ? g_ParticleLifetime : 1.0f;
+        g_ParticleLifetimePercentageReal = 100.0f * frame / lt;
+        g_ParticleLifetimePercentage = g_ParticleLifetimePercentageReal;
+        g_ParticleLifetimePercentageRemainder = g_ParticleLifetimePercentageReal - g_ParticleLifetimePercentage;
     }
 
     static float* g_papValues;
diff --git a/Runtime/Particle/CRealElement.cpp b/Runtime/Particle/CRealElement.cpp
index 041330d13..754a4c62b 100644
--- a/Runtime/Particle/CRealElement.cpp
+++ b/Runtime/Particle/CRealElement.cpp
@@ -25,7 +25,7 @@ bool CREKeyframeEmitter::GetValue(int frame, float& valOut) const
 {
     if (!x4_percent)
     {
-        int emitterTime = CParticleGlobals::g_emitterTimeInt;
+        int emitterTime = CParticleGlobals::g_EmitterTime;
         int calcKey = emitterTime;
         if (xc_loop)
         {
@@ -47,8 +47,8 @@ bool CREKeyframeEmitter::GetValue(int frame, float& valOut) const
     }
     else
     {
-        int ltPerc = CParticleGlobals::g_particleLifetimePercentTweenInt;
-        float ltPercRem = CParticleGlobals::g_particleLifetimePercentTweenIntFloatRem;
+        int ltPerc = CParticleGlobals::g_ParticleLifetimePercentage;
+        float ltPercRem = CParticleGlobals::g_ParticleLifetimePercentageRemainder;
         if (ltPerc == 100)
             valOut = x18_keys[100];
         else
@@ -59,7 +59,7 @@ bool CREKeyframeEmitter::GetValue(int frame, float& valOut) const
 
 bool CRELifetimeTween::GetValue(int frame, float& valOut) const
 {
-    float ltFac = frame / CParticleGlobals::g_particleLifetimeFloat;
+    float ltFac = frame / CParticleGlobals::g_ParticleLifetimeReal;
     float a, b;
     x4_a->GetValue(frame, a);
     x8_b->GetValue(frame, b);
@@ -149,7 +149,7 @@ bool CRELifetimePercent::GetValue(int frame, float& valOut) const
     float a;
     x4_percentVal->GetValue(frame, a);
     a = std::max(0.0f, a);
-    valOut = (a / 100.0f) * CParticleGlobals::g_particleLifetimeFloat;
+    valOut = (a / 100.0f) * CParticleGlobals::g_ParticleLifetimeReal;
     return false;
 }
 
diff --git a/Runtime/Particle/CVectorElement.cpp b/Runtime/Particle/CVectorElement.cpp
index a1f2122fb..a2405b9dc 100644
--- a/Runtime/Particle/CVectorElement.cpp
+++ b/Runtime/Particle/CVectorElement.cpp
@@ -25,7 +25,7 @@ bool CVEKeyframeEmitter::GetValue(int frame, Zeus::CVector3f& valOut) const
 {
     if (!x4_percent)
     {
-        int emitterTime = CParticleGlobals::g_emitterTimeInt;
+        int emitterTime = CParticleGlobals::g_EmitterTime;
         int calcKey = emitterTime;
         if (xc_loop)
         {
@@ -47,8 +47,8 @@ bool CVEKeyframeEmitter::GetValue(int frame, Zeus::CVector3f& valOut) const
     }
     else
     {
-        int ltPerc = CParticleGlobals::g_particleLifetimePercentTweenInt;
-        float ltPercRem = CParticleGlobals::g_particleLifetimePercentTweenIntFloatRem;
+        int ltPerc = CParticleGlobals::g_ParticleLifetimePercentage;
+        float ltPercRem = CParticleGlobals::g_ParticleLifetimePercentageRemainder;
         if (ltPerc == 100)
             valOut = x18_keys[100];
         else