Compare commits

..

22 Commits

Author SHA1 Message Date
4f1140b217 Total overhaul
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m27s
2024-12-17 19:12:18 -05:00
dd4b7b7d29 Close either window now
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m41s
2024-12-17 15:16:27 -05:00
a68ced6874 More things
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m37s
2024-12-17 15:14:22 -05:00
d5a08ecea2 More things
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m32s
2024-12-17 15:11:30 -05:00
df32610007 More things
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 7m11s
2024-12-17 13:12:45 -05:00
921f2118e8 Fix double free
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 3m43s
2024-12-17 11:58:20 -05:00
780fd8308a Found double free isue
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 6m51s
2024-12-16 12:40:11 -05:00
20b6f1041f Got most of RWindow refactored. Had to hack the fuck out of it to test it.
All checks were successful
Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m38s
2024-12-13 17:09:24 -05:00
94960e0433 Getting started on platform specific stuff
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m32s
2024-12-13 15:38:18 -05:00
2a63ad8054 More Pimpl work
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m39s
2024-12-13 14:40:04 -05:00
cbfce17d44 More Pimpl work
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m32s
2024-12-13 14:37:27 -05:00
1f17244662 More Pimpl work
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m54s
2024-12-13 13:18:48 -05:00
5ff4fb2a73 Began Pimpl rewrite of RWindow
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m28s
2024-12-11 16:26:54 -05:00
30f20394c8 Create RenderEngine
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 4m55s
2024-12-09 15:05:20 -05:00
4264f008c2 Create WindowHandler
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m25s
2024-12-08 15:33:18 -05:00
4ab07d97e3 Create WindowEvents
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m38s
2024-12-08 14:53:49 -05:00
cb5222e476 Create WindowProperties
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m33s
2024-12-08 14:14:48 -05:00
e0c001b1f1 Critiques
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m26s
2024-12-07 19:03:03 -05:00
fdde8486f7 Remove garbonk. This is being refactored
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m51s
2024-12-07 18:34:17 -05:00
51e3787d38 Starting refactor
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled
2024-12-07 18:33:08 -05:00
66c3ebb9da Fix IsMouseButtonDown infinite loop
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled
2024-12-07 18:32:13 -05:00
2a2293842a Fix IsMouseButtonDown infinite loop
Some checks failed
Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled
2024-12-07 18:30:34 -05:00
47 changed files with 2280 additions and 2532 deletions

View File

@@ -17,7 +17,7 @@ jobs:
- run: echo "The ${{ gitea.repository }} repository has been cloned to the runner."
- run: echo "The workflow is now ready to run your tests on the runner."
- run: echo "Install toolchain and run ReCI build test"
- run: apt-get update && apt-get install -y lua5.3 git libxrandr-dev libvulkan-dev && git clone $RECI_GIT $RECI
- run: apt-get update && apt-get install -y lua5.3 git libxrandr-dev && git clone $RECI_GIT $RECI
- run: lua $RECI/reci.lua -f $RECI/scripts/buildtools.reci -f reci/scripts/builddeps.reci -f $RECI/scripts/buildtest.reci
- run: echo this exists so I can run the reci test
- run: echo "This job's status is ${{ job.status }}."

View File

