liblibgb.c 1.2021.3

package/gb/gb_gl.h

@@ -0,0 +1,2592 @@
+/* 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 system 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;
+	u32 mipmap_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);
+
+	glGenerateMipmap(GL_TEXTURE_2D);
+
+	glBindTexture(GL_TEXTURE_2D, 0);
+	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) {
+	if (t != NULL) {
+		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);
+	bs->mipmap_sampler = gbgl_make_sampler(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_REPEAT, GL_REPEAT);
+
+	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->mipmap_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