revitalise

1 files changed, 238 insertions, 106 deletions

diff --git a/rsgl.c3l/include/RSGL.h b/rsgl.c3l/include/RSGL.h
index 3c28e44..9ea15dd 100644
--- a/rsgl.c3l/include/RSGL.h
+++ b/rsgl.c3l/include/RSGL.h
@@ -1,6 +1,6 @@
 /*
 *
-* Copyright (c) 2021-25 ColleagueRiley ColleagueRiley@gmail.com
+* Copyright (c) 2021-26 ColleagueRiley ColleagueRiley@gmail.com
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
@@ -31,12 +31,6 @@
     #define RSGL_MAX_VERTS [number of verts] - set max number of verts to be allocated (global, not per batch)
 */
 #include <stdint.h>
-#ifndef RSGL_MAX_BATCHES
-#define RSGL_MAX_BATCHES 2028
-#endif
-#ifndef RSGL_MAX_VERTS
-#define RSGL_MAX_VERTS 8192
-#endif
 
 #ifndef RSGL_MALLOC
 #include <stdlib.h>
@@ -45,6 +39,15 @@
 #define RSGL_FREE free
 #endif
 
+#ifndef RSGL_ASSERT
+	#include <assert.h>
+	#define RSGL_ASSERT(x) assert(x)
+#endif
+
+#ifndef RSGL__STATIC_ASSERT
+	#define RSGL_STATIC_ASSERT(check_name, x) typedef char RSGL_check_##check_name[(x) ? 1 : -1];
+#endif
+
 #ifndef RSGL_SIN
 #include <math.h>
 #define RSGL_SIN sinf
@@ -61,6 +64,13 @@
 	#define RSGL_MEMSET(ptr, value, num) memset(ptr, value, num)
 #endif
 
+#ifdef RSGL_DEBUG
+	#ifndef RSGL_PRINTF
+		#include <stdio.h>
+		#define RSGL_PRINTF printf
+	#endif /* RSGL_PRINTF */
+#endif /* RSGL_DEBUG */
+
 #ifndef RSGL_H
 #define RSGL_H
 #ifndef RSGLDEF
@@ -71,18 +81,30 @@
 #endif
 #endif
 
+#include <stddef.h>
+
 #ifndef RSGL_INT_DEFINED
-    #define RSGL_INT_DEFINED
-	#if defined(_MSC_VER) || defined(__SYMBIAN32__)
-		typedef unsigned char 	u8;
-		typedef signed char		i8;
-		typedef unsigned short  u16;
-		typedef signed short 	i16;
-		typedef unsigned int 	u32;
-		typedef signed int		i32;
-		typedef unsigned long long	u64;
-		typedef signed   long long	i64;
-	#else
+	#ifdef RSGL_USE_INT /* optional for any system that might not have stdint.h */
+		#include <limits.h>
+		typedef unsigned char       u8;
+		typedef signed char         i8;
+		typedef unsigned short     u16;
+		typedef signed short 	   i16;
+		#if INT_MAX == 0x7FFFFFFF
+			typedef unsigned int  u32;
+			typedef signed int    i32;
+		#else
+			typedef unsigned long int  u32;
+			typedef signed long int    i32;
+		#endif
+		#if LONG_MAX == 0x7FFFFFFFFFFFFFFFL
+	typedef unsigned long u64;
+			typedef signed long   i64;
+		#else
+			typedef unsigned long long u64;
+			typedef signed long long   i64;
+		#endif
+	#else /* use stdint standard types instead of c "standard" types */
 		#include <stdint.h>
 
 		typedef uint8_t     u8;
@@ -94,19 +116,71 @@
 		typedef uint64_t   u64;
 		typedef int64_t    i64;
 	#endif
+	#define RSGL_INT_DEFINED
 #endif
 
+RSGL_STATIC_ASSERT(size64, sizeof(i64) == 8)
+RSGL_STATIC_ASSERT(size32, sizeof(i32) == 4)
+RSGL_STATIC_ASSERT(size16, sizeof(i16) == 2)
+
 #ifndef RSGL_BOOL_DEFINED
