Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-19 23:12:11 +03:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Remove uwp specific sources

Browse Source
This commit is contained in:
Miodrag Milanovic 2021-10-26 11:28:11 +02:00
parent 9d61cf33d1
commit 67389f4cbd
10 changed files with 0 additions and 2559 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
scripts/src/osd/modules.lua
View File

@ -104,7 +104,6 @@ function osdmodulesbuild()
MAME_DIR .. "src/osd/modules/input/input_xinput.cpp",
MAME_DIR .. "src/osd/modules/input/input_xinput.h",
MAME_DIR .. "src/osd/modules/input/input_winhybrid.cpp",
MAME_DIR .. "src/osd/modules/input/input_uwp.cpp",
MAME_DIR .. "src/osd/modules/input/input_mac.cpp",
MAME_DIR .. "src/osd/modules/output/output_module.h",
MAME_DIR .. "src/osd/modules/output/none.cpp",

652
src/osd/modules/input/input_uwp.cpp
View File

@ -1,652 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Brad Hughes
//============================================================
//
// input_uwp.cpp - UWP input implementation
//
//============================================================
#include "input_module.h"
#include "modules/osdmodule.h"
#if defined(OSD_UWP)
#include <agile.h>
#include <ppltasks.h>
#include <collection.h>
#undef interface
// MAME headers
#include "emu.h"
#include "uiinput.h"
#include "strconv.h"
// MAMEOS headers
#include "winmain.h"
#include "input_common.h"
#include "input_windows.h"
namespace {
#define UWP_BUTTON_COUNT 32
using namespace concurrency;
using namespace Windows::UI::Core;
using namespace Windows::Foundation;
using namespace Windows::Foundation::Collections;
using namespace Windows::Gaming::Input;
//============================================================
// UWP Base device/module implementation
//============================================================
//============================================================
// UwpInputDevice - base class for implementing an input
// device in C++/CX. To be used with uwp_input_device
//============================================================
private ref class UwpInputDevice
{
private:
running_machine & m_machine;
std::string m_name;
std::string m_id;
input_device_class m_devclass;
input_module & m_module;
input_device *m_inputdevice;
internal:
UwpInputDevice(running_machine &machine, std::string &&name, std::string &&id, input_device_class deviceclass, input_module &module) :
m_machine(machine),
m_name(std::move(name)),
m_id(std::move(id)),
m_devclass(deviceclass),
m_module(module),
m_inputdevice(nullptr)
{
}
property running_machine & Machine
{
running_machine & get() { return m_machine; }
}
property const std::string & Name
{
const std::string & get() { return m_name; }
}
property const std::string & Id
{
const std::string & get() { return m_id; }
}
property input_device_class DeviceClass
{
input_device_class get() { return m_devclass; }
}
property input_module & Module
{
input_module & get() { return m_module; }
}
property input_device* InputDevice
{
input_device* get() { return m_inputdevice; }
void set(input_device* value) { m_inputdevice = value; }
}
virtual void Poll()
{
}
virtual void Reset()
{
}
};
//============================================================
// uwp_input_device - a device that can be used to wrap a
// C++/CX ref class for an input device implementation
//============================================================
class uwp_input_device : public device_info
{
private:
UwpInputDevice ^m_wrapped_device;
public:
uwp_input_device(UwpInputDevice ^device) :
device_info(device->Machine, std::string(device->Name), std::string(device->Id), device->DeviceClass, device->Module),
m_wrapped_device(device)
{
}
void poll() override
{
m_wrapped_device->Poll();
}
void reset() override
{
m_wrapped_device->Reset();
}
};
//============================================================
// UwpInputModule - a base class that can be used to
// implement an input module with a C++/CX class.
// normally used with uwp_wininput_module
//============================================================
class uwp_input_module;
private ref class UwpInputModule
{
private:
const std::string m_type;
const std::string m_name;
uwp_input_module *m_module;
internal:
UwpInputModule(std::string &&type, std::string &&name) :
m_type(std::move(type)),
m_name(std::move(name)),
m_module(nullptr)
{
}
property const std::string & Type
{
const std::string & get() { return m_type; }
}
property const std::string & Name
{
const std::string & get() { return m_name; }
}
property uwp_input_module * NativeModule
{
uwp_input_module * get() { return m_module; }
void set(uwp_input_module * value) { m_module = value; }
}
virtual void input_init(running_machine &machine)
{
}
};
//============================================================
// uwp_input_module - an input module that can be
// used to create an input module with a C++/CX ref class
//============================================================
class uwp_input_module : public wininput_module
{
private:
UwpInputModule^ m_refmodule;
public:
uwp_input_module(UwpInputModule^ refmodule) :
wininput_module(refmodule->Type.c_str(), refmodule->Name.c_str()),
m_refmodule(refmodule)
{
refmodule->NativeModule = this;
}
void input_init(running_machine &machine) override
{
m_refmodule->input_init(machine);
}
};
//============================================================
// UWP Keyboard Implementation
//============================================================
//============================================================
// UwpKeyboardDevice
//============================================================
private ref class UwpKeyboardDevice : public UwpInputDevice
{
private:
keyboard_state keyboard;
Platform::Agile<CoreWindow> m_coreWindow;
std::mutex m_state_lock;
internal:
UwpKeyboardDevice(Platform::Agile<CoreWindow> coreWindow, running_machine& machine, std::string &&name, std::string &&id, input_module &module) :
UwpInputDevice(machine, std::move(name), std::move(id), DEVICE_CLASS_KEYBOARD, module),
keyboard({{0}}),
m_coreWindow(coreWindow)
{
coreWindow->Dispatcher->AcceleratorKeyActivated += ref new TypedEventHandler<CoreDispatcher^, AcceleratorKeyEventArgs^>(this, &UwpKeyboardDevice::OnAcceleratorKeyActivated);
coreWindow->KeyDown += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &UwpKeyboardDevice::OnKeyDown);
coreWindow->KeyUp += ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &UwpKeyboardDevice::OnKeyUp);
coreWindow->CharacterReceived += ref new TypedEventHandler<CoreWindow^, CharacterReceivedEventArgs^>(this, &UwpKeyboardDevice::OnCharacterReceived);
}
void Reset() override
{
std::lock_guard<std::mutex> scope_lock(m_state_lock);
memset(&keyboard, 0, sizeof(keyboard));
}
void Configure()
{
keyboard_trans_table &table = keyboard_trans_table::instance();
// populate it indexed by the scancode
for (int keynum = KEY_UNKNOWN + 1; keynum < MAX_KEYS; keynum++)
{
input_item_id itemid = table.map_di_scancode_to_itemid(keynum);
const char *keyname = table.ui_label_for_mame_key(itemid);
char temp[256];
if (!keyname)
{
snprintf(temp, std::size(temp), "Scan%03d", keynum);
keyname = temp;
}
// add the item to the device
this->InputDevice->add_item(keyname, itemid, generic_button_get_state<std::uint8_t>, &keyboard.state[keynum]);
}
}
void OnKeyDown(CoreWindow^ win, KeyEventArgs^ args)
{
std::lock_guard<std::mutex> scope_lock(m_state_lock);
CorePhysicalKeyStatus status = args->KeyStatus;
int discancode = (status.ScanCode & 0x7f) | (status.IsExtendedKey ? 0x80 : 0x00);
keyboard.state[discancode] = 0x80;
}
void OnKeyUp(CoreWindow^ win, KeyEventArgs^ args)
{
std::lock_guard<std::mutex> scope_lock(m_state_lock);
CorePhysicalKeyStatus status = args->KeyStatus;
int discancode = (status.ScanCode & 0x7f) | (status.IsExtendedKey ? 0x80 : 0x00);
keyboard.state[discancode] = 0;
}
void OnCharacterReceived(CoreWindow ^sender, CharacterReceivedEventArgs ^args)
{
this->Machine.ui_input().push_char_event(osd_common_t::s_window_list.front()->target(), args->KeyCode);
}
void OnAcceleratorKeyActivated(CoreDispatcher ^sender, AcceleratorKeyEventArgs ^args)
{
std::lock_guard<std::mutex> scope_lock(m_state_lock);
auto eventType = args->EventType;
if (eventType == CoreAcceleratorKeyEventType::SystemKeyDown ||
eventType == CoreAcceleratorKeyEventType::SystemKeyUp)
{
CorePhysicalKeyStatus status = args->KeyStatus;
int discancode = (status.ScanCode & 0x7f) | (status.IsExtendedKey ? 0x80 : 0x00);
keyboard.state[discancode] =
eventType == CoreAcceleratorKeyEventType::SystemKeyDown ? 0x80 : 0;
}
}
};
//============================================================
// UwpKeyboardModule
//============================================================
private ref class UwpKeyboardModule : public UwpInputModule
{
private:
running_machine *m_machine;
internal:
UwpKeyboardModule() : UwpInputModule(OSD_KEYBOARDINPUT_PROVIDER, "uwp")
{
}
void input_init(running_machine &machine) override
{
auto first_window = std::static_pointer_cast<uwp_window_info>(osd_common_t::s_window_list.front());
auto coreWindow = first_window->platform_window();
// allocate the UWP implementation of the device object
UwpKeyboardDevice ^refdevice = ref new UwpKeyboardDevice(coreWindow, machine, "UWP Keyboard 1", "UWP Keyboard 1", *this->NativeModule);
// Allocate the wrapper and add it to the list
auto created_devinfo = std::make_unique<uwp_input_device>(refdevice);
uwp_input_device &devinfo = NativeModule->devicelist()->add_device<uwp_input_device>(machine, std::move(created_devinfo));
// Give the UWP implementation a handle to the input_device
refdevice->InputDevice = devinfo.device();
// Configure the device
refdevice->Configure();
}
};
//============================================================
// uwp_keyboard_module
//============================================================
class uwp_keyboard_module : public uwp_input_module
{
public:
uwp_keyboard_module()
: uwp_input_module(ref new UwpKeyboardModule())
{
}
};
// default axis names
static const char *const uwp_axis_name[] =
{
"LSX",
"LSY",
"RSX",
"RSY"
};
static const input_item_id uwp_axis_ids[] =
{
ITEM_ID_XAXIS,
ITEM_ID_YAXIS,
ITEM_ID_RXAXIS,
ITEM_ID_RYAXIS
};
struct gamepad_state
{
BYTE buttons[UWP_BUTTON_COUNT];
LONG left_trigger;
LONG right_trigger;
LONG left_thumb_x;
LONG left_thumb_y;
LONG right_thumb_x;
LONG right_thumb_y;
};
// Maps different UWP GameControllerButtonLabels to a halfway-sane input_item_id in many cases
static input_item_id buttonlabel_to_itemid[] =
{
input_item_id::ITEM_ID_INVALID, // GameControllerButtonLabel::None
input_item_id::ITEM_ID_SELECT, // GameControllerButtonLabel::XboxBack
input_item_id::ITEM_ID_START, // GameControllerButtonLabel::XboxStart
input_item_id::ITEM_ID_START, // GameControllerButtonLabel::XboxMenu
input_item_id::ITEM_ID_SELECT, // GameControllerButtonLabel::XboxView
input_item_id::ITEM_ID_HAT1UP, // GameControllerButtonLabel::XboxUp
input_item_id::ITEM_ID_HAT1DOWN, // GameControllerButtonLabel::XboxDown
input_item_id::ITEM_ID_HAT1LEFT, // GameControllerButtonLabel::XboxLeft
input_item_id::ITEM_ID_HAT1RIGHT, // GameControllerButtonLabel::XboxRight
input_item_id::ITEM_ID_BUTTON1, // GameControllerButtonLabel::XboxA
input_item_id::ITEM_ID_BUTTON2, // GameControllerButtonLabel::XboxB
input_item_id::ITEM_ID_BUTTON3, // GameControllerButtonLabel::XboxX
input_item_id::ITEM_ID_BUTTON4, // GameControllerButtonLabel::XboxY
input_item_id::ITEM_ID_BUTTON5, // GameControllerButtonLabel::XboxLeftBumper
input_item_id::ITEM_ID_ZAXIS, // GameControllerButtonLabel::XboxLeftTrigger
input_item_id::ITEM_ID_BUTTON7, // GameControllerButtonLabel::XboxLeftStickButton
input_item_id::ITEM_ID_BUTTON6, // GameControllerButtonLabel::XboxRightBumper
input_item_id::ITEM_ID_RZAXIS, // GameControllerButtonLabel::XboxRightTrigger
input_item_id::ITEM_ID_BUTTON8, // GameControllerButtonLabel::XboxRightStickButton
input_item_id::ITEM_ID_BUTTON9, // GameControllerButtonLabel::XboxPaddle1
input_item_id::ITEM_ID_BUTTON10, // GameControllerButtonLabel::XboxPaddle2
input_item_id::ITEM_ID_BUTTON11, // GameControllerButtonLabel::XboxPaddle3
input_item_id::ITEM_ID_BUTTON12, // GameControllerButtonLabel::XboxPaddle4
input_item_id::ITEM_ID_INVALID, // GameControllerButtonLabel_Mode
input_item_id::ITEM_ID_SELECT, // GameControllerButtonLabel_Select
input_item_id::ITEM_ID_START, // GameControllerButtonLabel_Menu
input_item_id::ITEM_ID_SELECT, // GameControllerButtonLabel_View
input_item_id::ITEM_ID_SELECT, // GameControllerButtonLabel_Back
input_item_id::ITEM_ID_START, // GameControllerButtonLabel_Start
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Options
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Share
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Up
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Down
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Left
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Right
input_item_id::ITEM_ID_BUTTON1, // GameControllerButtonLabel_LetterA
input_item_id::ITEM_ID_BUTTON2, // GameControllerButtonLabel_LetterB
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_LetterC
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_LetterL
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_LetterR
input_item_id::ITEM_ID_BUTTON3, // GameControllerButtonLabel_LetterX
input_item_id::ITEM_ID_BUTTON4, // GameControllerButtonLabel_LetterY
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_LetterZ
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Cross
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Circle
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Square
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Triangle
input_item_id::ITEM_ID_BUTTON5, // GameControllerButtonLabel_LeftBumper
input_item_id::ITEM_ID_ZAXIS, // GameControllerButtonLabel_LeftTrigger
input_item_id::ITEM_ID_BUTTON7, // GameControllerButtonLabel_LeftStickButton
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Left1
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Left2
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Left3
input_item_id::ITEM_ID_BUTTON6, // GameControllerButtonLabel_RightBumper
input_item_id::ITEM_ID_RZAXIS, // GameControllerButtonLabel_RightTrigger
input_item_id::ITEM_ID_BUTTON8, // GameControllerButtonLabel_RightStickButton
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Right1
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Right2
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Right3
input_item_id::ITEM_ID_BUTTON9, // GameControllerButtonLabel_Paddle1
input_item_id::ITEM_ID_BUTTON10, // GameControllerButtonLabel_Paddle2
input_item_id::ITEM_ID_BUTTON11, // GameControllerButtonLabel_Paddle3
input_item_id::ITEM_ID_BUTTON12, // GameControllerButtonLabel_Paddle4
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Plus
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Minus
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_DownLeftArrow
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_DialLeft
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_DialRight
input_item_id::ITEM_ID_OTHER_SWITCH, // GameControllerButtonLabel_Suspension
};
//============================================================
// UwpJoystickDevice
//============================================================
private ref class UwpJoystickDevice : public UwpInputDevice
{
private:
Gamepad ^m_pad;
bool m_configured;
gamepad_state state;
internal:
UwpJoystickDevice(Gamepad^ pad, running_machine &machine, const char *name, const char *id, input_module &module)
: UwpInputDevice(machine, name, id, DEVICE_CLASS_JOYSTICK, module),
m_pad(pad),
m_configured(false),
state({0})
{}
void Poll() override
{
// If the device hasn't been configured, don't poll
if (!m_configured)
return;
GamepadReading reading = m_pad->GetCurrentReading();
for (int butnum = 0; butnum < UWP_BUTTON_COUNT; butnum++)
{
GamepadButtons currentButton = GamepadButtons(1 << butnum);
state.buttons[butnum] = (reading.Buttons & currentButton) != GamepadButtons::None ? 0xFF : 0;
}
// Now grab the axis values
// Each of the thumbstick axis members is a signed value between -32768 and 32767 describing the position of the thumbstick
// However, the Y axis values are inverted from what MAME expects, so negate the value
state.left_thumb_x = normalize_absolute_axis(reading.LeftThumbstickX, -1, 1);
state.left_thumb_y = -normalize_absolute_axis(reading.LeftThumbstickY, -1, 1);
state.right_thumb_x = normalize_absolute_axis(reading.RightThumbstickX, -1, 1);
state.right_thumb_y = -normalize_absolute_axis(reading.RightThumbstickY, -1, 1);
// Get the trigger values
state.left_trigger = normalize_absolute_axis(reading.LeftTrigger, 0.0, 1.0);
state.right_trigger = normalize_absolute_axis(reading.RightTrigger, 0.0, 1.0);
// For the UI, triggering UI_CONFIGURE is odd. It requires a EVENT_CHAR first
static constexpr int menuhotkey = (int)(GamepadButtons::View | GamepadButtons::X);
if (((int)reading.Buttons & menuhotkey) == menuhotkey)
{
ui_event uiev;
memset(&uiev, 0, sizeof(uiev));
uiev.event_type = ui_event::IME_CHAR;
this->Machine.ui_input().push_event(uiev);
}
}
void Reset() override
{
memset(&state, 0, sizeof(state));
}
void Configure()
{
// If the device has already been configured, don't do it again
if (m_configured)
return;
GamepadReading r = m_pad->GetCurrentReading();
// Add the axes
for (int axisnum = 0; axisnum < 4; axisnum++)
{
this->InputDevice->add_item(
uwp_axis_name[axisnum],
uwp_axis_ids[axisnum],
generic_axis_get_state<LONG>,
&state.left_thumb_x + axisnum);
}
// populate the buttons
for (int butnum = 0; butnum < UWP_BUTTON_COUNT; butnum++)
{
GamepadButtons button = GamepadButtons(1 << butnum);
auto label = m_pad->GetButtonLabel(button);
if (label != GameControllerButtonLabel::None)
{
std::string desc = osd::text::from_wstring(label.ToString()->Data());
this->InputDevice->add_item(
desc.c_str(),
buttonlabel_to_itemid[static_cast<int>(label)],
generic_button_get_state<BYTE>,
&state.buttons[butnum]);
}
}
this->InputDevice->add_item(
"Left Trigger",
ITEM_ID_ZAXIS,
generic_axis_get_state<LONG>,
&state.left_trigger);
this->InputDevice->add_item(
"Right Trigger",
ITEM_ID_RZAXIS,
generic_axis_get_state<LONG>,
&state.right_trigger);
m_configured = true;
}
};
//============================================================
// UwpJoystickModule
//============================================================
private ref class UwpJoystickModule : public UwpInputModule
{
private:
boolean m_joysticks_discovered;
internal:
UwpJoystickModule()
: UwpInputModule(OSD_JOYSTICKINPUT_PROVIDER, "uwp"),
m_joysticks_discovered(false)
{
}
void input_init(running_machine &machine) override
{
PerformGamepadDiscovery();
auto pads = Gamepad::Gamepads;
int padindex = 0;
std::for_each(begin(pads), end(pads), [&](Gamepad^ pad)
{
std::ostringstream namestream;
namestream << "UWP Gamepad " << (padindex + 1);
auto name = namestream.str();
// allocate the UWP implementation of the device object
UwpJoystickDevice ^refdevice = ref new UwpJoystickDevice(pad, machine, name.c_str(), name.c_str(), *this->NativeModule);
// Allocate the wrapper and add it to the list
auto created_devinfo = std::make_unique<uwp_input_device>(refdevice);
auto &devinfo = NativeModule->devicelist()->add_device<uwp_input_device>(machine, std::move(created_devinfo));
// Give the UWP implementation a handle to the input_device
refdevice->InputDevice = devinfo->device();
// Configure the device
refdevice->Configure();
padindex++;
});
}
private:
void PerformGamepadDiscovery()
{
Gamepad::GamepadAdded += ref new EventHandler<Gamepad ^>(this, &UwpJoystickModule::OnGamepadAdded);
auto start = std::chrono::system_clock::now();
// We need to pause a bit and pump events so gamepads get discovered
while (std::chrono::system_clock::now() - start < std::chrono::milliseconds(1000))
CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
m_joysticks_discovered = true;
}
void OnGamepadAdded(Platform::Object ^sender, Gamepad ^pad)
{
if (m_joysticks_discovered)
{
osd_printf_error("Input: UWP Compatible %s gamepad plugged in AFTER discovery complete!\n", pad->IsWireless ? "Wireless" : "Wired");
}
else
{
osd_printf_verbose("Input: UWP Compatible %s gamepad discovered.\n", pad->IsWireless ? "Wireless" : "Wired");
}
}
};
//============================================================
// uwp_joystick_module
//============================================================
class uwp_joystick_module : public uwp_input_module
{
public:
uwp_joystick_module() : uwp_input_module(ref new UwpJoystickModule())
{
}
};
} // anonymous namespace
#else // defined(OSD_UWP)
MODULE_NOT_SUPPORTED(uwp_keyboard_module, OSD_KEYBOARDINPUT_PROVIDER, "uwp")
MODULE_NOT_SUPPORTED(uwp_joystick_module, OSD_JOYSTICKINPUT_PROVIDER, "uwp")
#endif // defined(OSD_UWP)
MODULE_DEFINITION(KEYBOARDINPUT_UWP, uwp_keyboard_module)
MODULE_DEFINITION(JOYSTICKINPUT_UWP, uwp_joystick_module)

