path: root/gb_gl.h

/* gb.h - v0.05  - OpenGL Helper Library - public domain
                 - no warranty implied; use at your own risk

	This is a single header file with a bunch of useful stuff
	for working with OpenGL

===========================================================================
	YOU MUST

		#define GBGL_IMPLEMENTATION

	in EXACTLY _one_ C or C++ file that includes this header, BEFORE the
	include like this:

		#define GBGL_IMPLEMENTATION
		#include "gb_gl.h"

	All other files should just #include "gb_gl.h" without #define

	Dependencies
		NOTE: You may need change the path

		This library REQUIRES "stb_image.h" for loading images from file
		This library REQUIRES "gb.h" at this moment in time.
		If you are using the font library (e.g. GBGL_NO_FONTS is _not_ defined):
			This library then REQUIRES "stb_truetype.h" for ttf handling
			This library then REQUIRES "stb_rect_pack.h"

			NOTE(bill): I may remove these dependencies for the font handling by
			embedding the needed types and procedures.

	Optional Dependencies
		"gb_math.h" as a lot of useful things in it over <math.h>.
		Why not have a look at it?

	Optional Defines
		GBGL_NO_FONTS       - Do no use font subsystem
		GBGL_NO_BASIC_STATE - Do no use basic state subsystem

	Steps for supporting dynamic reload:
		You _MUST_ defined you own malloc and free that use whatever
		permanent memory systen you are using:

			#define gbgl_malloc
			#define gbgl_free


===========================================================================

Conventions used:
	gbglTypesAreLikeThis (None core types)
	gbgl_functions_and_variables_like_this
	Prefer // Comments
	Never use _t suffix for types (I think they are stupid...)


Version History:
	0.06  - Enum convention change
	0.05  - gbglColour
	0.04e - Change brace style because why not?
	0.04d - Use new gb.h file handling system
	0.04c - Use new gb.h file handling system
	0.04b - Work with the new gb.h
	0.04a - Better Documentation
	0.04  - Remove gb_math.h dependency
	0.03a - Better Rounded Rect
	0.03  - Basic State Rendering
	0.02  - Font Caching and Rendering
	0.01  - Initial Version

LICENSE
	This software is dual-licensed to the public domain and under the following
	license: you are granted a perpetual, irrevocable license to copy, modify,
	publish, and distribute this file as you see fit.

WARNING
	- This library is _highly_ experimental and features may not work as expected.
	- This also means that many functions are not documented.

CREDITS
	Written by Ginger Bill

*/

#ifndef GBGL_INCLUDE_GB_GL_H
#define GBGL_INCLUDE_GB_GL_H

#ifndef GB_IMPLEMENTATION
#include "gb.h"
#endif

#ifndef STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#endif


#if !defined(GBGL_NO_FONTS)
	#ifndef STB_RECT_PACK_IMPLEMENTATION
	#include "stb_rect_pack.h"
	#endif

	#ifndef STB_TRUETYPE_IMPLEMENTATION
	#include "stb_truetype.h"
	#endif
#endif


#if defined(GBGL_USE_GB_MATH)
	#ifndef GB_MATH_IMPLEMENTATION
	#include "gb_math.h"
	#endif

	#define gbgl_lerp(x, y, t) gb_lerp(x, y, t)
	#define gbgl_sin(x)        gb_sin(x)
	#define gbgl_cos(x)        gb_cos(x)
	#define gbgl_abs(x)        gb_abs(x)
	#define gbgl_min(x, y)     gb_min(x, y)
	#define gbgl_max(x, y)     gb_max(x, y)
	#define gbgl_round(x)      gb_round(x)

#else
	#if !defined(GBGL_USE_CUSTOM_MATH)
	#include <math.h>

	#define gbgl_lerp(x, y, t) ((x)*(1.0f-(t)) + (y)*(t))
	#define gbgl_sin(x)        sinf(x)
	#define gbgl_cos(x)        cosf(x)
	#define gbgl_abs(x)        ((x) >= 0 ? (x) : -(x))
	#define gbgl_min(x, y)     ((x) < (y) ? (x) : (y))
	#define gbgl_max(x, y)     ((x) > (y) ? (x) : (y))
	#define gbgl_round(x)      (((x) >= 0.0f) ? floorf((x) + 0.5f) : ceilf((x) - 0.5f))

	#endif
#endif

#define gbgl_clamp(x, lower, upper) gbgl_min(gbgl_max((x), (lower)), (upper))
#define gbgl_clamp01(x) gbgl_clamp(x, 0, 1)