-#define RSGL_BOOL_DEFINED
+	#define RSGL_BOOL_DEFINED
 
-#include <stdbool.h>
-typedef bool RSGL_bool;
+	#include <stdbool.h>
+	typedef bool RSGL_bool;
 #endif
 
 #define RSGL_TRUE (RSGL_bool)1
 #define RSGL_FALSE (RSGL_bool)0
 
-typedef enum RSGL_textureFormat {
+#ifndef RSGL_MAX_BATCHES
+	#define RSGL_MAX_BATCHES 2028
+#endif
+
+	#ifndef RSGL_MAX_VERTS
+#define RSGL_MAX_VERTS 8192
+#endif
+
+#define RSGL_ENUM(type, name) type name; enum name##_enum
+
+/* 
+******
+RSGL_debug
+*****
+*/
+
+/*! @brief the type of debug message */
+typedef RSGL_ENUM(u8, RSGL_debugType) {
+	RSGL_typeError = 0, RSGL_typeWarning, RSGL_typeInfo
+};
+
+/*! @brief error codes for known failure types */
+typedef RSGL_ENUM(u8, RSGL_errorCode) {
+	RSGL_noError = 0, /*!< no error */
+	RSGL_errorBackend, 
+	RSGL_errorQueryFail,
+	RSGL_errorShader,
+	RSGL_infoBackend,
+	RSGL_infoShader,
+	RSGL_warningBackend
+};
+
+/*! @brief data for debug messages */
+typedef struct RSGL_debugInfo {
+	RSGL_debugType type; /*!< the type of message */
+	RSGL_errorCode code; /*!< the code for the specific type of debug message */
+	const char* msg; /*!< string message */
+} RSGL_debugInfo;
+
+typedef void (* RSGL_debugFunc)(const RSGL_debugInfo* info);
+
+/* 
+******
+RSGL_renderer types
+*****
+*/
+
+typedef RSGL_ENUM(i32, RSGL_textureFormat) {
 	RSGL_formatNone = 0,
 	RSGL_formatRGB,    /*!< 8-bit RGB (3 channels) */
     RSGL_formatBGR,    /*!< 8-bit BGR (3 channels) */
@@ -116,17 +190,17 @@ typedef enum RSGL_textureFormat {
     RSGL_formatGrayscale,   /*!< 8-bit grayscale (1 channel) */
     RSGL_formatGrayscaleAlpha,   /*!< 8-bit grayscale alpha (1 channel) */
 	RSGL_formatCount
-} RSGL_textureFormat;
+};
 
-typedef enum RSGL_textureDataType {
+typedef RSGL_ENUM(i32, RSGL_textureDataType) {
 	RSGL_textureDataInt = 0,
 	RSGL_textureDataFloat
-} RSGL_textureDataType;
+};
 
-typedef enum RSGL_textureFilter {
+typedef RSGL_ENUM(i32, RSGL_textureFilter) {
 	RSGL_filterNearest = 0,
 	RSGL_filterLinear
-} RSGL_textureFilter;
+};
 
 typedef struct RSGL_textureBlob {
 	void* data; /* input data */
@@ -197,41 +271,23 @@ typedef struct RSGL_color {
 #define RSGL_RGB_TO_HEX(r, g, b, a) (RSGL_COLOR_TO_HEX(RSGL_RGBA(r, g, b, a)))
 #define RSGL_RGBA_TO_HEX(r, g, b) (RSGL_COLOR_TO_HEX(RSGL_RGB(r, g, b, a)))
 
-/*
-*********************
-RSGL matrix math
-*********************
-*/
-
 #ifndef RSGL_mat4
 typedef struct RSGL_mat4 {
     float m[16];
 } RSGL_mat4;
 #endif
 
-RSGLDEF RSGL_mat4 RSGL_mat4_loadIdentity(void);
-RSGLDEF RSGL_mat4 RSGL_mat4_scale(float matrix[16], float x, float y, float z);
-RSGLDEF RSGL_mat4 RSGL_mat4_rotate(float matrix[16], float angle, float x, float y, float z);
-RSGLDEF RSGL_mat4 RSGL_mat4_translate(float matrix[16], float x, float y, float z);
-RSGLDEF RSGL_mat4 RSGL_mat4_perspective(float matrix[16], float fovY, float aspect, float zNear, float zFar);
-RSGLDEF RSGL_mat4 RSGL_mat4_ortho(float matrix[16], float left, float right, float bottom, float top, float znear, float zfar);
-RSGLDEF RSGL_mat4 RSGL_mat4_lookAt(float matrix[16], float eyeX, float eyeY, float eyeZ, float targetX, float targetY, float targetZ, float upX, float upY, float upZ);
-
-RSGLDEF RSGL_mat4 RSGL_mat4_multiply(float left[16], float right[16]);
-
-RSGLDEF RSGL_vec3D RSGL_mat4_multiplyPoint(RSGL_mat4 matrix, RSGL_vec3D point);
-
 /*
 *******
 RSGL_perspective
 *******
 */
 
-typedef enum RSGL_projectionType {
+typedef RSGL_ENUM(i32, RSGL_projectionType) {
 	RSGL_projectionOrtho2D = 0,
 	RSGL_projectionOrtho3D,
 	RSGL_projectionPerspective3D,
-} RSGL_projectionType;
+};
 
 typedef struct RSGL_projection2D {
 	RSGL_projectionType type;
@@ -253,7 +309,26 @@ typedef union RSGL_projection {
 	RSGL_projection3D p3D;
 } RSGL_projection;
 
-RSGLDEF RSGL_mat4 RSGL_projection_getMatrix(const RSGL_projection* projection);
+/*
+*******
+RSGL_draw low level
+*******
+*/
+
+typedef RSGL_ENUM(i32, RSGL_drawType) {
+	RSGL_TRIANGLES = 0,
+	RSGL_POINTS = 1,
+	RSGL_LINES = 2
+};
+
+typedef struct RSGL_rawVerts {
+	RSGL_drawType type;
+	float* verts;
+	float* texCoords;
+	u16* elements;
+	size_t elmCount;
+	size_t vert_count;
+} RSGL_rawVerts;
 
 /*
 *********************
@@ -262,12 +337,12 @@ RSGL renderer
 */
 
 /* used internally for RSGL_deleteProgram */
-typedef enum RSGL_shaderType {
+typedef RSGL_ENUM(i32, RSGL_shaderType) {
 	RSGL_shaderTypeNone = 0,
 	RSGL_shaderTypeStandard = 1, /* standard vertex+fragment shader */
 	RSGL_shaderTypeCompute = 2,
 	RSGL_shaderTypeGeometry = 4, /* unimplemented as of now */
-} RSGL_shaderType;
+};
 
 /* shader program and blob */
 typedef struct RSGL_programBlob {
@@ -291,7 +366,7 @@ typedef struct RSGL_programInfo {
 typedef struct RSGL_BATCH {
     size_t start, len; /* when batch starts and it's length */
     size_t elmStart, elmCount; /* when element batch starts and it's length */
-    u32 type;
+	RSGL_drawType type;
     RSGL_texture tex;
     float lineWidth;
     RSGL_mat4 matrix;
@@ -308,13 +383,13 @@ typedef struct RSGL_renderData {
 	RSGL_mat4 perspective; /* perspective matrix */
 } RSGL_renderData;
 
-typedef enum RSGL_bufferType {
+typedef RSGL_ENUM(i32, RSGL_bufferType) {
 	RSGL_arrayBuffer = 0,
 	RSGL_elementArrayBuffer,
 	RSGL_shaderStorageBuffer,
 	RSGL_textureBuffer,
 	RSGL_uniformBuffer
-} RSGL_bufferType;
+};
 
 typedef struct RSGL_renderBuffers {
 	size_t vertex, color, texture, elements;
@@ -401,6 +476,81 @@ typedef struct RSGL_renderer {
 	RSGL_renderBuffers buffers;
 } RSGL_renderer;
 
+/*
+*******
+RSGL_view
+*******
+*/
+
+typedef RSGL_ENUM(i32, RSGL_viewType) {
+	RSGL_viewTypeNone = 0,
+	RSGL_viewType2D,
+	RSGL_viewType3D,
+};
+
+typedef struct RSGL_view2D {
+	RSGL_viewType type;
+	RSGL_vec3D offset;
+	RSGL_vec3D target;
+    float rotation;
+    float zoom;
+} RSGL_view2D;
+
+/* RSGL translation */
+typedef struct RSGL_view3D {
+	RSGL_viewType type;
+	RSGL_vec3D pos;
+	RSGL_vec3D target;
+    RSGL_vec3D up;
+} RSGL_view3D;
+
+typedef union RSGL_view {
+	RSGL_viewType type;
+	RSGL_view2D view2D;
+	RSGL_view3D view3D;
+} RSGL_view;
+
+/* 
+******
+RSGL_debug
+*****
+*/
+
+RSGLDEF RSGL_debugFunc RSGL_setDebugCallback(RSGL_debugFunc func);
+RSGLDEF void RSGL_debugCallback(RSGL_debugType type, RSGL_errorCode code, const char* msg);
+
+/*
+*********************
+RSGL matrix math
+*********************
+*/
+
+RSGLDEF RSGL_mat4 RSGL_mat4_loadIdentity(void);
+RSGLDEF RSGL_mat4 RSGL_mat4_scale(float matrix[16], float x, float y, float z);
+RSGLDEF RSGL_mat4 RSGL_mat4_rotate(float matrix[16], float angle, float x, float y, float z);
+RSGLDEF RSGL_mat4 RSGL_mat4_translate(float matrix[16], float x, float y, float z);
+RSGLDEF RSGL_mat4 RSGL_mat4_perspective(float matrix[16], float fovY, float aspect, float zNear, float zFar);
+RSGLDEF RSGL_mat4 RSGL_mat4_ortho(float matrix[16], float left, float right, float bottom, float top, float znear, float zfar);
+RSGLDEF RSGL_mat4 RSGL_mat4_lookAt(float matrix[16], float eyeX, float eyeY, float eyeZ, float targetX, float targetY, float targetZ, float upX, float upY, float upZ);
+
+RSGLDEF RSGL_mat4 RSGL_mat4_multiply(float left[16], float right[16]);
+
+RSGLDEF RSGL_vec3D RSGL_mat4_multiplyPoint(RSGL_mat4 matrix, RSGL_vec3D point);
+
+/*
+*******
+RSGL_perspective
+*******
+*/
+
+RSGLDEF RSGL_mat4 RSGL_projection_getMatrix(const RSGL_projection* projection);
+
+/*
+*********************
+RSGL renderer
+*********************
+*/
+
 RSGLDEF void RSGL_renderer_getRenderState(RSGL_renderer* renderer, RSGL_renderState* state);
 
 RSGLDEF size_t RSGL_renderer_size(RSGL_renderer* renderer);
@@ -490,21 +640,6 @@ RSGL_drawRawVerts is a function used internally by RSGL, but you can use it your
 RSGL_drawRawVerts batches a given set of points based on th data to be rendered
 */
 
-typedef enum RSGL_drawType {
-	RSGL_TRIANGLES = 0,
-	RSGL_POINTS = 1,
-	RSGL_LINES = 2
-} RSGL_drawType;
-
-typedef struct RSGL_rawVerts {
-	RSGL_drawType type;
-	float* verts;
-	float* texCoords;
-	u16* elements;
-	size_t elmCount;
-	size_t vert_count;
-} RSGL_rawVerts;
-
 RSGLDEF i32 RSGL_drawRawVerts(RSGL_renderer* renderer, const RSGL_rawVerts* data);
 
 /*
@@ -567,16 +702,12 @@ RSGLDEF i32 RSGL_drawCube(RSGL_renderer* renderer, RSGL_cube cube);
 RSGLDEF i32 RSGL_drawTriangleOutline(RSGL_renderer* renderer, RSGL_vec3D triangle[3], u32 thickness);
 
 RSGLDEF i32 RSGL_drawRectOutline(RSGL_renderer* renderer, RSGL_rect r, u32 thickness);
-RSGLDEF i32 RSGL_drawRectOutline(RSGL_renderer* renderer, RSGL_rect r, u32 thickness);
 
 RSGLDEF i32 RSGL_drawRoundRectOutline(RSGL_renderer* renderer, RSGL_rect r, RSGL_vec2D rounding, u32 thickness);
-RSGLDEF i32 RSGL_drawRoundRectOutline(RSGL_renderer* renderer, RSGL_rect r, RSGL_vec2D rounding, u32 thickness);
 
 RSGLDEF i32 RSGL_drawPolygonOutline(RSGL_renderer* renderer, RSGL_rect r, u32 sides, u32 thickness);
-RSGLDEF i32 RSGL_drawPolygonOutline(RSGL_renderer* renderer, RSGL_rect r, u32 sides, u32 thickness);
 
 RSGLDEF i32 RSGL_drawArcOutline(RSGL_renderer* renderer, RSGL_rect o, RSGL_vec2D arc, u32 thickness);
-RSGLDEF i32 RSGL_drawArcOutline(RSGL_renderer* renderer, RSGL_rect o, RSGL_vec2D arc, u32 thickness);
 
 RSGLDEF i32 RSGL_drawOvalOutline(RSGL_renderer* renderer, RSGL_rect o, u32 thickness);
 
@@ -586,34 +717,6 @@ RSGL_view
 *******
 */
 
-typedef enum RSGL_viewType {
-	RSGL_viewTypeNone = 0,
-	RSGL_viewType2D,
-	RSGL_viewType3D,
-} RSGL_viewType;
-
-typedef struct RSGL_view2D {
-	RSGL_viewType type;
-	RSGL_vec3D offset;
-	RSGL_vec3D target;
-    float rotation;
-    float zoom;
-} RSGL_view2D;
-
-/* RSGL translation */
-typedef struct RSGL_view3D {
-	RSGL_viewType type;
-	RSGL_vec3D pos;
-	RSGL_vec3D target;
-    RSGL_vec3D up;
-} RSGL_view3D;
-
-typedef union RSGL_view {
-	RSGL_viewType type;
-	RSGL_view2D view2D;
-	RSGL_view3D view3D;
-} RSGL_view;
-
 RSGLDEF RSGL_mat4 RSGL_view_getMatrix(const RSGL_view* view);
 
 #endif /* ndef RSGL_HIGHLEVEL_H && ndef RSGL_NO_HIGHLEVEL */
@@ -646,6 +749,33 @@ RSGLDEF RSGL_mat4 RSGL_view_getMatrix(const RSGL_view* view);
             RSGL_GET_MATRIX_Z(x, y, z), \
             RSGL_GET_MATRIX_W(x, y, z) \
 
+RSGL_debugFunc RSGL_debugCallbackSrc = NULL;
+RSGL_debugFunc RSGL_setDebugCallback(RSGL_debugFunc func) {
+	RSGL_debugFunc prev = func;
+	RSGL_debugCallbackSrc = func;
+	return prev;
+}
+
+void RSGL_debugCallback(RSGL_debugType type, RSGL_errorCode code, const char* msg) {
+	RSGL_debugInfo info;
+	info.type = type;
+	info.code = code;
+	info.msg = msg;
+
+	if (RSGL_debugCallbackSrc) RSGL_debugCallbackSrc(&info);
+
+    #ifdef RSGL_DEBUG
+	switch (type) {
+		case RSGL_typeInfo: RSGL_PRINTF("RSGL INFO (%i %i): %s", type, code, msg); break;
+		case RSGL_typeError: RSGL_PRINTF("RSGL DEBUG (%i %i): %s", type, code, msg); break;
+		case RSGL_typeWarning: RSGL_PRINTF("RSGL WARNING (%i %i): %s", type, code, msg); break;
+		default: break;
+	}
+
+	RSGL_PRINTF("\n");
+	#endif
+}
+
 void RSGL_renderer_forceBatch(RSGL_renderer* renderer) {
     renderer->state.forceBatch = RSGL_TRUE;
 }
@@ -844,8 +974,9 @@ void RSGL_renderer_initPtr(RSGL_rendererProc proc, void* loader, void* data, RSG
 	renderer->data.len = 0;
 	renderer->data.elements_count = 0;
 
-	if (renderer->proc.initPtr)
+	if (renderer->proc.initPtr) {
 		renderer->proc.initPtr(renderer->ctx, loader);
+	}
 
 	RSGL_renderer_setFramebuffer(renderer, 0);
 
@@ -911,7 +1042,7 @@ RSGL_texture RSGL_renderer_createTexture(RSGL_renderer* renderer, const RSGL_tex
 	return tex;
 }
 void RSGL_renderer_copyToTexture(RSGL_renderer* renderer, RSGL_texture texture, size_t x, size_t y, const RSGL_textureBlob* blob) {
-    return renderer->proc.copyToTexture(renderer->ctx, texture, x, y, blob);
+    renderer->proc.copyToTexture(renderer->ctx, texture, x, y, blob);
 }
 void RSGL_renderer_deleteTexture(RSGL_renderer* renderer, RSGL_texture tex) { renderer->proc.deleteTexture(renderer->ctx, tex); }
 void RSGL_renderer_scissorStart(RSGL_renderer* renderer, RSGL_rect scissor, i32 height) {
@@ -953,9 +1084,8 @@ RSGL_programInfo RSGL_renderer_createProgram(RSGL_renderer* renderer, RSGL_progr
 	RSGL_programInfo info;
 	RSGL_MEMSET(&info, 0, sizeof(info));
 
-	if (blob->fragment == NULL || blob->vertex == NULL) {
+	if (renderer->proc.createProgram != NULL && (blob->fragment == NULL || blob->vertex == NULL)) {
 		RSGL_programBlob pBlob = RSGL_renderer_defaultBlob(renderer);
-		renderer->defaultProgram = RSGL_renderer_createProgram(renderer, &pBlob);
 
 		if (blob->vertex == NULL) {
 			blob->vertex = pBlob.vertex;
@@ -974,7 +1104,9 @@ RSGL_programInfo RSGL_renderer_createProgram(RSGL_renderer* renderer, RSGL_progr
 
 	return info;
 }
-void RSGL_renderer_deleteProgram(RSGL_renderer* renderer, const RSGL_programInfo* program) { return renderer->proc.deleteProgram(renderer->ctx, program); }
+void RSGL_renderer_deleteProgram(RSGL_renderer* renderer, const RSGL_programInfo* program) { 
+	renderer->proc.deleteProgram(renderer->ctx, program); 
+}
 
 size_t RSGL_renderer_findShaderVariable(RSGL_renderer* renderer, const RSGL_programInfo* program, const char* var, size_t len) {
     return renderer->proc.findShaderVariable(renderer->ctx, program, var, len);
@@ -1129,7 +1261,7 @@ RFont_texture RFont_RSGL_createAtlas(RSGL_renderer* renderer, u32 atlasWidth, u3
 	RSGL_textureBlob blob;
 	blob.data = NULL;
 	blob.width = atlasWidth;
-	blob.height = atlasWidth;
+	blob.height = atlasHeight;
 	blob.dataType = RSGL_textureDataInt;
 	blob.dataFormat = RSGL_formatRGBA; //RSGL_formatRGBA;
 	blob.textureFormat = RSGL_formatRGBA;//RSGL_formatRGBA;