mirror of https://github.com/AxioDL/metaforce.git
Refactor GuiSys (remove general logic handling)
This commit is contained in:
parent
6b765838a7
commit
19a371c931
|
@ -1,6 +1,4 @@
|
|||
#include "CAuiEnergyBarT01.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
#include "CGuiLogicalEventTrigger.hpp"
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
|
|
@ -3,11 +3,4 @@
|
|||
namespace urde
|
||||
{
|
||||
|
||||
typedef bool(CAuiMeter::*FMAF)(CGuiFunctionDef* def, CGuiControllerInfo* info);
|
||||
static std::unordered_map<u32, FMAF> WidgetFnMap;
|
||||
|
||||
void CAuiMeter::LoadWidgetFnMap()
|
||||
{
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -9,7 +9,6 @@ namespace urde
|
|||
class CAuiMeter : public CGuiCompoundWidget
|
||||
{
|
||||
public:
|
||||
static void LoadWidgetFnMap();
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -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__
|
|
@ -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);
|
||||
}
|
||||
|
||||
}
|
|
@ -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__
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -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__
|
|
@ -1,6 +1,4 @@
|
|||
#include "CGuiBackground.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
#include "CGuiLogicalEventTrigger.hpp"
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
|
|
@ -1,6 +1,5 @@
|
|||
#include "CGuiCamera.hpp"
|
||||
#include "CGuiFrame.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
#include "Graphics/CGraphics.hpp"
|
||||
|
||||
namespace urde
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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);
|
||||
};
|
||||
|
||||
|
|
|
@ -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__
|
|
@ -1,10 +0,0 @@
|
|||
#ifndef __URDE_CGUIFACTORIES_HPP__
|
||||
#define __URDE_CGUIFACTORIES_HPP__
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif // __URDE_CGUIFACTORIES_HPP__
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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__
|
|
@ -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)
|
||||
{
|
||||
}
|
||||
|
||||
}
|
|
@ -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__
|
|
@ -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)
|
||||
|
|
|
@ -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,6 +1,5 @@
|
|||
#include "CGuiHeadWidget.hpp"
|
||||
#include "CGuiFrame.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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__
|
|
@ -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__
|
|
@ -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);
|
||||
|
|
|
@ -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;}
|
||||
|
|
|
@ -1,6 +1,4 @@
|
|||
#include "CGuiPane.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
#include "CGuiLogicalEventTrigger.hpp"
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
|
@ -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__
|
|
@ -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__
|
|
@ -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);
|
||||
|
|
|
@ -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);}
|
||||
|
|
|
@ -1,6 +1,4 @@
|
|||
#include "CGuiStaticImage.hpp"
|
||||
#include "CGuiAnimController.hpp"
|
||||
#include "CGuiLogicalEventTrigger.hpp"
|
||||
#include "CGuiFrame.hpp"
|
||||
#include "CGuiSys.hpp"
|
||||
#include "CSimplePool.hpp"
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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__
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
};
|
||||
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -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();
|
||||
};
|
||||
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue