AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'override' of https://github.com/lioncash/urde

This commit is contained in:
Phillip Stephens 2019-08-09 06:27:54 -07:00
parent 8089566788 2059535b55
commit 5eaa7a23e8
144 changed files with 1011 additions and 999 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
Runtime/Audio/CSfxManager.hpp
View File

@ -125,16 +125,16 @@ public:
float x55_cachedMaxVol; float x55_cachedMaxVol;
public: public:
bool IsPlaying() const; bool IsPlaying() const override;
void Play(); void Play() override;
void Stop(); void Stop() override;
bool Ready(); bool Ready() override;
ESfxAudibility GetAudible(const zeus::CVector3f&); ESfxAudibility GetAudible(const zeus::CVector3f&) override;
amuse::ObjToken<amuse::Voice> GetVoice() const { return x50_emitterHandle->getVoice(); } amuse::ObjToken<amuse::Voice> GetVoice() const override { return x50_emitterHandle->getVoice(); }
u16 GetSfxId() const; u16 GetSfxId() const override;
void UpdateEmitterSilent(); void UpdateEmitterSilent() override;
void UpdateEmitter(); void UpdateEmitter() override;
void SetReverb(float rev); void SetReverb(float rev) override;
CAudioSys::C3DEmitterParmData& GetEmitterData() { return x24_parmData; } CAudioSys::C3DEmitterParmData& GetEmitterData() { return x24_parmData; }
amuse::ObjToken<amuse::Emitter> GetHandle() const { return x50_emitterHandle; } amuse::ObjToken<amuse::Emitter> GetHandle() const { return x50_emitterHandle; }
@ -154,16 +154,16 @@ public:
bool x24_ready = true; bool x24_ready = true;
public: public:
bool IsPlaying() const; bool IsPlaying() const override;
void Play(); void Play() override;
void Stop(); void Stop() override;
bool Ready(); bool Ready() override;
ESfxAudibility GetAudible(const zeus::CVector3f&) { return ESfxAudibility::Aud3; } ESfxAudibility GetAudible(const zeus::CVector3f&) override { return ESfxAudibility::Aud3; }
amuse::ObjToken<amuse::Voice> GetVoice() const { return x1c_voiceHandle; } amuse::ObjToken<amuse::Voice> GetVoice() const override { return x1c_voiceHandle; }
u16 GetSfxId() const; u16 GetSfxId() const override;
void UpdateEmitterSilent(); void UpdateEmitterSilent() override;
void UpdateEmitter(); void UpdateEmitter() override;
void SetReverb(float rev); void SetReverb(float rev) override;
void SetVolume(float vol) { x20_vol = vol; } void SetVolume(float vol) { x20_vol = vol; }
CSfxWrapper(bool looped, s16 prio, u16 sfxId, float vol, float pan, CSfxWrapper(bool looped, s16 prio, u16 sfxId, float vol, float pan,

4
Runtime/Audio/CStaticAudioPlayer.hpp
View File

@ -37,8 +37,8 @@ class CStaticAudioPlayer {
struct AudioVoiceCallback : boo::IAudioVoiceCallback { struct AudioVoiceCallback : boo::IAudioVoiceCallback {
CStaticAudioPlayer& m_parent; CStaticAudioPlayer& m_parent;
void preSupplyAudio(boo::IAudioVoice&, double) {} void preSupplyAudio(boo::IAudioVoice&, double) override {}
size_t supplyAudio(boo::IAudioVoice& voice, size_t frames, int16_t* data) { size_t supplyAudio(boo::IAudioVoice& voice, size_t frames, int16_t* data) override {
if (m_parent.IsReady()) { if (m_parent.IsReady()) {
m_parent.x38_dvdRequests.clear(); m_parent.x38_dvdRequests.clear();
m_parent.Decode(data, frames); m_parent.Decode(data, frames);

10
Runtime/CDvdFile.cpp
View File

@ -18,20 +18,20 @@ class CFileDvdRequest : public IDvdRequest {
std::function<void(u32)> m_callback; std::function<void(u32)> m_callback;
public: public:
~CFileDvdRequest() { PostCancelRequest(); } ~CFileDvdRequest() override { PostCancelRequest(); }
void WaitUntilComplete() { void WaitUntilComplete() override {
while (!m_complete.load() && !m_cancel.load()) { while (!m_complete.load() && !m_cancel.load()) {
std::unique_lock<std::mutex> lk(CDvdFile::m_WaitMutex); std::unique_lock<std::mutex> lk(CDvdFile::m_WaitMutex);
} }
} }
bool IsComplete() { return m_complete.load(); } bool IsComplete() override { return m_complete.load(); }
void PostCancelRequest() { void PostCancelRequest() override {
std::unique_lock<std::mutex> waitlk(CDvdFile::m_WaitMutex); std::unique_lock<std::mutex> waitlk(CDvdFile::m_WaitMutex);
m_cancel.store(true); m_cancel.store(true);
} }
EMediaType GetMediaType() const { return EMediaType::File; } EMediaType GetMediaType() const override { return EMediaType::File; }
CFileDvdRequest(CDvdFile& file, void* buf, u32 len, ESeekOrigin whence, int off, std::function<void(u32)>&& cb) CFileDvdRequest(CDvdFile& file, void* buf, u32 len, ESeekOrigin whence, int off, std::function<void(u32)>&& cb)
: m_reader(file.m_reader), m_buf(buf), m_len(len), m_whence(whence), m_offset(off), m_callback(std::move(cb)) {} : m_reader(file.m_reader), m_buf(buf), m_len(len), m_whence(whence), m_offset(off), m_callback(std::move(cb)) {}

2
Runtime/CMainFlowBase.hpp
View File

@ -12,7 +12,7 @@ protected:
public: public:
CMainFlowBase(const char* name) : CIOWin(name) {} CMainFlowBase(const char* name) : CIOWin(name) {}
EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue); EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue) override;
virtual void AdvanceGameState(CArchitectureQueue& queue) = 0; virtual void AdvanceGameState(CArchitectureQueue& queue) = 0;
virtual void SetGameState(EClientFlowStates state, CArchitectureQueue& queue) = 0; virtual void SetGameState(EClientFlowStates state, CArchitectureQueue& queue) = 0;
}; };

4
Runtime/CPlayMovieBase.hpp
View File

@ -10,8 +10,8 @@ class CPlayMovieBase : public CIOWin {
public: public:
CPlayMovieBase(const char* iowName, const char* path) : CIOWin(iowName), x18_moviePlayer(path, 0.0, false, false) {} CPlayMovieBase(const char* iowName, const char* path) : CIOWin(iowName), x18_moviePlayer(path, 0.0, false, false) {}
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) { return EMessageReturn::Normal; } EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override { return EMessageReturn::Normal; }
void Draw() const {} void Draw() const override {}
}; };
} // namespace urde } // namespace urde

46
Runtime/CResFactory.hpp
View File

@ -45,58 +45,64 @@ private:
public: public:
CResLoader& GetLoader() { return x4_loader; } CResLoader& GetLoader() { return x4_loader; }
std::unique_ptr<IObj> Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef); std::unique_ptr<IObj> Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef) override;
void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*, CObjectReference* selfRef); void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*,
void AsyncIdle(); CObjectReference* selfRef) override;
void CancelBuild(const SObjectTag&); void AsyncIdle() override;
void CancelBuild(const SObjectTag&) override;
bool CanBuild(const SObjectTag& tag) { return x4_loader.ResourceExists(tag); } bool CanBuild(const SObjectTag& tag) override { return x4_loader.ResourceExists(tag); }
u32 ResourceSize(const urde::SObjectTag& tag) { return x4_loader.ResourceSize(tag); } u32 ResourceSize(const urde::SObjectTag& tag) override { return x4_loader.ResourceSize(tag); }
std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag) { return x4_loader.LoadResourceSync(tag); } std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag) override {
return x4_loader.LoadResourceSync(tag);
}
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size) { std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size) override {
return x4_loader.LoadNewResourcePartSync(tag, off, size); return x4_loader.LoadNewResourcePartSync(tag, off, size);
} }
void GetTagListForFile(const char* pakName, std::vector<SObjectTag>& out) const { void GetTagListForFile(const char* pakName, std::vector<SObjectTag>& out) const override {
return x4_loader.GetTagListForFile(pakName, out); return x4_loader.GetTagListForFile(pakName, out);
} }
std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target) { std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target) override {
return x4_loader.LoadResourceAsync(tag, target); return x4_loader.LoadResourceAsync(tag, target);
} }
std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size, void* target) { std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size,
void* target) override {
return x4_loader.LoadResourcePartAsync(tag, off, size, target); return x4_loader.LoadResourcePartAsync(tag, off, size, target);
} }
const SObjectTag* GetResourceIdByName(std::string_view name) const { return x4_loader.GetResourceIdByName(name); } const SObjectTag* GetResourceIdByName(std::string_view name) const override {
return x4_loader.GetResourceIdByName(name);
}
FourCC GetResourceTypeById(CAssetId id) const { return x4_loader.GetResourceTypeById(id); } FourCC GetResourceTypeById(CAssetId id) const override { return x4_loader.GetResourceTypeById(id); }
std::vector<std::pair<std::string, SObjectTag>> GetResourceIdToNameList() const { std::vector<std::pair<std::string, SObjectTag>> GetResourceIdToNameList() const {
return x4_loader.GetResourceIdToNameList(); return x4_loader.GetResourceIdToNameList();
} }
void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const { void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const override {
return x4_loader.EnumerateResources(lambda); return x4_loader.EnumerateResources(lambda);
} }
void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const { void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const override {
return x4_loader.EnumerateNamedResources(lambda); return x4_loader.EnumerateNamedResources(lambda);
} }
void LoadPersistentResources(CSimplePool& sp); void LoadPersistentResources(CSimplePool& sp);
void UnloadPersistentResources() { m_nonWorldTokens.clear(); } void UnloadPersistentResources() { m_nonWorldTokens.clear(); }
void LoadOriginalIDs(CSimplePool& sp); void LoadOriginalIDs(CSimplePool& sp) override;
CAssetId TranslateOriginalToNew(CAssetId id) const; CAssetId TranslateOriginalToNew(CAssetId id) const override;
CAssetId TranslateNewToOriginal(CAssetId id) const; CAssetId TranslateNewToOriginal(CAssetId id) const override;
CResLoader* GetResLoader() { return &x4_loader; } CResLoader* GetResLoader() override { return &x4_loader; }
CFactoryMgr* GetFactoryMgr() { return &x5c_factoryMgr; } CFactoryMgr* GetFactoryMgr() override { return &x5c_factoryMgr; }
}; };
} // namespace urde } // namespace urde

20
Runtime/CSimplePool.hpp
View File

@ -19,16 +19,16 @@ protected:
public: public:
CSimplePool(IFactory& factory); CSimplePool(IFactory& factory);
~CSimplePool(); ~CSimplePool() override;
CToken GetObj(const SObjectTag&, const CVParamTransfer&); CToken GetObj(const SObjectTag&, const CVParamTransfer&) override;
CToken GetObj(const SObjectTag&); CToken GetObj(const SObjectTag&) override;
CToken GetObj(std::string_view); CToken GetObj(std::string_view) override;
CToken GetObj(std::string_view, const CVParamTransfer&); CToken GetObj(std::string_view, const CVParamTransfer&) override;
bool HasObject(const SObjectTag&) const; bool HasObject(const SObjectTag&) const override;
bool ObjectIsLive(const SObjectTag&) const; bool ObjectIsLive(const SObjectTag&) const override;
IFactory& GetFactory() const { return x18_factory; } IFactory& GetFactory() const override { return x18_factory; }
void Flush(); void Flush() override;
void ObjectUnreferenced(const SObjectTag&); void ObjectUnreferenced(const SObjectTag&) override;
std::vector<SObjectTag> GetReferencedTags() const; std::vector<SObjectTag> GetReferencedTags() const;
}; };

15
Runtime/GameObjectLists.hpp
View File

@ -8,39 +8,38 @@ class CActorList : public CObjectList {
public: public:
CActorList(); CActorList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
}; };
class CPhysicsActorList : public CObjectList { class CPhysicsActorList : public CObjectList {
public: public:
CPhysicsActorList(); CPhysicsActorList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
}; };
class CGameCameraList : public CObjectList { class CGameCameraList : public CObjectList {
public: public:
CGameCameraList(); CGameCameraList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
}; };
class CListeningAiList : public CObjectList { class CListeningAiList : public CObjectList {
public: public:
CListeningAiList(); CListeningAiList();
bool IsQualified(const CEntity&) override;
bool IsQualified(const CEntity&);
}; };
class CAiWaypointList : public CObjectList { class CAiWaypointList : public CObjectList {
public: public:
CAiWaypointList(); CAiWaypointList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
}; };
class CPlatformAndDoorList : public CObjectList { class CPlatformAndDoorList : public CObjectList {
public: public:
CPlatformAndDoorList(); CPlatformAndDoorList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
bool IsDoor(const CEntity&); bool IsDoor(const CEntity&);
bool IsPlatform(const CEntity&); bool IsPlatform(const CEntity&);
}; };
@ -49,7 +48,7 @@ class CGameLightList : public CObjectList {
public: public:
CGameLightList(); CGameLightList();
bool IsQualified(const CEntity&); bool IsQualified(const CEntity&) override;
}; };
} // namespace urde } // namespace urde

6
Runtime/GuiSys/CAuiEnergyBarT01.hpp
View File

@ -36,10 +36,10 @@ private:
public: public:
CAuiEnergyBarT01(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId txtrId); CAuiEnergyBarT01(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId txtrId);
FourCC GetWidgetTypeID() const { return FOURCC('ENRG'); } FourCC GetWidgetTypeID() const override { return FOURCC('ENRG'); }
static std::pair<zeus::CVector3f, zeus::CVector3f> DownloadBarCoordFunc(float t); static std::pair<zeus::CVector3f, zeus::CVector3f> DownloadBarCoordFunc(float t);
void Update(float dt); void Update(float dt) override;
void Draw(const CGuiWidgetDrawParms& drawParms) const; void Draw(const CGuiWidgetDrawParms& drawParms) const override;
float GetActualFraction() const { return xe0_maxEnergy == 0.f ? 0.f : xf4_setEnergy / xe0_maxEnergy; } float GetActualFraction() const { return xe0_maxEnergy == 0.f ? 0.f : xf4_setEnergy / xe0_maxEnergy; }
float GetSetEnergy() const { return xf4_setEnergy; } float GetSetEnergy() const { return xf4_setEnergy; }
float GetMaxEnergy() const { return xe0_maxEnergy; } float GetMaxEnergy() const { return xe0_maxEnergy; }

10
Runtime/GuiSys/CAuiImagePane.hpp
View File

@ -38,13 +38,13 @@ public:
CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId, CAssetId, CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId, CAssetId,
rstl::reserved_vector<zeus::CVector3f, 4>&& coords, rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, rstl::reserved_vector<zeus::CVector3f, 4>&& coords, rstl::reserved_vector<zeus::CVector2f, 4>&& uvs,
bool initTex); bool initTex);
FourCC GetWidgetTypeID() const { return FOURCC('IMGP'); } FourCC GetWidgetTypeID() const override { return FOURCC('IMGP'); }
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
void Reset(ETraversalMode mode); void Reset(ETraversalMode mode) override;
void Update(float dt); void Update(float dt) override;
void Draw(const CGuiWidgetDrawParms& params) const; void Draw(const CGuiWidgetDrawParms& params) const override;
bool GetIsFinishedLoadingWidgetSpecific() const; bool GetIsFinishedLoadingWidgetSpecific() const override;
void SetTextureID0(CAssetId tex, CSimplePool* sp); void SetTextureID0(CAssetId tex, CSimplePool* sp);
void SetAnimationParms(const zeus::CVector2f& vec, float interval, float duration); void SetAnimationParms(const zeus::CVector2f& vec, float interval, float duration);
void SetDeResFactor(float d) { x14c_deResFactor = d; } void SetDeResFactor(float d) { x14c_deResFactor = d; }

8
Runtime/GuiSys/CAuiMeter.hpp
View File

@ -15,14 +15,14 @@ class CAuiMeter : public CGuiGroup {
public: public:
CAuiMeter(const CGuiWidgetParms& parms, bool noRoundUp, u32 maxCapacity, u32 workerCount); CAuiMeter(const CGuiWidgetParms& parms, bool noRoundUp, u32 maxCapacity, u32 workerCount);
FourCC GetWidgetTypeID() const { return FOURCC('METR'); } FourCC GetWidgetTypeID() const override { return FOURCC('METR'); }
void OnVisibleChange(); void OnVisibleChange() override;
void SetCurrValue(s32 val); void SetCurrValue(s32 val);
void SetCapacity(s32 cap); void SetCapacity(s32 cap);
void SetMaxCapacity(s32 cap); void SetMaxCapacity(s32 cap);
CGuiWidget* GetWorkerWidget(int id) const; CGuiWidget* GetWorkerWidget(int id) const override;
bool AddWorkerWidget(CGuiWidget* worker); bool AddWorkerWidget(CGuiWidget* worker) override;
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
}; };

4
Runtime/GuiSys/CConsoleOutputWindow.hpp
View File