#if defined(__cplusplus)
extern "C" {
#endif


#ifndef GBGL_DEF
#define GBGL_DEF extern
#endif

#ifndef gbgl_malloc
#define gbgl_malloc(sz) malloc(sz)
#endif

#ifndef gbgl_free
#define gbgl_free(ptr) free(ptr)
#endif

#ifndef GBGL_TAU
#define GBGL_TAU 6.28318530717958647692528676655900576f
#endif



////////////////////////////////////////////////////////////////
//
// Colour Type
// It's quite useful
// TODO(bill): Does this need to be in this library?
//             Can I remove the anonymous struct extension?
//

#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4201)
#endif

typedef union gbglColour {
	u32    rgba; // NOTE(bill): 0xaabbggrr in little endian
	struct { u8 r, g, b, a; };
	u8     e[4];
} gbglColour;
GB_STATIC_ASSERT(gb_size_of(gbglColour) == gb_size_of(u32));

#if defined(_MSC_VER)
#pragma warning(pop)
#endif


GB_DEF gbglColour gbgl_colour(f32 r, f32 g, f32 b, f32 a);

gb_global gbglColour const gbglColour_White   = {0xffffffff};
gb_global gbglColour const gbglColour_Grey    = {0xff808080};
gb_global gbglColour const gbglColour_Black   = {0xff000000};

gb_global gbglColour const gbglColour_Red     = {0xff0000ff};
gb_global gbglColour const gbglColour_Orange  = {0xff0099ff};
gb_global gbglColour const gbglColour_Yellow  = {0xff00ffff};
gb_global gbglColour const gbglColour_Green   = {0xff00ff00};
gb_global gbglColour const gbglColour_Cyan    = {0xffffff00};
gb_global gbglColour const gbglColour_Blue    = {0xffff0000};
gb_global gbglColour const gbglColour_Violet  = {0xffff007f};
gb_global gbglColour const gbglColour_Magenta = {0xffff00ff};


////////////////////////////////////////////////////////////////
//
// Generic Stuff
//
//


#ifndef GBGL_VERT_PTR_AA_GENERIC
#define GBGL_VERT_PTR_AA_GENERIC
// NOTE(bill) The "default" is just the f32 version
#define gbgl_vert_ptr_aa(index, element_count, Type, var_name) \
    gbgl_vert_ptr_aa_f32(index, element_count, Type, var_name)

#define gbgl_vert_ptr_aa_f32(index, element_count, Type, var_name) do {  \
	glVertexAttribPointer(index,                                         \
	                      element_count,                                 \
	                      GL_FLOAT,                                      \
	                      false,                                         \
	                      gb_size_of(Type),                              \
	                      (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                    \
} while (0)

#define gbgl_vert_ptr_aa_u8(index, element_count, Type, var_name) do {   \
	glVertexAttribPointer(index,                                         \
	                      element_count,                                 \
	                      GL_UNSIGNED_BYTE,                              \
	                      false,                                         \
	                      gb_size_of(Type),                              \
	                      (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                    \
} while (0)

#define gbgl_vert_ptr_aa_u8n(index, element_count, Type, var_name) do {  \
	glVertexAttribPointer(index,                                         \
	                      element_count,                                 \
	                      GL_UNSIGNED_BYTE,                              \
	                      true,                                          \
	                      gb_size_of(Type),                              \
	                      (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                    \
} while (0)

#define gbgl_vert_ptr_aa_u32(index, element_count, Type, var_name) do {   \
	glVertexAttribIPointer(index,                                         \
	                       element_count,                                 \
	                       GL_UNSIGNED_INT,                               \
	                       gb_size_of(Type),                              \
	                       (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                     \
} while (0)

#define gbgl_vert_ptr_aa_u16(index, element_count, Type, var_name) do {   \
	glVertexAttribIPointer(index,                                         \
	                       element_count,                                 \
	                       GL_UNSIGNED_SHORT,                             \
	                       gb_size_of(Type),                              \
	                       (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                     \
} while (0)

#define gbgl_vert_ptr_aa_u16n(index, element_count, Type, var_name) do { \
	glVertexAttribPointer(index,                                         \
	                      element_count,                                 \
	                      GL_UNSIGNED_SHORT,                             \
	                      true,                                          \
	                      gb_size_of(Type),                              \
	                      (void const *)(gb_offset_of(Type, var_name))); \
	glEnableVertexAttribArray(index);                                    \
} while (0)

#endif


GBGL_DEF u32 gbgl_make_sampler(u32 min_filter, u32 max_filter, u32 s_wrap, u32 t_wrap);




////////////////////////////////////////////////////////////////
//
// Data Buffers
//
//


typedef enum gbglBufferDataType {
	gbglBufferData_u8 = GL_UNSIGNED_BYTE,
	gbglBufferData_i8 = GL_BYTE,

	gbglBufferData_u16 = GL_UNSIGNED_SHORT,
	gbglBufferData_i16 = GL_SHORT,
	gbglBufferData_f16 = GL_HALF_FLOAT,

	gbglBufferData_u32 = GL_UNSIGNED_INT,
	gbglBufferData_i32 = GL_INT,
	gbglBufferData_f32 = GL_FLOAT,

	gbglBufferData_f8, // NOTE(bill): This is not a "real" OpenGL type but it is needed for internal format enums
} gbglBufferDataType;


// NOTE(bill) index+1 = channels count
#if defined(GBGL_USE_SRGB_TEXTURE_FORMAT)
i32 const gbglTextureFormat[4] = { GL_RED, GL_RG, GL_SRGB8, GL_SRGB8_ALPHA8 };
#else
i32 const gbglTextureFormat[4] = { GL_RED, GL_RG, GL_RGB, GL_RGBA };
#endif

i32 const gbglInternalTextureFormat_8[4]  = { GL_R8,   GL_RG8,   GL_RGB8,	  GL_RGBA8   };
i32 const gbglInternalTextureFormat_16[4] = { GL_R16,  GL_RG16,  GL_RGB16,  GL_RGBA16  };
i32 const gbglInternalTextureFormat_32[4] = { GL_R32F, GL_RG32F, GL_RGB32F, GL_RGBA32F };

i32 const gbglInternalTextureFormat_u8[4] = { GL_R8UI, GL_RG8UI, GL_RGB8UI, GL_RGB8UI };
i32 const gbglInternalTextureFormat_i8[4] = { GL_R8I,  GL_RG8I,  GL_RGB8I,  GL_RGB8I  };
i32 const gbglInternalTextureFormat_f8[4] = { GL_R8,   GL_RG8,   GL_RGB8,   GL_RGB8   };

i32 const gbglInternalTextureFormat_u16[4] = { GL_R16UI, GL_RG16UI, GL_RGB16UI, GL_RGB16UI };
i32 const gbglInternalTextureFormat_i16[4] = { GL_R16I,  GL_RG16I,  GL_RGB16I,  GL_RGB16I  };
i32 const gbglInternalTextureFormat_f16[4] = { GL_R16F,  GL_RG16F,  GL_RGB16F,  GL_RGB16F  };

i32 const gbglInternalTextureFormat_u32[4] = { GL_R32UI, GL_RG32UI, GL_RGB32UI, GL_RGBA32UI };
i32 const gbglInternalTextureFormat_i32[4] = { GL_R32I,  GL_RG32I,  GL_RGB32I,  GL_RGBA32I  };
i32 const gbglInternalTextureFormat_f32[4] = { GL_R32F,  GL_RG32F,  GL_RGB32F,  GL_RGBA32F  };

gb_inline i32 gbgl_texture_format(gbglBufferDataType data_type, i32 channel_count) {
	GB_ASSERT(gb_is_between(channel_count, 1, 4));
	switch (data_type) {
	case gbglBufferData_u8:  return gbglInternalTextureFormat_u8[channel_count-1];
	case gbglBufferData_i8:  return gbglInternalTextureFormat_i8[channel_count-1];
	case gbglBufferData_f8:  return gbglInternalTextureFormat_f8[channel_count-1];
	case gbglBufferData_u16: return gbglInternalTextureFormat_u16[channel_count-1];
	case gbglBufferData_i16: return gbglInternalTextureFormat_i16[channel_count-1];
	case gbglBufferData_f16: return gbglInternalTextureFormat_f16[channel_count-1];
	case gbglBufferData_u32: return gbglInternalTextureFormat_u32[channel_count-1];
	case gbglBufferData_i32: return gbglInternalTextureFormat_i32[channel_count-1];
	case gbglBufferData_f32: return gbglInternalTextureFormat_f32[channel_count-1];
	}
	return gbglInternalTextureFormat_f32[4-1];
}

typedef struct gbglTBO {
	u32 buffer_obj_handle;
	u32 buffer_handle;
} gbglTBO;

// NOTE(bill): usage_hint == (GL_STATIC_DRAW, GL_STREAM_DRAW, GL_DYNAMIC_DRAW)
GBGL_DEF u32     gbgl_make_vbo(void const *data, isize size, i32 usage_hint);
GBGL_DEF u32     gbgl_make_ebo(void const *data, isize size, i32 usage_hint);
GBGL_DEF gbglTBO gbgl_make_tbo(gbglBufferDataType data_type, i32 channel_count, void const *data, isize size, i32 usage_hint);

GBGL_DEF void gbgl_vbo_copy(u32 vbo_handle, void *const data, isize size, isize offset);
GBGL_DEF void gbgl_ebo_copy(u32 ebo_handle, void *const data, isize size, isize offset);
GBGL_DEF void gbgl_tbo_copy(gbglTBO tbo,    void *const data, isize size, isize offset);



GBGL_DEF void gbgl_bind_vbo(u32 vbo_handle);
GBGL_DEF void gbgl_bind_ebo(u32 ebo_handle);
GBGL_DEF void gbgl_bind_tbo(gbglTBO tbo, i32 sampler_handle, i32 tex_unit);

// NOTE(bill): access = GL_WRITE_ONLY, etc.
GBGL_DEF void *gbgl_map_vbo(u32 vbo_handle, i32 access);
GBGL_DEF void *gbgl_map_ebo(u32 ebo_handle, i32 access);
GBGL_DEF void gbgl_unmap_vbo(void);
GBGL_DEF void gbgl_unmap_ebo(void);



////////////////////////////////////////////////////////////////
//
// Shader
//
//

typedef enum gbglShaderType {
	gbglShader_Vertex,
	gbglShader_Fragment,
	gbglShader_Geometry,

	gbglShader_Count,
} gbglShaderType;

i32 const gbglShaderMap[gbglShader_Count] = {
	GL_VERTEX_SHADER,   /* gbglShader_Vertex   */
	GL_FRAGMENT_SHADER, /* gbglShader_Fragment */
	GL_GEOMETRY_SHADER, /* gbglShader_Geometry */
};

typedef enum gbglShaderError {
	gbglShaderError_None,
	gbglShaderError_ShaderCompile,
	gbglShaderError_Linking,
	gbglShaderError_UnableToReadFile,

	gbglShaderError_Count,
} gbglShaderError;

#ifndef GBGL_MAX_UNIFORM_COUNT
#define GBGL_MAX_UNIFORM_COUNT 32
#endif

typedef struct gbglShader {
	u32 shaders[gbglShader_Count];
	u32 program;

	i32   uniform_locs[GBGL_MAX_UNIFORM_COUNT];
	char *uniform_names[GBGL_MAX_UNIFORM_COUNT];
	i32   uniform_count;

	u32   type_flags;

	gbFile files[gbglShader_Count];

	char base_name[64];
} gbglShader;



#ifndef GBGL_SHADER_FILE_EXTENSIONS_DEFINED
#define GBGL_SHADER_FILE_EXTENSIONS_DEFINED
gb_global char const *gbglShaderFileExtensions[gbglShader_Count] = {".vs", ".fs", ".gs"};
#endif


GBGL_DEF gbglShaderError gbgl_load_shader_from_file      (gbglShader *s, u32 type_bits, char const *filename);
GBGL_DEF gbglShaderError gbgl_load_shader_from_memory_vf (gbglShader *s, char const *vert_source, char const *frag_source);
GBGL_DEF gbglShaderError gbgl_load_shader_from_memory_vfg(gbglShader *s, char const *vert_source, char const *frag_source, char const *geom_source);

GBGL_DEF void gbgl_destroy_shader    (gbglShader *shader);
GBGL_DEF b32  gbgl_has_shader_changed(gbglShader *shader);
GBGL_DEF b32  gbgl_reload_shader     (gbglShader *shader); // TODO(bill): Return an error code?
GBGL_DEF void gbgl_use_shader        (gbglShader *shader);
GBGL_DEF b32  gbgl_is_shader_in_use  (gbglShader *shader);

GBGL_DEF i32 gbgl_get_uniform(gbglShader *shader, char const *name);

GBGL_DEF void gbgl_set_uniform_int       (gbglShader *s, char const *name, i32 i);
GBGL_DEF void gbgl_set_uniform_float     (gbglShader *s, char const *name, f32 f);
GBGL_DEF void gbgl_set_uniform_vec2      (gbglShader *s, char const *name, f32 const *v);
GBGL_DEF void gbgl_set_uniform_vec3      (gbglShader *s, char const *name, f32 const *v);
GBGL_DEF void gbgl_set_uniform_vec4      (gbglShader *s, char const *name, f32 const *v);
GBGL_DEF void gbgl_set_uniform_mat4      (gbglShader *s, char const *name, f32 const *m);
GBGL_DEF void gbgl_set_uniform_mat4_count(gbglShader *s, char const *name, f32 const *m, isize count);
GBGL_DEF void gbgl_set_uniform_colour    (gbglShader *s, char const *name, gbglColour col);


////////////////////////////////////////////////////////////////
//
// Texture
//
//

typedef enum gbglTextureType {
	gbglgTexture_2D,
	gbglgTexture_CubeMap,

	gbglgTexture_Count,
} gbglTextureType;

gb_global i32 const GBGL_TEXTURE_TYPE[gbglgTexture_Count] = {
	GL_TEXTURE_2D,       /* gbglgTexture_2D */
	GL_TEXTURE_CUBE_MAP, /* gbglgTexture_CubeMap */
};


typedef struct gbglTexture {
	i32 width, height, channel_count;
	gbglBufferDataType data_type;
	gbglTextureType type;
	u32 handle;
} gbglTexture;

GBGL_DEF b32  gbgl_load_texture2d_from_file  (gbglTexture *texture, b32 flip_vertically, char const *filename, ...);
GBGL_DEF b32  gbgl_load_texture2d_from_memory(gbglTexture *texture, void const *data, i32 width, i32 height, i32 channel_count);
GBGL_DEF b32  gbgl_init_texture2d_coloured   (gbglTexture *texture, gbglColour colour);
GBGL_DEF void gbgl_destroy_texture           (gbglTexture *texture);

GBGL_DEF void gbgl_bind_texture2d(gbglTexture const *texture, u32 position, u32 sampler);





////////////////////////////////////////////////////////////////
//
// Render Buffer
//
//

// TODO(bill): Record depth and stencil and numerous colour attachments

typedef struct gbglRenderBuffer {
	i32 width, height;
	i32 channel_count;
	u32 handle;

	gbglTexture colour_texture;
} gbglRenderBuffer;

#define GBGL_MAX_RENDER_COLOUR_BUFFERS 16
gb_global u32 const gbglColourBufferAttachments[GBGL_MAX_RENDER_COLOUR_BUFFERS] = {
	GL_COLOR_ATTACHMENT0,
	GL_COLOR_ATTACHMENT1,
	GL_COLOR_ATTACHMENT2,
	GL_COLOR_ATTACHMENT3,
	GL_COLOR_ATTACHMENT4,
	GL_COLOR_ATTACHMENT5,
	GL_COLOR_ATTACHMENT6,
	GL_COLOR_ATTACHMENT7,
	GL_COLOR_ATTACHMENT8,
	GL_COLOR_ATTACHMENT9,
	GL_COLOR_ATTACHMENT10,
	GL_COLOR_ATTACHMENT11,
	GL_COLOR_ATTACHMENT12,
	GL_COLOR_ATTACHMENT13,
	GL_COLOR_ATTACHMENT14,
	GL_COLOR_ATTACHMENT15,
};


GBGL_DEF b32  gbgl_init_render_buffer   (gbglRenderBuffer *rb, i32 width, i32 height, i32 channel_count);
GBGL_DEF void gbgl_destroy_render_buffer(gbglRenderBuffer *rb);
GBGL_DEF void gbgl_render_to_buffer(gbglRenderBuffer const *rb);
GBGL_DEF void gbgl_render_to_screen(i32 width, i32 height);


////////////////////////////////////////////////////////////////
//
// Font Stuff
//
//

#if !defined(GBGL_NO_FONTS)

typedef struct gbglGlyphMapKVPair {
	char32 codepoint;
	u16    index;
} gbglGlyphMapKVPair;

typedef struct gbglGlyphInfo {
	f32 s0, t0, s1, t1;
	i16 xoff, yoff;
	f32 xadv;
} gbglGlyphInfo;

typedef struct gbglKernPair {
	union {
		i32 packed;
		struct { u16 i0, i1; };
	};
	f32 kern;
} gbglKernPair;

typedef enum gbglJustifyType {
	gbglJustify_Left,
	gbglJustify_Centre,
	gbglJustify_Right,
} gbglJustifyType;

typedef enum gbglTextParamType {
	gbglTextParam_Invalid,
	gbglTextParam_MaxWidth,
	gbglTextParam_Justify,
	gbglTextParam_TextureFilter,

	gbglTextParam_Count,
} gbglTextParamType;

typedef struct gbglTextParam {
	gbglTextParamType type;
	union {
		f32 val_f32;
		i32 val_i32;
	};
} gbglTextParam;

typedef struct gbglFont {
	isize glyph_count;
	isize kern_pair_count;
	i32 bitmap_width, bitmap_height;
	f32 size;
	i32 ascent, descent, line_gap;
	char *ttf_filename;
	gbglTexture texture;

	gbglGlyphMapKVPair *glyph_map;
	gbglGlyphInfo *     glyphs;
	gbglKernPair *      kern_table;

	struct gbglFont *next; // NOTE(bill): Allow as linked list
} gbglFont;

typedef struct gbglFontCachedTTF {
	char *                    name;
	u8 *                      ttf;
	stbtt_fontinfo            finfo;
	struct gbglFontCachedTTF *next;
} gbglFontCachedTTF;

typedef struct gbglFontCache {
	isize font_char_list_count;
	char *font_char_list;

	isize   codepoint_count;
	char32 *codepoints;

	stbtt_pack_range *ranges;
	stbtt_packedchar *packed_char_data;
	stbrp_rect *      rect_cache;

	gbglFontCachedTTF *ttf_buffer;
	gbglFont *         fonts;
} gbglFontCache;


#if 0
GBGL_DEF void gbgl_destroy_font_cache(gbglFontCache *fc);
#endif

// NOTE(bill): gbgl_load_font_from_file will load from file if it is not found
GBGL_DEF gbglFont *gbgl_load_font_from_file     (gbglFontCache *fc, char const *ttf_filename, f32 font_size);
GBGL_DEF gbglFont *gbgl_get_font_only_from_cache(gbglFontCache *fc, char const *ttf_filename, f32 font_size);
GBGL_DEF gbglFont *gbgl_cache_font              (gbglFontCache *fc, char const *ttf_filename, f32 font_size);


GBGL_DEF b32            gbgl_get_packed_font_dim                (gbglFontCache *cache, gbglFontCachedTTF *ttf, i32 *width, i32 *height);
GBGL_DEF gbglGlyphInfo *gbgl_get_glyph_info                     (gbglFont *font, char32 codepoint, isize *out_index);
GBGL_DEF f32            gbgl_get_font_kerning_from_glyph_indices(gbglFont *font, isize left_index, isize right_index);
GBGL_DEF void           gbgl_get_string_dimensions              (gbglFont *font, char const *str, f32 *out_width, f32 *out_height);
GBGL_DEF f32            gbgl_get_sub_string_width               (gbglFont *font, char const *str, isize char_count);
GBGL_DEF i32            gbgl_get_wrapped_line_count             (gbglFont *font, char const *str, isize max_len, isize max_width);
GBGL_DEF f32            gbgl_get_string_width                   (gbglFont *font, char const *str, isize max_len);


#endif

////////////////////////////////////////////////////////////////
//
// Basic State
//
//

#if !defined(GBGL_NO_BASIC_STATE)

#ifndef GBGL_BS_MAX_VERTEX_COUNT
#define GBGL_BS_MAX_VERTEX_COUNT 32
#endif

#ifndef GBGL_BS_MAX_INDEX_COUNT
#define GBGL_BS_MAX_INDEX_COUNT 6
#endif


#if !defined(GBGL_NO_FONTS)

#ifndef GBGL_MAX_RENDER_STRING_LENGTH
#define GBGL_MAX_RENDER_STRING_LENGTH 4096
#endif

#ifndef gbglTextParam_Stack_size
#define gbglTextParam_Stack_size 128
#endif

#ifndef GBGL_FONT_CHAR_LIST
#define GBGL_FONT_CHAR_LIST \
	"Āā㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľŁł"\
	"ŃńŅņņŇňʼnŊŋŌōōŎŏŐőŒœŕŖŗŘřŚśŜŝŞşŠšŢţŤťŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽža!ö"\
	"\"#$%%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"\
	"ŠšŒœŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõøùúûüýþÿ®™£"\
	" \t\r\n"
#endif

#ifndef GBGL_PT_TO_PX_SCALE
#define GBGL_PT_TO_PX_SCALE (96.0f / 72.0f)
#endif

#ifndef GBGL_TAB_CHARACTER_WIDTH
#define GBGL_TAB_CHARACTER_WIDTH 4
#endif

#endif

typedef struct gbglBasicVertex {
	f32 x, y;
	f32 u, v;
} gbglBasicVertex;

typedef struct gbglBasicState {
	gbglBasicVertex vertices[GBGL_BS_MAX_VERTEX_COUNT];
	u16 indices[GBGL_BS_MAX_INDEX_COUNT];

	u32 vao, vbo, ebo;
	u32 nearest_sampler;
	u32 linear_sampler;
	gbglShader ortho_tex_shader;
	gbglShader ortho_col_shader;

	f32 ortho_mat[16];
	i32 width, height;

#if !defined(GBGL_NO_FONTS)
	gbglFontCache   font_cache;
	gbglShader      font_shader;
	gbglBasicVertex font_vertices[GBGL_MAX_RENDER_STRING_LENGTH * 4];
	u16             font_indices[GBGL_MAX_RENDER_STRING_LENGTH * 6];
	u32             font_vao, font_vbo, font_ebo;
	char            font_text_buffer[GBGL_MAX_RENDER_STRING_LENGTH * 4]; // NOTE(bill): Maximum of 4 bytes per char for utf-8
	u32             font_samplers[2];

	gbglTextParam text_param_stack[gbglTextParam_Stack_size];
	isize         text_param_stack_count;
	gbglTextParam text_params[gbglTextParam_Count];
#endif
} gbglBasicState;

GBGL_DEF void gbgl_bs_init(gbglBasicState *bs, i32 window_width, i32 window_height);
GBGL_DEF void gbgl_bs_set_resolution(gbglBasicState *bs, i32 window_width, i32 window_height);
GBGL_DEF void gbgl_bs_begin(gbglBasicState *bs, i32 window_width, i32 window_height);
GBGL_DEF void gbgl_bs_end(gbglBasicState *bs);

GBGL_DEF void gbgl_bs_draw_textured_rect(gbglBasicState *bs, gbglTexture *tex, f32 x, f32 y, f32 w, f32 h, b32 v_up);
GBGL_DEF void gbgl_bs_draw_rect(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, gbglColour col);
GBGL_DEF void gbgl_bs_draw_rect_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, gbglColour col, f32 thickness);
GBGL_DEF void gbgl_bs_draw_quad(gbglBasicState *bs,
                                f32 x0, f32 y0,
                                f32 x1, f32 y1,
                                f32 x2, f32 y2,
                                f32 x3, f32 y3,
                                gbglColour col);
GBGL_DEF void gbgl_bs_draw_quad_outline(gbglBasicState *bs,
                                        f32 x0, f32 y0,
                                        f32 x1, f32 y1,
                                        f32 x2, f32 y2,
                                        f32 x3, f32 y3,
                                        gbglColour col, f32 thickness);

GBGL_DEF void gbgl_bs_draw_line(gbglBasicState *bs, f32 x0, f32 y0, f32 x1, f32 y1, gbglColour col, f32 thickness);

GBGL_DEF void gbgl_bs_draw_elliptical_arc(gbglBasicState *bs, f32 x, f32 y, f32 radius_a, f32 radius_b, f32 min_angle, f32 max_angle, gbglColour col);
GBGL_DEF void gbgl_bs_draw_elliptical_arc_outline(gbglBasicState *bs, f32 x, f32 y, f32 radius_a, f32 radius_b,
                                                  f32 min_angle, f32 max_angle, gbglColour col, f32 thickness);

GBGL_DEF void gbgl_bs_draw_circle(gbglBasicState *bs, f32 x, f32 y, f32 radius, gbglColour col);
GBGL_DEF void gbgl_bs_draw_circle_outline(gbglBasicState *bs, f32 x, f32 y, f32 radius, gbglColour col, f32 thickness);


// Corners Flags:
// 1 - Bottom Left
// 2 - Bottom Right
// 4 - Top    Right
// 8 - Top    Left
// NOTE(bill): Apple, please don't sue me!
GBGL_DEF void gbgl_bs_draw_rounded_rect_corners(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, u32 corners);
GBGL_DEF void gbgl_bs_draw_rounded_rect(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col);

GBGL_DEF void gbgl_bs_draw_rounded_rect_corners_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, f32 thickness, u32 corners);
GBGL_DEF void gbgl_bs_draw_rounded_rect_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, f32 thickness);


#if !defined(GBGL_NO_FONTS)
GBGL_DEF isize gbgl_bs_draw_substring(gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *str, isize len);
GBGL_DEF isize gbgl_bs_draw_string   (gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *fmt, ...);
GBGL_DEF isize gbgl_bs_draw_string_va(gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *fmt, va_list va);
#endif


#endif

#if defined(__cplusplus)
}
#endif

#endif

////////////////////////////////////////////////////////////////
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                        Implementation                      //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
//                                                            //
////////////////////////////////////////////////////////////////


#if defined(GBGL_IMPLEMENTATION)

gb_inline gbglColour gbgl_colour(f32 r, f32 g, f32 b, f32 a) {
	gbglColour result;
	result.r = cast(u8)(gbgl_clamp01(r) * 255.0f);
	result.g = cast(u8)(gbgl_clamp01(g) * 255.0f);
	result.b = cast(u8)(gbgl_clamp01(b) * 255.0f);
	result.a = cast(u8)(gbgl_clamp01(a) * 255.0f);
	return result;
}


u32 gbgl_make_sampler(u32 min_filter, u32 max_filter, u32 s_wrap, u32 t_wrap) {
	u32 samp;
	glGenSamplers(1, &samp);
	glSamplerParameteri(samp, GL_TEXTURE_MIN_FILTER, min_filter);
	glSamplerParameteri(samp, GL_TEXTURE_MAG_FILTER, max_filter);
	glSamplerParameteri(samp, GL_TEXTURE_WRAP_S,     s_wrap);
	glSamplerParameteri(samp, GL_TEXTURE_WRAP_T,     t_wrap);
	return samp;
}


////////////////////////////////////////////////////////////////
//
// Data Buffers
//
//

gb_inline u32 gbgl__make_buffer(isize size, void const *data, i32 target, i32 usage_hint) {
	u32 buffer_handle;
	glGenBuffers(1, &buffer_handle);
	glBindBuffer(target, buffer_handle);
	glBufferData(target, size, data, usage_hint);
	return buffer_handle;
}

gb_inline void gbgl__buffer_copy(u32 buffer_handle, i32 target, void const *data, isize size, isize offset) {
	glBindBuffer(target, buffer_handle);
	glBufferSubData(target, offset, size, data);
}

// NOTE(bill): usage_hint == (GL_STATIC_DRAW, GL_STREAM_DRAW, GL_DYNAMIC_DRAW)
gb_inline u32 gbgl_make_vbo(void const *data, isize size, i32 usage_hint) {
	return gbgl__make_buffer(size, data, GL_ARRAY_BUFFER, usage_hint);
}

gb_inline u32 gbgl_make_ebo(void const *data, isize size, i32 usage_hint) {
	return gbgl__make_buffer(size, data, GL_ELEMENT_ARRAY_BUFFER, usage_hint);
}

gb_inline gbglTBO gbgl_make_tbo(gbglBufferDataType data_type, i32 channel_count, void const *data, isize size, i32 usage_hint) {
	gbglTBO tbo;
	i32 internal_format;

	tbo.buffer_obj_handle = gbgl__make_buffer(size, data, GL_TEXTURE_BUFFER, usage_hint);

	glGenTextures(1, &tbo.buffer_handle);
	glBindTexture(GL_TEXTURE_BUFFER, tbo.buffer_handle);
	internal_format = gbgl_texture_format(data_type, channel_count);
	glTexBuffer(GL_TEXTURE_BUFFER, internal_format, tbo.buffer_obj_handle);
	return tbo;
}

gb_inline void gbgl_vbo_copy(u32 vbo_handle, void *const data, isize size, isize offset) {
	gbgl__buffer_copy(vbo_handle, GL_ARRAY_BUFFER, data, size, offset);
}

gb_inline void gbgl_ebo_copy(u32 ebo_handle, void *const data, isize size, isize offset) {
	gbgl__buffer_copy(ebo_handle, GL_ELEMENT_ARRAY_BUFFER, data, size, offset);
}

gb_inline void gbgl_tbo_copy(gbglTBO tbo, void *const data, isize size, isize offset) {
	gbgl__buffer_copy(tbo.buffer_obj_handle, GL_TEXTURE_BUFFER, data, size, offset);
}

gb_inline void gbgl_bind_vbo(u32 vbo_handle) { glBindBuffer(GL_ARRAY_BUFFER, vbo_handle); }
gb_inline void gbgl_bind_ebo(u32 ebo_handle) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo_handle); }