207
src/osd/modules/lib/osdlib_uwp.cpp
View File

@ -1,207 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Olivier Galibert, R. Belmont, Brad Hughes
//============================================================
//
// sdlos_*.c - OS specific low level code
//
// SDLMAME by Olivier Galibert and R. Belmont
//
//============================================================
// MAME headers
#include "osdlib.h"
#include "osdcomm.h"
#include "osdcore.h"
#include "strconv.h"
#include <cstdio>
#include <cstdlib>
#include <map>
#include <memory>
#include <windows.h>
#include <memoryapi.h>
#include <wrl\client.h>
using namespace Platform;
using namespace Windows::ApplicationModel::DataTransfer;
using namespace Windows::Foundation;
//============================================================
// GLOBAL VARIABLES
//============================================================
std::map<const char *, std::unique_ptr<char>> g_runtime_environment;
//============================================================
// osd_getenv
//============================================================
const char *osd_getenv(const char *name)
{
for (auto iter = g_runtime_environment.begin(); iter != g_runtime_environment.end(); iter++)
{
if (stricmp(iter->first, name) == 0)
{
osd_printf_debug("ENVIRONMENT: Get %s = value: '%s'", name, iter->second.get());
return iter->second.get();
}
}
return nullptr;
}
//============================================================
// osd_setenv
//============================================================
int osd_setenv(const char *name, const char *value, int overwrite)
{
if (!overwrite)
{
if (osd_getenv(name) != nullptr)
return 0;
}
auto buf = std::make_unique<char>(strlen(name) + strlen(value) + 2);
sprintf(buf.get(), "%s=%s", name, value);
g_runtime_environment[name] = std::move(buf);
osd_printf_debug("ENVIRONMENT: Set %s to value: '%s'", name, buf.get());
return 0;
}
//============================================================
// osd_process_kill
//============================================================
void osd_process_kill()
{
TerminateProcess(GetCurrentProcess(), -1);
}
//============================================================
// osd_break_into_debugger
//============================================================
void osd_break_into_debugger(const char *message)
{
if (IsDebuggerPresent())
{
OutputDebugStringA(message);
__debugbreak();
}
}
//============================================================
// get_clipboard_text_by_format
//============================================================
static bool get_clipboard_text_by_format(std::string &result_text, UINT format, std::string (*convert)(LPCVOID data))
{
DataPackageView^ dataPackageView;
IAsyncOperation<String^>^ getTextOp;
String^ clipboardText;
dataPackageView = Clipboard::GetContent();
getTextOp = dataPackageView->GetTextAsync();
clipboardText = getTextOp->GetResults();
result_text = convert(clipboardText->Data());
return !result_text.empty();
}
//============================================================
// convert_wide
//============================================================
static std::string convert_wide(LPCVOID data)
{
return osd::text::from_wstring((LPCWSTR) data);
}
//============================================================
// convert_ansi
//============================================================
static std::string convert_ansi(LPCVOID data)
{
return osd::text::from_astring((LPCSTR) data);
}
//============================================================
// osd_get_clipboard_text
//============================================================
std::string osd_get_clipboard_text()
{
std::string result;
// try to access unicode text
if (!get_clipboard_text_by_format(result, CF_UNICODETEXT, convert_wide))
{
// try to access ANSI text
get_clipboard_text_by_format(result, CF_TEXT, convert_ansi);
}
return result;
}
//============================================================
// osd_getpid
//============================================================
int osd_getpid()
{
return GetCurrentProcessId();
}
namespace osd {
bool invalidate_instruction_cache(void const *start, std::size_t size)
{
return FlushInstructionCache(GetCurrentProcess(), start, size) != 0;
}
void *virtual_memory_allocation::do_alloc(std::initializer_list<std::size_t> blocks, unsigned intent, std::size_t &size, std::size_t &page_size)
{
SYSTEM_INFO info;
GetSystemInfo(&info);
SIZE_T s(0);
for (std::size_t b : blocks)
s += (b + info.dwPageSize - 1) / info.dwPageSize;
s *= info.dwPageSize;
if (!s)
return nullptr;
LPVOID const result(VirtualAllocFromApp(nullptr, s, MEM_COMMIT, PAGE_NOACCESS));
if (result)
{
size = s;
page_size = info.dwPageSize;
}
return result;
}
void virtual_memory_allocation::do_free(void *start, std::size_t size)
{
VirtualFree(start, 0, MEM_RELEASE);
}
bool virtual_memory_allocation::do_set_access(void *start, std::size_t size, unsigned access)
{
ULONG p, o;
if (access & EXECUTE)
p = (access & WRITE) ? PAGE_EXECUTE_READWRITE : (access & READ) ? PAGE_EXECUTE_READ : PAGE_EXECUTE;
else
p = (access & WRITE) ? PAGE_READWRITE : (access & READ) ? PAGE_READONLY : PAGE_NOACCESS;
return VirtualProtectFromApp(start, size, p, &o) != 0;
}
} // namespace osd

