modularise

1 files changed, 0 insertions, 1925 deletions

diff --git a/include/RSGL.h b/include/RSGL.h
deleted file mode 100644
index 3c28e44..0000000
--- a/include/RSGL.h
+++ /dev/null
@@ -1,1925 +0,0 @@
-/*
-*
-* Copyright (c) 2021-25 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
-* arising from the use of this software.
-*
-* Permission is granted to anyone to use this software for any purpose,
-* including commercial applications, and to alter it and redistribute it
-* freely, subject to the following restrictions:
-*
-* 1. The origin of this software must not be misrepresented; you must not
-* claim that you wrote the original software. If you use this software
-* in a product, an acknowledgment in the product documentation would be
-* appreciated but is not required.
-* 2. Altered source versions must be plainly marked as such, and must not be
-* misrepresented as being the original software.
-* 3. This notice may not be removed or altered from any source distribution.
-*
-*
-*/
-
-/*
-    define args
-    (MAKE SURE RSGL_IMPLEMENTATION is in exactly one header or you use -DRSGL_IMPLEMENTATION)
-	#define RSGL_IMPLEMENTATION - makes it so source code is included with header
-
-    #define RSGL_RFONT - do include functions to help with integrating RFont and RSGL
-	#define RSGL_MAX_BATCHES [number of batches] - set max number of batches to be allocated
-    #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>
-#define RSGL_MALLOC malloc
-#define RSGL_REALLOC realloc
-#define RSGL_FREE free
-#endif
-
-#ifndef RSGL_SIN
-#include <math.h>
-#define RSGL_SIN sinf
-#define RSGL_COS cosf
-#endif
-
-#ifndef RSGL_UNUSED
-#define RSGL_UNUSED(x) (void) (x);
-#endif
-
-#ifndef RSGL_MEMCPY
-	#include <string.h>
-	#define RSGL_MEMCPY(dest, src, count) memcpy(dest, src, count)
-	#define RSGL_MEMSET(ptr, value, num) memset(ptr, value, num)
-#endif
-
-#ifndef RSGL_H
-#define RSGL_H
-#ifndef RSGLDEF
-#ifdef __APPLE__
-#define RSGLDEF extern inline
-#else
-#define RSGLDEF inline
-#endif
-#endif
-
-#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
-		#include <stdint.h>
-
-		typedef uint8_t     u8;
-		typedef int8_t      i8;
-		typedef uint16_t   u16;
-		typedef int16_t    i16;
-		typedef uint32_t   u32;
-		typedef int32_t    i32;
-		typedef uint64_t   u64;
-		typedef int64_t    i64;
-	#endif
-#endif
-
-#ifndef RSGL_BOOL_DEFINED
-#define RSGL_BOOL_DEFINED
-
-#include <stdbool.h>
-typedef bool RSGL_bool;
-#endif
-
-#define RSGL_TRUE (RSGL_bool)1
-#define RSGL_FALSE (RSGL_bool)0
-
-typedef enum RSGL_textureFormat {
-	RSGL_formatNone = 0,
-	RSGL_formatRGB,    /*!< 8-bit RGB (3 channels) */
-    RSGL_formatBGR,    /*!< 8-bit BGR (3 channels) */
-	RSGL_formatRGBA,   /*!< 8-bit RGBA (4 channels) */
-    RSGL_formatBGRA,   /*!< 8-bit BGRA (4 channels) */
-    RSGL_formatRed,   /*!< 8-bit RED (1 channel) */
-    RSGL_formatGrayscale,   /*!< 8-bit grayscale (1 channel) */
-    RSGL_formatGrayscaleAlpha,   /*!< 8-bit grayscale alpha (1 channel) */
-	RSGL_formatCount
-} RSGL_textureFormat;
-
-typedef enum RSGL_textureDataType {
-	RSGL_textureDataInt = 0,
-	RSGL_textureDataFloat
-} RSGL_textureDataType;
-
-typedef enum RSGL_textureFilter {
-	RSGL_filterNearest = 0,
-	RSGL_filterLinear
-} RSGL_textureFilter;
-
-typedef struct RSGL_textureBlob {
-	void* data; /* input data */
-	size_t width; /* width of the texture */
-	size_t height; /* height of the texture */
-	RSGL_textureDataType dataType;
-	RSGL_textureFormat dataFormat; /* format of the input data */
-	RSGL_textureFormat textureFormat; /* final format for the texture */
-	RSGL_textureFilter minFilter; /* filter used when rendering a surface smaller than the base texture */
-	RSGL_textureFilter magFilter;  /* filter used when rendering a surface bigger than the base texture */
-} RSGL_textureBlob;
-
-#ifndef RSGL_texture
-#define RSGL_texture size_t
-#endif
-
-#ifndef RSGL_framebuffer
-#define RSGL_framebuffer size_t
-#endif
-
-/*
-*******
-RSGL shapes
-*******
-*/
-
-#ifndef RSGL_rect
-typedef struct RSGL_rect { float x, y, w, h; } RSGL_rect;
-#endif
-
-#define RSGL_RECT(x, y, w, h) (RSGL_rect){(float)x, (float)y, (float)w, (float)h}
-
-#ifndef RSGL_cube
-typedef struct RSGL_cube { float x, y, z, w, h, l; } RSGL_cube;
-#endif
-
-#define RSGL_CUBE(x, y, z, w, h, l) (RSGL_cube){(float)x, (float)y, (float)z, (float)w, (float)h, (float)l}
-
-#ifndef RSGL_vec2D
-typedef struct RSGL_vec2D { float x, y; } RSGL_vec2D;
-#endif
-#define RSGL_VEC2D(x, y) (RSGL_vec2D){(float)x, (float)y}
-
-#ifndef RSGL_vec3D
-typedef struct RSGL_vec3D { float x, y, z; } RSGL_vec3D;
-#endif
-
-#define RSGL_VEC3D(x, y, z) (RSGL_vec3D){(float)x, (float)y, (float)z}
-
-#define RSGL_TRIANGLE(p1, p2, p3) (RSGL_vec3D[3]){p1, p2, p3}
-#define RSGL_createTriangle(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z) RSGL_TRIANGLE3D(RSGL_VEC3D(p1x, p1y, p1z), RSGL_VEC3D(p2x, p2y, p2z), RSGL_VEC3D(p3x, p3y, p3z))
-
-/*
-the color stucture is in
-ABGR by default for performance reasons
-(converting color to hex for example)
-*/
-#ifndef RSGL_color
-typedef struct RSGL_color {
-    u8 a, b, g, r;
-} RSGL_color;
-#endif
-
-#define RSGL_RGBA(r, g, b, a) ((RSGL_color){(u8)(a), (u8)(b), (u8)(g), (u8)(r)})
-#define RSGL_RGB(r, g, b) ((RSGL_color){255, (u8)(b), (u8)(g), (u8)(r)})
-
-#define RSGL_COLOR_TO_HEX(color) ((u32)(color) & 0xFFFFFF00)
-#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 {
-	RSGL_projectionOrtho2D = 0,
-	RSGL_projectionOrtho3D,
-	RSGL_projectionPerspective3D,
-} RSGL_projectionType;
-
-typedef struct RSGL_projection2D {
-	RSGL_projectionType type;
-	u32 width;
-	u32 height;
-} RSGL_projection2D;
-
-typedef struct RSGL_projection3D {
-	RSGL_projectionType type;
-	float fov;
-	float ratio;
-	float pNear;
-	float pFar;
-} RSGL_projection3D;
-
-typedef union RSGL_projection {
-	RSGL_projectionType type;
-	RSGL_projection2D p2D;
-	RSGL_projection3D p3D;
-} RSGL_projection;
-
-RSGLDEF RSGL_mat4 RSGL_projection_getMatrix(const RSGL_projection* projection);
-
-/*
-*********************
-RSGL renderer
-*********************
-*/
-
-/* used internally for RSGL_deleteProgram */
-typedef enum 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 {
-	const char* vertex;
-	size_t vertexLen;
-	const char* fragment;
-	size_t fragmentLen;
-} RSGL_programBlob;
-
-typedef struct RSGL_programInfo {
-    size_t program;
-	size_t perspectiveView;
-	size_t model;
-	size_t vertexPosition;
-	size_t vertexTexCoord;
-	size_t vertexColor;
-
-	RSGL_shaderType type;
-} 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_texture tex;
-    float lineWidth;
-    RSGL_mat4 matrix;
-} RSGL_BATCH; /* batch data type for rendering */
-
-typedef struct RSGL_renderData {
-	float* verts;
-	float* texCoords;
-	float* colors;
-	u16* elements;
-	size_t elements_count;
-    size_t len; /* number of verts */
-
-	RSGL_mat4 perspective; /* perspective matrix */
-} RSGL_renderData;
-
-typedef enum 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;
-	size_t maxVerts;
-
-	RSGL_BATCH batches[RSGL_MAX_BATCHES];
-    size_t batchCount;
-} RSGL_renderBuffers;
-
-typedef struct RSGL_renderState {
-    float* gradient; /* does not allocate any memory */
-
-	RSGL_rect source;
-    RSGL_texture texture;
-    u32 gradient_len;
-
-	RSGL_color color;
-
-    RSGL_vec3D rotate;
-	RSGL_programInfo* program;
-	RSGL_renderBuffers* buffers;
-
-    RSGL_vec3D center;
-    float lineWidth;
-	RSGL_mat4 modelMatrix;
-	RSGL_mat4 viewMatrix;
-	RSGL_mat4 perspectiveMatrix;
-	RSGL_bool forceBatch;
-	RSGL_bool overflow;
-	RSGL_framebuffer framebuffer;
-} RSGL_renderState;
-
-typedef struct RSGL_renderPass {
-	RSGL_programInfo* program;
-	float* matrix;
-	RSGL_renderBuffers* buffers;
-	RSGL_framebuffer framebuffer;
-} RSGL_renderPass;
-
-typedef struct RSGL_rendererProc {
-	size_t (*size)(void); /* get the size of the renderer's internal struct */
-	RSGL_programBlob (*defaultBlob)(void* ctx);
-	void (*initPtr)(void* ctx, void* proc); /* init render backend */
-	void (*freePtr)(void* ctx); /* free render backend */
-	void (*render)(void* ctx, const RSGL_renderPass* pass);
-	void (*clear)(void* ctx, RSGL_framebuffer framebuffer, float r, float g, float b, float a);
-	void (*viewport)(void* ctx, i32 x, i32 y, i32 w, i32 h);
-	void (*setSurface)(void* ctx, void* surface);
-	RSGL_texture (*createTexture)(void* ctx, const RSGL_textureBlob* blob);
-	void (*copyToTexture)(void* ctx, RSGL_texture texture, size_t x, size_t y, const RSGL_textureBlob* blob);
-	void (*deleteTexture)(void* ctx, RSGL_texture tex);
-	void (*scissorStart)(void* ctx, float x, float y, float w, float h, float renderer_height);
-	void (*scissorEnd)(void* ctx);
-	RSGL_programInfo (*createProgram)(void* ctx, RSGL_programBlob* blob);
-	void (*deleteProgram)(void* ctx, const RSGL_programInfo* program);
-	size_t (*findShaderVariable)(void*, const RSGL_programInfo*, const char*, size_t);
-	void (*updateShaderVariable)(void*, const RSGL_programInfo*, size_t, const float[], u8);
-	RSGL_programInfo (*createComputeProgram)(void* ctx, const char* CShaderCode);
-	void (*dispatchComputeProgram)(void* ctx, const RSGL_programInfo* program, u32 groups_x, u32 groups_y, u32 groups_z);
-	void (*bindComputeTexture)(void* ctx, u32 texture, u8 format);
-	void (*createBuffer)(void* ctx, RSGL_bufferType type,  size_t size, const void* data, size_t* buffer);
-	void (*updateBuffer)(void* ctx, RSGL_bufferType type, size_t buffer, void* data, size_t start, size_t len);
-	void (*deleteBuffer)(void* ctx, size_t buffer);
-	RSGL_framebuffer (*createFramebuffer)(void* ctx, size_t width, size_t height);
-	void (*attachFramebuffer)(void* ctx, RSGL_framebuffer fbo, RSGL_texture tex, u8 attachType, u8 mipLevel);
-	void (*deleteFramebuffer)(void* ctx, RSGL_framebuffer fbo);
-} RSGL_rendererProc;
-
-typedef struct RSGL_renderer {
-	RSGL_renderData data;
-	RSGL_renderState state;
-	RSGL_rendererProc proc;
-	void* userPtr;
-	void* ctx; /* pointer for the renderer backend to store any internal data it wants/needs  */
-
-	RSGL_texture defaultTexture;
-	RSGL_programInfo defaultProgram;
-	RSGL_mat4 defaultPerspectiveMatrix;
-
-    float verts[RSGL_MAX_VERTS * 3];
-    float texCoords[RSGL_MAX_VERTS * 2];
-    float colors[RSGL_MAX_VERTS * 4];
-    u16 elements[RSGL_MAX_VERTS * 6];
-	RSGL_renderBuffers buffers;
-} RSGL_renderer;
-
-RSGLDEF void RSGL_renderer_getRenderState(RSGL_renderer* renderer, RSGL_renderState* state);
-
-RSGLDEF size_t RSGL_renderer_size(RSGL_renderer* renderer);
-
-RSGLDEF void RSGL_renderer_initPtr(RSGL_rendererProc proc,
-                        void* loader, /* opengl prozc address ex. wglProcAddress */
-						void* ptr, /* pointer to allocate backend data */
-					    RSGL_renderer* renderer
-					);
-
-RSGLDEF RSGL_renderer* RSGL_renderer_init(RSGL_rendererProc proc, void* loader);
-RSGLDEF void RSGL_renderer_updateSize(RSGL_renderer* renderer, size_t width, size_t height);
-RSGLDEF void RSGL_renderer_freePtr(RSGL_renderer* renderer);
-
-RSGLDEF void RSGL_renderer_setSurface(RSGL_renderer* renderer, void* surface);
-
-RSGLDEF void RSGL_renderer_createBuffer(RSGL_renderer* renderer, RSGL_bufferType type, size_t size, const void* data, size_t* buffer);
-RSGLDEF void RSGL_renderer_updateBuffer(RSGL_renderer* renderer, RSGL_bufferType type, size_t buffer, void* data, size_t start, size_t len);
-RSGLDEF void RSGL_renderer_deleteBuffer(RSGL_renderer* renderer, size_t buffer);
-
-RSGLDEF void RSGL_renderer_createRenderBuffers(RSGL_renderer* renderer, size_t size, RSGL_renderBuffers* buffers);
-RSGLDEF void RSGL_renderer_deleteRenderBuffers(RSGL_renderer* renderer, RSGL_renderBuffers* buffers);
-
-RSGLDEF void RSGL_renderer_render(RSGL_renderer* renderer); /* draw current batch */
-RSGLDEF void RSGL_renderer_updateRenderBuffers(RSGL_renderer* renderer);
-RSGLDEF void RSGL_renderer_renderBuffers(RSGL_renderer* renderer);
-
-RSGLDEF void RSGL_renderer_free(RSGL_renderer* renderer);
-
-RSGLDEF void RSGL_renderer_setRotate(RSGL_renderer* renderer, RSGL_vec3D rotate); /* apply rotation to drawing */
-RSGLDEF void RSGL_renderer_setTexture(RSGL_renderer* renderer, RSGL_texture texture); /* apply texture to drawing */
-RSGLDEF void RSGL_renderer_setTextureSource(RSGL_renderer* renderer, RSGL_texture texture, RSGL_rect rect); /* apply texture to drawing (limited to the given rect) */
-RSGLDEF void RSGL_renderer_setColor(RSGL_renderer* renderer, RSGL_color color); /* apply color to drawing */
-RSGLDEF void RSGL_renderer_setProgram(RSGL_renderer* renderer, RSGL_programInfo* program); /* use shader program for drawing */
-RSGLDEF void RSGL_renderer_setFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer framebuffer);
-RSGLDEF void RSGL_renderer_setRenderBuffers(RSGL_renderer* renderer, RSGL_renderBuffers* buffers);
-RSGLDEF void RSGL_renderer_setGradient(RSGL_renderer* renderer,
-                                float* gradient, /* array of gradients */
-                                size_t len /* length of array */
-                            ); /* apply gradient to drawing, based on color list*/
-RSGLDEF void RSGL_renderer_setCenter(RSGL_renderer* renderer, RSGL_vec3D center); /* the center of the drawing (or shape), this is used for rotation */
-RSGLDEF void RSGL_renderer_setOverflow(RSGL_renderer* renderer, RSGL_bool overflow);
-/* args clear after a draw function by default, this toggles that */
-RSGLDEF void RSGL_renderer_clearArgs(RSGL_renderer* renderer); /* clears the args */
-
-RSGLDEF RSGL_mat4 RSGL_renderer_initDrawMatrix(RSGL_renderer* renderer, RSGL_vec3D center);
-
-/* renders the current batches */
-RSGLDEF void RSGL_renderer_clear(RSGL_renderer* renderer, RSGL_color color);
-RSGLDEF void RSGL_renderer_viewport(RSGL_renderer* renderer, RSGL_rect rect);
-/* create a texture based on a given bitmap, this must be freed later using RSGL_deleteTexture or opengl*/
-RSGLDEF RSGL_texture RSGL_renderer_createTexture(RSGL_renderer* renderer, const RSGL_textureBlob* blob);
-/* updates an existing texture wiht a new bitmap */
-RSGLDEF void RSGL_renderer_copyToTexture(RSGL_renderer* renderer, RSGL_texture texture, size_t x, size_t y, const RSGL_textureBlob* blob);
-/* delete a texture */
-RSGLDEF void RSGL_renderer_deleteTexture(RSGL_renderer* renderer, RSGL_texture tex);
-RSGLDEF RSGL_framebuffer RSGL_renderer_createFramebuffer(RSGL_renderer* renderer, size_t width, size_t height);
-RSGLDEF void RSGL_renderer_attachFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer fbo, RSGL_texture tex, u8 attachType, u8 mipLevel);
-RSGLDEF void RSGL_renderer_deleteFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer fbo);
-/* starts scissoring */
-RSGLDEF void RSGL_renderer_scissorStart(RSGL_renderer* renderer, RSGL_rect scissor, i32 height);
-/* stops scissoring */
-RSGLDEF void RSGL_renderer_scissorEnd(RSGL_renderer* renderer);
-/* custom shader program */
-RSGLDEF RSGL_programBlob RSGL_renderer_defaultBlob(RSGL_renderer* ctx);
-RSGLDEF RSGL_programInfo RSGL_renderer_createProgram(RSGL_renderer* renderer, RSGL_programBlob* blob);
-RSGLDEF void RSGL_renderer_deleteProgram(RSGL_renderer* renderer, const RSGL_programInfo* program);
-RSGLDEF size_t RSGL_renderer_findShaderVariable(RSGL_renderer* renderer, const RSGL_programInfo* program, const char* var, size_t len);
-RSGLDEF void RSGL_renderer_updateShaderVariable(RSGL_renderer* renderer, const RSGL_programInfo* program, size_t var, const float value[], u8 len);
-RSGLDEF void RSGL_renderer_forceBatch(RSGL_renderer* renderer);
-
-RSGLDEF void RSGL_renderer_setPerspectiveMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix);
-RSGLDEF void RSGL_renderer_setDefaultPerspectiveMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix);
-
-RSGLDEF void RSGL_renderer_setModelMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix);
-RSGLDEF void RSGL_renderer_resetModelMatrix(RSGL_renderer* renderer);
-
-RSGLDEF RSGL_programInfo RSGL_renderer_createComputeProgram(RSGL_renderer* renderer, const char *CShaderCode);
-RSGLDEF void RSGL_renderer_dispatchComputeProgram(RSGL_renderer* renderer, const RSGL_programInfo* program, u32 groups_x, u32 groups_y, u32 groups_z);
-RSGLDEF void RSGL_renderer_bindComputeTexture(RSGL_renderer* renderer, u32 texture, u8 format);
-
-/*
-*******
-RSGL_draw low level
-*******
-RSGL_drawRawVerts is a function used internally by RSGL, but you can use it yourself
-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);
-
-/*
- ******
- * Rfont_RSGL RFont integration *
- ******
- * */
-
-#ifdef RSGL_RFONT
-RSGLDEF struct RFont_renderer_proc RFont_RSGL_renderer_proc(void);
-
-RSGLDEF struct RFont_renderer* RFont_RSGL_renderer_init(struct RSGL_renderer* ptr);
-RSGLDEF void RFont_RSGL_renderer_initPtr(struct RSGL_renderer* ptr, struct RFont_renderer* renderer);
-RSGLDEF void RFont_RSGL_renderer_free(struct RFont_renderer* renderer);
-#endif
-
-#endif /* ndef RSGL_H */
-
-/*
-*******
-RSGL high level API
-*******
-*/
-
-#if !defined(RSGL_NO_HIGHLEVEL) && !defined(RSGL_HIGHLEVEL_H)
-
-
-/*
-*******
-RSGL_draw primitives
-*******
-*/
-
-/* 2D shape drawing */
-/* in the function names, F means float */
-
-RSGLDEF i32 RSGL_drawPoint(RSGL_renderer* renderer, RSGL_vec2D p);
-
-RSGLDEF i32 RSGL_drawRect(RSGL_renderer* renderer, RSGL_rect r);
-
-RSGLDEF i32 RSGL_drawRoundRect(RSGL_renderer* renderer, RSGL_rect r, RSGL_vec2D rounding);
-
-RSGLDEF i32 RSGL_drawPolygon(RSGL_renderer* renderer, RSGL_rect r, u32 sides);
-
-RSGLDEF i32 RSGL_drawArc(RSGL_renderer* renderer, RSGL_rect o, RSGL_vec2D arc);
-
-RSGLDEF i32 RSGL_drawOval(RSGL_renderer* renderer, RSGL_rect o);
-
-RSGLDEF i32 RSGL_drawLine(RSGL_renderer* renderer, RSGL_vec2D p1, RSGL_vec2D p2, u32 thickness);
-
-/* 3D objects */
-RSGLDEF i32 RSGL_drawTriangle(RSGL_renderer* renderer, RSGL_vec3D[3]);
-RSGLDEF i32 RSGL_drawPoint3D(RSGL_renderer* renderer, RSGL_vec3D p);
-RSGLDEF i32 RSGL_drawLine3D(RSGL_renderer* renderer, RSGL_vec3D p1, RSGL_vec3D p2, u32 thickness);
-RSGLDEF i32 RSGL_drawCube(RSGL_renderer* renderer, RSGL_cube cube);
-
-/* 2D outlines */
-
-/* thickness means the thickness of the line */
-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);
-
-/*
-*******
-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 */
-
-#ifdef RSGL_IMPLEMENTATION
-
-#ifndef M_PI
-    #define M_PI 3.14159265358979323846f
-#endif
-#ifndef DEG2RAD
-    #define DEG2RAD (float)(M_PI / 180.0f)
-#endif
-#ifndef RAD2DEG
-    #define RAD2DEG (float)(180.0f / M_PI)
-#endif
-
-#define RSGL_GET_MATRIX_X(x, y, z) (float)(matrix.m[0] * x + matrix.m[4] * y + matrix.m[8] * z + matrix.m[12])
-#define RSGL_GET_MATRIX_Y(x, y, z) (float)(matrix.m[1] * x + matrix.m[5] * y + matrix.m[9] * z + matrix.m[13])
-#define RSGL_GET_MATRIX_Z(x, y, z) (float)(matrix.m[2] * x + matrix.m[6] * y + matrix.m[10] * z + matrix.m[14])
-#define RSGL_GET_MATRIX_W(x, y, z) (float)(matrix.m[2] * x + matrix.m[7] * y + matrix.m[11] * z + matrix.m[15])
-
-#define RSGL_GET_MATRIX_POINT(x, y, z) \
-            RSGL_GET_MATRIX_X((x), (y), (z)) / RSGL_GET_MATRIX_W((x), (y), (z)), \
-            RSGL_GET_MATRIX_Y((x), (y), (z)) / RSGL_GET_MATRIX_W((x), (y), (z)), \
-            RSGL_GET_MATRIX_Z((x), (y), (z)) / RSGL_GET_MATRIX_W((x), (y), (z))
-
-#define RSGL_GET_MATRIX_POINTW(x, y, z) \
-            RSGL_GET_MATRIX_X(x, y, z), \
-            RSGL_GET_MATRIX_Y(x, y, z), \
-            RSGL_GET_MATRIX_Z(x, y, z), \
-            RSGL_GET_MATRIX_W(x, y, z) \
-
-void RSGL_renderer_forceBatch(RSGL_renderer* renderer) {
-    renderer->state.forceBatch = RSGL_TRUE;
-}
-
-void RSGL_renderer_setPerspectiveMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix) {
-	renderer->state.perspectiveMatrix = matrix;
-}
-
-void RSGL_renderer_setDefaultPerspectiveMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix) {
-	renderer->defaultPerspectiveMatrix = matrix;
-}
-
-void RSGL_renderer_setViewMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix) {
-    renderer->state.viewMatrix = matrix;
-}
-void RSGL_renderer_resetViewMatrix(RSGL_renderer* renderer) {
-	RSGL_renderer_setViewMatrix(renderer, RSGL_mat4_loadIdentity());
-}
-
-void RSGL_renderer_setModelMatrix(RSGL_renderer* renderer, RSGL_mat4 matrix) {
-    renderer->state.modelMatrix = matrix;
-    renderer->state.forceBatch = RSGL_TRUE;
-}
-
-
-void RSGL_renderer_resetModelMatrix(RSGL_renderer* renderer) {
-	RSGL_renderer_setModelMatrix(renderer, RSGL_mat4_loadIdentity());
-}
-
-void RSGL_renderer_getRenderState(RSGL_renderer* renderer, RSGL_renderState* state) {
-	if (state) *state = renderer->state;
-}
-
-void RSGL_renderer_setOverflow(RSGL_renderer* renderer, RSGL_bool overflow) {
-	renderer->state.overflow = overflow;
-}
-#include <stdio.h>
-i32 RSGL_drawRawVerts(RSGL_renderer* renderer, const RSGL_rawVerts* data) {
-	if ((renderer->state.buffers->batchCount + 1 >= RSGL_MAX_BATCHES || renderer->data.len + data->vert_count >= renderer->state.buffers->maxVerts) && renderer->state.overflow) {
-        RSGL_renderer_render(renderer);
-    }
-
-	RSGL_BATCH* batch = NULL;
-	RSGL_color c = renderer->state.color;
-
-    if (
-        renderer->state.buffers->batchCount == 0 ||
-        renderer->state.buffers->batches[renderer->state.buffers->batchCount - 1].tex != renderer->state.texture  ||
-        renderer->state.buffers->batches[renderer->state.buffers->batchCount - 1].lineWidth != renderer->state.lineWidth ||
-        renderer->state.buffers->batches[renderer->state.buffers->batchCount - 1].type != data->type ||
-        renderer->state.forceBatch
-    ) {
-        renderer->state.forceBatch = RSGL_FALSE;
-        renderer->state.buffers->batchCount += 1;
-
-        batch = &renderer->state.buffers->batches[renderer->state.buffers->batchCount - 1];
-		batch->start = renderer->data.len;
-        batch->len = 0;
-   		batch->elmStart = renderer->data.elements_count;
-        batch->elmCount = 0;
-		batch->type = data->type;
-        batch->tex = renderer->state.texture;
-        batch->lineWidth = renderer->state.lineWidth;
-		batch->matrix = renderer->state.modelMatrix;
-    } else {
-        batch = &renderer->state.buffers->batches[renderer->state.buffers->batchCount - 1];
-    }
-
-    if (batch == NULL) {
-        return -1;
-	}
-
-	batch->elmCount += data->elmCount;
-    batch->len += data->vert_count;
-
-    RSGL_MEMCPY(&renderer->data.verts[renderer->data.len * 3], data->verts, data->vert_count * sizeof(float) * 3);
-    RSGL_MEMCPY(&renderer->data.texCoords[renderer->data.len * 2], data->texCoords, data->vert_count * sizeof(float) * 2);
-
-	size_t i;
-	for (i = 0; i < data->elmCount; i++) {
-		size_t index = renderer->data.elements_count + i;
-		u16 elm = data->elements[i] + (u16)renderer->data.len;
-		renderer->data.elements[index] = elm;
-	}
-
-	renderer->data.elements_count += data->elmCount;
-
-    float color[4] = {c.r / 255.0f, c.g / 255.0f, c.b / 255.0f, c.a / 255.0f};
-
-    if (renderer->state.gradient_len && renderer->state.gradient && (i64)(data->vert_count - 1) > 0) {
-        RSGL_MEMCPY(&renderer->data.colors[renderer->data.len * 4], color, sizeof(float) * 4);
-        RSGL_MEMCPY(&renderer->data.colors[renderer->data.len * 4 + 4], renderer->state.gradient, (data->vert_count - 1) * sizeof(float) * 4);
-    }
-    else {
-        size_t i;
-        for (i = 0; i < data->vert_count * 4; i += 4)
-            RSGL_MEMCPY(&renderer->data.colors[(renderer->data.len * 4) + i], color, sizeof(float) * 4);
-    }
-
-    renderer->data.len += data->vert_count;
-	return renderer->state.buffers->batchCount - 1;
-}
-
-/*
-*********************
-RSGL_GRAPHICS_CONTEXT
-*********************
-*/
-
-void RSGL_renderer_setSurface(RSGL_renderer* renderer, void* surface) {
-	renderer->proc.setSurface(renderer->ctx, surface);
-}
-
-void RSGL_renderer_createBuffer(RSGL_renderer* renderer, RSGL_bufferType type, size_t size, const void* data, size_t* buffer) {
-	if (renderer->proc.createBuffer) {
-		renderer->proc.createBuffer(renderer->ctx, type, size, data, buffer);
-	}
-}
-
-void RSGL_renderer_deleteRenderBuffers(RSGL_renderer* renderer, RSGL_renderBuffers* buffers) {
-	RSGL_renderer_deleteBuffer(renderer, buffers->elements);
-	RSGL_renderer_deleteBuffer(renderer, buffers->vertex);
-	RSGL_renderer_deleteBuffer(renderer, buffers->color);
-	RSGL_renderer_deleteBuffer(renderer, buffers->texture);
-}
-
-void RSGL_renderer_createRenderBuffers(RSGL_renderer* renderer, size_t size, RSGL_renderBuffers* buffers) {
-	buffers->maxVerts = size;
-	renderer->proc.createBuffer(renderer->ctx, RSGL_arrayBuffer, size * 3 * sizeof(float), NULL, &buffers->vertex);
-	renderer->proc.createBuffer(renderer->ctx, RSGL_arrayBuffer, size * 4 * sizeof(float), NULL, &buffers->color);
-	renderer->proc.createBuffer(renderer->ctx, RSGL_arrayBuffer, size * 2 * sizeof(float), NULL, &buffers->texture);
-	renderer->proc.createBuffer(renderer->ctx, RSGL_elementArrayBuffer, size * 6 * sizeof(u16), NULL, &buffers->elements);
-}
-
-void RSGL_renderer_updateBuffer(RSGL_renderer* renderer, RSGL_bufferType type, size_t buffer, void* data, size_t start, size_t len) {
-	if (renderer->proc.updateBuffer)
-		renderer->proc.updateBuffer(renderer->ctx, type, buffer, data, start, len);
-}
-
-void RSGL_renderer_deleteBuffer(RSGL_renderer* renderer, size_t buffer) {
-	if (renderer->proc.deleteBuffer)
-		renderer->proc.deleteBuffer(renderer->ctx, buffer);
-}
-
-void RSGL_renderer_updateRenderBuffers(RSGL_renderer* renderer) {
-	RSGL_renderer_updateBuffer(renderer, RSGL_arrayBuffer, renderer->state.buffers->vertex, renderer->data.verts, 0, renderer->data.len * 3 * sizeof(float));
-	RSGL_renderer_updateBuffer(renderer, RSGL_arrayBuffer, renderer->state.buffers->color, renderer->data.colors, 0, renderer->data.len * 4 * sizeof(float));
-	RSGL_renderer_updateBuffer(renderer, RSGL_arrayBuffer, renderer->state.buffers->texture, renderer->data.texCoords, 0, renderer->data.len * 2 * sizeof(float));
-	RSGL_renderer_updateBuffer(renderer, RSGL_elementArrayBuffer, renderer->state.buffers->elements, renderer->data.elements, 0, renderer->data.elements_count * sizeof(u16));
-}
-
-void RSGL_renderer_renderBuffers(RSGL_renderer* renderer) {
-	RSGL_mat4 matrix = RSGL_mat4_multiply(renderer->defaultPerspectiveMatrix.m, renderer->state.perspectiveMatrix.m);
-	matrix = RSGL_mat4_multiply(matrix.m, renderer->state.viewMatrix.m);
-
-
-	RSGL_renderPass pass;
-	pass.program = renderer->state.program;
-	pass.matrix = matrix.m;
-	pass.buffers = renderer->state.buffers;
-	pass.framebuffer = renderer->state.framebuffer;
-
-	if (renderer->proc.render)
-		renderer->proc.render(renderer->ctx, &pass);
-
-	renderer->data.len = 0;
-	renderer->data.elements_count = 0;
-}
-
-void RSGL_renderer_render(RSGL_renderer* renderer) {
-	if (renderer->data.len && renderer->state.buffers->batchCount) {
-		RSGL_renderer_updateRenderBuffers(renderer);
-	}
-
-	RSGL_renderer_renderBuffers(renderer);
-
-	renderer->state.buffers->batchCount = 0;
-}
-
-size_t RSGL_renderer_size(RSGL_renderer* renderer) {
-	if (renderer->proc.size) return renderer->proc.size();
-	return 0;
-}
-
-void RSGL_renderer_initPtr(RSGL_rendererProc proc, void* loader, void* data, RSGL_renderer* renderer) {
-	renderer->ctx = data;
-	renderer->proc = proc;
-    RSGL_renderer_clearArgs(renderer);
-    renderer->state.color = RSGL_RGBA(0, 0, 0, 255);
-
-    renderer->state.modelMatrix = RSGL_mat4_loadIdentity();
-	renderer->data.verts = renderer->verts;
-	renderer->data.texCoords = renderer->texCoords;
-	renderer->data.elements = renderer->elements;
-	renderer->data.colors = renderer->colors;
-	renderer->data.len = 0;
-	renderer->data.elements_count = 0;
-
-	if (renderer->proc.initPtr)
-		renderer->proc.initPtr(renderer->ctx, loader);
-
-	RSGL_renderer_setFramebuffer(renderer, 0);
-
-	RSGL_programBlob pBlob = RSGL_renderer_defaultBlob(renderer);
-	renderer->defaultProgram = RSGL_renderer_createProgram(renderer, &pBlob);
-	RSGL_renderer_setProgram(renderer, &renderer->defaultProgram);
-
-    u8 white[4] = {255, 255, 255, 255};
-	RSGL_textureBlob blob;
-	blob.data = white;
-	blob.width = 1;
-	blob.height = 1;
-	blob.dataType = RSGL_textureDataInt;
-	blob.dataFormat = RSGL_formatRGBA;
-	blob.textureFormat = RSGL_formatRGBA;
-    renderer->defaultTexture = RSGL_renderer_createTexture(renderer, &blob);
-
-	RSGL_renderer_setTexture(renderer, renderer->defaultTexture);
-
-	RSGL_renderer_createRenderBuffers(renderer, RSGL_MAX_VERTS, &renderer->buffers);
-    renderer->buffers.batchCount = 0;
-	renderer->state.buffers = &renderer->buffers;
-
-	RSGL_renderer_setModelMatrix(renderer, RSGL_mat4_loadIdentity());
-	RSGL_renderer_resetViewMatrix(renderer);
-	RSGL_renderer_setPerspectiveMatrix(renderer, RSGL_mat4_loadIdentity());
-}
-
-
-RSGL_renderer* RSGL_renderer_init(RSGL_rendererProc proc, void* loader) {
-	RSGL_renderer* renderer = (RSGL_renderer*)RSGL_MALLOC(sizeof(RSGL_renderer));
-	void* data = RSGL_MALLOC(proc.size());
-	RSGL_renderer_initPtr(proc, loader, data, renderer);
-	return renderer;
-}
-
-void RSGL_renderer_freePtr(RSGL_renderer* renderer) {
-	RSGL_renderer_deleteRenderBuffers(renderer, &renderer->buffers);
-
-	if (renderer->proc.freePtr)
-		renderer->proc.freePtr(renderer->ctx);
-
-	renderer->state.buffers->batchCount = 0;
-	renderer->data.len = 0;
-	renderer->data.elements_count = 0;
-}
-
-void RSGL_renderer_free(RSGL_renderer* renderer) {
-	RSGL_renderer_freePtr(renderer);
-	if (renderer->ctx)
-		RSGL_FREE(renderer->ctx);
-	RSGL_FREE(renderer);
-}
-
-void RSGL_renderer_clear(RSGL_renderer* renderer, RSGL_color color) {
-	if (renderer->proc.clear)
-		renderer->proc.clear(renderer->ctx, renderer->state.framebuffer, ((float)color.r) / 255.0f, ((float)color.g) / 255.0f, ((float)color.b) / 255.0f, ((float)color.a) / 255.0f);
-}
-void RSGL_renderer_viewport(RSGL_renderer* renderer, RSGL_rect rect) { renderer->proc.viewport(renderer->ctx, rect.x, rect.y, rect.w, rect.h); }
-RSGL_texture RSGL_renderer_createTexture(RSGL_renderer* renderer, const RSGL_textureBlob* blob) {
-    RSGL_texture tex = 0;
-	if (renderer->proc.createTexture) tex = renderer->proc.createTexture(renderer->ctx, blob);
-	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);
-}
-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) {
-	renderer->proc.scissorStart(renderer->ctx, scissor.x, scissor.y, scissor.w, scissor.h, height);
-}
-
-RSGL_framebuffer RSGL_renderer_createFramebuffer(RSGL_renderer* renderer, size_t width, size_t height) {
-	RSGL_framebuffer framebuffer = 0;
-	if (renderer->proc.createFramebuffer) {
-		framebuffer = renderer->proc.createFramebuffer(renderer->ctx, width, height);
-	}
-	return framebuffer;
-}
-
-void RSGL_renderer_attachFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer fbo, RSGL_texture tex, u8 attachType, u8 mipLevel) {
-	if (renderer->proc.attachFramebuffer)
-		renderer->proc.attachFramebuffer(renderer->ctx, fbo, tex, attachType, mipLevel);
-}
-
-void RSGL_renderer_deleteFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer fbo) {
-	if (renderer->proc.deleteFramebuffer)
-		renderer->proc.deleteFramebuffer(renderer->ctx, fbo);
-}
-
-void RSGL_renderer_scissorEnd(RSGL_renderer* renderer) {
-	renderer->proc.scissorEnd(renderer->ctx);
-}
-RSGL_programBlob RSGL_renderer_defaultBlob(RSGL_renderer* renderer) {
-	RSGL_programBlob blob;
-	RSGL_MEMSET(&blob, 0, sizeof(blob));
-
-	if (renderer->proc.defaultBlob) {
-		blob = renderer->proc.defaultBlob(renderer);
-	}
-
-	return blob;
-}
-RSGL_programInfo RSGL_renderer_createProgram(RSGL_renderer* renderer, RSGL_programBlob* blob) {
-	RSGL_programInfo info;
-	RSGL_MEMSET(&info, 0, sizeof(info));
-
-	if (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;
-			blob->vertexLen = pBlob.vertexLen;
-		}
-
-		if (blob->fragment == NULL) {
-			blob->fragment = pBlob.fragment;
-			blob->fragmentLen = pBlob.fragmentLen;
-		}
-	}
-
-	if (renderer->proc.createProgram) {
-		info = renderer->proc.createProgram(renderer->ctx, blob);
-	}
-
-	return info;
-}
-void RSGL_renderer_deleteProgram(RSGL_renderer* renderer, const RSGL_programInfo* program) { return 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);
-}
-
-void RSGL_renderer_updateShaderVariable(RSGL_renderer* renderer, const RSGL_programInfo* program, size_t var, const float value[], u8 len) {
-	if (renderer->proc.updateShaderVariable) {
-		renderer->proc.updateShaderVariable(renderer->ctx, program, var, value, len);
-	}
-}
-
-RSGL_programInfo RSGL_renderer_createComputeProgram(RSGL_renderer* renderer, const char* CShaderCode) {
-	return renderer->proc.createComputeProgram(renderer->ctx, CShaderCode);
-}
-
-void RSGL_renderer_dispatchComputeProgram(RSGL_renderer* renderer, const RSGL_programInfo* program, u32 groups_x, u32 groups_y, u32 groups_z) {
-	renderer->proc.dispatchComputeProgram(renderer->ctx, program, groups_x, groups_y, groups_z);
-}
-
-void RSGL_renderer_bindComputeTexture(RSGL_renderer* renderer, u32 texture, u8 format) {
-	renderer->proc.bindComputeTexture(renderer->ctx, texture, format);
-}
-
-void RSGL_renderer_updateSize(RSGL_renderer* renderer, size_t width, size_t height) {
-	RSGL_projection projection;
-	projection.p2D.type = RSGL_projectionOrtho2D;
-	projection.p2D.width = width;
-	projection.p2D.height = height;
-
-	RSGL_mat4 matrix = RSGL_projection_getMatrix(&projection);
-	RSGL_renderer_setDefaultPerspectiveMatrix(renderer, matrix);
-}
-
-void RSGL_renderer_setRotate(RSGL_renderer* renderer, RSGL_vec3D rotate){
-    renderer->state.rotate = RSGL_VEC3D(rotate.x * DEG2RAD, rotate.y * DEG2RAD, rotate.z * DEG2RAD);
-}
-void RSGL_renderer_setTexture(RSGL_renderer* renderer, RSGL_texture texture) {
-	if (texture == 0)
-		renderer->state.texture = renderer->defaultTexture;
-	else
-		renderer->state.texture = texture;
-
-	renderer->state.source = RSGL_RECT(0, 0, 1, 1);
-}
-
-void RSGL_renderer_setTextureSource(RSGL_renderer* renderer, RSGL_texture texture, RSGL_rect rect) {
-	RSGL_renderer_setTexture(renderer, texture);
-	renderer->state.source = rect;
-}
-
-void RSGL_renderer_setColor(RSGL_renderer* renderer, RSGL_color color) {
-	renderer->state.color = color;
-}
-
-void RSGL_renderer_setRenderBuffers(RSGL_renderer* renderer, RSGL_renderBuffers* buffers) {
-	if (buffers == NULL)
-		renderer->state.buffers = &renderer->buffers;
-	else
-		renderer->state.buffers = buffers;
-}
-
-void RSGL_renderer_setProgram(RSGL_renderer* renderer, RSGL_programInfo* program) {
-	if (program == NULL)
-		renderer->state.program = &renderer->defaultProgram;
-	else
-		renderer->state.program = program;
-}
-
-void RSGL_renderer_setFramebuffer(RSGL_renderer* renderer, RSGL_framebuffer framebuffer) {
-	renderer->state.framebuffer = framebuffer;
-}
-
-void RSGL_renderer_setGradient(RSGL_renderer* renderer, float gradient[], size_t len) {
-    renderer->state.gradient_len = len;
-    renderer->state.gradient = gradient;
-}
-void RSGL_renderer_setCenter(RSGL_renderer* renderer, RSGL_vec3D center) {
-    renderer->state.center = center;
-}
-
-RSGL_mat4 RSGL_renderer_initDrawMatrix(RSGL_renderer* renderer, RSGL_vec3D center) {
-    RSGL_mat4 matrix = RSGL_mat4_loadIdentity();
-
-    if (renderer->state.rotate.x || renderer->state.rotate.y || renderer->state.rotate.z) {
-        if (renderer->state.center.x != -1 && renderer->state.center.y != -1 &&  renderer->state.center.z != -1)
-            center = renderer->state.center;
-
-		matrix = RSGL_mat4_translate(matrix.m, center.x, center.y, center.z);
-        matrix = RSGL_mat4_rotate(matrix.m, renderer->state.rotate.z,  0, 0, 1);
-        matrix = RSGL_mat4_rotate(matrix.m, renderer->state.rotate.y, 0, 1, 0);
-        matrix = RSGL_mat4_rotate(matrix.m, renderer->state.rotate.x, 1, 0, 0);
-        matrix = RSGL_mat4_translate(matrix.m, -center.x, -center.y, -center.z);
-    }
-
-    return matrix;
-}
-
-void RSGL_renderer_clearArgs(RSGL_renderer* renderer) {
-	RSGL_MEMSET(&renderer->state, 0, sizeof(renderer->state));
-	renderer->state.center =  RSGL_VEC3D(-1, -1, -1);
-	renderer->state.overflow = RSGL_TRUE;
-}
-
-/*
-****
-RFont_RSGL integration
-****
-*/
-
-#ifdef RSGL_RFONT
-
-#ifndef RFONT_H
-
-#ifdef RSGL_INT_DEFINED
-	#ifndef RFONT_INT_DEFINED
-		#define RFONT_INT_DEFINED
-	#endif
-#endif
-
-#include "RFont.h"
-#endif
-
-struct RFont_renderer* RFont_RSGL_renderer_init(struct RSGL_renderer* ptr) {
-	RFont_renderer* renderer = (RFont_renderer*)RFONT_MALLOC(sizeof(RFont_renderer));
-	RFont_renderer_initPtr(RFont_RSGL_renderer_proc(), ptr, renderer);
-	return renderer;
-}
-void RFont_RSGL_renderer_initPtr(struct RSGL_renderer* ptr, struct RFont_renderer* renderer) { RFont_renderer_initPtr(RFont_RSGL_renderer_proc(), ptr, renderer); }
-
-void RFont_RSGL_renderer_free(struct RFont_renderer* renderer) {
-	RFONT_FREE(renderer);
-}
-
-void RFont_RSGL_render_text(RSGL_renderer* renderer, const RFont_render_data* src) {
-    RSGL_texture save = renderer->state.texture;
-	RSGL_renderer_setTexture(renderer, src->atlas);
-
-	RSGL_rawVerts data;
-	data.type = RSGL_TRIANGLES;
-	data.verts = src->verts;
-	data.texCoords = src->tcoords;
-	data.elements = src->elements;
-	data.elmCount = src->nelements;
-	data.vert_count = src->nverts;
-	i32 batch = RSGL_drawRawVerts(renderer, &data);
-	RSGL_UNUSED(batch);
-
-    RSGL_renderer_setTexture(renderer, save);
-}
-
-RFont_texture RFont_RSGL_createAtlas(RSGL_renderer* renderer, u32 atlasWidth, u32 atlasHeight) {
-	RSGL_textureBlob blob;
-	blob.data = NULL;
-	blob.width = atlasWidth;
-	blob.height = atlasWidth;
-	blob.dataType = RSGL_textureDataInt;
-	blob.dataFormat = RSGL_formatRGBA; //RSGL_formatRGBA;
-	blob.textureFormat = RSGL_formatRGBA;//RSGL_formatRGBA;
-	RFont_texture id = RSGL_renderer_createTexture(renderer, &blob);
-	return id;
-}
-
-void RFont_RSGL_deleteAtlas(RSGL_renderer* renderer, RFont_texture atlas) {
-	RSGL_renderer_deleteTexture(renderer, atlas);
-}
-
-void RFont_RSGL_bitmapToAtlas(RSGL_renderer* renderer, RFont_texture atlas, u32 atlasWidth, u32 atlasHeight, u32 maxHeight, u8* bitmap, float w, float h, float* x, float* y) {
-	RSGL_UNUSED(atlasHeight);
-	if (((*x) + w) >= atlasWidth) {
-		*x = 0;
-		*y += (float)maxHeight;
-	}
-
-	RSGL_textureBlob blob;
-	blob.width = w;
-	blob.height = h;
-	blob.dataType = RSGL_textureDataInt;
-	blob.dataFormat = RSGL_formatRGBA;
-	blob.textureFormat = blob.dataFormat;
-
-	u8* newBitmap = (u8*)RSGL_MALLOC(w * h * 4);
-
-	for (size_t indexY = 0; indexY < (size_t)h; indexY++) {
-		for (size_t indexX = 0; indexX < (size_t)w; indexX++) {
-			size_t index = ((indexY * (size_t)w * 4) + indexX * 4);
-			size_t oIndex = ((indexY * (size_t)w) + indexX);
-
-			u8 value = bitmap[oIndex];
-
-			newBitmap[index + 0] = value;
-			newBitmap[index + 1] = value;
-			newBitmap[index + 2] = value;
-			newBitmap[index + 3] = value;
-		}
-	}
-
-	blob.data = newBitmap;
-
-	RSGL_renderer_copyToTexture(renderer, atlas, (size_t)(*x), (size_t)(*y), &blob);
-
-	RSGL_FREE(newBitmap);
-
-	*x += w;
-}
-
-void RFont_RSGL_setFrameBuffer(RSGL_renderer* renderer, u32 width, u32 height) {
-	RSGL_renderer_updateSize(renderer, width, height);
-}
-
-void RFont_RSGL_setColor(RSGL_renderer* renderer, float r, float g, float b, float a) {
-	RSGL_renderer_setColor(renderer, RSGL_RGBA(r * 255.0f, g * 255.0f, b * 255.0f, a * 255.0f));
-}
-
-RFont_renderer_proc RFont_RSGL_renderer_proc(void) {
-	RFont_renderer_proc proc;
-	RSGL_MEMSET(&proc, 0, sizeof(proc));
-	proc.create_atlas = (RFont_texture (*)(void* ctx, u32 atlasWidth, u32 atlasHeight))RFont_RSGL_createAtlas;
-	proc.free_atlas = (void (*)(void*, RSGL_texture))RFont_RSGL_deleteAtlas;
-	proc.bitmap_to_atlas = (void(*)(void*, RFont_texture, u32, u32, u32, u8*, float, float, float*, float*))RFont_RSGL_bitmapToAtlas;
-	proc.render = (void (*)(void*, const RFont_render_data* data))RFont_RSGL_render_text;
-	proc.set_framebuffer = (void (*)(void*, u32, u32))RFont_RSGL_setFrameBuffer;
-	proc.set_color = (void (*)(void*, float, float, float, float))RFont_RSGL_setColor;
-	return proc;
-}
-
-#endif
-
-#if !defined(RSGL_NO_HIGHLEVEL)
-
-/*
-****
-RSGL_draw
-****
-*/
-
-i32 RSGL_drawPoint(RSGL_renderer* renderer, RSGL_vec2D p) {
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, RSGL_VEC3D(p.x, p.y, 0.0f));
-
-    float points[] = {RSGL_GET_MATRIX_POINT((float)p.x, (float)p.y, 0.0f)};
-    float texPoints[] = { renderer->state.source.x, renderer->state.source.y };
-	u16 elements[] = { 0 };
-
-	RSGL_rawVerts data;
-	data.type = RSGL_POINTS;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 1;
-	data.vert_count = 1;
-
-    return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawRect(RSGL_renderer* renderer, RSGL_rect r) {
-    float texPoints[] = {
-                                renderer->state.source.x, renderer->state.source.y,
-                                renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-                                renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-                                renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-                            };
-
-    RSGL_vec3D center = (RSGL_vec3D){r.x + (r.w / 2.0f), r.y + (r.h / 2.0f), 0.0f};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {
-                                RSGL_GET_MATRIX_POINT(r.x, r.y, 0.0f),
-                                RSGL_GET_MATRIX_POINT(r.x, r.y + r.h, 0.0f),
-                                RSGL_GET_MATRIX_POINT(r.x + r.w, r.y, 0.0f),
-                                RSGL_GET_MATRIX_POINT(r.x + r.w, r.y + r.h, 0.0f),
-                            };
-
-	u16 elements[] = {
-		0, 1, 2,
-		3, 2, 1
-	};
-
-	RSGL_rawVerts data;
-	data.type = RSGL_TRIANGLES;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 6;
-	data.vert_count = 4;
-
-	return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawRoundRect(RSGL_renderer* renderer, RSGL_rect r, RSGL_vec2D rounding) {
-    RSGL_drawRect(renderer, RSGL_RECT(r.x + (rounding.x / 2), r.y, r.w - rounding.x, r.h));
-    RSGL_drawRect(renderer, RSGL_RECT(r.x, r.y + (rounding.y / 2), r.w,  r.h - rounding.y));
-
-    RSGL_drawArc(renderer, RSGL_RECT(r.x, r.y, rounding.x, rounding.y), (RSGL_vec2D){180, 270});
-    RSGL_drawArc(renderer, RSGL_RECT(r.x + (r.w - rounding.x), r.y, rounding.x, rounding.y), (RSGL_vec2D){90, 180});
-    RSGL_drawArc(renderer, RSGL_RECT(r.x + (r.w - rounding.x), r.y  + (r.h - rounding.y), rounding.x, rounding.y), (RSGL_vec2D){0, 90});
-	return RSGL_drawArc(renderer, RSGL_RECT(r.x, r.y  + (r.h - rounding.y),  rounding.x, rounding.y), (RSGL_vec2D){270, 360});
-}
-
-i32 RSGL_drawPolygonOutlineEx(RSGL_renderer* renderer, RSGL_rect o, u32 sides, RSGL_vec2D arc);
-
-i32 RSGL_drawPolygonEx(RSGL_renderer* renderer, RSGL_rect o, u32 sides, RSGL_vec2D arc) {
-	static float verts[360 * 3];
-    static float texcoords[360 * 2];
-	static u16 elements[360 * 6];
-
-    RSGL_vec3D center =  (RSGL_vec3D){o.x + (o.w / 2.0f), o.y + (o.h / 2.0f), 0};
-
-	o = (RSGL_rect){o.x, o.y, o.w / 2, o.h / 2};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float displacement = 360.0f / (float)sides;
-    float angle = displacement * arc.x;
-
-    size_t vIndex = 0;
-    size_t tIndex = 0;
-	size_t iIndex = 0;
-
-	float texCenterX =  (0.5 * (renderer->state.source.w));
-	float texCenterY = (0.5 * (renderer->state.source.h));
-
-	RSGL_UNUSED(texCenterX);
-	RSGL_UNUSED(texCenterY);
-
-	{
-        RSGL_vec2D p = {center.x, center.y};
-
-        texcoords[tIndex] = (renderer->state.source.x) + texCenterX;
-        texcoords[tIndex + 1] = (renderer->state.source.y) + texCenterY;
-        float temp[3] = { RSGL_GET_MATRIX_POINT(p.x, p.y, 0.0) };
-        memcpy(verts + vIndex, temp, 3 * sizeof(float));
-
-		angle += displacement;
-        tIndex += 2;
-        vIndex += 3;
-	}
-
-    u32 i;
-    for (i = 0; i < sides + 1; i++) {
-		RSGL_vec2D p = {RSGL_COS(angle * DEG2RAD), RSGL_SIN(angle * DEG2RAD)};
-
-        texcoords[tIndex] = ((p.x + 1.0f) * texCenterX) + (renderer->state.source.x) ;
-        texcoords[tIndex + 1] = ((p.y + 1.0f) * texCenterY) + (renderer->state.source.y);
-
-		float temp[3] = { RSGL_GET_MATRIX_POINT(o.x + o.w + (p.x * o.w), o.y + o.h + (p.y * o.h), 0.0) };
-        memcpy(&verts[vIndex], temp, 3 * sizeof(float));
-
-		elements[iIndex + 0] = i;
-
-		if (i < sides)
-			elements[iIndex + 1] = i + 1;
-		else
-			elements[iIndex + 1] = 1;
-
-		elements[iIndex + 2] = 0;
-
-		angle += displacement;
-        tIndex += 2;
-        vIndex += 3;
-		iIndex += 3;
-    }
-
-	RSGL_rawVerts data;
-	data.type = RSGL_TRIANGLES;
-	data.verts = verts;
-	data.texCoords = texcoords;
-	data.elements = elements;
-	data.elmCount = iIndex;
-	data.vert_count = (vIndex / 3);
-
-    i32 out = RSGL_drawRawVerts(renderer, &data);
-	return out;
-}
-
-i32 RSGL_drawPolygon(RSGL_renderer* renderer, RSGL_rect o, u32 sides) { return RSGL_drawPolygonEx(renderer, o, sides, (RSGL_vec2D){0, (float)sides}); }
-
-
-i32 RSGL_drawArc(RSGL_renderer* renderer, RSGL_rect o, RSGL_vec2D arc) {
-    u32 verts = (u32)((float)((2 * M_PI * ((o.w + o.h) / 2.0f)) / 10) + 0.5);
-    verts %= 360;
-
-    return RSGL_drawPolygonEx(renderer, o, verts, arc);
-}
-
-i32 RSGL_drawOval(RSGL_renderer* renderer, RSGL_rect o) {
-    float verts = ((2 * M_PI * ((o.w + o.h) / 2.0f)) / 10);
-    verts = (verts > 360 ? 360 : verts);
-
-    return RSGL_drawPolygonEx(renderer, o, verts, (RSGL_vec2D){0, verts});
-}
-
-/*
-    3D
-*/
-
-i32 RSGL_drawPoint3D(RSGL_renderer* renderer, RSGL_vec3D p) {
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, p);
-
-    float points[] = {RSGL_GET_MATRIX_POINT((float)p.x, (float)p.y, (float)p.z)};
-    float texPoints[] = { renderer->state.source.x, renderer->state.source.y };
-	u16 elements[] = { 0, };
-
-	RSGL_rawVerts data;
-	data.type = RSGL_POINTS;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 1;
-	data.vert_count = 1;
-
-    return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawLine3D(RSGL_renderer* renderer, RSGL_vec3D p1, RSGL_vec3D p2, u32 thickness) {
-    renderer->state.lineWidth = thickness;
-
-    RSGL_vec3D center = {(p1.x + p2.x) / 2.0f, (p1.y + p2.y) / 2.0f, (p1.z + p2.z) / 2.0f};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {RSGL_GET_MATRIX_POINT(p1.x, p1.y, p1.z), RSGL_GET_MATRIX_POINT(p2.x, p2.y, p2.z)};
-    float texPoints[] = { renderer->state.source.x, renderer->state.source.y,  renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h};
-	u16 elements[] = { 0, 1 };
-
-	RSGL_rawVerts data;
-	data.type = RSGL_LINES;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 4;
-	data.vert_count = 2;
-
-	return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawTriangle(RSGL_renderer* renderer, RSGL_vec3D t[3]) {
-	RSGL_vec3D center = {t[2].x, (t[2].y + t[0].y) / 2.0f, t[1].z};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {
-            RSGL_GET_MATRIX_POINT(t[0].x, t[0].y, t[0].z),
-            RSGL_GET_MATRIX_POINT(t[1].x, t[1].y, t[1].z),
-            RSGL_GET_MATRIX_POINT(t[2].x, t[2].y, t[2].z)
-    };
-
-	float texPoints[] = {
-                renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-                renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-				((float)(t[2].x - t[0].x)/t[1].x < 1) ? (renderer->state.source.x + (float)(t[2].x - t[0].x) / t[1].x) : renderer->state.source.x, renderer->state.source.y,
-    };
-
-	u16 elements[] = {
-		0, 1, 2,
-	};
-
-	RSGL_rawVerts data;
-	data.type = RSGL_TRIANGLES;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 3;
-	data.vert_count = 3;
-
-    return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawCube(RSGL_renderer* renderer, RSGL_cube cube) {
-	float texPoints[] = {
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-
-		renderer->state.source.x, renderer->state.source.y,
-		renderer->state.source.x, renderer->state.source.y + renderer->state.source.h,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y,
-		renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h,
-    };
-
-    RSGL_vec3D center = {
-        cube.x + (cube.w / 2.0f),
-        cube.y + (cube.h / 2.0f),
-        cube.z
-    };
-
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {
-        // Front face
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y,         cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y + cube.h, cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y,         cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z),
-        // Back face
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y,         cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y,         cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y + cube.h, cube.z + cube.l),
-        // Left face
-        RSGL_GET_MATRIX_POINT(cube.x, cube.y,         cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x, cube.y + cube.h, cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x, cube.y,         cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x, cube.y + cube.h, cube.z),
-        // Right face
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y,         cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y,         cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z + cube.l),
-        // Top face
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y + cube.h, cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y + cube.h, cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y + cube.h, cube.z + cube.l),
-        // Bottom face
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y, cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x,         cube.y, cube.z),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y, cube.z + cube.l),
-        RSGL_GET_MATRIX_POINT(cube.x + cube.w, cube.y, cube.z),
-    };
-
-	u16 elements[] = {
-		0, 1, 2,
-		3, 2, 1,
-
-		4, 5, 6,
-		7, 6, 5,
-
-		8, 9, 10,
-		11, 10, 9,
-
-		12, 13, 14,
-		15, 14, 13,
-
-		16, 17, 18,
-		19, 18, 17,
-
-		20, 21, 22,
-		23, 21, 22,
-	};
-
-	RSGL_rawVerts data;
-	data.type = RSGL_TRIANGLES;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = sizeof(elements) / sizeof(u16);
-	data.vert_count = sizeof(points) / sizeof(float) / 3;
-
-	return RSGL_drawRawVerts(renderer, &data);
-}
-
-/*
-outlines
-*/
-
-i32 RSGL_drawLine(RSGL_renderer* renderer, RSGL_vec2D p1, RSGL_vec2D p2, u32 thickness) {
-    renderer->state.lineWidth = thickness;
-
-    RSGL_vec3D center = {(p1.x + p2.x) / 2.0f, (p1.y + p2.y) / 2.0f, 0.0f};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {RSGL_GET_MATRIX_POINT(p1.x, p1.y, 0.0f), RSGL_GET_MATRIX_POINT(p2.x, p2.y, 0.0f)};
-    float texPoints[] = { renderer->state.source.x, renderer->state.source.y,  renderer->state.source.x + renderer->state.source.w, renderer->state.source.y + renderer->state.source.h};
-
-	u16 elements[] = { 0, 1 };
-
-	RSGL_rawVerts data;
-	data.type = RSGL_LINES;
-	data.verts = points;
-	data.texCoords = texPoints;
-	data.elements = elements;
-	data.elmCount = 4;
-	data.vert_count = 2;
-
-	return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawTriangleOutline(RSGL_renderer* renderer, RSGL_vec3D t[3], u32 thickness) {
-    renderer->state.lineWidth = thickness;
-    RSGL_vec3D center = {t[2].x, (t[2].y + t[0].y) / 2.0f, 0};
-    RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    float points[] = {RSGL_GET_MATRIX_POINT(t[2].x, t[2].y, t[2].z),
-                        RSGL_GET_MATRIX_POINT(t[0].x, t[0].y,t[0].z),
-                        RSGL_GET_MATRIX_POINT(t[0].x, t[0].y, t[0].z),
-                    RSGL_GET_MATRIX_POINT(t[1].x, t[1].y,t[1].z),
-                    RSGL_GET_MATRIX_POINT(t[1].x, t[1].y, t[1].z),
-                    RSGL_GET_MATRIX_POINT(t[2].x, t[2].y, t[2].z)};
-
-    float texCoords[18];
-
-	u16 elements[] = {
-		0, 1, 2,
-		3, 2, 1
-	};
-
-	RSGL_rawVerts data;
-	data.type = RSGL_LINES;
-	data.verts = points;
-	data.texCoords = texCoords;
-	data.elements = elements;
-	data.elmCount = 6;
-	data.vert_count = 6;
-
-    return RSGL_drawRawVerts(renderer, &data);
-}
-i32 RSGL_drawRectOutline(RSGL_renderer* renderer, RSGL_rect r, u32 thickness) {
-    RSGL_renderer_setCenter(renderer, (RSGL_vec3D){r.x + (r.w / 2.0f), r.y + (r.h / 2.0f), 0.0f});
-    RSGL_drawLine(renderer, (RSGL_vec2D){r.x, r.y}, (RSGL_vec2D){r.x + r.w, r.y}, thickness);
-
-    RSGL_renderer_setCenter(renderer, (RSGL_vec3D){r.x + (r.w / 2.0f), r.y + (r.h / 2.0f), 0.0f});
-    RSGL_drawLine(renderer, (RSGL_vec2D){r.x, r.y}, (RSGL_vec2D){r.x, r.y + r.h}, thickness);
-
-    RSGL_renderer_setCenter(renderer, (RSGL_vec3D){r.x + (r.w / 2.0f), r.y + (r.h / 2.0f), 0.0f});
-    RSGL_drawLine(renderer, (RSGL_vec2D){r.x, r.y + r.h}, (RSGL_vec2D){r.x + r.w, r.y + r.h}, thickness);
-
-    RSGL_renderer_setCenter(renderer, (RSGL_vec3D){r.x + (r.w / 2.0f), r.y + (r.h / 2.0f), 0.0f});
-    return RSGL_drawLine(renderer, (RSGL_vec2D){r.x + r.w, r.y}, (RSGL_vec2D){r.x + r.w, r.y + r.h}, thickness);
-}
-i32 RSGL_drawRoundRectOutline(RSGL_renderer* renderer, RSGL_rect r, RSGL_vec2D rounding, u32 thickness) {
-    RSGL_drawRect(renderer, RSGL_RECT(r.x + (rounding.x/2), r.y, r.w - rounding.x, (int)(thickness + !thickness)));
-    RSGL_drawRect(renderer, RSGL_RECT(r.x + (rounding.x/2), r.y + r.h, r.w - rounding.x, (int)(thickness + !thickness)));
-    RSGL_drawRect(renderer, RSGL_RECT(r.x, r.y + (rounding.y/2), (int)(thickness + !thickness),  r.h - rounding.y));
-    RSGL_drawRect(renderer, RSGL_RECT(r.x + r.w, r.y + (rounding.y/2), (int)(thickness + !thickness),  r.h - rounding.y));
-
-    RSGL_drawArcOutline(renderer, RSGL_RECT(r.x, r.y, rounding.x, rounding.y), (RSGL_vec2D){180, 270}, thickness);
-    RSGL_drawArcOutline(renderer, RSGL_RECT(r.x + (r.w - rounding.x), r.y, rounding.x, rounding.y), (RSGL_vec2D){90, 180}, thickness);
-    RSGL_drawArcOutline(renderer, RSGL_RECT(r.x + (r.w - rounding.x), r.y  + (r.h - rounding.y) - 1, rounding.x, rounding.y + 2), (RSGL_vec2D){0, 90}, thickness);
-    return RSGL_drawArcOutline(renderer, RSGL_RECT(r.x + 1, r.y  + (r.h - rounding.y) - 1,  rounding.x, rounding.y + 2), (RSGL_vec2D){270, 360}, thickness);
-}
-
-i32 RSGL_drawPolygonOutlineEx(RSGL_renderer* renderer, RSGL_rect o, u32 sides, RSGL_vec2D arc) {
-    static float verts[360 * 2 * 3];
-    static float texCoords[360 * 2 * 2];
-
-    RSGL_vec3D center = (RSGL_vec3D) {o.x + (o.w / 2.0f), o.y + (o.h / 2.0f), 0.0f};
-        RSGL_mat4 matrix = RSGL_renderer_initDrawMatrix(renderer, center);
-
-    o = (RSGL_rect){o.x + (o.w / 2), o.y + (o.h / 2), o.w / 2, o.h / 2};
-
-    float displacement = 360.0f / (float)sides;
-    float centralAngle = displacement * arc.x;
-
-    i32 i;
-    u32 j;
-    size_t index = 0;
-
-    for (i = arc.x; i < arc.y; i++) {
-        for (j = 0; j < 2; j++) {
-            float temp[3] = {
-                RSGL_GET_MATRIX_POINT(
-                    o.x + (RSGL_SIN(DEG2RAD * centralAngle) * o.w),
-                    o.y + (RSGL_COS(DEG2RAD * centralAngle) * o.h),
-                    (0.0)
-                )
-            };
-            memcpy(verts + index, temp, sizeof(float) * 3);
-
-            if (!j) centralAngle += displacement;
-            index += 3;
-        }
-    }
-
-	u16 elements[] = {
-		0, 1, 2,
-		3, 2, 1
-	};
-
-	RSGL_rawVerts data;
-	data.type = RSGL_LINES;
-	data.verts = verts;
-	data.texCoords = texCoords;
-	data.elements = elements;
-	data.elmCount = 6;
-	data.vert_count = 6;
-
-    return RSGL_drawRawVerts(renderer, &data);
-}
-
-i32 RSGL_drawPolygonOutline(RSGL_renderer* renderer, RSGL_rect o, u32 sides, u32 thickness) {
-    renderer->state.lineWidth = thickness;
-    return RSGL_drawPolygonOutlineEx(renderer, o, sides, (RSGL_vec2D){0, (float)sides});
-}
-i32 RSGL_drawArcOutline(RSGL_renderer* renderer, RSGL_rect o, RSGL_vec2D arc, u32 thickness) {
-    float verts = ((2 * M_PI * ((o.w + o.h) / 2.0f)) / 10);
-    verts = (verts > 360 ? 360 : verts);
-
-    renderer->state.lineWidth = thickness;
-    return RSGL_drawPolygonOutlineEx(renderer, o, verts, arc);
-}
-
-i32 RSGL_drawOvalOutline(RSGL_renderer* renderer, RSGL_rect o, u32 thickness) {
-    float verts = ((2 * M_PI * ((o.w + o.h) / 2.0f)) / 10);
-    verts = (verts > 360 ? 360 : verts);
-
-    renderer->state.lineWidth = thickness;
-    return RSGL_drawPolygonOutlineEx(renderer, o, verts, (RSGL_vec2D){0, verts});
-}
-
-/*
-******
-RSGL_view
-******
-*/
-
-/* Multiply the current matrix by a rotation matrix */
-RSGL_mat4 RSGL_projection_getMatrix(const RSGL_projection* projection) {
-    RSGL_mat4 matrix = RSGL_mat4_loadIdentity();
-	switch (projection->type) {
-		case RSGL_projectionPerspective3D:
-			matrix = RSGL_mat4_perspective(matrix.m, projection->p3D.fov, projection->p3D.ratio, projection->p3D.pNear, projection->p3D.pFar);
-			break;
-		case RSGL_projectionOrtho3D: {
-			double top = projection->p3D.fov / 2.0;
-			double right = top * projection->p3D.ratio;
-
-			matrix = RSGL_mat4_ortho(matrix.m, -right, right, -top, top, projection->p3D.pNear, projection->p3D.pFar);
-			break;
-		}
-		case RSGL_projectionOrtho2D:
-			matrix = RSGL_mat4_ortho(matrix.m, 0, projection->p2D.width, projection->p2D.height, 0, 0, 1.0);
-			break;
-		default: break;
-	}
-
-    return matrix;
-}
-
-
-RSGL_mat4 RSGL_view_getMatrix(const RSGL_view* view) {
-    RSGL_mat4 matrix = RSGL_mat4_loadIdentity();
-	switch (view->type) {
-		case RSGL_viewType2D:
-			matrix = RSGL_mat4_translate(matrix.m, -view->view2D.target.x, -view->view2D.target.y, -view->view2D.target.z);
-			matrix = RSGL_mat4_rotate(matrix.m, view->view2D.rotation, 0, 0, 1);
-			matrix = RSGL_mat4_scale(matrix.m, view->view2D.zoom, view->view2D.zoom, 1.0f);
-			matrix = RSGL_mat4_translate(matrix.m, view->view2D.offset.x, view->view2D.offset.y, view->view2D.offset.z);
-			break;
-		case RSGL_viewType3D:
-			matrix = RSGL_mat4_lookAt(matrix.m, view->view3D.pos.x, view->view3D.pos.y, view->view3D.pos.z, view->view3D.target.x, view->view3D.target.y, view->view3D.target.z,
-										view->view3D.up.x, view->view3D.up.y, view->view3D.up.z);
-			break;
-		default: break;
-	}
-
-	return matrix;
-}
-
-#endif
-
-/*
-******
-RSGL_Matrix
-******
-*/
-
-
-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)  {
-	float matLookAt[16];
-
-    float length = 0.0f;
-    float ilength = 0.0f;
-
-    RSGL_vec3D vz = { eyeX - targetX, eyeY - targetY, eyeZ - targetZ };
-
-    RSGL_vec3D v = vz;
-    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
-    if (length == 0.0f) length = 1.0f;
-    ilength = 1.0f/length;
-    vz.x *= ilength;
-    vz.y *= ilength;
-    vz.z *= ilength;
-
-    RSGL_vec3D vx = { upY*vz.z - upZ*vz.y, upZ*vz.x - upX*vz.z, upX*vz.y - upY*vz.x };
-
-    v = vx;
-    length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
-    if (length == 0.0f) length = 1.0f;
-    ilength = 1.0f/length;
-    vx.x *= ilength;
-    vx.y *= ilength;
-    vx.z *= ilength;
-
-    RSGL_vec3D vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x };
-
-    matLookAt[0] = vx.x;
-    matLookAt[1] = vy.x;
-    matLookAt[2] = vz.x;
-    matLookAt[3] = 0.0f;
-    matLookAt[4] = vx.y;
-    matLookAt[5] = vy.y;
-    matLookAt[6] = vz.y;
-    matLookAt[7] = 0.0f;
-    matLookAt[8] = vx.z;
-    matLookAt[9] = vy.z;
-    matLookAt[10] = vz.z;
-    matLookAt[11] = 0.0f;
-    matLookAt[12] = -(vx.x*eyeX + vx.y*eyeY + vx.z*eyeZ);
-    matLookAt[13] = -(vy.x*eyeX + vy.y*eyeY + vy.z*eyeZ);
-    matLookAt[14] = -(vz.x*eyeX + vz.y*eyeY + vz.z*eyeZ);
-	matLookAt[15] = 1.0f;
-
-    return RSGL_mat4_multiply(matrix, matLookAt);
-}
-
-RSGL_mat4 RSGL_mat4_ortho(float matrix[16], float left, float right, float bottom, float top, float znear, float zfar) {
-    float rl = (float)(right - left);
-    float tb = (float)(top - bottom);
-    float fn = (float)(zfar - znear);
-
-    float matOrtho[16] = {
-        (2.0f / rl),                          0.0f,                             0.0f,                                 0.0f,
-        0.0f,                                (2.0f / tb),                       0.0f,                                0.00,
-        0.0f,                                 0.0f,                             (-2.0f / fn),                         0.0f,
-        (-((float)left + (float)right) / rl), -((float)top + (float)bottom)/tb, (-((float)zfar + (float)znear) / fn), 1.0f
-    };
-
-    return RSGL_mat4_multiply(matrix, matOrtho);
-}
-
-RSGL_mat4 RSGL_mat4_scale(float matrix[16], float x, float y, float z) {
-	RSGL_mat4 result;
-
-	for (int i = 0; i < 16; ++i) {
-		result.m[i] = matrix[i];
-	}
-
-	result.m[0] += matrix[0]*x + matrix[4]*y + matrix[8]*z;
-	result.m[13] += matrix[1]*x + matrix[5]*y + matrix[9]*z;
-	result.m[10] += matrix[2]*x + matrix[6]*y + matrix[10]*z;
-	result.m[11] += matrix[2] + matrix[6] + matrix[10];
-
-	return result;
-}
-
-
-
-/* Multiply the current matrix by a translation matrix */
-RSGL_mat4 RSGL_mat4_translate(float matrix[16], float x, float y, float z) {
-	RSGL_mat4 result;
-
-	for (int i = 0; i < 16; ++i) {
-		result.m[i] = matrix[i];
-	}
-
-	result.m[12] += matrix[0]*x + matrix[4]*y + matrix[8]*z;
-	result.m[13] += matrix[1]*x + matrix[5]*y + matrix[9]*z;
-	result.m[14] += matrix[2]*x + matrix[6]*y + matrix[10]*z;
-
-	return result;
-}
-
-RSGL_mat4 RSGL_mat4_loadIdentity(void) {
-    RSGL_mat4 matrix = (RSGL_mat4) {
-        {
-            1.0f, 0.0f, 0.0f, 0.0f,
-            0.0f, 1.0f, 0.0f, 0.0f,
-            0.0f, 0.0f, 1.0f, 0.0f,
-            0.0f, 0.0f, 0.0f, 1.0f
-        }
-    };
-
-    return matrix;
-}
-
-RSGL_mat4 RSGL_mat4_rotate(float matrix[16], float angle, float x, float y, float z) {
-	/* Axis vector (x, y, z) normalization */
-	float lengthSquared = x * x + y * y + z * z;
-	if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) {
-		float inverseLength = 1.0f / sqrtf(lengthSquared);
-		x *= inverseLength;
-		y *= inverseLength;
-		z *= inverseLength;
-	}
-
-	/* Rotation matrix generation */
-	float sinres = RSGL_SIN(angle);
-	float cosres = RSGL_COS(angle);
-	float t = 1.0f - cosres;
-
-	float matRotation[16] =  {
-            x * x * t + cosres,   	  	y * x * t + z * sinres,   	z * x * t - y * sinres,   	0.0f,
-            x * y * t - z * sinres,   	y * y * t + cosres,   		z * y * t + x * sinres,   	0.0f,
-            x * z * t + y * sinres,   	y * z * t - x * sinres,  	z * z * t + cosres,   		0.0f,
-            0.0f,   					0.0f,   					0.0f,   					1.0f
-	};
-
-	return RSGL_mat4_multiply(matRotation, matrix);
-}
-
-RSGL_mat4 RSGL_mat4_perspective(float matrix[16], float fovY, float aspect, float zNear, float zFar) {
-    fovY =  (fovY * DEG2RAD) / 2.0f;
-    const float f = (RSGL_COS(fovY) / RSGL_SIN(fovY));
-
-    float perspective[16] = {
-            (f / aspect), 0.0f,  0.0f,                                   0.0f,
-            0,            f,     0.0f,                                   0.0f,
-            0.0f,         0.0f,  (zFar + zNear) / (zNear - zFar),       -1.0f,
-            0.0f,         0.0f,  (2.0f * zFar * zNear) / (zNear - zFar),  0.0f
-    };
-
-	return RSGL_mat4_multiply(matrix, perspective);
-}
-
-RSGL_vec3D RSGL_mat4_multiplyPoint(RSGL_mat4 matrix, RSGL_vec3D point) {
-	return (RSGL_vec3D){RSGL_GET_MATRIX_POINT(point.x, point.y, point.z)};
-}
-
-RSGL_mat4 RSGL_mat4_multiply(float left[16], float right[16]) {
-    return (RSGL_mat4) {
-        {
-            left[0] * right[0] + left[1] * right[4] + left[2] * right[8] + left[3] * right[12],
-            left[0] * right[1] + left[1] * right[5] + left[2] * right[9] + left[3] * right[13],
-            left[0] * right[2] + left[1] * right[6] + left[2] * right[10] + left[3] * right[14],
-            left[0] * right[3] + left[1] * right[7] + left[2] * right[11] + left[3] * right[15],
-            left[4] * right[0] + left[5] * right[4] + left[6] * right[8] + left[7] * right[12],
-            left[4] * right[1] + left[5] * right[5] + left[6] * right[9] + left[7] * right[13],
-            left[4] * right[2] + left[5] * right[6] + left[6] * right[10] + left[7] * right[14],
-            left[4] * right[3] + left[5] * right[7] + left[6] * right[11] + left[7] * right[15],
-            left[8] * right[0] + left[9] * right[4] + left[10] * right[8] + left[11] * right[12],
-            left[8] * right[1] + left[9] * right[5] + left[10] * right[9] + left[11] * right[13],
-            left[8] * right[2] + left[9] * right[6] + left[10] * right[10] + left[11] * right[14],
-            left[8] * right[3] + left[9] * right[7] + left[10] * right[11] + left[11] * right[15],
-            left[12] * right[0] + left[13] * right[4] + left[14] * right[8] + left[15] * right[12],
-            left[12] * right[1] + left[13] * right[5] + left[14] * right[9] + left[15] * right[13],
-            left[12] * right[2] + left[13] * right[6] + left[14] * right[10] + left[15] * right[14],
-            left[12] * right[3] + left[13] * right[7] + left[14] * right[11] + left[15] * right[15]
-        }
-    };
-}
-#endif /* RSGL_IMPLEMENTATION */