Merge pull request #11331 from deReeperJosh/skylandersportal

Emulate Skylanders Portals within Dolphin

Source/Core/Core/CMakeLists.txt

@@ -399,6 +399,8 @@ add_library(core
   IOS/USB/Bluetooth/WiimoteHIDAttr.h
   IOS/USB/Common.cpp
   IOS/USB/Common.h
+  IOS/USB/Emulated/Skylander.cpp
+  IOS/USB/Emulated/Skylander.h
   IOS/USB/Host.cpp
   IOS/USB/Host.h
   IOS/USB/OH0/OH0.cpp

Source/Core/Core/Config/MainSettings.cpp

@@ -551,6 +551,11 @@ void SetUSBDeviceWhitelist(const std::set<std::pair<u16, u16>>& devices)
   Config::SetBase(Config::MAIN_USB_PASSTHROUGH_DEVICES, SaveUSBWhitelistToString(devices));
 }
 
+// Main.EmulatedUSBDevices
+
+const Info<bool> MAIN_EMULATE_SKYLANDER_PORTAL{
+    {System::Main, "EmulatedUSBDevices", "EmulateSkylanderPortal"}, false};
+
 // The reason we need this function is because some memory card code
 // expects to get a non-NTSC-K region even if we're emulating an NTSC-K Wii.
 DiscIO::Region ToGameCubeRegion(DiscIO::Region region)

Source/Core/Core/Config/MainSettings.h

@@ -342,6 +342,10 @@ extern const Info<std::string> MAIN_USB_PASSTHROUGH_DEVICES;
 std::set<std::pair<u16, u16>> GetUSBDeviceWhitelist();
 void SetUSBDeviceWhitelist(const std::set<std::pair<u16, u16>>& devices);
 
+// Main.EmulatedUSBDevices
+
+extern const Info<bool> MAIN_EMULATE_SKYLANDER_PORTAL;
+
 // GameCube path utility functions
 
 // Replaces NTSC-K with some other region, and doesn't replace non-NTSC-K regions

Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp

@@ -29,7 +29,7 @@ bool IsSettingSaveable(const Config::Location& config_location)
     for (const std::string_view section :
          {"NetPlay", "General", "GBA", "Display", "Network", "Analytics", "AndroidOverlayButtons",
           "DSP", "GameList", "FifoPlayer", "AutoUpdate", "Movie", "Input", "Debug",
-          "BluetoothPassthrough", "USBPassthrough", "Interface"})
+          "BluetoothPassthrough", "USBPassthrough", "Interface", "EmulatedUSBDevices"})
     {
       if (config_location.section == section)
         return true;

Source/Core/Core/IOS/USB/Common.cpp

@@ -38,6 +38,13 @@ void TransferCommand::OnTransferComplete(s32 return_value) const
   m_ios.EnqueueIPCReply(ios_request, return_value, 0, CoreTiming::FromThread::NON_CPU);
 }
 