2
src/osd/modules/lib/osdobj_common.cpp
View File

@ -260,7 +260,6 @@ void osd_common_t::register_options()
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_RAWINPUT);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_DINPUT);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_WIN32);
REGISTER_MODULE(m_mod_man, KEYBOARDINPUT_UWP);
REGISTER_MODULE(m_mod_man, KEYBOARD_NONE);
REGISTER_MODULE(m_mod_man, MOUSEINPUT_SDL);
@ -278,7 +277,6 @@ void osd_common_t::register_options()
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_WINHYBRID);
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_DINPUT);
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_XINPUT);
REGISTER_MODULE(m_mod_man, JOYSTICKINPUT_UWP);
REGISTER_MODULE(m_mod_man, JOYSTICK_NONE);
REGISTER_MODULE(m_mod_man, OUTPUT_NONE);

103
src/osd/uwp/uwpcompat.cpp
View File

@ -1,103 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Brad Hughes, Miodrag Milanovic
//============================================================
//
// uwpcompat.h - Universal Windows Platform compat forced includes
//
//============================================================
#include "uwpcompat.h"
#include <windows.h>
#include <cerrno>
#undef interface
#include "emu.h"
extern "C" {
BOOL WINAPI GetVersionEx(
_Inout_ LPOSVERSIONINFO lpVersionInfo
)
{
lpVersionInfo->dwMajorVersion = 10;
return TRUE;
}
HANDLE
WINAPI
CreateFileW(
_In_ LPCWSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile
)
{
// TODO: Handle other arguments that go into last param (pCreateExParams)
return CreateFile2((wchar_t*)lpFileName, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
}
HANDLE
WINAPI
CreateFileA(
_In_ LPCSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile
)
{
wchar_t filepath[MAX_PATH + 1];
if (MultiByteToWideChar(CP_ACP, 0, lpFileName, strlen(lpFileName), filepath, MAX_PATH))
return CreateFileW(filepath, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
SetLastError(E_FAIL);
return INVALID_HANDLE_VALUE;
}
DWORD WINAPI GetTickCount(void)
{
return osd_ticks();
}
// This is only in here so callers get an error
HMODULE WINAPI LoadLibraryExA(
_In_ LPCSTR lpLibFileName,
_Reserved_ HANDLE hFile,
_In_ DWORD dwFlags
)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return nullptr;
}
HMODULE WINAPI LoadLibraryExW(
_In_ LPCWSTR lpLibFileName,
_Reserved_ HANDLE hFile,
_In_ DWORD dwFlags
)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return nullptr;
}
DWORD WINAPI GetFileSize(
_In_ HANDLE hFile,
_Out_opt_ LPDWORD lpFileSizeHigh
)
{
FILE_STANDARD_INFO file_info;
GetFileInformationByHandleEx(hFile, FileStandardInfo, &file_info, sizeof(file_info));
if(lpFileSizeHigh!=nullptr)
{
*lpFileSizeHigh = file_info.EndOfFile.HighPart;
}
return file_info.EndOfFile.LowPart;
}
}

