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

Refactor GuiSys (remove general logic handling)

This commit is contained in:
Jack Andersen 2016-12-15 12:37:34 -10:00
parent 6b765838a7
commit 19a371c931
54 changed files with 446 additions and 2642 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Runtime/GuiSys/CAuiEnergyBarT01.cpp
View File

@ -1,6 +1,4 @@
#include "CAuiEnergyBarT01.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{

7
Runtime/GuiSys/CAuiMeter.cpp
View File

@ -3,11 +3,4 @@
namespace urde
{
typedef bool(CAuiMeter::*FMAF)(CGuiFunctionDef* def, CGuiControllerInfo* info);
static std::unordered_map<u32, FMAF> WidgetFnMap;
void CAuiMeter::LoadWidgetFnMap()
{
}
}

1
Runtime/GuiSys/CAuiMeter.hpp
View File

@ -9,7 +9,6 @@ namespace urde
class CAuiMeter : public CGuiCompoundWidget
{
public:
static void LoadWidgetFnMap();
};
}

0
Runtime/GuiSys/CGuiAnimBase.cpp
View File

85
Runtime/GuiSys/CGuiAnimBase.hpp
View File

@ -1,85 +0,0 @@
#ifndef __URDE_CGUIANIMBASE_HPP__
#define __URDE_CGUIANIMBASE_HPP__
#include "RetroTypes.hpp"
#include "CGuiRandomVar.hpp"
namespace urde
{
class CGuiAnimController;
class CGuiWidgetDrawParams;
enum class EGuiAnimType
{
Rotation = 0,
Translation = 1,
Scaling = 2,
Shearing = 3,
Dissolve = 4,
Keyframe = 5,
Particles = 6,
SFX = 9
};
class CGuiAnimBase
{
friend class CGuiAnimSet;
float x4_ = 0.f;
float x8_ = 0.f;
float xc_;
CGuiRandomVar x10_randomVar;
float x1c_ = 0.f;
bool x20_isDone = false;
s32 x24_ = -1;
bool x28_;
public:
virtual ~CGuiAnimBase() = default;
CGuiAnimBase(float fval, const CGuiRandomVar& randVar, bool flag)
: xc_(fval), x10_randomVar(randVar), x28_(flag) {}
float GetFVal() const {return xc_;}
const CGuiRandomVar& GetRandomVar() const {return x10_randomVar;}
virtual void AnimInit(const CGuiAnimController* controller, float);
virtual void AnimUpdate(CGuiAnimController* controller, float dt);
virtual void AnimDraw(const CGuiWidgetDrawParams& params) const;
virtual void CalcInitVelocity(const CGuiAnimController* controller);
virtual void GetAnimType(const CGuiAnimController* controller) const;
virtual bool GetIsFinishedLoading() const {return true;}
};
class CGuiAnimRotation : public CGuiAnimBase
{
};
class CGuiAnimTranslation : public CGuiAnimBase
{
};
class CGuiAnimScaling : public CGuiAnimBase
{
};
class CGuiAnimShearing : public CGuiAnimBase
{
};
class CGuiAnimDissolve : public CGuiAnimBase
{
};
class CGuiAnimKeyframe : public CGuiAnimBase
{
};
class CGuiAnimParticles : public CGuiAnimBase
{
};
class CGuiAnimSFX : public CGuiAnimBase
{
};
}
#endif // __URDE_CGUIANIMBASE_HPP__

174
Runtime/GuiSys/CGuiAnimController.cpp
View File

@ -1,174 +0,0 @@
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiAnimBase.hpp"
#include "CGuiControllerInfo.hpp"
namespace urde
{
void CGuiAnimSet::AddAnim(CGuiAnimBase* anim)
{
x0_map[x20_++] = anim;
RecalcTotalTime();
}
void CGuiAnimSet::RecalcTotalTime()
{
x28_totalTime = 0.f;
for (std::pair<const int, CGuiAnimBase*>& anim : x0_map)
{
float num = anim.second->GetRandomVar().GenNum();
if (num < x28_totalTime)
num = x28_totalTime;
else
num += anim.second->GetFVal();
if (num > x28_totalTime)
x28_totalTime = num;
}
}
void CGuiAnimSet::Init(CGuiAnimController* controller, float fval)
{
x19_isDone = false;
x1c_ = false;
for (std::pair<const int, CGuiAnimBase*>& anim : x0_map)
{
x2c_ = 1.f;
anim.second->AnimInit(controller, fval);
}
}
void CGuiAnimSet::Update(CGuiAnimController* controller, bool flag)
{
x19_isDone = true;
for (std::pair<const int, CGuiAnimBase*>& anim : x0_map)
{
anim.second->AnimUpdate(controller, controller->x164_ * x2c_);
if (!anim.second->x20_isDone)
x19_isDone = false;
}
if (x19_isDone && !x1c_)
{
x1c_ = true;
CGuiFuncParm a(intptr_t(controller->x168_widget->GetSelfId()));
CGuiFuncParm b(intptr_t(int(x14_id) + 5));
CGuiFunctionDef fa(0, false, a, b);
CGuiControllerInfo cInfo;
controller->x168_widget->MAF_SendMessage(&fa, &cInfo);
if (x1b_)
controller->x168_widget->SetVisibility(false, ETraversalMode::Children);
}
if (x19_isDone && x1a_ && flag)
Init(controller, 0.f);
}
CGuiAnimController::CGuiAnimController(const CGuiWidget::CGuiWidgetParms& parms, CGuiWidget* widget)
: CGuiWidget(parms), x168_widget(widget)
{
}
CGuiAnimSet* CGuiAnimController::FindAnimSet(EGuiAnimBehListID id) const
{
if (id < EGuiAnimBehListID::Zero || id >= EGuiAnimBehListID::EGuiAnimBehListIDMAX)
return nullptr;
return xf8_sets[int(id)].get();
}
void CGuiAnimController::AddAnimation(CGuiAnimBase* anim, EGuiAnimBehListID id)
{
CGuiAnimSet* set = FindAnimSet(id);
if (!set)
{
xf8_sets[int(id)] = std::make_unique<CGuiAnimSet>(id);
set = xf8_sets[int(id)].get();
}
set->AddAnim(anim);
}
void CGuiAnimController::ResetListUpdateState()
{
for (std::unique_ptr<CGuiAnimSet>& set : xf8_sets)
set->x18_update = false;
}
void CGuiAnimController::SetListUpdateState(EGuiAnimBehListID id, bool state)
{
CGuiAnimSet* set = FindAnimSet(id);
if (set)
set->x18_update = false;
}
float CGuiAnimController::GetAnimSetLength(EGuiAnimBehListID id) const
{
CGuiAnimSet* set = FindAnimSet(id);
if (set)
return set->x28_totalTime;
return 0.f;
}
void CGuiAnimController::IsAnimsDone(EGuiAnimBehListID id, bool& isDone) const
{
CGuiAnimSet* set = FindAnimSet(id);
if (set)
isDone = set->x19_isDone;
else
isDone = true;
}
void CGuiAnimController::InitTransform(CGuiWidget* widget, EGuiAnimBehListID id, float fval,
bool flag, EGuiAnimInitMode initMode)
{
switch (initMode)
{
case EGuiAnimInitMode::One:
case EGuiAnimInitMode::Three:
FinishAnim();
default: break;
}
x80_transform = widget->GetTransform();
switch (initMode)
{
case EGuiAnimInitMode::Three:
case EGuiAnimInitMode::Two:
x16c_ = xb8_;
break;
case EGuiAnimInitMode::One:
x16c_ = zeus::CColor::skClear;
default: break;
}
if (flag)
ResetListUpdateState();
CGuiAnimSet* set = FindAnimSet(id);
if (set)
{
set->Init(this, fval);
set->x18_update = true;
}
Update(0.f);
}
void CGuiAnimController::FinishAnim()
{
float bup = x164_;
x164_ = 100000.f;
Step(false);
x164_ = bup;
}
void CGuiAnimController::Step(bool flag)
{
x170_ = 0;
for (std::unique_ptr<CGuiAnimSet>& set : xf8_sets)
if (set && set->x18_update)
set->Update(this, flag);
}
}

57
Runtime/GuiSys/CGuiAnimController.hpp
View File

@ -1,57 +0,0 @@
#ifndef __URDE_CGUIANIMCONTROLLER_HPP__
#define __URDE_CGUIANIMCONTROLLER_HPP__
#include "CGuiWidget.hpp"
#include <array>
namespace urde
{
class CGuiAnimSet
{
friend class CGuiAnimController;
std::unordered_map<int, CGuiAnimBase*> x0_map;
EGuiAnimBehListID x14_id;
bool x18_update = false;
bool x19_isDone = true;
bool x1a_ = false;
bool x1b_ = false;
bool x1c_ = false;
u32 x20_ = 0;
u32 x24_ = 0;
float x28_totalTime = 0.f;
float x2c_ = 1.f;
public:
CGuiAnimSet(EGuiAnimBehListID id) : x14_id(id) {}
void AddAnim(CGuiAnimBase* anim);
void RecalcTotalTime();
void Init(CGuiAnimController* controller, float fval);
void Update(CGuiAnimController* controller, bool flag);
};
class CGuiAnimController : public CGuiWidget
{
friend class CGuiAnimSet;
std::array<std::unique_ptr<CGuiAnimSet>, 13> xf8_sets;
float x164_ = 0.f;
CGuiWidget* x168_widget;
zeus::CColor x16c_ = zeus::CColor::skClear;
u32 x170_ = 0;
public:
CGuiAnimController(const CGuiWidget::CGuiWidgetParms& parms, CGuiWidget* widget);
CGuiAnimSet* FindAnimSet(EGuiAnimBehListID id) const;
void AddAnimation(CGuiAnimBase* anim, EGuiAnimBehListID id);
void ResetListUpdateState();
void SetListUpdateState(EGuiAnimBehListID id, bool state);
float GetAnimSetLength(EGuiAnimBehListID id) const;
void IsAnimsDone(EGuiAnimBehListID id, bool& isDone) const;
void InitTransform(CGuiWidget* widget, EGuiAnimBehListID id, float fval, bool flag,
EGuiAnimInitMode initMode);
void FinishAnim();
void Step(bool flag);
};
}
#endif // __URDE_CGUIANIMCONTROLLER_HPP__

30
Runtime/GuiSys/CGuiAutoRepeatData.cpp
View File

@ -1,30 +0,0 @@
#include "CGuiAutoRepeatData.hpp"
namespace urde
{
void CGuiAutoRepeatData::AddAutoEvent(int cIdx, CGuiPhysicalMsg::PhysicalMap& events, float eTime)
{
if (x28_pressed[cIdx])
{
if (x2c_defer[cIdx])
{
x2c_defer[cIdx] = false;
return;
}
if (eTime >= x8_nextDue[cIdx])
{
CGuiPhysicalMsg::AddControllerID(events, x0_instEvent, true);
x8_nextDue[cIdx] = x18_remainder[cIdx] + eTime;
x18_remainder[cIdx] -= 0.05;
if (x18_remainder[cIdx] < 0.05)
x18_remainder[cIdx] = 0.05;
}
if (CGuiPhysicalMsg::FindControllerID(events, x4_contEvent) ==
CGuiPhysicalMsg::EControllerState::NotPressed)
x28_pressed[cIdx] = false;
}
}
}

32
Runtime/GuiSys/CGuiAutoRepeatData.hpp
View File

@ -1,32 +0,0 @@
#ifndef __URDE_CGUIAUTOREPEATDATA_HPP__
#define __URDE_CGUIAUTOREPEATDATA_HPP__
#include "CGuiPhysicalMsg.hpp"
namespace urde
{
class CGuiAutoRepeatData
{
EPhysicalControllerID x0_instEvent;
EPhysicalControllerID x4_contEvent;
float x8_nextDue[4] = {0.f, 0.f, 0.f, 0.f};
float x18_remainder[4] = {0.2f, 0.2f, 0.2f, 0.2f};
bool x28_pressed[4] = {};
bool x2c_defer[4] = {};
public:
CGuiAutoRepeatData(EPhysicalControllerID inst, EPhysicalControllerID cont)
: x0_instEvent(inst), x4_contEvent(cont) {}
void SetActive(int cIdx, float eTime)
{
x8_nextDue[cIdx] = eTime + 0.6f;
x28_pressed[cIdx] = true;
x2c_defer[cIdx] = true;
x18_remainder[cIdx] = 0.2f;
}
void AddAutoEvent(int cIdx, CGuiPhysicalMsg::PhysicalMap& events, float eTime);
};
}
#endif // __URDE_CGUIAUTOREPEATDATA_HPP__

2
Runtime/GuiSys/CGuiBackground.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiBackground.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{

1
Runtime/GuiSys/CGuiCamera.cpp
View File

@ -1,6 +1,5 @@
#include "CGuiCamera.hpp"
#include "CGuiFrame.hpp"
#include "CGuiAnimController.hpp"
#include "Graphics/CGraphics.hpp"
namespace urde

34
Runtime/GuiSys/CGuiCompoundWidget.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiCompoundWidget.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{
@ -10,18 +8,7 @@ CGuiCompoundWidget::CGuiCompoundWidget(const CGuiWidgetParms& parms)
{
}
void CGuiCompoundWidget::OnInvisible()
{
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
while (child)
{
child->SetIsVisible(false);
child = static_cast<CGuiWidget*>(child->GetNextSibling());
}
CGuiWidget::OnInvisible();
}
void CGuiCompoundWidget::OnVisible()
void CGuiCompoundWidget::OnVisibleChange()
{
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
while (child)
@ -29,29 +16,18 @@ void CGuiCompoundWidget::OnVisible()
child->SetIsVisible(true);
child = static_cast<CGuiWidget*>(child->GetNextSibling());
}
CGuiWidget::OnVisible();
CGuiWidget::OnVisibleChange();
}
void CGuiCompoundWidget::OnDeActivate()
void CGuiCompoundWidget::OnActiveChange()
{
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
while (child)
{
child->SetIsActive(false, false);
child->SetIsActive(true);
child = static_cast<CGuiWidget*>(child->GetNextSibling());
}
CGuiWidget::OnDeActivate();
}
void CGuiCompoundWidget::OnActivate(bool flag)
{
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
while (child)
{
child->SetIsActive(true, flag);
child = static_cast<CGuiWidget*>(child->GetNextSibling());
}
CGuiWidget::OnDeActivate();
CGuiWidget::OnActiveChange();
}
CGuiWidget* CGuiCompoundWidget::GetWorkerWidget(int id)

6
Runtime/GuiSys/CGuiCompoundWidget.hpp
View File

@ -12,10 +12,8 @@ public:
CGuiCompoundWidget(const CGuiWidgetParms& parms);
FourCC GetWidgetTypeID() const {return FourCC(-1);}
void OnInvisible();
void OnVisible();
void OnDeActivate();
void OnActivate(bool);
void OnVisibleChange();
void OnActiveChange();
virtual CGuiWidget* GetWorkerWidget(int id);
};

23
Runtime/GuiSys/CGuiControllerInfo.hpp
View File

@ -1,23 +0,0 @@
#ifndef __URDE_CGUICONTROLLERINFO_HPP__
#define __URDE_CGUICONTROLLERINFO_HPP__
#include "RetroTypes.hpp"
namespace urde
{
struct CGuiControllerInfo
{
public:
struct CGuiControllerStateInfo
{
char cIdx = 0;
char lx = 0, ly = 0, rx = 0, ry = 0;
};
u32 x0_ = 0;
CGuiControllerStateInfo x4_stateInfo;
};
}
#endif // __URDE_CGUICONTROLLERINFO_HPP__

0
Runtime/GuiSys/CGuiFactories.cpp
View File

10
Runtime/GuiSys/CGuiFactories.hpp
View File

@ -1,10 +0,0 @@
#ifndef __URDE_CGUIFACTORIES_HPP__
#define __URDE_CGUIFACTORIES_HPP__
namespace urde
{
}
#endif // __URDE_CGUIFACTORIES_HPP__

531
Runtime/GuiSys/CGuiFrame.cpp
View File

