PrimeDecomp
/
prime
mirror of https://github.com/PrimeDecomp/prime.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert override removal

This commit is contained in:
Luke Street 2023-02-06 12:01:01 -05:00
parent d43dc0ead2
commit b6ddfcfc35
148 changed files with 1030 additions and 1023 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/Collision/CCollidableSphere.hpp
View File

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

6
include/GuiSys/CGuiCompoundWidget.hpp
View File

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

6
include/GuiSys/CGuiGroup.hpp
View File

@ -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);
void OnActivate();
bool AddWorkerWidget(CGuiWidget* worker) override;
void OnActivate() override;
private:
uint xb8_workerCount;

8
include/GuiSys/CGuiModel.hpp
View File

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

2
include/GuiSys/CGuiPane.hpp
View File

@ -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;

12
include/GuiSys/CGuiTextPane.hpp
View File

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

22
include/Kyoto/Alloc/CGameAllocator.hpp
View File

@ -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);
bool FreeSecondary(const void* ptr);
void ReleaseAllSecondary();
void SetOutOfMemoryCallback(FOutOfMemoryCb cb, const void* target);
int EnumAllocations(FEnumAllocationsCb func, const void* ptr, bool b) const;
SAllocInfo GetAllocInfo(const void* ptr) const;
SMetrics GetMetrics() const;
void OffsetFakeStatics(int offset);
const CCallStack& cs) override;
bool FreeSecondary(const void* ptr) override;
void ReleaseAllSecondary() override;
void SetOutOfMemoryCallback(FOutOfMemoryCb cb, const void* target) override;
int EnumAllocations(FEnumAllocationsCb func, const void* ptr, bool b) const override;
SAllocInfo GetAllocInfo(const void* ptr) const override;
SMetrics GetMetrics() const override;
void OffsetFakeStatics(int offset) override;
static uint GetFreeBinEntryForSize(uint);
void AddFreeEntryToFreeList(SGameMemInfo*);

12
include/Kyoto/Input/CDolphinController.hpp
View File

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

32
include/Kyoto/Particles/CColorElement.hpp
View File

@ -14,8 +14,8 @@ class CCEConstant : public CColorElement {
public:
CCEConstant(CRealElement* r, CRealElement* g, CRealElement* b, CRealElement* a);
~CCEConstant();
bool GetValue(int frame, CColor& colorOut) const;
~CCEConstant() override;
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();
bool GetValue(int frame, CColor& colorOut) const;
~CCEFastConstant() override;
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();
bool GetValue(int frame, CColor& colorOut) const;
~CCEFade() override;
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();
bool GetValue(int frame, CColor& colorOut) const;
~CCEFadeEnd() override;
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();
bool GetValue(int frame, CColor& colorOut) const;
~CCETimeChain() override;
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();
bool GetValue(int frame, CColor& colorOut) const;
~CCEPulse() override;
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();
bool GetValue(int frame, CColor& valOut) const;
~CCEKeyframeEmitter() override;
bool GetValue(int frame, CColor& valOut) const override;
};
class CCEParticleColor : public CColorElement {
public:
~CCEParticleColor() {}
bool GetValue(int frame, CColor& colorOut) const;
~CCEParticleColor() override {}
bool GetValue(int frame, CColor& colorOut) const override;
};
#endif // _CCOLORELEMENT

54
include/Kyoto/Particles/CElementGen.hpp
View File

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

78
include/Kyoto/Particles/CIntElement.hpp
View File