139
src/osd/uwp/uwpcompat.h
View File

@ -1,139 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Brad Hughes, Miodrag Milanovic
//============================================================
//
// uwpcompat.h - Universal Windows Platform compat forced includes
//
//============================================================
#ifndef __UWPCOMPAT_H__
#define __UWPCOMPAT_H__
#ifdef __cplusplus
extern "C" {
#endif
#ifndef NOGDI
#define NOGDI
#endif
#include <windows.h>
#include <cstdio>
int system(const char *command);
const char *getenv(const char *varname);
HANDLE
WINAPI
CreateFileA(
_In_ LPCSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile
);
HANDLE
WINAPI
CreateFileW(
_In_ LPCWSTR lpFileName,
_In_ DWORD dwDesiredAccess,
_In_ DWORD dwShareMode,
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes,
_In_ DWORD dwCreationDisposition,
_In_ DWORD dwFlagsAndAttributes,
_In_opt_ HANDLE hTemplateFile
);
#ifdef UNICODE
#define CreateFile CreateFileW
#else
#define CreateFile CreateFileA
#endif // !UNICODE
BOOL WINAPI GetVersionEx(
_Inout_ LPOSVERSIONINFO lpVersionInfo
);
DWORD WINAPI GetTickCount(void);
FILE *_popen(
const char *command,
const char *mode
);
int _pclose(
FILE *stream);
_Ret_maybenull_
HMODULE WINAPI LoadLibraryA(
_In_ LPCSTR lpFileName
);
_Ret_maybenull_
HMODULE WINAPI LoadLibraryW(
_In_ LPCWSTR lpFileName
);
#ifdef UNICODE
#define LoadLibrary LoadLibraryW
#else
#define LoadLibrary LoadLibraryA
#endif // !UNICODE
_Ret_maybenull_
HMODULE WINAPI GetModuleHandleA(
_In_ LPCSTR lpModuleName
);
_Ret_maybenull_
HMODULE WINAPI GetModuleHandleW(
_In_ LPCWSTR lpModuleName
);
#ifdef UNICODE
#define GetModuleHandle GetModuleHandleW
#else
#define GetModuleHandle GetModuleHandleA
#endif // !UNICODE
_Ret_maybenull_
HMODULE
WINAPI
LoadLibraryExA(
_In_ LPCSTR lpLibFileName,
_Reserved_ HANDLE hFile,
_In_ DWORD dwFlags
);
_Ret_maybenull_
HMODULE
WINAPI
LoadLibraryExW(
_In_ LPCWSTR lpLibFileName,
_Reserved_ HANDLE hFile,
_In_ DWORD dwFlags
);
#ifdef UNICODE
#define LoadLibraryEx LoadLibraryExW
#else
#define LoadLibraryEx LoadLibraryExA
#endif // !UNICODE
DWORD
WINAPI
GetFileSize(
_In_ HANDLE hFile,
_Out_opt_ LPDWORD lpFileSizeHigh
);
#ifdef __cplusplus
}
#endif
#endif // __UWPCOMPAT_H__

