path: root/rsgl.c3l/include/RSGL_gl.h

#ifndef RSGL_H
#include "RSGL.h"
#endif

#ifndef RSGL_GL_H
#define RSGL_GL_H

typedef struct RSGL_glRenderer RSGL_glRenderer;

RSGLDEF RSGL_rendererProc RSGL_GL_rendererProc(void);
RSGLDEF size_t RSGL_GL_size(void);

RSGLDEF RSGL_renderer* RSGL_GL_renderer_init(void* loader);
RSGLDEF void RSGL_GL_renderer_initPtr(void* loader, RSGL_glRenderer* ptr, RSGL_renderer* renderer);

#endif /* RSGL_GL_H */

#ifdef RSGL_IMPLEMENTATION

#ifdef __EMSCRIPTEN__
	#if defined(RSGL_GL2)
		#undef RSGL_GL2
		#define RSGL_GLES2
	#endif
	#if defined(RSGL_GL3)
		#undef RSGL_GL3
		#define RSGL_GLES3
	#endif
#endif

#if !defined(RSGL_GLES3) && !defined(RSGL_GLES2) && !defined(RSGL_GL2) && !defined(RSGL_GL3)
	#ifndef __EMSCRIPTEN__
		#define RSGL_GL3
	#else
		#define RSGL_GLES3
	#endif
#endif

#if (defined(__EMSCRIPTEN__) || defined(RSGL_GLES3) || defined(RSGL_GLES2)) && defined(RSGL_GL_USE_GLAD) 
	#undef RSGL_GL_USE_GLAD
#endif

#if defined(RSGL_GLES3)
	#include <GLES3/gl3.h>
#elif defined(RSGL_GLES2)
	#include <GLES2/gl2.h>
#endif

#ifdef RSGL_GL_USE_GLAD
	#if !defined(GLAD_GL_H_) || !defined(GLAD_GL_IMPLEMENTATION) 
		#define GLAD_MALLOC RSGL_MALLOC 
		#define GLAD_FREE RSGL_FREE
		#define GLAD_GL_IMPLEMENTATION
		#include "glad.h"
	#endif
#endif

#ifndef RSGL_SNPRINTF
	#include <stdio.h>
	#define RSGL_SNPRINTF snprintf 
#endif /* RSGL_SNPRINTF */

RSGLDEF void RSGL_GL_render(RSGL_glRenderer* ctx, const RSGL_renderPass* pass);
RSGLDEF void RSGL_GL_initPtr(RSGL_glRenderer* ctx, void* proc); /* init render backend */
RSGLDEF void RSGL_GL_freePtr(RSGL_glRenderer* ctx); /* free render backend */
RSGLDEF void RSGL_GL_clear(RSGL_glRenderer* ctx, RSGL_framebuffer framebuffer, float r, float g, float b, float a);
RSGLDEF void RSGL_GL_viewport(RSGL_glRenderer* ctx, i32 x, i32 y, i32 w, i32 h);
RSGLDEF void RSGL_GL_createBuffer(RSGL_glRenderer* ctx, RSGL_bufferType type, size_t size, const void* data, size_t* buffer);
RSGLDEF void RSGL_GL_updateBuffer(RSGL_glRenderer* ctx, RSGL_bufferType type, size_t buffer, const void* data, size_t start, size_t end);
RSGLDEF void RSGL_GL_deleteBuffer(RSGL_glRenderer* ctx, size_t buffer);
RSGLDEF RSGL_programBlob RSGL_GL_defaultBlob(RSGL_glRenderer* ctx);
/* create a texture based on a given bitmap, this must be freed later using RSGL_deleteTexture or opengl*/
RSGLDEF RSGL_texture RSGL_GL_createTexture(RSGL_glRenderer* ctx, const RSGL_textureBlob* blob);
/* updates an existing texture wiht a new bitmap */
RSGLDEF void RSGL_GL_copyToTexture(RSGL_glRenderer* ctx, RSGL_texture texture, size_t x, size_t y, const RSGL_textureBlob* blob);
/* delete a texture */
RSGLDEF void RSGL_GL_deleteTexture(RSGL_glRenderer* ctx, RSGL_texture tex);
/* starts scissoring */
RSGLDEF void RSGL_GL_scissorStart(RSGL_glRenderer* ctx, float x, float y, float w, float h, float renderer_height);
/* stops scissoring */
RSGLDEF void RSGL_GL_scissorEnd(RSGL_glRenderer* ctx);
/* program loading */
RSGLDEF RSGL_programInfo RSGL_GL_createProgram(RSGL_glRenderer* ctx, RSGL_programBlob* blob);
RSGLDEF void RSGL_GL_deleteProgram(RSGL_glRenderer* ctx, const RSGL_programInfo* program);
RSGLDEF size_t RSGL_GL_findShaderVariable(RSGL_glRenderer* ctx, const RSGL_programInfo*  program, const char* var, const size_t len);
RSGLDEF void RSGL_GL_updateShaderVariable(RSGL_glRenderer* ctx, const RSGL_programInfo* program, size_t var, const float value[], u8 len);

