peter
/
gb
1
0
Fork 0
Code Projects Releases Wiki Activity
gb/gb_gl.h

2339 lines
69 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* gb.h - v0.01 - 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
NOTE
This library REQUIRES "stb_image.h" for loading images from file
- You may need change the path
This library REQUIRES "gb.h" at this moment in time.
This library REQUIRES "gb_math.h" at this moment in time.
===========================================================================
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.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 GB_MATH_IMPLEMENTATION
#include "gb_math.h"
#endif
#ifndef STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#endif
#ifndef STB_RECT_PACK_IMPLEMENTATION
#include "stb_rect_pack.h"
#endif
#ifndef STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
#endif
#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
////////////////////////////////////////////////////////////////
//
// 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_generate_sampler(u32 min_filter, u32 max_filter, u32 s_wrap, u32 t_wrap);
////////////////////////////////////////////////////////////////
//
// Data Buffers
//
//
typedef enum gbglBufferDataType {
GBGL_BDT_U8 = GL_UNSIGNED_BYTE,
GBGL_BDT_I8 = GL_BYTE,
GBGL_BDT_U16 = GL_UNSIGNED_SHORT,
GBGL_BDT_I16 = GL_SHORT,
GBGL_BDT_F16 = GL_HALF_FLOAT,
GBGL_BDT_U32 = GL_UNSIGNED_INT,
GBGL_BDT_I32 = GL_INT,
GBGL_BDT_F32 = GL_FLOAT,
GBGL_BDT_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 GBGL_TEXTURE_FORMAT[4] = { GL_RED, GL_RG, GL_SRGB8, GL_SRGB8_ALPHA8 };
#else
i32 const GBGL_TEXTURE_FORMAT[4] = { GL_RED, GL_RG, GL_RGB, GL_RGBA };
#endif
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_8[4] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_16[4] = { GL_R16, GL_RG16, GL_RGB16, GL_RGBA16 };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_32[4] = { GL_R32F, GL_RG32F, GL_RGB32F, GL_RGBA32F };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_U8[4] = { GL_R8UI, GL_RG8UI, GL_RGB8UI, GL_RGB8UI };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_I8[4] = { GL_R8I, GL_RG8I, GL_RGB8I, GL_RGB8I };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_F8[4] = { GL_R8, GL_RG8, GL_RGB8, GL_RGB8 };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_U16[4] = { GL_R16UI, GL_RG16UI, GL_RGB16UI, GL_RGB16UI };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_I16[4] = { GL_R16I, GL_RG16I, GL_RGB16I, GL_RGB16I };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_F16[4] = { GL_R16F, GL_RG16F, GL_RGB16F, GL_RGB16F };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_U32[4] = { GL_R32UI, GL_RG32UI, GL_RGB32UI, GL_RGBA32UI };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_I32[4] = { GL_R32I, GL_RG32I, GL_RGB32I, GL_RGBA32I };
i32 const GBGL_INTERNAL_TEXTURE_FORMAT_F32[4] = { GL_R32F, GL_RG32F, GL_RGB32F, GL_RGBA32F };
gb_inline i32
gbgl__get_texture_format(gbglBufferDataType data_type, i32 channel_count)
{
GB_ASSERT(channel_count >= 1 && channel_count <= 4);
switch (data_type) {
case GBGL_BDT_U8: return GBGL_INTERNAL_TEXTURE_FORMAT_U8[channel_count-1];
case GBGL_BDT_I8: return GBGL_INTERNAL_TEXTURE_FORMAT_I8[channel_count-1];
case GBGL_BDT_F8: return GBGL_INTERNAL_TEXTURE_FORMAT_F8[channel_count-1];
case GBGL_BDT_U16: return GBGL_INTERNAL_TEXTURE_FORMAT_U16[channel_count-1];
case GBGL_BDT_I16: return GBGL_INTERNAL_TEXTURE_FORMAT_I16[channel_count-1];
case GBGL_BDT_F16: return GBGL_INTERNAL_TEXTURE_FORMAT_F16[channel_count-1];
case GBGL_BDT_U32: return GBGL_INTERNAL_TEXTURE_FORMAT_U32[channel_count-1];
case GBGL_BDT_I32: return GBGL_INTERNAL_TEXTURE_FORMAT_I32[channel_count-1];
case GBGL_BDT_F32: return GBGL_INTERNAL_TEXTURE_FORMAT_F32[channel_count-1];
}
return GBGL_INTERNAL_TEXTURE_FORMAT_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 {
GBGL_SHADER_TYPE_VERTEX,
GBGL_SHADER_TYPE_FRAGMENT,
GBGL_SHADER_TYPE_GEOMETRY,
GBGL_SHADER_TYPE_COUNT,
} gbglShaderType;
i32 const GBGL_SHADER_TYPE[GBGL_SHADER_TYPE_COUNT] = {
GL_VERTEX_SHADER, /* GBGL_SHADER_TYPE_VERTEX */
GL_FRAGMENT_SHADER, /* GBGL_SHADER_TYPE_FRAGMENT */
GL_GEOMETRY_SHADER, /* GBGL_SHADER_TYPE_GEOMETRY */
};
typedef enum gbglShaderError {
GBGL_SHADER_ERROR_NONE,
GBGL_SHADER_ERROR_SHADER_COMPILE,
GBGL_SHADER_ERROR_LINKING,
GBGL_SHADER_ERROR_UNABLE_TO_READ_FILE,
GBGL_SHADER_ERROR_COUNT,
} gbglShaderError;
#ifndef GBGL_MAX_UNIFORM_COUNT
#define GBGL_MAX_UNIFORM_COUNT 32
#endif
typedef struct gbglShader {
u32 shaders[GBGL_SHADER_TYPE_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[GBGL_SHADER_TYPE_COUNT];
char base_name[64];
} gbglShader;
#ifndef GBGL_SHADER_FILE_EXTENSIONS_DEFINED
#define GBGL_SHADER_FILE_EXTENSIONS_DEFINED
gb_global char const *GBGL_SHADER_FILE_EXTENSIONS[GBGL_SHADER_TYPE_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_vf_from_source (gbglShader *s, char const *vert_source, char const *frag_source);
GBGL_DEF gbglShaderError gbgl_load_shader_vfg_from_source(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, gbVec2 v);
GBGL_DEF void gbgl_set_uniform_vec3 (gbglShader *s, char const *name, gbVec3 v);
GBGL_DEF void gbgl_set_uniform_vec4 (gbglShader *s, char const *name, gbVec4 v);
GBGL_DEF void gbgl_set_uniform_mat4 (gbglShader *s, char const *name, gbMat4 const *m);
GBGL_DEF void gbgl_set_uniform_mat4_count(gbglShader *s, char const *name, gbMat4 const *m, isize count);
GBGL_DEF void gbgl_set_uniform_colour (gbglShader *s, char const *name, gbColour col);
////////////////////////////////////////////////////////////////
//
// Texture
//
//
typedef enum gbglTextureType {
GBGL_TEXTURE_TYPE_2D,
GBGL_TEXTURE_TYPE_CUBE_MAP,
GBGL_TEXTURE_TYPE_COUNT,
} gbglTextureType;
gb_global i32 const GBGL_TEXTURE_TYPE[GBGL_TEXTURE_TYPE_COUNT] = {
GL_TEXTURE_2D, /* GBGL_TEXTURE_TYPE_2D */
GL_TEXTURE_CUBE_MAP, /* GBGL_TEXTURE_TYPE_CUBE_MAP */
};
typedef struct gbglTexture {
i32 width, height;
i32 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, gbColour 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 GBGL_COLOUR_BUFFER_ATTACHMENTS[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
//
//
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 {
GBGL_JUSTIFY_LEFT,
GBGL_JUSTIFY_CENTRE,
GBGL_JUSTIFY_RIGHT,
} gbglJustifyType;
typedef enum gbglTextParamType {
GBGL_TEXT_PARAM_INVALID,
GBGL_TEXT_PARAM_MAX_WIDTH,
GBGL_TEXT_PARAM_JUSTIFY,
GBGL_TEXT_PARAM_TEXTURE_FILTER,
GBGL_TEXT_PARAM_COUNT,
} gbglTextParamType;
typedef struct gbglTextParam {
gbglTextParamType type;
union {
f32 val_f32;
i32 val_i32;
gbVec2 val_vec2;
};
} 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;
} 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;
GBGL_DEF gbglFont *gbgl_get_font (gbglFontCache *fc, char const *ttf_filename, f32 font_size);
GBGL_DEF gbglFont *gbgl_get_font_only(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 GB_COMPARE_PROC(gbgl_font_glyph_map_search_proc);
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_kern_amt_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);
////////////////////////////////////////////////////////////////
//
// 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
#ifndef GBGL_MAX_RENDER_STRING_LENGTH
#define GBGL_MAX_RENDER_STRING_LENGTH 4096
#endif
#ifndef GBGL_TEXT_PARAM_STACK_SIZE
#define GBGL_TEXT_PARAM_STACK_SIZE 128
#endif
#ifndef GBGL_FONT_CHAR_LIST
#define GBGL_FONT_CHAR_LIST "Āā㥹ĆćĈĉĊċČčĎďĐđĒēĔĕĖėĘęĚěĜĝĞğĠġĢģĤĥĨĩĪīĬĭĮįİıIJijĴĵĶķĸĹĺĻļĽľŁłŃńŅņņŇňʼnŊŋŌōōŎŏŐőŒœŕŖŗŘřŚśŜŝŞşŠšŢţŤťŨũŪūŬŭŮůŰűŲųŴŵŶŷŸŹźŻżŽža!ö\"#$%%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~Šš?ŒœŸÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõøùúûüýþÿ®™"
#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
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;
gbMat4 ortho_mat;
i32 width, height;
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[GBGL_TEXT_PARAM_STACK_SIZE];
isize text_param_stack_count;
gbglTextParam text_params[GBGL_TEXT_PARAM_COUNT];
} 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, gbVec2 pos, gbVec2 dim, b32 v_up);
GBGL_DEF void gbgl_bs_draw_rect(gbglBasicState *bs, gbVec2 pos, gbVec2 dim, gbColour col);
GBGL_DEF void gbgl_bs_draw_rect_outline(gbglBasicState *bs, gbVec2 pos, gbVec2 dim, gbColour col, f32 thickness);
GBGL_DEF void gbgl_bs_draw_quad(gbglBasicState *bs,
gbVec2 p0, gbVec2 p1, gbVec2 p2, gbVec2 p3,
gbColour col);
GBGL_DEF void gbgl_bs_draw_quad_outline(gbglBasicState *bs,
gbVec2 p0, gbVec2 p1, gbVec2 p2, gbVec2 p3,
gbColour col, f32 thickness);
GBGL_DEF void gbgl_bs_draw_line(gbglBasicState *bs, gbVec2 p0, gbVec2 p1, gbColour col, f32 thickness);
GBGL_DEF void gbgl_bs_draw_circle(gbglBasicState *bs, gbVec2 p, f32 radius, gbColour col);
GBGL_DEF void gbgl_bs_draw_circle_outline(gbglBasicState *bs, gbVec2 p, f32 radius, gbColour col, f32 thickness);
GBGL_DEF isize gbgl_bs_draw_substring(gbglBasicState *bs, gbglFont *font, i32 x, i32 y, gbColour col, char const *str, isize len);
GBGL_DEF isize gbgl_bs_draw_string (gbglBasicState *bs, gbglFont *font, i32 x, i32 y, gbColour col, char const *fmt, ...);
GBGL_DEF isize gbgl_bs_draw_string_va(gbglBasicState *bs, gbglFont *font, i32 x, i32 y, gbColour col, char const *fmt, va_list va);
#if defined(__cplusplus)
}
#endif
#endif
////////////////////////////////////////////////////////////////
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// Implementation //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
// //
////////////////////////////////////////////////////////////////
#if defined(GBGL_IMPLEMENTATION)
u32
gbgl_generate_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__get_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 = GBGL_SHADER_ERROR_NONE;
if (!gb_open_file(&shader->files[type], "%s%s", name, GBGL_SHADER_FILE_EXTENSIONS[type])) {
err = GBGL_SHADER_ERROR_UNABLE_TO_READ_FILE;
} 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);
// TODO(bill): LOG MALLOC USAGE
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(GBGL_SHADER_TYPE[type]);
glShaderSource(shader->shaders[type], 1, &file_source, NULL);
glCompileShader(shader->shaders[type]);
glGetShaderiv(shader->shaders[type], GL_COMPILE_STATUS, &params);
if (!params) {
gb_fprintf(stderr, "Shader Source:\n%s\n", file_source);
glGetShaderInfoLog(shader->shaders[type], gb_size_of(info_log), NULL, info_log);
gb_fprintf(stderr, "Shader compilation failed:\n %s\n", info_log);
err = GBGL_SHADER_ERROR_SHADER_COMPILE;
}
gbgl_free(file_source);
}
gb_close_file(&shader->files[type]);
}
return err;
}
gbglShaderError
gbgl__load_single_shader_from_source(gbglShader *s, gbglShaderType type, char const *text)
{
gbglShaderError err = GBGL_SHADER_ERROR_NONE;
i32 status;
s->shaders[type] = glCreateShader(GBGL_SHADER_TYPE[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_fprintf(stderr, "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_fprintf(stderr, log_info);
err = GBGL_SHADER_ERROR_SHADER_COMPILE;
}
return err;
}
gbglShaderError
gbgl__link_shader(gbglShader *shader)
{
gbglShaderError err = GBGL_SHADER_ERROR_NONE;
i32 i, status;
shader->program = glCreateProgram();
for (i = 0; i < GBGL_SHADER_TYPE_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_fprintf(stderr, "Shader linking failed:\n %s \n", log_info);
err = GBGL_SHADER_ERROR_LINKING;
}
for (i = 0; i < GBGL_SHADER_TYPE_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 = GBGL_SHADER_ERROR_NONE;
b32 loaded_shader[GBGL_SHADER_TYPE_COUNT] = {0};
i32 i;
gb_zero_struct(shader);
shader->type_flags = type_bits;
gb_strncpy(shader->base_name, filename, gb_size_of(shader->base_name));
for (i = 0; i < GBGL_SHADER_TYPE_COUNT; i++) {
if (type_bits & GB_BIT(i)) {
err = gbgl__load_single_shader_from_file(shader, cast(gbglShaderType)i, filename);
if (err != GBGL_SHADER_ERROR_NONE)
return err;
loaded_shader[i] = true;
}
}
err = gbgl__link_shader(shader);
return err;
}
gbglShaderError
gbgl_load_shader_vf_from_source(gbglShader *s, char const *vert_source, char const *frag_source)
{
gbglShaderError err = GBGL_SHADER_ERROR_NONE;
gb_zero_struct(s);
s->type_flags = GB_BIT(GBGL_SHADER_TYPE_VERTEX) | GB_BIT(GBGL_SHADER_TYPE_FRAGMENT);
err = gbgl__load_single_shader_from_source(s, GBGL_SHADER_TYPE_VERTEX, vert_source);
if (err != GBGL_SHADER_ERROR_NONE) return err;
err = gbgl__load_single_shader_from_source(s, GBGL_SHADER_TYPE_FRAGMENT, frag_source);
if (err != GBGL_SHADER_ERROR_NONE) return err;
err = gbgl__link_shader(s);
return err;
}
gbglShaderError
gbgl_load_shader_vfg_from_source(gbglShader *s, char const *vert_source, char const *frag_source, char const *geom_source)
{
gbglShaderError err = GBGL_SHADER_ERROR_NONE;
gb_zero_struct(s);
s->type_flags = GB_BIT(GBGL_SHADER_TYPE_VERTEX) | GB_BIT(GBGL_SHADER_TYPE_FRAGMENT) | GB_BIT(GBGL_SHADER_TYPE_GEOMETRY);
err = gbgl__load_single_shader_from_source(s, GBGL_SHADER_TYPE_VERTEX, vert_source);
if (err != GBGL_SHADER_ERROR_NONE) return err;
err = gbgl__load_single_shader_from_source(s, GBGL_SHADER_TYPE_FRAGMENT, frag_source);
if (err != GBGL_SHADER_ERROR_NONE) return err;
err = gbgl__load_single_shader_from_source(s, GBGL_SHADER_TYPE_GEOMETRY, geom_source);
if (err != GBGL_SHADER_ERROR_NONE) return err;
err = gbgl__link_shader(s);
return err;
}
gb_inline void
gbgl_destroy_shader(gbglShader *shader)
{
i32 i;
for (i = 0; i < GBGL_SHADER_TYPE_COUNT; i++) {
if (shader->type_flags & GB_BIT(i)) {
gb_close_file(&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 < GBGL_SHADER_TYPE_COUNT; i++) {
if (shader->type_flags & GB_BIT(i)) {
if (gb_has_file_changed(&shader->files[i])) {
return true;
}
}
}
return false;
}
b32
gbgl_reload_shader(gbglShader *shader)
{
i32 i;
for (i = 0; i < GBGL_SHADER_TYPE_COUNT; i++) {
if (shader->type_flags & GB_BIT(i)) {
if (gbgl__load_single_shader_from_file(shader, cast(gbglShaderType)i, shader->base_name) != GBGL_SHADER_ERROR_NONE)
return false;
}
}
if (gbgl__link_shader(shader) != GBGL_SHADER_ERROR_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_cstring(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, gbVec2 v)
{
glUniform2fv(gbgl_get_uniform(s, name), 1, v.e);
}
gb_inline void
gbgl_set_uniform_vec3(gbglShader *s, char const *name, gbVec3 v)
{
glUniform3fv(gbgl_get_uniform(s, name), 1, v.e);
}
gb_inline void
gbgl_set_uniform_vec4(gbglShader *s, char const *name, gbVec4 v)
{
glUniform4fv(gbgl_get_uniform(s, name), 1, v.e);
}
gb_inline void
gbgl_set_uniform_mat4(gbglShader *s, char const *name, gbMat4 const *m)
{
gbgl_set_uniform_mat4_count(s, name, m, 1);
}
gb_inline void
gbgl_set_uniform_mat4_count(gbglShader *s, char const *name, gbMat4 const *m, isize count)
{
glUniformMatrix4fv(gbgl_get_uniform(s, name), count, false, cast(f32 const *)m);
}
gb_inline void
gbgl_set_uniform_colour(gbglShader *s, char const *name, gbColour col)
{
gbVec4 v;
v.r = col.r / 255.0f;
v.g = col.g / 255.0f;
v.b = col.b / 255.0f;
v.a = col.a / 255.0f;
gbgl_set_uniform_vec4(s, name, v);
}
////////////////////////////////////////////////////////////////
//
// Render Buffer
//
//
#if 0
b32
gbgl_render_buffer_init(gbglRenderBuffer *in_out_rb)
{
i32 i;
if (in_out_rb->colour_buffer_count >= GBGL_MAX_RENDER_COLOUR_BUFFERS) {
return false;
}
glGenFramebuffers(1, &in_out_rb->gl_frame_buffer_handle);
glBindFramebuffer(GL_FRAMEBUFFER, in_out_rb->gl_frame_buffer_handle);
glGenTextures(in_out_rb->colour_buffer_count, in_out_rb->handles);
for (i = 0; i < in_out_rb->colour_buffer_count; i++) {
i32 channel_count = in_out_rb->channel_count[i];
glBindTexture(GL_TEXTURE_2D, in_out_rb->handles[i]);
glTexImage2D(GL_TEXTURE_2D, 0,
GBGL_INTERNAL_TEXTURE_FORMAT_8[channel_count-1],
in_out_rb->width, in_out_rb->height, 0,
GBGL_TEXTURE_FORMAT[channel_count-1],
in_out_rb->data_type[0], 0);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0 + i, GL_TEXTURE_2D,
in_out_rb->handles[0], 0);
}
glDrawBuffers(in_out_rb->colour_buffer_count, GBGL_COLOUR_BUFFER_ATTACHMENTS);
//@TODO: not every valid permutation has been tested, it's likely that there's a format/internal format mismatch somewhere
if (in_out_rb->has_depth || in_out_rb->has_stencil) {
if (in_out_rb->has_depth && in_out_rb->has_stencil) {
glGenRenderbuffers(1, &in_out_rb->gl_depth_stencil_buffer_handle);
glBindRenderbuffer(GL_RENDERBUFFER, in_out_rb->gl_depth_stencil_buffer_handle);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, in_out_rb->width, in_out_rb->height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, in_out_rb->gl_depth_stencil_buffer_handle);
} else if (in_out_rb->has_depth) {
glGenRenderbuffers(1, &in_out_rb->gl_depth_stencil_buffer_handle);
glBindRenderbuffer(GL_RENDERBUFFER, in_out_rb->gl_depth_stencil_buffer_handle);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, in_out_rb->width, in_out_rb->height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, in_out_rb->gl_depth_stencil_buffer_handle);
} else if (in_out_rb->has_stencil) {
GB_PANIC("A framebuffer cannot have a stencil without depth"); // NOTE(bill): no stencil w/o depth
}
}
in_out_rb->gl_frame_buffer_status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (in_out_rb->gl_frame_buffer_status != GL_FRAMEBUFFER_COMPLETE) {
gb_fprintf(stderr, "Unable to create OpenGL Frame buffer. Frame buffer incomplete: %d\n", in_out_rb->gl_frame_buffer_status);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return in_out_rb->gl_frame_buffer_status == GL_FRAMEBUFFER_COMPLETE;
}
#endif
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_struct(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_fprintf(stderr, "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_struct(tex);
tex->width = width;
tex->height = height;
tex->channel_count = channel_count;
tex->data_type = GBGL_BDT_U8;
tex->type = GBGL_TEXTURE_TYPE_2D;
glGenTextures(1, &tex->handle);
glBindTexture(GL_TEXTURE_2D, tex->handle);
glTexImage2D(GL_TEXTURE_2D, 0,
GBGL_INTERNAL_TEXTURE_FORMAT_8[channel_count-1],
width, height, 0,
GBGL_TEXTURE_FORMAT[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_sprintf_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_fprintf(stderr, "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, gbColour colour)
{
return gbgl_load_texture2d_from_memory(t, &colour.rgba, 1, 1, 4);
}
void
gbgl_bind_texture2d(gbglTexture const *t, u32 position, u32 sampler)
{
GB_ASSERT(t->type == GBGL_TEXTURE_TYPE_2D);
if (position > 31) {
position = 31;
gb_fprintf(stderr, "Textures can only bound to position [0 ... 31]\n");
gb_fprintf(stderr, "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
//
//
gb_inline i32
gbgl__sort_kern_pair(void const *a, void const *b)
{
gbglKernPair *kp0 = cast(gbglKernPair *)a;
gbglKernPair *kp1 = cast(gbglKernPair *)b;
return kp0->packed - kp1->packed;
}
gb_inline i32
gbgl__glypth_map_sort(void const *a, void const *b)
{
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, 0, *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);
STBRP_SORT(cache->rect_cache, cache->codepoint_count, gb_size_of(cache->rect_cache[0]), 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, 0, *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;
}
gb_inline gbglFont *
gbgl_get_font(gbglFontCache *fc, char const *ttf_filename, f32 font_size)
{
gbglFont *f = gbgl_get_font_only(fc, ttf_filename, font_size);
if (f) {
return f;
} else {
return gbgl_cache_font(fc, ttf_filename, font_size);
}
}
gb_inline gbglFont *
gbgl_get_font_only(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)
{
gbglFontCache *font_cache = fc;
gbglFont *f = gbgl_get_font_only(fc, ttf_filename, font_size);
gbglFontCachedTTF *ttf = NULL;
isize i;
if (f)
return f;
if (!font_cache->fonts) {
font_cache->fonts = cast(gbglFont *)gbgl_malloc(gb_size_of(gbglFont));
f = font_cache->fonts;
} else {
f = font_cache->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)
return NULL;
gb_zero_struct(f);
// NOTE(bill): Make sure the character list file has been loaded
if (!font_cache->font_char_list) {
isize codepoint_count = 0, cpi = 0;
font_cache->font_char_list = GBGL_FONT_CHAR_LIST;
font_cache->font_char_list_count = gb_strlen(GBGL_FONT_CHAR_LIST);
for (i = 0; i < font_cache->font_char_list_count; i++) {
char32 c;
isize utf8_len = gb_utf8_decode_len(font_cache->font_char_list + i, font_cache->font_char_list_count, &c);
i += utf8_len-1;
codepoint_count++;
}
font_cache->codepoint_count = codepoint_count;
font_cache->ranges = cast(stbtt_pack_range *)gbgl_malloc(gb_size_of(stbtt_pack_range) * codepoint_count);
font_cache->codepoints = cast(char32 *) gbgl_malloc(gb_size_of(char32) * codepoint_count);
font_cache->packed_char_data = cast(stbtt_packedchar *)gbgl_malloc(gb_size_of(stbtt_packedchar) * codepoint_count);
font_cache->rect_cache = cast(stbrp_rect *) gbgl_malloc(gb_size_of(stbrp_rect) * codepoint_count);
if (!font_cache->ranges || !font_cache->codepoints || !font_cache->packed_char_data) {
gb_fprintf(stderr, "Unable to get memory for fonts");
}
for (i = 0; i < font_cache->font_char_list_count; i++) {
isize utf8_len = gb_utf8_decode_len(font_cache->font_char_list+i, font_cache->font_char_list_count, font_cache->codepoints+cpi);
i += utf8_len-1;
cpi++;
}
GB_ASSERT(cpi == font_cache->codepoint_count);
for (i = 0; i < font_cache->codepoint_count; i++) {
font_cache->ranges[i].first_unicode_codepoint_in_range = font_cache->codepoints[i];
font_cache->ranges[i].array_of_unicode_codepoints = 0;
font_cache->ranges[i].num_chars = 1;
font_cache->ranges[i].chardata_for_range = font_cache->packed_char_data + i;
}
}
{
gbglFontCachedTTF **ttf_cache = &font_cache->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;
*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_struct(&(*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';
{
gbFile file;
if (gb_open_file(&file, ttf_filename)) {
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_close_file(&file);
} else {
GB_PANIC("Could not open ttf file: %s", ttf_filename);
}
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 < font_cache->codepoint_count; i++)
font_cache->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(font_cache, ttf, &w, &h)) {
isize str_len, i, j;
// NOTE(bill): Setup the font data
f->glyph_count = font_cache->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, 0);
GB_ASSERT(res == 1);
res = stbtt_PackFontRanges(&spc, ttf->ttf, 0, font_cache->ranges, font_cache->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)font_cache->packed_char_data[i].x0;
gi->t0 = cast(f32)font_cache->packed_char_data[i].y0;
gi->s1 = cast(f32)font_cache->packed_char_data[i].x1;
gi->t1 = cast(f32)font_cache->packed_char_data[i].y1;
gi->xoff = cast(i16)font_cache->packed_char_data[i].xoff;
gi->yoff = cast(i16)font_cache->packed_char_data[i].yoff;
gi->xadv = font_cache->packed_char_data[i].xadvance;
}
for (i = 0; i < f->glyph_count; i++) {
f->glyph_map[i].codepoint = font_cache->codepoints[i];
f->glyph_map[i].index = i;
}
gb_qsort(f->glyph_map, f->glyph_count, gb_size_of(*f->glyph_map), gbgl__glypth_map_sort);
{ // 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, font_cache->codepoints[i], font_cache->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, font_cache->codepoints[i], font_cache->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_qsort(f->kern_table, f->kern_pair_count, gb_size_of(f->kern_table[0]), gbgl__sort_kern_pair);
}
}
}
} else {
GB_PANIC("Failure loading font");
gb_zero_struct(&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);
}
gbglGlyphInfo *
gbgl_get_glyph_info(gbglFont *font, char32 codepoint, isize *out_index)
{
isize index = gb_binary_search(font->glyph_map, font->glyph_count, gb_size_of(*font->glyph_map), &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;
}
f32
gbgl_get_font_kern_amt_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_kern_amt_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_kern_amt_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_kern_amt_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);
}
////////////////////////////////////////////////////////////////
//
// 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_generate_sampler(GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
bs->linear_sampler = gbgl_generate_sampler(GL_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
gbgl_load_shader_vf_from_source(&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_vf_from_source(&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");
gbgl_load_shader_vf_from_source(&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"
" float alpha = texture2D(u_tex, v_tex_coord).r;\n"
" o_colour = u_colour * alpha;\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_generate_sampler(GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
bs->font_samplers[1] = gbgl_generate_sampler(GL_LINEAR, GL_LINEAR, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
bs->text_params[GBGL_TEXT_PARAM_MAX_WIDTH].val_i32 = 0;
bs->text_params[GBGL_TEXT_PARAM_JUSTIFY].val_i32 = GBGL_JUSTIFY_LEFT;
bs->text_params[GBGL_TEXT_PARAM_TEXTURE_FILTER].val_i32 = 0;
}
void
gbgl_bs_set_resolution(gbglBasicState *bs, i32 window_width, i32 window_height)
{
bs->width = window_width;
bs->height = window_height;
gb_mat4_ortho2d(&bs->ortho_mat, 0, bs->width, 0, bs->height);
}
void
gbgl_bs_begin(gbglBasicState *bs, i32 window_width, i32 window_height)
{
glBindVertexArray(bs->vao);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_CULL_FACE);
gbgl_bs_set_resolution(bs, window_width, window_height);
}
void
gbgl_bs_end(gbglBasicState *bs)
{
glBindVertexArray(0);
}
void
gbgl_bs_draw_textured_rect(gbglBasicState *bs, gbglTexture *tex, gbVec2 pos, gbVec2 dim, b32 v_up)
{
bs->vertices[0].x = pos.x;
bs->vertices[0].y = pos.y;
bs->vertices[0].u = 0.0f;
bs->vertices[0].v = v_up ? 0.0f : 1.0f;
bs->vertices[1].x = pos.x + dim.x;
bs->vertices[1].y = pos.y;
bs->vertices[1].u = 1.0f;
bs->vertices[1].v = v_up ? 0.0f : 1.0f;
bs->vertices[2].x = pos.x + dim.x;
bs->vertices[2].y = pos.y + dim.y;
bs->vertices[2].u = 1.0f;
bs->vertices[2].v = v_up ? 1.0f : 0.0f;
bs->vertices[3].x = pos.x;
bs->vertices[3].y = pos.y + dim.y;
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);
}
void
gbgl_bs_draw_rect(gbglBasicState *bs, gbVec2 pos, gbVec2 dim, gbColour col)
{
gbgl_bs_draw_quad(bs,
gb_vec2(pos.x, pos.y),
gb_vec2(pos.x+dim.x, pos.y),
gb_vec2(pos.x+dim.x, pos.y+dim.y),
gb_vec2(pos.x, pos.y+dim.y),
col);
}
void
gbgl_bs_draw_rect_outline(gbglBasicState *bs, gbVec2 pos, gbVec2 dim, gbColour col, f32 thickness)
{
gbgl_bs_draw_quad_outline(bs,
gb_vec2(pos.x, pos.y),
gb_vec2(pos.x+dim.x, pos.y),
gb_vec2(pos.x+dim.x, pos.y+dim.y),
gb_vec2(pos.x, pos.y+dim.y),
col,
thickness);
}
gb_internal void
gbgl__bs_setup_ortho_colour_state(gbglBasicState *bs, isize vertex_count, gbColour col)
{
gbVec4 vcol = gb_vec4(col.r/255.0f, col.g/255.0f, col.b/255.0f, col.a/255.0f);
gbgl_use_shader(&bs->ortho_col_shader);
gbgl_set_uniform_mat4(&bs->ortho_col_shader, "u_ortho_mat", &bs->ortho_mat);
gbgl_set_uniform_vec4(&bs->ortho_col_shader, "u_colour", vcol);
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);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
void
gbgl_bs_draw_quad(gbglBasicState *bs,
gbVec2 p0, gbVec2 p1, gbVec2 p2, gbVec2 p3, gbColour col)
{
bs->vertices[0].x = p0.x;
bs->vertices[0].y = p0.y;
bs->vertices[1].x = p1.x;
bs->vertices[1].y = p1.y;
bs->vertices[2].x = p2.x;
bs->vertices[2].y = p2.y;
bs->vertices[3].x = p3.x;
bs->vertices[3].y = p3.y;
gbgl__bs_setup_ortho_colour_state(bs, 4, col);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, NULL);
}
void
gbgl_bs_draw_quad_outline(gbglBasicState *bs, gbVec2 p0, gbVec2 p1, gbVec2 p2, gbVec2 p3, gbColour col, f32 thickness)
{
bs->vertices[0].x = p0.x;
bs->vertices[0].y = p0.y;
bs->vertices[1].x = p1.x;
bs->vertices[1].y = p1.y;
bs->vertices[2].x = p2.x;
bs->vertices[2].y = p2.y;
bs->vertices[3].x = p3.x;
bs->vertices[3].y = p3.y;
gbgl__bs_setup_ortho_colour_state(bs, 4, col);
glLineWidth(thickness);
glDrawArrays(GL_LINE_LOOP, 0, 4);
}
void
gbgl_bs_draw_line(gbglBasicState *bs, gbVec2 p0, gbVec2 p1, gbColour col, f32 thickness)
{
bs->vertices[0].x = p0.x;
bs->vertices[0].y = p0.y;
bs->vertices[1].x = p1.x;
bs->vertices[1].y = p1.y;
gbgl__bs_setup_ortho_colour_state(bs, 2, col);
glLineWidth(thickness);
glDrawArrays(GL_LINES, 0, 2);
}
void
gbgl_bs_draw_circle(gbglBasicState *bs, gbVec2 p, f32 radius, gbColour col)
{
isize i;
bs->vertices[0].x = p.x;
bs->vertices[0].y = p.y;
for (i = 0; i < 31; i++) {
f32 t = cast(f32)i / 30.0f;
f32 theta = t * GB_MATH_TAU;
f32 c = gb_cos(theta);
f32 s = gb_sin(theta);
bs->vertices[i+1].x = p.x + c*radius;
bs->vertices[i+1].y = p.y + s*radius;
}
gbgl__bs_setup_ortho_colour_state(bs, 32, col);
glDrawArrays(GL_TRIANGLE_FAN, 0, 32);
}
void
gbgl_bs_draw_circle_outline(gbglBasicState *bs, gbVec2 p, f32 radius, gbColour col, f32 thickness)
{
isize i;
for (i = 0; i < 32; i++) {
f32 t = cast(f32)i / 31.0f;
f32 theta = t * GB_MATH_TAU;
f32 c = gb_cos(theta);
f32 s = gb_sin(theta);
bs->vertices[i].x = p.x + c*radius;
bs->vertices[i].y = p.y + s*radius;
}
gbgl__bs_setup_ortho_colour_state(bs, 32, col);
glLineWidth(thickness);
glDrawArrays(GL_LINE_LOOP, 0, 32);
}
isize
gbgl_bs_draw_substring(gbglBasicState *bs, gbglFont *font, i32 x, i32 y, gbColour col, char const *str, isize len)
{
isize char_count = gb_utf8_strnlen(str, len);
if (char_count <= 0) {
return 0;
} else {
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 line_count = 1, glyph_count = 0, i;
f32 font_height = font->size;
i32 max_width = bs->text_params[GBGL_TEXT_PARAM_MAX_WIDTH].val_i32;
f32 max_width32 = cast(f32)max_width;
gbglJustifyType justify = cast(gbglJustifyType)bs->text_params[GBGL_TEXT_PARAM_JUSTIFY].val_i32;
if (justify == GBGL_JUSTIFY_CENTRE) {
f32 width;
gbgl_get_string_dimensions(font, ptr, &width, NULL);
x = cast(i32)gb_round(cast(f32)x - width*0.5f);
} else if (justify == GBGL_JUSTIFY_RIGHT) {
f32 width;
gbgl_get_string_dimensions(font, ptr, &width, NULL);
x = cast(i32)gb_round(cast(f32)x - width);
}
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;
gi = gbgl_get_glyph_info(font, cp, &curr_index);
if (!gi) {
gi = gbgl_get_glyph_info(font, ' ', &curr_index);
}
if (cp == '\t')
draw_this_glyph_count = GBGL_TAB_CHARACTER_WIDTH;
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 >= max_width32)) {
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 = x0;
bs->font_vertices[glyph_count*4 + 1].y = y1;
bs->font_vertices[glyph_count*4 + 1].u = s0;
bs->font_vertices[glyph_count*4 + 1].v = t1;
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 = x1;
bs->font_vertices[glyph_count*4 + 3].y = y0;
bs->font_vertices[glyph_count*4 + 3].u = s1;
bs->font_vertices[glyph_count*4 + 3].v = t0;
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_kern_amt_from_glyph_indices(font, curr_index, next_index);
}
}
px += gi->xadv + kern;
}
}
}
{
isize sampler_handle = 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[GBGL_TEXT_PARAM_TEXTURE_FILTER].val_i32 < gb_count_of(bs->font_samplers));
if (bs->text_params[GBGL_TEXT_PARAM_TEXTURE_FILTER].val_i32 < gb_count_of(bs->font_samplers))
sampler_handle = bs->text_params[GBGL_TEXT_PARAM_TEXTURE_FILTER].val_i32;
gbgl_bind_texture2d(&font->texture, 0, bs->font_samplers[sampler_handle]);
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, i32 x, i32 y, gbColour 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;
}
isize
gbgl_bs_draw_string_va(gbglBasicState *bs, gbglFont *font, i32 x, i32 y, gbColour 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
View Git Blame Copy Permalink