@ -14,8 +14,8 @@ class CIEConstant : public CIntElement {
public:
CIEConstant(int val);
~CIEConstant();
bool GetValue(int frame, int& valOut) const;
~CIEConstant() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEDeath() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEAdd() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEMultiply() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEModulo() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIERandom() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIESampleAndHold() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEImpulse() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEInitialRandom() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIETimeChain() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEClamp() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEPulse() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIELifetimePercent() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIEKeyframeEmitter() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIESubtract() override;
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();
bool GetValue(int frame, int& valOut) const;
~CIERealToInt() override;
bool GetValue(int frame, int& valOut) const override;
};
class CIEGetCumulativeParticleCount : public CIntElement {
public:
~CIEGetCumulativeParticleCount() {}
bool GetValue(int frame, int& valOut) const;
~CIEGetCumulativeParticleCount() override {}
bool GetValue(int frame, int& valOut) const override;
};
class CIEGetActiveParticleCount : public CIntElement {
public:
~CIEGetActiveParticleCount() {}
bool GetValue(int frame, int& valOut) const;
~CIEGetActiveParticleCount() override {}
bool GetValue(int frame, int& valOut) const override;
};
class CIEGetEmitterTime : public CIntElement {
public:
~CIEGetEmitterTime();
bool GetValue(int frame, int& valOut) const;
~CIEGetEmitterTime() override;
bool GetValue(int frame, int& valOut) const override;
};
#endif // _CINTELEMENT

52
include/Kyoto/Particles/CModVectorElement.hpp
View File

@ -13,8 +13,8 @@ class CMVEConstant : public CModVectorElement {
public:
CMVEConstant(CRealElement* a, CRealElement* b, CRealElement* c);
~CMVEConstant();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEConstant() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEFastConstant() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEGravity() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEWind() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEExplode() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVETimeChain() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEPulse() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEImplosion() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVELinearImplosion() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEExponentialImplosion() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVESwirl() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVEBounce() override;
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();
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const;
~CMVESetPosition() override;
bool GetValue(int frame, CVector3f& pVel, CVector3f& pPos) const override;
};
#endif // _CMODVECTORELEMENT

52
include/Kyoto/Particles/CParticleElectric.hpp
View File

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

160
include/Kyoto/Particles/CRealElement.hpp
View File