RSGLDEF RSGL_framebuffer RSGL_GL_createFramebuffer(RSGL_glRenderer* renderer, size_t width, size_t height);
RSGLDEF void RSGL_GL_attachFramebuffer(RSGL_glRenderer* renderer, RSGL_framebuffer fbo, RSGL_texture tex, u8 attachType, u8 mipLevel);
RSGLDEF void RSGL_GL_deleteFramebuffer(RSGL_glRenderer* renderer, RSGL_framebuffer fbo);

#ifdef RSGL_USE_COMPUTE
RSGLDEF RSGL_programInfo RSGL_GL_createComputeProgram(RSGL_glRenderer* ctx, const char* CShaderCode);
RSGLDEF void RSGL_GL_dispatchComputeProgram(RSGL_glRenderer* ctx, RSGL_programInfo program, u32 groups_x, u32 groups_y, u32 groups_z);
RSGLDEF void RSGL_GL_bindComputeTexture(RSGL_glRenderer* ctx, u32 texture, u8 format);
#endif

/* WebGL doesn't support compute shaders */
#if defined(__EMSCRIPTEN__) && defined(RSGL_USE_COMPUTE)
	#undef RSGL_USE_COMPUTE
#endif

RSGL_renderer* RSGL_GL_renderer_init(void* loader) { return RSGL_renderer_init(RSGL_GL_rendererProc(), loader); }
void RSGL_GL_renderer_initPtr(void* loader, RSGL_glRenderer* ptr, RSGL_renderer* renderer) { RSGL_renderer_initPtr(RSGL_GL_rendererProc(), loader, ptr, renderer); }

#define RSGL_MULTILINE_STR(...) #__VA_ARGS__

struct RSGL_glRenderer {
	u32 vao;
};

size_t RSGL_GL_size(void) {
	return sizeof(RSGL_glRenderer);
}