@@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.18..3.27)
project(ReWindow
project(ReWindowLibrary
VERSION 1.0
LANGUAGES CXX
)
@@ -16,6 +16,11 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
# Enable Package Managers
include(cmake/CPM.cmake)
CPMAddPackage(
NAME J3ML
URL https://git.redacted.cc/josh/j3ml/archive/Release-3.2.zip
)
CPMAddPackage(
NAME Event
URL https://git.redacted.cc/josh/Event/archive/Release-12.zip
@@ -26,16 +31,8 @@ CPMAddPackage(
URL https://git.redacted.cc/josh/jlog/archive/Prerelease-16.zip
)
#TODO dlopen these at runtime so if one isn't supported the program still works.
if (UNIX AND NOT APPLE)
include_directories(${Vulkan_INCLUDE_DIR})
endif()
if (WIN32)
include_directories(${VULKAN_SDK}/Include)
endif()
find_package(OpenGL REQUIRED)
include_directories(${OPENGL_INCLUDE_DIRS})
include_directories(${J3ML_SOURCE_DIR}/include)
include_directories(${jlog_SOURCE_DIR}/include)
@@ -45,38 +42,40 @@ file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")
file(GLOB_RECURSE HEADERS "include/logger/*.h" "include/logger/*.hpp")
if(UNIX AND NOT APPLE)
file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/linux/*.cpp" "src/platform/shared/*.cpp" "src/ReWindow/*.cpp" )
file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/linux/*.cpp" "src/platform/shared/*.cpp" "src/logger/*.cpp" )
endif()
if(WIN32)
file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp" "src/ReWindow/*.cpp")
file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp" "src/logger/*.cpp")
endif()
include_directories("include")
if(UNIX)
add_library(ReWindow SHARED ${SOURCES})
add_library(ReWindowLibrary SHARED ${SOURCES})
endif()
if(WIN32)
add_library(ReWindow STATIC ${SOURCES})
add_library(ReWindowLibrary STATIC ${SOURCES})
endif()
target_include_directories(ReWindow PUBLIC ${Event_SOURCE_DIR}/include)
target_include_directories(ReWindowLibrary PUBLIC ${Event_SOURCE_DIR}/include)
# Why god???
set_target_properties(ReWindow PROPERTIES LINKER_LANGUAGE CXX)
set_target_properties(ReWindowLibrary PROPERTIES LINKER_LANGUAGE CXX)
if(UNIX AND NOT APPLE)
target_link_libraries(ReWindow PUBLIC X11 Event jlog)
target_link_libraries(ReWindow PUBLIC)
add_executable(ReWindowDemo main.cpp)
target_link_libraries(ReWindowDemo PUBLIC ReWindow)
target_link_libraries(ReWindowLibrary PUBLIC X11 Xrandr J3ML Event jlog ${OPENGL_LIBRARIES})
target_link_libraries(ReWindowLibrary PUBLIC)
add_executable(ReWindowLibraryDemo main.cpp)
target_link_libraries(ReWindowLibraryDemo PUBLIC ReWindowLibrary)
endif()
if(WIN32)
target_compile_options(ReWindow PUBLIC /utf-8)
target_link_libraries(ReWindow PUBLIC Event jlog)
add_executable(ReWindowDemo main.cpp)
target_link_libraries(ReWindowDemo PUBLIC ReWindow)
target_compile_options(ReWindowLibrary PUBLIC /utf-8)
target_link_libraries(ReWindowLibrary PUBLIC J3ML Event jlog ${OPENGL_LIBRARIES})
add_executable(ReWindowLibraryDemo main.cpp)
target_link_libraries(ReWindowLibraryDemo PUBLIC ReWindowLibrary)
endif()

View File

@@ -1,48 +1,34 @@
# ReWindow
[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)
A library which allows easily creating and managing a window and it's events across multiple platforms *primarily for games*.
## Features
- Window Creation - Create multiple windows at once. Windows can also create so-called `message-boxes`, which are technically windows too.
- Window Management - Change the state of the window, title, size, fullscreen mode, v-sync, and more.
- Window Events - Callback function hooks for reading user-input and window state events, such as exit, focus, etc.
- State of the Art C++20
- Supported Platforms: X11 on Linux, Windows
- Builds on ARM.
- One API supports all platforms.
- Supports OpenGL, Vulkan, Software Rendering(?)
- Public Domain.
- Lightweight AF.
- Painless integration with \<your favorite graphics API\>. (Ours is JGL!)
- Straightforward, well-documented source code and API.
- Packaged with InputService as a built-in, portable input API.
## Run Demo
Install dependencies
```bash
Fedora/RHEL: dnf install cmake make gcc-g++ libX11 libX11-devel mesa-libGL-devel vulkan-loader-devel
Ubuntu/Debian: apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev libvulkan-dev libxrandr-dev
```
Clone the repository
```bash
git clone https://git.redacted.cc/Redacted/ReWindow.git
```
Build
```bash
cd ReWindow && mkdir build && cd build && cmake .. && make
```
Run it
```bash
./ReWindowDemo
```
# ReWindow
[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)
A library which allows easily creating and managing a window and it's events across multiple platforms *primarily for games*.
## Run Demo
Install dependencies
```bash
Fedora/RHEL: dnf install cmake make gcc-g++ libX11 libX11-devel mesa-libGL-devel
Ubuntu/Debian: apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev libxrandr-dev
```
Clone the repository
```bash
git clone https://git.redacted.cc/Redacted/ReWindow.git
```
Build
```bash
cd ReWindow && mkdir build && cd build && cmake .. && make
```
Run it
```bash
./ReWindowDemo
```

View File

@@ -1,10 +0,0 @@
#pragma once
/// X11 Clipboard API looked unhinged. So fuck it, use this system for now.
namespace ClipboardService
{
std::string GetClipboard(int historyIndex = 0);
void SetClipboard(const std::string& str, bool overwrites_last = false);
unsigned int GetClipboardHistorySize();
unsigned int GetClipboardHistoryMax();
}

View File

@@ -0,0 +1,39 @@
#pragma once
#include <vector>
#include "J3ML/J3ML.hpp"
namespace ReWindow {
class FullscreenGraphicsMode;
class Display;
}
///A given graphics mode that a display supports.
///Upon startup, We'll poll the display server for this.
class ReWindow::FullscreenGraphicsMode {
private:
u32 width;
u32 height;
short refresh_rate;
public:
FullscreenGraphicsMode() = default;
FullscreenGraphicsMode(u32 width, u32 height, short refresh_rate);
[[nodiscard]] u32 getWidth() const;
[[nodiscard]] u32 getHeight() const;
[[nodiscard]] float getRefreshRate() const;
};
///Refers to a particular monitor the user has.
class ReWindow::Display {
private:
///* The graphics mode of the display when our program was started. The primary use for this
///* is so that if the user has selected a different mode in-game we can restore the old mode upon exit. *///
FullscreenGraphicsMode default_graphics_mode{};
///All graphics modes that a given display supports.
std::vector<FullscreenGraphicsMode> graphics_modes;
public:
Display() = default;
Display(const FullscreenGraphicsMode& default_graphics_mode, const std::vector<FullscreenGraphicsMode>& graphics_modes);
FullscreenGraphicsMode getDefaultGraphicsMode();
std::vector<FullscreenGraphicsMode> getGraphicsModes();
static std::vector<Display> getDisplaysFromWindowManager();
};

View File

@@ -0,0 +1,32 @@
/// ReWindowLibrary
/// A C++20 Library for creating and managing windows in a platform-independent manner
/// Developed and Maintained by the boys @ Redacted Software.
/// (c) 2024 Redacted Software
/// This work is dedicated to the public domain.
/// @file gamepad.h
/// @desc A class that models the functionality of a gamepad / controller device.
/// @edit 2024-07-29
#pragma once
namespace ReWindow {
class GamepadState {
public:
std::map<GamepadButton, bool> PressedButtons;
};
class Gamepad;
class Xbox360Gamepad;
class XboxOneGamepad;
class PS4Gamepad;
class Ultimate8BitDoPro2Gamepad;
}
class ReWindow::Gamepad {
public:
virtual ~Gamepad() = default;
};
class ReWindow::XboxOneGamepad : public Gamepad {};
class ReWindow::PS4Gamepad : public Gamepad {};

View File

@@ -0,0 +1,109 @@
/// ReWindowLibrary
/// A C++20 Library for creating and managing windows in a platform-independent manner
/// Developed and Maintained by the boys @ Redacted Software.
/// (c) 2024 Redacted Software
/// This work is dedicated to the public domain.
/// @file gamepadbutton.h
/// @desc GamepadButton class and enumerations to define standard buttons found on a Gamepad
/// @edit 2024-07-29
#include <string>
#include <utility>
#include "J3ML/LinearAlgebra.hpp"
namespace ReWindow {
class GamepadButton;
class GamepadTrigger;
class GamepadThumbstick;
}
class ReWindow::GamepadButton {
protected:
std::string mnemonic_btn_code;
public:
explicit GamepadButton(std::string mnemonic) : mnemonic_btn_code(std::move(mnemonic)){}
[[nodiscard]] std::string GetMnemonicButtonCode() const;
/// Compares two GamepadButtons by their mnemonic button codes, not their activation state.
bool operator ==(const GamepadButton& rhs) const;
};
class ReWindow::GamepadTrigger {
protected:
std::string mnemonic_trigger_code;
/// A float value between 0 and 1 representing how much the trigger has been pushed in by.
float position = 0.0f;
/// The minimum possible movement of the trigger from the at-rest position.
/// Movements less than this won't count.
float dead_zone = 0.0f;
public:
void SetDeadzone(float minimum = 0.01f);
[[nodiscard]] float GetActuation() const;
public:
explicit GamepadTrigger(std::string mnemonic) : mnemonic_trigger_code(std::move(mnemonic)){}
};
class ReWindow::GamepadThumbstick {
protected:
std::string mnemonic_stick_code;
// X -1 is all the way left, X +1 is all the way right.
// Y -1 is all the way down, Y +1 is all the way up.
Vector2 position = {0.0f, 0.0f};
// The minimum possible movement from the center in any direction.
float dead_zone = 0.0f;
public:
[[nodiscard]] Vector2 GetPosition() const;
void SetDeadzone(float minimum = 0.01f);
public:
explicit GamepadThumbstick(std::string mnemonic) : mnemonic_stick_code(std::move(mnemonic)){}
};
using J3ML::LinearAlgebra::Vector2;
namespace ReWindow::GamepadButtons {
static const GamepadButton Triangle("");
static const GamepadButton Square("");
static const GamepadButton Circle("");
static const GamepadButton Cross("X");
// If you like xbox :shrug:
static const GamepadButton Y = Triangle;
static const GamepadButton X = Square;
static const GamepadButton A = Cross;
static const GamepadButton B = Circle;
static const GamepadButton LButton("LB");
static const GamepadButton RButton("RB");
/* For controllers where L2 & R2 is a button or counts as one when pressed all the way down.
* Gamecube & PS2 controllers do this. - Redacted. */
static const GamepadButton LButton2("LB2");
static const GamepadButton RButton2("RB2");
// The buttons when you press in the sticks.
static const GamepadButton LButton3("LB3");
static const GamepadButton RButton3("RB3");
// Will eventually need to handle making it not possible to, for ex. Press left and right at the same time.
static const GamepadButton DPadUp("DPU");
static const GamepadButton DPadDown("DPD");
static const GamepadButton DPadLeft("DPL");
static const GamepadButton DPadRight("DPR");
static const GamepadButton Select("SEL");
static const GamepadButton Start("START");
}
namespace ReWindow::GamepadTriggers {
static const ReWindow::GamepadTrigger Left {"LT"};
static const ReWindow::GamepadTrigger Right {"RT"};
}
namespace ReWindow::GamepadThumbsticks {
static const GamepadThumbstick Left {"LS"};
static const GamepadThumbstick Right {"RS"};
}

View File

@@ -1,23 +0,0 @@
#pragma once
#include <Event.h>
#include <ReWindow/types/WindowEvents.h>
namespace InputService {
using namespace ReWindow;
inline Event<KeyboardEvent> OnKeyboardEvent;
inline Event<KeyboardEvent> OnKeyEvent;
inline Event<KeyDownEvent> OnKeyDown;
inline Event<KeyUpEvent> OnKeyUp;
inline Event<MouseMoveEvent> OnMouseEvent;
inline Event<MouseButtonEvent> OnMouseButtonEvent;
inline Event<MouseMoveEvent> OnMouseMove;
inline Event<MouseButtonDownEvent> OnMouseDown;
inline Event<MouseButtonUpEvent> OnMouseUp;
inline Event<MouseWheelEvent> OnMouseWheel;
bool IsKeyDown(const Key& key);
bool IsMouseButtonDown(const MouseButton& button);
std::pair<int, int> GetMousePosition();
std::pair<int, int> GetWindowSize();
};

View File

@@ -6,8 +6,9 @@
#include <stdexcept>
#include <iostream>
#include <string>
#include <ReWindow/data/X11Scancodes.h>
#include <ReWindow/data/WindowsScancodes.h>
#include "rewindow/X11Scancodes.hpp"
#include "rewindow/WindowsScancodes.hpp"
#include "J3ML/LinearAlgebra.hpp"
class Key

View File

@@ -13,6 +13,10 @@
namespace ReWindow
{
class KeyboardState {
public:
std::map<Key, bool> PressedKeys;
};
class InputDevice {};
class Keyboard : public InputDevice

View File

@@ -1,13 +0,0 @@
#pragma once
#include <jlog/Logger.hpp>
namespace ReWindow::Logger {
using namespace jlog;
extern GenericLogger Info;
extern GenericLogger Fatal;
extern GenericLogger Error;
extern GenericLogger Warning;
extern GenericLogger Debug;
}

View File

@@ -0,0 +1,14 @@
#pragma once
#include "jlog/Logger.hpp"
namespace ReWindow::Logger {
using namespace jlog;
using Logger = GenericLogger;
extern Logger Info;
extern Logger Fatal;
extern Logger Error;
extern Logger Warning;
extern Logger Debug;
}

View File

@@ -0,0 +1,80 @@
/// ReWindowLibrary
/// A C++20 Library for creating and managing windows in a platform-independent manner
/// Developed and Maintained by the boys @ Redacted Software.
/// (c) 2024 Redacted Software
/// This work is dedicated to the public domain.
/// @file keyboard.h
/// @desc A class that models the functionality of a mouse / pointer device.
/// @edit 2024-07-29
#pragma once
namespace ReWindow
{
class MouseState {
public:
struct
{
bool LMB = false;
bool RMB = false;
bool MMB = false;
bool SideButton1 = false;
bool SideButton2 = false;
bool MWheelUp = false;
bool MWheelDown = false;
} Buttons;
Vector2 Position;
int Wheel = 0;
[[nodiscard]] bool IsDown(const MouseButton& btn) const
{
if (btn == MouseButtons::Left) return Buttons.LMB;
if (btn == MouseButtons::Right) return Buttons.RMB;
if (btn == MouseButtons::Middle) return Buttons.MMB;
if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
//if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
//if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
return false; // Unknown button?
}
void Set(const MouseButton& btn, bool state)
{
if (btn == MouseButtons::Left) Buttons.LMB = state;
if (btn == MouseButtons::Right) Buttons.RMB = state;
if (btn == MouseButtons::Middle) Buttons.MMB = state;
if (btn == MouseButtons::Mouse4) Buttons.SideButton1 = state;
if (btn == MouseButtons::Mouse5) Buttons.SideButton2 = state;
//if (btn == MouseButtons::MWheelUp) Buttons.MWheelUp = state;
//if (btn == MouseButtons::MWheelDown) Buttons.MWheelDown = state;
}
bool& operator[](const MouseButton& btn)
{
if (btn == MouseButtons::Left) return Buttons.LMB;
if (btn == MouseButtons::Right) return Buttons.RMB;
if (btn == MouseButtons::Middle) return Buttons.MMB;
if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
//if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
//if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
throw std::runtime_error("Attempted to handle unmapped mouse button");
}
};
class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
class Pointer : public InputDevice {};
class Mouse : public Pointer
{
};
}

View File

@@ -0,0 +1,223 @@
#pragma once
#include <cstdint>
#include <vector>
#include "Event.h"
#include <map>
#include <thread>
#include "Key.hpp"
#include "rewindow/Cursors.hpp"
#include "MouseButton.hpp"
#include "GamepadButton.hpp"
#include "J3ML/LinearAlgebra.hpp"
#include "WindowEvents.hpp"
#include <format>
#include <queue>
#include <experimental/propagate_const>
namespace ReWindow {
enum class RenderingAPI: uint8_t {
OPENGL = 0,
//Vulkan is unimplemented.
VULKAN = 1,
};
//
class RWindowImpl;
class XLibImpl;
class Win32Impl;
class RWindow;
}
class ReWindow::RWindow {
private:
RWindowImpl* Impl = nullptr;
public:
//RWindow() = default;
//RWindow();
static RWindowImpl* GetPlatformImplementation(const RWindowParams& args) {
#if UNIX
return new XLibImpl(args);
#endif
#if WIN32
return new Win32Impl(args);
#endif
return nullptr;
}
explicit RWindow(const RWindowParams& params)
: Impl(GetPlatformImplementation(params)) { }
RWindow()
: RWindow({
.title = "Redacted Window",
.width = 640, .height = 480,
.fullscreen = false,
.resizable = true,
.vsync = false
}) { }
// TODO: Is this one valid?
explicit RWindow(RWindowImpl* wImpl)
: Impl(wImpl) { }
RWindow(RWindowImpl* wImpl, RenderImpl* wRenderImpl)
: Impl(wImpl), Renderer(wRenderImpl) { }
/*
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) :
RWindowImpl(wTitle, wWidth, wHeight, wRenderer, wFullscreen, wResizable, wVsync) {};
*/
~RWindow() = default;
public:
// Platform dependant
void Open() { Impl->Open(); };
void Close() { Impl->Close(); };
void PollEvents() { Impl->PollEvents(); };
void Refresh() { Impl->Refresh(); };
public:
// Shared
/// Returns whether the window currently has mouse and/or keyboard focus.
[[nodiscard]] bool IsFocused() const { return Impl->IsFocused(); };
/// Returns whether the window is currently in Fullscreen.
// TODO: Support Fullscreen, FullscreenWindowed, and Windowed?
[[nodiscard]] bool IsFullscreen() const { return Impl->IsFullscreen(); } ;
/// Returns whether the window can be resized.
[[nodiscard]] bool IsResizable() const { return Impl->IsResizable(); } ;
/// Returns whether V-Sync is enabled.
[[nodiscard]] bool IsVsyncEnabled() const { return Impl->IsVsyncEnabled(); } ;
/// Returns whether the window is considered to be alive. Once dead, any logic loop should be terminated, and the cleanup procedure should run.
[[nodiscard]] bool IsAlive() const { return Impl->IsAlive(); } ;
// Should have IsOpen since window could be closed then reopened
public:
// Platform dependant
/// Sets whether or not to make the window fullscreen.
/// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
void SetFullscreen(bool fs) { Impl->SetFullscreen(fs); };
/// Sets whether or not to make the window resizable.
/// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
void SetResizable(bool resizable) { Impl->SetResizable(resizable); };
/// Sets whether or not to enable vertical synchronization.
/// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
void SetVsyncEnabled(bool vsync) { Impl->SetVsyncEnabled(vsync); };
/// Requests the operating system to change the window size.
/// @param width
/// @param height
void SetSize(int width, int height) { Impl->SetSize(width, height); };
/// Requests the operating system to change the window size.
/// @param size
void SetSize(const Vector2& size) { Impl->SetSize(size); };
// Shared
/// Sets the title of this window.
void SetTitle(const std::string& title) { Impl->SetTitle(title); };
public:
// Shared
[[nodiscard]] std::string GetTitle() const { return Impl->GetTitle(); } ;
/// Returns the position of the window's top-left corner relative to the display
[[nodiscard]] Vector2 GetPos() const { return Impl->GetPos(); } ;
/// Returns the known size of the window, in {x,y} pixel measurement.
[[nodiscard]] Vector2 GetSize() const { return Impl->GetSize(); } ;
/// Returns the horizontal length of the renderable area in pixels.
[[nodiscard]] int GetWidth() const { return Impl->GetWidth(); } ;
/// Returns the vertical length of the renderable area, in pixels.
[[nodiscard]] int GetHeight() const { return Impl->GetHeight(); } ;
/// Returns the amount of time, in seconds, between the current and last frame.
/// Technically, no, it returns the elapsed time of the frame, start to finish.
[[nodiscard]] float GetDeltaTime() const { return Impl->GetDeltaTime(); } ;
/// Returns the approximate frames-per-second using delta time.
[[nodiscard]] float GetRefreshRate() const { return Impl->GetRefreshRate(); } ;
/// Returns the number of frames ran since the windows' creation.
[[nodiscard]] float GetRefreshCounter() const { return Impl->GetRefreshCounter(); } ;
public:
// Figure out what to do with these later
void Raise() const { Impl->Raise(); };
void Lower() const { Impl->Lower(); };
void DestroyOSWindowHandle() { Impl->DestroyOSWindowHandle(); };
void SetCursorVisible(bool cursor_enable) { Impl->SetCursorVisible(cursor_enable); };
Vector2 GetAccurateMouseCoordinates() const { return Impl->GetAccurateMouseCoordinates(); } ;
void GLSwapBuffers() { Impl->GLSwapBuffers(); };
void Fullscreen() { Impl->Fullscreen(); };
void RestoreFromFullscreen() { Impl->RestoreFromFullscreen(); };
// I know this doesn't modify the class, but it indirectly modifies the window
// Making it const just seems deceptive.
void SetCursorStyle(CursorStyle style) const { return Impl->SetCursorStyle(style); } ;
Vector2 GetPositionOfRenderableArea() const { return Impl->GetPositionOfRenderableArea(); } ;
std::string getGraphicsDriverVendor() { return Impl->getGraphicsDriverVendor(); };
void SetFlag(RWindowFlags flag, bool state) { Impl->SetFlag(flag, state); };
void processKeyRelease (Key key) { Impl->processKeyRelease(key); };
void processKeyPress (Key key) { Impl->processKeyPress(key); };
void processOnClose() { Impl->processOnClose(); };
void processOnOpen() { Impl->processOnOpen(); };
void processMousePress(const MouseButton& btn) { Impl->processMousePress(btn); };
void processMouseRelease(const MouseButton& btn) { Impl->processMouseRelease(btn); };
void processFocusIn() { Impl->processFocusIn(); };
void processFocusOut() { Impl->processFocusOut(); };
void processMouseMove(Vector2 last_pos, Vector2 new_pos) { Impl->processMouseMove(last_pos, new_pos); };
void processMouseWheel(int scrolls) { Impl->processMouseWheel(scrolls); };
virtual void OnOpen() {}
virtual void OnClosing() {}
virtual void OnFocusLost(const RWindowEvent& e) {}
virtual void OnFocusGain(const RWindowEvent& e) {}
virtual void OnRefresh(float elapsed) {}
virtual void OnResizeSuccess() {}
virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
virtual void OnKeyDown(const KeyDownEvent&) {}
virtual void OnKeyUp(const KeyUpEvent&) {}
virtual void OnMouseMove(const MouseMoveEvent&) {}
virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
virtual void OnMouseWheel(const MouseWheelEvent&) {}
Event<> OnOpenEvent;
Event<> OnClosingEvent;
Event<RWindowEvent> OnFocusLostEvent;
Event<RWindowEvent> OnFocusGainEvent;
Event<float> OnRefreshEvent;
Event<WindowResizeRequestEvent> OnResizeRequestEvent;
Event<KeyDownEvent> OnKeyDownEvent;
Event<KeyUpEvent> OnKeyUpEvent;
Event<MouseMoveEvent> OnMouseMoveEvent;
Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
Event<MouseWheelEvent> OnMouseWheelEvent;
Vector2 GetMouseCoordinates() const { return Impl->GetMouseCoordinates(); };
bool GetFlag(RWindowFlags flag) const { return Impl->GetFlag(flag); };
//bool IsAlive() const { return Impl->
//IsAlive(); };
void SetSizeWithoutEvent(const Vector2& size) { Impl->SetSizeWithoutEvent(size); };
void LogEvent(const RWindowEvent& e) { Impl->LogEvent(e); };
RWindowEvent GetLastEvent() const { return Impl->GetLastEvent(); }
void SetLastKnownWindowSize(const Vector2& size) { Impl->SetLastKnownWindowSize(size); };
void SetRenderer(RenderingAPI api) { Impl->SetRenderer(api); };
bool IsKeyDown(Key key) const { return Impl->IsKeyDown(key); };
bool IsMouseButtonDown(const MouseButton &button) const { return Impl->IsMouseButtonDown(button); };
void ManagedRefresh() { Impl->ManagedRefresh(); };
float ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) { return Impl->ComputeElapsedFrameTimeSeconds(start, end); };
std::chrono::steady_clock::time_point GetTimestamp() { return Impl->GetTimestamp(); };
void UpdateFrameTiming(float frame_time) { Impl->UpdateFrameTiming(frame_time); };
//bool IsResizable() const { return Impl->
//IsResizable(); };
//bool IsFullscreen() const { return Impl->
//IsFullscreen(); };
//bool IsFocused() const { return Impl->
//IsFocused(); };
//bool IsVsyncEnabled() const { return Impl->
//IsVsyncEnabled(); };
void ForceClose() { Impl->ForceClose(); };
void ForceCloseAndTerminateProgram() { Impl->ForceCloseAndTerminateProgram(); };
int GetMouseWheelPersistent() const { return Impl->GetMouseWheelPersistent();}
[[nodiscard]] bool IsOpen() const { return Impl->IsOpen();}
[[nodiscard]] bool IsClosing() const { return Impl->IsClosing();}
};

View File

@@ -0,0 +1,167 @@
#pragma once
namespace ReWindow { class RWindowImpl; }
class ReWindow::RWindowImpl {
protected: // Should maybe make private
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;
std::string title = "Redacted Window";
Vector2 lastKnownWindowSize {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 avg_refresh_rate = 0.0f;
// Figure out what to do with this shit later
bool flags[5];
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;
//
public:
explicit RWindowImpl(const RWindowParams& params)
: RWindowImpl(params.title, params.width, params.height, RenderingAPI::OPENGL, params.fullscreen, p)
explicit RWindowImpl(const std::string& wTitle,
int wWidth = 640, int wHeight = 480,
RenderingAPI wRenderer = RenderingAPI::OPENGL,
bool wFullscreen = false,
bool wResizable = true,
bool wVsync = false);
~RWindowImpl();
public:
virtual void Open();
virtual void Close();
virtual void PollEvents();
virtual void Refresh();
public:
bool IsFocused() const;
bool IsFullscreen() const;
bool IsResizable() const;
bool IsVsyncEnabled() const;
bool IsAlive() const;
public:
void SetFullscreen(bool fs);
void SetResizable(bool fs);
void SetVsyncEnabled(bool vsync);
void SetSize(int width, int height);
void SetSize(const Vector2& size);
// Added here for now
void SetPos(int x, int y);
void SetPos(const Vector2& pos);
//
virtual void SetTitle(const std::string& title);
public:
std::string GetTitle() const;
Vector2 GetPos() const;
Vector2 GetSize() const;
int GetWidth() const;
int GetHeight() const;
float GetDeltaTime() const;
float GetRefreshRate() const;
float GetRefreshCounter() const;
public:
// Figure out what to do with these later
void Raise() const;
void Lower() const;
void DestroyOSWindowHandle();
void SetCursorVisible(bool cursor_enable);
Vector2 GetAccurateMouseCoordinates() const;
void GLSwapBuffers();
void Fullscreen();
void RestoreFromFullscreen();
// I know this doesn't modify the class, but it indirectly modifies the window
// Making it const just seems deceptive.
void SetCursorStyle(CursorStyle style) const;
Vector2 GetPositionOfRenderableArea() const;
std::string getGraphicsDriverVendor();
void SetFlag(RWindowFlags flag, bool state);
// Make protected
void processKeyRelease (Key key);
void processKeyPress (Key key);
void processOnClose();
void processOnOpen();
void processMousePress(const MouseButton& btn);
void processMouseRelease(const MouseButton& btn);
void processFocusIn();
void processFocusOut();
void processMouseMove(Vector2 last_pos, Vector2 new_pos);
void processMouseWheel(int scrolls);
//
virtual void OnOpen() {}
virtual void OnClosing() {}
virtual void OnFocusLost(const RWindowEvent& e) {}
virtual void OnFocusGain(const RWindowEvent& e) {}
virtual void OnRefresh(float elapsed) {}
virtual void OnResizeSuccess() {}
virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
virtual void OnKeyDown(const KeyDownEvent&) {}
virtual void OnKeyUp(const KeyUpEvent&) {}
virtual void OnMouseMove(const MouseMoveEvent&) {}
virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
virtual void OnMouseWheel(const MouseWheelEvent&) {}
Event<> OnOpenEvent;
Event<> OnClosingEvent;
Event<RWindowEvent> OnFocusLostEvent;
Event<RWindowEvent> OnFocusGainEvent;
Event<float> OnRefreshEvent;
Event<WindowResizeRequestEvent> OnResizeRequestEvent;
Event<KeyDownEvent> OnKeyDownEvent;
Event<KeyUpEvent> OnKeyUpEvent;
Event<MouseMoveEvent> OnMouseMoveEvent;
Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
Event<MouseWheelEvent> OnMouseWheelEvent;
Vector2 GetMouseCoordinates() const;
bool GetFlag(RWindowFlags flag) const;
//bool IsAlive() const;
void SetSizeWithoutEvent(const Vector2& size);
std::vector<RWindowEvent> eventLog;
std::queue<RWindowEvent> eventQueue;
void LogEvent(const RWindowEvent& e) { eventLog.push_back(e);};
RWindowEvent GetLastEvent() const {
return eventLog.back();
};
void SetLastKnownWindowSize(const Vector2& size);
void SetRenderer(RenderingAPI api);
bool IsKeyDown(Key key) const;
bool IsMouseButtonDown(const MouseButton &button) const;
void ManagedRefresh();
float ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end);
std::chrono::steady_clock::time_point GetTimestamp();
void UpdateFrameTiming(float frame_time);
/*
bool IsResizable() const;
bool IsFullscreen() const;
bool IsFocused() const;
bool IsVsyncEnabled() const;
*/
void ForceClose();
void ForceCloseAndTerminateProgram();
int GetMouseWheelPersistent() const { return currentMouse.Wheel;}
[[nodiscard]] bool IsOpen() const { return open;}
[[nodiscard]] bool IsClosing() const { return closing;}
};

View File

@@ -0,0 +1,15 @@
#pragma once
#include <string>
namespace ReWindow {
struct RWindowParams
{
std::string title;
int width;
int height;
bool fullscreen;
bool resizable;
bool vsync;
};
}

View File

@@ -0,0 +1,5 @@
#pragma once
class ReWindow::Win32Impl : ReWindow::RWindowImpl {
public:
};

View File

@@ -0,0 +1,85 @@
#pragma once
#include <chrono>
#include "Key.hpp"
#include "MouseButton.hpp"
namespace ReWindow {
using namespace std::chrono_literals;
using precision_clock = std::chrono::high_resolution_clock;
using precision_timestamp = precision_clock::time_point;
class TimestampedEvent {
private:
public:
precision_timestamp Timestamp;
TimestampedEvent() : Timestamp(precision_clock::now())
{ }
};
class RWindowEvent : public TimestampedEvent {
public:
RWindowEvent() : TimestampedEvent() { }
};
class KeyboardEvent : public RWindowEvent {
public:
Key key;
KeyState state;
KeyboardEvent(Key key, KeyState state) : RWindowEvent(), key(key), state(state) {}
};
class MouseEvent : public RWindowEvent {};
class GamepadEvent : public RWindowEvent {};
class MouseMoveEvent : public MouseEvent {
public:
Vector2 Position;
Vector2 Delta;
MouseMoveEvent(const Vector2 &pos) : MouseEvent(), Position(pos)
{}
MouseMoveEvent(int x, int y) : MouseEvent(), Position(Vector2(x, y))
{}
};
class KeyDownEvent : public KeyboardEvent {
public:
KeyDownEvent(Key key) : KeyboardEvent(key, KeyState::Pressed) {}
};
class KeyUpEvent : public KeyboardEvent {
public:
KeyUpEvent(Key key) : KeyboardEvent(key, KeyState::Released) {}
};
class MouseWheelEvent : public MouseEvent
{
public:
int WheelMovement;
MouseWheelEvent() = default;
MouseWheelEvent(int wheel) : MouseEvent(), WheelMovement(wheel) {}
};
class MouseButtonDownEvent : public MouseEvent {
public:
MouseButton Button;
MouseButtonDownEvent() = default;
MouseButtonDownEvent(MouseButton button) : MouseEvent(), Button(button) {}
};
class MouseButtonUpEvent : public MouseEvent {
public:
MouseButton Button;
MouseButtonUpEvent() = default;
MouseButtonUpEvent(MouseButton button) : MouseEvent(), Button(button) {}
};
class WindowResizeRequestEvent : public RWindowEvent
{
public:
Vector2 Size;
};
}

View File

@@ -0,0 +1,37 @@
#pragma once
#include <ReWindow/RWindowImpl.hpp>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <GL/glx.h>
#include "J3ML/LinearAlgebra.hpp"
namespace ReWindow { class XLibImpl; };
class ReWindow::XLibImpl : ReWindow::RWindowImpl {
Window window;
XEvent xev;
Display* display = XOpenDisplay(nullptr);
int defaultScreen = DefaultScreen(display);
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
// Make it start as floating because fuck tiling WMs
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
GLXContext glContext;
Cursor invisible_cursor = 0;
Vector2 render_area_position = {0, 0};
Vector2 position = {0, 0};
bool should_poll_x_for_mouse_pos = true;
public:
void Open() override;
void Close() override;
void PollEvents() override;
void SetTitle(const std::string &title) override;
void Refresh() override;
};

View File

@@ -1,26 +0,0 @@
/// ReWindowLibrary
/// A C++20 Library for creating and managing windows in a platform-independent manner
/// Developed and Maintained by the boys @ Redacted Software.
/// (c) 2024 Redacted Software
/// This work is dedicated to the public domain.
/// @file keyboard.h
/// @desc A class that models the functionality of a mouse / pointer device.
/// @edit 2024-07-29
#pragma once
namespace ReWindow
{
class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
class Pointer : public InputDevice {};
class Mouse : public Pointer
{
};
}

View File

@@ -1,401 +0,0 @@
#pragma once
#include <cstdint>
#include <vector>
#include <Event.h>
#include <map>
#include <thread>
#include <ReWindow/types/Key.h>
#include <ReWindow/types/Cursors.h>
#include <ReWindow/types/MouseButton.h>
#include <ReWindow/types/WindowEvents.h>
#include <queue>
namespace ReWindow {
struct KeyboardState { std::map<Key, bool> PressedKeys; };
class MouseState;
class RWindow;
class OpenGLWindow;
class VulkanWindow;
}
class ReWindow::MouseState {
public:
struct
{
bool LMB = false;
bool RMB = false;
bool MMB = false;
bool SideButton1 = false;
bool SideButton2 = false;
bool MWheelUp = false;
bool MWheelDown = false;
}
Buttons;
std::pair<int, int> Position;
int Wheel = 0;
public:
[[nodiscard]] bool IsDown(const MouseButton& btn) const;
void Set(const MouseButton& btn, bool state);
bool& operator[](const MouseButton& btn);
};
/// 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 ReWindow::RWindow {
protected:
class Platform;
Platform* platform;
inline static RWindow* extant;
int width = 640;
int height = 480;
bool open = false; // Is the underlying OS-Window-Handle actually open.
bool closing = false;
bool resizable = true;
bool fullscreen_mode = false;
bool focused = true;
bool vsync = false;
bool cursor_visible = true;
bool cursor_focused = false;
bool toggling_cursor_focus = false;
bool key_repeat = false;
float delta_time = 0.f;
float refresh_rate = 0.f;
unsigned long long refresh_count = 0;
std::string title = "Redacted Window";
std::vector<RWindowEvent> eventLog; // history of all logged window events.
std::queue<RWindowEvent> eventQueue; //
MouseState currentMouse; // purrent frame mouse state.
MouseState previousMouse; // previous frame mouse state
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;
/// Returns the most accurate and recent available mouse coordinates relative to the top left corner of the renderable area (not including the title bar).
/// @note Call this version at most **once** per-frame. It polls the X-Window server and therefore is quite slow.
/// @see getCursorPos();
[[nodiscard]] std::pair<int, int> GetAccurateCursorCoordinates() const;
protected:
void LogEvent(const RWindowEvent& e) { eventLog.push_back(e); }
//void EnqueueEvent(const RWindowEvent& e) { eventQueue.push(e);}
[[nodiscard]] RWindowEvent GetLastEvent() const { return eventLog.back(); }
/// Requests the operating system to make the window fullscreen. Saves the previous window size as well.
void Fullscreen();
/// Requests the operating system to take the window out of fullscreen mode. Previously saved window size is restored, if possible.
void RestoreFromFullscreen();
public:
KeyboardState currentKeyboard; // current frame keyboard state.
KeyboardState previousKeyboard; // previous frame keyboard state.
/// The default constructor does not set any members, and are left uninitialized.
RWindow();
/// 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 wFullscreen
/// @param wResizable
/// @param wVsync
explicit RWindow(const std::string& wTitle, int wWidth = 640, int wHeight = 480,
bool wFullscreen = false, bool wResizable = true, bool wVsync = false);
/// The destructor deallocates and cleans up any memory used by the RWindow program.
/// @note If the window handle is not already destroyed, it will be done here.
virtual ~RWindow();
static RWindow* GetExtant() { return extant; };
/// Bindables are provided for hooking into window instances conveniently, without the need to derive and override for simple use cases.
Event<> OnOpenEvent;
Event<> OnClosingEvent;
Event<RWindowEvent> OnFocusLostEvent;
Event<RWindowEvent> OnFocusGainEvent;
Event<float> OnRefreshEvent;
Event<WindowResizeRequestEvent> OnResizeRequestEvent;
Event<KeyDownEvent> OnKeyDownEvent;
Event<KeyUpEvent> OnKeyUpEvent;
Event<MouseMoveEvent> OnMouseMoveEvent;
Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
Event<MouseWheelEvent> OnMouseWheelEvent;
/// These methods can also be overridden in derived classes.
/// Called upon the window requesting to open.
virtual void OnOpen() {}
/// Called right before the window closes.
virtual void OnClosing() {}
/// Called when the window loses focus.
virtual void OnFocusLost(const RWindowEvent& e) {}
/// Called when the window gains focus.
virtual void OnFocusGain(const RWindowEvent& e) {}
/// Called when the window is 'refreshed', in other words, a render pass is completed.
virtual void OnRefresh(float elapsed) {}
/// Called when a resize request has succeeded.
virtual void OnResizeSuccess() {}
/// Called when a resize request is sent to the operating system.
virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
virtual void OnKeyDown(const KeyDownEvent&) {}
virtual void OnKeyUp(const KeyUpEvent&) {}
virtual void OnMouseMove(const MouseMoveEvent&) {}
virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
virtual void OnMouseWheel(const MouseWheelEvent&) {}
[[nodiscard]] int GetMouseWheelPersistent() const { return currentMouse.Wheel; }
[[nodiscard]] bool IsOpen() const { return open; }
/// Returns whether the window is currently visible to the user.
// TODO On Linux, Some desktop environments don't always do this when switching workspaces.
[[nodiscard]] bool IsVisible() const;
[[nodiscard]] bool IsClosing() const { return closing; }
/// Returns whether the window currently has mouse and/or keyboard focus.
[[nodiscard]] bool IsFocused() const;
/// Returns whether the window is currently in Fullscreen.
// TODO: Support Fullscreen, FullscreenWindowed, and Windowed?
[[nodiscard]] bool IsFullscreen() const;
/// Returns whether the window can be resized.
[[nodiscard]] bool IsResizable() const;
/// Returns whether V-Sync is enabled.
[[nodiscard]] bool IsVsyncEnabled() const;
/// Returns whether the window is considered to be alive. Once dead, any logic loop should be terminated, and the cleanup procedure should run.
[[nodiscard]] bool IsAlive() const;
/// Returns whether the given key is currently being pressed.
[[nodiscard]] bool IsKeyDown(Key key) const;
/// Returns whether the given mouse button is currently being pressed.
[[nodiscard]] bool IsMouseButtonDown(const MouseButton& button) const;
[[nodiscard]] float GetDeltaTime() const;
/// Returns the approximate frames-per-second using delta time.
[[nodiscard]] float GetRefreshRate() const;
/// Returns the number of frames ran since the windows' creation.
[[nodiscard]] unsigned long long GetRefreshCount() const;
/// Cleans up and closes the window object.
void Close();
/// Closes the window immediately, potentially without allowing finalization to occur.
void ForceClose();
/** Display a small window with some text and an "OK" button.
* I tried un-defining the macro, Calling it in a lambda,
* Calling MessageBoxA, Putting the call to the MessageBox
* function in its own namespace and then calling that.
* It just wouldn't let me name it MessageBox - Redacted. */
/// @note Execution of the parent window is stopped while the message box is up.
void DialogOK(const std::string& title, const std::string& message);
/// Sets whether the window is fullscreen.
void SetFullscreen(bool fs);
/// Sets whether the window can be resized by the user.
/// @note Resize events will still be sent if fullscreen is toggled.
void DisableResizing();
/// Sets the title of this window.
void SetTitle(const std::string& title);
[[nodiscard]] std::string GetTitle() const;
/// Returns the horizontal length of this window, in pixels.
[[nodiscard]] int GetWidth() const;
/// Returns the vertical length of this window, in pixels.
[[nodiscard]] int GetHeight() const;
/// This is unfortunately here because of the poor design of windows. Maybe once interfaces are done this won't be required anymore.
void SetSizeWithoutEvent(const std::pair<int, int>& size);
/// Tells the underlying window manager to destroy this window and drop the handle.
/// The window, in theory, can not be re-opened after this.
void DestroyOSWindowHandle();
/// Reads events from the operating system, and processes them accordingly.
/// TODO: Move out of public API, consumers should call Refresh or ideally an update() call.
void PollEvents();
/// Updates internal window state, similar to ManagedRefresh, but without accounting for any timekeeping. This is left up to the user.
void Refresh();
/// Updates the window and handles timing internally.
void ManagedRefresh();
/// Requests the operating system to change the window size.
/// @param width
/// @param height
void SetSize(int width, int height);
/// Requests the operating system to change the window size.
/// @param size
void SetSize(const std::pair<int, int>& size);
/// Returns the position of the window's top-left corner relative to the display
[[nodiscard]] std::pair<int, int> GetPosition() const;
/// Returns the known size of the window, in {x,y} pixel measurement.
[[nodiscard]] std::pair<int, int> GetSize() const;
/// Requests the operating system to move the window to the specified coordinates on the display.
/// @param x The horizontal screen position to place the window at.
/// @param y The vertical screen position to place the window at.
void SetPosition(int x, int y);
/// Requests the operating system to move the window to the specified coordinates on the display.
/// @param pos A std::pair<int, int> representing the x,y coordinates of the desired window destination. Fractional values are ignored.
void SetPosition(const std::pair<int, int>& pos);
/// Pull the window to the top, such that it is displayed on top of everything else.
/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
void Raise();
/// Push the window Lower, such that it is effectively hidden behind other windows.
/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
void Lower();
// TODO verify functionality if the cursor is invisible.
void SetCursorStyle(CursorStyle style) const;
void SetCursorCustomIcon() const;
/// @returns Where the cursor was just before we teleported it to the center.
/// @note You should check if our window is in focus before doing this.
/// @note This is useful for 3D games.
std::pair<int, int> SetCursorCenter();
/// Set the position of the cursor relative to the top-left corner of the renderable area.
/// @returns False if the cursor could not be guaranteed to be teleported.
/// @note our window *must* be visible and in focus.
/// @note Moving the cursor outside our window is unsupported.
/// @note Doesn't update where the mouse is observed for this refresh.
[[nodiscard]] bool SetCursorPosition(const std::pair<int, int>& position);
[[nodiscard]] bool SetCursorPosition(int x, int y);
/// Tells the operating system to not allow the cursor to go off our window.
/// @note This is useful for 3D games.
void SetCursorFocused(bool state);
/// Hides the cursor when it's inside our window.
/// @note This is useful for 3D games.
void SetCursorVisible(bool cursor_enable);
/// @returns Whether the cursor is visible.
bool GetCursorVisible();
/// @returns Whether the cursor is focused (cannot go off of our window).
/// @note Delayed until the next time our window is in focus.
bool GetCursorFocused();
/// Returns an std::pair<int, int> representing mouse coordinates relative to the top-left corner of the window.
/// This result is cached from the operating-system each time poll events is called.
/// @see GetAccurateMouseCoordinates().
[[nodiscard]] std::pair<int, int> GetCursorPosition() const;
/// Returns the current time, represented as a high-resolution std::chrono alias.
static std::chrono::steady_clock::time_point GetTimestamp();
/// Computes elapsed time from a start-point and end-point.
float ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end);
/// Updates internals to account for the latest calculated frame time.
void UpdateFrameTiming(float frame_time);
public:
/// These unfortunately *have* to be public because of the poor design of the windows event loop.
void processKeyRelease(Key key);
void processKeyPress(Key key);
/// @note This will be invoked **before** the window-close procedure begins.
void processOnClose();
/// @note This will be invoked **after** the window-open procedure completes.
void processOnOpen();
void processMousePress(const MouseButton& btn);
void processMouseRelease(const MouseButton& btn);
void processFocusIn();
void processFocusOut();
void processMouseMove(const std::pair<int, int>& last_pos, const std::pair<int, int>& new_pos);
void processMouseWheel(int scrolls);
/// Virtual functions which *must* be overridden based on the Renderer.
public:
virtual void SwapBuffers() = 0;
/// Sets whether vertical sync is enabled.
/// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
virtual void SetVsyncEnabled(bool state) = 0;
/// Sets whether we're using key repeat.
void SetKeyRepeatEnabled(bool state);
/// @returns If key repeat is enabled.
[[nodiscard]] bool IsKeyRepeat() const { return key_repeat; };
/// Returns the name of the developer of the user's graphics driver, if it can be determined.
virtual std::string GetGraphicsDriverVendor() = 0;
/// This function instructs the operating system to create the actual window, and give it to us to control.
/// Calling this function, therefore, creates the real 'window' object on the operating system.
[[nodiscard]] virtual bool Open() = 0;
/// Bring attention to the user, On X11 this flashes the entry for this window in the window list.
/// @note If the window is already in focus when this is called nothing happens.
void Flash();
/// @returns True if we are definitely running on a software renderer.
/// @note For some APIs this isn't typically possible.
[[nodiscard]] virtual bool SoftwareRendered() { return false; }
};
// TODO Set flags in window constructor.
class ReWindow::OpenGLWindow : public RWindow {
protected:
uint8_t gl_major, gl_minor;
public:
void SwapBuffers() override;
void SetVsyncEnabled(bool state) override;
std::string GetGraphicsDriverVendor() override;
[[nodiscard]] bool Open() override;
[[nodiscard]] bool SoftwareRendered() override;
public:
OpenGLWindow(const std::string& title, int width, int height, uint8_t gl_major, uint8_t gl_minor);
};
class ReWindow::VulkanWindow : public RWindow {
public:
void SwapBuffers() override;
void SetVsyncEnabled(bool state) override;
std::string GetGraphicsDriverVendor() override;
[[nodiscard]] bool Open() override;
VulkanWindow(const std::string& title, int width, int height);
};

