RuntimeCommonB: Use the override specifier where applicable

Applies the override keyword where applicable to indicate visually where member function overriding is occurring. This only targets the RuntimeCommonB target as a starting point, which resolves around 900+ cases where the keyword could be used.
2025-12-08 13:44:56 +00:00 · 2019-08-09 08:45:18 -04:00
parent 5acf9ecbcf
commit 2059535b55
144 changed files with 1011 additions and 999 deletions
--- a/Runtime/Particle/CColorElement.hpp
+++ b/Runtime/Particle/CColorElement.hpp
@@ -17,7 +17,7 @@ class CCEKeyframeEmitter : public CColorElement {

 public:
  CCEKeyframeEmitter(CInputStream& in);
-  bool GetValue(int frame, zeus::CColor& colorOut) const;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEConstant : public CColorElement {
@@ -30,7 +30,7 @@ public:
  CCEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c,
              std::unique_ptr<CRealElement>&& d)
  : x4_r(std::move(a)), x8_g(std::move(b)), xc_b(std::move(c)), x10_a(std::move(d)) {}
-  bool GetValue(int frame, zeus::CColor& colorOut) const;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEFastConstant : public CColorElement {
@@ -38,7 +38,7 @@ class CCEFastConstant : public CColorElement {

 public:
  CCEFastConstant(float a, float b, float c, float d) : x4_val(a, b, c, d) {}
-  bool GetValue(int frame, zeus::CColor& colorOut) const;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCETimeChain : public CColorElement {
@@ -49,7 +49,7 @@ class CCETimeChain : public CColorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEFadeEnd : public CColorElement {
@@ -62,7 +62,7 @@ public:
  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;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEFade : public CColorElement {
@@ -73,7 +73,7 @@ class CCEFade : public CColorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEPulse : public CColorElement {
@@ -86,11 +86,11 @@ public:
  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;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };

 class CCEParticleColor : public CColorElement {
 public:
-  bool GetValue(int frame, zeus::CColor& colorOut) const;
+  bool GetValue(int frame, zeus::CColor& colorOut) const override;
 };
 } // namespace urde
--- a/Runtime/Particle/CElementGen.hpp
+++ b/Runtime/Particle/CElementGen.hpp
@@ -142,7 +142,7 @@ private:
 public:
  CElementGen(const TToken<CGenDescription>& gen, EModelOrientationType orientType = EModelOrientationType::Normal,
              EOptionalSystemFlags flags = EOptionalSystemFlags::One);
-  ~CElementGen();
+  ~CElementGen() override;

  boo::ObjToken<boo::IShaderDataBinding> m_normalDataBind[2];
  boo::ObjToken<boo::IShaderDataBinding> m_normalSubDataBind[2];
@@ -191,34 +191,34 @@ public:
  void RenderParticles();
  void RenderParticlesIndirectTexture();

-  bool Update(double);
-  void Render(const CActorLights* = nullptr);
-  void SetOrientation(const zeus::CTransform&);
-  void SetTranslation(const zeus::CVector3f&);
-  void SetGlobalOrientation(const zeus::CTransform&);
-  void SetGlobalTranslation(const zeus::CVector3f&);
-  void SetGlobalScale(const zeus::CVector3f&);
-  void SetLocalScale(const zeus::CVector3f&);
+  bool Update(double) override;
+  void Render(const CActorLights* = nullptr) override;
+  void SetOrientation(const zeus::CTransform&) override;
+  void SetTranslation(const zeus::CVector3f&) override;
+  void SetGlobalOrientation(const zeus::CTransform&) override;
+  void SetGlobalTranslation(const zeus::CVector3f&) override;
+  void SetGlobalScale(const zeus::CVector3f&) override;
+  void SetLocalScale(const zeus::CVector3f&) override;
  void SetGlobalOrientAndTrans(const zeus::CTransform& xf);
-  void SetParticleEmission(bool);
-  void SetModulationColor(const zeus::CColor&);
-  void SetGeneratorRate(float rate);
-  const zeus::CTransform& GetOrientation() const;
-  const zeus::CVector3f& GetTranslation() const;
-  const zeus::CTransform& GetGlobalOrientation() const;
-  const zeus::CVector3f& GetGlobalTranslation() const;
-  const zeus::CVector3f& GetGlobalScale() const;
-  const zeus::CColor& GetModulationColor() const;
-  float GetGeneratorRate() const { return x98_generatorRate; }
-  bool IsSystemDeletable() const;
-  std::optional<zeus::CAABox> GetBounds() const;
-  u32 GetParticleCount() const;
-  bool SystemHasLight() const;
-  CLight GetLight() const;
-  bool GetParticleEmission() const;
-  void DestroyParticles();
-  void Reset();
-  FourCC Get4CharId() const { return FOURCC('PART'); }
+  void SetParticleEmission(bool) override;
+  void SetModulationColor(const zeus::CColor&) override;
+  void SetGeneratorRate(float rate) override;
+  const zeus::CTransform& GetOrientation() const override;
+  const zeus::CVector3f& GetTranslation() const override;
+  const zeus::CTransform& GetGlobalOrientation() const override;
+  const zeus::CVector3f& GetGlobalTranslation() const override;
+  const zeus::CVector3f& GetGlobalScale() const override;
+  const zeus::CColor& GetModulationColor() const override;
+  float GetGeneratorRate() const override { return x98_generatorRate; }
+  bool IsSystemDeletable() const override;
+  std::optional<zeus::CAABox> GetBounds() const override;
+  u32 GetParticleCount() const override;
+  bool SystemHasLight() const override;
+  CLight GetLight() const override;
+  bool GetParticleEmission() const override;
+  void DestroyParticles() override;
+  void Reset() override;
+  FourCC Get4CharId() const override { return FOURCC('PART'); }
  size_t GetNumActiveChildParticles() const { return x290_activePartChildren.size(); }
  CParticleGen& GetActiveChildParticle(size_t idx) const { return *x290_activePartChildren[idx]; }
  bool IsIndirectTextured() const { return x28_loadedGenDesc->x54_x40_TEXR && x28_loadedGenDesc->x58_x44_TIND; }
--- a/Runtime/Particle/CEmitterElement.hpp
+++ b/Runtime/Particle/CEmitterElement.hpp
@@ -13,7 +13,7 @@ class CEESimpleEmitter : public CEmitterElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
 };

 class CVESphere : public CEmitterElement {
@@ -24,7 +24,7 @@ class CVESphere : public CEmitterElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
 };

 class CVEAngleSphere : public CEmitterElement {
@@ -48,7 +48,7 @@ public:
  , 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;
+  bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
 };

 } // namespace urde
--- a/Runtime/Particle/CFlameWarp.hpp
+++ b/Runtime/Particle/CFlameWarp.hpp
@@ -37,12 +37,12 @@ public:
  const zeus::CVector3f& GetFloatingPoint() const { return x80_floatingPoint; }
  void SetMaxDistSq(float d) { x8c_maxDistSq = d; }
  void SetStateManager(CStateManager& mgr) { x9c_stateMgr = &mgr; }
-  bool UpdateWarp() { return xa0_24_activated; }
-  void ModifyParticles(std::vector<CParticle>& particles);
-  void Activate(bool val) { xa0_24_activated = val; }
-  bool IsActivated() { return xa0_24_activated; }
+  bool UpdateWarp() override { return xa0_24_activated; }
+  void ModifyParticles(std::vector<CParticle>& particles) override;
+  void Activate(bool val) override { xa0_24_activated = val; }
+  bool IsActivated() override { return xa0_24_activated; }
  bool IsProcessed() const { return xa0_26_processed; }
-  FourCC Get4CharID() { return FOURCC('FWRP'); }
+  FourCC Get4CharID() override { return FOURCC('FWRP'); }
  void ResetPosition(const zeus::CVector3f& pos) {
    for (auto& vec : x4_collisionPoints) {
      vec = pos;
--- a/Runtime/Particle/CIntElement.hpp
+++ b/Runtime/Particle/CIntElement.hpp
@@ -17,8 +17,8 @@ class CIEKeyframeEmitter : public CIntElement {

 public:
  CIEKeyframeEmitter(CInputStream& in);
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEDeath : public CIntElement {
@@ -28,8 +28,8 @@ class CIEDeath : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEClamp : public CIntElement {
@@ -40,8 +40,8 @@ class CIEClamp : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIETimeChain : public CIntElement {
@@ -52,8 +52,8 @@ class CIETimeChain : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEAdd : public CIntElement {
@@ -62,8 +62,8 @@ class CIEAdd : public CIntElement {

 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEConstant : public CIntElement {
@@ -71,8 +71,8 @@ class CIEConstant : public CIntElement {

 public:
  CIEConstant(int val) : x4_val(val) {}
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEImpulse : public CIntElement {
@@ -80,8 +80,8 @@ class CIEImpulse : public CIntElement {

 public:
  CIEImpulse(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIELifetimePercent : public CIntElement {
@@ -89,8 +89,8 @@ class CIELifetimePercent : public CIntElement {

 public:
  CIELifetimePercent(std::unique_ptr<CIntElement>&& a) : x4_percentVal(std::move(a)) {}
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEInitialRandom : public CIntElement {
@@ -100,8 +100,8 @@ class CIEInitialRandom : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEPulse : public CIntElement {
@@ -114,8 +114,8 @@ public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEMultiply : public CIntElement {
@@ -125,8 +125,8 @@ class CIEMultiply : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIESampleAndHold : public CIntElement {
@@ -139,8 +139,8 @@ class CIESampleAndHold : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIERandom : public CIntElement {
@@ -150,8 +150,8 @@ class CIERandom : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIETimeScale : public CIntElement {
@@ -159,26 +159,26 @@ class CIETimeScale : public CIntElement {

 public:
  CIETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEGetCumulativeParticleCount : public CIntElement {
 public:
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEGetActiveParticleCount : public CIntElement {
 public:
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEGetEmitterTime : public CIntElement {
 public:
-  bool GetValue(int frame, int& valOut) const;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIEModulo : public CIntElement {
@@ -188,8 +188,8 @@ class CIEModulo : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 class CIESubtract : public CIntElement {
@@ -199,8 +199,8 @@ class CIESubtract : public CIntElement {
 public:
  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;
-  int GetMaxValue() const;
+  bool GetValue(int frame, int& valOut) const override;
+  int GetMaxValue() const override;
 };

 } // namespace urde
--- a/Runtime/Particle/CModVectorElement.hpp
+++ b/Runtime/Particle/CModVectorElement.hpp
@@ -21,7 +21,7 @@ public:
  , 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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEExponentialImplosion : public CModVectorElement {
@@ -39,7 +39,7 @@ public:
  , 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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVELinearImplosion : public CModVectorElement {
@@ -57,7 +57,7 @@ public:
  , 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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVETimeChain : public CModVectorElement {
@@ -69,7 +69,7 @@ public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEBounce : public CModVectorElement {
@@ -85,7 +85,7 @@ class CMVEBounce : public CModVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEConstant : public CModVectorElement {
@@ -96,7 +96,7 @@ class CMVEConstant : public CModVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEFastConstant : public CModVectorElement {
@@ -104,7 +104,7 @@ class CMVEFastConstant : public CModVectorElement {

 public:
  CMVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {}
-  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEGravity : public CModVectorElement {
@@ -112,7 +112,7 @@ class CMVEGravity : public CModVectorElement {

 public:
  CMVEGravity(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEExplode : public CModVectorElement {
@@ -122,7 +122,7 @@ class CMVEExplode : public CModVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVESetPosition : public CModVectorElement {
@@ -130,7 +130,7 @@ class CMVESetPosition : public CModVectorElement {

 public:
  CMVESetPosition(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEPulse : public CModVectorElement {
@@ -143,7 +143,7 @@ public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVEWind : public CModVectorElement {
@@ -153,7 +153,7 @@ class CMVEWind : public CModVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 class CMVESwirl : public CModVectorElement {
@@ -169,7 +169,7 @@ public:
  , x8_curveBinormal(std::move(b))
  , xc_filterGain(std::move(c))
  , x10_tangentialVelocity(std::move(d)) {}
-  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const;
+  bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
 };

 } // namespace urde
--- a/Runtime/Particle/CParticleElectric.hpp
+++ b/Runtime/Particle/CParticleElectric.hpp
@@ -105,39 +105,39 @@ private:
 public:
  CParticleElectric(const TToken<CElectricDescription>& desc);

-  bool Update(double);
-  void Render(const CActorLights* = nullptr);
-  void SetOrientation(const zeus::CTransform&);
-  void SetTranslation(const zeus::CVector3f&);
-  void SetGlobalOrientation(const zeus::CTransform&);
-  void SetGlobalTranslation(const zeus::CVector3f&);
-  void SetGlobalScale(const zeus::CVector3f&);
-  void SetLocalScale(const zeus::CVector3f&);
-  void SetParticleEmission(bool);
-  void SetModulationColor(const zeus::CColor&);
+  bool Update(double) override;
+  void Render(const CActorLights* = nullptr) override;
+  void SetOrientation(const zeus::CTransform&) override;
+  void SetTranslation(const zeus::CVector3f&) override;
+  void SetGlobalOrientation(const zeus::CTransform&) override;
+  void SetGlobalTranslation(const zeus::CVector3f&) override;
+  void SetGlobalScale(const zeus::CVector3f&) override;
+  void SetLocalScale(const zeus::CVector3f&) override;
+  void SetParticleEmission(bool) override;
+  void SetModulationColor(const zeus::CColor&) override;
  void SetOverrideIPos(const zeus::CVector3f& vec) { x178_overrideIPos.emplace(vec); }
  void SetOverrideIVel(const zeus::CVector3f& vec) { x188_overrideIVel.emplace(vec); }
  void SetOverrideFPos(const zeus::CVector3f& vec) { x198_overrideFPos.emplace(vec); }
  void SetOverrideFVel(const zeus::CVector3f& vec) { x1a8_overrideFVel.emplace(vec); }
-  const zeus::CTransform& GetOrientation() const;
-  const zeus::CVector3f& GetTranslation() const;
-  const zeus::CTransform& GetGlobalOrientation() const;
-  const zeus::CVector3f& GetGlobalTranslation() const;
-  const zeus::CVector3f& GetGlobalScale() const;
-  const zeus::CColor& GetModulationColor() const;
-  bool IsSystemDeletable() const;
-  std::optional<zeus::CAABox> GetBounds() const;
-  u32 GetParticleCount() const;
-  bool SystemHasLight() const;
-  CLight GetLight() const;
-  bool GetParticleEmission() const;
-  void DestroyParticles();
-  void Reset() {}
+  const zeus::CTransform& GetOrientation() const override;
+  const zeus::CVector3f& GetTranslation() const override;
+  const zeus::CTransform& GetGlobalOrientation() const override;
+  const zeus::CVector3f& GetGlobalTranslation() const override;
+  const zeus::CVector3f& GetGlobalScale() const override;
+  const zeus::CColor& GetModulationColor() const override;
+  bool IsSystemDeletable() const override;
+  std::optional<zeus::CAABox> GetBounds() const override;
+  u32 GetParticleCount() const override;
+  bool SystemHasLight() const override;
+  CLight GetLight() const override;
+  bool GetParticleEmission() const override;
+  void DestroyParticles() override;
+  void Reset() override {}
  void ForceParticleCreation(s32 count) {
    CGlobalRandom gRnd{x14c_randState};
    CreateNewParticles(count);
  }
-  FourCC Get4CharId() const { return FOURCC('ELSC'); }
+  FourCC Get4CharId() const override { return FOURCC('ELSC'); }
 };

 } // namespace urde
--- a/Runtime/Particle/CParticleSwoosh.hpp
+++ b/Runtime/Particle/CParticleSwoosh.hpp
@@ -129,35 +129,35 @@ class CParticleSwoosh : public CParticleGen {

 public:
  CParticleSwoosh(const TToken<CSwooshDescription>& desc, int);
-  ~CParticleSwoosh();
+  ~CParticleSwoosh() override;

  CSwooshDescription* GetDesc() { return x1c_desc.GetObj(); }

-  bool Update(double);
-  void Render(const CActorLights* = nullptr);
-  void SetOrientation(const zeus::CTransform&);
-  void SetTranslation(const zeus::CVector3f&);
-  void SetGlobalOrientation(const zeus::CTransform&);
-  void SetGlobalTranslation(const zeus::CVector3f&);
-  void SetGlobalScale(const zeus::CVector3f&);
-  void SetLocalScale(const zeus::CVector3f&);
-  void SetParticleEmission(bool);
-  void SetModulationColor(const zeus::CColor&);
-  const zeus::CTransform& GetOrientation() const;
-  const zeus::CVector3f& GetTranslation() const;
-  const zeus::CTransform& GetGlobalOrientation() const;
-  const zeus::CVector3f& GetGlobalTranslation() const;
-  const zeus::CVector3f& GetGlobalScale() const;
-  const zeus::CColor& GetModulationColor() const;
-  bool IsSystemDeletable() const;
-  std::optional<zeus::CAABox> GetBounds() const;
-  u32 GetParticleCount() const;
-  bool SystemHasLight() const;
-  CLight GetLight() const;
-  bool GetParticleEmission() const;
-  void DestroyParticles();
-  void Reset() {}
-  FourCC Get4CharId() const { return FOURCC('SWHC'); }
+  bool Update(double) override;
+  void Render(const CActorLights* = nullptr) override;
+  void SetOrientation(const zeus::CTransform&) override;
+  void SetTranslation(const zeus::CVector3f&) override;
+  void SetGlobalOrientation(const zeus::CTransform&) override;
+  void SetGlobalTranslation(const zeus::CVector3f&) override;
+  void SetGlobalScale(const zeus::CVector3f&) override;
+  void SetLocalScale(const zeus::CVector3f&) override;
+  void SetParticleEmission(bool) override;
+  void SetModulationColor(const zeus::CColor&) override;
+  const zeus::CTransform& GetOrientation() const override;
+  const zeus::CVector3f& GetTranslation() const override;
+  const zeus::CTransform& GetGlobalOrientation() const override;
+  const zeus::CVector3f& GetGlobalTranslation() const override;
+  const zeus::CVector3f& GetGlobalScale() const override;
+  const zeus::CColor& GetModulationColor() const override;
+  bool IsSystemDeletable() const override;
+  std::optional<zeus::CAABox> GetBounds() const override;
+  u32 GetParticleCount() const override;
+  bool SystemHasLight() const override;
+  CLight GetLight() const override;
+  bool GetParticleEmission() const override;
+  void DestroyParticles() override;
+  void Reset() override {}
+  FourCC Get4CharId() const override { return FOURCC('SWHC'); }
  void SetRenderGaps(bool r) { x1d0_27_renderGaps = r; }

  void DoWarmupUpdate() {
--- a/Runtime/Particle/CRealElement.hpp
+++ b/Runtime/Particle/CRealElement.hpp
@@ -17,7 +17,7 @@ class CREKeyframeEmitter : public CRealElement {

 public:
  CREKeyframeEmitter(CInputStream& in);
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRELifetimeTween : public CRealElement {
@@ -27,7 +27,7 @@ class CRELifetimeTween : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREConstant : public CRealElement {
@@ -35,8 +35,8 @@ class CREConstant : public CRealElement {

 public:
  CREConstant(float val) : x4_val(val) {}
-  bool GetValue(int frame, float& valOut) const;
-  bool IsConstant() const { return true; }
+  bool GetValue(int frame, float& valOut) const override;
+  bool IsConstant() const override { return true; }
 };

 class CRETimeChain : public CRealElement {
@@ -47,7 +47,7 @@ class CRETimeChain : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREAdd : public CRealElement {
@@ -57,7 +57,7 @@ class CREAdd : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREClamp : public CRealElement {
@@ -68,7 +68,7 @@ class CREClamp : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREInitialRandom : public CRealElement {
@@ -78,8 +78,8 @@ class CREInitialRandom : public CRealElement {
 public:
  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; }
+  bool GetValue(int frame, float& valOut) const override;
+  bool IsConstant() const override { return true; }
 };

 class CRERandom : public CRealElement {
@@ -89,7 +89,7 @@ class CRERandom : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREDotProduct : public CRealElement {
@@ -99,7 +99,7 @@ class CREDotProduct : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREMultiply : public CRealElement {
@@ -109,7 +109,7 @@ class CREMultiply : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREPulse : public CRealElement {
@@ -122,7 +122,7 @@ public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRETimeScale : public CRealElement {
@@ -130,7 +130,7 @@ class CRETimeScale : public CRealElement {

 public:
  CRETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRELifetimePercent : public CRealElement {
@@ -138,7 +138,7 @@ class CRELifetimePercent : public CRealElement {

 public:
  CRELifetimePercent(std::unique_ptr<CRealElement>&& a) : x4_percentVal(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRESineWave : public CRealElement {
@@ -149,7 +149,7 @@ class CRESineWave : public CRealElement {
 public:
  CRESineWave(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
  : x4_frequency(std::move(a)), x8_amplitude(std::move(b)), xc_phase(std::move(c)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREInitialSwitch : public CRealElement {
@@ -159,7 +159,7 @@ class CREInitialSwitch : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRECompareLessThan : public CRealElement {
@@ -172,7 +172,7 @@ public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRECompareEquals : public CRealElement {
@@ -185,57 +185,57 @@ public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam1 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam2 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam3 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam4 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam5 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam6 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam7 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleAccessParam8 : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleSizeOrLineLength : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREParticleRotationOrLineWidth : public CRealElement {
 public:
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRESubtract : public CRealElement {
@@ -245,7 +245,7 @@ class CRESubtract : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREVectorMagnitude : public CRealElement {
@@ -253,7 +253,7 @@ class CREVectorMagnitude : public CRealElement {

 public:
  CREVectorMagnitude(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREVectorXToReal : public CRealElement {
@@ -261,7 +261,7 @@ class CREVectorXToReal : public CRealElement {

 public:
  CREVectorXToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREVectorYToReal : public CRealElement {
@@ -269,7 +269,7 @@ class CREVectorYToReal : public CRealElement {

 public:
  CREVectorYToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREVectorZToReal : public CRealElement {
@@ -277,7 +277,7 @@ class CREVectorZToReal : public CRealElement {

 public:
  CREVectorZToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CRECEXT : public CRealElement {
@@ -285,7 +285,7 @@ class CRECEXT : public CRealElement {

 public:
  CRECEXT(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREIntTimesReal : public CRealElement {
@@ -295,7 +295,7 @@ class CREIntTimesReal : public CRealElement {
 public:
  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;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREConstantRange : public CRealElement {
@@ -315,7 +315,7 @@ public:
  , x10_inRange(std::move(d))
  , x14_outOfRange(std::move(e)) {}

-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREGetComponentRed : public CRealElement {
@@ -324,7 +324,7 @@ class CREGetComponentRed : public CRealElement {
 public:
  CREGetComponentRed(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}

-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREGetComponentGreen : public CRealElement {
@@ -333,7 +333,7 @@ class CREGetComponentGreen : public CRealElement {
 public:
  CREGetComponentGreen(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}

-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREGetComponentBlue : public CRealElement {
@@ -342,7 +342,7 @@ class CREGetComponentBlue : public CRealElement {
 public:
  CREGetComponentBlue(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}

-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };

 class CREGetComponentAlpha : public CRealElement {
@@ -351,6 +351,6 @@ class CREGetComponentAlpha : public CRealElement {
 public:
  CREGetComponentAlpha(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}

-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 } // namespace urde
--- a/Runtime/Particle/CUVElement.hpp
+++ b/Runtime/Particle/CUVElement.hpp
@@ -26,10 +26,10 @@ struct CUVEConstant : public CUVElement {

 public:
  CUVEConstant(TToken<CTexture>&& tex) : x4_tex(std::move(tex)) {}
-  TLockedToken<CTexture> GetValueTexture(int frame) const { return TLockedToken<CTexture>(x4_tex); }
-  void GetValueUV(int frame, SUVElementSet& valOut) const { valOut = {0.f, 0.f, 1.f, 1.f}; }
-  bool HasConstantTexture() const { return true; }
-  bool HasConstantUV() const { return true; }
+  TLockedToken<CTexture> GetValueTexture(int frame) const override { return TLockedToken<CTexture>(x4_tex); }
+  void GetValueUV(int frame, SUVElementSet& valOut) const override { valOut = {0.f, 0.f, 1.f, 1.f}; }
+  bool HasConstantTexture() const override { return true; }
+  bool HasConstantUV() const override { return true; }
 };

 struct CUVEAnimTexture : public CUVElement {
@@ -44,10 +44,10 @@ public:
  CUVEAnimTexture(TToken<CTexture>&& tex, std::unique_ptr<CIntElement>&& tileW, std::unique_ptr<CIntElement>&& tileH,
                  std::unique_ptr<CIntElement>&& strideW, std::unique_ptr<CIntElement>&& strideH,
                  std::unique_ptr<CIntElement>&& cycleFrames, bool loop);
-  TLockedToken<CTexture> GetValueTexture(int frame) const { return TLockedToken<CTexture>(x4_tex); }
-  void GetValueUV(int frame, SUVElementSet& valOut) const;
-  bool HasConstantTexture() const { return true; }
-  bool HasConstantUV() const { return false; }
+  TLockedToken<CTexture> GetValueTexture(int frame) const override { return TLockedToken<CTexture>(x4_tex); }
+  void GetValueUV(int frame, SUVElementSet& valOut) const override;
+  bool HasConstantTexture() const override { return true; }
+  bool HasConstantUV() const override { return false; }
 };

 } // namespace urde
--- a/Runtime/Particle/CVectorElement.hpp
+++ b/Runtime/Particle/CVectorElement.hpp
@@ -17,7 +17,7 @@ class CVEKeyframeEmitter : public CVectorElement {

 public:
  CVEKeyframeEmitter(CInputStream& in);
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVECone : public CVectorElement {
@@ -28,7 +28,7 @@ class CVECone : public CVectorElement {

 public:
  CVECone(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b);
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVETimeChain : public CVectorElement {
@@ -40,7 +40,7 @@ public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEAngleCone : public CVectorElement {
@@ -58,7 +58,7 @@ public:
  , xc_angleXRange(std::move(c))
  , x10_angleYRange(std::move(d))
  , x14_magnitude(std::move(e)) {}
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEAdd : public CVectorElement {
@@ -68,7 +68,7 @@ class CVEAdd : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVECircleCluster : public CVectorElement {
@@ -81,7 +81,7 @@ class CVECircleCluster : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEConstant : public CVectorElement {
@@ -92,7 +92,7 @@ class CVEConstant : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEFastConstant : public CVectorElement {
@@ -100,8 +100,8 @@ class CVEFastConstant : public CVectorElement {

 public:
  CVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {}
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
-  bool IsFastConstant() const { return true; }
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
+  bool IsFastConstant() const override { return true; }
 };

 class CVECircle : public CVectorElement {
@@ -115,7 +115,7 @@ class CVECircle : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEMultiply : public CVectorElement {
@@ -125,7 +125,7 @@ class CVEMultiply : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVERealToVector : public CVectorElement {
@@ -133,7 +133,7 @@ class CVERealToVector : public CVectorElement {

 public:
  CVERealToVector(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEPulse : public CVectorElement {
@@ -146,42 +146,42 @@ public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleVelocity : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleColor : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleLocation : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleSystemOrientationFront : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleSystemOrientationUp : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleSystemOrientationRight : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEParticleSystemTranslation : public CVectorElement {
 public:
-  bool GetValue(int frame, zeus::CVector3f& valOut) const;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVESubtract : public CVectorElement {
@@ -191,7 +191,7 @@ class CVESubtract : public CVectorElement {
 public:
  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;
+  bool GetValue(int frame, zeus::CVector3f& valOut) const override;
 };

 class CVEColorToVector : public CVectorElement {
@@ -200,7 +200,7 @@ class CVEColorToVector : public CVectorElement {
 public:
  CVEColorToVector(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}

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

 } // namespace urde