gb_inline void gbgl_bind_tbo(gbglTBO tbo, i32 sampler_handle, i32 tex_unit) {
	glActiveTexture(GL_TEXTURE0 + tex_unit);
	glBindTexture(GL_TEXTURE_BUFFER, tbo.buffer_handle);
	glBindSampler(0, sampler_handle);
}

// NOTE(bill): access = GL_WRITE_ONLY, etc.
gb_inline void * gbgl_map_vbo(u32 vbo_handle, i32 access) {
	gbgl_bind_vbo(vbo_handle);
	return glMapBuffer(GL_ARRAY_BUFFER, access);
}

gb_inline void * gbgl_map_ebo(u32 ebo_handle, i32 access) {
	gbgl_bind_ebo(ebo_handle);
	return glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, access);
}

gb_inline void gbgl_unmap_vbo(void) { glUnmapBuffer(GL_ARRAY_BUFFER); }
gb_inline void gbgl_unmap_ebo(void) { glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); }



////////////////////////////////////////////////////////////////
//
// Shader
//
//


gbglShaderError gbgl__load_single_shader_from_file(gbglShader *shader, gbglShaderType type, char const *name) {
	gbglShaderError err = gbglShaderError_None;
	gbFileError ferr;
	gb_local_persist char filepath[1024];
	gb_snprintf(filepath, gb_count_of(filepath), "%s%s", name, gbglShaderFileExtensions[type]);
	ferr = gb_file_open(&shader->files[type], filepath);

	if (ferr != gbFileError_None) {
		err = gbglShaderError_UnableToReadFile;
	} else {
		gb_local_persist char info_log[4096];
		i64 file_size = gb_file_size(&shader->files[type]);
		char *file_source = cast(char *)gbgl_malloc(file_size+1);

		GB_ASSERT_NOT_NULL(file_source);
		if (file_source) {
			i32 params;

			gb_file_read_at(&shader->files[type], file_source, file_size, 0);
			file_source[file_size] = '\0';

			shader->shaders[type] = glCreateShader(gbglShaderMap[type]);
			glShaderSource(shader->shaders[type], 1, &file_source, NULL);
			glCompileShader(shader->shaders[type]);
			glGetShaderiv(shader->shaders[type], GL_COMPILE_STATUS, &params);
			if (!params) {
				gb_printf_err("Shader Source:\n%s\n", file_source);
				glGetShaderInfoLog(shader->shaders[type], gb_size_of(info_log), NULL, info_log);
				gb_printf_err("Shader compilation failed:\n %s\n", info_log);

				err = gbglShaderError_ShaderCompile;
			}

			gbgl_free(file_source);
		}
		gb_file_close(&shader->files[type]);
	}

	return err;
}

