Big fixes and big memory leak refactor (linux only for now)

2025-12-08 15:04:56 +00:00 · 2018-05-19 20:14:57 -10:00
parent 5f03362149
commit f60af632b3
84 changed files with 849 additions and 689 deletions
--- a/Runtime/Particle/CColorElement.hpp
+++ b/Runtime/Particle/CColorElement.hpp
@@ -29,8 +29,9 @@ class CCEConstant : public CColorElement
    std::unique_ptr<CRealElement> xc_c;
    std::unique_ptr<CRealElement> x10_d;
 public:
-    CCEConstant(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d)
-    : x4_a(a), x8_b(b), xc_c(c), x10_d(d) {}
+    CCEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {}
    bool GetValue(int frame, zeus::CColor& colorOut) const;
 };

@@ -49,8 +50,9 @@ class CCETimeChain : public CColorElement
    std::unique_ptr<CColorElement> x8_b;
    std::unique_ptr<CIntElement> xc_swFrame;
 public:
-    CCETimeChain(CColorElement* a, CColorElement* b, CIntElement* c)
-    : x4_a(a), x8_b(b), xc_swFrame(c) {}
+    CCETimeChain(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b,
+                 std::unique_ptr<CIntElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
    bool GetValue(int frame, zeus::CColor& colorOut) const;
 };

@@ -61,8 +63,9 @@ class CCEFadeEnd : public CColorElement
    std::unique_ptr<CRealElement> xc_startFrame;
    std::unique_ptr<CRealElement> x10_endFrame;
 public:
-    CCEFadeEnd(CColorElement* a, CColorElement* b, CRealElement* c, CRealElement* d)
-    : x4_a(a), x8_b(b), xc_startFrame(c), x10_endFrame(d) {}
+    CCEFadeEnd(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b,
+               std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_startFrame(std::move(c)), x10_endFrame(std::move(d)) {}
    bool GetValue(int frame, zeus::CColor& colorOut) const;
 };

@@ -72,8 +75,9 @@ class CCEFade : public CColorElement
    std::unique_ptr<CColorElement> x8_b;
    std::unique_ptr<CRealElement> xc_endFrame;
 public:
-    CCEFade(CColorElement* a, CColorElement* b, CRealElement* c)
-    : x4_a(a), x8_b(b), xc_endFrame(c) {}
+    CCEFade(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b,
+            std::unique_ptr<CRealElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_endFrame(std::move(c)) {}
    bool GetValue(int frame, zeus::CColor& colorOut) const;
 };

@@ -84,8 +88,9 @@ class CCEPulse : public CColorElement
    std::unique_ptr<CColorElement> xc_aVal;
    std::unique_ptr<CColorElement> x10_bVal;
 public:
-    CCEPulse(CIntElement* a, CIntElement* b, CColorElement* c, CColorElement* d)
-    : x4_aDuration(a), x8_bDuration(b), xc_aVal(c), x10_bVal(d) {}
+    CCEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+             std::unique_ptr<CColorElement>&& c, std::unique_ptr<CColorElement>&& d)
+    : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
    bool GetValue(int frame, zeus::CColor& colorOut) const;
 };

