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

Introduce new timer based on vsync

This commit is contained in:
Jaby Blubb 2023-08-27 21:29:43 +02:00
parent ac4d788c4c
commit e707fae349
6 changed files with 129 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
examples/PoolBox/application/src/main.cpp
View File

@ -2,23 +2,40 @@
#include "assets.hpp"
#include <PSX/GPU/gpu_primitives.hpp>
#include <PSX/GPU/gpu.hpp>
#include <PSX/Timer/frame_timer.hpp>
#include <stdio.h>
using namespace JabyEngine;
static SimpleTimer<uint8_t> timer;
static void setup() {
Assets::load_for_main();
FontWriter::setup();
timer.reset();
}
static void update() {
const auto end_pos = FontWriter::write({0, 32}, "Cody is cute\n&\na \x1b[8;0;0mBAAAAABY!!!");
FontWriter::write(end_pos, "\x1b[0;7;7mJaby was\nhere c:");
if(timer.is_expired_for(1000_ms)) {
printf("Dino\n");
timer.reset();
}
}
static void render() {
GPU::swap_buffers_vsync(1);
FontWriter::render();
}
void main() {
setup();
while(true) {
const auto end_pos = FontWriter::write({0, 32}, "Cody is cute\n&\na \x1b[8;0;0mBAAAAABY!!!");
FontWriter::write(end_pos, "\x1b[0;7;7mJaby was\nhere c:");
GPU::swap_buffers_vsync(1);
FontWriter::render();
update();
render();
}
}

2
include/PSX/GPU/gpu.hpp
View File

@ -18,9 +18,11 @@ namespace JabyEngine {
#ifdef JABYENGINE_PAL
static constexpr size_t Width = 320;
static constexpr size_t Height = 256;
static constexpr uint32_t frames_per_sec = 50;
#else
static constexpr size_t Width = 320;
static constexpr size_t Height = 240;
static constexpr uint32_t frames_per_sec = 50;
#endif
static uint8_t current_id;

25
include/PSX/Timer/frame_time_helper.hpp Normal file
View File

@ -0,0 +1,25 @@
#ifndef __JABYENGINE_FRAME_TIME_HELPER_HPP__
#define __JABYENGINE_FRAME_TIME_HELPER_HPP__
#include <PSX/GPU/gpu.hpp>
#include <limits.h>
namespace JabyEngine {
static constexpr double ms_per_frame = 1000.0/static_cast<double>(GPU::Display::frames_per_sec);
template<typename T>
static constexpr T ms_to_vsync_ticks(T time_ms) {
return static_cast<T>(static_cast<double>(time_ms)/ms_per_frame);
}
static constexpr uint32_t operator ""_ms(unsigned long long time) {
return static_cast<uint32_t>(ms_to_vsync_ticks(time));
}
static constexpr size_t max_ms_time_u8 = UI8_MAX*ms_per_frame;
static constexpr size_t max_ms_time_u16 = UI16_MAX*ms_per_frame;
static constexpr size_t max_ms_time_u32 = UI32_MAX;
#undef literal_operator_template
}
using JabyEngine::operator""_ms;
#endif //!__JABYENGINE_FRAME_TIME_HELPER_HPP__

59
include/PSX/Timer/frame_timer.hpp Normal file
View File

@ -0,0 +1,59 @@
#ifndef __JABYENGINE_FRAME_TIMER_HPP__
#define __JABYENGINE_FRAME_TIMER_HPP__
#include "frame_time_helper.hpp"
#include <stdint.h>
namespace JabyEngine {
class MasterTime {
private:
static uint32_t value;
public:
static uint32_t read() {
return reinterpret_cast<volatile uint32_t&>(MasterTime::value);
}
template<typename T>
static T read_as() {
return static_cast<T>(MasterTime::read());
}
};
template<typename T>
class SimpleTimer {
protected:
T value = 0;
public:
constexpr SimpleTimer() = default;
bool is_expired_for(T time) const {
return static_cast<T>((MasterTime::read_as<T>() - this->value)) >= time;
}
void reset() {
this->value = MasterTime::read_as<T>();
}
};
template<typename T>
class IntervalTimer : public SimpleTimer<T> {
private:
T interval = 0;
public:
constexpr IntervalTimer() = default;
constexpr IntervalTimer(T interval) : SimpleTimer<T>(), interval(interval) {
}
void set_interval(T interval) {
this->interval = interval;
}
bool is_expired() const {
return SimpleTimer<T>::is_expired_for(this->interval);
}
};
}
#endif //!__JABYENGINE_FRAME_TIMER_HPP__

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

@ -1,4 +1,8 @@
#include "../../internal-include/GPU/gpu_internal.hpp"
// We need to access the master time
#define private public
#include <PSX/Timer/frame_timer.hpp>
#undef private
#include <PSX/System/IOPorts/interrupt_io.hpp>
#include <PSX/System/syscalls.h>
@ -7,11 +11,11 @@ namespace JabyEngine {
uint8_t Display :: current_id = 1; //< Setup will call exchange and set it to 0
namespace internal {
static uint8_t vsync_count = 0;
static InterruptVerifierResult interrupt_verifier();
static void interrupt_handler(uint32_t);
static uint8_t vsync_counter = 0;
InterrupCallback callback = {
.next = nullptr,
.handler_function = reinterpret_cast<InterruptHandler>(interrupt_handler),
@ -29,9 +33,8 @@ namespace JabyEngine {
}
static void interrupt_handler(uint32_t) {
if(vsync_count != 0xFF) {
vsync_count++;
}
vsync_counter++;
MasterTime::value++;
Interrupt::ack_irq(Interrupt::VBlank);
__syscall_ReturnFromException();
@ -47,14 +50,10 @@ namespace JabyEngine {
}
void wait_vsync(uint8_t syncs) {
volatile uint8_t& vsync_count = reinterpret_cast<volatile uint8_t&>(internal::vsync_count);
volatile auto& vsync_count = reinterpret_cast<volatile uint8_t&>(vsync_counter);
const uint8_t dst_value = vsync_count + syncs;
if(internal::vsync_count >= syncs) {
syncs = internal::vsync_count + 1;
}
while(vsync_count < syncs);
vsync_count = 0;
while(vsync_count != dst_value);
}
void render(const uint32_t* data, size_t words) {

5
src/Library/src/Timer/frame_timer.cpp Normal file
View File

@ -0,0 +1,5 @@
#include <PSX/Timer/frame_timer.hpp>
namespace JabyEngine {
uint32_t MasterTime :: value = 0;
}