- Decided to remove boost due to extensive dependencies

- Huge refactor on Wayland loading to support retrieval of Protocol headers
 - Setup EGL to create surfaces for Wayland windows

source/platform/linux/wayland/display.cpp

@@ -18,9 +18,11 @@
 
 #include <fennec/platform/linux/wayland/display.h>
 #include <fennec/platform/linux/wayland/lib/loader.h>
-#include <fennec/platform/linux/wayland/lib/wayland-client.h>
+#include <fennec/platform/linux/wayland/lib/wayland.h>
 
 #include <fennec/lang/startup.h>
+#include <fennec/platform/linux/wayland/window.h>
+#include <fennec/platform/linux/wayland/lib/headers/wayland-client-protocols.h>
 
 namespace fennec
 {
@@ -42,7 +44,6 @@ wayland_display::wayland_display(platform* platform)
 	, _handle(nullptr)
 	, _registry(nullptr)
 	, _compositor(nullptr)
-	, _shell(nullptr)
 	, _seat(nullptr)
 	, _shm(nullptr)
 	, _fifo(false) {
@@ -89,14 +90,13 @@ bool wayland_display::connected() const {
 	return _handle != nullptr;
 }
 
-window* wayland_display::create_window() {
-	return nullptr;
+window* wayland_display::create_window(window* parent) {
+	return new wayland_window(this, static_cast<wayland_window*>(parent));
 }
 
 void wayland_display::cleanup() {
 
 	// Cleanup members
-	if (_shell)      wl_shell_destroy(_shell);
 	if (_compositor) wl_compositor_destroy(_compositor);
 	if (_registry)   wl_registry_destroy(_registry);
 	if (_handle) {
@@ -104,7 +104,6 @@ void wayland_display::cleanup() {
 		wl_display_disconnect(_handle);
 	}
 
-	_shell = nullptr;
 	_compositor = nullptr;
 	_registry = nullptr;
 	_handle = nullptr;
@@ -121,11 +120,9 @@ void wayland_display::listen_global(void* data, wl_registry* registry, uint32_t
 	const cstring interface = cstring(itfc, strlen(itfc) + 1);
 
 	if (interface == "wl_compositor") {
-		device->_compositor = static_cast<wl_compositor*>(wl_registry_bind(registry, name, wl_compositor_interface, version));
-	} else if (interface == "wl_shell") {
-		device->_shell = static_cast<wl_shell*>(wl_registry_bind(registry, name, wl_shell_interface, version));
+		device->_compositor = static_cast<wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, version));
 	} else if (interface == "wl_seat") {
-		device->_seat = static_cast<wl_seat*>(wl_registry_bind(registry, name, wl_seat_interface, version));
+		device->_seat = static_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, version));
 		wl_seat_add_listener(device->_seat, &seat_listener, device);
 	} else if (interface == "wp_fifo_manager_v1") {
 		device->_fifo = true;

source/platform/linux/wayland/lib/loader.cpp

@@ -16,13 +16,13 @@
 //  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 // =====================================================================================================================
 
-#include <fennec/platform/linux/wayland/lib/wayland-client.h>
+#include <fennec/platform/linux/wayland/lib/headers/wayland-client-protocols.h>
 #include <fennec/platform/linux/wayland/lib/loader.h>
 
 #define FENNEC_LIB(name)            bool FENNEC_HAS_LIB_##name;
-#define FENNEC_SYMBOL(ret, fn, ...) using sym_##fn = ret(*)(__VA_ARGS__); \
-                                    sym_##fn fn;
-#define FENNEC_GLOBAL(type, name)   type* name;
+#define FENNEC_SYMBOL(ret, fn, ...) using WAYLAND_sym_##fn = ret(*)(__VA_ARGS__); \
+                                    WAYLAND_sym_##fn WAYLAND_##fn;
+#define FENNEC_GLOBAL(type, name)   type* WAYLAND_##name;
 #include <fennec/platform/linux/wayland/lib/sym.h>
 
 namespace fennec
@@ -57,10 +57,10 @@ bool load_symbols(platform* platform) {
 							return false; \
 						} \
 	                    current_lib = &_FENNEC_LIB_##lib;
-#define FENNEC_SYMBOL(ret, fn, ...) fn = (sym_##fn)(platform->find_symbol(current_lib->obj, #fn)); \
-	                                assertf(fn != nullptr, "Failed to find symbol: " #fn);
-#define FENNEC_GLOBAL(type, name)   name = (type*)(platform->find_symbol(current_lib->obj, #name)); \
-	                                assertf(name != nullptr, "Failed to find global: " #name);
+#define FENNEC_SYMBOL(ret, fn, ...) WAYLAND_##fn = (WAYLAND_sym_##fn)(platform->find_symbol(current_lib->obj, #fn)); \
+	                                assertf(WAYLAND_##fn != nullptr, "Failed to find symbol: " #fn);
+#define FENNEC_GLOBAL(type, name)   WAYLAND_##name = (type*)(platform->find_symbol(current_lib->obj, #name)); \
+	                                assertf(WAYLAND_##name != nullptr, "Failed to find global: " #name);
 #include <fennec/platform/linux/wayland/lib/sym.h>
 
 
@@ -74,9 +74,9 @@ void unload_symbols(platform* platform) {
 	}
 
 #define FENNEC_LIB(lib) platform->unload_object(_FENNEC_LIB_##lib.obj); \
-	                    _FENNEC_LIB_##lib.obj = nullptr;
-#define FENNEC_SYMBOL(ret, fn, ...) fn = nullptr;
-#define FENNEC_GLOBAL(type, name) name = nullptr;
+	                    _FENNEC_LIB_##lib.obj    = nullptr;
+#define FENNEC_SYMBOL(ret, fn, ...) WAYLAND_##fn = nullptr;
+#define FENNEC_GLOBAL(type, name) WAYLAND_##name = nullptr;
 #include <fennec/platform/linux/wayland/lib/sym.h>
 }
 

source/platform/linux/wayland/window.cpp

@@ -0,0 +1,139 @@
+// =====================================================================================================================
+//  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/>.
+// =====================================================================================================================
+
+#include <fennec/platform/interface/gfxcontext.h>
+#include <fennec/platform/interface/gfxsurface.h>
+
+#include <fennec/platform/linux/wayland/window.h>
+#include <fennec/platform/linux/wayland/lib/wayland.h>
+
+namespace fennec
+{
+
+bool wayland_window::running() {
+	return _surface != nullptr;
+}
+
+void wayland_window::configure(const config& config) {
+	_config = config;
+}
+
+bool wayland_window::initialize(bool) {
+
+	wayland_display* display = static_cast<wayland_display*>(_display);
+
+	_handle = wl_compositor_create_surface(display->get_compositor());
+
+	_surface = display->get_context()->create_surface(this);
+
+	return false;
+}
+
+bool wayland_window::shutdown() {
+	delete _surface;
+	wl_surface_destroy(_handle);
+	_display = nullptr;
+	_surface = nullptr;
+	_shell   = nullptr;
+	_handle  = nullptr;
+	return false;
+}
+
+bool wayland_window::set_title(const cstring& title) {
+	if (not _config) {
+		return true;
+	}
+	_config->title = title;
+	wl_shell_surface_set_title(_shell, _config->title.cstr());
+
+	return false;
+}
+
+bool wayland_window::set_title(const string& title) {
+	if (not _config) {
+		return true;
+	}
+	_config->title = title;
+	wl_shell_surface_set_title(_shell, _config->title.cstr());
+
+	return false;
+}
+
+bool wayland_window::set_width(size_t w) {
+	if (not _config) {
+		return true;
+	}
+	_config->width = w;
+	_surface->resize(_config->width, _config->height);
+
+	return false;
+}
+
+bool wayland_window::set_height(size_t h) {
+	if (not _config) {
+		return true;
+	}
+	_config->height = h;
+	_surface->resize(_config->width, _config->height);
+
+	return false;
+}
+
+bool wayland_window::resize(size_t w, size_t h) {
+	if (not _config) {
+		return true;
+	}
+	_config->width = w;
+	_config->height = h;
+	_surface->resize(_config->width, _config->height);
+
+	return false;
+}
+
+bool wayland_window::set_resizable(bool) {
+	return false; // TODO
+}
+
+bool wayland_window::set_fullscreen_mode(fullscreen_mode) {
+	return false; // TODO
+}
+
+bool wayland_window::grab_keyboard(bool) {
+	return false; // TODO
+}
+
+bool wayland_window::grab_mouse(bool) {
+	return false; // TODO
+}
+
+bool wayland_window::block_screensaver(bool) {
+	return false; // TODO
+}
+
+wayland_window::wayland_window(wayland_display* display, wayland_window* parent)
+	: window(display, parent, this)
+	, _handle()
+	, _shell()
+	, _nfs_width(0), _nfs_height(0) {
+}
+
+wayland_window::~wayland_window() {
+	wayland_window::shutdown();
+}
+
+}

source/platform/opengl/egl/context.cpp

@@ -21,6 +21,7 @@
 #include <fennec/platform/interface/display.h>
 #include <fennec/platform/interface/platform.h>
 #include <fennec/platform/opengl/egl/context.h>
+#include <fennec/platform/opengl/egl/surface.h>
 
 #include <GL/gl.h>
 
@@ -40,7 +41,10 @@ STATIC_CONSTRUCTOR(_egl_init) {
 }
 
 eglcontext::eglcontext(display* display)
-	: gfxcontext(display, "EGL", this) {
+	: gfxcontext(display, "EGL", this)
+	, _egldisplay(nullptr), _eglcontext(nullptr)
+	, _eglconfig(), _eglvmajor(0), _eglvminor(0)
+	, _eglctype(0), _extensions(nullptr) {
 
 	// Get the display format
 	const display::pixel_format& fmt = _display->get_color_format();
@@ -121,7 +125,7 @@ bool eglcontext::connected() {
 	return _eglcontext != nullptr;
 }
 
-const cstring& eglcontext::get_context_name() {
+const cstring& eglcontext::get_name() {
 	static constexpr cstring opengl = "OpenGL";
 	static constexpr cstring gles   = "GLES";
 	static constexpr cstring openvg = "OpenVG"; // this should never be used
@@ -137,8 +141,13 @@ bool eglcontext::check_extension(const cstring& ext) {
 	return _extensions.find(ext) != _extensions.size();
 }
 
-void eglcontext::make_current(gfxsurface*) {
+gfxsurface* eglcontext::create_surface(window* window) {
+	return new eglsurface(this, window);
+}
 
+void eglcontext::make_current(gfxsurface* surface) {
+	eglsurface* eglsurface = static_cast<fennec::eglsurface*>(surface);
+	eglMakeCurrent(_egldisplay, eglsurface->get_egl_surface(), eglsurface->get_egl_surface(), _eglcontext);
 }
 
 void eglcontext::cleanup() {

source/platform/opengl/egl/surface.cpp

@@ -0,0 +1,66 @@
+// =====================================================================================================================
+//  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/>.
+// =====================================================================================================================
+
+#include <fennec/platform/opengl/egl/surface.h>
+#include <fennec/platform/linux/wayland/lib/wayland.h>
+
+namespace fennec
+{
+
+eglsurface::~eglsurface() {
+	if (_window->is_type<wayland_window>()) {
+		wl_egl_window_destroy(static_cast<wl_egl_window*>(_handle));
+	}
+}
+
+void eglsurface::resize(size_t width, size_t height) {
+	gfxsurface::resize(width, height);
+	if (_window->is_type<wayland_window>()) {
+		wl_egl_window_resize(static_cast<wl_egl_window*>(_handle), width, height, 0, 0);
+	}
+}
+
+eglsurface::eglsurface(eglcontext* context, window* window)
+	: gfxsurface(context, window, this)
+	, _handle(nullptr)
+	, _surface(nullptr) {
+
+	const window::config& config = window->get_config();
+	if (window->is_type<wayland_window>()) {
+		_handle = wl_egl_window_create(window->get_native_handle(), config.width, config.height);
+	}
+
+	assert(
+		_handle != nullptr,
+		"Failed to create egl window!"
+	);
+
+	eglCreateWindowSurface(
+		context->get_egl_display(),
+		context->get_egl_config(),
+		reinterpret_cast<EGLNativeWindowType>(_handle),
+		nullptr
+	);
+
+	assert(
+		EGL_TRUE == eglMakeCurrent(context->get_egl_display(), _surface, _surface, context->get_egl_context()),
+		"Failed to create egl window!"
+	);
+}
+
+}