RSGL_rendererProc RSGL_GL_rendererProc() {
	RSGL_rendererProc proc;
	RSGL_MEMSET(&proc, 0, sizeof(proc));

	proc.render = (void (*)(void*, const RSGL_renderPass* pass))RSGL_GL_render;
    proc.size = (size_t (*)(void))RSGL_GL_size;
    proc.initPtr = (void (*)(void*, void*))RSGL_GL_initPtr;
    proc.freePtr = (void (*)(void*))RSGL_GL_freePtr;
    proc.clear = (void (*)(void*, RSGL_framebuffer, float, float, float, float))RSGL_GL_clear;
    proc.viewport = (void (*)(void*, i32, i32, i32, i32))RSGL_GL_viewport;
    proc.createTexture = (RSGL_texture (*)(void*, const RSGL_textureBlob* blob))RSGL_GL_createTexture;
    proc.copyToTexture = (void (*)(void*, RSGL_texture, size_t, size_t, const RSGL_textureBlob* blob))RSGL_GL_copyToTexture;
    proc.deleteTexture = (void (*)(void*, RSGL_texture))RSGL_GL_deleteTexture;
    proc.scissorStart = (void (*)(void*, float, float, float, float, float))RSGL_GL_scissorStart;
    proc.scissorEnd =  (void (*)(void*))RSGL_GL_scissorEnd;
    proc.createProgram = (RSGL_programInfo (*)(void*, RSGL_programBlob* blob))RSGL_GL_createProgram;
    proc.deleteProgram = (void (*)(void*, const RSGL_programInfo*))RSGL_GL_deleteProgram;
	proc.findShaderVariable = (size_t (*)(void*, const RSGL_programInfo*, const char*, size_t))RSGL_GL_findShaderVariable;
	proc.updateShaderVariable = (void (*)(void*, const RSGL_programInfo*, size_t, const float[], u8))RSGL_GL_updateShaderVariable;
	proc.createBuffer = (void (*)(void*, RSGL_bufferType, size_t, const void*, size_t*))RSGL_GL_createBuffer;
	proc.updateBuffer = (void (*)(void*, RSGL_bufferType, size_t, void*, size_t, size_t))RSGL_GL_updateBuffer;
	proc.deleteBuffer = (void (*)(void*, size_t))RSGL_GL_deleteBuffer;
	proc.defaultBlob = (RSGL_programBlob (*)(void*))RSGL_GL_defaultBlob;
	proc.createFramebuffer = (RSGL_framebuffer (*)(void*, size_t, size_t))RSGL_GL_createFramebuffer;
	proc.attachFramebuffer = (void (*)(void*, RSGL_framebuffer, RSGL_texture, u8, u8))RSGL_GL_attachFramebuffer;
	proc.deleteFramebuffer = (void (*)(void*, RSGL_framebuffer))RSGL_GL_deleteFramebuffer;
//	proc.setSurface = (void (*)(void*, void*))RSGL_GL_setSurface;
#ifdef RSGL_USE_COMPUTE
	proc.createComputeProgram = (RSGL_programInfo (*)(void*, const char*))RSGL_GL_createComputeProgram;
	proc.dispatchComputeProgram = (void (*)(void*, const RSGL_programInfo*, u32, u32, u32))RSGL_GL_dispatchComputeProgram;
	proc.bindComputeTexture = (void (*)(void*, u32, u8))RSGL_GL_bindComputeTexture;
#else
	proc.createComputeProgram = NULL;
	proc.dispatchComputeProgram = NULL;
	proc.bindComputeTexture = NULL;
#endif
	return proc;
}

void RSGL_GL_deleteTexture(RSGL_glRenderer* ctx, RSGL_texture tex) { glDeleteTextures(1, (u32*)&tex); }
void RSGL_GL_viewport(RSGL_glRenderer* ctx, i32 x, i32 y, i32 w, i32 h) { glViewport(x, y, w ,h); }

