nsyshid: Add infrastructure and support for emulating Skylander Portal (#971)

src/gui/CMakeLists.txt

@@ -101,6 +101,8 @@ add_library(CemuGui
   PairingDialog.h
   TitleManager.cpp
   TitleManager.h
+  EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp
+  EmulatedUSBDevices/EmulatedUSBDeviceFrame.h
   windows/PPCThreadsViewer
   windows/PPCThreadsViewer/DebugPPCThreadsWindow.cpp
   windows/PPCThreadsViewer/DebugPPCThreadsWindow.h

src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.cpp

@@ -0,0 +1,354 @@
+#include "gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h"
+
+#include <algorithm>
+#include <random>
+
+#include "config/CemuConfig.h"
+#include "gui/helpers/wxHelpers.h"
+#include "gui/wxHelper.h"
+#include "util/helpers/helpers.h"
+
+#include "Cafe/OS/libs/nsyshid/nsyshid.h"
+#include "Cafe/OS/libs/nsyshid/Skylander.h"
+
+#include "Common/FileStream.h"
+
+#include <wx/arrstr.h>
+#include <wx/button.h>
+#include <wx/checkbox.h>
+#include <wx/combobox.h>
+#include <wx/filedlg.h>
+#include <wx/msgdlg.h>
+#include <wx/notebook.h>
+#include <wx/panel.h>
+#include <wx/sizer.h>
+#include <wx/statbox.h>
+#include <wx/stattext.h>
+#include <wx/stream.h>
+#include <wx/textctrl.h>
+#include <wx/textentry.h>
+#include <wx/valnum.h>
+#include <wx/wfstream.h>
+
+#include "resource/embedded/resources.h"
+#include "EmulatedUSBDeviceFrame.h"
+
+EmulatedUSBDeviceFrame::EmulatedUSBDeviceFrame(wxWindow* parent)
+	: wxFrame(parent, wxID_ANY, _("Emulated USB Devices"), wxDefaultPosition,
+			  wxDefaultSize, wxDEFAULT_FRAME_STYLE | wxTAB_TRAVERSAL)
+{
+	SetIcon(wxICON(X_BOX));
+
+	auto& config = GetConfig();
+
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+	auto* notebook = new wxNotebook(this, wxID_ANY);
+
+	notebook->AddPage(AddSkylanderPage(notebook), _("Skylanders Portal"));
+
+	sizer->Add(notebook, 1, wxEXPAND | wxALL, 2);
+
+	SetSizerAndFit(sizer);
+	Layout();
+	Centre(wxBOTH);
+}
+
+EmulatedUSBDeviceFrame::~EmulatedUSBDeviceFrame() {}
+
+wxPanel* EmulatedUSBDeviceFrame::AddSkylanderPage(wxNotebook* notebook)
+{
+	auto* panel = new wxPanel(notebook);
+	auto* panelSizer = new wxBoxSizer(wxVERTICAL);
+	auto* box = new wxStaticBox(panel, wxID_ANY, _("Skylanders Manager"));
+	auto* boxSizer = new wxStaticBoxSizer(box, wxVERTICAL);
+
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	m_emulatePortal =
+		new wxCheckBox(box, wxID_ANY, _("Emulate Skylander Portal"));
+	m_emulatePortal->SetValue(
+		GetConfig().emulated_usb_devices.emulate_skylander_portal);
+	m_emulatePortal->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent&) {
+		GetConfig().emulated_usb_devices.emulate_skylander_portal =
+			m_emulatePortal->IsChecked();
+		g_config.Save();
+	});
+	row->Add(m_emulatePortal, 1, wxEXPAND | wxALL, 2);
+	boxSizer->Add(row, 1, wxEXPAND | wxALL, 2);
+	for (int i = 0; i < 16; i++)
+	{
+		boxSizer->Add(AddSkylanderRow(i, box), 1, wxEXPAND | wxALL, 2);
+	}
+	panelSizer->Add(boxSizer, 1, wxEXPAND | wxALL, 2);
+	panel->SetSizerAndFit(panelSizer);
+
+	return panel;
+}
+
+wxBoxSizer* EmulatedUSBDeviceFrame::AddSkylanderRow(uint8 row_number,
+													wxStaticBox* box)
+{
+	auto* row = new wxBoxSizer(wxHORIZONTAL);
+
+	row->Add(new wxStaticText(box, wxID_ANY,
+							  fmt::format("{} {}", _("Skylander").ToStdString(),
+										  (row_number + 1))),
+			 1, wxEXPAND | wxALL, 2);
+	m_skylanderSlots[row_number] =
+		new wxTextCtrl(box, wxID_ANY, _("None"), wxDefaultPosition, wxDefaultSize,
+					   wxTE_READONLY);
+	m_skylanderSlots[row_number]->SetMinSize(wxSize(150, -1));
+	m_skylanderSlots[row_number]->Disable();
+	row->Add(m_skylanderSlots[row_number], 1, wxEXPAND | wxALL, 2);
+	auto* loadButton = new wxButton(box, wxID_ANY, _("Load"));
+	loadButton->Bind(wxEVT_BUTTON, [row_number, this](wxCommandEvent&) {
+		LoadSkylander(row_number);
+	});
+	auto* createButton = new wxButton(box, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [row_number, this](wxCommandEvent&) {
+		CreateSkylander(row_number);
+	});
+	auto* clearButton = new wxButton(box, wxID_ANY, _("Clear"));
+	clearButton->Bind(wxEVT_BUTTON, [row_number, this](wxCommandEvent&) {
+		ClearSkylander(row_number);
+	});
+	row->Add(loadButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(createButton, 1, wxEXPAND | wxALL, 2);
+	row->Add(clearButton, 1, wxEXPAND | wxALL, 2);
+
+	return row;
+}
+
+void EmulatedUSBDeviceFrame::LoadSkylander(uint8 slot)
+{
+	wxFileDialog openFileDialog(this, _("Open Skylander dump"), "", "",
+								"Skylander files (*.sky;*.bin;*.dump;*.dmp)|*.sky;*.bin;*.dump;*.dmp",
+								wxFD_OPEN | wxFD_FILE_MUST_EXIST);
+	if (openFileDialog.ShowModal() != wxID_OK || openFileDialog.GetPath().empty())
+		return;
+
+	LoadSkylanderPath(slot, openFileDialog.GetPath());
+}
+
+void EmulatedUSBDeviceFrame::LoadSkylanderPath(uint8 slot, wxString path)
+{
+	std::unique_ptr<FileStream> skyFile(FileStream::openFile2(_utf8ToPath(path.utf8_string()), true));
+	if (!skyFile)
+	{
+		wxMessageDialog open_error(this, "Error Opening File: " + path.c_str());
+		open_error.ShowModal();
+		return;
+	}
+
+	std::array<uint8, 0x40 * 0x10> fileData;
+	if (skyFile->readData(fileData.data(), fileData.size()) != fileData.size())
+	{
+		wxMessageDialog open_error(this, "Failed to read file! File was too small");
+		open_error.ShowModal();
+		return;
+	}
+	ClearSkylander(slot);
+
+	uint16 skyId = uint16(fileData[0x11]) << 8 | uint16(fileData[0x10]);
+	uint16 skyVar = uint16(fileData[0x1D]) << 8 | uint16(fileData[0x1C]);
+
+	uint8 portalSlot = nsyshid::g_skyportal.LoadSkylander(fileData.data(),
+															std::move(skyFile));
+	m_skySlots[slot] = std::tuple(portalSlot, skyId, skyVar);
+	UpdateSkylanderEdits();
+}
+
+void EmulatedUSBDeviceFrame::CreateSkylander(uint8 slot)
+{
+	CreateSkylanderDialog create_dlg(this, slot);
+	create_dlg.ShowModal();
+	if (create_dlg.GetReturnCode() == 1)
+	{
+		LoadSkylanderPath(slot, create_dlg.GetFilePath());
+	}
+}
+
+void EmulatedUSBDeviceFrame::ClearSkylander(uint8 slot)
+{
+	if (auto slotInfos = m_skySlots[slot])
+	{
+		auto [curSlot, id, var] = slotInfos.value();
+		nsyshid::g_skyportal.RemoveSkylander(curSlot);
+		m_skySlots[slot] = {};
+		UpdateSkylanderEdits();
+	}
+}
+
+CreateSkylanderDialog::CreateSkylanderDialog(wxWindow* parent, uint8 slot)
+	: wxDialog(parent, wxID_ANY, _("Skylander Figure Creator"), wxDefaultPosition, wxSize(500, 150))
+{
+	auto* sizer = new wxBoxSizer(wxVERTICAL);
+
+	auto* comboRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* comboBox = new wxComboBox(this, wxID_ANY);
+	comboBox->Append("---Select---", reinterpret_cast<void*>(0xFFFFFFFF));
+	wxArrayString filterlist;
+	for (auto it = nsyshid::listSkylanders.begin(); it != nsyshid::listSkylanders.end(); it++)
+	{
+		const uint32 variant = uint32(uint32(it->first.first) << 16) | uint32(it->first.second);
+		comboBox->Append(it->second, reinterpret_cast<void*>(variant));
+		filterlist.Add(it->second);
+	}
+	comboBox->SetSelection(0);
+	bool enabled = comboBox->AutoComplete(filterlist);
+	comboRow->Add(comboBox, 1, wxEXPAND | wxALL, 2);
+
+	auto* idVarRow = new wxBoxSizer(wxHORIZONTAL);
+
+	wxIntegerValidator<uint32> validator;
+
+	auto* labelId = new wxStaticText(this, wxID_ANY, "ID:");
+	auto* labelVar = new wxStaticText(this, wxID_ANY, "Variant:");
+	auto* editId = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+	auto* editVar = new wxTextCtrl(this, wxID_ANY, _("0"), wxDefaultPosition, wxDefaultSize, 0, validator);
+
+	idVarRow->Add(labelId, 1, wxALL, 5);
+	idVarRow->Add(editId, 1, wxALL, 5);
+	idVarRow->Add(labelVar, 1, wxALL, 5);
+	idVarRow->Add(editVar, 1, wxALL, 5);
+
+	auto* buttonRow = new wxBoxSizer(wxHORIZONTAL);
+
+	auto* createButton = new wxButton(this, wxID_ANY, _("Create"));
+	createButton->Bind(wxEVT_BUTTON, [editId, editVar, this](wxCommandEvent&) {
+		long longSkyId;
+		if (!editId->GetValue().ToLong(&longSkyId) || longSkyId > 0xFFFF)
+		{
+			wxMessageDialog id_error(this, "Error Converting ID!", "ID Entered is Invalid");
+			id_error.ShowModal();
+			return;
+		}
+		long longSkyVar;
+		if (!editVar->GetValue().ToLong(&longSkyVar) || longSkyVar > 0xFFFF)
+		{
+			wxMessageDialog id_error(this, "Error Converting Variant!", "Variant Entered is Invalid");
+			id_error.ShowModal();
+			return;
+		}
+		uint16 skyId = longSkyId & 0xFFFF;
+		uint16 skyVar = longSkyVar & 0xFFFF;
+		const auto foundSky = nsyshid::listSkylanders.find(std::make_pair(skyId, skyVar));
+		wxString predefName;
+		if (foundSky != nsyshid::listSkylanders.end())
+		{
+			predefName = foundSky->second + ".sky";
+		}
+		else
+		{
+			predefName = wxString::Format(_("Unknown(%i %i).sky"), skyId, skyVar);
+		}
+		wxFileDialog
+			saveFileDialog(this, _("Create Skylander file"), "", predefName,
+						   "SKY files (*.sky)|*.sky", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
+
+		if (saveFileDialog.ShowModal() == wxID_CANCEL)
+			return;
+
+		m_filePath = saveFileDialog.GetPath();
+
+		wxFileOutputStream output_stream(saveFileDialog.GetPath());
+		if (!output_stream.IsOk())
+		{
+			wxMessageDialog saveError(this, "Error Creating Skylander File");
+			return;
+		}
+
+		std::array<uint8, 0x40 * 0x10> data{};
+
+		uint32 first_block = 0x690F0F0F;
+		uint32 other_blocks = 0x69080F7F;
+		memcpy(&data[0x36], &first_block, sizeof(first_block));
+		for (size_t index = 1; index < 0x10; index++)
+		{
+			memcpy(&data[(index * 0x40) + 0x36], &other_blocks, sizeof(other_blocks));
+		}
+		std::random_device rd;
+		std::mt19937 mt(rd());
+		std::uniform_int_distribution<int> dist(0, 255);
+		data[0] = dist(mt);
+		data[1] = dist(mt);
+		data[2] = dist(mt);
+		data[3] = dist(mt);
+		data[4] = data[0] ^ data[1] ^ data[2] ^ data[3];
+		data[5] = 0x81;
+		data[6] = 0x01;
+		data[7] = 0x0F;
+
+		memcpy(&data[0x10], &skyId, sizeof(skyId));
+		memcpy(&data[0x1C], &skyVar, sizeof(skyVar));
+
+		uint16 crc = nsyshid::g_skyportal.SkylanderCRC16(0xFFFF, data.data(), 0x1E);
+
+		memcpy(&data[0x1E], &crc, sizeof(crc));
+
+		output_stream.SeekO(0);
+		output_stream.WriteAll(data.data(), data.size());
+		output_stream.Close();
+
+		this->EndModal(1);
+	});
+	auto* cancelButton = new wxButton(this, wxID_ANY, _("Cancel"));
+	cancelButton->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) {
+		this->EndModal(0);
+	});
+
+	comboBox->Bind(wxEVT_COMBOBOX, [comboBox, editId, editVar, this](wxCommandEvent&) {
+		const uint64 sky_info = reinterpret_cast<uint64>(comboBox->GetClientData(comboBox->GetSelection()));
+		if (sky_info != 0xFFFFFFFF)
+		{
+			const uint16 skyId = sky_info >> 16;
+			const uint16 skyVar = sky_info & 0xFFFF;
+
+			editId->SetValue(wxString::Format(wxT("%i"), skyId));
+			editVar->SetValue(wxString::Format(wxT("%i"), skyVar));
+		}
+	});
+
+	buttonRow->Add(createButton, 1, wxALL, 5);
+	buttonRow->Add(cancelButton, 1, wxALL, 5);
+
+	sizer->Add(comboRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(idVarRow, 1, wxEXPAND | wxALL, 2);
+	sizer->Add(buttonRow, 1, wxEXPAND | wxALL, 2);
+
+	this->SetSizer(sizer);
+	this->Centre(wxBOTH);
+}
+
+wxString CreateSkylanderDialog::GetFilePath() const
+{
+	return m_filePath;
+}
+
+void EmulatedUSBDeviceFrame::UpdateSkylanderEdits()
+{
+	for (auto i = 0; i < 16; i++)
+	{
+		std::string displayString;
+		if (auto sd = m_skySlots[i])
+		{
+			auto [portalSlot, skyId, skyVar] = sd.value();
+			auto foundSky = nsyshid::listSkylanders.find(std::make_pair(skyId, skyVar));
+			if (foundSky != nsyshid::listSkylanders.end())
+			{
+				displayString = foundSky->second;
+			}
+			else
+			{
+				displayString = fmt::format("Unknown (Id:{} Var:{})", skyId, skyVar);
+			}
+		}
+		else
+		{
+			displayString = "None";
+		}
+
+		m_skylanderSlots[i]->ChangeValue(displayString);
+	}
+}

src/gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <array>
+
+#include <wx/dialog.h>
+#include <wx/frame.h>
+
+class wxBoxSizer;
+class wxCheckBox;
+class wxFlexGridSizer;
+class wxNotebook;
+class wxPanel;
+class wxStaticBox;
+class wxString;
+class wxTextCtrl;
+
+class EmulatedUSBDeviceFrame : public wxFrame {
+  public:
+	EmulatedUSBDeviceFrame(wxWindow* parent);
+	~EmulatedUSBDeviceFrame();
+
+  private:
+	wxCheckBox* m_emulatePortal;
+	std::array<wxTextCtrl*, 16> m_skylanderSlots;
+	std::array<std::optional<std::tuple<uint8, uint16, uint16>>, 16> m_skySlots;
+
+	wxPanel* AddSkylanderPage(wxNotebook* notebook);
+	wxBoxSizer* AddSkylanderRow(uint8 row_number, wxStaticBox* box);
+	void LoadSkylander(uint8 slot);
+	void LoadSkylanderPath(uint8 slot, wxString path);
+	void CreateSkylander(uint8 slot);
+	void ClearSkylander(uint8 slot);
+	void UpdateSkylanderEdits();
+};
+class CreateSkylanderDialog : public wxDialog {
+  public:
+	explicit CreateSkylanderDialog(wxWindow* parent, uint8 slot);
+	wxString GetFilePath() const;
+
+  protected:
+	wxString m_filePath;
+};

src/gui/MainWindow.cpp

@@ -30,6 +30,7 @@
 #include "Cafe/Filesystem/FST/FST.h"
 
 #include "gui/TitleManager.h"
+#include "gui/EmulatedUSBDevices/EmulatedUSBDeviceFrame.h"
 
 #include "Cafe/CafeSystem.h"
 
@@ -110,6 +111,7 @@ enum
 	MAINFRAME_MENU_ID_TOOLS_MEMORY_SEARCHER = 20600,
 	MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER,
 	MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER,
+	MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES,
 	// cpu
 	// cpu->timer speed
 	MAINFRAME_MENU_ID_TIMER_SPEED_1X = 20700,
@@ -188,6 +190,7 @@ EVT_MENU(MAINFRAME_MENU_ID_OPTIONS_INPUT, MainWindow::OnOptionsInput)
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_MEMORY_SEARCHER, MainWindow::OnToolsInput)
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER, MainWindow::OnToolsInput)
 EVT_MENU(MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER, MainWindow::OnToolsInput)