View File

@@ -1,97 +0,0 @@
#pragma once
#include <chrono>
#include <ReWindow/types/Key.h>
#include <ReWindow/types/MouseButton.h>
namespace ReWindow {
using namespace std::chrono_literals;
using precision_clock = std::chrono::high_resolution_clock;
using precision_timestamp = precision_clock::time_point;
class TimestampedEvent {
public:
precision_timestamp Timestamp;
explicit TimestampedEvent(precision_timestamp timestamp) : Timestamp(timestamp) {}
TimestampedEvent() : Timestamp(precision_clock::now())
{ }
};
class RWindowEvent : public TimestampedEvent {
public:
RWindowEvent() : TimestampedEvent() { }
};
class InputDeviceEvent : public RWindowEvent {
public:
InputDeviceEvent() : RWindowEvent() { }
};
class KeyboardEvent : public InputDeviceEvent {
public:
Key key;
KeyState state;
KeyboardEvent(const Key& key, KeyState state) : InputDeviceEvent(), key(key), state(state) {}
};
class MouseEvent : public InputDeviceEvent {};
class GamepadEvent : public InputDeviceEvent {};
class MouseButtonEvent : public MouseEvent {
public:
MouseButton Button;
bool Pressed; // TODO: replace with MouseButtonState enum
MouseButtonEvent() = default;
MouseButtonEvent(const MouseButton& button, bool pressed) : MouseEvent(), Button(button), Pressed(pressed) {}
};
class MouseButtonDownEvent : public MouseButtonEvent {
public:
MouseButtonDownEvent() = default;
explicit MouseButtonDownEvent(const MouseButton& button) : MouseButtonEvent(button, true) {}
};
class MouseButtonUpEvent : public MouseButtonEvent {
public:
MouseButtonUpEvent() = default;
explicit MouseButtonUpEvent(const MouseButton& button) : MouseButtonEvent(button, false) {}
};
class MouseMoveEvent : public MouseEvent {
public:
std::pair<int, int> Position;
std::pair<int, int> Delta;
MouseMoveEvent(const std::pair<int, int> &pos) : MouseEvent(), Position(pos)
{}
MouseMoveEvent(int x, int y) : MouseEvent(), Position(std::pair<int, int>(x, y))
{}
};
class KeyDownEvent : public KeyboardEvent {
public:
explicit KeyDownEvent(const Key& key) : KeyboardEvent(key, KeyState::Pressed) {}
};
class KeyUpEvent : public KeyboardEvent {
public:
explicit KeyUpEvent(const Key& key) : KeyboardEvent(key, KeyState::Released) {}
};
class MouseWheelEvent : public MouseEvent
{
public:
int WheelMovement;
MouseWheelEvent() = default;
MouseWheelEvent(int wheel) : MouseEvent(), WheelMovement(wheel) {}
};
class WindowResizeRequestEvent : public MouseButtonEvent
{
public:
std::pair<int, int> Size;
};
}

235
main.cpp
View File

@@ -1,30 +1,53 @@
#include <iostream>
#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
#include <ReWindow/RWindow.hpp>
#include <ReWindow/Display.hpp>
#include <ReWindow/Logger.hpp>
using namespace ReWindow;
std::ostream& operator<<(std::ostream& os, const std::pair<int, int>& v) {
return os << "{" << v.first << ", " << v.second << "}";
//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Windows :/
#if _WIN32
#include <windows.h>
#endif
#include <GL/gl.h>
Vector2 mouse_pos;
// TODO: Move to J3ML::LinearAlgebra::Vector2
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
return os << "{" << v.x << ", " << v.y << "}";
}
class MyWindow : public OpenGLWindow {
class MyWindow : public ReWindow::RWindow {
public:
float r = 255;
float b = 0;
float g = g;
public:
MyWindow(const std::string& title, int w, int h) : OpenGLWindow(title, w, h, 2, 1) {}
MyWindow(const std::string& title, int w, int h) : ReWindow::RWindow(title, w, h) {}
void OnMouseMove(const MouseMoveEvent& e) override {}
void OnMouseMove(const ReWindow::MouseMoveEvent& e) override {}
void OnKeyDown(const KeyDownEvent& e) override {
if (e.key == Keys::F11)
SetFullscreen(!IsFullscreen());
}
void OnKeyDown(const ReWindow::KeyDownEvent& e) override {}
bool OnResizeRequest(const WindowResizeRequestEvent& e) override { return true; }
void OnRefresh(float elapsed) override {
if (r >= 1)
r = 1;
if (b >= 1)
b = 1;
if (g >= 1)
g = 1;
glClearColor(r, g, b, 255);
glClear(GL_COLOR_BUFFER_BIT);
GLSwapBuffers();
auto pos = GetMouseCoordinates();
//std::cout << pos.x << ", " << pos.y << std::endl;
void OnMouseButtonDown(const MouseButtonDownEvent& e) override { RWindow::OnMouseButtonDown(e); }
//if (IsMouseButtonDown(MouseButtons::MWheelUp))
//std::cout << "WheelUp Mouse Button" << std::endl;
void OnMouseButtonUp(const MouseButtonUpEvent& e) override { RWindow::OnMouseButtonUp(e); }
//if (IsMouseButtonDown(MouseButtons::MWheelDown))
//std::cout << "WheelDown Mouse Button" << std::endl;
void OnRefresh(float elapsed) override {
if (IsMouseButtonDown(MouseButtons::Left))
std::cout << "Left Mouse Button" << std::endl;
@@ -40,39 +63,171 @@ class MyWindow : public OpenGLWindow {
if (IsMouseButtonDown(MouseButtons::Mouse5))
std::cout << "Mouse5 Mouse Button" << std::endl;
SwapBuffers();
if (IsKeyDown(Keys::N)) {
std::cout << "Gotteem" << std::endl;
}
RWindow::OnRefresh(elapsed);
}
bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {
//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;
RWindow::OnMouseButtonDown(e);
}
void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override
{
//std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
RWindow::OnMouseButtonUp(e);
}
};
int main() {
auto* window = new MyWindow("Test Window", 600, 480);
Logger::Debug(std::format("New window '{}' created. width={} height={}", window->GetTitle(), window->GetWidth(), window->GetHeight()));
if (window->Open())
Logger::Debug(std::format("Opened window '{}'", window->GetTitle()));
/*
std::vector<ReWindow::Display> d = ReWindow::Display::getDisplaysFromWindowManager();
for (ReWindow::Display& display : d) {
Logger::Debug("TODO: Cannot set flags until after window is open");
auto w = display.getDefaultGraphicsMode().getWidth();
auto h = display.getDefaultGraphicsMode().getHeight();
auto r = display.getDefaultGraphicsMode().getRefreshRate();
auto aspect = (float)w/(float)h;
std::cout << "Default: ";
std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
for (ReWindow::FullscreenGraphicsMode& fgm : display.getGraphicsModes()) {
w = fgm.GetWidth();
h = fgm.GetHeight();
r = fgm.getRefreshRate();
auto aspect = (float)w/(float)h;
std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
}
}
*/
MyWindow* window = new MyWindow("Test Window", 600, 480);
jlog::Debug(std::format("New window '{}' created. width={} height={}", window->GetTitle(), window->GetWidth(),
window->GetHeight()));
window->SetRenderer(ReWindow::RenderingAPI::OPENGL);
jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->GetTitle()));
window->Open();
jlog::Debug(std::format("Opened window '{}'", window->GetTitle()));
// TODO: Cannot set flags until after window is open
// Make this work somehow
jlog::Debug("TODO: Cannot set flags until after window is open");
window->SetFullscreen(false);
window->SetVsyncEnabled(true);
window->DisableResizing();
window->SetKeyRepeatEnabled(false);
Logger::Debug(std::format
(
"Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} KEY_REPEAT={} QUIT={}",
window->GetTitle(), window->IsFocused(), window->IsFullscreen(), window->IsResizable(),
window->IsVsyncEnabled(), window->IsKeyRepeat(), window->IsClosing())
);
window->SetResizable(true);
window->SetCursorVisible(false);
window->OnKeyDownEvent += [&] (KeyDownEvent e) { jlog::Debug(e.key.Mnemonic); };
window->OnMouseButtonDownEvent += [&] (MouseButtonDownEvent e) { jlog::Debug(e.Button.Mnemonic + std::to_string(e.Button.ButtonIndex)); };
window->OnMouseWheelEvent += [&, window] (MouseWheelEvent e) { std::cout << window->GetMouseWheelPersistent() << std::endl; };
ReWindow::Logger::Debug(std::format("Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} QUIT={}",
window->GetTitle(),
window->GetFlag(RWindowFlags::IN_FOCUS),
window->GetFlag(RWindowFlags::FULLSCREEN),
window->GetFlag(RWindowFlags::RESIZABLE),
window->GetFlag(RWindowFlags::VSYNC),
window->GetFlag(RWindowFlags::QUIT)));
window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e) {
jlog::Debug(e.key.Mnemonic);
};
window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
jlog::Debug(e.Button.Mnemonic + std::to_string(e.Button.ButtonIndex));
};
window->OnMouseWheelEvent += [&, window] (ReWindow::MouseWheelEvent e)
{
std::cout << window->GetMouseWheelPersistent() << std::endl;
};
/*
while (!window->IsClosing()) {
window->ManagedRefresh();
if (window->IsFocused())
window->SetCursorCenter();
}
//window->PollEvents();
window->ManagedRefresh();
}*/
// Found problem
// free(): double free detected in tcache 2
// delete window;
// Alternatively:
/*
* while (window->IsAlive()) {
* auto start = window->GetTimestamp();
* ourUpdateLogic(window->GetDeltaTime());
* window->update();
* ourDrawLogic();
* window->Refresh();
* auto end = window->GetTimestamp();
* auto dt = window->ComputeElapsedFrameTimeSeconds(start, end);
* window->UpdateFrameTiming(dt);
* }
*
*/
//exit(0);
MyWindow* windowdos = new MyWindow("Test Window Dos", 600, 480);
windowdos->SetRenderer(ReWindow::RenderingAPI::OPENGL);
windowdos->Open();
window->r = 0;
bool swap;
while (!windowdos->IsClosing() && !window->IsClosing()) {
window->r += 0.01;
if (window->r >= 1 && !swap) {
window->g += 0.01;
}
if (window->g >= 1 && !swap)
window->b += 0.01;
if (window->b >= 1) {
window->r = 0.01;
window->g = 0.01;
window->b = 0.01;
}
window->ManagedRefresh();
windowdos->ManagedRefresh();
//sleep(10);
}
delete window;
}
delete windowdos;
return 0;
}
/*
//Windows :(
#ifdef _WIN32
#ifndef UNICODE
#define UNICODE
#endif
extern "C" {
int wmain(int argc, wchar_t* argv[]) {
return main();
}
}
#endif
*/