void RSGL_GL_clear(RSGL_glRenderer* ctx, RSGL_framebuffer framebuffer, float r, float g, float b, float a) {
	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

    glClearColor(r, g, b, a);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

GLuint RSGL_GL_bufferTypeToNative(RSGL_bufferType type) {
	switch (type) {
		case RSGL_arrayBuffer: return GL_ARRAY_BUFFER;
		case RSGL_elementArrayBuffer: return GL_ELEMENT_ARRAY_BUFFER;
		#if !defined(__APPLE__) && !defined(RSGL_GLES2) && !defined(RSGL_GLES3)
			case RSGL_shaderStorageBuffer: return GL_SHADER_STORAGE_BUFFER;
			case RSGL_textureBuffer: return GL_TEXTURE_BUFFER;
			case RSGL_uniformBuffer: return GL_UNIFORM_BUFFER;
		#else
			case RSGL_shaderStorageBuffer: RSGL_ASSERT(!"shader storage buffer is not supported");
			case RSGL_textureBuffer: RSGL_ASSERT(!"shader texture buffer is not supported");
			case RSGL_uniformBuffer: RSGL_ASSERT(!"uniform buffer is not supported");
		#endif

		default: break;
	}

	return GL_ARRAY_BUFFER;
}

void RSGL_GL_createBuffer(RSGL_glRenderer* ctx, RSGL_bufferType type, size_t size, const void* data, size_t* buffer) {
	glGenBuffers(1, (u32*)buffer);

	GLenum usage = GL_STATIC_DRAW;
	if (data == NULL)
		usage = GL_DYNAMIC_DRAW;

	glBindBuffer(RSGL_GL_bufferTypeToNative(type), *(u32*)buffer);
	glBufferData(RSGL_GL_bufferTypeToNative(type), size, data, usage);
}

void RSGL_GL_updateBuffer(RSGL_glRenderer* ctx, RSGL_bufferType type, size_t buffer, const void* data, size_t start, size_t end) {
	glBindBuffer(RSGL_GL_bufferTypeToNative(type), *(u32*)&buffer);
	glBufferSubData(RSGL_GL_bufferTypeToNative(type), start, end, data);
}

void RSGL_GL_deleteBuffer(RSGL_glRenderer* ctx, size_t buffer) {
	glDeleteBuffers(1, (u32*)&buffer);
}

RSGL_programBlob RSGL_GL_defaultBlob(RSGL_glRenderer* ctx) {
#ifdef RSGL_GL3

	static const char *defaultVShaderCode = RSGL_MULTILINE_STR(
		\x23version 330                     \n
        in vec3 vertexPosition;            \n
        in vec2 vertexTexCoord;            \n
        in vec4 vertexColor;               \n
        out vec2 fragTexCoord;             \n
        out vec4 fragColor;                \n
        uniform mat4 model; \n
        uniform mat4 pv; \n
        void main() {
            fragTexCoord = vertexTexCoord;
            fragColor = vertexColor;
            gl_Position = pv * model * vec4(vertexPosition, 1.0);
        }
    );

    static const char* defaultFShaderCode = RSGL_MULTILINE_STR(
		\x23version 330      \n
		in vec2 fragTexCoord;
		in vec4 fragColor;
		out vec4 finalColor;
		uniform sampler2D texture0;
		void main() {
				finalColor = texture(texture0, fragTexCoord) * fragColor;
			}
		);

#elif defined(RSGL_GLES3)

	static const char *defaultVShaderCode = RSGL_MULTILINE_STR(
		\x23version 300 es                    \n
        in vec3 vertexPosition;            \n
        in vec2 vertexTexCoord;            \n
        in vec4 vertexColor;               \n
        out vec2 fragTexCoord;             \n
        out vec4 fragColor;                \n
        uniform mat4 model; \n
        uniform mat4 pv; \n
        void main() {
            fragTexCoord = vertexTexCoord;
            fragColor = vertexColor;
            gl_Position = pv * model * vec4(vertexPosition, 1.0);
        }
    );

    static const char* defaultFShaderCode = RSGL_MULTILINE_STR(
		\x23version 300 es                     \n
		precision mediump float;           \n
		in vec2 fragTexCoord;
		in vec4 fragColor;
		out vec4 finalColor;
		uniform sampler2D texture0;
		void main() {
				finalColor = texture(texture0, fragTexCoord) * fragColor;
			}
		);

#elif defined(RSGL_GLES2) || defined(RSGL_GL2)

	static const char *defaultVShaderCode = RSGL_MULTILINE_STR(
		\x23version 100                     \n
        attribute vec3 vertexPosition;            \n
        attribute vec2 vertexTexCoord;            \n
        attribute vec4 vertexColor;               \n
        varying vec2 fragTexCoord;             \n
        varying vec4 fragColor;                \n
        uniform mat4 model; \n
        uniform mat4 pv; \n
        void main() {
            fragTexCoord = vertexTexCoord;
            fragColor = vertexColor;
            gl_Position = pv * model * vec4(vertexPosition, 1.0);
        }
    );

    static const char* defaultFShaderCode = RSGL_MULTILINE_STR(
		\x23version 100                      \n
		precision mediump float;           \n
		varying vec2 fragTexCoord; \n
		varying	vec4 fragColor; \n
		vec4 finalColor;
		uniform sampler2D texture0;
		void main() {
				gl_FragColor= texture2D(texture0, fragTexCoord) * fragColor;
			}
		);
#endif

	RSGL_programBlob blob;
	blob.vertex = defaultVShaderCode;
	blob.vertexLen = sizeof(defaultVShaderCode);
	blob.fragment = defaultFShaderCode;
	blob.fragmentLen = sizeof(defaultFShaderCode );

	return blob;
}

/*
print matrix array code snippet
	for (size_t iy = 0; iy < 4; iy++) {
		for (size_t ix = 0; ix < 4; ix++) {
			printf"%f, ", matrix[(iy * 4) + ix]);
		}
		printf("\n");
	}

		printf("\n\n");
*/



void RSGL_GL_initPtr(RSGL_glRenderer* ctx, void* proc) {
	#if defined(RSGL_GL_USE_GLAD)
	if (gladLoadGL((GLADloadfunc)proc) == 0) {
        RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "Failed to load an OpenGL functions\n");
        return;
    }
	#else
    RSGL_UNUSED(proc);
    #endif

	char buf[256];

	RSGL_SNPRINTF(buf, 256, "OpenGL Vendor: %s\n", glGetString(GL_VENDOR));
	RSGL_debugCallback(RSGL_typeInfo, RSGL_infoBackend, buf);

	RSGL_SNPRINTF(buf, 256, "OpenGL Renderer: %s\n", glGetString(GL_RENDERER));
	RSGL_debugCallback(RSGL_typeInfo, RSGL_infoBackend, buf);

	RSGL_SNPRINTF(buf, 256, "OpenGL Version: %s\n", glGetString(GL_VERSION));
	RSGL_debugCallback(RSGL_typeInfo, RSGL_infoBackend, buf);
	
	RSGL_SNPRINTF(buf, 256, "GLSL Version: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
	RSGL_debugCallback(RSGL_typeInfo, RSGL_infoBackend, buf);

#if defined(RSGL_GLES3) || defined(RSGL_GL3)
	glGenVertexArrays(1, &ctx->vao);
#endif

	glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void RSGL_GL_freePtr(RSGL_glRenderer* ctx) {
#if defined(RSGL_GLES3) || defined(RSGL_GL3)
	glDeleteVertexArrays(0, &ctx->vao);
#endif
}

void RSGL_GL_render(RSGL_glRenderer* ctx, const RSGL_renderPass* pass) {
	glBindFramebuffer(GL_FRAMEBUFFER, pass->framebuffer);

#if defined(RSGL_GLES3) || defined(RSGL_GL3)
	glBindVertexArray(ctx->vao);
#endif

	glBindBuffer(GL_ARRAY_BUFFER, pass->buffers->vertex);
	glEnableVertexAttribArray(pass->program->vertexPosition);
    glVertexAttribPointer(pass->program->vertexPosition, 3, GL_FLOAT, 0, 0, 0);

	glBindBuffer(GL_ARRAY_BUFFER, pass->buffers->texture);
	glEnableVertexAttribArray(pass->program->vertexTexCoord);
    glVertexAttribPointer(pass->program->vertexTexCoord, 2, GL_FLOAT, 0, 0, 0);

	glBindBuffer(GL_ARRAY_BUFFER, pass->buffers->color);
	glEnableVertexAttribArray(pass->program->vertexColor);
    glVertexAttribPointer(pass->program->vertexColor, 4, GL_FLOAT, 0, 0, 0);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pass->buffers->elements);

	glUseProgram(pass->program->program);
	glUniformMatrix4fv(pass->program->perspectiveView, 1, GL_FALSE, pass->matrix);

	u32 i;
	for (i = 0; i < pass->buffers->batchCount; i++) {
		GLenum mode = GL_TRIANGLES;
		glBindTexture(GL_TEXTURE_2D, pass->buffers->batches[i].tex);

		if (pass->buffers->batches[i].lineWidth)
			glLineWidth(pass->buffers->batches[i].lineWidth);

		glUniformMatrix4fv(pass->program->model, 1, GL_FALSE, pass->buffers->batches[i].matrix.m);

		switch (pass->buffers->batches[i].type) {
			case RSGL_TRIANGLES: mode = GL_TRIANGLES; break;
			case RSGL_POINTS: mode = GL_POINTS; break;
			case RSGL_LINES:  mode = GL_LINES; break;
			default: break;
		}

		glDrawElements(mode, (i32)pass->buffers->batches[i].elmCount, GL_UNSIGNED_SHORT, (void*)(pass->buffers->batches[i].elmStart * sizeof(u16)));
	}

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	glBindTexture(GL_TEXTURE_2D, 0);
	glUseProgram(0);

#if defined(RSGL_GLES3) || defined(RSGL_GL3)
	glBindVertexArray(0);
#endif

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void RSGL_GL_scissorStart(RSGL_glRenderer* ctx, float x, float y, float w, float h, float renderer_height) {
    glEnable(GL_SCISSOR_TEST);

	glScissor(x, renderer_height - (y + h), w, h);
}

void RSGL_GL_scissorEnd(RSGL_glRenderer* ctx) {
    glDisable(GL_SCISSOR_TEST);
}

GLuint RSGL_GL_textureFormatToNative(RSGL_textureFormat format) {
	switch (format) {
		case RSGL_formatRGB: return GL_RGB;
		case RSGL_formatRGBA: return GL_RGBA;
		#if !defined(RSGL_GLES2) && !defined(RSGL_GLES3)
			case RSGL_formatBGR: return GL_BGR;
			case RSGL_formatBGRA: return GL_BGRA;
			case RSGL_formatRed: return GL_RED;
			case RSGL_formatGrayscale: return GL_RED;
			case RSGL_formatGrayscaleAlpha: return GL_RED;
		#else
			case RSGL_formatBGR: RSGL_ASSERT(!"GLES does not support BGR"); break;
			case RSGL_formatBGRA: RSGL_ASSERT(!"GLES does not support BGRA"); break;
			case RSGL_formatRed: RSGL_ASSERT(!"GLES does not support GL RED"); break;
			case RSGL_formatGrayscale: RSGL_ASSERT(!"GLES does not support GL RED"); break;
			case RSGL_formatGrayscaleAlpha: RSGL_ASSERT(!"GLES does not support GL RED"); break;
		#endif
		default: break;
	}

	return GL_RGBA;
}

GLuint RSGL_GL_textureDataTypeToNative(RSGL_textureDataType type) {
    switch (type) {
		case RSGL_textureDataInt: return GL_UNSIGNED_BYTE;
		case RSGL_textureDataFloat: return GL_FLOAT;
        default: break;
    }

	return GL_UNSIGNED_BYTE;
}

GLuint RSGL_GL_textureFilterToNative(RSGL_textureFilter filter) {
    switch (filter) {
		case RSGL_filterNearest:  return GL_NEAREST;
		case RSGL_filterLinear: return GL_LINEAR;
        default: break;
    }

	return GL_LINEAR;
}

/* textures / images */
RSGL_texture RSGL_GL_createTexture(RSGL_glRenderer* ctx, const RSGL_textureBlob* blob) {
    unsigned int id = 0;

    glBindTexture(GL_TEXTURE_2D, 0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glGenTextures(1, &id);
    glBindTexture(GL_TEXTURE_2D, id);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, RSGL_GL_textureFilterToNative(blob->minFilter));
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, RSGL_GL_textureFilterToNative(blob->magFilter));

#ifndef RSGL_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, blob->width);
#endif

#if defined(RSGL_GLES2)
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#else
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
#endif

	u32 dataFormat = RSGL_GL_textureFormatToNative(blob->dataFormat);
	u32 textureFormat = RSGL_GL_textureFormatToNative(blob->textureFormat);
	u32 dataType = RSGL_GL_textureDataTypeToNative(blob->dataType);

#if !defined(RSGL_GLES2) && !defined(RSGL_GLES3)
	if (blob->dataFormat == RSGL_formatGrayscale) {
		static GLint swizzleRgbaParams[4] = { GL_RED, GL_RED, GL_RED, GL_ONE  };
		glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleRgbaParams);
	} else if (blob->dataFormat == RSGL_formatGrayscaleAlpha) {
		static GLint swizzleRgbaParams[4] = { GL_ONE, GL_ONE, GL_ONE, GL_RED };
		glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleRgbaParams);
	}