gbglShaderError gbgl__load_single_shader_from_memory(gbglShader *s, gbglShaderType type, char const *text) {
	gbglShaderError err = gbglShaderError_None;
	i32 status;

	s->shaders[type] = glCreateShader(gbglShaderMap[type]);
	glShaderSource(s->shaders[type], 1, &text, 0);
	glCompileShader(s->shaders[type]);

	glGetShaderiv(s->shaders[type], GL_COMPILE_STATUS, &status);
	if (!status) {
		gb_local_persist char log_info[4096];
		i32 total_len, log_len;

		gb_printf_err("Unable to compile shader: %s\n", text);
		glGetShaderiv(s->shaders[type], GL_INFO_LOG_LENGTH, &status);
		total_len = status;

		glGetShaderInfoLog(s->shaders[type], 4095, &log_len, log_info);
		gb_printf_err(log_info);
		err = gbglShaderError_ShaderCompile;
	}

	return err;
}

gbglShaderError gbgl__link_shader(gbglShader *shader) {
	gbglShaderError err = gbglShaderError_None;
	i32 i, status;
	shader->program = glCreateProgram();
	for (i = 0; i < gbglShader_Count; i++) {
		if (shader->type_flags & GB_BIT(i))
			glAttachShader(shader->program, shader->shaders[i]);
	}

	glLinkProgram(shader->program);

	glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
	if (!status) {
		gb_local_persist char log_info[4096];
		glGetProgramInfoLog(shader->program, gb_size_of(log_info), NULL, log_info);
		gb_printf_err("Shader linking failed:\n %s \n", log_info);
		err = gbglShaderError_Linking;
	}

	for (i = 0; i < gbglShader_Count; i++) {
		if (shader->type_flags & GB_BIT(i))
			glDetachShader(shader->program, shader->shaders[i]);
	}

	return err;
}



gbglShaderError gbgl_load_shader_from_file(gbglShader *shader, u32 type_bits, char const *filename) {
	gbglShaderError err = gbglShaderError_None;
	b32 loaded_shader[gbglShader_Count] = {0};
	i32 i;

	gb_zero_item(shader);
	shader->type_flags = type_bits;
	gb_strncpy(shader->base_name, filename, gb_size_of(shader->base_name));

	for (i = 0; i < gbglShader_Count; i++) {
		if (type_bits & GB_BIT(i)) {
			err = gbgl__load_single_shader_from_file(shader, cast(gbglShaderType)i, filename);
			if (err != gbglShaderError_None)
				return err;
			loaded_shader[i] = true;
		}
	}
	err = gbgl__link_shader(shader);

	return err;
}




gbglShaderError gbgl_load_shader_from_memory_vf(gbglShader *s, char const *vert_source, char const *frag_source) {
	gbglShaderError err = gbglShaderError_None;

	gb_zero_item(s);
	s->type_flags = GB_BIT(gbglShader_Vertex) | GB_BIT(gbglShader_Fragment);

	err = gbgl__load_single_shader_from_memory(s, gbglShader_Vertex, vert_source);
	if (err != gbglShaderError_None) return err;
	err = gbgl__load_single_shader_from_memory(s, gbglShader_Fragment, frag_source);
	if (err != gbglShaderError_None) return err;

	err = gbgl__link_shader(s);

	return err;
}

gbglShaderError gbgl_load_shader_from_memory_vfg(gbglShader *s, char const *vert_source, char const *frag_source, char const *geom_source) {
	gbglShaderError err = gbglShaderError_None;

	gb_zero_item(s);
	s->type_flags = GB_BIT(gbglShader_Vertex) | GB_BIT(gbglShader_Fragment) | GB_BIT(gbglShader_Geometry);

	err = gbgl__load_single_shader_from_memory(s, gbglShader_Vertex, vert_source);
	if (err != gbglShaderError_None) return err;
	err = gbgl__load_single_shader_from_memory(s, gbglShader_Fragment, frag_source);
	if (err != gbglShaderError_None) return err;
	err = gbgl__load_single_shader_from_memory(s, gbglShader_Geometry, geom_source);
	if (err != gbglShaderError_None) return err;

	err = gbgl__link_shader(s);

	return err;
}

gb_inline void gbgl_destroy_shader(gbglShader *shader) {
	i32 i;
	for (i = 0; i < gbglShader_Count; i++) {
		if (shader->type_flags & GB_BIT(i)) {
			gb_file_close(&shader->files[i]);
			glDeleteShader(shader->shaders[i]);
		}
	}

	glDeleteProgram(shader->program);

	for (i = 0; i < shader->uniform_count; i++) {
		gbgl_free(shader->uniform_names[i]);
	}
}


gb_inline b32 gbgl_has_shader_changed(gbglShader *shader) {
	i32 i;
	for (i = 0; i < gbglShader_Count; i++) {
		if (shader->type_flags & GB_BIT(i)) {
			if (gb_file_has_changed(&shader->files[i])) {
				return true;
			}
		}
	}
	return false;
}


b32 gbgl_reload_shader(gbglShader *shader) {
	i32 i;
	for (i = 0; i < gbglShader_Count; i++) {
		if (shader->type_flags & GB_BIT(i)) {
			if (gbgl__load_single_shader_from_file(shader, cast(gbglShaderType)i, shader->base_name) != gbglShaderError_None)
				return false;
		}
	}

	if (gbgl__link_shader(shader) != gbglShaderError_None)
		return false;

	for (i = 0; i < shader->uniform_count; i++)
		shader->uniform_locs[i] = glGetUniformLocation(shader->program, shader->uniform_names[i]);


	return true;
}

gb_inline void gbgl_use_shader(gbglShader *s) { glUseProgram(s ? s->program : 0); }

gb_inline b32 gbgl_is_shader_in_use(gbglShader *s) {
	if (s) {
		i32 curr = 0;
		glGetIntegerv(GL_CURRENT_PROGRAM, &curr);
		return (curr == cast(i32)s->program);
	}
	return false;
}


i32 gbgl_get_uniform(gbglShader *s, char const *name) {
	i32 i, loc = -1;
	for (i = 0; i < s->uniform_count; i++) {
		if (gb_strcmp(s->uniform_names[i], name) == 0) {
			return s->uniform_locs[i];
		}
	}

	GB_ASSERT_MSG(s->uniform_count < GBGL_MAX_UNIFORM_COUNT,
	              "Uniform array for shader is full");

	loc = glGetUniformLocation(s->program, name);
	s->uniform_names[s->uniform_count] = gb_alloc_str(gb_heap_allocator(), name);
	s->uniform_locs[s->uniform_count] = loc;
	s->uniform_count++;

	return loc;
}



gb_inline void gbgl_set_uniform_int(gbglShader *s, char const *name, i32 i) {
	glUniform1i(gbgl_get_uniform(s, name), i);
}

gb_inline void gbgl_set_uniform_float(gbglShader *s, char const *name, f32 f) {
	glUniform1f(gbgl_get_uniform(s, name), f);
}

gb_inline void gbgl_set_uniform_vec2(gbglShader *s, char const *name, f32 const *v) {
	glUniform2fv(gbgl_get_uniform(s, name), 1, v);
}

gb_inline void gbgl_set_uniform_vec3(gbglShader *s, char const *name, f32 const *v) {
	glUniform3fv(gbgl_get_uniform(s, name), 1, v);
}

gb_inline void gbgl_set_uniform_vec4(gbglShader *s, char const *name, f32 const *v) {
	glUniform4fv(gbgl_get_uniform(s, name), 1, v);
}

gb_inline void gbgl_set_uniform_mat4(gbglShader *s, char const *name, f32 const *m) {
	gbgl_set_uniform_mat4_count(s, name, m, 1);
}

gb_inline void gbgl_set_uniform_mat4_count(gbglShader *s, char const *name, f32 const *m, isize count) {
	glUniformMatrix4fv(gbgl_get_uniform(s, name), count, false, m);
}


gb_inline void gbgl_set_uniform_colour(gbglShader *s, char const *name, gbglColour col) {
	f32 v[4];
	v[0] = col.r / 255.0f;
	v[1] = col.g / 255.0f;
	v[2] = col.b / 255.0f;
	v[3] = col.a / 255.0f;
	gbgl_set_uniform_vec4(s, name, v);
}



////////////////////////////////////////////////////////////////
//
// Render Buffer
//
//


b32 gbgl_init_render_buffer(gbglRenderBuffer *rb, i32 width, i32 height, i32 channel_count) {
	if ((rb->width == width) && (rb->height == height) && (rb->channel_count == channel_count)) return true;
	gbgl_destroy_render_buffer(rb);
	gb_zero_item(rb);

	rb->width = width;
	rb->height = height;

	glEnable(GL_FRAMEBUFFER_SRGB);

	glGenFramebuffers(1, &rb->handle);
	glBindFramebuffer(GL_FRAMEBUFFER, rb->handle);

	gbgl_load_texture2d_from_memory(&rb->colour_texture, NULL, width, height, channel_count);
	glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, rb->colour_texture.handle, 0);

	glBindTexture(GL_TEXTURE_2D, 0);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	{
		u32 draw_buffers[] = {GL_COLOR_ATTACHMENT0};
		glDrawBuffers(gb_count_of(draw_buffers), draw_buffers);
	}

	{
		u32 status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
		if (status != GL_FRAMEBUFFER_COMPLETE) {
			gb_printf_err("Framebuffer Status: 0x%x\n", status);
			return false;
		}
	}

	return true;
}

gb_inline void gbgl_destroy_render_buffer(gbglRenderBuffer *rb) {
	if (rb->handle)
		glDeleteFramebuffers(1, &rb->handle);

	gbgl_destroy_texture(&rb->colour_texture);
}


