Add new pointing device implementation with its unit tests

Author: Stovent

src/CDI/CDI.hpp

@@ -27,7 +27,6 @@ class CDI
     Callbacks m_callbacks; /**< The user callbacks. */
 
     SCC68070 m_cpu; /**< The main CPU. */
-    std::unique_ptr<ISlave> m_slave{}; /**< The slave processor. */
     std::unique_ptr<IRTC> m_timekeeper{}; /**< The NVRAM chip. */
 
     static std::unique_ptr<CDI> NewCDI(Boards board, bool useSoftCDI, std::span<const uint8_t> systemBios, std::span<const uint8_t> nvram, CDIConfig config = DEFAULT_CDICONFIG, Callbacks callbacks = Callbacks(), CDIDisc disc = CDIDisc());
@@ -51,6 +50,15 @@ class CDI
     void Stop(bool wait = true);
     bool IsRunning() const { return m_isRunning; }
 
+    // TODO: find a way to handle all input device types in a clean way.
+    virtual void SetUp(bool pressed) noexcept = 0;
+    virtual void SetRight(bool pressed) noexcept = 0;
+    virtual void SetDown(bool pressed) noexcept = 0;
+    virtual void SetLeft(bool pressed) noexcept = 0;
+    virtual void SetButton1(bool pressed) noexcept = 0;
+    virtual void SetButton2(bool pressed) noexcept = 0;
+    virtual void SetButton12(bool pressed) noexcept = 0;
+
     virtual uint8_t  PeekByte(uint32_t addr) const noexcept = 0;
     virtual uint16_t PeekWord(uint32_t addr) const noexcept = 0;
     virtual uint32_t PeekLong(uint32_t addr) const noexcept = 0;
@@ -85,6 +93,7 @@ class CDI
     friend SCC68070;
 
     CDIDisc m_disc; /**< CDI disc. */
+    std::unique_ptr<ISlave> m_slave{}; /**< The slave processor. */
 
     CDI(std::string_view boardName, CDIConfig config, Callbacks callbacks, CDIDisc disc = CDIDisc());
 

src/CDI/CMakeLists.txt

@@ -36,8 +36,8 @@ add_library(CeDImu ${LIBRARY_TYPE}
     CDIFile.cpp
     CDIFile.hpp
     Export.cpp
-    PointingDevice.cpp
-    PointingDevice.hpp
+    Pointing.cpp
+    Pointing.hpp
 )
 target_include_directories(CeDImu PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 

src/CDI/HLE/IKAT/IKAT.cpp

@@ -15,8 +15,8 @@ namespace HLE
 #define DELAY_RSP(channel, rsp) { delayedRsp[channel] = &rsp; \
                                 delayedRspFrame[channel] = cdi.GetTotalFrameCount() + 2; }
 
-IKAT::IKAT(CDI& idc, bool PAL, uint32_t busbase, PointingDevice::Class deviceClass)
-    : ISlave(idc, busbase, deviceClass)
+IKAT::IKAT(CDI& idc, bool PAL, uint32_t busbase)
+    : ISlave(idc, busbase)
     , registers{0}
     , delayedRsp{nullptr}
     , delayedRspFrame{0}
