working on OpenGL loading

2026-01-11 15:33:34 +00:00 · 2025-03-23 00:43:40 +01:00
parent 3e6aa18fbe
commit 6c2119d806
28 changed files with 1088 additions and 63 deletions
--- a/Sources/Backends/OpenGL/OpenGLDevice.c
+++ b/Sources/Backends/OpenGL/OpenGLDevice.c
@@ -0,0 +1,213 @@
+// Copyright (C) 2025 kanel
+// This file is part of "Pulse"
+// For conditions of distribution and use, see copyright notice in LICENSE
+
+#include <stdio.h>
+#include <string.h>
+
+
+#include <Pulse.h>
+
+#include "../../PulseInternal.h"
+#include "OpenGL.h"
+#include "OpenGLComputePipeline.h"
+#include "OpenGLCommandList.h"
+#include "OpenGLDevice.h"
+#include "OpenGLFence.h"
+#include "OpenGLBuffer.h"
+#include "OpenGLImage.h"
+#include "OpenGLComputePass.h"
+
+static const char* OpenGLFunctionIndexToFunctionName[] = {
+	#define PULSE_OPENGL_FUNCTION(fn, T) #fn,
+		#include "OpenGLFunctions.h"
+	#undef PULSE_OPENGL_FUNCTION
+};
+
+typedef GLFunction(*GLFunctionLoad)(const char*);
+
+const char* OpenGLVerbaliseError(GLenum code)
+{
+	switch (code)
+	{
+		// OpenGL / OpenGL ES error codes
+		case GL_INVALID_ENUM:                  return "an unacceptable value is specified for an enumerated argument";
+		case GL_INVALID_VALUE:                 return "a numeric argument is out of range";
+		case GL_INVALID_OPERATION:             return "the specified operation is not allowed in the current state";
+		case GL_INVALID_FRAMEBUFFER_OPERATION: return "the framebuffer object is not complete";
+		case GL_OUT_OF_MEMORY:                 return "there is not enough memory left to execute the command";
+
+		// OpenGL error codes
+		case GL_STACK_UNDERFLOW: return "an attempt has been made to perform an operation that would cause an internal stack to underflow";
+		case GL_STACK_OVERFLOW:  return "an attempt has been made to perform an operation that would cause an internal stack to overflow";
+
+		default: break;
+	}
+
+	return "unknown OpenGL error";
+}
+
+static void PulseCheckGLError(PulseDevice device, const char* function)
+{
+	OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*);
+
+	GLenum err = ((PFNGLGETERRORPROC)opengl_device->original_function_ptrs[glGetError])();
+	if(err == GL_NO_ERROR)
+		return;
+
+	char message[4096] = { 0 };
+	snprintf(message, 4096, "%s call to %s failed. Unrolling the error stack:\n", device->backend->backend == PULSE_BACKEND_OPENGL ? "(OpenGL)" : "(OpenGL ES)", function);
+
+	int i = 0;
+	for(; err != GL_NO_ERROR; err = ((PFNGLGETERRORPROC)opengl_device->original_function_ptrs[glGetError])(), i++)
+		snprintf(message + strlen(message), 4096 - strlen(message), "    #%d %s\n", i, OpenGLVerbaliseError(err));
+
+	PulseLogBackend(device->backend, PULSE_DEBUG_MESSAGE_SEVERITY_ERROR, message, __FILE__, function, 0);
+}
+
+static void OpenGLDeviceMakeCurrent(PulseDevice device)
+{
+	OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*);
+
+	#ifdef PULSE_PLAT_WINDOWS
+		if(opengl_device->context_type == OPENGL_CONTEXT_WGL)
+		{} // TODO: WGL
+		else
+		{
+			EGLInstance* instance = &opengl_device->egl_instance;
+			instance->eglMakeCurrent(instance->display, instance->surface, instance->surface, instance->context);
+		}
+	#else
+		EGLInstance* instance = &opengl_device->egl_instance;
+		instance->eglMakeCurrent(instance->display, instance->surface, instance->surface, instance->context);
+	#endif
+}
+
+#define PULSE_OPENGL_WRAPPER_RET(ret, fn, arg_list, param_list, cast) \
+	static ret PulseOpenGLWrapper_##fn arg_list \
+	{ \
+		OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*); \
+		OpenGLDeviceMakeCurrent(device); \
+		ret result = ((cast)opengl_device->original_function_ptrs[fn]) param_list; \
+		if(device->backend->debug_level != PULSE_NO_DEBUG) \
+			PulseCheckGLError(device, #fn); \
+		return result; \
+	}
+
+#define PULSE_OPENGL_WRAPPER(fn, arg_list, param_list, cast) \
+	static void PulseOpenGLWrapper_##fn arg_list \
+	{ \
+		OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*); \
+		OpenGLDeviceMakeCurrent(device); \
+		((cast)opengl_device->original_function_ptrs[fn]) param_list; \
+		if(device->backend->debug_level != PULSE_NO_DEBUG) \
+			PulseCheckGLError(device, #fn); \
+	}
+
+#include "OpenGLWraps.h"
+
+#undef PULSE_OPENGL_WRAPPER
+#undef PULSE_OPENGL_WRAPPER_RET
+
+static bool OpenGLLoadFunction(PulseDevice device, OpenGLFunctionIndex index)
+{
+	OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*);
+	GLFunctionLoad load = PULSE_NULLPTR;
+
+	#ifdef PULSE_PLAT_WINDOWS
+		if(opengl_device->context_type == OPENGL_CONTEXT_WGL)
+		{} // TODO: WGL
+		else
+			load = (GLFunctionLoad)opengl_device->egl_instance.eglGetProcAddress;
+	#else
+		load = (GLFunctionLoad)opengl_device->egl_instance.eglGetProcAddress;
+	#endif
+
+	GLFunction fn = load(OpenGLFunctionIndexToFunctionName[index]);
+	if(!fn)
+	{
+		PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
+		return false;
+	}
+	opengl_device->original_function_ptrs[index] = fn;
+	return true;
+}
+
+static bool OpenGLLoadFunctions(PulseDevice device)
+{
+	OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*);
+
+	for(int i = 0; i < OPENGL_FUNCTION_INDEX_END_ENUM; i++)
+	{
+		if(!OpenGLLoadFunction(device, i))
+			return false;
+	}
+
+	#define PULSE_OPENGL_FUNCTION(fn, T) opengl_device->fn = PulseOpenGLWrapper_##fn;
+		#include "OpenGLFunctions.h"
+	#undef PULSE_OPENGL_FUNCTION
+
+	return true;
+}
+
+PulseDevice OpenGLCreateDevice(PulseBackend backend, PulseDevice* forbiden_devices, uint32_t forbiden_devices_count)
+{
+	PULSE_CHECK_HANDLE_RETVAL(backend, PULSE_NULLPTR);
+
+	PulseDevice pulse_device = (PulseDeviceHandler*)calloc(1, sizeof(PulseDeviceHandler));
+	PULSE_CHECK_ALLOCATION_RETVAL(pulse_device, PULSE_NULL_HANDLE);
+
+	OpenGLDevice* device = (OpenGLDevice*)calloc(1, sizeof(OpenGLDevice));
+	PULSE_CHECK_ALLOCATION_RETVAL(device, PULSE_NULL_HANDLE);
+
+	pulse_device->driver_data = device;
+	pulse_device->backend = backend;
+
+	#ifdef PULSE_PLAT_WINDOWS
+		// WGL support
+		if(opengl_device->context_type == OPENGL_CONTEXT_WGL)
+		{
+			// TODO: WGL
+			device->context_type = OPENGL_CONTEXT_WGL;
+		}
+		else
+		{
+			EGLLoadInstance(&device->egl_instance, forbiden_devices, forbiden_devices_count, backend->backend == PULSE_BACKEND_OPENGL_ES);
+			device->context_type = OPENGL_CONTEXT_EGL;
+		}
+	#else
+		EGLLoadInstance(&device->egl_instance, forbiden_devices, forbiden_devices_count, backend->backend == PULSE_BACKEND_OPENGL_ES);
+		device->context_type = OPENGL_CONTEXT_EGL;
+	#endif
+
+	if(!OpenGLLoadFunctions(pulse_device))
+	{
+		EGLUnloadInstance(&device->egl_instance);
+		PulseSetInternalError(PULSE_ERROR_INITIALIZATION_FAILED);
+		return PULSE_NULL_HANDLE;
+	}
+
+	PULSE_LOAD_DRIVER_DEVICE(OpenGL);
+
+	if(PULSE_IS_BACKEND_HIGH_LEVEL_DEBUG(backend))
+		PulseLogInfoFmt(backend, "%s created device from %s", backend->backend == PULSE_BACKEND_OPENGL ? "(OpenGL)" : "(OpenGL ES)", device->glGetString(pulse_device, GL_RENDERER));
+	return pulse_device;
+}
+
+void OpenGLDestroyDevice(PulseDevice device)
+{
+	OpenGLDevice* opengl_device = OPENGL_RETRIEVE_DRIVER_DATA_AS(device, OpenGLDevice*);
+	if(opengl_device == PULSE_NULLPTR)
+		return;
+
+	#ifdef PULSE_PLAT_WINDOWS
+		if(opengl_device->context_type == OPENGL_CONTEXT_WGL)
+		{} // TODO: WGL
+		else
+			EGLUnloadInstance(&opengl_device->egl_instance);
+	#else
+		EGLUnloadInstance(&opengl_device->egl_instance);
+	#endif
+	free(opengl_device);
+	free(device);
+}