gb_inline void gbgl_render_to_buffer(gbglRenderBuffer const *rb) {
	GB_ASSERT_NOT_NULL(rb);
	glViewport(0, 0, rb->width, rb->height);
	glBindFramebuffer(GL_FRAMEBUFFER, rb->handle);
}

gb_inline void gbgl_render_to_screen(i32 width, i32 height) {
	glViewport(0, 0, width, height);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);
}


////////////////////////////////////////////////////////////////
//
// Texture
//
//


b32 gbgl_load_texture2d_from_memory(gbglTexture *tex, void const *data, i32 width, i32 height, i32 channel_count) {
	b32 result = true;

	gb_zero_item(tex);

	tex->width = width;
	tex->height = height;
	tex->channel_count = channel_count;
	tex->data_type = gbglBufferData_u8;
	tex->type = gbglgTexture_2D;

	glGenTextures(1, &tex->handle);
	glBindTexture(GL_TEXTURE_2D, tex->handle);


	glTexImage2D(GL_TEXTURE_2D, 0,
	             gbglInternalTextureFormat_8[channel_count-1],
	             width, height, 0,
	             gbglTextureFormat[channel_count-1],
	             GL_UNSIGNED_BYTE, data);

	glBindTexture(GL_TEXTURE_2D, 0);
	glGenerateMipmap(GL_TEXTURE_2D);
	glFinish();


	return result;
}

b32 gbgl_load_texture2d_from_file(gbglTexture *texture, b32 flip_vertically, char const *filename, ...) {
	b32 result;
	u8 *data;
	int width, height, comp;
	char *path;

	va_list va;
	va_start(va, filename);
	path = gb_bprintf_va(filename, va);
	va_end(va);

	stbi_set_flip_vertically_on_load(flip_vertically);
	data = stbi_load(path, &width, &height, &comp, 0);
	if (data == NULL) {
		gb_printf_err("Failed to load image: %s\n", path);
		result = false;
	} else {
		result = gbgl_load_texture2d_from_memory(texture, data, width, height, comp);
		stbi_image_free(data);
	}
	return result;
}

gb_inline b32 gbgl_make_texture2d_coloured(gbglTexture *t, gbglColour colour) {
	return gbgl_load_texture2d_from_memory(t, &colour.rgba, 1, 1, 4);
}


gb_inline void gbgl_bind_texture2d(gbglTexture const *t, u32 position, u32 sampler) {
	GB_ASSERT(t->type == gbglgTexture_2D);

	if (position > 31) {
		position = 31;
		gb_printf_err("Textures can only bound to position [0 ... 31]\n");
		gb_printf_err("Will bind to position [31]\n");
	}

	glActiveTexture(GL_TEXTURE0 + position);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, t ? t->handle : 0);
	glBindSampler(position, sampler);
}

gb_inline void gbgl_destroy_texture(gbglTexture *t) {
	if (t->handle) {
		glDeleteTextures(1, &t->handle);
	}
}



////////////////////////////////////////////////////////////////
//
// Font
//
//
#if !defined(GBGL_NO_FONTS)
gb_inline GB_COMPARE_PROC(gbgl__kern_pair_compare) {
	gbglKernPair *kp0 = cast(gbglKernPair *)a;
	gbglKernPair *kp1 = cast(gbglKernPair *)b;
	return kp0->packed - kp1->packed;
}


gb_inline GB_COMPARE_PROC(gbgl__glyph_map_compare) {
	gbglGlyphMapKVPair g0 = *cast(gbglGlyphMapKVPair *)a;
	gbglGlyphMapKVPair g1 = *cast(gbglGlyphMapKVPair *)b;
	return g0.codepoint - g1.codepoint;
}




b32 gbgl_get_packed_font_dim(gbglFontCache *cache, gbglFontCachedTTF *ttf, i32 *width, i32 *height) {
	b32 result = true;
	stbtt_pack_context spc;
	b32 ext_w = true;
	isize sanity_counter = 0, i, j;
	*width = *height = (1<<5);
	for (j = 0; j < cache->codepoint_count; j++) {
		cache->rect_cache[j].x = cache->rect_cache[j].y = 0;
	}

	for (;;) {
		i32 res = stbtt_PackBegin(&spc, NULL, *width, *height, 0, 1, 0);
		GB_ASSERT(res == 1);
		if (res != 1) {
			return false;
		} else {
			stbrp_context *rp_ctx;
			b32 fit = true;

			gb_zero_array(cache->rect_cache, cache->codepoint_count);
			rp_ctx = cast(stbrp_context *)spc.pack_info;
			stbtt_PackFontRangesGatherRects(&spc, &ttf->finfo, cache->ranges, cache->codepoint_count, cache->rect_cache);
			gb_sort_array(cache->rect_cache, cache->codepoint_count, rect_height_compare);

			for (i = 0; i < cache->codepoint_count; i++) {
				stbrp__findresult fr = stbrp__skyline_pack_rectangle(rp_ctx, cache->rect_cache[i].w, cache->rect_cache[i].h);
				if (fr.prev_link) {
					cache->rect_cache[i].x = cast(stbrp_coord)fr.x;
					cache->rect_cache[i].y = cast(stbrp_coord)fr.y;
				} else {
					int res;
					if (ext_w) {
						ext_w = false;
						*width <<= 1;
					} else {
						ext_w = true;
						*height <<= 1;
					}
					fit = false;
					for (j = 0; j < cache->codepoint_count; j++) {
						cache->rect_cache[j].x = cache->rect_cache[j].y = 0;
					}
					stbtt_PackEnd(&spc);
					res = stbtt_PackBegin(&spc, NULL, *width, *height, 0, 1, 0);
					GB_ASSERT(res == 1);
					if (res != 1) {
						result = false;
						goto done;
					}
					break;
				}
			}
			if (fit) {
				result = true;
				goto done;
			}
			if (++sanity_counter > 32) {
				result = false;
				goto done;
			}
		}
	}

done:
	stbtt_PackEnd(&spc);

	return result;
}

#if 0
void gbgl_destroy_font_cache(gbglFontCache *fc) {
	gbglFontCachedTTF *curr_ttf = fc->ttf_buffer;
	gbglFontCachedTTF *next_ttf = NULL;

	gbglFont *curr_font = fc->fonts;
	gbglFont *next_font = NULL;

	gbgl_free(fc->font_char_list);
	gbgl_free(fc->codepoints);
	gbgl_free(fc->ranges);
	gbgl_free(fc->packed_char_data);
	gbgl_free(fc->rect_cache);

	// NOTE(bill): Free all linked listed ttfs
	while (curr_ttf) {
		gbgl_free(curr_ttf->name);
		gbgl_free(curr_ttf->ttf);

		next_ttf = curr_ttf->next;
		gbgl_free(curr_ttf);
		curr_ttf = next_ttf;
	}

	// NOTE(bill): Free all linked listed fonts
	while (curr_font) {
		gbgl_free(curr_font->ttf_filename);
		gbgl_destroy_texture(&curr_font->texture);
		gbgl_free(curr_font->glyph_map);
		gbgl_free(curr_font->glyphs);
		gbgl_free(curr_font->kern_table);

		next_font = curr_font->next;
		gbgl_free(curr_font);
		curr_font = next_font;
	}
}
#endif


gb_inline gbglFont * gbgl_load_font_from_file(gbglFontCache *fc, char const *ttf_filename, f32 font_size) {
	gbglFont *f = gbgl_get_font_only_from_cache(fc, ttf_filename, font_size);
	if (f) return f;
	return gbgl_cache_font(fc, ttf_filename, font_size);
}


gb_inline gbglFont * gbgl_get_font_only_from_cache(gbglFontCache *fc, char const *ttf_filename, f32 font_size) {
	gbglFont *f = fc->fonts;
	while (f) {
		if (f->size == font_size && gb_strcmp(ttf_filename, f->ttf_filename) == 0) {
			return f;
		}
		f = f->next;
	}
	return NULL;
}