#endif

	glTexImage2D(GL_TEXTURE_2D, 0, dataFormat, blob->width, blob->height, 0, textureFormat, dataType, blob->data);
    glBindTexture(GL_TEXTURE_2D, 0);

    return id;
}

void RSGL_GL_copyToTexture(RSGL_glRenderer* ctx, RSGL_texture texture, size_t x, size_t y, const RSGL_textureBlob* blob) {
	glBindTexture(GL_TEXTURE_2D, texture);

#ifndef RSGL_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, blob->width);
#endif

	u32 dataFormat = RSGL_GL_textureFormatToNative(blob->dataFormat);

	u32 dataType = RSGL_GL_textureDataTypeToNative(blob->dataType);

#if !defined(RSGL_GLES2) && !defined(RSGL_GLES3)
	if (blob->dataFormat == RSGL_formatGrayscale) {
		static GLint swizzleRgbaParams[4] = { GL_RED, GL_RED, GL_RED, GL_ONE  };
		glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleRgbaParams);
	} else 	if (blob->dataFormat == RSGL_formatGrayscaleAlpha) {
		static GLint swizzleRgbaParams[4] = { GL_ONE, GL_ONE, GL_ONE, GL_RED };
		glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleRgbaParams);
	}
#endif

	glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, (i32)blob->width, (i32)blob->height, dataFormat, dataType, blob->data);
    glBindTexture(GL_TEXTURE_2D, 0);
}

