fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Refactor on platform implementation. See comment in interface/platform.h for more info

Browse Source
This commit is contained in:
Medusa Slockbower
2025-07-27 22:44:32 -04:00
parent d02a51fd8d
commit 8124ea2ae5
45 changed files with 4650 additions and 826 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/fennec/containers/array.h
View File

@@ -42,9 +42,13 @@ namespace fennec
///
/// \brief wrapper for fixed size arrays
///
/// \details | | |
/// |-|-|
/// | | |
/// \details
/// | Property | Value |
/// |----------|-------------------------|
/// | stable | \emoji heavy_check_mark |
/// | access | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
///
/// \tparam ValueT value type
/// \tparam ElemV number of elements
template<typename ValueT, size_t ElemV>

23
include/fennec/containers/dynarray.h
View File

@@ -38,6 +38,19 @@
namespace fennec
{
///
///
/// \brief wrapper for dynamically sized arrays
/// \details
/// | Property | Value |
/// |-----------|--------------|
/// | stable | \emoji anger |
/// | access | \f$O(1)\f$ |
/// | insertion | \f$O(N)\f$ |
/// | deletion | \f$O(N)\f$ |
/// | space | \f$O(N)\f$ |
///
/// \tparam TypeT value type
template<class TypeT, class Alloc = allocator<TypeT>>
class dynarray {
public:
@@ -123,12 +136,14 @@ public:
return _size == 0;
}
constexpr TypeT& operator[](size_t i) {
assertd(i < _size, "Array Out of Bounds"); return _alloc.data()[i];
constexpr TypeT& operator[](int i) {
assertd(i >= 0 and size_t(i) < _size, "Array Out of Bounds");
return _alloc.data()[i];
}
constexpr const TypeT& operator[](size_t i) const {
assertd(i < _size, "Array Out of Bounds"); return _alloc.data()[i];
constexpr const TypeT& operator[](int i) const {
assertd(i >= 0 and size_t(i) < _size, "Array Out of Bounds");
return _alloc.data()[i];
}
constexpr TypeT* begin() { return _alloc.data(); }

186
include/fennec/containers/list.h
View File

@@ -16,6 +16,18 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
///
/// \file list.h
/// \brief List of elements
///
///
/// \details
/// \author Medusa Slockbower
///
/// \copyright Copyright © 2025 Medusa Slockbower ([GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html))
///
///
#ifndef FENNEC_CONTAINERS_LIST_H
#define FENNEC_CONTAINERS_LIST_H
@@ -26,11 +38,22 @@
#include <fennec/math/common.h>
#include <fennec/platform/interface/window.h>
namespace fennec
{
///
///
/// \brief wrapper for lists of elements
/// \details
/// | Property | Value |
/// |-----------|--------------|
/// | stable | \emoji anger |
/// | access | \f$O(1)\f$ |
/// | insertion | \f$O(1)\f$ |
/// | deletion | \f$O(1)\f$ |
/// | space | \f$O(N)\f$ |
///
/// \tparam TypeT value type
template<class TypeT, class Alloc = allocator<TypeT>>
struct list {
public:
@@ -41,63 +64,7 @@ public:
class iterator;
private:
struct node {
optional<value_t> data;
size_t prev, next;
constexpr node()
: data()
, prev(npos)
, next(npos) {
}
constexpr node(size_t p, size_t n)
: data()
, prev(p)
, next(n) {
}
constexpr node(size_t p, size_t n, value_t&& val)
: data(fennec::forward<value_t>(val))
, prev(p)
, next(n) {
}
constexpr ~node() = default;
constexpr void clear() {
data = nullopt;
prev = npos;
next = npos;
}
};
size_t _next(size_t n) {
return _table[n].next;
}
size_t _prev(size_t n) {
return _table[n].prev;
}
size_t _walk(size_t i) {
size_t n = _root;
if (n == npos) return n;
while (i > 0 && n != npos) {
n = _next(n); --i;
}
return n;
}
size_t _next_free() {
if (not _freed.empty()) {
size_t n = _freed.back();
_freed.pop_back();
return n;
}
_table[_size];
return _size;
}
struct node;
public:
using elem_t = node;
@@ -113,19 +80,45 @@ public:
constexpr bool empty() const { return _root == npos; }
constexpr value_t& operator[](int i) {
assertd(i >= 0, "Index out of Bounds");
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
size_t n = _walk(i);
assertd(n != npos, "Index out of Bounds");
return *_table[n].data;
}
constexpr const value_t& operator[](int i) const {
assertd(i >= 0, "Index out of Bounds");
assertd(i >= 0 && size_t(i) < _size, "Index out of Bounds");
size_t n = _walk(i);
assertd(n != npos, "Index out of Bounds");
return *_table[n].data;
}
void insert(const iterator& it, value_t&& x) {
if (size() == capacity()) {
_expand();
}
size_t n = it._n;
size_t p = _next_free();
_table[p].data = fennec::forward<value_t>(x);
if (n == npos) {
if (empty()) {
_root = p;
_table[p].next = npos;
_table[p].prev = npos;
} else {
_table[p].prev = n;
_table[p].next = npos;
_last = n;
}
return;
}
_table[p].next = n;
_table[p].prev = _prev(n);
_table[n].prev = p;
++_size;
}
void insert(size_t i, value_t&& x) {
assert(i <= size(), "Index out of Bounds");
if (size() == capacity()) {
@@ -142,13 +135,14 @@ public:
}
_table[p].data = fennec::forward<value_t>(x);
if (i == size()) {
_table[p].prev = n;
_last = n;
}
else {
_table[p].next = n;
_table[p].prev = _prev(n);
_table[n].prev = p;
}
else {
_table[p].prev = n;
}
++_size;
}
@@ -239,6 +233,10 @@ public:
return *(_list->_table[_n].data);
}
constexpr value_t* operator->() {
return &*(_list->_table[_n].data);
}
constexpr bool operator==(const iterator& it) {
return _list == it._list and _n == it._n;
}
@@ -274,7 +272,65 @@ private:
friend class iterator;
constexpr void _expand() {
_table.reallocate(_table.capacity() * 2);
_table.reallocate(fennec::max(_table.capacity(), size_t(1)) * 2);
}
struct node {
optional<value_t> data;
size_t prev, next;
constexpr node()
: data()
, prev(npos)
, next(npos) {
}
constexpr node(size_t p, size_t n)
: data()
, prev(p)
, next(n) {
}
constexpr node(size_t p, size_t n, value_t&& val)
: data(fennec::forward<value_t>(val))
, prev(p)
, next(n) {
}
constexpr ~node() = default;
constexpr void clear() {
data = nullopt;
prev = npos;
next = npos;
}
};
size_t _next(size_t n) {
return _table[n].next;
}
size_t _prev(size_t n) {
return _table[n].prev;
}
size_t _walk(size_t i) {
size_t n = _root;
if (n == npos) return n;
while (i > 0 && n != npos) {
n = _next(n); --i;
}
return n;
}
size_t _next_free() {
if (not _freed.empty()) {
size_t n = _freed.back();
_freed.pop_back();
return n;
}
_table[_size];
return _size;
}
};

24
include/fennec/platform/interface/inputdevice.h → include/fennec/lang/startup.h
View File

@@ -16,21 +16,13 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_INTERFACE_INPUTDEVICE_H
#define FENNEC_PLATFORM_INTERFACE_INPUTDEVICE_H
#ifndef FENNEC_LANG_STARTUP_H
#define FENNEC_LANG_STARTUP_H
namespace fennec
{
// Helper for running a function before main()
#define STATIC_CONSTRUCTOR(f) \
inline static void f(void); \
struct f##_t_ { inline f##_t_(void) { f(); } }; inline static f##_t_ f##_; \
inline static void f(void)
class inputdevice {
public:
virtual bool has_keyboard() = 0;
virtual bool has_mouse() = 0;
virtual bool has_touch() = 0;
private:
};
}
#endif // FENNEC_PLATFORM_INTERFACE_INPUTDEVICE_H
#endif // FENNEC_LANG_STARTUP_H

22
include/fennec/platform/interface/dialog.h
View File

@@ -1,22 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_INTERFACE_DIALOG_H
#define FENNEC_PLATFORM_INTERFACE_DIALOG_H
#endif // FENNEC_PLATFORM_INTERFACE_DIALOG_H

27
include/fennec/platform/interface/displaydev.h → include/fennec/platform/interface/display.h
View File

@@ -16,18 +16,16 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_INTERFACE_DISPLAYDEV_H
#define FENNEC_PLATFORM_INTERFACE_DISPLAYDEV_H
#ifndef FENNEC_PLATFORM_INTERFACE_DISPLAY_H
#define FENNEC_PLATFORM_INTERFACE_DISPLAY_H
#include <fennec/lang/types.h>
#include <fennec/platform/interface/fwd.h>
#include <fennec/platform/interface/window.h>
namespace fennec
{
///
/// \brief Interface for display management
class displaydev
class display
{
public:
struct pixel_format {
@@ -40,7 +38,7 @@ public:
};
virtual bool connected() const = 0;
virtual ~displaydev() = default;
virtual ~display() = default;
virtual window* create_window() = 0;
@@ -63,9 +61,20 @@ protected:
gfxcontext* _context;
config _config;
displaydev(platform* platform);
explicit display(platform* platform)
: _platform(platform)
, _context(nullptr)
, _config {
.format = {
.depth = 24,
.r = 8,
.g = 8,
.b = 8,
}
} {
}
};
}
#endif // FENNEC_PLATFORM_INTERFACE_DISPLAYDEV_H
#endif // FENNEC_PLATFORM_INTERFACE_DISPLAY_H

17
include/fennec/platform/interface/fwd.h
View File

@@ -16,18 +16,19 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_INTERFACE_FORWARD_H
#define FENNEC_PLATFORM_INTERFACE_FORWARD_H
#ifndef FENNEC_PLATFORM_INTERFACE_FWD_H
#define FENNEC_PLATFORM_INTERFACE_FWD_H
namespace fennec
{
class platform;
class window;
class displaydev;
class gfxcontext;
class gfxsurface;
class platform; // Handles OS level functionality
class display; // Handles display protocols
class window; // Handles window surfaces of the display protocol
class inputdevice; // Handles input devices
class gfxcontext; // Handle Driver Contexts, i.e. EGL, WGL, VkWayland, etc.
class gfxsurface; // Handle
}
#endif // FENNEC_PLATFORM_INTERFACE_FORWARD_H
#endif // FENNEC_PLATFORM_INTERFACE_FWD_H

21
include/fennec/platform/interface/gfxcontext.h
View File

@@ -19,25 +19,4 @@
#ifndef FENNEC_PLATFORM_INTERFACE_GFXCONTEXT_H
#define FENNEC_PLATFORM_INTERFACE_GFXCONTEXT_H
#include <fennec/platform/interface/fwd.h>
namespace fennec
{
class gfxcontext {
public:
template<typename TypeT>
TypeT* get_device() {
return static_cast<TypeT*>(_device);
}
protected:
gfxcontext(displaydev* device);
private:
displaydev* _device;
};
}
#endif // FENNEC_PLATFORM_INTERFACE_GFXCONTEXT_H

48
include/fennec/platform/interface/gfxsurface.h
View File

@@ -1,48 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_INTERFACE_GFXSURFACE_H
#define FENNEC_PLATFORM_INTERFACE_GFXSURFACE_H
#include <fennec/platform/interface/fwd.h>
namespace fennec
{
class gfxsurface {
template<typename ContextT>
ContextT* get_context() {
return static_cast<ContextT*>(_context);
}
template<typename WindowT>
WindowT* get_window() {
return static_cast<WindowT*>(_window);
}
protected:
gfxsurface(window* window, gfxcontext* context);
private:
window* _window;
gfxcontext* _context;
};
}
#endif // FENNEC_PLATFORM_INTERFACE_GFXSURFACE_H

128
include/fennec/platform/interface/platform.h
View File

@@ -19,50 +19,118 @@
#ifndef FENNEC_PLATFORM_INTERFACE_PLATFORM_H
#define FENNEC_PLATFORM_INTERFACE_PLATFORM_H
#include <fennec/containers/list.h>
#include <fennec/fproc/strings/cstring.h>
#include <fennec/fproc/strings/string.h>
#include <fennec/platform/interface/fwd.h>
/*
* This class should resemble the target platform as a whole. By itself, it will represent the OS, i.e. Linux, Windows,
* etc.
*
* We want everything to be type agnostic from the top level down
*
* The general structure is:
* Platform -> Display Protocol -> GFX API -> GFX Context
* -> Window -> GFX Surface
* -> Input Protocol
*
* For example, let's say we are on Linux, using Wayland and OpenGL with EGL
* EGL will know that we are using OpenGL, but won't know we are using Wayland
* OpenGL won't know or care that Linux, EGL, or Wayland is being used
* Wayland won't know or care that OpenGL or EGL is being used
* Linux won't know or care that OpenGL, Wayland, or EGL are in use
*
* Why do we want everything to be type agnostic?
* Let's say someone wants to add a DirectX extension for Windows. They shouldn't have to touch the
* Windows platform class or Win32 display manager class at all to write the implementation. This
* allows the extension to remain entirely independent of the engine which allows you to just drop
* it into your project, and it will work as expected. This should also keep version compatibility
* issues to the absolute minimum.
*
* We can allow this by notifying the platform of all available drivers at startup and give them priorities.
* Then, the platform will load the highest priority first, only falling back when a driver fails to load or is
* deemed incompatible for whatever reason.
*
*
*/
namespace fennec
{
class platform {
public:
using shared_object = struct shared_object;
using function_pointer = void (*)(void);
using global = void*;
using symbol = void*;
struct shared_lib {
shared_object* _lib;
const cstring _name;
};
const string name;
struct config {
};
// Functions with default implementations
virtual string get_environment_variable(const cstring& var);
// Pure Virtual Functions
virtual displaydev* get_display() = 0;
virtual shared_object* load_object(const cstring& file) = 0;
virtual void unload_object(shared_object* obj) = 0;
virtual function_pointer find_symbol(shared_object* hndl, const cstring& name) = 0;
virtual global find_global(shared_object* hndl, const cstring& name) = 0;
protected:
platform();
virtual ~platform() = default;
// Dynamically linked objects
virtual shared_object* load_object(const cstring& file) = 0;
virtual void unload_object(shared_object* obj) = 0;
virtual symbol find_symbol(shared_object* obj, const cstring& name) = 0;
virtual void initialize(); // Initialize Drivers and Contexts
virtual void shutdown(); // Close Drivers and Contexts
display* get_display() { return _display; }
protected:
explicit platform(const cstring& name)
: name(name) {
auto& globals = _get_globals();
assertf(globals.singleton == nullptr, "Conflicting Platform Definitions.");
globals.singleton = this;
}
virtual void load_display();
display* _display;
private:
config _config;
platform(const platform&) = delete;
// Static Stuff ========================================================================================================
public:
using display_ctor = display* (*)(platform*);
using input_ctor = inputdevice* (*)(display*);
using gfxctx_ctor = gfxcontext* (*)(display*);
template<typename ctor>
struct driver {
int priority;
ctor constructor;
};
static void add_driver(display_ctor ctor, int priority);
static void add_driver(input_ctor ctor, int priority);
static void add_driver(gfxctx_ctor ctor, int priority);
private:
struct global_context {
platform* singleton;
list<driver<display_ctor>> displays;
list<driver<input_ctor>> inputs;
list<driver<gfxctx_ctor>> graphics;
global_context()
: singleton(nullptr) {
}
};
static global_context& _get_globals();
public:
static const global_context& get_globals() {
return _get_globals();
}
static platform* instance() {
return _get_globals().singleton;
}
};
}

9
include/fennec/platform/interface/window.h
View File

@@ -22,7 +22,6 @@
#include <fennec/containers/optional.h>
#include <fennec/fproc/strings/string.h>
#include <fennec/platform/interface/fwd.h>
#include <fennec/platform/interface/gfxsurface.h>
namespace fennec
{
@@ -84,11 +83,11 @@ public:
return _config->flags & flags_modal;
}
displaydev* get_display() {
display* get_display() {
return _display;
}
const displaydev* get_display() const {
const display* get_display() const {
return _display;
}
@@ -139,9 +138,9 @@ public:
protected:
virtual ~window() = default;
window(displaydev* display, window* parent);
window(display* display, window* parent);
displaydev* _display;
display* _display;
window* _parent;
optional<config> _config;
gfxsurface* _context;

36
include/fennec/platform/linux/platform.h
View File

@@ -18,42 +18,20 @@
#ifndef FENNEC_PLATFORM_LINUX_PLATFORM_H
#define FENNEC_PLATFORM_LINUX_PLATFORM_H
#include <fennec/containers/set.h>
#include <fennec/platform/interface/displaydev.h>
#include <fennec/platform/interface/platform.h>
#include <fennec/platform/unix/platform.h>
namespace fennec
{
class linux_platform : public platform {
class linux_platform : public unix_platform {
public:
enum display_ : int_t {
display_none = -1,
display_x11 = 0,
display_wayland,
};
linux_platform()
: unix_platform("linux") {
}
linux_platform();
~linux_platform() override;
void initialize() override;
shared_object* load_object(const cstring& file) override;
void unload_object(shared_object* obj) override;
function_pointer find_symbol(shared_object* hndl, const cstring& name) override;
global find_global(shared_object* hndl, const cstring& name) override;
displaydev* get_display() override;
private:
displaydev* _display;
int_t _display_driver;
void _runtime_client_checks();
void _find_display_driver();
void _runtime_server_checks();
void shutdown() override;
};
}

30
include/fennec/platform/linux/wayland/displaydev.h → include/fennec/platform/linux/wayland/display.h
View File

@@ -19,47 +19,31 @@
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_DISPLAY_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_DISPLAY_H
#include <fennec/containers/list.h>
#include <fennec/fproc/strings/cstring.h>
#include <fennec/platform/interface/displaydev.h>
#include <fennec/platform/linux/platform.h>
#include <fennec/platform/linux/wayland/fwd.h>
#include <fennec/platform/linux/wayland/lib/wayland-client.h>
#include <fennec/platform/interface/display.h>
#include <fennec/platform/linux/wayland/lib/fwd.h>
namespace fennec
{
class wayland_display : public displaydev {
class wayland_display : public display {
public:
wayland_display(linux_platform* platform);
wayland_display(linux_platform* platform, const cstring& drv);
explicit wayland_display(platform* platform);
~wayland_display() override;
bool connected() const override;
window* create_window() override;
inline wl_display* get_handle() { return _handle; }
inline wl_registry* get_registry() { return _registry; }
inline wl_compositor* get_compositor() { return _compositor; }
inline wl_shell* get_shell() { return _shell; }
inline wl_seat* get_seat() { return _seat; }
inline wl_pointer* get_pointer() { return _pointer; }
inline wl_keyboard* get_keyboard() { return _keyboard; }
inline wl_shm* get_shm() { return _shm; }
private:
wl_display* _handle;
wl_registry* _registry;
wl_compositor* _compositor;
wl_shell* _shell;
wl_seat* _seat;
wl_pointer* _pointer;
wl_keyboard* _keyboard;
wl_shm* _shm;
list<wayland_window*> _windows;
bool _fifo;
void cleanup();
static void listen_global(void*, wl_registry*, uint32_t, const char*, uint32_t);
static void listen_global_remove(void*, wl_registry*, uint32_t);

25
include/fennec/platform/linux/wayland/lib/fwd.h
View File

@@ -19,6 +19,31 @@
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_LIB_FWD_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_LIB_FWD_H
/*
* Copyright © 2008 Kristian Høgsberg
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <fennec/lang/types.h>
#include <stdarg.h>

6
include/fennec/platform/linux/wayland/lib/dyn.h → include/fennec/platform/linux/wayland/lib/loader.h
View File

@@ -19,7 +19,7 @@
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_DYN_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_DYN_H
#include <fennec/platform/linux/platform.h>
#include <fennec/platform/interface/platform.h>
namespace fennec
{
@@ -27,8 +27,8 @@ namespace fennec
namespace libwayland
{
bool load_symbols(linux_platform* platform);
void unload_symbols(linux_platform* platform);
bool load_symbols(platform* platform);
void unload_symbols(platform* platform);
}

25
include/fennec/platform/linux/wayland/lib/sym.h
View File

@@ -19,6 +19,31 @@
#include <fennec/lang/types.h>
#include <fennec/platform/linux/wayland/lib/fwd.h>
/*
* Copyright © 2008 Kristian Høgsberg
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef FENNEC_LIB
#define FENNEC_LIB(...)
#endif

6
include/fennec/platform/linux/wayland/lib/wayland-client.h
View File

@@ -19,10 +19,10 @@
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_SYM_DEF_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_SYM_DEF_H
#define FENNEC_LIB(name) inline bool FENNEC_HAS_LIB_##name = false;
#define FENNEC_LIB(name) extern bool FENNEC_HAS_LIB_##name;
#define FENNEC_SYMBOL(ret, fn, ...) using sym_##fn = ret(*)(__VA_ARGS__); \
inline sym_##fn fn = nullptr;
#define FENNEC_GLOBAL(type, name) inline type* name = nullptr;
extern sym_##fn fn;
#define FENNEC_GLOBAL(type, name) extern type* name;
#include <fennec/platform/linux/wayland/lib/sym.h>
#include <stdint.h>

60
include/fennec/platform/linux/wayland/window.h
View File

@@ -1,60 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_WINDOW_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_WINDOW_H
#include <fennec/platform/interface/window.h>
#include <fennec/platform/linux/wayland/fwd.h>
#include <fennec/platform/linux/wayland/lib/fwd.h>
namespace fennec
{
class wayland_window : window {
public:
bool running() override;
void configure(const config& config) override;
bool initialize(bool modal) override;
bool shutdown() override;
bool set_title(const cstring& title) override;
bool set_title(const string& title) override;
bool set_width(size_t w) override;
bool set_height(size_t h) override;
bool set_size(size_t w, size_t h) override;
bool set_fullscreen_mode(fullscreen_mode mode) override;
bool set_resizable(bool e) override;
bool grab_keyboard(bool e) override;
bool grab_mouse(bool e) override;
bool block_screensaver(bool e) override;
wayland_window(wayland_display* display, wayland_window* parent);
~wayland_window() override;
private:
wl_surface* _surface;
wl_shell_surface* _shell;
wl_callback* _callback;
gfxcontext* _context;
};
}
#endif // FENNEC_PLATFORM_LINUX_WAYLAND_WINDOW_H

215
include/fennec/platform/linux/xkb/lib/fwd.h Normal file
View File

@@ -0,0 +1,215 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_LINUX_XKB_LIB_FWD_H
#define FENNEC_PLATFORM_LINUX_XKB_LIB_FWD_H
#include <fennec/lang/types.h>
/*
* Copyright © 2009-2012 Daniel Stone
* Copyright © 2012 Intel Corporation
* Copyright © 2012 Ran Benita
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
struct xkb_context;
struct xkb_keymap;
struct xkb_state;
struct xkb_rule_names;
typedef uint32_t xkb_keycode_t;
typedef uint32_t xkb_keysym_t;
typedef uint32_t xkb_layout_index_t;
typedef uint32_t xkb_layout_mask_t;
typedef uint32_t xkb_level_index_t;
typedef uint32_t xkb_mod_index_t;
typedef uint32_t xkb_mod_mask_t;
typedef uint32_t xkb_led_index_t;
typedef uint32_t xkb_led_mask_t;
/**
* The iterator used by xkb_keymap_key_for_each().
*
* @sa xkb_keymap_key_for_each
* @memberof xkb_keymap
* @since 0.3.1
*/
typedef void
(*xkb_keymap_key_iter_t)(struct xkb_keymap *keymap, xkb_keycode_t key,
void *data);
/** Flags for xkb_keysym_from_name(). */
enum xkb_keysym_flags {
/** Do not apply any flags. */
XKB_KEYSYM_NO_FLAGS = 0,
/** Find keysym by case-insensitive search. */
XKB_KEYSYM_CASE_INSENSITIVE = (1 << 0)
};
/** Flags for context creation. */
enum xkb_context_flags {
/** Do not apply any context flags. */
XKB_CONTEXT_NO_FLAGS = 0,
/** Create this context with an empty include path. */
XKB_CONTEXT_NO_DEFAULT_INCLUDES = (1 << 0),
/**
* Don't take RMLVO names from the environment.
*
* @since 0.3.0
*/
XKB_CONTEXT_NO_ENVIRONMENT_NAMES = (1 << 1),
/**
* Disable the use of secure_getenv for this context, so that privileged
* processes can use environment variables. Client uses at their own risk.
*
* @since 1.5.0
*/
XKB_CONTEXT_NO_SECURE_GETENV = (1 << 2)
};
/** Specifies a logging level. */
enum xkb_log_level {
XKB_LOG_LEVEL_CRITICAL = 10, /**< Log critical internal errors only. */
XKB_LOG_LEVEL_ERROR = 20, /**< Log all errors. */
XKB_LOG_LEVEL_WARNING = 30, /**< Log warnings and errors. */
XKB_LOG_LEVEL_INFO = 40, /**< Log information, warnings, and errors. */
XKB_LOG_LEVEL_DEBUG = 50 /**< Log everything. */
};
/** Flags for keymap compilation. */
enum xkb_keymap_compile_flags {
/** Do not apply any flags. */
XKB_KEYMAP_COMPILE_NO_FLAGS = 0
};
/** The possible keymap formats. */
enum xkb_keymap_format {
/** The current/classic XKB text format, as generated by xkbcomp -xkb. */
XKB_KEYMAP_FORMAT_TEXT_V1 = 1
};
/** Specifies the direction of the key (press / release). */
enum xkb_key_direction {
XKB_KEY_UP, /**< The key was released. */
XKB_KEY_DOWN /**< The key was pressed. */
};
/**
* Modifier and layout types for state objects. This enum is bitmaskable,
* e.g. (XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED) is valid to
* exclude locked modifiers.
*
* In XKB, the DEPRESSED components are also known as 'base'.
*/
enum xkb_state_component {
/** Depressed modifiers, i.e. a key is physically holding them. */
XKB_STATE_MODS_DEPRESSED = (1 << 0),
/** Latched modifiers, i.e. will be unset after the next non-modifier
* key press. */
XKB_STATE_MODS_LATCHED = (1 << 1),
/** Locked modifiers, i.e. will be unset after the key provoking the
* lock has been pressed again. */
XKB_STATE_MODS_LOCKED = (1 << 2),
/** Effective modifiers, i.e. currently active and affect key
* processing (derived from the other state components).
* Use this unless you explicitly care how the state came about. */
XKB_STATE_MODS_EFFECTIVE = (1 << 3),
/** Depressed layout, i.e. a key is physically holding it. */
XKB_STATE_LAYOUT_DEPRESSED = (1 << 4),
/** Latched layout, i.e. will be unset after the next non-modifier
* key press. */
XKB_STATE_LAYOUT_LATCHED = (1 << 5),
/** Locked layout, i.e. will be unset after the key provoking the lock
* has been pressed again. */
XKB_STATE_LAYOUT_LOCKED = (1 << 6),
/** Effective layout, i.e. currently active and affects key processing
* (derived from the other state components).
* Use this unless you explicitly care how the state came about. */
XKB_STATE_LAYOUT_EFFECTIVE = (1 << 7),
/** LEDs (derived from the other state components). */
XKB_STATE_LEDS = (1 << 8)
};
/**
* Match flags for xkb_state_mod_indices_are_active() and
* xkb_state_mod_names_are_active(), specifying the conditions for a
* successful match. XKB_STATE_MATCH_NON_EXCLUSIVE is bitmaskable with
* the other modes.
*/
enum xkb_state_match {
/** Returns true if any of the modifiers are active. */
XKB_STATE_MATCH_ANY = (1 << 0),
/** Returns true if all of the modifiers are active. */
XKB_STATE_MATCH_ALL = (1 << 1),
/** Makes matching non-exclusive, i.e. will not return false if a
* modifier not specified in the arguments is active. */
XKB_STATE_MATCH_NON_EXCLUSIVE = (1 << 16)
};
enum xkb_consumed_mode {
/**
* This is the mode defined in the XKB specification and used by libX11.
*
* A modifier is consumed if and only if it *may affect* key translation.
*
* For example, if `Control+Alt+<Backspace>` produces some assigned keysym,
* then when pressing just `<Backspace>`, `Control` and `Alt` are consumed,
* even though they are not active, since if they *were* active they would
* have affected key translation.
*/
XKB_CONSUMED_MODE_XKB,
/**
* This is the mode used by the GTK+ toolkit.
*
* The mode consists of the following two independent heuristics:
*
* - The currently active set of modifiers, excluding modifiers which do
* not affect the key (as described for @ref XKB_CONSUMED_MODE_XKB), are
* considered consumed, if the keysyms produced when all of them are
* active are different from the keysyms produced when no modifiers are
* active.
*
* - A single modifier is considered consumed if the keysyms produced for
* the key when it is the only active modifier are different from the
* keysyms produced when no modifiers are active.
*/
XKB_CONSUMED_MODE_GTK
};
#endif // FENNEC_PLATFORM_LINUX_XKB_LIB_FWD_H

17
include/fennec/platform/linux/wayland/fwd.h → include/fennec/platform/linux/xkb/lib/loader.h
View File

@@ -16,15 +16,22 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_LINUX_WAYLAND_FWD_H
#define FENNEC_PLATFORM_LINUX_WAYLAND_FWD_H
#ifndef FENNEC_PLATFORM_LINUX_XKB_DYN_H
#define FENNEC_PLATFORM_LINUX_XKB_DYN_H
#include <fennec/platform/interface/platform.h>
namespace fennec
{
class wayland_display;
class wayland_window;
namespace libxkbcommon
{
bool load_symbols(platform* platform);
void unload_symbols(platform* platform);
}
#endif // FENNEC_PLATFORM_LINUX_WAYLAND_FWD_H
}
#endif // FENNEC_PLATFORM_LINUX_XKB_DYN_H

142
include/fennec/platform/linux/xkb/lib/sym.h Normal file
View File

@@ -0,0 +1,142 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
/*
* Copyright © 2009-2012 Daniel Stone
* Copyright © 2012 Intel Corporation
* Copyright © 2012 Ran Benita
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#include <stdio.h>
#include <fennec/platform/linux/xkb/lib/fwd.h>
#ifndef FENNEC_LIB
#define FENNEC_LIB(...)
#endif
#ifndef FENNEC_SYMBOL
#define FENNEC_SYMBOL(...)
#endif
#ifndef FENNEC_GLOBAL
#define FENNEC_GLOBAL(...)
#endif
FENNEC_LIB(XKB);
FENNEC_SYMBOL(int, xkb_keysym_get_name, xkb_keysym_t keysym, char *buffer, size_t size);
FENNEC_SYMBOL(xkb_keysym_t, xkb_keysym_from_name, const char *name, enum xkb_keysym_flags flags);
FENNEC_SYMBOL(int, xkb_keysym_to_utf8, xkb_keysym_t keysym, char *buffer, size_t size);
FENNEC_SYMBOL(uint32_t, xkb_keysym_to_utf32, xkb_keysym_t keysym);
FENNEC_SYMBOL(xkb_keysym_t, xkb_utf32_to_keysym, uint32_t ucs);
FENNEC_SYMBOL(xkb_keysym_t, xkb_keysym_to_upper, xkb_keysym_t ks);
FENNEC_SYMBOL(xkb_keysym_t, xkb_keysym_to_lower, xkb_keysym_t ks);
FENNEC_SYMBOL(struct xkb_context*, xkb_context_new, enum xkb_context_flags flags);
FENNEC_SYMBOL(struct xkb_context*, xkb_context_ref, struct xkb_context *context);
FENNEC_SYMBOL(void, xkb_context_unref, struct xkb_context *context);
FENNEC_SYMBOL(void, xkb_context_set_user_data, struct xkb_context *context, void *user_data);
FENNEC_SYMBOL(void*, xkb_context_get_user_data, struct xkb_context *context);
FENNEC_SYMBOL(int, xkb_context_include_path_append, struct xkb_context *context, const char *path);
FENNEC_SYMBOL(int, xkb_context_include_path_append_default, struct xkb_context *context);
FENNEC_SYMBOL(int, xkb_context_include_path_reset_defaults, struct xkb_context *context);
FENNEC_SYMBOL(void, xkb_context_include_path_clear, struct xkb_context *context);
FENNEC_SYMBOL(unsigned int, xkb_context_num_include_paths, struct xkb_context *context);
FENNEC_SYMBOL(const char*, xkb_context_include_path_get, struct xkb_context *context, unsigned int index);
FENNEC_SYMBOL(void, xkb_context_set_log_level, struct xkb_context *context, enum xkb_log_level level);
FENNEC_SYMBOL(enum xkb_log_level, xkb_context_get_log_level, struct xkb_context *context);
FENNEC_SYMBOL(void, xkb_context_set_log_verbosity, struct xkb_context *context, int verbosity);
FENNEC_SYMBOL(int, xkb_context_get_log_verbosity, struct xkb_context *context);
FENNEC_SYMBOL(void, xkb_context_set_log_fn, struct xkb_context *context, void (*log_fn)(struct xkb_context *context, enum xkb_log_level level, const char *format, va_list args));
FENNEC_SYMBOL(struct xkb_keymap*, xkb_keymap_new_from_names, struct xkb_context *context, const struct xkb_rule_names *names, enum xkb_keymap_compile_flags flags);
FENNEC_SYMBOL(struct xkb_keymap*, xkb_keymap_new_from_file, struct xkb_context *context, FILE *file, enum xkb_keymap_format format, enum xkb_keymap_compile_flags flags);
FENNEC_SYMBOL(struct xkb_keymap*, xkb_keymap_new_from_string, struct xkb_context *context, const char *string, enum xkb_keymap_format format, enum xkb_keymap_compile_flags flags);
FENNEC_SYMBOL(struct xkb_keymap*, xkb_keymap_new_from_buffer, struct xkb_context *context, const char *buffer, size_t length, enum xkb_keymap_format format, enum xkb_keymap_compile_flags flags);
FENNEC_SYMBOL(struct xkb_keymap*, xkb_keymap_ref, struct xkb_keymap *keymap);
FENNEC_SYMBOL(void, xkb_keymap_unref, struct xkb_keymap *keymap);
FENNEC_SYMBOL(char*, xkb_keymap_get_as_string, struct xkb_keymap *keymap, enum xkb_keymap_format format);
FENNEC_SYMBOL(xkb_keycode_t, xkb_keymap_min_keycode, struct xkb_keymap *keymap);
FENNEC_SYMBOL(xkb_keycode_t, xkb_keymap_max_keycode, struct xkb_keymap *keymap);
FENNEC_SYMBOL(void, xkb_keymap_key_for_each, struct xkb_keymap *keymap, xkb_keymap_key_iter_t iter, void *data);
FENNEC_SYMBOL(const char*, xkb_keymap_key_get_name, struct xkb_keymap *keymap, xkb_keycode_t key);
FENNEC_SYMBOL(xkb_keycode_t, xkb_keymap_key_by_name, struct xkb_keymap *keymap, const char *name);
FENNEC_SYMBOL(xkb_mod_index_t, xkb_keymap_num_mods, struct xkb_keymap *keymap);
FENNEC_SYMBOL(const char*, xkb_keymap_mod_get_name, struct xkb_keymap *keymap, xkb_mod_index_t idx);
FENNEC_SYMBOL(xkb_mod_index_t, xkb_keymap_mod_get_index, struct xkb_keymap *keymap, const char *name);
FENNEC_SYMBOL(xkb_layout_index_t, xkb_keymap_num_layouts, struct xkb_keymap *keymap);
FENNEC_SYMBOL(const char*, xkb_keymap_layout_get_name, struct xkb_keymap *keymap, xkb_layout_index_t idx);
FENNEC_SYMBOL(xkb_layout_index_t, xkb_keymap_layout_get_index, struct xkb_keymap *keymap, const char *name);
FENNEC_SYMBOL(xkb_led_index_t, xkb_keymap_num_leds, struct xkb_keymap *keymap);
FENNEC_SYMBOL(const char*, xkb_keymap_led_get_name, struct xkb_keymap *keymap, xkb_led_index_t idx);
FENNEC_SYMBOL(xkb_led_index_t, xkb_keymap_led_get_index, struct xkb_keymap *keymap, const char *name);
FENNEC_SYMBOL(xkb_layout_index_t, xkb_keymap_num_layouts_for_key, struct xkb_keymap *keymap, xkb_keycode_t key);
FENNEC_SYMBOL(xkb_level_index_t, xkb_keymap_num_levels_for_key, struct xkb_keymap *keymap, xkb_keycode_t key, xkb_layout_index_t layout);
FENNEC_SYMBOL(size_t, xkb_keymap_key_get_mods_for_level, struct xkb_keymap *keymap, xkb_keycode_t key, xkb_layout_index_t layout, xkb_level_index_t level, xkb_mod_mask_t *masks_out, size_t masks_size);
FENNEC_SYMBOL(int, xkb_keymap_key_get_syms_by_level, struct xkb_keymap *keymap, xkb_keycode_t key, xkb_layout_index_t layout, xkb_level_index_t level, const xkb_keysym_t **syms_out);
FENNEC_SYMBOL(int, xkb_keymap_key_repeats, struct xkb_keymap *keymap, xkb_keycode_t key);
FENNEC_SYMBOL(struct xkb_state*, xkb_state_new, struct xkb_keymap *keymap);
FENNEC_SYMBOL(struct xkb_state*, xkb_state_ref, struct xkb_state *state);
FENNEC_SYMBOL(void, xkb_state_unref, struct xkb_state *state);
FENNEC_SYMBOL(struct xkb_keymap*, xkb_state_get_keymap, struct xkb_state *state);
FENNEC_SYMBOL(enum xkb_state_component, xkb_state_update_key, struct xkb_state *state, xkb_keycode_t key, enum xkb_key_direction direction);
FENNEC_SYMBOL(enum xkb_state_component, xkb_state_update_mask, struct xkb_state *state, xkb_mod_mask_t depressed_mods, xkb_mod_mask_t latched_mods, xkb_mod_mask_t locked_mods, xkb_layout_index_t depressed_layout, xkb_layout_index_t latched_layout, xkb_layout_index_t locked_layout);
FENNEC_SYMBOL(int, xkb_state_key_get_syms, struct xkb_state *state, xkb_keycode_t key, const xkb_keysym_t **syms_out);
FENNEC_SYMBOL(int, xkb_state_key_get_utf8, struct xkb_state *state, xkb_keycode_t key, char *buffer, size_t size);
FENNEC_SYMBOL(uint32_t, xkb_state_key_get_utf32, struct xkb_state *state, xkb_keycode_t key);
FENNEC_SYMBOL(xkb_keysym_t, xkb_state_key_get_one_sym, struct xkb_state *state, xkb_keycode_t key);
FENNEC_SYMBOL(xkb_layout_index_t, xkb_state_key_get_layout, struct xkb_state *state, xkb_keycode_t key);
FENNEC_SYMBOL(xkb_level_index_t, xkb_state_key_get_level, struct xkb_state *state, xkb_keycode_t key, xkb_layout_index_t layout);
FENNEC_SYMBOL(xkb_mod_mask_t, xkb_state_serialize_mods, struct xkb_state *state, enum xkb_state_component components);
FENNEC_SYMBOL(xkb_layout_index_t, xkb_state_serialize_layout, struct xkb_state *state, enum xkb_state_component components);
FENNEC_SYMBOL(int, xkb_state_mod_name_is_active, struct xkb_state *state, const char *name, enum xkb_state_component type);
FENNEC_SYMBOL(int, xkb_state_mod_names_are_active, struct xkb_state *state, enum xkb_state_component type, enum xkb_state_match match, ...);
FENNEC_SYMBOL(int, xkb_state_mod_index_is_active, struct xkb_state *state, xkb_mod_index_t idx, enum xkb_state_component type);
FENNEC_SYMBOL(int, xkb_state_mod_indices_are_active, struct xkb_state *state, enum xkb_state_component type, enum xkb_state_match match, ...);
FENNEC_SYMBOL(xkb_mod_mask_t, xkb_state_key_get_consumed_mods2, struct xkb_state *state, xkb_keycode_t key, enum xkb_consumed_mode mode);
FENNEC_SYMBOL(xkb_mod_mask_t, xkb_state_key_get_consumed_mods, struct xkb_state *state, xkb_keycode_t key);
FENNEC_SYMBOL(int, xkb_state_mod_index_is_consumed2, struct xkb_state *state, xkb_keycode_t key, xkb_mod_index_t idx, enum xkb_consumed_mode mode);
FENNEC_SYMBOL(int, xkb_state_mod_index_is_consumed, struct xkb_state *state, xkb_keycode_t key, xkb_mod_index_t idx);
FENNEC_SYMBOL(xkb_mod_mask_t, xkb_state_mod_mask_remove_consumed, struct xkb_state *state, xkb_keycode_t key, xkb_mod_mask_t mask);
FENNEC_SYMBOL(int, xkb_state_layout_name_is_active, struct xkb_state *state, const char *name, enum xkb_state_component type);
FENNEC_SYMBOL(int, xkb_state_layout_index_is_active, struct xkb_state *state, xkb_layout_index_t idx, enum xkb_state_component type);
FENNEC_SYMBOL(int, xkb_state_led_name_is_active, struct xkb_state *state, const char *name);
FENNEC_SYMBOL(int, xkb_state_led_index_is_active, struct xkb_state *state, xkb_led_index_t idx);
#undef FENNEC_LIB
#undef FENNEC_SYMBOL
#undef FENNEC_GLOBAL

3355
include/fennec/platform/linux/xkb/lib/xkbcommon-keysyms.h Normal file
View File

File diff suppressed because it is too large Load Diff

45
include/fennec/platform/linux/xkb/lib/xkbcommon-names.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright © 2012 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#ifndef _XKBCOMMON_NAMES_H
#define _XKBCOMMON_NAMES_H
/**
* @file
* @brief Predefined names for common modifiers and LEDs.
*/
#define XKB_MOD_NAME_SHIFT "Shift"
#define XKB_MOD_NAME_CAPS "Lock"
#define XKB_MOD_NAME_CTRL "Control"
#define XKB_MOD_NAME_ALT "Mod1"
#define XKB_MOD_NAME_NUM "Mod2"
#define XKB_MOD_NAME_LOGO "Mod4"
#define XKB_LED_NAME_CAPS "Caps Lock"
#define XKB_LED_NAME_NUM "Num Lock"
#define XKB_LED_NAME_SCROLL "Scroll Lock"
#endif

157
include/fennec/platform/linux/xkb/lib/xkbcommon.h Normal file
View File

@@ -0,0 +1,157 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_LINUX_XKB_LIB_XKBCOMMON_H
#define FENNEC_PLATFORM_LINUX_XKB_LIB_XKBCOMMON_H
#define FENNEC_LIB(name) extern bool FENNEC_HAS_LIB_##name;
#define FENNEC_SYMBOL(ret, fn, ...) using sym_##fn = ret(*)(__VA_ARGS__); \
extern sym_##fn fn;
#define FENNEC_GLOBAL(type, name) extern type* name;
#include <fennec/platform/linux/xkb/lib/sym.h>
/*
* Copyright © 2009-2012 Daniel Stone
* Copyright © 2012 Intel Corporation
* Copyright © 2012 Ran Benita
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#include <fennec/platform/linux/xkb/lib/xkbcommon-names.h>
#include <fennec/platform/linux/xkb/lib/xkbcommon-keysyms.h>
#define XKB_KEYCODE_INVALID (0xffffffff)
#define XKB_LAYOUT_INVALID (0xffffffff)
#define XKB_LEVEL_INVALID (0xffffffff)
#define XKB_MOD_INVALID (0xffffffff)
#define XKB_LED_INVALID (0xffffffff)
#define XKB_KEYCODE_MAX (0xffffffff - 1)
/**
* Maximum keysym value
*
* @since 1.6.0
* @sa xkb_keysym_t
* @ingroup keysyms
*/
#define XKB_KEYSYM_MAX 0x1fffffff
/**
* Test whether a value is a valid extended keycode.
* @sa xkb_keycode_t
**/
#define xkb_keycode_is_legal_ext(key) (key <= XKB_KEYCODE_MAX)
/**
* Test whether a value is a valid X11 keycode.
* @sa xkb_keycode_t
*/
#define xkb_keycode_is_legal_x11(key) (key >= 8 && key <= 255)
/**
* Names to compile a keymap with, also known as RMLVO.
*
* The names are the common configuration values by which a user picks
* a keymap.
*
* If the entire struct is NULL, then each field is taken to be NULL.
* You should prefer passing NULL instead of choosing your own defaults.
*/
struct xkb_rule_names {
/**
* The rules file to use. The rules file describes how to interpret
* the values of the model, layout, variant and options fields.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_RULES environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *rules;
/**
* The keyboard model by which to interpret keycodes and LEDs.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_MODEL environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *model;
/**
* A comma separated list of layouts (languages) to include in the
* keymap.
*
* If NULL or the empty string "", a default value is used.
* If the XKB_DEFAULT_LAYOUT environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *layout;
/**
* A comma separated list of variants, one per layout, which may
* modify or augment the respective layout in various ways.
*
* Generally, should either be empty or have the same number of values
* as the number of layouts. You may use empty values as in "intl,,neo".
*
* If NULL or the empty string "", and a default value is also used
* for the layout, a default value is used. Otherwise no variant is
* used.
* If the XKB_DEFAULT_VARIANT environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *variant;
/**
* A comma separated list of options, through which the user specifies
* non-layout related preferences, like which key combinations are used
* for switching layouts, or which key is the Compose key.
*
* If NULL, a default value is used. If the empty string "", no
* options are used.
* If the XKB_DEFAULT_OPTIONS environment variable is set, it is used
* as the default. Otherwise the system default is used.
*/
const char *options;
};
/**
* Get the keymap as a string in the format from which it was created.
* @sa xkb_keymap_get_as_string()
**/
#define XKB_KEYMAP_USE_ORIGINAL_FORMAT ((enum xkb_keymap_format) -1)
#endif // FENNEC_PLATFORM_LINUX_XKB_LIB_XKBCOMMON_H

44
include/fennec/platform/opengl/egl/context.h
View File

@@ -1,44 +0,0 @@
// =====================================================================================================================
// fennec, a free and open source game engine
// Copyright © 2025 Medusa Slockbower
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_EGL_CONTEXT_H
#define FENNEC_PLATFORM_EGL_CONTEXT_H
#include <EGL/egl.h>
#include <fennec/platform/interface/displaydev.h>
#include <fennec/platform/interface/gfxcontext.h>
#if FENNEC_HAS_WAYLAND
#include <fennec/platform/linux/wayland/fwd.h>
#endif
namespace fennec
{
class eglcontext : gfxcontext {
public:
eglcontext(displaydev* device);
EGLDisplay display;
EGLContext context;
EGLConfig config;
};
}
#endif // FENNEC_PLATFORM_EGL_CONTEXT_H

29
include/fennec/platform/opengl/egl/surface.h → include/fennec/platform/unix/platform.h
View File

@@ -16,28 +16,27 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
#ifndef FENNEC_PLATFORM_OPENGL_EGL_SURFACE_H
#define FENNEC_PLATFORM_OPENGL_EGL_SURFACE_H
#include <EGL/egl.h>
#include <fennec/platform/interface/gfxsurface.h>
#include <fennec/platform/opengl/egl/context.h>
#if FENNEC_HAS_WAYLAND
#endif
#ifndef FENNEC_PLATFORM_UNIX_UNIX_PLATFORM_H
#define FENNEC_PLATFORM_UNIX_UNIX_PLATFORM_H
#include <fennec/platform/interface/platform.h>
namespace fennec
{
class eglsurface : gfxsurface {
class unix_platform : public platform {
public:
eglsurface(eglcontext* context);
explicit unix_platform(const cstring& name)
: platform(name) {
}
shared_object* load_object(const cstring& file) override;
void unload_object(shared_object* obj) override;
symbol find_symbol(shared_object* obj, const cstring& name) override;
private:
EGLSurface surface;
};
}
#endif // FENNEC_PLATFORM_OPENGL_EGL_SURFACE_H
#endif // FENNEC_PLATFORM_UNIX_UNIX_PLATFORM_H