@@ -29,16 +29,21 @@ IKAT::IKAT(CDI& idc, bool PAL, uint32_t busbase, PointingDevice::Class deviceCla
 
 void IKAT::UpdatePointerState()
 {
+    std::array<uint8_t, 4> packet{};
+    const size_t size = pointingDevice.GetState(packet);
+
     channelOut[CHB].clear();
-    channelOut[CHB].insert(channelOut[CHB].begin(), pointingDevice.m_pointerMessage.begin(), pointingDevice.m_pointerMessage.end());
+    channelOut[CHB].insert(channelOut[CHB].begin(), packet.begin(), packet.begin() + size);
 
     UNSET_REMTY(CHB_SR)
     SET_INT(CHB)
 }
 
 void IKAT::IncrementTime(const size_t ns)
 {
-    pointingDevice.IncrementTime(ns);
+    const bool irq = pointingDevice.IncrementTime(ns);
+    if(irq) // Got packet.
+        UpdatePointerState();
 
     for(int channel = CHA; channel <= CHD; channel++)
     {

src/CDI/HLE/IKAT/IKAT.hpp

@@ -14,7 +14,7 @@ namespace HLE
 class IKAT : public ISlave
 {
 public:
-    IKAT(CDI& idc, bool PAL, uint32_t busbase, PointingDevice::Class deviceClass);
+    IKAT(CDI& idc, bool PAL, uint32_t busbase);
 
     IKAT(const IKAT&) = delete;
     IKAT& operator=(const IKAT&) = delete;

src/CDI/Pointing.cpp

@@ -0,0 +1,143 @@
+/** \file Pointing.cpp
+ * \brief Implementation of the pointing devices of the CD-I.
+ */
+
+#include "Pointing.hpp"
+#include "common/utils.hpp"
+
+#include <algorithm>
+#include <print>
+#include <utility>
+
+namespace Pointing
+{
+
+// size_t RelativeCoordinate::GetState(const std::span<uint8_t> packet) noexcept
+// {
+//     std::unique_lock<std::mutex> lock{m_stateMutex};
+//
+//     const uint8_t button1 = static_cast<uint8_t>(m_lastState.btn1) << 5;
+//     const uint8_t button2 = static_cast<uint8_t>(m_lastState.btn2) << 4;
+//
+//     const uint8_t x = m_lastState.left ? -SPEED : (m_lastState.right ? SPEED : 0);
+//     const uint8_t y = m_lastState.up ? -SPEED : (m_lastState.down ? SPEED : 0);
+//
+//     std::println("{} {} {} {} {}", SPEED, button1, button2, x, y);
+//
+//     packet[0] = 0x40 | button1 | button2 | (y >> 4 & 0x0C) | (x >> 6 & 3);
+//     packet[1] = x & 0x3F;
+//     packet[2] = y & 0x3F;
+//
+//     return BYTES_PER_PACKET;
+// }
+
+// bool RelativeCoordinate::IncrementTime(const double ns) noexcept
+// {
+//     // TODO: coroutine?
+//     bool sendPacket = false;
+//     std::lock_guard<std::mutex> lock{m_stateMutex};
+//
+//     if(!m_timeNs.has_value()) // Packet can be sent immediately.
+//     {
+//         sendPacket = m_state.HasChanged(m_lastState);
+//         if(sendPacket)
+//             m_timeNs = 0.0; // Start counting time.
+//     }
+//     else // m_timeNs has a value, waiting for packet delay.
+//     {
+//         *m_timeNs += ns;
+//
+//         if(*m_timeNs >= PACKET_DELTA)
+//         {
+//             sendPacket = m_state.HasChanged(m_lastState);
+//             if(sendPacket)
+//                 *m_timeNs -= PACKET_DELTA; // Consecutive packet, start counting again.
+//             else
+//                 m_timeNs = std::nullopt;
+//         }
+//     }
+//
+//     if(sendPacket)
+//     {
+//         m_lastState = m_state; // To be retrieved later by the Slave chip or driver.
+//         m_state.ClearDirections();
+//     }
+//
+//     return sendPacket;
+// }
+
+size_t Maneuvering::GetState(const std::span<uint8_t> packet) noexcept
+{
+    const int speed = GetMovementSpeed();
+
+    const uint8_t button1 = static_cast<uint8_t>(m_lastState.btn1);
+    const uint8_t button2 = static_cast<uint8_t>(m_lastState.btn2);
+
+    const uint8_t x = m_lastState.left ? -speed : (m_lastState.right ? speed : 0);
+    const uint8_t y = m_lastState.up ? -speed : (m_lastState.down ? speed : 0);
+
+    packet[0] = 0x40 | (button1 << 5) | (button2 << 4) | (y >> 4 & 0x0C) | (x >> 6 & 3);
+    packet[1] = x & 0x3F;
+    packet[2] = y & 0x3F;
+
+    std::println("{} {} {} {} {}", speed, m_lastState.btn1, m_lastState.btn2, x, y);
+
+    return Maneuvering::BYTES_PER_PACKET;
+}
+
+bool Maneuvering::IncrementTime(const double ns) noexcept
+{
+    // TODO: coroutine?
+    bool sendPacket = false;
+    std::lock_guard<std::mutex> lock{m_stateMutex};
+
+    if(!m_timeNs.has_value()) // Packet can be sent immediately.
+    {
+        sendPacket = m_state.HasAnyButtonChanged(m_lastState) || m_state.HasPadPressed();
+        if(sendPacket)
+        {
+            m_timeNs = 0.0; // Start counting time.
+            m_consecutivePackets = 1;
+        }
+    }
+    else // m_timeNs has a value, waiting for packet delay.
+    {
+        *m_timeNs += ns;
+
+        if(*m_timeNs >= PACKET_DELTA)
+        {
+            sendPacket = m_state.HasAnyButtonChanged(m_lastState) || m_state.HasPadPressed();
+            if(sendPacket) // Consecutive packet, start counting again.
+            {
+                *m_timeNs -= PACKET_DELTA;
+                if(m_state.HasPadPressed())
+                    IncrementConsecutivePacket();
+                else
+                    m_consecutivePackets = 0;
+            }
+            else // No consecutive packet.
+            {
+                m_timeNs = std::nullopt;
+                m_consecutivePackets = 0;
+            }
+        }
+    }
+
+    if(sendPacket)
+        m_lastState = m_state; // To be retrieved later by the Slave chip or driver.
+
+    return sendPacket;
+}
+
+int Maneuvering::GetMovementSpeed() const noexcept
+{
+    switch(m_speed)
+    {
+    case GamepadSpeed::N:  return std::min(8, m_consecutivePackets + (m_consecutivePackets & 1));
+    case GamepadSpeed::I:  return 1;
+    case GamepadSpeed::II: return std::min(16, 2 * m_consecutivePackets);
+    }
+    std::unreachable();
+}
+
+} // namespace Pointing