metaforce/Runtime/Input/CInputGenerator.hpp.old

163 lines
6.3 KiB
C++
Raw Normal View History

#pragma once
#include <array>
#include <atomic>
#include <mutex>
#include "Runtime/Input/InputTypes.hpp"
#include "Runtime/Input/CFinalInput.hpp"
#include "Runtime/Input/CKeyboardMouseController.hpp"
namespace metaforce {
class CArchitectureQueue;
class CInputGenerator /*: public boo::DeviceFinder*/ {
enum class EStatusChange { NoChange = 0, Connected = 1, Disconnected = 2 };
/* When the sticks are used as logical (digital) input,
* these thresholds determine the vector magnitude indicating
* the logical state */
float m_leftDiv;
float m_rightDiv;
CKeyboardMouseControllerData m_data;
std::array<SAuroraControllerState, 4> m_state;
CFinalInput m_lastUpdate;
const CFinalInput& getFinalInput(unsigned idx, float dt);
bool m_firstFrame = true;
public:
CInputGenerator(float leftDiv, float rightDiv)
: /*boo::DeviceFinder({dev_typeid(DolphinSmashAdapter)}),*/ m_leftDiv(leftDiv), m_rightDiv(rightDiv) {}
// ~CInputGenerator() override {
// if (smashAdapter) {
// smashAdapter->setCallback(nullptr);
// smashAdapter->closeDevice();
// }
// }
void controllerAdded(uint32_t which) noexcept;
void controllerRemoved(uint32_t which) noexcept;
void controllerButton(uint32_t which, aurora::ControllerButton button, bool pressed) noexcept;
void controllerAxis(uint32_t which, aurora::ControllerAxis axis, int16_t value) noexcept;
/* Keyboard and mouse events are delivered on the main game
* thread as part of the app's main event loop. The OS is responsible
* for buffering events in its own way, then boo flushes the buffer
* at the start of each frame, invoking these methods. No atomic locking
* is necessary, only absolute state tracking. */
void mouseDown(const SWindowCoord&, EMouseButton button, EModifierKey) {
m_data.m_mouseButtons[size_t(button)] = true;
}
void mouseUp(const SWindowCoord&, EMouseButton button, EModifierKey) {
m_data.m_mouseButtons[size_t(button)] = false;
}
void mouseMove(const SWindowCoord& coord) { m_data.m_mouseCoord = coord; }
void scroll(const SWindowCoord&, const SScrollDelta& scroll) { m_data.m_accumScroll += scroll; }
void charKeyDown(uint8_t charCode, aurora::ModifierKey, bool) {
charCode = tolower(charCode);
if (charCode > 255)
return;
m_data.m_charKeys[charCode] = true;
}
void charKeyUp(uint8_t charCode, aurora::ModifierKey mods) {
charCode = tolower(charCode);
if (charCode > 255)
return;
m_data.m_charKeys[charCode] = false;
}
void specialKeyDown(aurora::SpecialKey key, aurora::ModifierKey, bool) { m_data.m_specialKeys[size_t(key)] = true; }
void specialKeyUp(aurora::SpecialKey key, aurora::ModifierKey) { m_data.m_specialKeys[size_t(key)] = false; }
void modKeyDown(aurora::ModifierKey mod, bool) { m_data.m_modMask = m_data.m_modMask | mod; }
void modKeyUp(aurora::ModifierKey mod) { m_data.m_modMask = m_data.m_modMask & ~mod; }
void reset() { m_data.m_accumScroll.zeroOut(); }
// /* Input via the smash adapter is received asynchronously on a USB
// * report thread. This class atomically exchanges that data to the
// * game thread as needed */
// struct DolphinSmashAdapterCallback : boo::IDolphinSmashAdapterCallback {
// std::array<std::atomic<EStatusChange>, 4> m_statusChanges;
// std::array<bool, 4> m_connected{};
// std::array<boo::DolphinControllerState, 4> m_states;
// std::mutex m_stateLock;
// void controllerConnected(unsigned idx, boo::EDolphinControllerType) override {
// /* Controller thread */
// m_statusChanges[idx].store(EStatusChange::Connected);
// }
// void controllerDisconnected(unsigned idx) override {
// /* Controller thread */
// std::unique_lock lk{m_stateLock};
// m_statusChanges[idx].store(EStatusChange::Disconnected);
// m_states[idx].reset();
// }
// void controllerUpdate(unsigned idx, boo::EDolphinControllerType,
// const boo::DolphinControllerState& state) override {
// /* Controller thread */
// std::unique_lock lk{m_stateLock};
// m_states[idx] = state;
// }
//
// std::array<CFinalInput, 4> m_lastUpdates;
// const CFinalInput& getFinalInput(unsigned idx, float dt, float leftDiv, float rightDiv) {
// /* Game thread */
// std::unique_lock lk{m_stateLock};
// boo::DolphinControllerState state = m_states[idx];
// lk.unlock();
// state.clamp(); /* PADClamp equivalent */
// m_lastUpdates[idx] = CFinalInput(idx, dt, state, m_lastUpdates[idx], leftDiv, rightDiv);
// return m_lastUpdates[idx];
// }
// EStatusChange getStatusChange(unsigned idx, bool& connected) {
// /* Game thread */
// EStatusChange ch = m_statusChanges[idx].exchange(EStatusChange::NoChange);
// if (ch == EStatusChange::Connected)
// m_connected[idx] = true;
// else if (ch == EStatusChange::Disconnected)
// m_connected[idx] = false;
// connected = m_connected[idx];
// return ch;
// }
// } m_dolphinCb;
// /* Device connection/disconnection events are handled on a separate thread
// * using the relevant OS API. This thread blocks in a loop until an event is
// * received. Device pointers should only be manipulated by this thread using
// * the deviceConnected() and deviceDisconnected() callbacks. */
// std::shared_ptr<boo::DolphinSmashAdapter> smashAdapter;
// void deviceConnected(boo::DeviceToken& tok) override {
// /* Device listener thread */
// if (!smashAdapter) {
// auto dev = tok.openAndGetDevice();
// if (dev && dev->getTypeHash() == dev_typeid(DolphinSmashAdapter)) {
// smashAdapter = std::static_pointer_cast<boo::DolphinSmashAdapter>(tok.openAndGetDevice());
// smashAdapter->setCallback(&m_dolphinCb);
// }
// }
// }
// void deviceDisconnected(boo::DeviceToken&, boo::DeviceBase* device) override {
// if (smashAdapter.get() == device)
// smashAdapter.reset();
// }
void SetMotorState(EIOPort port, EMotorState state);
void ControlAllMotors(const std::array<EMotorState, 4>& states) {
for (u32 i = 0; i <= size_t(EIOPort::Player4); ++i ) {
SetMotorState(EIOPort(i), states[i]);
}
}
/* This is where the game thread enters */
void Update(float dt, CArchitectureQueue& queue);
CFinalInput GetLastInput() const { return m_lastUpdate; }
};
} // namespace metaforce