jaby
/
jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Support VSync callback

This commit is contained in:
jaby 2024-05-15 21:43:12 +02:00
parent 3c0cc3bb6a
commit deb5bf8442
11 changed files with 156 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/PoolBox/application/src/application.cpp
View File

@ -7,6 +7,7 @@
#include <FontWriter/font_writer.hpp>
#include <PSX/Audio/CDDA.hpp>
#include <PSX/Periphery/periphery.hpp>
#include <PSX/System/callbacks.hpp>
#include <stdio.hpp>
using namespace JabyEngine;
@ -156,6 +157,10 @@ namespace LoadingScene {
if(old_state_changer != state_changer) {
printf("Loading new state...\n");
Callback::VSyncCallback::install([]() {
printf("Still loading...\n");
});
update();
GPU::swap_buffers_vsync(1);
render();
@ -165,6 +170,7 @@ namespace LoadingScene {
state_changer.asset_load();
old_state_changer = state_changer;
CDDA::pop_play();
Callback::VSyncCallback::uninstall();
}
state_changer.main();

20
include/PSX/System/callbacks.hpp Normal file
View File

@ -0,0 +1,20 @@
#pragma once
#include "syscalls.hpp"
namespace JabyEngine {
namespace Callback {
struct VSyncCallback {
using Function = void (*)();
static Function callback;
static void install(Function function) {
VSyncCallback::callback = function;
}
static void uninstall() {
VSyncCallback::install(nullptr);
}
};
}
}

20
include/PSX/System/syscalls.hpp
View File

@ -118,6 +118,7 @@ namespace JabyEngine {
typedef InterruptVerifierResult (*InterruptVerifier)();
typedef uint32_t (*InterruptHandler)(uint32_t);
using ThreadHandle = uint32_t;
#pragma pack(push, 1)
struct InterrupCallback {
@ -143,26 +144,11 @@ namespace JabyEngine {
return __syscall_function_cast(Table_A, void*(*)(void*, const void*, size_t))(dst, src, len);
}
static __always_inline uint32_t OpenTh(void (*thread_func)(), uint32_t* stack_ptr, uint32_t* gp) {
static __always_inline ThreadHandle OpenThread(void (*thread_func)(), uint32_t* stack_ptr, uint32_t* gp) {
register uint32_t FuncID asm("t1") = 0x0E;
__asm__ volatile("" : "=r"(FuncID) : "r"(FuncID));
return __syscall_function_cast(Table_B, uint32_t(*)(void(*)(), uint32_t*, uint32_t*))(thread_func, stack_ptr, gp);
}
static __always_inline uint32_t ChangeTh(uint32_t thread) {
register uint32_t FuncID asm("t1") = 0x10;
__asm__ volatile("" : "=r"(FuncID) : "r"(FuncID));
return __syscall_function_cast(Table_B, uint32_t(*)(uint32_t))(thread);
}
static __always_inline int changeThreadSubFunction(uint32_t address) {
register int n asm("a0") = 3;
register int tcb asm("a1") = address;
register int r asm("v0");
__asm__ volatile("syscall\n" : "=r"(r) : "r"(n), "r"(tcb) : "memory");
return r;
return __syscall_function_cast(Table_B, ThreadHandle(*)(void(*)(), uint32_t*, uint32_t*))(thread_func, stack_ptr, gp);
}
static __always_inline void InitPad(uint8_t *portA, uint32_t portASize, uint8_t *portB, uint32_t portBSize) {

43
include/PSX/System/threads.hpp Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include "syscalls.hpp"
namespace JabyEngine {
struct Thread {
static constexpr uint32_t idx_from_handle(SysCall::ThreadHandle thread) {
return thread & 0xFFFF;
}
static void prepare_next(SysCall::ThreadHandle thread) {
table_of_tables.processes->current_tcb = &table_of_tables.threads[idx_from_handle(thread)];
}
static void execute_next() {
SysCall::ReturnFromException();
}
static void set_kernel_mode_for(SysCall::ThreadHandle handle) {
table_of_tables.threads[idx_from_handle(handle)].sr = 0x0;
}
static void set_user_mode_for(SysCall::ThreadHandle handle) {
table_of_tables.threads[idx_from_handle(handle)].sr = 0x40000404;
}
};
struct MainThread {
static void prepare_if_main(SysCall::ThreadHandle handle) {
if(table_of_tables.processes->current_tcb == &table_of_tables.threads[0]) {
Thread::prepare_next(handle);
}
}
static void prepare_restore() {
Thread::prepare_next(0);
}
static void restore() {
MainThread::prepare_restore();
Thread::execute_next();
}
};
}

4
src/Library/internal-include/BootLoader/boot_loader.hpp
View File

@ -8,6 +8,10 @@ namespace JabyEngine {
void identify();
}
namespace Callbacks {
void setup();
}
namespace CD {
void setup();
}

21
src/Library/internal-include/System/callbacks_internal.hpp Normal file
View File

@ -0,0 +1,21 @@
#pragma once
#include <PSX/System/threads.hpp>
namespace JabyEngine {
namespace Callback {
namespace internal {
namespace VSync {
static constexpr size_t StackSize = 64;
extern SysCall::ThreadHandle thread_handle;
extern uint32_t stack[StackSize];
void routine();
static void execute() {
MainThread::prepare_if_main(VSync::thread_handle);
Thread::execute_next();
}
}
}
}
}

21
src/Library/src/BootLoader/callbacks_boot.cpp Normal file
View File

@ -0,0 +1,21 @@
#include "../../internal-include/BootLoader/boot_loader.hpp"
#include "../../internal-include/System/callbacks_internal.hpp"
namespace JabyEngine {
namespace boot {
namespace Callbacks {
namespace InternalCallback = JabyEngine::Callback::internal;
void setup() {
SysCall::EnterCriticalSection();
InternalCallback::VSync::thread_handle = SysCall::OpenThread(
InternalCallback::VSync::routine,
&InternalCallback::VSync::stack[InternalCallback::VSync::StackSize - 1],
SysCall::get_gp()
);
Thread::set_user_mode_for(InternalCallback::VSync::thread_handle);
SysCall::ExitCriticalSection();
}
}
}
}

2
src/Library/src/BootLoader/start_boot.cpp
View File

@ -47,6 +47,7 @@ namespace JabyEngine {
static constexpr auto DebugScale = 1.0;
BIOS::identify();
Callbacks::setup();
__debug_boot_color_at(::JabyEngine::GPU::Color24::Grey(), DebugX, DebugY, DebugScale);
DMA::setup();
@ -69,7 +70,6 @@ namespace JabyEngine {
test_bios_font();
test_gte_scale();
//Pause??
SPU::setup();
}
}

38
src/Library/src/CD/cd.cpp
View File

@ -13,9 +13,6 @@ namespace JabyEngine {
static SysCall::InterruptVerifierResult interrupt_verifier();
static uint32_t interrupt_handler(uint32_t);
static uint32_t stack[1024];
static uint32_t thread = 0;
static SectorBufferAllocator sector_allocator;
static uint32_t cur_lba;
static uint32_t dst_lba;
@ -112,12 +109,15 @@ namespace JabyEngine {
} break;
case CD_IO::Interrupt::DataEnd: {
if(thread != 0 && table_of_tables.processes->current_tcb == &table_of_tables.threads[0]) {
//changeThread(thread);
printf("About to change...\n");
table_of_tables.processes->current_tcb = &table_of_tables.threads[thread&0xFFFF];
printf("Changed!\n");
}
CD_IO::PortIndex0::change_to();
Command::send<CD_IO::PortIndex0>(CD_IO::Command::SetLoc, static_cast<uint8_t>(0x0), static_cast<uint8_t>(0x09), static_cast<uint8_t>(0x0));
CD_IO::PortIndex1::change_to();
while(CD_IO::Interrupt::get_type(CD_IO::PortIndex1::InterruptFlag) != CD_IO::Interrupt::Acknowledge);
CD_IO::Interrupt::ack_extended(CD_IO::PortIndex1::InterruptFlag);
CD_IO::PortIndex0::change_to();
Command::send<CD_IO::PortIndex0>(CD_IO::Command::Play);
} break;
case CD_IO::Interrupt::DiskError: {
@ -152,26 +152,6 @@ namespace JabyEngine {
}
void enable_CDDA() {
if(thread == 0) {
SysCall::EnterCriticalSection();
thread = SysCall::OpenTh([]() {
printf("Hallo!\n");
CD_IO::PortIndex0::change_to();
printf("Wait...\n");
Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetLoc, static_cast<uint8_t>(0x0), static_cast<uint8_t>(0x09), static_cast<uint8_t>(0x0));
printf("Done!\n");
Command::send<CD_IO::PortIndex0>(CD_IO::Command::Play);
table_of_tables.processes->current_tcb = &table_of_tables.threads[0];
SysCall::ReturnFromException();
}, &stack[1023], SysCall::get_gp());
SysCall::ExitCriticalSection();
table_of_tables.threads[thread&0xFFFF].sr = table_of_tables.threads[0].sr;
printf(">>> 0x%X\n", table_of_tables.threads[0].sr);
}
Command::wait_completed();
CD_IO::PortIndex0::change_to();
Command::send_wait<CD_IO::PortIndex0>(CD_IO::Command::SetMode, AudioSectorMode);

4
src/Library/src/GPU/gpu.cpp
View File

@ -1,4 +1,5 @@
#include "../../internal-include/GPU/gpu_internal.hpp"
#include "../../internal-include/System/callbacks_internal.hpp"
#include <PSX/Timer/frame_timer.hpp>
#include <PSX/System/IOPorts/interrupt_io.hpp>
#include <PSX/System/syscalls.hpp>
@ -40,8 +41,7 @@ namespace JabyEngine {
MasterTime::value++;
Interrupt::ack_irq(Interrupt::VBlank);
SysCall::ReturnFromException();
__builtin_unreachable();
Callback::internal::VSync::execute();
}
uint32_t Display :: exchange_buffer_and_display() {

26
src/Library/src/System/callbacks.cpp Normal file
View File

@ -0,0 +1,26 @@
#include "../../internal-include/System/callbacks_internal.hpp"
#include <PSX/System/callbacks.hpp>
#include <stdio.hpp>
namespace JabyEngine {
namespace Callback {
VSyncCallback::Function VSyncCallback :: callback = nullptr;
namespace internal {
namespace VSync {
SysCall::ThreadHandle thread_handle = 0;
uint32_t stack[StackSize] = {0};
void routine() {
while(true) {
if(VSyncCallback::callback) {
VSyncCallback::callback();
}
MainThread::restore();
}
}
}
}
}
}