@ -2,31 +2,29 @@
#include "CGuiWidget.hpp"
#include "CGuiSys.hpp"
#include "CGuiHeadWidget.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiMessage.hpp"
#include "CGuiLight.hpp"
#include "CGuiCamera.hpp"
#include "Graphics/CGraphics.hpp"
#include "Input/CFinalInput.hpp"
#include "zeus/CColor.hpp"
#include "CSimplePool.hpp"
namespace urde
{
CGuiFrame::CGuiFrame(ResId id, const std::string& name, CGuiSys& sys, int a, int b, int c)
: x4_name(name), x14_id(id), x1c_transitionOpts(EFrameTransitionOptions::Zero),
x3c_guiSys(sys), xb0_a(a), xb4_b(b), xb8_c(c), xbc_24_loaded(false)
CGuiFrame::CGuiFrame(ResId id, CGuiSys& sys, int a, int b, int c, CSimplePool* sp)
: x0_id(id), x8_guiSys(sys), x4c_a(a), x50_b(b), x54_c(c), x58_24_loaded(false)
{
xa0_lights.resize(8);
x48_rootWidget.reset(new CGuiWidget(
x3c_lights.resize(8);
x10_rootWidget.reset(new CGuiWidget(
CGuiWidget::CGuiWidgetParms(this, false, 0, 0, false, false, false, zeus::CColor::skWhite,
CGuiWidget::EGuiModelDrawFlags::Alpha, false,
x3c_guiSys.x2c_mode != CGuiSys::EUsageMode::Zero)));
x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero)));
}
CGuiWidget* CGuiFrame::FindWidget(const std::string& name) const
{
s16 id = x64_idDB.FindWidgetID(name);
s16 id = x18_idDB.FindWidgetID(name);
if (id == -1)
return nullptr;
return FindWidget(id);
@ -34,319 +32,12 @@ CGuiWidget* CGuiFrame::FindWidget(const std::string& name) const
CGuiWidget* CGuiFrame::FindWidget(s16 id) const
{
return x48_rootWidget->FindWidget(id);
}
void CGuiFrame::ResetControllerStatus()
{
x0_controllerStatus[0] = false;
x0_controllerStatus[1] = false;
x0_controllerStatus[2] = false;
x0_controllerStatus[3] = false;
}
void CGuiFrame::InterpretGUIControllerState(const CFinalInput& input,
CGuiPhysicalMsg::PhysicalMap& state,
char& lx, char& ly, char& rx, char& ry)
{
zeus::CVector2f left(std::fabs(input.ALeftX()), std::fabs(input.ALeftY()));
bool leftThreshold = false;
if (left.magnitude() >= 0.6f)
leftThreshold = true;
zeus::CVector2f right(std::fabs(input.ARightX()), std::fabs(input.ARightY()));
bool rightThreshold = false;
if (right.magnitude() >= 0.6f)
rightThreshold = true;
if (leftThreshold)
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickThreshold, false);
if (input.ALeftX() < 0.f)
lx = input.ALeftX() * 128.f;
else
lx = input.ALeftX() * 127.f;
if (input.ALeftY() < 0.f)
ly = input.ALeftY() * 128.f;
else
ly = input.ALeftY() * 127.f;
if (0.7f < input.ALeftY())
{
if (input.PLAUp())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickUpInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftUpInst, false);
}
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickUp, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftUp, false);
}
if (-0.7f > input.ALeftY())
{
if (input.PLADown())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickDownInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftDownInst, false);
}
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickDown, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftDown, false);
}
if (0.7f < input.ALeftX())
{
if (input.PLARight())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickRightInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftRightInst, false);
}
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickRight, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftRight, false);
}
if (-0.7f > input.ALeftX())
{
if (input.PLALeft())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickLeftInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftLeftInst, false);
}
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickLeft, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftLeft, false);
}
}
else
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftStickRelease, false);
lx = 0;
ly = 0;
}
if (rightThreshold)
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickThreshold, false);
if (input.ARightX() < 0.f)
rx = input.ARightX() * 128.f;
else
rx = input.ARightX() * 127.f;
if (input.ARightY() < 0.f)
ry = input.ARightY() * 128.f;
else
ry = input.ARightY() * 127.f;
if (0.7f < input.ARightY())
{
if (input.PRAUp())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickUpInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickUp, false);
}
if (-0.7f > input.ARightY())
{
if (input.PRADown())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickDownInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickDown, false);
}
if (0.7f < input.ARightX())
{
if (input.PRARight())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickRightInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickRight, false);
}
if (-0.7f > input.ARightX())
{
if (input.PRALeft())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickLeftInst, false);
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickLeft, false);
}
}
else
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RightStickRelease, false);
rx = 0;
ry = 0;
}
if (input.PDPUp())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadUpInst, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftUpInst, false);
}
else if (input.DDPUp())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadUp, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftUp, false);
}
if (input.PDPDown())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadDownInst, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftDownInst, false);
}
else if (input.DDPDown())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadDown, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftDown, false);
}
if (input.PDPRight())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadRightInst, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftRightInst, false);
}
else if (input.DDPRight())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadRight, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftRight, false);
}
if (input.PDPLeft())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadLeftInst, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftLeftInst, false);
}
else if (input.DDPLeft())
{
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::DPadLeft, false);
if (leftThreshold)
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LeftLeft, false);
}
if (input.PStart())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::StartInst, false);
if (input.DStart())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::Start, false);
if (input.PB())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::BInst, false);
if (input.DB())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::B, false);
if (input.PA())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::AInst, false);
if (input.DA())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::A, false);
if (input.PX())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::XInst, false);
if (input.DX())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::X, false);
if (input.PY())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::YInst, false);
if (input.DY())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::Y, false);
if (input.PZ())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::ZInst, false);
if (input.DZ())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::Z, false);
if (input.PLTrigger())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::LInst, false);
if (input.DLTrigger())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::L, false);
if (input.PRTrigger())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::RInst, false);
if (input.DRTrigger())
CGuiPhysicalMsg::AddControllerID(state, EPhysicalControllerID::R, false);
}
CGuiFrame::WidgetToLogicalEventMap* CGuiFrame::FindWidget2LogicalEventMap(u64 events)
{
auto search = x7c_messageMap.find(events);
if (search == x7c_messageMap.cend())
return nullptr;
return search->second.get();
}
CGuiFrame::LogicalEventList* CGuiFrame::FindLogicalEventList(u64 events, s16 id)
{
CGuiFrame::WidgetToLogicalEventMap* map = FindWidget2LogicalEventMap(events);
if (!map)
return nullptr;
auto search = map->find(id);
if (search == map->cend())
return nullptr;
return search->second.get();
}
bool CGuiFrame::SendWidgetMessage(s16 id,
std::list<std::unique_ptr<CGuiFrameMessageMapNode>>& list,
CGuiPhysicalMsg::PhysicalMap& state,
CGuiControllerInfo::CGuiControllerStateInfo& csInfo)
{
CGuiWidget* widget = FindWidget(id);
for (std::unique_ptr<CGuiFrameMessageMapNode>& node : list)
{
CGuiMessage msg(CGuiMessage::Type(node->GetTrigger().GetTriggerId()),
reinterpret_cast<intptr_t>(&state),
reinterpret_cast<intptr_t>(&csInfo));
if (!widget->Message(msg))
return false;
}
return true;
}
void CGuiFrame::ClearAllMessageMap()
{
x7c_messageMap.clear();
}
void CGuiFrame::ClearMessageMap(const CGuiLogicalEventTrigger* trigger, s16 id)
{
CGuiFrame::LogicalEventList* list =
FindLogicalEventList(trigger->GetPhysicalMsg().x0_curStates, id);
if (list)
list->clear();
}
void CGuiFrame::AddMessageMap(const CGuiLogicalEventTrigger* trigger, s16 id)
{
u64 events = trigger->GetPhysicalMsg().x0_curStates;
int triggerId = trigger->GetTriggerId();
CGuiFrame::WidgetToLogicalEventMap* map = FindWidget2LogicalEventMap(events);
if (!map)
{
auto it =
x7c_messageMap.emplace(std::make_pair(events, std::make_unique<WidgetToLogicalEventMap>()));
map = it.first->second.get();
}
CGuiFrame::LogicalEventList* list = FindLogicalEventList(events, id);
if (!list)
{
auto it =
map->emplace(std::make_pair(id, std::make_unique<LogicalEventList>()));
list = it.first->second.get();
}
for (std::unique_ptr<CGuiFrameMessageMapNode>& node : *list)
if (node->GetTrigger().GetTriggerId() == triggerId)
return;
list->push_back(std::make_unique<CGuiFrameMessageMapNode>(trigger->GetPhysicalMsg(), triggerId));
return x10_rootWidget->FindWidget(id);
}
void CGuiFrame::SortDrawOrder()
{
std::sort(x90_widgets.begin(), x90_widgets.end(),
std::sort(x2c_widgets.begin(), x2c_widgets.end(),
[](const CGuiWidget* a, const CGuiWidget* b) -> bool
{
return a->GetWorldPosition().y < b->GetWorldPosition().y;
@ -359,7 +50,7 @@ void CGuiFrame::EnableLights(u32 lights) const
zeus::CColor accumColor(zeus::CColor::skBlack);
ERglLight lightId = ERglLight::Zero;
int idx = 0;
for (CGuiLight* light : xa0_lights)
for (CGuiLight* light : x3c_lights)
{
if ((lights & (1 << idx)) != 0)
{
@ -371,7 +62,7 @@ void CGuiFrame::EnableLights(u32 lights) const
++reinterpret_cast<std::underlying_type_t<ERglLight>&>(lightId);
++idx;
}
if (xa0_lights.empty())
if (x3c_lights.empty())
CGraphics::SetAmbientColor(zeus::CColor::skWhite);
else
CGraphics::SetAmbientColor(accumColor);
@ -384,223 +75,69 @@ void CGuiFrame::DisableLights() const
void CGuiFrame::RemoveLight(CGuiLight* light)
{
xa0_lights[light->GetLoadedIdx()] = nullptr;
x3c_lights[light->GetLoadedIdx()] = nullptr;
}
void CGuiFrame::AddLight(CGuiLight* light)
{
xa0_lights[light->GetLoadedIdx()] = light;
x3c_lights[light->GetLoadedIdx()] = light;
}
bool CGuiFrame::GetIsFinishedLoading() const
{
if (xbc_24_loaded)
if (x58_24_loaded)
return true;
for (const CGuiWidget* widget : x90_widgets)
for (const CGuiWidget* widget : x2c_widgets)
{
if (widget->GetIsFinishedLoading())
continue;
return false;
}
const_cast<CGuiFrame*>(this)->xbc_24_loaded = true;
const_cast<CGuiFrame*>(this)->x58_24_loaded = true;
return true;
}
void CGuiFrame::Touch() const
{
for (const CGuiWidget* widget : x90_widgets)
for (const CGuiWidget* widget : x2c_widgets)
widget->Touch();
}
void CGuiFrame::ProcessControllerInput(const CFinalInput& input)
void CGuiFrame::Update(float dt)
{
if (x18_ & 0x4 && input.ControllerIdx() == 0)
{
CGuiPhysicalMsg::PhysicalMap state;
CGuiControllerInfo::CGuiControllerStateInfo stateInfo;
stateInfo.cIdx = input.ControllerIdx();
InterpretGUIControllerState(input, state, stateInfo.lx, stateInfo.ly, stateInfo.rx, stateInfo.ry);
float eventTime = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::steady_clock::now() - x3c_guiSys.x40_constructTime).count() / 1000000.f;
for (const std::pair<EPhysicalControllerID, CGuiPhysicalMsg::CPhysicalID>& newPair : state)
{
auto search = x3c_guiSys.GetRepeatMap().find(newPair.first);
if (search != x3c_guiSys.GetRepeatMap().end())
search->second.SetActive(input.ControllerIdx(), eventTime);
}
for (std::pair<const EPhysicalControllerID, CGuiAutoRepeatData>& pair : x3c_guiSys.GetRepeatMap())
{
pair.second.AddAutoEvent(input.ControllerIdx(), state, eventTime);
}
CGuiPhysicalMsg msg(state);
SetControllerStatus(input.ControllerIdx(), true);
for (std::pair<const u64, std::unique_ptr<WidgetToLogicalEventMap>>& outer : x7c_messageMap)
{
if (outer.second)
{
for (std::pair<const s16, std::unique_ptr<LogicalEventList>>& inner : *outer.second)
{
if (inner.second && inner.second->size())
{
LogicalEventList& list = *inner.second;
if (msg.Exists(list.back()->GetTrigger().GetPhysicalMsg()))
if (!SendWidgetMessage(inner.first, list, state, stateInfo))
break;
}
}
}
}
}
}
bool CGuiFrame::Update(float dt)
{
if (x34_ != EFrameStates::Four)
return false;
if (x18_ & 2)
{
EGuiAnimBehListID listId = EGuiAnimBehListID::NegOne;
bool something = true;
x44_headWidget->InitializeRGBAFactor();
x44_headWidget->Update(dt);
x44_headWidget->RecalculateAllRGBA();
switch (x34_)
{
case EFrameStates::One:
if (!xbd_flag2)
{
CGuiControllerInfo cInfo;
x44_headWidget->BroadcastMessage(0, &cInfo);
xbd_flag2 = true;
}
break;
case EFrameStates::Three:
listId = EGuiAnimBehListID::One;
break;
default:
break;
}
if (listId != EGuiAnimBehListID::NegOne)
x44_headWidget->IsAllAnimsDone(listId, something, ETraversalMode::ChildrenAndSiblings);
if (something)
{
switch (x34_)
{
case EFrameStates::One:
{
x34_ = x38_;
x44_headWidget->SetAnimUpdateState(EGuiAnimBehListID::Zero, false, ETraversalMode::Single);
x44_headWidget->InitializeAnimControllers(EGuiAnimBehListID::Two, 0.f, false,
EGuiAnimInitMode::Five, ETraversalMode::Single);
CGuiWidget* camSib = static_cast<CGuiWidget*>(x4c_camera->GetNextSibling());
if (camSib)
{
camSib->SetAnimUpdateState(EGuiAnimBehListID::Zero, false, ETraversalMode::ChildrenAndSiblings);
camSib->InitializeAnimControllers(EGuiAnimBehListID::Two, 0.f, false,
EGuiAnimInitMode::Five, ETraversalMode::ChildrenAndSiblings);
}
xbd_flag2 = false;
break;
}
case EFrameStates::Three:
{
CGuiControllerInfo cInfo;
x44_headWidget->BroadcastMessage(1, &cInfo);
ClearAllMessageMap();
x18_ &= ~0x3;
x44_headWidget->ResetAllAnimUpdateState();
xbd_flag2 = false;
break;
}
default:
break;
}
}
return x34_ != EFrameStates::Zero;
}
return false;
xc_headWidget->Update(dt);
}
void CGuiFrame::Draw(const CGuiWidgetDrawParms& parms) const
{
if (x18_)
if (x4_)
{
CGraphics::SetCullMode(ERglCullMode::None);
CGraphics::SetAmbientColor(zeus::CColor::skWhite);
DisableLights();
x4c_camera->Draw(parms);
x14_camera->Draw(parms);
// Set one-stage modulate
CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha,
ERglBlendFactor::InvSrcAlpha, ERglLogicOp::Clear);
if (x50_background)
x50_background->Draw(parms);
for (const CGuiWidget* widget : x90_widgets)
for (const CGuiWidget* widget : x2c_widgets)
if (widget->GetIsVisible())
widget->Draw(parms);
}
CGraphics::SetCullMode(ERglCullMode::Front);
}
void CGuiFrame::Stop(const CGuiFrameTransitionOptions& transOpts, EFrameStates states, bool flag)
{
x18_ &= 0xFFFFFFFB;
x38_ = states;
if (flag)
x34_ = x38_;
else
{
x44_headWidget->InitializeAnimControllers(EGuiAnimBehListID::One, transOpts.xc_, true,
EGuiAnimInitMode::Two, ETraversalMode::Single);
CGuiWidget* camSib = static_cast<CGuiWidget*>(x4c_camera->GetNextSibling());
if (camSib)
{
camSib->InitializeAnimControllers(EGuiAnimBehListID::One, transOpts.xc_, true,
EGuiAnimInitMode::Two, ETraversalMode::ChildrenAndSiblings);
}
}
}
void CGuiFrame::Run(CGuiFrame* frame, const CGuiFrameTransitionOptions& transOpts,
EFrameStates states, bool flag)
{
ResetControllerStatus();
x34_ = EFrameStates::One;
x38_ = EFrameStates::Two;
float len = 0.f;
x4c_camera->GetBranchAnimLen(EGuiAnimBehListID::Zero, len, ETraversalMode::Single);
len += transOpts.xc_ + transOpts.x10_ + transOpts.x14_;
x44_headWidget->InitializeAnimControllers(EGuiAnimBehListID::Zero, len, true,
EGuiAnimInitMode::One, ETraversalMode::Single);
CGuiWidget* camSib = static_cast<CGuiWidget*>(x4c_camera->GetNextSibling());
if (camSib)
{
camSib->InitializeAnimControllers(EGuiAnimBehListID::Zero, len, true,
EGuiAnimInitMode::One, ETraversalMode::ChildrenAndSiblings);
}
x18_ |= 0x7;
x44_headWidget->RegisterEventHandler(ETraversalMode::ChildrenAndSiblings);
}
void CGuiFrame::Initialize()
{
SortDrawOrder();
x44_headWidget->SetColor(x44_headWidget->xbc_color);
x44_headWidget->InitializeRecursive();
xc_headWidget->SetColor(xc_headWidget->xa4_color);
xc_headWidget->InitializeRecursive();
}
void CGuiFrame::LoadWidgetsInGame(CInputStream& in)
{
u32 count = in.readUint32Big();
x90_widgets.reserve(count);
x2c_widgets.reserve(count);
for (u32 i=0 ; i<count ; ++i)
{
FourCC type = in.readUint32Big();
@ -613,39 +150,33 @@ void CGuiFrame::LoadWidgetsInGame(CInputStream& in)
case SBIG('BGND'):
break;
default:
x90_widgets.push_back(widget);
x2c_widgets.push_back(widget);
break;
}
}
Initialize();
}
CGuiFrame* CGuiFrame::CreateFrame(ResId frmeId, CGuiSys& sys, CInputStream& in)
CGuiFrame* CGuiFrame::CreateFrame(ResId frmeId, CGuiSys& sys, CInputStream& in, CSimplePool* sp)
{
std::string name = CreateFrameName(frmeId);
in.readInt32Big();
int a = in.readInt32Big();
int b = in.readInt32Big();
int c = in.readInt32Big();
CGuiFrame* ret = new CGuiFrame(frmeId, name, sys, a, b, c);
CGuiFrame* ret = new CGuiFrame(frmeId, sys, a, b, c, sp);
ret->LoadWidgetsInGame(in);
return ret;
}
std::unique_ptr<IObj> RGuiFrameFactoryInGame(const SObjectTag& tag, CInputStream& in,
const CVParamTransfer&,
const CVParamTransfer& cvParms,
CObjectReference* selfRef)
{
std::unique_ptr<CGuiFrame> frame(CGuiFrame::CreateFrame(tag.id, *g_GuiSys, in));
CSimplePool* sp = static_cast<CSimplePool*>(static_cast<TObjOwnerParam<IObjectStore*>*>(cvParms.GetObj())->GetParam());
std::unique_ptr<CGuiFrame> frame(CGuiFrame::CreateFrame(tag.id, *g_GuiSys, in, sp));
return TToken<CGuiFrame>::GetIObjObjectFor(std::move(frame));
}
std::string CGuiFrame::CreateFrameName(ResId frmeId)
{
/* formatting token originally "frame_%x" for 32-bit ids */
return hecl::Format("frame_%016" PRIX64, frmeId);
}
}

116
Runtime/GuiSys/CGuiFrame.hpp
View File

@ -2,10 +2,6 @@
#define __URDE_CGUIFRAME_HPP__
#include "CGuiWidget.hpp"
#include "CGuiAutoRepeatData.hpp"
#include "CGuiPhysicalMsg.hpp"
#include "CGuiControllerInfo.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiWidgetIdDB.hpp"
#include "IObj.hpp"
@ -19,99 +15,35 @@ class CFinalInput;
class CGuiLight;
class CVParamTransfer;
class CObjectReference;
enum class EFrameTransitionOptions
{
Zero
};
struct CGuiFrameTransitionOptions
{
EFrameTransitionOptions x0_opts;
bool x4_ = true;
float x8_ = 1.f;
float xc_ = 0.f;
float x10_ = 0.f;
float x14_ = 0.f;
public:
CGuiFrameTransitionOptions(EFrameTransitionOptions opts)
: x0_opts(opts) {}
};
class CGuiFrameMessageMapNode
{
CGuiLogicalEventTrigger x0_trigger;
public:
CGuiFrameMessageMapNode(const CGuiPhysicalMsg& msg, int val)
: x0_trigger(msg, val, false) {}
const CGuiLogicalEventTrigger& GetTrigger() const {return x0_trigger;}
};
class CSimplePool;
class CGuiFrame
{
public:
enum class EFrameStates
{
Zero = 0,
One = 1,
Two = 2,
Three = 3,
Four = 4
};
private:
bool x0_controllerStatus[4] = {};
std::string x4_name;
ResId x14_id;
u32 x18_ = 0;
CGuiFrameTransitionOptions x1c_transitionOpts;
EFrameStates x34_ = EFrameStates::Zero;
EFrameStates x38_ = EFrameStates::Zero;
CGuiSys& x3c_guiSys;
u32 x40_ = 0;
CGuiHeadWidget* x44_headWidget = nullptr;
std::unique_ptr<CGuiWidget> x48_rootWidget;
CGuiCamera* x4c_camera = nullptr;
CGuiWidget* x50_background = nullptr;
zeus::CQuaternion x54_;
CGuiWidgetIdDB x64_idDB;
using LogicalEventList = std::list<std::unique_ptr<CGuiFrameMessageMapNode>>;
using WidgetToLogicalEventMap =
std::unordered_map<s16, std::unique_ptr<LogicalEventList>>;
std::unordered_map<u64, std::unique_ptr<WidgetToLogicalEventMap>> x7c_messageMap;
std::vector<CGuiWidget*> x90_widgets;
std::vector<CGuiLight*> xa0_lights;
int xb0_a;
int xb4_b;
int xb8_c;
bool xbc_24_loaded : 1;
bool xbd_flag2 = false;
static void InterpretGUIControllerState(const CFinalInput& input,
CGuiPhysicalMsg::PhysicalMap& state,
char& lx, char& ly, char& rx, char& ry);
ResId x0_id;
u32 x4_ = 0;
CGuiSys& x8_guiSys;
CGuiHeadWidget* xc_headWidget = nullptr;
std::unique_ptr<CGuiWidget> x10_rootWidget;
CGuiCamera* x14_camera = nullptr;
CGuiWidgetIdDB x18_idDB;
std::vector<CGuiWidget*> x2c_widgets;
std::vector<CGuiLight*> x3c_lights;
int x4c_a;
int x50_b;
int x54_c;
bool x58_24_loaded : 1;
public:
CGuiFrame(ResId id, const std::string& name, CGuiSys& sys, int a, int b, int c);
CGuiFrame(ResId id, CGuiSys& sys, int a, int b, int c, CSimplePool* sp);
CGuiSys& GetGuiSys() {return x3c_guiSys;}
CGuiSys& GetGuiSys() {return x8_guiSys;}
CGuiLight* GetFrameLight(int idx) {return xa0_lights[idx];}
CGuiLight* GetFrameLight(int idx) {return x3c_lights[idx];}
CGuiWidget* FindWidget(const std::string& name) const;
CGuiWidget* FindWidget(s16 id) const;
void ResetControllerStatus();
void SetControllerStatus(int idx, bool set) {x0_controllerStatus[idx] = set;}
void SetFrameBackground(CGuiWidget* bg) {x50_background = bg;}
void SetFrameCamera(CGuiCamera* camr) {x4c_camera = camr;}
void SetHeadWidget(CGuiHeadWidget* hwig) {x44_headWidget = hwig;}
WidgetToLogicalEventMap* FindWidget2LogicalEventMap(u64 events);
LogicalEventList* FindLogicalEventList(u64 events, s16 id);
bool SendWidgetMessage(s16,
std::list<std::unique_ptr<CGuiFrameMessageMapNode>>&,
CGuiPhysicalMsg::PhysicalMap& state,
CGuiControllerInfo::CGuiControllerStateInfo& csInfo);
void ClearAllMessageMap();
void ClearMessageMap(const CGuiLogicalEventTrigger* trigger, s16 id);
void AddMessageMap(const CGuiLogicalEventTrigger* trigger, s16 id);
void SetFrameCamera(CGuiCamera* camr) {x14_camera = camr;}
void SetHeadWidget(CGuiHeadWidget* hwig) {xc_headWidget = hwig;}
void SortDrawOrder();
void EnableLights(u32 lights) const;
void DisableLights() const;
@ -119,19 +51,15 @@ public:
void AddLight(CGuiLight* light);
bool GetIsFinishedLoading() const;
void Touch() const;
void ProcessControllerInput(const CFinalInput& input);
bool Update(float dt);
void Update(float dt);
void Draw(const CGuiWidgetDrawParms& parms) const;
void Stop(const CGuiFrameTransitionOptions&, EFrameStates, bool);
void Run(CGuiFrame*, const CGuiFrameTransitionOptions&, EFrameStates, bool);
void Initialize();
void LoadWidgetsInGame(CInputStream& in);
CGuiWidgetIdDB& GetWidgetIdDB() {return x64_idDB;}
CGuiWidgetIdDB& GetWidgetIdDB() {return x18_idDB;}
static CGuiFrame* CreateFrame(ResId frmeId, CGuiSys& sys, CInputStream& in);
static std::string CreateFrameName(ResId frmeId);
static CGuiFrame* CreateFrame(ResId frmeId, CGuiSys& sys, CInputStream& in, CSimplePool* sp);
};
std::unique_ptr<IObj> RGuiFrameFactoryInGame(const SObjectTag& tag, CInputStream& in,

0
Runtime/GuiSys/CGuiFuncParm.cpp
View File

44
Runtime/GuiSys/CGuiFuncParm.hpp
View File

@ -1,44 +0,0 @@
#ifndef __URDE_CGUIFUNCPARM_HPP__
#define __URDE_CGUIFUNCPARM_HPP__
#include "RetroTypes.hpp"
namespace urde
{
class CGuiFuncParm
{
friend class CGuiMessage;
public:
enum class Type
{
Null = -1,
Int = 0,
Float = 1,
IntrusivePointer = 2
};
private:
Type x0_type = Type::Null;
union
{
intptr_t x4_int;
float x4_float;
void* x4_ptr = nullptr;
};
public:
CGuiFuncParm() = default;
CGuiFuncParm(intptr_t arg) : x0_type(Type::Int), x4_int(arg) {}
CGuiFuncParm(float arg) : x0_type(Type::Float), x4_float(arg) {}
CGuiFuncParm(void* arg) : x0_type(Type::IntrusivePointer), x4_ptr(arg) {}
~CGuiFuncParm()
{
if (x0_type == Type::IntrusivePointer)
delete static_cast<u8*>(x4_ptr);
}
};
}
#endif // __URDE_CGUIFUNCPARM_HPP__

30
Runtime/GuiSys/CGuiFunctionDef.cpp
View File

@ -1,30 +0,0 @@
#include "CGuiFunctionDef.hpp"
namespace urde
{
CGuiFunctionDef::CGuiFunctionDef(int funcId, bool flag,
const CGuiFuncParm& a, const CGuiFuncParm& b,
const CGuiFuncParm& c, const CGuiFuncParm& d)
: x0_funcId(funcId), x4_parmCount(4), x48_flag(flag)
{
x8_parms[0] = a;
x8_parms[1] = b;
x8_parms[2] = c;
x8_parms[3] = d;
}
CGuiFunctionDef::CGuiFunctionDef(int funcId, bool flag,
const CGuiFuncParm& a, const CGuiFuncParm& b)
: x0_funcId(funcId), x4_parmCount(2), x48_flag(flag)
{
x8_parms[0] = a;
x8_parms[1] = b;
}
CGuiFunctionDef::CGuiFunctionDef(int funcId, bool flag)
: x0_funcId(funcId), x48_flag(flag)
{
}
}

32
Runtime/GuiSys/CGuiFunctionDef.hpp
View File

@ -1,32 +0,0 @@
#ifndef __URDE_CGUIFUNCTIONDEF_HPP__
#define __URDE_CGUIFUNCTIONDEF_HPP__
#include "CGuiFuncParm.hpp"
#include <array>
namespace urde
{
class CGuiFunctionDef
{
int x0_funcId;
unsigned x4_parmCount = 0;
std::array<CGuiFuncParm, 8> x8_parms;
bool x48_flag;
public:
const CGuiFuncParm& GetParm(int parm)
{
return x8_parms[parm];
}
CGuiFunctionDef(int funcId, bool,
const CGuiFuncParm& a, const CGuiFuncParm& b,
const CGuiFuncParm& c, const CGuiFuncParm& d);
CGuiFunctionDef(int funcId, bool,
const CGuiFuncParm& a, const CGuiFuncParm& b);
CGuiFunctionDef(int funcId, bool);
};
}
#endif // __URDE_CGUIFUNCTIONDEF_HPP__

42
Runtime/GuiSys/CGuiGroup.cpp
View File

@ -1,7 +1,4 @@
#include "CGuiGroup.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiControllerInfo.hpp"
namespace urde
{
@ -25,8 +22,8 @@ void CGuiGroup::SelectWorkerWidget(int workerId, bool setActive, bool setVisible
CGuiWidget* sel = GetSelectedWidget();
if (setActive)
{
sel->SetIsActive(false, false);
child->SetIsActive(true, false);
sel->SetIsActive(false);
child->SetIsActive(true);
}
if (setVisible)
{
@ -50,42 +47,11 @@ bool CGuiGroup::AddWorkerWidget(CGuiWidget* worker)
return true;
}
void CGuiGroup::OnDeActivate()
void CGuiGroup::OnActiveChange()
{
CGuiWidget* sel = GetSelectedWidget();
if (sel)
sel->SetIsActive(false, true);
}
void CGuiGroup::OnActivate(bool flag)
{
CGuiWidget* sel = GetSelectedWidget();
if (sel)
sel->SetIsActive(true, flag);
}
bool CGuiGroup::DoUnregisterEventHandler()
{
CGuiWidget::DoUnregisterEventHandler();
GetSelectedWidget()->UnregisterEventHandler(ETraversalMode::Children);
return true;
}
bool CGuiGroup::DoRegisterEventHandler()
{
CGuiWidget::DoRegisterEventHandler();
CGuiWidget* sel = GetSelectedWidget();
if (GetIsActive() && sel)
{
CGuiFuncParm a((intptr_t(sel->GetSelfId())));
CGuiFuncParm b((intptr_t(3)));
CGuiFunctionDef def(0, false, a, b);
CGuiControllerInfo cInfo;
MAF_SendMessage(&def, &cInfo);
}
if (sel)
sel->RegisterEventHandler(ETraversalMode::Children);
return true;
sel->SetIsActive(true);
}
CGuiGroup* CGuiGroup::Create(CGuiFrame* frame, CInputStream& in, bool flag)

5
Runtime/GuiSys/CGuiGroup.hpp
View File

@ -18,10 +18,7 @@ public:
void SelectWorkerWidget(int workerId, bool setActive, bool setVisible);
CGuiWidget* GetSelectedWidget();
bool AddWorkerWidget(CGuiWidget* worker);
void OnDeActivate();
void OnActivate(bool flag);
bool DoUnregisterEventHandler();
bool DoRegisterEventHandler();
void OnActiveChange();
static CGuiGroup* Create(CGuiFrame* frame, CInputStream& in, bool flag);
static void LoadWidgetFnMap();

1
Runtime/GuiSys/CGuiHeadWidget.cpp
View File

@ -1,6 +1,5 @@
#include "CGuiHeadWidget.hpp"
#include "CGuiFrame.hpp"
#include "CGuiAnimController.hpp"
namespace urde
{

14
Runtime/GuiSys/CGuiLight.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiLight.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiFrame.hpp"
namespace urde
@ -21,7 +19,7 @@ CGuiLight::CGuiLight(const CGuiWidgetParms& parms, const CLight& light)
CGuiLight::~CGuiLight()
{
xc8_frame->RemoveLight(this);
xb0_frame->RemoveLight(this);
}
CLight CGuiLight::BuildLight() const
@ -31,13 +29,13 @@ CLight CGuiLight::BuildLight() const
switch (xf8_type)
{
case ELightType::Spot:
ret = CLight::BuildSpot(GetWorldPosition(), x34_worldXF.basis[1], xbc_color, xfc_spotCutoff);
ret = CLight::BuildSpot(GetWorldPosition(), x34_worldXF.basis[1], xa4_color, xfc_spotCutoff);
break;
case ELightType::Point:
ret = CLight::BuildPoint(GetWorldPosition(), xbc_color);
ret = CLight::BuildPoint(GetWorldPosition(), xa4_color);
break;
case ELightType::Directional:
ret = CLight::BuildDirectional(x34_worldXF.basis[1], xbc_color);
ret = CLight::BuildDirectional(x34_worldXF.basis[1], xa4_color);
break;
default: break;
}
@ -50,9 +48,9 @@ CLight CGuiLight::BuildLight() const
void CGuiLight::SetIsVisible(bool vis)
{
if (vis)
xc8_frame->AddLight(this);
xb0_frame->AddLight(this);
else
xc8_frame->RemoveLight(this);
xb0_frame->RemoveLight(this);
CGuiWidget::SetIsVisible(vis);
}

0
Runtime/GuiSys/CGuiLogicalEventTrigger.cpp
View File

23
Runtime/GuiSys/CGuiLogicalEventTrigger.hpp
View File

@ -1,23 +0,0 @@
#ifndef __URDE_CGUILOGICALEVENTTRIGGER_HPP__
#define __URDE_CGUILOGICALEVENTTRIGGER_HPP__
#include "CGuiPhysicalMsg.hpp"
namespace urde
{
class CGuiLogicalEventTrigger
{
CGuiPhysicalMsg x0_msg;
int x10_triggerId;
bool x14_flag;
public:
CGuiLogicalEventTrigger(const CGuiPhysicalMsg& msg, int val, bool flag)
: x0_msg(msg), x10_triggerId(val), x14_flag(flag) {}
const CGuiPhysicalMsg& GetPhysicalMsg() const {return x0_msg;}
int GetTriggerId() const {return x10_triggerId;}
};
}
#endif // __URDE_CGUILOGICALEVENTTRIGGER_HPP__

0
Runtime/GuiSys/CGuiMessage.cpp
View File

38
Runtime/GuiSys/CGuiMessage.hpp
View File

@ -1,38 +0,0 @@
#ifndef __URDE_CGUIMESSAGE_HPP__
#define __URDE_CGUIMESSAGE_HPP__
#include "RetroTypes.hpp"
#include "CGuiFuncParm.hpp"
namespace urde
{
class CGuiMessage
{
public:
enum class Type
{
Eighteen = 18,
Nineteen = 19
};
private:
Type x4_type;
CGuiFuncParm x8_a;
CGuiFuncParm x10_b;
public:
CGuiMessage(Type type, intptr_t a, intptr_t b)
: x4_type(type), x8_a(a), x10_b(b) {}
Type GetType() const {return x4_type;}
intptr_t GetInt(u32 val) const
{
if (val == 0x60EF4DB0)
return x8_a.x4_int;
else
return x10_b.x4_int;
}
};
}
#endif // __URDE_CGUIMESSAGE_HPP__

21
Runtime/GuiSys/CGuiModel.cpp
View File

@ -2,7 +2,6 @@
#include "CGuiFrame.hpp"
#include "CGuiSys.hpp"
#include "CSimplePool.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiWidgetDrawParms.hpp"
#include "Graphics/CGraphics.hpp"
@ -55,13 +54,13 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const
if (GetIsVisible())
{
zeus::CColor moduCol = xb4_;
zeus::CColor moduCol = xa8_color2;
moduCol.a *= parms.x0_alphaMod;
xc8_frame->EnableLights(x10c_lightMask);
if (xf6_29_cullFaces)
xb0_frame->EnableLights(x10c_lightMask);
if (xb6_29_cullFaces)
CGraphics::SetCullMode(ERglCullMode::Front);
switch (xc4_drawFlags)
switch (xac_drawFlags)
{
case EGuiModelDrawFlags::Shadeless:
{
@ -77,24 +76,24 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const
}
case EGuiModelDrawFlags::Alpha:
{
CModelFlags flags(4, 0, (xf7_24_depthWrite << 1) | xf6_31_depthTest, moduCol);
CModelFlags flags(4, 0, (xb7_24_depthWrite << 1) | xb6_31_depthTest, moduCol);
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::Additive:
{
CModelFlags flags(3, 0, (xf7_24_depthWrite << 1) | xf6_31_depthTest, moduCol);
CModelFlags flags(3, 0, (xb7_24_depthWrite << 1) | xb6_31_depthTest, moduCol);
model->Draw(flags);
break;
}
case EGuiModelDrawFlags::AlphaAdditiveOverdraw:
{
CModelFlags flags(4, 0, xf6_31_depthTest, moduCol);
CModelFlags flags(4, 0, xb6_31_depthTest, moduCol);
model->Draw(flags);
flags.m_blendMode = 5;
flags.m_matSetIdx = 0;
flags.m_flags = (xf7_24_depthWrite << 1) | xf6_31_depthTest;
flags.m_flags = (xb7_24_depthWrite << 1) | xb6_31_depthTest;
flags.color = moduCol;
model->Draw(flags);
break;
@ -102,9 +101,9 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const
default: break;
}
if (xf6_29_cullFaces)
if (xb6_29_cullFaces)
CGraphics::SetCullMode(ERglCullMode::None);
xc8_frame->DisableLights();
xb0_frame->DisableLights();
}
CGuiWidget::Draw(parms);

5
Runtime/GuiSys/CGuiObject.hpp
View File

@ -9,9 +9,6 @@
namespace urde
{
struct CGuiWidgetDrawParms;
class CGuiMessage;
class CGuiFunctionDef;
struct CGuiControllerInfo;
class CGuiObject
{
@ -26,7 +23,7 @@ public:
virtual ~CGuiObject();
virtual void Update(float dt);
virtual void Draw(const CGuiWidgetDrawParms& parms) const;
virtual bool Message(const CGuiMessage& msg)=0;
virtual bool Message()=0;
void MoveInWorld(const zeus::CVector3f& vec);
const zeus::CVector3f& GetLocalPosition() const {return x4_localXF.origin;}

2
Runtime/GuiSys/CGuiPane.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiPane.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{

47
Runtime/GuiSys/CGuiPhysicalMsg.cpp
View File

@ -1,47 +0,0 @@
#include "CGuiPhysicalMsg.hpp"
namespace urde
{
CGuiPhysicalMsg::CGuiPhysicalMsg(const PhysicalMap& map)
{
SetMessage(map, true);
}
bool CGuiPhysicalMsg::Exists(const CGuiPhysicalMsg& other) const
{
return ((~x8_repeatStates | other.x8_repeatStates) & x0_curStates) == other.x0_curStates;
}
void CGuiPhysicalMsg::SetMessage(const PhysicalMap& map, bool pressed)
{
for (const std::pair<EPhysicalControllerID, CPhysicalID>& item : map)
{
u64 physicalBit = 1 << u64(item.second.x0_key);
if (pressed)
x0_curStates |= physicalBit;
else
x0_curStates &= ~physicalBit;
if (item.second.x4_repeat)
x8_repeatStates |= physicalBit;
else
x8_repeatStates &= ~physicalBit;
}
}
void CGuiPhysicalMsg::AddControllerID(PhysicalMap& map, EPhysicalControllerID key, bool repeat)
{
map.emplace(std::make_pair(key, CPhysicalID{key, repeat}));
}
CGuiPhysicalMsg::EControllerState
CGuiPhysicalMsg::FindControllerID(const PhysicalMap& map, EPhysicalControllerID key)
{
auto search = map.find(key);
if (search == map.cend())
return EControllerState::NotPressed;
return search->second.x4_repeat ? EControllerState::PressRepeat : EControllerState::Press;
}
}

111
Runtime/GuiSys/CGuiPhysicalMsg.hpp
View File

@ -1,111 +0,0 @@
#ifndef __URDE_CGUIPHYSICALMSG_HPP__
#define __URDE_CGUIPHYSICALMSG_HPP__
#include <unordered_map>
#include "RetroTypes.hpp"
namespace urde
{
enum class EPhysicalControllerID
{
AInst = 1,
A = 2,
BInst = 3,
B = 4,
LInst = 5,
L = 6,
RInst = 7,
R = 8,
XInst = 9,
X = 10,
YInst = 11,
Y = 12,
ZInst = 13,
Z = 14,
StartInst = 15,
Start = 16,
DPadUpInst = 17,
DPadUp = 18,
DPadRightInst = 19,
DPadRight = 20,
DPadDownInst = 21,
DPadDown = 22,
DPadLeftInst = 23,
DPadLeft = 24,
LeftUpInst = 25,
LeftUp = 26,
LeftRightInst = 27,
LeftRight = 28,
LeftDownInst = 29,
LeftDown = 30,
LeftLeftInst = 31,
LeftLeft = 32,
LeftStickUpInst = 33,
LeftStickUp = 34,
LeftStickRightInst = 35,
LeftStickRight = 36,
LeftStickDownInst = 37,
LeftStickDown = 38,
LeftStickLeftInst = 39,
LeftStickLeft = 40,
RightStickUpInst = 41,
RightStickUp = 42,
RightStickRightInst = 43,
RightStickRight = 44,
RightStickDownInst = 45,
RightStickDown = 46,
RightStickLeftInst = 47,
RightStickLeft = 48,
LeftStickThreshold = 49,
LeftStickRelease = 50,
RightStickThreshold = 51,
RightStickRelease = 52
};
}
namespace std
{
template <> struct hash<urde::EPhysicalControllerID>
{
size_t operator() (const urde::EPhysicalControllerID& id) const noexcept {return size_t(id);}
};
}
namespace urde
{
struct CGuiPhysicalMsg
{
u64 x0_curStates = 0;
u64 x8_repeatStates = 0;
struct CPhysicalID
{
EPhysicalControllerID x0_key;
bool x4_repeat;
CPhysicalID(EPhysicalControllerID key, bool repeat) : x0_key(key), x4_repeat(repeat) {}
};
using PhysicalMap = std::unordered_map<EPhysicalControllerID, CPhysicalID>;
CGuiPhysicalMsg(const PhysicalMap& map);
bool Exists(const CGuiPhysicalMsg& other) const;
void SetMessage(const PhysicalMap& map, bool pressed);
static void AddControllerID(PhysicalMap& map, EPhysicalControllerID key, bool repeat);
enum class EControllerState
{
NotPressed = -1,
Press = 0,
PressRepeat = 1
};
static EControllerState FindControllerID(const PhysicalMap& map, EPhysicalControllerID key);
};
}
#endif // __URDE_CGUIPHYSICALMSG_HPP__

0
Runtime/GuiSys/CGuiRandomVar.cpp
View File

32
Runtime/GuiSys/CGuiRandomVar.hpp
View File

@ -1,32 +0,0 @@
#ifndef __URDE_CGUIRANDOMVAR_HPP__
#define __URDE_CGUIRANDOMVAR_HPP__
namespace urde
{
class CGuiRandomVar
{
public:
enum class Type
{
Zero,
One
} x0_type;
float x4_num;
float GenNum() const
{
switch (x0_type)
{
case Type::Zero:
case Type::One:
return x4_num;
default: break;
}
return 0.f;
}
};
}
#endif // __URDE_CGUIRANDOMVAR_HPP__

27
Runtime/GuiSys/CGuiSliderGroup.cpp
View File

@ -1,19 +1,8 @@
#include "CGuiSliderGroup.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{
typedef bool(CGuiSliderGroup::*FMAF)(CGuiFunctionDef* def, CGuiControllerInfo* info);
static std::unordered_map<u32, FMAF> WidgetFnMap;
void CGuiSliderGroup::LoadWidgetFnMap()
{
WidgetFnMap.emplace(std::make_pair(18, &CGuiSliderGroup::MAF_Increment));
WidgetFnMap.emplace(std::make_pair(19, &CGuiSliderGroup::MAF_Decrement));
}
CGuiSliderGroup::CGuiSliderGroup(const CGuiWidgetParms& parms, float a, float b, float c, float d)
: CGuiCompoundWidget(parms), xf8_minVal(a), xfc_maxVal(b), x100_curVal(c), x104_increment(d)
{
@ -25,22 +14,6 @@ void CGuiSliderGroup::SetSelectionChangedCallback
x114_changeCallback = std::move(func);
}
bool CGuiSliderGroup::MAF_Increment(CGuiFunctionDef*, CGuiControllerInfo*)
{
float oldVal = x100_curVal;
SetCurVal(x100_curVal + x104_increment);
x114_changeCallback(this, oldVal);
return true;
}
bool CGuiSliderGroup::MAF_Decrement(CGuiFunctionDef*, CGuiControllerInfo*)
{
float oldVal = x100_curVal;
SetCurVal(x100_curVal - x104_increment);
x114_changeCallback(this, oldVal);
return true;
}
void CGuiSliderGroup::SetCurVal(float cur)
{
x100_curVal = zeus::clamp(xf8_minVal, cur, xfc_maxVal);

3
Runtime/GuiSys/CGuiSliderGroup.hpp
View File

@ -19,11 +19,8 @@ class CGuiSliderGroup : public CGuiCompoundWidget
public:
CGuiSliderGroup(const CGuiWidgetParms& parms, float a, float b, float c, float d);
FourCC GetWidgetTypeID() const {return FOURCC('SLGP');}
static void LoadWidgetFnMap();
void SetSelectionChangedCallback(std::function<void(const CGuiSliderGroup*, float)>&& func);
bool MAF_Increment(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_Decrement(CGuiFunctionDef* def, CGuiControllerInfo* info);
void SetIncrement(float inc) {x104_increment = inc;}
void SetMinVal(float min) {xf8_minVal = min; SetCurVal(x100_curVal);}
void SetMaxVal(float max) {xfc_maxVal = max; SetCurVal(x100_curVal);}

2
Runtime/GuiSys/CGuiStaticImage.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiStaticImage.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiFrame.hpp"
#include "CGuiSys.hpp"
#include "CSimplePool.hpp"

69
Runtime/GuiSys/CGuiSys.cpp
View File

@ -25,15 +25,6 @@ CGuiSys* g_GuiSys = nullptr;
CTextExecuteBuffer* g_TextExecuteBuf = nullptr;
CTextParser* g_TextParser = nullptr;
void CGuiSys::AddFactories(EUsageMode /* mode */)
{
x8_factoryMgr.m_factories.clear();
}
void CGuiSys::LoadWidgetFunctions()
{
}
CGuiWidget* CGuiSys::CreateWidgetInGame(FourCC type, CInputStream& in, CGuiFrame* frame)
{
switch (type)
@ -74,62 +65,12 @@ CGuiWidget* CGuiSys::CreateWidgetInGame(FourCC type, CInputStream& in, CGuiFrame
}
CGuiSys::CGuiSys(IFactory& resFactory, CSimplePool& resStore, EUsageMode mode)
: x0_resFactory(resFactory), x4_resStore(resStore), x2c_mode(mode),
x38_frameFactoryParams(new TObjOwnerParam<CGuiResFrameData>(CGuiResFrameData(*this))),
x30_textExecuteBuf(new CTextExecuteBuffer()),
x34_textParser(new CTextParser(resStore)),
x40_constructTime(std::chrono::steady_clock::now())
: x0_resFactory(resFactory), x4_resStore(resStore), x8_mode(mode),
xc_textExecuteBuf(new CTextExecuteBuffer()),
x10_textParser(new CTextParser(resStore))
{
AddFactories(mode);
LoadWidgetFunctions();
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::DPadUpInst,
CGuiAutoRepeatData(EPhysicalControllerID::DPadUpInst, EPhysicalControllerID::DPadUp)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::DPadRightInst,
CGuiAutoRepeatData(EPhysicalControllerID::DPadRightInst, EPhysicalControllerID::DPadRight)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::DPadDownInst,
CGuiAutoRepeatData(EPhysicalControllerID::DPadDownInst, EPhysicalControllerID::DPadDown)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::DPadLeftInst,
CGuiAutoRepeatData(EPhysicalControllerID::DPadLeftInst, EPhysicalControllerID::DPadLeft)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftStickRightInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftStickRightInst, EPhysicalControllerID::LeftStickRight)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftStickDownInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftStickDownInst, EPhysicalControllerID::LeftStickDown)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftStickLeftInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftStickLeftInst, EPhysicalControllerID::LeftStickLeft)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::RightStickUpInst,
CGuiAutoRepeatData(EPhysicalControllerID::RightStickUpInst, EPhysicalControllerID::RightStickUp)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::RightStickRightInst,
CGuiAutoRepeatData(EPhysicalControllerID::RightStickRightInst, EPhysicalControllerID::RightStickRight)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::RightStickDownInst,
CGuiAutoRepeatData(EPhysicalControllerID::RightStickDownInst, EPhysicalControllerID::RightStickDown)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::RightStickLeftInst,
CGuiAutoRepeatData(EPhysicalControllerID::RightStickLeftInst, EPhysicalControllerID::RightStickLeft)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftUpInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftUpInst, EPhysicalControllerID::LeftUp)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftRightInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftRightInst, EPhysicalControllerID::LeftRight)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftDownInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftDownInst, EPhysicalControllerID::LeftDown)));
x18_repeatMap.emplace(std::make_pair(EPhysicalControllerID::LeftLeftInst,
CGuiAutoRepeatData(EPhysicalControllerID::LeftLeftInst, EPhysicalControllerID::LeftLeft)));
g_TextExecuteBuf = x30_textExecuteBuf.get();
g_TextParser = x34_textParser.get();
g_TextExecuteBuf = xc_textExecuteBuf.get();
g_TextParser = x10_textParser.get();
}
}

37
Runtime/GuiSys/CGuiSys.hpp
View File

@ -5,8 +5,6 @@
#include <unordered_map>
#include <vector>
#include <stack>
#include <chrono>
#include "CGuiAutoRepeatData.hpp"
#include "CSaveableState.hpp"
#include "IOStreams.hpp"
@ -22,19 +20,6 @@ class CGuiFrame;
class CTextParser;
class CTextExecuteBuffer;
typedef CGuiObject*(*FGuiFactoryFunc)(const SObjectTag&, const CVParamTransfer&);
class CGuiFactoryMgr
{
friend class CGuiSys;
std::unordered_map<FourCC, FGuiFactoryFunc> m_factories;
public:
void AddFactory(FourCC key, FGuiFactoryFunc func)
{
m_factories[key] = func;
}
};
class CGuiSys
{
friend class CGuiFrame;
@ -48,23 +33,16 @@ public:
private:
IFactory& x0_resFactory;
CSimplePool& x4_resStore;
CGuiFactoryMgr x8_factoryMgr;
std::unordered_map<EPhysicalControllerID, CGuiAutoRepeatData> x18_repeatMap;
EUsageMode x2c_mode;
std::unique_ptr<CTextExecuteBuffer> x30_textExecuteBuf;
std::unique_ptr<CTextParser> x34_textParser;
CVParamTransfer x38_frameFactoryParams;
std::chrono::time_point<std::chrono::steady_clock> x40_constructTime;
EUsageMode x8_mode;
std::unique_ptr<CTextExecuteBuffer> xc_textExecuteBuf;
std::unique_ptr<CTextParser> x10_textParser;
void AddFactories(EUsageMode mode);
void LoadWidgetFunctions();
static CGuiWidget* CreateWidgetInGame(FourCC type, CInputStream& in, CGuiFrame* frame);
public:
CGuiSys(IFactory& resFactory, CSimplePool& resStore, EUsageMode mode);
CSimplePool& GetResStore() {return x4_resStore;}
std::unordered_map<EPhysicalControllerID, CGuiAutoRepeatData>& GetRepeatMap() {return x18_repeatMap;}
EUsageMode GetUsageMode() const {return x2c_mode;}
EUsageMode GetUsageMode() const {return x8_mode;}
};
/** Global GuiSys instance */
@ -76,13 +54,6 @@ extern CTextExecuteBuffer* g_TextExecuteBuf;
/** Global CTextParser instance */
extern CTextParser* g_TextParser;
/** Parameter pack for FRME factory */
struct CGuiResFrameData
{
CGuiSys& x0_guiSys;
CGuiResFrameData(CGuiSys& guiSys) : x0_guiSys(guiSys) {}
};
}
#endif // __URDE_CGUISYS_HPP__

284
Runtime/GuiSys/CGuiTableGroup.cpp
View File

@ -1,282 +1,36 @@
#include "CGuiTableGroup.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
namespace urde
{
typedef bool(CGuiTableGroup::*FMAF)(CGuiFunctionDef* def, CGuiControllerInfo* info);
static std::unordered_map<u32, FMAF> WidgetFnMap;
void CGuiTableGroup::LoadWidgetFnMap()
{
WidgetFnMap.emplace(std::make_pair(21, &CGuiTableGroup::MAF_SelectNextColumn));
WidgetFnMap.emplace(std::make_pair(22, &CGuiTableGroup::MAF_SelectPrevColumn));
WidgetFnMap.emplace(std::make_pair(23, &CGuiTableGroup::MAF_SelectNextRow));
WidgetFnMap.emplace(std::make_pair(24, &CGuiTableGroup::MAF_SelectPrevRow));
WidgetFnMap.emplace(std::make_pair(25, &CGuiTableGroup::MAF_SelectNextColumnSkipUnActivated));
WidgetFnMap.emplace(std::make_pair(26, &CGuiTableGroup::MAF_SelectPrevColumnSkipUnActivated));
WidgetFnMap.emplace(std::make_pair(27, &CGuiTableGroup::MAF_SelectNextRowSkipUnActivated));
WidgetFnMap.emplace(std::make_pair(28, &CGuiTableGroup::MAF_SelectPrevRowSkipUnActivated));
WidgetFnMap.emplace(std::make_pair(29, &CGuiTableGroup::MAF_SelectColumnAtIndex));
WidgetFnMap.emplace(std::make_pair(30, &CGuiTableGroup::MAF_SelectRowAtIndex));
WidgetFnMap.emplace(std::make_pair(31, &CGuiTableGroup::MAF_InitializeTable));
WidgetFnMap.emplace(std::make_pair(32, &CGuiTableGroup::MAF_MenuAdvance));
WidgetFnMap.emplace(std::make_pair(33, &CGuiTableGroup::MAF_MenuCancel));
}
void CGuiVirtualBox::GetDifference(int a, int b, int& aOut, int& bOut)
{
if (a < x0_)
{
aOut = a - x0_;
}
else
{
if (a > x0_ + x8_)
aOut = a - x0_ + x8_;
else
aOut = 0;
}
if (b < x4_)
{
bOut = b - x4_;
}
else
{
if (b > x4_ + xc_)
bOut = b - x4_ + xc_;
else
bOut = 0;
}
}
bool CGuiVirtualBox::ShiftHorizontal(int a, bool b)
{
bool ret = false;
FillCellsInBox(x24_.get());
int r31 = x4_ + a;
if (r31 < 0)
{
ret = true;
if (b)
x4_ = x14_ - xc_;
else
x4_ = 0;
}
else
{
if (r31 + xc_ > x14_)
{
ret = true;
if (b)
x4_ = 0;
else
x4_ = x14_ - xc_;
}
else
x4_ = r31;
}
FillCellsInBox(x20_.get());
ResolveTransitionCells();
return ret;
}
bool CGuiVirtualBox::ShiftVertical(int a, bool b)
{
bool ret = false;
FillCellsInBox(x24_.get());
int r31 = x0_ + a;
if (r31 < 0)
{
ret = true;
if (b)
x0_ = x10_ - x8_;
else
x0_ = 0;
}
else
{
if (r31 + x8_ > x10_)
{
ret = true;
if (b)
x0_ = 0;
else
x0_ = x10_ - x8_;
}
else
x0_ = r31;
}
FillCellsInBox(x20_.get());
ResolveTransitionCells();
return ret;
}
void CGuiVirtualBox::ResolveTransitionCells()
{
int prod = x8_ * xc_;
x1c_ = 0;
for (int i=0 ; i<prod ; ++i)
x20_[i].x8_ = 0;
for (int i=0 ; i<prod ; ++i)
{
CCellPos& c1 = x24_[i];
bool needsAdd = true;
for (int j=0 ; j<prod ; ++j)
{
CCellPos& c2 = x20_[i];
if (c2.x8_)
continue;
if (c1.x0_ == c2.x0_ && c1.x4_ == c2.x4_)
{
c2.x8_ = true;
needsAdd = false;
break;
}
}
if (needsAdd)
x2c_[x1c_++] = c1;
}
for (int i=0, j=0 ; i<prod ; ++i)
{
CCellPos& c1 = x20_[i];
if (c1.x8_)
continue;
x28_[j++] = c1;
}
}
void CGuiVirtualBox::FillCellsInBox(CCellPos* cells)
{
for (int i=0 ; i<x8_ ; ++i)
{
int val = x0_ + i;
for (int j=0 ; j<xc_ ; ++j)
{
CCellPos& cell = cells[i*xc_+j];
cell.x0_ = val;
cell.x4_ = x4_ + j;
}
}
}
CGuiTableGroup::CGuiTableGroup(const CGuiWidgetParms& parms, int a, int b, ETableGroupModes modes,
int c, int d, bool e, bool f, float g, float h, bool i, float j,
CGuiVirtualBox&& box)
CGuiTableGroup::CGuiTableGroup(const CGuiWidgetParms& parms, int a, int b, bool c)
: CGuiCompoundWidget(parms),
xf8_(a), xfc_(b),
x118_(f), x119_(e),
x11c_(h), x120_(g),
x124_(i), x128_(j),
x130_modes(modes),
x134_box(std::move(box))
{
x100_[0][0] = c;
x100_[0][1] = d;
x100_[1][0] = c;
x100_[1][1] = d;
x100_[2][0] = c;
x100_[2][1] = d;
}
bool CGuiTableGroup::MAF_SelectNextColumn(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectPrevColumn(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectNextRow(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectPrevRow(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectNextColumnSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectPrevColumnSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectNextRowSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectPrevRowSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectColumnAtIndex(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_SelectRowAtIndex(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_InitializeTable(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_MenuAdvance(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiTableGroup::MAF_MenuCancel(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
xc0_(a), xc4_(b),
xc8_(b), xcc_(b),
xd0_(c)
{}
CGuiTableGroup* CGuiTableGroup::Create(CGuiFrame* frame, CInputStream& in, bool flag)
{
CGuiWidgetParms parms = ReadWidgetHeader(frame, in, flag);
int a = in.readInt16Big();
in.readInt16Big();
in.readUint32Big();
int b = in.readInt16Big();
ETableGroupModes modes = ETableGroupModes(in.readUint32Big());
int c = in.readInt16Big();
int d = in.readInt16Big();
bool e = in.readBool();
bool f = in.readBool();
float g = in.readFloatBig();
float h = in.readFloatBig();
bool i = in.readBool();
float j = in.readFloatBig();
in.readInt16Big();
bool c = in.readBool();
in.readBool();
in.readFloatBig();
in.readFloatBig();
in.readBool();
in.readFloatBig();
in.readInt16Big();
in.readInt16Big();
in.readInt16Big();
in.readInt16Big();
int ba = in.readInt16Big();
int bb = in.readInt16Big();
int bc = in.readInt16Big();
int bd = in.readInt16Big();
CGuiVirtualBox box(ba, bb, bc, bd, a, b);
CGuiTableGroup* ret = new CGuiTableGroup(parms, a, b, modes, c, d, e,
f, g, h, i, j, std::move(box));
CGuiTableGroup* ret = new CGuiTableGroup(parms, a, b, c);
ret->ParseBaseInfo(frame, in, parms);
return ret;
}

83
Runtime/GuiSys/CGuiTableGroup.hpp
View File

@ -6,83 +6,30 @@
namespace urde
{
struct CCellPos
{
u32 x0_ = 0;
u32 x4_ = 0;
bool x8_ = false;
};
class CGuiVirtualBox
{
int x0_;
int x4_;
int x8_;
int xc_;
int x10_;
int x14_;
int x18_;
int x1c_ = 0;
std::unique_ptr<CCellPos[]> x20_;
std::unique_ptr<CCellPos[]> x24_;
std::unique_ptr<CCellPos[]> x28_;
std::unique_ptr<CCellPos[]> x2c_;
public:
CGuiVirtualBox(int a,int b,int c,int d,int e,int f)
: x0_(a), x4_(b), x8_(c), xc_(d), x10_(e), x14_(f), x18_(std::max(x10_, x14_)),
x20_(new CCellPos[c*d]),
x24_(new CCellPos[c*d]),
x28_(new CCellPos[x18_]),
x2c_(new CCellPos[x18_]) {}
void GetDifference(int,int,int&,int&);
bool ShiftHorizontal(int,bool);
bool ShiftVertical(int,bool);
void ResolveTransitionCells();
void FillCellsInBox(CCellPos* cells);
};
class CGuiTableGroup : public CGuiCompoundWidget
{
public:
enum class ETableGroupModes
struct SomeState
{
float x0_ = 0.f;
};
private:
SomeState xb8_;
SomeState xbc_;
int xc0_;
int xc4_;
int xc8_;
int xcc_;
bool xd0_;
bool xd1_ = true;
std::function<void(const CGuiTableGroup*)> xd4_doMenuAdvance;
std::function<void(const CGuiTableGroup*)> xec_doMenuCancel;
std::function<void(const CGuiTableGroup*)> x104_doMenuSelChange;
int xf8_;
int xfc_;
int x100_[3][2];
bool x118_;
bool x119_;
float x11c_;
float x120_;
bool x124_;
float x128_;
bool x12c_ = false;
ETableGroupModes x130_modes;
CGuiVirtualBox x134_box;
public:
CGuiTableGroup(const CGuiWidgetParms& parms, int, int, ETableGroupModes modes,
int, int, bool, bool, float, float, bool, float, CGuiVirtualBox&& box);
FourCC GetWidgetTypeID() const {return FOURCC('TBGP');}
static void LoadWidgetFnMap();
bool MAF_SelectNextColumn(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectPrevColumn(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectNextRow(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectPrevRow(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectNextColumnSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectPrevColumnSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectNextRowSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectPrevRowSkipUnActivated(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectColumnAtIndex(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SelectRowAtIndex(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_InitializeTable(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_MenuAdvance(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_MenuCancel(CGuiFunctionDef* def, CGuiControllerInfo* info);
public:
CGuiTableGroup(const CGuiWidgetParms& parms, int, int, bool);
FourCC GetWidgetTypeID() const {return FOURCC('TBGP');}
void SetMenuAdvanceCallback(std::function<void(const CGuiTableGroup*)>&& cb)
{
@ -99,6 +46,8 @@ public:
x104_doMenuSelChange = std::move(cb);
}
void SetD1(bool v) { xd1_ = v; }
static CGuiTableGroup* Create(CGuiFrame* frame, CInputStream& in, bool);
};

8
Runtime/GuiSys/CGuiTextPane.cpp
View File

@ -1,6 +1,4 @@
#include "CGuiTextPane.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CFontImageDef.hpp"
#include "CGuiFrame.hpp"
#include "CGuiSys.hpp"
@ -63,13 +61,13 @@ void CGuiTextPane::Draw(const CGuiWidgetDrawParms& parms) const
zeus::CTransform::Scale(dims.x, 1.f, dims.y);
CGraphics::SetModelMatrix(x34_worldXF * local);
zeus::CColor geomCol = xb4_;
zeus::CColor geomCol = xa8_color2;
geomCol.a *= parms.x0_alphaMod;
const_cast<CGuiTextPane*>(this)->xd4_textSupport.SetGeometryColor(geomCol);
CGraphics::SetDepthWriteMode(xf6_31_depthTest, ERglEnum::LEqual, xf7_24_depthWrite);
CGraphics::SetDepthWriteMode(xb6_31_depthTest, ERglEnum::LEqual, xb7_24_depthWrite);
switch (xc4_drawFlags)
switch (xac_drawFlags)
{
case EGuiModelDrawFlags::Shadeless:
case EGuiModelDrawFlags::Opaque:

8
Runtime/GuiSys/CGuiTextSupport.cpp
View File

@ -176,7 +176,7 @@ void CGuiTextSupport::AddText(const std::wstring& str)
ClearBuffer();
}
void CGuiTextSupport::SetText(const std::wstring& str)
void CGuiTextSupport::SetText(const std::wstring& str, bool scanFlag)
{
if (x0_string.compare(str))
{
@ -184,12 +184,14 @@ void CGuiTextSupport::SetText(const std::wstring& str)
x3c_curTime = 0.f;
x0_string = str;
ClearBuffer();
x308_scanFlag = scanFlag;
x304_scanCounter = 0;
}
}
void CGuiTextSupport::SetText(const std::string& str)
void CGuiTextSupport::SetText(const std::string& str, bool scanFlag)
{
SetText(hecl::UTF8ToWide(str));
SetText(hecl::UTF8ToWide(str), scanFlag);
}
bool CGuiTextSupport::GetIsTextSupportFinishedLoading() const

8
Runtime/GuiSys/CGuiTextSupport.hpp
View File

@ -100,8 +100,8 @@ class CGuiTextSupport
std::list<u8> x2f0_;
u32 x300_ = 0;
u32 x304_ = 0;
u32 x308_ = 0;
u32 x304_scanCounter = 0;
bool x308_scanFlag = false;
public:
CGuiTextSupport(ResId fontId, const CGuiTextProperties& props,
@ -119,8 +119,8 @@ public:
void SetOutlineColor(const zeus::CColor& col);
void SetFontColor(const zeus::CColor& col);
void AddText(const std::wstring& str);
void SetText(const std::wstring& str);
void SetText(const std::string& str);
void SetText(const std::wstring& str, bool scanFlag=false); // Flag set for scan write effect
void SetText(const std::string& str, bool scanFlag=false);
bool GetIsTextSupportFinishedLoading() const;
};

554
Runtime/GuiSys/CGuiWidget.cpp
View File

@ -1,38 +1,20 @@
#include "CGuiWidget.hpp"
#include "CGuiFrame.hpp"
#include "CGuiAnimController.hpp"
#include "CGuiLogicalEventTrigger.hpp"
#include "CGuiMessage.hpp"
namespace urde
{
static logvisor::Module Log("urde::CGuiWidget");
typedef bool(CGuiWidget::*FMAF)(CGuiFunctionDef* def, CGuiControllerInfo* info);
static std::unordered_map<u32, FMAF> WidgetFnMap;
void CGuiWidget::LoadWidgetFnMap()
{
WidgetFnMap.emplace(std::make_pair(2, &CGuiWidget::MAF_StartAnimationSet));
WidgetFnMap.emplace(std::make_pair(3, &CGuiWidget::MAF_SendMessage));
WidgetFnMap.emplace(std::make_pair(6, &CGuiWidget::MAF_PauseAnim));
WidgetFnMap.emplace(std::make_pair(7, &CGuiWidget::MAF_ResumeAnim));
WidgetFnMap.emplace(std::make_pair(11, &CGuiWidget::MAF_SetState));
WidgetFnMap.emplace(std::make_pair(12, &CGuiWidget::MAF_SetStateOfWidget));
}
CGuiWidget::CGuiWidget(const CGuiWidgetParms& parms)
: x7c_selfId(parms.x6_selfId), x7e_parentId(parms.x8_parentId),
xbc_color(parms.x10_color), xc0_color2(parms.x10_color),
xc4_drawFlags(parms.x14_drawFlags), xc8_frame(parms.x0_frame),
xf6_24_pg(parms.xd_g), xf6_25_isVisible(parms.xa_defaultVisible),
xf6_26_isActive(parms.xb_defaultActive),
xf6_27_(true), xf6_28_eventLock(false),
xf6_29_cullFaces(parms.xc_cullFaces), xf6_30_(false),
xf6_31_depthTest(true), xf7_24_depthWrite(false), xf7_25_(true)
: x70_selfId(parms.x6_selfId), x72_parentId(parms.x8_parentId),
xa4_color(parms.x10_color), xa8_color2(parms.x10_color),
xac_drawFlags(parms.x14_drawFlags), xb0_frame(parms.x0_frame),
xb6_24_pg(parms.xd_g), xb6_25_isVisible(parms.xa_defaultVisible),
xb6_26_isActive(parms.xb_defaultActive),
xb6_27_(true), xb6_28_eventLock(false),
xb6_29_cullFaces(parms.xc_cullFaces), xb6_30_(false),
xb6_31_depthTest(true), xb7_24_depthWrite(false), xb7_25_(true)
{
if (parms.x4_useAnimController)
EnsureHasAnimController();
RecalcWidgetColor(ETraversalMode::Single);
}
@ -65,7 +47,7 @@ CGuiWidget* CGuiWidget::Create(CGuiFrame* frame, CInputStream& in, bool flag)
return ret;
}
bool CGuiWidget::Message(const CGuiMessage& msg)
bool CGuiWidget::Message()
{
return false;
}
@ -75,97 +57,49 @@ void CGuiWidget::ParseBaseInfo(CGuiFrame* frame, CInputStream& in, const CGuiWid
CGuiWidget* parent = frame->FindWidget(parms.x8_parentId);
bool a = in.readBool();
if (a)
xf4_workerId = in.readInt16Big();
xb4_workerId = in.readInt16Big();
zeus::CVector3f trans;
trans.readBig(in);
zeus::CMatrix3f orient;
orient.readBig(in);
x80_transform = zeus::CTransform(orient, trans);
x74_transform = zeus::CTransform(orient, trans);
ReapplyXform();
zeus::CVector3f rotCenter;
rotCenter.readBig(in);
SetRotationCenter(rotCenter);
ParseMessages(in, parms);
ParseAnimations(in, parms);
in.readUint16Big();
if (a)
if (!parent->AddWorkerWidget(this))
{
Log.report(logvisor::Warning,
"Warning: Discarding useless worker id. Parent is not a compound widget.");
xf4_workerId = -1;
xb4_workerId = -1;
}
parent->AddChildWidget(this, false, true);
}
void CGuiWidget::ParseMessages(CInputStream& in, const CGuiWidgetParms& parms)
void CGuiWidget::Update(float dt)
{
s16 count = in.readInt16Big();
assert(count == 0);
count = in.readInt16Big();
assert(count == 0);
}
void CGuiWidget::ParseAnimations(CInputStream& in, const CGuiWidgetParms& parms)
{
s16 count = in.readInt16Big();
assert(count == 0);
}
std::vector<ResId> CGuiWidget::GetTextureAssets() const
{
return {};
}
std::vector<ResId> CGuiWidget::GetModelAssets() const
{
return {};
}
std::vector<ResId> CGuiWidget::GetFontAssets() const
{
return {};
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->Update(dt);
CGuiWidget* sib = static_cast<CGuiWidget*>(GetNextSibling());
if (sib)
sib->Update(dt);
}
void CGuiWidget::Draw(const CGuiWidgetDrawParms&) const {}
void CGuiWidget::Initialize() {}
void CGuiWidget::Touch() const {}
bool CGuiWidget::GetIsVisible() const
{
return xf6_25_isVisible;
return xb6_25_isVisible;
}
bool CGuiWidget::GetIsActive() const
{
return xf6_26_isActive;
}
CGuiTextSupport* CGuiWidget::TextSupport()
{
return nullptr;
}
const CGuiTextSupport* CGuiWidget::GetTextSupport() const
{
return nullptr;
}
void CGuiWidget::ModifyRGBA(CGuiWidget* widget)
{
xb8_ += widget->xb8_;
xb4_ = xb8_ + xc0_color2;
}
void CGuiWidget::RecalculateAllRGBA()
{
CGuiWidget* parent = static_cast<CGuiWidget*>(GetParent());
if (parent)
ModifyRGBA(parent);
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->RecalculateAllRGBA();
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->RecalculateAllRGBA();
return xb6_26_isActive;
}
void CGuiWidget::InitializeRGBAFactor()
@ -183,52 +117,9 @@ bool CGuiWidget::GetIsFinishedLoadingWidgetSpecific() const
return true;
}
std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* CGuiWidget::FindTriggerList(int id)
{
auto search = xcc_triggerMap.find(id);
if (search == xcc_triggerMap.cend())
return nullptr;
return search->second.get();
}
void CGuiWidget::AddTrigger(std::unique_ptr<CGuiLogicalEventTrigger>&& trigger)
{
int tid = trigger->GetTriggerId();
std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* list = FindTriggerList(tid);
if (!list)
{
auto it =
xcc_triggerMap.emplace(std::make_pair(tid,
std::make_unique<std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>>()));
list = it.first->second.get();
}
list->push_back(std::move(trigger));
}
std::vector<std::unique_ptr<CGuiFunctionDef>>* CGuiWidget::FindFunctionDefList(int id)
{
auto search = xe0_functionMap.find(id);
if (search == xe0_functionMap.cend())
return nullptr;
return search->second.get();
}
void CGuiWidget::AddFunctionDef(s32 id, std::unique_ptr<CGuiFunctionDef>&& def)
{
std::vector<std::unique_ptr<CGuiFunctionDef>>* list = FindFunctionDefList(id);
if (!list)
{
auto it =
xe0_functionMap.emplace(std::make_pair(id,
std::make_unique<std::vector<std::unique_ptr<CGuiFunctionDef>>>()));
list = it.first->second.get();
}
list->push_back(std::move(def));
}
void CGuiWidget::SetIdlePosition(const zeus::CVector3f& pos, bool reapply)
{
x80_transform.origin = pos;
x74_transform.origin = pos;
if (reapply)
ReapplyXform();
}
@ -237,136 +128,7 @@ void CGuiWidget::ReapplyXform()
{
RotateReset();
SetLocalPosition(zeus::CVector3f::skZero);
MultiplyO2P(x80_transform);
}
void CGuiWidget::EnsureHasAnimController()
{
if (!xb0_animController)
{
xb0_animController.reset(new CGuiAnimController(
CGuiWidgetParms(xc8_frame, false, -1, -1, true, false, false,
zeus::CColor::skWhite, EGuiModelDrawFlags::Alpha,
true, false), this));
}
}
void CGuiWidget::BroadcastMessage(int id, CGuiControllerInfo* info)
{
CGuiFuncParm a((intptr_t(x7c_selfId)));
CGuiFuncParm b((intptr_t(id)));
CGuiFunctionDef def(0, false, a, b);
MAF_SendMessage(&def, info);
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->BroadcastMessage(id, info);
CGuiWidget* sib = static_cast<CGuiWidget*>(GetNextSibling());
if (sib)
sib->BroadcastMessage(id, info);
}
void CGuiWidget::LockEvents(bool lock)
{
xf6_28_eventLock = lock;
if (lock)
DoUnregisterEventHandler();
else
DoRegisterEventHandler();
}
void CGuiWidget::UnregisterEventHandler()
{
bool flag = DoUnregisterEventHandler();
if (!flag)
{
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->UnregisterEventHandler();
}
CGuiWidget* sib = static_cast<CGuiWidget*>(GetNextSibling());
if (sib && flag)
sib->UnregisterEventHandler();
}
void CGuiWidget::UnregisterEventHandler(ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
if (!DoUnregisterEventHandler())
{
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->UnregisterEventHandler();
}
break;
case ETraversalMode::Single:
DoUnregisterEventHandler();
break;
default:
UnregisterEventHandler();
break;
}
}
bool CGuiWidget::DoUnregisterEventHandler()
{
for (auto& item : xcc_triggerMap)
for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : *item.second)
xc8_frame->ClearMessageMap(trigger.get(), x7c_selfId);
return false;
}
void CGuiWidget::RegisterEventHandler()
{
bool flag = DoRegisterEventHandler();
if (!flag)
{
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->RegisterEventHandler();
}
CGuiWidget* sib = static_cast<CGuiWidget*>(GetNextSibling());
if (sib && flag)
sib->RegisterEventHandler();
}
void CGuiWidget::RegisterEventHandler(ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
if (!DoRegisterEventHandler())
{
CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
if (ch)
ch->RegisterEventHandler();
}
break;
case ETraversalMode::Single:
DoRegisterEventHandler();
break;
default:
RegisterEventHandler();
break;
}
}
bool CGuiWidget::DoRegisterEventHandler()
{
if (xf6_28_eventLock || !GetIsActive())
return false;
for (auto& item : xcc_triggerMap)
for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : *item.second)
xc8_frame->AddMessageMap(trigger.get(), x7c_selfId);
return false;
}
CGuiWidget* CGuiWidget::RemoveChildWidget(CGuiWidget* widget, bool makeWorldLocal)
{
return static_cast<CGuiWidget*>(RemoveChildObject(widget, makeWorldLocal));
MultiplyO2P(x74_transform);
}
void CGuiWidget::AddChildWidget(CGuiWidget* widget, bool makeWorldLocal, bool atEnd)
@ -379,29 +141,6 @@ bool CGuiWidget::AddWorkerWidget(CGuiWidget* worker)
return false;
}
void CGuiWidget::AddAnim(EGuiAnimBehListID id, CGuiAnimBase* anim)
{
if (!xb0_animController)
{
xb0_animController.reset(new CGuiAnimController(
CGuiWidgetParms(xc8_frame, false, -1, -1, false, false, false,
zeus::CColor::skWhite, EGuiModelDrawFlags::Alpha, true, false), this));
}
xb0_animController->AddAnimation(anim, id);
}
void CGuiWidget::ResetAllAnimUpdateState()
{
if (xb0_animController)
xb0_animController->ResetListUpdateState();
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->ResetAllAnimUpdateState();
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->ResetAllAnimUpdateState();
}
void CGuiWidget::SetVisibility(bool vis, ETraversalMode mode)
{
switch (mode)
@ -428,184 +167,13 @@ void CGuiWidget::SetVisibility(bool vis, ETraversalMode mode)
SetIsVisible(vis);
}
void CGuiWidget::SetAnimUpdateState(EGuiAnimBehListID id, bool state)
{
if (xb0_animController)
xb0_animController->SetListUpdateState(id, state);
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->SetAnimUpdateState(id, state);
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->SetAnimUpdateState(id, state);
}
void CGuiWidget::SetAnimUpdateState(EGuiAnimBehListID id, bool state, ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
{
if (xb0_animController)
xb0_animController->SetListUpdateState(id, state);
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->SetAnimUpdateState(id, state);
break;
}
case ETraversalMode::Single:
{
if (xb0_animController)
xb0_animController->SetListUpdateState(id, state);
break;
}
default:
SetAnimUpdateState(id, state);
break;
}
}
void CGuiWidget::GetBranchAnimLen(EGuiAnimBehListID id, float& len)
{
if (xb0_animController)
{
float aLen = xb0_animController->GetAnimSetLength(id);
if (aLen > len)
len = aLen;
}
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->GetBranchAnimLen(id, len);
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->GetBranchAnimLen(id, len);
}
void CGuiWidget::GetBranchAnimLen(EGuiAnimBehListID id, float& len, ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
{
if (xb0_animController)
{
float aLen = xb0_animController->GetAnimSetLength(id);
if (aLen > len)
len = aLen;
}
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->GetBranchAnimLen(id, len);
break;
}
case ETraversalMode::Single:
{
if (xb0_animController)
{
float aLen = xb0_animController->GetAnimSetLength(id);
if (aLen > len)
len = aLen;
}
break;
}
default:
GetBranchAnimLen(id, len);
break;
}
}
void CGuiWidget::IsAllAnimsDone(EGuiAnimBehListID id, bool& isDone)
{
if (xb0_animController)
{
if (!isDone)
return;
xb0_animController->IsAnimsDone(id, isDone);
}
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->IsAllAnimsDone(id, isDone);
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->IsAllAnimsDone(id, isDone);
}
void CGuiWidget::IsAllAnimsDone(EGuiAnimBehListID id, bool& isDone, ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
{
if (xb0_animController)
{
xb0_animController->IsAnimsDone(id, isDone);
if (!isDone)
return;
}
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->IsAllAnimsDone(id, isDone);
break;
}
case ETraversalMode::Single:
{
if (xb0_animController)
xb0_animController->IsAnimsDone(id, isDone);
break;
}
default:
IsAllAnimsDone(id, isDone);
break;
}
}
void CGuiWidget::InitializeAnimControllers(EGuiAnimBehListID id, float fval, bool flag,
EGuiAnimInitMode initMode)
{
if (xb0_animController)
xb0_animController->InitTransform(this, id, fval, flag, initMode);
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->InitializeAnimControllers(id, fval, flag, initMode);
CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
if (nextSib)
nextSib->InitializeAnimControllers(id, fval, flag, initMode);
}
void CGuiWidget::InitializeAnimControllers(EGuiAnimBehListID id, float fval, bool flag,
EGuiAnimInitMode initMode, ETraversalMode mode)
{
switch (mode)
{
case ETraversalMode::Children:
{
if (xb0_animController)
xb0_animController->InitTransform(this, id, fval, flag, initMode);
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
child->InitializeAnimControllers(id, fval, flag, initMode);
break;
}
case ETraversalMode::Single:
{
if (xb0_animController)
xb0_animController->InitTransform(this, id, fval, flag, initMode);
break;
}
default:
InitializeAnimControllers(id, fval, flag, initMode);
break;
}
}
void CGuiWidget::RecalcWidgetColor(ETraversalMode mode)
{
CGuiWidget* parent = static_cast<CGuiWidget*>(GetParent());
if (parent)
xc0_color2 = xbc_color * parent->xc0_color2;
xa8_color2 = xa4_color * parent->xa8_color2;
else
xc0_color2 = xbc_color;
xb4_ = xb8_ + xc0_color2;
xa8_color2 = xa4_color;
switch (mode)
{
@ -627,7 +195,7 @@ void CGuiWidget::RecalcWidgetColor(ETraversalMode mode)
CGuiWidget* CGuiWidget::FindWidget(s16 id)
{
if (x7c_selfId == id)
if (x70_selfId == id)
return this;
CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
if (child)
@ -648,10 +216,7 @@ CGuiWidget* CGuiWidget::FindWidget(s16 id)
bool CGuiWidget::GetIsFinishedLoading() const
{
bool widgetFinished = GetIsFinishedLoadingWidgetSpecific();
if (!xb0_animController)
return widgetFinished;
return widgetFinished && xb0_animController->GetIsFinishedLoading();
return GetIsFinishedLoadingWidgetSpecific();
}
void CGuiWidget::InitializeRecursive()
@ -667,69 +232,26 @@ void CGuiWidget::InitializeRecursive()
void CGuiWidget::SetColor(const zeus::CColor& color)
{
xbc_color = color;
xa4_color = color;
RecalcWidgetColor(ETraversalMode::Children);
}
void CGuiWidget::OnDeActivate() {}
void CGuiWidget::OnActivate(bool) {}
void CGuiWidget::OnInvisible() {}
void CGuiWidget::OnVisible() {}
void CGuiWidget::OnActiveChange() {}
void CGuiWidget::OnVisibleChange() {}
void CGuiWidget::SetIsVisible(bool vis)
{
xf6_25_isVisible = vis;
if (vis)
OnVisible();
else
OnInvisible();
xb6_25_isVisible = vis;
OnVisibleChange();
}
void CGuiWidget::SetIsActive(bool a, bool b)
void CGuiWidget::SetIsActive(bool a)
{
if (a == xf6_26_isActive)
return;
xf6_26_isActive = a;
if (a)
if (a != xb6_26_isActive)
{
RegisterEventHandler(ETraversalMode::Children);
OnActivate(b);
}
else
{
RegisterEventHandler(ETraversalMode::Children);
OnDeActivate();
xb6_26_isActive = a;
OnActiveChange();
}
}
bool CGuiWidget::MAF_StartAnimationSet(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiWidget::MAF_SendMessage(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiWidget::MAF_PauseAnim(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiWidget::MAF_ResumeAnim(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiWidget::MAF_SetState(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
bool CGuiWidget::MAF_SetStateOfWidget(CGuiFunctionDef* def, CGuiControllerInfo* info)
{
return false;
}
}

134
Runtime/GuiSys/CGuiWidget.hpp
View File

@ -3,27 +3,13 @@
#include "IOStreams.hpp"
#include "CGuiObject.hpp"
#include "CGuiFunctionDef.hpp"
#include "zeus/CColor.hpp"
namespace urde
{
class CGuiAnimBase;
class CGuiFrame;
class CGuiMessage;
class CGuiAnimController;
class CGuiLogicalEventTrigger;
class CGuiTextSupport;
enum class EGuiAnimBehListID
{
NegOne = -1,
Zero = 0,
One = 1,
Two = 2,
EGuiAnimBehListIDMAX = 13
};
enum class ETraversalMode
{
ChildrenAndSiblings = 0,
@ -31,14 +17,6 @@ enum class ETraversalMode
Single = 2
};
enum class EGuiAnimInitMode
{
One = 1,
Two = 2,
Three = 3,
Five = 5
};
enum class EGuiTextureClampModeHorz
{
NoClamp = 0,
@ -88,32 +66,25 @@ public:
x8_parentId(parentId), xa_defaultVisible(defaultVisible), xb_defaultActive(defaultActive),
xc_cullFaces(cullFaces), xd_g(g), xe_h(h), x10_color(color), x14_drawFlags(drawFlags) {}
};
static void LoadWidgetFnMap();
virtual FourCC GetWidgetTypeID() const {return FOURCC('BWIG');}
protected:
s16 x7c_selfId;
s16 x7e_parentId;
zeus::CTransform x80_transform;
std::unique_ptr<CGuiAnimController> xb0_animController;
zeus::CColor xb4_ = zeus::CColor::skWhite;
zeus::CColor xb8_ = zeus::CColor::skClear;
zeus::CColor xbc_color;
zeus::CColor xc0_color2;
EGuiModelDrawFlags xc4_drawFlags;
CGuiFrame* xc8_frame;
std::unordered_map<int, std::unique_ptr<std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>>> xcc_triggerMap;
std::unordered_map<int, std::unique_ptr<std::vector<std::unique_ptr<CGuiFunctionDef>>>> xe0_functionMap;
s16 xf4_workerId = -1;
bool xf6_24_pg : 1;
bool xf6_25_isVisible : 1;
bool xf6_26_isActive : 1;
bool xf6_27_ : 1;
bool xf6_28_eventLock : 1;
bool xf6_29_cullFaces : 1;
bool xf6_30_ : 1;
bool xf6_31_depthTest : 1;
bool xf7_24_depthWrite : 1;
bool xf7_25_ : 1;
s16 x70_selfId;
s16 x72_parentId;
zeus::CTransform x74_transform;
zeus::CColor xa4_color;
zeus::CColor xa8_color2;
EGuiModelDrawFlags xac_drawFlags;
CGuiFrame* xb0_frame;
s16 xb4_workerId = -1;
bool xb6_24_pg : 1;
bool xb6_25_isVisible : 1;
bool xb6_26_isActive : 1;
bool xb6_27_ : 1;
bool xb6_28_eventLock : 1;
bool xb6_29_cullFaces : 1;
bool xb6_30_ : 1;
bool xb6_31_depthTest : 1;
bool xb7_24_depthWrite : 1;
bool xb7_25_ : 1;
public:
CGuiWidget(const CGuiWidgetParms& parms);
@ -121,77 +92,40 @@ public:
static CGuiWidgetParms ReadWidgetHeader(CGuiFrame* frame, CInputStream& in, bool);
static CGuiWidget* Create(CGuiFrame* frame, CInputStream& in, bool);
virtual bool Message(const CGuiMessage& msg);
virtual void ParseBaseInfo(CGuiFrame* frame, CInputStream& in, const CGuiWidgetParms& parms);
virtual void ParseMessages(CInputStream& in, const CGuiWidgetParms& parms);
virtual void ParseAnimations(CInputStream& in, const CGuiWidgetParms& parms);
virtual std::vector<ResId> GetTextureAssets() const;
virtual std::vector<ResId> GetModelAssets() const;
virtual std::vector<ResId> GetFontAssets() const;
virtual void Update(float dt);
virtual void Draw(const CGuiWidgetDrawParms& drawParms) const;
virtual bool Message();
virtual void Initialize();
virtual void Touch() const;
virtual bool GetIsVisible() const;
virtual bool GetIsActive() const;
virtual CGuiTextSupport* TextSupport();
virtual const CGuiTextSupport* GetTextSupport() const;
virtual void ModifyRGBA(CGuiWidget* widget);
virtual void AddAnim(EGuiAnimBehListID, CGuiAnimBase*);
virtual void AddChildWidget(CGuiWidget* widget, bool makeWorldLocal, bool atEnd);
virtual CGuiWidget* RemoveChildWidget(CGuiWidget* widget, bool makeWorldLocal);
virtual FourCC GetWidgetTypeID() const {return FOURCC('BWIG');}
virtual bool AddWorkerWidget(CGuiWidget* worker);
virtual bool GetIsFinishedLoadingWidgetSpecific() const;
virtual void OnVisible();
virtual void OnInvisible();
virtual void OnActivate(bool);
virtual void OnDeActivate();
virtual bool DoRegisterEventHandler();
virtual bool DoUnregisterEventHandler();
virtual void OnVisibleChange();
virtual void OnActiveChange();
s16 GetSelfId() const {return x7c_selfId;}
s16 GetParentId() const {return x7e_parentId;}
s16 GetWorkerId() const {return xf4_workerId;}
const zeus::CTransform& GetTransform() const {return x80_transform;}
std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* FindTriggerList(int id);
void AddTrigger(std::unique_ptr<CGuiLogicalEventTrigger>&& trigger);
std::vector<std::unique_ptr<CGuiFunctionDef>>* FindFunctionDefList(int id);
void AddFunctionDef(s32 id, std::unique_ptr<CGuiFunctionDef>&& def);
const zeus::CVector3f& GetIdlePosition() const {return x80_transform.origin;}
s16 GetSelfId() const {return x70_selfId;}
s16 GetParentId() const {return x72_parentId;}
s16 GetWorkerId() const {return xb4_workerId;}
const zeus::CTransform& GetTransform() const {return x74_transform;}
const zeus::CVector3f& GetIdlePosition() const {return x74_transform.origin;}
void SetIdlePosition(const zeus::CVector3f& pos, bool reapply);
void ReapplyXform();
void SetIsVisible(bool);
void SetIsActive(bool, bool);
void EnsureHasAnimController();
void SetIsActive(bool);
void BroadcastMessage(int, CGuiControllerInfo* info);
void LockEvents(bool);
void UnregisterEventHandler();
void UnregisterEventHandler(ETraversalMode);
void RegisterEventHandler();
void RegisterEventHandler(ETraversalMode);
void ResetAllAnimUpdateState();
void SetB627(bool v) { xb6_27_ = v; }
void ParseBaseInfo(CGuiFrame* frame, CInputStream& in, const CGuiWidgetParms& parms);
void AddChildWidget(CGuiWidget* widget, bool makeWorldLocal, bool atEnd);
void SetVisibility(bool, ETraversalMode);
void SetAnimUpdateState(EGuiAnimBehListID, bool);
void SetAnimUpdateState(EGuiAnimBehListID, bool, ETraversalMode);
void GetBranchAnimLen(EGuiAnimBehListID, float&);
void GetBranchAnimLen(EGuiAnimBehListID, float&, ETraversalMode);
void IsAllAnimsDone(EGuiAnimBehListID, bool&);
void IsAllAnimsDone(EGuiAnimBehListID, bool&, ETraversalMode);
void InitializeAnimControllers(EGuiAnimBehListID, float, bool, EGuiAnimInitMode);
void InitializeAnimControllers(EGuiAnimBehListID, float, bool, EGuiAnimInitMode, ETraversalMode);
void RecalcWidgetColor(ETraversalMode);
void SetColor(const zeus::CColor& color);
void RecalculateAllRGBA();
void InitializeRGBAFactor();
CGuiWidget* FindWidget(s16 id);
bool GetIsFinishedLoading() const;
void InitializeRecursive();
bool MAF_StartAnimationSet(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SendMessage(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_PauseAnim(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_ResumeAnim(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SetState(CGuiFunctionDef* def, CGuiControllerInfo* info);
bool MAF_SetStateOfWidget(CGuiFunctionDef* def, CGuiControllerInfo* info);
};
}

21
Runtime/GuiSys/CMakeLists.txt
View File

@ -15,24 +15,14 @@ set(GUISYS_SOURCES
CConsoleOutputWindow.hpp
CErrorOutputWindow.cpp
CErrorOutputWindow.hpp
CGuiAnimBase.cpp
CGuiAnimBase.hpp
CGuiAnimController.cpp
CGuiAnimController.hpp
CGuiAutoRepeatData.cpp
CGuiAutoRepeatData.hpp
CGuiCamera.cpp
CGuiCamera.hpp
CGuiFactories.cpp
CGuiFactories.hpp
CGuiFrame.cpp
CGuiFrame.hpp
CGuiLight.cpp
CGuiLight.hpp
CGuiModel.cpp
CGuiModel.hpp
CGuiRandomVar.cpp
CGuiRandomVar.hpp
CGuiSliderGroup.cpp
CGuiSliderGroup.hpp
CGuiStaticImage.cpp
@ -62,15 +52,6 @@ set(GUISYS_SOURCES
CRasterFont.hpp
CGuiGroup.cpp
CGuiGroup.hpp
CGuiFunctionDef.cpp
CGuiFunctionDef.hpp
CGuiFuncParm.cpp
CGuiFuncParm.hpp
CGuiPhysicalMsg.cpp
CGuiPhysicalMsg.hpp
CGuiControllerInfo.hpp
CGuiLogicalEventTrigger.cpp
CGuiLogicalEventTrigger.hpp
CGuiWidgetIdDB.cpp
CGuiWidgetIdDB.hpp
CGuiHeadWidget.cpp
@ -79,8 +60,6 @@ set(GUISYS_SOURCES
CGuiBackground.hpp
CGuiPane.cpp
CGuiPane.hpp
CGuiMessage.cpp
CGuiMessage.hpp
CFontRenderState.cpp
CFontRenderState.hpp
CTextExecuteBuffer.cpp

179
Runtime/MP1/CFrontEndUI.cpp
View File

@ -13,6 +13,7 @@
#include "GuiSys/CGuiFrame.hpp"
#include "GuiSys/CStringTable.hpp"
#include "GuiSys/CGuiTableGroup.hpp"
#include "GuiSys/CGuiModel.hpp"
#include "CGameState.hpp"
#include "CDependencyGroup.hpp"
#include "Audio/CAudioGroupSet.hpp"
@ -67,20 +68,125 @@ CFrontEndUI::SNewFileSelectFrame::SNewFileSelectFrame(CSaveUI* sui, u32 rnd)
: x0_rnd(rnd), x4_saveUI(sui)
{
x10_frme = g_SimplePool->GetObj("FRME_NewFileSelect");
}
CFrontEndUI::SFileSelectOption CFrontEndUI::FindFileSelectOption(CGuiFrame* frame, int idx)
{
SFileSelectOption ret;
ret.x0_base = frame->FindWidget(hecl::Format("basewidget_file%d", idx).c_str());
ret.x4_textpanes[0] = FindTextPanePair(frame, hecl::Format("textpane_filename%d", idx).c_str());
ret.x4_textpanes[1] = FindTextPanePair(frame, hecl::Format("textpane_world%d", idx).c_str());
ret.x4_textpanes[2] = FindTextPanePair(frame, hecl::Format("textpane_playtime%d", idx).c_str());
ret.x4_textpanes[3] = FindTextPanePair(frame, hecl::Format("textpane_date%d", idx).c_str());
return ret;
}
void CFrontEndUI::SNewFileSelectFrame::FinishedLoading()
{
x20_tablegroup_fileselect = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_fileselect"));
x24_model_erase = static_cast<CGuiModel*>(x1c_loadedFrame->FindWidget("model_erase"));
xf8_model_erase_position = x24_model_erase->GetLocalPosition();
x28_textpane_erase = FindTextPanePair(x1c_loadedFrame, "textpane_erase");
x58_textpane_popupextra = FindTextPanePair(x1c_loadedFrame, "textpane_popupextra");
x40_tablegroup_popup = static_cast<CGuiTableGroup*>(x1c_loadedFrame->FindWidget("tablegroup_popup"));
x44_model_dash7 = static_cast<CGuiModel*>(x1c_loadedFrame->FindWidget("model_dash7"));
x60_textpane_cancel = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_cancel"));
FindAndSetPairText(x1c_loadedFrame, "textpane_title", g_MainStringTable->GetString(97));
CGuiTextPane* proceed = static_cast<CGuiTextPane*>(x1c_loadedFrame->FindWidget("textpane_proceed"));
if (proceed)
proceed->TextSupport()->SetText(g_MainStringTable->GetString(85));
x40_tablegroup_popup->SetIsVisible(false);
x40_tablegroup_popup->SetIsActive(false);
x40_tablegroup_popup->SetD1(false);
CGuiWidget* worker = x40_tablegroup_popup->GetWorkerWidget(2);
worker->SetB627(false);
worker->SetVisibility(false, ETraversalMode::Children);
x20_tablegroup_fileselect->SetMenuAdvanceCallback(
std::bind(&SNewFileSelectFrame::DoMenuAdvance, this, std::placeholders::_1));
x20_tablegroup_fileselect->SetMenuSelectionChangeCallback(
std::bind(&SNewFileSelectFrame::DoMenuSelectionChange, this, std::placeholders::_1));
x20_tablegroup_fileselect->SetMenuCancelCallback(
std::bind(&SNewFileSelectFrame::DoMenuAdvance, this, std::placeholders::_1));
x40_tablegroup_popup->SetMenuAdvanceCallback(
std::bind(&SNewFileSelectFrame::DoMenuAdvance, this, std::placeholders::_1));
x40_tablegroup_popup->SetMenuSelectionChangeCallback(
std::bind(&SNewFileSelectFrame::DoMenuSelectionChange, this, std::placeholders::_1));
x40_tablegroup_popup->SetMenuCancelCallback(
std::bind(&SNewFileSelectFrame::DoMenuAdvance, this, std::placeholders::_1));
for (int i=0 ; i<3 ; ++i)
x64_fileSelections[i] = FindFileSelectOption(x1c_loadedFrame, i);
x104_rowPitch = (x64_fileSelections[1].x0_base->GetLocalPosition() - x64_fileSelections[0].x0_base->GetLocalPosition()).z;
}
bool CFrontEndUI::SNewFileSelectFrame::PumpLoad()
{
if (x1c_loadedFrame)
return true;
if (x10_frme.IsLoaded())
{
if (x10_frme->GetIsFinishedLoading())
{
x1c_loadedFrame = x10_frme.GetObj();
FinishedLoading();
return true;
}
}
return false;
}
void CFrontEndUI::SNewFileSelectFrame::DoMenuSelectionChange(const CGuiTableGroup* caller)
{
}
void CFrontEndUI::SNewFileSelectFrame::DoMenuAdvance(const CGuiTableGroup* caller)
{
}
CFrontEndUI::SGBASupportFrame::SGBASupportFrame()
{
x4_gbaSupport = std::make_unique<CGBASupport>();
xc_gbaScreen = g_SimplePool->GetObj("FRME_GBAScreen");
x18_gbaLink = g_SimplePool->GetObj("FRME_GBALink");
}
void CFrontEndUI::SGBASupportFrame::FinishedLoading()
{
}
bool CFrontEndUI::SGBASupportFrame::PumpLoad()
{
}
void CFrontEndUI::SGuiTextPair::SetPairText(const std::wstring& str)
{
x0_panes[0]->TextSupport()->SetText(str);
x0_panes[1]->TextSupport()->SetText(str);
}
CFrontEndUI::SGuiTextPair CFrontEndUI::FindTextPanePair(CGuiFrame* frame, const char* name)
{
SGuiTextPair ret;
ret.x0_panes[0] = static_cast<CGuiTextPane*>(frame->FindWidget(name));
ret.x0_panes[1] = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
return ret;
}
void CFrontEndUI::FindAndSetPairText(CGuiFrame* frame, const char* name, const std::wstring& str)
{
CGuiTextPane* w1 = static_cast<CGuiTextPane*>(frame->FindWidget(name));
w1->TextSupport()->SetText(str);
CGuiTextPane* w2 = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
w2->TextSupport()->SetText(str);
}
void CFrontEndUI::SFrontEndFrame::FinishedLoading()
{
x18_tablegroup_mainmenu = static_cast<CGuiTableGroup*>(x14_loadedFrme->FindWidget("tablegroup_mainmenu"));
@ -123,22 +229,6 @@ bool CFrontEndUI::SFrontEndFrame::PumpLoad()
return false;
}
CFrontEndUI::SGuiTextPair CFrontEndUI::SFrontEndFrame::FindTextPanePair(CGuiFrame* frame, const char* name)
{
SGuiTextPair ret;
ret.x0_panes[0] = static_cast<CGuiTextPane*>(frame->FindWidget(name));
ret.x0_panes[1] = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
return ret;
}
void CFrontEndUI::SFrontEndFrame::FindAndSetPairText(CGuiFrame* frame, const char* name, const std::wstring& str)
{
CGuiTextPane* w1 = static_cast<CGuiTextPane*>(frame->FindWidget(name));
w1->TextSupport()->SetText(str);
CGuiTextPane* w2 = static_cast<CGuiTextPane*>(frame->FindWidget(hecl::Format("%sb", name).c_str()));
w2->TextSupport()->SetText(str);
}
void CFrontEndUI::SFrontEndFrame::DoMenuSelectionChange(const CGuiTableGroup* caller)
{
}
@ -167,6 +257,20 @@ CFrontEndUI::SFusionBonusFrame::SFusionBonusFrame()
0, 0, g_SimplePool);
}
bool CFrontEndUI::SFusionBonusFrame::DoUpdateWithSaveUI(float dt, CSaveUI* saveUi)
{
bool flag = (saveUi && saveUi->x10_ != 16) ? false : true;
x10_remTime = std::max(x10_remTime - dt, 0.f);
zeus::CColor geomCol(zeus::CColor::skWhite);
geomCol.a = std::min(x10_remTime, 1.f);
xc_textSupport->SetGeometryColor(geomCol);
if (xc_textSupport->GetIsTextSupportFinishedLoading())
{
}
}
CFrontEndUI::SOptionsFrontEndFrame::SOptionsFrontEndFrame()
{
x4_frme = g_SimplePool->GetObj("FRME_OptionsFrontEnd");
@ -404,14 +508,14 @@ void CFrontEndUI::ProcessUserInput(const CFinalInput& input, CArchitectureQueue&
void CFrontEndUI::TransitionToFive()
{
if (x14_screen >= EScreen::Five)
if (x14_phase >= EPhase::Five)
return;
const u16* sfx = FETransitionForwardSFX[x1c_rndB];
CSfxManager::SfxStart(sfx[0], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
CSfxManager::SfxStart(sfx[1], 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
x14_screen = EScreen::Five;
x14_phase = EPhase::Five;
StartStateTransition(EScreen::Five);
}
@ -444,40 +548,40 @@ CIOWin::EMessageReturn CFrontEndUI::Update(float dt, CArchitectureQueue& queue)
UpdateMusicVolume();
switch (x14_screen)
switch (x14_phase)
{
case EScreen::Zero:
case EPhase::Zero:
if (!x20_depsGroup.IsLoaded())
return EMessageReturn::Exit;
FinishedLoadingDepsGroup();
x20_depsGroup.Unlock();
x14_screen = EScreen::One;
x14_phase = EPhase::One;
case EScreen::One:
case EPhase::One:
if (PumpLoad())
{
xe0_newFileSel = std::make_unique<SNewFileSelectFrame>(xdc_saveUI.get(), x1c_rndB);
xe4_gbaSupport = std::make_unique<CGBASupport>();
xe4_gbaSupportFrme = std::make_unique<SGBASupportFrame>();
xe8_frontendFrme = std::make_unique<SFrontEndFrame>(x1c_rndB);
x38_pressStart.GetObj();
CAudioSys::AddAudioGroup(x44_frontendAudioGrp->GetAudioGroupData());
xd4_audio1 = std::make_unique<CStaticAudioPlayer>("Audio/frontend_1.rsf", 416480, 1973664);
xd8_audio2 = std::make_unique<CStaticAudioPlayer>("Audio/frontend_2.rsf", 273556, 1636980);
x14_screen = EScreen::Two;
x14_phase = EPhase::Two;
}
if (x14_screen == EScreen::One)
if (x14_phase == EPhase::One)
return EMessageReturn::Exit;
case EScreen::Two:
case EPhase::Two:
if (!xd4_audio1->IsReady() || !xd8_audio2->IsReady() ||
!xe0_newFileSel->PumpLoad() || !xe4_gbaSupport->PumpLoad() ||
!xe0_newFileSel->PumpLoad() || !xe4_gbaSupportFrme->PumpLoad() ||
!xe8_frontendFrme->PumpLoad() || !xdc_saveUI->PumpLoad())
return EMessageReturn::Exit;
xf4_curAudio = xd4_audio1.get();
xf4_curAudio->StartMixing();
x14_screen = EScreen::Three;
x14_phase = EPhase::Three;
case EScreen::Three:
case EPhase::Three:
{
bool moviesReady = true;
if (PumpMovieLoad())
@ -497,16 +601,23 @@ CIOWin::EMessageReturn CFrontEndUI::Update(float dt, CArchitectureQueue& queue)
if (moviesReady)
{
x14_screen = EScreen::Four;
x14_phase = EPhase::Four;
StartStateTransition(EScreen::One);
}
else
return EMessageReturn::Exit;
}
case EScreen::Four:
if (xec_)
case EPhase::Four:
case EPhase::Five:
if (xec_fusionFrme)
{
xdc_saveUI->Update(dt);
if (xec_fusionFrme->DoUpdateWithSaveUI(dt, xdc_saveUI.get()))
{
xec_fusionFrme.reset();
xf4_curAudio->StartMixing();
}
break;
}
}
@ -530,7 +641,7 @@ CIOWin::EMessageReturn CFrontEndUI::OnMessage(const CArchitectureMessage& msg, C
}
case EArchMsgType::QuitGameplay:
{
x14_screen = EScreen::Six;
x14_phase = EPhase::Six;
break;
}
default: break;

80
Runtime/MP1/CFrontEndUI.hpp
View File

@ -27,6 +27,7 @@ class CSaveUI;
class CGuiTextPane;
class CGuiWidget;
class CGuiTableGroup;
class CGuiModel;
namespace MP1
{
@ -35,6 +36,16 @@ class CNESEmulator;
class CFrontEndUI : public CIOWin
{
public:
enum class EPhase
{
Zero,
One,
Two,
Three,
Four,
Five,
Six
};
enum class EScreen
{
Zero,
@ -64,32 +75,66 @@ public:
CGuiTextPane* x0_panes[2] = {};
void SetPairText(const std::wstring& str);
};
static SGuiTextPair FindTextPanePair(CGuiFrame* frame, const char* name);
static void FindAndSetPairText(CGuiFrame* frame, const char* name, const std::wstring& str);
struct SFileSelectOption
{
CGuiWidget* x0_base;
/* filename, world, playtime, date */
SGuiTextPair x4_textpanes[4];
};
static SFileSelectOption FindFileSelectOption(CGuiFrame* frame, int idx);
struct SNewFileSelectFrame
{
u32 x0_rnd;
CSaveUI* x4_saveUI;
TLockedToken<CGuiFrame> x10_frme;
CGuiFrame* x1c_ = nullptr;
CGuiWidget* x20_ = nullptr;
CGuiWidget* x24_ = nullptr;
SGuiTextPair x28_;
CGuiFrame* x1c_loadedFrame = nullptr;
CGuiTableGroup* x20_tablegroup_fileselect = nullptr;
CGuiModel* x24_model_erase = nullptr;
SGuiTextPair x28_textpane_erase;
SGuiTextPair x30_;
SGuiTextPair x38_;
CGuiWidget* x40_ = nullptr;
CGuiWidget* x44_ = nullptr;
CGuiTableGroup* x40_tablegroup_popup = nullptr;
CGuiModel* x44_model_dash7 = nullptr;
SGuiTextPair x48_;
SGuiTextPair x50_;
SGuiTextPair x58_;
CGuiWidget* x60_ = nullptr;
CGuiWidget* x64_ = nullptr;
zeus::CVector3f xf8_;
float x104_ = 0.f;
SGuiTextPair x58_textpane_popupextra;
CGuiTextPane* x60_textpane_cancel = nullptr;
SFileSelectOption x64_fileSelections[3];
zeus::CVector3f xf8_model_erase_position;
float x104_rowPitch = 0.f;
float x108_ = 0.f;
bool x10c_ = false;
bool x10d_ = false;
bool x10e_ = false;
SNewFileSelectFrame(CSaveUI* sui, u32 rnd);
void FinishedLoading();
bool PumpLoad();
void DoMenuSelectionChange(const CGuiTableGroup* caller);
void DoMenuAdvance(const CGuiTableGroup* caller);
};
struct SGBASupportFrame
{
u32 x0_ = 0;
std::unique_ptr<CGBASupport> x4_gbaSupport;
TLockedToken<CGuiFrame> xc_gbaScreen;
TLockedToken<CGuiFrame> x18_gbaLink;
CGuiFrame* x24_loadedFrame = nullptr;
CGuiWidget* x28_ = nullptr;
CGuiWidget* x2c_ = nullptr;
SGuiTextPair x30_;
bool x38_ = false;
bool x39_ = false;
bool x3a_ = false;
SGBASupportFrame();
void FinishedLoading();
bool PumpLoad();
};
@ -104,8 +149,6 @@ public:
SFrontEndFrame(u32 rnd);
void FinishedLoading();
bool PumpLoad();
static SGuiTextPair FindTextPanePair(CGuiFrame* frame, const char* name);
static void FindAndSetPairText(CGuiFrame* frame, const char* name, const std::wstring& str);
void DoMenuSelectionChange(const CGuiTableGroup* caller);
void DoMenuAdvance(const CGuiTableGroup* caller);
@ -116,11 +159,12 @@ public:
u32 x0_ = 0;
std::unique_ptr<CNESEmulator> x4_nesEmu;
std::unique_ptr<CGuiTextSupport> xc_textSupport;
float x10_ = 8.f;
float x10_remTime = 8.f;
bool x14_ = false;
bool x15_ = true;
SFusionBonusFrame();
bool DoUpdateWithSaveUI(float dt, CSaveUI* saveUi);
};
struct SOptionsFrontEndFrame
@ -151,7 +195,7 @@ public:
};
private:
EScreen x14_screen = EScreen::Zero;
EPhase x14_phase = EPhase::Zero;
u32 x18_rndA;
u32 x1c_rndB;
TLockedToken<CDependencyGroup> x20_depsGroup;
@ -178,10 +222,10 @@ private:
std::unique_ptr<CStaticAudioPlayer> xd8_audio2;
std::unique_ptr<CSaveUI> xdc_saveUI;
std::unique_ptr<SNewFileSelectFrame> xe0_newFileSel;
std::unique_ptr<CGBASupport> xe4_gbaSupport;
std::unique_ptr<SGBASupportFrame> xe4_gbaSupportFrme;
std::unique_ptr<SFrontEndFrame> xe8_frontendFrme;
u32 xec_ = 0;
u32 xf0_ = 0;
std::unique_ptr<SFusionBonusFrame> xec_fusionFrme;
std::unique_ptr<SOptionsFrontEndFrame> xf0_optionsFrme;
CStaticAudioPlayer* xf4_curAudio = nullptr;
void SetMovieSecondsDeferred()

16
Runtime/MP1/CGBASupport.cpp
View File

@ -5,9 +5,21 @@ namespace urde
namespace MP1
{
bool CGBASupport::PumpLoad()
CGBASupport* CGBASupport::SharedInstance = nullptr;
CGBASupport::CGBASupport()
: CDvdFile("client_pad.bin")
{
return false;
x28_fileSize = ROUND_UP_32(Length());
x2c_buffer.reset(new u8[x28_fileSize]);
x30_dvdReq = AsyncRead(x2c_buffer.get(), x28_fileSize);
//InitDSPComm();
SharedInstance = this;
}
CGBASupport::~CGBASupport()
{
SharedInstance = nullptr;
}
}

17
Runtime/MP1/CGBASupport.hpp
View File

@ -1,15 +1,28 @@
#ifndef __URDE_CGBASUPPORT_HPP__
#define __URDE_CGBASUPPORT_HPP__
#include "CDvdFile.hpp"
namespace urde
{
namespace MP1
{
class CGBASupport
class CGBASupport : public CDvdFile
{
u32 x28_fileSize;
std::unique_ptr<u8[]> x2c_buffer;
std::shared_ptr<IDvdRequest> x30_dvdReq;
u32 x34_ = 0;
float x38_ = 0.f;
bool x3c_ = false;
u32 x40_ = -1;
bool x44_ = false;
bool x45_ = false;
static CGBASupport* SharedInstance;
public:
bool PumpLoad();
CGBASupport();
~CGBASupport();
};
}