209
src/osd/uwp/video.cpp
View File

@ -1,209 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Brad Hughes, Aaron Giles
//============================================================
//
// video.c - UWP video handling
//
//============================================================
#include <exception>
// standard windows headers
#include <windows.h>
#include <dxgi1_2.h>
#include <wrl\client.h>
#undef interface
// MAME headers
#include "emu.h"
#include "emuopts.h"
#include "render.h"
#include "uiinput.h"
// MAMEOS headers
#include "winmain.h"
#include "video.h"
#include "window.h"
#include "strconv.h"
#include "modules/osdwindow.h"
using namespace Platform;
using namespace Microsoft::WRL;
using namespace Windows::UI::Core;
//============================================================
// GLOBAL VARIABLES
//============================================================
osd_video_config video_config;
//============================================================
// PROTOTYPES
//============================================================
static void get_resolution(const char *defdata, const char *data, osd_window_config *config, int report_error);
//============================================================
// video_init
//============================================================
// FIXME: Temporary workaround
static osd_window_config windows[MAX_VIDEO_WINDOWS]; // configuration data per-window
bool windows_osd_interface::video_init()
{
// extract data from the options
extract_video_config();
// initialize the window system so we can make windows
window_init();
// create the windows
windows_options &options = downcast<windows_options &>(machine().options());
for (int index = 0; index < video_config.numscreens; index++)
{
uwp_window_info::create(machine(), index, m_monitor_module->pick_monitor(options, index), &windows[index]);
}
if (video_config.mode != VIDEO_MODE_NONE)
{
auto win = std::static_pointer_cast<uwp_window_info>(osd_common_t::s_window_list.front());
win->platform_window()->Activate();
}
return true;
}
//============================================================
// video_exit
//============================================================
void windows_osd_interface::video_exit()
{
window_exit();
}
//============================================================
// update
//============================================================
void windows_osd_interface::update(bool skip_redraw)
{
osd_common_t::update(skip_redraw);
// if we're not skipping this redraw, update all windows
if (!skip_redraw)
{
// profiler_mark(PROFILER_BLIT);
for (auto window : osd_common_t::s_window_list)
window->update();
// profiler_mark(PROFILER_END);
}
// if we're running, disable some parts of the debugger
if ((machine().debug_flags & DEBUG_FLAG_OSD_ENABLED) != 0)
debugger_update();
}
//============================================================
// input_update
//============================================================
void windows_osd_interface::input_update()
{
// poll the joystick values here
winwindow_process_events(machine(), true, false);
poll_input(machine());
check_osd_inputs();
}
//============================================================
// check_osd_inputs
//============================================================
void windows_osd_interface::check_osd_inputs()
{
}
//============================================================
// extract_video_config
//============================================================
void windows_osd_interface::extract_video_config()
{
const char *stemp;
// global options: extract the data
video_config.windowed = options().window();
video_config.prescale = options().prescale();
video_config.filter = options().filter();
video_config.numscreens = options().numscreens();
// if we are in debug mode, never go full screen
if (machine().debug_flags & DEBUG_FLAG_OSD_ENABLED)
video_config.windowed = TRUE;
// per-window options: extract the data
const char *default_resolution = options().resolution();
get_resolution(default_resolution, options().resolution(0), &windows[0], TRUE);
get_resolution(default_resolution, options().resolution(1), &windows[1], TRUE);
get_resolution(default_resolution, options().resolution(2), &windows[2], TRUE);
get_resolution(default_resolution, options().resolution(3), &windows[3], TRUE);
// video options: extract the data
stemp = options().video();
if (strcmp(stemp, "auto") == 0)
video_config.mode = VIDEO_MODE_BGFX;
else if (strcmp(stemp, "bgfx") == 0)
video_config.mode = VIDEO_MODE_BGFX;
else if (strcmp(stemp, "none") == 0)
{
video_config.mode = VIDEO_MODE_NONE;
if (!emulator_info::standalone() && options().seconds_to_run() == 0)
osd_printf_warning("Warning: -video none doesn't make much sense without -seconds_to_run\n");
}
else
{
osd_printf_warning("Invalid video value %s; reverting to gdi\n", stemp);
video_config.mode = VIDEO_MODE_GDI;
}
video_config.waitvsync = options().wait_vsync();
video_config.syncrefresh = options().sync_refresh();
video_config.triplebuf = options().triple_buffer();
video_config.switchres = options().switch_res();
if (video_config.prescale < 1 || video_config.prescale > 8)
{
osd_printf_warning("Invalid prescale option, reverting to '1'\n");
video_config.prescale = 1;
}
}
//============================================================
// get_resolution
//============================================================
static void get_resolution(const char *defdata, const char *data, osd_window_config *config, int report_error)
{
config->width = config->height = config->depth = config->refresh = 0;
if (strcmp(data, OSDOPTVAL_AUTO) == 0)
{
if (strcmp(defdata, OSDOPTVAL_AUTO) == 0)
return;
data = defdata;
}
if (sscanf(data, "%dx%dx%d", &config->width, &config->height, &config->depth) < 2 && report_error)
osd_printf_error("Illegal resolution value = %s\n", data);
const char * at_pos = strchr(data, '@');
if (at_pos)
if (sscanf(at_pos + 1, "%d", &config->refresh) < 1 && report_error)
osd_printf_error("Illegal refresh rate in resolution value = %s\n", data);
}

