Revert override removal

include/Collision/CCollidableSphere.hpp

@@ -12,11 +12,11 @@ public:
   CCollidableSphere(const CSphere& sphere, const CMaterialList& material)
   : CCollisionPrimitive(material), x10_sphere(sphere) {}
 
-  uint GetTableIndex() const;
+  uint GetTableIndex() const override;
-  CAABox CalculateAABox(const CTransform4f&) const;
+  CAABox CalculateAABox(const CTransform4f&) const override;
-  CAABox CalculateLocalAABox() const;
+  CAABox CalculateLocalAABox() const override;
-  FourCC GetPrimType() const;
+  FourCC GetPrimType() const override;
-  ~CCollidableSphere() {}
+  ~CCollidableSphere() override {}
   CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const;
 
 private:

include/GuiSys/CGuiCompoundWidget.hpp

@@ -5,10 +5,10 @@
 
 class CGuiCompoundWidget : public CGuiWidget {
 public:
-  FourCC GetWidgetTypeID() const { return -1; }
+  FourCC GetWidgetTypeID() const override { return -1; }
 
-  void OnVisible();
+  void OnVisible() override;
-  void OnActivate();
+  void OnActivate() override;
   virtual CGuiWidget* GetWorkerWidget(int id) const;
 private:
 };

include/GuiSys/CGuiGroup.hpp

@@ -5,13 +5,13 @@
 
 class CGuiGroup : public CGuiCompoundWidget {
 public:
-  FourCC GetWidgetTypeID() const { return 'GRUP'; }
+  FourCC GetWidgetTypeID() const override { return 'GRUP'; }
 
   void SelectWorkerWidget(int workerId, bool setActive, bool setVisible);
   CGuiWidget* GetSelectedWidget();
   const CGuiWidget* GetSelectedWidget() const;
-  bool AddWorkerWidget(CGuiWidget* worker);
+  bool AddWorkerWidget(CGuiWidget* worker) override;
-  void OnActivate();
+  void OnActivate() override;
 
 private:
   uint xb8_workerCount;

include/GuiSys/CGuiModel.hpp

@@ -14,10 +14,10 @@ public:
             bool flag);
 
   const TLockedToken< CModel >& GetModel() const { return xb8_model; }
-  bool GetIsFinishedLoadingWidgetSpecific() const;
+  bool GetIsFinishedLoadingWidgetSpecific() const override;
-  void Touch() const;
+  void Touch() const override;
-  void Draw(const CGuiWidgetDrawParms& parms) const;
+  void Draw(const CGuiWidgetDrawParms& parms) const override;
-  // bool TestCursorHit(const CMatrix4f& vp, const CVector2f& point) const;
+  // bool TestCursorHit(const CMatrix4f& vp, const CVector2f& point) const override;
 
 private:
   TLockedToken< CModel > xb8_model;

include/GuiSys/CGuiPane.hpp

@@ -7,7 +7,7 @@ class CGuiPane : public CGuiWidget {
 public:
   CGuiPane(const CGuiWidgetParms& parms, const CVector2f& dim, const CVector3f& scaleCenter);
 
-  void Draw(const CGuiWidgetDrawParms& parms) const;
+  void Draw(const CGuiWidgetDrawParms& parms) const override;
   virtual void ScaleDimensions(const CVector3f& scale);
   virtual void SetDimensions(const CVector2f& dim, bool initVBO);
   virtual CVector2f GetDimensions() const;

include/GuiSys/CGuiTextPane.hpp

@@ -19,12 +19,12 @@ public:
 
   CGuiTextSupport& TextSupport() { return xd4_textSupport; }
   const CGuiTextSupport& GetTextSupport() const { return xd4_textSupport; }
-  void Update(float dt);
+  void Update(float dt) override;
-  bool GetIsFinishedLoadingWidgetSpecific() const;
+  bool GetIsFinishedLoadingWidgetSpecific() const override;
-  void SetDimensions(const CVector2f& dim, bool initVBO);
+  void SetDimensions(const CVector2f& dim, bool initVBO) override;
-  void ScaleDimensions(const CVector3f& scale);
+  void ScaleDimensions(const CVector3f& scale) override;
-  void Draw(const CGuiWidgetDrawParms& parms) const;
+  void Draw(const CGuiWidgetDrawParms& parms) const override;
-  // bool TestCursorHit(const CMatrix4f& vp, const CVector2f& point) const;
+  // bool TestCursorHit(const CMatrix4f& vp, const CVector2f& point) const override;
 
 private:
   CGuiTextSupport xd4_textSupport;

include/Kyoto/Alloc/CGameAllocator.hpp

@@ -70,23 +70,23 @@ public:
 
   bool Initialize(COsContext& ctx);
   void Shutdown();
-  void* Alloc(size_t size, EHint hint, EScope scope, EType type, const CCallStack& cs);
+  void* Alloc(size_t size, EHint hint, EScope scope, EType type, const CCallStack& cs) override;
   SGameMemInfo* FindFreeBlock(uint);
   SGameMemInfo* FindFreeBlockFromTopOfHeap(uint);
   uint FixupAllocPtrs(SGameMemInfo*, uint, uint, EHint, const CCallStack&);
   void UpdateAllocDebugStats(unsigned int, unsigned int, unsigned int);
-  bool Free(const void* ptr);
+  bool Free(const void* ptr) override;
   bool FreeNormalAllocation(const void* ptr);
-  void ReleaseAll();
+  void ReleaseAll() override;
   void* AllocSecondary(size_t size, EHint hint, EScope scope, EType type,
-                       const CCallStack& cs);
+                       const CCallStack& cs) override;
-  bool FreeSecondary(const void* ptr);
+  bool FreeSecondary(const void* ptr) override;
-  void ReleaseAllSecondary();
+  void ReleaseAllSecondary() override;
-  void SetOutOfMemoryCallback(FOutOfMemoryCb cb, const void* target);
+  void SetOutOfMemoryCallback(FOutOfMemoryCb cb, const void* target) override;
-  int EnumAllocations(FEnumAllocationsCb func, const void* ptr, bool b) const;
+  int EnumAllocations(FEnumAllocationsCb func, const void* ptr, bool b) const override;
-  SAllocInfo GetAllocInfo(const void* ptr) const;
+  SAllocInfo GetAllocInfo(const void* ptr) const override;
-  SMetrics GetMetrics() const;
+  SMetrics GetMetrics() const override;
-  void OffsetFakeStatics(int offset);
+  void OffsetFakeStatics(int offset) override;
 
   static uint GetFreeBinEntryForSize(uint);
   void AddFreeEntryToFreeList(SGameMemInfo*);

include/Kyoto/Input/CDolphinController.hpp