@ -7,8 +7,8 @@ namespace urde {
class CConsoleOutputWindow : public CIOWin { class CConsoleOutputWindow : public CIOWin {
public: public:
CConsoleOutputWindow(int, float, float); CConsoleOutputWindow(int, float, float);
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
void Draw() const; void Draw() const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/GuiSys/CErrorOutputWindow.hpp
View File

@ -25,9 +25,9 @@ private:
public: public:
CErrorOutputWindow(bool); CErrorOutputWindow(bool);
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
bool GetIsContinueDraw() const { return int(x14_state) < 2; } bool GetIsContinueDraw() const override { return int(x14_state) < 2; }
void Draw() const; void Draw() const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/GuiSys/CGuiCamera.hpp
View File

@ -38,14 +38,14 @@ private:
public: public:
CGuiCamera(const CGuiWidgetParms& parms, float left, float right, float top, float bottom, float znear, float zfar); CGuiCamera(const CGuiWidgetParms& parms, float left, float right, float top, float bottom, float znear, float zfar);
CGuiCamera(const CGuiWidgetParms& parms, float fov, float aspect, float znear, float zfar); CGuiCamera(const CGuiWidgetParms& parms, float fov, float aspect, float znear, float zfar);
FourCC GetWidgetTypeID() const { return FOURCC('CAMR'); } FourCC GetWidgetTypeID() const override { return FOURCC('CAMR'); }
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
zeus::CVector3f ConvertToScreenSpace(const zeus::CVector3f& vec) const; zeus::CVector3f ConvertToScreenSpace(const zeus::CVector3f& vec) const;
const SProjection& GetProjection() const { return m_proj; } const SProjection& GetProjection() const { return m_proj; }
void SetFov(float fov) { m_proj.xbc_fov = fov; } void SetFov(float fov) { m_proj.xbc_fov = fov; }
void Draw(const CGuiWidgetDrawParms& parms) const; void Draw(const CGuiWidgetDrawParms& parms) const override;
std::shared_ptr<CGuiCamera> shared_from_this() { std::shared_ptr<CGuiCamera> shared_from_this() {
return std::static_pointer_cast<CGuiCamera>(CGuiObject::shared_from_this()); return std::static_pointer_cast<CGuiCamera>(CGuiObject::shared_from_this());

6
Runtime/GuiSys/CGuiCompoundWidget.hpp
View File

@ -7,10 +7,10 @@ namespace urde {
class CGuiCompoundWidget : public CGuiWidget { class CGuiCompoundWidget : public CGuiWidget {
public: public:
CGuiCompoundWidget(const CGuiWidgetParms& parms); CGuiCompoundWidget(const CGuiWidgetParms& parms);
FourCC GetWidgetTypeID() const { return FourCC(-1); } FourCC GetWidgetTypeID() const override { return FourCC(-1); }
void OnVisibleChange(); void OnVisibleChange() override;
void OnActiveChange(); void OnActiveChange() override;
virtual CGuiWidget* GetWorkerWidget(int id) const; virtual CGuiWidget* GetWorkerWidget(int id) const;
}; };

6
Runtime/GuiSys/CGuiGroup.hpp
View File

@ -11,12 +11,12 @@ class CGuiGroup : public CGuiCompoundWidget {
public: public:
CGuiGroup(const CGuiWidgetParms& parms, int defaultWorker, bool b); CGuiGroup(const CGuiWidgetParms& parms, int defaultWorker, bool b);
FourCC GetWidgetTypeID() const { return FOURCC('GRUP'); } FourCC GetWidgetTypeID() const override { return FOURCC('GRUP'); }
void SelectWorkerWidget(int workerId, bool setActive, bool setVisible); void SelectWorkerWidget(int workerId, bool setActive, bool setVisible);
CGuiWidget* GetSelectedWidget(); CGuiWidget* GetSelectedWidget();
bool AddWorkerWidget(CGuiWidget* worker); bool AddWorkerWidget(CGuiWidget* worker) override;
void OnActiveChange(); void OnActiveChange() override;
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
static void LoadWidgetFnMap(); static void LoadWidgetFnMap();

2
Runtime/GuiSys/CGuiHeadWidget.hpp
View File

@ -6,7 +6,7 @@ namespace urde {
class CGuiHeadWidget : public CGuiWidget { class CGuiHeadWidget : public CGuiWidget {
public: public:
FourCC GetWidgetTypeID() const { return FOURCC('HWIG'); } FourCC GetWidgetTypeID() const override { return FOURCC('HWIG'); }
CGuiHeadWidget(const CGuiWidgetParms& parms); CGuiHeadWidget(const CGuiWidgetParms& parms);
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);

6
Runtime/GuiSys/CGuiLight.hpp
View File

@ -19,12 +19,12 @@ class CGuiLight : public CGuiWidget {
zeus::CColor xdc_ambColor = zeus::skBlack; zeus::CColor xdc_ambColor = zeus::skBlack;
public: public:
~CGuiLight(); ~CGuiLight() override;
CGuiLight(const CGuiWidgetParms& parms, const CLight& light); CGuiLight(const CGuiWidgetParms& parms, const CLight& light);
FourCC GetWidgetTypeID() const { return FOURCC('LITE'); } FourCC GetWidgetTypeID() const override { return FOURCC('LITE'); }
CLight BuildLight() const; CLight BuildLight() const;
void SetIsVisible(bool vis); void SetIsVisible(bool vis) override;
u32 GetLightId() const { return xd8_lightId; } u32 GetLightId() const { return xd8_lightId; }
const zeus::CColor& GetAmbientLightColor() const { return xdc_ambColor; } const zeus::CColor& GetAmbientLightColor() const { return xdc_ambColor; }
void SetSpotCutoff(float v) { xbc_spotCutoff = v; } void SetSpotCutoff(float v) { xbc_spotCutoff = v; }

10
Runtime/GuiSys/CGuiModel.hpp
View File

@ -14,14 +14,14 @@ class CGuiModel : public CGuiWidget {
public: public:
CGuiModel(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId modelId, u32 lightMask, bool flag); CGuiModel(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId modelId, u32 lightMask, bool flag);
FourCC GetWidgetTypeID() const { return FOURCC('MODL'); } FourCC GetWidgetTypeID() const override { return FOURCC('MODL'); }
std::vector<CAssetId> GetModelAssets() const { return {xc8_modelId}; } std::vector<CAssetId> GetModelAssets() const { return {xc8_modelId}; }
const TLockedToken<CModel>& GetModel() const { return xb8_model; } const TLockedToken<CModel>& GetModel() const { return xb8_model; }
bool GetIsFinishedLoadingWidgetSpecific() const; bool GetIsFinishedLoadingWidgetSpecific() const override;
void Touch() const; void Touch() const override;
void Draw(const CGuiWidgetDrawParms& parms) const; void Draw(const CGuiWidgetDrawParms& parms) const override;
bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const; bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const override;
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
}; };

2
Runtime/GuiSys/CGuiPane.hpp
View File

@ -17,7 +17,7 @@ protected:
public: public:
CGuiPane(const CGuiWidgetParms& parms, const zeus::CVector2f& dim, const zeus::CVector3f& scaleCenter); CGuiPane(const CGuiWidgetParms& parms, const zeus::CVector2f& dim, const zeus::CVector3f& scaleCenter);
FourCC GetWidgetTypeID() const { return FOURCC('PANE'); } FourCC GetWidgetTypeID() const override { return FOURCC('PANE'); }
virtual void ScaleDimensions(const zeus::CVector3f& scale); virtual void ScaleDimensions(const zeus::CVector3f& scale);
virtual void SetDimensions(const zeus::CVector2f& dim, bool initVBO); virtual void SetDimensions(const zeus::CVector2f& dim, bool initVBO);

12
Runtime/GuiSys/CGuiSliderGroup.hpp
View File

@ -35,7 +35,7 @@ private:
public: public:
CGuiSliderGroup(const CGuiWidgetParms& parms, float a, float b, float c, float d); CGuiSliderGroup(const CGuiWidgetParms& parms, float a, float b, float c, float d);
FourCC GetWidgetTypeID() const { return FOURCC('SLGP'); } FourCC GetWidgetTypeID() const override { return FOURCC('SLGP'); }
EState GetState() const { return xf0_state; } EState GetState() const { return xf0_state; }
void SetSelectionChangedCallback(std::function<void(CGuiSliderGroup*, float)>&& func); void SetSelectionChangedCallback(std::function<void(CGuiSliderGroup*, float)>&& func);
@ -51,13 +51,13 @@ public:
void SetCurVal(float cur); void SetCurVal(float cur);
float GetGurVal() const { return xc0_roundedCurVal; } float GetGurVal() const { return xc0_roundedCurVal; }
bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const; bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const override;
void ProcessUserInput(const CFinalInput& input); void ProcessUserInput(const CFinalInput& input) override;
void Update(float dt); void Update(float dt) override;
bool AddWorkerWidget(CGuiWidget* worker); bool AddWorkerWidget(CGuiWidget* worker) override;
CGuiWidget* GetWorkerWidget(int id) const; CGuiWidget* GetWorkerWidget(int id) const override;
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
}; };

6
Runtime/GuiSys/CGuiTableGroup.hpp
View File

@ -45,7 +45,7 @@ private:
public: public:
CGuiTableGroup(const CGuiWidgetParms& parms, int, int, bool); CGuiTableGroup(const CGuiWidgetParms& parms, int, int, bool);
FourCC GetWidgetTypeID() const { return FOURCC('TBGP'); } FourCC GetWidgetTypeID() const override { return FOURCC('TBGP'); }
void SetMenuAdvanceCallback(std::function<void(CGuiTableGroup*)>&& cb) { xd4_doMenuAdvance = std::move(cb); } void SetMenuAdvanceCallback(std::function<void(CGuiTableGroup*)>&& cb) { xd4_doMenuAdvance = std::move(cb); }
@ -84,9 +84,9 @@ public:
void SetWorkersMouseActive(bool); void SetWorkersMouseActive(bool);
void ProcessUserInput(const CFinalInput& input); void ProcessUserInput(const CFinalInput& input) override;
bool AddWorkerWidget(CGuiWidget* worker) { return true; } bool AddWorkerWidget(CGuiWidget* worker) override { return true; }
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
}; };

14
Runtime/GuiSys/CGuiTextPane.hpp
View File

@ -12,17 +12,17 @@ public:
CGuiTextPane(const CGuiWidgetParms& parms, CSimplePool* sp, const zeus::CVector2f& dim, const zeus::CVector3f& vec, CGuiTextPane(const CGuiWidgetParms& parms, CSimplePool* sp, const zeus::CVector2f& dim, const zeus::CVector3f& vec,
CAssetId fontId, const CGuiTextProperties& props, const zeus::CColor& col1, const zeus::CColor& col2, CAssetId fontId, const CGuiTextProperties& props, const zeus::CColor& col1, const zeus::CColor& col2,
s32 padX, s32 padY); s32 padX, s32 padY);
FourCC GetWidgetTypeID() const { return FOURCC('TXPN'); } FourCC GetWidgetTypeID() const override { return FOURCC('TXPN'); }
CGuiTextSupport& TextSupport() { return xd4_textSupport; } CGuiTextSupport& TextSupport() { return xd4_textSupport; }
const CGuiTextSupport& GetTextSupport() const { return xd4_textSupport; } const CGuiTextSupport& GetTextSupport() const { return xd4_textSupport; }
void Update(float dt); void Update(float dt) override;
bool GetIsFinishedLoadingWidgetSpecific() const; bool GetIsFinishedLoadingWidgetSpecific() const override;
std::vector<CAssetId> GetFontAssets() const { return {xd4_textSupport.x5c_fontId}; } std::vector<CAssetId> GetFontAssets() const { return {xd4_textSupport.x5c_fontId}; }
void SetDimensions(const zeus::CVector2f& dim, bool initVBO); void SetDimensions(const zeus::CVector2f& dim, bool initVBO) override;
void ScaleDimensions(const zeus::CVector3f& scale); void ScaleDimensions(const zeus::CVector3f& scale) override;
void Draw(const CGuiWidgetDrawParms& parms) const; void Draw(const CGuiWidgetDrawParms& parms) const override;
bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const; bool TestCursorHit(const zeus::CMatrix4f& vp, const zeus::CVector2f& point) const override;
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
}; };

7
Runtime/GuiSys/CGuiWidget.hpp
View File

@ -86,10 +86,11 @@ public:
static CGuiWidgetParms ReadWidgetHeader(CGuiFrame* frame, CInputStream& in); static CGuiWidgetParms ReadWidgetHeader(CGuiFrame* frame, CInputStream& in);
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
void Update(float dt) override;
void Draw(const CGuiWidgetDrawParms& drawParms) const override;
void Initialize() override;
virtual void Reset(ETraversalMode mode); virtual void Reset(ETraversalMode mode);
virtual void Update(float dt);
virtual void Draw(const CGuiWidgetDrawParms& drawParms) const;
virtual void Initialize();
virtual void ProcessUserInput(const CFinalInput& input); virtual void ProcessUserInput(const CFinalInput& input);
virtual void Touch() const; virtual void Touch() const;
virtual bool GetIsVisible() const; virtual bool GetIsVisible() const;

84
Runtime/GuiSys/CHudDecoInterface.hpp
View File

@ -53,15 +53,15 @@ class CHudDecoInterfaceCombat : public IHudDecoInterface {
public: public:
CHudDecoInterfaceCombat(CGuiFrame& selHud); CHudDecoInterfaceCombat(CGuiFrame& selHud);
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetHudRotation(const zeus::CQuaternion& rot); void SetHudRotation(const zeus::CQuaternion& rot) override;
void SetHudOffset(const zeus::CVector3f& off); void SetHudOffset(const zeus::CVector3f& off) override;
void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position); void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position) override;
void SetFrameColorValue(float v); void SetFrameColorValue(float v) override;
void Update(float dt, const CStateManager& stateMgr); void Update(float dt, const CStateManager& stateMgr) override;
void UpdateCameraDebugSettings(float fov, float y, float z); void UpdateCameraDebugSettings(float fov, float y, float z) override;
void UpdateHudAlpha(); void UpdateHudAlpha() override;
}; };
class CHudDecoInterfaceScan : public IHudDecoInterface { class CHudDecoInterfaceScan : public IHudDecoInterface {
@ -104,22 +104,22 @@ class CHudDecoInterfaceScan : public IHudDecoInterface {
public: public:
CHudDecoInterfaceScan(CGuiFrame& selHud); CHudDecoInterfaceScan(CGuiFrame& selHud);
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetHudRotation(const zeus::CQuaternion& rot); void SetHudRotation(const zeus::CQuaternion& rot) override;
void SetHudOffset(const zeus::CVector3f& off); void SetHudOffset(const zeus::CVector3f& off) override;
void SetReticuleTransform(const zeus::CMatrix3f& xf); void SetReticuleTransform(const zeus::CMatrix3f& xf) override;
void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position); void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position) override;
void SetFrameColorValue(float v); void SetFrameColorValue(float v) override;
void InitializeFlatFrame(); void InitializeFlatFrame();
const CScannableObjectInfo* GetCurrScanInfo(const CStateManager& stateMgr) const; const CScannableObjectInfo* GetCurrScanInfo(const CStateManager& stateMgr) const;
void UpdateScanDisplay(const CStateManager& stateMgr, float dt); void UpdateScanDisplay(const CStateManager& stateMgr, float dt);
void Update(float dt, const CStateManager& stateMgr); void Update(float dt, const CStateManager& stateMgr) override;
void Draw() const; void Draw() const override;
void ProcessInput(const CFinalInput& input); void ProcessInput(const CFinalInput& input) override;
void UpdateCameraDebugSettings(float fov, float y, float z); void UpdateCameraDebugSettings(float fov, float y, float z) override;
void UpdateHudAlpha(); void UpdateHudAlpha() override;
float GetHudTextAlpha() const; float GetHudTextAlpha() const override;
}; };
class CHudDecoInterfaceXRay : public IHudDecoInterface { class CHudDecoInterfaceXRay : public IHudDecoInterface {
@ -142,17 +142,17 @@ class CHudDecoInterfaceXRay : public IHudDecoInterface {
public: public:
CHudDecoInterfaceXRay(CGuiFrame& selHud); CHudDecoInterfaceXRay(CGuiFrame& selHud);
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetHudRotation(const zeus::CQuaternion& rot); void SetHudRotation(const zeus::CQuaternion& rot) override;
void SetHudOffset(const zeus::CVector3f& off); void SetHudOffset(const zeus::CVector3f& off) override;
void SetReticuleTransform(const zeus::CMatrix3f& xf); void SetReticuleTransform(const zeus::CMatrix3f& xf) override;
void SetDecoRotation(float angle); void SetDecoRotation(float angle) override;
void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position); void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position) override;
void SetFrameColorValue(float v); void SetFrameColorValue(float v) override;
void Update(float dt, const CStateManager& stateMgr); void Update(float dt, const CStateManager& stateMgr) override;
void UpdateCameraDebugSettings(float fov, float y, float z); void UpdateCameraDebugSettings(float fov, float y, float z) override;
void UpdateHudAlpha(); void UpdateHudAlpha() override;
}; };
class CHudDecoInterfaceThermal : public IHudDecoInterface { class CHudDecoInterfaceThermal : public IHudDecoInterface {
@ -175,15 +175,15 @@ class CHudDecoInterfaceThermal : public IHudDecoInterface {
public: public:
CHudDecoInterfaceThermal(CGuiFrame& selHud); CHudDecoInterfaceThermal(CGuiFrame& selHud);
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetHudRotation(const zeus::CQuaternion& rot); void SetHudRotation(const zeus::CQuaternion& rot) override;
void SetHudOffset(const zeus::CVector3f& off); void SetHudOffset(const zeus::CVector3f& off) override;
void SetReticuleTransform(const zeus::CMatrix3f& xf); void SetReticuleTransform(const zeus::CMatrix3f& xf) override;
void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position); void SetDamageTransform(const zeus::CMatrix3f& rotation, const zeus::CVector3f& position) override;
void Update(float dt, const CStateManager& stateMgr); void Update(float dt, const CStateManager& stateMgr) override;
void UpdateCameraDebugSettings(float fov, float y, float z); void UpdateCameraDebugSettings(float fov, float y, float z) override;
void UpdateHudAlpha(); void UpdateHudAlpha() override;
}; };
} // namespace urde } // namespace urde

16
Runtime/GuiSys/CHudFreeLookInterface.hpp
View File

@ -45,10 +45,10 @@ class CHudFreeLookInterface : public IFreeLookInterface {
public: public:
CHudFreeLookInterface(CGuiFrame& selHud, EHudType hudType, bool inFreeLook, bool lookControlHeld, bool lockedOnObj); CHudFreeLookInterface(CGuiFrame& selHud, EHudType hudType, bool inFreeLook, bool lookControlHeld, bool lockedOnObj);
void Update(float dt); void Update(float dt) override;
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetFreeLookState(bool inFreeLook, bool lookControlHeld, bool lockedOnObj, float vertLookAngle); void SetFreeLookState(bool inFreeLook, bool lookControlHeld, bool lockedOnObj, float vertLookAngle) override;
}; };
class CHudFreeLookInterfaceXRay : public IFreeLookInterface { class CHudFreeLookInterfaceXRay : public IFreeLookInterface {
@ -67,10 +67,10 @@ class CHudFreeLookInterfaceXRay : public IFreeLookInterface {
public: public:
CHudFreeLookInterfaceXRay(CGuiFrame& selHud, bool inFreeLook, bool lookControlHeld, bool lockedOnObj); CHudFreeLookInterfaceXRay(CGuiFrame& selHud, bool inFreeLook, bool lookControlHeld, bool lockedOnObj);
void Update(float dt); void Update(float dt) override;
void SetIsVisibleDebug(bool v); void SetIsVisibleDebug(bool v) override;
void SetIsVisibleGame(bool v); void SetIsVisibleGame(bool v) override;
void SetFreeLookState(bool inFreeLook, bool lookControlHeld, bool lockedOnObj, float vertLookAngle); void SetFreeLookState(bool inFreeLook, bool lookControlHeld, bool lockedOnObj, float vertLookAngle) override;
}; };
} // namespace urde } // namespace urde