19
src/osd/uwp/video.h
View File

@ -1,19 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
//============================================================
//
// video.h - UWP implementation of MAME video routines
//
//============================================================
#ifndef __UWP_VIDEO__
#define __UWP_VIDEO__
#include "modules/osdhelper.h"
inline osd_rect RECT_to_osd_rect(const RECT &r)
{
return osd_rect(r.left, r.top, r.right - r.left, r.bottom - r.top);
}
#endif

1076
src/osd/uwp/window.cpp
View File

File diff suppressed because it is too large Load Diff

151
src/osd/uwp/window.h
View File

@ -1,151 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles, Brad Hughes
//============================================================
//
// window.h - UWP window handling
//
//============================================================
#ifndef __UWP_WINDOW__
#define __UWP_WINDOW__
// standard windows headers
#include <windows.h>
#include <windowsx.h>
#include <mmsystem.h>
#include <inspectable.h>
#include <agile.h>
#include <chrono>
#include <mutex>
#include <memory>
#include <list>
#include "render.h"
#include "modules/osdwindow.h"
//============================================================
// PARAMETERS
//============================================================
//============================================================
// CONSTANTS
//============================================================
#define RESIZE_STATE_NORMAL 0
#define RESIZE_STATE_RESIZING 1
#define RESIZE_STATE_PENDING 2
//============================================================
// TYPE DEFINITIONS
//============================================================
class uwp_window_info : public osd_window_t<Platform::Agile<Windows::UI::Core::CoreWindow>>
{
public:
uwp_window_info(running_machine &machine, int index, std::shared_ptr<osd_monitor_info> monitor, const osd_window_config *config);
void update() override;
virtual osd_dim get_size() override
{
auto bounds = platform_window()->Bounds;
return osd_dim(bounds.Width, bounds.Height);
}
bool win_has_menu() override
{
return false;
}
void capture_pointer() override;
void release_pointer() override;
void show_pointer() override;
void hide_pointer() override;
void complete_destroy() override;
// static
static void create(running_machine &machine, int index, std::shared_ptr<osd_monitor_info> monitor, const osd_window_config *config);
// member variables
volatile int m_init_state;
// window handle and info
RECT m_non_fullscreen_bounds;
int m_startmaximized;
int m_isminimized;
int m_ismaximized;
// monitor info
int m_fullscreen_safe;
float m_aspect;
// rendering info
std::mutex m_render_lock;
unsigned m_targetview;
int m_targetorient;
render_layer_config m_targetlayerconfig;
u32 m_targetvismask;
// input info
std::chrono::system_clock::time_point m_lastclicktime;
int m_lastclickx;
int m_lastclicky;
private:
int complete_create();
void draw_video_contents(bool update);
int wnd_extra_width();
int wnd_extra_height();
osd_rect constrain_to_aspect_ratio(const osd_rect &rect, int adjustment);
osd_dim get_min_bounds(int constrain);
osd_dim get_max_bounds(int constrain);
void update_minmax_state();
void minimize_window();
void maximize_window();
void adjust_window_position_after_major_change();
void set_fullscreen(int fullscreen);
static POINT s_saved_cursor_pos;
static Windows::UI::Core::CoreCursor^ s_cursor;
};
struct osd_draw_callbacks
{
osd_renderer *(*create)(osd_window *window);
void (*exit)(void);
};
//============================================================
// PROTOTYPES
//============================================================
bool winwindow_has_focus(void);
void winwindow_process_events(running_machine &machine, bool ingame, bool nodispatch);
void winwindow_process_events_periodic(running_machine &machine);
//============================================================
// rect_width / rect_height
//============================================================
static inline int rect_width(const RECT *rect)
{
return rect->right - rect->left;
}
static inline int rect_height(const RECT *rect)
{
return rect->bottom - rect->top;
}
#endif