void RSGL_opengl_getError(void) {
	GLenum err;
	while ((err = glGetError()) != GL_NO_ERROR) {
		switch (err) {
			case GL_INVALID_ENUM:
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "OpenGL error: GL_INVALID_ENUM\n");
				break;
			case GL_INVALID_VALUE:
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "OpenGL error: GL_INVALID_VALUE\n");
				break;
			case GL_INVALID_OPERATION:
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "OpenGL error: GL_INVALID_OPERATION\n");
				break;
			#if !defined(RSGL_GLES2) && !defined(RSGL_GLES3)
			case GL_STACK_OVERFLOW:
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "OpenGL error: GL_STACK_OVERFLOW\n");
				break;
			case GL_STACK_UNDERFLOW:
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, "OpenGL error: GL_STACK_UNDERFLOW\n");
				break;
			#endif
			default: {
				char buf[256];
				RSGL_SNPRINTF(buf, 256, "OpenGL error: Unknown error code 0x%x\n", err);
				RSGL_debugCallback(RSGL_typeError, RSGL_errorBackend, buf);
				break;
			}
		}
	}
}


void RSGL_debug_shader(u32 src, const char *shader, const char *action) {
    GLint status;

	if (action[0] == 'l')
		glGetProgramiv(src, GL_LINK_STATUS, &status);
	else
		glGetShaderiv(src, GL_COMPILE_STATUS, &status);

	char buf[1024];

	if (status == GL_TRUE) {
		RSGL_SNPRINTF(buf, 256, "%s Shader %s successfully.\n", shader, action);
		RSGL_debugCallback(RSGL_typeInfo, RSGL_infoShader, buf);
	} else {
		RSGL_SNPRINTF(buf, 256, "%s Shader failed to %s.\n", shader, action);
		RSGL_debugCallback(RSGL_typeError, RSGL_errorShader, buf);

		GLchar infoLog[512];
		if (action[0] == 'c') {
			glGetShaderInfoLog(src, 1024, NULL, infoLog);
			RSGL_SNPRINTF(buf, 1024, "%s Shader info log:\n%s\n", shader, infoLog);
		} else {
			glGetProgramInfoLog(src, 1024, NULL, infoLog);
			RSGL_SNPRINTF(buf, 1024, "%s info log:\n%s\n", shader, infoLog);
		}

		RSGL_debugCallback(RSGL_typeError, RSGL_errorShader, buf);

		RSGL_opengl_getError();
	}
}