View File

@@ -1 +1 @@
Main:new("Install build dependencies", "apt-get install -yq libx11-6 libx11-dev libgl-dev libvulkan-dev")
Main:new("Install build dependencies", "apt-get install -yq libx11-6 libx11-dev libgl-dev")

View File

@@ -1,28 +0,0 @@
#include <string>
#include <vector>
#include "ReWindow/ClipboardService.h"
std::vector<std::string> clipboard_history;
std::string clipboard;
namespace ClipboardService {
std::string GetClipboard(int historyIndex) {
if (historyIndex > 0) {
return clipboard_history[historyIndex - 1];
}
return clipboard;
}
void SetClipboard(const std::string& str, bool overwrites_last) {
if (!overwrites_last) {
clipboard_history.push_back(clipboard);
}
clipboard = str;
}
}

View File

@@ -0,0 +1,25 @@
#include <ReWindow/GamepadButton.hpp>
bool ReWindow::GamepadButton::operator ==(const GamepadButton &rhs) const {
return this->GetMnemonicButtonCode() == rhs.GetMnemonicButtonCode();
}
std::string ReWindow::GamepadButton::GetMnemonicButtonCode() const {
return mnemonic_btn_code;
}
void ReWindow::GamepadThumbstick::SetDeadzone(float minimum) {
dead_zone = minimum;
}
Vector2 ReWindow::GamepadThumbstick::GetPosition() const {
return position;
}
void ReWindow::GamepadTrigger::SetDeadzone(float minimum) {
dead_zone = minimum;
}
float ReWindow::GamepadTrigger::GetActuation() const {
return position;
}

View File

@@ -1,17 +0,0 @@
#include "ReWindow/InputService.h"
#include "ReWindow/types/Window.h"
namespace InputService
{
bool IsKeyDown(const Key &key) {
return RWindow::GetExtant()->IsKeyDown(key);
}
bool IsMouseButtonDown(const MouseButton &button) {
return RWindow::GetExtant()->IsMouseButtonDown(button);
}
std::pair<int, int> GetMousePosition() {
return RWindow::GetExtant()->GetCursorPosition();
}
std::pair<int, int> GetWindowSize() {
return RWindow::GetExtant()->GetSize();
}
}

View File

@@ -1,4 +1,5 @@
#include <ReWindow/types/Key.h>
#include <ReWindow/Key.hpp>
//#include <ReWindow/logger.h>
//std::vector<Key> Key::keyboard = {};
std::vector<Key> Key::GetKeyboard() { return keyboard; }

View File

@@ -1,11 +1,11 @@
#include "ReWindow/Logger.h"
#include <ReWindow/Logger.hpp>
namespace ReWindow::Logger {
using namespace jlog;
using namespace Colors;
using Logger = GenericLogger;
GenericLogger Info {"ReWindow", GlobalLogFile, Gray, Gray, Gray, Gray};
GenericLogger Fatal {"ReWindow::Fatal", GlobalLogFile, Reds::Crimson, Gray, Gray, Reds::Crimson, White};
GenericLogger Debug {"ReWindow::Debug", GlobalLogFile, Purples::Purple, Gray, Gray, Purples::Purple, White};
GenericLogger Error {"ReWindow::Error", GlobalLogFile, Red, Gray, Gray, Gray};
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};
}

View File

@@ -1,6 +1,7 @@
#include <ReWindow/types/MouseButton.h>
#include <ReWindow/MouseButton.hpp>
#include <string>
#include <ReWindow/Logger.h>
#include <X11/X.h>
#include <ReWindow/Logger.hpp>
MouseButton::MouseButton(const std::string& charcode, unsigned int index) {

View File

@@ -0,0 +1,279 @@
#include <ReWindow/RWindowImpl.hpp>
Vector2 RWindowImpl::GetMouseCoordinates() const {
return currentMouse.Position;
}
bool RWindowImpl::GetFlag(RWindowFlags flag) const {
return flags[(int) flag];
}
bool RWindowImpl::IsAlive() const {
return (!closing) && open;
}
void RWindowImpl::SetFullscreen(bool fs) {
if (fs)
Fullscreen();
else
RestoreFromFullscreen();
}
#pragma region Event Processors Implementation
void RWindowImpl::processFocusIn()
{
RWindowEvent event {};
OnFocusGain(event);
OnFocusGainEvent(event);
LogEvent(event);
}
void RWindowImpl::processFocusOut()
{
RWindowEvent event {};
OnFocusLost(event);
OnFocusLostEvent(event);
LogEvent(event);
}
void RWindowImpl::processMousePress(const MouseButton& btn)
{
currentMouse.Set(btn, true);
auto event = MouseButtonDownEvent(btn);
OnMouseButtonDown(event);
OnMouseButtonDownEvent(event);
LogEvent(event);
}
void RWindowImpl::processMouseMove(Vector2 last_pos, Vector2 new_pos)
{
currentMouse.Position = new_pos;
auto event = MouseMoveEvent(new_pos);
OnMouseMove(event);
OnMouseMoveEvent(event);
LogEvent(event);
}
void RWindowImpl::processMouseRelease(const MouseButton& btn)
{
currentMouse.Set(btn, false);
auto event = MouseButtonUpEvent(btn);
OnMouseButtonUp(event);
OnMouseButtonUpEvent(event);
LogEvent(event);
}
void RWindowImpl::processKeyRelease(Key key) {
currentKeyboard.PressedKeys[key] = false;
auto event = KeyUpEvent(key);
OnKeyUp(event);
OnKeyUpEvent(key);
LogEvent(event);
}
void RWindowImpl::processKeyPress(Key key) {
currentKeyboard.PressedKeys[key] = true;
auto event = KeyDownEvent(key);
OnKeyDown(event);
OnKeyDownEvent(key);
LogEvent(event);
}
void RWindowImpl::processOnClose()
{
auto event = RWindowEvent();
OnClosing();
OnClosingEvent();
LogEvent(event);
}
void RWindowImpl::processOnOpen()
{
auto event = RWindowEvent();
OnOpen();
OnOpenEvent();
LogEvent(event);
}
#pragma endregion
std::string RWindowImpl::GetTitle() const {
return this->title;
}
/*
Vector2 RWindowImpl::GetSize() const
{
return {this->width, this->height};
}
*/
int RWindowImpl::GetWidth() const
{
return this->width;
}
int RWindowImpl::GetHeight() const
{
return this->height;
}
void RWindowImpl::SetSizeWithoutEvent(const Vector2& size) {
width = size.x;
height = size.y;
}
void RWindowImpl::SetLastKnownWindowSize(const Vector2& size) {
lastKnownWindowSize = size;
}
void RWindowImpl::SetRenderer(RenderingAPI api) {
renderer = api;
}
void RWindowImpl::SetSize(const Vector2& size) {
this->width = size.x;
this->height = size.y;
this->SetSize(size.x, size.y);
}
bool RWindowImpl::IsKeyDown(Key key) const {
if (currentKeyboard.PressedKeys.contains(key))
return currentKeyboard.PressedKeys.at(key);
return false; // NOTE: Key may not be mapped!!
}
bool RWindowImpl::IsMouseButtonDown(const MouseButton &button) const {
// TODO: Implement MouseButton map
return currentMouse.IsDown(button);
}
void RWindowImpl::ManagedRefresh()
{
auto begin = GetTimestamp();
Refresh();
auto end = GetTimestamp();
float dt = ComputeElapsedFrameTimeSeconds(begin, end);
UpdateFrameTiming(dt);
}
/*
void RWindowImpl::Refresh() {
PollEvents();
OnRefresh(delta_time);
// Only call once and cache the result.
currentMouse.Position = GetAccurateMouseCoordinates();
/// TODO: Implement optional minimum epsilon to trigger a Mouse Update.
if (currentMouse.Position != previousMouse.Position) {
processMouseMove(previousMouse.Position, currentMouse.Position);
previousMouse.Position = currentMouse.Position;
}
}
*/
float RWindowImpl::ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) {
auto frame_time = end - start;
unsigned long int frame_time_us = std::chrono::duration_cast<std::chrono::microseconds>(frame_time).count();
float frame_time_s = frame_time_us / (1000.f * 1000.f);
return frame_time_s;
}
std::chrono::steady_clock::time_point RWindowImpl::GetTimestamp() {
return std::chrono::steady_clock::now();
}
void RWindowImpl::UpdateFrameTiming(float frame_time) {
delta_time = frame_time;
refresh_rate = 1.f / delta_time;
refresh_rate_prev_5 = refresh_rate_prev_4;
refresh_rate_prev_4 = refresh_rate_prev_3;
refresh_rate_prev_3 = refresh_rate_prev_2;
refresh_rate_prev_2 = refresh_rate_prev_1;
refresh_rate_prev_1 = refresh_rate;
avg_refresh_rate = (refresh_rate_prev_1 + refresh_rate_prev_2 + refresh_rate_prev_3 + refresh_rate_prev_4 + refresh_rate_prev_5) / 5.f;
refresh_count++;
}
void RWindowImpl::processMouseWheel(int scrolls)
{
currentMouse.Wheel += scrolls;
auto ev = MouseWheelEvent(scrolls);
OnMouseWheel(ev);
OnMouseWheelEvent(ev);
previousMouse.Wheel = currentMouse.Wheel;
}
bool RWindowImpl::IsResizable() const {
return resizable;
}
bool RWindowImpl::IsFullscreen() const {
return fullscreen_mode;
}
bool RWindowImpl::IsFocused() const {
return focused;
}
bool RWindowImpl::IsVsyncEnabled() const {
return vsync;
}
float RWindowImpl::GetDeltaTime() const { return delta_time; }
float RWindowImpl::GetRefreshRate() const { return refresh_rate; }
float RWindowImpl::GetRefreshCounter() const { return refresh_count; }
void RWindowImpl::Close() {
closing = true;
processOnClose();
}
void RWindowImpl::Open() {
open = true;
processOnOpen();
}
void RWindowImpl::ForceClose() {
Close();
DestroyOSWindowHandle();
}
void RWindowImpl::ForceCloseAndTerminateProgram() {
ForceClose();
exit(0);
}
void RWindowImpl::PollEvents()
{
previousKeyboard = currentKeyboard;
previousMouse.Buttons = currentMouse.Buttons;
}
void RWindowImpl::Refresh()
{
PollEvents();
OnRefresh(delta_time);
// Only call once and cache the result.
currentMouse.Position = GetAccurateMouseCoordinates();
/// TODO: Implement optional minimum epsilon to trigger a Mouse Update.
if (currentMouse.Position != previousMouse.Position) {
processMouseMove(previousMouse.Position, currentMouse.Position);
previousMouse.Position = currentMouse.Position;
}
}

302
src/ReWindow/Win32Impl.cpp Normal file
View File