--- a/Runtime/Particle/CDecal.cpp
+++ b/Runtime/Particle/CDecal.cpp
@@ -32,7 +32,7 @@ CDecal::CDecal(const TToken<CDecalDescription>& desc, const zeus::CTransform& xf
    else
        x5c_29_modelInvalid = true;

-    CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx)
+    CGraphicsCommitResources([this](boo::IGraphicsDataFactory::Context& ctx)
    {
        for (int i=0 ; i<2 ; ++i)
        {
--- a/Runtime/Particle/CDecalDataFactory.cpp
+++ b/Runtime/Particle/CDecalDataFactory.cpp
@@ -67,19 +67,19 @@ bool CDecalDataFactory::CreateDPSM(CDecalDescription* desc, CInputStream& in, CS
            desc->x38_DMDL = CPF::GetModel(in, resPool);
            break;
        case SBIG('DLFT'):
-            desc->x48_DLFT.reset(CPF::GetIntElement(in));
+            desc->x48_DLFT = CPF::GetIntElement(in);
            break;
        case SBIG('DMOP'):
-            desc->x4c_DMOP.reset(CPF::GetVectorElement(in));
+            desc->x4c_DMOP = CPF::GetVectorElement(in);
            break;
        case SBIG('DMRT'):
-            desc->x50_DMRT.reset(CPF::GetVectorElement(in));
+            desc->x50_DMRT = CPF::GetVectorElement(in);
            break;
        case SBIG('DMSC'):
-            desc->x54_DMSC.reset(CPF::GetVectorElement(in));
+            desc->x54_DMSC = CPF::GetVectorElement(in);
            break;
        case SBIG('DMCL'):
-            desc->x58_DMCL.reset(CPF::GetColorElement(in));
+            desc->x58_DMCL = CPF::GetColorElement(in);
            break;
        case SBIG('DMAB'):
            desc->x5c_24_DMAB = CPF::GetBool(in);
@@ -106,27 +106,27 @@ void CDecalDataFactory::GetQuadDecalInfo(CInputStream& in, CSimplePool* resPool,
    {
    case SBIG('1LFT'):
    case SBIG('2LFT'):
-        quad.x0_LFT.reset(CPF::GetIntElement(in));
+        quad.x0_LFT = CPF::GetIntElement(in);
        break;
    case SBIG('1SZE'):
    case SBIG('2SZE'):
-        quad.x4_SZE.reset(CPF::GetRealElement(in));
+        quad.x4_SZE = CPF::GetRealElement(in);
        break;
    case SBIG('1ROT'):
    case SBIG('2ROT'):
-        quad.x8_ROT.reset(CPF::GetRealElement(in));
+        quad.x8_ROT = CPF::GetRealElement(in);
        break;
    case SBIG('1OFF'):
    case SBIG('2OFF'):
-        quad.xc_OFF.reset(CPF::GetVectorElement(in));
+        quad.xc_OFF = CPF::GetVectorElement(in);
        break;
    case SBIG('1CLR'):
    case SBIG('2CLR'):
-        quad.x10_CLR.reset(CPF::GetColorElement(in));
+        quad.x10_CLR = CPF::GetColorElement(in);
        break;
    case SBIG('1TEX'):
    case SBIG('2TEX'):
-        quad.x14_TEX.reset(CPF::GetTextureElement(in, resPool));
+        quad.x14_TEX = CPF::GetTextureElement(in, resPool);
        break;
    case SBIG('1ADD'):
    case SBIG('2ADD'):
--- a/Runtime/Particle/CElementGen.cpp
+++ b/Runtime/Particle/CElementGen.cpp
@@ -234,7 +234,7 @@ CElementGen::CElementGen(const TToken<CGenDescription>& gen,
    size_t maxInsts = x26c_30_MBLR ? (m_maxMBSP * x90_MAXP) : x90_MAXP;
    maxInsts = (maxInsts == 0 ? 256 : maxInsts);

-    CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
+    CGraphicsCommitResources([&](boo::IGraphicsDataFactory::Context& ctx)
    {
        if (!x26c_31_LINE)
        {
--- a/Runtime/Particle/CEmitterElement.hpp
+++ b/Runtime/Particle/CEmitterElement.hpp
@@ -13,8 +13,8 @@ class CEESimpleEmitter : public CEmitterElement
    std::unique_ptr<CVectorElement> x4_loc;
    std::unique_ptr<CVectorElement> x8_vec;
 public:
-    CEESimpleEmitter(CVectorElement* a, CVectorElement* b)
-    : x4_loc(a), x8_vec(b) {}
+    CEESimpleEmitter(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
+    : x4_loc(std::move(a)), x8_vec(std::move(b)) {}
    bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const;
 };

@@ -24,8 +24,9 @@ class CVESphere : public CEmitterElement
    std::unique_ptr<CRealElement> x8_sphereRadius;
    std::unique_ptr<CRealElement> xc_velocityMag;
 public:
-    CVESphere(CVectorElement* a, CRealElement* b, CRealElement* c)
-    : x4_sphereOrigin(a), x8_sphereRadius(b), xc_velocityMag(c) {}
+    CVESphere(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b,
+              std::unique_ptr<CRealElement>&& c)
+    : x4_sphereOrigin(std::move(a)), x8_sphereRadius(std::move(b)), xc_velocityMag(std::move(c)) {}
    bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const;
 };

@@ -39,9 +40,13 @@ class CVEAngleSphere : public CEmitterElement
    std::unique_ptr<CRealElement> x18_angleXRange;
    std::unique_ptr<CRealElement> x1c_angleYRange;
 public:
-    CVEAngleSphere(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d,
-                   CRealElement* e, CRealElement* f, CRealElement* g)
-    : x4_sphereOrigin(a), x8_sphereRadius(b), xc_velocityMag(c), x10_angleXBias(d), x14_angleYBias(e), x18_angleXRange(f), x1c_angleYRange(g) {}
+    CVEAngleSphere(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b,
+                   std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d,
+                   std::unique_ptr<CRealElement>&& e, std::unique_ptr<CRealElement>&& f,
+                   std::unique_ptr<CRealElement>&& g)
+    : x4_sphereOrigin(std::move(a)), x8_sphereRadius(std::move(b)), xc_velocityMag(std::move(c)),
+      x10_angleXBias(std::move(d)), x14_angleYBias(std::move(e)), x18_angleXRange(std::move(f)),
+      x1c_angleYRange(std::move(g)) {}
    bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const;
 };

--- a/Runtime/Particle/CIntElement.hpp
+++ b/Runtime/Particle/CIntElement.hpp
@@ -27,8 +27,8 @@ class CIEDeath : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIEDeath(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIEDeath(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -38,8 +38,8 @@ class CIEClamp : public CIntElement
    std::unique_ptr<CIntElement> x8_max;
    std::unique_ptr<CIntElement> xc_val;
 public:
-    CIEClamp(CIntElement* a, CIntElement* b, CIntElement* c)
-    : x4_min(a), x8_max(b), xc_val(c) {}
+    CIEClamp(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c)
+    : x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -49,8 +49,8 @@ class CIETimeChain : public CIntElement
    std::unique_ptr<CIntElement> x8_b;
    std::unique_ptr<CIntElement> xc_swFrame;
 public:
-    CIETimeChain(CIntElement* a, CIntElement* b, CIntElement* c)
-    : x4_a(a), x8_b(b), xc_swFrame(c) {}
+    CIETimeChain(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -59,8 +59,8 @@ class CIEAdd : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIEAdd(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIEAdd(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -76,8 +76,8 @@ class CIEImpulse : public CIntElement
 {
    std::unique_ptr<CIntElement> x4_a;
 public:
-    CIEImpulse(CIntElement* a)
-    : x4_a(a) {}
+    CIEImpulse(std::unique_ptr<CIntElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -85,8 +85,8 @@ class CIELifetimePercent : public CIntElement
 {
    std::unique_ptr<CIntElement> x4_percentVal;
 public:
-    CIELifetimePercent(CIntElement* a)
-    : x4_percentVal(a) {}
+    CIELifetimePercent(std::unique_ptr<CIntElement>&& a)
+    : x4_percentVal(std::move(a)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -95,8 +95,8 @@ class CIEInitialRandom : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIEInitialRandom(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIEInitialRandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -107,8 +107,9 @@ class CIEPulse : public CIntElement
    std::unique_ptr<CIntElement> xc_aVal;
    std::unique_ptr<CIntElement> x10_bVal;
 public:
-    CIEPulse(CIntElement* a, CIntElement* b, CIntElement* c, CIntElement* d)
-    : x4_aDuration(a), x8_bDuration(b), xc_aVal(c), x10_bVal(d) {}
+    CIEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+             std::unique_ptr<CIntElement>&& c, std::unique_ptr<CIntElement>&& d)
+    : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -117,8 +118,8 @@ class CIEMultiply : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIEMultiply(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIEMultiply(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -130,8 +131,9 @@ class CIESampleAndHold : public CIntElement
    std::unique_ptr<CIntElement> x10_waitFramesMax;
    int x14_holdVal;
 public:
-    CIESampleAndHold(CIntElement* a, CIntElement* b, CIntElement* c)
-    : x4_sampleSource(a), xc_waitFramesMin(b), x10_waitFramesMax(c) {}
+    CIESampleAndHold(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+                     std::unique_ptr<CIntElement>&& c)
+    : x4_sampleSource(std::move(a)), xc_waitFramesMin(std::move(b)), x10_waitFramesMax(std::move(c)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -140,8 +142,8 @@ class CIERandom : public CIntElement
    std::unique_ptr<CIntElement> x4_min;
    std::unique_ptr<CIntElement> x8_max;
 public:
-    CIERandom(CIntElement* a, CIntElement* b)
-    : x4_min(a), x8_max(b) {}
+    CIERandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_min(std::move(a)), x8_max(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -149,8 +151,8 @@ class CIETimeScale : public CIntElement
 {
    std::unique_ptr<CRealElement> x4_a;
 public:
-    CIETimeScale(CRealElement* a)
-    : x4_a(a) {}
+    CIETimeScale(std::unique_ptr<CRealElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -177,8 +179,8 @@ class CIEModulo : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIEModulo(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIEModulo(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

@@ -187,8 +189,8 @@ class CIESubtract : public CIntElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CIntElement> x8_b;
 public:
-    CIESubtract(CIntElement* a, CIntElement* b)
-    : x4_a(a), x8_b(b) {}
+    CIESubtract(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, int& valOut) const;
 };

--- a/Runtime/Particle/CModVectorElement.cpp
+++ b/Runtime/Particle/CModVectorElement.cpp
@@ -99,8 +99,10 @@ bool CMVETimeChain::GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f&
        return x4_a->GetValue(frame, pVel, pPos);
 }

-CMVEBounce::CMVEBounce(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d, bool f)
-: x4_planePoint(a), x8_planeNormal(b), xc_friction(c), x10_restitution(d), x14_planePrecomputed(false), x15_dieOnPenetrate(f), x24_planeD(0.0)
+CMVEBounce::CMVEBounce(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+                       std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e)
+: x4_planePoint(std::move(a)), x8_planeNormal(std::move(b)), xc_friction(std::move(c)),
+  x10_restitution(std::move(d)), x14_planePrecomputed(false), x15_dieOnPenetrate(e), x24_planeD(0.0)
 {
    if (x4_planePoint && x8_planeNormal && x4_planePoint->IsFastConstant() && x8_planeNormal->IsFastConstant())
    {
--- a/Runtime/Particle/CModVectorElement.hpp
+++ b/Runtime/Particle/CModVectorElement.hpp
@@ -16,8 +16,10 @@ class CMVEImplosion : public CModVectorElement
    std::unique_ptr<CRealElement> x10_minMag;
    bool x14_enableMinMag;
 public:
-    CMVEImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d, bool e)
-    : x4_implPoint(a), x8_magScale(b), xc_maxMag(c), x10_minMag(d), x14_enableMinMag(e) {}
+    CMVEImplosion(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b,
+                  std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e)
+    : x4_implPoint(std::move(a)), x8_magScale(std::move(b)), xc_maxMag(std::move(c)), x10_minMag(std::move(d)),
+      x14_enableMinMag(std::move(e)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -29,8 +31,10 @@ class CMVEExponentialImplosion : public CModVectorElement
    std::unique_ptr<CRealElement> x10_minMag;
    bool x14_enableMinMag;
 public:
-    CMVEExponentialImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d, bool e)
-    : x4_implPoint(a), x8_magScale(b), xc_maxMag(c), x10_minMag(d), x14_enableMinMag(e) {}
+    CMVEExponentialImplosion(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b,
+                             std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e)
+    : x4_implPoint(std::move(a)), x8_magScale(std::move(b)), xc_maxMag(std::move(c)), x10_minMag(std::move(d)),
+      x14_enableMinMag(std::move(e)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -42,8 +46,10 @@ class CMVELinearImplosion : public CModVectorElement
    std::unique_ptr<CRealElement> x10_minMag;
    bool x14_enableMinMag;
 public:
-    CMVELinearImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d, bool e)
-    : x4_implPoint(a), x8_magScale(b), xc_maxMag(c), x10_minMag(d), x14_enableMinMag(e) {}
+    CMVELinearImplosion(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b,
+                        std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e)
+    : x4_implPoint(std::move(a)), x8_magScale(std::move(b)), xc_maxMag(std::move(c)), x10_minMag(std::move(d)),
+      x14_enableMinMag(std::move(e)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -53,8 +59,9 @@ class CMVETimeChain : public CModVectorElement
    std::unique_ptr<CModVectorElement> x8_b;
    std::unique_ptr<CIntElement> xc_swFrame;
 public:
-    CMVETimeChain(CModVectorElement* a, CModVectorElement* b, CIntElement* c)
-    : x4_a(a), x8_b(b), xc_swFrame(c) {}
+    CMVETimeChain(std::unique_ptr<CModVectorElement>&& a, std::unique_ptr<CModVectorElement>&& b,
+                  std::unique_ptr<CIntElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -69,7 +76,8 @@ class CMVEBounce : public CModVectorElement
    zeus::CVector3f x18_planeValidatedNormal;
    float x24_planeD;
 public:
-    CMVEBounce(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d, bool e);
+    CMVEBounce(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+               std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e);
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -79,8 +87,9 @@ class CMVEConstant : public CModVectorElement
    std::unique_ptr<CRealElement> x8_y;
    std::unique_ptr<CRealElement> xc_z;
 public:
-    CMVEConstant(CRealElement* a, CRealElement* b, CRealElement* c)
-    : x4_x(a), x8_y(b), xc_z(c) {}
+    CMVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                 std::unique_ptr<CRealElement>&& c)
+    : x4_x(std::move(a)), x8_y(std::move(b)), xc_z(std::move(c)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -97,8 +106,8 @@ class CMVEGravity : public CModVectorElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CMVEGravity(CVectorElement* a)
-    : x4_a(a) {}
+    CMVEGravity(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -107,8 +116,8 @@ class CMVEExplode : public CModVectorElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CMVEExplode(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CMVEExplode(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -116,8 +125,8 @@ class CMVESetPosition : public CModVectorElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CMVESetPosition(CVectorElement* a)
-    : x4_a(a) {}
+    CMVESetPosition(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -128,8 +137,9 @@ class CMVEPulse : public CModVectorElement
    std::unique_ptr<CModVectorElement> xc_aVal;
    std::unique_ptr<CModVectorElement> x10_bVal;
 public:
-    CMVEPulse(CIntElement* a, CIntElement* b, CModVectorElement* c, CModVectorElement* d)
-    : x4_aDuration(a), x8_bDuration(b), xc_aVal(c), x10_bVal(d) {}
+    CMVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+              std::unique_ptr<CModVectorElement>&& c, std::unique_ptr<CModVectorElement>&& d)
+    : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -138,8 +148,8 @@ class CMVEWind : public CModVectorElement
    std::unique_ptr<CVectorElement> x4_velocity;
    std::unique_ptr<CRealElement> x8_factor;
 public:
-    CMVEWind(CVectorElement* a, CRealElement* b)
-    : x4_velocity(a), x8_factor(b) {}
+    CMVEWind(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_velocity(std::move(a)), x8_factor(std::move(b)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

@@ -150,8 +160,10 @@ class CMVESwirl : public CModVectorElement
    std::unique_ptr<CRealElement> xc_targetRadius;
    std::unique_ptr<CRealElement> x10_tangentialVelocity;
 public:
-    CMVESwirl(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d)
-    : x4_helixPoint(a), x8_curveBinormal(b), xc_targetRadius(c), x10_tangentialVelocity(d) {}
+    CMVESwirl(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+              std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_helixPoint(std::move(a)), x8_curveBinormal(std::move(b)),
+      xc_targetRadius(std::move(c)), x10_tangentialVelocity(std::move(d)) {}
    bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
 };

--- a/Runtime/Particle/CParticleDataFactory.cpp
+++ b/Runtime/Particle/CParticleDataFactory.cpp
--- a/Runtime/Particle/CParticleDataFactory.hpp
+++ b/Runtime/Particle/CParticleDataFactory.hpp
@@ -80,13 +80,13 @@ class CParticleDataFactory
    static SChildGeneratorDesc GetChildGeneratorDesc(CInputStream& in, CSimplePool* resPool, const std::vector<CAssetId>& tracker);
    static SSwooshGeneratorDesc GetSwooshGeneratorDesc(CInputStream& in, CSimplePool* resPool);
    static SElectricGeneratorDesc GetElectricGeneratorDesc(CInputStream& in, CSimplePool* resPool);
-    static CUVElement* GetTextureElement(CInputStream& in, CSimplePool* resPool);
-    static CColorElement* GetColorElement(CInputStream& in);
-    static CModVectorElement* GetModVectorElement(CInputStream& in);
-    static CEmitterElement* GetEmitterElement(CInputStream& in);
-    static CVectorElement* GetVectorElement(CInputStream& in);
-    static CRealElement* GetRealElement(CInputStream& in);
-    static CIntElement* GetIntElement(CInputStream& in);
+    static std::unique_ptr<CUVElement> GetTextureElement(CInputStream& in, CSimplePool* resPool);
+    static std::unique_ptr<CColorElement> GetColorElement(CInputStream& in);
+    static std::unique_ptr<CModVectorElement> GetModVectorElement(CInputStream& in);
+    static std::unique_ptr<CEmitterElement> GetEmitterElement(CInputStream& in);
+    static std::unique_ptr<CVectorElement> GetVectorElement(CInputStream& in);
+    static std::unique_ptr<CRealElement> GetRealElement(CInputStream& in);
+    static std::unique_ptr<CIntElement> GetIntElement(CInputStream& in);

    static float GetReal(CInputStream& in);
    static s32 GetInt(CInputStream& in);
--- a/Runtime/Particle/CParticleElectricDataFactory.cpp
+++ b/Runtime/Particle/CParticleElectricDataFactory.cpp
@@ -43,52 +43,52 @@ bool CParticleElectricDataFactory::CreateELSM(CElectricDescription* desc, CInput
        switch (clsId)
        {
        case SBIG('LIFE'):
-            desc->x0_LIFE.reset(CPF::GetIntElement(in));
+            desc->x0_LIFE = CPF::GetIntElement(in);
            break;
        case SBIG('SLIF'):
-            desc->x4_SLIF.reset(CPF::GetIntElement(in));
+            desc->x4_SLIF = CPF::GetIntElement(in);
            break;
        case SBIG('GRAT'):
-            desc->x8_GRAT.reset(CPF::GetRealElement(in));
+            desc->x8_GRAT = CPF::GetRealElement(in);
            break;
        case SBIG('SCNT'):
-            desc->xc_SCNT.reset(CPF::GetIntElement(in));
+            desc->xc_SCNT = CPF::GetIntElement(in);
            break;
        case SBIG('SSEG'):
-            desc->x10_SSEG.reset(CPF::GetIntElement(in));
+            desc->x10_SSEG = CPF::GetIntElement(in);
            break;
        case SBIG('COLR'):
-            desc->x14_COLR.reset(CPF::GetColorElement(in));
+            desc->x14_COLR = CPF::GetColorElement(in);
            break;
        case SBIG('IEMT'):
-            desc->x18_IEMT.reset(CPF::GetEmitterElement(in));
+            desc->x18_IEMT = CPF::GetEmitterElement(in);
            break;
        case SBIG('FEMT'):
-            desc->x1c_FEMT.reset(CPF::GetEmitterElement(in));
+            desc->x1c_FEMT = CPF::GetEmitterElement(in);
            break;
        case SBIG('AMPL'):
-            desc->x20_AMPL.reset(CPF::GetRealElement(in));
+            desc->x20_AMPL = CPF::GetRealElement(in);
            break;
        case SBIG('AMPD'):
-            desc->x24_AMPD.reset(CPF::GetRealElement(in));
+            desc->x24_AMPD = CPF::GetRealElement(in);
            break;
        case SBIG('LWD1'):
-            desc->x28_LWD1.reset(CPF::GetRealElement(in));
+            desc->x28_LWD1 = CPF::GetRealElement(in);
            break;
        case SBIG('LWD2'):
-            desc->x2c_LWD2.reset(CPF::GetRealElement(in));
+            desc->x2c_LWD2 = CPF::GetRealElement(in);
            break;
        case SBIG('LWD3'):
-            desc->x30_LWD3.reset(CPF::GetRealElement(in));
+            desc->x30_LWD3 = CPF::GetRealElement(in);
            break;
        case SBIG('LCL1'):
-            desc->x34_LCL1.reset(CPF::GetColorElement(in));
+            desc->x34_LCL1 = CPF::GetColorElement(in);
            break;
        case SBIG('LCL2'):
-            desc->x38_LCL2.reset(CPF::GetColorElement(in));
+            desc->x38_LCL2 = CPF::GetColorElement(in);
            break;
        case SBIG('LCL3'):
-            desc->x3c_LCL3.reset(CPF::GetColorElement(in));
+            desc->x3c_LCL3 = CPF::GetColorElement(in);
            break;
        case SBIG('SSWH'):
            desc->x40_SSWH = CPF::GetSwooshGeneratorDesc(in, resPool);
--- a/Runtime/Particle/CParticleSwoosh.cpp
+++ b/Runtime/Particle/CParticleSwoosh.cpp
@@ -69,7 +69,7 @@ CParticleSwoosh::CParticleSwoosh(const TToken<CSwooshDescription>& desc, int len
        {
            int maxVerts = x1b4_LENG * (x1b0_SPLN+1) * x1b8_SIDE * 4;
            m_cachedVerts.reserve(maxVerts);
-            CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
+            CGraphicsCommitResources([&](boo::IGraphicsDataFactory::Context& ctx)
            {
                m_vertBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(CParticleSwooshShaders::Vert), maxVerts);
                m_uniformBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CMatrix4f), 1);
--- a/Runtime/Particle/CParticleSwooshDataFactory.cpp
+++ b/Runtime/Particle/CParticleSwooshDataFactory.cpp
@@ -41,55 +41,55 @@ bool CParticleSwooshDataFactory::CreateWPSM(CSwooshDescription* desc, CInputStre
        switch (clsId)
        {
        case SBIG('PSLT'):
-            desc->x0_PSLT.reset(CPF::GetIntElement(in));
+            desc->x0_PSLT = CPF::GetIntElement(in);
            break;
        case SBIG('TIME'):
-            desc->x4_TIME.reset(CPF::GetRealElement(in));
+            desc->x4_TIME = CPF::GetRealElement(in);
            break;
        case SBIG('LRAD'):
-            desc->x8_LRAD.reset(CPF::GetRealElement(in));
+            desc->x8_LRAD = CPF::GetRealElement(in);
            break;
        case SBIG('RRAD'):
-            desc->xc_RRAD.reset(CPF::GetRealElement(in));
+            desc->xc_RRAD = CPF::GetRealElement(in);
            break;
        case SBIG('LENG'):
-            desc->x10_LENG.reset(CPF::GetIntElement(in));
+            desc->x10_LENG = CPF::GetIntElement(in);
            break;
        case SBIG('COLR'):
-            desc->x14_COLR.reset(CPF::GetColorElement(in));
+            desc->x14_COLR = CPF::GetColorElement(in);
            break;
        case SBIG('SIDE'):
-            desc->x18_SIDE.reset(CPF::GetIntElement(in));
+            desc->x18_SIDE = CPF::GetIntElement(in);
            break;
        case SBIG('IROT'):
-            desc->x1c_IROT.reset(CPF::GetRealElement(in));
+            desc->x1c_IROT = CPF::GetRealElement(in);
            break;
        case SBIG('ROTM'):
-            desc->x20_ROTM.reset(CPF::GetRealElement(in));
+            desc->x20_ROTM = CPF::GetRealElement(in);
            break;
        case SBIG('POFS'):
-            desc->x24_POFS.reset(CPF::GetVectorElement(in));
+            desc->x24_POFS = CPF::GetVectorElement(in);
            break;
        case SBIG('IVEL'):
-            desc->x28_IVEL.reset(CPF::GetVectorElement(in));
+            desc->x28_IVEL = CPF::GetVectorElement(in);
            break;
        case SBIG('NPOS'):
-            desc->x2c_NPOS.reset(CPF::GetVectorElement(in));
+            desc->x2c_NPOS = CPF::GetVectorElement(in);
            break;
        case SBIG('VELM'):
-            desc->x30_VELM.reset(CPF::GetModVectorElement(in));
+            desc->x30_VELM = CPF::GetModVectorElement(in);
            break;
        case SBIG('VLM2'):
-            desc->x34_VLM2.reset(CPF::GetModVectorElement(in));
+            desc->x34_VLM2 = CPF::GetModVectorElement(in);
            break;
        case SBIG('SPLN'):
-            desc->x38_SPLN.reset(CPF::GetIntElement(in));
+            desc->x38_SPLN = CPF::GetIntElement(in);
            break;
        case SBIG('TEXR'):
-            desc->x3c_TEXR.reset(CPF::GetTextureElement(in, resPool));
+            desc->x3c_TEXR = CPF::GetTextureElement(in, resPool);
            break;
        case SBIG('TSPN'):
-            desc->x40_TSPN.reset(CPF::GetIntElement(in));
+            desc->x40_TSPN = CPF::GetIntElement(in);
            break;
        case SBIG('LLRD'):
            desc->x44_24_LLRD = CPF::GetBool(in);
--- a/Runtime/Particle/CProjectileWeaponDataFactory.cpp
+++ b/Runtime/Particle/CProjectileWeaponDataFactory.cpp
@@ -43,34 +43,34 @@ bool CProjectileWeaponDataFactory::CreateWPSM(CWeaponDescription* desc, CInputSt
        switch (clsId)
        {
        case SBIG('IORN'):
-            desc->x0_IORN.reset(CPF::GetVectorElement(in));
+            desc->x0_IORN = CPF::GetVectorElement(in);
            break;
        case SBIG('IVEC'):
-            desc->x4_IVEC.reset(CPF::GetVectorElement(in));
+            desc->x4_IVEC = CPF::GetVectorElement(in);
            break;
        case SBIG('PSOV'):
-            desc->x8_PSOV.reset(CPF::GetVectorElement(in));
+            desc->x8_PSOV = CPF::GetVectorElement(in);
            break;
        case SBIG('PSVM'):
-            desc->xc_PSVM.reset(CPF::GetModVectorElement(in));
+            desc->xc_PSVM = CPF::GetModVectorElement(in);
            break;
        case SBIG('VMD2'):
            desc->x10_VMD2 = CPF::GetBool(in);
            break;
        case SBIG('PSLT'):
-            desc->x14_PSLT.reset(CPF::GetIntElement(in));
+            desc->x14_PSLT = CPF::GetIntElement(in);
            break;
        case SBIG('PSCL'):
-            desc->x18_PSCL.reset(CPF::GetVectorElement(in));
+            desc->x18_PSCL = CPF::GetVectorElement(in);
            break;
        case SBIG('PCOL'):
-            desc->x1c_PCOL.reset(CPF::GetColorElement(in));
+            desc->x1c_PCOL = CPF::GetColorElement(in);
            break;
        case SBIG('POFS'):
-            desc->x20_POFS.reset(CPF::GetVectorElement(in));
+            desc->x20_POFS = CPF::GetVectorElement(in);
            break;
        case SBIG('OFST'):
-            desc->x24_OFST.reset(CPF::GetVectorElement(in));
+            desc->x24_OFST = CPF::GetVectorElement(in);
            break;
        case SBIG('APSO'):
            desc->x28_APSO = CPF::GetBool(in);
@@ -94,7 +94,7 @@ bool CProjectileWeaponDataFactory::CreateWPSM(CWeaponDescription* desc, CInputSt
            desc->x2e_AS13 = CPF::GetBool(in);
            break;
        case SBIG('TRAT'):
-            desc->x30_TRAT.reset(CPF::GetRealElement(in));
+            desc->x30_TRAT = CPF::GetRealElement(in);
            break;
        case SBIG('APSM'):
        {
@@ -151,10 +151,10 @@ bool CProjectileWeaponDataFactory::CreateWPSM(CWeaponDescription* desc, CInputSt
            break;
        }
        case SBIG('RNGE'):
-            desc->xac_RNGE.reset(CPF::GetRealElement(in));
+            desc->xac_RNGE = CPF::GetRealElement(in);
            break;
        case SBIG('FOFF'):
-            desc->xb0_FOFF.reset(CPF::GetRealElement(in));
+            desc->xb0_FOFF = CPF::GetRealElement(in);
            break;
        default:
        {
--- a/Runtime/Particle/CRealElement.hpp
+++ b/Runtime/Particle/CRealElement.hpp
@@ -27,8 +27,8 @@ class CRELifetimeTween : public CRealElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CRELifetimeTween(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CRELifetimeTween(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -47,8 +47,8 @@ class CRETimeChain : public CRealElement
    std::unique_ptr<CRealElement> x8_b;
    std::unique_ptr<CIntElement> xc_swFrame;
 public:
-    CRETimeChain(CRealElement* a, CRealElement* b, CIntElement* c)
-    : x4_a(a), x8_b(b), xc_swFrame(c) {}
+    CRETimeChain(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CIntElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -57,8 +57,8 @@ class CREAdd : public CRealElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CREAdd(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CREAdd(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -68,8 +68,8 @@ class CREClamp : public CRealElement
    std::unique_ptr<CRealElement> x8_max;
    std::unique_ptr<CRealElement> xc_val;
 public:
-    CREClamp(CRealElement* a, CRealElement* b, CRealElement* c)
-    : x4_min(a), x8_max(b), xc_val(c) {}
+    CREClamp(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
+    : x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -78,8 +78,8 @@ class CREInitialRandom : public CRealElement
    std::unique_ptr<CRealElement> x4_min;
    std::unique_ptr<CRealElement> x8_max;
 public:
-    CREInitialRandom(CRealElement* a, CRealElement* b)
-    : x4_min(a), x8_max(b) {}
+    CREInitialRandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_min(std::move(a)), x8_max(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
    bool IsConstant() const {return true;}
 };
@@ -89,8 +89,8 @@ class CRERandom : public CRealElement
    std::unique_ptr<CRealElement> x4_min;
    std::unique_ptr<CRealElement> x8_max;
 public:
-    CRERandom(CRealElement* a, CRealElement* b)
-    : x4_min(a), x8_max(b) {}
+    CRERandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_min(std::move(a)), x8_max(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -99,8 +99,8 @@ class CREDotProduct : public CRealElement
    std::unique_ptr<CVectorElement> x4_a;
    std::unique_ptr<CVectorElement> x8_b;
 public:
-    CREDotProduct(CVectorElement* a, CVectorElement* b)
-        : x4_a(a), x8_b(b) {}
+    CREDotProduct(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
+        : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -109,8 +109,8 @@ class CREMultiply : public CRealElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CREMultiply(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CREMultiply(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -121,8 +121,9 @@ class CREPulse : public CRealElement
    std::unique_ptr<CRealElement> xc_valA;
    std::unique_ptr<CRealElement> x10_valB;
 public:
-    CREPulse(CIntElement* a, CIntElement* b, CRealElement* c, CRealElement* d)
-    : x4_aDuration(a), x8_bDuration(b), xc_valA(c), x10_valB(d) {}
+    CREPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+             std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_valA(std::move(c)), x10_valB(std::move(d)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -130,8 +131,8 @@ class CRETimeScale : public CRealElement
 {
    std::unique_ptr<CRealElement> x4_a;
 public:
-    CRETimeScale(CRealElement* a)
-    : x4_a(a) {}
+    CRETimeScale(std::unique_ptr<CRealElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -139,8 +140,8 @@ class CRELifetimePercent : public CRealElement
 {
    std::unique_ptr<CRealElement> x4_percentVal;
 public:
-    CRELifetimePercent(CRealElement* a)
-    : x4_percentVal(a) {}
+    CRELifetimePercent(std::unique_ptr<CRealElement>&& a)
+    : x4_percentVal(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -150,8 +151,9 @@ class CRESineWave : public CRealElement
    std::unique_ptr<CRealElement> x8_linearFrame;
    std::unique_ptr<CRealElement> xc_constantFrame;
 public:
-    CRESineWave(CRealElement* a, CRealElement* b, CRealElement* c)
-    : x4_magnitude(a), x8_linearFrame(b), xc_constantFrame(c) {}
+    CRESineWave(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                std::unique_ptr<CRealElement>&& c)
+    : x4_magnitude(std::move(a)), x8_linearFrame(std::move(b)), xc_constantFrame(std::move(c)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -160,8 +162,8 @@ class CREInitialSwitch : public CRealElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CREInitialSwitch(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CREInitialSwitch(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -172,8 +174,9 @@ class CRECompareLessThan : public CRealElement
    std::unique_ptr<CRealElement> xc_c;
    std::unique_ptr<CRealElement> x10_d;
 public:
-    CRECompareLessThan(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d)
-    : x4_a(a), x8_b(b), xc_c(c), x10_d(d) {}
+    CRECompareLessThan(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                       std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -184,8 +187,9 @@ class CRECompareEquals : public CRealElement
    std::unique_ptr<CRealElement> xc_c;
    std::unique_ptr<CRealElement> x10_d;
 public:
-    CRECompareEquals(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d)
-    : x4_a(a), x8_b(b), xc_c(c), x10_d(d) {}
+    CRECompareEquals(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                     std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -254,8 +258,8 @@ class CRESubtract : public CRealElement
    std::unique_ptr<CRealElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CRESubtract(CRealElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CRESubtract(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -263,8 +267,8 @@ class CREVectorMagnitude : public CRealElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CREVectorMagnitude(CVectorElement* a)
-    : x4_a(a) {}
+    CREVectorMagnitude(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -272,8 +276,8 @@ class CREVectorXToReal : public CRealElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CREVectorXToReal(CVectorElement* a)
-    : x4_a(a) {}
+    CREVectorXToReal(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -281,8 +285,8 @@ class CREVectorYToReal : public CRealElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CREVectorYToReal(CVectorElement* a)
-    : x4_a(a) {}
+    CREVectorYToReal(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -290,8 +294,8 @@ class CREVectorZToReal : public CRealElement
 {
    std::unique_ptr<CVectorElement> x4_a;
 public:
-    CREVectorZToReal(CVectorElement* a)
-    : x4_a(a) {}
+    CREVectorZToReal(std::unique_ptr<CVectorElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -299,8 +303,8 @@ class CRECEXT : public CRealElement
 {
    std::unique_ptr<CIntElement> x4_a;
 public:
-    CRECEXT(CIntElement* a)
-    : x4_a(a) {}
+    CRECEXT(std::unique_ptr<CIntElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -309,8 +313,8 @@ class CREIntTimesReal : public CRealElement
    std::unique_ptr<CIntElement> x4_a;
    std::unique_ptr<CRealElement> x8_b;
 public:
-    CREIntTimesReal(CIntElement* a, CRealElement* b)
-    : x4_a(a), x8_b(b) {}
+    CREIntTimesReal(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CRealElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, float& valOut) const;
 };

@@ -322,8 +326,11 @@ class CREConstantRange : public CRealElement
    std::unique_ptr<CRealElement> x10_inRange;
    std::unique_ptr<CRealElement> x14_outOfRange;
 public:
-    CREConstantRange(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d, CRealElement* e)
-        : x4_val(a), x8_min(b), xc_max(c), x10_inRange(d), x14_outOfRange(e) {}
+    CREConstantRange(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                     std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d,
+                     std::unique_ptr<CRealElement>&& e)
+        : x4_val(std::move(a)), x8_min(std::move(b)), xc_max(std::move(c)),
+          x10_inRange(std::move(d)), x14_outOfRange(std::move(e)) {}

    bool GetValue(int frame, float& valOut) const;
 };
@@ -332,8 +339,8 @@ class CREGetComponentRed : public CRealElement
 {
    std::unique_ptr<CColorElement> x4_a;
 public:
-    CREGetComponentRed(CColorElement* a)
-        : x4_a(a) {}
+    CREGetComponentRed(std::unique_ptr<CColorElement>&& a)
+        : x4_a(std::move(a)) {}

    bool GetValue(int frame, float& valOut) const;
 };
@@ -342,8 +349,8 @@ class CREGetComponentGreen : public CRealElement
 {
    std::unique_ptr<CColorElement> x4_a;
 public:
-    CREGetComponentGreen(CColorElement* a)
-        : x4_a(a) {}
+    CREGetComponentGreen(std::unique_ptr<CColorElement>&& a)
+        : x4_a(std::move(a)) {}

    bool GetValue(int frame, float& valOut) const;
 };
@@ -352,8 +359,8 @@ class CREGetComponentBlue : public CRealElement
 {
    std::unique_ptr<CColorElement> x4_a;
 public:
-    CREGetComponentBlue(CColorElement* a)
-        : x4_a(a) {}
+    CREGetComponentBlue(std::unique_ptr<CColorElement>&& a)
+        : x4_a(std::move(a)) {}

    bool GetValue(int frame, float& valOut) const;
 };
@@ -362,8 +369,8 @@ class CREGetComponentAlpha : public CRealElement
 {
    std::unique_ptr<CColorElement> x4_a;
 public:
-    CREGetComponentAlpha(CColorElement* a)
-        : x4_a(a) {}
+    CREGetComponentAlpha(std::unique_ptr<CColorElement>&& a)
+        : x4_a(std::move(a)) {}

    bool GetValue(int frame, float& valOut) const;
 };
--- a/Runtime/Particle/CUVElement.cpp
+++ b/Runtime/Particle/CUVElement.cpp
@@ -5,18 +5,15 @@
 namespace urde
 {

-CUVEAnimTexture::CUVEAnimTexture(TToken<CTexture>&& tex, CIntElement* a, CIntElement* b,
-                                 CIntElement* c, CIntElement* d, CIntElement* e, bool f)
-: x4_tex(std::move(tex)), x24_loop(f), x28_cycleFrames(e)
+CUVEAnimTexture::CUVEAnimTexture(TToken<CTexture>&& tex, std::unique_ptr<CIntElement>&& a,
+                                 std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c,
+                                 std::unique_ptr<CIntElement>&& d, std::unique_ptr<CIntElement>&& e, bool f)
+: x4_tex(std::move(tex)), x24_loop(f), x28_cycleFrames(std::move(e))
 {
    a->GetValue(0, x10_tileW);
-    delete a;
    b->GetValue(0, x14_tileH);
-    delete b;
    c->GetValue(0, x18_strideW);
-    delete c;
    d->GetValue(0, x1c_strideH);
-    delete d;

    int width = x4_tex.GetObj()->GetWidth();
    int height = x4_tex.GetObj()->GetHeight();
--- a/Runtime/Particle/CUVElement.hpp
+++ b/Runtime/Particle/CUVElement.hpp
@@ -55,8 +55,9 @@ struct CUVEAnimTexture : public CUVElement
    std::unique_ptr<CIntElement> x28_cycleFrames;
    std::vector<SUVElementSet> x2c_uvElems;
 public:
-    CUVEAnimTexture(TToken<CTexture>&& tex, CIntElement* a, CIntElement* b,
-                    CIntElement* c, CIntElement* d, CIntElement* e, bool f);
+    CUVEAnimTexture(TToken<CTexture>&& tex, std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+                    std::unique_ptr<CIntElement>&& c, std::unique_ptr<CIntElement>&& d,
+                    std::unique_ptr<CIntElement>&& e, bool f);
    TLockedToken<CTexture> GetValueTexture(int frame) const
    {
        return TLockedToken<CTexture>(x4_tex);
--- a/Runtime/Particle/CVectorElement.cpp
+++ b/Runtime/Particle/CVectorElement.cpp
@@ -61,8 +61,8 @@ bool CVEKeyframeEmitter::GetValue(int frame, zeus::CVector3f& valOut) const
    return false;
 }

-CVECone::CVECone(CVectorElement* a, CRealElement* b)
-: x4_direction(a), x8_magnitude(b)
+CVECone::CVECone(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b)
+: x4_direction(std::move(a)), x8_magnitude(std::move(b))
 {
    zeus::CVector3f av;
    x4_direction->GetValue(0, av);
@@ -136,8 +136,9 @@ bool CVEAdd::GetValue(int frame, zeus::CVector3f& valOut) const
    return false;
 }

-CVECircleCluster::CVECircleCluster(CVectorElement* a, CVectorElement* b, CIntElement* c, CRealElement* d)
-: x4_a(a), x24_magnitude(d)
+CVECircleCluster::CVECircleCluster(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+                                   std::unique_ptr<CIntElement>&& c, std::unique_ptr<CRealElement>&& d)
+: x4_a(std::move(a)), x24_magnitude(std::move(d))
 {
    int cv;
    c->GetValue(0, cv);
@@ -151,9 +152,6 @@ CVECircleCluster::CVECircleCluster(CVectorElement* a, CVectorElement* b, CIntEle
    else
        x8_xVec = bv.cross(zeus::CVector3f(1.f, 0.f, 0.f));
    x14_yVec = bv.cross(x8_xVec);
-
-    delete b;
-    delete c;
 }

 bool CVECircleCluster::GetValue(int frame, zeus::CVector3f& valOut) const
@@ -194,8 +192,11 @@ bool CVEFastConstant::GetValue(int frame, zeus::CVector3f& valOut) const
    return false;
 }

-CVECircle::CVECircle(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d, CRealElement* e)
-: x4_direction(a), x20_angleConstant(c), x24_angleLinear(d), x28_radius(e)
+CVECircle::CVECircle(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+                     std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d,
+                     std::unique_ptr<CRealElement>&& e)
+: x4_direction(std::move(a)), x20_angleConstant(std::move(c)),
+  x24_angleLinear(std::move(d)), x28_radius(std::move(e))
 {
    zeus::CVector3f bv;
    b->GetValue(0, bv);
@@ -205,7 +206,6 @@ CVECircle::CVECircle(CVectorElement* a, CVectorElement* b, CRealElement* c, CRea
    else
        x8_xVec = bv.cross(zeus::CVector3f(1.f, 0.f, 0.f));
    x14_yVec = bv.cross(x8_xVec);
-    delete b;
 }

 bool CVECircle::GetValue(int frame, zeus::CVector3f& valOut) const
--- a/Runtime/Particle/CVectorElement.hpp
+++ b/Runtime/Particle/CVectorElement.hpp
@@ -29,7 +29,7 @@ class CVECone : public CVectorElement
    zeus::CVector3f xc_xVec;
    zeus::CVector3f x18_yVec;
 public:
-    CVECone(CVectorElement* a, CRealElement* b);
+    CVECone(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b);
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -39,8 +39,9 @@ class CVETimeChain : public CVectorElement
    std::unique_ptr<CVectorElement> x8_b;
    std::unique_ptr<CIntElement> xc_swFrame;
 public:
-    CVETimeChain(CVectorElement* a, CVectorElement* b, CIntElement* c)
-    : x4_a(a), x8_b(b), xc_swFrame(c) {}
+    CVETimeChain(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+                 std::unique_ptr<CIntElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -52,8 +53,11 @@ class CVEAngleCone : public CVectorElement
    std::unique_ptr<CRealElement> x10_angleYRange;
    std::unique_ptr<CRealElement> x14_magnitude;
 public:
-    CVEAngleCone(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d, CRealElement* e)
-    : x4_angleXConstant(a), x8_angleYConstant(b), xc_angleXRange(c), x10_angleYRange(d), x14_magnitude(e) {}
+    CVEAngleCone(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
+                 std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d,
+                 std::unique_ptr<CRealElement>&& e)
+    : x4_angleXConstant(std::move(a)), x8_angleYConstant(std::move(b)),
+      xc_angleXRange(std::move(c)), x10_angleYRange(std::move(d)), x14_magnitude(std::move(e)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -62,8 +66,8 @@ class CVEAdd : public CVectorElement
    std::unique_ptr<CVectorElement> x4_a;
    std::unique_ptr<CVectorElement> x8_b;
 public:
-    CVEAdd(CVectorElement* a, CVectorElement* b)
-    : x4_a(a), x8_b(b) {}
+    CVEAdd(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -75,7 +79,8 @@ class CVECircleCluster : public CVectorElement
    float x20_deltaAngle;
    std::unique_ptr<CRealElement> x24_magnitude;
 public:
-    CVECircleCluster(CVectorElement* a, CVectorElement* b, CIntElement* c, CRealElement* d);
+    CVECircleCluster(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+                     std::unique_ptr<CIntElement>&& c, std::unique_ptr<CRealElement>&& d);
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -85,8 +90,8 @@ class CVEConstant : public CVectorElement
    std::unique_ptr<CRealElement> x8_b;
    std::unique_ptr<CRealElement> xc_c;
 public:
-    CVEConstant(CRealElement* a, CRealElement* b, CRealElement* c)
-    : x4_a(a), x8_b(b), xc_c(c) {}
+    CVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
+    : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -108,7 +113,9 @@ class CVECircle : public CVectorElement
    std::unique_ptr<CRealElement> x24_angleLinear;
    std::unique_ptr<CRealElement> x28_radius;
 public:
-    CVECircle(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d, CRealElement* e);
+    CVECircle(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
+              std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d,
+              std::unique_ptr<CRealElement>&& e);
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -117,8 +124,8 @@ class CVEMultiply : public CVectorElement
    std::unique_ptr<CVectorElement> x4_a;
    std::unique_ptr<CVectorElement> x8_b;
 public:
-    CVEMultiply(CVectorElement* a, CVectorElement* b)
-    : x4_a(a), x8_b(b) {}
+    CVEMultiply(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
+    : x4_a(std::move(a)), x8_b(std::move(b)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -126,8 +133,8 @@ class CVERealToVector : public CVectorElement
 {
    std::unique_ptr<CRealElement> x4_a;
 public:
-    CVERealToVector(CRealElement* a)
-    : x4_a(a) {}
+    CVERealToVector(std::unique_ptr<CRealElement>&& a)
+    : x4_a(std::move(a)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -138,8 +145,9 @@ class CVEPulse : public CVectorElement
    std::unique_ptr<CVectorElement> xc_aVal;
    std::unique_ptr<CVectorElement> x10_bVal;
 public:
-    CVEPulse(CIntElement* a, CIntElement* b, CVectorElement* c, CVectorElement* d)
-    : x4_aDuration(a), x8_bDuration(b), xc_aVal(c), x10_bVal(d) {}
+    CVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b,
+             std::unique_ptr<CVectorElement>&& c, std::unique_ptr<CVectorElement>&& d)
+    : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };

@@ -190,8 +198,8 @@ class CVESubtract : public CVectorElement
    std::unique_ptr<CVectorElement> x4_a;
    std::unique_ptr<CVectorElement> x8_b;
 public:
-    CVESubtract(CVectorElement* a, CVectorElement* b)
-        : x4_a(a), x8_b(b)
+    CVESubtract(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
+        : x4_a(std::move(a)), x8_b(std::move(b))
    {}
    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };
@@ -200,8 +208,8 @@ class CVEColorToVector : public CVectorElement
 {
    std::unique_ptr<CColorElement> x4_a;
 public:
-    CVEColorToVector(CColorElement* a)
-        : x4_a(a) {}
+    CVEColorToVector(std::unique_ptr<CColorElement>&& a)
+        : x4_a(std::move(a)) {}

    bool GetValue(int frame, zeus::CVector3f& valOut) const;
 };