RSGL_programInfo RSGL_GL_createProgram(RSGL_glRenderer* ctx, RSGL_programBlob* blob) {
	RSGL_programInfo program;
	u32 vShader, fShader;

	/* compile vertex shader */
	vShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vShader, 1, &blob->vertex, NULL);
	glCompileShader(vShader);

	RSGL_debug_shader(vShader, "Vertex", "compile");

	/* compile fragment shader */
	fShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fShader, 1, &blob->fragment, NULL);
	glCompileShader(fShader);

	RSGL_debug_shader(fShader, "Fragment", "compile");

	/* create program and link vertex and fragment shaders */
	program.program = glCreateProgram();

	glAttachShader(program.program, vShader);
	glAttachShader(program.program, fShader);
	glLinkProgram(program.program);

	RSGL_debug_shader(program.program, "Program", "link");

	glDeleteShader(vShader);
	glDeleteShader(fShader);

	glUseProgram(program.program);

	program.vertexPosition = glGetAttribLocation(program.program, "vertexPosition");
	program.vertexTexCoord = glGetAttribLocation(program.program, "vertexTexCoord");
	program.vertexColor = glGetAttribLocation(program.program, "vertexColor");

	program.perspectiveView = glGetUniformLocation(program.program, "pv");
	program.model = glGetUniformLocation(program.program, "model");

	if (program.perspectiveView < 0 || program.model < 0) {
		RSGL_debugCallback(RSGL_typeError, RSGL_errorQueryFail, "Failed to locate the shader variables\n");
	}

	glUseProgram(0);

	program.type = RSGL_shaderTypeStandard;
	return program;
}