@ -12,9 +12,9 @@ class CREConstant : public CRealElement {
public:
CREConstant(float val);
~CREConstant();
bool GetValue(int frame, float& valOut) const;
bool IsConstant() const { return true; }
~CREConstant() override;
bool GetValue(int frame, float& valOut) const override;
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();
bool GetValue(int frame, float& valOut) const;
~CRESineWave() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRETimeScale() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREAdd() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREMultiply() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREDotProduct() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRERandom() override;
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();
bool GetValue(int frame, float& valOut) const;
bool IsConstant() const { return true; }
~CREInitialRandom() override;
bool GetValue(int frame, float& valOut) const override;
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();
bool GetValue(int frame, float& valOut) const;
~CRETimeChain() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREClamp() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREPulse() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRELifetimePercent() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRELifetimeTween() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREKeyframeEmitter() override;
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter1 : public CRealElement {
public:
~CREParticleAccessParameter1() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter1() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter2 : public CRealElement {
public:
~CREParticleAccessParameter2() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter2() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter3 : public CRealElement {
public:
~CREParticleAccessParameter3() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter3() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter4 : public CRealElement {
public:
~CREParticleAccessParameter4() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter4() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter5 : public CRealElement {
public:
~CREParticleAccessParameter5() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter5() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter6 : public CRealElement {
public:
~CREParticleAccessParameter6() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter6() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter7 : public CRealElement {
public:
~CREParticleAccessParameter7() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter7() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleAccessParameter8 : public CRealElement {
public:
~CREParticleAccessParameter8() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleAccessParameter8() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleSizeOrLineLength : public CRealElement {
public:
~CREParticleSizeOrLineLength() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleSizeOrLineLength() override {}
bool GetValue(int frame, float& valOut) const override;
};
class CREParticleRotationOrLineWidth : public CRealElement {
public:
~CREParticleRotationOrLineWidth() {}
bool GetValue(int frame, float& valOut) const;
~CREParticleRotationOrLineWidth() override {}
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();
bool GetValue(int frame, float& valOut) const;
~CREVectorXToReal() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREVectorYToReal() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREVectorZToReal() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREVectorMagnitude() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREInitialSwitch() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRECompareLessThan() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRECompareEqual() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREConstantRange() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREExternalVar() override;
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();
bool GetValue(int frame, float& valOut) const;
~CRESubtract() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREGetComponentRed() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREGetComponentGreen() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREGetComponentBlue() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREGetComponentAlpha() override;
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();
bool GetValue(int frame, float& valOut) const;
~CREIntTimesReal() override;
bool GetValue(int frame, float& valOut) const override;
};
#endif // _CREALELEMENT

20
include/Kyoto/Particles/CUVElement.hpp
View File

@ -13,11 +13,11 @@ class CUVEConstant : public CUVElement {
public:
CUVEConstant(TToken< CTexture > tex);
~CUVEConstant();
TLockedToken< CTexture > GetValueTexture(int frame) const;
void GetValueUV(int frame, SUVElementSet& valOut) const;
bool HasConstantTexture() const { return true; }
bool HasConstantUV() const { return true; }
~CUVEConstant() override;
TLockedToken< CTexture > GetValueTexture(int frame) const override;
void GetValueUV(int frame, SUVElementSet& valOut) const override;
bool HasConstantTexture() const override { 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();
TLockedToken< CTexture > GetValueTexture(int frame) const;
void GetValueUV(int frame, SUVElementSet& valOut) const;
bool HasConstantTexture() const { return true; }
bool HasConstantUV() const { return false; }
~CUVEAnimTexture() override;
TLockedToken< CTexture > GetValueTexture(int frame) const override;
void GetValueUV(int frame, SUVElementSet& valOut) const override;
bool HasConstantTexture() const override { return true; }
bool HasConstantUV() const override { return false; }
};
#endif // _CUVELEMENT

40
include/Kyoto/Particles/CVectorElement.hpp
View File

@ -11,9 +11,9 @@
class CVEFastConstant : public CVectorElement {
public:
CVEFastConstant(float x, float y, float z);
~CVEFastConstant();
bool GetValue(int frame, CVector3f& valOut) const;
bool IsFastConstant() const { return true; }
~CVEFastConstant() override;
bool GetValue(int frame, CVector3f& valOut) const override;
bool IsFastConstant() const override { return true; }
private:
CVector3f x4_val;
@ -21,51 +21,51 @@ private:
class CVEParticleLocation : public CVectorElement {
public:
~CVEParticleLocation() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleLocation() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleColor : public CVectorElement {
public:
~CVEParticleColor() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleColor() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleVelocity : public CVectorElement {
public:
~CVEParticleVelocity() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleVelocity() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleSystemOrientationFront : public CVectorElement {
public:
~CVEParticleSystemOrientationFront() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleSystemOrientationFront() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleSystemOrientationUp : public CVectorElement {
public:
~CVEParticleSystemOrientationUp() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleSystemOrientationUp() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleSystemOrientationRight : public CVectorElement {
public:
~CVEParticleSystemOrientationRight() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleSystemOrientationRight() override {}
bool GetValue(int frame, CVector3f& valOut) const override;
};
class CVEParticleSystemTranslation : public CVectorElement {
public:
~CVEParticleSystemTranslation() {}
bool GetValue(int frame, CVector3f& valOut) const;
~CVEParticleSystemTranslation() override {}
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

2
include/Kyoto/Particles/IElement.hpp
View File

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

4
include/Kyoto/Streams/CMemoryInStream.hpp
View File

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

4
include/Kyoto/Streams/CZipInputStream.hpp
View File

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

130
include/MetaRender/CCubeRenderer.hpp
View File

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

6
include/MetroidPrime/BodyState/CABSAim.hpp
View File

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

6
include/MetroidPrime/BodyState/CABSFlinch.hpp
View File

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

6
include/MetroidPrime/BodyState/CABSIdle.hpp
View File

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

6
include/MetroidPrime/BodyState/CABSReaction.hpp
View File

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

8
include/MetroidPrime/BodyState/CBSAttack.hpp
View File

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

12
include/MetroidPrime/BodyState/CBSCover.hpp
View File

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

10
include/MetroidPrime/BodyState/CBSDie.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSFall.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSGenerate.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSGetup.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSGroundHit.hpp
View File

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

8
include/MetroidPrime/BodyState/CBSKnockBack.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSLieOnGround.hpp
View File

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

8
include/MetroidPrime/BodyState/CBSLocomotion.hpp
View File

@ -14,10 +14,10 @@ protected:
public:
bool IsMoving() const override = 0;
bool CanShoot() const { return true; }
void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController& bc);
bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
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);

8
include/MetroidPrime/BodyState/CBSLoopAttack.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSLoopReaction.hpp
View File

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

8
include/MetroidPrime/BodyState/CBSProjectileAttack.hpp
View File

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

8
include/MetroidPrime/BodyState/CBSScripted.hpp
View File

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

10
include/MetroidPrime/BodyState/CBSSlide.hpp
View File

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

10
include/MetroidPrime/BodyState/CBSStep.hpp
View File

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

6
include/MetroidPrime/BodyState/CBSTaunt.hpp
View File

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

14
include/MetroidPrime/BodyState/CBSTurn.hpp
View File

@ -8,12 +8,12 @@
class CBSTurn : public CBodyState {
public:
CBSTurn();
~CBSTurn() {}
~CBSTurn() override {}
bool CanShoot() const { return true; }
void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController&);
bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
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);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
};
#endif // _CBSTURN

2
include/MetroidPrime/BodyState/CBodyStateCmdMgr.hpp
View File

@ -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; }

2
include/MetroidPrime/CActor.hpp
View File

@ -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);

10
include/MetroidPrime/CAnimationDatabaseGame.hpp
View File

@ -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;
uint GetNumMetaAnims() const;
rstl::string GetMetaAnimName(uint idx) const;
void GetAllUniquePrimitives(rstl::vector< CPrimitive >& primsOut) const;
const rstl::rc_ptr< IMetaAnim >& GetMetaAnim(uint idx) const override;
uint GetNumMetaAnims() const override;
rstl::string GetMetaAnimName(uint idx) const override;
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;

4
include/MetroidPrime/CAudioStateWin.hpp
View File

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

26
include/MetroidPrime/CCollisionActor.hpp
View File

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

4
include/MetroidPrime/CConsoleOutputWindow.hpp
View File

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

8
include/MetroidPrime/CCredits.hpp
View File

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

6
include/MetroidPrime/CEffect.hpp
View File

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

8
include/MetroidPrime/CErrorOutputWindow.hpp
View File

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

16
include/MetroidPrime/CExplosion.hpp
View File

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

12
include/MetroidPrime/CFlameWarp.hpp
View File

@ -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);
void Activate(bool val) { xa0_24_activated = val; }
bool IsActivated();
CColor* color, float* lineLengthOrSize, float* lineWidthOrRota) override;
void Activate(bool val) override { xa0_24_activated = val; }
bool IsActivated() override;
bool IsProcessed() const { return xa0_26_processed; }
FourCC Get4CharID();
FourCC Get4CharID() override;
void ResetPosition(const CVector3f& pos);
CAABox CalculateBounds() const;

16
include/MetroidPrime/CGameArea.hpp
View File

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

4
include/MetroidPrime/CGameLight.hpp
View File

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

8
include/MetroidPrime/CMainFlow.hpp
View File

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

34
include/MetroidPrime/CParticleGenInfoGeneric.hpp
View File

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

8
include/MetroidPrime/CPhysicsActor.hpp
View File

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

6
include/MetroidPrime/CSplashScreen.hpp
View File

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

22
include/MetroidPrime/CWorld.hpp
View File

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

14
include/MetroidPrime/Cameras/CBallCamera.hpp
View File

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

10
include/MetroidPrime/Cameras/CCinematicCamera.hpp
View File

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

8
include/MetroidPrime/Cameras/CGameCamera.hpp
View File

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

4
include/MetroidPrime/Cameras/CInterpolationCamera.hpp
View File

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

10
include/MetroidPrime/Enemies/CAi.hpp
View File

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

14
include/MetroidPrime/Enemies/CFlaahgraPlants.hpp
View File

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

32
include/MetroidPrime/Enemies/CMetaree.hpp
View File

@ -17,31 +17,31 @@ public:
float f3, float f4, const CActorParameters& aParms);
// CEntity
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
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 Halt(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
void Flee(CStateManager&, EStateMsg, float);
void Explode(CStateManager&, EStateMsg, float);
bool InRange(CStateManager&, float);
bool Delay(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
void Dead(CStateManager&, EStateMsg, float) override;
void Halt(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float) override;
void Explode(CStateManager&, EStateMsg, float) override;
bool InRange(CStateManager&, float) override;
bool Delay(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
// CPatterned
void ThinkAboutMove(float);
void ThinkAboutMove(float) override;
private:
float x568_delay;

6
include/MetroidPrime/Enemies/CMetroidPrimeProjectile.hpp
View File

@ -42,12 +42,12 @@ public:
bool sendCollideMsg);
// CEntity
~CMetroidPrimeProjectile();
void Accept(IVisitor& visitor);
~CMetroidPrimeProjectile() override;
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

34
include/MetroidPrime/Enemies/CNewIntroBoss.hpp
View File

@ -19,30 +19,30 @@ public:
CAssetId beamTextureId, CAssetId beamGlowTextureId);
// CEntity
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
// CActor
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
rstl::optional_object< CAABox > GetTouchBounds() const;
void OnScanStateChange(EScanState, CStateManager&);
CAABox GetSortingBounds(const CStateManager&) const;
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
rstl::optional_object< CAABox > GetTouchBounds() const override;
void OnScanStateChange(EScanState, CStateManager&) override;
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 Generate(CStateManager& mgr, EStateMsg msg, float arg);
void Attack(CStateManager&, EStateMsg, float);
bool InAttackPosition(CStateManager&, float);
bool AnimOver(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool ShouldTurn(CStateManager&, float);
bool AIStage(CStateManager&, float);
void Patrol(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager& mgr, EStateMsg msg, float arg) override;
void Attack(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool ShouldTurn(CStateManager&, float) override;
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;

112
include/MetroidPrime/Enemies/CPatterned.hpp
View File

@ -151,73 +151,73 @@ public:
EBodyType body, const CActorParameters& params, EKnockBackVariant kbVariant);
// CEntity
~CPatterned();
void Accept(IVisitor& visitor);
void PreThink(float dt, CStateManager& mgr);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
~CPatterned() override;
void Accept(IVisitor& visitor) override;
void PreThink(float dt, CStateManager& mgr) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
// CActor
void PreRender(CStateManager&, const CFrustumPlanes&);
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
void Render(const CStateManager&) const;
bool CanRenderUnsorted(const CStateManager&) const;
rstl::optional_object< CAABox > GetTouchBounds() const;
void Touch(CActor&, CStateManager&);
CVector3f GetOrbitPosition(const CStateManager&) const;
CVector3f GetAimPosition(const CStateManager&, float) const;
void PreRender(CStateManager&, const CFrustumPlanes&) override;
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
void Render(const CStateManager&) const override;
bool CanRenderUnsorted(const CStateManager&) const override;
rstl::optional_object< CAABox > GetTouchBounds() const override;
void Touch(CActor&, CStateManager&) override;
CVector3f GetOrbitPosition(const CStateManager&) const override;
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);
void TakeDamage(const CVector3f& direction, float magnitude);
void Patrol(CStateManager&, EStateMsg, float);
void FollowPattern(CStateManager&, EStateMsg, float);
void Dead(CStateManager&, EStateMsg, float);
void PathFind(CStateManager&, EStateMsg, float);
void Start(CStateManager&, EStateMsg, float);
void TargetPatrol(CStateManager&, EStateMsg, float);
void TargetPlayer(CStateManager&, EStateMsg, float);
bool Leash(CStateManager&, float);
bool OffLine(CStateManager&, float);
bool Attacked(CStateManager&, float);
bool PathShagged(CStateManager&, float);
bool PathOver(CStateManager&, float);
bool PathFound(CStateManager&, float);
bool TooClose(CStateManager&, float);
bool InRange(CStateManager&, float);
bool InMaxRange(CStateManager&, float);
bool InDetectionRange(CStateManager&, float);
bool SpotPlayer(CStateManager&, float);
bool PlayerSpot(CStateManager&, float);
bool PatternOver(CStateManager&, float);
bool PatternShagged(CStateManager&, float);
bool HasAttackPattern(CStateManager&, float);
bool HasPatrolPath(CStateManager&, float);
bool HasRetreatPattern(CStateManager&, float);
bool Delay(CStateManager&, float);
bool RandomDelay(CStateManager&, float);
bool FixedDelay(CStateManager&, float);
bool Default(CStateManager&, float);
bool AnimOver(CStateManager&, float);
bool InPosition(CStateManager&, float);
bool Stuck(CStateManager&, float);
bool NoPathNodes(CStateManager&, float);
bool Landed(CStateManager&, float);
bool PatrolPathOver(CStateManager&, float);
bool CodeTrigger(CStateManager&, float);
bool Random(CStateManager&, float);
bool FixedRandom(CStateManager&, float);
bool inDeferred, float magnitude) override;
void TakeDamage(const CVector3f& direction, float magnitude) override;
void Patrol(CStateManager&, EStateMsg, float) override;
void FollowPattern(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager&, EStateMsg, float) override;
void Start(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float) override;
void TargetPlayer(CStateManager&, EStateMsg, float) override;
bool Leash(CStateManager&, float) override;
bool OffLine(CStateManager&, float) override;
bool Attacked(CStateManager&, float) override;
bool PathShagged(CStateManager&, float) override;
bool PathOver(CStateManager&, float) override;
bool PathFound(CStateManager&, float) override;
bool TooClose(CStateManager&, float) override;
bool InRange(CStateManager&, float) override;
bool InMaxRange(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float) override;
bool PlayerSpot(CStateManager&, float) override;
bool PatternOver(CStateManager&, float) override;
bool PatternShagged(CStateManager&, float) override;
bool HasAttackPattern(CStateManager&, float) override;
bool HasPatrolPath(CStateManager&, float) override;
bool HasRetreatPattern(CStateManager&, float) override;
bool Delay(CStateManager&, float) override;
bool RandomDelay(CStateManager&, float) override;
bool FixedDelay(CStateManager&, float) override;
bool Default(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override;
bool InPosition(CStateManager&, float) override;
bool Stuck(CStateManager&, float) override;
bool NoPathNodes(CStateManager&, float) override;
bool Landed(CStateManager&, float) override;
bool PatrolPathOver(CStateManager&, float) override;
bool CodeTrigger(CStateManager&, float) override;
bool Random(CStateManager&, float) override;
bool FixedRandom(CStateManager&, float) override;
// CPatterned
virtual void Freeze(CStateManager& mgr, const CVector3f& pos, const CUnitVector3f& dir,

14
include/MetroidPrime/Enemies/CPuffer.hpp
View File

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

2
include/MetroidPrime/Enemies/CRipperControlledPlatform.hpp
View File

@ -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;

14
include/MetroidPrime/GameObjectLists.hpp
View File

@ -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;
};

48
include/MetroidPrime/Player/CPlayer.hpp
View File

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

14
include/MetroidPrime/ScriptObjects/CFire.hpp
View File

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

12
include/MetroidPrime/ScriptObjects/CHUDBillboardEffect.hpp
View File

@ -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 Think(float dt, CStateManager& mgr);
void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum);
void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const;
void Render(const CStateManager& mgr) const;
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const CFrustumPlanes& frustum) override;
void AddToRenderer(const CFrustumPlanes& frustum, const CStateManager& mgr) const override;
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(); }

4
include/MetroidPrime/ScriptObjects/CRepulsor.hpp
View File

@ -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 AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
float GetAffectRadius() const { return xe8_affectRadius; }
};

22
include/MetroidPrime/ScriptObjects/CScriptActor.hpp
View File

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

6
include/MetroidPrime/ScriptObjects/CScriptActorKeyframe.hpp
View File

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

6
include/MetroidPrime/ScriptObjects/CScriptActorRotate.hpp
View File

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

12
include/MetroidPrime/ScriptObjects/CScriptAiJumpPoint.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptAreaAttributes.hpp
View File

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

10
include/MetroidPrime/ScriptObjects/CScriptBallTrigger.hpp
View File

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

6
include/MetroidPrime/ScriptObjects/CScriptBeam.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptCameraBlurKeyframe.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptCameraFilterKeyframe.hpp
View File

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

8
include/MetroidPrime/ScriptObjects/CScriptCameraHintTrigger.hpp
View File

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

8
include/MetroidPrime/ScriptObjects/CScriptCameraPitchVolume.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptCameraShaker.hpp
View File

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

8
include/MetroidPrime/ScriptObjects/CScriptCameraWaypoint.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptControllerAction.hpp
View File

@ -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 Think(float, CStateManager&);
void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&) override;
static ControlMapper::ECommands GetCommand(ECommands cmd);
};

4
include/MetroidPrime/ScriptObjects/CScriptCounter.hpp
View File

@ -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 Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Accept(IVisitor& visitor) override;
};
#endif // _CSCRIPTCOUNTER

12
include/MetroidPrime/ScriptObjects/CScriptCoverPoint.hpp
View File

@ -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 Think(float, CStateManager&);
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
void Render(const CStateManager&) const;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
rstl::optional_object< CAABox > GetTouchBounds() const;
void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&) override;
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
void Render(const CStateManager&) const override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
rstl::optional_object< CAABox > GetTouchBounds() const override;
bool ShouldCrouch() const;
bool ShouldStay() const;

20
include/MetroidPrime/ScriptObjects/CScriptDamageableTrigger.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptDebugCameraWaypoint.hpp
View File

@ -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;

4
include/MetroidPrime/ScriptObjects/CScriptDistanceFog.hpp
View File

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

10
include/MetroidPrime/ScriptObjects/CScriptDock.hpp
View File

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

4
include/MetroidPrime/ScriptObjects/CScriptDockAreaChange.hpp
View File

@ -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 Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Accept(IVisitor& visitor) override;
~CScriptDockAreaChange();
};

14
include/MetroidPrime/ScriptObjects/CScriptEMPulse.hpp
View File

@ -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 Think(float, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const;
void CalculateRenderBounds();
rstl::optional_object< CAABox > GetTouchBounds() const;
void Touch(CActor&, CStateManager&);
void Accept(IVisitor&) override;
void Think(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddToRenderer(const CFrustumPlanes&, const CStateManager&) const override;
void CalculateRenderBounds() override;
rstl::optional_object< CAABox > GetTouchBounds() const override;
void Touch(CActor&, CStateManager&) override;
private:
float xe8_duration;

4
include/MetroidPrime/ScriptObjects/CScriptGenerator.hpp
View File

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

Some files were not shown because too many files have changed in this diff Show More