diff --git a/CMakeLists.txt b/CMakeLists.txt index 54615d7..b151c69 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -74,16 +74,16 @@ add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/RecompiledPatches/patches.c add_executable(MMRecomp) set (SOURCES - ${CMAKE_SOURCE_DIR}/portultra/audio.cpp - ${CMAKE_SOURCE_DIR}/portultra/events.cpp - ${CMAKE_SOURCE_DIR}/portultra/mesgqueue.cpp - ${CMAKE_SOURCE_DIR}/portultra/misc_ultra.cpp - ${CMAKE_SOURCE_DIR}/portultra/port_main.c - ${CMAKE_SOURCE_DIR}/portultra/scheduler.cpp - ${CMAKE_SOURCE_DIR}/portultra/task_win32.cpp - ${CMAKE_SOURCE_DIR}/portultra/threads.cpp - ${CMAKE_SOURCE_DIR}/portultra/timer.cpp - ${CMAKE_SOURCE_DIR}/portultra/ultrainit.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/audio.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/events.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/mesgqueue.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/misc_ultra.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/port_main.c + ${CMAKE_SOURCE_DIR}/ultramodern/scheduler.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/task_win32.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/threads.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/timer.cpp + ${CMAKE_SOURCE_DIR}/ultramodern/ultrainit.cpp ${CMAKE_SOURCE_DIR}/src/ai.cpp ${CMAKE_SOURCE_DIR}/src/cont.cpp @@ -95,8 +95,8 @@ set (SOURCES ${CMAKE_SOURCE_DIR}/src/overlays.cpp ${CMAKE_SOURCE_DIR}/src/pak.cpp ${CMAKE_SOURCE_DIR}/src/pi.cpp - ${CMAKE_SOURCE_DIR}/src/portultra_stubs.cpp - ${CMAKE_SOURCE_DIR}/src/portultra_translation.cpp + ${CMAKE_SOURCE_DIR}/src/ultra_stubs.cpp + ${CMAKE_SOURCE_DIR}/src/ultra_translation.cpp ${CMAKE_SOURCE_DIR}/src/print.cpp ${CMAKE_SOURCE_DIR}/src/recomp.cpp ${CMAKE_SOURCE_DIR}/src/rt64_layer.cpp diff --git a/include/rt64_layer.h b/include/rt64_layer.h index b74ad3f..e63940e 100644 --- a/include/rt64_layer.h +++ b/include/rt64_layer.h @@ -1,7 +1,7 @@ #ifndef __RT64_LAYER_H__ #define __RT64_LAYER_H__ -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" typedef struct { // void* hWnd; diff --git a/portultra/ultrainit.cpp b/portultra/ultrainit.cpp deleted file mode 100644 index f8f4c93..0000000 --- a/portultra/ultrainit.cpp +++ /dev/null @@ -1,14 +0,0 @@ -#include "ultra64.h" -#include "multilibultra.hpp" - -void Multilibultra::preinit(uint8_t* rdram, uint8_t* rom, Multilibultra::WindowHandle window_handle) { - Multilibultra::set_main_thread(); - Multilibultra::init_events(rdram, rom, window_handle); - Multilibultra::init_timers(rdram); - Multilibultra::init_audio(); - Multilibultra::save_init(); -} - -extern "C" void osInitialize() { - Multilibultra::init_scheduler(); -} diff --git a/src/ai.cpp b/src/ai.cpp index 835bb01..44dbea2 100644 --- a/src/ai.cpp +++ b/src/ai.cpp @@ -1,8 +1,8 @@ #include "recomp.h" #include #include -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" #define VI_NTSC_CLOCK 48681812 @@ -12,16 +12,16 @@ extern "C" void osAiSetFrequency_recomp(uint8_t* rdram, recomp_context* ctx) { //uint32_t dacRate = (uint32_t)(((float)VI_NTSC_CLOCK / freq) + 0.5f); //freq = VI_NTSC_CLOCK / dacRate; ctx->r2 = freq; - Multilibultra::set_audio_frequency(freq); + ultramodern::set_audio_frequency(freq); } extern "C" void osAiSetNextBuffer_recomp(uint8_t* rdram, recomp_context* ctx) { - Multilibultra::queue_audio_buffer(rdram, ctx->r4, ctx->r5); + ultramodern::queue_audio_buffer(rdram, ctx->r4, ctx->r5); ctx->r2 = 0; } extern "C" void osAiGetLength_recomp(uint8_t* rdram, recomp_context* ctx) { - ctx->r2 = Multilibultra::get_remaining_audio_bytes(); + ctx->r2 = ultramodern::get_remaining_audio_bytes(); } extern "C" void osAiGetStatus_recomp(uint8_t* rdram, recomp_context* ctx) { diff --git a/src/cont.cpp b/src/cont.cpp index b6b2663..6dbe26d 100644 --- a/src/cont.cpp +++ b/src/cont.cpp @@ -1,9 +1,9 @@ -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #include "recomp_helpers.h" -static Multilibultra::input_callbacks_t input_callbacks; +static ultramodern::input_callbacks_t input_callbacks; -void set_input_callbacks(const Multilibultra::input_callbacks_t& callbacks) { +void set_input_callbacks(const ultramodern::input_callbacks_t& callbacks) { input_callbacks = callbacks; } @@ -33,7 +33,7 @@ extern "C" void osContInit_recomp(uint8_t* rdram, recomp_context* ctx) { } extern "C" void osContStartReadData_recomp(uint8_t* rdram, recomp_context* ctx) { - Multilibultra::send_si_message(); + ultramodern::send_si_message(); } extern "C" void osContGetReadData_recomp(uint8_t* rdram, recomp_context* ctx) { @@ -63,7 +63,7 @@ extern "C" void osContGetReadData_recomp(uint8_t* rdram, recomp_context* ctx) { } extern "C" void osContStartQuery_recomp(uint8_t * rdram, recomp_context * ctx) { - Multilibultra::send_si_message(); + ultramodern::send_si_message(); } extern "C" void osContGetQuery_recomp(uint8_t * rdram, recomp_context * ctx) { diff --git a/src/eep.cpp b/src/eep.cpp index 211a93a..16ad42e 100644 --- a/src/eep.cpp +++ b/src/eep.cpp @@ -1,5 +1,5 @@ #include "recomp.h" -#include "../portultra/ultra64.h" +#include "../ultramodern/ultra64.h" void save_write(uint8_t* rdram, gpr rdram_address, uint32_t offset, uint32_t count); void save_read(uint8_t* rdram, gpr rdram_address, uint32_t offset, uint32_t count); diff --git a/src/flash.cpp b/src/flash.cpp index 3dcccea..ae41111 100644 --- a/src/flash.cpp +++ b/src/flash.cpp @@ -1,9 +1,11 @@ #include #include -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" +// TODO move this out into ultramodern code + constexpr uint32_t flash_size = 1024 * 1024 / 8; // 1Mbit constexpr uint32_t page_size = 128; constexpr uint32_t pages_per_sector = 128; @@ -19,7 +21,7 @@ void save_clear(uint32_t start, uint32_t size, char value); std::array write_buffer; extern "C" void osFlashInit_recomp(uint8_t * rdram, recomp_context * ctx) { - ctx->r2 = Multilibultra::flash_handle; + ctx->r2 = ultramodern::flash_handle; } extern "C" void osFlashReadStatus_recomp(uint8_t * rdram, recomp_context * ctx) { @@ -42,13 +44,13 @@ extern "C" void osFlashClearStatus_recomp(uint8_t * rdram, recomp_context * ctx) } extern "C" void osFlashAllErase_recomp(uint8_t * rdram, recomp_context * ctx) { - save_clear(0, Multilibultra::save_size, 0xFF); + save_clear(0, ultramodern::save_size, 0xFF); ctx->r2 = 0; } extern "C" void osFlashAllEraseThrough_recomp(uint8_t * rdram, recomp_context * ctx) { - save_clear(0, Multilibultra::save_size, 0xFF); + save_clear(0, ultramodern::save_size, 0xFF); ctx->r2 = 0; } diff --git a/src/main/main.cpp b/src/main/main.cpp index 0d3fac7..3e68637 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -4,8 +4,8 @@ #include #include -#include "../../portultra/ultra64.h" -#include "../../portultra/multilibultra.hpp" +#include "../../ultramodern/ultra64.h" +#include "../../ultramodern/ultramodern.hpp" #define SDL_MAIN_HANDLED #ifdef _WIN32 #include "SDL.h" @@ -23,7 +23,7 @@ #endif extern "C" void init(); -/*extern "C"*/ void start(Multilibultra::WindowHandle window_handle, const Multilibultra::audio_callbacks_t* audio_callbacks, const Multilibultra::input_callbacks_t* input_callbacks); +/*extern "C"*/ void start(ultramodern::WindowHandle window_handle, const ultramodern::audio_callbacks_t* audio_callbacks, const ultramodern::input_callbacks_t* input_callbacks); template void exit_error(const char* str, Ts ...args) { @@ -138,7 +138,7 @@ bool sdl_event_filter(void* userdata, SDL_Event* event) { } break; case SDL_EventType::SDL_QUIT: - Multilibultra::quit(); + ultramodern::quit(); return true; default: queue_event(*event); @@ -147,7 +147,7 @@ bool sdl_event_filter(void* userdata, SDL_Event* event) { return false; } -Multilibultra::gfx_callbacks_t::gfx_data_t create_gfx() { +ultramodern::gfx_callbacks_t::gfx_data_t create_gfx() { SDL_SetHint(SDL_HINT_WINDOWS_DPI_AWARENESS, "system"); if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) > 0) { exit_error("Failed to initialize SDL2: %s\n", SDL_GetError()); @@ -158,7 +158,7 @@ Multilibultra::gfx_callbacks_t::gfx_data_t create_gfx() { SDL_Window* window; -Multilibultra::WindowHandle create_window(Multilibultra::gfx_callbacks_t::gfx_data_t) { +ultramodern::WindowHandle create_window(ultramodern::gfx_callbacks_t::gfx_data_t) { window = SDL_CreateWindow("Recomp", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, SDL_WINDOW_RESIZABLE ); if (window == nullptr) { @@ -170,11 +170,11 @@ Multilibultra::WindowHandle create_window(Multilibultra::gfx_callbacks_t::gfx_da SDL_GetWindowWMInfo(window, &wmInfo); #if defined(_WIN32) - return Multilibultra::WindowHandle{ wmInfo.info.win.window, GetCurrentThreadId() }; + return ultramodern::WindowHandle{ wmInfo.info.win.window, GetCurrentThreadId() }; #elif defined(__ANDROID__) static_assert(false && "Unimplemented"); #elif defined(__linux__) - return Multilibultra::WindowHandle{ wmInfo.info.x11.display, wmInfo.info.x11.window }; + return ultramodern::WindowHandle{ wmInfo.info.x11.display, wmInfo.info.x11.window }; #else static_assert(false && "Unimplemented"); #endif @@ -344,23 +344,23 @@ int main(int argc, char** argv) { init(); - Multilibultra::gfx_callbacks_t gfx_callbacks{ + ultramodern::gfx_callbacks_t gfx_callbacks{ .create_gfx = create_gfx, .create_window = create_window, .update_gfx = update_gfx, }; - Multilibultra::audio_callbacks_t audio_callbacks{ + ultramodern::audio_callbacks_t audio_callbacks{ .queue_samples = queue_samples, .get_frames_remaining = get_frames_remaining, .set_frequency = set_frequency, }; - Multilibultra::input_callbacks_t input_callbacks{ + ultramodern::input_callbacks_t input_callbacks{ .get_input = get_input, }; - Multilibultra::start({}, audio_callbacks, input_callbacks, gfx_callbacks); + ultramodern::start({}, audio_callbacks, input_callbacks, gfx_callbacks); return EXIT_SUCCESS; } diff --git a/src/math_routines.cpp b/src/math_routines.cpp index e0f82aa..f5117c5 100644 --- a/src/math_routines.cpp +++ b/src/math_routines.cpp @@ -1,4 +1,4 @@ -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" diff --git a/src/pak.cpp b/src/pak.cpp index 777ece6..70142d0 100644 --- a/src/pak.cpp +++ b/src/pak.cpp @@ -1,6 +1,6 @@ #include "recomp.h" -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" extern "C" void osPfsInitPak_recomp(uint8_t * rdram, recomp_context* ctx) { ctx->r2 = 1; // PFS_ERR_NOPACK diff --git a/src/pi.cpp b/src/pi.cpp index 39bfdad..e24a8dc 100644 --- a/src/pi.cpp +++ b/src/pi.cpp @@ -3,8 +3,8 @@ #include #include #include "recomp.h" -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" // Flashram occupies the same physical address as sram, but that issue is avoided because libultra exposes // a high-level interface for flashram. Because that high-level interface is reimplemented, low level accesses @@ -24,12 +24,12 @@ extern std::unique_ptr rom; extern size_t rom_size; extern "C" void osCartRomInit_recomp(uint8_t* rdram, recomp_context* ctx) { - OSPiHandle* handle = TO_PTR(OSPiHandle, Multilibultra::cart_handle); + OSPiHandle* handle = TO_PTR(OSPiHandle, ultramodern::cart_handle); handle->type = 0; // cart handle->baseAddress = phys_to_k1(rom_base); handle->domain = 0; - ctx->r2 = (gpr)Multilibultra::cart_handle; + ctx->r2 = (gpr)ultramodern::cart_handle; } extern "C" void osCreatePiManager_recomp(uint8_t* rdram, recomp_context* ctx) { @@ -89,7 +89,7 @@ void save_clear(uint32_t start, uint32_t size, char value) { } } -void Multilibultra::save_init() { +void ultramodern::save_init() { std::ifstream save_file{ save_filename, std::ios_base::binary }; if (save_file.good()) { diff --git a/src/print.cpp b/src/print.cpp index a904fa2..7c7bd23 100644 --- a/src/print.cpp +++ b/src/print.cpp @@ -1,5 +1,5 @@ -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" #include "euc-jp.h" diff --git a/src/recomp.cpp b/src/recomp.cpp index 17f2f6e..ac26006 100644 --- a/src/recomp.cpp +++ b/src/recomp.cpp @@ -10,7 +10,7 @@ #include #include #include "recomp.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #ifdef _WIN32 #define EXPORT __declspec(dllexport) @@ -210,28 +210,28 @@ EXPORT extern "C" void init() { std::atomic_int game_started = -1; -void Multilibultra::start_game(int game) { +void ultramodern::start_game(int game) { game_started.store(game); game_started.notify_all(); } -bool Multilibultra::is_game_started() { +bool ultramodern::is_game_started() { return game_started.load() != -1; } -void set_audio_callbacks(const Multilibultra::audio_callbacks_t& callbacks); -void set_input_callbacks(const Multilibultra::input_callbacks_t& callback); +void set_audio_callbacks(const ultramodern::audio_callbacks_t& callbacks); +void set_input_callbacks(const ultramodern::input_callbacks_t& callback); std::atomic_bool exited = false; -void Multilibultra::quit() { +void ultramodern::quit() { exited.store(true); int desired = -1; game_started.compare_exchange_strong(desired, -2); game_started.notify_all(); } -void Multilibultra::start(WindowHandle window_handle, const audio_callbacks_t& audio_callbacks, const input_callbacks_t& input_callbacks, const gfx_callbacks_t& gfx_callbacks_) { +void ultramodern::start(WindowHandle window_handle, const audio_callbacks_t& audio_callbacks, const input_callbacks_t& input_callbacks, const gfx_callbacks_t& gfx_callbacks_) { set_audio_callbacks(audio_callbacks); set_input_callbacks(input_callbacks); @@ -252,12 +252,12 @@ void Multilibultra::start(WindowHandle window_handle, const audio_callbacks_t& a } } - std::thread game_thread{[](Multilibultra::WindowHandle window_handle) { + std::thread game_thread{[](ultramodern::WindowHandle window_handle) { debug_printf("[Recomp] Starting\n"); - Multilibultra::set_native_thread_name("Game Start Thread"); + ultramodern::set_native_thread_name("Game Start Thread"); - Multilibultra::preinit(rdram_buffer.get(), rom.get(), window_handle); + ultramodern::preinit(rdram_buffer.get(), rom.get(), window_handle); game_started.wait(-1); @@ -280,5 +280,5 @@ void Multilibultra::start(WindowHandle window_handle, const audio_callbacks_t& a } } game_thread.join(); - Multilibultra::join_event_threads(); + ultramodern::join_event_threads(); } diff --git a/src/rt64_layer.cpp b/src/rt64_layer.cpp index ab75aab..e5a5583 100644 --- a/src/rt64_layer.cpp +++ b/src/rt64_layer.cpp @@ -2,7 +2,7 @@ #include // #include -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #include "rt64_layer.h" #include "rt64_render_hooks.h" @@ -45,7 +45,7 @@ void dummy_check_interrupts() { } -void RT64Init(uint8_t* rom, uint8_t* rdram, Multilibultra::WindowHandle window_handle) { +void RT64Init(uint8_t* rom, uint8_t* rdram, ultramodern::WindowHandle window_handle) { set_rt64_hooks(); // Dynamic loading //auto RT64 = LoadLibrary("RT64.dll"); diff --git a/src/sp.cpp b/src/sp.cpp index b90daad..b3ee63f 100644 --- a/src/sp.cpp +++ b/src/sp.cpp @@ -1,6 +1,6 @@ #include #include -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" extern "C" void osSpTaskLoad_recomp(uint8_t* rdram, recomp_context* ctx) { @@ -33,7 +33,7 @@ extern "C" void osSpTaskStartGo_recomp(uint8_t* rdram, recomp_context* ctx) { dump_file.write(ram_unswapped.get(), ram_size); dump_frame = false; } - Multilibultra::submit_rsp_task(rdram, ctx->r4); + ultramodern::submit_rsp_task(rdram, ctx->r4); } extern "C" void osSpTaskYield_recomp(uint8_t* rdram, recomp_context* ctx) { diff --git a/src/ui/ui_events.cpp b/src/ui/ui_events.cpp index 355b4d3..51a4b0c 100644 --- a/src/ui/ui_events.cpp +++ b/src/ui/ui_events.cpp @@ -1,5 +1,7 @@ +#define _CRT_SECURE_NO_WARNINGS + #include "recomp_ui.h" -#include "../../portultra/multilibultra.hpp" +#include "../../ultramodern/ultramodern.hpp" #include "nfd.h" #include "RmlUi/Core.h" @@ -39,7 +41,7 @@ std::unique_ptr make_event_listener_instancer() { ret->register_event("start_game", [](Rml::Event& event) { - Multilibultra::start_game(0); + ultramodern::start_game(0); set_current_menu(Menu::None); } ); diff --git a/src/portultra_stubs.cpp b/src/ultra_stubs.cpp similarity index 94% rename from src/portultra_stubs.cpp rename to src/ultra_stubs.cpp index b499ad3..f2ac704 100644 --- a/src/portultra_stubs.cpp +++ b/src/ultra_stubs.cpp @@ -1,5 +1,5 @@ -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" // None of these functions need to be reimplemented, so stub them out diff --git a/src/portultra_translation.cpp b/src/ultra_translation.cpp similarity index 96% rename from src/portultra_translation.cpp rename to src/ultra_translation.cpp index bed5aa7..771758f 100644 --- a/src/portultra_translation.cpp +++ b/src/ultra_translation.cpp @@ -1,6 +1,6 @@ #include -#include "../portultra/ultra64.h" -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultra64.h" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" extern "C" void osInitialize_recomp(uint8_t * rdram, recomp_context * ctx) { @@ -133,7 +133,7 @@ extern "C" void __osSetFpcCsr_recomp(uint8_t * rdram, recomp_context * ctx) { // if (buf->magic == SETJMP_MAGIC) { // // If so, longjmp to it // // Setjmp/longjmp does not work across threads, so verify that this buffer was made by this thread -// assert(buf->owner == Multilibultra::this_thread()); +// assert(buf->owner == ultramodern::this_thread()); // longjmp(buf->storage->buffer, ctx->r5); // } else { // // Otherwise, check if it was one built manually by the game with $ra pointing to a function @@ -159,5 +159,5 @@ extern "C" void __osSetFpcCsr_recomp(uint8_t * rdram, recomp_context * ctx) { //} // //extern "C" int32_t osGetThreadEx(void) { -// return Multilibultra::this_thread(); +// return ultramodern::this_thread(); //} diff --git a/src/vi.cpp b/src/vi.cpp index a38cabe..309e984 100644 --- a/src/vi.cpp +++ b/src/vi.cpp @@ -1,4 +1,4 @@ -#include "../portultra/multilibultra.hpp" +#include "../ultramodern/ultramodern.hpp" #include "recomp.h" extern "C" void osViSetYScale_recomp(uint8_t* rdram, recomp_context * ctx) { diff --git a/portultra/audio.cpp b/ultramodern/audio.cpp similarity index 86% rename from portultra/audio.cpp rename to ultramodern/audio.cpp index ba2949a..8fa2061 100644 --- a/portultra/audio.cpp +++ b/ultramodern/audio.cpp @@ -1,28 +1,28 @@ #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" #include static uint32_t sample_rate = 48000; -static Multilibultra::audio_callbacks_t audio_callbacks; +static ultramodern::audio_callbacks_t audio_callbacks; -void set_audio_callbacks(const Multilibultra::audio_callbacks_t& callbacks) { +void set_audio_callbacks(const ultramodern::audio_callbacks_t& callbacks) { audio_callbacks = callbacks; } -void Multilibultra::init_audio() { +void ultramodern::init_audio() { // Pick an initial dummy sample rate; this will be set by the game later to the true sample rate. set_audio_frequency(48000); } -void Multilibultra::set_audio_frequency(uint32_t freq) { +void ultramodern::set_audio_frequency(uint32_t freq) { if (audio_callbacks.set_frequency) { audio_callbacks.set_frequency(freq); } sample_rate = freq; } -void Multilibultra::queue_audio_buffer(RDRAM_ARG PTR(int16_t) audio_data_, uint32_t byte_count) { +void ultramodern::queue_audio_buffer(RDRAM_ARG PTR(int16_t) audio_data_, uint32_t byte_count) { // Buffer for holding the output of swapping the audio channels. This is reused across // calls to reduce runtime allocations. static std::vector swap_buffer; @@ -59,7 +59,7 @@ float buffer_offset_frames = 0.5f; // If there's ever any audio popping, check here first. Some games are very sensitive to // the remaining sample count and reporting a number that's too high here can lead to issues. // Reporting a number that's too low can lead to audio lag in some games. -uint32_t Multilibultra::get_remaining_audio_bytes() { +uint32_t ultramodern::get_remaining_audio_bytes() { // Get the number of remaining buffered audio bytes. uint32_t buffered_byte_count; if (audio_callbacks.get_frames_remaining != nullptr) { diff --git a/portultra/events.cpp b/ultramodern/events.cpp similarity index 93% rename from portultra/events.cpp rename to ultramodern/events.cpp index dc1f7e0..4669912 100644 --- a/portultra/events.cpp +++ b/ultramodern/events.cpp @@ -12,7 +12,7 @@ #include "blockingconcurrentqueue.h" #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" #include "recomp.h" #include "recomp_ui.h" #include "rsp.h" @@ -99,17 +99,17 @@ extern std::atomic_bool exited; void set_dummy_vi(); void vi_thread_func() { - Multilibultra::set_native_thread_name("VI Thread"); + ultramodern::set_native_thread_name("VI Thread"); // This thread should be prioritized over every other thread in the application, as it's what allows // the game to generate new audio and gfx lists. - Multilibultra::set_native_thread_priority(Multilibultra::ThreadPriority::Critical); + ultramodern::set_native_thread_priority(ultramodern::ThreadPriority::Critical); using namespace std::chrono_literals; int remaining_retraces = events_context.vi.retrace_count; while (!exited) { // Determine the next VI time (more accurate than adding 16ms each VI interrupt) - auto next = Multilibultra::get_start() + (total_vis * 1000000us) / (60 * Multilibultra::get_speed_multiplier()); + auto next = ultramodern::get_start() + (total_vis * 1000000us) / (60 * ultramodern::get_speed_multiplier()); //if (next > std::chrono::system_clock::now()) { // printf("Sleeping for %" PRIu64 " us to get from %" PRIu64 " us to %" PRIu64 " us \n", // (next - std::chrono::system_clock::now()) / 1us, @@ -120,7 +120,7 @@ void vi_thread_func() { //} std::this_thread::sleep_until(next); // Calculate how many VIs have passed - uint64_t new_total_vis = (Multilibultra::time_since_start() * (60 * Multilibultra::get_speed_multiplier()) / 1000ms) + 1; + uint64_t new_total_vis = (ultramodern::time_since_start() * (60 * ultramodern::get_speed_multiplier()) / 1000ms) + 1; if (new_total_vis > total_vis + 1) { //printf("Skipped % " PRId64 " frames in VI interupt thread!\n", new_total_vis - total_vis - 1); } @@ -134,7 +134,7 @@ void vi_thread_func() { if (remaining_retraces == 0) { remaining_retraces = events_context.vi.retrace_count; - if (Multilibultra::is_game_started()) { + if (ultramodern::is_game_started()) { if (events_context.vi.mq != NULLPTR) { if (osSendMesg(PASS_RDRAM events_context.vi.mq, events_context.vi.msg, OS_MESG_NOBLOCK) == -1) { //printf("Game skipped a VI frame!\n"); @@ -174,7 +174,7 @@ void dp_complete() { osSendMesg(PASS_RDRAM events_context.dp.mq, events_context.dp.msg, OS_MESG_NOBLOCK); } -void RT64Init(uint8_t* rom, uint8_t* rdram, Multilibultra::WindowHandle window_handle); +void RT64Init(uint8_t* rom, uint8_t* rdram, ultramodern::WindowHandle window_handle); void RT64SendDL(uint8_t* rdram, const OSTask* task); void RT64UpdateScreen(uint32_t vi_origin); void RT64ChangeWindow(); @@ -220,8 +220,8 @@ void run_rsp_microcode(uint8_t* rdram, const OSTask* task, RspUcodeFunc* ucode_f void task_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_ready) { - Multilibultra::set_native_thread_name("SP Task Thread"); - Multilibultra::set_native_thread_priority(Multilibultra::ThreadPriority::Normal); + ultramodern::set_native_thread_name("SP Task Thread"); + ultramodern::set_native_thread_priority(ultramodern::ThreadPriority::Normal); // Notify the caller thread that this thread is ready. thread_ready->test_and_set(); @@ -257,11 +257,11 @@ void task_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_rea } } -void gfx_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_ready, Multilibultra::WindowHandle window_handle) { +void gfx_thread_func(uint8_t* rdram, uint8_t* rom, std::atomic_flag* thread_ready, ultramodern::WindowHandle window_handle) { using namespace std::chrono_literals; - Multilibultra::set_native_thread_name("Gfx Thread"); - Multilibultra::set_native_thread_priority(Multilibultra::ThreadPriority::Normal); + ultramodern::set_native_thread_name("Gfx Thread"); + ultramodern::set_native_thread_priority(ultramodern::ThreadPriority::Normal); RT64Init(rom, rdram, window_handle); @@ -445,7 +445,7 @@ extern "C" PTR(void) osViGetCurrentFramebuffer() { return events_context.vi.current_buffer; } -void Multilibultra::submit_rsp_task(RDRAM_ARG PTR(OSTask) task_) { +void ultramodern::submit_rsp_task(RDRAM_ARG PTR(OSTask) task_) { OSTask* task = TO_PTR(OSTask, task_); // Send gfx tasks to the graphics action queue @@ -459,12 +459,12 @@ void Multilibultra::submit_rsp_task(RDRAM_ARG PTR(OSTask) task_) { } } -void Multilibultra::send_si_message() { +void ultramodern::send_si_message() { uint8_t* rdram = events_context.rdram; osSendMesg(PASS_RDRAM events_context.si.mq, events_context.si.msg, OS_MESG_NOBLOCK); } -void Multilibultra::init_events(uint8_t* rdram, uint8_t* rom, Multilibultra::WindowHandle window_handle) { +void ultramodern::init_events(uint8_t* rdram, uint8_t* rom, ultramodern::WindowHandle window_handle) { std::atomic_flag gfx_thread_ready; std::atomic_flag task_thread_ready; events_context.rdram = rdram; @@ -479,7 +479,7 @@ void Multilibultra::init_events(uint8_t* rdram, uint8_t* rom, Multilibultra::Win events_context.vi.thread = std::thread{ vi_thread_func }; } -void Multilibultra::join_event_threads() { +void ultramodern::join_event_threads() { events_context.sp.gfx_thread.join(); events_context.vi.thread.join(); diff --git a/portultra/mesgqueue.cpp b/ultramodern/mesgqueue.cpp similarity index 70% rename from portultra/mesgqueue.cpp rename to ultramodern/mesgqueue.cpp index fd7a0bb..141b751 100644 --- a/portultra/mesgqueue.cpp +++ b/ultramodern/mesgqueue.cpp @@ -2,7 +2,7 @@ #include #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" #include "recomp.h" extern "C" void osCreateMesgQueue(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSMesg) msg, s32 count) { @@ -51,26 +51,26 @@ extern "C" s32 osSendMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) OSMesgQueue *mq = TO_PTR(OSMesgQueue, mq_); // Prevent accidentally blocking anything that isn't a game thread - if (!Multilibultra::is_game_thread()) { + if (!ultramodern::is_game_thread()) { flags = OS_MESG_NOBLOCK; } - Multilibultra::disable_preemption(); + ultramodern::disable_preemption(); if (flags == OS_MESG_NOBLOCK) { // If non-blocking, fail if the queue is full if (MQ_IS_FULL(mq)) { - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); return -1; } } else { // Otherwise, yield this thread until the queue has room while (MQ_IS_FULL(mq)) { - debug_printf("[Message Queue] Thread %d is blocked on send\n", TO_PTR(OSThread, Multilibultra::this_thread())->id); - thread_queue_insert(PASS_RDRAM &mq->blocked_on_send, Multilibultra::this_thread()); - Multilibultra::enable_preemption(); - Multilibultra::pause_self(PASS_RDRAM1); - Multilibultra::disable_preemption(); + debug_printf("[Message Queue] Thread %d is blocked on send\n", TO_PTR(OSThread, ultramodern::this_thread())->id); + thread_queue_insert(PASS_RDRAM &mq->blocked_on_send, ultramodern::this_thread()); + ultramodern::enable_preemption(); + ultramodern::pause_self(PASS_RDRAM1); + ultramodern::disable_preemption(); } } @@ -84,18 +84,18 @@ extern "C" s32 osSendMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) to_run = thread_queue_pop(PASS_RDRAM &mq->blocked_on_recv); } - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); if (to_run) { debug_printf("[Message Queue] Thread %d is unblocked\n", to_run->id); - if (Multilibultra::is_game_thread()) { - OSThread* self = TO_PTR(OSThread, Multilibultra::this_thread()); + if (ultramodern::is_game_thread()) { + OSThread* self = TO_PTR(OSThread, ultramodern::this_thread()); if (to_run->priority > self->priority) { - Multilibultra::swap_to_thread(PASS_RDRAM to_run); + ultramodern::swap_to_thread(PASS_RDRAM to_run); } else { - Multilibultra::schedule_running_thread(to_run); + ultramodern::schedule_running_thread(to_run); } } else { - Multilibultra::schedule_running_thread(to_run); + ultramodern::schedule_running_thread(to_run); } } return 0; @@ -103,22 +103,22 @@ extern "C" s32 osSendMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) extern "C" s32 osJamMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) { OSMesgQueue *mq = TO_PTR(OSMesgQueue, mq_); - Multilibultra::disable_preemption(); + ultramodern::disable_preemption(); if (flags == OS_MESG_NOBLOCK) { // If non-blocking, fail if the queue is full if (MQ_IS_FULL(mq)) { - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); return -1; } } else { // Otherwise, yield this thread in a loop until the queue is no longer full while (MQ_IS_FULL(mq)) { - debug_printf("[Message Queue] Thread %d is blocked on jam\n", TO_PTR(OSThread, Multilibultra::this_thread())->id); - thread_queue_insert(PASS_RDRAM &mq->blocked_on_send, Multilibultra::this_thread()); - Multilibultra::enable_preemption(); - Multilibultra::pause_self(PASS_RDRAM1); - Multilibultra::disable_preemption(); + debug_printf("[Message Queue] Thread %d is blocked on jam\n", TO_PTR(OSThread, ultramodern::this_thread())->id); + thread_queue_insert(PASS_RDRAM &mq->blocked_on_send, ultramodern::this_thread()); + ultramodern::enable_preemption(); + ultramodern::pause_self(PASS_RDRAM1); + ultramodern::disable_preemption(); } } @@ -132,14 +132,14 @@ extern "C" s32 osJamMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) to_run = thread_queue_pop(PASS_RDRAM &mq->blocked_on_recv); } - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); if (to_run) { debug_printf("[Message Queue] Thread %d is unblocked\n", to_run->id); - OSThread *self = TO_PTR(OSThread, Multilibultra::this_thread()); + OSThread *self = TO_PTR(OSThread, ultramodern::this_thread()); if (to_run->priority > self->priority) { - Multilibultra::swap_to_thread(PASS_RDRAM to_run); + ultramodern::swap_to_thread(PASS_RDRAM to_run); } else { - Multilibultra::schedule_running_thread(to_run); + ultramodern::schedule_running_thread(to_run); } } return 0; @@ -148,22 +148,22 @@ extern "C" s32 osJamMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, OSMesg msg, s32 flags) extern "C" s32 osRecvMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSMesg) msg_, s32 flags) { OSMesgQueue *mq = TO_PTR(OSMesgQueue, mq_); OSMesg *msg = TO_PTR(OSMesg, msg_); - Multilibultra::disable_preemption(); + ultramodern::disable_preemption(); if (flags == OS_MESG_NOBLOCK) { // If non-blocking, fail if the queue is empty if (MQ_IS_EMPTY(mq)) { - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); return -1; } } else { // Otherwise, yield this thread in a loop until the queue is no longer full while (MQ_IS_EMPTY(mq)) { - debug_printf("[Message Queue] Thread %d is blocked on receive\n", TO_PTR(OSThread, Multilibultra::this_thread())->id); - thread_queue_insert(PASS_RDRAM &mq->blocked_on_recv, Multilibultra::this_thread()); - Multilibultra::enable_preemption(); - Multilibultra::pause_self(PASS_RDRAM1); - Multilibultra::disable_preemption(); + debug_printf("[Message Queue] Thread %d is blocked on receive\n", TO_PTR(OSThread, ultramodern::this_thread())->id); + thread_queue_insert(PASS_RDRAM &mq->blocked_on_recv, ultramodern::this_thread()); + ultramodern::enable_preemption(); + ultramodern::pause_self(PASS_RDRAM1); + ultramodern::disable_preemption(); } } @@ -180,14 +180,14 @@ extern "C" s32 osRecvMesg(RDRAM_ARG PTR(OSMesgQueue) mq_, PTR(OSMesg) msg_, s32 to_run = thread_queue_pop(PASS_RDRAM &mq->blocked_on_send); } - Multilibultra::enable_preemption(); + ultramodern::enable_preemption(); if (to_run) { debug_printf("[Message Queue] Thread %d is unblocked\n", to_run->id); - OSThread *self = TO_PTR(OSThread, Multilibultra::this_thread()); + OSThread *self = TO_PTR(OSThread, ultramodern::this_thread()); if (to_run->priority > self->priority) { - Multilibultra::swap_to_thread(PASS_RDRAM to_run); + ultramodern::swap_to_thread(PASS_RDRAM to_run); } else { - Multilibultra::schedule_running_thread(to_run); + ultramodern::schedule_running_thread(to_run); } } return 0; diff --git a/portultra/misc_ultra.cpp b/ultramodern/misc_ultra.cpp similarity index 100% rename from portultra/misc_ultra.cpp rename to ultramodern/misc_ultra.cpp diff --git a/portultra/port_main.c b/ultramodern/port_main.c similarity index 100% rename from portultra/port_main.c rename to ultramodern/port_main.c diff --git a/portultra/scheduler.cpp b/ultramodern/scheduler.cpp similarity index 93% rename from portultra/scheduler.cpp rename to ultramodern/scheduler.cpp index 60cfb9e..678b5bb 100644 --- a/portultra/scheduler.cpp +++ b/ultramodern/scheduler.cpp @@ -3,7 +3,7 @@ #include #include -#include "multilibultra.hpp" +#include "ultramodern.hpp" class OSThreadComparator { public: @@ -134,10 +134,10 @@ void swap_running_thread(thread_queue_t& running_thread_queue, OSThread*& cur_ru } else { debug_printf("[Scheduler] Switching execution to thread %d (%d)\n", new_running_thread->id, new_running_thread->priority); } - Multilibultra::resume_thread_impl(new_running_thread); + ultramodern::resume_thread_impl(new_running_thread); cur_running_thread = new_running_thread; } else if (cur_running_thread && cur_running_thread->state != OSThreadState::RUNNING) { - Multilibultra::resume_thread_impl(cur_running_thread); + ultramodern::resume_thread_impl(cur_running_thread); } } else { cur_running_thread = nullptr; @@ -191,7 +191,7 @@ extern "C" void do_yield() { std::this_thread::yield(); } -namespace Multilibultra { +namespace ultramodern { void init_scheduler() { scheduler_context.can_preempt = true; @@ -208,16 +208,16 @@ void schedule_running_thread(OSThread *t) { } void swap_to_thread(RDRAM_ARG OSThread *to) { - OSThread *self = TO_PTR(OSThread, Multilibultra::this_thread()); + OSThread *self = TO_PTR(OSThread, ultramodern::this_thread()); debug_printf("[Scheduler] Scheduling swap from thread %d to %d\n", self->id, to->id); { std::lock_guard lock{scheduler_context.mutex}; scheduler_context.to_schedule.push_back(to); - Multilibultra::set_self_paused(PASS_RDRAM1); + ultramodern::set_self_paused(PASS_RDRAM1); scheduler_context.action_count.fetch_add(1); scheduler_context.action_count.notify_all(); } - Multilibultra::wait_for_resumed(PASS_RDRAM1); + ultramodern::wait_for_resumed(PASS_RDRAM1); } void reprioritize_thread(OSThread *t, OSPri pri) { @@ -229,16 +229,16 @@ void reprioritize_thread(OSThread *t, OSPri pri) { } void pause_self(RDRAM_ARG1) { - OSThread *self = TO_PTR(OSThread, Multilibultra::this_thread()); + OSThread *self = TO_PTR(OSThread, ultramodern::this_thread()); debug_printf("[Scheduler] Thread %d pausing itself\n", self->id); { std::lock_guard lock{scheduler_context.mutex}; - Multilibultra::set_self_paused(PASS_RDRAM1); + ultramodern::set_self_paused(PASS_RDRAM1); scheduler_context.to_stop.push_back(self); scheduler_context.action_count.fetch_add(1); scheduler_context.action_count.notify_all(); } - Multilibultra::wait_for_resumed(PASS_RDRAM1); + ultramodern::wait_for_resumed(PASS_RDRAM1); } void cleanup_thread(OSThread *t) { @@ -250,13 +250,13 @@ void cleanup_thread(OSThread *t) { void disable_preemption() { scheduler_context.premption_mutex.lock(); - if (Multilibultra::is_game_thread()) { + if (ultramodern::is_game_thread()) { scheduler_context.can_preempt = false; } } void enable_preemption() { - if (Multilibultra::is_game_thread()) { + if (ultramodern::is_game_thread()) { scheduler_context.can_preempt = true; } #pragma warning(push) @@ -275,6 +275,6 @@ void notify_scheduler() { } extern "C" void pause_self(uint8_t* rdram) { - Multilibultra::pause_self(rdram); + ultramodern::pause_self(rdram); } diff --git a/portultra/task_win32.cpp b/ultramodern/task_win32.cpp similarity index 81% rename from portultra/task_win32.cpp rename to ultramodern/task_win32.cpp index 7f6d8fe..c3e511c 100644 --- a/portultra/task_win32.cpp +++ b/ultramodern/task_win32.cpp @@ -3,7 +3,7 @@ #include #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" extern "C" unsigned int sleep(unsigned int seconds) { Sleep(seconds * 1000); diff --git a/portultra/threads.cpp b/ultramodern/threads.cpp similarity index 84% rename from portultra/threads.cpp rename to ultramodern/threads.cpp index 5a35e30..abb3b57 100644 --- a/portultra/threads.cpp +++ b/ultramodern/threads.cpp @@ -4,7 +4,7 @@ #include #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" // Native APIs only used to set thread names for easier debugging #ifdef _WIN32 @@ -18,18 +18,18 @@ thread_local bool is_main_thread = false; thread_local bool is_game_thread = false; thread_local PTR(OSThread) thread_self = NULLPTR; -void Multilibultra::set_main_thread() { +void ultramodern::set_main_thread() { ::is_game_thread = true; is_main_thread = true; } -bool Multilibultra::is_game_thread() { +bool ultramodern::is_game_thread() { return ::is_game_thread; } #if 0 int main(int argc, char** argv) { - Multilibultra::set_main_thread(); + ultramodern::set_main_thread(); bootproc(); } @@ -44,7 +44,7 @@ void run_thread_function(uint8_t* rdram, uint64_t addr, uint64_t sp, uint64_t ar struct thread_terminated : std::exception {}; #if defined(_WIN32) -void Multilibultra::set_native_thread_name(const std::string& name) { +void ultramodern::set_native_thread_name(const std::string& name) { std::wstring wname{name.begin(), name.end()}; HRESULT r; @@ -54,7 +54,7 @@ void Multilibultra::set_native_thread_name(const std::string& name) { ); } -void Multilibultra::set_native_thread_priority(ThreadPriority pri) { +void ultramodern::set_native_thread_priority(ThreadPriority pri) { int nPriority = THREAD_PRIORITY_NORMAL; // Convert ThreadPriority to Win32 priority @@ -81,11 +81,11 @@ void Multilibultra::set_native_thread_priority(ThreadPriority pri) { // SetThreadPriority(GetCurrentThread(), nPriority); } #elif defined(__linux__) -void Multilibultra::set_native_thread_name(const std::string& name) { +void ultramodern::set_native_thread_name(const std::string& name) { pthread_setname_np(pthread_self(), name.c_str()); } -void Multilibultra::set_native_thread_priority(ThreadPriority pri) { +void ultramodern::set_native_thread_priority(ThreadPriority pri) { // TODO linux thread priority printf("set_native_thread_priority unimplemented\n"); // int nPriority = THREAD_PRIORITY_NORMAL; @@ -121,8 +121,8 @@ static void _thread_func(RDRAM_ARG PTR(OSThread) self_, PTR(thread_func_t) entry is_game_thread = true; // Set the thread name - Multilibultra::set_native_thread_name("Game Thread " + std::to_string(self->id)); - Multilibultra::set_native_thread_priority(Multilibultra::ThreadPriority::High); + ultramodern::set_native_thread_name("Game Thread " + std::to_string(self->id)); + ultramodern::set_native_thread_priority(ultramodern::ThreadPriority::High); // Set initialized to false to indicate that this thread can be started. self->context->initialized.store(true); @@ -131,8 +131,8 @@ static void _thread_func(RDRAM_ARG PTR(OSThread) self_, PTR(thread_func_t) entry debug_printf("[Thread] Thread waiting to be started: %d\n", self->id); // Wait until the thread is marked as running. - Multilibultra::set_self_paused(PASS_RDRAM1); - Multilibultra::wait_for_resumed(PASS_RDRAM1); + ultramodern::set_self_paused(PASS_RDRAM1); + ultramodern::wait_for_resumed(PASS_RDRAM1); debug_printf("[Thread] Thread started: %d\n", self->id); @@ -144,7 +144,7 @@ static void _thread_func(RDRAM_ARG PTR(OSThread) self_, PTR(thread_func_t) entry } // Dispose of this thread after it completes. - Multilibultra::cleanup_thread(self); + ultramodern::cleanup_thread(self); } extern "C" void osStartThread(RDRAM_ARG PTR(OSThread) t_) { @@ -157,9 +157,9 @@ extern "C" void osStartThread(RDRAM_ARG PTR(OSThread) t_) { debug_printf("[os] Thread %d is ready to be started\n", t->id); if (thread_self && (t->priority > TO_PTR(OSThread, thread_self)->priority)) { - Multilibultra::swap_to_thread(PASS_RDRAM t); + ultramodern::swap_to_thread(PASS_RDRAM t); } else { - Multilibultra::schedule_running_thread(t); + ultramodern::schedule_running_thread(t); } } @@ -206,14 +206,14 @@ extern "C" void osSetThreadPri(RDRAM_ARG PTR(OSThread) t, OSPri pri) { bool pause_self = false; if (pri > TO_PTR(OSThread, thread_self)->priority) { pause_self = true; - Multilibultra::set_self_paused(PASS_RDRAM1); + ultramodern::set_self_paused(PASS_RDRAM1); } else if (t == thread_self && pri < TO_PTR(OSThread, thread_self)->priority) { pause_self = true; - Multilibultra::set_self_paused(PASS_RDRAM1); + ultramodern::set_self_paused(PASS_RDRAM1); } - Multilibultra::reprioritize_thread(TO_PTR(OSThread, t), pri); + ultramodern::reprioritize_thread(TO_PTR(OSThread, t), pri); if (pause_self) { - Multilibultra::wait_for_resumed(PASS_RDRAM1); + ultramodern::wait_for_resumed(PASS_RDRAM1); } } @@ -233,7 +233,7 @@ extern "C" OSId osGetThreadId(RDRAM_ARG PTR(OSThread) t) { // TODO yield thread, need a stable priority queue in the scheduler -void Multilibultra::set_self_paused(RDRAM_ARG1) { +void ultramodern::set_self_paused(RDRAM_ARG1) { debug_printf("[Thread] Thread pausing itself: %d\n", TO_PTR(OSThread, thread_self)->id); TO_PTR(OSThread, thread_self)->state = OSThreadState::PAUSED; TO_PTR(OSThread, thread_self)->context->running.store(false); @@ -246,19 +246,19 @@ void check_destroyed(OSThread* t) { } } -void Multilibultra::wait_for_resumed(RDRAM_ARG1) { +void ultramodern::wait_for_resumed(RDRAM_ARG1) { check_destroyed(TO_PTR(OSThread, thread_self)); TO_PTR(OSThread, thread_self)->context->running.wait(false); check_destroyed(TO_PTR(OSThread, thread_self)); } -void Multilibultra::pause_thread_impl(OSThread* t) { +void ultramodern::pause_thread_impl(OSThread* t) { t->state = OSThreadState::PREEMPTED; t->context->running.store(false); t->context->running.notify_all(); } -void Multilibultra::resume_thread_impl(OSThread *t) { +void ultramodern::resume_thread_impl(OSThread *t) { if (t->state == OSThreadState::PREEMPTED) { // Nothing to do here } @@ -267,6 +267,6 @@ void Multilibultra::resume_thread_impl(OSThread *t) { t->context->running.notify_all(); } -PTR(OSThread) Multilibultra::this_thread() { +PTR(OSThread) ultramodern::this_thread() { return thread_self; } diff --git a/portultra/timer.cpp b/ultramodern/timer.cpp similarity index 93% rename from portultra/timer.cpp rename to ultramodern/timer.cpp index ca53605..06c4e69 100644 --- a/portultra/timer.cpp +++ b/ultramodern/timer.cpp @@ -4,7 +4,7 @@ #include "blockingconcurrentqueue.h" #include "ultra64.h" -#include "multilibultra.hpp" +#include "ultramodern.hpp" // Start time for the program static std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now(); @@ -60,8 +60,8 @@ uint64_t time_now() { } void timer_thread(RDRAM_ARG1) { - Multilibultra::set_native_thread_name("Timer Thread"); - Multilibultra::set_native_thread_priority(Multilibultra::ThreadPriority::VeryHigh); + ultramodern::set_native_thread_name("Timer Thread"); + ultramodern::set_native_thread_priority(ultramodern::ThreadPriority::VeryHigh); // Lambda comparator function to keep the set ordered auto timer_sort = [PASS_RDRAM1](PTR(OSTimer) a_, PTR(OSTimer) b_) { @@ -134,20 +134,20 @@ void timer_thread(RDRAM_ARG1) { } } -void Multilibultra::init_timers(RDRAM_ARG1) { +void ultramodern::init_timers(RDRAM_ARG1) { timer_context.thread = std::thread{ timer_thread, PASS_RDRAM1 }; timer_context.thread.detach(); } -uint32_t Multilibultra::get_speed_multiplier() { +uint32_t ultramodern::get_speed_multiplier() { return speed_multiplier; } -std::chrono::system_clock::time_point Multilibultra::get_start() { +std::chrono::system_clock::time_point ultramodern::get_start() { return start_time; } -std::chrono::system_clock::duration Multilibultra::time_since_start() { +std::chrono::system_clock::duration ultramodern::time_since_start() { return std::chrono::system_clock::now() - start_time; } diff --git a/portultra/ultra64.h b/ultramodern/ultra64.h similarity index 99% rename from portultra/ultra64.h rename to ultramodern/ultra64.h index dc117b3..7fa0333 100644 --- a/portultra/ultra64.h +++ b/ultramodern/ultra64.h @@ -1,5 +1,5 @@ -#ifndef __ULTRA64_MULTILIBULTRA_H__ -#define __ULTRA64_MULTILIBULTRA_H__ +#ifndef __ULTRA64_ultramodern_H__ +#define __ULTRA64_ultramodern_H__ #include diff --git a/ultramodern/ultrainit.cpp b/ultramodern/ultrainit.cpp new file mode 100644 index 0000000..4d51781 --- /dev/null +++ b/ultramodern/ultrainit.cpp @@ -0,0 +1,14 @@ +#include "ultra64.h" +#include "ultramodern.hpp" + +void ultramodern::preinit(uint8_t* rdram, uint8_t* rom, ultramodern::WindowHandle window_handle) { + ultramodern::set_main_thread(); + ultramodern::init_events(rdram, rom, window_handle); + ultramodern::init_timers(rdram); + ultramodern::init_audio(); + ultramodern::save_init(); +} + +extern "C" void osInitialize() { + ultramodern::init_scheduler(); +} diff --git a/portultra/multilibultra.hpp b/ultramodern/ultramodern.hpp similarity index 97% rename from portultra/multilibultra.hpp rename to ultramodern/ultramodern.hpp index 533db5f..f5d2a77 100644 --- a/portultra/multilibultra.hpp +++ b/ultramodern/ultramodern.hpp @@ -1,5 +1,5 @@ -#ifndef __MULTILIBULTRA_HPP__ -#define __MULTILIBULTRA_HPP__ +#ifndef __ultramodern_HPP__ +#define __ultramodern_HPP__ #include #include @@ -26,7 +26,7 @@ struct UltraThreadContext { std::atomic_bool initialized; }; -namespace Multilibultra { +namespace ultramodern { #if defined(_WIN32) // Native HWND handle to the target window. @@ -128,7 +128,7 @@ bool is_game_started(); void quit(); void join_event_threads(); -} // namespace Multilibultra +} // namespace ultramodern #define MIN(a, b) ((a) < (b) ? (a) : (b))