gbglFont * gbgl_cache_font(gbglFontCache *fc, char const *ttf_filename, f32 font_size) {
	gbglFont *f = gbgl_get_font_only_from_cache(fc, ttf_filename, font_size);
	gbglFontCachedTTF *ttf = NULL;
	isize i;

	if (f) { // NOTE(bill): The font is already cached
		return f;
	}

	if (!fc->fonts) {
		fc->fonts = cast(gbglFont *)gbgl_malloc(gb_size_of(gbglFont));
		f = fc->fonts;
	} else {
		f = fc->fonts;
		while (f && f->next)
			f = f->next;
		f->next = cast(gbglFont *)gbgl_malloc(gb_size_of(gbglFont));
		f = f->next;
	}
	GB_ASSERT_NOT_NULL(f);
	if (!f) {
		gb_printf_err("Failed to cache font\n");
		return NULL;
	}

	gb_zero_item(f);

	// NOTE(bill): Make sure the character list file has been loaded
	if (!fc->font_char_list) {
		isize codepoint_count = 0, cpi = 0;
		fc->font_char_list = GBGL_FONT_CHAR_LIST;
		fc->font_char_list_count = gb_strlen(GBGL_FONT_CHAR_LIST);

		for (i = 0; i < fc->font_char_list_count; i++) {
			char32 c;
			isize utf8_len = gb_utf8_decode_len(fc->font_char_list + i, fc->font_char_list_count, &c);
			i += utf8_len-1;
			codepoint_count++;
		}

		fc->codepoint_count = codepoint_count;
		fc->ranges           = cast(stbtt_pack_range *)gbgl_malloc(gb_size_of(stbtt_pack_range) * codepoint_count);
		fc->codepoints       = cast(char32 *)          gbgl_malloc(gb_size_of(char32)           * codepoint_count);
		fc->packed_char_data = cast(stbtt_packedchar *)gbgl_malloc(gb_size_of(stbtt_packedchar) * codepoint_count);
		fc->rect_cache       = cast(stbrp_rect *)      gbgl_malloc(gb_size_of(stbrp_rect)       * codepoint_count);

		if (!fc->ranges || !fc->codepoints || !fc->packed_char_data) {
			gb_printf_err("Unable to get memory for fonts");
		}

		for (i = 0; i < fc->font_char_list_count; i++) {
			isize utf8_len = gb_utf8_decode_len(fc->font_char_list+i, fc->font_char_list_count, fc->codepoints+cpi);
			i += utf8_len-1;
			cpi++;
		}
		GB_ASSERT(cpi == fc->codepoint_count);
		for (i = 0; i < fc->codepoint_count; i++) {
			fc->ranges[i].first_unicode_codepoint_in_range = fc->codepoints[i];
			fc->ranges[i].array_of_unicode_codepoints = 0;
			fc->ranges[i].num_chars = 1;
			fc->ranges[i].chardata_for_range = fc->packed_char_data + i;
		}
	}

	{
		gbglFontCachedTTF **ttf_cache = &fc->ttf_buffer;

		while (*ttf_cache) {
			if (gb_strcmp((*ttf_cache)->name, ttf_filename) == 0)
				break;
			ttf_cache = &(*ttf_cache)->next;
		}
		if (!*ttf_cache) {
			isize name_len;
			gbFile file;


			*ttf_cache = cast(gbglFontCachedTTF *)gbgl_malloc(gb_size_of(gbglFontCachedTTF));
			GB_ASSERT_NOT_NULL(*ttf_cache);
			(*ttf_cache)->name = NULL;
			(*ttf_cache)->ttf  = NULL;
			gb_zero_item(&(*ttf_cache)->finfo);
			(*ttf_cache)->next = NULL;


			name_len = gb_strlen(ttf_filename);
			(*ttf_cache)->name = cast(char *)gbgl_malloc(name_len+1);
			gb_strncpy((*ttf_cache)->name, ttf_filename, name_len);
			(*ttf_cache)->name[name_len] = '\0';

			if (gb_file_open(&file, ttf_filename) == gbFileError_None) {
				i64 len = gb_file_size(&file);
				(*ttf_cache)->ttf = cast(u8 *)gbgl_malloc(len);
				GB_ASSERT_NOT_NULL((*ttf_cache)->ttf);

				gb_file_read_at(&file, (*ttf_cache)->ttf, len, 0);

				gb_file_close(&file);
			} else {
				GB_PANIC("Could not open ttf file");
			}

			stbtt_InitFont(&(*ttf_cache)->finfo, (*ttf_cache)->ttf, stbtt_GetFontOffsetForIndex((*ttf_cache)->ttf, 0));
		}
		ttf = *ttf_cache;
		GB_ASSERT_NOT_NULL(ttf);
	}

	// NOTE(bill): Set the range for the this look up
	for (i = 0; i < fc->codepoint_count; i++)
		fc->ranges[i].font_size = font_size;

	{ // NOTE(bill): Figure out smallest non-square power of 2 texture size
		i32 w, h;
		if (gbgl_get_packed_font_dim(fc, ttf, &w, &h)) {
			isize str_len, i, j;

			// NOTE(bill): Setup the font data
			f->glyph_count   = fc->codepoint_count;
			f->bitmap_width  = w;
			f->bitmap_height = h;
			f->size          = font_size;

			str_len = gb_strlen(ttf_filename);
			f->ttf_filename = cast(char *)gbgl_malloc(str_len+1);
			gb_strncpy(f->ttf_filename, ttf_filename, str_len);

			f->glyph_map = cast(gbglGlyphMapKVPair *)gbgl_malloc(gb_size_of(*f->glyph_map) * f->glyph_count);
			f->glyphs    = cast(gbglGlyphInfo *)     gbgl_malloc(gb_size_of(*f->glyphs)    * f->glyph_count);
			if (!f->glyph_map || !f->glyphs) {
				f = NULL;
				return f;
			} else {
				stbtt_pack_context spc;
				u8 *px;
				i32 res;
				f32 scale;

				px = cast(u8 *)gbgl_malloc(w * h);
				res = stbtt_PackBegin(&spc, px, w, h, 0, 1, NULL);
				GB_ASSERT(res == 1);
				res = stbtt_PackFontRanges(&spc, ttf->ttf, 0, fc->ranges, fc->codepoint_count);
				GB_ASSERT(res == 1);
				stbtt_PackEnd(&spc);

				gbgl_load_texture2d_from_memory(&f->texture, px, w, h, 1);

				gbgl_free(px);

				scale = stbtt_ScaleForPixelHeight(&ttf->finfo, font_size);
				stbtt_GetFontVMetrics(&ttf->finfo, &f->ascent, &f->descent, &f->line_gap);
				f->ascent   = cast(i32)(cast(f32)f->ascent   * scale);
				f->descent  = cast(i32)(cast(f32)f->descent  * scale);
				f->line_gap = cast(i32)(cast(f32)f->line_gap * scale);

				for (i = 0; i < f->glyph_count; i++) {
					gbglGlyphInfo *gi = f->glyphs + i;
					gi->s0 = cast(f32)fc->packed_char_data[i].x0;
					gi->t0 = cast(f32)fc->packed_char_data[i].y0;
					gi->s1 = cast(f32)fc->packed_char_data[i].x1;
					gi->t1 = cast(f32)fc->packed_char_data[i].y1;

					gi->xoff = cast(i16)fc->packed_char_data[i].xoff;
					gi->yoff = cast(i16)fc->packed_char_data[i].yoff;
					gi->xadv = fc->packed_char_data[i].xadvance;
				}

				for (i = 0; i < f->glyph_count; i++) {
					f->glyph_map[i].codepoint = fc->codepoints[i];
					f->glyph_map[i].index = i;
				}

				gb_sort_array(f->glyph_map, f->glyph_count, gbgl__glyph_map_compare);

				{ // Kerning Table
					isize kps_count = 0;
					for (i = 0; i < f->glyph_count; i++) {
						for (j = 0; j < f->glyph_count; j++) {
							i32 kern = stbtt_GetCodepointKernAdvance(&ttf->finfo, fc->codepoints[i], fc->codepoints[j]);
							if (kern != 0)
								kps_count++;
						}
					}
					f->kern_pair_count = kps_count;
					if (kps_count > 0) {
						int ikp = 0;
						f->kern_table = cast(gbglKernPair *)gbgl_malloc(gb_size_of(*f->kern_table) * kps_count);
						for (i = 0; i < f->glyph_count; i++) {
							for (j = 0; j < f->glyph_count; j++) {
								isize kern = stbtt_GetCodepointKernAdvance(&ttf->finfo, fc->codepoints[i], fc->codepoints[j]);
								if (kern != 0) {
									gbglKernPair *kp = f->kern_table + ikp++;
									kp->i0 = cast(u16)i;
									kp->i1 = cast(u16)j;
									kp->kern = cast(f32)kern * scale;
								}
							}
						}
						gb_sort_array(f->kern_table, f->kern_pair_count, gbgl__kern_pair_compare);
					}
				}
			}
		} else {
			GB_PANIC("Failure loading font");
			gb_zero_item(&f);
		}
	}
	return f;
}


gb_inline GB_COMPARE_PROC(gbgl__font_glyph_map_search_proc) {
	gbglGlyphMapKVPair const *gm = cast(gbglGlyphMapKVPair const *)a;
	char32 ucp = *cast(char32 const *)b;
	return cast(i32)(cast(i64)gm->codepoint - cast(i64)ucp);
}

gb_inline gbglGlyphInfo * gbgl_get_glyph_info(gbglFont *font, char32 codepoint, isize *out_index) {
	isize index = gb_binary_search_array(font->glyph_map, font->glyph_count, &codepoint, gbgl__font_glyph_map_search_proc);
	if (index >= 0) {
		GB_ASSERT(codepoint == font->glyph_map[index].codepoint);
		if (out_index)
			*out_index = font->glyph_map[index].index;
		return font->glyphs + font->glyph_map[index].index;
	}
	return NULL;
}

gb_inline f32 gbgl_get_font_kerning_from_glyph_indices(gbglFont *font, isize left_index, isize right_index) {
	isize needle = (right_index << 16) | (left_index & 0xff);

	isize f = 0;
	isize l = font->kern_pair_count - 1;
	isize m = (f + l) >> 1;

	while (f <= l) {
		isize cmp = font->kern_table[m].packed - needle;
		if (cmp < 0)
			f = m + 1;
		else if (cmp > 0)
			l = m - 1;
		else
			return font->kern_table[m].kern;
		m = (f + l) >> 1;
	}
	return 0.0f;
}

void gbgl_get_string_dimensions(gbglFont *font, char const *str, f32 *out_width, f32 *out_height) {
	isize len, char_count, i;

	f32 w = 0.0f;
	f32 h = 0.0f;
	char const *ptr = str;

	len = gb_strlen(str);
	char_count = gb_utf8_strnlen(str, len);

	for (i = 0; i < char_count; i++) {
		char32 cp;
		isize byte_len, curr_index;
		gbglGlyphInfo *gi;

		byte_len = gb_utf8_decode_len(ptr, len-(ptr-str), &cp);
		ptr += byte_len;
		gi = gbgl_get_glyph_info(font, cp, &curr_index);
		if (gi) {
			f32 kern = 0;
			if (i < char_count-1) {
				isize next_index;
				char32 next_cp = 0;
				gbglGlyphInfo *ngi;
				gb_utf8_decode_len(ptr, len-(ptr-str), &next_cp);
				ngi = gbgl_get_glyph_info(font, next_cp, &next_index);
				if (ngi) kern = gbgl_get_font_kerning_from_glyph_indices(font, curr_index, next_index);
			}
			w += gi->xadv + kern;
		}
	}

	if (out_width)  *out_width  = w;
	if (out_height) *out_height = h;
}

f32 gbgl_get_sub_string_width(gbglFont *font, char const *str, isize char_count) {
	isize i, len;
	f32 w = 0;
	char const *ptr = str;
	len = gb_strlen(str);
	for (i = 0; i < char_count; i++) {
		if (*ptr == 0) {
			break;
		} else {
			char32 cp;
			isize byte_len, curr_index;
			f32 kern = 0;
			gbglGlyphInfo *gi;

			byte_len = gb_utf8_decode_len(ptr, len-(ptr-str), &cp);
			ptr += byte_len;
			if (ptr - str > char_count)
				break;

			gi = gbgl_get_glyph_info(font, cp, &curr_index);
			if (i < char_count-1) {
				isize next_index;
				char32 next_cp = 0;
				gb_utf8_decode_len(ptr, len-(ptr-str), &next_cp);
				gbgl_get_glyph_info(font, next_cp, &next_index);
				kern = gbgl_get_font_kerning_from_glyph_indices(font, curr_index, next_index);
			}
			w += gi->xadv + kern;
		}

	}
	return w;
}

i32 gbgl_get_wrapped_line_count(gbglFont *font, char const *str, isize max_len, isize max_width) {
	isize i, str_len, char_count, line_count = 1;
	f32 w = 0;
	char const *ptr = str;

	str_len = gb_strnlen(str, max_len);
	char_count = gb_utf8_strnlen(str, str_len);

	for (i = 0; i < char_count; i++) {
		char32 cp;
		isize byte_len, curr_index;
		gbglGlyphInfo *gi;
		f32 kern = 0;

		byte_len = gb_utf8_decode_len(ptr, str_len-(ptr-str), &cp);
		ptr += byte_len;
		// NOTE(bill): Check calculation here
		if (ptr-str >= max_len-6)
			break;

		gi = gbgl_get_glyph_info(font, cp, &curr_index);
		if (gi) {
			if (w + gi->xadv >= cast(f32)max_width) {
				line_count++;
				w = 0.0f;
			}
		}

		if (i < char_count-1) {
			char32 next_cp;
			isize next_index;
			gb_utf8_decode_len(ptr, str_len-(ptr-str), &next_cp);

			gbgl_get_glyph_info(font, next_cp, &next_index);
			kern = gbgl_get_font_kerning_from_glyph_indices(font, curr_index, next_index);
		}

		if (gi) {
			w += gi->xadv + kern;
		}
	}

	return line_count;
}

gb_inline f32 gbgl_get_string_width(gbglFont *font, char const *str, isize max_len) {
	isize len = gb_strnlen(str, max_len);
	isize char_count = gb_utf8_strnlen(str, len);
	return gbgl_get_sub_string_width(font, str, char_count);
}

#endif


////////////////////////////////////////////////////////////////
//
// Basic State
//
//

#if !defined(GBGL_NO_BASIC_STATE)


