Redacted/ReWindow
2
1
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases 69 Wiki Activity

Further cleanup (Not stable), WIP RenderingAPI refactor, WIP windows fixes.
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled
Details

Browse Source
This commit is contained in:
josh
2024-12-06 15:22:04 -05:00
parent 2d9f7e08b0
commit 1950aee948
6 changed files with 149 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/rewindow/logger/logger.h
View File

@@ -4,7 +4,11 @@
namespace ReWindow::Logger {
using namespace jlog;
using Logger = GenericLogger;
extern GenericLogger Fatal;
extern GenericLogger Debug;
extern Logger Info;
extern Logger Fatal;
extern Logger Error;
extern Logger Warning;
extern Logger Debug;
}

110
include/rewindow/types/window.h
View File

@@ -11,6 +11,7 @@
#include <J3ML/LinearAlgebra.hpp>
#include <rewindow/types/WindowEvents.hpp>
#include <format>
#include <queue>
enum class RWindowFlags: uint8_t {
@@ -99,25 +100,48 @@ namespace ReWindow
}
};
class IRenderer {
public:
virtual void Initialize();
virtual void SwapBuffers();
virtual std::string GetDriverVendor();
virtual void SetVsync(bool enabled);
virtual void SetViewportSize(int width, int height);
virtual void MakeCurrent();
};
class VulkanRenderBase : public IRenderer {};
class GLRenderBase : public IRenderer {};
class GLXRenderer : public GLRenderBase {};
class WGLRenderer : public GLRenderBase {};
// TODO: Refactor RenderingAPI into a polymorphic class interface for greater reusability.
/// RWindow is a class implementation of a platform-independent window abstraction.
/// This library also provides abstractions for user-input devices, and their interaction with the window.
class RWindow {
public:
#pragma region Constructors
/// The default constructor sets a default size and window title.
RWindow();
/// Constructs a window by explicitly setting title, width and height.
RWindow(const std::string& title, int width, int height);
/// The default constructor does not set any members, and are left uninitialized.
RWindow() = default;
/// Constructs a window by explicitly setting the title, width, height, and optionally; rendering API, fullscreen, resizable, and vsync.
/// @param wTitle The window title text.
/// @param wWidth
/// @param wHeight
/// @param wRenderer
/// @param wFullscreen
/// @param wResizable
/// @param wVsync
explicit RWindow(const std::string& wTitle, int wWidth = 640, int wHeight = 480,
RenderingAPI wRenderer = RenderingAPI::OPENGL,
bool wFullscreen = false,
bool wResizable = true,
bool wVsync = false);
/// Constructs a window as above with the additional argument of explicitly setting which render API is to be used.
RWindow(const std::string& title, int width, int height, RenderingAPI renderer);
/// The destructor deallocates and cleans up any memory used by the RWindow program.
~RWindow() {
if (open)
DestroyOSWindowHandle();
}
/// @note If the window handle is not already destroyed, it will be done here.
~RWindow();
#pragma endregion
@@ -342,6 +366,12 @@ namespace ReWindow
/// Returns the number of frames ran since the windows' creation.
[[nodiscard]] float GetRefreshCounter() const;
protected:
void LogEvent(const RWindowEvent& e) { eventLog.push_back(e);}
//void EnqueueEvent(const RWindowEvent& e) { eventQueue.push(e);}
RWindowEvent GetLastEvent() const {
return eventLog.back();
}
/// Requests the operating system to make the window fullscreen. Saves the previous window size as well.
void Fullscreen();
@@ -350,48 +380,44 @@ namespace ReWindow
protected:
#pragma region Data
// Is the underlying OS-Window-Handle actually open.
int width = 1280;
int height = 720;
bool open = false; // Is the underlying OS-Window-Handle actually open.
bool resizable = true;
bool fullscreen_mode = false;
bool focused = true;
bool vsync = false;
bool cursor_visible = true;
bool closing = false;
float delta_time = 0.f;
float refresh_rate = 0.f;
unsigned int refresh_count = 0;
bool open = false;
std::string title = "Redacted Window";
int width = 1280;
int height = 720;
bool fullscreen_mode = false;
bool focused = true;
bool vsync = false;
bool cursor_visible = true;
bool closing = false;
bool resizable = true;
Vector2 lastKnownWindowSize {0, 0};
bool flags[5];
std::vector<RWindowEvent> eventLog;
KeyboardState currentKeyboard; // Current Frame's Keyboard State
KeyboardState previousKeyboard; // Previous Frame's Keyboard State
MouseState currentMouse;
MouseState previousMouse;
std::vector<RWindowEvent> eventLog; // history of all logged window events.
std::queue<RWindowEvent> eventQueue; //
KeyboardState currentKeyboard; // current frame keyboard state.
KeyboardState previousKeyboard; // previous frame keyboard state.
MouseState currentMouse; // purrent frame mouse state.
MouseState previousMouse; // previous frame mouse state
RenderingAPI renderer = RenderingAPI::OPENGL;
//Vector2 mouse_coords = {0, 0};
//Vector2 last_mouse_coords = {0, 0};
// TODO: Implement ringbuffer / circular vector class of some sort.
float refresh_rate_prev_1 = 0.f;
float refresh_rate_prev_2 = 0.f;
float refresh_rate_prev_3 = 0.f;
float refresh_rate_prev_4 = 0.f;
float refresh_rate_prev_5 = 0.f;
float delta_time = 0.f;
float refresh_rate = 0.f;
unsigned int refresh_count = 0;
// TODO: Implement ringbuffer / circular vector class of some sort.
float refresh_rate_prev_1 = 0.f;
float refresh_rate_prev_2 = 0.f;
float refresh_rate_prev_3 = 0.f;
float refresh_rate_prev_4 = 0.f;
float refresh_rate_prev_5 = 0.f;
float avg_refresh_rate = 0.0f;
float avg_refresh_rate = 0.0f;
#pragma endregion
#pragma region Internals
/// Returns the most accurate and recent available mouse coordinates.

6
main.cpp
View File

@@ -61,19 +61,19 @@ class MyWindow : public ReWindow::RWindow {
}
bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {
std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
//std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
return true;
}
void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent &e) override
{
std::cout << "Overload Down: " << e.Button.Mnemonic << std::endl;
//std::cout << "Overload Down: " << e.Button.Mnemonic << std::endl;
RWindow::OnMouseButtonDown(e);
}
void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override
{
std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
//std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
RWindow::OnMouseButtonUp(e);
}
};