+void TransferCommand::ScheduleTransferCompletion(s32 return_value, u32 expected_time_us) const
+{
+  auto ticks = SystemTimers::GetTicksPerSecond();
+  s64 cycles_in_future = static_cast<s64>((static_cast<u64>(ticks) * expected_time_us) / 1'000'000);
+  m_ios.EnqueueIPCReply(ios_request, return_value, cycles_in_future, CoreTiming::FromThread::ANY);
+}
+
 void IsoMessage::SetPacketReturnValue(const size_t packet_num, const u16 return_value) const
 {
   auto& system = Core::System::GetInstance();

Source/Core/Core/IOS/USB/Common.h

@@ -109,6 +109,7 @@ struct TransferCommand
   // Called after a transfer has completed to reply to the IPC request.
   // This can be overridden for additional processing before replying.
   virtual void OnTransferComplete(s32 return_value) const;
+  void ScheduleTransferCompletion(s32 return_value, u32 expected_time_us) const;
   std::unique_ptr<u8[]> MakeBuffer(size_t size) const;
   void FillBuffer(const u8* src, size_t size) const;
 

Source/Core/Core/IOS/USB/Emulated/Skylander.h

@@ -0,0 +1,116 @@
+// Copyright 2022 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <map>
+#include <mutex>
+#include <queue>
+#include <vector>
+
+#include "Common/CommonTypes.h"
+#include "Common/IOFile.h"
+#include "Core/IOS/USB/Common.h"
+
+// The maximum possible characters the portal can handle.
+// The status array is 32 bits and every character takes 2 bits.
+// 32/2 = 16
+constexpr u8 MAX_SKYLANDERS = 16;
+
+namespace IOS::HLE::USB
+{
+class SkylanderUSB final : public Device
+{
+public:
+  SkylanderUSB(Kernel& ios, const std::string& device_name);
+  ~SkylanderUSB();
+  DeviceDescriptor GetDeviceDescriptor() const override;
+  std::vector<ConfigDescriptor> GetConfigurations() const override;
+  std::vector<InterfaceDescriptor> GetInterfaces(u8 config) const override;
+  std::vector<EndpointDescriptor> GetEndpoints(u8 config, u8 interface, u8 alt) const override;
+  bool Attach() override;
+  bool AttachAndChangeInterface(u8 interface) override;
+  int CancelTransfer(u8 endpoint) override;
+  int ChangeInterface(u8 interface) override;
+  int GetNumberOfAltSettings(u8 interface) override;
+  int SetAltSetting(u8 alt_setting) override;
+  int SubmitTransfer(std::unique_ptr<CtrlMessage> message) override;
+  int SubmitTransfer(std::unique_ptr<BulkMessage> message) override;
+  int SubmitTransfer(std::unique_ptr<IntrMessage> message) override;
+  int SubmitTransfer(std::unique_ptr<IsoMessage> message) override;
+  void ScheduleTransfer(std::unique_ptr<TransferCommand> command, const std::array<u8, 64>& data,
+                        s32 expected_count, u64 expected_time_us);
+
+private:
+  Kernel& m_ios;
+  u16 m_vid = 0;
+  u16 m_pid = 0;
+  u8 m_active_interface = 0;
+  bool m_device_attached = false;
+  DeviceDescriptor m_device_descriptor;
+  std::vector<ConfigDescriptor> m_config_descriptor;
+  std::vector<InterfaceDescriptor> m_interface_descriptor;
+  std::vector<EndpointDescriptor> m_endpoint_descriptor;
+  std::queue<std::array<u8, 64>> m_queries;
+};
+
+struct Skylander final
+{
+  File::IOFile sky_file;
+  u8 status = 0;
+  std::queue<u8> queued_status;
+  std::array<u8, 0x40 * 0x10> data{};
+  u32 last_id = 0;
+  void Save();
+
+  enum : u8
+  {
+    REMOVED = 0,
+    READY = 1,
+    REMOVING = 2,
+    ADDED = 3
+  };
+};
+
+struct SkylanderLEDColor final
+{
+  u8 red = 0;
+  u8 green = 0;
+  u8 blue = 0;
+};
+
+class SkylanderPortal final
+{
+public:
+  void Activate();
+  void Deactivate();
+  bool IsActivated();
+  void UpdateStatus();
+  void SetLEDs(u8 side, u8 r, u8 g, u8 b);
+
+  std::array<u8, 64> GetStatus();
+  void QueryBlock(u8 sky_num, u8 block, u8* reply_buf);
+  void WriteBlock(u8 sky_num, u8 block, const u8* to_write_buf, u8* reply_buf);
+
+  bool CreateSkylander(const std::string& file_path, u16 sky_id, u16 sky_var);
+  bool RemoveSkylander(u8 sky_num);
+  u8 LoadSkylander(u8* buf, File::IOFile in_file);
+
+protected:
+  std::mutex sky_mutex;
+
+  bool m_activated = true;
+  bool m_status_updated = false;
+  u8 m_interrupt_counter = 0;
+  SkylanderLEDColor m_color_right = {};
+  SkylanderLEDColor m_color_left = {};
+  SkylanderLEDColor m_color_trap = {};
+
+  std::array<Skylander, MAX_SKYLANDERS> skylanders;
+
+private:
+  static bool IsSkylanderNumberValid(u8 sky_num);
+  static bool IsBlockNumberValid(u8 block);
+};
+
+}  // namespace IOS::HLE::USB

Source/Core/Core/IOS/USB/Host.cpp

@@ -22,7 +22,10 @@
 #include "Core/Config/MainSettings.h"
 #include "Core/Core.h"
 #include "Core/IOS/USB/Common.h"
+#include "Core/IOS/USB/Emulated/Skylander.h"
 #include "Core/IOS/USB/LibusbDevice.h"
+#include "Core/NetPlayProto.h"
+#include "Core/System.h"
 
 namespace IOS::HLE
 {
@@ -34,7 +37,7 @@ USBHost::~USBHost() = default;
 
 std::optional<IPCReply> USBHost::Open(const OpenRequest& request)
 {
-  if (!m_has_initialised && !Core::WantsDeterminism())
+  if (!m_has_initialised)
   {
     GetScanThread().Start();
     // Force a device scan to complete, because some games (including Your Shape) only care
@@ -96,12 +99,15 @@ bool USBHost::ShouldAddDevice(const USB::Device& device) const
   return true;
 }
 
+void USBHost::Update()
+{
+  if (Core::WantsDeterminism())
+    UpdateDevices();
+}
+
 // This is called from the scan thread. Returns false if we failed to update the device list.
 bool USBHost::UpdateDevices(const bool always_add_hooks)
 {
-  if (Core::WantsDeterminism())
-    return true;
-
   DeviceChangeHooks hooks;
   std::set<u64> plugged_devices;
   // If we failed to get a new, up-to-date list of devices, we cannot detect device removals.
@@ -115,31 +121,35 @@ bool USBHost::UpdateDevices(const bool always_add_hooks)
 bool USBHost::AddNewDevices(std::set<u64>& new_devices, DeviceChangeHooks& hooks,
                             const bool always_add_hooks)
 {
+  AddEmulatedDevices(new_devices, hooks, always_add_hooks);
 #ifdef __LIBUSB__
-  auto whitelist = Config::GetUSBDeviceWhitelist();
-  if (whitelist.empty())
-    return true;
-
-  if (m_context.IsValid())
+  if (!Core::WantsDeterminism())
   {
-    const int ret = m_context.GetDeviceList([&](libusb_device* device) {
-      libusb_device_descriptor descriptor;
-      libusb_get_device_descriptor(device, &descriptor);
-      if (whitelist.count({descriptor.idVendor, descriptor.idProduct}) == 0)
-        return true;
-
-      auto usb_device = std::make_unique<USB::LibusbDevice>(m_ios, device, descriptor);
-      if (!ShouldAddDevice(*usb_device))
-        return true;
-
-      const u64 id = usb_device->GetId();
-      new_devices.insert(id);
-      if (AddDevice(std::move(usb_device)) || always_add_hooks)
-        hooks.emplace(GetDeviceById(id), ChangeEvent::Inserted);
+    auto whitelist = Config::GetUSBDeviceWhitelist();
+    if (whitelist.empty())
       return true;
-    });
-    if (ret != LIBUSB_SUCCESS)
-      WARN_LOG_FMT(IOS_USB, "GetDeviceList failed: {}", LibusbUtils::ErrorWrap(ret));
+
+    if (m_context.IsValid())
+    {
+      const int ret = m_context.GetDeviceList([&](libusb_device* device) {
+        libusb_device_descriptor descriptor;
+        libusb_get_device_descriptor(device, &descriptor);
+        if (whitelist.count({descriptor.idVendor, descriptor.idProduct}) == 0)
+          return true;
+
+        auto usb_device = std::make_unique<USB::LibusbDevice>(m_ios, device, descriptor);
+        if (!ShouldAddDevice(*usb_device))
+          return true;
+
+        const u64 id = usb_device->GetId();
+        new_devices.insert(id);
+        if (AddDevice(std::move(usb_device)) || always_add_hooks)
+          hooks.emplace(GetDeviceById(id), ChangeEvent::Inserted);
+        return true;
+      });
+      if (ret != LIBUSB_SUCCESS)
+        WARN_LOG_FMT(IOS_USB, "GetDeviceList failed: {}", LibusbUtils::ErrorWrap(ret));
+    }
   }
 #endif
   return true;
@@ -175,6 +185,24 @@ void USBHost::DispatchHooks(const DeviceChangeHooks& hooks)
     OnDeviceChangeEnd();
 }
 
+void USBHost::AddEmulatedDevices(std::set<u64>& new_devices, DeviceChangeHooks& hooks,
+                                 bool always_add_hooks)
+{
+  if (Config::Get(Config::MAIN_EMULATE_SKYLANDER_PORTAL) && !NetPlay::IsNetPlayRunning())
+  {
+    auto skylanderportal = std::make_unique<USB::SkylanderUSB>(m_ios, "Skylander Portal");
+    if (ShouldAddDevice(*skylanderportal))
+    {
+      const u64 skyid = skylanderportal->GetId();
+      new_devices.insert(skyid);
+      if (AddDevice(std::move(skylanderportal)) || always_add_hooks)
+      {
+        hooks.emplace(GetDeviceById(skyid), ChangeEvent::Inserted);
+      }
+    }
+  }
+}
+
 USBHost::ScanThread::~ScanThread()
 {
   Stop();
@@ -182,14 +210,19 @@ USBHost::ScanThread::~ScanThread()
 
 void USBHost::ScanThread::WaitForFirstScan()
 {
-  m_first_scan_complete_event.Wait();
+  if (m_thread_running.IsSet())
+  {
+    m_first_scan_complete_event.Wait();
+  }
 }
 
 void USBHost::ScanThread::Start()
 {
   if (Core::WantsDeterminism())
+  {
+    m_host->UpdateDevices();
     return;
-
+  }
   if (m_thread_running.TestAndSet())
   {
     m_thread = std::thread([this] {

Source/Core/Core/IOS/USB/Host.h

@@ -76,10 +76,13 @@ protected:
 
 private:
   bool AddDevice(std::unique_ptr<USB::Device> device);
+  void Update() override;
   bool UpdateDevices(bool always_add_hooks = false);
   bool AddNewDevices(std::set<u64>& new_devices, DeviceChangeHooks& hooks, bool always_add_hooks);
   void DetectRemovedDevices(const std::set<u64>& plugged_devices, DeviceChangeHooks& hooks);
   void DispatchHooks(const DeviceChangeHooks& hooks);
+  void AddEmulatedDevices(std::set<u64>& new_devices, DeviceChangeHooks& hooks,
+                          bool always_add_hooks);
 
   bool m_has_initialised = false;
   LibusbUtils::Context m_context;

Source/Core/Core/System.cpp

@@ -20,6 +20,7 @@
 #include "Core/HW/SI/SI.h"
 #include "Core/HW/Sram.h"
 #include "Core/HW/VideoInterface.h"
+#include "IOS/USB/Emulated/Skylander.h"
 #include "VideoCommon/CommandProcessor.h"
 #include "VideoCommon/Fifo.h"
 #include "VideoCommon/GeometryShaderManager.h"
@@ -47,6 +48,7 @@ struct System::Impl
   Fifo::FifoManager m_fifo;
   GeometryShaderManager m_geometry_shader_manager;
   GPFifo::GPFifoManager m_gp_fifo;
+  IOS::HLE::USB::SkylanderPortal m_skylander_portal;
   Memory::MemoryManager m_memory;
   MemoryInterface::MemoryInterfaceState m_memory_interface_state;
   PixelEngine::PixelEngineManager m_pixel_engine;
@@ -151,6 +153,11 @@ GPFifo::GPFifoManager& System::GetGPFifo() const
   return m_impl->m_gp_fifo;
 }
 
+IOS::HLE::USB::SkylanderPortal& System::GetSkylanderPortal() const
+{
+  return m_impl->m_skylander_portal;
+}
+
 Memory::MemoryManager& System::GetMemory() const
 {
   return m_impl->m_memory;

Source/Core/Core/System.h

@@ -47,6 +47,10 @@ namespace GPFifo
 {
 class GPFifoManager;
 }
+namespace IOS::HLE::USB
+{
+class SkylanderPortal;
+};
 namespace Memory
 {
 class MemoryManager;
@@ -116,6 +120,7 @@ public:
   Fifo::FifoManager& GetFifo() const;
   GeometryShaderManager& GetGeometryShaderManager() const;
   GPFifo::GPFifoManager& GetGPFifo() const;
+  IOS::HLE::USB::SkylanderPortal& GetSkylanderPortal() const;
   Memory::MemoryManager& GetMemory() const;
   MemoryInterface::MemoryInterfaceState& GetMemoryInterfaceState() const;
   PixelEngine::PixelEngineManager& GetPixelEngine() const;

Source/Core/DolphinLib.props

@@ -374,6 +374,7 @@
     <ClInclude Include="Core\IOS\USB\Bluetooth\WiimoteDevice.h" />
     <ClInclude Include="Core\IOS\USB\Bluetooth\WiimoteHIDAttr.h" />
     <ClInclude Include="Core\IOS\USB\Common.h" />
+    <ClInclude Include="Core\IOS\USB\Emulated\Skylander.h" />
     <ClInclude Include="Core\IOS\USB\Host.h" />
     <ClInclude Include="Core\IOS\USB\LibusbDevice.h" />
     <ClInclude Include="Core\IOS\USB\OH0\OH0.h" />
@@ -987,6 +988,7 @@
     <ClCompile Include="Core\IOS\USB\Bluetooth\WiimoteDevice.cpp" />
     <ClCompile Include="Core\IOS\USB\Bluetooth\WiimoteHIDAttr.cpp" />
     <ClCompile Include="Core\IOS\USB\Common.cpp" />
+    <ClCompile Include="Core\IOS\USB\Emulated\Skylander.cpp" />
     <ClCompile Include="Core\IOS\USB\Host.cpp" />
     <ClCompile Include="Core\IOS\USB\LibusbDevice.cpp" />
     <ClCompile Include="Core\IOS\USB\OH0\OH0.cpp" />

Source/Core/DolphinQt/CMakeLists.txt

@@ -325,6 +325,8 @@ add_executable(dolphin-emu
   Settings/USBDeviceAddToWhitelistDialog.h
   Settings/WiiPane.cpp
   Settings/WiiPane.h
+  SkylanderPortal/SkylanderPortalWindow.cpp
+  SkylanderPortal/SkylanderPortalWindow.h
   TAS/GCTASInputWindow.cpp
   TAS/GCTASInputWindow.h
   TAS/GBATASInputWindow.cpp

Source/Core/DolphinQt/DolphinQt.vcxproj

@@ -200,6 +200,7 @@
     <ClCompile Include="Settings\PathPane.cpp" />
     <ClCompile Include="Settings\USBDeviceAddToWhitelistDialog.cpp" />
     <ClCompile Include="Settings\WiiPane.cpp" />
+    <ClCompile Include="SkylanderPortal\SkylanderPortalWindow.cpp" />
     <ClCompile Include="TAS\GCTASInputWindow.cpp" />
     <ClCompile Include="TAS\GBATASInputWindow.cpp" />
     <ClCompile Include="TAS\IRWidget.cpp" />
@@ -379,6 +380,7 @@
     <QtMoc Include="Settings\PathPane.h" />
     <QtMoc Include="Settings\USBDeviceAddToWhitelistDialog.h" />
     <QtMoc Include="Settings\WiiPane.h" />
+    <QtMoc Include="SkylanderPortal\SkylanderPortalWindow.h" />
     <QtMoc Include="TAS\GCTASInputWindow.h" />
     <QtMoc Include="TAS\GBATASInputWindow.h" />
     <QtMoc Include="TAS\IRWidget.h" />

Source/Core/DolphinQt/MainWindow.cpp

@@ -111,6 +111,7 @@
 #include "DolphinQt/RiivolutionBootWidget.h"
 #include "DolphinQt/SearchBar.h"
 #include "DolphinQt/Settings.h"
+#include "DolphinQt/SkylanderPortal/SkylanderPortalWindow.h"
 #include "DolphinQt/TAS/GBATASInputWindow.h"
 #include "DolphinQt/TAS/GCTASInputWindow.h"
 #include "DolphinQt/TAS/WiiTASInputWindow.h"
@@ -520,6 +521,7 @@ void MainWindow::ConnectMenuBar()
   connect(m_menu_bar, &MenuBar::StartNetPlay, this, &MainWindow::ShowNetPlaySetupDialog);
   connect(m_menu_bar, &MenuBar::BrowseNetPlay, this, &MainWindow::ShowNetPlayBrowser);
   connect(m_menu_bar, &MenuBar::ShowFIFOPlayer, this, &MainWindow::ShowFIFOPlayer);
+  connect(m_menu_bar, &MenuBar::ShowSkylanderPortal, this, &MainWindow::ShowSkylanderPortal);
   connect(m_menu_bar, &MenuBar::ConnectWiiRemote, this, &MainWindow::OnConnectWiiRemote);
 
   // Movie
@@ -1301,6 +1303,18 @@ void MainWindow::ShowFIFOPlayer()
   m_fifo_window->activateWindow();
 }
 
+void MainWindow::ShowSkylanderPortal()
+{
+  if (!m_skylander_window)
+  {
+    m_skylander_window = new SkylanderPortalWindow;
+  }
+
+  m_skylander_window->show();
+  m_skylander_window->raise();
+  m_skylander_window->activateWindow();
+}
+
 void MainWindow::StateLoad()
 {
   QString path =

Source/Core/DolphinQt/MainWindow.h

@@ -43,6 +43,7 @@ class RegisterWidget;
 class RenderWidget;
 class SearchBar;
 class SettingsWindow;
+class SkylanderPortalWindow;
 class ThreadWidget;
 class ToolBar;
 class WatchWidget;
@@ -159,6 +160,7 @@ private:
   void ShowNetPlaySetupDialog();
   void ShowNetPlayBrowser();
   void ShowFIFOPlayer();
+  void ShowSkylanderPortal();
   void ShowMemcardManager();
   void ShowResourcePackManager();
   void ShowCheatsManager();
@@ -222,6 +224,7 @@ private:
   SettingsWindow* m_settings_window = nullptr;
   GraphicsWindow* m_graphics_window = nullptr;
   FIFOPlayerWindow* m_fifo_window = nullptr;
+  SkylanderPortalWindow* m_skylander_window = nullptr;
   MappingWindow* m_hotkey_window = nullptr;
   FreeLookWindow* m_freelook_window = nullptr;
 

Source/Core/DolphinQt/MenuBar.cpp

@@ -221,6 +221,8 @@ void MenuBar::AddToolsMenu()
 
   tools_menu->addAction(tr("FIFO Player"), this, &MenuBar::ShowFIFOPlayer);
 
+  tools_menu->addAction(tr("&Skylanders Portal"), this, &MenuBar::ShowSkylanderPortal);
+
   tools_menu->addSeparator();
 
   tools_menu->addAction(tr("Start &NetPlay..."), this, &MenuBar::StartNetPlay);

Source/Core/DolphinQt/MenuBar.h

@@ -89,6 +89,7 @@ signals:
   void ShowAboutDialog();
   void ShowCheatsManager();
   void ShowResourcePackManager();
+  void ShowSkylanderPortal();
   void ConnectWiiRemote(int id);
 
   // Options