void gbgl_bs_init(gbglBasicState *bs, i32 window_width, i32 window_height) {
	isize i;

	gbgl_bs_set_resolution(bs, window_width, window_height);
	glGenVertexArrays(1, &bs->vao);
	glBindVertexArray(bs->vao);

	bs->vbo = gbgl_make_vbo(NULL, gb_size_of(gbglBasicVertex) * GBGL_BS_MAX_VERTEX_COUNT, GL_DYNAMIC_DRAW);

	for (i = 0; i < GBGL_BS_MAX_INDEX_COUNT / 6; i++) {
		bs->indices[i*6 + 0] = i*4 + 0;
		bs->indices[i*6 + 1] = i*4 + 1;
		bs->indices[i*6 + 2] = i*4 + 2;
		bs->indices[i*6 + 3] = i*4 + 2;
		bs->indices[i*6 + 4] = i*4 + 3;
		bs->indices[i*6 + 5] = i*4 + 0;
	}
	bs->ebo = gbgl_make_ebo(bs->indices, gb_size_of(u16) * GBGL_BS_MAX_INDEX_COUNT, GL_STATIC_DRAW);

	bs->nearest_sampler = gbgl_make_sampler(GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
	bs->linear_sampler  = gbgl_make_sampler(GL_LINEAR,  GL_LINEAR,  GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);

	gbgl_load_shader_from_memory_vf(&bs->ortho_tex_shader,
		"#version 410 core\n"
		"layout (location = 0) in vec4 a_position;\n"
		"layout (location = 1) in vec2 a_tex_coord;\n"
		"uniform mat4 u_ortho_mat;\n"
		"out vec2 v_tex_coord;\n"
		"void main(void) {\n"
		"	gl_Position = u_ortho_mat * a_position;\n"
		"	v_tex_coord = a_tex_coord;\n"
		"}\n",

		"#version 410 core\n"
		"precision mediump float;"
		"in vec2 v_tex_coord;\n"
		"layout (binding = 0) uniform sampler2D u_tex;\n"
		"out vec4 o_colour;\n"
		"void main(void) {\n"
		"	o_colour = texture2D(u_tex, v_tex_coord);\n"
		"}\n"
	);

	gbgl_load_shader_from_memory_vf(&bs->ortho_col_shader,
		"#version 410 core\n"
		"precision mediump float;"
		"layout (location = 0) in vec4 a_position;\n"
		"uniform mat4 u_ortho_mat;\n"
		"void main(void) {\n"
		"	gl_Position = u_ortho_mat * a_position;\n"
		"}\n",

		"#version 410 core\n"
		"uniform vec4 u_colour;\n"
		"out vec4 o_colour;\n"
		"void main(void) {\n"
		"	o_colour = u_colour;\n"
		"}\n"
	);


#if !defined(GBGL_NO_FONTS)
	gbgl_load_shader_from_memory_vf(&bs->font_shader,
		"#version 410 core\n"
		"layout (location = 0) in vec4 a_position;\n"
		"layout (location = 1) in vec2 a_tex_coord;\n"
		"uniform mat4 u_ortho_mat;\n"
		"out vec2 v_tex_coord;\n"
		"void main(void) {\n"
		"	gl_Position = u_ortho_mat * a_position;\n"
		"	v_tex_coord = a_tex_coord;\n"
		"}\n",

		"#version 410 core\n"
		"in vec2 v_tex_coord;\n"
		"uniform vec4 u_colour;\n"
		"layout (binding = 0) uniform sampler2D u_tex;\n"
		"out vec4 o_colour;\n"
		"void main(void) {\n"
		"	o_colour = u_colour * texture2D(u_tex, v_tex_coord).r;\n"
		"}\n"
	);

	glGenVertexArrays(1, &bs->font_vao);
	glBindVertexArray(bs->font_vao);

	bs->font_vbo = gbgl_make_vbo(NULL, gb_size_of(gbglBasicVertex) * GBGL_MAX_RENDER_STRING_LENGTH * 4, GL_DYNAMIC_DRAW);

	for (i = 0; i < GBGL_MAX_RENDER_STRING_LENGTH; i++) {
		bs->font_indices[i*6 + 0] = i*4 + 0;
		bs->font_indices[i*6 + 1] = i*4 + 1;
		bs->font_indices[i*6 + 2] = i*4 + 2;
		bs->font_indices[i*6 + 3] = i*4 + 2;
		bs->font_indices[i*6 + 4] = i*4 + 3;
		bs->font_indices[i*6 + 5] = i*4 + 0;
	}
	bs->font_ebo = gbgl_make_ebo(bs->font_indices, gb_size_of(u16) * GBGL_MAX_RENDER_STRING_LENGTH * 6, GL_STATIC_DRAW);

	bs->font_samplers[0] = gbgl_make_sampler(GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
	bs->font_samplers[1] = gbgl_make_sampler(GL_LINEAR,  GL_LINEAR,  GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);

	bs->text_params[gbglTextParam_MaxWidth]     .val_i32 = 0;
	bs->text_params[gbglTextParam_Justify]       .val_i32 = gbglJustify_Left;
	bs->text_params[gbglTextParam_TextureFilter].val_i32 = 0;
#endif
}

gb_inline void gbgl_bs_set_resolution(gbglBasicState *bs, i32 window_width, i32 window_height) {
	f32 left   = 0.0f;
	f32 right  = cast(f32)window_width;
	f32 bottom = 0.0f;
	f32 top    = cast(f32)window_height;
	f32 znear  = 0.0f;
	f32 zfar   = 1.0f;

	bs->width  = window_width;
	bs->height = window_height;

	bs->ortho_mat[0] = 2.0f / (right - left);
	bs->ortho_mat[1] = 0.0f;
	bs->ortho_mat[2] = 0.0f;
	bs->ortho_mat[3] = 0.0f;

	bs->ortho_mat[4] = 0.0f;
	bs->ortho_mat[5] = 2.0f / (top - bottom);
	bs->ortho_mat[6] = 0.0f;
	bs->ortho_mat[7] = 0.0f;

	bs->ortho_mat[8]  =  0.0f;
	bs->ortho_mat[9]  =  0.0f;
	bs->ortho_mat[10] = -2.0f / (zfar - znear);
	bs->ortho_mat[11] =  0.0f;

	bs->ortho_mat[12] = -(right + left) / (right - left);
	bs->ortho_mat[13] = -(top + bottom) / (top - bottom);
	bs->ortho_mat[14] = -(zfar + znear) / (zfar - znear);
	bs->ortho_mat[15] = 1.0f;
}

gb_inline void gbgl_bs_begin(gbglBasicState *bs, i32 window_width, i32 window_height) {
	glBindVertexArray(bs->vao);
	glDisable(GL_SCISSOR_TEST);
	gbgl_bs_set_resolution(bs, window_width, window_height);
}

gb_inline void gbgl_bs_end(gbglBasicState *bs) {
	glBindVertexArray(0);
}




void gbgl_bs_draw_textured_rect(gbglBasicState *bs, gbglTexture *tex, f32 x, f32 y, f32 w, f32 h, b32 v_up) {
	bs->vertices[0].x = x;
	bs->vertices[0].y = y;
	bs->vertices[0].u = 0.0f;
	bs->vertices[0].v = v_up ? 0.0f : 1.0f;

	bs->vertices[1].x = x + w;
	bs->vertices[1].y = y;
	bs->vertices[1].u = 1.0f;
	bs->vertices[1].v = v_up ? 0.0f : 1.0f;

	bs->vertices[2].x = x + w;
	bs->vertices[2].y = y + h;
	bs->vertices[2].u = 1.0f;
	bs->vertices[2].v = v_up ? 1.0f : 0.0f;

	bs->vertices[3].x = x;
	bs->vertices[3].y = y + h;
	bs->vertices[3].u = 0.0f;
	bs->vertices[3].v = v_up ? 1.0f : 0.0f;

	gbgl_use_shader(&bs->ortho_tex_shader);
	gbgl_set_uniform_mat4(&bs->ortho_tex_shader, "u_ortho_mat", bs->ortho_mat);
	gbgl_bind_texture2d(tex, 0, bs->nearest_sampler);

	gbgl_vbo_copy(bs->vbo, bs->vertices, 4*gb_size_of(bs->vertices[0]), 0);

	gbgl_vert_ptr_aa(0, 2, gbglBasicVertex, x);
	gbgl_vert_ptr_aa(1, 2, gbglBasicVertex, u);

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bs->ebo);

	glEnable(GL_BLEND);
	glBlendEquationi(0, GL_FUNC_ADD);
	glBlendFunci(0, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
}

gb_inline void gbgl_bs_draw_rect(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, gbglColour col) {
	gbgl_bs_draw_quad(bs,
	                  x,   y,
	                  x+w, y,
	                  x+w, y+h,
	                  x,   y+h,
	                  col);
}

gb_inline void gbgl_bs_draw_rect_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, gbglColour col, f32 thickness) {
	gbgl_bs_draw_quad_outline(bs,
	                          x,   y,
	                          x+w, y,
	                          x+w, y+h,
	                          x,   y+h,
	                          col,
	                          thickness);
}


gb_internal void gbgl__bs_setup_ortho_colour_state(gbglBasicState *bs, isize vertex_count, gbglColour col) {

	gbgl_use_shader(&bs->ortho_col_shader);
	gbgl_set_uniform_mat4(&bs->ortho_col_shader, "u_ortho_mat", bs->ortho_mat);
	gbgl_set_uniform_colour(&bs->ortho_col_shader, "u_colour", col);

	gbgl_vbo_copy(bs->vbo, bs->vertices, vertex_count*gb_size_of(bs->vertices[0]), 0);
	gbgl_vert_ptr_aa(0, 2, gbglBasicVertex, x);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bs->ebo);

	glEnable(GL_BLEND);
	glBlendEquation(GL_FUNC_ADD);
	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}

gb_inline void gbgl_bs_draw_quad(gbglBasicState *bs,
                                 f32 x0, f32 y0,
                                 f32 x1, f32 y1,
                                 f32 x2, f32 y2,
                                 f32 x3, f32 y3,
                                 gbglColour col) {
	bs->vertices[0].x = x0;
	bs->vertices[0].y = y0;

	bs->vertices[1].x = x1;
	bs->vertices[1].y = y1;

	bs->vertices[2].x = x2;
	bs->vertices[2].y = y2;

	bs->vertices[3].x = x3;
	bs->vertices[3].y = y3;

	gbgl__bs_setup_ortho_colour_state(bs, 4, col);
	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
}

gb_inline void gbgl_bs_draw_quad_outline(gbglBasicState *bs,
                                         f32 x0, f32 y0,
                                         f32 x1, f32 y1,
                                         f32 x2, f32 y2,
                                         f32 x3, f32 y3,
                                         gbglColour col, f32 thickness) {
	bs->vertices[0].x = x0;
	bs->vertices[0].y = y0;

	bs->vertices[1].x = x1;
	bs->vertices[1].y = y1;

	bs->vertices[2].x = x2;
	bs->vertices[2].y = y2;

	bs->vertices[3].x = x3;
	bs->vertices[3].y = y3;

	gbgl__bs_setup_ortho_colour_state(bs, 4, col);
	glLineWidth(thickness);
	glDrawArrays(GL_LINE_LOOP, 0, 4);
}

gb_inline void gbgl_bs_draw_line(gbglBasicState *bs, f32 x0, f32 y0, f32 x1, f32 y1, gbglColour col, f32 thickness) {
	bs->vertices[0].x = x0;
	bs->vertices[0].y = y0;

	bs->vertices[1].x = x1;
	bs->vertices[1].y = y1;

	gbgl__bs_setup_ortho_colour_state(bs, 2, col);
	glLineWidth(thickness);
	glDrawArrays(GL_LINES, 0, 2);
}

gb_inline void gbgl_bs_draw_elliptical_arc(gbglBasicState *bs, f32 x, f32 y, f32 radius_a, f32 radius_b,
                                           f32 min_angle, f32 max_angle, gbglColour col) {
	isize i;

	bs->vertices[0].x = x;
	bs->vertices[0].y = y;

	for (i = 0; i < 31; i++) {
		f32 t = cast(f32)i / 30.0f;
		f32 a = gbgl_lerp(min_angle, max_angle, t);
		f32 c = gbgl_cos(a);
		f32 s = gbgl_sin(a);
		bs->vertices[i+1].x = x + c*radius_a;
		bs->vertices[i+1].y = y + s*radius_b;
	}

	gbgl__bs_setup_ortho_colour_state(bs, 32, col);
	glDrawArrays(GL_TRIANGLE_FAN, 0, 32);
}

gb_inline void gbgl_bs_draw_elliptical_arc_outline(gbglBasicState *bs, f32 x, f32 y, f32 radius_a, f32 radius_b,
                                                   f32 min_angle, f32 max_angle, gbglColour col, f32 thickness) {
	isize i;

	for (i = 0; i < 32; i++) {
		f32 t = cast(f32)i / 31.0f;
		f32 a = gbgl_lerp(min_angle, max_angle, t);
		f32 c = gbgl_cos(a);
		f32 s = gbgl_sin(a);
		bs->vertices[i+1].x = x + c*radius_a;
		bs->vertices[i+1].y = y + s*radius_b;
	}

	gbgl__bs_setup_ortho_colour_state(bs, 32, col);
	glLineWidth(thickness);
	glDrawArrays(GL_LINES, 0, 32);
}