56
Runtime/GuiSys/CInstruction.hpp
View File

@ -25,8 +25,8 @@ class CColorInstruction : public CInstruction {
public: public:
CColorInstruction(EColorType tp, const CTextColor& color) : x4_cType(tp), x8_color(color) {} CColorInstruction(EColorType tp, const CTextColor& color) : x4_cType(tp), x8_color(color) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CColorOverrideInstruction : public CInstruction { class CColorOverrideInstruction : public CInstruction {
@ -35,8 +35,8 @@ class CColorOverrideInstruction : public CInstruction {
public: public:
CColorOverrideInstruction(int idx, const CTextColor& color) : x4_overrideIdx(idx), x8_color(color) {} CColorOverrideInstruction(int idx, const CTextColor& color) : x4_overrideIdx(idx), x8_color(color) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CFontInstruction : public CInstruction { class CFontInstruction : public CInstruction {
@ -44,10 +44,10 @@ class CFontInstruction : public CInstruction {
public: public:
CFontInstruction(const TToken<CRasterFont>& font) : x4_font(font) {} CFontInstruction(const TToken<CRasterFont>& font) : x4_font(font) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void GetAssets(std::vector<CToken>& assetsOut) const; void GetAssets(std::vector<CToken>& assetsOut) const override;
size_t GetAssetCount() const; size_t GetAssetCount() const override;
}; };
class CLineExtraSpaceInstruction : public CInstruction { class CLineExtraSpaceInstruction : public CInstruction {
@ -55,8 +55,8 @@ class CLineExtraSpaceInstruction : public CInstruction {
public: public:
CLineExtraSpaceInstruction(s32 extraSpace) : x4_extraSpace(extraSpace) {} CLineExtraSpaceInstruction(s32 extraSpace) : x4_extraSpace(extraSpace) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CLineInstruction : public CInstruction { class CLineInstruction : public CInstruction {
@ -84,8 +84,8 @@ public:
void TestLargestFont(s32 w, s32 h, s32 b); void TestLargestFont(s32 w, s32 h, s32 b);
void TestLargestImage(s32 w, s32 h, s32 b); void TestLargestImage(s32 w, s32 h, s32 b);
void InvokeLTR(CFontRenderState& state) const; void InvokeLTR(CFontRenderState& state) const;
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
s32 GetHeight() const { s32 GetHeight() const {
if (x10_largestMonoHeight && !x30_imageBaseline) if (x10_largestMonoHeight && !x30_imageBaseline)
@ -107,20 +107,20 @@ class CLineSpacingInstruction : public CInstruction {
public: public:
CLineSpacingInstruction(float spacing) : x4_lineSpacing(spacing) {} CLineSpacingInstruction(float spacing) : x4_lineSpacing(spacing) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CPopStateInstruction : public CInstruction { class CPopStateInstruction : public CInstruction {
public: public:
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CPushStateInstruction : public CInstruction { class CPushStateInstruction : public CInstruction {
public: public:
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CRemoveColorOverrideInstruction : public CInstruction { class CRemoveColorOverrideInstruction : public CInstruction {
@ -128,8 +128,8 @@ class CRemoveColorOverrideInstruction : public CInstruction {
public: public:
CRemoveColorOverrideInstruction(int idx) : x4_idx(idx) {} CRemoveColorOverrideInstruction(int idx) : x4_idx(idx) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CImageInstruction : public CInstruction { class CImageInstruction : public CInstruction {
@ -137,16 +137,16 @@ class CImageInstruction : public CInstruction {
public: public:
CImageInstruction(const CFontImageDef& image) : x4_image(image) {} CImageInstruction(const CFontImageDef& image) : x4_image(image) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void GetAssets(std::vector<CToken>& assetsOut) const; void GetAssets(std::vector<CToken>& assetsOut) const override;
size_t GetAssetCount() const; size_t GetAssetCount() const override;
}; };
class CTextInstruction : public CInstruction { class CTextInstruction : public CInstruction {
std::u16string x4_str; /* used to be a placement-new sized allocation */ std::u16string x4_str; /* used to be a placement-new sized allocation */
public: public:
CTextInstruction(const char16_t* str, int len) : x4_str(str, len) {} CTextInstruction(const char16_t* str, int len) : x4_str(str, len) {}
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CBlockInstruction : public CInstruction { class CBlockInstruction : public CInstruction {
@ -182,15 +182,15 @@ public:
, x1c_vertJustification(vjust) {} , x1c_vertJustification(vjust) {}
void TestLargestFont(s32 monoW, s32 monoH, s32 baseline); void TestLargestFont(s32 monoW, s32 monoH, s32 baseline);
void SetupPositionLTR(CFontRenderState& state) const; void SetupPositionLTR(CFontRenderState& state) const;
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
class CWordInstruction : public CInstruction { class CWordInstruction : public CInstruction {
public: public:
void InvokeLTR(CFontRenderState& state) const; void InvokeLTR(CFontRenderState& state) const;
void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void Invoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const; void PageInvoke(CFontRenderState& state, CTextRenderBuffer* buf) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/GuiSys/CSplashScreen.hpp
View File

@ -23,8 +23,8 @@ private:
public: public:
CSplashScreen(ESplashScreen); CSplashScreen(ESplashScreen);
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
void Draw() const; void Draw() const override;
}; };
} // namespace urde } // namespace urde

12
Runtime/IOStreams.hpp
View File

@ -46,7 +46,7 @@ public:
void Flush(); void Flush();
~CBitStreamWriter() { Flush(); } ~CBitStreamWriter() override { Flush(); }
}; };
using CMemoryInStream = athena::io::MemoryReader; using CMemoryInStream = athena::io::MemoryReader;
@ -60,11 +60,11 @@ class CZipInputStream : public CInputStream {
public: public:
CZipInputStream(std::unique_ptr<CInputStream>&& strm); CZipInputStream(std::unique_ptr<CInputStream>&& strm);
~CZipInputStream(); ~CZipInputStream() override;
atUint64 readUBytesToBuf(void* buf, atUint64 len); atUint64 readUBytesToBuf(void* buf, atUint64 len) override;
void seek(atInt64, athena::SeekOrigin) {} void seek(atInt64, athena::SeekOrigin) override {}
atUint64 position() const { return 0; } atUint64 position() const override { return 0; }
atUint64 length() const { return 0; } atUint64 length() const override { return 0; }
}; };
#endif #endif

2
Runtime/IObj.hpp
View File

@ -25,7 +25,7 @@ public:
static std::unique_ptr<TObjOwnerDerivedFromIObj<T>> GetNewDerivedObject(std::unique_ptr<T>&& obj) { static std::unique_ptr<TObjOwnerDerivedFromIObj<T>> GetNewDerivedObject(std::unique_ptr<T>&& obj) {
return std::unique_ptr<TObjOwnerDerivedFromIObj<T>>(new TObjOwnerDerivedFromIObj<T>(obj.release())); return std::unique_ptr<TObjOwnerDerivedFromIObj<T>>(new TObjOwnerDerivedFromIObj<T>(obj.release()));
} }
~TObjOwnerDerivedFromIObj() { std::default_delete<T>()(static_cast<T*>(m_objPtr)); } ~TObjOwnerDerivedFromIObj() override { std::default_delete<T>()(static_cast<T*>(m_objPtr)); }
T* GetObj() { return static_cast<T*>(m_objPtr); } T* GetObj() { return static_cast<T*>(m_objPtr); }
}; };

2
Runtime/IVParamObj.hpp
View File

@ -7,7 +7,7 @@ namespace urde {
class IVParamObj : public IObj { class IVParamObj : public IObj {
public: public:
virtual ~IVParamObj() {} ~IVParamObj() override = default;
}; };
template <class T> template <class T>

13
Runtime/Input/CInputGenerator.hpp
View File

@ -34,7 +34,7 @@ public:
CInputGenerator(float leftDiv, float rightDiv) CInputGenerator(float leftDiv, float rightDiv)
: boo::DeviceFinder({dev_typeid(DolphinSmashAdapter)}), m_leftDiv(leftDiv), m_rightDiv(rightDiv) {} : boo::DeviceFinder({dev_typeid(DolphinSmashAdapter)}), m_leftDiv(leftDiv), m_rightDiv(rightDiv) {}
~CInputGenerator() { ~CInputGenerator() override {
if (smashAdapter) if (smashAdapter)
smashAdapter->setCallback(nullptr); smashAdapter->setCallback(nullptr);
} }
@ -81,17 +81,18 @@ public:
bool m_connected[4] = {}; bool m_connected[4] = {};
boo::DolphinControllerState m_states[4]; boo::DolphinControllerState m_states[4];
std::mutex m_stateLock; std::mutex m_stateLock;
void controllerConnected(unsigned idx, boo::EDolphinControllerType) { void controllerConnected(unsigned idx, boo::EDolphinControllerType) override {
/* Controller thread */ /* Controller thread */
m_statusChanges[idx].store(EStatusChange::Connected); m_statusChanges[idx].store(EStatusChange::Connected);
} }
void controllerDisconnected(unsigned idx) { void controllerDisconnected(unsigned idx) override {
/* Controller thread */ /* Controller thread */
std::unique_lock<std::mutex> lk(m_stateLock); std::unique_lock<std::mutex> lk(m_stateLock);
m_statusChanges[idx].store(EStatusChange::Disconnected); m_statusChanges[idx].store(EStatusChange::Disconnected);
m_states[idx].reset(); m_states[idx].reset();
} }
void controllerUpdate(unsigned idx, boo::EDolphinControllerType, const boo::DolphinControllerState& state) { void controllerUpdate(unsigned idx, boo::EDolphinControllerType,
const boo::DolphinControllerState& state) override {
/* Controller thread */ /* Controller thread */
std::unique_lock<std::mutex> lk(m_stateLock); std::unique_lock<std::mutex> lk(m_stateLock);
m_states[idx] = state; m_states[idx] = state;
@ -124,7 +125,7 @@ public:
* received. Device pointers should only be manipulated by this thread using * received. Device pointers should only be manipulated by this thread using
* the deviceConnected() and deviceDisconnected() callbacks. */ * the deviceConnected() and deviceDisconnected() callbacks. */
std::shared_ptr<boo::DolphinSmashAdapter> smashAdapter; std::shared_ptr<boo::DolphinSmashAdapter> smashAdapter;
void deviceConnected(boo::DeviceToken& tok) { void deviceConnected(boo::DeviceToken& tok) override {
/* Device listener thread */ /* Device listener thread */
if (!smashAdapter) { if (!smashAdapter) {
auto dev = tok.openAndGetDevice(); auto dev = tok.openAndGetDevice();
@ -134,7 +135,7 @@ public:
} }
} }
} }
void deviceDisconnected(boo::DeviceToken&, boo::DeviceBase* device) { void deviceDisconnected(boo::DeviceToken&, boo::DeviceBase* device) override {
if (smashAdapter.get() == device) if (smashAdapter.get() == device)
smashAdapter.reset(); smashAdapter.reset();
} }

16
Runtime/Particle/CColorElement.hpp
View File

@ -17,7 +17,7 @@ class CCEKeyframeEmitter : public CColorElement {
public: public:
CCEKeyframeEmitter(CInputStream& in); CCEKeyframeEmitter(CInputStream& in);
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEConstant : public CColorElement { class CCEConstant : public CColorElement {
@ -30,7 +30,7 @@ public:
CCEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c, CCEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c,
std::unique_ptr<CRealElement>&& d) std::unique_ptr<CRealElement>&& d)
: x4_r(std::move(a)), x8_g(std::move(b)), xc_b(std::move(c)), x10_a(std::move(d)) {} : x4_r(std::move(a)), x8_g(std::move(b)), xc_b(std::move(c)), x10_a(std::move(d)) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEFastConstant : public CColorElement { class CCEFastConstant : public CColorElement {
@ -38,7 +38,7 @@ class CCEFastConstant : public CColorElement {
public: public:
CCEFastConstant(float a, float b, float c, float d) : x4_val(a, b, c, d) {} CCEFastConstant(float a, float b, float c, float d) : x4_val(a, b, c, d) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCETimeChain : public CColorElement { class CCETimeChain : public CColorElement {
@ -49,7 +49,7 @@ class CCETimeChain : public CColorElement {
public: public:
CCETimeChain(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CIntElement>&& c) CCETimeChain(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CIntElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEFadeEnd : public CColorElement { class CCEFadeEnd : public CColorElement {
@ -62,7 +62,7 @@ public:
CCEFadeEnd(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CRealElement>&& c, CCEFadeEnd(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CRealElement>&& c,
std::unique_ptr<CRealElement>&& d) std::unique_ptr<CRealElement>&& d)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_startFrame(std::move(c)), x10_endFrame(std::move(d)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_startFrame(std::move(c)), x10_endFrame(std::move(d)) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEFade : public CColorElement { class CCEFade : public CColorElement {
@ -73,7 +73,7 @@ class CCEFade : public CColorElement {
public: public:
CCEFade(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CRealElement>&& c) CCEFade(std::unique_ptr<CColorElement>&& a, std::unique_ptr<CColorElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_endFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_endFrame(std::move(c)) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEPulse : public CColorElement { class CCEPulse : public CColorElement {
@ -86,11 +86,11 @@ public:
CCEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CColorElement>&& c, CCEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CColorElement>&& c,
std::unique_ptr<CColorElement>&& d) std::unique_ptr<CColorElement>&& d)
: x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {} : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
class CCEParticleColor : public CColorElement { class CCEParticleColor : public CColorElement {
public: public:
bool GetValue(int frame, zeus::CColor& colorOut) const; bool GetValue(int frame, zeus::CColor& colorOut) const override;
}; };
} // namespace urde } // namespace urde

56
Runtime/Particle/CElementGen.hpp
View File

@ -142,7 +142,7 @@ private:
public: public:
CElementGen(const TToken<CGenDescription>& gen, EModelOrientationType orientType = EModelOrientationType::Normal, CElementGen(const TToken<CGenDescription>& gen, EModelOrientationType orientType = EModelOrientationType::Normal,
EOptionalSystemFlags flags = EOptionalSystemFlags::One); EOptionalSystemFlags flags = EOptionalSystemFlags::One);
~CElementGen(); ~CElementGen() override;
boo::ObjToken<boo::IShaderDataBinding> m_normalDataBind[2]; boo::ObjToken<boo::IShaderDataBinding> m_normalDataBind[2];
boo::ObjToken<boo::IShaderDataBinding> m_normalSubDataBind[2]; boo::ObjToken<boo::IShaderDataBinding> m_normalSubDataBind[2];
@ -191,34 +191,34 @@ public:
void RenderParticles(); void RenderParticles();
void RenderParticlesIndirectTexture(); void RenderParticlesIndirectTexture();
bool Update(double); bool Update(double) override;
void Render(const CActorLights* = nullptr); void Render(const CActorLights* = nullptr) override;
void SetOrientation(const zeus::CTransform&); void SetOrientation(const zeus::CTransform&) override;
void SetTranslation(const zeus::CVector3f&); void SetTranslation(const zeus::CVector3f&) override;
void SetGlobalOrientation(const zeus::CTransform&); void SetGlobalOrientation(const zeus::CTransform&) override;
void SetGlobalTranslation(const zeus::CVector3f&); void SetGlobalTranslation(const zeus::CVector3f&) override;
void SetGlobalScale(const zeus::CVector3f&); void SetGlobalScale(const zeus::CVector3f&) override;
void SetLocalScale(const zeus::CVector3f&); void SetLocalScale(const zeus::CVector3f&) override;
void SetGlobalOrientAndTrans(const zeus::CTransform& xf); void SetGlobalOrientAndTrans(const zeus::CTransform& xf);
void SetParticleEmission(bool); void SetParticleEmission(bool) override;
void SetModulationColor(const zeus::CColor&); void SetModulationColor(const zeus::CColor&) override;
void SetGeneratorRate(float rate); void SetGeneratorRate(float rate) override;
const zeus::CTransform& GetOrientation() const; const zeus::CTransform& GetOrientation() const override;
const zeus::CVector3f& GetTranslation() const; const zeus::CVector3f& GetTranslation() const override;
const zeus::CTransform& GetGlobalOrientation() const; const zeus::CTransform& GetGlobalOrientation() const override;
const zeus::CVector3f& GetGlobalTranslation() const; const zeus::CVector3f& GetGlobalTranslation() const override;
const zeus::CVector3f& GetGlobalScale() const; const zeus::CVector3f& GetGlobalScale() const override;
const zeus::CColor& GetModulationColor() const; const zeus::CColor& GetModulationColor() const override;
float GetGeneratorRate() const { return x98_generatorRate; } float GetGeneratorRate() const override { return x98_generatorRate; }
bool IsSystemDeletable() const; bool IsSystemDeletable() const override;
std::optional<zeus::CAABox> GetBounds() const; std::optional<zeus::CAABox> GetBounds() const override;
u32 GetParticleCount() const; u32 GetParticleCount() const override;
bool SystemHasLight() const; bool SystemHasLight() const override;
CLight GetLight() const; CLight GetLight() const override;
bool GetParticleEmission() const; bool GetParticleEmission() const override;
void DestroyParticles(); void DestroyParticles() override;
void Reset(); void Reset() override;
FourCC Get4CharId() const { return FOURCC('PART'); } FourCC Get4CharId() const override { return FOURCC('PART'); }
size_t GetNumActiveChildParticles() const { return x290_activePartChildren.size(); } size_t GetNumActiveChildParticles() const { return x290_activePartChildren.size(); }
CParticleGen& GetActiveChildParticle(size_t idx) const { return *x290_activePartChildren[idx]; } CParticleGen& GetActiveChildParticle(size_t idx) const { return *x290_activePartChildren[idx]; }
bool IsIndirectTextured() const { return x28_loadedGenDesc->x54_x40_TEXR && x28_loadedGenDesc->x58_x44_TIND; } bool IsIndirectTextured() const { return x28_loadedGenDesc->x54_x40_TEXR && x28_loadedGenDesc->x58_x44_TIND; }

6
Runtime/Particle/CEmitterElement.hpp
View File

@ -13,7 +13,7 @@ class CEESimpleEmitter : public CEmitterElement {
public: public:
CEESimpleEmitter(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b) CEESimpleEmitter(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
: x4_loc(std::move(a)), x8_vec(std::move(b)) {} : x4_loc(std::move(a)), x8_vec(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const; bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
}; };
class CVESphere : public CEmitterElement { class CVESphere : public CEmitterElement {
@ -24,7 +24,7 @@ class CVESphere : public CEmitterElement {
public: public:
CVESphere(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c) CVESphere(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_sphereOrigin(std::move(a)), x8_sphereRadius(std::move(b)), xc_velocityMag(std::move(c)) {} : x4_sphereOrigin(std::move(a)), x8_sphereRadius(std::move(b)), xc_velocityMag(std::move(c)) {}
bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const; bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
}; };
class CVEAngleSphere : public CEmitterElement { class CVEAngleSphere : public CEmitterElement {
@ -48,7 +48,7 @@ public:
, x14_angleYBias(std::move(e)) , x14_angleYBias(std::move(e))
, x18_angleXRange(std::move(f)) , x18_angleXRange(std::move(f))
, x1c_angleYRange(std::move(g)) {} , x1c_angleYRange(std::move(g)) {}
bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const; bool GetValue(int frame, zeus::CVector3f& pPos, zeus::CVector3f& pVel) const override;
}; };
} // namespace urde } // namespace urde

10
Runtime/Particle/CFlameWarp.hpp
View File

@ -37,12 +37,12 @@ public:
const zeus::CVector3f& GetFloatingPoint() const { return x80_floatingPoint; } const zeus::CVector3f& GetFloatingPoint() const { return x80_floatingPoint; }
void SetMaxDistSq(float d) { x8c_maxDistSq = d; } void SetMaxDistSq(float d) { x8c_maxDistSq = d; }
void SetStateManager(CStateManager& mgr) { x9c_stateMgr = &mgr; } void SetStateManager(CStateManager& mgr) { x9c_stateMgr = &mgr; }
bool UpdateWarp() { return xa0_24_activated; } bool UpdateWarp() override { return xa0_24_activated; }
void ModifyParticles(std::vector<CParticle>& particles); void ModifyParticles(std::vector<CParticle>& particles) override;
void Activate(bool val) { xa0_24_activated = val; } void Activate(bool val) override { xa0_24_activated = val; }
bool IsActivated() { return xa0_24_activated; } bool IsActivated() override { return xa0_24_activated; }
bool IsProcessed() const { return xa0_26_processed; } bool IsProcessed() const { return xa0_26_processed; }
FourCC Get4CharID() { return FOURCC('FWRP'); } FourCC Get4CharID() override { return FOURCC('FWRP'); }
void ResetPosition(const zeus::CVector3f& pos) { void ResetPosition(const zeus::CVector3f& pos) {
for (auto& vec : x4_collisionPoints) { for (auto& vec : x4_collisionPoints) {
vec = pos; vec = pos;

76
Runtime/Particle/CIntElement.hpp
View File

@ -17,8 +17,8 @@ class CIEKeyframeEmitter : public CIntElement {
public: public:
CIEKeyframeEmitter(CInputStream& in); CIEKeyframeEmitter(CInputStream& in);
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEDeath : public CIntElement { class CIEDeath : public CIntElement {
@ -28,8 +28,8 @@ class CIEDeath : public CIntElement {
public: public:
CIEDeath(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIEDeath(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEClamp : public CIntElement { class CIEClamp : public CIntElement {
@ -40,8 +40,8 @@ class CIEClamp : public CIntElement {
public: public:
CIEClamp(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c) CIEClamp(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c)
: x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {} : x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIETimeChain : public CIntElement { class CIETimeChain : public CIntElement {
@ -52,8 +52,8 @@ class CIETimeChain : public CIntElement {
public: public:
CIETimeChain(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c) CIETimeChain(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEAdd : public CIntElement { class CIEAdd : public CIntElement {
@ -62,8 +62,8 @@ class CIEAdd : public CIntElement {
public: public:
CIEAdd(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) : x4_a(std::move(a)), x8_b(std::move(b)) {} CIEAdd(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEConstant : public CIntElement { class CIEConstant : public CIntElement {
@ -71,8 +71,8 @@ class CIEConstant : public CIntElement {
public: public:
CIEConstant(int val) : x4_val(val) {} CIEConstant(int val) : x4_val(val) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEImpulse : public CIntElement { class CIEImpulse : public CIntElement {
@ -80,8 +80,8 @@ class CIEImpulse : public CIntElement {
public: public:
CIEImpulse(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {} CIEImpulse(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIELifetimePercent : public CIntElement { class CIELifetimePercent : public CIntElement {
@ -89,8 +89,8 @@ class CIELifetimePercent : public CIntElement {
public: public:
CIELifetimePercent(std::unique_ptr<CIntElement>&& a) : x4_percentVal(std::move(a)) {} CIELifetimePercent(std::unique_ptr<CIntElement>&& a) : x4_percentVal(std::move(a)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEInitialRandom : public CIntElement { class CIEInitialRandom : public CIntElement {
@ -100,8 +100,8 @@ class CIEInitialRandom : public CIntElement {
public: public:
CIEInitialRandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIEInitialRandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEPulse : public CIntElement { class CIEPulse : public CIntElement {
@ -114,8 +114,8 @@ public:
CIEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c, CIEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c,
std::unique_ptr<CIntElement>&& d) std::unique_ptr<CIntElement>&& d)
: x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {} : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEMultiply : public CIntElement { class CIEMultiply : public CIntElement {
@ -125,8 +125,8 @@ class CIEMultiply : public CIntElement {
public: public:
CIEMultiply(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIEMultiply(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIESampleAndHold : public CIntElement { class CIESampleAndHold : public CIntElement {
@ -139,8 +139,8 @@ class CIESampleAndHold : public CIntElement {
public: public:
CIESampleAndHold(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c) CIESampleAndHold(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CIntElement>&& c)
: x4_sampleSource(std::move(a)), xc_waitFramesMin(std::move(b)), x10_waitFramesMax(std::move(c)) {} : x4_sampleSource(std::move(a)), xc_waitFramesMin(std::move(b)), x10_waitFramesMax(std::move(c)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIERandom : public CIntElement { class CIERandom : public CIntElement {
@ -150,8 +150,8 @@ class CIERandom : public CIntElement {
public: public:
CIERandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIERandom(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_min(std::move(a)), x8_max(std::move(b)) {} : x4_min(std::move(a)), x8_max(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIETimeScale : public CIntElement { class CIETimeScale : public CIntElement {
@ -159,26 +159,26 @@ class CIETimeScale : public CIntElement {
public: public:
CIETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {} CIETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEGetCumulativeParticleCount : public CIntElement { class CIEGetCumulativeParticleCount : public CIntElement {
public: public:
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEGetActiveParticleCount : public CIntElement { class CIEGetActiveParticleCount : public CIntElement {
public: public:
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEGetEmitterTime : public CIntElement { class CIEGetEmitterTime : public CIntElement {
public: public:
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIEModulo : public CIntElement { class CIEModulo : public CIntElement {
@ -188,8 +188,8 @@ class CIEModulo : public CIntElement {
public: public:
CIEModulo(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIEModulo(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
class CIESubtract : public CIntElement { class CIESubtract : public CIntElement {
@ -199,8 +199,8 @@ class CIESubtract : public CIntElement {
public: public:
CIESubtract(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b) CIESubtract(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, int& valOut) const; bool GetValue(int frame, int& valOut) const override;
int GetMaxValue() const; int GetMaxValue() const override;
}; };
} // namespace urde } // namespace urde

26
Runtime/Particle/CModVectorElement.hpp
View File

@ -21,7 +21,7 @@ public:
, xc_maxMag(std::move(c)) , xc_maxMag(std::move(c))
, x10_minMag(std::move(d)) , x10_minMag(std::move(d))
, x14_enableMinMag(std::move(e)) {} , x14_enableMinMag(std::move(e)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEExponentialImplosion : public CModVectorElement { class CMVEExponentialImplosion : public CModVectorElement {
@ -39,7 +39,7 @@ public:
, xc_maxMag(std::move(c)) , xc_maxMag(std::move(c))
, x10_minMag(std::move(d)) , x10_minMag(std::move(d))
, x14_enableMinMag(std::move(e)) {} , x14_enableMinMag(std::move(e)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVELinearImplosion : public CModVectorElement { class CMVELinearImplosion : public CModVectorElement {
@ -57,7 +57,7 @@ public:
, xc_maxMag(std::move(c)) , xc_maxMag(std::move(c))
, x10_minMag(std::move(d)) , x10_minMag(std::move(d))
, x14_enableMinMag(std::move(e)) {} , x14_enableMinMag(std::move(e)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVETimeChain : public CModVectorElement { class CMVETimeChain : public CModVectorElement {
@ -69,7 +69,7 @@ public:
CMVETimeChain(std::unique_ptr<CModVectorElement>&& a, std::unique_ptr<CModVectorElement>&& b, CMVETimeChain(std::unique_ptr<CModVectorElement>&& a, std::unique_ptr<CModVectorElement>&& b,
std::unique_ptr<CIntElement>&& c) std::unique_ptr<CIntElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEBounce : public CModVectorElement { class CMVEBounce : public CModVectorElement {
@ -85,7 +85,7 @@ class CMVEBounce : public CModVectorElement {
public: public:
CMVEBounce(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b, CMVEBounce(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e); std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d, bool e);
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEConstant : public CModVectorElement { class CMVEConstant : public CModVectorElement {
@ -96,7 +96,7 @@ class CMVEConstant : public CModVectorElement {
public: public:
CMVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c) CMVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_x(std::move(a)), x8_y(std::move(b)), xc_z(std::move(c)) {} : x4_x(std::move(a)), x8_y(std::move(b)), xc_z(std::move(c)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEFastConstant : public CModVectorElement { class CMVEFastConstant : public CModVectorElement {
@ -104,7 +104,7 @@ class CMVEFastConstant : public CModVectorElement {
public: public:
CMVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {} CMVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEGravity : public CModVectorElement { class CMVEGravity : public CModVectorElement {
@ -112,7 +112,7 @@ class CMVEGravity : public CModVectorElement {
public: public:
CMVEGravity(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CMVEGravity(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEExplode : public CModVectorElement { class CMVEExplode : public CModVectorElement {
@ -122,7 +122,7 @@ class CMVEExplode : public CModVectorElement {
public: public:
CMVEExplode(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CMVEExplode(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVESetPosition : public CModVectorElement { class CMVESetPosition : public CModVectorElement {
@ -130,7 +130,7 @@ class CMVESetPosition : public CModVectorElement {
public: public:
CMVESetPosition(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CMVESetPosition(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEPulse : public CModVectorElement { class CMVEPulse : public CModVectorElement {
@ -143,7 +143,7 @@ public:
CMVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CModVectorElement>&& c, CMVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CModVectorElement>&& c,
std::unique_ptr<CModVectorElement>&& d) std::unique_ptr<CModVectorElement>&& d)
: x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {} : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVEWind : public CModVectorElement { class CMVEWind : public CModVectorElement {
@ -153,7 +153,7 @@ class CMVEWind : public CModVectorElement {
public: public:
CMVEWind(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b) CMVEWind(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_velocity(std::move(a)), x8_factor(std::move(b)) {} : x4_velocity(std::move(a)), x8_factor(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
class CMVESwirl : public CModVectorElement { class CMVESwirl : public CModVectorElement {
@ -169,7 +169,7 @@ public:
, x8_curveBinormal(std::move(b)) , x8_curveBinormal(std::move(b))
, xc_filterGain(std::move(c)) , xc_filterGain(std::move(c))
, x10_tangentialVelocity(std::move(d)) {} , x10_tangentialVelocity(std::move(d)) {}
bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const; bool GetValue(int frame, zeus::CVector3f& pVel, zeus::CVector3f& pPos) const override;
}; };
} // namespace urde } // namespace urde

50
Runtime/Particle/CParticleElectric.hpp
View File

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

52
Runtime/Particle/CParticleSwoosh.hpp
View File

@ -129,35 +129,35 @@ class CParticleSwoosh : public CParticleGen {
public: public:
CParticleSwoosh(const TToken<CSwooshDescription>& desc, int); CParticleSwoosh(const TToken<CSwooshDescription>& desc, int);
~CParticleSwoosh(); ~CParticleSwoosh() override;
CSwooshDescription* GetDesc() { return x1c_desc.GetObj(); } CSwooshDescription* GetDesc() { return x1c_desc.GetObj(); }
bool Update(double); bool Update(double) override;
void Render(const CActorLights* = nullptr); void Render(const CActorLights* = nullptr) override;
void SetOrientation(const zeus::CTransform&); void SetOrientation(const zeus::CTransform&) override;
void SetTranslation(const zeus::CVector3f&); void SetTranslation(const zeus::CVector3f&) override;
void SetGlobalOrientation(const zeus::CTransform&); void SetGlobalOrientation(const zeus::CTransform&) override;
void SetGlobalTranslation(const zeus::CVector3f&); void SetGlobalTranslation(const zeus::CVector3f&) override;
void SetGlobalScale(const zeus::CVector3f&); void SetGlobalScale(const zeus::CVector3f&) override;
void SetLocalScale(const zeus::CVector3f&); void SetLocalScale(const zeus::CVector3f&) override;
void SetParticleEmission(bool); void SetParticleEmission(bool) override;
void SetModulationColor(const zeus::CColor&); void SetModulationColor(const zeus::CColor&) override;
const zeus::CTransform& GetOrientation() const; const zeus::CTransform& GetOrientation() const override;
const zeus::CVector3f& GetTranslation() const; const zeus::CVector3f& GetTranslation() const override;
const zeus::CTransform& GetGlobalOrientation() const; const zeus::CTransform& GetGlobalOrientation() const override;
const zeus::CVector3f& GetGlobalTranslation() const; const zeus::CVector3f& GetGlobalTranslation() const override;
const zeus::CVector3f& GetGlobalScale() const; const zeus::CVector3f& GetGlobalScale() const override;
const zeus::CColor& GetModulationColor() const; const zeus::CColor& GetModulationColor() const override;
bool IsSystemDeletable() const; bool IsSystemDeletable() const override;
std::optional<zeus::CAABox> GetBounds() const; std::optional<zeus::CAABox> GetBounds() const override;
u32 GetParticleCount() const; u32 GetParticleCount() const override;
bool SystemHasLight() const; bool SystemHasLight() const override;
CLight GetLight() const; CLight GetLight() const override;
bool GetParticleEmission() const; bool GetParticleEmission() const override;
void DestroyParticles(); void DestroyParticles() override;
void Reset() {} void Reset() override {}
FourCC Get4CharId() const { return FOURCC('SWHC'); } FourCC Get4CharId() const override { return FOURCC('SWHC'); }
void SetRenderGaps(bool r) { x1d0_27_renderGaps = r; } void SetRenderGaps(bool r) { x1d0_27_renderGaps = r; }
void DoWarmupUpdate() { void DoWarmupUpdate() {

82
Runtime/Particle/CRealElement.hpp
View File

@ -17,7 +17,7 @@ class CREKeyframeEmitter : public CRealElement {
public: public:
CREKeyframeEmitter(CInputStream& in); CREKeyframeEmitter(CInputStream& in);
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRELifetimeTween : public CRealElement { class CRELifetimeTween : public CRealElement {
@ -27,7 +27,7 @@ class CRELifetimeTween : public CRealElement {
public: public:
CRELifetimeTween(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CRELifetimeTween(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREConstant : public CRealElement { class CREConstant : public CRealElement {
@ -35,8 +35,8 @@ class CREConstant : public CRealElement {
public: public:
CREConstant(float val) : x4_val(val) {} CREConstant(float val) : x4_val(val) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
bool IsConstant() const { return true; } bool IsConstant() const override { return true; }
}; };
class CRETimeChain : public CRealElement { class CRETimeChain : public CRealElement {
@ -47,7 +47,7 @@ class CRETimeChain : public CRealElement {
public: public:
CRETimeChain(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CIntElement>&& c) CRETimeChain(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CIntElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREAdd : public CRealElement { class CREAdd : public CRealElement {
@ -57,7 +57,7 @@ class CREAdd : public CRealElement {
public: public:
CREAdd(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CREAdd(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREClamp : public CRealElement { class CREClamp : public CRealElement {
@ -68,7 +68,7 @@ class CREClamp : public CRealElement {
public: public:
CREClamp(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c) CREClamp(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {} : x4_min(std::move(a)), x8_max(std::move(b)), xc_val(std::move(c)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREInitialRandom : public CRealElement { class CREInitialRandom : public CRealElement {
@ -78,8 +78,8 @@ class CREInitialRandom : public CRealElement {
public: public:
CREInitialRandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CREInitialRandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_min(std::move(a)), x8_max(std::move(b)) {} : x4_min(std::move(a)), x8_max(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
bool IsConstant() const { return true; } bool IsConstant() const override { return true; }
}; };
class CRERandom : public CRealElement { class CRERandom : public CRealElement {
@ -89,7 +89,7 @@ class CRERandom : public CRealElement {
public: public:
CRERandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CRERandom(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_min(std::move(a)), x8_max(std::move(b)) {} : x4_min(std::move(a)), x8_max(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREDotProduct : public CRealElement { class CREDotProduct : public CRealElement {
@ -99,7 +99,7 @@ class CREDotProduct : public CRealElement {
public: public:
CREDotProduct(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b) CREDotProduct(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREMultiply : public CRealElement { class CREMultiply : public CRealElement {
@ -109,7 +109,7 @@ class CREMultiply : public CRealElement {
public: public:
CREMultiply(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CREMultiply(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREPulse : public CRealElement { class CREPulse : public CRealElement {
@ -122,7 +122,7 @@ public:
CREPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CRealElement>&& c, CREPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CRealElement>&& c,
std::unique_ptr<CRealElement>&& d) std::unique_ptr<CRealElement>&& d)
: x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_valA(std::move(c)), x10_valB(std::move(d)) {} : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_valA(std::move(c)), x10_valB(std::move(d)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRETimeScale : public CRealElement { class CRETimeScale : public CRealElement {
@ -130,7 +130,7 @@ class CRETimeScale : public CRealElement {
public: public:
CRETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {} CRETimeScale(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRELifetimePercent : public CRealElement { class CRELifetimePercent : public CRealElement {
@ -138,7 +138,7 @@ class CRELifetimePercent : public CRealElement {
public: public:
CRELifetimePercent(std::unique_ptr<CRealElement>&& a) : x4_percentVal(std::move(a)) {} CRELifetimePercent(std::unique_ptr<CRealElement>&& a) : x4_percentVal(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRESineWave : public CRealElement { class CRESineWave : public CRealElement {
@ -149,7 +149,7 @@ class CRESineWave : public CRealElement {
public: public:
CRESineWave(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c) CRESineWave(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_frequency(std::move(a)), x8_amplitude(std::move(b)), xc_phase(std::move(c)) {} : x4_frequency(std::move(a)), x8_amplitude(std::move(b)), xc_phase(std::move(c)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREInitialSwitch : public CRealElement { class CREInitialSwitch : public CRealElement {
@ -159,7 +159,7 @@ class CREInitialSwitch : public CRealElement {
public: public:
CREInitialSwitch(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CREInitialSwitch(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRECompareLessThan : public CRealElement { class CRECompareLessThan : public CRealElement {
@ -172,7 +172,7 @@ public:
CRECompareLessThan(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, CRECompareLessThan(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d) std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRECompareEquals : public CRealElement { class CRECompareEquals : public CRealElement {
@ -185,57 +185,57 @@ public:
CRECompareEquals(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, CRECompareEquals(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b,
std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d) std::unique_ptr<CRealElement>&& c, std::unique_ptr<CRealElement>&& d)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)), x10_d(std::move(d)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam1 : public CRealElement { class CREParticleAccessParam1 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam2 : public CRealElement { class CREParticleAccessParam2 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam3 : public CRealElement { class CREParticleAccessParam3 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam4 : public CRealElement { class CREParticleAccessParam4 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam5 : public CRealElement { class CREParticleAccessParam5 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam6 : public CRealElement { class CREParticleAccessParam6 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam7 : public CRealElement { class CREParticleAccessParam7 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleAccessParam8 : public CRealElement { class CREParticleAccessParam8 : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleSizeOrLineLength : public CRealElement { class CREParticleSizeOrLineLength : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREParticleRotationOrLineWidth : public CRealElement { class CREParticleRotationOrLineWidth : public CRealElement {
public: public:
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRESubtract : public CRealElement { class CRESubtract : public CRealElement {
@ -245,7 +245,7 @@ class CRESubtract : public CRealElement {
public: public:
CRESubtract(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b) CRESubtract(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREVectorMagnitude : public CRealElement { class CREVectorMagnitude : public CRealElement {
@ -253,7 +253,7 @@ class CREVectorMagnitude : public CRealElement {
public: public:
CREVectorMagnitude(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CREVectorMagnitude(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREVectorXToReal : public CRealElement { class CREVectorXToReal : public CRealElement {
@ -261,7 +261,7 @@ class CREVectorXToReal : public CRealElement {
public: public:
CREVectorXToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CREVectorXToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREVectorYToReal : public CRealElement { class CREVectorYToReal : public CRealElement {
@ -269,7 +269,7 @@ class CREVectorYToReal : public CRealElement {
public: public:
CREVectorYToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CREVectorYToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREVectorZToReal : public CRealElement { class CREVectorZToReal : public CRealElement {
@ -277,7 +277,7 @@ class CREVectorZToReal : public CRealElement {
public: public:
CREVectorZToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {} CREVectorZToReal(std::unique_ptr<CVectorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CRECEXT : public CRealElement { class CRECEXT : public CRealElement {
@ -285,7 +285,7 @@ class CRECEXT : public CRealElement {
public: public:
CRECEXT(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {} CRECEXT(std::unique_ptr<CIntElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREIntTimesReal : public CRealElement { class CREIntTimesReal : public CRealElement {
@ -295,7 +295,7 @@ class CREIntTimesReal : public CRealElement {
public: public:
CREIntTimesReal(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CRealElement>&& b) CREIntTimesReal(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CRealElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREConstantRange : public CRealElement { class CREConstantRange : public CRealElement {
@ -315,7 +315,7 @@ public:
, x10_inRange(std::move(d)) , x10_inRange(std::move(d))
, x14_outOfRange(std::move(e)) {} , x14_outOfRange(std::move(e)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREGetComponentRed : public CRealElement { class CREGetComponentRed : public CRealElement {
@ -324,7 +324,7 @@ class CREGetComponentRed : public CRealElement {
public: public:
CREGetComponentRed(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {} CREGetComponentRed(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREGetComponentGreen : public CRealElement { class CREGetComponentGreen : public CRealElement {
@ -333,7 +333,7 @@ class CREGetComponentGreen : public CRealElement {
public: public:
CREGetComponentGreen(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {} CREGetComponentGreen(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREGetComponentBlue : public CRealElement { class CREGetComponentBlue : public CRealElement {
@ -342,7 +342,7 @@ class CREGetComponentBlue : public CRealElement {
public: public:
CREGetComponentBlue(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {} CREGetComponentBlue(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
class CREGetComponentAlpha : public CRealElement { class CREGetComponentAlpha : public CRealElement {
@ -351,6 +351,6 @@ class CREGetComponentAlpha : public CRealElement {
public: public:
CREGetComponentAlpha(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {} CREGetComponentAlpha(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, float& valOut) const; bool GetValue(int frame, float& valOut) const override;
}; };
} // namespace urde } // namespace urde

16
Runtime/Particle/CUVElement.hpp
View File

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

44
Runtime/Particle/CVectorElement.hpp
View File

@ -17,7 +17,7 @@ class CVEKeyframeEmitter : public CVectorElement {
public: public:
CVEKeyframeEmitter(CInputStream& in); CVEKeyframeEmitter(CInputStream& in);
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVECone : public CVectorElement { class CVECone : public CVectorElement {
@ -28,7 +28,7 @@ class CVECone : public CVectorElement {
public: public:
CVECone(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b); CVECone(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CRealElement>&& b);
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVETimeChain : public CVectorElement { class CVETimeChain : public CVectorElement {
@ -40,7 +40,7 @@ public:
CVETimeChain(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b, CVETimeChain(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
std::unique_ptr<CIntElement>&& c) std::unique_ptr<CIntElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_swFrame(std::move(c)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEAngleCone : public CVectorElement { class CVEAngleCone : public CVectorElement {
@ -58,7 +58,7 @@ public:
, xc_angleXRange(std::move(c)) , xc_angleXRange(std::move(c))
, x10_angleYRange(std::move(d)) , x10_angleYRange(std::move(d))
, x14_magnitude(std::move(e)) {} , x14_magnitude(std::move(e)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEAdd : public CVectorElement { class CVEAdd : public CVectorElement {
@ -68,7 +68,7 @@ class CVEAdd : public CVectorElement {
public: public:
CVEAdd(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b) CVEAdd(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVECircleCluster : public CVectorElement { class CVECircleCluster : public CVectorElement {
@ -81,7 +81,7 @@ class CVECircleCluster : public CVectorElement {
public: public:
CVECircleCluster(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b, CVECircleCluster(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b,
std::unique_ptr<CIntElement>&& c, std::unique_ptr<CRealElement>&& d); std::unique_ptr<CIntElement>&& c, std::unique_ptr<CRealElement>&& d);
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEConstant : public CVectorElement { class CVEConstant : public CVectorElement {
@ -92,7 +92,7 @@ class CVEConstant : public CVectorElement {
public: public:
CVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c) CVEConstant(std::unique_ptr<CRealElement>&& a, std::unique_ptr<CRealElement>&& b, std::unique_ptr<CRealElement>&& c)
: x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)) {} : x4_a(std::move(a)), x8_b(std::move(b)), xc_c(std::move(c)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEFastConstant : public CVectorElement { class CVEFastConstant : public CVectorElement {
@ -100,8 +100,8 @@ class CVEFastConstant : public CVectorElement {
public: public:
CVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {} CVEFastConstant(float a, float b, float c) : x4_val(a, b, c) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
bool IsFastConstant() const { return true; } bool IsFastConstant() const override { return true; }
}; };
class CVECircle : public CVectorElement { class CVECircle : public CVectorElement {
@ -115,7 +115,7 @@ class CVECircle : public CVectorElement {
public: public:
CVECircle(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b, std::unique_ptr<CRealElement>&& c, CVECircle(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b, std::unique_ptr<CRealElement>&& c,
std::unique_ptr<CRealElement>&& d, std::unique_ptr<CRealElement>&& e); std::unique_ptr<CRealElement>&& d, std::unique_ptr<CRealElement>&& e);
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEMultiply : public CVectorElement { class CVEMultiply : public CVectorElement {
@ -125,7 +125,7 @@ class CVEMultiply : public CVectorElement {
public: public:
CVEMultiply(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b) CVEMultiply(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVERealToVector : public CVectorElement { class CVERealToVector : public CVectorElement {
@ -133,7 +133,7 @@ class CVERealToVector : public CVectorElement {
public: public:
CVERealToVector(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {} CVERealToVector(std::unique_ptr<CRealElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEPulse : public CVectorElement { class CVEPulse : public CVectorElement {
@ -146,42 +146,42 @@ public:
CVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CVectorElement>&& c, CVEPulse(std::unique_ptr<CIntElement>&& a, std::unique_ptr<CIntElement>&& b, std::unique_ptr<CVectorElement>&& c,
std::unique_ptr<CVectorElement>&& d) std::unique_ptr<CVectorElement>&& d)
: x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {} : x4_aDuration(std::move(a)), x8_bDuration(std::move(b)), xc_aVal(std::move(c)), x10_bVal(std::move(d)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleVelocity : public CVectorElement { class CVEParticleVelocity : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleColor : public CVectorElement { class CVEParticleColor : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleLocation : public CVectorElement { class CVEParticleLocation : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleSystemOrientationFront : public CVectorElement { class CVEParticleSystemOrientationFront : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleSystemOrientationUp : public CVectorElement { class CVEParticleSystemOrientationUp : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleSystemOrientationRight : public CVectorElement { class CVEParticleSystemOrientationRight : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEParticleSystemTranslation : public CVectorElement { class CVEParticleSystemTranslation : public CVectorElement {
public: public:
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVESubtract : public CVectorElement { class CVESubtract : public CVectorElement {
@ -191,7 +191,7 @@ class CVESubtract : public CVectorElement {
public: public:
CVESubtract(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b) CVESubtract(std::unique_ptr<CVectorElement>&& a, std::unique_ptr<CVectorElement>&& b)
: x4_a(std::move(a)), x8_b(std::move(b)) {} : x4_a(std::move(a)), x8_b(std::move(b)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
class CVEColorToVector : public CVectorElement { class CVEColorToVector : public CVectorElement {
@ -200,7 +200,7 @@ class CVEColorToVector : public CVectorElement {
public: public:
CVEColorToVector(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {} CVEColorToVector(std::unique_ptr<CColorElement>&& a) : x4_a(std::move(a)) {}
bool GetValue(int frame, zeus::CVector3f& valOut) const; bool GetValue(int frame, zeus::CVector3f& valOut) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Weapon/CBeamProjectile.hpp
View File

@ -39,7 +39,7 @@ public:
EMaterialTypes matType, const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner, EMaterialTypes matType, const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner,
EProjectileAttrib attribs, bool growingBeam); EProjectileAttrib attribs, bool growingBeam);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
float GetMaxRadius() const { return x2f4_beamRadius; } float GetMaxRadius() const { return x2f4_beamRadius; }
const zeus::CVector3f& GetSurfaceNormal() const { return x30c_collisionNormal; } const zeus::CVector3f& GetSurfaceNormal() const { return x30c_collisionNormal; }
EDamageType GetDamageType() const { return x2f8_damageType; } EDamageType GetDamageType() const { return x2f8_damageType; }
@ -54,8 +54,8 @@ public:
s32 GetIntMaxLength() const { return x2e8_intMaxLength; } s32 GetIntMaxLength() const { return x2e8_intMaxLength; }
TUniqueId GetCollisionActorId() const { return x2fe_collisionActorId; } TUniqueId GetCollisionActorId() const { return x2fe_collisionActorId; }
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void CalculateRenderBounds(); void CalculateRenderBounds() override;
virtual void ResetBeam(CStateManager&, bool); virtual void ResetBeam(CStateManager&, bool);
virtual void UpdateFx(const zeus::CTransform&, float, CStateManager&); virtual void UpdateFx(const zeus::CTransform&, float, CStateManager&);
virtual void Fire(const zeus::CTransform&, CStateManager&, bool) = 0; virtual void Fire(const zeus::CTransform&, CStateManager&, bool) = 0;

14
Runtime/Weapon/CBomb.hpp
View File

@ -24,15 +24,15 @@ public:
CBomb(const TCachedToken<CGenDescription>& particle1, const TCachedToken<CGenDescription>& particle2, TUniqueId uid, CBomb(const TCachedToken<CGenDescription>& particle1, const TCachedToken<CGenDescription>& particle2, TUniqueId uid,
TAreaId aid, TUniqueId playerId, float f1, const zeus::CTransform& xf, const CDamageInfo& dInfo); TAreaId aid, TUniqueId playerId, float f1, const zeus::CTransform& xf, const CDamageInfo& dInfo);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void Explode(const zeus::CVector3f&, CStateManager&); void Explode(const zeus::CVector3f&, CStateManager&);
void UpdateLight(float, CStateManager&); void UpdateLight(float, CStateManager&);
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void SetVelocityWR(const zeus::CVector3f& vel) { x158_velocity = vel; } void SetVelocityWR(const zeus::CVector3f& vel) { x158_velocity = vel; }
void SetConstantAccelerationWR(const zeus::CVector3f& acc) { x164_acceleration = acc; } void SetConstantAccelerationWR(const zeus::CVector3f& acc) { x164_acceleration = acc; }
void SetFuseDisabled(bool b) { x190_26_disableFuse = false; } void SetFuseDisabled(bool b) { x190_26_disableFuse = false; }

14
Runtime/Weapon/CElectricBeamProjectile.hpp
View File

@ -27,12 +27,12 @@ public:
const zeus::CTransform&, EMaterialTypes, const CDamageInfo&, TUniqueId, TAreaId, TUniqueId, const zeus::CTransform&, EMaterialTypes, const CDamageInfo&, TUniqueId, TAreaId, TUniqueId,
EProjectileAttrib); EProjectileAttrib);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void PreRender(CStateManager&, const zeus::CFrustum&); void PreRender(CStateManager&, const zeus::CFrustum&) override;
void Touch(CActor&, CStateManager&){}; void Touch(CActor&, CStateManager&) override {}
void UpdateFx(const zeus::CTransform&, float, CStateManager&); void UpdateFx(const zeus::CTransform&, float, CStateManager&) override;
void ResetBeam(CStateManager&, bool); void ResetBeam(CStateManager&, bool) override;
void Fire(const zeus::CTransform&, CStateManager&, bool); void Fire(const zeus::CTransform&, CStateManager&, bool) override;
}; };
} // namespace urde } // namespace urde

8
Runtime/Weapon/CFlameThrower.hpp
View File

@ -51,10 +51,10 @@ public:
const CDamageInfo& dInfo, TUniqueId uid, TAreaId aId, TUniqueId owner, EProjectileAttrib attribs, const CDamageInfo& dInfo, TUniqueId uid, TAreaId aId, TUniqueId owner, EProjectileAttrib attribs,
CAssetId playerSteamTxtr, s16 playerHitSfx, CAssetId playerIceTxtr); CAssetId playerSteamTxtr, s16 playerHitSfx, CAssetId playerIceTxtr);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void SetTransform(const zeus::CTransform& xf, float); void SetTransform(const zeus::CTransform& xf, float);
void Reset(CStateManager&, bool); void Reset(CStateManager&, bool);
void Fire(const zeus::CTransform&, CStateManager&, bool); void Fire(const zeus::CTransform&, CStateManager&, bool);

6
Runtime/Weapon/CGameProjectile.hpp
View File

@ -61,9 +61,9 @@ public:
const std::optional<TLockedToken<CGenDescription>>& visorParticle, u16 visorSfx, const std::optional<TLockedToken<CGenDescription>>& visorParticle, u16 visorSfx,
bool sendCollideMsg); bool sendCollideMsg);
virtual void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
virtual void ResolveCollisionWithActor(const CRayCastResult& res, CActor& act, CStateManager& mgr); virtual void ResolveCollisionWithActor(const CRayCastResult& res, CActor& act, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
static EProjectileAttrib GetBeamAttribType(EWeaponType wType); static EProjectileAttrib GetBeamAttribType(EWeaponType wType);
void DeleteProjectileLight(CStateManager&); void DeleteProjectileLight(CStateManager&);
void CreateProjectileLight(std::string_view, const CLight&, CStateManager&); void CreateProjectileLight(std::string_view, const CLight&, CStateManager&);
@ -81,7 +81,7 @@ public:
CProjectileTouchResult CanCollideWithGameObject(CActor& act, CStateManager& mgr) const; CProjectileTouchResult CanCollideWithGameObject(CActor& act, CStateManager& mgr) const;
CProjectileTouchResult CanCollideWithTrigger(CActor& act, CStateManager& mgr) const; CProjectileTouchResult CanCollideWithTrigger(CActor& act, CStateManager& mgr) const;
zeus::CAABox GetProjectileBounds() const; zeus::CAABox GetProjectileBounds() const;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
CProjectileWeapon& ProjectileWeapon() { return x170_projectile; } CProjectileWeapon& ProjectileWeapon() { return x170_projectile; }
const CProjectileWeapon& GetProjectileWeapon() const { return x170_projectile; } const CProjectileWeapon& GetProjectileWeapon() const { return x170_projectile; }
TUniqueId GetHomingTargetId() const { return x2c0_homingTargetId; } TUniqueId GetHomingTargetId() const { return x2c0_homingTargetId; }

20
Runtime/Weapon/CIceBeam.hpp
View File

@ -18,17 +18,17 @@ public:
CIceBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial, CIceBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial,
const zeus::CVector3f& scale); const zeus::CVector3f& scale);
void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf); void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf) override;
void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr, void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr,
TUniqueId homingTarget, float chargeFactor1, float chargeFactor2); TUniqueId homingTarget, float chargeFactor1, float chargeFactor2) override;
void EnableFx(bool enable); void EnableFx(bool enable) override;
void EnableSecondaryFx(ESecondaryFxType type); void EnableSecondaryFx(ESecondaryFxType type) override;
void Update(float dt, CStateManager& mgr); void Update(float dt, CStateManager& mgr) override;
void Load(CStateManager& mgr, bool subtypeBasePose); void Load(CStateManager& mgr, bool subtypeBasePose) override;
void Unload(CStateManager& mgr); void Unload(CStateManager& mgr) override;
bool IsLoaded() const; bool IsLoaded() const override;
}; };
} // namespace urde } // namespace urde

20
Runtime/Weapon/CPhazonBeam.hpp
View File

@ -37,18 +37,18 @@ public:
void UpdateBeam(float dt, const zeus::CTransform& targetXf, const zeus::CVector3f& localBeamPos, CStateManager& mgr); void UpdateBeam(float dt, const zeus::CTransform& targetXf, const zeus::CVector3f& localBeamPos, CStateManager& mgr);
void CreateBeam(CStateManager& mgr); void CreateBeam(CStateManager& mgr);
void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf); void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf) override;
void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr, void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr,
TUniqueId homingTarget, float chargeFactor1, float chargeFactor2); TUniqueId homingTarget, float chargeFactor1, float chargeFactor2) override;
void Update(float dt, CStateManager& mgr); void Update(float dt, CStateManager& mgr) override;
void Load(CStateManager& mgr, bool subtypeBasePose); void Load(CStateManager& mgr, bool subtypeBasePose) override;
void Unload(CStateManager& mgr); void Unload(CStateManager& mgr) override;
bool IsLoaded() const; bool IsLoaded() const override;
void Draw(bool drawSuitArm, const CStateManager& mgr, const zeus::CTransform& xf, const CModelFlags& flags, void Draw(bool drawSuitArm, const CStateManager& mgr, const zeus::CTransform& xf, const CModelFlags& flags,
const CActorLights* lights) const; const CActorLights* lights) const override;
void DrawMuzzleFx(const CStateManager& mgr) const; void DrawMuzzleFx(const CStateManager& mgr) const override;
}; };
} // namespace urde } // namespace urde

16
Runtime/Weapon/CPlasmaBeam.hpp
View File

@ -30,15 +30,15 @@ public:
} }
void DeleteBeam(CStateManager& mgr); void DeleteBeam(CStateManager& mgr);
void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf); void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf) override;
void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr, void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr,
TUniqueId homingTarget, float chargeFactor1, float chargeFactor2); TUniqueId homingTarget, float chargeFactor1, float chargeFactor2) override;
void EnableSecondaryFx(ESecondaryFxType type); void EnableSecondaryFx(ESecondaryFxType type) override;
void Update(float dt, CStateManager& mgr); void Update(float dt, CStateManager& mgr) override;
void Load(CStateManager& mgr, bool subtypeBasePose); void Load(CStateManager& mgr, bool subtypeBasePose) override;
void Unload(CStateManager& mgr); void Unload(CStateManager& mgr) override;
bool IsLoaded() const; bool IsLoaded() const override;
}; };
} // namespace urde } // namespace urde

18
Runtime/Weapon/CPlasmaProjectile.hpp
View File

@ -104,14 +104,14 @@ public:
const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner, const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner,
const PlayerEffectResoures& res, bool growingBeam, EProjectileAttrib attribs); const PlayerEffectResoures& res, bool growingBeam, EProjectileAttrib attribs);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void ResetBeam(CStateManager& mgr, bool fullReset); void ResetBeam(CStateManager& mgr, bool fullReset) override;
void UpdateFx(const zeus::CTransform& xf, float dt, CStateManager& mgr); void UpdateFx(const zeus::CTransform& xf, float dt, CStateManager& mgr) override;
void Fire(const zeus::CTransform& xf, CStateManager& mgr, bool b); void Fire(const zeus::CTransform& xf, CStateManager& mgr, bool b) override;
void Touch(CActor& other, CStateManager& mgr); void Touch(CActor& other, CStateManager& mgr) override;
bool CanRenderUnsorted(const CStateManager& mgr) const; bool CanRenderUnsorted(const CStateManager& mgr) const override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const; void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
}; };
} // namespace urde } // namespace urde

18
Runtime/Weapon/CPowerBeam.hpp
View File

@ -20,16 +20,16 @@ public:
CPowerBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial, CPowerBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial,
const zeus::CVector3f& scale); const zeus::CVector3f& scale);
void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PreRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf); void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf) override;
void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr, void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr,
TUniqueId homingTarget, float chargeFactor1, float chargeFactor2); TUniqueId homingTarget, float chargeFactor1, float chargeFactor2) override;
void EnableSecondaryFx(ESecondaryFxType type); void EnableSecondaryFx(ESecondaryFxType type) override;
void Update(float dt, CStateManager& mgr); void Update(float dt, CStateManager& mgr) override;
void Load(CStateManager& mgr, bool subtypeBasePose); void Load(CStateManager& mgr, bool subtypeBasePose) override;
void Unload(CStateManager& mgr); void Unload(CStateManager& mgr) override;
bool IsLoaded() const; bool IsLoaded() const override;
}; };
} // namespace urde } // namespace urde

14
Runtime/Weapon/CPowerBomb.hpp
View File

@ -20,13 +20,13 @@ public:
CPowerBomb(const TToken<CGenDescription>& particle, TUniqueId uid, TAreaId aid, TUniqueId playerId, CPowerBomb(const TToken<CGenDescription>& particle, TUniqueId uid, TAreaId aid, TUniqueId playerId,
const zeus::CTransform& xf, const CDamageInfo& dInfo); const zeus::CTransform& xf, const CDamageInfo& dInfo);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
std::optional<zeus::CAABox> GetTouchBounds() const { return {}; } std::optional<zeus::CAABox> GetTouchBounds() const override { return {}; }
void Touch(CActor&, CStateManager&) { /*x158_24_canStartFilter; */ void Touch(CActor&, CStateManager&) override { /*x158_24_canStartFilter; */
} }
float GetCurTime() const { return x15c_curTime; } float GetCurTime() const { return x15c_curTime; }
void ApplyDynamicDamage(const zeus::CVector3f&, CStateManager&); void ApplyDynamicDamage(const zeus::CVector3f&, CStateManager&);

6
Runtime/Weapon/CTargetableProjectile.hpp
View File

@ -16,10 +16,10 @@ public:
const std::optional<TLockedToken<CGenDescription>>& visorParticle, u16 visorSfx, const std::optional<TLockedToken<CGenDescription>>& visorParticle, u16 visorSfx,
bool sendCollideMsg); bool sendCollideMsg);
void Accept(IVisitor&); void Accept(IVisitor&) override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const; zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
bool Explode(const zeus::CVector3f& pos, const zeus::CVector3f& normal, EWeaponCollisionResponseTypes type, bool Explode(const zeus::CVector3f& pos, const zeus::CVector3f& normal, EWeaponCollisionResponseTypes type,
CStateManager& mgr, const CDamageVulnerability& dVuln, TUniqueId hitActor); CStateManager& mgr, const CDamageVulnerability& dVuln, TUniqueId hitActor) override;
}; };
} // namespace urde } // namespace urde

16
Runtime/Weapon/CWaveBeam.hpp
View File

@ -20,15 +20,15 @@ public:
CWaveBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial, CWaveBeam(CAssetId characterId, EWeaponType type, TUniqueId playerId, EMaterialTypes playerMaterial,
const zeus::CVector3f& scale); const zeus::CVector3f& scale);
void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf); void PostRenderGunFx(const CStateManager& mgr, const zeus::CTransform& xf) override;
void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf); void UpdateGunFx(bool shotSmoke, float dt, const CStateManager& mgr, const zeus::CTransform& xf) override;
void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr, void Fire(bool underwater, float dt, EChargeState chargeState, const zeus::CTransform& xf, CStateManager& mgr,
TUniqueId homingTarget, float chargeFactor1, float chargeFactor2); TUniqueId homingTarget, float chargeFactor1, float chargeFactor2) override;
void EnableSecondaryFx(ESecondaryFxType type); void EnableSecondaryFx(ESecondaryFxType type) override;
void Update(float dt, CStateManager& mgr); void Update(float dt, CStateManager& mgr) override;
void Load(CStateManager& mgr, bool subtypeBasePose); void Load(CStateManager& mgr, bool subtypeBasePose) override;
void Unload(CStateManager& mgr); void Unload(CStateManager& mgr) override;
bool IsLoaded() const; bool IsLoaded() const override;
}; };
} // namespace urde } // namespace urde

10
Runtime/Weapon/CWeapon.hpp
View File

@ -24,7 +24,7 @@ public:
const zeus::CTransform& xf, const CMaterialFilter& filter, const CMaterialList& mList, const CDamageInfo&, const zeus::CTransform& xf, const CMaterialFilter& filter, const CMaterialList& mList, const CDamageInfo&,
EProjectileAttrib attribs, CModelData&& mData); EProjectileAttrib attribs, CModelData&& mData);
virtual void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
bool HasAttrib(EProjectileAttrib attrib) const { return (int(xe8_projectileAttribs) & int(attrib)) == int(attrib); } bool HasAttrib(EProjectileAttrib attrib) const { return (int(xe8_projectileAttribs) & int(attrib)) == int(attrib); }
EProjectileAttrib GetAttribField() const { return xe8_projectileAttribs; } EProjectileAttrib GetAttribField() const { return xe8_projectileAttribs; }
const CMaterialFilter& GetFilter() const { return xf8_filter; } const CMaterialFilter& GetFilter() const { return xf8_filter; }
@ -38,10 +38,10 @@ public:
float GetDamageDuration() const { return x150_damageDuration; } float GetDamageDuration() const { return x150_damageDuration; }
float GetInterferenceDuration() const { return x154_interferenceDuration; } float GetInterferenceDuration() const { return x154_interferenceDuration; }
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const; const CWeaponMode&, EProjectileAttrib) const override;
void FluidFXThink(EFluidState state, CScriptWater& water, CStateManager& mgr); void FluidFXThink(EFluidState state, CScriptWater& water, CStateManager& mgr) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CActor.hpp
View File

@ -98,8 +98,8 @@ public:
CActor(TUniqueId uid, bool active, std::string_view name, const CEntityInfo& info, const zeus::CTransform&, CActor(TUniqueId uid, bool active, std::string_view name, const CEntityInfo& info, const zeus::CTransform&,
CModelData&& mData, const CMaterialList& list, const CActorParameters& params, TUniqueId otherUid); CModelData&& mData, const CMaterialList& list, const CActorParameters& params, TUniqueId otherUid);
virtual void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
virtual void SetActive(bool active) { void SetActive(bool active) override {
xe4_27_notInSortedLists = true; xe4_27_notInSortedLists = true;
xe4_28_transformDirty = true; xe4_28_transformDirty = true;
xe4_29_actorLightsDirty = true; xe4_29_actorLightsDirty = true;

14
Runtime/World/CAi.hpp
View File

@ -39,19 +39,21 @@ public:
const CStateMachine* GetStateMachine() const; const CStateMachine* GetStateMachine() const;
virtual void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
virtual CHealthInfo* HealthInfo(CStateManager&) { return &x258_healthInfo; } CHealthInfo* HealthInfo(CStateManager&) override { return &x258_healthInfo; }
const CDamageVulnerability* GetDamageVulnerability() const override { return &x260_damageVulnerability; }
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const override;
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
virtual void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) = 0; virtual void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) = 0;
virtual void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, virtual void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type,
bool inDeferred, float magnitude) = 0; bool inDeferred, float magnitude) = 0;
virtual const CDamageVulnerability* GetDamageVulnerability() const { return &x260_damageVulnerability; }
virtual void TakeDamage(const zeus::CVector3f& direction, float magnitude) {} virtual void TakeDamage(const zeus::CVector3f& direction, float magnitude) {}
virtual bool CanBeShot(const CStateManager&, int) { return true; } virtual bool CanBeShot(const CStateManager&, int) { return true; }
virtual bool IsListening() const { return false; } virtual bool IsListening() const { return false; }
virtual bool Listen(const zeus::CVector3f&, EListenNoiseType) { return 0; } virtual bool Listen(const zeus::CVector3f&, EListenNoiseType) { return 0; }
virtual EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const;
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&);
virtual zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, virtual zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const { const zeus::CVector3f& aimPos) const {

14
Runtime/World/CAmbientAI.hpp
View File

@ -29,13 +29,13 @@ public:
const zeus::CAABox&, const CMaterialList&, float, const CHealthInfo&, const CDamageVulnerability&, const zeus::CAABox&, const CMaterialList&, float, const CHealthInfo&, const CDamageVulnerability&,
const CActorParameters&, float, float, s32, s32, bool); const CActorParameters&, float, float, s32, s32, bool);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
CHealthInfo* HealthInfo(CStateManager&) { return &x260_healthInfo; } CHealthInfo* HealthInfo(CStateManager&) override{ return &x260_healthInfo; }
const CDamageVulnerability* GetDamageVulnerability() const { return &x268_dVuln; } const CDamageVulnerability* GetDamageVulnerability() const override{ return &x268_dVuln; }
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&) {} void Touch(CActor&, CStateManager&) override{}
void RandomizePlaybackRate(CStateManager&); void RandomizePlaybackRate(CStateManager&);
}; };

4
Runtime/World/CEffect.hpp
View File

@ -8,8 +8,8 @@ class CEffect : public CActor {
public: public:
CEffect(TUniqueId uid, const CEntityInfo& info, bool active, std::string_view name, const zeus::CTransform& xf); CEffect(TUniqueId uid, const CEntityInfo& info, bool active, std::string_view name, const zeus::CTransform& xf);
virtual void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const {} void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override{}
virtual void Render(const CStateManager&) const {} void Render(const CStateManager&) const override{}
}; };
} // namespace urde } // namespace urde

14
Runtime/World/CExplosion.hpp
View File

@ -26,13 +26,13 @@ public:
std::string_view name, const zeus::CTransform& xf, u32, const zeus::CVector3f& scale, std::string_view name, const zeus::CTransform& xf, u32, const zeus::CVector3f& scale,
const zeus::CColor& color); const zeus::CColor& color);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void PreRender(CStateManager&, const zeus::CFrustum&); void PreRender(CStateManager&, const zeus::CFrustum&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
bool CanRenderUnsorted(const CStateManager&) const; bool CanRenderUnsorted(const CStateManager&) const override;
}; };
} // namespace urde } // namespace urde

12
Runtime/World/CFire.hpp
View File

@ -28,17 +28,17 @@ public:
CFire(TToken<CGenDescription>, TUniqueId, TAreaId, bool, TUniqueId, const zeus::CTransform&, const CDamageInfo&, CFire(TToken<CGenDescription>, TUniqueId, TAreaId, bool, TUniqueId, const zeus::CTransform&, const CDamageInfo&,
const zeus::CAABox&, const zeus::CVector3f&, bool, CAssetId, bool, bool, bool, float, float, float, float); const zeus::CAABox&, const zeus::CVector3f&, bool, CAssetId, bool, bool, bool, float, float, float, float);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const { std::optional<zeus::CAABox> GetTouchBounds() const override {
if (GetActive()) if (GetActive())
return x128_; return x128_;
return {}; return {};
} }
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
}; };
} // namespace urde } // namespace urde

16
Runtime/World/CFishCloud.hpp
View File

@ -135,14 +135,14 @@ public:
CAssetId part1, u32 partCount1, CAssetId part2, u32 partCount2, CAssetId part3, u32 partCount3, CAssetId part1, u32 partCount1, CAssetId part2, u32 partCount2, CAssetId part3, u32 partCount3,
CAssetId part4, u32 partCount4, u32 deathSfx, bool repelFromThreats, bool hotInThermal); CAssetId part4, u32 partCount4, u32 deathSfx, bool repelFromThreats, bool hotInThermal);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void CalculateRenderBounds(); void CalculateRenderBounds() override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor& other, CStateManager& mgr); void Touch(CActor& other, CStateManager& mgr) override;
void RemoveRepulsor(TUniqueId source); void RemoveRepulsor(TUniqueId source);
void RemoveAttractor(TUniqueId source); void RemoveAttractor(TUniqueId source);
bool AddRepulsor(TUniqueId source, bool swirl, float radius, float priority); bool AddRepulsor(TUniqueId source, bool swirl, float radius, float priority);

4
Runtime/World/CFishCloudModifier.hpp
View File

@ -13,8 +13,8 @@ public:
CFishCloudModifier(TUniqueId uid, bool active, std::string_view name, const CEntityInfo& eInfo, CFishCloudModifier(TUniqueId uid, bool active, std::string_view name, const CEntityInfo& eInfo,
const zeus::CVector3f& pos, bool isRepulsor, bool swirl, float radius, const zeus::CVector3f& pos, bool isRepulsor, bool swirl, float radius,
float priority); float priority);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddSelf(CStateManager&); void AddSelf(CStateManager&);
void RemoveSelf(CStateManager&); void RemoveSelf(CStateManager&);

4
Runtime/World/CFluidPlaneCPU.hpp
View File

@ -94,8 +94,8 @@ public:
const CScriptWater* water) const; const CScriptWater* water) const;
void Render(const CStateManager& mgr, float alpha, const zeus::CAABox& aabb, const zeus::CTransform& xf, void Render(const CStateManager& mgr, float alpha, const zeus::CAABox& aabb, const zeus::CTransform& xf,
const zeus::CTransform& areaXf, bool noNormals, const zeus::CFrustum& frustum, const zeus::CTransform& areaXf, bool noNormals, const zeus::CFrustum& frustum,
const std::optional<CRippleManager>& rippleManager, TUniqueId waterId, const std::optional<CRippleManager>& rippleManager, TUniqueId waterId, const bool* gridFlags,
const bool* gridFlags, u32 gridDimX, u32 gridDimY, const zeus::CVector3f& areaCenter) const; u32 gridDimX, u32 gridDimY, const zeus::CVector3f& areaCenter) const override;
float GetReflectionBlend() const { return x114_reflectionBlend; } float GetReflectionBlend() const { return x114_reflectionBlend; }
float GetSpecularMax() const { return x110_specularMax; } float GetSpecularMax() const { return x110_specularMax; }
float GetSpecularMin() const { return x10c_specularMin; } float GetSpecularMin() const { return x10c_specularMin; }

12
Runtime/World/CFluidPlaneDoor.hpp
View File

@ -15,16 +15,16 @@ class CFluidPlaneDoor final : public CFluidPlane {
public: public:
CFluidPlaneDoor(CAssetId patternTex1, CAssetId patternTex2, CAssetId colorTex, float tileSize, u32 tileSubdivisions, CFluidPlaneDoor(CAssetId patternTex1, CAssetId patternTex2, CAssetId colorTex, float tileSize, u32 tileSubdivisions,
EFluidType fluidType, float alpha, const CFluidUVMotion& uvMotion); EFluidType fluidType, float alpha, const CFluidUVMotion& uvMotion);
void AddRipple(float mag, TUniqueId rippler, const zeus::CVector3f& center, CScriptWater& water, CStateManager& mgr) { void AddRipple(float mag, TUniqueId rippler, const zeus::CVector3f& center, CScriptWater& water,
} CStateManager& mgr) override {}
void AddRipple(float intensity, TUniqueId rippler, const zeus::CVector3f& center, const zeus::CVector3f& velocity, void AddRipple(float intensity, TUniqueId rippler, const zeus::CVector3f& center, const zeus::CVector3f& velocity,
const CScriptWater& water, CStateManager& mgr, const zeus::CVector3f& upVec) {} const CScriptWater& water, CStateManager& mgr, const zeus::CVector3f& upVec) override {}
void AddRipple(const CRipple& ripple, const CScriptWater& water, CStateManager& mgr) {} void AddRipple(const CRipple& ripple, const CScriptWater& water, CStateManager& mgr) override {}
void Render(const CStateManager& mgr, float alpha, const zeus::CAABox& aabb, const zeus::CTransform& xf, void Render(const CStateManager& mgr, float alpha, const zeus::CAABox& aabb, const zeus::CTransform& xf,
const zeus::CTransform& areaXf, bool noNormals, const zeus::CFrustum& frustum, const zeus::CTransform& areaXf, bool noNormals, const zeus::CFrustum& frustum,
const std::optional<CRippleManager>& rippleManager, TUniqueId waterId, const std::optional<CRippleManager>& rippleManager, TUniqueId waterId, const bool* gridFlags,
const bool* gridFlags, u32 gridDimX, u32 gridDimY, const zeus::CVector3f& areaCenter) const; u32 gridDimX, u32 gridDimY, const zeus::CVector3f& areaCenter) const override;
}; };
} // namespace urde } // namespace urde

2
Runtime/World/CFluidPlaneGPU.hpp
View File

@ -17,7 +17,7 @@ public:
void RenderStripWithRipples(float curY, const CFluidPlaneRender::SHFieldSample (&heights)[46][46], void RenderStripWithRipples(float curY, const CFluidPlaneRender::SHFieldSample (&heights)[46][46],
const u8 (&flags)[9][9], int startYDiv, const CFluidPlaneRender::SPatchInfo& info, const u8 (&flags)[9][9], int startYDiv, const CFluidPlaneRender::SPatchInfo& info,
std::vector<CFluidPlaneShader::Vertex>& vOut, std::vector<CFluidPlaneShader::Vertex>& vOut,
std::vector<CFluidPlaneShader::PatchVertex>& pvOut) const; std::vector<CFluidPlaneShader::PatchVertex>& pvOut) const override;
}; };
} // namespace urde } // namespace urde

34
Runtime/World/CGameArea.hpp
View File

@ -50,14 +50,14 @@ class CDummyGameArea final : public IGameArea {
public: public:
CDummyGameArea(CInputStream& in, int idx, int mlvlVersion); CDummyGameArea(CInputStream& in, int idx, int mlvlVersion);
std::pair<std::unique_ptr<u8[]>, s32> IGetScriptingMemoryAlways() const; std::pair<std::unique_ptr<u8[]>, s32> IGetScriptingMemoryAlways() const override;
TAreaId IGetAreaId() const; TAreaId IGetAreaId() const override;
CAssetId IGetAreaAssetId() const; CAssetId IGetAreaAssetId() const override;
bool IIsActive() const; bool IIsActive() const override;
TAreaId IGetAttachedAreaId(int) const; TAreaId IGetAttachedAreaId(int) const override;
u32 IGetNumAttachedAreas() const; u32 IGetNumAttachedAreas() const override;
CAssetId IGetStringTableAssetId() const; CAssetId IGetStringTableAssetId() const override;
const zeus::CTransform& IGetTM() const; const zeus::CTransform& IGetTM() const override;
}; };
struct CAreaRenderOctTree { struct CAreaRenderOctTree {
@ -164,7 +164,7 @@ public:
public: public:
CAreaObjectList(TAreaId areaIdx) : CObjectList(EGameObjectList::Invalid), x200c_areaIdx(areaIdx) {} CAreaObjectList(TAreaId areaIdx) : CObjectList(EGameObjectList::Invalid), x200c_areaIdx(areaIdx) {}
bool IsQualified(const CEntity& ent); bool IsQualified(const CEntity& ent) override;
}; };
enum class EOcclusionState { Occluded, Visible }; enum class EOcclusionState { Occluded, Visible };
@ -272,15 +272,15 @@ public:
void ReadDependencyList(); void ReadDependencyList();
void SetLoadPauseState(bool paused); void SetLoadPauseState(bool paused);
std::pair<std::unique_ptr<u8[]>, s32> IGetScriptingMemoryAlways() const; std::pair<std::unique_ptr<u8[]>, s32> IGetScriptingMemoryAlways() const override;
TAreaId GetAreaId() const { return x4_selfIdx; } TAreaId GetAreaId() const { return x4_selfIdx; }
TAreaId IGetAreaId() const { return x4_selfIdx; } TAreaId IGetAreaId() const override { return x4_selfIdx; }
CAssetId IGetAreaAssetId() const { return x84_mrea; } CAssetId IGetAreaAssetId() const override { return x84_mrea; }
bool IIsActive() const; bool IIsActive() const override;
TAreaId IGetAttachedAreaId(int) const; TAreaId IGetAttachedAreaId(int) const override;
u32 IGetNumAttachedAreas() const; u32 IGetNumAttachedAreas() const override;
CAssetId IGetStringTableAssetId() const; CAssetId IGetStringTableAssetId() const override;
const zeus::CTransform& IGetTM() const; const zeus::CTransform& IGetTM() const override;
void SetXRaySpeedAndTarget(float speed, float target); void SetXRaySpeedAndTarget(float speed, float target);
void SetThermalSpeedAndTarget(float speed, float target); void SetThermalSpeedAndTarget(float speed, float target);

4
Runtime/World/CGameLight.hpp
View File

@ -14,8 +14,8 @@ public:
CGameLight(TUniqueId, TAreaId, bool, std::string_view, const zeus::CTransform&, TUniqueId, const CLight&, CGameLight(TUniqueId, TAreaId, bool, std::string_view, const zeus::CTransform&, TUniqueId, const CLight&,
u32 sourceId, u32, float); u32 sourceId, u32, float);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void SetLightPriorityAndId(); void SetLightPriorityAndId();
void SetLight(const CLight&); void SetLight(const CLight&);
CLight GetLight() const; CLight GetLight() const;

12
Runtime/World/CHUDBillboardEffect.hpp
View File

@ -29,12 +29,12 @@ public:
const std::optional<TToken<CElectricDescription>>& electric, TUniqueId uid, const std::optional<TToken<CElectricDescription>>& electric, TUniqueId uid,
bool active, std::string_view name, float dist, const zeus::CVector3f& scale0, bool active, std::string_view name, float dist, const zeus::CVector3f& scale0,
const zeus::CColor& color, const zeus::CVector3f& scale1, const zeus::CVector3f& translation); const zeus::CColor& color, const zeus::CVector3f& scale1, const zeus::CVector3f& translation);
~CHUDBillboardEffect(); ~CHUDBillboardEffect() override;
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const; void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
bool IsElementGen() const { return x104_26_isElementGen; } bool IsElementGen() const { return x104_26_isElementGen; }
void SetRunIndefinitely(bool b) { x104_27_runIndefinitely = b; } void SetRunIndefinitely(bool b) { x104_27_runIndefinitely = b; }
CParticleGen* GetParticleGen() const { return xe8_generator.get(); } CParticleGen* GetParticleGen() const { return xe8_generator.get(); }

2
Runtime/World/CIceImpact.hpp
View File

@ -9,7 +9,7 @@ public:
CIceImpact(const TLockedToken<CGenDescription>& particle, TUniqueId uid, TAreaId aid, bool active, CIceImpact(const TLockedToken<CGenDescription>& particle, TUniqueId uid, TAreaId aid, bool active,
std::string_view name, const zeus::CTransform& xf, u32 flags, const zeus::CVector3f& scale, std::string_view name, const zeus::CTransform& xf, u32 flags, const zeus::CVector3f& scale,
const zeus::CColor& color); const zeus::CColor& color);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
}; };
} // namespace urde } // namespace urde

111
Runtime/World/CPatterned.hpp
View File

@ -256,67 +256,70 @@ public:
CPatterned::EMovementType movement, EColliderType collider, EBodyType body, const CActorParameters& params, CPatterned::EMovementType movement, EColliderType collider, EBodyType body, const CActorParameters& params,
EKnockBackVariant kbVariant); EKnockBackVariant kbVariant);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void PreThink(float dt, CStateManager& mgr) { x500_preThinkDt = dt; CEntity::Think(x500_preThinkDt, mgr); } void PreThink(float dt, CStateManager& mgr) override {
void Think(float, CStateManager&); x500_preThinkDt = dt;
void PreRender(CStateManager&, const zeus::CFrustum&); CEntity::Think(x500_preThinkDt, mgr);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; }
void Render(const CStateManager& mgr) const; void Think(float, CStateManager&) override;
void PreRender(CStateManager&, const zeus::CFrustum&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Render(const CStateManager& mgr) const override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr); void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr) override;
void Touch(CActor& act, CStateManager& mgr); void Touch(CActor& act, CStateManager& mgr) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
bool CanRenderUnsorted(const CStateManager& mgr) const; bool CanRenderUnsorted(const CStateManager& mgr) const override;
zeus::CVector3f GetOrbitPosition(const CStateManager& mgr) const { return GetAimPosition(mgr, 0.f); } zeus::CVector3f GetOrbitPosition(const CStateManager& mgr) const override { return GetAimPosition(mgr, 0.f); }
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const; zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const override;
zeus::CTransform GetLctrTransform(std::string_view name) const; zeus::CTransform GetLctrTransform(std::string_view name) const;
zeus::CTransform GetLctrTransform(CSegId id) const; zeus::CTransform GetLctrTransform(CSegId id) const;
bool ApplyBoneTracking() const; bool ApplyBoneTracking() const;
void DeathDelete(CStateManager& mgr); void DeathDelete(CStateManager& mgr);
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred, void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude); float magnitude) override;
void TakeDamage(const zeus::CVector3f&, float arg); void TakeDamage(const zeus::CVector3f&, float arg) override;
bool FixedRandom(CStateManager&, float arg); bool FixedRandom(CStateManager&, float arg) override;
bool Random(CStateManager&, float arg); bool Random(CStateManager&, float arg) override;
bool CodeTrigger(CStateManager&, float arg); bool CodeTrigger(CStateManager&, float arg) override;
bool FixedDelay(CStateManager&, float arg); bool FixedDelay(CStateManager&, float arg) override;
bool RandomDelay(CStateManager&, float arg); bool RandomDelay(CStateManager&, float arg) override;
bool Delay(CStateManager&, float arg); bool Delay(CStateManager&, float arg) override;
bool PatrolPathOver(CStateManager&, float arg); bool PatrolPathOver(CStateManager&, float arg) override;
bool Stuck(CStateManager&, float arg); bool Stuck(CStateManager&, float arg) override;
bool AnimOver(CStateManager&, float arg); bool AnimOver(CStateManager&, float arg) override;
bool InPosition(CStateManager&, float arg); bool InPosition(CStateManager&, float arg) override;
bool HasPatrolPath(CStateManager& mgr, float arg); bool HasPatrolPath(CStateManager& mgr, float arg) override;
bool Attacked(CStateManager&, float arg); bool Attacked(CStateManager&, float arg) override;
bool PatternShagged(CStateManager&, float arg); bool PatternShagged(CStateManager&, float arg) override;
bool PatternOver(CStateManager&, float arg); bool PatternOver(CStateManager&, float arg) override;
bool HasRetreatPattern(CStateManager& mgr, float arg); bool HasRetreatPattern(CStateManager& mgr, float arg) override;
bool HasAttackPattern(CStateManager& mgr, float arg); bool HasAttackPattern(CStateManager& mgr, float arg) override;
bool NoPathNodes(CStateManager&, float arg); bool NoPathNodes(CStateManager&, float arg) override;
bool PathShagged(CStateManager&, float arg); bool PathShagged(CStateManager&, float arg) override;
bool PathFound(CStateManager&, float arg); bool PathFound(CStateManager&, float arg) override;
bool PathOver(CStateManager&, float arg); bool PathOver(CStateManager&, float arg) override;
bool Landed(CStateManager&, float arg); bool Landed(CStateManager&, float arg) override;
bool PlayerSpot(CStateManager&, float arg); bool PlayerSpot(CStateManager&, float arg) override;
bool SpotPlayer(CStateManager&, float arg); bool SpotPlayer(CStateManager&, float arg) override;
bool Leash(CStateManager&, float arg); bool Leash(CStateManager&, float arg) override;
bool InDetectionRange(CStateManager&, float arg); bool InDetectionRange(CStateManager&, float arg) override;
bool InMaxRange(CStateManager&, float arg); bool InMaxRange(CStateManager&, float arg) override;
bool TooClose(CStateManager&, float arg); bool TooClose(CStateManager&, float arg) override;
bool InRange(CStateManager&, float arg); bool InRange(CStateManager&, float arg) override;
bool OffLine(CStateManager&, float arg); bool OffLine(CStateManager&, float arg) override;
bool Default(CStateManager&, float arg) { return true; } bool Default(CStateManager&, float arg) override { return true; }
void PathFind(CStateManager&, EStateMsg msg, float dt); void PathFind(CStateManager&, EStateMsg msg, float dt) override;
void Dead(CStateManager&, EStateMsg msg, float dt); void Dead(CStateManager&, EStateMsg msg, float dt) override;
void TargetPlayer(CStateManager&, EStateMsg msg, float dt); void TargetPlayer(CStateManager&, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg msg, float dt); void TargetPatrol(CStateManager&, EStateMsg msg, float dt) override;
void FollowPattern(CStateManager&, EStateMsg msg, float dt); void FollowPattern(CStateManager&, EStateMsg msg, float dt) override;
void Patrol(CStateManager&, EStateMsg msg, float dt); void Patrol(CStateManager&, EStateMsg msg, float dt) override;
void Start(CStateManager&, EStateMsg msg, float dt) {} void Start(CStateManager&, EStateMsg msg, float dt) override {}
void TryCommand(CStateManager& mgr, pas::EAnimationState state, CPatternedTryFunc func, int arg); void TryCommand(CStateManager& mgr, pas::EAnimationState state, CPatternedTryFunc func, int arg);
void TryLoopReaction(CStateManager& mgr, int arg); void TryLoopReaction(CStateManager& mgr, int arg);
@ -364,7 +367,7 @@ public:
void LaunchProjectile(const zeus::CTransform& gunXf, CStateManager& mgr, int maxAllowed, EProjectileAttrib attrib, void LaunchProjectile(const zeus::CTransform& gunXf, CStateManager& mgr, int maxAllowed, EProjectileAttrib attrib,
bool playerHoming, const std::optional<TLockedToken<CGenDescription>>& visorParticle, bool playerHoming, const std::optional<TLockedToken<CGenDescription>>& visorParticle,
u16 visorSfx, bool sendCollideMsg, const zeus::CVector3f& scale); u16 visorSfx, bool sendCollideMsg, const zeus::CVector3f& scale);
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
void SetDestPos(const zeus::CVector3f& pos) { x2e0_destPos = pos; } void SetDestPos(const zeus::CVector3f& pos) { x2e0_destPos = pos; }
void UpdateAlphaDelta(float dt, CStateManager& mgr); void UpdateAlphaDelta(float dt, CStateManager& mgr);

6
Runtime/World/CPhysicsActor.hpp
View File

@ -112,9 +112,9 @@ public:
CPhysicsActor(TUniqueId, bool, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CPhysicsActor(TUniqueId, bool, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CMaterialList&, const zeus::CAABox&, const SMoverData&, const CActorParameters&, float, float); const CMaterialList&, const zeus::CAABox&, const SMoverData&, const CActorParameters&, float, float);
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const; zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
zeus::CVector3f GetAimPosition(const CStateManager&, float val) const; zeus::CVector3f GetAimPosition(const CStateManager&, float val) const override;
virtual const CCollisionPrimitive* GetCollisionPrimitive() const; virtual const CCollisionPrimitive* GetCollisionPrimitive() const;
virtual zeus::CTransform GetPrimitiveTransform() const; virtual zeus::CTransform GetPrimitiveTransform() const;
virtual void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&); virtual void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&);

46
Runtime/World/CPlayer.hpp
View File

@ -367,23 +367,23 @@ public:
void AsyncLoadSuit(CStateManager& mgr); void AsyncLoadSuit(CStateManager& mgr);
void LoadAnimationTokens(); void LoadAnimationTokens();
bool HasTransitionBeamModel() const; bool HasTransitionBeamModel() const;
bool CanRenderUnsorted(const CStateManager& mgr) const; bool CanRenderUnsorted(const CStateManager& mgr) const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& v1, const zeus::CVector3f& v2, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& v1, const zeus::CVector3f& v2,
const CDamageInfo& info) const; const CDamageInfo& info) const override;
const CDamageVulnerability* GetDamageVulnerability() const; const CDamageVulnerability* GetDamageVulnerability() const override;
zeus::CVector3f GetHomingPosition(const CStateManager& mgr, float) const; zeus::CVector3f GetHomingPosition(const CStateManager& mgr, float) const override;
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const; zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const override;
void FluidFXThink(CActor::EFluidState, CScriptWater& water, CStateManager& mgr); void FluidFXThink(CActor::EFluidState, CScriptWater& water, CStateManager& mgr) override;
zeus::CVector3f GetDamageLocationWR() const { return x564_damageLocation; } zeus::CVector3f GetDamageLocationWR() const { return x564_damageLocation; }
float GetPrevDamageAmount() const { return x560_prevDamageAmt; } float GetPrevDamageAmount() const { return x560_prevDamageAmt; }
float GetDamageAmount() const { return x55c_damageAmt; } float GetDamageAmount() const { return x55c_damageAmt; }
bool WasDamaged() const { return x558_wasDamaged; } bool WasDamaged() const { return x558_wasDamaged; }
void TakeDamage(bool, const zeus::CVector3f&, float, EWeaponType, CStateManager& mgr); void TakeDamage(bool, const zeus::CVector3f&, float, EWeaponType, CStateManager& mgr);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
CHealthInfo* HealthInfo(CStateManager& mgr); CHealthInfo* HealthInfo(CStateManager& mgr) override;
bool IsUnderBetaMetroidAttack(CStateManager& mgr) const; bool IsUnderBetaMetroidAttack(CStateManager& mgr) const;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor& actor, CStateManager& mgr); void Touch(CActor& actor, CStateManager& mgr) override;
void DoPreThink(float dt, CStateManager& mgr); void DoPreThink(float dt, CStateManager& mgr);
void DoThink(float dt, CStateManager& mgr); void DoThink(float dt, CStateManager& mgr);
void UpdateScanningState(const CFinalInput& input, CStateManager& mgr, float); void UpdateScanningState(const CFinalInput& input, CStateManager& mgr, float);
@ -394,11 +394,11 @@ public:
bool GetExplorationMode() const; bool GetExplorationMode() const;
bool GetCombatMode() const; bool GetCombatMode() const;
void RenderGun(const CStateManager& mgr, const zeus::CVector3f&) const; void RenderGun(const CStateManager& mgr, const zeus::CVector3f&) const;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void RenderReflectedPlayer(CStateManager& mgr); void RenderReflectedPlayer(CStateManager& mgr);
void PreRender(CStateManager& mgr, const zeus::CFrustum&); void PreRender(CStateManager& mgr, const zeus::CFrustum&) override;
void CalculateRenderBounds(); void CalculateRenderBounds() override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void ComputeFreeLook(const CFinalInput& input); void ComputeFreeLook(const CFinalInput& input);
void UpdateFreeLookState(const CFinalInput&, float dt, CStateManager&); void UpdateFreeLookState(const CFinalInput&, float dt, CStateManager&);
void UpdateFreeLook(float dt); void UpdateFreeLook(float dt);
@ -427,9 +427,9 @@ public:
void ResetControlDirectionInterpolation(); void ResetControlDirectionInterpolation();
void SetControlDirectionInterpolation(float time); void SetControlDirectionInterpolation(float time);
void UpdatePlayerControlDirection(float dt, CStateManager& mgr); void UpdatePlayerControlDirection(float dt, CStateManager& mgr);
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void PreThink(float, CStateManager&); void PreThink(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void SetVisorSteam(float, float, float, CAssetId, bool); void SetVisorSteam(float, float, float, CAssetId, bool);
void UpdateFootstepSounds(const CFinalInput& input, CStateManager&, float); void UpdateFootstepSounds(const CFinalInput& input, CStateManager&, float);
u16 GetMaterialSoundUnderPlayer(CStateManager& mgr, const u16*, u32, u16); u16 GetMaterialSoundUnderPlayer(CStateManager& mgr, const u16*, u32, u16);
@ -514,15 +514,15 @@ public:
zeus::CVector3f GetEyePosition() const; zeus::CVector3f GetEyePosition() const;
float GetEyeHeight() const; float GetEyeHeight() const;
float GetUnbiasedEyeHeight() const; float GetUnbiasedEyeHeight() const;
float GetStepUpHeight() const; float GetStepUpHeight() const override;
float GetStepDownHeight() const; float GetStepDownHeight() const override;
void Teleport(const zeus::CTransform& xf, CStateManager& mgr, bool resetBallCam); void Teleport(const zeus::CTransform& xf, CStateManager& mgr, bool resetBallCam);
void BombJump(const zeus::CVector3f& pos, CStateManager& mgr); void BombJump(const zeus::CVector3f& pos, CStateManager& mgr);
zeus::CTransform CreateTransformFromMovementDirection() const; zeus::CTransform CreateTransformFromMovementDirection() const;
const CCollisionPrimitive* GetCollisionPrimitive() const; const CCollisionPrimitive* GetCollisionPrimitive() const override;
const CCollidableSphere* GetCollidableSphere() const; const CCollidableSphere* GetCollidableSphere() const;
zeus::CTransform GetPrimitiveTransform() const; zeus::CTransform GetPrimitiveTransform() const override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr); void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr) override;
float GetBallMaxVelocity() const; float GetBallMaxVelocity() const;
float GetActualBallMaxVelocity(float dt) const; float GetActualBallMaxVelocity(float dt) const;
float GetActualFirstPersonMaxVelocity(float dt) const; float GetActualFirstPersonMaxVelocity(float dt) const;
@ -536,7 +536,7 @@ public:
void FinishSidewaysDash(); void FinishSidewaysDash();
void ComputeDash(const CFinalInput& input, float dt, CStateManager& mgr); void ComputeDash(const CFinalInput& input, float dt, CStateManager& mgr);
void ComputeMovement(const CFinalInput& input, CStateManager& mgr, float dt); void ComputeMovement(const CFinalInput& input, CStateManager& mgr, float dt);
float GetWeight() const; float GetWeight() const override;
zeus::CVector3f GetDampedClampedVelocityWR() const; zeus::CVector3f GetDampedClampedVelocityWR() const;
const CVisorSteam& GetVisorSteam() const { return x7a0_visorSteam; } const CVisorSteam& GetVisorSteam() const { return x7a0_visorSteam; }
float GetVisorStaticAlpha() const { return x74c_visorStaticAlpha; } float GetVisorStaticAlpha() const { return x74c_visorStaticAlpha; }

4
Runtime/World/CRepulsor.hpp
View File

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

20
Runtime/World/CScriptActor.hpp
View File

@ -32,17 +32,17 @@ public:
const CHealthInfo& hInfo, const CDamageVulnerability& dVuln, const CActorParameters& actParms, const CHealthInfo& hInfo, const CDamageVulnerability& dVuln, const CActorParameters& actParms,
bool looping, bool active, s32 shaderIdx, float xrayAlpha, bool noThermalHotZ, bool castsShadow, bool looping, bool active, s32 shaderIdx, float xrayAlpha, bool noThermalHotZ, bool castsShadow,
bool scaleAdvancementDelta, bool materialFlag54); bool scaleAdvancementDelta, bool materialFlag54);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void PreRender(CStateManager&, const zeus::CFrustum&); void PreRender(CStateManager&, const zeus::CFrustum&) override;
zeus::CAABox GetSortingBounds(const CStateManager&) const; zeus::CAABox GetSortingBounds(const CStateManager&) const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const; const CWeaponMode&, EProjectileAttrib) const override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const { return &x268_damageVulnerability; } const CDamageVulnerability* GetDamageVulnerability() const override { return &x268_damageVulnerability; }
CHealthInfo* HealthInfo(CStateManager&) { return &x260_currentHealth; } CHealthInfo* HealthInfo(CStateManager&) override { return &x260_currentHealth; }
bool IsPlayerActor() const { return x2e3_24_isPlayerActor; } bool IsPlayerActor() const { return x2e3_24_isPlayerActor; }
}; };
}; // namespace urde }; // namespace urde

6
Runtime/World/CScriptActorKeyframe.hpp
View File

@ -25,9 +25,9 @@ public:
CScriptActorKeyframe(TUniqueId uid, std::string_view name, const CEntityInfo& info, s32 animId, bool looping, CScriptActorKeyframe(TUniqueId uid, std::string_view name, const CEntityInfo& info, s32 animId, bool looping,
float lifetime, bool isPassive, u32 fadeOut, bool active, float totalPlayback); float lifetime, bool isPassive, u32 fadeOut, bool active, float totalPlayback);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void UpdateEntity(TUniqueId, CStateManager&); void UpdateEntity(TUniqueId, CStateManager&);
bool IsPassive() const { return x44_25_isPassive; } bool IsPassive() const { return x44_25_isPassive; }
void SetIsPassive(bool b) { x44_25_isPassive = b; } void SetIsPassive(bool b) { x44_25_isPassive = b; }

6
Runtime/World/CScriptActorRotate.hpp
View File

@ -30,9 +30,9 @@ class CScriptActorRotate : public CEntity {
public: public:
CScriptActorRotate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CVector3f&, float, bool, bool, bool); CScriptActorRotate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CVector3f&, float, bool, bool, bool);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
}; };
} // namespace urde } // namespace urde

12
Runtime/World/CScriptAiJumpPoint.hpp
View File

@ -21,12 +21,12 @@ private:
public: public:
CScriptAiJumpPoint(TUniqueId, std::string_view, const CEntityInfo&, zeus::CTransform&, bool, float); CScriptAiJumpPoint(TUniqueId, std::string_view, const CEntityInfo&, zeus::CTransform&, bool, float);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const {} void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override {}
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
bool GetInUse(TUniqueId uid) const; bool GetInUse(TUniqueId uid) const;
TUniqueId GetJumpPoint() const { return x10c_currentWaypoint; } TUniqueId GetJumpPoint() const { return x10c_currentWaypoint; }
TUniqueId GetJumpTarget() const { return x10e_nextWaypoint; } TUniqueId GetJumpTarget() const { return x10e_nextWaypoint; }

4
Runtime/World/CScriptAreaAttributes.hpp
View File

@ -19,8 +19,8 @@ public:
float thermalHeat, float xrayFogDistance, float worldLightingLevel, CAssetId skybox, float thermalHeat, float xrayFogDistance, float worldLightingLevel, CAssetId skybox,
EPhazonType phazonType); EPhazonType phazonType);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
bool GetNeedsSky() const { return x34_24_showSkybox; } bool GetNeedsSky() const { return x34_24_showSkybox; }
bool GetNeedsEnvFx() const { return x38_envFx != EEnvFxType::None; } bool GetNeedsEnvFx() const { return x38_envFx != EEnvFxType::None; }

10
Runtime/World/CScriptBallTrigger.hpp
View File

@ -15,10 +15,10 @@ public:
CScriptBallTrigger(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CVector3f&, const zeus::CVector3f&, CScriptBallTrigger(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CVector3f&, const zeus::CVector3f&,
bool, float, float, float, const zeus::CVector3f&, bool); bool, float, float, float, const zeus::CVector3f&, bool);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager& mgr); void Think(float, CStateManager& mgr) override;
void InhabitantAdded(CActor&, CStateManager&); void InhabitantAdded(CActor&, CStateManager&) override;
void InhabitantExited(CActor&, CStateManager&); void InhabitantExited(CActor&, CStateManager&) override;
}; };
} // namespace urde } // namespace urde

6
Runtime/World/CScriptBeam.hpp
View File

@ -16,8 +16,8 @@ public:
CScriptBeam(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, bool, CScriptBeam(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, bool,
const TToken<CWeaponDescription>&, const CBeamInfo&, const CDamageInfo&); const TToken<CWeaponDescription>&, const CBeamInfo&, const CDamageInfo&);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CScriptCameraBlurKeyframe.hpp
View File

@ -15,7 +15,7 @@ public:
CScriptCameraBlurKeyframe(TUniqueId uid, std::string_view name, const CEntityInfo& info, EBlurType type, float amount, CScriptCameraBlurKeyframe(TUniqueId uid, std::string_view name, const CEntityInfo& info, EBlurType type, float amount,
u32 unk, float timeIn, float timeOut, bool active); u32 unk, float timeIn, float timeOut, bool active);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CScriptCameraFilterKeyframe.hpp
View File

@ -20,7 +20,7 @@ public:
EFilterShape shape, u32 filterIdx, u32 unk, const zeus::CColor& color, float timeIn, EFilterShape shape, u32 filterIdx, u32 unk, const zeus::CColor& color, float timeIn,
float timeOut, CAssetId txtr, bool active); float timeOut, CAssetId txtr, bool active);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CScriptCameraHint.hpp
View File

@ -90,8 +90,8 @@ public:
float clampRotRange, float elevation, float interpolateTime, float clampVelTime, float clampRotRange, float elevation, float interpolateTime, float clampVelTime,
float controlInterpDur); float controlInterpDur);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void ClearIdList() { x150_helpers.clear(); } void ClearIdList() { x150_helpers.clear(); }
void SetInactive(bool inactive) { x166_inactive = inactive; } void SetInactive(bool inactive) { x166_inactive = inactive; }

8
Runtime/World/CScriptCameraHintTrigger.hpp
View File

@ -23,9 +23,9 @@ public:
const zeus::CTransform& xf, bool deactivateOnEnter, const zeus::CTransform& xf, bool deactivateOnEnter,
bool deactivateOnExit); bool deactivateOnExit);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void Touch(CActor& other, CStateManager& mgr); void Touch(CActor& other, CStateManager& mgr) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
}; };
} // namespace urde } // namespace urde

8
Runtime/World/CScriptCameraPitchVolume.hpp
View File

@ -25,10 +25,10 @@ public:
CScriptCameraPitchVolume(TUniqueId, bool, std::string_view, const CEntityInfo&, const zeus::CVector3f&, CScriptCameraPitchVolume(TUniqueId, bool, std::string_view, const CEntityInfo&, const zeus::CVector3f&,
const zeus::CTransform&, const zeus::CRelAngle&, const zeus::CRelAngle&, float); const zeus::CTransform&, const zeus::CRelAngle&, const zeus::CRelAngle&, float);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
float GetUpPitch() const { return x124_upPitch; } float GetUpPitch() const { return x124_upPitch; }
float GetDownPitch() const { return x128_downPitch; } float GetDownPitch() const { return x128_downPitch; }
const zeus::CVector3f& GetScale() const { return x12c_scale; } const zeus::CVector3f& GetScale() const { return x12c_scale; }

4
Runtime/World/CScriptCameraShaker.hpp
View File

@ -11,8 +11,8 @@ class CScriptCameraShaker : public CEntity {
public: public:
CScriptCameraShaker(TUniqueId uid, std::string_view name, const CEntityInfo& info, bool active, CScriptCameraShaker(TUniqueId uid, std::string_view name, const CEntityInfo& info, bool active,
const CCameraShakeData& shakeData); const CCameraShakeData& shakeData);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
}; };
} // namespace urde } // namespace urde

8
Runtime/World/CScriptCameraWaypoint.hpp
View File

@ -12,10 +12,10 @@ public:
CScriptCameraWaypoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, CScriptCameraWaypoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
bool active, float hfov, u32); bool active, float hfov, u32);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const {} void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override {}
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
TUniqueId GetRandomNextWaypointId(CStateManager& mgr) const; TUniqueId GetRandomNextWaypointId(CStateManager& mgr) const;
float GetHFov() const { return xe8_hfov; } float GetHFov() const { return xe8_hfov; }
}; };

6
Runtime/World/CScriptColorModulate.hpp
View File

@ -45,9 +45,9 @@ public:
const zeus::CColor& colorB, EBlendMode blendMode, float timeA2B, float timeB2A, bool doReverse, const zeus::CColor& colorB, EBlendMode blendMode, float timeA2B, float timeB2A, bool doReverse,
bool resetTargetWhenDone, bool depthCompare, bool depthUpdate, bool depthBackwards, bool active); bool resetTargetWhenDone, bool depthCompare, bool depthUpdate, bool depthBackwards, bool active);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
CModelFlags CalculateFlags(const zeus::CColor&) const; CModelFlags CalculateFlags(const zeus::CColor&) const;
void SetTargetFlags(CStateManager&, const CModelFlags&); void SetTargetFlags(CStateManager&, const CModelFlags&);
static TUniqueId FadeOutHelper(CStateManager& mgr, TUniqueId obj, float fadetime); static TUniqueId FadeOutHelper(CStateManager& mgr, TUniqueId obj, float fadetime);

4
Runtime/World/CScriptControllerAction.hpp
View File

@ -20,8 +20,8 @@ class CScriptControllerAction : public CEntity {
public: public:
CScriptControllerAction(TUniqueId uid, std::string_view name, const CEntityInfo& info, bool active, CScriptControllerAction(TUniqueId uid, std::string_view name, const CEntityInfo& info, bool active,
ControlMapper::ECommands command, bool b1, u32 w1, bool b2); ControlMapper::ECommands command, bool b1, u32 w1, bool b2);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CScriptCounter.hpp
View File

@ -13,8 +13,8 @@ class CScriptCounter : public CEntity {
public: public:
CScriptCounter(TUniqueId, std::string_view name, const CEntityInfo& info, s32, s32, bool, bool); CScriptCounter(TUniqueId, std::string_view name, const CEntityInfo& info, s32, s32, bool, bool);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
}; };
} // namespace urde } // namespace urde

12
Runtime/World/CScriptCoverPoint.hpp
View File

@ -32,12 +32,12 @@ public:
CScriptCoverPoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, zeus::CTransform xf, bool active, CScriptCoverPoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, zeus::CTransform xf, bool active,
u32 flags, bool crouch, float horizontalAngle, float verticalAngle, float coverTime); u32 flags, bool crouch, float horizontalAngle, float verticalAngle, float coverTime);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const {} void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override {}
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void SetInUse(bool inUse); void SetInUse(bool inUse);
bool GetInUse(TUniqueId uid) const; bool GetInUse(TUniqueId uid) const;
bool ShouldLandHere() const { return xe8_26_landHere; } bool ShouldLandHere() const { return xe8_26_landHere; }

20
Runtime/World/CScriptDamageableTrigger.hpp
View File

@ -45,16 +45,16 @@ public:
const CDamageVulnerability& dVuln, u32 faceFlag, CAssetId patternTex1, CAssetId patternTex2, const CDamageVulnerability& dVuln, u32 faceFlag, CAssetId patternTex1, CAssetId patternTex2,
CAssetId colorTex, ECanOrbit canOrbit, bool active, const CVisorParameters& vParams); CAssetId colorTex, ECanOrbit canOrbit, bool active, const CVisorParameters& vParams);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const; const CWeaponMode&, EProjectileAttrib) const override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const; void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
const CDamageVulnerability* GetDamageVulnerability() const { return &x174_dVuln; } const CDamageVulnerability* GetDamageVulnerability() const override { return &x174_dVuln; }
CHealthInfo* HealthInfo(CStateManager&) { return &x16c_hInfo; } CHealthInfo* HealthInfo(CStateManager&) override { return &x16c_hInfo; }
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
}; };
} // namespace urde } // namespace urde

18
Runtime/World/CScriptDebris.hpp
View File

@ -70,15 +70,15 @@ public:
const zeus::CVector3f& particle3Scale, EOrientationType particle3Or, bool solid, bool dieOnProjectile, const zeus::CVector3f& particle3Scale, EOrientationType particle3Or, bool solid, bool dieOnProjectile,
bool noBounce, bool active); bool noBounce, bool active);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const; void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void Touch(CActor& other, CStateManager& mgr); void Touch(CActor& other, CStateManager& mgr) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&); void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&) override;
}; };
} // namespace urde } // namespace urde

2
Runtime/World/CScriptDebugCameraWaypoint.hpp
View File

@ -11,7 +11,7 @@ public:
CScriptDebugCameraWaypoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, CScriptDebugCameraWaypoint(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
u32 w1); u32 w1);
void Accept(IVisitor&); void Accept(IVisitor&) override;
}; };
} // namespace urde } // namespace urde

4
Runtime/World/CScriptDistanceFog.hpp
View File

@ -21,7 +21,7 @@ public:
CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, ERglFogMode, const zeus::CColor&, CScriptDistanceFog(TUniqueId, std::string_view, const CEntityInfo&, ERglFogMode, const zeus::CColor&,
const zeus::CVector2f&, float, const zeus::CVector2f&, bool, bool, float, float, float, float); const zeus::CVector2f&, float, const zeus::CVector2f&, bool, bool, float, float, float, float);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
}; };
} // namespace urde } // namespace urde

10
Runtime/World/CScriptDock.hpp
View File

@ -26,11 +26,11 @@ public:
const zeus::CVector3f& extent, s32 dock, TAreaId area, bool active, s32 dockReferenceCount, const zeus::CVector3f& extent, s32 dock, TAreaId area, bool active, s32 dockReferenceCount,
bool loadConnected); bool loadConnected);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void CleanUp() {} void CleanUp() {}
zeus::CPlane GetPlane(const CStateManager&) const; zeus::CPlane GetPlane(const CStateManager&) const;
TAreaId GetAreaId() const { return x260_area; } TAreaId GetAreaId() const { return x260_area; }

4
Runtime/World/CScriptDockAreaChange.hpp
View File

@ -9,7 +9,7 @@ class CScriptDockAreaChange : public CEntity {
public: public:
CScriptDockAreaChange(TUniqueId, std::string_view, const CEntityInfo&, s32, bool); CScriptDockAreaChange(TUniqueId, std::string_view, const CEntityInfo&, s32, bool);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
}; };
} // namespace urde } // namespace urde

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