@@ -11,12 +11,12 @@ class CDolphinController : public IController {
 
 public:
   CDolphinController();
-  ~CDolphinController();
+  ~CDolphinController() override;
-  void Poll();
+  void Poll() override;
-  uint GetDeviceCount() const;
+  uint GetDeviceCount() const override;
-  CControllerGamepadData& GetGamepadData(int controller);
+  CControllerGamepadData& GetGamepadData(int controller) override;
-  uint GetControllerType(int) const;
+  uint GetControllerType(int) const override;
-  void SetMotorState(EIOPort port, EMotorState state);
+  void SetMotorState(EIOPort port, EMotorState state) override;
 
   bool Initialize();
   float GetAnalogStickMaxValue(EJoyAxis axis) const;

include/Kyoto/Particles/CColorElement.hpp

@@ -14,8 +14,8 @@ class CCEConstant : public CColorElement {
 
 public:
   CCEConstant(CRealElement* r, CRealElement* g, CRealElement* b, CRealElement* a);
-  ~CCEConstant();
+  ~CCEConstant() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCEFastConstant : public CColorElement {
@@ -23,8 +23,8 @@ class CCEFastConstant : public CColorElement {
 
 public:
   CCEFastConstant(float r, float g, float b, float a);
-  ~CCEFastConstant();
+  ~CCEFastConstant() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCEFade : public CColorElement {
@@ -34,8 +34,8 @@ class CCEFade : public CColorElement {
 
 public:
   CCEFade(CColorElement* a, CColorElement* b, CRealElement* end);
-  ~CCEFade();
+  ~CCEFade() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCEFadeEnd : public CColorElement {
@@ -46,8 +46,8 @@ class CCEFadeEnd : public CColorElement {
 
 public:
   CCEFadeEnd(CColorElement* a, CColorElement* b, CRealElement* start, CRealElement* end);
-  ~CCEFadeEnd();
+  ~CCEFadeEnd() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCETimeChain : public CColorElement {
@@ -57,8 +57,8 @@ class CCETimeChain : public CColorElement {
 
 public:
   CCETimeChain(CColorElement* a, CColorElement* b, CIntElement* c);
-  ~CCETimeChain();
+  ~CCETimeChain() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCEPulse : public CColorElement {
@@ -69,8 +69,8 @@ class CCEPulse : public CColorElement {
 
 public:
   CCEPulse(CIntElement* a, CIntElement* b, CColorElement* c, CColorElement* d);
-  ~CCEPulse();
+  ~CCEPulse() override;
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 class CCEKeyframeEmitter : public CColorElement {
@@ -84,14 +84,14 @@ class CCEKeyframeEmitter : public CColorElement {
 
 public:
   CCEKeyframeEmitter(CInputStream& in);
-  ~CCEKeyframeEmitter();
+  ~CCEKeyframeEmitter() override;
-  bool GetValue(int frame, CColor& valOut) const;
+  bool GetValue(int frame, CColor& valOut) const override;
 };
 
 class CCEParticleColor : public CColorElement {
 public:
-  ~CCEParticleColor() {}
+  ~CCEParticleColor() override {}
-  bool GetValue(int frame, CColor& colorOut) const;
+  bool GetValue(int frame, CColor& colorOut) const override;
 };
 
 #endif // _CCOLORELEMENT

include/Kyoto/Particles/CElementGen.hpp

@@ -43,34 +43,34 @@ public:
 
   CElementGen(TToken< CGenDescription >, EModelOrientationType = kMOT_Normal,
               EOptionalSystemFlags = kOSF_One);
-  ~CElementGen();
+  ~CElementGen() override;
 
-  virtual void Update(double);
+  virtual void Update(double) override;
-  virtual void Render() const;
+  virtual void Render() const override;
-  virtual void SetOrientation(const CTransform4f& orientation);
+  virtual void SetOrientation(const CTransform4f& orientation) override;
-  virtual void SetTranslation(const CVector3f& translation);
+  virtual void SetTranslation(const CVector3f& translation) override;
-  virtual void SetGlobalOrientation(const CTransform4f& orientation);
+  virtual void SetGlobalOrientation(const CTransform4f& orientation) override;
-  virtual void SetGlobalTranslation(const CVector3f& translation);
+  virtual void SetGlobalTranslation(const CVector3f& translation) override;
-  virtual void SetGlobalScale(const CVector3f& scale);
+  virtual void SetGlobalScale(const CVector3f& scale) override;
-  virtual void SetLocalScale(const CVector3f& scale);
+  virtual void SetLocalScale(const CVector3f& scale) override;
-  virtual void SetParticleEmission(bool emission);
+  virtual void SetParticleEmission(bool emission) override;
-  virtual void SetModulationColor(const CColor& col);
+  virtual void SetModulationColor(const CColor& col) override;
-  virtual void SetGeneratorRate(float rate) {}
+  virtual void SetGeneratorRate(float rate) override {}
-  virtual const CTransform4f& GetOrientation() const;
+  virtual const CTransform4f& GetOrientation() const override;
-  virtual const CVector3f& GetTranslation() const;
+  virtual const CVector3f& GetTranslation() const override;
-  virtual CTransform4f GetGlobalOrientation() const;
+  virtual CTransform4f GetGlobalOrientation() const override;
-  virtual CVector3f GetGlobalTranslation() const;
+  virtual CVector3f GetGlobalTranslation() const override;
-  virtual CVector3f GetGlobalScale() const;
+  virtual CVector3f GetGlobalScale() const override;
-  virtual bool GetParticleEmission() const;
+  virtual bool GetParticleEmission() const override;
-  virtual CColor GetModulationColor() const;
+  virtual CColor GetModulationColor() const override;
-  virtual bool IsSystemDeletable() const;
+  virtual bool IsSystemDeletable() const override;
-  virtual rstl::optional_object<CAABox> GetBounds() const;
+  virtual rstl::optional_object<CAABox> GetBounds() const override;
-  virtual int GetParticleCount() const;
+  virtual int GetParticleCount() const override;
-  virtual bool SystemHasLight() const;
+  virtual bool SystemHasLight() const override;
-  virtual CLight GetLight();
+  virtual CLight GetLight() override;
-  virtual void DestroyParticles();
+  virtual void DestroyParticles() override;
-  virtual void AddModifier(CWarp*);
+  virtual void AddModifier(CWarp*) override;
-  virtual uint Get4CharId() const;
+  virtual uint Get4CharId() const override;
 
   int GetEmitterTime() const;
   int GetSystemCount();

include/Kyoto/Particles/CIntElement.hpp

@@ -14,8 +14,8 @@ class CIEConstant : public CIntElement {
 
 public:
   CIEConstant(int val);
-  ~CIEConstant();
+  ~CIEConstant() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEDeath : public CIntElement {
@@ -24,8 +24,8 @@ class CIEDeath : public CIntElement {
 
 public:
   CIEDeath(CIntElement* a, CIntElement* b);
-  ~CIEDeath();
+  ~CIEDeath() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEAdd : public CIntElement {
@@ -34,8 +34,8 @@ class CIEAdd : public CIntElement {
 
 public:
   CIEAdd(CIntElement* a, CIntElement* b);
-  ~CIEAdd();
+  ~CIEAdd() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEMultiply : public CIntElement {
@@ -44,8 +44,8 @@ class CIEMultiply : public CIntElement {
 
 public:
   CIEMultiply(CIntElement* a, CIntElement* b);
-  ~CIEMultiply();
+  ~CIEMultiply() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEModulo : public CIntElement {
@@ -54,8 +54,8 @@ class CIEModulo : public CIntElement {
 
 public:
   CIEModulo(CIntElement* a, CIntElement* b);
-  ~CIEModulo();
+  ~CIEModulo() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIERandom : public CIntElement {
@@ -64,8 +64,8 @@ class CIERandom : public CIntElement {
 
 public:
   CIERandom(CIntElement* a, CIntElement* b);
-  ~CIERandom();
+  ~CIERandom() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIESampleAndHold : public CIntElement {
@@ -77,8 +77,8 @@ class CIESampleAndHold : public CIntElement {
 
 public:
   CIESampleAndHold(CIntElement* a, CIntElement* b, CIntElement* c);
-  ~CIESampleAndHold();
+  ~CIESampleAndHold() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEImpulse : public CIntElement {
@@ -86,8 +86,8 @@ class CIEImpulse : public CIntElement {
 
 public:
   CIEImpulse(CIntElement* a);
-  ~CIEImpulse();
+  ~CIEImpulse() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIETimescale : public CIntElement {
@@ -96,7 +96,7 @@ class CIETimescale : public CIntElement {
 public:
   CIETimescale(CRealElement* a);
   ~CIETimescale();
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEInitialRandom : public CIntElement {
@@ -105,8 +105,8 @@ class CIEInitialRandom : public CIntElement {
 
 public:
   CIEInitialRandom(CIntElement* a, CIntElement* b);
-  ~CIEInitialRandom();
+  ~CIEInitialRandom() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIETimeChain : public CIntElement {
@@ -116,8 +116,8 @@ class CIETimeChain : public CIntElement {
 
 public:
   CIETimeChain(CIntElement* a, CIntElement* b, CIntElement* c);
-  ~CIETimeChain();
+  ~CIETimeChain() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEClamp : public CIntElement {
@@ -127,8 +127,8 @@ class CIEClamp : public CIntElement {
 
 public:
   CIEClamp(CIntElement* a, CIntElement* b, CIntElement* c);
-  ~CIEClamp();
+  ~CIEClamp() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEPulse : public CIntElement {
@@ -139,8 +139,8 @@ class CIEPulse : public CIntElement {
 
 public:
   CIEPulse(CIntElement* a, CIntElement* b, CIntElement* c, CIntElement* d);
-  ~CIEPulse();
+  ~CIEPulse() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIELifetimePercent : public CIntElement {
@@ -148,8 +148,8 @@ class CIELifetimePercent : public CIntElement {
 
 public:
   CIELifetimePercent(CIntElement* a);
-  ~CIELifetimePercent();
+  ~CIELifetimePercent() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEKeyframeEmitter : public CIntElement {
@@ -163,8 +163,8 @@ class CIEKeyframeEmitter : public CIntElement {
 
 public:
   CIEKeyframeEmitter(CInputStream& in);
-  ~CIEKeyframeEmitter();
+  ~CIEKeyframeEmitter() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIESubtract : public CIntElement {
@@ -173,8 +173,8 @@ class CIESubtract : public CIntElement {
 
 public:
   CIESubtract(CIntElement* a, CIntElement* b);
-  ~CIESubtract();
+  ~CIESubtract() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIERealToInt : public CIntElement {
@@ -183,26 +183,26 @@ class CIERealToInt : public CIntElement {
 
 public:
   CIERealToInt(CRealElement* a, CRealElement* b);
-  ~CIERealToInt();
+  ~CIERealToInt() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEGetCumulativeParticleCount : public CIntElement {
 public:
-  ~CIEGetCumulativeParticleCount() {}
+  ~CIEGetCumulativeParticleCount() override {}
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEGetActiveParticleCount : public CIntElement {
 public:
-  ~CIEGetActiveParticleCount() {}
+  ~CIEGetActiveParticleCount() override {}
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 class CIEGetEmitterTime : public CIntElement {
 public:
-  ~CIEGetEmitterTime();
+  ~CIEGetEmitterTime() override;
-  bool GetValue(int frame, int& valOut) const;
+  bool GetValue(int frame, int& valOut) const override;
 };
 
 #endif // _CINTELEMENT

include/Kyoto/Particles/CModVectorElement.hpp

@@ -13,8 +13,8 @@ class CMVEConstant : public CModVectorElement {
 
 public:
   CMVEConstant(CRealElement* a, CRealElement* b, CRealElement* c);
-  ~CMVEConstant();
+  ~CMVEConstant() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEFastConstant : public CModVectorElement {
@@ -22,8 +22,8 @@ class CMVEFastConstant : public CModVectorElement {
 
 public:
   CMVEFastConstant(float a, float b, float c);
-  ~CMVEFastConstant();
+  ~CMVEFastConstant() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEGravity : public CModVectorElement {
@@ -31,8 +31,8 @@ class CMVEGravity : public CModVectorElement {
 
 public:
   CMVEGravity(CVectorElement* a);
-  ~CMVEGravity();
+  ~CMVEGravity() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEWind : public CModVectorElement {
@@ -41,8 +41,8 @@ class CMVEWind : public CModVectorElement {
 
 public:
   CMVEWind(CVectorElement* velocity, CRealElement* factor);
-  ~CMVEWind();
+  ~CMVEWind() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEExplode : public CModVectorElement {
@@ -51,8 +51,8 @@ class CMVEExplode : public CModVectorElement {
 
 public:
   CMVEExplode(CRealElement* a, CRealElement* b);
-  ~CMVEExplode();
+  ~CMVEExplode() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVETimeChain : public CModVectorElement {
@@ -62,8 +62,8 @@ class CMVETimeChain : public CModVectorElement {
 
 public:
   CMVETimeChain(CModVectorElement* a, CModVectorElement* b, CIntElement* c);
-  ~CMVETimeChain();
+  ~CMVETimeChain() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEPulse : public CModVectorElement {
@@ -74,8 +74,8 @@ class CMVEPulse : public CModVectorElement {
 
 public:
   CMVEPulse(CIntElement* a, CIntElement* b, CModVectorElement* c, CModVectorElement* d);
-  ~CMVEPulse();
+  ~CMVEPulse() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEImplosion : public CModVectorElement {
@@ -87,8 +87,8 @@ class CMVEImplosion : public CModVectorElement {
 
 public:
   CMVEImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d, bool e);
-  ~CMVEImplosion();
+  ~CMVEImplosion() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVELinearImplosion : public CModVectorElement {
@@ -100,8 +100,8 @@ class CMVELinearImplosion : public CModVectorElement {
 
 public:
   CMVELinearImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d, bool e);
-  ~CMVELinearImplosion();
+  ~CMVELinearImplosion() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEExponentialImplosion : public CModVectorElement {
@@ -114,8 +114,8 @@ class CMVEExponentialImplosion : public CModVectorElement {
 public:
   CMVEExponentialImplosion(CVectorElement* a, CRealElement* b, CRealElement* c, CRealElement* d,
                            bool e);
-  ~CMVEExponentialImplosion();
+  ~CMVEExponentialImplosion() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVESwirl : public CModVectorElement {
@@ -126,8 +126,8 @@ class CMVESwirl : public CModVectorElement {
 
 public:
   CMVESwirl(CVectorElement* a, CVectorElement* b, CRealElement* c, CRealElement* d);
-  ~CMVESwirl();
+  ~CMVESwirl() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVEBounce : public CModVectorElement {
@@ -143,8 +143,8 @@ class CMVEBounce : public CModVectorElement {
 public:
   CMVEBounce(CVectorElement* planePoint, CVectorElement* planeNormal, CRealElement* friction,
              CRealElement* restitution, bool e);
-  ~CMVEBounce();
+  ~CMVEBounce() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 class CMVESetPosition : public CModVectorElement {
@@ -152,8 +152,8 @@ class CMVESetPosition : public CModVectorElement {
 
 public:
   CMVESetPosition(CVectorElement* a);
-  ~CMVESetPosition();
+  ~CMVESetPosition() override;
-  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
+  bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
 };
 
 #endif // _CMODVECTORELEMENT

include/Kyoto/Particles/CParticleElectric.hpp

@@ -11,33 +11,33 @@ class CParticleElectric : public CParticleGen {
 public:
   explicit CParticleElectric(TToken<CElectricDescription> desc);
 
-  ~CParticleElectric();
+  ~CParticleElectric() override;
-  void Update(double);
+  void Update(double) override;
-  void Render() const;
+  void Render() const override;
-  void SetOrientation(const CTransform4f& orientation);
+  void SetOrientation(const CTransform4f& orientation) override;
-  void SetTranslation(const CVector3f& translation);
+  void SetTranslation(const CVector3f& translation) override;
-  void SetGlobalOrientation(const CTransform4f& orientation);
+  void SetGlobalOrientation(const CTransform4f& orientation) override;
-  void SetGlobalTranslation(const CVector3f& translation);
+  void SetGlobalTranslation(const CVector3f& translation) override;
-  void SetGlobalScale(const CVector3f& scale);
+  void SetGlobalScale(const CVector3f& scale) override;
-  void SetLocalScale(const CVector3f& scale);
+  void SetLocalScale(const CVector3f& scale) override;
-  void SetParticleEmission(bool emission);
+  void SetParticleEmission(bool emission) override;
-  void SetModulationColor(const CColor& col);
+  void SetModulationColor(const CColor& col) override;
   void SetGeneratorRate(float rate) {}
-  const CTransform4f& GetOrientation() const;
+  const CTransform4f& GetOrientation() const override;
-  const CVector3f& GetTranslation() const;
+  const CVector3f& GetTranslation() const override;
-  CTransform4f GetGlobalOrientation() const;
+  CTransform4f GetGlobalOrientation() const override;
-  CVector3f GetGlobalTranslation() const;
+  CVector3f GetGlobalTranslation() const override;
-  CVector3f GetGlobalScale() const;
+  CVector3f GetGlobalScale() const override;
-  bool GetParticleEmission() const;
+  bool GetParticleEmission() const override;
-  CColor GetModulationColor() const;
+  CColor GetModulationColor() const override;
-  bool IsSystemDeletable() const;
+  bool IsSystemDeletable() const override;
-  rstl::optional_object<CAABox> GetBounds() const;
+  rstl::optional_object<CAABox> GetBounds() const override;
-  int GetParticleCount() const;
+  int GetParticleCount() const override;
-  bool SystemHasLight() const;
+  bool SystemHasLight() const override;
-  CLight GetLight();
+  CLight GetLight() override;
-  void DestroyParticles();
+  void DestroyParticles() override;
-  void AddModifier(CWarp*);
+  void AddModifier(CWarp*) override;
-  uint Get4CharId() const;
+  uint Get4CharId() const override;
 
   
   void SetOverrideIPos(const CVector3f& vec) { x178_overrideIPos = vec; }

include/Kyoto/Particles/CRealElement.hpp

@@ -12,9 +12,9 @@ class CREConstant : public CRealElement {
 
 public:
   CREConstant(float val);
-  ~CREConstant();
+  ~CREConstant() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
-  bool IsConstant() const { return true; }
+  bool IsConstant() const override { return true; }
 };
 
 class CRESineWave : public CRealElement {
@@ -24,8 +24,8 @@ class CRESineWave : public CRealElement {
 
 public:
   CRESineWave(CRealElement* a, CRealElement* b, CRealElement* c);
-  ~CRESineWave();
+  ~CRESineWave() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRETimeScale : public CRealElement {
@@ -33,8 +33,8 @@ class CRETimeScale : public CRealElement {
 
 public:
   CRETimeScale(CRealElement* a);
-  ~CRETimeScale();
+  ~CRETimeScale() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREAdd : public CRealElement {
@@ -43,8 +43,8 @@ class CREAdd : public CRealElement {
 
 public:
   CREAdd(CRealElement* a, CRealElement* b);
-  ~CREAdd();
+  ~CREAdd() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREMultiply : public CRealElement {
@@ -53,8 +53,8 @@ class CREMultiply : public CRealElement {
 
 public:
   CREMultiply(CRealElement* a, CRealElement* b);
-  ~CREMultiply();
+  ~CREMultiply() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREDotProduct : public CRealElement {
@@ -63,8 +63,8 @@ class CREDotProduct : public CRealElement {
 
 public:
   CREDotProduct(CVectorElement* a, CVectorElement* b);
-  ~CREDotProduct();
+  ~CREDotProduct() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRERandom : public CRealElement {
@@ -73,8 +73,8 @@ class CRERandom : public CRealElement {
 
 public:
   CRERandom(CRealElement* min, CRealElement* max);
-  ~CRERandom();
+  ~CRERandom() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREInitialRandom : public CRealElement {
@@ -83,9 +83,9 @@ class CREInitialRandom : public CRealElement {
 
 public:
   CREInitialRandom(CRealElement* min, CRealElement* max);
-  ~CREInitialRandom();
+  ~CREInitialRandom() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
-  bool IsConstant() const { return true; }
+  bool IsConstant() const override { return true; }
 };
 
 class CRETimeChain : public CRealElement {
@@ -95,8 +95,8 @@ class CRETimeChain : public CRealElement {
 
 public:
   CRETimeChain(CRealElement* a, CRealElement* b, CIntElement* c);
-  ~CRETimeChain();
+  ~CRETimeChain() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREClamp : public CRealElement {
@@ -106,8 +106,8 @@ class CREClamp : public CRealElement {
 
 public:
   CREClamp(CRealElement* a, CRealElement* b, CRealElement* c);
-  ~CREClamp();
+  ~CREClamp() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREPulse : public CRealElement {
@@ -118,8 +118,8 @@ class CREPulse : public CRealElement {
 
 public:
   CREPulse(CIntElement* a, CIntElement* b, CRealElement* c, CRealElement* d);
-  ~CREPulse();
+  ~CREPulse() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRELifetimePercent : public CRealElement {
@@ -127,8 +127,8 @@ class CRELifetimePercent : public CRealElement {
 
 public:
   CRELifetimePercent(CRealElement* a); // : x4_percentVal(a) {}
-  ~CRELifetimePercent();
+  ~CRELifetimePercent() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRELifetimeTween : public CRealElement {
@@ -137,8 +137,8 @@ class CRELifetimeTween : public CRealElement {
 
 public:
   CRELifetimeTween(CRealElement* a, CRealElement* b);
-  ~CRELifetimeTween();
+  ~CRELifetimeTween() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREKeyframeEmitter : public CRealElement {
@@ -152,68 +152,68 @@ class CREKeyframeEmitter : public CRealElement {
 
 public:
   CREKeyframeEmitter(CInputStream& in);
-  ~CREKeyframeEmitter();
+  ~CREKeyframeEmitter() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter1 : public CRealElement {
 public:
-  ~CREParticleAccessParameter1() {}
+  ~CREParticleAccessParameter1() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter2 : public CRealElement {
 public:
-  ~CREParticleAccessParameter2() {}
+  ~CREParticleAccessParameter2() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter3 : public CRealElement {
 public:
-  ~CREParticleAccessParameter3() {}
+  ~CREParticleAccessParameter3() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter4 : public CRealElement {
 public:
-  ~CREParticleAccessParameter4() {}
+  ~CREParticleAccessParameter4() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter5 : public CRealElement {
 public:
-  ~CREParticleAccessParameter5() {}
+  ~CREParticleAccessParameter5() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter6 : public CRealElement {
 public:
-  ~CREParticleAccessParameter6() {}
+  ~CREParticleAccessParameter6() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter7 : public CRealElement {
 public:
-  ~CREParticleAccessParameter7() {}
+  ~CREParticleAccessParameter7() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleAccessParameter8 : public CRealElement {
 public:
-  ~CREParticleAccessParameter8() {}
+  ~CREParticleAccessParameter8() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleSizeOrLineLength : public CRealElement {
 public:
-  ~CREParticleSizeOrLineLength() {}
+  ~CREParticleSizeOrLineLength() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREParticleRotationOrLineWidth : public CRealElement {
 public:
-  ~CREParticleRotationOrLineWidth() {}
+  ~CREParticleRotationOrLineWidth() override {}
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREVectorXToReal : public CRealElement {
@@ -221,8 +221,8 @@ class CREVectorXToReal : public CRealElement {
 
 public:
   CREVectorXToReal(CVectorElement* a);
-  ~CREVectorXToReal();
+  ~CREVectorXToReal() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREVectorYToReal : public CRealElement {
@@ -230,8 +230,8 @@ class CREVectorYToReal : public CRealElement {
 
 public:
   CREVectorYToReal(CVectorElement* a);
-  ~CREVectorYToReal();
+  ~CREVectorYToReal() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREVectorZToReal : public CRealElement {
@@ -239,8 +239,8 @@ class CREVectorZToReal : public CRealElement {
 
 public:
   CREVectorZToReal(CVectorElement* a);
-  ~CREVectorZToReal();
+  ~CREVectorZToReal() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREVectorMagnitude : public CRealElement {
@@ -248,8 +248,8 @@ class CREVectorMagnitude : public CRealElement {
 
 public:
   CREVectorMagnitude(CVectorElement* a);
-  ~CREVectorMagnitude();
+  ~CREVectorMagnitude() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREInitialSwitch : public CRealElement {
@@ -258,8 +258,8 @@ class CREInitialSwitch : public CRealElement {
 
 public:
   CREInitialSwitch(CRealElement* a, CRealElement* b);
-  ~CREInitialSwitch();
+  ~CREInitialSwitch() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRECompareLessThan : public CRealElement {
@@ -270,8 +270,8 @@ class CRECompareLessThan : public CRealElement {
 
 public:
   CRECompareLessThan(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d);
-  ~CRECompareLessThan();
+  ~CRECompareLessThan() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRECompareEqual : public CRealElement {
@@ -282,8 +282,8 @@ class CRECompareEqual : public CRealElement {
 
 public:
   CRECompareEqual(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d);
-  ~CRECompareEqual();
+  ~CRECompareEqual() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREConstantRange : public CRealElement {
@@ -296,8 +296,8 @@ class CREConstantRange : public CRealElement {
 public:
   CREConstantRange(CRealElement* a, CRealElement* b, CRealElement* c, CRealElement* d,
                    CRealElement* e);
-  ~CREConstantRange();
+  ~CREConstantRange() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREExternalVar : public CRealElement {
@@ -305,8 +305,8 @@ class CREExternalVar : public CRealElement {
 
 public:
   CREExternalVar(CIntElement* a);
-  ~CREExternalVar();
+  ~CREExternalVar() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CRESubtract : public CRealElement {
@@ -315,8 +315,8 @@ class CRESubtract : public CRealElement {
 
 public:
   CRESubtract(CRealElement* a, CRealElement* b);
-  ~CRESubtract();
+  ~CRESubtract() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREGetComponentRed : public CRealElement {
@@ -324,8 +324,8 @@ class CREGetComponentRed : public CRealElement {
 
 public:
   CREGetComponentRed(CColorElement* a);
-  ~CREGetComponentRed();
+  ~CREGetComponentRed() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREGetComponentGreen : public CRealElement {
@@ -333,8 +333,8 @@ class CREGetComponentGreen : public CRealElement {
 
 public:
   CREGetComponentGreen(CColorElement* a);
-  ~CREGetComponentGreen();
+  ~CREGetComponentGreen() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREGetComponentBlue : public CRealElement {
@@ -342,8 +342,8 @@ class CREGetComponentBlue : public CRealElement {
 
 public:
   CREGetComponentBlue(CColorElement* a);
-  ~CREGetComponentBlue();
+  ~CREGetComponentBlue() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREGetComponentAlpha : public CRealElement {
@@ -351,8 +351,8 @@ class CREGetComponentAlpha : public CRealElement {
 
 public:
   CREGetComponentAlpha(CColorElement* a);
-  ~CREGetComponentAlpha();
+  ~CREGetComponentAlpha() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 class CREIntTimesReal : public CRealElement {
@@ -361,8 +361,8 @@ class CREIntTimesReal : public CRealElement {
 
 public:
   CREIntTimesReal(CIntElement* a, CRealElement* b);
-  ~CREIntTimesReal();
+  ~CREIntTimesReal() override;
-  bool GetValue(int frame, float& valOut) const;
+  bool GetValue(int frame, float& valOut) const override;
 };
 
 #endif // _CREALELEMENT

include/Kyoto/Particles/CUVElement.hpp

@@ -13,11 +13,11 @@ class CUVEConstant : public CUVElement {
 
 public:
   CUVEConstant(TToken< CTexture > tex);
-  ~CUVEConstant();
+  ~CUVEConstant() override;
-  TLockedToken< CTexture > GetValueTexture(int frame) const;
+  TLockedToken< CTexture > GetValueTexture(int frame) const override;
-  void GetValueUV(int frame, SUVElementSet& valOut) const;
+  void GetValueUV(int frame, SUVElementSet& valOut) const override;
-  bool HasConstantTexture() const { return true; }
+  bool HasConstantTexture() const override { return true; }
-  bool HasConstantUV() const { return true; }
+  bool HasConstantUV() const override { return true; }
 };
 
 class CUVEAnimTexture : public CUVElement {
@@ -34,11 +34,11 @@ class CUVEAnimTexture : public CUVElement {
 public:
   CUVEAnimTexture(TToken< CTexture > tex, CIntElement* tileW, CIntElement* tileH,
                   CIntElement* strideW, CIntElement* strideH, CIntElement* cycleFrames, bool loop);
-  ~CUVEAnimTexture();
+  ~CUVEAnimTexture() override;
-  TLockedToken< CTexture > GetValueTexture(int frame) const;
+  TLockedToken< CTexture > GetValueTexture(int frame) const override;
-  void GetValueUV(int frame, SUVElementSet& valOut) const;
+  void GetValueUV(int frame, SUVElementSet& valOut) const override;
-  bool HasConstantTexture() const { return true; }
+  bool HasConstantTexture() const override { return true; }
-  bool HasConstantUV() const { return false; }
+  bool HasConstantUV() const override { return false; }
 };
 
 #endif // _CUVELEMENT

include/Kyoto/Particles/CVectorElement.hpp

@@ -11,9 +11,9 @@
 class CVEFastConstant : public CVectorElement {
 public:
   CVEFastConstant(float x, float y, float z);
-  ~CVEFastConstant();
+  ~CVEFastConstant() override;
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
-  bool IsFastConstant() const { return true; }
+  bool IsFastConstant() const override { return true; }
 
 private:
   CVector3f x4_val;
@@ -21,51 +21,51 @@ private:
 
 class CVEParticleLocation : public CVectorElement {
 public:
-  ~CVEParticleLocation() {}
+  ~CVEParticleLocation() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleColor : public CVectorElement {
 public:
-  ~CVEParticleColor() {}
+  ~CVEParticleColor() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleVelocity : public CVectorElement {
 public:
-  ~CVEParticleVelocity() {}
+  ~CVEParticleVelocity() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleSystemOrientationFront : public CVectorElement {
 public:
-  ~CVEParticleSystemOrientationFront() {}
+  ~CVEParticleSystemOrientationFront() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleSystemOrientationUp : public CVectorElement {
 public:
-  ~CVEParticleSystemOrientationUp() {}
+  ~CVEParticleSystemOrientationUp() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleSystemOrientationRight : public CVectorElement {
 public:
-  ~CVEParticleSystemOrientationRight() {}
+  ~CVEParticleSystemOrientationRight() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEParticleSystemTranslation : public CVectorElement {
 public:
-  ~CVEParticleSystemTranslation() {}
+  ~CVEParticleSystemTranslation() override {}
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEConstant : public CVectorElement {
 public:
   CVEConstant(CRealElement* x, CRealElement* y, CRealElement* z);
   ~CVEConstant();
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 
 public:
   CRealElement* x4_x;
@@ -82,7 +82,7 @@ class CVECone : public CVectorElement {
 public:
   CVECone(CVectorElement* direction, CRealElement* magnitude);
   ~CVECone();
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 class CVEAngleCone : public CVectorElement {
@@ -96,7 +96,7 @@ public:
   CVEAngleCone(CRealElement* angleXConstant, CRealElement* angleYConstant,
                CRealElement* angleXRange, CRealElement* angleYRange, CRealElement* magnitude);
   ~CVEAngleCone();
-  bool GetValue(int frame, CVector3f& valOut) const;
+  bool GetValue(int frame, CVector3f& valOut) const override;
 };
 
 #endif // _CVECTORELEMENT

include/Kyoto/Particles/IElement.hpp

@@ -27,7 +27,7 @@ public:
 
 class CIntElement : public IElement {
 public:
-  ~CIntElement() {};
+  ~CIntElement() override{};
   virtual bool GetValue(int frame, int& valOut) const = 0;
 };
 

include/Kyoto/Streams/CMemoryInStream.hpp

@@ -12,8 +12,8 @@ public:
 
   CMemoryInStream(const void* ptr, unsigned long len);
   CMemoryInStream(const void* ptr, unsigned long len, EOwnerShip ownership);
-  virtual ~CMemoryInStream() {}
+  virtual ~CMemoryInStream() override {}
-  virtual size_t Read(void* dest, size_t len);
+  virtual size_t Read(void* dest, size_t len) override;
 };
 
 #endif // _CMEMORYINSTREAM

include/Kyoto/Streams/CZipInputStream.hpp

@@ -13,8 +13,8 @@
 class CZipInputStream : public CInputStream {
 public:
   CZipInputStream(rstl::auto_ptr< CInputStream > in);
-  ~CZipInputStream();
+  ~CZipInputStream() override;
-  size_t Read(void* dest, size_t len);
+  size_t Read(void* dest, size_t len) override;
 
 private:
   rstl::single_ptr<uchar> mCompBuf;

include/MetaRender/CCubeRenderer.hpp

@@ -22,75 +22,75 @@ class CModel;
 
 class CCubeRenderer : public IRenderer, public IWeaponRenderer {
 public:
-  ~CCubeRenderer();
+  ~CCubeRenderer() override;
   // TODO types
-  void AddStaticGeometry();
+  void AddStaticGeometry() override;
-  void EnablePVS(const CPVSVisSet& set, int areaIdx);
+  void EnablePVS(const CPVSVisSet& set, int areaIdx) override;
-  void DisablePVS();
+  void DisablePVS() override;
-  void RemoveStaticGeometry();
+  void RemoveStaticGeometry() override;
-  void DrawUnsortedGeometry(int areaIdx, int mask, int targetMask);
+  void DrawUnsortedGeometry(int areaIdx, int mask, int targetMask) override;
-  void DrawSortedGeometry(int areaIdx, int mask, int targetMask);
+  void DrawSortedGeometry(int areaIdx, int mask, int targetMask) override;
-  void DrawStaticGeometry(int areaIdx, int mask, int targetMask);
+  void DrawStaticGeometry(int areaIdx, int mask, int targetMask) override;
-  void DrawAreaGeometry(int areaIdx, int mask, int targetMask);
+  void DrawAreaGeometry(int areaIdx, int mask, int targetMask) override;
-  void PostRenderFogs();
+  void PostRenderFogs() override;
-  void SetModelMatrix(const CTransform4f& xf);
+  void SetModelMatrix(const CTransform4f& xf) override;
-  void AddParticleGen(const CParticleGen& gen);
+  void AddParticleGen(const CParticleGen& gen) override;
-  void AddParticleGen2();
+  void AddParticleGen2() override;
-  void AddPlaneObject();
+  void AddPlaneObject() override;
   void AddDrawable(const void* obj, const CVector3f& pos, const CAABox& bounds, int mode,
-                   IRenderer::EDrawableSorting sorting);
+                   IRenderer::EDrawableSorting sorting) override;
-  void SetDrawableCallback(TDrawableCallback cb, void* ctx);
+  void SetDrawableCallback(TDrawableCallback cb, void* ctx) override;
-  void SetWorldViewpoint();
+  void SetWorldViewpoint() override;
-  void SetPerspective1(float, float, float, float, float);
+  void SetPerspective1(float, float, float, float, float) override;
-  void SetPerspective2();
+  void SetPerspective2() override;
   rstl::pair< CVector2f, CVector2f > SetViewportOrtho(bool centered, float znear,
-                                                      float zfar);
+                                                      float zfar) override;
-  void SetClippingPlanes(const CFrustumPlanes&);
+  void SetClippingPlanes(const CFrustumPlanes&) override;
-  void SetViewport(int left, int right, int width, int height);
+  void SetViewport(int left, int right, int width, int height) override;
-  void SetDepthReadWrite(bool read, bool update);
+  void SetDepthReadWrite(bool read, bool update) override;
-  void SetBlendMode_AdditiveAlpha();
+  void SetBlendMode_AdditiveAlpha() override;
-  void SetBlendMode_AlphaBlended();
+  void SetBlendMode_AlphaBlended() override;
-  void SetBlendMode_NoColorWrite();
+  void SetBlendMode_NoColorWrite() override;
-  void SetBlendMode_ColorMultiply();
+  void SetBlendMode_ColorMultiply() override;
-  void SetBlendMode_InvertDst();
+  void SetBlendMode_InvertDst() override;
-  void SetBlendMode_InvertSrc();
+  void SetBlendMode_InvertSrc() override;
-  void SetBlendMode_Replace();
+  void SetBlendMode_Replace() override;
-  void SetBlendMode_AdditiveDestColor();
+  void SetBlendMode_AdditiveDestColor() override;
-  void SetDebugOption();
+  void SetDebugOption() override;
-  void BeginScene();
+  void BeginScene() override;
-  void EndScene();
+  void EndScene() override;
-  void BeginPrimitive(GXPrimitive prim, int count);
+  void BeginPrimitive(GXPrimitive prim, int count) override;
-  void BeginLines(int nverts);
+  void BeginLines(int nverts) override;
-  void BeginLineStrip(int nverts);
+  void BeginLineStrip(int nverts) override;
-  void BeginTriangles(int nverts);
+  void BeginTriangles(int nverts) override;
-  void BeginTriangleStrip(int nverts);
+  void BeginTriangleStrip(int nverts) override;
-  void BeginTriangleFan(int nverts);
+  void BeginTriangleFan(int nverts) override;
-  void PrimVertex(const CVector3f& vtx);
+  void PrimVertex(const CVector3f& vtx) override;
-  void PrimNormal(const CVector3f& nrm);
+  void PrimNormal(const CVector3f& nrm) override;
-  void PrimColor(float r, float g, float b, float a);
+  void PrimColor(float r, float g, float b, float a) override;
-  void PrimColor(const CColor& color);
+  void PrimColor(const CColor& color) override;
-  void EndPrimitive();
+  void EndPrimitive() override;
-  void SetAmbientColor(const CColor& color);
+  void SetAmbientColor(const CColor& color) override;
-  void DrawString();
+  void DrawString() override;
-  void GetFPS();
+  void GetFPS() override;
-  void CacheReflection();
+  void CacheReflection() override;
-  void DrawSpaceWarp();
+  void DrawSpaceWarp() override;
-  void DrawThermalModel();
+  void DrawThermalModel() override;
-  void DrawModelDisintegrate();
+  void DrawModelDisintegrate() override;
-  void DrawModelFlat();
+  void DrawModelFlat() override;
-  void SetWireframeFlags();
+  void SetWireframeFlags() override;
-  void SetWorldFog();
+  void SetWorldFog() override;
   void RenderFogVolume(const CColor&, const CAABox&, const TLockedToken< CModel >*,
-                       const CSkinnedModel*);
+                       const CSkinnedModel*) override;
-  void SetThermal();
+  void SetThermal() override;
-  void SetThermalColdScale();
+  void SetThermalColdScale() override;
-  void DoThermalBlendCold();
+  void DoThermalBlendCold() override;
-  void DoThermalBlendHot();
+  void DoThermalBlendHot() override;
-  void GetStaticWorldDataSize();
+  void GetStaticWorldDataSize() override;
-  void SetGXRegister1Color();
+  void SetGXRegister1Color() override;
-  void SetWorldLightFadeLevel();
+  void SetWorldLightFadeLevel() override;
-  void Something();
+  void Something() override;
-  void PrepareDynamicLights(const rstl::vector<CLight>& lights);
+  void PrepareDynamicLights(const rstl::vector<CLight>& lights) override;
 
   void AllocatePhazonSuitMaskTexture();
 

include/MetroidPrime/BodyState/CABSAim.hpp

@@ -6,9 +6,9 @@
 class CABSAim : public CAdditiveBodyState {
 public:
   CABSAim();
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
 private:
   bool x4_needsIdle;

include/MetroidPrime/BodyState/CABSFlinch.hpp

@@ -10,9 +10,9 @@ class CABSFlinch : public CAdditiveBodyState {
 
 public:
   CABSFlinch();
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
   ~CABSFlinch();
 };
 

include/MetroidPrime/BodyState/CABSIdle.hpp

@@ -7,9 +7,9 @@ class CABSIdle : public CAdditiveBodyState {
   pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc) const;
 
 public:
-  void Start(CBodyController& bc, CStateManager& mgr) {}
+  void Start(CBodyController& bc, CStateManager& mgr) override {}
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc) {}
+  void Shutdown(CBodyController& bc) override {}
 };
 
 #endif // _CABSIDLE

include/MetroidPrime/BodyState/CABSReaction.hpp

@@ -8,9 +8,9 @@ public:
   CABSReaction();
   ~CABSReaction();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
   float GetWeight() const { return x4_weight; }
   bool IsActive() const { return x10_active; }

include/MetroidPrime/BodyState/CBSAttack.hpp

@@ -11,10 +11,10 @@ class CBSAttack : public CBodyState {
 public:
   CBSAttack();
   
-  bool CanShoot() const { return false; }
+  bool CanShoot() const override { return false; }
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   pas::EAnimationState x4_nextState; // = pas::kAS_Invalid;

include/MetroidPrime/BodyState/CBSCover.hpp

@@ -6,12 +6,12 @@
 class CBSCover : public CBodyState {
 public:
   CBSCover();
-  bool IsMoving() const { return true; }
+  bool IsMoving() const override { return true; }
-  bool ApplyHeadTracking() const { return false; }
+  bool ApplyHeadTracking() const override { return false; }
-  bool CanShoot() const;
+  bool CanShoot() const override;
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
   pas::ECoverDirection GetCoverDirection() const { return x8_coverDirection; }
   bool GetNeedsExit() const { return xc_needsExit; }

include/MetroidPrime/BodyState/CBSDie.hpp

@@ -8,11 +8,11 @@ public:
   CBSDie();
   ~CBSDie();
 
-  bool IsDead() const;
+  bool IsDead() const override;
-  bool IsDying() const;
+  bool IsDying() const override;
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   float x4_remTime;

include/MetroidPrime/BodyState/CBSFall.hpp

@@ -8,9 +8,9 @@ public:
   CBSFall();
   ~CBSFall();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
 private:
   float x4_rotateSpeed;

include/MetroidPrime/BodyState/CBSGenerate.hpp

@@ -8,9 +8,9 @@ public:
   CBSGenerate();
   ~CBSGenerate();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);

include/MetroidPrime/BodyState/CBSGetup.hpp

@@ -8,9 +8,9 @@ public:
   CBSGetup();
   ~CBSGetup();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
 private:
   pas::EFallState x4_fallState;

include/MetroidPrime/BodyState/CBSGroundHit.hpp

@@ -8,9 +8,9 @@ public:
 CBSGroundHit();
 ~CBSGroundHit();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
 private:
   float x4_rotateSpeed;

include/MetroidPrime/BodyState/CBSKnockBack.hpp

@@ -8,10 +8,10 @@ public:
   CBSKnockBack();
   ~CBSKnockBack();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
-  bool IsMoving() const;
+  bool IsMoving() const override;
 
 private:
   float x4_curTime;

include/MetroidPrime/BodyState/CBSLieOnGround.hpp

@@ -10,9 +10,9 @@ public:
   explicit CBSLieOnGround(const CActor& actor);
   ~CBSLieOnGround();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
 
 private:
   uint x4_24_hasGroundHit : 1;

include/MetroidPrime/BodyState/CBSLocomotion.hpp

@@ -14,10 +14,10 @@ protected:
 
 public:
   bool IsMoving() const override = 0;
-  bool CanShoot() const { return true; }
+  bool CanShoot() const override { return true; }
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController& bc);
+  void Shutdown(CBodyController& bc) override;
   virtual bool IsPitchable() const { return false; }
   virtual float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const = 0;
   virtual float ApplyLocomotionPhysics(float dt, CBodyController& bc);

include/MetroidPrime/BodyState/CBSLoopAttack.hpp

@@ -7,10 +7,10 @@ class CBSLoopAttack : public CBodyState {
 public:
   CBSLoopAttack();
 
-  bool CanShoot() const { return true; }
+  bool CanShoot() const override { return true; }
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
   pas::ELoopState GetState() const { return x4_state; }
   pas::ELoopAttackType GetAttackType() const { return x8_loopAttackType; }

include/MetroidPrime/BodyState/CBSLoopReaction.hpp

@@ -7,9 +7,9 @@ class CBSLoopReaction : public CBodyState {
 public:
   CBSLoopReaction();
   
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&) {}
+  void Shutdown(CBodyController&) override {}
 
 private:
   pas::ELoopState x4_state;

include/MetroidPrime/BodyState/CBSProjectileAttack.hpp

@@ -8,10 +8,10 @@ public:
   CBSProjectileAttack();
   ~CBSProjectileAttack();
 
-  bool CanShoot() const;
+  bool CanShoot() const override;
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);

include/MetroidPrime/BodyState/CBSScripted.hpp

@@ -8,10 +8,10 @@ public:
   CBSScripted();
   ~CBSScripted();
 
-  bool ApplyHeadTracking() const;
+  bool ApplyHeadTracking() const override;
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   bool x4_24_loopAnim : 1;

include/MetroidPrime/BodyState/CBSSlide.hpp

@@ -10,11 +10,11 @@ public:
   CBSSlide();
   ~CBSSlide();
   
-  bool ApplyHeadTracking() const;
+  bool ApplyHeadTracking() const override;
-  bool IsMoving() const;
+  bool IsMoving() const override;
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 private:
   float x4_rotateSpeed;

include/MetroidPrime/BodyState/CBSStep.hpp

@@ -8,11 +8,11 @@ public:
   CBSStep();
   ~CBSStep();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
-  bool IsMoving() const;
+  bool IsMoving() const override;
-  bool CanShoot() const;
+  bool CanShoot() const override;
 
 private:
   pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);

include/MetroidPrime/BodyState/CBSTaunt.hpp

@@ -8,9 +8,9 @@ public:
   CBSTaunt();
   ~CBSTaunt();
 
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
   private:
   pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);

include/MetroidPrime/BodyState/CBSTurn.hpp

@@ -8,12 +8,12 @@
 class CBSTurn : public CBodyState {
 public:
   CBSTurn();
-  ~CBSTurn() {}
+  ~CBSTurn() override {}
 
-  bool CanShoot() const { return true; }
+  bool CanShoot() const override { return true; }
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
-  void Shutdown(CBodyController&);
+  void Shutdown(CBodyController&) override;
 
 protected:
   float x4_rotateSpeed;
@@ -28,8 +28,8 @@ protected:
 class CBSFlyerTurn : public CBSTurn {
 public:
   CBSFlyerTurn();
-  void Start(CBodyController& bc, CStateManager& mgr);
+  void Start(CBodyController& bc, CStateManager& mgr) override;
-  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
+  pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
 };
 
 #endif // _CBSTURN

include/MetroidPrime/BodyState/CBodyStateCmdMgr.hpp

@@ -156,7 +156,7 @@ public:
   CBCSlideCmd(pas::ESlideType type, const CVector3f& dir)
   : CBodyStateCmd(kBSC_Slide), x8_type(type), xc_dir(dir) {}
 
-  ~CBCSlideCmd() {}
+  ~CBCSlideCmd() override {}
 
   pas::ESlideType GetSlideType() const { return x8_type; }
   const CVector3f& GetSlideDirection() const { return xc_dir; }

include/MetroidPrime/CActor.hpp

@@ -56,7 +56,7 @@ public:
   CActor(TUniqueId uid, bool active, const rstl::string& name, const CEntityInfo& info,
          const CTransform4f& xf, const CModelData& mData, const CMaterialList& list,
          const CActorParameters& params, TUniqueId nextDrawNode);
-  ~CActor();
+  ~CActor() override;
 
   void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
   void SetActive(const bool active);

include/MetroidPrime/CAnimationDatabaseGame.hpp

@@ -34,12 +34,12 @@ class CAnimationDatabaseGame : public CAnimationDatabase {
 public:
   explicit CAnimationDatabaseGame(const rstl::vector< CAnimation >& anims);
 
-  const rstl::rc_ptr< IMetaAnim >& GetMetaAnim(uint idx) const;
+  const rstl::rc_ptr< IMetaAnim >& GetMetaAnim(uint idx) const override;
-  uint GetNumMetaAnims() const;
+  uint GetNumMetaAnims() const override;
-  rstl::string GetMetaAnimName(uint idx) const;
+  rstl::string GetMetaAnimName(uint idx) const override;
-  void GetAllUniquePrimitives(rstl::vector< CPrimitive >& primsOut) const;
+  void GetAllUniquePrimitives(rstl::vector< CPrimitive >& primsOut) const override;
   void GetUniquePrimitivesFromMetaAnim(rstl::set< CPrimitive >& primsOut,
-                                       const rstl::string& name) const;
+                                       const rstl::string& name) const override;
 
 private:
   rstl::vector< rstl::rc_ptr< IMetaAnim > > x10_anims;

include/MetroidPrime/CAudioStateWin.hpp

@@ -9,8 +9,8 @@ class CAudioStateWin : public CIOWin {
 public:
   CAudioStateWin();
 
-  ~CAudioStateWin();
+  ~CAudioStateWin() override;
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
 };
 
 #endif // _CAUDIOSTATEWIN

include/MetroidPrime/CCollisionActor.hpp

@@ -30,26 +30,26 @@ public:
                   float mass);
 
   // CEntity
-  ~CCollisionActor();
+  ~CCollisionActor() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  CHealthInfo* HealthInfo(CStateManager&);
+  CHealthInfo* HealthInfo(CStateManager&) override;
-  const CDamageVulnerability* GetDamageVulnerability() const;
+  const CDamageVulnerability* GetDamageVulnerability() const override;
   const CDamageVulnerability* GetDamageVulnerability(const CVector3f&, const CVector3f&,
-                                                     const CDamageInfo&) const;
+                                                     const CDamageInfo&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
-  CVector3f GetOrbitPosition(const CStateManager&) const;
+  CVector3f GetOrbitPosition(const CStateManager&) const override;
-  CVector3f GetScanObjectIndicatorPosition(const CStateManager&) const;
+  CVector3f GetScanObjectIndicatorPosition(const CStateManager&) const override;
   EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&,
                                                          const CWeaponMode&,
-                                                         int /*EProjectileAttrib?*/) const;
+                                                         int /*EProjectileAttrib?*/) const override;
-  void OnScanStateChange(EScanState, CStateManager&);
+  void OnScanStateChange(EScanState, CStateManager&) override;
 
   // CPhysicsActor
-  CTransform4f GetPrimitiveTransform() const;
+  CTransform4f GetPrimitiveTransform() const override;
 
 private:
   EPrimitiveType x258_primitiveType;

include/MetroidPrime/CConsoleOutputWindow.hpp

@@ -12,8 +12,8 @@ class CConsoleOutputWindow : public CIOWin {
 public:
   CConsoleOutputWindow(int, float, float);
 
-  ~CConsoleOutputWindow();
+  ~CConsoleOutputWindow() override;
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
   void Update(float);
   void Draw() const;
 private:

include/MetroidPrime/CCredits.hpp

@@ -19,11 +19,11 @@ class CVector3f;
 class CCredits : public CIOWin {
 public:
   CCredits();
-  ~CCredits();
+  ~CCredits() override;
 
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
-  bool GetIsContinueDraw() const;
+  bool GetIsContinueDraw() const override;
-  void Draw() const;
+  void Draw() const override;
 
   EMessageReturn Update(float, CArchitectureQueue& queue);
   EMessageReturn ProcessUserInput(const CFinalInput& input);

include/MetroidPrime/CEffect.hpp

@@ -11,11 +11,11 @@ public:
           const CTransform4f& xf);
 
   // CEntity
-  ~CEffect() {}
+  ~CEffect() override {}
 
   // CActor
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
 };
 CHECK_SIZEOF(CEffect, 0xe8)
 

include/MetroidPrime/CErrorOutputWindow.hpp

@@ -8,11 +8,11 @@
 class CErrorOutputWindow : public CIOWin {
 public:
   CErrorOutputWindow(bool);
-  ~CErrorOutputWindow();
+  ~CErrorOutputWindow() override;
 
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
-  bool GetIsContinueDraw() const;
+  bool GetIsContinueDraw() const override;
-  void Draw() const;
+  void Draw() const override;
 
   void UpdateWindow();
 

include/MetroidPrime/CExplosion.hpp

@@ -22,16 +22,16 @@ public:
              const CVector3f& scale, const CColor& color);
 
   // CEntity
-  ~CExplosion();
+  ~CExplosion() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void PreRender(CStateManager&, const CFrustumPlanes&);
+  void PreRender(CStateManager&, const CFrustumPlanes&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  void CalculateRenderBounds();
+  void CalculateRenderBounds() override;
 
 public:
   rstl::single_ptr< CParticleGen > xe8_particleGen;

include/MetroidPrime/CFlameWarp.hpp

@@ -14,7 +14,7 @@ class CColor;
 class CFlameWarp : public CWarp {
 public:
   CFlameWarp(float maxInfluenceDist, const CVector3f& warpPoint, bool collisionWarp);
-  ~CFlameWarp();
+  ~CFlameWarp() override;
 
   const rstl::reserved_vector< CVector3f, 9 >& GetCollisionPoints() const {
     return x4_collisionPoints;
@@ -26,14 +26,14 @@ public:
   const CVector3f& GetFloatingPoint() const { return x80_floatingPoint; }
   void SetMaxDistSq(float d) { x8c_maxDistSq = d; }
   void SetStateManager(CStateManager& mgr) { x9c_stateMgr = &mgr; }
-  bool UpdateWarp();
+  bool UpdateWarp() override;
   void ModifyParticles(int particleCount, int stripe, int*, CVector3f* particlePos,
                                  CVector3f* particlePrevPos, CVector3f* particleVelocity,
-                                 CColor* color, float* lineLengthOrSize, float* lineWidthOrRota);
+                                 CColor* color, float* lineLengthOrSize, float* lineWidthOrRota) override;
-  void Activate(bool val) { xa0_24_activated = val; }
+  void Activate(bool val) override { xa0_24_activated = val; }
-  bool IsActivated();
+  bool IsActivated() override;
   bool IsProcessed() const { return xa0_26_processed; }
-  FourCC Get4CharID();
+  FourCC Get4CharID() override;
   void ResetPosition(const CVector3f& pos);
   CAABox CalculateBounds() const;
 

include/MetroidPrime/CGameArea.hpp

@@ -94,14 +94,14 @@ public:
   };
 
   ~CGameArea();
-  const CTransform4f& IGetTM() const;
+  const CTransform4f& IGetTM() const override;
-  CAssetId IGetStringTableAssetId() const;
+  CAssetId IGetStringTableAssetId() const override;
-  uint IGetNumAttachedAreas() const;
+  uint IGetNumAttachedAreas() const override;
-  TAreaId IGetAttachedAreaId(int) const;
+  TAreaId IGetAttachedAreaId(int) const override;
-  bool IIsActive() const;
+  bool IIsActive() const override;
-  CAssetId IGetAreaAssetId() const;
+  CAssetId IGetAreaAssetId() const override;
-  int IGetAreaSaveId() const;
+  int IGetAreaSaveId() const override;
-  rstl::pair< rstl::auto_ptr< uchar >, int > IGetScriptingMemoryAlways() const;
+  rstl::pair< rstl::auto_ptr< uchar >, int > IGetScriptingMemoryAlways() const override;
 
   TAreaId GetId() const { return x4_selfIdx; }
   const CTransform4f& GetTM() const { return xc_transform; }

include/MetroidPrime/CGameLight.hpp

@@ -14,8 +14,8 @@ public:
 
   void SetLight(const CLight& light);
   CLight GetLight() const;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
   void SetLightPriorityAndId();
 
 private:

include/MetroidPrime/CMainFlow.hpp

@@ -24,10 +24,10 @@ class CMainFlow : public CIOWin {
 public:
   CMainFlow();
 
-  ~CMainFlow();
+  ~CMainFlow() override;
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
-  bool GetIsContinueDraw() const;
+  bool GetIsContinueDraw() const override;
-  void Draw() const;
+  void Draw() const override;
 
   void AdvanceGameState(CArchitectureQueue& queue);
   void SetGameState(EClientFlowStates state, CArchitectureQueue& queue);

include/MetroidPrime/CParticleGenInfoGeneric.hpp

@@ -14,23 +14,23 @@ public:
                           EParticleGenType state);
   ~CParticleGenInfoGeneric();
 
-  virtual void AddToRenderer();
+  virtual void AddToRenderer() override;
-  virtual void Render();
+  virtual void Render() override;
-  virtual void Update(float dt, CStateManager& stateMgr);
+  virtual void Update(float dt, CStateManager& stateMgr) override;
-  virtual void SetOrientation(const CTransform4f& xf, CStateManager& stateMgr);
+  virtual void SetOrientation(const CTransform4f& xf, CStateManager& stateMgr) override;
-  virtual void SetTranslation(const CVector3f& trans, CStateManager& stateMgr);
+  virtual void SetTranslation(const CVector3f& trans, CStateManager& stateMgr) override;
-  virtual void SetGlobalOrientation(const CTransform4f& xf, CStateManager& stateMgr);
+  virtual void SetGlobalOrientation(const CTransform4f& xf, CStateManager& stateMgr) override;
-  virtual void SetGlobalTranslation(const CVector3f& trans, CStateManager& stateMgr);
+  virtual void SetGlobalTranslation(const CVector3f& trans, CStateManager& stateMgr) override;
-  virtual void SetGlobalScale(const CVector3f& scale);
+  virtual void SetGlobalScale(const CVector3f& scale) override;
-  virtual void SetParticleEmission(bool isActive, CStateManager& stateMgr);
+  virtual void SetParticleEmission(bool isActive, CStateManager& stateMgr) override;
-  virtual bool IsSystemDeletable() const;
+  virtual bool IsSystemDeletable() const override;
-  virtual rstl::optional_object<CAABox> GetBounds() const;
+  virtual rstl::optional_object<CAABox> GetBounds() const override;
-  virtual bool HasActiveParticles() const;
+  virtual bool HasActiveParticles() const override;
-  virtual void DestroyParticles();
+  virtual void DestroyParticles() override;
-  virtual bool HasLight() const;
+  virtual bool HasLight() const override;
-  virtual TUniqueId GetLightId() const;
+  virtual TUniqueId GetLightId() const override;
-  virtual void DeleteLight(CStateManager& stateMgr);
+  virtual void DeleteLight(CStateManager& stateMgr) override;
-  virtual void SetModulationColor(const CColor& color);
+  virtual void SetModulationColor(const CColor& color) override;
 
   const rstl::rc_ptr< CParticleGen >& GetParticleSystem() const { return x84_system; }
 

include/MetroidPrime/CPhysicsActor.hpp

@@ -68,10 +68,10 @@ public:
                 float stepUp, float stepDown);
 
   // CActor
-  ~CPhysicsActor();
+  ~CPhysicsActor() override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  CVector3f GetOrbitPosition(const CStateManager& mgr) const;
+  CVector3f GetOrbitPosition(const CStateManager& mgr) const override;
-  CVector3f GetAimPosition(const CStateManager& mgr, float val) const;
+  CVector3f GetAimPosition(const CStateManager& mgr, float val) const override;
 
   // CPhysicsActor
   virtual const CCollisionPrimitive* GetCollisionPrimitive() const;

include/MetroidPrime/CSplashScreen.hpp

@@ -15,9 +15,9 @@ public:
 
   CSplashScreen(ESplashScreen);
 
-  ~CSplashScreen();
+  ~CSplashScreen() override;
-  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&);
+  EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
-  void Draw() const;
+  void Draw() const override;
 };
 
 #endif // _CSPLASHSCREEN

include/MetroidPrime/CWorld.hpp

@@ -64,17 +64,17 @@ enum EEnvFxType {
 class CWorld : public IWorld {
 public:
   ~CWorld();
-  CAssetId IGetWorldAssetId() const;
+  CAssetId IGetWorldAssetId() const override;
-  CAssetId IGetStringTableAssetId() const;
+  CAssetId IGetStringTableAssetId() const override;
-  CAssetId IGetSaveWorldAssetId() const;
+  CAssetId IGetSaveWorldAssetId() const override;
-  const CMapWorld* IGetMapWorld() const;
+  const CMapWorld* IGetMapWorld() const override;
-  CMapWorld* IMapWorld();
+  CMapWorld* IMapWorld() override;
-  const IGameArea* IGetAreaAlways(TAreaId id) const;
+  const IGameArea* IGetAreaAlways(TAreaId id) const override;
-  TAreaId IGetCurrentAreaId() const;
+  TAreaId IGetCurrentAreaId() const override;
-  TAreaId IGetAreaId(CAssetId id) const;
+  TAreaId IGetAreaId(CAssetId id) const override;
-  bool ICheckWorldComplete();
+  bool ICheckWorldComplete() override;
-  rstl::string IGetDefaultAudioTrack() const;
+  rstl::string IGetDefaultAudioTrack() const override;
-  int IGetAreaCount() const;
+  int IGetAreaCount() const override;
 
   void SetLoadPauseState(bool);
   void TouchSky() const;

include/MetroidPrime/Cameras/CBallCamera.hpp

@@ -99,17 +99,17 @@ public:
               float farZ, float aspect);
 
   // CEntity
-  ~CBallCamera();
+  ~CBallCamera() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
 
   // CGameCamera
-  void ProcessInput(const CFinalInput&, CStateManager& mgr);
+  void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
-  void Reset(const CTransform4f&, CStateManager& mgr);
+  void Reset(const CTransform4f&, CStateManager& mgr) override;
 
   // CBallCamera
   void SetupColliders(rstl::vector< CCameraCollider >& out, float xMag, float zMag, float radius,

include/MetroidPrime/Cameras/CCinematicCamera.hpp

@@ -12,14 +12,14 @@ public:
                    float zfar, float aspect, uint flags);
   ~CCinematicCamera();
   // CActor
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CGameCamera
 
-  void ProcessInput(const CFinalInput&, CStateManager& mgr);
+  void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
-  void Reset(const CTransform4f&, CStateManager& mgr);
+  void Reset(const CTransform4f&, CStateManager& mgr) override;
 
   // CCinematicCamera
   u32 GetFlags() const { return x21c_flags; }

include/MetroidPrime/Cameras/CGameCamera.hpp

@@ -17,10 +17,10 @@ public:
               TUniqueId watchedId, bool disableInput, int controllerIdx);
 
   // CEntity
-  ~CGameCamera();
+  ~CGameCamera() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
-  void SetActive(const bool active);
+  void SetActive(uchar active) override;
 
   // CGameCamera
   virtual void ProcessInput(const CFinalInput&, CStateManager& mgr) = 0;

include/MetroidPrime/Cameras/CInterpolationCamera.hpp

@@ -7,8 +7,8 @@ class CInterpolationCamera : public CGameCamera {
 public:
   CInterpolationCamera(TUniqueId uid, const CTransform4f& xf);
   // CGameCamera
-  void ProcessInput(const CFinalInput&, CStateManager& mgr);
+  void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
-  void Reset(const CTransform4f&, CStateManager& mgr);
+  void Reset(const CTransform4f&, CStateManager& mgr) override;
 private:
   TUniqueId x188_targetId;
   float x18c_time;

include/MetroidPrime/Enemies/CAi.hpp

@@ -20,13 +20,13 @@ public:
 
   // const CStateMachine* GetStateMachine() const;
   ~CAi();
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  CHealthInfo* HealthInfo(CStateManager&);
+  CHealthInfo* HealthInfo(CStateManager&) override;
-  const CDamageVulnerability* GetDamageVulnerability() const { return nullptr; }
+  const CDamageVulnerability* GetDamageVulnerability() const override { return nullptr; }
   EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&,
                                                          const CWeaponMode&,
-                                                         int) const;
+                                                         int) const override;
-  void FluidFXThink(EFluidState, CScriptWater&, CStateManager&);
+  void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
   ;
 
   virtual void Death(CStateManager& mgr, const CVector3f& direction, EScriptObjectState state) = 0;

include/MetroidPrime/Enemies/CFlaahgraPlants.hpp

@@ -16,15 +16,15 @@ public:
                   TUniqueId, const CTransform4f&, const CDamageInfo&, const CVector3f&);
 
   // CEntity
-  ~CFlaahgraPlants();
+  ~CFlaahgraPlants() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
 
   // CActor
-  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const;
+  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor& actor, CStateManager& mgr);
+  void Touch(CActor& actor, CStateManager& mgr) override;
 
 private:
   rstl::auto_ptr< CElementGen > xe8_elementGen;

include/MetroidPrime/Enemies/CMetaree.hpp

@@ -17,31 +17,31 @@ public:
            float f3, float f4, const CActorParameters& aParms);
 
   // CEntity
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
 
   // CPhysicsActor
   void CollidedWith(const TUniqueId& id, const CCollisionInfoList& list,
-                    CStateManager& mgr);
+                    CStateManager& mgr) override;
 
   // CAi
-  void Dead(CStateManager&, EStateMsg, float);
+  void Dead(CStateManager&, EStateMsg, float) override;
-  void Halt(CStateManager&, EStateMsg, float);
+  void Halt(CStateManager&, EStateMsg, float) override;
-  void Attack(CStateManager&, EStateMsg, float);
+  void Attack(CStateManager&, EStateMsg, float) override;
-  void Active(CStateManager&, EStateMsg, float);
+  void Active(CStateManager&, EStateMsg, float) override;
-  void InActive(CStateManager&, EStateMsg, float);
+  void InActive(CStateManager&, EStateMsg, float) override;
-  void Flee(CStateManager&, EStateMsg, float);
+  void Flee(CStateManager&, EStateMsg, float) override;
-  void Explode(CStateManager&, EStateMsg, float);
+  void Explode(CStateManager&, EStateMsg, float) override;
-  bool InRange(CStateManager&, float);
+  bool InRange(CStateManager&, float) override;
-  bool Delay(CStateManager&, float);
+  bool Delay(CStateManager&, float) override;
-  bool ShouldAttack(CStateManager&, float);
+  bool ShouldAttack(CStateManager&, float) override;
 
   // CPatterned
-  void ThinkAboutMove(float);
+  void ThinkAboutMove(float) override;
 
 private:
   float x568_delay;

include/MetroidPrime/Enemies/CMetroidPrimeProjectile.hpp

@@ -42,12 +42,12 @@ public:
       bool sendCollideMsg);
 
   // CEntity
-  ~CMetroidPrimeProjectile();
+  ~CMetroidPrimeProjectile() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
 
   // CEnergyProjectile
   bool Explode(const CVector3f& pos, const CVector3f& normal, EWeaponCollisionResponseTypes type,
-               CStateManager& mgr, const CDamageVulnerability& dVuln, TUniqueId hitActor);
+               CStateManager& mgr, const CDamageVulnerability& dVuln, TUniqueId hitActor) override;
 };
 
 #endif // _CMETROIDPRIMEPROJECTILE

include/MetroidPrime/Enemies/CNewIntroBoss.hpp

@@ -19,30 +19,30 @@ public:
                 CAssetId beamTextureId, CAssetId beamGlowTextureId);
 
   // CEntity
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void OnScanStateChange(EScanState, CStateManager&);
+  void OnScanStateChange(EScanState, CStateManager&) override;
-  CAABox GetSortingBounds(const CStateManager&) const;
+  CAABox GetSortingBounds(const CStateManager&) const override;
   void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type,
-                       float dt);
+                       float dt) override;
 
   // CAi
-  void Patrol(CStateManager&, EStateMsg, float);
+  void Patrol(CStateManager&, EStateMsg, float) override;
-  void Generate(CStateManager& mgr, EStateMsg msg, float arg);
+  void Generate(CStateManager& mgr, EStateMsg msg, float arg) override;
-  void Attack(CStateManager&, EStateMsg, float);
+  void Attack(CStateManager&, EStateMsg, float) override;
-  bool InAttackPosition(CStateManager&, float);
+  bool InAttackPosition(CStateManager&, float) override;
-  bool AnimOver(CStateManager&, float);
+  bool AnimOver(CStateManager&, float) override;
-  bool ShouldAttack(CStateManager&, float);
+  bool ShouldAttack(CStateManager&, float) override;
-  bool ShouldTurn(CStateManager&, float);
+  bool ShouldTurn(CStateManager&, float) override;
-  bool AIStage(CStateManager&, float);
+  bool AIStage(CStateManager&, float) override;
 
   // CPatterned
-  CProjectileInfo* ProjectileInfo();
+  CProjectileInfo* ProjectileInfo() override;
 
   pas::ELocomotionType GetLocoForHealth(const CStateManager& mgr) const;
   pas::EGenerateType GetGenerateForHealth(const CStateManager& mgr) const;

include/MetroidPrime/Enemies/CPatterned.hpp

@@ -151,73 +151,73 @@ public:
              EBodyType body, const CActorParameters& params, EKnockBackVariant kbVariant);
 
   // CEntity
-  ~CPatterned();
+  ~CPatterned() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void PreThink(float dt, CStateManager& mgr);
+  void PreThink(float dt, CStateManager& mgr) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
 
   // CActor
-  void PreRender(CStateManager&, const CFrustumPlanes&);
+  void PreRender(CStateManager&, const CFrustumPlanes&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  bool CanRenderUnsorted(const CStateManager&) const;
+  bool CanRenderUnsorted(const CStateManager&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
-  CVector3f GetOrbitPosition(const CStateManager&) const;
+  CVector3f GetOrbitPosition(const CStateManager&) const override;
-  CVector3f GetAimPosition(const CStateManager&, float) const;
+  CVector3f GetAimPosition(const CStateManager&, float) const override;
   EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&,
                                                          const CWeaponMode&,
-                                                         int /*EProjectileAttrib?*/) const;
+                                                         int /*EProjectileAttrib?*/) const override;
   void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type,
-                       float dt);
+                       float dt) override;
 
   // CPhysicsActor
   void CollidedWith(const TUniqueId& id, const CCollisionInfoList& list,
-                    CStateManager& mgr);
+                    CStateManager& mgr) override;
 
   // CAi
-  void Death(CStateManager& mgr, const CVector3f& direction, EScriptObjectState state);
+  void Death(CStateManager& mgr, const CVector3f& direction, EScriptObjectState state) override;
   void KnockBack(const CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type,
-                 bool inDeferred, float magnitude);
+                 bool inDeferred, float magnitude) override;
-  void TakeDamage(const CVector3f& direction, float magnitude);
+  void TakeDamage(const CVector3f& direction, float magnitude) override;
-  void Patrol(CStateManager&, EStateMsg, float);
+  void Patrol(CStateManager&, EStateMsg, float) override;
-  void FollowPattern(CStateManager&, EStateMsg, float);
+  void FollowPattern(CStateManager&, EStateMsg, float) override;
-  void Dead(CStateManager&, EStateMsg, float);
+  void Dead(CStateManager&, EStateMsg, float) override;
-  void PathFind(CStateManager&, EStateMsg, float);
+  void PathFind(CStateManager&, EStateMsg, float) override;
-  void Start(CStateManager&, EStateMsg, float);
+  void Start(CStateManager&, EStateMsg, float) override;
-  void TargetPatrol(CStateManager&, EStateMsg, float);
+  void TargetPatrol(CStateManager&, EStateMsg, float) override;
-  void TargetPlayer(CStateManager&, EStateMsg, float);
+  void TargetPlayer(CStateManager&, EStateMsg, float) override;
-  bool Leash(CStateManager&, float);
+  bool Leash(CStateManager&, float) override;
-  bool OffLine(CStateManager&, float);
+  bool OffLine(CStateManager&, float) override;
-  bool Attacked(CStateManager&, float);
+  bool Attacked(CStateManager&, float) override;
-  bool PathShagged(CStateManager&, float);
+  bool PathShagged(CStateManager&, float) override;
-  bool PathOver(CStateManager&, float);
+  bool PathOver(CStateManager&, float) override;
-  bool PathFound(CStateManager&, float);
+  bool PathFound(CStateManager&, float) override;
-  bool TooClose(CStateManager&, float);
+  bool TooClose(CStateManager&, float) override;
-  bool InRange(CStateManager&, float);
+  bool InRange(CStateManager&, float) override;
-  bool InMaxRange(CStateManager&, float);
+  bool InMaxRange(CStateManager&, float) override;
-  bool InDetectionRange(CStateManager&, float);
+  bool InDetectionRange(CStateManager&, float) override;
-  bool SpotPlayer(CStateManager&, float);
+  bool SpotPlayer(CStateManager&, float) override;
-  bool PlayerSpot(CStateManager&, float);
+  bool PlayerSpot(CStateManager&, float) override;
-  bool PatternOver(CStateManager&, float);
+  bool PatternOver(CStateManager&, float) override;
-  bool PatternShagged(CStateManager&, float);
+  bool PatternShagged(CStateManager&, float) override;
-  bool HasAttackPattern(CStateManager&, float);
+  bool HasAttackPattern(CStateManager&, float) override;
-  bool HasPatrolPath(CStateManager&, float);
+  bool HasPatrolPath(CStateManager&, float) override;
-  bool HasRetreatPattern(CStateManager&, float);
+  bool HasRetreatPattern(CStateManager&, float) override;
-  bool Delay(CStateManager&, float);
+  bool Delay(CStateManager&, float) override;
-  bool RandomDelay(CStateManager&, float);
+  bool RandomDelay(CStateManager&, float) override;
-  bool FixedDelay(CStateManager&, float);
+  bool FixedDelay(CStateManager&, float) override;
-  bool Default(CStateManager&, float);
+  bool Default(CStateManager&, float) override;
-  bool AnimOver(CStateManager&, float);
+  bool AnimOver(CStateManager&, float) override;
-  bool InPosition(CStateManager&, float);
+  bool InPosition(CStateManager&, float) override;
-  bool Stuck(CStateManager&, float);
+  bool Stuck(CStateManager&, float) override;
-  bool NoPathNodes(CStateManager&, float);
+  bool NoPathNodes(CStateManager&, float) override;
-  bool Landed(CStateManager&, float);
+  bool Landed(CStateManager&, float) override;
-  bool PatrolPathOver(CStateManager&, float);
+  bool PatrolPathOver(CStateManager&, float) override;
-  bool CodeTrigger(CStateManager&, float);
+  bool CodeTrigger(CStateManager&, float) override;
-  bool Random(CStateManager&, float);
+  bool Random(CStateManager&, float) override;
-  bool FixedRandom(CStateManager&, float);
+  bool FixedRandom(CStateManager&, float) override;
 
   // CPatterned
   virtual void Freeze(CStateManager& mgr, const CVector3f& pos, const CUnitVector3f& dir,

include/MetroidPrime/Enemies/CPuffer.hpp

@@ -17,13 +17,13 @@ public:
           const CDamageInfo& cloudDamage, CAssetId cloudSteam, float f2, bool b1, bool b2, bool b3,
           const CDamageInfo& explosionDamage, ushort sfxId);
 
-  ~CPuffer();
+  ~CPuffer() override;
-  void Accept(IVisitor&);
+  void Accept(IVisitor&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
-  void Death(CStateManager&, const CVector3f&, EScriptObjectState);
+  void Death(CStateManager&, const CVector3f&, EScriptObjectState) override;
 
 private:
   CVector3f x568_face;

include/MetroidPrime/Enemies/CRipperControlledPlatform.hpp

@@ -11,7 +11,7 @@ public:
       const CAABox&, bool, const rstl::optional_object< TLockedToken< CCollidableOBBTreeGroupContainer > >&);
   ~CRipperControlledPlatform();
 
-  CQuaternion Move(float, CStateManager&);
+  CQuaternion Move(float, CStateManager&) override;
 
 private:
   TUniqueId x358_owner;

include/MetroidPrime/GameObjectLists.hpp

@@ -6,37 +6,37 @@
 class CActorList : public CObjectList {
 public:
   CActorList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 class CPhysicsActorList : public CObjectList {
 public:
   CPhysicsActorList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 class CGameCameraList : public CObjectList {
 public:
   CGameCameraList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 class CListeningAiList : public CObjectList {
 public:
   CListeningAiList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 class CAiWaypointList : public CObjectList {
 public:
   CAiWaypointList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 class CPlatformAndDoorList : public CObjectList {
 public:
   CPlatformAndDoorList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
   static uchar IsPlatform(const CEntity* ent);
   static uchar IsDoor(const CEntity*);
 };
@@ -44,7 +44,7 @@ public:
 class CGameLightList : public CObjectList {
 public:
   CGameLightList();
-  uchar IsQualified(const CEntity& ent);
+  uchar IsQualified(const CEntity& ent) override;
 };
 
 

include/MetroidPrime/Player/CPlayer.hpp

@@ -143,36 +143,36 @@ public:
   };
 
   // CEntity
-  ~CPlayer();
+  ~CPlayer() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void PreThink(float dt, CStateManager& mgr);
+  void PreThink(float dt, CStateManager& mgr) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void PreRender(CStateManager&, const CFrustumPlanes&);
+  void PreRender(CStateManager&, const CFrustumPlanes&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  bool CanRenderUnsorted(const CStateManager&) const;
+  bool CanRenderUnsorted(const CStateManager&) const override;
-  void CalculateRenderBounds();
+  void CalculateRenderBounds() override;
-  CHealthInfo* HealthInfo(CStateManager&);
+  CHealthInfo* HealthInfo(CStateManager&) override;
-  const CDamageVulnerability* GetDamageVulnerability() const;
+  const CDamageVulnerability* GetDamageVulnerability() const override;
   const CDamageVulnerability* GetDamageVulnerability(const CVector3f&, const CVector3f&,
-                                                     const CDamageInfo&) const;
+                                                     const CDamageInfo&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
-  CVector3f GetAimPosition(const CStateManager&, float) const;
+  CVector3f GetAimPosition(const CStateManager&, float) const override;
-  CVector3f GetHomingPosition(const CStateManager&, float) const;
+  CVector3f GetHomingPosition(const CStateManager&, float) const override;
-  void FluidFXThink(EFluidState, CScriptWater&, CStateManager&);
+  void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
 
   // CPhysicsActor
-  const CCollisionPrimitive* GetCollisionPrimitive() const;
+  const CCollisionPrimitive* GetCollisionPrimitive() const override;
-  CTransform4f GetPrimitiveTransform() const;
+  CTransform4f GetPrimitiveTransform() const override;
   void CollidedWith(const TUniqueId& id, const CCollisionInfoList& list,
-                    CStateManager& mgr);
+                    CStateManager& mgr) override;
-  float GetStepDownHeight() const;
+  float GetStepDownHeight() const override;
-  float GetStepUpHeight() const;
+  float GetStepUpHeight() const override;
-  float GetWeight() const;
+  float GetWeight() const override;
 
   // CPlayer
   virtual bool IsTransparent();

include/MetroidPrime/ScriptObjects/CFire.hpp

@@ -18,15 +18,15 @@ public:
         float f2, float f3, float f4);
 
   // CEntity
-  ~CFire();
+  ~CFire() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
 
 private:
   rstl::single_ptr< CElementGen > xe8_;

include/MetroidPrime/ScriptObjects/CHUDBillboardEffect.hpp

@@ -14,13 +14,13 @@ public:
                       TUniqueId uid, bool active, const rstl::string& name, float dist,
                       const CVector3f& scale0, const CColor& color, const CVector3f& scale1,
                       const CVector3f& translation);
-  ~CHUDBillboardEffect();
+  ~CHUDBillboardEffect() override;
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum);
+  void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum) override;
-  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const;
+  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const override;
-  void Render(const CStateManager& mgr) const;
+  void Render(const CStateManager& mgr) const override;
   bool IsElementGen() const { return x104_26_isElementGen; }
   void SetRunIndefinitely(bool b) { x104_27_runIndefinitely = b; }
   CParticleGen* GetParticleGen() const { return xe8_generator.get(); }

include/MetroidPrime/ScriptObjects/CRepulsor.hpp

@@ -9,8 +9,8 @@ class CRepulsor : public CActor {
 public:
   CRepulsor(TUniqueId, bool, const rstl::string&, const CEntityInfo&, const CVector3f&, float);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
 
   float GetAffectRadius() const { return xe8_affectRadius; }
 };

include/MetroidPrime/ScriptObjects/CScriptActor.hpp

@@ -19,23 +19,23 @@ public:
                bool scaleAdvancementDelta, bool materialFlag54);
 
   // CEntity
-  ~CScriptActor();
+  ~CScriptActor() override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
 
   // CActor
-  void PreRender(CStateManager&, const CFrustumPlanes&);
+  void PreRender(CStateManager&, const CFrustumPlanes&) override;
-  CHealthInfo* HealthInfo(CStateManager&);
+  CHealthInfo* HealthInfo(CStateManager&) override;
-  const CDamageVulnerability* GetDamageVulnerability() const;
+  const CDamageVulnerability* GetDamageVulnerability() const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
 
   // CPhysicsActor
   EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&,
                                                          const CWeaponMode&,
-                                                         int) const;
+                                                         int) const override;
-  CAABox GetSortingBounds(const CStateManager&) const;
+  CAABox GetSortingBounds(const CStateManager&) const override;
 
   bool IsPlayerActor() const { return x2e3_24_isPlayerActor; }
 

include/MetroidPrime/ScriptObjects/CScriptActorKeyframe.hpp

@@ -10,9 +10,9 @@ public:
                        bool looping, float lifetime, bool isPassive, int fadeOut, bool active,
                        float totalPlayback);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
   void UpdateEntity(TUniqueId, CStateManager&);
   bool IsPassive() const { return x44_25_isPassive; }
   void SetIsPassive(bool b) { x44_25_isPassive = b; }

include/MetroidPrime/ScriptObjects/CScriptActorRotate.hpp

@@ -14,9 +14,9 @@ public:
                      bool, bool, bool);
   ~CScriptActorRotate();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
 
 private:
   CVector3f x34_rotation;

include/MetroidPrime/ScriptObjects/CScriptAiJumpPoint.hpp

@@ -18,12 +18,12 @@ public:
                      float);
   ~CScriptAiJumpPoint();
   
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
   bool GetInUse(TUniqueId uid) const;
   TUniqueId GetJumpPoint() const { return x10c_currentWaypoint; }
   TUniqueId GetJumpTarget() const { return x10e_nextWaypoint; }

include/MetroidPrime/ScriptObjects/CScriptAreaAttributes.hpp

@@ -20,8 +20,8 @@ public:
                         float thermalHeat, float xrayFogDistance, float worldLightingLevel, CAssetId skybox,
                         EPhazonType phazonType);
 
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
   ~CScriptAreaAttributes();
 
   bool GetNeedsSky() const { return x34_24_showSkybox; }

include/MetroidPrime/ScriptObjects/CScriptBallTrigger.hpp

@@ -9,11 +9,11 @@ public:
                      const CVector3f&, bool, float, float, float, const CVector3f&, bool);
   ~CScriptBallTrigger();
 
-  void Accept(IVisitor&);
+  void Accept(IVisitor&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void Think(float, CStateManager& mgr);
+  void Think(float, CStateManager& mgr) override;
-  void InhabitantAdded(CActor&, CStateManager&);
+  void InhabitantAdded(CActor&, CStateManager&) override;
-  void InhabitantExited(CActor&, CStateManager&);
+  void InhabitantExited(CActor&, CStateManager&) override;
 
 private:
   float x150_force;

include/MetroidPrime/ScriptObjects/CScriptBeam.hpp

@@ -18,9 +18,9 @@ public:
               const TToken< CWeaponDescription >&, const CBeamInfo&, const CDamageInfo&);
   ~CScriptBeam();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
 };
 
 #endif // _CSCRIPTBEAM

include/MetroidPrime/ScriptObjects/CScriptCameraBlurKeyframe.hpp

@@ -18,8 +18,8 @@ public:
                             float timeOut, bool active);
   ~CScriptCameraBlurKeyframe();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
 };
 
 #endif // _CSCRIPTCAMERABLURKEYFRAME

include/MetroidPrime/ScriptObjects/CScriptCameraFilterKeyframe.hpp

@@ -26,8 +26,8 @@ public:
                               float timeOut, CAssetId txtr, bool active);
   ~CScriptCameraFilterKeyframe();
 
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
 };
 
 #endif // _CSCRIPTCAMERAFILTERKEYFRAME

include/MetroidPrime/ScriptObjects/CScriptCameraHintTrigger.hpp

@@ -19,10 +19,10 @@ public:
                            bool deactivateOnEnter, bool deactivateOnExit);
   ~CScriptCameraHintTrigger();
   
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float dt, CStateManager& mgr);
+  void Think(float dt, CStateManager& mgr) override;
-  void Touch(CActor& other, CStateManager& mgr);
+  void Touch(CActor& other, CStateManager& mgr) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
 };
 
 #endif // _CSCRIPTCAMERAHINTTRIGGER

include/MetroidPrime/ScriptObjects/CScriptCameraPitchVolume.hpp

@@ -13,10 +13,10 @@ public:
                            const CRelAngle&, float);
   ~CScriptCameraPitchVolume();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
   // float GetUpPitch() const { return x124_upPitch; }
   // float GetDownPitch() const { return x128_downPitch; }
   // const CVector3f& GetScale() const { return x12c_scale; }

include/MetroidPrime/ScriptObjects/CScriptCameraShaker.hpp

@@ -13,8 +13,8 @@ public:
                       const CCameraShakeData& shakeData);
   ~CScriptCameraShaker();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
 };
 
 #endif // _CSCRIPTCAMERASHAKER

include/MetroidPrime/ScriptObjects/CScriptCameraWaypoint.hpp

@@ -12,10 +12,10 @@ public:
                         const CTransform4f& xf, bool active, float hfov, uint);
   ~CScriptCameraWaypoint();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
 
   TUniqueId GetRandomNextWaypointId(const CStateManager& mgr) const;
   float GetHFov() const { return xe8_hfov; }

include/MetroidPrime/ScriptObjects/CScriptControllerAction.hpp

@@ -84,8 +84,8 @@ public:
   CScriptControllerAction(TUniqueId uid, const rstl::string& name, const CEntityInfo& info,
                           bool active, ECommands command, bool b1, uint w1, bool b2);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
 
   static ControlMapper::ECommands GetCommand(ECommands cmd);
 };

include/MetroidPrime/ScriptObjects/CScriptCounter.hpp

@@ -13,8 +13,8 @@ public:
   CScriptCounter(TUniqueId, const rstl::string& name, const CEntityInfo& info, int, int, bool, bool);
   ~CScriptCounter();
 
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
 };
 
 #endif // _CSCRIPTCOUNTER

include/MetroidPrime/ScriptObjects/CScriptCoverPoint.hpp

@@ -11,12 +11,12 @@ public:
                     const CTransform4f& xf, bool active, uint flags, bool crouch, float horizontalAngle,
                     float verticalAngle, float coverTime);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void Render(const CStateManager&) const;
+  void Render(const CStateManager&) const override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
 
   bool ShouldCrouch() const;
   bool ShouldStay() const;

include/MetroidPrime/ScriptObjects/CScriptDamageableTrigger.hpp

@@ -24,18 +24,18 @@ public:
                            CAssetId colorTex, ECanOrbit canOrbit, bool active,
                            const CVisorParameters& vParams);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
   EWeaponCollisionResponseTypes GetCollisionResponseType(const CVector3f&, const CVector3f&,
                                                          const CWeaponMode&,
-                                                         int /*EProjectileAttrib?*/) const;
+                                                         int /*EProjectileAttrib?*/) const override;
-  void Render(const CStateManager& mgr) const;
+  void Render(const CStateManager& mgr) const override;
-  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const;
+  void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const override;
-  void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum);
+  void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum) override;
-  const CDamageVulnerability* GetDamageVulnerability() const { return &x174_dVuln; }
+  const CDamageVulnerability* GetDamageVulnerability() const override { return &x174_dVuln; }
-  CHealthInfo* HealthInfo(CStateManager&) { return &x16c_hInfo; }
+  CHealthInfo* HealthInfo(CStateManager&) override { return &x16c_hInfo; }
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
 
 private:
   CFrustumPlanes xe8_frustum;

include/MetroidPrime/ScriptObjects/CScriptDebugCameraWaypoint.hpp

@@ -9,9 +9,9 @@ class CScriptDebugCameraWaypoint : public CActor {
 public:
   CScriptDebugCameraWaypoint(TUniqueId uid, const rstl::string& name, const CEntityInfo& info,
                              const CTransform4f& xf, uint value);
-  ~CScriptDebugCameraWaypoint();
+  ~CScriptDebugCameraWaypoint() override;
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
 
 private:
   uint xe8_value;

include/MetroidPrime/ScriptObjects/CScriptDistanceFog.hpp

@@ -25,8 +25,8 @@ public:
                      float);
   ~CScriptDistanceFog();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
 };
 
 #endif // _CSCRIPTDISTANCEFOG

include/MetroidPrime/ScriptObjects/CScriptDock.hpp

@@ -11,11 +11,11 @@ public:
 
   void SetDockReference(CStateManager& mgr, int);
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
   void CleanUp() {}
   CPlane GetPlane(const CStateManager&) const;
   TAreaId GetAreaId() const { return x260_area; }

include/MetroidPrime/ScriptObjects/CScriptDockAreaChange.hpp

@@ -9,8 +9,8 @@ class CScriptDockAreaChange : public CEntity {
 public:
   CScriptDockAreaChange(TUniqueId, const rstl::string&, const CEntityInfo&, int, bool);
 
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
 
   ~CScriptDockAreaChange();
 };

include/MetroidPrime/ScriptObjects/CScriptEMPulse.hpp

@@ -11,13 +11,13 @@ public:
   CScriptEMPulse(TUniqueId, const rstl::string&, const CEntityInfo&, const CTransform4f&, bool,
                  float, float, float, float, float, float, float, CAssetId);
 
-  void Accept(IVisitor&);
+  void Accept(IVisitor&) override;
-  void Think(float, CStateManager&);
+  void Think(float, CStateManager&) override;
-  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
+  void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
-  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
+  void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
-  void CalculateRenderBounds();
+  void CalculateRenderBounds() override;
-  rstl::optional_object< CAABox > GetTouchBounds() const;
+  rstl::optional_object< CAABox > GetTouchBounds() const override;
-  void Touch(CActor&, CStateManager&);
+  void Touch(CActor&, CStateManager&) override;
 
 private:
   float xe8_duration;

include/MetroidPrime/ScriptObjects/CScriptGenerator.hpp

@@ -10,8 +10,8 @@ public:
                    bool active, float minScale, float maxScale);
   ~CScriptGenerator();
 
-  void Accept(IVisitor& visitor);
+  void Accept(IVisitor& visitor) override;
-  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
+  void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
 
 private:
   int x34_spawnCount;