gb_inline void gbgl_bs_draw_circle(gbglBasicState *bs, f32 x, f32 y, f32 radius, gbglColour col) {
	gbgl_bs_draw_elliptical_arc(bs, x, y, radius, radius, 0, GBGL_TAU, col);
}

gb_inline void gbgl_bs_draw_circle_outline(gbglBasicState *bs, f32 x, f32 y, f32 radius, gbglColour col, f32 thickness) {
	gbgl_bs_draw_elliptical_arc_outline(bs, x, y, radius, radius, 0, GBGL_TAU, col, thickness);
}

void gbgl_bs_draw_rounded_rect_corners(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, u32 corners) {
	if ((2.0f*roundness > gbgl_abs(w)) ||
	    (2.0f*roundness > gbgl_abs(h))) {
		roundness = 0.5f*gbgl_min(gbgl_abs(w), gbgl_abs(h));
	}

	if (roundness == 0 || corners == 0) {
		gbgl_bs_draw_rect(bs, x, y, w, h, col);
	} else {
		isize i, vc = 0;

		bs->vertices[vc].x = x + 0.5f*w;
		bs->vertices[vc].y = y + 0.5f*h;
		vc++;

		if (corners & 1) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.5f*GBGL_TAU, 0.75f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + roundness + c*roundness;
				bs->vertices[vc].y = y + roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y;
			vc++;
		}

		if (corners & 2) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.75f*GBGL_TAU, 1.00f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + w - roundness + c*roundness;
				bs->vertices[vc].y = y + roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x + w;
			bs->vertices[vc].y = y;
			vc++;
		}


		if (corners & 4) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.00f*GBGL_TAU, 0.25f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + w - roundness + c*roundness;
				bs->vertices[vc].y = y + h - roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x + w;
			bs->vertices[vc].y = y + h;
			vc++;
		}

		if (corners & 8) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.25f*GBGL_TAU, 0.50f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + roundness + c*roundness;
				bs->vertices[vc].y = y + h - roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y + h;
			vc++;
		}

		if (corners & 1) {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y + roundness;
		} else {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y;
		}
		vc++;

		gbgl__bs_setup_ortho_colour_state(bs, vc, col);
		glDrawArrays(GL_TRIANGLE_FAN, 0, vc);
	}
}

gb_inline void gbgl_bs_draw_rounded_rect(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col) {
	gbgl_bs_draw_rounded_rect_corners(bs, x, y, w, h, roundness, col, 1|2|4|8);
}


void gbgl_bs_draw_rounded_rect_corners_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, f32 thickness, u32 corners) {
	if ((2.0f*roundness > gbgl_abs(w)) ||
	    (2.0f*roundness > gbgl_abs(h))) {
		roundness = 0.5f*gbgl_min(gbgl_abs(w), gbgl_abs(h));
	}

	if (roundness == 0 || corners == 0) {
		gbgl_bs_draw_rect_outline(bs, x, y, w, h, col, thickness);
	} else {
		isize i, vc = 0;

		if (corners & 1) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.5f*GBGL_TAU, 0.75f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + roundness + c*roundness;
				bs->vertices[vc].y = y + roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y;
			vc++;
		}

		if (corners & 2) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.75f*GBGL_TAU, 1.00f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + w - roundness + c*roundness;
				bs->vertices[vc].y = y + roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x + w;
			bs->vertices[vc].y = y;
			vc++;
		}


		if (corners & 4) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.00f*GBGL_TAU, 0.25f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + w - roundness + c*roundness;
				bs->vertices[vc].y = y + h - roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x + w;
			bs->vertices[vc].y = y + h;
			vc++;
		}

		if (corners & 8) {
			for (i = 0; i < 6; i++) {
				f32 t = cast(f32)i / 5.0f;
				f32 a = gbgl_lerp(0.25f*GBGL_TAU, 0.50f*GBGL_TAU, t);
				f32 c = gbgl_cos(a);
				f32 s = gbgl_sin(a);
				bs->vertices[vc].x = x + roundness + c*roundness;
				bs->vertices[vc].y = y + h - roundness + s*roundness;
				vc++;
			}
		} else {
			bs->vertices[vc].x = x;
			bs->vertices[vc].y = y + h;
			vc++;
		}

		gbgl__bs_setup_ortho_colour_state(bs, vc, col);
		glLineWidth(thickness);
		glDrawArrays(GL_LINE_LOOP, 0, vc);
	}
}

gb_inline void gbgl_bs_draw_rounded_rect_outline(gbglBasicState *bs, f32 x, f32 y, f32 w, f32 h, f32 roundness, gbglColour col, f32 thickness) {
	gbgl_bs_draw_rounded_rect_corners_outline(bs, x, y, w, h, roundness, col, thickness, 1|2|4|8);
}




#if !defined(GBGL_NO_FONTS)


isize gbgl_bs_draw_substring(gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *str, isize len) {
	isize char_count = gb_utf8_strnlen(str, len);
	isize line_count = 0;
	if (char_count > 0) {
		char const *ptr = str;

		f32 sf = 1.0f / cast(f32)font->bitmap_width;
		f32 tf = 1.0f / cast(f32)font->bitmap_height;

		f32 ox, oy;
		f32 px, py;

		isize glyph_count = 0, i;
		f32 font_height = font->size;
		i32 max_width = bs->text_params[gbglTextParam_MaxWidth].val_i32;

		gbglJustifyType justify = cast(gbglJustifyType)bs->text_params[gbglTextParam_Justify].val_i32;
		if (justify == gbglJustify_Centre) {
			f32 width;
			gbgl_get_string_dimensions(font, ptr, &width, NULL);
			x = gbgl_round(x - width*0.5f);
		} else if (justify == gbglJustify_Right) {
			f32 width;
			gbgl_get_string_dimensions(font, ptr, &width, NULL);
			x = gbgl_round(x - width);
		}

		line_count = 1;

		ox = x;
		oy = y;
		px = ox;
		py = oy;

		for (i = 0; i < char_count; i++) {
			char32 cp;
			isize byte_len, curr_index, draw_this_glyph_count = 1, j;
			gbglGlyphInfo *gi;

			byte_len = gb_utf8_decode_len(ptr, len-(ptr-str), &cp);
			ptr += byte_len;
			if (ptr - str > len)
				break;

			if (cp == '\t') {
				draw_this_glyph_count = GBGL_TAB_CHARACTER_WIDTH;
				cp = ' '; // TODO(bill): Set tab to be space
			}


			gi = gbgl_get_glyph_info(font, cp, &curr_index);
			if (!gi) {
				gi = gbgl_get_glyph_info(font, ' ', &curr_index);
			}

			if (gi) {
				for (j = 0; j < draw_this_glyph_count; j++) {
					f32 s0, t0, s1, t1;
					f32 x0, y0, x1, y1;
					f32 kern = 0.0f;


					if (cp == '\r' || cp == '\n' ||
					    (max_width > 0 && px - ox + gi->xadv >= cast(f32)max_width)) {
						px = ox;

						py -= font_height;
						line_count += 2;

						if (cp == '\r' || cp == '\n') {
							if (cp == '\r' && ptr[1] == '\n')
								ptr++;
							continue;
						}
					}

					s0 = cast(f32)gi->s0 * sf;
					t0 = cast(f32)gi->t0 * tf;
					s1 = cast(f32)gi->s1 * sf;
					t1 = cast(f32)gi->t1 * tf;

					x0 = px + gi->xoff;
					y0 = py - gi->yoff;
					x1 = x0 + (gi->s1 - gi->s0);
					y1 = y0 + (gi->t0 - gi->t1);

					bs->font_vertices[glyph_count*4 + 0].x = x0;
					bs->font_vertices[glyph_count*4 + 0].y = y0;
					bs->font_vertices[glyph_count*4 + 0].u = s0;
					bs->font_vertices[glyph_count*4 + 0].v = t0;

					bs->font_vertices[glyph_count*4 + 1].x = x1;
					bs->font_vertices[glyph_count*4 + 1].y = y0;
					bs->font_vertices[glyph_count*4 + 1].u = s1;
					bs->font_vertices[glyph_count*4 + 1].v = t0;

					bs->font_vertices[glyph_count*4 + 2].x = x1;
					bs->font_vertices[glyph_count*4 + 2].y = y1;
					bs->font_vertices[glyph_count*4 + 2].u = s1;
					bs->font_vertices[glyph_count*4 + 2].v = t1;

					bs->font_vertices[glyph_count*4 + 3].x = x0;
					bs->font_vertices[glyph_count*4 + 3].y = y1;
					bs->font_vertices[glyph_count*4 + 3].u = s0;
					bs->font_vertices[glyph_count*4 + 3].v = t1;

					glyph_count++;

					if (i < char_count-1) {
						isize next_index;
						char32 next_cp = 0;
						gbglGlyphInfo *ngi;

						gb_utf8_decode_len(ptr, len-(ptr-str), &next_cp);
						ngi = gbgl_get_glyph_info(font, next_cp, &next_index);
						if (ngi) {
							kern = gbgl_get_font_kerning_from_glyph_indices(font, curr_index, next_index);
						}
					}

					px += gi->xadv + kern;
				}
			}
		}


		if (glyph_count > 0) {
			isize sampler_index = 0;

			gbgl_use_shader(&bs->font_shader);
			gbgl_set_uniform_mat4(&bs->font_shader, "u_ortho_mat", bs->ortho_mat);
			gbgl_set_uniform_colour(&bs->font_shader, "u_colour", col);
			GB_ASSERT(bs->text_params[gbglTextParam_TextureFilter].val_i32 < gb_count_of(bs->font_samplers));
			if (bs->text_params[gbglTextParam_TextureFilter].val_i32 < gb_count_of(bs->font_samplers))
				sampler_index = bs->text_params[gbglTextParam_TextureFilter].val_i32;

			gbgl_bind_texture2d(&font->texture, 0, bs->font_samplers[sampler_index]);
			gbgl_vbo_copy(bs->font_vbo, bs->font_vertices, gb_size_of(bs->font_vertices[0]) * glyph_count * 4, 0);

			gbgl_vert_ptr_aa(0, 2, gbglBasicVertex, x);
			gbgl_vert_ptr_aa(1, 2, gbglBasicVertex, u);

			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bs->font_ebo);

			glEnable(GL_BLEND);
			glBlendEquation(GL_FUNC_ADD);
			glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
			glDrawElements(GL_TRIANGLES, glyph_count*6, GL_UNSIGNED_SHORT, NULL);

		}
	}
	return line_count;
}

isize gbgl_bs_draw_string(gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *fmt, ...) {
	isize len;
	va_list va;
	va_start(va, fmt);
	len = gbgl_bs_draw_string_va(bs, font, x, y, col, fmt, va);
	va_end(va);
	return len;
}

gb_inline isize gbgl_bs_draw_string_va(gbglBasicState *bs, gbglFont *font, f32 x, f32 y, gbglColour col, char const *fmt, va_list va) {
	isize len = gb_snprintf_va(bs->font_text_buffer, gb_size_of(bs->font_text_buffer),
	                           fmt, va);
	isize char_count = gb_utf8_strnlen(bs->font_text_buffer, len);
	if (char_count <= 0)
		return 0;
	return gbgl_bs_draw_substring(bs, font, x, y, col, bs->font_text_buffer, len);
}

#endif // !defined(GBGL_NO_FONTS)
#endif // !defined(GBGL_NO_BASIC_STATE)

#endif