From 3029184d1e448ede5bfeac55ac217339c2f73cff Mon Sep 17 00:00:00 2001 From: Luke Street Date: Tue, 18 Oct 2022 23:35:06 -0400 Subject: [PATCH] Implement rstl::list::push_back; CInputGenerator 98% --- include/Kyoto/CResFactory.hpp | 2 +- include/Kyoto/CResLoader.hpp | 6 +-- include/Kyoto/Input/CDolphinController.hpp | 14 ++--- include/MetroidPrime/CArchitectureQueue.hpp | 2 +- include/rstl/list.hpp | 59 ++++++++++++++------- src/MetroidPrime/CInputGenerator.cpp | 59 ++++++++++++--------- 6 files changed, 86 insertions(+), 56 deletions(-) diff --git a/include/Kyoto/CResFactory.hpp b/include/Kyoto/CResFactory.hpp index c37abc7c..dcfdcd39 100644 --- a/include/Kyoto/CResFactory.hpp +++ b/include/Kyoto/CResFactory.hpp @@ -46,7 +46,7 @@ private: uint xa4_; uint xa8_; uint xac_; - rstl::list< void > xb0_; + rstl::list< unkptr > xb0_; }; CHECK_SIZEOF(CResFactory, 0xc8); diff --git a/include/Kyoto/CResLoader.hpp b/include/Kyoto/CResLoader.hpp index c639d36e..12bc49ef 100644 --- a/include/Kyoto/CResLoader.hpp +++ b/include/Kyoto/CResLoader.hpp @@ -28,9 +28,9 @@ public: CInputStream* LoadNewResourceSync(const SObjectTag& tag, char* extBuf); private: - rstl::list< void > x0_aramList; - rstl::list< void > x18_pakLoadedList; - rstl::list< void > x30_pakLoadingList; + rstl::list< unkptr > x0_aramList; + rstl::list< unkptr > x18_pakLoadedList; + rstl::list< unkptr > x30_pakLoadingList; unkptr x48_curPak; CAssetId x4c_cachedResId; SResInfo* x50_cachedResInfo; diff --git a/include/Kyoto/Input/CDolphinController.hpp b/include/Kyoto/Input/CDolphinController.hpp index a7ce667d..ea4d29ce 100644 --- a/include/Kyoto/Input/CDolphinController.hpp +++ b/include/Kyoto/Input/CDolphinController.hpp @@ -11,14 +11,14 @@ class CDolphinController : public IController { public: CDolphinController(); - virtual ~CDolphinController(); - void Poll(); - uint GetDeviceCount() const; - CControllerGamepadData& GetGamepadData(int controller); - uint GetControllerType(int) const; - void SetMotorState(EIOPort port, EMotorState state); - bool Initialize(); + ~CDolphinController() override; + void Poll() override; + uint GetDeviceCount() const override; + CControllerGamepadData& GetGamepadData(int controller) override; + uint GetControllerType(int) const override; + void SetMotorState(EIOPort port, EMotorState state) override; + bool Initialize(); float GetAnalogStickMaxValue(EJoyAxis axis) const; private: diff --git a/include/MetroidPrime/CArchitectureQueue.hpp b/include/MetroidPrime/CArchitectureQueue.hpp index b8173473..b25af3b8 100644 --- a/include/MetroidPrime/CArchitectureQueue.hpp +++ b/include/MetroidPrime/CArchitectureQueue.hpp @@ -10,7 +10,7 @@ class CArchitectureQueue { public: bool Push(const CArchitectureMessage& msg) { - // x0_queue.push_back(msg); + x0_queue.push_back(msg); return false; // TODO } void Pop(); // TODO diff --git a/include/rstl/list.hpp b/include/rstl/list.hpp index 2029e1d6..6cbf7267 100644 --- a/include/rstl/list.hpp +++ b/include/rstl/list.hpp @@ -3,6 +3,7 @@ #include "types.h" +#include "rstl/construct.hpp" #include "rstl/rmemory_allocator.hpp" namespace rstl { @@ -11,14 +12,18 @@ class list { public: class iterator; class const_iterator; - iterator erase(const iterator &item); + iterator erase(const iterator& item); + private: class node; - node *erase(const node *item); + node* erase(const node* item); public: list() - : x4_start(&xc_empty), x8_end(&xc_empty), xc_empty(&xc_empty, &xc_empty) {} + : x4_start(reinterpret_cast< node* >(&xc_empty_prev)) + , x8_end(reinterpret_cast< node* >(&xc_empty_prev)) + , xc_empty(reinterpret_cast< node* >(&xc_empty_prev), reinterpret_cast< node* >(&xc_empty_prev)) + , x14_count(0) {} ~list() { node* cur = x4_start; while (cur != x8_end) { @@ -27,7 +32,7 @@ public: cur = cur->get_next(); } } - void push_back(const T&); + void push_back(const T& val) { do_insert_before(x8_end, val); } void clear() { // iterator e = end(); iterator cur = begin(); @@ -50,28 +55,40 @@ private: struct node { node* x0_prev; node* x4_next; - union { - T* x8_item; - uint x8_count; - }; + uchar x8_item[sizeof(T)]; - node(node* prev, node* next) : x0_prev(prev), x4_next(next), x8_count(0) {} + node(node* prev, node* next) : x0_prev(prev), x4_next(next) {} node* get_prev() const { return x0_prev; } node* get_next() const { return x4_next; } - T* get_value() { return x8_item; } - const T* get_value_const() const { return x8_item; } - - // todo set_next / set_prev + void set_prev(node* prev) { x0_prev = prev; } + void set_next(node* next) { x4_next = next; } + T* get_value() { return reinterpret_cast< T* >(&x8_item); } }; + node* create_node(node* prev, node* next, const T& val) { + node* n = new node(prev, next); + construct(n->get_value(), val); + return n; + } + + void do_insert_before(node* n, const T& val) { + node* nn = create_node(n->get_prev(), n, val); + if (n == x4_start) { + x4_start = nn; + } + nn->get_prev()->set_next(nn); + nn->get_next()->set_prev(nn); + ++x14_count; + } + public: class const_iterator { - public:; + public: typedef T* value_type; const_iterator() : current(nullptr) {} - const_iterator(const node *begin) : current(begin) {} + const_iterator(const node* begin) : current(begin) {} const_iterator& operator++() { this->current = this->current->x4_next; return *this; @@ -92,17 +109,18 @@ public: const node* current; }; - class iterator: const_iterator { + class iterator : const_iterator { public: typedef T* value_type; iterator() : const_iterator(nullptr) {} - iterator(node *begin) : const_iterator(begin) {} + iterator(node* begin) : const_iterator(begin) {} iterator& operator++() { this->current = this->current->x4_next; return *this; } - iterator operator++(int) { return const_iterator(this->current->x4_next; } + iterator operator++(int) { return const_iterator(this->current->x4_next; + } iterator& operator--() { this->current = this->current->x0_prev; return *this; @@ -113,6 +131,7 @@ public: T* operator->() const { return current->get_value(); } bool operator==(const iterator& other) const { return current == other.current; } bool operator!=(const iterator& other) const { return current != other.current; } + protected: node* current; }; @@ -121,7 +140,9 @@ private: Alloc x0_allocator; node* x4_start; node* x8_end; - node xc_empty; + node* xc_empty_prev; + node* x10_empty_next; + uint x14_count; }; } // namespace rstl diff --git a/src/MetroidPrime/CInputGenerator.cpp b/src/MetroidPrime/CInputGenerator.cpp index b47c4245..383862e8 100644 --- a/src/MetroidPrime/CInputGenerator.cpp +++ b/src/MetroidPrime/CInputGenerator.cpp @@ -4,6 +4,7 @@ #include "MetroidPrime/Decode.hpp" #include "Kyoto/Basics/COsContext.hpp" + CInputGenerator::CInputGenerator(COsContext* ctx, float leftDiv, float rightDiv) : x0_context(ctx) , x4_controller(IController::Create(*ctx)) @@ -13,40 +14,48 @@ CInputGenerator::CInputGenerator(COsContext* ctx, float leftDiv, float rightDiv) x8_connectedControllers[i] = false; } } + bool CInputGenerator::Update(float dt, CArchitectureQueue& queue) { - bool ret; + int availSlot = 0; if (!x0_context->Update()) { - ret = false; - } else { - int availSlot = 0; - bool firstController = false; - if (!x4_controller.null()) { - x4_controller->Poll(); - for (int i = 0; i < x4_controller->GetDeviceCount(); ++i) { + return false; + } + + bool firstController = false; + if (!x4_controller.null()) { + int count = x4_controller->GetDeviceCount(); + x4_controller->Poll(); + for (int i = 0; i < count; ++i) { + const CControllerGamepadData& cont = x4_controller->GetGamepadData(i); + if (cont.DeviceIsPresent()) { if (i == 0) { firstController = true; } - CControllerGamepadData cont = x4_controller->GetGamepadData(i); - if (cont.DeviceIsPresent()) { - queue.Push(MakeMsg::CreateUserInput(kAMT_Game, - CFinalInput(i, dt, cont, xc_leftDiv, x10_rightDiv))); - ++availSlot; + { + CFinalInput input(i, dt, cont, xc_leftDiv, x10_rightDiv); + CArchitectureMessage msg = MakeMsg::CreateUserInput(kAMT_Game, input); + queue.Push(msg); } + ++availSlot; + } - if (x8_connectedControllers[i] != cont.DeviceIsPresent()) { - queue.Push(MakeMsg::CreateControllerStatus(kAMT_Game, i, cont.DeviceIsPresent())); - x8_connectedControllers[i] = cont.DeviceIsPresent(); - } + bool connected = cont.DeviceIsPresent(); + if (x8_connectedControllers[i] != connected) { + CArchitectureMessage msg = MakeMsg::CreateControllerStatus(kAMT_Game, i, connected); + queue.Push(msg); + x8_connectedControllers[i] = connected; } } - - if (firstController) { - queue.Push(MakeMsg::CreateUserInput(kAMT_Game, CFinalInput(availSlot, dt, *x0_context))); - } else { - queue.Push(MakeMsg::CreateUserInput(kAMT_Game, CFinalInput(0, dt, *x0_context))); - } - ret = true; } - return ret; + + if (!firstController) { + CArchitectureMessage msg = MakeMsg::CreateUserInput(kAMT_Game, CFinalInput(0, dt, *x0_context)); + queue.Push(msg); + } else { + CArchitectureMessage msg = + MakeMsg::CreateUserInput(kAMT_Game, CFinalInput(availSlot, dt, *x0_context)); + queue.Push(msg); + } + return true; }