ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[UI] Loop thread to main thread WindowedAppContext

This commit is contained in:
Triang3l 2021-08-28 19:38:24 +03:00
parent f540c188bf
commit 6ce5330f5f
95 changed files with 2343 additions and 1235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
premake5.lua
View File

@ -189,6 +189,12 @@ filter("platforms:Windows")
"bcrypt",
})
-- Embed the manifest for things like dependencies and DPI awareness.
filter({"platforms:Windows", "kind:ConsoleApp or WindowedApp"})
files({
"src/xenia/base/app_win32.manifest"
})
-- Create scratch/ path
if not os.isdir("scratch") then
os.mkdir("scratch")
@ -243,9 +249,13 @@ workspace("xenia")
include("third_party/SDL2.lua")
end
-- Disable treating warnings as fatal errors for all third party projects:
-- Disable treating warnings as fatal errors for all third party projects, as
-- well as other things relevant only to Xenia itself.
for _, prj in ipairs(premake.api.scope.current.solution.projects) do
project(prj.name)
removefiles({
"src/xenia/base/app_win32.manifest"
})
removeflags({
"FatalWarnings",
})

35
src/xenia/app/emulator_window.cc
View File

@ -11,6 +11,7 @@
#include "third_party/fmt/include/fmt/format.h"
#include "third_party/imgui/imgui.h"
#include "xenia/base/assert.h"
#include "xenia/base/clock.h"
#include "xenia/base/cvar.h"
#include "xenia/base/debugging.h"
@ -42,10 +43,11 @@ using xe::ui::UIEvent;
const std::string kBaseTitle = "xenia";
EmulatorWindow::EmulatorWindow(Emulator* emulator)
EmulatorWindow::EmulatorWindow(Emulator* emulator,
ui::WindowedAppContext& app_context)
: emulator_(emulator),
loop_(ui::Loop::Create()),
window_(ui::Window::Create(loop_.get(), kBaseTitle)) {
app_context_(app_context),
window_(ui::Window::Create(app_context, kBaseTitle)) {
base_title_ = kBaseTitle +
#ifdef DEBUG
#if _NO_DEBUG_HEAP == 1
@ -63,23 +65,14 @@ EmulatorWindow::EmulatorWindow(Emulator* emulator)
")";
}
EmulatorWindow::~EmulatorWindow() {
loop_->PostSynchronous([this]() { window_.reset(); });
}
std::unique_ptr<EmulatorWindow> EmulatorWindow::Create(Emulator* emulator) {
std::unique_ptr<EmulatorWindow> emulator_window(new EmulatorWindow(emulator));
emulator_window->loop()->PostSynchronous([&emulator_window]() {
xe::threading::set_name("Windowing Loop");
xe::Profiler::ThreadEnter("Windowing Loop");
std::unique_ptr<EmulatorWindow> EmulatorWindow::Create(
Emulator* emulator, ui::WindowedAppContext& app_context) {
assert_true(app_context.IsInUIThread());
std::unique_ptr<EmulatorWindow> emulator_window(
new EmulatorWindow(emulator, app_context));
if (!emulator_window->Initialize()) {
xe::FatalError("Failed to initialize main window");
return;
return nullptr;
}
});
return emulator_window;
}
@ -91,8 +84,8 @@ bool EmulatorWindow::Initialize() {
UpdateTitle();
window_->on_closed.AddListener([this](UIEvent* e) { loop_->Quit(); });
loop_->on_quit.AddListener([this](UIEvent* e) { window_.reset(); });
window_->on_closed.AddListener(
[this](UIEvent* e) { app_context_.QuitFromUIThread(); });
window_->on_file_drop.AddListener(
[this](FileDropEvent* e) { FileDrop(e->filename()); });
@ -313,7 +306,7 @@ void EmulatorWindow::FileOpen() {
file_picker->set_multi_selection(false);
file_picker->set_title("Select Content Package");
file_picker->set_extensions({
{"Supported Files", "*.iso;*.xex;*.xcp;*.*"},
{"Supported Files", "*.iso;*.xex;*.*"},
{"Disc Image (*.iso)", "*.iso"},
{"Xbox Executable (*.xex)", "*.xex"},
//{"Content Package (*.xcp)", "*.xcp" },

14
src/xenia/app/emulator_window.h
View File

@ -13,9 +13,9 @@
#include <memory>
#include <string>
#include "xenia/ui/loop.h"
#include "xenia/ui/menu_item.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/xbox.h"
namespace xe {
@ -27,12 +27,11 @@ namespace app {
class EmulatorWindow {
public:
virtual ~EmulatorWindow();
static std::unique_ptr<EmulatorWindow> Create(Emulator* emulator);
static std::unique_ptr<EmulatorWindow> Create(
Emulator* emulator, ui::WindowedAppContext& app_context);
Emulator* emulator() const { return emulator_; }
ui::Loop* loop() const { return loop_.get(); }
ui::WindowedAppContext& app_context() const { return app_context_; }
ui::Window* window() const { return window_.get(); }
void UpdateTitle();
@ -40,7 +39,8 @@ class EmulatorWindow {
void SetInitializingShaderStorage(bool initializing);
private:
explicit EmulatorWindow(Emulator* emulator);
explicit EmulatorWindow(Emulator* emulator,
ui::WindowedAppContext& app_context);
bool Initialize();
@ -60,7 +60,7 @@ class EmulatorWindow {
void ShowCommitID();
Emulator* emulator_;
std::unique_ptr<ui::Loop> loop_;
ui::WindowedAppContext& app_context_;
std::unique_ptr<ui::Window> window_;
std::string base_title_;
uint64_t cursor_hide_time_ = 0;

2
src/xenia/app/premake5.lua
View File

@ -52,8 +52,8 @@ project("xenia-app")
local_platform_files()
files({
"xenia_main.cc",
"../base/main_"..platform_suffix..".cc",
"../base/main_init_"..platform_suffix..".cc",
"../ui/windowed_app_main_"..platform_suffix..".cc",
})
resincludedirs({

258
src/xenia/app/xenia_main.cc
View File

@ -7,18 +7,29 @@
******************************************************************************
*/
#include <atomic>
#include <cstdlib>
#include <functional>
#include <memory>
#include <string>
#include <thread>
#include <vector>
#include "xenia/app/discord/discord_presence.h"
#include "xenia/app/emulator_window.h"
#include "xenia/base/cvar.h"
#include "xenia/base/debugging.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/platform.h"
#include "xenia/base/profiling.h"
#include "xenia/base/threading.h"
#include "xenia/config.h"
#include "xenia/debug/ui/debug_window.h"
#include "xenia/emulator.h"
#include "xenia/ui/file_picker.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/vfs/devices/host_path_device.h"
// Available audio systems:
@ -44,7 +55,6 @@
#endif // XE_PLATFORM_WIN32
#include "third_party/fmt/include/fmt/format.h"
#include "third_party/xbyak/xbyak/xbyak_util.h"
DEFINE_string(apu, "any", "Audio system. Use: [any, nop, sdl, xaudio2]", "APU");
DEFINE_string(gpu, "any", "Graphics system. Use: [any, d3d12, vulkan, null]",
@ -91,6 +101,21 @@ DEFINE_bool(discord, true, "Enable Discord rich presence", "General");
namespace xe {
namespace app {
class EmulatorApp final : public xe::ui::WindowedApp {
public:
static std::unique_ptr<xe::ui::WindowedApp> Create(
xe::ui::WindowedAppContext& app_context) {
return std::unique_ptr<xe::ui::WindowedApp>(new EmulatorApp(app_context));
}
~EmulatorApp();
bool OnInitialize() override;
protected:
void OnDestroy() override;
private:
template <typename T, typename... Args>
class Factory {
private:
@ -167,7 +192,43 @@ class Factory {
}
};
std::unique_ptr<apu::AudioSystem> CreateAudioSystem(cpu::Processor* processor) {
explicit EmulatorApp(xe::ui::WindowedAppContext& app_context);
static std::unique_ptr<apu::AudioSystem> CreateAudioSystem(
cpu::Processor* processor);
static std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem();
static std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
ui::Window* window);
void EmulatorThread();
void ShutdownEmulatorThreadFromUIThread();
std::unique_ptr<Emulator> emulator_;
std::unique_ptr<EmulatorWindow> emulator_window_;
// Created on demand, used by the emulator.
std::unique_ptr<xe::debug::ui::DebugWindow> debug_window_;
// Refreshing the emulator - placed after its dependencies.
std::atomic<bool> emulator_thread_quit_requested_;
std::unique_ptr<xe::threading::Event> emulator_thread_event_;
std::thread emulator_thread_;
};
EmulatorApp::EmulatorApp(xe::ui::WindowedAppContext& app_context)
: xe::ui::WindowedApp(app_context, "xenia", "[Path to .iso/.xex]") {
AddPositionalOption("target");
}
EmulatorApp::~EmulatorApp() {
// Should be shut down from OnDestroy if OnInitialize has ever been done, but
// for the most safety as a running thread may be destroyed only after
// joining.
ShutdownEmulatorThreadFromUIThread();
}
std::unique_ptr<apu::AudioSystem> EmulatorApp::CreateAudioSystem(
cpu::Processor* processor) {
Factory<apu::AudioSystem, cpu::Processor*> factory;
#if XE_PLATFORM_WIN32
factory.Add<apu::xaudio2::XAudio2AudioSystem>("xaudio2");
@ -177,7 +238,7 @@ std::unique_ptr<apu::AudioSystem> CreateAudioSystem(cpu::Processor* processor) {
return factory.Create(cvars::apu, processor);
}
std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() {
std::unique_ptr<gpu::GraphicsSystem> EmulatorApp::CreateGraphicsSystem() {
Factory<gpu::GraphicsSystem> factory;
#if XE_PLATFORM_WIN32
factory.Add<gpu::d3d12::D3D12GraphicsSystem>("d3d12");
@ -187,7 +248,7 @@ std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() {
return factory.Create(cvars::gpu);
}
std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
std::vector<std::unique_ptr<hid::InputDriver>> EmulatorApp::CreateInputDrivers(
ui::Window* window) {
std::vector<std::unique_ptr<hid::InputDriver>> drivers;
if (cvars::hid.compare("nop") == 0) {
@ -215,9 +276,9 @@ std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
return drivers;
}
int xenia_main(const std::vector<std::string>& args) {
bool EmulatorApp::OnInitialize() {
Profiler::Initialize();
Profiler::ThreadEnter("main");
Profiler::ThreadEnter("Main");
// Figure out where internal files and content should go.
std::filesystem::path storage_root = cvars::storage_root;
@ -275,20 +336,55 @@ int xenia_main(const std::vector<std::string>& args) {
}
// Create the emulator but don't initialize so we can setup the window.
auto emulator =
emulator_ =
std::make_unique<Emulator>("", storage_root, content_root, cache_root);
// Main emulator display window.
auto emulator_window = EmulatorWindow::Create(emulator.get());
emulator_window_ = EmulatorWindow::Create(emulator_.get(), app_context());
if (!emulator_window_) {
XELOGE("Failed to create the main emulator window");
return false;
}
// Setup the emulator and run its loop in a separate thread.
emulator_thread_quit_requested_.store(false, std::memory_order_relaxed);
emulator_thread_event_ = xe::threading::Event::CreateAutoResetEvent(false);
emulator_thread_ = std::thread(&EmulatorApp::EmulatorThread, this);
return true;
}
void EmulatorApp::OnDestroy() {
ShutdownEmulatorThreadFromUIThread();
if (cvars::discord) {
discord::DiscordPresence::Shutdown();
}
Profiler::Dump();
// The profiler needs to shut down before the graphics context.
Profiler::Shutdown();
// TODO(DrChat): Remove this code and do a proper exit.
XELOGI("Cheap-skate exit!");
std::quick_exit(EXIT_SUCCESS);
}
void EmulatorApp::EmulatorThread() {
assert_not_null(emulator_thread_event_);
xe::threading::set_name("Emulator");
Profiler::ThreadEnter("Emulator");
// Setup and initialize all subsystems. If we can't do something
// (unsupported system, memory issues, etc) this will fail early.
X_STATUS result =
emulator->Setup(emulator_window->window(), CreateAudioSystem,
emulator_->Setup(emulator_window_->window(), CreateAudioSystem,
CreateGraphicsSystem, CreateInputDrivers);
if (XFAILED(result)) {
XELOGE("Failed to setup emulator: {:08X}", result);
return 1;
app_context().RequestDeferredQuit();
return;
}
if (cvars::mount_scratch) {
@ -297,10 +393,11 @@ int xenia_main(const std::vector<std::string>& args) {
if (!scratch_device->Initialize()) {
XELOGE("Unable to scan scratch path");
} else {
if (!emulator->file_system()->RegisterDevice(std::move(scratch_device))) {
if (!emulator_->file_system()->RegisterDevice(
std::move(scratch_device))) {
XELOGE("Unable to register scratch path");
} else {
emulator->file_system()->RegisterSymbolicLink("scratch:", "\\SCRATCH");
emulator_->file_system()->RegisterSymbolicLink("scratch:", "\\SCRATCH");
}
}
}
@ -311,10 +408,10 @@ int xenia_main(const std::vector<std::string>& args) {
if (!cache0_device->Initialize()) {
XELOGE("Unable to scan cache0 path");
} else {
if (!emulator->file_system()->RegisterDevice(std::move(cache0_device))) {
if (!emulator_->file_system()->RegisterDevice(std::move(cache0_device))) {
XELOGE("Unable to register cache0 path");
} else {
emulator->file_system()->RegisterSymbolicLink("cache0:", "\\CACHE0");
emulator_->file_system()->RegisterSymbolicLink("cache0:", "\\CACHE0");
}
}
@ -323,10 +420,10 @@ int xenia_main(const std::vector<std::string>& args) {
if (!cache1_device->Initialize()) {
XELOGE("Unable to scan cache1 path");
} else {
if (!emulator->file_system()->RegisterDevice(std::move(cache1_device))) {
if (!emulator_->file_system()->RegisterDevice(std::move(cache1_device))) {
XELOGE("Unable to register cache1 path");
} else {
emulator->file_system()->RegisterSymbolicLink("cache1:", "\\CACHE1");
emulator_->file_system()->RegisterSymbolicLink("cache1:", "\\CACHE1");
}
}
@ -339,79 +436,62 @@ int xenia_main(const std::vector<std::string>& args) {
if (!cache_device->Initialize()) {
XELOGE("Unable to scan cache path");
} else {
if (!emulator->file_system()->RegisterDevice(std::move(cache_device))) {
if (!emulator_->file_system()->RegisterDevice(std::move(cache_device))) {
XELOGE("Unable to register cache path");
} else {
emulator->file_system()->RegisterSymbolicLink("cache:", "\\CACHE");
emulator_->file_system()->RegisterSymbolicLink("cache:", "\\CACHE");
}
}
}
// Set a debug handler.
// This will respond to debugging requests so we can open the debug UI.
std::unique_ptr<xe::debug::ui::DebugWindow> debug_window;
if (cvars::debug) {
emulator->processor()->set_debug_listener_request_handler(
[&](xe::cpu::Processor* processor) {
if (debug_window) {
return debug_window.get();
emulator_->processor()->set_debug_listener_request_handler(
[this](xe::cpu::Processor* processor) {
if (debug_window_) {
return debug_window_.get();
}
emulator_window->loop()->PostSynchronous([&]() {
debug_window = xe::debug::ui::DebugWindow::Create(
emulator.get(), emulator_window->loop());
debug_window->window()->on_closed.AddListener(
[&](xe::ui::UIEvent* e) {
emulator->processor()->set_debug_listener(nullptr);
emulator_window->loop()->Post(
[&]() { debug_window.reset(); });
app_context().CallInUIThreadSynchronous([this]() {
debug_window_ = xe::debug::ui::DebugWindow::Create(emulator_.get(),
app_context());
debug_window_->window()->on_closed.AddListener(
[this](xe::ui::UIEvent* e) {
emulator_->processor()->set_debug_listener(nullptr);
app_context().CallInUIThread(
[this]() { debug_window_.reset(); });
});
});
return debug_window.get();
// If failed to enqueue the UI thread call, this will just be null.
return debug_window_.get();
});
}
auto evt = xe::threading::Event::CreateAutoResetEvent(false);
emulator->on_launch.AddListener([&](auto title_id, const auto& game_title) {
emulator_->on_launch.AddListener([&](auto title_id, const auto& game_title) {
if (cvars::discord) {
discord::DiscordPresence::PlayingTitle(
game_title.empty() ? "Unknown Title" : std::string(game_title));
}
emulator_window->UpdateTitle();
evt->Set();
app_context().CallInUIThread([this]() { emulator_window_->UpdateTitle(); });
emulator_thread_event_->Set();
});
emulator->on_shader_storage_initialization.AddListener(
[&](bool initializing) {
emulator_window->SetInitializingShaderStorage(initializing);
emulator_->on_shader_storage_initialization.AddListener(
[this](bool initializing) {
app_context().CallInUIThread([this, initializing]() {
emulator_window_->SetInitializingShaderStorage(initializing);
});
});
emulator->on_terminate.AddListener([&]() {
emulator_->on_terminate.AddListener([]() {
if (cvars::discord) {
discord::DiscordPresence::NotPlaying();
}
});
emulator_window->window()->on_closing.AddListener([&](ui::UIEvent* e) {
// This needs to shut down before the graphics context.
Profiler::Shutdown();
});
bool exiting = false;
emulator_window->loop()->on_quit.AddListener([&](ui::UIEvent* e) {
exiting = true;
evt->Set();
if (cvars::discord) {
discord::DiscordPresence::Shutdown();
}
// TODO(DrChat): Remove this code and do a proper exit.
XELOGI("Cheap-skate exit!");
exit(0);
});
// Enable the main menu now that the emulator is properly loaded
emulator_window->window()->EnableMainMenu();
app_context().CallInUIThread(
[this]() { emulator_window_->window()->EnableMainMenu(); });
// Grab path from the flag or unnamed argument.
std::filesystem::path path;
@ -420,50 +500,56 @@ int xenia_main(const std::vector<std::string>& args) {
}
// Toggles fullscreen
if (cvars::fullscreen) emulator_window->ToggleFullscreen();
if (cvars::fullscreen) {
app_context().CallInUIThread(
[this]() { emulator_window_->ToggleFullscreen(); });
}
if (!path.empty()) {
// Normalize the path and make absolute.
auto abs_path = std::filesystem::absolute(path);
result = emulator->LaunchPath(abs_path);
result = emulator_->LaunchPath(abs_path);
if (XFAILED(result)) {
xe::FatalError(fmt::format("Failed to launch target: {:08X}", result));
emulator.reset();
emulator_window.reset();
return 1;
app_context().RequestDeferredQuit();
return;
}
}
// Now, we're going to use the main thread to drive events related to
// emulation.
while (!exiting) {
xe::threading::Wait(evt.get(), false);
// Now, we're going to use this thread to drive events related to emulation.
while (!emulator_thread_quit_requested_.load(std::memory_order_relaxed)) {
xe::threading::Wait(emulator_thread_event_.get(), false);
while (true) {
emulator->WaitUntilExit();
if (emulator->TitleRequested()) {
emulator->LaunchNextTitle();
emulator_->WaitUntilExit();
if (emulator_->TitleRequested()) {
emulator_->LaunchNextTitle();
} else {
break;
}
}
}
debug_window.reset();
emulator.reset();
if (cvars::discord) {
discord::DiscordPresence::Shutdown();
}
Profiler::Dump();
Profiler::Shutdown();
emulator_window.reset();
return 0;
void EmulatorApp::ShutdownEmulatorThreadFromUIThread() {
// TODO(Triang3l): Proper shutdown of the emulator (relying on std::quick_exit
// for now) - currently WaitUntilExit loops forever otherwise (plus possibly
// lots of other things not shutting down correctly now). Some parts of the
// code call the regular std::exit, which seems to be calling destructors (at
// least on Linux), so the entire join is currently commented out.
#if 0
// Same thread as the one created it, to make sure there's zero possibility of
// a race with the creation of the emulator thread.
assert_true(app_context().IsInUIThread());
emulator_thread_quit_requested_.store(true, std::memory_order_relaxed);
if (!emulator_thread_.joinable()) {
return;
}
emulator_thread_event_->Set();
emulator_thread_.join();
#endif
}
} // namespace app
} // namespace xe
DEFINE_ENTRY_POINT("xenia", xe::app::xenia_main, "[Path to .iso/.xex]",
"target");
XE_DEFINE_WINDOWED_APP(xenia, xe::app::EmulatorApp::Create);

143
src/xenia/apu/xaudio2/xaudio2_audio_driver.cc
View File

@ -9,13 +9,14 @@
#include "xenia/apu/xaudio2/xaudio2_audio_driver.h"
// Must be included before xaudio2.h so we get the right windows.h include.
#include "xenia/base/platform_win.h"
#include "xenia/apu/apu_flags.h"
#include "xenia/apu/conversion.h"
#include "xenia/apu/xaudio2/xaudio2_api.h"
#include "xenia/base/assert.h"
#include "xenia/base/clock.h"
#include "xenia/base/logging.h"
#include "xenia/base/platform_win.h"
#include "xenia/base/threading.h"
namespace xe {
namespace apu {
@ -73,11 +74,6 @@ bool XAudio2AudioDriver::Initialize() {
}
}
// First CPU (2.8 default). XAUDIO2_ANY_PROCESSOR (2.7 default) steals too
// much time from other things. Ideally should process audio on what roughly
// represents thread 4 (5th) on the Xbox 360 (2.7 default on the console), or
// even beyond the 6 guest cores.
api::XAUDIO2_PROCESSOR processor = 0x00000001;
if (api_minor_version_ >= 8) {
union {
// clang-format off
@ -94,7 +90,7 @@ bool XAudio2AudioDriver::Initialize() {
assert_always();
return false;
}
hr = xaudio2_create(&objects_.api_2_8.audio, 0, processor);
hr = xaudio2_create(&objects_.api_2_8.audio, 0, kProcessor);
if (FAILED(hr)) {
XELOGE("XAudio2Create failed with {:08X}", hr);
assert_always();
@ -102,20 +98,38 @@ bool XAudio2AudioDriver::Initialize() {
}
return InitializeObjects(objects_.api_2_8);
} else {
hr = CoCreateInstance(__uuidof(api::XAudio2_7), NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&objects_.api_2_7.audio));
if (FAILED(hr)) {
XELOGE("CoCreateInstance for XAudio2 failed with {:08X}", hr);
assert_always();
// We need to be able to accept frames from any non-STA thread - primarily
// from any guest thread, so MTA needs to be used. The AudioDriver, however,
// may be initialized from the UI thread, which has the STA concurrency
// model, or from another thread regardless of its concurrency model. So,
// all management of the objects needs to be performed in MTA. Launch the
// lifecycle management thread, which will handle initialization and
// shutdown, and also provide a scope for implicit MTA in threads that have
// never initialized COM explicitly, which lasts until all threads that have
// initialized MTA explicitly have uninitialized it - the thread that holds
// the MTA scope needs to be running while other threads are able to submit
// frames as they might have not initialized MTA explicitly.
// https://devblogs.microsoft.com/oldnewthing/?p=4613
assert_false(mta_thread_.joinable());
mta_thread_initialization_attempt_completed_ = false;
mta_thread_shutdown_requested_ = false;
mta_thread_ = std::thread(&XAudio2AudioDriver::MTAThread, this);
{
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
while (true) {
if (mta_thread_initialization_attempt_completed_) {
break;
}
mta_thread_initialization_completion_cond_.wait(
mta_thread_initialization_completion_lock);
}
}
if (!mta_thread_initialization_completion_result_) {
mta_thread_.join();
return false;
}
hr = objects_.api_2_7.audio->Initialize(0, processor);
if (FAILED(hr)) {
XELOGE("IXAudio2::Initialize failed with {:08X}", hr);
assert_always();
return false;
}
return InitializeObjects(objects_.api_2_7);
return true;
}
}
@ -249,7 +263,16 @@ void XAudio2AudioDriver::Shutdown() {
if (api_minor_version_ >= 8) {
ShutdownObjects(objects_.api_2_8);
} else {
ShutdownObjects(objects_.api_2_7);
// XAudio 2.7 lifecycle is managed by the MTA thread.
if (mta_thread_.joinable()) {
{
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
mta_thread_shutdown_requested_ = true;
}
mta_thread_shutdown_request_cond_.notify_all();
mta_thread_.join();
}
}
if (xaudio2_module_) {
@ -283,6 +306,82 @@ void XAudio2AudioDriver::ShutdownObjects(Objects& objects) {
}
}
void XAudio2AudioDriver::MTAThread() {
xe::threading::set_name("XAudio 2.7 MTA");
assert_false(mta_thread_initialization_attempt_completed_);
bool initialized = false;
// Initializing MTA COM in this thread, as well making other (guest) threads
// that don't explicitly call CoInitializeEx implicitly MTA for the period of
// time when they can interact with XAudio 2.7 through the XAudio2AudioDriver,
// until the CoUninitialize (to be more precise, the CoUninitialize for the
// last remaining MTA thread, but we need implicit MTA for the audio here).
// https://devblogs.microsoft.com/oldnewthing/?p=4613
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
if (FAILED(hr)) {
XELOGE("XAudio 2.7 MTA thread CoInitializeEx failed with {:08X}", hr);
} else {
hr = CoCreateInstance(__uuidof(api::XAudio2_7), nullptr,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&objects_.api_2_7.audio));
if (FAILED(hr)) {
XELOGE("CoCreateInstance for XAudio2 failed with {:08X}", hr);
} else {
hr = objects_.api_2_7.audio->Initialize(0, kProcessor);
if (FAILED(hr)) {
XELOGE("IXAudio2::Initialize failed with {:08X}", hr);
} else {
if (InitializeObjects(objects_.api_2_7)) {
initialized = true;
// Initialized successfully, await a shutdown request while keeping an
// implicit COM MTA scope.
mta_thread_initialization_completion_result_ = true;
{
std::unique_lock<std::mutex>
mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
mta_thread_initialization_attempt_completed_ = true;
}
mta_thread_initialization_completion_cond_.notify_all();
{
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
while (true) {
if (mta_thread_shutdown_requested_) {
break;
}
mta_thread_shutdown_request_cond_.wait(
mta_thread_shutdown_request_lock);
}
}
}
// Even if InitializeObjects has failed, need to clean up with
// ShutdownObjects.
ShutdownObjects(objects_.api_2_7);
}
}
CoUninitialize();
}
if (!initialized) {
mta_thread_initialization_completion_result_ = false;
{
// Failed to initialize - notify the threads waiting for the
// initialization.
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
mta_thread_initialization_attempt_completed_ = true;
}
mta_thread_initialization_completion_cond_.notify_all();
}
}
} // namespace xaudio2
} // namespace apu
} // namespace xe

33
src/xenia/apu/xaudio2/xaudio2_audio_driver.h
View File

@ -10,8 +10,13 @@
#ifndef XENIA_APU_XAUDIO2_XAUDIO2_AUDIO_DRIVER_H_
#define XENIA_APU_XAUDIO2_XAUDIO2_AUDIO_DRIVER_H_
#include <condition_variable>
#include <mutex>
#include <thread>
#include "xenia/apu/audio_driver.h"
#include "xenia/apu/xaudio2/xaudio2_api.h"
#include "xenia/base/platform.h"
#include "xenia/base/threading.h"
struct IXAudio2;
@ -28,17 +33,45 @@ class XAudio2AudioDriver : public AudioDriver {
~XAudio2AudioDriver() override;
bool Initialize();
// Must not be called from COM STA threads as MTA XAudio 2.7 may be used. It's
// fine to call this from threads that have never initialized COM as
// initializing MTA for any thread implicitly initializes it for all threads
// not explicitly requesting STA (until COM is uninitialized all threads that
// have initialized MTA).
// https://devblogs.microsoft.com/oldnewthing/?p=4613
void SubmitFrame(uint32_t frame_ptr) override;
void Shutdown();
private:
// First CPU (2.8 default). XAUDIO2_ANY_PROCESSOR (2.7 default) steals too
// much time from other things. Ideally should process audio on what roughly
// represents thread 4 (5th) on the Xbox 360 (2.7 default on the console), or
// even beyond the 6 guest cores.
api::XAUDIO2_PROCESSOR kProcessor = 0x00000001;
// For XAudio 2.7, InitializeObjects and ShutdownObjects must be called only
// in the lifecycle management thread with COM MTA initialized.
template <typename Objects>
bool InitializeObjects(Objects& objects);
template <typename Objects>
void ShutdownObjects(Objects& objects);
void MTAThread();
void* xaudio2_module_ = nullptr;
uint32_t api_minor_version_ = 7;
bool mta_thread_initialization_completion_result_;
std::mutex mta_thread_initialization_completion_mutex_;
std::condition_variable mta_thread_initialization_completion_cond_;
bool mta_thread_initialization_attempt_completed_;
std::mutex mta_thread_shutdown_request_mutex_;
std::condition_variable mta_thread_shutdown_request_cond_;
bool mta_thread_shutdown_requested_;
std::thread mta_thread_;
union {
struct {
api::IXAudio2_7* audio;

14
src/xenia/base/app_win32.manifest Normal file
View File

@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3" manifestVersion="1.0">
<dependency>
<dependentAssembly>
<assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*" />
</dependentAssembly>
</dependency>
<asmv3:application>
<asmv3:windowsSettings>
<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">True/PM</dpiAware>
<dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitor</dpiAwareness>
</asmv3:windowsSettings>
</asmv3:application>
</assembly>

22
src/xenia/base/console.h Normal file
View File

@ -0,0 +1,22 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_BASE_CONSOLE_H_
#define XENIA_BASE_CONSOLE_H_
namespace xe {
// Returns true if there is a user-visible console attached to receive stdout.
bool has_console_attached();
void AttachConsole();
} // namespace xe
#endif // XENIA_BASE_CONSOLE_H_

42
src/xenia/base/main.h → src/xenia/base/console_app_main.h
View File

@ -2,54 +2,50 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_BASE_MAIN_H_
#define XENIA_BASE_MAIN_H_
#ifndef XENIA_BASE_CONSOLE_APP_MAIN_H_
#define XENIA_BASE_CONSOLE_APP_MAIN_H_
#include <optional>
#include <string>
#include <vector>
#include "xenia/base/cvar.h"
#include "xenia/base/platform.h"
namespace xe {
// Returns true if there is a user-visible console attached to receive stdout.
bool has_console_attached();
void AttachConsole();
// Extern defined by user code. This must be present for the application to
// launch.
struct EntryInfo {
struct ConsoleAppEntryInfo {
std::string name;
int (*entry_point)(const std::vector<std::string>& args);
bool transparent_options; // no argument parsing
std::optional<std::string> positional_usage;
std::optional<std::vector<std::string>> positional_options;
std::string positional_usage;
std::vector<std::string> positional_options;
};
EntryInfo GetEntryInfo();
ConsoleAppEntryInfo GetConsoleAppEntryInfo();
#define DEFINE_ENTRY_POINT(name, entry_point, positional_usage, ...) \
xe::EntryInfo xe::GetEntryInfo() { \
// TODO(Triang3l): Multiple console app entry points on Android when a console
// activity is added. This is currently for individual executables running on
// Termux.
#define XE_DEFINE_CONSOLE_APP(name, entry_point, positional_usage, ...) \
xe::ConsoleAppEntryInfo xe::GetConsoleAppEntryInfo() { \
std::initializer_list<std::string> positional_options = {__VA_ARGS__}; \
return xe::EntryInfo{ \
return xe::ConsoleAppEntryInfo{ \
name, entry_point, false, positional_usage, \
std::vector<std::string>(std::move(positional_options))}; \
}
// TODO(Joel Linn): Add some way to filter consumed arguments in
// cvar::ParseLaunchArguments()
#define DEFINE_ENTRY_POINT_TRANSPARENT(name, entry_point) \
xe::EntryInfo xe::GetEntryInfo() { \
return xe::EntryInfo{name, entry_point, true, std::nullopt, std::nullopt}; \
#define XE_DEFINE_CONSOLE_APP_TRANSPARENT(name, entry_point) \
xe::ConsoleAppEntryInfo xe::GetConsoleAppEntryInfo() { \
return xe::ConsoleAppEntryInfo{name, entry_point, true, std::string(), \
std::vector<std::string>()}; \
}
} // namespace xe
#endif // XENIA_BASE_MAIN_H_
#endif // XENIA_BASE_CONSOLE_APP_MAIN_H_

10
src/xenia/base/console_app_main_android.cc Normal file
View File

@ -0,0 +1,10 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/base/console_app_posix.cc"

34
src/xenia/base/main_posix.cc → src/xenia/base/console_app_main_posix.cc
View File

@ -7,42 +7,32 @@
******************************************************************************
*/
#include <stdio.h>
#include <unistd.h>
#include <string>
#include <vector>
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/main.h"
#include "xenia/base/filesystem.h"
#include "xenia/base/logging.h"
#include "xenia/base/string.h"
namespace xe {
bool has_console_attached() { return isatty(fileno(stdin)) == 1; }
void AttachConsole() {}
} // namespace xe
extern "C" int main(int argc, char** argv) {
auto entry_info = xe::GetEntryInfo();
xe::ConsoleAppEntryInfo entry_info = xe::GetConsoleAppEntryInfo();
if (!entry_info.transparent_options) {
cvar::ParseLaunchArguments(argc, argv, entry_info.positional_usage.value(),
entry_info.positional_options.value());
cvar::ParseLaunchArguments(argc, argv, entry_info.positional_usage,
entry_info.positional_options);
}
// Initialize logging. Needs parsed cvars.
xe::InitializeLogging(entry_info.name);
std::vector<std::string> args;
for (int n = 0; n < argc; n++) {
args.push_back(argv[n]);
args.emplace_back(argv[n]);
}
// Initialize logging. Needs parsed FLAGS.
xe::InitializeLogging(entry_info.name);
// Call app-provided entry point.
int result = entry_info.entry_point(args);
xe::ShutdownLogging();
return result;
}

36
src/xenia/base/console_app_main_win.cc Normal file
View File

@ -0,0 +1,36 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <cstdlib>
#include <vector>
#include "xenia/base/console_app_main.h"
#include "xenia/base/main_win.h"
int main(int argc_ignored, char** argv_ignored) {
xe::ConsoleAppEntryInfo entry_info = xe::GetConsoleAppEntryInfo();
std::vector<std::string> args;
if (!xe::ParseWin32LaunchArguments(entry_info.transparent_options,
entry_info.positional_usage,
entry_info.positional_options, &args)) {
return EXIT_FAILURE;
}
int result = xe::InitializeWin32App(entry_info.name);
if (result) {
return result;
}
result = entry_info.entry_point(args);
xe::ShutdownWin32App();
return result;
}

21
src/xenia/base/console_posix.cc Normal file
View File

@ -0,0 +1,21 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <stdio.h>
#include <unistd.h>
#include "xenia/base/console.h"
namespace xe {
bool has_console_attached() { return isatty(fileno(stdin)) == 1; }
void AttachConsole() {}
} // namespace xe

60
src/xenia/base/console_win.cc Normal file
View File

@ -0,0 +1,60 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <fcntl.h>
#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include "xenia/base/console.h"
#include "xenia/base/platform_win.h"
namespace xe {
// TODO(Triang3l): Set the default depending on the actual subsystem. Currently
// it inhibits message boxes.
static bool has_console_attached_ = true;
bool has_console_attached() { return has_console_attached_; }
static bool has_shell_environment_variable() {
size_t size = 0;
// Check if SHELL exists
// If it doesn't, then we are in a Windows Terminal
auto error = getenv_s(&size, nullptr, 0, "SHELL");
if (error) {
return false;
}
return !!size;
}
void AttachConsole() {
bool has_console = ::AttachConsole(ATTACH_PARENT_PROCESS) == TRUE;
if (!has_console || !has_shell_environment_variable()) {
// We weren't launched from a console, so just return.
has_console_attached_ = false;
return;
}
AllocConsole();
has_console_attached_ = true;
auto std_handle = (intptr_t)GetStdHandle(STD_OUTPUT_HANDLE);
auto con_handle = _open_osfhandle(std_handle, _O_TEXT);
auto fp = _fdopen(con_handle, "w");
freopen_s(&fp, "CONOUT$", "w", stdout);
std_handle = (intptr_t)GetStdHandle(STD_ERROR_HANDLE);
con_handle = _open_osfhandle(std_handle, _O_TEXT);
fp = _fdopen(con_handle, "w");
freopen_s(&fp, "CONOUT$", "w", stderr);
}
} // namespace xe

2
src/xenia/base/cvar.cc
View File

@ -14,8 +14,8 @@
#define UTF_CPP_CPLUSPLUS 201703L
#include "third_party/utfcpp/source/utf8.h"
#include "xenia/base/console.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/system.h"
namespace utfcpp = utf8;

2
src/xenia/base/logging.cc
View File

@ -18,10 +18,10 @@
#include "third_party/disruptorplus/include/disruptorplus/sequence_barrier.hpp"
#include "third_party/disruptorplus/include/disruptorplus/spin_wait_strategy.hpp"
#include "xenia/base/atomic.h"
#include "xenia/base/console.h"
#include "xenia/base/cvar.h"
#include "xenia/base/debugging.h"
#include "xenia/base/filesystem.h"
#include "xenia/base/main.h"
#include "xenia/base/math.h"
#include "xenia/base/memory.h"
#include "xenia/base/ring_buffer.h"

10
src/xenia/base/main_init_android.cc Normal file
View File

@ -0,0 +1,10 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
// Nothing. Stub.

6
src/xenia/base/main_init_posix.cc
View File

@ -2,13 +2,9 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/base/main.h"
#include <cstdlib>
// Nothing. Stub.

3
src/xenia/base/main_init_win.cc
View File

@ -7,10 +7,11 @@
******************************************************************************
*/
#include "xenia/base/main.h"
#include "xenia/base/platform_win.h"
#include <cstdlib>
// Includes Windows headers, so it goes after platform_win.h.
#include "third_party/xbyak/xbyak/xbyak_util.h"
class StartupAvxCheck {

134
src/xenia/base/main_win.cc
View File

@ -7,14 +7,12 @@
******************************************************************************
*/
#include <fcntl.h>
#include <io.h>
#include <cstdlib>
#include <malloc.h>
#include <cstring>
#include "xenia/base/cvar.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/main_win.h"
#include "xenia/base/platform_win.h"
#include "xenia/base/string.h"
@ -24,54 +22,11 @@
// For RequestHighPerformance.
#include <winternl.h>
// Includes Windows headers, so it goes here.
#include "third_party/xbyak/xbyak/xbyak_util.h"
DEFINE_bool(win32_high_freq, true,
"Requests high performance from the NT kernel", "Kernel");
DEFINE_bool(enable_console, false, "Open a console window with the main window",
"General");
namespace xe {
bool has_console_attached_ = true;
bool has_console_attached() { return has_console_attached_; }
bool has_shell_environment_variable() {
size_t size = 0;
// Check if SHELL exists
// If it doesn't, then we are in a Windows Terminal
auto error = getenv_s(&size, nullptr, 0, "SHELL");
if (error) {
return false;
}
return !!size;
}
void AttachConsole() {
bool has_console = ::AttachConsole(ATTACH_PARENT_PROCESS) == TRUE;
if (!has_console || !has_shell_environment_variable()) {
// We weren't launched from a console, so just return.
has_console_attached_ = false;
return;
}
AllocConsole();
has_console_attached_ = true;
auto std_handle = (intptr_t)GetStdHandle(STD_OUTPUT_HANDLE);
auto con_handle = _open_osfhandle(std_handle, _O_TEXT);
auto fp = _fdopen(con_handle, "w");
freopen_s(&fp, "CONOUT$", "w", stdout);
std_handle = (intptr_t)GetStdHandle(STD_ERROR_HANDLE);
con_handle = _open_osfhandle(std_handle, _O_TEXT);
fp = _fdopen(con_handle, "w");
freopen_s(&fp, "CONOUT$", "w", stderr);
}
static void RequestHighPerformance() {
#if XE_PLATFORM_WIN32
NTSTATUS(*NtQueryTimerResolution)
@ -97,8 +52,10 @@ static void RequestHighPerformance() {
#endif
}
static bool parse_launch_arguments(const xe::EntryInfo& entry_info,
std::vector<std::string>& args) {
bool ParseWin32LaunchArguments(
bool transparent_options, const std::string_view positional_usage,
const std::vector<std::string>& positional_options,
std::vector<std::string>* args_out) {
auto command_line = GetCommandLineW();
int wargc;
@ -118,48 +75,24 @@ static bool parse_launch_arguments(const xe::EntryInfo& entry_info,
LocalFree(wargv);
if (!entry_info.transparent_options) {
cvar::ParseLaunchArguments(argc, argv, entry_info.positional_usage.value(),
entry_info.positional_options.value());
if (!transparent_options) {
cvar::ParseLaunchArguments(argc, argv, positional_usage,
positional_options);
}
args.clear();
if (args_out) {
args_out->clear();
for (int n = 0; n < argc; n++) {
args.push_back(std::string(argv[n]));
args_out->push_back(std::string(argv[n]));
}
}
return true;
}
int Main() {
auto entry_info = xe::GetEntryInfo();
std::vector<std::string> args;
if (!parse_launch_arguments(entry_info, args)) {
return 1;
}
// Attach a console so we can write output to stdout. If the user hasn't
// redirected output themselves it'll pop up a window.
if (cvars::enable_console) {
xe::AttachConsole();
}
// Setup COM on the main thread.
// NOTE: this may fail if COM has already been initialized - that's OK.
#pragma warning(suppress : 6031)
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
int InitializeWin32App(const std::string_view app_name) {
// Initialize logging. Needs parsed FLAGS.
xe::InitializeLogging(entry_info.name);
Xbyak::util::Cpu cpu;
if (!cpu.has(Xbyak::util::Cpu::tAVX)) {
xe::FatalError(
"Your CPU does not support AVX, which is required by Xenia. See the "
"FAQ for system requirements at https://xenia.jp");
return -1;
}
xe::InitializeLogging(app_name);
// Print version info.
XELOGI(
@ -175,38 +108,9 @@ int Main() {
RequestHighPerformance();
}
// Call app-provided entry point.
int result = entry_info.entry_point(args);
xe::ShutdownLogging();
return result;
return 0;
}
void ShutdownWin32App() { xe::ShutdownLogging(); }
} // namespace xe
// Used in console mode apps; automatically picked based on subsystem.
int main(int argc_ignored, char** argv_ignored) { return xe::Main(); }
// Used in windowed apps; automatically picked based on subsystem.
int WINAPI wWinMain(HINSTANCE, HINSTANCE, LPWSTR command_line, int) {
// Run normal entry point.
return xe::Main();
}
#if defined _M_IX86
#pragma comment( \
linker, \
"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"") // NOLINT(whitespace/line_length)
#elif defined _M_IA64
#pragma comment( \
linker, \
"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"") // NOLINT(whitespace/line_length)
#elif defined _M_X64
#pragma comment( \
linker, \
"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"") // NOLINT(whitespace/line_length)
#else
#pragma comment( \
linker, \
"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") // NOLINT(whitespace/line_length)
#endif

29
src/xenia/base/main_win.h Normal file
View File

@ -0,0 +1,29 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_BASE_MAIN_WIN_H_
#define XENIA_BASE_MAIN_WIN_H_
#include <string>
#include <vector>
namespace xe {
// Functions for calling in both windowed and console entry points.
bool ParseWin32LaunchArguments(
bool transparent_options, const std::string_view positional_usage,
const std::vector<std::string>& positional_options,
std::vector<std::string>* args_out);
// InitializeWin32App uses cvars, call ParseWin32LaunchArguments before.
int InitializeWin32App(const std::string_view app_name);
void ShutdownWin32App();
} // namespace xe
#endif // XENIA_BASE_MAIN_WIN_H_

3
src/xenia/base/premake5.lua
View File

@ -11,7 +11,8 @@ project("xenia-base")
defines({
})
local_platform_files()
removefiles({"main_*.cc"})
removefiles({"console_app_main_*.cc"})
removefiles({"main_init_*.cc"})
files({
"debug_visualizers.natvis",
})

4
src/xenia/cpu/ppc/testing/ppc_testing_main.cc
View File

@ -7,10 +7,10 @@
******************************************************************************
*/
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/filesystem.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/math.h"
#include "xenia/base/platform.h"
#include "xenia/base/string_buffer.h"
@ -483,5 +483,5 @@ int main(const std::vector<std::string>& args) {
} // namespace cpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-cpu-ppc-test", xe::cpu::test::main, "[test name]",
XE_DEFINE_CONSOLE_APP("xenia-cpu-ppc-test", xe::cpu::test::main, "[test name]",
"test_name");

17
src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc
View File

@ -7,6 +7,8 @@
******************************************************************************
*/
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/filesystem.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
@ -23,6 +25,7 @@ DEFINE_string(test_path, "src/xenia/cpu/ppc/testing/",
"Directory scanned for test files.");
DEFINE_string(test_bin_path, "src/xenia/cpu/ppc/testing/bin/",
"Directory with binary outputs of the test files.");
DEFINE_transient_string(test_name, "", "Test suite name.", "General");
extern "C" void xe_call_native(void* context, void* fn);
@ -505,19 +508,13 @@ bool RunTests(const std::wstring& test_name) {
return failed_count ? false : true;
}
int main(const std::vector<std::wstring>& args) {
// Grab test name, if present.
std::wstring test_name;
if (args.size() >= 2) {
test_name = args[1];
}
return RunTests(test_name) ? 0 : 1;
int main(const std::vector<std::string>& args) {
return RunTests(cvars::test_name) ? 0 : 1;
}
} // namespace test
} // namespace cpu
} // namespace xe
DEFINE_ENTRY_POINT(L"xenia-cpu-ppc-test", L"xenia-cpu-ppc-test [test name]",
xe::cpu::test::main);
XE_DEFINE_CONSOLE_APP("xenia-cpu-ppc-test", xe::cpu::test::main, "[test name]",
"test_name");

4
src/xenia/cpu/ppc/testing/premake5.lua
View File

@ -17,7 +17,7 @@ project("xenia-cpu-ppc-tests")
})
files({
"ppc_testing_main.cc",
"../../../base/main_"..platform_suffix..".cc",
"../../../base/console_app_main_"..platform_suffix..".cc",
})
files({
"*.s",
@ -46,7 +46,7 @@ project("xenia-cpu-ppc-nativetests")
})
files({
"ppc_testing_native_main.cc",
"../../../base/main_"..platform_suffix..".cc",
"../../../base/console_app_main_"..platform_suffix..".cc",
})
files({
"instr_*.s",

8
src/xenia/cpu/testing/sandbox_main.cc
View File

@ -7,7 +7,7 @@
******************************************************************************
*/
#include "xenia/base/main.h"
#include "xenia/base/console_app_main.h"
#include "xenia/cpu/backend/x64/x64_backend.h"
#include "xenia/cpu/cpu.h"
#include "xenia/cpu/ppc/ppc_context.h"
@ -23,10 +23,10 @@ using xe::cpu::ppc::PPCContext;
// TODO(benvanik): simple memory? move more into core?
int main(std::vector<std::wstring>& args) {
int main(std::vector<std::string>& args) {
#if XE_OPTION_PROFILING
xe::Profiler::Initialize();
xe::Profiler::ThreadEnter("main");
xe::Profiler::ThreadEnter("Main");
#endif // XE_OPTION_PROFILING
size_t memory_size = 16 * 1024 * 1024;
@ -79,4 +79,4 @@ int main(std::vector<std::wstring>& args) {
} // namespace cpu
} // namespace xe
DEFINE_ENTRY_POINT(L"xenia-cpu-sandbox", L"?", xe::cpu::sandbox::main);
XE_DEFINE_CONSOLE_APP("xenia-cpu-sandbox", xe::cpu::sandbox::main, "");

1
src/xenia/cpu/testing/util.h
View File

@ -12,7 +12,6 @@
#include <vector>
#include "xenia/base/main.h"
#include "xenia/cpu/backend/x64/x64_backend.h"
#include "xenia/cpu/hir/hir_builder.h"
#include "xenia/cpu/ppc/ppc_context.h"

40
src/xenia/debug/ui/debug_window.cc
View File

@ -32,6 +32,7 @@
#include "xenia/kernel/xthread.h"
#include "xenia/ui/graphics_provider.h"
#include "xenia/ui/imgui_drawer.h"
#include "xenia/ui/windowed_app_context.h"
DEFINE_bool(imgui_debug, false, "Show ImGui debugging tools.", "UI");
@ -50,11 +51,12 @@ using xe::ui::UIEvent;
const std::string kBaseTitle = "Xenia Debugger";
DebugWindow::DebugWindow(Emulator* emulator, xe::ui::Loop* loop)
DebugWindow::DebugWindow(Emulator* emulator,
xe::ui::WindowedAppContext& app_context)
: emulator_(emulator),
processor_(emulator->processor()),
loop_(loop),
window_(xe::ui::Window::Create(loop_, kBaseTitle)) {
app_context_(app_context),
window_(xe::ui::Window::Create(app_context_, kBaseTitle)) {
if (cs_open(CS_ARCH_X86, CS_MODE_64, &capstone_handle_) != CS_ERR_OK) {
assert_always("Failed to initialize capstone");
}
@ -63,16 +65,18 @@ DebugWindow::DebugWindow(Emulator* emulator, xe::ui::Loop* loop)
}
DebugWindow::~DebugWindow() {
loop_->PostSynchronous([this]() { window_.reset(); });
// Make sure pending functions referencing the DebugWindow are executed.
app_context_.ExecutePendingFunctionsFromUIThread();
if (capstone_handle_) {
cs_close(&capstone_handle_);
}
}
std::unique_ptr<DebugWindow> DebugWindow::Create(Emulator* emulator,
xe::ui::Loop* loop) {
std::unique_ptr<DebugWindow> debug_window(new DebugWindow(emulator, loop));
std::unique_ptr<DebugWindow> DebugWindow::Create(
Emulator* emulator, xe::ui::WindowedAppContext& app_context) {
std::unique_ptr<DebugWindow> debug_window(
new DebugWindow(emulator, app_context));
if (!debug_window->Initialize()) {
xe::FatalError("Failed to initialize debug window");
return nullptr;
@ -87,8 +91,6 @@ bool DebugWindow::Initialize() {
return false;
}
loop_->on_quit.AddListener([this](UIEvent* e) { window_.reset(); });
// Main menu.
auto main_menu = MenuItem::Create(MenuItem::Type::kNormal);
auto file_menu = MenuItem::Create(MenuItem::Type::kPopup, "&File");
@ -1425,7 +1427,7 @@ void DebugWindow::UpdateCache() {
auto kernel_state = emulator_->kernel_state();
auto object_table = kernel_state->object_table();
loop_->Post([this]() {
app_context_.CallInUIThread([this]() {
std::string title = kBaseTitle;
switch (processor_->execution_state()) {
case cpu::ExecutionState::kEnded:
@ -1531,9 +1533,7 @@ Breakpoint* DebugWindow::LookupBreakpointAtAddress(
}
}
void DebugWindow::OnFocus() {
loop_->Post([this]() { window_->set_focus(true); });
}
void DebugWindow::OnFocus() { Focus(); }
void DebugWindow::OnDetached() {
UpdateCache();
@ -1546,30 +1546,34 @@ void DebugWindow::OnDetached() {
void DebugWindow::OnExecutionPaused() {
UpdateCache();
loop_->Post([this]() { window_->set_focus(true); });
Focus();
}
void DebugWindow::OnExecutionContinued() {
UpdateCache();
loop_->Post([this]() { window_->set_focus(true); });
Focus();
}
void DebugWindow::OnExecutionEnded() {
UpdateCache();
loop_->Post([this]() { window_->set_focus(true); });
Focus();
}
void DebugWindow::OnStepCompleted(cpu::ThreadDebugInfo* thread_info) {
UpdateCache();
SelectThreadStackFrame(thread_info, 0, true);
loop_->Post([this]() { window_->set_focus(true); });
Focus();
}
void DebugWindow::OnBreakpointHit(Breakpoint* breakpoint,
cpu::ThreadDebugInfo* thread_info) {
UpdateCache();
SelectThreadStackFrame(thread_info, 0, true);
loop_->Post([this]() { window_->set_focus(true); });
Focus();
}
void DebugWindow::Focus() const {
app_context_.CallInUIThread([this]() { window_->set_focus(true); });
}
} // namespace ui

15
src/xenia/debug/ui/debug_window.h
View File

@ -18,9 +18,9 @@
#include "xenia/cpu/debug_listener.h"
#include "xenia/cpu/processor.h"
#include "xenia/emulator.h"
#include "xenia/ui/loop.h"
#include "xenia/ui/menu_item.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/xbox.h"
namespace xe {
@ -31,11 +31,11 @@ class DebugWindow : public cpu::DebugListener {
public:
~DebugWindow();
static std::unique_ptr<DebugWindow> Create(Emulator* emulator,
xe::ui::Loop* loop);
static std::unique_ptr<DebugWindow> Create(
Emulator* emulator, xe::ui::WindowedAppContext& app_context);
Emulator* emulator() const { return emulator_; }
xe::ui::Loop* loop() const { return loop_; }
xe::ui::WindowedAppContext& app_context() const { return app_context_; }
xe::ui::Window* window() const { return window_.get(); }
void OnFocus() override;
@ -48,7 +48,8 @@ class DebugWindow : public cpu::DebugListener {
cpu::ThreadDebugInfo* thread_info) override;
private:
explicit DebugWindow(Emulator* emulator, xe::ui::Loop* loop);
explicit DebugWindow(Emulator* emulator,
xe::ui::WindowedAppContext& app_context);
bool Initialize();
void DrawFrame();
@ -86,9 +87,11 @@ class DebugWindow : public cpu::DebugListener {
cpu::Breakpoint* LookupBreakpointAtAddress(
cpu::Breakpoint::AddressType address_type, uint64_t address);
void Focus() const;
Emulator* emulator_ = nullptr;
cpu::Processor* processor_ = nullptr;
xe::ui::Loop* loop_ = nullptr;
xe::ui::WindowedAppContext& app_context_;
std::unique_ptr<xe::ui::Window> window_;
uint64_t last_draw_tick_count_ = 0;

6
src/xenia/emulator.cc
View File

@ -40,6 +40,8 @@
#include "xenia/kernel/xboxkrnl/xboxkrnl_module.h"
#include "xenia/memory.h"
#include "xenia/ui/imgui_dialog.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/vfs/devices/disc_image_device.h"
#include "xenia/vfs/devices/host_path_device.h"
#include "xenia/vfs/devices/null_device.h"
@ -233,7 +235,7 @@ X_STATUS Emulator::Setup(
if (display_window_) {
// Finish initializing the display.
display_window_->loop()->PostSynchronous([this]() {
display_window_->app_context().CallInUIThreadSynchronous([this]() {
xe::ui::GraphicsContextLock context_lock(display_window_->context());
Profiler::set_window(display_window_);
});
@ -583,7 +585,7 @@ bool Emulator::ExceptionCallback(Exception* ex) {
}
// Display a dialog telling the user the guest has crashed.
display_window()->loop()->PostSynchronous([&]() {
display_window()->app_context().CallInUIThreadSynchronous([this]() {
xe::ui::ImGuiDialog::ShowMessageBox(
display_window(), "Uh-oh!",
"The guest has crashed.\n\n"

2
src/xenia/gpu/d3d12/d3d12_graphics_system.cc
View File

@ -49,7 +49,7 @@ std::string D3D12GraphicsSystem::name() const {
X_STATUS D3D12GraphicsSystem::Setup(cpu::Processor* processor,
kernel::KernelState* kernel_state,
ui::Window* target_window) {
provider_ = xe::ui::d3d12::D3D12Provider::Create(target_window);
provider_ = xe::ui::d3d12::D3D12Provider::Create();
auto d3d12_provider = static_cast<xe::ui::d3d12::D3D12Provider*>(provider());
auto device = d3d12_provider->GetDevice();

4
src/xenia/gpu/d3d12/d3d12_trace_dump_main.cc
View File

@ -7,8 +7,8 @@
******************************************************************************
*/
#include "xenia/base/console_app_main.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/gpu/d3d12/d3d12_command_processor.h"
#include "xenia/gpu/d3d12/d3d12_graphics_system.h"
#include "xenia/gpu/trace_dump.h"
@ -54,6 +54,6 @@ int trace_dump_main(const std::vector<std::string>& args) {
} // namespace gpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-gpu-d3d12-trace-dump",
XE_DEFINE_CONSOLE_APP("xenia-gpu-d3d12-trace-dump",
xe::gpu::d3d12::trace_dump_main, "some.trace",
"target_trace_file");

29
src/xenia/gpu/d3d12/d3d12_trace_viewer_main.cc
View File

@ -2,13 +2,15 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <memory>
#include <string>
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/gpu/d3d12/d3d12_command_processor.h"
#include "xenia/gpu/d3d12/d3d12_graphics_system.h"
#include "xenia/gpu/trace_viewer.h"
@ -17,10 +19,13 @@ namespace xe {
namespace gpu {
namespace d3d12 {
using namespace xe::gpu::xenos;
class D3D12TraceViewer : public TraceViewer {
class D3D12TraceViewer final : public TraceViewer {
public:
static std::unique_ptr<WindowedApp> Create(
xe::ui::WindowedAppContext& app_context) {
return std::unique_ptr<WindowedApp>(new D3D12TraceViewer(app_context));
}
std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() override {
return std::unique_ptr<gpu::GraphicsSystem>(new D3D12GraphicsSystem());
}
@ -45,17 +50,15 @@ class D3D12TraceViewer : public TraceViewer {
// TextureInfo/SamplerInfo which are going away.
return 0;
}
};
int trace_viewer_main(const std::vector<std::string>& args) {
D3D12TraceViewer trace_viewer;
return trace_viewer.Main(args);
}
private:
explicit D3D12TraceViewer(xe::ui::WindowedAppContext& app_context)
: TraceViewer(app_context, "xenia-gpu-d3d12-trace-viewer") {}
};
} // namespace d3d12
} // namespace gpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-gpu-d3d12-trace-viewer",
xe::gpu::d3d12::trace_viewer_main, "some.trace",
"target_trace_file");
XE_DEFINE_WINDOWED_APP(xenia_gpu_d3d12_trace_viewer,
xe::gpu::d3d12::D3D12TraceViewer::Create);

4
src/xenia/gpu/d3d12/premake5.lua
View File

@ -54,7 +54,7 @@ project("xenia-gpu-d3d12-trace-viewer")
})
files({
"d3d12_trace_viewer_main.cc",
"../../base/main_"..platform_suffix..".cc",
"../../ui/windowed_app_main_"..platform_suffix..".cc",
})
-- Only create the .user file if it doesn't already exist.
local user_file = project_root.."/build/xenia-gpu-d3d12-trace-viewer.vcxproj.user"
@ -101,7 +101,7 @@ project("xenia-gpu-d3d12-trace-dump")
})
files({
"d3d12_trace_dump_main.cc",
"../../base/main_"..platform_suffix..".cc",
"../../base/console_app_main_"..platform_suffix..".cc",
})
-- Only create the .user file if it doesn't already exist.
local user_file = project_root.."/build/xenia-gpu-d3d12-trace-dump.vcxproj.user"

29
src/xenia/gpu/graphics_system.cc
View File

@ -18,7 +18,8 @@
#include "xenia/gpu/command_processor.h"
#include "xenia/gpu/gpu_flags.h"
#include "xenia/ui/graphics_provider.h"
#include "xenia/ui/loop.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
DEFINE_bool(
store_shaders, true,
@ -57,22 +58,24 @@ X_STATUS GraphicsSystem::Setup(cpu::Processor* processor,
// This must happen on the UI thread.
std::unique_ptr<xe::ui::GraphicsContext> processor_context = nullptr;
if (provider_) {
// Setup the context the command processor will do all its drawing in.
bool contexts_initialized = true;
processor_context = provider()->CreateOffscreenContext();
if (processor_context) {
if (target_window_) {
target_window_->loop()->PostSynchronous([&]() {
if (!target_window_->app_context().CallInUIThreadSynchronous([&]() {
// Create the context used for presentation.
assert_null(target_window->context());
target_window_->set_context(provider_->CreateContext(target_window_));
// Setup the context the command processor will do all its drawing in.
// It's shared with the display context so that we can resolve
// framebuffers from it.
processor_context = provider()->CreateOffscreenContext();
});
} else {
processor_context = provider()->CreateOffscreenContext();
target_window_->set_context(
provider_->CreateContext(target_window_));
})) {
contexts_initialized = false;
}
if (!processor_context) {
}
} else {
contexts_initialized = false;
}
if (!contexts_initialized) {
xe::FatalError(
"Unable to initialize graphics context. Xenia requires Vulkan "
"support.\n"

2
src/xenia/gpu/null/null_graphics_system.cc
View File

@ -26,7 +26,7 @@ X_STATUS NullGraphicsSystem::Setup(cpu::Processor* processor,
ui::Window* target_window) {
// This is a null graphics system, but we still setup vulkan because UI needs
// it through us :|
provider_ = xe::ui::vulkan::VulkanProvider::Create(target_window);
provider_ = xe::ui::vulkan::VulkanProvider::Create();
return GraphicsSystem::Setup(processor, kernel_state, target_window);
}

2
src/xenia/gpu/premake5.lua
View File

@ -45,7 +45,7 @@ project("xenia-gpu-shader-compiler")
})
files({
"shader_compiler_main.cc",
"../base/main_"..platform_suffix..".cc",
"../base/console_app_main_"..platform_suffix..".cc",
})
filter("platforms:Windows")

7
src/xenia/gpu/shader_compiler_main.cc
View File

@ -13,9 +13,9 @@
#include <vector>
#include "xenia/base/assert.h"
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/platform.h"
#include "xenia/base/string.h"
#include "xenia/base/string_buffer.h"
@ -229,5 +229,6 @@ int shader_compiler_main(const std::vector<std::string>& args) {
} // namespace gpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-gpu-shader-compiler", xe::gpu::shader_compiler_main,
"shader.bin", "shader_input");
XE_DEFINE_CONSOLE_APP("xenia-gpu-shader-compiler",
xe::gpu::shader_compiler_main, "shader.bin",
"shader_input");

2
src/xenia/gpu/trace_dump.cc
View File

@ -100,7 +100,7 @@ bool TraceDump::Setup() {
return false;
}
graphics_system_ = emulator_->graphics_system();
player_ = std::make_unique<TracePlayer>(nullptr, graphics_system_);
player_ = std::make_unique<TracePlayer>(graphics_system_);
return true;
}

5
src/xenia/gpu/trace_player.cc
View File

@ -17,9 +17,8 @@
namespace xe {
namespace gpu {
TracePlayer::TracePlayer(xe::ui::Loop* loop, GraphicsSystem* graphics_system)
: loop_(loop),
graphics_system_(graphics_system),
TracePlayer::TracePlayer(GraphicsSystem* graphics_system)
: graphics_system_(graphics_system),
current_frame_index_(0),
current_command_index_(-1) {
// Need to allocate all of physical memory so that we can write to it during

4
src/xenia/gpu/trace_player.h
View File

@ -16,7 +16,6 @@
#include "xenia/base/threading.h"
#include "xenia/gpu/trace_protocol.h"
#include "xenia/gpu/trace_reader.h"
#include "xenia/ui/loop.h"
namespace xe {
namespace gpu {
@ -30,7 +29,7 @@ enum class TracePlaybackMode {
class TracePlayer : public TraceReader {
public:
TracePlayer(xe::ui::Loop* loop, GraphicsSystem* graphics_system);
TracePlayer(GraphicsSystem* graphics_system);
~TracePlayer() override;
GraphicsSystem* graphics_system() const { return graphics_system_; }
@ -54,7 +53,6 @@ class TracePlayer : public TraceReader {
void PlayTraceOnThread(const uint8_t* trace_data, size_t trace_size,
TracePlaybackMode playback_mode, bool clear_caches);
xe::ui::Loop* loop_;
GraphicsSystem* graphics_system_;
int current_frame_index_;
int current_command_index_;

76
src/xenia/gpu/trace_viewer.cc
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -13,10 +13,12 @@
#include "third_party/half/include/half.hpp"
#include "third_party/imgui/imgui.h"
#include "xenia/base/assert.h"
#include "xenia/base/clock.h"
#include "xenia/base/logging.h"
#include "xenia/base/math.h"
#include "xenia/base/string.h"
#include "xenia/base/system.h"
#include "xenia/base/threading.h"
#include "xenia/gpu/command_processor.h"
#include "xenia/gpu/gpu_flags.h"
@ -30,6 +32,7 @@
#include "xenia/ui/imgui_drawer.h"
#include "xenia/ui/virtual_key.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/xbox.h"
DEFINE_path(target_trace_file, "", "Specifies the trace file to load.", "GPU");
@ -46,22 +49,16 @@ static const ImVec4 kColorComment =
static const ImVec4 kColorIgnored =
ImVec4(100 / 255.0f, 100 / 255.0f, 100 / 255.0f, 255 / 255.0f);
TraceViewer::TraceViewer() = default;
TraceViewer::TraceViewer(xe::ui::WindowedAppContext& app_context,
const std::string_view name)
: xe::ui::WindowedApp(app_context, name, "some.trace") {
AddPositionalOption("target_trace_file");
}
TraceViewer::~TraceViewer() = default;
int TraceViewer::Main(const std::vector<std::string>& args) {
// Grab path from the flag or unnamed argument.
std::filesystem::path path;
if (!cvars::target_trace_file.empty()) {
// Passed as a named argument.
// TODO(benvanik): find something better than gflags that supports
// unicode.
path = cvars::target_trace_file;
} else if (args.size() >= 2) {
// Passed as an unnamed argument.
path = xe::to_path(args[1]);
}
bool TraceViewer::OnInitialize() {
std::filesystem::path path = cvars::target_trace_file;
// If no path passed, ask the user.
if (path.empty()) {
@ -83,42 +80,37 @@ int TraceViewer::Main(const std::vector<std::string>& args) {
}
if (path.empty()) {
xe::FatalError("No trace file specified");
return 1;
xe::ShowSimpleMessageBox(xe::SimpleMessageBoxType::Warning,
"No trace file specified");
return false;
}
// Normalize the path and make absolute.
auto abs_path = std::filesystem::absolute(path);
if (!Setup()) {
xe::FatalError("Unable to setup trace viewer");
return 1;
xe::ShowSimpleMessageBox(xe::SimpleMessageBoxType::Error,
"Unable to setup trace viewer");
return false;
}
if (!Load(std::move(abs_path))) {
xe::FatalError("Unable to load trace file; not found?");
return 1;
xe::ShowSimpleMessageBox(xe::SimpleMessageBoxType::Error,
"Unable to load trace file; not found?");
return false;
}
Run();
return 0;
return true;
}
bool TraceViewer::Setup() {
// Main display window.
loop_ = ui::Loop::Create();
window_ = xe::ui::Window::Create(loop_.get(), "xenia-gpu-trace-viewer");
loop_->PostSynchronous([&]() {
xe::threading::set_name("Win32 Loop");
assert_true(app_context().IsInUIThread());
window_ = xe::ui::Window::Create(app_context(), "xenia-gpu-trace-viewer");
if (!window_->Initialize()) {
xe::FatalError("Failed to initialize main window");
return;
XELOGE("Failed to initialize main window");
return false;
}
});
window_->on_closed.AddListener([&](xe::ui::UIEvent* e) {
loop_->Quit();
XELOGI("User-initiated death!");
exit(1);
});
loop_->on_quit.AddListener([&](xe::ui::UIEvent* e) { window_.reset(); });
window_->on_closed.AddListener(
[this](xe::ui::UIEvent* e) { app_context().QuitFromUIThread(); });
window_->Resize(1920, 1200);
// Create the emulator but don't initialize so we can setup the window.
@ -142,9 +134,9 @@ bool TraceViewer::Setup() {
}
});
player_ = std::make_unique<TracePlayer>(loop_.get(), graphics_system_);
player_ = std::make_unique<TracePlayer>(graphics_system_);
window_->on_painting.AddListener([&](xe::ui::UIEvent* e) {
window_->on_painting.AddListener([this](xe::ui::UIEvent* e) {
DrawUI();
// Continuous paint.
@ -167,16 +159,6 @@ bool TraceViewer::Load(const std::filesystem::path& trace_file_path) {
return true;
}
void TraceViewer::Run() {
// Wait until we are exited.
loop_->AwaitQuit();
player_.reset();
emulator_.reset();
window_.reset();
loop_.reset();
}
void TraceViewer::DrawMultilineString(const std::string_view str) {
size_t i = 0;
bool done = false;

20
src/xenia/gpu/trace_viewer.h
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -18,13 +18,8 @@
#include "xenia/gpu/trace_protocol.h"
#include "xenia/gpu/xenos.h"
#include "xenia/memory.h"
namespace xe {
namespace ui {
class Loop;
class Window;
} // namespace ui
} // namespace xe
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app.h"
namespace xe {
namespace gpu {
@ -32,14 +27,15 @@ namespace gpu {
struct SamplerInfo;
struct TextureInfo;
class TraceViewer {
class TraceViewer : public xe::ui::WindowedApp {
public:
virtual ~TraceViewer();
int Main(const std::vector<std::string>& args);
bool OnInitialize() override;
protected:
TraceViewer();
explicit TraceViewer(xe::ui::WindowedAppContext& app_context,
const std::string_view name);
virtual std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() = 0;
@ -60,7 +56,6 @@ class TraceViewer {
virtual bool Setup();
std::unique_ptr<xe::ui::Loop> loop_;
std::unique_ptr<xe::ui::Window> window_;
std::unique_ptr<Emulator> emulator_;
Memory* memory_ = nullptr;
@ -75,7 +70,6 @@ class TraceViewer {
};
bool Load(const std::filesystem::path& trace_file_path);
void Run();
void DrawUI();
void DrawControllerUI();

4
src/xenia/gpu/vulkan/premake5.lua
View File

@ -62,7 +62,7 @@ project("xenia-gpu-vulkan-trace-viewer")
})
files({
"vulkan_trace_viewer_main.cc",
"../../base/main_"..platform_suffix..".cc",
"../../ui/windowed_app_main_"..platform_suffix..".cc",
})
filter("platforms:Linux")
@ -128,7 +128,7 @@ project("xenia-gpu-vulkan-trace-dump")
})
files({
"vulkan_trace_dump_main.cc",
"../../base/main_"..platform_suffix..".cc",
"../../base/console_app_main_"..platform_suffix..".cc",
})
filter("platforms:Linux")

2
src/xenia/gpu/vulkan/vulkan_graphics_system.cc
View File

@ -37,7 +37,7 @@ X_STATUS VulkanGraphicsSystem::Setup(cpu::Processor* processor,
kernel::KernelState* kernel_state,
ui::Window* target_window) {
// Must create the provider so we can create contexts.
auto provider = xe::ui::vulkan::VulkanProvider::Create(target_window);
auto provider = xe::ui::vulkan::VulkanProvider::Create();
device_ = provider->device();
provider_ = std::move(provider);

4
src/xenia/gpu/vulkan/vulkan_trace_dump_main.cc
View File

@ -7,8 +7,8 @@
******************************************************************************
*/
#include "xenia/base/console_app_main.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/gpu/trace_dump.h"
#include "xenia/gpu/vulkan/vulkan_command_processor.h"
#include "xenia/gpu/vulkan/vulkan_graphics_system.h"
@ -55,6 +55,6 @@ int trace_dump_main(const std::vector<std::string>& args) {
} // namespace gpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-gpu-vulkan-trace-dump",
XE_DEFINE_CONSOLE_APP("xenia-gpu-vulkan-trace-dump",
xe::gpu::vulkan::trace_dump_main, "some.trace",
"target_trace_file");

27
src/xenia/gpu/vulkan/vulkan_trace_viewer_main.cc
View File

@ -2,13 +2,15 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <memory>
#include <string>
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/gpu/trace_viewer.h"
#include "xenia/gpu/vulkan/vulkan_command_processor.h"
#include "xenia/gpu/vulkan/vulkan_graphics_system.h"
@ -19,8 +21,13 @@ namespace vulkan {
using namespace xe::gpu::xenos;
class VulkanTraceViewer : public TraceViewer {
class VulkanTraceViewer final : public TraceViewer {
public:
static std::unique_ptr<WindowedApp> Create(
xe::ui::WindowedAppContext& app_context) {
return std::unique_ptr<WindowedApp>(new VulkanTraceViewer(app_context));
}
std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() override {
return std::unique_ptr<gpu::GraphicsSystem>(new VulkanGraphicsSystem());
}
@ -60,17 +67,15 @@ class VulkanTraceViewer : public TraceViewer {
// return static_cast<uintptr_t>(texture->handle);
return 0;
}
};
int trace_viewer_main(const std::vector<std::string>& args) {
VulkanTraceViewer trace_viewer;
return trace_viewer.Main(args);
}
private:
explicit VulkanTraceViewer(xe::ui::WindowedAppContext& app_context)
: TraceViewer(app_context, "xenia-gpu-vulkan-trace-viewer") {}
};
} // namespace vulkan
} // namespace gpu
} // namespace xe
DEFINE_ENTRY_POINT("xenia-gpu-vulkan-trace-viewer",
xe::gpu::vulkan::trace_viewer_main, "some.trace",
"target_trace_file");
XE_DEFINE_WINDOWED_APP(xenia_gpu_vulkan_trace_viewer,
xe::gpu::vulkan::VulkanTraceViewer::Create);

128
src/xenia/hid/hid_demo.cc
View File

@ -10,15 +10,17 @@
#include <array>
#include <cstring>
#include <forward_list>
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#include "third_party/fmt/include/fmt/format.h"
#include "third_party/imgui/imgui.h"
#include "xenia/base/clock.h"
#include "xenia/base/cvar.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/threading.h"
#include "xenia/hid/hid_flags.h"
#include "xenia/hid/input_system.h"
@ -26,6 +28,7 @@
#include "xenia/ui/virtual_key.h"
#include "xenia/ui/vulkan/vulkan_provider.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app.h"
// Available input drivers:
#include "xenia/hid/nop/nop_hid.h"
@ -46,10 +49,36 @@ DEFINE_string(hid, "any", "Input system. Use: [any, nop, sdl, winkey, xinput]",
namespace xe {
namespace hid {
std::unique_ptr<xe::hid::InputSystem> input_system_;
bool is_active = true;
class HidDemoApp final : public ui::WindowedApp {
public:
static std::unique_ptr<ui::WindowedApp> Create(
ui::WindowedAppContext& app_context) {
return std::unique_ptr<ui::WindowedApp>(new HidDemoApp(app_context));
}
std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
bool OnInitialize() override;
private:
explicit HidDemoApp(ui::WindowedAppContext& app_context)
: ui::WindowedApp(app_context, "xenia-hid-demo") {}
static std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
ui::Window* window);
void DrawUserInputGetState(uint32_t user_index) const;
void DrawInputGetState() const;
void DrawUserInputGetKeystroke(uint32_t user_index, bool poll,
bool hide_repeats, bool clear_log) const;
void DrawInputGetKeystroke(bool poll, bool hide_repeats,
bool clear_log) const;
std::unique_ptr<ui::GraphicsProvider> graphics_provider_;
std::unique_ptr<ui::Window> window_;
std::unique_ptr<InputSystem> input_system_;
bool is_active_ = true;
};
std::vector<std::unique_ptr<hid::InputDriver>> HidDemoApp::CreateInputDrivers(
ui::Window* window) {
std::vector<std::unique_ptr<hid::InputDriver>> drivers;
if (cvars::hid.compare("nop") == 0) {
@ -94,60 +123,46 @@ std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
return drivers;
}
std::unique_ptr<xe::ui::GraphicsProvider> CreateDemoGraphicsProvider(
xe::ui::Window* window) {
return xe::ui::vulkan::VulkanProvider::Create(window);
bool HidDemoApp::OnInitialize() {
// Create graphics provider that provides the context for the window.
graphics_provider_ = xe::ui::vulkan::VulkanProvider::Create();
if (!graphics_provider_) {
return false;
}
void DrawInputGetState();
void DrawInputGetKeystroke(bool poll, bool hide_repeats, bool clear_log);
int hid_demo_main(const std::vector<std::string>& args) {
// Create run loop and the window.
auto loop = ui::Loop::Create();
auto window = xe::ui::Window::Create(loop.get(), GetEntryInfo().name);
loop->PostSynchronous([&window]() {
xe::threading::set_name("Win32 Loop");
if (!window->Initialize()) {
FatalError("Failed to initialize main window");
return;
// Create the window.
window_ = xe::ui::Window::Create(app_context(), GetName());
if (!window_->Initialize()) {
XELOGE("Failed to initialize main window");
return false;
}
});
window->on_closed.AddListener([&loop](xe::ui::UIEvent* e) {
loop->Quit();
window_->on_closed.AddListener([this](xe::ui::UIEvent* e) {
XELOGI("User-initiated death!");
exit(1);
app_context().QuitFromUIThread();
});
loop->on_quit.AddListener([&window](xe::ui::UIEvent* e) { window.reset(); });
// Initial size setting, done here so that it knows the menu exists.
window->Resize(COL_WIDTH_STATE + COL_WIDTH_STROKE, ROW_HEIGHT_GENERAL + 500);
window_->Resize(COL_WIDTH_STATE + COL_WIDTH_STROKE, ROW_HEIGHT_GENERAL + 500);
// Create the graphics context used for drawing and setup the window.
std::unique_ptr<xe::ui::GraphicsProvider> graphics_provider;
loop->PostSynchronous([&window, &graphics_provider]() {
// Create context and give it to the window.
// The window will finish initialization wtih the context (loading
// resources, etc).
graphics_provider = CreateDemoGraphicsProvider(window.get());
window->set_context(graphics_provider->CreateContext(window.get()));
// Create the graphics context for the window. The window will finish
// initialization with the context (loading resources, etc).
window_->set_context(graphics_provider_->CreateContext(window_.get()));
// Initialize input system and all drivers.
input_system_ = std::make_unique<xe::hid::InputSystem>(window.get());
auto drivers = CreateInputDrivers(window.get());
input_system_ = std::make_unique<xe::hid::InputSystem>(window_.get());
auto drivers = CreateInputDrivers(window_.get());
for (size_t i = 0; i < drivers.size(); ++i) {
auto& driver = drivers[i];
driver->set_is_active_callback([]() -> bool { return is_active; });
driver->set_is_active_callback([this]() -> bool { return is_active_; });
input_system_->AddDriver(std::move(driver));
}
window->Invalidate();
});
window_->Invalidate();
window->set_imgui_input_enabled(true);
window_->set_imgui_input_enabled(true);
window->on_painting.AddListener([&](xe::ui::UIEvent* e) {
auto& io = window->imgui_drawer()->GetIO();
window_->on_painting.AddListener([this](xe::ui::UIEvent* e) {
auto& io = window_->imgui_drawer()->GetIO();
const ImGuiWindowFlags wflags =
ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
@ -161,7 +176,7 @@ int hid_demo_main(const std::vector<std::string>& args) {
ImVec2(COL_WIDTH_STATE + COL_WIDTH_STROKE, ROW_HEIGHT_GENERAL));
ImGui::Text("Input System (hid) = \"%s\"", cvars::hid.c_str());
ImGui::Checkbox("is_active", &is_active);
ImGui::Checkbox("is_active", &is_active_);
}
ImGui::End();
@ -201,21 +216,13 @@ int hid_demo_main(const std::vector<std::string>& args) {
ImGui::End();
// Continuous paint.
window->Invalidate();
window_->Invalidate();
});
// Wait until we are exited.
loop->AwaitQuit();
input_system_.reset();
loop->PostSynchronous([&graphics_provider]() { graphics_provider.reset(); });
window.reset();
loop.reset();
return 0;
return true;
}
void DrawUserInputGetState(uint32_t user_index) {
void HidDemoApp::DrawUserInputGetState(uint32_t user_index) const {
ImGui::Text("User %u:", user_index);
X_INPUT_STATE state;
@ -274,7 +281,7 @@ void DrawUserInputGetState(uint32_t user_index) {
ImGui::Text(" ");
}
void DrawInputGetState() {
void HidDemoApp::DrawInputGetState() const {
ImGui::BeginChild("##input_get_state_scroll");
for (uint32_t user_index = 0; user_index < MAX_USERS; ++user_index) {
DrawUserInputGetState(user_index);
@ -282,7 +289,11 @@ void DrawInputGetState() {
ImGui::EndChild();
}
static const std::unordered_map<ui::VirtualKey, const std::string> kVkPretty = {
void HidDemoApp::DrawUserInputGetKeystroke(uint32_t user_index, bool poll,
bool hide_repeats,
bool clear_log) const {
static const std::unordered_map<ui::VirtualKey, const std::string> kVkPretty =
{
{ui::VirtualKey::kXInputPadA, "A"},
{ui::VirtualKey::kXInputPadB, "B"},
{ui::VirtualKey::kXInputPadX, "X"},
@ -320,8 +331,6 @@ static const std::unordered_map<ui::VirtualKey, const std::string> kVkPretty = {
{ui::VirtualKey::kXInputPadRThumbDownLeft, "R Thumb down & left"},
};
void DrawUserInputGetKeystroke(uint32_t user_index, bool poll,
bool hide_repeats, bool clear_log) {
const size_t maxLog = 128;
static std::array<std::forward_list<std::string>, MAX_USERS> event_logs;
static std::array<uint64_t, MAX_USERS> last_event_times = {};
@ -400,7 +409,8 @@ void DrawUserInputGetKeystroke(uint32_t user_index, bool poll,
}
}
void DrawInputGetKeystroke(bool poll, bool hide_repeats, bool clear_log) {
void HidDemoApp::DrawInputGetKeystroke(bool poll, bool hide_repeats,
bool clear_log) const {
bool tab_bar = ImGui::BeginTabBar("DrawInputGetKeystroke");
for (uint32_t user_index = 0; user_index < MAX_USERS; ++user_index) {
DrawUserInputGetKeystroke(user_index, poll, hide_repeats, clear_log);
@ -411,4 +421,4 @@ void DrawInputGetKeystroke(bool poll, bool hide_repeats, bool clear_log) {
} // namespace hid
} // namespace xe
DEFINE_ENTRY_POINT("xenia-hid-demo", xe::hid::hid_demo_main, "");
XE_DEFINE_WINDOWED_APP(xenia_hid_demo, xe::hid::HidDemoApp::Create);

2
src/xenia/hid/premake5.lua
View File

@ -32,7 +32,7 @@ project("xenia-hid-demo")
})
files({
"hid_demo.cc",
"../base/main_"..platform_suffix..".cc",
"../ui/windowed_app_main_"..platform_suffix..".cc",
})
resincludedirs({
project_root,

18
src/xenia/hid/sdl/sdl_input_driver.cc
View File

@ -22,6 +22,7 @@
#include "xenia/hid/hid_flags.h"
#include "xenia/ui/virtual_key.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
// TODO(joellinn) make this path relative to the config folder.
DEFINE_path(mappings_file, "gamecontrollerdb.txt",
@ -43,6 +44,12 @@ SDLInputDriver::SDLInputDriver(xe::ui::Window* window)
keystroke_states_() {}
SDLInputDriver::~SDLInputDriver() {
// Make sure the CallInUIThread is executed before destroying the references.
if (sdl_pumpevents_queued_) {
window()->app_context().CallInUIThreadSynchronous([this]() {
window()->app_context().ExecutePendingFunctionsFromUIThread();
});
}
for (size_t i = 0; i < controllers_.size(); i++) {
if (controllers_.at(i).sdl) {
SDL_GameControllerClose(controllers_.at(i).sdl);
@ -65,8 +72,9 @@ X_STATUS SDLInputDriver::Setup() {
}
// SDL_PumpEvents should only be run in the thread that initialized SDL - we
// are hijacking the window loop thread for that.
window()->loop()->PostSynchronous([&]() {
// are hijacking the UI thread for that. If this function fails to be queued,
// the "initialized" variables will be false - that's handled safely.
window()->app_context().CallInUIThreadSynchronous([this]() {
if (!xe::helper::sdl::SDLHelper::Prepare()) {
return;
}
@ -129,7 +137,9 @@ X_STATUS SDLInputDriver::Setup() {
}
}
});
return sdl_events_initialized_ && sdl_gamecontroller_initialized_;
return (sdl_events_initialized_ && sdl_gamecontroller_initialized_)
? X_STATUS_SUCCESS
: X_STATUS_UNSUCCESSFUL;
}
X_RESULT SDLInputDriver::GetCapabilities(uint32_t user_index, uint32_t flags,
@ -693,7 +703,7 @@ void SDLInputDriver::QueueControllerUpdate() {
bool is_queued = false;
sdl_pumpevents_queued_.compare_exchange_strong(is_queued, true);
if (!is_queued) {
window()->loop()->Post([this]() {
window()->app_context().CallInUIThread([this]() {
SDL_PumpEvents();
sdl_pumpevents_queued_ = false;
});

6
src/xenia/kernel/xam/xam_nui.cc
View File

@ -15,6 +15,7 @@
#include "xenia/kernel/xam/xam_private.h"
#include "xenia/ui/imgui_dialog.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/xbox.h"
namespace xe {
@ -50,15 +51,16 @@ dword_result_t XamShowNuiTroubleshooterUI(unknown_t unk1, unknown_t unk2,
auto display_window = kernel_state()->emulator()->display_window();
xe::threading::Fence fence;
display_window->loop()->PostSynchronous([&]() {
if (display_window->app_context().CallInUIThreadSynchronous([&]() {
xe::ui::ImGuiDialog::ShowMessageBox(
display_window, "NUI Troubleshooter",
"The game has indicated there is a problem with NUI (Kinect).")
->Then(&fence);
});
})) {
++xam_dialogs_shown_;
fence.Wait();
--xam_dialogs_shown_;
}
return 0;
}

17
src/xenia/kernel/xam/xam_ui.cc
View File

@ -17,6 +17,7 @@
#include "xenia/kernel/xam/xam_private.h"
#include "xenia/ui/imgui_dialog.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app_context.h"
#include "xenia/xbox.h"
namespace xe {
@ -76,11 +77,16 @@ X_RESULT xeXamDispatchDialog(T* dialog,
result = close_callback(dialog);
});
xe::threading::Fence fence;
kernel_state()->emulator()->display_window()->loop()->PostSynchronous(
[&dialog, &fence]() { dialog->Then(&fence); });
xe::ui::WindowedAppContext& app_context =
kernel_state()->emulator()->display_window()->app_context();
if (app_context.CallInUIThreadSynchronous(
[&dialog, &fence]() { dialog->Then(&fence); })) {
++xam_dialogs_shown_;
fence.Wait();
--xam_dialogs_shown_;
} else {
delete dialog;
}
// dialog should be deleted at this point!
return result;
};
@ -117,11 +123,14 @@ X_RESULT xeXamDispatchDialogEx(
result = close_callback(dialog, extended_error, length);
});
xe::threading::Fence fence;
display_window->loop()->PostSynchronous(
[&dialog, &fence]() { dialog->Then(&fence); });
if (display_window->app_context().CallInUIThreadSynchronous(
[&dialog, &fence]() { dialog->Then(&fence); })) {
++xam_dialogs_shown_;
fence.Wait();
--xam_dialogs_shown_;
} else {
delete dialog;
}
// dialog should be deleted at this point!
return result;
};

18
src/xenia/kernel/xthread.cc
View File

@ -11,10 +11,6 @@
#include <cstring>
#ifdef XE_PLATFORM_WIN32
#include <objbase.h>
#endif
#include "third_party/fmt/include/fmt/format.h"
#include "xenia/base/byte_stream.h"
#include "xenia/base/clock.h"
@ -383,20 +379,6 @@ X_STATUS XThread::Create() {
// Set name immediately, if we have one.
thread_->set_name(thread_name_);
#ifdef XE_PLATFORM_WIN32
// Setup COM on this thread.
//
// https://devblogs.microsoft.com/oldnewthing/?p=4613
//
// "If any thread in the process calls CoInitialize[Ex] with the
// COINIT_MULTITHREADED flag, then that not only initializes the current
// thread as a member of the multi-threaded apartment, but it also says,
// "Any thread which has never called CoInitialize[Ex] is also part of the
// multi-threaded apartment."
#pragma warning(suppress : 6031)
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
#endif
// Profiler needs to know about the thread.
xe::Profiler::ThreadEnter(thread_name_.c_str());

5
src/xenia/tools/api-scanner/api_scanner_loader.h
View File

@ -7,11 +7,12 @@
******************************************************************************
*/
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
#include "xenia/base/main.h"
#include "xenia/base/math.h"
#include "xenia/base/string.h"
#include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/fs/filesystem.h"
#include "xenia/kernel/objects/xfile.h"

18
src/xenia/tools/api-scanner/api_scanner_main.cc
View File

@ -7,17 +7,25 @@
******************************************************************************
*/
#include "api_scanner_loader.h"
#include <cstdio>
#include <string>
#include <vector>
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/string.h"
#include "xenia/tools/api_scanner_loader.h"
namespace xe {
namespace tools {
DEFINE_string(target, "", "List of file to extract imports from");
DEFINE_transient_string(target, "", "List of file to extract imports from");
// TODO(Triang3l): Change to std::string (currently doesn't even compile).
int api_scanner_main(std::vector<std::wstring>& args) {
// XXX we need gflags to split multiple flags into arrays for us
if (args.size() == 2 || !FLAGS_target.empty()) {
if (args.size() == 2 || !cvars::target.empty()) {
apiscanner_loader loader_;
std::wstring target(cvars::target.empty() ? args[1]
: xe::to_wstring(cvars::target));
@ -41,5 +49,5 @@ int api_scanner_main(std::vector<std::wstring>& args) {
} // namespace tools
} // namespace xe
DEFINE_ENTRY_POINT(L"api-scanner", L"api-scanner --target=<target file>",
xe::tools::api_scanner_main);
XE_DEFINE_CONSOLE_APP("api-scanner", xe::tools::api_scanner_main,
"[target file]", "target");

7
src/xenia/ui/d3d12/d3d12_provider.cc
View File

@ -47,8 +47,8 @@ bool D3D12Provider::IsD3D12APIAvailable() {
return true;
}
std::unique_ptr<D3D12Provider> D3D12Provider::Create(Window* main_window) {
std::unique_ptr<D3D12Provider> provider(new D3D12Provider(main_window));
std::unique_ptr<D3D12Provider> D3D12Provider::Create() {
std::unique_ptr<D3D12Provider> provider(new D3D12Provider);
if (!provider->Initialize()) {
xe::FatalError(
"Unable to initialize Direct3D 12 graphics subsystem.\n"
@ -63,9 +63,6 @@ std::unique_ptr<D3D12Provider> D3D12Provider::Create(Window* main_window) {
return provider;
}
D3D12Provider::D3D12Provider(Window* main_window)
: GraphicsProvider(main_window) {}
D3D12Provider::~D3D12Provider() {
if (graphics_analysis_ != nullptr) {
graphics_analysis_->Release();

4
src/xenia/ui/d3d12/d3d12_provider.h
View File

@ -27,7 +27,7 @@ class D3D12Provider : public GraphicsProvider {
static bool IsD3D12APIAvailable();
static std::unique_ptr<D3D12Provider> Create(Window* main_window);
static std::unique_ptr<D3D12Provider> Create();
std::unique_ptr<GraphicsContext> CreateContext(
Window* target_window) override;
@ -147,7 +147,7 @@ class D3D12Provider : public GraphicsProvider {
}
private:
explicit D3D12Provider(Window* main_window);
D3D12Provider() = default;
static bool EnableIncreaseBasePriorityPrivilege();
bool Initialize();

34
src/xenia/ui/d3d12/d3d12_window_demo.cc
View File

@ -2,28 +2,44 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <memory>
#include <string>
#include <vector>
#include "xenia/base/main.h"
#include "xenia/ui/d3d12/d3d12_provider.h"
#include "xenia/ui/window.h"
#include "xenia/ui/window_demo.h"
#include "xenia/ui/windowed_app.h"
namespace xe {
namespace ui {
namespace d3d12 {
int window_demo_main(const std::vector<std::string>& args);
std::unique_ptr<GraphicsProvider> CreateDemoGraphicsProvider(Window* window) {
return xe::ui::d3d12::D3D12Provider::Create(window);
class D3D12WindowDemoApp final : public WindowDemoApp {
public:
static std::unique_ptr<WindowedApp> Create(WindowedAppContext& app_context) {
return std::unique_ptr<WindowedApp>(new D3D12WindowDemoApp(app_context));
}
protected:
std::unique_ptr<GraphicsProvider> CreateGraphicsProvider() const override;
private:
explicit D3D12WindowDemoApp(WindowedAppContext& app_context)
: WindowDemoApp(app_context, "xenia-ui-window-d3d12-demo") {}
};
std::unique_ptr<GraphicsProvider> D3D12WindowDemoApp::CreateGraphicsProvider()
const {
return D3D12Provider::Create();
}
} // namespace d3d12
} // namespace ui
} // namespace xe
DEFINE_ENTRY_POINT("xenia-ui-window-d3d12-demo", xe::ui::window_demo_main, "");
XE_DEFINE_WINDOWED_APP(xenia_ui_window_d3d12_demo,
xe::ui::d3d12::D3D12WindowDemoApp::Create);

2
src/xenia/ui/d3d12/premake5.lua
View File

@ -30,7 +30,7 @@ project("xenia-ui-window-d3d12-demo")
files({
"../window_demo.cc",
"d3d12_window_demo.cc",
project_root.."/src/xenia/base/main_"..platform_suffix..".cc",
project_root.."/src/xenia/ui/windowed_app_main_"..platform_suffix..".cc",
})
resincludedirs({
project_root,

34
src/xenia/ui/file_picker_win.cc
View File

@ -12,6 +12,9 @@
#include "xenia/base/string.h"
#include "xenia/ui/file_picker.h"
// Microsoft headers after platform_win.h.
#include <wrl/client.h>
namespace xe {
namespace ui {
@ -106,32 +109,16 @@ Win32FilePicker::Win32FilePicker() = default;
Win32FilePicker::~Win32FilePicker() = default;
template <typename T>
struct com_ptr {
com_ptr() : value(nullptr) {}
~com_ptr() { reset(); }
void reset() {
if (value) {
value->Release();
value = nullptr;
}
}
operator T*() { return value; }
T* operator->() const { return value; }
T** addressof() { return &value; }
T* value;
};
bool Win32FilePicker::Show(void* parent_window_handle) {
// TODO(benvanik): FileSaveDialog.
assert_true(mode() == Mode::kOpen);
// TODO(benvanik): folder dialogs.
assert_true(type() == Type::kFile);
com_ptr<IFileDialog> file_dialog;
Microsoft::WRL::ComPtr<IFileDialog> file_dialog;
HRESULT hr =
CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(file_dialog.addressof()));
IID_PPV_ARGS(&file_dialog));
if (!SUCCEEDED(hr)) {
return false;
}
@ -180,14 +167,13 @@ bool Win32FilePicker::Show(void* parent_window_handle) {
}
// Create an event handling object, and hook it up to the dialog.
com_ptr<IFileDialogEvents> file_dialog_events;
hr = CDialogEventHandler_CreateInstance(
IID_PPV_ARGS(file_dialog_events.addressof()));
Microsoft::WRL::ComPtr<IFileDialogEvents> file_dialog_events;
hr = CDialogEventHandler_CreateInstance(IID_PPV_ARGS(&file_dialog_events));
if (!SUCCEEDED(hr)) {
return false;
}
DWORD cookie;
hr = file_dialog->Advise(file_dialog_events, &cookie);
hr = file_dialog->Advise(file_dialog_events.Get(), &cookie);
if (!SUCCEEDED(hr)) {
return false;
}
@ -201,8 +187,8 @@ bool Win32FilePicker::Show(void* parent_window_handle) {
// Obtain the result once the user clicks the 'Open' button.
// The result is an IShellItem object.
com_ptr<IShellItem> shell_item;
hr = file_dialog->GetResult(shell_item.addressof());
Microsoft::WRL::ComPtr<IShellItem> shell_item;
hr = file_dialog->GetResult(&shell_item);
if (!SUCCEEDED(hr)) {
return false;
}

7
src/xenia/ui/graphics_provider.h
View File

@ -36,9 +36,6 @@ class GraphicsProvider {
virtual ~GraphicsProvider() = default;
// The 'main' window of an application, used to query provider information.
Window* main_window() const { return main_window_; }
// Creates a new graphics context and swapchain for presenting to a window.
virtual std::unique_ptr<GraphicsContext> CreateContext(
Window* target_window) = 0;
@ -48,9 +45,7 @@ class GraphicsProvider {
virtual std::unique_ptr<GraphicsContext> CreateOffscreenContext() = 0;
protected:
explicit GraphicsProvider(Window* main_window) : main_window_(main_window) {}
Window* main_window_ = nullptr;
GraphicsProvider() = default;
};
} // namespace ui

37
src/xenia/ui/loop.cc
View File

@ -1,37 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/loop.h"
#include "xenia/base/assert.h"
#include "xenia/base/threading.h"
namespace xe {
namespace ui {
Loop::Loop() = default;
Loop::~Loop() = default;
void Loop::PostSynchronous(std::function<void()> fn) {
if (is_on_loop_thread()) {
// Prevent deadlock if we are executing on ourselves.
fn();
return;
}
xe::threading::Fence fence;
Post([&fn, &fence]() {
fn();
fence.Signal();
});
fence.Wait();
}
} // namespace ui
} // namespace xe

45
src/xenia/ui/loop.h
View File

@ -1,45 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_LOOP_H_
#define XENIA_UI_LOOP_H_
#include <functional>
#include <memory>
#include "xenia/base/delegate.h"
#include "xenia/ui/ui_event.h"
namespace xe {
namespace ui {
class Loop {
public:
static std::unique_ptr<Loop> Create();
Loop();
virtual ~Loop();
// Returns true if the currently executing code is within the loop thread.
virtual bool is_on_loop_thread() = 0;
virtual void Post(std::function<void()> fn) = 0;
virtual void PostDelayed(std::function<void()> fn, uint64_t delay_millis) = 0;
void PostSynchronous(std::function<void()> fn);
virtual void Quit() = 0;
virtual void AwaitQuit() = 0;
Delegate<UIEvent*> on_quit;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_LOOP_H_

81
src/xenia/ui/loop_gtk.cc
View File

@ -1,81 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/loop_gtk.h"
#include <gdk/gdkx.h>
#include <gtk/gtk.h>
#include "xenia/base/assert.h"
namespace xe {
namespace ui {
std::unique_ptr<Loop> Loop::Create() { return std::make_unique<GTKLoop>(); }
GTKLoop::GTKLoop() : thread_id_() {
gtk_init(nullptr, nullptr);
xe::threading::Fence init_fence;
thread_ = std::thread([&init_fence, this]() {
xe::threading::set_name("GTK Loop");
thread_id_ = std::this_thread::get_id();
init_fence.Signal();
ThreadMain();
quit_fence_.Signal();
});
init_fence.Wait();
}
GTKLoop::~GTKLoop() {
Quit();
thread_.join();
}
void GTKLoop::ThreadMain() { gtk_main(); }
bool GTKLoop::is_on_loop_thread() {
return thread_id_ == std::this_thread::get_id();
}
gboolean _posted_fn_thunk(gpointer posted_fn) {
// convert gpointer back to std::function, call it, then free std::function
std::function<void()>* f =
reinterpret_cast<std::function<void()>*>(posted_fn);
std::function<void()>& func = *f;
func();
delete f;
// Tells GDK we don't want to run this again
return G_SOURCE_REMOVE;
}
void GTKLoop::Post(std::function<void()> fn) {
assert_true(thread_id_ != std::thread::id());
// converting std::function to a generic pointer for gdk
gdk_threads_add_idle(_posted_fn_thunk, reinterpret_cast<gpointer>(
new std::function<void()>(fn)));
}
void GTKLoop::PostDelayed(std::function<void()> fn, uint64_t delay_millis) {
gdk_threads_add_timeout(
delay_millis, _posted_fn_thunk,
reinterpret_cast<gpointer>(new std::function<void()>(fn)));
}
void GTKLoop::Quit() {
assert_true(thread_id_ != std::thread::id());
Post([]() { gtk_main_quit(); });
}
void GTKLoop::AwaitQuit() { quit_fence_.Wait(); }
} // namespace ui
} // namespace xe

131
src/xenia/ui/loop_win.cc
View File

@ -1,131 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/loop_win.h"
#include "xenia/base/assert.h"
namespace xe {
namespace ui {
std::unique_ptr<Loop> Loop::Create() { return std::make_unique<Win32Loop>(); }
Win32Loop::Win32Loop() : thread_id_(0) {
timer_queue_ = CreateTimerQueue();
xe::threading::Fence init_fence;
thread_ = std::thread([&init_fence, this]() {
xe::threading::set_name("Win32 Loop");
thread_id_ = GetCurrentThreadId();
// Make a Win32 call to enable the thread queue.
MSG msg;
PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
init_fence.Signal();
ThreadMain();
quit_fence_.Signal();
});
init_fence.Wait();
}
Win32Loop::~Win32Loop() {
Quit();
thread_.join();
DeleteTimerQueueEx(timer_queue_, INVALID_HANDLE_VALUE);
std::lock_guard<std::mutex> lock(pending_timers_mutex_);
while (!pending_timers_.empty()) {
auto timer = pending_timers_.back();
pending_timers_.pop_back();
delete timer;
}
}
void Win32Loop::ThreadMain() {
MSG msg;
while (!should_exit_ && GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
// Process queued functions.
std::lock_guard<std::recursive_mutex> lock(posted_functions_mutex_);
for (auto it = posted_functions_.begin(); it != posted_functions_.end();) {
(*it).Call();
it = posted_functions_.erase(it);
}
}
UIEvent e(nullptr);
on_quit(&e);
}
bool Win32Loop::is_on_loop_thread() {
return thread_id_ == GetCurrentThreadId();
}
void Win32Loop::Post(std::function<void()> fn) {
assert_true(thread_id_ != 0);
{
std::lock_guard<std::recursive_mutex> lock(posted_functions_mutex_);
PostedFn posted_fn(fn);
posted_functions_.push_back(posted_fn);
}
while (!PostThreadMessage(thread_id_, WM_NULL, 0, 0)) {
Sleep(1);
}
}
void Win32Loop::TimerQueueCallback(void* context, uint8_t) {
auto timer = reinterpret_cast<PendingTimer*>(context);
auto loop = timer->loop;
auto fn = std::move(timer->fn);
DeleteTimerQueueTimer(timer->timer_queue, timer->timer_handle, NULL);
{
std::lock_guard<std::mutex> lock(loop->pending_timers_mutex_);
loop->pending_timers_.remove(timer);
}
delete timer;
loop->Post(std::move(fn));
}
void Win32Loop::PostDelayed(std::function<void()> fn, uint64_t delay_millis) {
if (!delay_millis) {
Post(std::move(fn));
return;
}
auto timer = new PendingTimer();
timer->loop = this;
timer->timer_queue = timer_queue_;
timer->fn = std::move(fn);
{
std::lock_guard<std::mutex> lock(pending_timers_mutex_);
pending_timers_.push_back(timer);
}
CreateTimerQueueTimer(&timer->timer_handle, timer_queue_,
WAITORTIMERCALLBACK(TimerQueueCallback), timer,
DWORD(delay_millis), 0,
WT_EXECUTEINTIMERTHREAD | WT_EXECUTEONLYONCE);
}
void Win32Loop::Quit() {
assert_true(thread_id_ != 0);
should_exit_ = true;
while (!PostThreadMessage(thread_id_, WM_NULL, 0, 0)) {
Sleep(1);
}
}
void Win32Loop::AwaitQuit() { quit_fence_.Wait(); }
} // namespace ui
} // namespace xe

74
src/xenia/ui/loop_win.h
View File

@ -1,74 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_LOOP_WIN_H_
#define XENIA_UI_LOOP_WIN_H_
#include <list>
#include <mutex>
#include <thread>
#include "xenia/base/platform_win.h"
#include "xenia/base/threading.h"
#include "xenia/ui/loop.h"
namespace xe {
namespace ui {
class Win32Loop : public Loop {
public:
Win32Loop();
~Win32Loop() override;
bool is_on_loop_thread() override;
void Post(std::function<void()> fn) override;
void PostDelayed(std::function<void()> fn, uint64_t delay_millis) override;
void Quit() override;
void AwaitQuit() override;
private:
struct PendingTimer {
Win32Loop* loop;
HANDLE timer_queue;
HANDLE timer_handle;
std::function<void()> fn;
};
class PostedFn {
public:
explicit PostedFn(std::function<void()> fn) : fn_(std::move(fn)) {}
void Call() { fn_(); }
private:
std::function<void()> fn_;
};
void ThreadMain();
static void TimerQueueCallback(void* context, uint8_t);
std::thread thread_;
DWORD thread_id_;
bool should_exit_ = false;
xe::threading::Fence quit_fence_;
HANDLE timer_queue_;
std::mutex pending_timers_mutex_;
std::list<PendingTimer*> pending_timers_;
std::recursive_mutex posted_functions_mutex_;
std::list<PostedFn> posted_functions_;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_LOOP_WIN_H_

1
src/xenia/ui/premake5.lua
View File

@ -13,3 +13,4 @@ project("xenia-ui")
})
local_platform_files()
removefiles({"*_demo.cc"})
removefiles({"windowed_app_main_*.cc"})

2
src/xenia/ui/vulkan/premake5.lua
View File

@ -45,7 +45,7 @@ project("xenia-ui-window-vulkan-demo")
files({
"../window_demo.cc",
"vulkan_window_demo.cc",
project_root.."/src/xenia/base/main_"..platform_suffix..".cc",
project_root.."/src/xenia/ui/windowed_app_main_"..platform_suffix..".cc",
})
resincludedirs({
project_root,

7
src/xenia/ui/vulkan/vulkan_provider.cc
View File

@ -24,8 +24,8 @@ namespace xe {
namespace ui {
namespace vulkan {
std::unique_ptr<VulkanProvider> VulkanProvider::Create(Window* main_window) {
std::unique_ptr<VulkanProvider> provider(new VulkanProvider(main_window));
std::unique_ptr<VulkanProvider> VulkanProvider::Create() {
std::unique_ptr<VulkanProvider> provider(new VulkanProvider);
if (!provider->Initialize()) {
xe::FatalError(
"Unable to initialize Vulkan graphics subsystem.\n"
@ -40,9 +40,6 @@ std::unique_ptr<VulkanProvider> VulkanProvider::Create(Window* main_window) {
return provider;
}
VulkanProvider::VulkanProvider(Window* main_window)
: GraphicsProvider(main_window) {}
VulkanProvider::~VulkanProvider() {
device_.reset();
instance_.reset();

4
src/xenia/ui/vulkan/vulkan_provider.h
View File

@ -25,7 +25,7 @@ class VulkanProvider : public GraphicsProvider {
public:
~VulkanProvider() override;
static std::unique_ptr<VulkanProvider> Create(Window* main_window);
static std::unique_ptr<VulkanProvider> Create();
VulkanInstance* instance() const { return instance_.get(); }
VulkanDevice* device() const { return device_.get(); }
@ -35,7 +35,7 @@ class VulkanProvider : public GraphicsProvider {
std::unique_ptr<GraphicsContext> CreateOffscreenContext() override;
protected:
explicit VulkanProvider(Window* main_window);
VulkanProvider() = default;
bool Initialize();

34
src/xenia/ui/vulkan/vulkan_window_demo.cc
View File

@ -2,28 +2,44 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <memory>
#include <string>
#include <vector>
#include "xenia/base/main.h"
#include "xenia/ui/vulkan/vulkan_provider.h"
#include "xenia/ui/window.h"
#include "xenia/ui/window_demo.h"
#include "xenia/ui/windowed_app.h"
namespace xe {
namespace ui {
namespace vulkan {
int window_demo_main(const std::vector<std::string>& args);
std::unique_ptr<GraphicsProvider> CreateDemoGraphicsProvider(Window* window) {
return xe::ui::vulkan::VulkanProvider::Create(window);
class VulkanWindowDemoApp final : public WindowDemoApp {
public:
static std::unique_ptr<WindowedApp> Create(WindowedAppContext& app_context) {
return std::unique_ptr<WindowedApp>(new VulkanWindowDemoApp(app_context));
}
protected:
std::unique_ptr<GraphicsProvider> CreateGraphicsProvider() const override;
private:
explicit VulkanWindowDemoApp(WindowedAppContext& app_context)
: WindowDemoApp(app_context, "xenia-ui-window-vulkan-demo") {}
};
std::unique_ptr<GraphicsProvider> VulkanWindowDemoApp::CreateGraphicsProvider()
const {
return VulkanProvider::Create();
}
} // namespace vulkan
} // namespace ui
} // namespace xe
DEFINE_ENTRY_POINT("xenia-ui-window-vulkan-demo", xe::ui::window_demo_main, "");
XE_DEFINE_WINDOWED_APP(xenia_ui_window_vulkan_demo,
xe::ui::vulkan::VulkanWindowDemoApp::Create);

4
src/xenia/ui/window.cc
View File

@ -31,8 +31,8 @@ constexpr double kDoubleClickDistance = 5;
constexpr int32_t kMouseWheelDetent = 120;
Window::Window(Loop* loop, const std::string& title)
: loop_(loop), title_(title) {}
Window::Window(WindowedAppContext& app_context, const std::string& title)
: app_context_(app_context), title_(title) {}
Window::~Window() {
// Context must have been cleaned up already in OnDestroy.

21
src/xenia/ui/window.h
View File

@ -16,10 +16,10 @@
#include "xenia/base/delegate.h"
#include "xenia/base/platform.h"
#include "xenia/ui/graphics_context.h"
#include "xenia/ui/loop.h"
#include "xenia/ui/menu_item.h"
#include "xenia/ui/ui_event.h"
#include "xenia/ui/window_listener.h"
#include "xenia/ui/windowed_app_context.h"
namespace xe {
namespace ui {
@ -31,11 +31,13 @@ class ImGuiDrawer;
class Window {
public:
static std::unique_ptr<Window> Create(Loop* loop, const std::string& title);
static std::unique_ptr<Window> Create(WindowedAppContext& app_context_,
const std::string& title);
virtual ~Window();
Loop* loop() const { return loop_; }
WindowedAppContext& app_context() const { return app_context_; }
virtual NativePlatformHandle native_platform_handle() const = 0;
virtual NativeWindowHandle native_handle() const = 0;
@ -69,8 +71,11 @@ class Window {
virtual bool is_bordered() const { return false; }
virtual void set_bordered(bool enabled) {}
virtual int get_dpi() const { return 96; }
virtual float get_dpi_scale() const { return get_dpi() / 96.f; }
virtual int get_medium_dpi() const { return 96; }
virtual int get_dpi() const { return get_medium_dpi(); }
virtual float get_dpi_scale() const {
return float(get_dpi()) / float(get_medium_dpi());
}
bool has_focus() const { return has_focus_; }
virtual void set_focus(bool value) { has_focus_ = value; }
@ -78,6 +83,8 @@ class Window {
bool is_cursor_visible() const { return is_cursor_visible_; }
virtual void set_cursor_visible(bool value) { is_cursor_visible_ = value; }
// TODO(Triang3l): Don't scale for guest output - use physical pixels. Use
// logical pixels only for the immediate drawer.
int32_t width() const { return width_; }
int32_t height() const { return height_; }
int32_t scaled_width() const { return int32_t(width_ * get_dpi_scale()); }
@ -135,7 +142,7 @@ class Window {
Delegate<MouseEvent*> on_mouse_wheel;
protected:
Window(Loop* loop, const std::string& title);
Window(WindowedAppContext& app_context, const std::string& title);
void ForEachListener(std::function<void(WindowListener*)> fn);
void TryForEachListener(std::function<bool(WindowListener*)> fn);
@ -170,7 +177,7 @@ class Window {
void OnKeyPress(KeyEvent* e, bool is_down, bool is_char);
Loop* loop_ = nullptr;
WindowedAppContext& app_context_;
std::unique_ptr<MenuItem> main_menu_;
std::string title_;
#ifdef XE_PLATFORM_GNU_LINUX

81
src/xenia/ui/window_demo.cc
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -12,7 +12,6 @@
#include "third_party/imgui/imgui.h"
#include "xenia/base/clock.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/profiling.h"
#include "xenia/base/threading.h"
#include "xenia/ui/graphics_provider.h"
@ -20,28 +19,29 @@
#include "xenia/ui/imgui_drawer.h"
#include "xenia/ui/virtual_key.h"
#include "xenia/ui/window.h"
#include "xenia/ui/window_demo.h"
namespace xe {
namespace ui {
// Implemented in one of the window_*_demo.cc files under a subdir.
std::unique_ptr<GraphicsProvider> CreateDemoGraphicsProvider(Window* window);
WindowDemoApp::~WindowDemoApp() { Profiler::Shutdown(); }
int window_demo_main(const std::vector<std::string>& args) {
bool WindowDemoApp::OnInitialize() {
Profiler::Initialize();
Profiler::ThreadEnter("main");
Profiler::ThreadEnter("Main");
// Create run loop and the window.
auto loop = ui::Loop::Create();
auto window = xe::ui::Window::Create(loop.get(), GetEntryInfo().name);
loop->PostSynchronous([&window]() {
xe::threading::set_name("Win32 Loop");
xe::Profiler::ThreadEnter("Win32 Loop");
if (!window->Initialize()) {
FatalError("Failed to initialize main window");
return;
// Create graphics provider that provides the context for the window.
graphics_provider_ = CreateGraphicsProvider();
if (!graphics_provider_) {
return false;
}
// Create the window.
window_ = xe::ui::Window::Create(app_context(), GetName());
if (!window_->Initialize()) {
XELOGE("Failed to initialize main window");
return false;
}
});
// Main menu.
auto main_menu = MenuItem::Create(MenuItem::Type::kNormal);
@ -49,7 +49,7 @@ int window_demo_main(const std::vector<std::string>& args) {
{
file_menu->AddChild(MenuItem::Create(MenuItem::Type::kString, "&Close",
"Alt+F4",
[&window]() { window->Close(); }));
[this]() { window_->Close(); }));
}
main_menu->AddChild(std::move(file_menu));
auto debug_menu = MenuItem::Create(MenuItem::Type::kPopup, "&Debug");
@ -62,37 +62,28 @@ int window_demo_main(const std::vector<std::string>& args) {
[]() { Profiler::TogglePause(); }));
}
main_menu->AddChild(std::move(debug_menu));
window->set_main_menu(std::move(main_menu));
window_->set_main_menu(std::move(main_menu));
// Initial size setting, done here so that it knows the menu exists.
window->Resize(1920, 1200);
window_->Resize(1920, 1200);
// Create the graphics context used for drawing and setup the window.
std::unique_ptr<GraphicsProvider> graphics_provider;
loop->PostSynchronous([&window, &graphics_provider]() {
// Create graphics provider and an initial context for the window.
// The window will finish initialization with the context (loading
// resources, etc).
graphics_provider = CreateDemoGraphicsProvider(window.get());
window->set_context(graphics_provider->CreateContext(window.get()));
// Create the graphics context for the window. The window will finish
// initialization with the context (loading resources, etc).
window_->set_context(graphics_provider_->CreateContext(window_.get()));
// Setup the profiler display.
GraphicsContextLock context_lock(window->context());
Profiler::set_window(window.get());
GraphicsContextLock context_lock(window_->context());
Profiler::set_window(window_.get());
// Enable imgui input.
window->set_imgui_input_enabled(true);
});
window_->set_imgui_input_enabled(true);
window->on_closed.AddListener(
[&loop, &window, &graphics_provider](xe::ui::UIEvent* e) {
loop->Quit();
Profiler::Shutdown();
window_->on_closed.AddListener([this](xe::ui::UIEvent* e) {
XELOGI("User-initiated death!");
app_context().QuitFromUIThread();
});
loop->on_quit.AddListener([&window](xe::ui::UIEvent* e) { window.reset(); });
window->on_key_down.AddListener([](xe::ui::KeyEvent* e) {
window_->on_key_down.AddListener([](xe::ui::KeyEvent* e) {
switch (e->virtual_key()) {
case VirtualKey::kF3:
Profiler::ToggleDisplay();
@ -102,23 +93,19 @@ int window_demo_main(const std::vector<std::string>& args) {
}
});
window->on_painting.AddListener([&](xe::ui::UIEvent* e) {
auto& io = window->imgui_drawer()->GetIO();
window_->on_painting.AddListener([this](xe::ui::UIEvent* e) {
auto& io = window_->imgui_drawer()->GetIO();
ImGui::ShowDemoWindow();
ImGui::ShowMetricsWindow();
Profiler::Flip();
// Continuous paint.
window->Invalidate();
window_->Invalidate();
});
// Wait until we are exited.
loop->AwaitQuit();
window.reset();
loop.reset();
graphics_provider.reset();
return 0;
return true;
}
} // namespace ui

44
src/xenia/ui/window_demo.h Normal file
View File

@ -0,0 +1,44 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOW_DEMO_H_
#define XENIA_UI_WINDOW_DEMO_H_
#include <memory>
#include <string>
#include "xenia/ui/graphics_provider.h"
#include "xenia/ui/window.h"
#include "xenia/ui/windowed_app.h"
namespace xe {
namespace ui {
class WindowDemoApp : public WindowedApp {
public:
~WindowDemoApp();
bool OnInitialize() override;
protected:
explicit WindowDemoApp(WindowedAppContext& app_context,
const std::string_view name)
: WindowedApp(app_context, name) {}
virtual std::unique_ptr<GraphicsProvider> CreateGraphicsProvider() const = 0;
private:
std::unique_ptr<GraphicsProvider> graphics_provider_;
std::unique_ptr<Window> window_;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOW_DEMO_H_

14
src/xenia/ui/window_gtk.cc
View File

@ -22,12 +22,13 @@
namespace xe {
namespace ui {
std::unique_ptr<Window> Window::Create(Loop* loop, const std::string& title) {
return std::make_unique<GTKWindow>(loop, title);
std::unique_ptr<Window> Window::Create(WindowedAppContext& app_context,
const std::string& title) {
return std::make_unique<GTKWindow>(app_context, title);
}
GTKWindow::GTKWindow(Loop* loop, const std::string& title)
: Window(loop, title) {}
GTKWindow::GTKWindow(WindowedAppContext& app_context, const std::string& title)
: Window(app_context, title) {}
GTKWindow::~GTKWindow() {
OnDestroy();
@ -92,7 +93,7 @@ gboolean close_callback(GtkWidget* widget, gpointer data) {
return G_SOURCE_CONTINUE;
}
void GTKWindow::Create() {
bool GTKWindow::OnCreate() {
// GTK optionally allows passing argv and argc here for parsing gtk specific
// options. We won't bother
window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
@ -129,10 +130,7 @@ void GTKWindow::Create() {
gtk_box_pack_end(GTK_BOX(box_), drawing_area_, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window_), box_);
gtk_widget_show_all(window_);
}
bool GTKWindow::OnCreate() {
loop()->PostSynchronous([this]() { this->Create(); });
return super::OnCreate();
}

3
src/xenia/ui/window_gtk.h
View File

@ -28,7 +28,7 @@ class GTKWindow : public Window {
using super = Window;
public:
GTKWindow(Loop* loop, const std::string& title);
GTKWindow(WindowedAppContext& app_context, const std::string& title);
~GTKWindow() override;
NativePlatformHandle native_platform_handle() const override {
@ -74,7 +74,6 @@ class GTKWindow : public Window {
void OnResize(UIEvent* e) override;
private:
void Create();
GtkWidget* window_;
GtkWidget* box_;
GtkWidget* drawing_area_;

59
src/xenia/ui/window_win.cc
View File

@ -18,16 +18,19 @@
#include "xenia/base/logging.h"
#include "xenia/base/platform_win.h"
#include "xenia/ui/virtual_key.h"
#include "xenia/ui/windowed_app_context_win.h"
namespace xe {
namespace ui {
std::unique_ptr<Window> Window::Create(Loop* loop, const std::string& title) {
return std::make_unique<Win32Window>(loop, title);
std::unique_ptr<Window> Window::Create(WindowedAppContext& app_context,
const std::string& title) {
return std::make_unique<Win32Window>(app_context, title);
}
Win32Window::Win32Window(Loop* loop, const std::string& title)
: Window(loop, title) {}
Win32Window::Win32Window(WindowedAppContext& app_context,
const std::string& title)
: Window(app_context, title) {}
Win32Window::~Win32Window() {
OnDestroy();
@ -43,37 +46,32 @@ Win32Window::~Win32Window() {
}
NativePlatformHandle Win32Window::native_platform_handle() const {
return ::GetModuleHandle(nullptr);
return static_cast<const Win32WindowedAppContext&>(app_context()).hinstance();
}
bool Win32Window::Initialize() { return OnCreate(); }
bool Win32Window::OnCreate() {
HINSTANCE hInstance = GetModuleHandle(nullptr);
HINSTANCE hInstance =
static_cast<const Win32WindowedAppContext&>(app_context()).hinstance();
if (!SetProcessDpiAwareness_ || !GetDpiForMonitor_) {
// Per-monitor DPI awareness is expected to be enabled via the manifest, as
// that's the recommended way, which also doesn't require calling
// SetProcessDpiAwareness before doing anything that may depend on DPI
// awareness (so it's safe to use any Windows APIs before this code).
// TODO(Triang3l): Safe handling of per-monitor DPI awareness v2, with
// automatic scaling on DPI change.
if (!GetDpiForMonitor_) {
auto shcore = GetModuleHandleW(L"shcore.dll");
if (shcore) {
SetProcessDpiAwareness_ =
GetProcAddress(shcore, "SetProcessDpiAwareness");
GetDpiForMonitor_ = GetProcAddress(shcore, "GetDpiForMonitor");
}
}
static bool has_registered_class = false;
if (!has_registered_class) {
// Tell Windows that we're DPI aware.
if (SetProcessDpiAwareness_) {
auto spda = (decltype(&SetProcessDpiAwareness))SetProcessDpiAwareness_;
auto res = spda(PROCESS_PER_MONITOR_DPI_AWARE);
if (res != S_OK) {
XELOGW("Failed to set process DPI awareness. (code = 0x{:08X})",
static_cast<uint32_t>(res));
}
}
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
WNDCLASSEXW wcex;
wcex.cbSize = sizeof(wcex);
wcex.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wcex.lpfnWndProc = Win32Window::WndProcThunk;
wcex.cbClsExtra = 0;
@ -85,7 +83,7 @@ bool Win32Window::OnCreate() {
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wcex.lpszMenuName = nullptr;
wcex.lpszClassName = L"XeniaWindowClass";
if (!RegisterClassEx(&wcex)) {
if (!RegisterClassExW(&wcex)) {
XELOGE("RegisterClassEx failed");
return false;
}
@ -216,7 +214,9 @@ bool Win32Window::SetIcon(const void* buffer, size_t size) {
}
// Reset icon to default.
auto default_icon = LoadIconW(GetModuleHandle(nullptr), L"MAINICON");
auto default_icon = LoadIconW(
static_cast<const Win32WindowedAppContext&>(app_context()).hinstance(),
L"MAINICON");
SendMessageW(hwnd_, WM_SETICON, ICON_BIG,
reinterpret_cast<LPARAM>(default_icon));
SendMessageW(hwnd_, WM_SETICON, ICON_SMALL,
@ -316,13 +316,22 @@ void Win32Window::set_bordered(bool enabled) {
}
int Win32Window::get_dpi() const {
// TODO(Triang3l): Cache until WM_DPICHANGED is received (which, with
// per-monitor awareness v2 will also receive the new suggested window size).
// According to MSDN, x and y are identical.
if (!GetDpiForMonitor_) {
return 96;
HDC screen_hdc = GetDC(nullptr);
if (!screen_hdc) {
return get_medium_dpi();
}
int logical_pixels_x = GetDeviceCaps(screen_hdc, LOGPIXELSX);
ReleaseDC(nullptr, screen_hdc);
return logical_pixels_x;
}
HMONITOR monitor = MonitorFromWindow(hwnd_, MONITOR_DEFAULTTOPRIMARY);
// According to msdn, x and y are identical...
UINT dpi_x, dpi_y;
auto gdfm = (decltype(&GetDpiForMonitor))GetDpiForMonitor_;
gdfm(monitor, MDT_DEFAULT, &dpi_x, &dpi_y);

3
src/xenia/ui/window_win.h
View File

@ -24,7 +24,7 @@ class Win32Window : public Window {
using super = Window;
public:
Win32Window(Loop* loop, const std::string& title);
Win32Window(WindowedAppContext& app_context, const std::string& title);
~Win32Window() override;
NativePlatformHandle native_platform_handle() const override;
@ -90,7 +90,6 @@ class Win32Window : public Window {
WINDOWPLACEMENT windowed_pos_ = {0};
POINT last_mouse_pos_ = {0};
void* SetProcessDpiAwareness_ = nullptr;
void* GetDpiForMonitor_ = nullptr;
};

129
src/xenia/ui/windowed_app.h Normal file
View File

@ -0,0 +1,129 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOWED_APP_H_
#define XENIA_UI_WINDOWED_APP_H_
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
#include "xenia/base/platform.h"
#include "xenia/ui/windowed_app_context.h"
#if XE_PLATFORM_ANDROID
#include <android/native_activity.h>
#include "xenia/ui/windowed_app_context_android.h"
#endif
namespace xe {
namespace ui {
// Interface between the platform's entry points (in the main, UI, thread that
// also runs the message loop) and the app that implements it.
class WindowedApp {
public:
// WindowedApps are expected to provide a static creation function, for
// creating an instance of the class (which may be called before
// initialization of platform-specific parts, should preferably be as simple
// as possible).
WindowedApp(const WindowedApp& app) = delete;
WindowedApp& operator=(const WindowedApp& app) = delete;
virtual ~WindowedApp() = default;
WindowedAppContext& app_context() const { return app_context_; }
// Same as the executable (project), xenia-library-app.
const std::string& GetName() const { return name_; }
const std::string& GetPositionalOptionsUsage() const {
return positional_options_usage_;
}
const std::vector<std::string>& GetPositionalOptions() const {
return positional_options_;
}
// Called once before receiving other lifecycle callback invocations. Cvars
// will be initialized with the launch arguments. Returns whether the app has
// been initialized successfully (otherwise platform-specific code must call
// OnDestroy and refuse to continue running the app).
virtual bool OnInitialize() = 0;
// See OnDestroy for more info.
void InvokeOnDestroy() {
// For safety and convenience of referencing objects owned by the app in
// pending functions queued in or after OnInitialize, make sure they are
// executed before telling the app that destruction needs to happen.
app_context().ExecutePendingFunctionsFromUIThread();
OnDestroy();
}
protected:
// Positional options should be initialized in the constructor if needed.
// Cvars will not have been initialized with the arguments at the moment of
// construction (as the result depends on construction).
explicit WindowedApp(
WindowedAppContext& app_context, const std::string_view name,
const std::string_view positional_options_usage = std::string_view())
: app_context_(app_context),
name_(name),
positional_options_usage_(positional_options_usage) {}
// For calling from the constructor.
void AddPositionalOption(const std::string_view option) {
positional_options_.emplace_back(option);
}
// OnDestroy entry point may be called (through InvokeOnDestroy) by the
// platform-specific lifecycle interface at request of either the app itself
// or the OS - thus should be possible for the lifecycle interface to call at
// any moment (not from inside other lifecycle callbacks though). The app will
// also be destroyed when that happens, so the destructor will also be called
// (but this is more safe with respect to exceptions). This is only guaranteed
// to be called if OnInitialize has already happened (successfully or not) -
// in case of an error before initialization, the destructor may be called
// alone as well. Context's pending functions will be executed before the
// call, so it's safe to destroy dependencies of them here (though it may
// still be possible to add more pending functions here depending on whether
// the context was explicitly shut down before this is invoked).
virtual void OnDestroy() {}
private:
WindowedAppContext& app_context_;
std::string name_;
std::string positional_options_usage_;
std::vector<std::string> positional_options_;
};
#if XE_PLATFORM_ANDROID
// Multiple apps in a single library. ANativeActivity_onCreate chosen via
// android.app.func_name of the NativeActivity of each app.
#define XE_DEFINE_WINDOWED_APP(export_name, creator) \
__attribute__((visibility("default"))) extern "C" void export_name( \
ANativeActivity* activity, void* saved_state, size_t saved_state_size) { \
xe::ui::AndroidWindowedAppContext::StartAppOnNativeActivityCreate( \
activity, saved_state, saved_state_size, creator); \
}
#else
// Separate executables for each app.
std::unique_ptr<WindowedApp> (*GetWindowedAppCreator())(
WindowedAppContext& app_context);
#define XE_DEFINE_WINDOWED_APP(export_name, creator) \
std::unique_ptr<xe::ui::WindowedApp> (*xe::ui::GetWindowedAppCreator())( \
xe::ui::WindowedAppContext & app_context) { \
return creator; \
}
#endif
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOWED_APP_H_

180
src/xenia/ui/windowed_app_context.cc Normal file
View File

@ -0,0 +1,180 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/windowed_app_context.h"
#include <utility>
#include "xenia/base/assert.h"
#include "xenia/base/threading.h"
namespace xe {
namespace ui {
WindowedAppContext::~WindowedAppContext() {
// The UI thread is responsible for managing the lifetime of the context.
assert_true(IsInUIThread());
// It's okay to destroy the context from a platform's internal UI loop
// callback, primarily on platforms where the loop is run by the OS itself,
// and the context can't be created and destroyed in a RAII way, rather, it's
// created in an initialization handler and destroyed in a shutdown handler
// called by the OS. However, destruction must not be done from within the
// queued functions - as in this case, the pending function container, the
// mutex, will be accessed after having been destroyed already.
// Make sure CallInUIThreadDeferred doesn't call
// NotifyUILoopOfPendingFunctions, which is virtual.
is_in_destructor_ = true;
// Make sure the final ExecutePendingFunctionsFromUIThread doesn't call
// PlatformQuitFromUIThread, which is virtual.
has_quit_ = true;
// Platform-specific quit is expected to be performed by the subclass (the
// order of it vs. the final ExecutePendingFunctionsFromUIThread shouldn't
// matter anymore, the implementation may assume that no pending functions
// will be requested for execution specifically via the platform-specific
// loop, as there should be no more references to the context in other
// threads), can't call the virtual PlatformQuitFromUIThread anymore.
ExecutePendingFunctionsFromUIThread(true);
}
bool WindowedAppContext::CallInUIThreadDeferred(
std::function<void()> function) {
{
std::unique_lock<std::mutex> pending_functions_lock(
pending_functions_mutex_);
if (!pending_functions_accepted_) {
// Will not be called as the loop will not be executed anymore.
return false;
}
pending_functions_.emplace_back(std::move(function));
}
// Notify unconditionally, even if currently running pending functions. It's
// possible for pending functions themselves to run inner platform message
// loops, such as when displaying dialogs - in this case, the notification is
// needed to run the new function from such an inner loop. A modal loop can be
// started even in leftovers happening during the quit, where there's still
// opportunity for enqueueing and executing new pending functions - so only
// checking if called in the destructor (it's safe to check this without
// locking a mutex as it's assumed that if the object is already being
// destroyed, no other threads can have references to it - any access would
// result in a race condition anyway) as the subclass has already been
// destroyed. Having pending_functions_mutex_ unlocked also means that
// NotifyUILoopOfPendingFunctions may be done while the UI thread is calling
// or has already called PlatformQuitFromUIThread - but it's better than
// keeping pending_functions_mutex_ locked as NotifyUILoopOfPendingFunctions
// may be implemented as pushing to a fixed-size pipe, in which case it will
// have to wait until free space is available, but if the UI thread tries to
// lock the mutex afterwards to execute pending functions (and encouters
// contention), nothing will be able to receive from the pipe anymore and thus
// free the space, causing a deadlock.
if (!is_in_destructor_) {
NotifyUILoopOfPendingFunctions();
}
return true;
}
bool WindowedAppContext::CallInUIThread(std::function<void()> function) {
if (IsInUIThread()) {
// The intention is just to make sure the code is executed in the UI thread,
// don't defer execution if no need to.
function();
return true;
}
return CallInUIThreadDeferred(std::move(function));
}
bool WindowedAppContext::CallInUIThreadSynchronous(
std::function<void()> function) {
if (IsInUIThread()) {
// Prevent deadlock if called from the UI thread.
function();
return true;
}
xe::threading::Fence fence;
if (!CallInUIThreadDeferred([&function, &fence]() {
function();
fence.Signal();
})) {
return false;
}
fence.Wait();
return true;
}
void WindowedAppContext::QuitFromUIThread() {
assert_true(IsInUIThread());
bool has_quit_previously = has_quit_;
// Make sure PlatformQuitFromUIThread is called only once, not from nested
// pending function execution during the quit - otherwise it will be called
// when it's still possible to add new pending functions. This isn't as wrong
// as calling PlatformQuitFromUIThread from the destructor, but still a part
// of the contract for simplicity.
has_quit_ = true;
// Executing pending function unconditionally because it's the contract of
// this method that functions are executed immediately.
ExecutePendingFunctionsFromUIThread(true);
if (has_quit_previously) {
// Potentially calling QuitFromUIThread from inside a pending function (in
// the worst and dangerous case, from a pending function executed in the
// destructor - and PlatformQuitFromUIThread is virtual).
return;
}
// Call the platform-specific shutdown while letting it assume that no new
// functions will be queued anymore (but NotifyUILoopOfPendingFunctions may
// still be called after PlatformQuitFromUIThread as the two are not
// interlocked). This is different than the order in the destruction, but
// there this assumption is ensured by the expectation that there should be no
// more references to the context in other threads that would allow queueing
// new functions with calling NotifyUILoopOfPendingFunctions.
PlatformQuitFromUIThread();
}
void WindowedAppContext::ExecutePendingFunctionsFromUIThread(bool is_final) {
assert_true(IsInUIThread());
std::unique_lock<std::mutex> pending_functions_lock(pending_functions_mutex_);
while (!pending_functions_.empty()) {
// Removing the function from the queue before executing it, as the function
// itself may call ExecutePendingFunctionsFromUIThread - if it's kept, the
// inner loop will try to execute it again, resulting in potentially endless
// recursion, and even if it's terminated, each level will be trying to
// remove the same function from the queue - instead, actually removing
// other functions, or even beyond the end of the queue.
std::function<void()> function = std::move(pending_functions_.front());
pending_functions_.pop_front();
// Call the function with the lock released as it may take an indefinitely
// long time to execute if it opens some dialog (possibly with its own
// platform message loop), and in that case, without unlocking, no other
// thread would be able to add new pending functions (which would result in
// unintended waits for user input). This also allows using std::mutex
// instead of std::recursive_mutex.
pending_functions_lock.unlock();
function();
pending_functions_lock.lock();
}
if (is_final) {
// Atomically with completion of the pending functions loop, disallow adding
// new functions after executing the existing ones - it was possible to
// enqueue new functions from the leftover ones as there still was
// opportunity to call them, so it wasn't necessary to disallow adding
// before executing, but now new functions will potentially never be
// executed. This is done even if this is just an inner pending functions
// execution and there's still potential possibility of adding and executing
// new functions in the outer loops - for simplicity and consistency (so
// QuitFromUIThread's behavior doesn't depend as much on the location of the
// call - inside a pending function or from some system callback of the
// window), assuming after a PlatformQuitFromUIThread call, it's not
// possible to add new pending functions anymore.
pending_functions_accepted_ = false;
}
}
} // namespace ui
} // namespace xe

184
src/xenia/ui/windowed_app_context.h Normal file
View File

@ -0,0 +1,184 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOWED_APP_CONTEXT_H_
#define XENIA_UI_WINDOWED_APP_CONTEXT_H_
#include <cstdint>
#include <deque>
#include <functional>
#include <mutex>
#include <thread>
#include "xenia/base/assert.h"
namespace xe {
namespace ui {
// Context for inputs provided by the entry point and interacting with the
// platform's UI loop, to be implemented by platforms.
class WindowedAppContext {
public:
WindowedAppContext(const WindowedAppContext& context) = delete;
WindowedAppContext& operator=(const WindowedAppContext& context) = delete;
virtual ~WindowedAppContext();
// The thread where the object is created will be assumed to be the UI thread,
// for the purpose of being able to perform CallInUIThreadSynchronous before
// running the loop.
bool IsInUIThread() const {
return std::this_thread::get_id() == ui_thread_id_;
}
// CallInUIThreadDeferred and CallInUIThread are fire and forget - will be
// executed at some point the future when the UI thread is running the loop
// and is not busy doing other things.
// Therefore, references to objects in the function may outlive the owners of
// those objects, so use-after-free is very easy to create if not being
// careful enough.
// There are two solutions to this issue:
// - Signaling a fence in the function, awaiting it before destroying objects
// referenced by the function (works for shutdown from non-UI threads, or
// for CallInUIThread, but not CallInUIThreadDeferred, in the UI thread).
// - Calling ExecutePendingFunctionsFromUIThread in the UI thread before
// destroying objects referenced by the function (works for shutdown from
// the UI thread, though CallInUIThreadSynchronous doing
// ExecutePendingFunctionsFromUIThread is also an option for shutdown from
// any thread).
// (These are not required if all the called function is doing is triggering a
// quit with the context pointer captured by value, as the only object
// involved will be the context itself, with a pointer that is valid until
// it's destroyed - the most late location of the pending function execution
// possible.)
// Returning true if the function has been enqueued (it will be called at some
// point, at worst, before exiting the loop) or called immediately, false if
// it was dropped (if calling after exiting the loop).
// It's okay to enqueue functions from queued functions already being
// executed. As execution may be happening during the destruction of the
// context as well, in this case, CallInUIThreadDeferred must make sure it
// doesn't call anything virtual in the destructor.
// Enqueues the function regardless of the current thread. Won't necessarily
// be executed directly from the platform main loop as
// ExecutePendingFunctionsFromUIThread may be called anywhere (for instance,
// to await pending functions before destroying what they are referencing).
bool CallInUIThreadDeferred(std::function<void()> function);
// Executes the function immediately if already in the UI thread, enqueues it
// otherwise.
bool CallInUIThread(std::function<void()> function);
bool CallInUIThreadSynchronous(std::function<void()> function);
// It's okay to call this function from the queued functions themselves (such
// as in the case of waiting for a pending async CallInUIThreadDeferred
// described above - the wait may be done inside a CallInUIThreadSynchronous
// function safely).
void ExecutePendingFunctionsFromUIThread() {
ExecutePendingFunctionsFromUIThread(false);
}
// If on the target platform, the program itself is supposed to run the UI
// loop, this may be checked before doing blocking message waits as an
// additional safety measure beyond what PlatformQuitFromUIThread guarantees,
// and if true, the loop should be terminated (pending function will already
// have been executed). This doesn't imply that pending functions have been
// executed in all contexts, however - they can be executing from quitting
// itself (in the worst case, in the destructor where virtual methods can't be
// called), and in this case, this will be returning true.
bool HasQuitFromUIThread() const {
assert_true(IsInUIThread());
return has_quit_;
}
// Immediately disallows adding new pending UI functions, executes the already
// queued ones, and makes sure that the UI loop is aware that it was asked to
// stop running. This must not destroy the context or the app directly - the
// actual app shutdown will be initiated at some point outside the scope of
// app's callbacks. May call virtual functions - invoke
// ExecutePendingFunctionsFromUIThread(true) in the destructor instead, and
// use the platform-specific destructor to invoke the needed
// PlatformQuitFromUIThread logic (it should be safe, in case of destruction,
// to perform platform-specific quit request logic before the common part -
// NotifyUILoopOfPendingFunctions won't be called after the platform-specific
// quit request logic in this case anyway as destruction expects that there
// are no references to the object in other threads). Safe to call from within
// pending functions - requesting quit from non-UI threads is possible via
// methods like CallInUIThreadSynchronous. For deferred, rather than
// immediate, quitting from the UI thread, CallInUIThreadDeferred may be used
// (but the context pointer should be captured by value not to require
// explicit completion forcing in case the storage of the pointer is lost
// before the function is called).
void QuitFromUIThread();
// Callable from any thread. This is a special case where a completely
// fire-and-forget CallInUIThreadDeferred is safe, as the function only
// references nonvirtual functions of the context itself, and will be called
// at most from the destructor. No need to return the result - it doesn't
// matter if has quit already or not, as that's the intention anyway.
void RequestDeferredQuit() {
CallInUIThreadDeferred([this] { QuitFromUIThread(); });
}
protected:
WindowedAppContext() : ui_thread_id_(std::this_thread::get_id()) {}
// Can be called from any thread (including the UI thread) to ask the OS to
// run an iteration of the UI loop (with or without processing internal UI
// messages, this is platform-dependent) so pending functions will be executed
// at some point. pending_functions_mutex_ will not be locked when this is
// called (to make sure that, for example, the caller, waiting for space in
// the OS's message queue, such as in case of a Linux pipe, won't be blocking
// the UI thread that has started executing pending messages while pumping
// that pipe, resulting in a deadlock) - implementations don't directly see
// anything protected by it anyway, and a spurious notification shouldn't be
// causing any damage, this is similar to how condition variables can be
// signaled outside the critical section (signaling inside the critical
// section may also cause contention if the thread waiting is woken up quickly
// enough). This, however, means that NotifyUILoopOfPendingFunctions may be
// called in a non-UI thread after the final pending message processing
// followed by PlatformQuitFromUIThread in the UI thread - so it can still be
// called after a quit.
virtual void NotifyUILoopOfPendingFunctions() = 0;
// Called when requesting a quit in the UI thread to tell the platform that
// the UI loop needs to be terminated. The pending function queue is assumed
// to be empty before this is called, and no new pending functions can be
// added (but NotifyUILoopOfPendingFunctions may still be called as it's not
// mutually exclusive with PlatformQuitFromUIThread - if this matters, the
// platform implementation itself should be resolving this case).
virtual void PlatformQuitFromUIThread() = 0;
std::thread::id ui_thread_id_;
private:
// May be called with is_final == true from the destructor - must not call
// anything virtual in this case.
void ExecutePendingFunctionsFromUIThread(bool is_final);
// Accessible by the UI thread.
bool has_quit_ = false;
bool is_in_destructor_ = false;
// Synchronizes producers with each other and with the consumer, as well as
// all of them with the pending_functions_accepted_ variable which indicates
// whether shutdown has not been performed yet, as after the shutdown, no new
// functions will be executed anymore, therefore no new function should be
// queued, as it will never be called (thus CallInUIThreadSynchronous for it
// will never return, for instance).
std::mutex pending_functions_mutex_;
std::deque<std::function<void()>> pending_functions_;
// Protected by pending_functions_mutex_, writable by the UI thread, readable
// by any thread. Must be set to false before exiting the main platform loop,
// but before that, all pending functions must be executed no matter what, as
// they may need to signal fences currently being awaited (like the
// CallInUIThreadSynchronous fence).
bool pending_functions_accepted_ = true;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOWED_APP_CONTEXT_H_

67
src/xenia/ui/windowed_app_context_android.cc Normal file
View File

@ -0,0 +1,67 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/windowed_app_context_android.h"
#include <android/native_activity.h>
#include "xenia/base/assert.h"
#include "xenia/ui/windowed_app.h"
namespace xe {
namespace ui {
void AndroidWindowedAppContext::StartAppOnNativeActivityCreate(
ANativeActivity* activity, [[maybe_unused]] void* saved_state,
[[maybe_unused]] size_t saved_state_size,
std::unique_ptr<WindowedApp> (*app_creator)(
WindowedAppContext& app_context)) {
AndroidWindowedAppContext* app_context =
new AndroidWindowedAppContext(activity);
// The pointer is now held by the Activity as its ANativeActivity::instance,
// until the destruction.
if (!app_context->InitializeApp(app_creator)) {
delete app_context;
ANativeActivity_finish(activity);
}
}
AndroidWindowedAppContext::~AndroidWindowedAppContext() {
// TODO(Triang3l): Unregister activity callbacks.
activity_->instance = nullptr;
}
void AndroidWindowedAppContext::NotifyUILoopOfPendingFunctions() {
// TODO(Triang3l): Request message processing in the UI thread.
}
void AndroidWindowedAppContext::PlatformQuitFromUIThread() {
ANativeActivity_finish(activity);
}
AndroidWindowedAppContext::AndroidWindowedAppContext(ANativeActivity* activity)
: activity_(activity) {
activity_->instance = this;
// TODO(Triang3l): Register activity callbacks.
}
bool AndroidWindowedAppContext::InitializeApp(std::unique_ptr<WindowedApp> (
*app_creator)(WindowedAppContext& app_context)) {
assert_null(app_);
app_ = app_creator(this);
if (!app_->OnInitialize()) {
app_->InvokeOnDestroy();
app_.reset();
return false;
}
return true;
}
} // namespace ui
} // namespace xe

61
src/xenia/ui/windowed_app_context_android.h Normal file
View File

@ -0,0 +1,61 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOWED_APP_CONTEXT_ANDROID_H_
#define XENIA_UI_WINDOWED_APP_CONTEXT_ANDROID_H_
#include <android/native_activity.h>
#include <memory>
#include "xenia/ui/windowed_app_context.h"
namespace xe {
namespace ui {
class WindowedApp;
class AndroidWindowedAppContext final : public WindowedAppContext {
public:
// For calling from android.app.func_name exports.
static void StartAppOnNativeActivityCreate(
ANativeActivity* activity, void* saved_state, size_t saved_state_size,
std::unique_ptr<WindowedApp> (*app_creator)(
WindowedAppContext& app_context));
// Defined in the translation unit where WindowedApp is complete because of
// std::unique_ptr.
~AndroidWindowedAppContext();
ANativeActivity* activity() const { return activity_; }
WindowedApp* app() const { return app_.get(); }
void NotifyUILoopOfPendingFunctions() override;
void PlatformQuitFromUIThread() override;
private:
explicit AndroidWindowedAppContext(ANativeActivity* activity);
bool InitializeApp(std::unique_ptr<WindowedApp> (*app_creator)(
WindowedAppContext& app_context));
// TODO(Triang3l): Switch from ANativeActivity to the context itself being the
// object for communication with the Java code when NativeActivity isn't used
// anymore as its functionality is heavily limited.
ANativeActivity* activity_;
std::unique_ptr<WindowedApp> app_;
// TODO(Triang3l): The rest of the context, including quit handler (and the
// destructor) calling `finish` on the activity, UI looper notification
// posting, etc.
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOWED_APP_CONTEXT_ANDROID_H_

112
src/xenia/ui/windowed_app_context_gtk.cc Normal file
View File

@ -0,0 +1,112 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/windowed_app_context_gtk.h"
#include <gdk/gdk.h>
#include <glib.h>
#include <gtk/gtk.h>
namespace xe {
namespace ui {
GTKWindowedAppContext::~GTKWindowedAppContext() {
// Remove the idle sources as their data pointer (to this context) is now
// outdated.
if (quit_idle_pending_) {
g_source_remove(quit_idle_pending_);
}
{
// Lock the mutex for a pending_functions_idle_pending_ access memory
// barrier, even though no other threads can access this object anymore.
std::lock_guard<std::mutex> pending_functions_idle_pending_lock(
pending_functions_idle_pending_mutex_);
if (pending_functions_idle_pending_) {
g_source_remove(pending_functions_idle_pending_);
}
}
}
void GTKWindowedAppContext::NotifyUILoopOfPendingFunctions() {
std::lock_guard<std::mutex> pending_functions_idle_pending_lock(
pending_functions_idle_pending_mutex_);
if (!pending_functions_idle_pending_) {
pending_functions_idle_pending_ =
gdk_threads_add_idle(PendingFunctionsSourceFunc, this);
}
}
void GTKWindowedAppContext::PlatformQuitFromUIThread() {
if (quit_idle_pending_ || !gtk_main_level()) {
return;
}
gtk_main_quit();
// Quit from all loops in the context, current inner, upcoming inner (this is
// why the idle function is added even at the main level of 1), until we can
// return to the tail of RunMainGTKLoop.
quit_idle_pending_ = gdk_threads_add_idle(QuitSourceFunc, this);
}
void GTKWindowedAppContext::RunMainGTKLoop() {
// For safety, in case the quit request somehow happened before the loop.
if (HasQuitFromUIThread()) {
return;
}
assert_zero(gtk_main_level());
gtk_main();
// Something else - not QuitFromUIThread - might have done gtk_main_quit for
// the outer loop. If it has exited for some reason, let the context know, so
// pending function won't be added pointlessly.
QuitFromUIThread();
// Don't interfere with main loops of other contexts that will possibly be
// executed in this thread later (if this is not the only app that will be
// executed in this process, for example, or if some WindowedAppContext-less
// dialog is opened after the windowed app has quit) - cancel the scheduled
// quit chain as we have quit already.
if (quit_idle_pending_) {
g_source_remove(quit_idle_pending_);
quit_idle_pending_ = 0;
}
}
gboolean GTKWindowedAppContext::PendingFunctionsSourceFunc(gpointer data) {
auto& app_context = *static_cast<GTKWindowedAppContext*>(data);
// Allow new pending function notifications to be made, and stop tracking the
// lifetime of the idle source that is already being executed and thus
// removed. This must be done before executing the functions (if done after,
// notifications may be missed if they happen between the execution of the
// functions and the reset of pending_functions_idle_pending_).
{
std::lock_guard<std::mutex> pending_functions_idle_pending_lock(
app_context.pending_functions_idle_pending_mutex_);
app_context.pending_functions_idle_pending_ = 0;
}
app_context.ExecutePendingFunctionsFromUIThread();
return G_SOURCE_REMOVE;
}
gboolean GTKWindowedAppContext::QuitSourceFunc(gpointer data) {
auto app_context = static_cast<GTKWindowedAppContext*>(data);
guint main_level = gtk_main_level();
assert_not_zero(main_level);
if (!main_level) {
app_context->quit_idle_pending_ = 0;
return G_SOURCE_REMOVE;
}
gtk_main_quit();
// Quit from all loops in the context, current inner, upcoming inner (this is
// why the idle function is added even at the main level of 1), until we can
// return to the tail of RunMainGTKLoop.
app_context->quit_idle_pending_ =
gdk_threads_add_idle(QuitSourceFunc, app_context);
return G_SOURCE_REMOVE;
}
} // namespace ui
} // namespace xe

46
src/xenia/ui/windowed_app_context_gtk.h Normal file
View File

@ -0,0 +1,46 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOWED_APP_CONTEXT_GTK_H_
#define XENIA_UI_WINDOWED_APP_CONTEXT_GTK_H_
#include <glib.h>
#include <mutex>
#include "xenia/ui/windowed_app_context.h"
namespace xe {
namespace ui {
class GTKWindowedAppContext final : public WindowedAppContext {
public:
GTKWindowedAppContext() = default;
~GTKWindowedAppContext();
void NotifyUILoopOfPendingFunctions() override;
void PlatformQuitFromUIThread() override;
void RunMainGTKLoop();
private:
static gboolean PendingFunctionsSourceFunc(gpointer data);
static gboolean QuitSourceFunc(gpointer data);
std::mutex pending_functions_idle_pending_mutex_;
guint pending_functions_idle_pending_ = 0;
guint quit_idle_pending_ = 0;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOWED_APP_CONTEXT_GTK_H_

130
src/xenia/ui/windowed_app_context_win.cc Normal file
View File

@ -0,0 +1,130 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/ui/windowed_app_context_win.h"
#include <cstdlib>
#include "xenia/base/platform_win.h"
namespace xe {
namespace ui {
bool Win32WindowedAppContext::pending_functions_window_class_registered_;
Win32WindowedAppContext::~Win32WindowedAppContext() {
if (pending_functions_hwnd_) {
DestroyWindow(pending_functions_hwnd_);
}
}
bool Win32WindowedAppContext::Initialize() {
// Logging possibly not initialized in this function yet.
// Create the message-only window for executing pending functions - using a
// window instead of executing them between iterations so non-main message
// loops, such as Windows modals, can execute pending functions too.
static const WCHAR kPendingFunctionsWindowClassName[] =
L"XeniaPendingFunctionsWindowClass";
if (!pending_functions_window_class_registered_) {
WNDCLASSEXW pending_functions_window_class = {};
pending_functions_window_class.cbSize =
sizeof(pending_functions_window_class);
pending_functions_window_class.lpfnWndProc = PendingFunctionsWndProc;
pending_functions_window_class.hInstance = hinstance_;
pending_functions_window_class.lpszClassName =
kPendingFunctionsWindowClassName;
if (!RegisterClassExW(&pending_functions_window_class)) {
return false;
}
pending_functions_window_class_registered_ = true;
}
pending_functions_hwnd_ = CreateWindowExW(
0, kPendingFunctionsWindowClassName, L"Xenia Pending Functions",
WS_OVERLAPPED, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
HWND_MESSAGE, nullptr, hinstance_, this);
if (!pending_functions_hwnd_) {
return false;
}
return true;
}
void Win32WindowedAppContext::NotifyUILoopOfPendingFunctions() {
while (!PostMessageW(pending_functions_hwnd_,
kPendingFunctionsWindowClassMessageExecute, 0, 0)) {
Sleep(1);
}
}
void Win32WindowedAppContext::PlatformQuitFromUIThread() {
// Send WM_QUIT to whichever loop happens to process it - may be the loop of a
// built-in modal window, which is unaware of HasQuitFromUIThread, don't let
// it delay quitting indefinitely.
PostQuitMessage(EXIT_SUCCESS);
}
int Win32WindowedAppContext::RunMainMessageLoop() {
int result = EXIT_SUCCESS;
MSG message;
// The HasQuitFromUIThread check is not absolutely required, but for
// additional safety in case WM_QUIT is not received for any reason.
while (!HasQuitFromUIThread()) {
BOOL message_result = GetMessageW(&message, nullptr, 0, 0);
if (message_result == 0 || message_result == -1) {
// WM_QUIT (0 - this is the primary message loop, no need to resend, also
// contains the result from PostQuitMessage in wParam) or an error
// (-1). Quitting the context will run the pending functions. Getting
// WM_QUIT doesn't imply that QuitFromUIThread has been called already, it
// may originate in some place other than PlatformQuitFromUIThread as
// well - call it to finish everything including the pending functions.
QuitFromUIThread();
result = message_result ? EXIT_FAILURE : int(message.wParam);
break;
}
TranslateMessage(&message);
DispatchMessageW(&message);
}
return result;
}
LRESULT CALLBACK Win32WindowedAppContext::PendingFunctionsWndProc(
HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
if (message == WM_CLOSE) {
// Need the window for the entire context's lifetime, don't allow anything
// to close it.
return 0;
}
if (message == WM_NCCREATE) {
SetWindowLongPtrW(
hwnd, GWLP_USERDATA,
reinterpret_cast<LONG_PTR>(
reinterpret_cast<const CREATESTRUCTW*>(lparam)->lpCreateParams));
} else {
auto app_context = reinterpret_cast<Win32WindowedAppContext*>(
GetWindowLongPtrW(hwnd, GWLP_USERDATA));
if (app_context) {
switch (message) {
case WM_DESTROY:
// The message-only window owned by the context is being destroyed,
// thus the context won't be able to execute pending functions
// anymore - can't continue functioning normally.
app_context->QuitFromUIThread();
break;
case kPendingFunctionsWindowClassMessageExecute:
app_context->ExecutePendingFunctionsFromUIThread();
break;
default:
break;
}
}
}
return DefWindowProcW(hwnd, message, wparam, lparam);
}
} // namespace ui
} // namespace xe

58
src/xenia/ui/windowed_app_context_win.h Normal file
View File

@ -0,0 +1,58 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_UI_WINDOWED_APP_CONTEXT_WIN_H_
#define XENIA_UI_WINDOWED_APP_CONTEXT_WIN_H_
#include <memory>
#include "xenia/base/platform_win.h"
#include "xenia/ui/windowed_app_context.h"
namespace xe {
namespace ui {
class Win32WindowedAppContext final : public WindowedAppContext {
public:
// Must call Initialize and check its result after creating to be able to
// perform pending function calls.
explicit Win32WindowedAppContext(HINSTANCE hinstance, int show_cmd)
: hinstance_(hinstance), show_cmd_(show_cmd) {}
~Win32WindowedAppContext();
bool Initialize();
HINSTANCE hinstance() const { return hinstance_; }
int show_cmd() const { return show_cmd_; }
void NotifyUILoopOfPendingFunctions() override;
void PlatformQuitFromUIThread() override;
int RunMainMessageLoop();
private:
enum : UINT {
kPendingFunctionsWindowClassMessageExecute = WM_USER,
};
static LRESULT CALLBACK PendingFunctionsWndProc(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam);
HINSTANCE hinstance_;
int show_cmd_;
HWND pending_functions_hwnd_ = nullptr;
static bool pending_functions_window_class_registered_;
};
} // namespace ui
} // namespace xe
#endif // XENIA_UI_WINDOWED_APP_CONTEXT_WIN_H_

64
src/xenia/ui/windowed_app_main_posix.cc Normal file
View File

@ -0,0 +1,64 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <gtk/gtk.h>
#include <cstdio>
#include <cstdlib>
#include <memory>
#include "xenia/base/cvar.h"
#include "xenia/base/logging.h"
#include "xenia/ui/windowed_app.h"
#include "xenia/ui/windowed_app_context_gtk.h"
extern "C" int main(int argc_pre_gtk, char** argv_pre_gtk) {
// Initialize GTK+, which will handle and remove its own arguments from argv.
// Both GTK+ and Xenia use --option=value argument format (see man
// gtk-options), however, it's meaningless to try to parse the same argument
// both as a GTK+ one and as a cvar. Make GTK+ options take precedence in case
// of a name collision, as there's an alternative way of setting Xenia options
// (the config).
int argc_post_gtk = argc_pre_gtk;
char** argv_post_gtk = argv_pre_gtk;
if (!gtk_init_check(&argc_post_gtk, &argv_post_gtk)) {
// Logging has not been initialized yet.
std::fputs("Failed to initialize GTK+\n", stderr);
return EXIT_FAILURE;
}
int result;
{
xe::ui::GTKWindowedAppContext app_context;
std::unique_ptr<xe::ui::WindowedApp> app =
xe::ui::GetWindowedAppCreator()(app_context);
cvar::ParseLaunchArguments(argc_post_gtk, argv_post_gtk,
app->GetPositionalOptionsUsage(),
app->GetPositionalOptions());
// Initialize logging. Needs parsed cvars.
xe::InitializeLogging(app->GetName());
if (app->OnInitialize()) {
app_context.RunMainGTKLoop();
result = EXIT_SUCCESS;
} else {
result = EXIT_FAILURE;
}
app->InvokeOnDestroy();
}
// Logging may still be needed in the destructors.
xe::ShutdownLogging();
return result;
}

70
src/xenia/ui/windowed_app_main_win.cc Normal file
View File

@ -0,0 +1,70 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include <cstdlib>
#include <memory>
#include "xenia/base/console.h"
#include "xenia/base/cvar.h"
#include "xenia/base/main_win.h"
#include "xenia/base/platform_win.h"
#include "xenia/ui/windowed_app.h"
#include "xenia/ui/windowed_app_context_win.h"
DEFINE_bool(enable_console, false, "Open a console window with the main window",
"General");
int WINAPI wWinMain(HINSTANCE hinstance, HINSTANCE hinstance_prev,
LPWSTR command_line, int show_cmd) {
int result;
{
xe::ui::Win32WindowedAppContext app_context(hinstance, show_cmd);
// TODO(Triang3l): Initialize creates a window. Set DPI awareness via the
// manifest.
if (!app_context.Initialize()) {
return EXIT_FAILURE;
}
std::unique_ptr<xe::ui::WindowedApp> app =
xe::ui::GetWindowedAppCreator()(app_context);
if (!xe::ParseWin32LaunchArguments(false, app->GetPositionalOptionsUsage(),
app->GetPositionalOptions(), nullptr)) {
return EXIT_FAILURE;
}
// TODO(Triang3l): Rework this, need to initialize the console properly,
// disable has_console_attached_ by default in windowed apps, and attach
// only if needed.
if (cvars::enable_console) {
xe::AttachConsole();
}
// Initialize COM on the UI thread with the apartment-threaded concurrency
// model, so dialogs can be used.
if (FAILED(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED))) {
return EXIT_FAILURE;
}
xe::InitializeWin32App(app->GetName());
result =
app->OnInitialize() ? app_context.RunMainMessageLoop() : EXIT_FAILURE;
app->InvokeOnDestroy();
}
// Logging may still be needed in the destructors.
xe::ShutdownWin32App();
CoUninitialize();
return result;
}

2
src/xenia/vfs/premake5.lua
View File

@ -27,7 +27,7 @@ project("xenia-vfs-dump")
files({
"vfs_dump.cc",
project_root.."/src/xenia/base/main_"..platform_suffix..".cc",
project_root.."/src/xenia/base/console_app_main_"..platform_suffix..".cc",
})
resincludedirs({
project_root,

7
src/xenia/vfs/vfs_dump.cc
View File

@ -2,7 +2,7 @@
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2020 Ben Vanik. All rights reserved. *
* Copyright 2021 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
@ -11,8 +11,9 @@
#include <string>
#include <vector>
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/logging.h"
#include "xenia/base/main.h"
#include "xenia/base/math.h"
#include "xenia/vfs/devices/stfs_container_device.h"
@ -113,5 +114,5 @@ int vfs_dump_main(const std::vector<std::string>& args) {
} // namespace vfs
} // namespace xe
DEFINE_ENTRY_POINT("xenia-vfs-dump", xe::vfs::vfs_dump_main,
XE_DEFINE_CONSOLE_APP("xenia-vfs-dump", xe::vfs::vfs_dump_main,
"[source] [dump_path]", "source", "dump_path");

2
tools/build/scripts/test_suite.lua
View File

@ -31,7 +31,7 @@ local function combined_test_suite(test_suite_name, project_root, base_path, con
})
files({
project_root.."/"..build_tools_src.."/test_suite_main.cc",
project_root.."/src/xenia/base/main_"..platform_suffix..".cc",
project_root.."/src/xenia/base/console_app_main_"..platform_suffix..".cc",
base_path.."/**_test.cc",
})
filter("toolset:msc")

4
tools/build/src/test_suite_main.cc
View File

@ -13,8 +13,8 @@
#include <string>
#include <vector>
#include "xenia/base/console_app_main.h"
#include "xenia/base/cvar.h"
#include "xenia/base/main.h"
#define CATCH_CONFIG_RUNNER
#include "third_party/catch/single_include/catch2/catch.hpp"
@ -43,5 +43,5 @@ int test_suite_main(const std::vector<std::string>& args) {
#error XE_TEST_SUITE_NAME is undefined!
#endif
DEFINE_ENTRY_POINT_TRANSPARENT(XE_TEST_SUITE_NAME,
XE_DEFINE_CONSOLE_APP_TRANSPARENT(XE_TEST_SUITE_NAME,
xe::test_suite::test_suite_main);