The-Homebrew-Cloud/Zelda64Recomp
2
0
Fork 0
mirror of https://github.com/Mr-Wiseguy/Zelda64Recomp.git synced 2024-07-20 13:25:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Renamed everything ultra related to "ultramodern"

Browse Source
This commit is contained in:
Mr-Wiseguy 2023-11-12 19:40:02 -05:00
parent 8188aee2c1
commit 244d37e3c8
31 changed files with 204 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
CMakeLists.txt
View File

@ -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

2
include/rt64_layer.h
View File

@ -1,7 +1,7 @@
#ifndef __RT64_LAYER_H__
#define __RT64_LAYER_H__
#include "../portultra/multilibultra.hpp"
#include "../ultramodern/ultramodern.hpp"
typedef struct {
// void* hWnd;

14
portultra/ultrainit.cpp
View File

@ -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();
}

10
src/ai.cpp
View File

@ -1,8 +1,8 @@
#include "recomp.h"
#include <cstdio>
#include <string>
#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) {

10
src/cont.cpp
View File

@ -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) {

2
src/eep.cpp
View File

@ -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);

12
src/flash.cpp
View File

@ -1,9 +1,11 @@
#include <array>
#include <cassert>
#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<char, page_size> 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;
}

24
src/main/main.cpp
View File

@ -4,8 +4,8 @@
#include <vector>
#include <filesystem>
#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<typename... Ts>
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;
}

2
src/math_routines.cpp
View File

@ -1,4 +1,4 @@
#include "../portultra/multilibultra.hpp"
#include "../ultramodern/ultramodern.hpp"
#include "recomp.h"

4
src/pak.cpp
View File

@ -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

10
src/pi.cpp
View File

@ -3,8 +3,8 @@
#include <array>
#include <cstring>
#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<uint8_t[]> 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()) {

4
src/print.cpp
View File

@ -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"

22
src/recomp.cpp
View File

@ -10,7 +10,7 @@
#include <fstream>
#include <iostream>
#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();
}

4
src/rt64_layer.cpp
View File

@ -2,7 +2,7 @@
#include <cstring>
// #include <Windows.h>
#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");

4
src/sp.cpp
View File

@ -1,6 +1,6 @@
#include <cstdio>
#include <fstream>
#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) {

6
src/ui/ui_events.cpp
View File

@ -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<Rml::EventListenerInstancer> 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);
}
);

4
src/portultra_stubs.cpp → src/ultra_stubs.cpp
View File

@ -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

8
src/portultra_translation.cpp → src/ultra_translation.cpp
View File

@ -1,6 +1,6 @@
#include <memory>
#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();
//}

2
src/vi.cpp
View File

@ -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) {

14
portultra/audio.cpp → ultramodern/audio.cpp
View File

@ -1,28 +1,28 @@
#include "ultra64.h"
#include "multilibultra.hpp"
#include "ultramodern.hpp"
#include <cassert>
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<int16_t> 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) {

32
portultra/events.cpp → ultramodern/events.cpp
View File

@ -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();

74
portultra/mesgqueue.cpp → ultramodern/mesgqueue.cpp
View File

@ -2,7 +2,7 @@
#include <atomic>
#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;

0
portultra/misc_ultra.cpp → ultramodern/misc_ultra.cpp
View File

0
portultra/port_main.c → ultramodern/port_main.c
View File

26
portultra/scheduler.cpp → ultramodern/scheduler.cpp
View File

@ -3,7 +3,7 @@
#include <atomic>
#include <vector>
#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);
}

2
portultra/task_win32.cpp → ultramodern/task_win32.cpp
View File

@ -3,7 +3,7 @@
#include <Windows.h>
#include "ultra64.h"
#include "multilibultra.hpp"
#include "ultramodern.hpp"
extern "C" unsigned int sleep(unsigned int seconds) {
Sleep(seconds * 1000);

48
portultra/threads.cpp → ultramodern/threads.cpp
View File

@ -4,7 +4,7 @@
#include <string>
#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;
}

14
portultra/timer.cpp → ultramodern/timer.cpp
View File

@ -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;
}

4
portultra/ultra64.h → ultramodern/ultra64.h
View File

@ -1,5 +1,5 @@
#ifndef __ULTRA64_MULTILIBULTRA_H__
#define __ULTRA64_MULTILIBULTRA_H__
#ifndef __ULTRA64_ultramodern_H__
#define __ULTRA64_ultramodern_H__
#include <stdint.h>

14
ultramodern/ultrainit.cpp Normal file
View File

@ -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();
}

8
portultra/multilibultra.hpp → ultramodern/ultramodern.hpp
View File

@ -1,5 +1,5 @@
#ifndef __MULTILIBULTRA_HPP__
#define __MULTILIBULTRA_HPP__
#ifndef __ultramodern_HPP__
#define __ultramodern_HPP__
#include <thread>
#include <atomic>
@ -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))