8
src/logger/logger.cpp
View File

@@ -2,6 +2,10 @@
namespace ReWindow::Logger {
using namespace jlog;
GenericLogger Fatal {"ReWindow::fatal", GlobalLogFile, Colors::Reds::Crimson, Colors::Gray, Colors::Gray, Colors::Reds::Crimson, Colors::White};
GenericLogger Debug {"ReWindow::debug", GlobalLogFile, Colors::Purples::Purple, Colors::Gray, Colors::Gray, Colors::Purples::Purple, Colors::White};
using namespace Colors;
using Logger = GenericLogger;
Logger Info {"ReWindow", GlobalLogFile, Gray, Gray, Gray, Gray};
Logger Fatal {"ReWindow::fatal", GlobalLogFile, Reds::Crimson, Gray, Gray, Reds::Crimson, White};
Logger Debug {"ReWindow::debug", GlobalLogFile, Purples::Purple, Gray, Gray, Purples::Purple, White};
}

31
src/platform/linux/window.cpp
View File

@@ -119,14 +119,14 @@ void RWindow::PollEvents() {
XNextEvent(display, &xev);
if (xev.type == ClientMessage)
Logger::Debug(std::format("Recieved event '{}'", "ClientMessage"));
Logger::Info(std::format("Event '{}'", "ClientMessage"));
if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) && static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
Close();
}
if (xev.type == FocusIn) {
Logger::Debug(std::format("Recieved event '{}'", "FocusIn"));
Logger::Debug(std::format("Event'{}'", "FocusIn"));
XAutoRepeatOff(display);
SetFlag(RWindowFlags::IN_FOCUS, true);
@@ -140,7 +140,7 @@ void RWindow::PollEvents() {
}
if (xev.type == FocusOut) {
Logger::Debug(std::format("Recieved event '{}'", "FocusOut"));
Logger::Debug(std::format("Event '{}'", "FocusOut"));
XAutoRepeatOn(display);
SetFlag(RWindowFlags::IN_FOCUS, false);
@@ -151,14 +151,14 @@ void RWindow::PollEvents() {
}
if (xev.type == KeyRelease) {
Logger::Debug(std::format("Recieved event '{}'", "KeyRelease"));
Logger::Debug(std::format("Event '{}'", "KeyRelease"));
auto scancode = (X11Scancode) xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyRelease(key);
}
if (xev.type == KeyPress) {
Logger::Debug(std::format("Recieved event '{}'", "KeyPress"));
Logger::Debug(std::format("Event '{}'", "KeyPress"));
auto scancode = (X11Scancode) xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyPress(key);
@@ -171,7 +171,7 @@ void RWindow::PollEvents() {
// and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
if (xev.xbutton.button != 4 && xev.xbutton.button != 5) {
MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
Logger::Debug(std::format("Recieved event '{}'", "ButtonRelease"));
Logger::Debug(std::format("Event '{}'", "ButtonRelease"));
processMouseRelease(button);
}
}
@@ -189,7 +189,7 @@ void RWindow::PollEvents() {
{
MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
Logger::Debug(std::format("Window event: MouseButtonPress {}", button.Mnemonic));
Logger::Debug(std::format("Event: MouseButtonPress {}", button.Mnemonic));
processMousePress(button);
}
@@ -197,18 +197,18 @@ void RWindow::PollEvents() {
if (xev.type == Expose)
{
Logger::Debug(std::format("Recieved event '{}'", "Expose"));
Logger::Debug(std::format("Event '{}'", "Expose"));
}
// NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.
if (xev.type == MotionNotify)
{
Logger::Debug(std::format("Recieved event '{}'", "MotionNotify"));
Logger::Debug(std::format("Event '{}'", "MotionNotify"));
}
if (xev.type == ConfigureNotify) {
if (this->width != xev.xconfigurerequest.width || this->height != xev.xconfigurerequest.height) {
Logger::Debug(std::format("Recieved event '{}'", "ResizeRequest"));
Logger::Debug(std::format("Event '{}'", "ResizeRequest"));
this->width = xev.xconfigurerequest.width;
this->height = xev.xconfigurerequest.height;
@@ -240,7 +240,7 @@ void RWindow::SetSize(int newWidth, int newHeight) {
this->height = newHeight;
XResizeWindow(display, window, newWidth, newHeight);
XFlush(display);
Logger::Debug(std::format("Set size for window '{}'. width={} height={}", this->title, newWidth, newHeight));
Logger::Info(std::format("Set size for '{}' to {} x {}", this->title, newWidth, newHeight));
}
Vector2 RWindow::GetAccurateMouseCoordinates() const {
@@ -292,9 +292,8 @@ void RWindow::GLSwapBuffers() {
}
void RWindow::Fullscreen() {
Logger::Debug(std::format("Fullscreening window '{}'", this->title));
Logger::Info(std::format("Fullscreening '{}'", this->title));
fullscreen_mode = true;
XEvent xev;
@@ -311,11 +310,11 @@ void RWindow::Fullscreen() {
xev.xclient.data.l[1] = fullscreen_mode;
xev.xclient.data.l[2] = 0;
XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
Logger::Debug(std::format("Fullscreened window '{}'", this->title));
Logger::Debug(std::format("Fullscreened '{}'", this->title));
}
void RWindow::RestoreFromFullscreen() {
Logger::Debug(std::format("Restoring window '{}' from Fullscreen", this->title));
Logger::Debug(std::format("Restoring '{}' from Fullscreen", this->title));
fullscreen_mode = false;
XEvent xev;
Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
@@ -329,7 +328,7 @@ void RWindow::RestoreFromFullscreen() {
xev.xclient.data.l[1] = fullscreen_mode;
xev.xclient.data.l[2] = 0;
XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
Logger::Debug(std::format("Restored window '{}' from Fullscreen", this->title));
Logger::Debug(std::format("Restored '{}' from Fullscreen", this->title));
}
void RWindow::SetVsyncEnabled(bool b) {

90
src/platform/shared/window.cpp
View File

@@ -15,22 +15,18 @@ std::string RWindowFlagToStr(RWindowFlags flag) {
using namespace ReWindow;
RWindow::RWindow() {
title = "ReWindow Application";
width = 640;
height = 480;
//RWindow::singleton = this;
RWindow::RWindow(const std::string& wTitle, int wWidth, int wHeight, RenderingAPI wRenderer, bool wFullscreen, bool wResizable, bool wVsync)
: title(wTitle), width(wWidth), height(wHeight), renderer(wRenderer), fullscreen_mode(wFullscreen), resizable(wResizable), vsync(wVsync),
flags{false,wFullscreen,wResizable,wVsync} {
}
RWindow::RWindow(const std::string& title, int width, int height) : flags{false,false,false,false} {
this->title = title;
this->width = width;
this->height = height;
//RWindow::singleton = this;
RWindow::~RWindow() {
if (open)
DestroyOSWindowHandle();
}
RWindow::RWindow(const std::string& title, int width, int height, RenderingAPI renderer) :
title(title), width(width), height(height), renderer(renderer) {}
Vector2 RWindow::GetMouseCoordinates() const {
return currentMouse.Position;
@@ -51,11 +47,13 @@ void RWindow::SetFullscreen(bool fs) {
RestoreFromFullscreen();
}
#pragma region Event Processors Implementation
void RWindow::processFocusIn()
{
RWindowEvent event {};
OnFocusGain(event);
OnFocusGainEvent(event);
LogEvent(event);
}
void RWindow::processFocusOut()
@@ -63,31 +61,35 @@ void RWindow::processFocusOut()
RWindowEvent event {};
OnFocusLost(event);
OnFocusLostEvent(event);
LogEvent(event);
}
void RWindow::processMousePress(const MouseButton& btn)
{
currentMouse.Set(btn, true);
auto eventData = MouseButtonDownEvent(btn);
OnMouseButtonDown(eventData);
OnMouseButtonDownEvent(eventData);
auto event = MouseButtonDownEvent(btn);
OnMouseButtonDown(event);
OnMouseButtonDownEvent(event);
LogEvent(event);
}
void RWindow::processMouseMove(Vector2 last_pos, Vector2 new_pos)
{
currentMouse.Position = new_pos;
auto eventData = MouseMoveEvent(new_pos);
OnMouseMove(eventData);
OnMouseMoveEvent(eventData);
auto event = MouseMoveEvent(new_pos);
OnMouseMove(event);
OnMouseMoveEvent(event);
LogEvent(event);
}
void RWindow::processMouseRelease(const MouseButton& btn)
{
currentMouse.Set(btn, false);
auto eventData = MouseButtonUpEvent(btn);
OnMouseButtonUp(eventData);
OnMouseButtonUpEvent(eventData);
auto event = MouseButtonUpEvent(btn);
OnMouseButtonUp(event);
OnMouseButtonUpEvent(event);
LogEvent(event);
}
@@ -96,8 +98,34 @@ void RWindow::processKeyRelease(Key key) {
auto event = KeyUpEvent(key);
OnKeyUp(event);
OnKeyUpEvent(key);
LogEvent(event);
}
void RWindow::processKeyPress(Key key) {
currentKeyboard.PressedKeys[key] = true;
auto event = KeyDownEvent(key);
OnKeyDown(event);
OnKeyDownEvent(key);
LogEvent(event);
}
void RWindow::processOnClose()
{
auto event = RWindowEvent();
OnClosing();
OnClosingEvent();
LogEvent(event);
}
void RWindow::processOnOpen()
{
auto event = RWindowEvent();
OnOpen();
OnOpenEvent();
LogEvent(event);
}
#pragma endregion
std::string RWindow::GetTitle() const {
return this->title;
@@ -151,24 +179,6 @@ bool RWindow::IsMouseButtonDown(const MouseButton &button) const {
return currentMouse.IsDown(button);
}
void RWindow::processKeyPress(Key key) {
currentKeyboard.PressedKeys[key] = true;
auto eventData = KeyDownEvent(key);
OnKeyDown(eventData);
OnKeyDownEvent(key);
}
void RWindow::processOnClose()
{
OnClosing();
OnClosingEvent();
}
void RWindow::processOnOpen()
{
OnOpen();
OnOpenEvent();
}
void RWindow::ManagedRefresh()
{
@@ -267,3 +277,5 @@ bool RWindow::IsFocused() const {
exit(0);
}