@@ -0,0 +1,302 @@
#include <Windows.h>
#include <gl/GL.h>
#include <ReWindow/RWindow.hpp>
using namespace ReWindow;
bool fullscreenmode = false;
bool open = false;
HINSTANCE hInstance = GetModuleHandle(nullptr);
HWND hwnd;
HDC hdc;
HGLRC glContext;
void raise() { SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
void lower() { SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
void RWindow::SetFlag(RWindowFlags flag, bool state) {
flags[(int) flag] = state;
if (flag == RWindowFlags::RESIZABLE && !state) {
RECT rect;
GetWindowRect(hwnd, &rect);
LONG style = GetWindowLong(hwnd, GWL_STYLE);
style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
SetWindowLong(hwnd, GWL_STYLE, style);
SetWindowPos(hwnd, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
}
}wasd
void RWindow::SetResizable(bool resizable) {
SetFlag(RWindowFlags::RESIZABLE, resizable);;
}
void RWindow::PollEvents() {
MSG msg;
while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
void RWindow::SetSize(int newWidth, int newHeight) {
if (!resizable) return;
this->width = width;
this->height = height;
SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
}
Vector2 RWindow::GetAccurateMouseCoordinates() const {
POINT point;
GetCursorPos(&point);
ScreenToClient(hwnd, &point);
return { (float)point.x, (float)point.y };
}
void RWindow::SetCursorVisible(bool cursor_enable) {
cursor_visible = cursor_enable;
}
bool RWindow::GetCursorVisible() {
return cursor_visible;
}
Vector2 RWindow::GetSize() const {
RECT rect;
GetClientRect(hwnd, &rect);
return { (float)(rect.right - rect.left), (float)(rect.bottom - rect.top) };
}
void RWindow::SetPos(int x, int y) {
SetWindowPos(hwnd, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
void RWindow::SetPos(const Vector2& pos) {
SetPos(pos.x, pos.y);
}
void RWindow::Fullscreen() {
// Implement fullscreen
SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_OVERLAPPEDWINDOW);
SetWindowPos(hwnd, HWND_TOP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_FRAMECHANGED | SWP_NOOWNERZORDER);
}
void RWindow::RestoreFromFullscreen() {
// Implement restore from fullscreen
SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW);
SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
}
void RWindow::SetVsyncEnabled(bool b) {
typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC)(int interval);
auto wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
if (wglSwapIntervalEXT)
wglSwapIntervalEXT(b ? 1 : 0);
}
RWindow* eWindow = nullptr;
KeyboardState* pKeyboard = nullptr;
KeyboardState* cKeyboard = nullptr;
//Event loop.
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch (uMsg) {
case WM_CLOSE: {
DestroyWindow(hwnd);
eWindow->processOnClose();
}
case WM_DESTROY: {
exit(0);
}
case WM_SIZE: {
eWindow->SetSizeWithoutEvent({(float) LOWORD(lParam), (float) HIWORD(lParam)});
auto eventData = WindowResizeRequestEvent();
eventData.Size = {(float) eWindow->GetWidth(), (float) eWindow->GetHeight()};
eWindow->SetLastKnownWindowSize({(float) eWindow->GetWidth(), (float) eWindow->GetHeight()});
// TODO: Implement eWindow->processOnResize()
eWindow->OnResizeRequest(eventData);
eWindow->OnResizeRequestEvent(eventData);
//Just to be absolutely sure the OpenGL viewport resizes along with the window.
glViewport(0, 0, eWindow->GetWidth(), eWindow->GetHeight());
break;
}
case WM_SETFOCUS: {
eWindow->processFocusIn();
eWindow->SetFlag(RWindowFlags::IN_FOCUS, true);
break;
}
case WM_KILLFOCUS: {
eWindow->processFocusOut();
eWindow->SetFlag(RWindowFlags::IN_FOCUS, false);
break;
}
case WM_SETCURSOR: {
if (LOWORD(lParam) == HTCLIENT && eWindow->GetCursorVisible() == false)
SetCursor(nullptr);
break;
}
case WM_KEYDOWN: {
auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
//Key repeat fix.
if (!pKeyboard->PressedKeys[key]) {
eWindow->processKeyPress(key);
}
break;
}
case WM_KEYUP: {
auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
eWindow->processKeyRelease(key);
break;
}
//Mouse Buttons.
case WM_MOUSEWHEEL: {
int wheel_delta = GET_WHEEL_DELTA_WPARAM(wParam);
// TODO: Determine sign of wheel_delta for each direction, (and on linux too), and document this.
eWindow->processMouseWheel(wheel_delta);
break;
}
case WM_LBUTTONDOWN: {
eWindow->processMousePress(MouseButtons::Left);
break;
}
case WM_LBUTTONUP: {
eWindow->processMouseRelease(MouseButtons::Left);
break;
}
case WM_RBUTTONDOWN: {
eWindow->processMousePress(MouseButtons::Right);
break;
}
case WM_RBUTTONUP: {
eWindow->processMouseRelease(MouseButtons::Right);
break;
}
case WM_MBUTTONDOWN: {
eWindow->processMousePress(MouseButtons::Middle);
break;
}
case WM_MBUTTONUP: {
eWindow->processMouseRelease(MouseButtons::Middle);
break;
}
case WM_XBUTTONDOWN: {
WORD button = GET_XBUTTON_WPARAM(wParam);
if (button == XBUTTON1)
eWindow->processMousePress(MouseButtons::Mouse4);
if (button == XBUTTON2)
eWindow->processMousePress(MouseButtons::Mouse5);
break;
}
case WM_XBUTTONUP: {
WORD button = GET_XBUTTON_WPARAM(wParam);
if (button == XBUTTON1)
eWindow->processMouseRelease(MouseButtons::Mouse4);
if (button == XBUTTON2)
eWindow->processMouseRelease(MouseButtons::Mouse5);
break;
}
//This is the same as "Motion Notify" in the X Window System.
case WM_MOUSEMOVE:
break;
}
if (pKeyboard != nullptr && cKeyboard != nullptr)
pKeyboard = cKeyboard;
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
void RWindow::SetCursorStyle(CursorStyle style) const {}
void RWindow::Open() {
eWindow = this;
pKeyboard = &previousKeyboard;
cKeyboard = &currentKeyboard;
WNDCLASS wc = { };
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.lpszClassName = "RWindowClass";
RegisterClass(&wc);
hwnd = CreateWindowEx(
0,
"RWindowClass",
title.c_str(),
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, width, height,
nullptr,
nullptr,
hInstance,
nullptr
);
if (renderer == RenderingAPI::OPENGL) {
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24,
8,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};
hdc = GetDC(hwnd);
int pixelFormat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, pixelFormat, &pfd);
glContext = wglCreateContext(hdc);
wglMakeCurrent(hdc, glContext);
}
ShowWindow(hwnd, SW_SHOW);
open = true;
}
void RWindow::GLSwapBuffers() {
SwapBuffers(hdc);
}
std::string RWindow::getGraphicsDriverVendor() {
return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
}

View File

@@ -0,0 +1,7 @@
#include <ReWindow/WindowEvents.hpp>
namespace ReWindow
{
}

481
src/ReWindow/XLibImpl.cpp Normal file
View File

@@ -0,0 +1,481 @@
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <GL/glx.h>
#include <cstdlib>
#include <cstring>
#include <ReWindow/RWindow.hpp>
#include <ReWindow/Cursors.hpp>
#include <J3ML/J3ML.hpp>
#include <ReWindow/Logger.hpp>
// TODO: Move all "global" members to be instantiated class members of Window
// Doing this would break the intended "Platform-Specific" Encapsulation
// So should we do derived platform-specific subclasses?
// The intended goal of the ReWindow class is a one-stop object that handles window management on **ALL** platforms
using namespace ReWindow;
/*
Window window;
XEvent xev;
Display* display = XOpenDisplay(nullptr);
int defaultScreen = DefaultScreen(display);
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
// Make it start as floating because fuck tiling WMs
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
GLXContext glContext;
Cursor invisible_cursor = 0;
Vector2 render_area_position = {0, 0};
Vector2 position = {0, 0};
bool should_poll_x_for_mouse_pos = true;
*/
class RWindowImpl::Platform {
public:
Platform() = default;
public:
Window window;
XEvent xev;
Display* display = XOpenDisplay(nullptr);
int defaultScreen = DefaultScreen(display);
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
// Make it start as floating because fuck tiling WMs
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
GLXContext glContext;
Cursor invisible_cursor = 0;
Vector2 render_area_position = {0, 0};
Vector2 position = {0, 0};
bool should_poll_x_for_mouse_pos = true;
};
RWindowImpl::RWindowImpl(const std::string &wTitle, int wWidth, int wHeight, RenderingAPI wRenderer, bool wFullscreen, bool wResizable, bool wVsync) : pPlatform(new Platform) {
title = wTitle;
width = wWidth;
height = wHeight;
renderer = wRenderer;
fullscreen_mode = wFullscreen;
resizable = wResizable;
vsync = wVsync;
}
RWindowImpl::~RWindowImpl() {
if (pPlatform) { std::cout << "FUCK" << std::endl; delete pPlatform; };
if (open)
DestroyOSWindowHandle();
}
void XLibImpl::SetTitle(const std::string &title) {
RWindowImpl::SetTitle(title);
XStoreName(pPlatform->display, pPlatform->window, title.c_str());
}
void XLibImpl::Open() {
pPlatform->xSetWindowAttributes.border_pixel = BlackPixel(pPlatform->display, pPlatform->defaultScreen);
pPlatform->xSetWindowAttributes.background_pixel = BlackPixel(pPlatform->display, pPlatform->defaultScreen);
pPlatform->xSetWindowAttributes.override_redirect = True;
pPlatform->xSetWindowAttributes.event_mask = ExposureMask;
//SetVsyncEnabled(vsync);
if (renderer == RenderingAPI::OPENGL) {
GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
pPlatform->visual = glXChooseVisual(pPlatform->display, pPlatform->defaultScreen, glAttributes);
pPlatform->glContext = glXCreateContext(pPlatform->display, pPlatform->visual, nullptr, GL_TRUE);
}
pPlatform->xSetWindowAttributes.colormap = XCreateColormap(pPlatform->display, RootWindow(pPlatform->display, pPlatform->defaultScreen), pPlatform->visual->visual, AllocNone);
pPlatform->window = XCreateWindow(pPlatform->display, RootWindow(pPlatform->display, pPlatform->defaultScreen), 0, 0, width, height, 0, pPlatform->visual->depth,
InputOutput, pPlatform->visual->visual, CWBackPixel | CWColormap | CWBorderPixel | NoEventMask,
&pPlatform->xSetWindowAttributes);
// Set window to floating because fucking tiling WMs
pPlatform->windowTypeAtom = XInternAtom(pPlatform->display, "_NET_WM_WINDOW_TYPE", False);
pPlatform->windowTypeUtilityAtom = XInternAtom(pPlatform->display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
XChangeProperty(pPlatform->display, pPlatform->window, pPlatform->windowTypeAtom, XA_ATOM, 32, PropModeReplace,
(unsigned char *)&pPlatform->windowTypeUtilityAtom, 1);
//
XSelectInput(pPlatform->display, pPlatform->window,
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
PointerMotionMask |
PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
SubstructureNotifyMask | CWColormap );
XMapWindow(pPlatform->display, pPlatform->window);
XStoreName(pPlatform->display, pPlatform->window, title.c_str());
pPlatform->wmDeleteWindow = XInternAtom(pPlatform->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(pPlatform->display, pPlatform->window, &pPlatform->wmDeleteWindow, 1);
if (renderer == RenderingAPI::OPENGL)
glXMakeCurrent(pPlatform->display, pPlatform->window, pPlatform->glContext);
// Get the position of the renderable area relative to the rest of the window.
XGetWindowAttributes(pPlatform->display, pPlatform->window, &pPlatform->windowAttributes);
pPlatform->render_area_position = { (float) pPlatform->windowAttributes.x, (float) pPlatform->windowAttributes.y };
RWindowImpl::Open();
}
void XLibImpl::Close()
{
RWindowImpl::Close();
}
//using namespace ReWindow;
void RWindowImpl::Raise() const {
Logger::Debug(std::format("Raising window '{}'", this->title));
// Get the position of the renderable area relative to the rest of the window.
XGetWindowAttributes(pPlatform->display, pPlatform->window, &pPlatform->windowAttributes);
pPlatform->render_area_position = { (float) pPlatform->windowAttributes.x, (float) pPlatform->windowAttributes.y };
XRaiseWindow(pPlatform->display, pPlatform->window);
}
void RWindowImpl::Lower() const
{
Logger::Debug(std::format("Lowering window '{}'", this->title));
XLowerWindow(pPlatform->display, pPlatform->window);
}
void RWindowImpl::DestroyOSWindowHandle() {
Logger::Debug(std::format("Destroying window '{}'", this->title));
XDestroySubwindows(pPlatform->display, pPlatform->window);
Logger::Debug(std::format("Destroyed window '{}'", this->title));
XDestroyWindow(pPlatform->display, pPlatform->window);
system("xset r on"); // Re-set X-server parameter to enable key-repeat.
open = false;
}
//void RWindow::
void RWindowImpl::SetCursorVisible(bool cursor_enable) {
cursor_visible = cursor_enable;
if (pPlatform->invisible_cursor == 0) {
Pixmap blank_pixmap = XCreatePixmap(pPlatform->display, pPlatform->window, 1, 1, 1);
XColor dummy; dummy.pixel = 0; dummy.red = 0; dummy.flags = 0;
pPlatform->invisible_cursor = XCreatePixmapCursor(pPlatform->display, blank_pixmap, blank_pixmap, &dummy, &dummy, 0, 0);
XFreePixmap(pPlatform->display, blank_pixmap);
}
if (!cursor_enable)
XDefineCursor(pPlatform->display, pPlatform->window, pPlatform->invisible_cursor);
if (cursor_enable)
XUndefineCursor(pPlatform->display, pPlatform->window);
}
void RWindowImpl::SetResizable(bool sizable) {
XGetWindowAttributes(pPlatform->display,pPlatform->window,&pPlatform->windowAttributes);
this->resizable = sizable;
if (!sizable)
{
Logger::Debug("Once you've done this you cannot make it resizable again.");
pPlatform->hints.flags = PMinSize | PMaxSize;
pPlatform->hints.min_width = pPlatform->hints.max_width = pPlatform->windowAttributes.width;
pPlatform->hints.min_height = pPlatform->hints.max_height = pPlatform->windowAttributes.height;
XSetWMNormalHints(pPlatform->display, pPlatform->window, &pPlatform->hints);
}
//this->SetFlag(RWindowFlags::RESIZABLE, resizable);
}
// Fuck you
void RWindowImpl::SetFlag(RWindowFlags flag, bool state) {
XGetWindowAttributes(pPlatform->display,pPlatform->window,&pPlatform->windowAttributes);
flags[(int) flag] = state;
//Once you've done this you cannot make it resizable again.
if (flag == RWindowFlags::RESIZABLE && !state) {
Logger::Debug("Once you've done this you cannot make it resizable again.");
pPlatform->hints.flags = PMinSize | PMaxSize;
pPlatform->hints.min_width = pPlatform->hints.max_width = pPlatform->windowAttributes.width;
pPlatform->hints.min_height = pPlatform->hints.max_height = pPlatform->windowAttributes.height;
XSetWMNormalHints(pPlatform->display, pPlatform->window, &pPlatform->hints);
}
Logger::Debug(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
}
void XLibImpl::PollEvents() {
while(XPending(pPlatform->display)) {
XNextEvent(pPlatform->display, &pPlatform->xev);
if (pPlatform->xev.type == ClientMessage)
Logger::Info(std::format("Event '{}'", "ClientMessage"));
if (pPlatform->xev.xclient.message_type == XInternAtom(pPlatform->display, "WM_PROTOCOLS", False) && static_cast<Atom>(pPlatform->xev.xclient.data.l[0]) == pPlatform->wmDeleteWindow) {
Logger::Info("Closing");
Close();
}
if (pPlatform->xev.type == FocusIn) {
Logger::Debug(std::format("Event'{}'", "FocusIn"));
XAutoRepeatOff(pPlatform->display);
SetFlag(RWindowFlags::IN_FOCUS, true);
if (!cursor_visible)
XDefineCursor(pPlatform->display, pPlatform->window, pPlatform->invisible_cursor);
// Get the position of the renderable area relative to the rest of the window.
XGetWindowAttributes(pPlatform->display, pPlatform->window, &pPlatform->windowAttributes);
pPlatform->render_area_position = { (float) pPlatform->windowAttributes.x, (float) pPlatform->windowAttributes.y };
processFocusIn();
}
if (pPlatform->xev.type == FocusOut) {
Logger::Debug(std::format("Event '{}'", "FocusOut"));
XAutoRepeatOn(pPlatform->display);
SetFlag(RWindowFlags::IN_FOCUS, false);
if (!cursor_visible)
XUndefineCursor(pPlatform->display, pPlatform->window);
processFocusOut();
}
if (pPlatform->xev.type == KeyRelease) {
Logger::Debug(std::format("Event '{}'", "KeyRelease"));
auto scancode = (X11Scancode) pPlatform->xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyRelease(key);
}
if (pPlatform->xev.type == KeyPress) {
Logger::Debug(std::format("Event '{}'", "KeyPress"));
auto scancode = (X11Scancode) pPlatform->xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyPress(key);
}
if (pPlatform->xev.type == ButtonRelease) {
// Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
// Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
// and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
if (pPlatform->xev.xbutton.button != 4 && pPlatform->xev.xbutton.button != 5) {
MouseButton button = GetMouseButtonFromXButton(pPlatform->xev.xbutton.button);
Logger::Debug(std::format("Event '{}'", "ButtonRelease"));
processMouseRelease(button);
}
}
if (pPlatform->xev.type == ButtonPress) {
// Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
// Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
// and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
if (pPlatform->xev.xbutton.button == 4) {
processMouseWheel(-1);
} else if (pPlatform->xev.xbutton.button == 5) {
processMouseWheel(1);
} else
{
MouseButton button = GetMouseButtonFromXButton(pPlatform->xev.xbutton.button);
Logger::Debug(std::format("Event: MouseButtonPress {}", button.Mnemonic));
processMousePress(button);
}
}
if (pPlatform->xev.type == Expose)
{
Logger::Debug(std::format("Event '{}'", "Expose"));
// Essentially allows more than one window to be drawable
// https://www.khronos.org/opengl/wiki/Programming_OpenGL_in_Linux:_GLX_and_Xlib
// https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glXMakeCurrent.xml
//glXMakeCurrent(pPlatform->display, pPlatform->window, pPlatform->glContext);
}
// NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.
if (pPlatform->xev.type == MotionNotify)
{
Logger::Debug(std::format("Event '{}'", "MotionNotify"));
}
if (pPlatform->xev.type == ConfigureNotify) {
if (this->width != pPlatform->xev.xconfigurerequest.width || this->height != pPlatform->xev.xconfigurerequest.height) {
Logger::Debug(std::format("Event '{}'", "ResizeRequest"));
this->width = pPlatform->xev.xconfigurerequest.width;
this->height = pPlatform->xev.xconfigurerequest.height;
auto eventData = WindowResizeRequestEvent();
eventData.Size = { (float) pPlatform->xev.xconfigurerequest.width, (float) pPlatform->xev.xconfigurerequest.height };
lastKnownWindowSize = eventData.Size;
OnResizeRequest(eventData);
OnResizeRequestEvent(eventData);
}
//Window Moved.
if (pPlatform->position.x != pPlatform->xev.xconfigurerequest.x || pPlatform->position.y != pPlatform->xev.xconfigurerequest.y)
pPlatform->position = { (float) pPlatform->xev.xconfigurerequest.x, (float) pPlatform->xev.xconfigurerequest.y };
}
}
RWindowImpl::PollEvents();
}
void XLibImpl::Refresh() {
// Essentially allows more than one window to be drawable
// https://www.khronos.org/opengl/wiki/Programming_OpenGL_in_Linux:_GLX_and_Xlib
// https://registry.khronos.org/OpenGL-Refpages/gl2.1/xhtml/glXMakeCurrent.xml
glXMakeCurrent(pPlatform->display, pPlatform->window, pPlatform->glContext);
RWindowImpl::Refresh();
}
// Might make the window go off the screen on some window managers.
void RWindowImpl::SetSize(int newWidth, int newHeight) {
if (!resizable) return;
this->width = newWidth;
this->height = newHeight;
XResizeWindow(pPlatform->display, pPlatform->window, newWidth, newHeight);
XFlush(pPlatform->display);
Logger::Info(std::format("Set size for '{}' to {} x {}", this->title, newWidth, newHeight));
}
Vector2 RWindowImpl::GetAccurateMouseCoordinates() const {
Window root_return, child_return;
int root_x_ret, root_y_ret;
int win_x_ret, win_y_ret;
uint32_t mask_return;
// This seems to be relative to the top left corner of the renderable area.
bool mouseAvailable = XQueryPointer(pPlatform->display, pPlatform->window, &root_return, &child_return, &root_x_ret, &root_y_ret, &win_x_ret, &win_y_ret, &mask_return);
if (mouseAvailable) {
// TODO: normalize coordinates from displaySpace to windowSpace
// TODO: fire mouse movement event
Vector2 m_coords = { (float) win_x_ret, (float) win_y_ret };
return m_coords;
}
return Vector2::Zero;
}
Vector2 RWindowImpl::GetSize() const {
return {(float) this->width, (float) this->height};
}
//Vector2 RWindow::getLastKnownResize() const
//{
// return lastKnownWindowSize;
//}
// TODO: implement integer vector2/3 types
Vector2 RWindowImpl::GetPos() const {
return pPlatform->position;
}
void RWindowImpl::SetPos(int x, int y) {
XMoveWindow(pPlatform->display, pPlatform->window, x, y);
pPlatform->position = { (float) x, (float) y };
}
void RWindowImpl::SetPos(const Vector2& pos) {
SetPos(pos.x, pos.y);
}
void RWindowImpl::GLSwapBuffers() {
glXSwapBuffers(pPlatform->display,pPlatform->window);
}
void RWindowImpl::Fullscreen() {
Logger::Info(std::format("Fullscreening '{}'", this->title));
fullscreen_mode = true;
XEvent xev;
Atom wm_state = XInternAtom(pPlatform->display, "_NET_WM_STATE", true);
Atom wm_fullscreen = XInternAtom(pPlatform->display, "_NET_WM_STATE_FULLSCREEN", true);
XChangeProperty(pPlatform->display, pPlatform->window, wm_state, XA_ATOM, 32, PropModeReplace, (unsigned char *)&wm_fullscreen, 1);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = pPlatform->window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
xev.xclient.data.l[1] = fullscreen_mode;
xev.xclient.data.l[2] = 0;
XSendEvent(pPlatform->display, DefaultRootWindow(pPlatform->display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
Logger::Debug(std::format("Fullscreened '{}'", this->title));
}
void RWindowImpl::RestoreFromFullscreen() {
Logger::Debug(std::format("Restoring '{}' from Fullscreen", this->title));
fullscreen_mode = false;
XEvent xev;
Atom wm_state = XInternAtom(pPlatform->display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(pPlatform->display, "_NET_WM_STATE_FULLSCREEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = pPlatform->window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 0; // _NET_WM_STATE_REMOVE
xev.xclient.data.l[1] = fullscreen_mode;
xev.xclient.data.l[2] = 0;
XSendEvent(pPlatform->display, DefaultRootWindow(pPlatform->display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
Logger::Debug(std::format("Restored '{}' from Fullscreen", this->title));
}
void RWindowImpl::SetVsyncEnabled(bool b) {
PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
glXSwapIntervalEXT(pPlatform->display, pPlatform->window, b);
}
// I know this doesn't modify the class, but it indirectly modifies the window
// Making it const just seems deceptive.
void RWindowImpl::SetCursorStyle(CursorStyle style) const {
u32 x11_cursor_resolved_enum = static_cast<u32>(style.X11Cursor);
Cursor c = XCreateFontCursor(pPlatform->display, x11_cursor_resolved_enum);
XDefineCursor(pPlatform->display, pPlatform->window, c);
}
void RWindowImpl::SetTitle(const std::string &title) {
this->title = title;
}
Vector2 RWindowImpl::GetPositionOfRenderableArea() const {
return pPlatform->render_area_position;
}
std::string RWindowImpl::getGraphicsDriverVendor() {
return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
}
// TODO: Implement ControllerButton map

View File

@@ -1,235 +0,0 @@
#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
#include <GL/glx.h>
#include <dlfcn.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
using namespace ReWindow;
class ReWindow::RWindow::Platform {
public:
Window window;
XEvent xev;
Display* display;
int defaultScreen;
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
Cursor invisible_cursor = 0;
XWMHints* wm_hints = nullptr;
GLXContext gl_context;
};
void* glx_lib = nullptr;
void* opengl_lib = nullptr;
namespace OpenGL {
bool constructor_success = false;
typedef const GLubyte *(*glGetString_t)(GLenum name);
glGetString_t glGetString = nullptr;
typedef Bool (*glXMakeCurrent_t)(Display *dpy, GLXDrawable drawable, GLXContext ctx);
glXMakeCurrent_t glXMakeCurrent = nullptr;
typedef void *(*glXGetProcAddressARB_t)(const GLubyte *procname);
glXGetProcAddressARB_t glXGetProcAddressARB = nullptr;
typedef void (*glXSwapBuffers_t)(Display *dpy, GLXDrawable drawable);
glXSwapBuffers_t glXSwapBuffers = nullptr;
typedef GLXContext (*glXCreateContext_t)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
glXCreateContext_t glXCreateContext = nullptr;
typedef GLXFBConfig *(*glXChooseFBConfig_t)(Display *dpy, int screen, const int *attribList, int *nItems);
glXChooseFBConfig_t glXChooseFBConfig = nullptr;
typedef XVisualInfo *(*glXGetVisualFromFBConfig_t)(Display *dpy, GLXFBConfig config);
glXGetVisualFromFBConfig_t glXGetVisualFromFBConfig = nullptr;
typedef XVisualInfo *(*glXChooseVisual_t)(Display *dpy, int screen, const int *attribList);
glXChooseVisual_t glXChooseVisual = nullptr;
typedef GLXContext (*glXCreateContextAttribsARBProc)(Display *, GLXFBConfig, GLXContext, Bool, const int *);
}
// Used to determine if we should force our window to start as floating on tiling window managers.
[[nodiscard]] bool TilingWindowManager() {
const char* xdg_env = std::getenv("XDG_CURRENT_DESKTOP");
const char* session_env = std::getenv("DESKTOP_SESSION");
std::string xdg_current_desktop = xdg_env ? xdg_env : "";
std::string desktop_session = session_env ? session_env : "";
if (xdg_current_desktop == "i3" || desktop_session == "i3")
return true;
return false;
// TODO check for dwm & sway.
}
void OpenGLWindow::SwapBuffers() {
OpenGL::glXSwapBuffers(platform->display,platform->window);
}
void OpenGLWindow::SetVsyncEnabled(bool state) {
auto glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) OpenGL::glXGetProcAddressARB((const GLubyte *) "glXSwapIntervalEXT");
glXSwapIntervalEXT(platform->display, platform->window, state);
}
std::string OpenGLWindow::GetGraphicsDriverVendor() {
return std::string((const char*) OpenGL::glGetString(GL_VENDOR));
}
bool OpenGLWindow::Open() {
bool tiling = TilingWindowManager();
if (!OpenGL::constructor_success)
return false;
platform->display = XOpenDisplay(nullptr);
platform->defaultScreen = DefaultScreen(platform->display);
platform->xSetWindowAttributes.border_pixel = BlackPixel(platform->display, platform->defaultScreen);
platform->xSetWindowAttributes.background_pixel = BlackPixel(platform->display, platform->defaultScreen);
platform->xSetWindowAttributes.event_mask = ExposureMask;
if (tiling)
platform->xSetWindowAttributes.override_redirect = True;
auto glXCreateContextAttribsARB = (OpenGL::glXCreateContextAttribsARBProc) OpenGL::glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB");
XVisualInfo* vi = nullptr;
// Fallback to the old way if you somehow don't have this.
if (!glXCreateContextAttribsARB) {
GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
platform->visual = OpenGL::glXChooseVisual(platform->display, platform->defaultScreen, glAttributes);
platform->gl_context = OpenGL::glXCreateContext(platform->display, platform->visual, nullptr, GL_TRUE);
platform->window = XCreateWindow(platform->display, RootWindow(platform->display, platform->defaultScreen), 0, 0, width, height, 0, platform->visual->depth,
InputOutput, platform->visual->visual, CWBackPixel | CWColormap | CWBorderPixel | NoEventMask, &platform->xSetWindowAttributes);
Logger::Debug("Created OpenGL Context with glXCreateContext.");
if (!platform->window)
return false;
}
else {
static int visual_attributes[]
{
GLX_X_RENDERABLE, True, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8,
GLX_DOUBLEBUFFER, True, None
};
int fb_count;
GLXFBConfig* fb_configurations = OpenGL::glXChooseFBConfig(platform->display, platform->defaultScreen, visual_attributes, &fb_count);
if (!fb_configurations || fb_count == 0)
return false;
GLXFBConfig best_fbc = fb_configurations[0];
vi = OpenGL::glXGetVisualFromFBConfig(platform->display, best_fbc);
if (!vi)
return false;
platform->xSetWindowAttributes.colormap = XCreateColormap(platform->display, RootWindow(platform->display, vi->screen), vi->visual, AllocNone);
platform->window = XCreateWindow(platform->display, RootWindow(platform->display, vi->screen), 0, 0, width, height, 0, vi->depth, InputOutput,
vi->visual, CWBackPixel | CWColormap | CWBorderPixel, &platform->xSetWindowAttributes);
int context_attributes[] { GLX_CONTEXT_MAJOR_VERSION_ARB, gl_major, GLX_CONTEXT_MINOR_VERSION_ARB, gl_minor, None };
platform->gl_context = glXCreateContextAttribsARB(platform->display, best_fbc, nullptr, True, context_attributes);
XFree(fb_configurations);
Logger::Debug("Created OpenGL Context with glXCreateContextAttribsARB");
}
if (!platform->gl_context)
return false;
if (!OpenGL::glXMakeCurrent(platform->display, platform->window, platform->gl_context))
return false;
if (vi)
XFree(vi);
XSelectInput(platform->display, platform->window, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask | SubstructureNotifyMask | VisibilityChangeMask | CWColormap );
XMapWindow(platform->display, platform->window);
XStoreName(platform->display, platform->window, title.c_str());
if (tiling) {
platform->windowTypeAtom = XInternAtom(platform->display, "_NET_WM_WINDOW_TYPE", False);
platform->windowTypeUtilityAtom = XInternAtom(platform->display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
XChangeProperty(platform->display, platform->window, platform->windowTypeAtom, XA_ATOM, 32, PropModeReplace,
(unsigned char *) &platform->windowTypeUtilityAtom, 1);
}
platform->wmDeleteWindow = XInternAtom(platform->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(platform->display, platform->window, &platform->wmDeleteWindow, 1);
XGetWindowAttributes(platform->display, platform->window, &platform->windowAttributes);
open = true;
processOnOpen();
return true;
}
OpenGLWindow::OpenGLWindow(const std::string& title, int width, int height, uint8_t gl_major, uint8_t gl_minor)
: gl_major(gl_major), gl_minor(gl_minor), RWindow(title, width, height) {
// Try this first.
glx_lib = dlopen("libGLX.so", RTLD_NOLOAD);
opengl_lib = dlopen("libOpenGL.so", RTLD_NOLOAD);
if (!glx_lib)
glx_lib = dlopen("libGLX.so", RTLD_LAZY);
if (!glx_lib)
glx_lib = dlopen("libGLX.so.0", RTLD_LAZY);
if (!opengl_lib)
opengl_lib = dlopen("libGL.so", RTLD_LAZY);
if (!opengl_lib)
opengl_lib = dlopen("libOpenGL.so", RTLD_LAZY);
if (!opengl_lib)
opengl_lib = dlopen("libOpenGL.so.0", RTLD_LAZY);
if (!opengl_lib)
opengl_lib = dlopen("libOpenGL.so.0.0.0", RTLD_LAZY);
if (!opengl_lib)
Logger::Error("libOpenGL.so couldn't be found in your LD_LIBRARY_PATH."),
OpenGL::constructor_success = false;
if (!glx_lib)
Logger::Error("libGLX.so couldn't be found in your LD_LIBRARY_PATH."),
OpenGL::constructor_success = false;
OpenGL::glGetString = (OpenGL::glGetString_t) dlsym(opengl_lib, "glGetString");
OpenGL::glXMakeCurrent = (OpenGL::glXMakeCurrent_t) dlsym(glx_lib, "glXMakeCurrent");
OpenGL::glXGetProcAddressARB = (OpenGL::glXGetProcAddressARB_t) dlsym(glx_lib, "glXGetProcAddressARB");
OpenGL::glXSwapBuffers = (OpenGL::glXSwapBuffers_t) dlsym(glx_lib, "glXSwapBuffers");
OpenGL::glXCreateContext = (OpenGL::glXCreateContext_t) dlsym(glx_lib, "glXCreateContext");
OpenGL::glXChooseFBConfig = (OpenGL::glXChooseFBConfig_t) dlsym(glx_lib, "glXChooseFBConfig");
OpenGL::glXGetVisualFromFBConfig = (OpenGL::glXGetVisualFromFBConfig_t) dlsym(glx_lib, "glXGetVisualFromFBConfig");
OpenGL::glXChooseVisual = (OpenGL::glXChooseVisual_t) dlsym(glx_lib, "glXChooseVisual");
OpenGL::constructor_success = true;
}
bool OpenGLWindow::SoftwareRendered() {
std::string renderer((const char*) OpenGL::glGetString(GL_RENDERER));
if (renderer.find("llvmpipe"))
return true;
if (renderer.find("softpipe"))
return true;
return false;
}

View File

@@ -1,255 +0,0 @@
#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
#include <dlfcn.h>
#include <set>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_xlib.h>
using namespace ReWindow;
class ReWindow::RWindow::Platform {
public:
Window window;
XEvent xev;
Display* display;
int defaultScreen;
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
Cursor invisible_cursor = 0;
XWMHints* wm_hints = nullptr;
};
namespace Vulkan {
bool constructor_success = false;
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = nullptr;
PFN_vkCreateInstance vkCreateInstance = nullptr;
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = nullptr;
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = nullptr;
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = nullptr;
PFN_vkGetDeviceQueue vkGetDeviceQueue = nullptr;
PFN_vkCreateDevice vkCreateDevice = nullptr;
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = nullptr;
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = nullptr;
}
void* vulkan_lib = nullptr;
VkInstance vulkan_context = nullptr;
VkApplicationInfo vulkan_application_info{};
VkSurfaceKHR vulkan_surface = nullptr;
VkDevice vulkan_logical_device = nullptr;
VkQueue vulkan_graphics_queue = nullptr;
VkQueue vulkan_present_queue = nullptr;
// Necessary because some functions aren't available until you have a context (Vulkan is weird).
void LoadVulkanInstancedFunctions(VkInstance vulkan_ctx) {
Vulkan::vkGetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkGetPhysicalDeviceProperties");
Vulkan::vkEnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkEnumeratePhysicalDevices");
Vulkan::vkGetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkGetPhysicalDeviceQueueFamilyProperties");
Vulkan::vkGetDeviceQueue = (PFN_vkGetDeviceQueue) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkGetDeviceQueue");
Vulkan::vkCreateDevice = (PFN_vkCreateDevice) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkCreateDevice");
Vulkan::vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkCreateXlibSurfaceKHR");
Vulkan::vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) Vulkan::vkGetInstanceProcAddr(vulkan_ctx, "vkGetPhysicalDeviceSurfaceSupportKHR");
}
bool VulkanWindow::Open() {
if (!Vulkan::constructor_success)
return false;
platform->display = XOpenDisplay(nullptr);
platform->defaultScreen = DefaultScreen(platform->display);
platform->xSetWindowAttributes.border_pixel = BlackPixel(platform->display, platform->defaultScreen);
platform->xSetWindowAttributes.background_pixel = BlackPixel(platform->display, platform->defaultScreen);
platform->xSetWindowAttributes.override_redirect = True;
platform->xSetWindowAttributes.event_mask = ExposureMask;
vulkan_application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
vulkan_application_info.pApplicationName = title.c_str();
vulkan_application_info.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
vulkan_application_info.pEngineName = "";
vulkan_application_info.engineVersion = VK_MAKE_VERSION(1, 0, 0);
vulkan_application_info.apiVersion = VK_API_VERSION_1_0;
VkInstanceCreateInfo create_info{};
create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
create_info.pApplicationInfo = &vulkan_application_info;
const char* extensions[] = { "VK_KHR_surface", "VK_KHR_xlib_surface" };
create_info.enabledExtensionCount = 2;
create_info.ppEnabledExtensionNames = extensions;
if (Vulkan::vkCreateInstance(&create_info, nullptr, &vulkan_context) != VK_SUCCESS) {
Logger::Error("Couldn't create Vulkan instance.");
return false;
}
LoadVulkanInstancedFunctions(vulkan_context);
XVisualInfo visual_info_t{};
visual_info_t.screen = platform->defaultScreen;
int visual_count;
XVisualInfo* vi = XGetVisualInfo(platform->display, VisualScreenMask, &visual_info_t, &visual_count);
if (!vi)
return false;
Colormap colormap = XCreateColormap(platform->display, RootWindow(platform->display, vi->screen), vi->visual, AllocNone);
platform->xSetWindowAttributes.colormap = colormap;
platform->window = XCreateWindow(platform->display, RootWindow(platform->display, vi->screen),
0, 0, width, height, 0, vi->depth, InputOutput,
vi->visual, CWBackPixel | CWColormap | CWBorderPixel, &platform->xSetWindowAttributes);
if (!platform->window) {
Logger::Error("Failed to create X11 window for Vulkan.");
return false;
}
XFree(vi);
VkXlibSurfaceCreateInfoKHR surface_create_info{};
surface_create_info.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
surface_create_info.dpy = platform->display;
surface_create_info.window = platform-> window;
if (Vulkan::vkCreateXlibSurfaceKHR(vulkan_context, &surface_create_info, nullptr, &vulkan_surface) != VK_SUCCESS) {
Logger::Error("Failed to create Vulkan X11 surface.");
return false;
}
unsigned int device_count = 0;
Vulkan::vkEnumeratePhysicalDevices(vulkan_context, &device_count, nullptr);
if (device_count == 0) {
Logger::Error("Opening the window as Vulkan but there isn't a Vulkan compatible graphics card?");
return false;
}
std::vector<VkPhysicalDevice> vulkan_devices(device_count);
Vulkan::vkEnumeratePhysicalDevices(vulkan_context, &device_count, vulkan_devices.data());
VkPhysicalDevice selected_device = VK_NULL_HANDLE;
int graphics_family = -1;
int present_family = -1;
for (const auto& d : vulkan_devices) {
unsigned int queue_family_count = 0;
Vulkan::vkGetPhysicalDeviceQueueFamilyProperties(d, &queue_family_count, nullptr);
std::vector<VkQueueFamilyProperties> queue_families(queue_family_count);
Vulkan::vkGetPhysicalDeviceQueueFamilyProperties(d, &queue_family_count, queue_families.data());
bool has_graphics = false;
bool has_present = false;
for (unsigned int i = 0; i < queue_family_count; i++) {
if (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) { has_graphics = true; graphics_family = i; }
VkBool32 present_support = false;
Vulkan::vkGetPhysicalDeviceSurfaceSupportKHR(d, i, vulkan_surface, &present_support);
if (present_support) { has_present = true; present_family = i; }
if (has_graphics && has_present) { selected_device = d; break; }
}
if (selected_device != VK_NULL_HANDLE)
break;
}
if (selected_device == VK_NULL_HANDLE) {
Logger::Error("There isn't a Vulkan device which supports rendering & presenting?");
return false;
}
VkPhysicalDeviceProperties device_properties;
Vulkan::vkGetPhysicalDeviceProperties(selected_device, &device_properties);
Logger::Debug("Vulkan continuing with selected device: " + std::string(device_properties.deviceName));
float queue_prio = 1.0f;
std::vector<VkDeviceQueueCreateInfo> queue_create_info;
std::set<unsigned int> unique_queue_families = { (unsigned int) graphics_family, (unsigned int) present_family};
for (unsigned int qf : unique_queue_families) {
VkDeviceQueueCreateInfo vdqci{};
vdqci.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
vdqci.queueFamilyIndex = qf;
vdqci.queueCount = 1;
vdqci.pQueuePriorities = &queue_prio;
queue_create_info.push_back(vdqci);
}
// TODO allow the user to specify this.
VkPhysicalDeviceFeatures enabled_features{};
VkDeviceCreateInfo device_create_info{};
device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
device_create_info.queueCreateInfoCount = queue_create_info.size();
device_create_info.pQueueCreateInfos = queue_create_info.data();
device_create_info.pEnabledFeatures = &enabled_features;
// TODO allow the user to specify this.
std::vector<const char*> device_ext = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
device_create_info.enabledExtensionCount = device_ext.size();
device_create_info.ppEnabledExtensionNames = device_ext.data();
if (Vulkan::vkCreateDevice(selected_device, &device_create_info, nullptr, &vulkan_logical_device) != VK_SUCCESS) {
Logger::Error("Couldn't create the Vulkan logical device.");
return false;
}
Vulkan::vkGetDeviceQueue(vulkan_logical_device, graphics_family, 0, &vulkan_graphics_queue);
Vulkan::vkGetDeviceQueue(vulkan_logical_device, present_family, 0, &vulkan_present_queue);
XSelectInput(platform->display, platform->window, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask | SubstructureNotifyMask | VisibilityChangeMask | CWColormap );
XMapWindow(platform->display, platform->window);
XStoreName(platform->display, platform->window, title.c_str());
platform->windowTypeAtom = XInternAtom(platform->display, "_NET_WM_WINDOW_TYPE", False);
platform->windowTypeUtilityAtom = XInternAtom(platform->display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
XChangeProperty(platform->display, platform->window, platform->windowTypeAtom, XA_ATOM, 32, PropModeReplace, (unsigned char*) &platform->windowTypeUtilityAtom, 1);
platform->wmDeleteWindow = XInternAtom(platform->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(platform->display, platform->window, &platform->wmDeleteWindow, 1);
XGetWindowAttributes(platform->display, platform->window, &platform->windowAttributes);
open = true;
processOnOpen();
return true;
}
void VulkanWindow::SwapBuffers() {
}
void VulkanWindow::SetVsyncEnabled(bool state) {
}
std::string VulkanWindow::GetGraphicsDriverVendor() {
return "Unknown OpenGL";// TODO: Implement properly!
}
VulkanWindow::VulkanWindow(const std::string& title, int width, int height) : RWindow(title, width, height) {
vulkan_lib = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
if (!vulkan_lib)
vulkan_lib = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL);
if (!vulkan_lib)
Logger::Debug("libvulkan.so couldn't be found in your LD_LIBRARY_PATH."),
Vulkan::constructor_success = false;
Vulkan::vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) dlsym(vulkan_lib,"vkGetInstanceProcAddr");
Vulkan::vkCreateInstance = (PFN_vkCreateInstance) Vulkan::vkGetInstanceProcAddr(NULL, "vkCreateInstance");
Vulkan::constructor_success = true;
}

View File

@@ -1,532 +0,0 @@
#include <cstring>
#include <ReWindow/types/Window.h>
#include <ReWindow/types/Cursors.h>
#include <ReWindow/Logger.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
class ReWindow::RWindow::Platform {
public:
Window window;
XEvent xev;
Display* display;
int defaultScreen;
XVisualInfo* visual;
XSetWindowAttributes xSetWindowAttributes;
XWindowAttributes windowAttributes;
Atom wmDeleteWindow;
Atom windowTypeAtom;
Atom windowTypeUtilityAtom;
XSizeHints hints;
Cursor invisible_cursor = 0;
XWMHints* wm_hints = nullptr;
bool window_visible = true;
std::pair<int, int> position = { 0, 0 };
std::pair<int, int> size_before_fullscreen {0, 0};
};
using namespace ReWindow;
void RWindow::SetSize(const std::pair<int, int>& size) {
this->SetSize(size.first, size.second);
}
bool RWindow::SetCursorPosition(const std::pair<int, int>& position) {
if (!IsFocused())
return false;
if (!IsVisible())
return false;
if (position.first > GetWidth() || position.first < 0)
return false;
if (position.second > GetHeight() || position.second < 0)
return false;
// TODO XWarpPointer has no way to verify it actually happened.
XWarpPointer(platform->display, None, platform->window, 0, 0, 0, 0, position.first, position.second);
return true;
}
void RWindow::SetKeyRepeatEnabled(bool state) {
key_repeat = state;
if (state)
return (void) XAutoRepeatOn(platform->display);
XAutoRepeatOff(platform->display);
}
void RWindow::Flash() {
if (IsFocused())
return;
if (platform->wm_hints == nullptr)
platform->wm_hints = XAllocWMHints();
platform->wm_hints->flags = XUrgencyHint;
XSetWMHints(platform->display, platform->window, platform->wm_hints);
}
RWindow::RWindow() {
platform = new Platform();
extant = this;
}
void RWindow::SetCursorFocused(bool state) {
toggling_cursor_focus = state;
if (!state && cursor_focused) {
XUngrabPointer(platform->display, CurrentTime);
cursor_focused = state;
return;
}
}
std::pair<int, int> RWindow::SetCursorCenter() {
auto current_pos = GetAccurateCursorCoordinates();
XWarpPointer(platform->display, None, platform->window, 0, 0, 0, 0, width / 2, height / 2);
return current_pos;
}
RWindow::RWindow(const std::string& wTitle, int wWidth, int wHeight, bool wFullscreen, bool wResizable, bool wVsync)
: title(wTitle), width(wWidth), height(wHeight), fullscreen_mode(wFullscreen), resizable(wResizable), vsync(wVsync)
{ platform = new Platform(); extant = this; }
void RWindow::Raise() {
Logger::Debug(std::format("Raising window '{}'", this->title));
// Get the position of the renderable area relative to the rest of the window.
XGetWindowAttributes(platform->display, platform->window, &platform->windowAttributes);
XRaiseWindow(platform->display, platform->window);
}
void RWindow::DialogOK(const std::string& window_title, const std::string& message) {
int padding = 10;
XFontStruct* font = XLoadQueryFont(platform->display, "6x13");
int text_width = XTextWidth(font, message.c_str(), message.size());
int button_text_width = XTextWidth(font, "OK", 2);
std::pair<int, int> button_size = {80, 30};
std::pair<int, int> dimensions = { std::max(text_width + 2 * padding, button_size.first + 2 * padding), 82};
std::pair<int, int> text_pos = {(dimensions.first - text_width) / 2, padding + font->ascent};
std::pair<int, int> button_pos = { (dimensions.first - button_size.first) / 2, text_pos.second + font->ascent + padding };
Window window = XCreateSimpleWindow(platform->display, RootWindow(platform->display, platform->defaultScreen),
100, 100, dimensions.first, dimensions.second, 1,
BlackPixel(platform->display, platform->defaultScreen),
WhitePixel(platform->display, platform->defaultScreen));
XStoreName(platform->display, window, window_title.c_str());
XSelectInput(platform->display, window, ExposureMask | ButtonPressMask | StructureNotifyMask);
// No resizing.
XSizeHints hints;
hints.flags = PMinSize | PMaxSize;
hints.min_width = hints.max_width = dimensions.first;
hints.min_height = hints.max_height = dimensions.second;
XSetWMNormalHints(platform->display, window, &hints);
Atom wm_delete_window = XInternAtom(platform->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(platform->display, window, &wm_delete_window, 1);
XMapWindow(platform->display, window);
GC gc = XCreateGC(platform->display, window, 0, nullptr);
XSetForeground(platform->display, gc, BlackPixel(platform->display, platform->defaultScreen));
XEvent event;
while (true) {
XNextEvent(platform->display, &event);
if (event.type == Expose) {
XDrawString(platform->display, window, gc, text_pos.first, text_pos.second, message.c_str(), message.size());
XDrawString(platform->display, window, gc, button_pos.first + (button_size.first - button_text_width) / 2, button_pos.second + 20, "OK", 2);
XDrawRectangle(platform->display, window, gc, button_pos.first, button_pos.second, button_size.first, button_size.second);
}
else if (event.type == ClientMessage) {
if (event.xclient.message_type == XInternAtom(platform->display, "WM_PROTOCOLS", False) &&
static_cast<Atom>(event.xclient.data.l[0]) == wm_delete_window)
break;
}
else if (event.type == ButtonPress) {
if (event.xbutton.x >= button_pos.first && event.xbutton.x <= button_pos.first + button_size.first
&& event.xbutton.y >= button_pos.second && event.xbutton.y <= button_pos.second + button_size.second)
break;
}
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
XFreeFont(platform->display, font);
XFreeGC(platform->display, gc);
XDestroyWindow(platform->display, window);
}
void RWindow::Lower()
{
Logger::Debug(std::format("Lowering window '{}'", this->title));
XLowerWindow(platform->display, platform->window);
}
void RWindow::DestroyOSWindowHandle() {
// Turn key repeat back on.
XAutoRepeatOn(platform->display);
XFlush(platform->display);
Logger::Debug(std::format("Destroying sub-windows for window '{}'", this->title));
XDestroySubwindows(platform->display, platform->window);
Logger::Debug(std::format("Destroyed window '{}'", this->title));
XDestroyWindow(platform->display, platform->window);
XCloseDisplay(platform->display);
delete platform;
}
void RWindow::SetCursorVisible(bool cursor_enable) {
cursor_visible = cursor_enable;
if (platform->invisible_cursor == 0) {
Pixmap blank_pixmap = XCreatePixmap(platform->display, platform->window, 1, 1, 1);
XColor dummy; dummy.pixel = 0; dummy.red = 0; dummy.flags = 0;
platform->invisible_cursor = XCreatePixmapCursor(platform->display, blank_pixmap, blank_pixmap, &dummy, &dummy, 0, 0);
XFreePixmap(platform->display, blank_pixmap);
}
if (!cursor_enable)
XDefineCursor(platform->display, platform->window, platform->invisible_cursor);
if (cursor_enable)
XUndefineCursor(platform->display, platform->window);
}
void RWindow::DisableResizing() {
XGetWindowAttributes(platform->display, platform->window, &platform->windowAttributes);
platform->hints.flags = PMinSize | PMaxSize;
platform->hints.min_width = platform->hints.max_width = platform->windowAttributes.width;
platform->hints.min_height = platform->hints.max_height = platform->windowAttributes.height;
XSetWMNormalHints(platform->display, platform->window, &platform->hints);
this->resizable = false;
}
void RWindow::PollEvents() {
while(XPending(platform->display)) {
XNextEvent(platform->display, &platform->xev);
if (platform->xev.type == ClientMessage)
Logger::Info(std::format("Event '{}'", "ClientMessage"));
if (platform->xev.xclient.message_type == XInternAtom(platform->display, "WM_PROTOCOLS", False) &&
static_cast<Atom>(platform->xev.xclient.data.l[0]) == platform->wmDeleteWindow) {
Close();
}
if (platform->xev.type == FocusIn) {
Logger::Debug(std::format("Event'{}'", "FocusIn"));
if (!key_repeat)
XAutoRepeatOff(platform->display);
else
XAutoRepeatOn(platform->display);
XFlush(platform->display);
if (cursor_focused) {
cursor_focused = false;
SetCursorFocused(true);
}
if (platform->wm_hints) {
platform->wm_hints->flags &= ~XUrgencyHint;
XSetWMHints(platform->display, platform->window, platform->wm_hints);
XFree(platform->wm_hints);
}
if (!cursor_visible)
XDefineCursor(platform->display, platform->window, platform->invisible_cursor);
// Get the position of the renderable area relative to the rest of the window.
XGetWindowAttributes(platform->display, platform->window, &platform->windowAttributes);
processFocusIn();
focused = true;
}
if (platform->xev.type == UnmapNotify) {
if (cursor_focused) {
SetCursorFocused(false);
cursor_focused = true;
}
}
if (platform->xev.type == FocusOut) {
Logger::Debug(std::format("Event '{}'", "FocusOut"));
XAutoRepeatOn(platform->display);
XFlush(platform->display);
if (cursor_focused) {
SetCursorFocused(false);
cursor_focused = true;
}
if (!cursor_visible)
XUndefineCursor(platform->display, platform->window);
processFocusOut();
focused = false;
}
if (platform->xev.type == KeyRelease) {
Logger::Debug(std::format("Event '{}'", "KeyRelease"));
auto scancode = (X11Scancode) platform->xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyRelease(key);
}
if (platform->xev.type == KeyPress) {
Logger::Debug(std::format("Event '{}'", "KeyPress"));
auto scancode = (X11Scancode) platform->xev.xkey.keycode;
auto key = GetKeyFromX11Scancode(scancode);
processKeyPress(key);
}
if (platform->xev.type == ButtonRelease) {
// Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
// Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
// and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
if (platform->xev.xbutton.button != 4 && platform->xev.xbutton.button != 5) {
MouseButton button = GetMouseButtonFromXButton(platform->xev.xbutton.button);
Logger::Debug(std::format("Event '{}'", "ButtonRelease"));
processMouseRelease(button);
}
}
if (platform->xev.type == ButtonPress) {
// Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
// Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
// and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
if (platform->xev.xbutton.button == 4) {
processMouseWheel(-1);
} else if (platform->xev.xbutton.button == 5) {
processMouseWheel(1);
} else {
MouseButton button = GetMouseButtonFromXButton(platform->xev.xbutton.button);
Logger::Debug(std::format("Event: MouseButtonPress {}", button.Mnemonic));
processMousePress(button);
}
}
if (platform->xev.type == Expose) {
Logger::Debug(std::format("Event '{}'", "Expose"));
}
if (platform->xev.type == MotionNotify) {
if (toggling_cursor_focus) {
XWindowAttributes attrs;
XGetWindowAttributes(platform->display, platform->window, &attrs);
if (attrs.map_state == IsViewable) {
int result = XGrabPointer
(
platform->display, platform->window, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, platform->window, None, CurrentTime
);
if (result == GrabSuccess) {
toggling_cursor_focus = false;
cursor_focused = true;
}
}
}
}
if (platform->xev.type == ConfigureNotify) {
if (this->width != platform->xev.xconfigurerequest.width ||
this->height != platform->xev.xconfigurerequest.height) {
Logger::Debug(std::format("Event '{}'", "ResizeRequest"));
this->width = platform->xev.xconfigurerequest.width;
this->height = platform->xev.xconfigurerequest.height;
auto eventData = WindowResizeRequestEvent();
eventData.Size = {platform->xev.xconfigurerequest.width, platform->xev.xconfigurerequest.height};
OnResizeRequest(eventData);
OnResizeRequestEvent(eventData);
}
//Window Moved.
if (platform->position.first != platform->xev.xconfigurerequest.x || platform->position.second != platform->xev.xconfigurerequest.y)
platform->position = { platform->xev.xconfigurerequest.x, platform->xev.xconfigurerequest.y };
}
if (platform->xev.type == VisibilityNotify) {
if (platform->xev.xvisibility.state == VisibilityFullyObscured)
platform->window_visible = false;
else if (platform->xev.xvisibility.state == VisibilityUnobscured ||
platform->xev.xvisibility.state == VisibilityPartiallyObscured)
platform->window_visible = true;
}
}
previousKeyboard = currentKeyboard;
previousMouse.Buttons = currentMouse.Buttons;
}
// Might make the window go off the screen on some window managers.
void RWindow::SetSize(int newWidth, int newHeight) {
if (!resizable)
return;
this->width = newWidth;
this->height = newHeight;
XResizeWindow(platform->display, platform->window, newWidth, newHeight);
XFlush(platform->display);
Logger::Info(std::format("Set size for '{}' to {} x {}", this->title, newWidth, newHeight));
}
std::pair<int, int> RWindow::GetAccurateCursorCoordinates() const {
Window root_return, child_return;
int root_x_ret, root_y_ret;
int win_x_ret, win_y_ret;
uint32_t mask_return;
// This seems to be relative to the top left corner of the renderable area.
bool mouseAvailable = XQueryPointer(platform->display, platform->window, &root_return, &child_return, &root_x_ret, &root_y_ret, &win_x_ret, &win_y_ret, &mask_return);
if (mouseAvailable) {
// TODO: normalize coordinates from platform->displaySpace to windowSpace
// TODO: fire mouse movement event
std::pair<int, int> m_coords = { win_x_ret, win_y_ret };
return m_coords;
}
return {};
}
bool RWindow::IsVisible() const {
return platform->window_visible;
}
// TODO: implement integer std::pair<int, int>/3 types
std::pair<int, int> RWindow::GetPosition() const {
return platform->position;
}
std::pair<int, int> RWindow::GetSize() const { return { this->width, this->height }; }
void RWindow::SetPosition(int x, int y) {
XMoveWindow(platform->display, platform->window, x, y);
platform->position = {x, y};
}
void RWindow::SetPosition(const std::pair<int, int>& pos) {
SetPosition(pos.first, pos.second);
}
void RWindow::Fullscreen() {
platform->size_before_fullscreen = GetSize();
if (!this->resizable) {
XSizeHints hints;
hints.flags = PMinSize | PMaxSize;
hints.min_width = 0;
hints.min_height = 0;
hints.max_width = 100000;
hints.max_height = 100000;
XSetWMNormalHints(platform->display, platform->window, &hints);
XFlush(platform->display);
}
Atom wm_state = XInternAtom(platform->display, "_NET_WM_STATE", False);
Atom wm_fullscreen = XInternAtom(platform->display, "_NET_WM_STATE_FULLSCREEN", False);
if (!wm_state || !wm_fullscreen) {
Logger::Error("We don't have the required atom for fullscreen graphics mode?");
return;
}
XEvent xev{};
xev.type = ClientMessage;
xev.xclient.window = platform->window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = wm_fullscreen;
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 1;
xev.xclient.data.l[4] = 0;
XSendEvent(platform->display,
DefaultRootWindow(platform->display),
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&xev);
XFlush(platform->display);
fullscreen_mode = true;
Logger::Debug(std::format("Fullscreened '{}'", this->title));
}
void RWindow::RestoreFromFullscreen() {
Atom wm_state = XInternAtom(platform->display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(platform->display, "_NET_WM_STATE_FULLSCREEN", False);
if (!wm_state || !fullscreen) {
Logger::Error("We don't have the required atom for fullscreen graphics mode?");
return;
}
XEvent xev{};
xev.type = ClientMessage;
xev.xclient.window = platform->window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 0;
xev.xclient.data.l[1] = fullscreen;
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 1;
xev.xclient.data.l[4] = 0;
XSendEvent(
platform->display,
DefaultRootWindow(platform->display),
False,
SubstructureNotifyMask | SubstructureRedirectMask,
&xev
);
if (!this->resizable) {
XSizeHints hints;
hints.flags = PMinSize | PMaxSize;
hints.min_width = hints.max_width = platform->size_before_fullscreen.first;
hints.min_height = hints.max_height = platform->size_before_fullscreen.second;
XSetWMNormalHints(platform->display, platform->window, &hints);
this->width = platform->size_before_fullscreen.first;
this->height = platform->size_before_fullscreen.second;
}
XFlush(platform->display);
fullscreen_mode = false;
Logger::Debug(std::format("Restored '{}' from Fullscreen", this->title));
}
void RWindow::SetCursorStyle(CursorStyle style) const {
auto x11_cursor_resolved_enum = (unsigned int) style.X11Cursor;
Cursor c = XCreateFontCursor(platform->display, x11_cursor_resolved_enum);
XDefineCursor(platform->display, platform->window, c);
}
void RWindow::SetTitle(const std::string& title) {
this->title = title;
XStoreName(platform->display, platform->window, title.c_str());
}

View File

@@ -0,0 +1,74 @@
#include <ReWindow/Display.hpp>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#include <stdexcept>
using namespace ReWindow;
std::vector<ReWindow::Display> ReWindow::Display::getDisplaysFromWindowManager() {
std::vector<ReWindow::Display> result;
_XDisplay* display = XOpenDisplay(nullptr);
if (!display)
throw std::runtime_error("There isn't an X11 root display????");
Window root_window = DefaultRootWindow(display);
XRRScreenResources* screen_resources = XRRGetScreenResources(display, root_window);
if (!screen_resources)
throw std::runtime_error("Failed to get screen resources.");
for (int i = 0; i < screen_resources->noutput; i++) {
RROutput output = screen_resources->outputs[i];
XRROutputInfo* output_info = XRRGetOutputInfo(display, screen_resources, output);
if (output_info->connection == RR_Connected) {
ReWindow::Display d;
XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(display, screen_resources, output_info->crtc);
if (!crtc_info)
throw std::runtime_error("Failed to get CRT info.");
u32 default_width = (u32) crtc_info->width;
u32 default_height = (u32) crtc_info->height;
short default_refresh_rate = 0;
for (int k = 0; k < screen_resources->nmode; k++) {
if (screen_resources->modes[k].id == crtc_info->mode) {
XRRModeInfo mode_info = screen_resources->modes[k];
double refresh_rate;
if (mode_info.hTotal > 0 && mode_info.vTotal > 0)
refresh_rate = mode_info.dotClock / (double)(mode_info.hTotal * mode_info.vTotal),
default_refresh_rate = (short)refresh_rate;
d.default_graphics_mode = {default_width, default_height, default_refresh_rate};
break;
}
}
for (int j = 0; j < output_info->nmode; j++) {
RRMode mode = output_info->modes[j];
for (int k = 0; k < screen_resources->nmode; k++) {
if (screen_resources->modes[k].id == mode) {
XRRModeInfo mode_info = screen_resources->modes[k];
// Calculate Refresh rate from the mode's dot clock
double refresh_rate = 0.0;
if (mode_info.hTotal > 0 && mode_info.vTotal > 0)
refresh_rate = mode_info.dotClock / (double)(mode_info.hTotal * mode_info.vTotal);
d.graphics_modes.emplace_back((u32) mode_info.width,(u32) mode_info.height,(short) refresh_rate);
}
}
}
XRRFreeCrtcInfo(crtc_info);
result.push_back(d);
}
XRRFreeOutputInfo(output_info);
}
XRRFreeScreenResources(screen_resources);
XCloseDisplay(display);
return result;
}

View File

@@ -1,252 +0,0 @@
#include <ReWindow/types/Window.h>
#include <ReWindow/InputService.h>
#include <ReWindow/Logger.h>
using namespace ReWindow;
RWindow::~RWindow() {
if (open)
DestroyOSWindowHandle();
}
std::pair<int, int> RWindow::GetCursorPosition() const {
return currentMouse.Position;
}
bool RWindow::IsAlive() const {
return (!closing) && open;
}
void RWindow::SetFullscreen(bool fs) {
if (fs)
Fullscreen();
else
RestoreFromFullscreen();
}
#pragma region Event Processors Implementation
void RWindow::processFocusIn() {
RWindowEvent event {};
OnFocusGain(event);
OnFocusGainEvent(event);
LogEvent(event);
}
void RWindow::processFocusOut() {
RWindowEvent event {};
OnFocusLost(event);
OnFocusLostEvent(event);
LogEvent(event);
}
void RWindow::processMousePress(const MouseButton& btn) {
currentMouse.Set(btn, true);
auto event = MouseButtonDownEvent(btn);
OnMouseButtonDown(event);
OnMouseButtonDownEvent(event);
InputService::OnMouseButtonEvent(MouseButtonEvent(btn, true));
InputService::OnMouseDown(event);
LogEvent(event);
}
void RWindow::processMouseMove(const std::pair<int, int>& last_pos, const std::pair<int, int>& new_pos) {
currentMouse.Position = new_pos;
auto event = MouseMoveEvent(new_pos);
OnMouseMove(event);
OnMouseMoveEvent(event);
InputService::OnMouseMove(event);
LogEvent(event);
}
void RWindow::processMouseRelease(const MouseButton& btn) {
currentMouse.Set(btn, false);
auto event = MouseButtonUpEvent(btn);
OnMouseButtonUp(event);
OnMouseButtonUpEvent(event);
InputService::OnMouseButtonEvent(MouseButtonEvent(btn, false));
InputService::OnMouseUp(event);
LogEvent(event);
}
void RWindow::processKeyRelease(Key key) {
currentKeyboard.PressedKeys[key] = false;
auto event = KeyUpEvent(key);
OnKeyUp(event);
OnKeyUpEvent(event);
InputService::OnKeyboardEvent(KeyboardEvent(key, KeyState::Released));
InputService::OnKeyEvent(KeyboardEvent(key, KeyState::Released));
InputService::OnKeyUp(event);
LogEvent(event);
}
void RWindow::processKeyPress(Key key) {
currentKeyboard.PressedKeys[key] = true;
auto event = KeyDownEvent(key);
OnKeyDown(event);
OnKeyDownEvent(event);
InputService::OnKeyDown(event);
InputService::OnKeyboardEvent(KeyboardEvent(key, KeyState::Pressed));
InputService::OnKeyEvent(KeyboardEvent(key, KeyState::Pressed));
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; }
int RWindow::GetWidth() const { return this->width; }
int RWindow::GetHeight() const { return this->height; }
bool RWindow::IsResizable() const { return resizable; }
bool RWindow::IsFullscreen() const { return fullscreen_mode; }
bool RWindow::IsFocused() const { return focused; }
bool RWindow::IsVsyncEnabled() const { return vsync; }
float RWindow::GetDeltaTime() const { return delta_time; }
float RWindow::GetRefreshRate() const { return refresh_rate; }
bool RWindow::SetCursorPosition(const int x, const int y) { return SetCursorPosition({x, y}); }
unsigned long long RWindow::GetRefreshCount() const { return refresh_count; }
void RWindow::SetSizeWithoutEvent(const std::pair<int, int>& size) {
width = size.first;
height = size.second;
}
bool RWindow::IsKeyDown(Key key) const {
if (currentKeyboard.PressedKeys.contains(key))
return currentKeyboard.PressedKeys.at(key);
return false; // NOTE: Key may not be mapped!!
}
bool RWindow::IsMouseButtonDown(const MouseButton& button) const {
// TODO: Implement MouseButton map
return currentMouse.IsDown(button);
}
void RWindow::ManagedRefresh() {
auto begin = GetTimestamp();
Refresh();
auto end = GetTimestamp();
float dt = ComputeElapsedFrameTimeSeconds(begin, end);
UpdateFrameTiming(dt);
}
void RWindow::Refresh() {
PollEvents();
OnRefresh(delta_time);
// Only call once and cache the result.
currentMouse.Position = GetAccurateCursorCoordinates();
if (currentMouse.Position != previousMouse.Position) {
processMouseMove(previousMouse.Position, currentMouse.Position);
previousMouse.Position = currentMouse.Position;
}
}
bool RWindow::GetCursorFocused() {
return cursor_focused;
}
float RWindow::ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) {
auto frame_time = end - start;
unsigned long int frame_time_us = std::chrono::duration_cast<std::chrono::microseconds>(frame_time).count();
float frame_time_s = frame_time_us / (1000.f * 1000.f);
return frame_time_s;
}
std::chrono::steady_clock::time_point RWindow::GetTimestamp() {
return std::chrono::steady_clock::now();
}
void RWindow::UpdateFrameTiming(float frame_time) {
delta_time = frame_time;
refresh_rate = 1.f / delta_time;
refresh_rate_prev_5 = refresh_rate_prev_4;
refresh_rate_prev_4 = refresh_rate_prev_3;
refresh_rate_prev_3 = refresh_rate_prev_2;
refresh_rate_prev_2 = refresh_rate_prev_1;
refresh_rate_prev_1 = refresh_rate;
avg_refresh_rate = (refresh_rate_prev_1 + refresh_rate_prev_2 + refresh_rate_prev_3 + refresh_rate_prev_4 + refresh_rate_prev_5) / 5.f;
refresh_count++;
}
void RWindow::processMouseWheel(int scrolls) {
currentMouse.Wheel += scrolls;
auto ev = MouseWheelEvent(scrolls);
OnMouseWheel(ev);
OnMouseWheelEvent(ev);
previousMouse.Wheel = currentMouse.Wheel;
}
void RWindow::Close() {
closing = true;
processOnClose();
}
void RWindow::ForceClose() {
Close();
DestroyOSWindowHandle();
}
bool MouseState::IsDown(const MouseButton& btn) const {
if (btn == MouseButtons::Left) return Buttons.LMB;
if (btn == MouseButtons::Right) return Buttons.RMB;
if (btn == MouseButtons::Middle) return Buttons.MMB;
if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
//if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
//if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
return false; // Unknown button?
}
void MouseState::Set(const MouseButton& btn, bool state) {
if (btn == MouseButtons::Left) Buttons.LMB = state;
if (btn == MouseButtons::Right) Buttons.RMB = state;
if (btn == MouseButtons::Middle) Buttons.MMB = state;
if (btn == MouseButtons::Mouse4) Buttons.SideButton1 = state;
if (btn == MouseButtons::Mouse5) Buttons.SideButton2 = state;
//if (btn == MouseButtons::MWheelUp) Buttons.MWheelUp = state;
//if (btn == MouseButtons::MWheelDown) Buttons.MWheelDown = state;
}
bool &MouseState::operator [](const MouseButton& btn) {
if (btn == MouseButtons::Left) return Buttons.LMB;
if (btn == MouseButtons::Right) return Buttons.RMB;
if (btn == MouseButtons::Middle) return Buttons.MMB;
if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
//if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
//if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
throw std::invalid_argument("Attempted to handle unmapped mouse button.");
}

View File

@@ -0,0 +1,34 @@
#include <ReWindow/Display.hpp>
using namespace ReWindow;
FullscreenGraphicsMode::FullscreenGraphicsMode(u32 width, u32 height, short refresh_rate) {
this->width = width;
this->height = height;
this->refresh_rate = refresh_rate;
}
u32 FullscreenGraphicsMode::getWidth() const {
return width;
}
u32 FullscreenGraphicsMode::getHeight() const {
return height;
}
float FullscreenGraphicsMode::getRefreshRate() const {
return refresh_rate;
}
FullscreenGraphicsMode Display::getDefaultGraphicsMode() {
return default_graphics_mode;
}
std::vector<FullscreenGraphicsMode> Display::getGraphicsModes() {
return graphics_modes;
}
Display::Display(const FullscreenGraphicsMode& default_graphics_mode, const std::vector<FullscreenGraphicsMode>& graphics_modes) {
this->default_graphics_mode = default_graphics_mode;
this->graphics_modes = graphics_modes;
}

View File

@@ -1,511 +0,0 @@
#include <Windows.h>
#include <gl/GL.h>
#include <ReWindow/types/Window.h>
#include <ReWindow/Logger.h>
class ReWindow::RWindow::Platform {
public:
HINSTANCE hInstance;
HWND hwnd;
HDC hdc;
std::pair<int, int> window_size_before_fullscreen;
std::pair<int, int> window_position_before_fullscreen;
};
using namespace ReWindow;
// TODO get rid of this.
bool local_focused = true;
bool local_toggling_cursor_focused = false;
void RWindow::SetSize(int newWidth, int newHeight) {
if (!resizable)
return;
this->width = newWidth;
this->height = newHeight;
DWORD style = GetWindowLong(platform->hwnd, GWL_STYLE);
DWORD exStyle = GetWindowLong(platform->hwnd, GWL_EXSTYLE);
RECT rect = { 0, 0, newWidth, newHeight };
AdjustWindowRectEx(&rect, style, FALSE, exStyle);
int totalWidth = rect.right - rect.left;
int totalHeight = rect.bottom - rect.top;
SetWindowPos(platform->hwnd, nullptr, 0, 0, totalWidth, totalHeight,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
}
void RWindow::SetCursorFocused(bool state) {
local_toggling_cursor_focused = state;
if (state)
cursor_focused = true;
else if (!state && cursor_focused) {
ClipCursor(nullptr);
cursor_focused = false;
local_toggling_cursor_focused = false;
}
}
bool RWindow::SetCursorPosition(const std::pair<int, int>& position) {
if (!IsFocused())
return false;
if (!IsVisible())
return false;
if (position.first < 0 || position.first > GetWidth())
return false;
if (position.second < 0 || position.second > GetHeight())
return false;
POINT screen_pos = { position.first, position.second };
if (!ClientToScreen(platform->hwnd, &screen_pos))
return false;
if (!SetCursorPos(screen_pos.x, screen_pos.y))
return false;
return true;
}
std::pair<int, int> RWindow::SetCursorCenter() {
auto current_cursor_pos = GetAccurateCursorCoordinates();
RECT client_rect;
GetClientRect(platform->hwnd, &client_rect);
POINT center((client_rect.right - client_rect.left) / 2, (client_rect.bottom - client_rect.top) / 2 );
ClientToScreen(platform->hwnd, &center);
SetCursorPos(center.x, center.y);
return current_cursor_pos;
}
void RWindow::PollEvents() {
MSG msg;
while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
TranslateMessage(&msg),
DispatchMessage(&msg);
focused = local_focused;
}
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
auto* window = reinterpret_cast<RWindow*>( GetWindowLongPtr(hwnd, GWLP_USERDATA) );
switch (uMsg) {
case WM_CLOSE: {
window->processOnClose();
DestroyWindow(hwnd);
}
case WM_DESTROY: {
exit(0);
}
case WM_SIZE: {
window->SetSizeWithoutEvent({ LOWORD(lParam), HIWORD(lParam) });
auto eventData = WindowResizeRequestEvent();
eventData.Size = { window->GetWidth(), window->GetHeight() };
// TODO: Implement eWindow->processOnResize()
window->OnResizeRequest(eventData);
window->OnResizeRequestEvent(eventData);
break;
}
case WM_SETFOCUS: {
window->processFocusIn();
local_focused = true;
if (window->GetCursorFocused())
local_toggling_cursor_focused = true;
// Cancels window flashing.
// TODO check if we're flashing before this.
static FLASHWINFO flash_inter {sizeof(FLASHWINFO), hwnd, FLASHW_STOP, 0, 0};
FlashWindowEx(&flash_inter);
break;
}
case WM_KILLFOCUS: {
window->processFocusOut();
if (window->GetCursorFocused()) {
ClipCursor(nullptr);
local_toggling_cursor_focused = true;
}
local_focused = false;
}
case WM_SETCURSOR: {
if (LOWORD(lParam) == HTCLIENT && window->GetCursorVisible() == false)
SetCursor(nullptr);
break;
}
case WM_KEYDOWN: {
auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
if (window->IsKeyRepeat())
window->processKeyPress(key);
else if ((lParam & 1 << 30) == 0)
window->processKeyPress(key);
break;
}
case WM_KEYUP: {
auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
window->processKeyRelease(key);
break;
}
// Mouse Buttons.
case WM_MOUSEWHEEL: {
int wheel_delta = GET_WHEEL_DELTA_WPARAM(wParam);
// Clamp to normalized range [+1 or -1].
// TODO: Test this and make sure sign is the same on both platforms for each direction.
wheel_delta = (wheel_delta > 0) ? 1 : -1;
// TODO: Determine sign of wheel_delta for each direction, (and on linux too), and document this.
window->processMouseWheel(wheel_delta);
break;
}
case WM_LBUTTONDOWN: {
window->processMousePress(MouseButtons::Left);
break;
}
case WM_LBUTTONUP: {
window->processMouseRelease(MouseButtons::Left);
break;
}
case WM_RBUTTONDOWN: {
window->processMousePress(MouseButtons::Right);
break;
}
case WM_RBUTTONUP: {
window->processMouseRelease(MouseButtons::Right);
break;
}
case WM_MBUTTONDOWN: {
window->processMousePress(MouseButtons::Middle);
break;
}
case WM_MBUTTONUP: {
window->processMouseRelease(MouseButtons::Middle);
break;
}
case WM_XBUTTONDOWN: {
WORD button = GET_XBUTTON_WPARAM(wParam);
if (button == XBUTTON1)
window->processMousePress(MouseButtons::Mouse4);
if (button == XBUTTON2)
window->processMousePress(MouseButtons::Mouse5);
break;
}
case WM_XBUTTONUP: {
WORD button = GET_XBUTTON_WPARAM(wParam);
if (button == XBUTTON1)
window->processMouseRelease(MouseButtons::Mouse4);
if (button == XBUTTON2)
window->processMouseRelease(MouseButtons::Mouse5);
break;
}
//This is the same as "Motion Notify" in the X Window System.
case WM_MOUSEMOVE: {
if (local_toggling_cursor_focused) {
RECT rect;
if (GetClientRect(hwnd, &rect)) {
POINT top_left = { rect.left, rect.top };
POINT bottom_right = { rect.right, rect.bottom };
MapWindowPoints(hwnd, nullptr, &top_left, 1);
MapWindowPoints(hwnd, nullptr, &bottom_right, 1);
RECT clip_rect = { top_left.x, top_left.y, bottom_right.x, bottom_right.y };
if (ClipCursor(&clip_rect))
local_toggling_cursor_focused = false;
}
}
}
break;
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
bool fullscreenmode = false;
bool open = false;
void RWindow::Raise() { SetWindowPos(platform->hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
void RWindow::Lower() { SetWindowPos(platform->hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
//TODO somehow check if our window is entirely obscured by other windows.
bool RWindow::IsVisible() const {
if (!IsWindow(platform->hwnd))
return false;
if (IsIconic(platform->hwnd))
return false;
return true;
}
void RWindow::Flash() {
if (!focused) {
FLASHWINFO fi;
fi.cbSize = sizeof(FLASHWINFO);
fi.hwnd = platform->hwnd;
fi.dwFlags = FLASHW_ALL;
fi.uCount = 0;
fi.dwTimeout = 0;
FlashWindowEx(&fi);
}
}
void RWindow::DestroyOSWindowHandle() {
DestroyWindow(platform->hwnd);
}
void RWindow::DisableResizing() {
RECT rect;
GetWindowRect(platform->hwnd, &rect);
LONG style = GetWindowLong(platform->hwnd, GWL_STYLE);
style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
SetWindowLong(platform->hwnd, GWL_STYLE, style);
SetWindowPos(platform->hwnd, nullptr, rect.left, rect.top, rect.right - rect.left,
rect.bottom - rect.top, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
this->resizable = false;
}
std::pair<int, int> RWindow::GetAccurateCursorCoordinates() const {
POINT point;
GetCursorPos(&point);
ScreenToClient(platform->hwnd, &point);
return { point.x, point.y };
}
void RWindow::SetCursorVisible(bool cursor_enable) {
cursor_visible = cursor_enable;
}
bool RWindow::GetCursorVisible() {
return cursor_visible;
}
void RWindow::SetKeyRepeatEnabled(bool state) {
key_repeat = state;
}
std::pair<int, int> RWindow::GetSize() const {
RECT rect;
GetClientRect(platform->hwnd, &rect);
return { (rect.right - rect.left), (rect.bottom - rect.top) };
}
std::pair<int, int> RWindow::GetPosition() const {
RECT rect;
if (GetWindowRect(platform->hwnd, &rect))
return { rect.left, rect.top };
return { -1, -1 };
}
void RWindow::SetPosition(int x, int y) {
SetWindowPos(platform->hwnd, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}
void RWindow::SetPosition(const std::pair<int, int>& pos) {
SetPosition(pos.first, pos.second);
}
void RWindow::Fullscreen() {
platform->window_position_before_fullscreen = GetPosition();
platform->window_size_before_fullscreen = GetSize();
platform->window_position_before_fullscreen = this->GetPosition();
SetWindowLong(platform->hwnd, GWL_STYLE, GetWindowLong(platform->hwnd, GWL_STYLE) & ~WS_OVERLAPPEDWINDOW);
SetWindowPos(platform->hwnd, HWND_TOP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_FRAMECHANGED | SWP_NOOWNERZORDER);
fullscreen_mode = true;
}
void RWindow::RestoreFromFullscreen() {
SetWindowLong(platform->hwnd, GWL_STYLE, GetWindowLong(platform->hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW);
RECT rect = {0, 0, platform->window_size_before_fullscreen.first, platform->window_size_before_fullscreen.second };
AdjustWindowRectEx(&rect, GetWindowLong(platform->hwnd, GWL_STYLE), FALSE, GetWindowLong(platform->hwnd, GWL_EXSTYLE));
int window_width = rect.right - rect.left;
int window_height = rect.bottom - rect.top;
SetWindowPos(
platform->hwnd,
nullptr,
platform->window_position_before_fullscreen.first,
platform->window_position_before_fullscreen.second,
window_width,
window_height,
SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER
);
DisableResizing();
this->width = platform->window_position_before_fullscreen.first;
this->height = platform->window_position_before_fullscreen.second;
fullscreen_mode = false;
}
void RWindow::SetCursorStyle(CursorStyle style) const {}
RWindow::RWindow() {
extant = this;
platform = new Platform();
}
RWindow::RWindow(const std::string& wTitle, int wWidth, int wHeight,
bool wFullscreen, bool wResizable, bool wVsync) :
title(wTitle), width(wWidth), height(wHeight), fullscreen_mode(wFullscreen), resizable(wResizable),
vsync(wVsync) {
extant = this;
platform = new Platform();
}
void RWindow::DialogOK(const std::string& title, const std::string& message_box_text) {
MessageBox(nullptr, message_box_text.c_str(), title.c_str(), MB_OK);
}
HGLRC glContext;
HMODULE gl_lib = nullptr;
bool constructor_success = true;
namespace OpenGL {
typedef const GLubyte* (APIENTRY *GLGETSTRINGPROC)(GLenum name);
GLGETSTRINGPROC glGetString = nullptr;
typedef BOOL (WINAPI *WGLMAKECURRENTPROC)(HDC hdc, HGLRC hglrc);
WGLMAKECURRENTPROC wglMakeCurrent = nullptr;
typedef FARPROC (WINAPI *WGLGETPROCADDRPROC)(LPCSTR lpszProc);
WGLGETPROCADDRPROC wglGetProcAddress = nullptr;
typedef HGLRC (WINAPI *WGLCREATECONTEXTPROC)(HDC hdc);
WGLCREATECONTEXTPROC wglCreateContext = nullptr;
}
bool OpenGLWindow::Open() {
if (!constructor_success)
return false;
platform->hInstance = GetModuleHandle(nullptr);
WNDCLASS wc = { };
wc.lpfnWndProc = WindowProc;
wc.hInstance = platform->hInstance;
wc.lpszClassName = "RWindowClass";
RegisterClass(&wc);
RECT rect = { 0, 0, width, height };
AdjustWindowRectEx(&rect, WS_OVERLAPPEDWINDOW, FALSE, 0);
int win_width = rect.right - rect.left;
int win_height = rect.bottom - rect.top;
platform->hwnd = CreateWindowEx(
0,
"RWindowClass",
title.c_str(),
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, win_width, win_height,
nullptr,
nullptr,
platform->hInstance,
nullptr
);
SetWindowLongPtr(platform->hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
24,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24,
8,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};
platform->hdc = GetDC(platform->hwnd);
int pixelFormat = ChoosePixelFormat(platform->hdc, &pfd);
SetPixelFormat(platform->hdc, pixelFormat, &pfd);
glContext = OpenGL::wglCreateContext(platform->hdc);
OpenGL::wglMakeCurrent(platform->hdc, glContext);
ShowWindow(platform->hwnd, SW_SHOW);
open = true;
return true;
}
std::string OpenGLWindow::GetGraphicsDriverVendor() {
return std::string(reinterpret_cast<const char*>(OpenGL::glGetString(GL_VENDOR)));
}
void OpenGLWindow::SwapBuffers() {
::SwapBuffers(platform->hdc);
}
void OpenGLWindow::SetVsyncEnabled(bool b) {
typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC)(int interval);
auto wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) OpenGL::wglGetProcAddress("wglSwapIntervalEXT");
if (wglSwapIntervalEXT)
wglSwapIntervalEXT(b ? 1 : 0);
}
bool OpenGLWindow::SoftwareRendered() {
std::string renderer(reinterpret_cast<const char*>(OpenGL::glGetString(GL_RENDERER)));
if (renderer.find("llvmpipe"))
return true;
if (renderer.find("softpipe"))
return true;
if (renderer.find("GDI Generic"))
return true;
if (GetGraphicsDriverVendor().find("Mesa"))
return true;
return false;
}
OpenGLWindow::OpenGLWindow(const std::string& title, int width, int height, uint8_t gl_major, uint8_t gl_minor)
: gl_major(gl_major), gl_minor(gl_minor), RWindow(title, width, height) {
gl_lib = LoadLibrary("opengl32.dll");
if (!gl_lib)
Logger::Error("opengl32.dll couldn't be found. If you have it, you can try putting it in the same directory as the executable."),
constructor_success = false;
OpenGL::glGetString = (OpenGL::GLGETSTRINGPROC) GetProcAddress(gl_lib, "glGetString");
OpenGL::wglMakeCurrent = (OpenGL::WGLMAKECURRENTPROC) GetProcAddress(gl_lib, "wglMakeCurrent");
OpenGL::wglGetProcAddress = (OpenGL::WGLGETPROCADDRPROC) GetProcAddress(gl_lib, "wglGetProcAddress");
OpenGL::wglCreateContext = (OpenGL::WGLCREATECONTEXTPROC) GetProcAddress(gl_lib, "wglCreateContext");
}

View File

@@ -1,7 +0,0 @@
#include <ReWindow/types/WindowEvents.h>
namespace ReWindow
{
}