void RSGL_GL_deleteProgram(RSGL_glRenderer* ctx, const RSGL_programInfo* program) {
    glUseProgram(0);
    glDeleteProgram(program->program);
}

size_t RSGL_GL_findShaderArray(RSGL_glRenderer* ctx, const RSGL_programInfo* program, const char* var, const size_t len) {
	glUseProgram(program->program);
    int loc = glGetAttribLocation(program->program, var);
    glUseProgram(0);
	return loc;
}

size_t RSGL_GL_findShaderVariable(RSGL_glRenderer* ctx, const RSGL_programInfo* program, const char* var, const size_t len) {
	glUseProgram(program->program);
    int loc = glGetUniformLocation(program->program, var);
    glUseProgram(0);
	return loc;
}

void RSGL_GL_updateShaderVariable(RSGL_glRenderer* ctx, const RSGL_programInfo* program, size_t var, const float value[], u8 len) {
	glUseProgram(program->program);
    int loc = (int)var;

	switch (len) {
        case 1: glUniform1f(loc, value[0]); break;
        case 2: glUniform2f(loc, value[0], value[1]); break;
        case 3: glUniform3f(loc, value[0], value[1], value[2]); break;
        case 4: glUniform4f(loc, value[0], value[1], value[2], value[3]); break;
        case 16: glUniformMatrix4fv(loc, 1, GL_FALSE, value); break;
        default: break;
    }

    glUseProgram(0);
}

RSGL_framebuffer RSGL_GL_createFramebuffer(RSGL_glRenderer* ctx, size_t width, size_t height) {
	u32 result = 0;
	glGenFramebuffers(1, &result);
    return (RSGL_framebuffer)result;
}

void RSGL_GL_attachFramebuffer(RSGL_glRenderer* ctx, RSGL_framebuffer fbo, RSGL_texture tex, u8 attachType, u8 mipLevel) {
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);

    if (attachType < 8)
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, tex, mipLevel);

    if (attachType == 100)
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, tex, mipLevel);

    if (attachType == 200)
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, tex, mipLevel);

    glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void RSGL_GL_deleteFramebuffer(RSGL_glRenderer* ctx, RSGL_framebuffer fbo) {
	u32 value = fbo;
    glDeleteFramebuffers(1, &value);
}

#ifdef RSGL_USE_COMPUTE

RSGL_programInfo RSGL_GL_createComputeProgram(RSGL_glRenderer* ctx, const char* CShaderCode) {
	RSGL_programInfo program;
	program.type = RSGL_shaderTypeCompute;

	u32 compute = glCreateShader(GL_COMPUTE_SHADER);
	glShaderSource(compute, 1, &CShaderCode, NULL);
	glCompileShader(compute);

	RSGL_debug_shader(compute, "Compute", "compile");

	program.program = glCreateProgram();
	glAttachShader(program.program, compute);
	glLinkProgram(program.program);
	RSGL_debug_shader(program.program, "Program", "link");

	glDeleteShader(compute);

	return program;
}

void RSGL_GL_dispatchComputeProgram(RSGL_glRenderer* ctx, RSGL_programInfo program, u32 groups_x, u32 groups_y, u32 groups_z) {
	glUseProgram(program.program);
	glDispatchCompute(groups_x, groups_y, groups_z);
	glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
}


void RSGL_GL_bindComputeTexture(RSGL_glRenderer* ctx, u32 texture, u8 format) {
	u16 c = 0;
   switch (format) {
       case 2: c = GL_RG8; break;
       case 3: c = GL_RGB8; break;
       case 4: c = GL_RGBA8; break;
       default: break;
   }
	glBindImageTexture(0, texture, 0, GL_FALSE, 0, GL_READ_WRITE, c);
}

#endif

#endif /* RSGL_IMPLEMENTATION */