+EVT_MENU(MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES, MainWindow::OnToolsInput)
 // cpu menu
 EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_8X, MainWindow::OnDebugSetting)
 EVT_MENU(MAINFRAME_MENU_ID_TIMER_SPEED_4X, MainWindow::OnDebugSetting)
@@ -1515,6 +1518,29 @@ void MainWindow::OnToolsInput(wxCommandEvent& event)
 				});
 			m_title_manager->Show();
 		}
+		break;
+	}
+	case MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES:
+	{
+		if (m_usb_devices)
+		{
+			m_usb_devices->Show(true);
+			m_usb_devices->Raise();
+			m_usb_devices->SetFocus();
+		}
+		else
+		{
+			m_usb_devices = new EmulatedUSBDeviceFrame(this);
+			m_usb_devices->Bind(wxEVT_CLOSE_WINDOW, [this](wxCloseEvent& event)
+				{
+					if (event.CanVeto()) {
+						m_usb_devices->Show(false);
+						event.Veto();
+					}
+				});
+			m_usb_devices->Show(true);
+		}
+		break;
 	}
 	break;
 	}
@@ -2166,6 +2192,7 @@ void MainWindow::RecreateMenu()
 	m_memorySearcherMenuItem->Enable(false);
 	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_TITLE_MANAGER, _("&Title Manager"));
 	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_DOWNLOAD_MANAGER, _("&Download Manager"));
+	toolsMenu->Append(MAINFRAME_MENU_ID_TOOLS_EMULATED_USB_DEVICES, _("&Emulated USB Devices"));
 
 	m_menuBar->Append(toolsMenu, _("&Tools"));
 

src/gui/MainWindow.h

@@ -22,6 +22,7 @@ struct GameEntry;
 class DiscordPresence;
 class TitleManager;
 class GraphicPacksWindow2;
+class EmulatedUSBDeviceFrame;
 class wxLaunchGameEvent;
 
 wxDECLARE_EVENT(wxEVT_LAUNCH_GAME, wxLaunchGameEvent);
@@ -164,6 +165,7 @@ private:
 
 	MemorySearcherTool* m_toolWindow = nullptr;
 	TitleManager* m_title_manager = nullptr;
+	EmulatedUSBDeviceFrame* m_usb_devices = nullptr;
 	PadViewFrame* m_padView = nullptr;
 	GraphicPacksWindow2* m_graphic_pack_window = nullptr;