path: root/util/sokol_spritebatch.h

#if defined(SOKOL_IMPL) && !defined(SOKOL_SPRITEBATCH_IMPL)
#define SOKOL_SPRITEBATCH_IMPL
#endif

#ifndef SOKOL_SPRITEBATCH_INCLUDED
#define SOKOL_SPRITEBATCH_INCLUDED (1)

#if !defined(SOKOL_GFX_INCLUDED)
#error "Please include sokol_gfx.h before sokol_spritebatch.h"
#endif

#if defined(SOKOL_API_DECL) && !defined(SOKOL_SPRITEBATCH_API_DECL)
#define SOKOL_SPRITEBATCH_API_DECL SOKOL_API_DECL
#endif
#ifndef SOKOL_SPRITEBATCH_API_DECL
#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_SPRITEBATCH_IMPL)
#define SOKOL_SPRITEBATCH_API_DECL __declspec(dllexport)
#elif defined(_WIN32) && defined(SOKOL_DLL)
#define SOKOL_SPRITEBATCH_API_DECL __declspec(dllimport)
#else
#define SOKOL_SPRITEBATCH_API_DECL extern
#endif
#endif

typedef enum sb_sprite_flags {
    SB_FLIP_NONE = 0,
    SB_FLIP_X    = 1 << 0,
    SB_FLIP_Y    = 1 << 1,
    SB_FLIP_BOTH = SB_FLIP_Y | SB_FLIP_X,
    SB_Z_TILT    = 1<< 2
} sb_sprite_flags;

typedef enum sb_sort_mode {
    SB_SORT_MODE_DEFERRED,
    SB_SORT_MODE_TEXTURE,
    SB_SORT_MODE_BACK_TO_FRONT,
    SB_SORT_MODE_FRONT_TO_BACK
} sb_sort_mode;

typedef struct sb_float2 {
    float x;
    float y;
} sb_float2;

typedef struct sb_sprite_info {
    sg_image  image;
    float     width;
    float     height;
    sb_float2 position;
    float     depth;
    float     rotation;
    sb_float2 origin;
    sb_float2 scale;
    uint32_t  flags;
    sb_float2 source;
    sg_color  color;
} sb_sprite_info;

typedef struct sb_desc {
    int max_quads;
} sb_desc;

typedef struct sb_matrix {
  float m[4][4];
} sb_matrix;

typedef struct sb_viewport {
    int x, y, width, height;
    bool origin_top_left;
} sb_viewport;

typedef struct sb_render_state {
    sb_sort_mode sort_mode;
    sg_pipeline  pipeline;
    sb_matrix    transform_matrix;
    sb_viewport  viewport;
} sb_render_state;

SOKOL_SPRITEBATCH_API_DECL void sb_setup(const sb_desc* desc);
SOKOL_SPRITEBATCH_API_DECL void sb_shutdown(void);

SOKOL_SPRITEBATCH_API_DECL void sb_begin(const sb_render_state* render_state);
SOKOL_SPRITEBATCH_API_DECL void sb_sprite(const sb_sprite_info* sprite);
SOKOL_SPRITEBATCH_API_DECL void sb_end(void);

SOKOL_SPRITEBATCH_API_DECL void sb_draw(void);

SOKOL_SPRITEBATCH_API_DECL void sb_premultiply_alpha(uint8_t* pixels, int pixel_count);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* SOKOL_SPRITEBATCH_INCLUDED */

/*-- IMPLEMENTATION ----------------------------------------------------------*/
#ifdef SOKOL_SPRITEBATCH_IMPL
#define SOKOL_SPRITEBATCH_IMPL_INCLUDED (1)

#include <string.h> /* memset */
#include <math.h>   /* sinf, cosf */

#ifndef SOKOL_API_IMPL
    #define SOKOL_API_IMPL
#endif

#ifndef SOKOL_ASSERT
    #include <assert.h>
    #define SOKOL_ASSERT(c) assert(c)
#endif

#ifndef SOKOL_MALLOC
    #include <stdlib.h>
    #define SOKOL_MALLOC(s) malloc(s)
    #define SOKOL_FREE(result) free(result)
#endif

#define _SB_IMAGE_SLOT_MASK (0xFFFF)
#define _SB_DEFAULT(val, def) (((val) == 0) ? (def) : (val))
#define _SB_MAX_VERTICES (1 << 16)
#define _SB_MAX_QUADS (_SB_MAX_VERTICES / 4)
#define _SB_MAX_INDICES (_SB_MAX_QUADS * 6)
#define _SB_INITIAL_BATCH_CAPACITY 32

#ifndef SB_MAX_DEPTH
#define SB_MAX_DEPTH 1000.0f
#endif

typedef struct {
    sg_image image;
    int      width;
    int      height;
} _sb_sprite_data;

typedef struct {
    float    x;
    float    y;
    float    z;
    float    u;
    float    v;
    uint32_t rgba;
} _sb_vertex;

typedef struct {
    _sb_vertex top_left;
    _sb_vertex top_right;
    _sb_vertex bottom_left;
    _sb_vertex bottom_right;
    sg_image   image;
    uint64_t   sort_key;
} _sb_quad;

typedef struct {
    _sb_sprite_data* data;
    size_t           size;
} _sb_sprite_pool;

typedef struct {
    sg_image  image;
    int       base_element;
    int       num_elements;
    sb_matrix matrix;
} _sb_batch;

typedef struct {
    size_t     batch_size;
    size_t     batch_capacity;
    _sb_batch* batches;
} _sb_batch_data;

typedef struct {
    _sb_sprite_pool sprite_pool;
    _sb_quad*       quads;
    size_t          quad_count;
    _sb_vertex*     vertex_buffer_data;
    sg_buffer       vertex_buffer;
    sg_buffer       index_buffer;
    _sb_batch_data  batch_data;
    sg_bindings     bindings;
    bool            begin_called;
    sb_render_state render_state;
    sg_shader       default_shader;
    sg_pipeline     default_pipeline;
    sb_matrix       projection_matrix;
} _sb_t;

static _sb_t _sb;

#if defined(SOKOL_D3D11)
static const uint8_t vs_bytecode_hlsl4[884] = {
    0x44,0x58,0x42,0x43,0x5f,0x8c,0xaf,0xe1,0x5e,0x2d,0xba,0x0e,0x85,0xba,0xeb,0xc5,
    0x0c,0x64,0x6d,0x0c,0x01,0x00,0x00,0x00,0x74,0x03,0x00,0x00,0x05,0x00,0x00,0x00,
    0x34,0x00,0x00,0x00,0xf4,0x00,0x00,0x00,0x58,0x01,0x00,0x00,0xc8,0x01,0x00,0x00,
    0xf8,0x02,0x00,0x00,0x52,0x44,0x45,0x46,0xb8,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
    0x48,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x00,0x04,0xfe,0xff,
    0x10,0x81,0x00,0x00,0x90,0x00,0x00,0x00,0x3c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x76,0x73,0x5f,0x70,0x61,0x72,0x61,0x6d,
    0x73,0x00,0xab,0xab,0x3c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x60,0x00,0x00,0x00,
    0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x80,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x5f,0x32,0x31,0x5f,0x6d,0x76,0x70,0x00,0x02,0x00,0x03,0x00,
    0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x4d,0x69,0x63,0x72,
    0x6f,0x73,0x6f,0x66,0x74,0x20,0x28,0x52,0x29,0x20,0x48,0x4c,0x53,0x4c,0x20,0x53,
    0x68,0x61,0x64,0x65,0x72,0x20,0x43,0x6f,0x6d,0x70,0x69,0x6c,0x65,0x72,0x20,0x31,
    0x30,0x2e,0x31,0x00,0x49,0x53,0x47,0x4e,0x5c,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
    0x08,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x50,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
    0x03,0x03,0x00,0x00,0x50,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x03,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x0f,0x0f,0x00,0x00,0x54,0x45,0x58,0x43,
    0x4f,0x4f,0x52,0x44,0x00,0xab,0xab,0xab,0x4f,0x53,0x47,0x4e,0x68,0x00,0x00,0x00,
    0x03,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x0c,0x00,0x00,
    0x50,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x59,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,
    0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x00,0x53,0x56,0x5f,0x50,0x6f,0x73,0x69,
    0x74,0x69,0x6f,0x6e,0x00,0xab,0xab,0xab,0x53,0x48,0x44,0x52,0x28,0x01,0x00,0x00,
    0x40,0x00,0x01,0x00,0x4a,0x00,0x00,0x00,0x59,0x00,0x00,0x04,0x46,0x8e,0x20,0x00,
    0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x5f,0x00,0x00,0x03,0x72,0x10,0x10,0x00,
    0x00,0x00,0x00,0x00,0x5f,0x00,0x00,0x03,0x32,0x10,0x10,0x00,0x01,0x00,0x00,0x00,
    0x5f,0x00,0x00,0x03,0xf2,0x10,0x10,0x00,0x02,0x00,0x00,0x00,0x65,0x00,0x00,0x03,
    0x32,0x20,0x10,0x00,0x00,0x00,0x00,0x00,0x65,0x00,0x00,0x03,0xf2,0x20,0x10,0x00,
    0x01,0x00,0x00,0x00,0x67,0x00,0x00,0x04,0xf2,0x20,0x10,0x00,0x02,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x68,0x00,0x00,0x02,0x01,0x00,0x00,0x00,0x36,0x00,0x00,0x05,
    0x32,0x20,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x10,0x10,0x00,0x01,0x00,0x00,0x00,
    0x36,0x00,0x00,0x05,0xf2,0x20,0x10,0x00,0x01,0x00,0x00,0x00,0x46,0x1e,0x10,0x00,
    0x02,0x00,0x00,0x00,0x38,0x00,0x00,0x08,0xf2,0x00,0x10,0x00,0x00,0x00,0x00,0x00,
    0x56,0x15,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x8e,0x20,0x00,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x32,0x00,0x00,0x0a,0xf2,0x00,0x10,0x00,0x00,0x00,0x00,0x00,
    0x06,0x10,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x8e,0x20,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x46,0x0e,0x10,0x00,0x00,0x00,0x00,0x00,0x32,0x00,0x00,0x0a,
    0xf2,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0xa6,0x1a,0x10,0x00,0x00,0x00,0x00,0x00,
    0x46,0x8e,0x20,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x46,0x0e,0x10,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xf2,0x20,0x10,0x00,0x02,0x00,0x00,0x00,
    0x46,0x0e,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x8e,0x20,0x00,0x00,0x00,0x00,0x00,
    0x03,0x00,0x00,0x00,0x3e,0x00,0x00,0x01,0x53,0x54,0x41,0x54,0x74,0x00,0x00,0x00,
    0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,
    0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,
};

static const uint8_t fs_bytecode_hlsl4[620] = {
    0x44,0x58,0x42,0x43,0xd1,0x93,0x1f,0x1b,0x9d,0x70,0x90,0xeb,0xc2,0x7c,0x26,0x07,
    0xdf,0x52,0xda,0x49,0x01,0x00,0x00,0x00,0x6c,0x02,0x00,0x00,0x05,0x00,0x00,0x00,
    0x34,0x00,0x00,0x00,0xd4,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x54,0x01,0x00,0x00,
    0xf0,0x01,0x00,0x00,0x52,0x44,0x45,0x46,0x98,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x1c,0x00,0x00,0x00,0x00,0x04,0xff,0xff,
    0x10,0x81,0x00,0x00,0x6d,0x00,0x00,0x00,0x5c,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x69,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
    0x05,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x5f,0x74,0x65,0x78,0x5f,0x73,0x61,0x6d,
    0x70,0x6c,0x65,0x72,0x00,0x74,0x65,0x78,0x00,0x4d,0x69,0x63,0x72,0x6f,0x73,0x6f,
    0x66,0x74,0x20,0x28,0x52,0x29,0x20,0x48,0x4c,0x53,0x4c,0x20,0x53,0x68,0x61,0x64,
    0x65,0x72,0x20,0x43,0x6f,0x6d,0x70,0x69,0x6c,0x65,0x72,0x20,0x31,0x30,0x2e,0x31,
    0x00,0xab,0xab,0xab,0x49,0x53,0x47,0x4e,0x44,0x00,0x00,0x00,0x02,0x00,0x00,0x00,
    0x08,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x00,0x38,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
    0x0f,0x0f,0x00,0x00,0x54,0x45,0x58,0x43,0x4f,0x4f,0x52,0x44,0x00,0xab,0xab,0xab,
    0x4f,0x53,0x47,0x4e,0x2c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x08,0x00,0x00,0x00,
    0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x53,0x56,0x5f,0x54,0x61,0x72,0x67,0x65,
    0x74,0x00,0xab,0xab,0x53,0x48,0x44,0x52,0x94,0x00,0x00,0x00,0x40,0x00,0x00,0x00,
    0x25,0x00,0x00,0x00,0x5a,0x00,0x00,0x03,0x00,0x60,0x10,0x00,0x00,0x00,0x00,0x00,
    0x58,0x18,0x00,0x04,0x00,0x70,0x10,0x00,0x00,0x00,0x00,0x00,0x55,0x55,0x00,0x00,
    0x62,0x10,0x00,0x03,0x32,0x10,0x10,0x00,0x00,0x00,0x00,0x00,0x62,0x10,0x00,0x03,
    0xf2,0x10,0x10,0x00,0x01,0x00,0x00,0x00,0x65,0x00,0x00,0x03,0xf2,0x20,0x10,0x00,
    0x00,0x00,0x00,0x00,0x68,0x00,0x00,0x02,0x01,0x00,0x00,0x00,0x45,0x00,0x00,0x09,
    0xf2,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x10,0x10,0x00,0x00,0x00,0x00,0x00,
    0x46,0x7e,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x10,0x00,0x00,0x00,0x00,0x00,
    0x38,0x00,0x00,0x07,0xf2,0x20,0x10,0x00,0x00,0x00,0x00,0x00,0x46,0x0e,0x10,0x00,
    0x00,0x00,0x00,0x00,0x46,0x1e,0x10,0x00,0x01,0x00,0x00,0x00,0x3e,0x00,0x00,0x01,
    0x53,0x54,0x41,0x54,0x74,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
};
#if !defined(SOKOL_GFX_INCLUDED)
#error "Please include sokol_gfx.h before spritebatch-sapp.glsl.h"
#endif

static inline const sg_shader_desc* spritebatch_shader_desc(sg_backend backend) {
    if (backend == SG_BACKEND_D3D11) {
        static sg_shader_desc desc;
        static bool valid;
        if (!valid) {
            valid = true;
            desc.attrs[0].sem_name = "TEXCOORD";
            desc.attrs[0].sem_index = 0;
            desc.attrs[1].sem_name = "TEXCOORD";
            desc.attrs[1].sem_index = 1;
            desc.attrs[2].sem_name = "TEXCOORD";
            desc.attrs[2].sem_index = 2;
            desc.vs.bytecode.ptr = vs_bytecode_hlsl4;
            desc.vs.bytecode.size = 884;
            desc.vs.entry = "main";
            desc.vs.uniform_blocks[0].size = 64;
            desc.fs.bytecode.ptr = fs_bytecode_hlsl4;
            desc.fs.bytecode.size = 620;
            desc.fs.entry = "main";
            desc.fs.images[0].name = "tex";
            desc.fs.images[0].image_type = SG_IMAGETYPE_2D;
            desc.fs.images[0].sampler_type = SG_SAMPLERTYPE_FLOAT;
            desc.label = "spritebatch_shader";
        };
        return &desc;
    }
    return 0;
}

#endif

static inline bool _sb_matrix_is_null(const sb_matrix* m) {
    for (int y = 0; y < 4; y++) {
        for (int x = 0; x < 4; x++) {
            if (0.0f != m->m[y][x]) {
                return false;
            }
        }
    }
    return true;
}

static inline sb_matrix _sb_matrix_identity(void) {
    sb_matrix m = {
        {
            { 1.0f, 0.0f, 0.0f, 0.0f },
            { 0.0f, 1.0f, 0.0f, 0.0f },
            { 0.0f, 0.0f, 1.0f, 0.0f },
            { 0.0f, 0.0f, 0.0f, 1.0f }
        }
    };
    return m;
}

static inline sb_matrix _sb_orthographic_off_center(float left, float right, float bottom, float top, float near, float far) {
    sb_matrix result;

    result.m[0][0] = 2.0f / (right - left);
    result.m[0][1] = 0.0f;
    result.m[0][2] = 0.0f;
    result.m[0][3] = 0.0f;

    result.m[1][0] = 0.0f;
    result.m[1][1] = 2.0f / (top - bottom);
    result.m[1][2] = 0.0f;
    result.m[1][3] = 0.0f;

    result.m[2][0] = 0.0f;
    result.m[2][1] = 0.0f;
    result.m[2][2] = 1.0f / (near - far);
    result.m[2][3] = 0.0f;

    result.m[3][0] = (left + right) / (left - right);
    result.m[3][1] = (bottom + top) / (bottom - top);
    result.m[3][2] = near / (near - far);
    result.m[3][3] = 1.0f;

    return result;
}

static inline int _sg_image_slot_index(uint32_t id) {
    int slot_index = (int)(id & _SB_IMAGE_SLOT_MASK);
    SOKOL_ASSERT(0 != slot_index);
    return slot_index;
}

static inline void _sb_init_sprite_pool(void) {
    sg_desc sg_desc = sg_query_desc();
    int num_slots = sg_desc.image_pool_size;
    _sb.sprite_pool.size = (size_t)num_slots * sizeof(_sb_sprite_data);
    _sb.sprite_pool.data = (_sb_sprite_data*)SOKOL_MALLOC(_sb.sprite_pool.size);
    SOKOL_ASSERT(_sb.sprite_pool.data);
    memset(_sb.sprite_pool.data, 0, _sb.sprite_pool.size);
}

static inline void _sb_init_batch_data(void) {
    _sb.batch_data.batch_capacity = _SB_INITIAL_BATCH_CAPACITY;
    _sb.batch_data.batches = (_sb_batch*)SOKOL_MALLOC(_SB_INITIAL_BATCH_CAPACITY * sizeof(_sb_batch));
}

static inline void _sb_init_index_buffer(void) {
    uint16_t* index_buffer = (uint16_t*)SOKOL_MALLOC(_SB_MAX_INDICES * sizeof(uint16_t));
    SOKOL_ASSERT(index_buffer);

    uint16_t* index_ptr = index_buffer;
    for (uint32_t i = 0; i < _SB_MAX_QUADS; i++, index_ptr += 6) {
        // Triangle 1
        *(index_ptr + 0) = (uint16_t)(i * 4);
        *(index_ptr + 1) = (uint16_t)(i * 4 + 1);
        *(index_ptr + 2) = (uint16_t)(i * 4 + 2);
        // Triangle 2
        *(index_ptr + 3) = (uint16_t)(i * 4 + 1);
        *(index_ptr + 4) = (uint16_t)(i * 4 + 3);
        *(index_ptr + 5) = (uint16_t)(i * 4 + 2);
    }

    sg_buffer_desc index_buffer_desc;
    memset(&index_buffer_desc, 0, sizeof(index_buffer_desc));
    index_buffer_desc.size      = _SB_MAX_INDICES * sizeof(uint16_t);
    index_buffer_desc.type      = SG_BUFFERTYPE_INDEXBUFFER;
    index_buffer_desc.usage     = SG_USAGE_IMMUTABLE;
    index_buffer_desc.label     = "sokol-spritebatch-indices";
    index_buffer_desc.data.size = _SB_MAX_INDICES * sizeof(uint16_t);
    index_buffer_desc.data.ptr  = index_buffer;
    _sb.index_buffer = sg_make_buffer(&index_buffer_desc);
    SOKOL_ASSERT(SG_INVALID_ID != _sb.index_buffer.id);

    SOKOL_FREE(index_buffer);

    _sb.bindings.index_buffer = _sb.index_buffer;
}

static inline void _sb_init_quad_rotated(
    _sb_quad* quad, float x, float y, float dx, float dy,
    float w, float h, float sin, float cos, uint32_t rgba,
    sb_float2 top_left, sb_float2 bottom_right, float depth) {

    /* TODO: Z-tilt: what the hell do we do? */

    quad->top_left.x    = x + dx * cos - dy * sin;
    quad->top_left.y    = y + dx * sin + dy * cos;
    quad->top_left.z    = depth;
    quad->top_left.rgba = rgba;
    quad->top_left.u    = top_left.x;
    quad->top_left.v    = top_left.y;

    quad->top_right.x    = x + (dx + w) * cos - dy * sin;
    quad->top_right.y    = y + (dx + w) * sin + dy * cos;
    quad->top_right.z    = depth;
    quad->top_right.rgba = rgba;
    quad->top_right.u    = bottom_right.x;
    quad->top_right.v    = top_left.y;

    quad->bottom_left.x    = x + dx * cos - (dy + h) * sin;
    quad->bottom_left.y    = y + dx * sin + (dy + h) * cos;
    quad->bottom_left.z    = depth;
    quad->bottom_left.rgba = rgba;
    quad->bottom_left.u    = top_left.x;
    quad->bottom_left.v    = bottom_right.y;

    quad->bottom_right.x    = x + (dx + w) * cos - (dy + h) * sin;
    quad->bottom_right.y    = y + (dx + w) * sin + (dy + h) * cos;
    quad->bottom_right.z    = depth;
    quad->bottom_right.rgba = rgba;
    quad->bottom_right.u    = bottom_right.x;
    quad->bottom_right.v    = bottom_right.y;
}

static inline void _sb_init_quad(
    _sb_quad* quad, uint32_t flags, float x, float y, float w, float h, uint32_t rgba,
    sb_float2 top_left, sb_float2 bottom_right, float depth) {

    quad->top_left.x = x;
    quad->top_left.y = y;
    quad->top_left.z = depth;
    quad->top_left.rgba = rgba;
    quad->top_left.u = top_left.x;
    quad->top_left.v = top_left.y;

    quad->top_right.x = x + w;
    quad->top_right.y = y;
    quad->top_right.z = depth;
    quad->top_right.rgba = rgba;
    quad->top_right.u = bottom_right.x;
    quad->top_right.v = top_left.y;

    if ((flags & SB_Z_TILT) != SB_FLIP_NONE) {
        // move the topmost vertices further out to enable z-tilting
        const float angle = 0.785398f; // 45 degrees
        const float depth = h * tanf(angle);
        quad->top_left.z  -= depth;
        quad->top_right.z -= depth;
    }

    quad->bottom_left.x    = x;
    quad->bottom_left.y    = y + h;
    quad->bottom_left.z    = depth;
    quad->bottom_left.rgba = rgba;
    quad->bottom_left.u    = top_left.x;
    quad->bottom_left.v    = bottom_right.y;

    quad->bottom_right.x    = x + w;
    quad->bottom_right.y    = y + h;
    quad->bottom_right.z    = depth;
    quad->bottom_right.rgba = rgba;
    quad->bottom_right.u    = bottom_right.x;
    quad->bottom_right.v    = bottom_right.y;
}

static inline void _sb_init_vertex_buffer(void) {
    sg_buffer_desc vertex_buffer_desc;
    memset(&vertex_buffer_desc, 0, sizeof(vertex_buffer_desc));
    vertex_buffer_desc.size = _SB_MAX_VERTICES * sizeof(_sb_vertex);
    vertex_buffer_desc.type = SG_BUFFERTYPE_VERTEXBUFFER;
    vertex_buffer_desc.usage = SG_USAGE_STREAM;
    vertex_buffer_desc.label = "sokol-spritebatch-vertices";
    _sb.vertex_buffer = sg_make_buffer(&vertex_buffer_desc);
    SOKOL_ASSERT(SG_INVALID_ID != _sb.vertex_buffer.id);

    _sb.vertex_buffer_data = (_sb_vertex*)SOKOL_MALLOC(_SB_MAX_VERTICES * sizeof(_sb_vertex));
    SOKOL_ASSERT(_sb.vertex_buffer_data);

    _sb.bindings.vertex_buffers[0] = _sb.vertex_buffer;
}

static inline uint32_t _sb_float_flip(uint32_t f) {
    uint32_t mask = -(int32_t)(f >> 31) | 0x80000000;
    return f ^ mask;
}

static inline uint32_t _sb_depth_to_bits(float value) {
    // https://aras-p.info/blog/2014/01/16/rough-sorting-by-depth/
    // Taking highest 10 bits for rough sort of positive floats.
    // Sign is always zero, so only 9 bits in the result are used.
    // 0.01 maps to 240; 0.1 to 247; 1.0 to 254; 10.0 to 260;
    // 100.0 to 267; 1000.0 to 273 etc.
    uint32_t i;
    memcpy(&i, &value, sizeof(value));
    i = _sb_float_flip(i);
    return i >> 22; // take highest 10 bits
}

static inline uint64_t _sb_make_sort_key(const sb_sprite_info* sprite) {
    switch (_sb.render_state.sort_mode) {
    case SB_SORT_MODE_TEXTURE: {
        return (uint64_t)sprite->image.id;
    }
    case SB_SORT_MODE_BACK_TO_FRONT: {
        return (uint64_t)_sb_depth_to_bits(-sprite->depth) << 32 | sprite->image.id;
    }
    case SB_SORT_MODE_FRONT_TO_BACK: {
        return (uint64_t)_sb_depth_to_bits(sprite->depth) << 32 | sprite->image.id;
    }
    }
    return 0;
}

static inline uint32_t _sb_pack_color_bytes(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
    return (uint32_t)(((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)g << 8) | r);
}

static inline float _sb_clampf(float v, float low, float high) {
    if (v < low) {
        return low;
    }
    else if (v > high) {
        return high;
    }
    return v;
}

static inline uint32_t _sb_pack_color(const sg_color* color) {
    const uint8_t r = (uint8_t)(_sb_clampf(color->r, 0.0f, 1.0f) * 255.0f);
    const uint8_t g = (uint8_t)(_sb_clampf(color->g, 0.0f, 1.0f) * 255.0f);
    const uint8_t b = (uint8_t)(_sb_clampf(color->b, 0.0f, 1.0f) * 255.0f);
    const uint8_t a = (uint8_t)(_sb_clampf(color->a, 0.0f, 1.0f) * 255.0f);
    return _sb_pack_color_bytes(r, g, b, a);
}

static inline int _sb_quad_compare(const void* a, const void* b) {
    uint64_t key_a = ((const _sb_quad*)a)->sort_key;
    uint64_t key_b = ((const _sb_quad*)b)->sort_key;
    if (key_a < key_b) return -1;
    if (key_a > key_b) return  1;
    return 0;
}

static inline void* _sb_realloc(void* old_ptr, size_t old_size, size_t new_size) {
    SOKOL_ASSERT((new_size > 0) && (new_size > old_size));
    void* new_ptr = SOKOL_MALLOC(new_size);
    SOKOL_ASSERT(new_ptr);
    if (old_ptr) {
        if (old_size > 0) {
            memcpy(new_ptr, old_ptr, old_size);
        }
        SOKOL_FREE(old_ptr);
    }
    return new_ptr;
}

static inline void _sb_grow_batch_buffer(void) {
    const size_t new_capacity = _sb.batch_data.batch_capacity * 2;
    _sb.batch_data.batches = (_sb_batch*)_sb_realloc(_sb.batch_data.batches, _sb.batch_data.batch_capacity, new_capacity);
    _sb.batch_data.batch_capacity = new_capacity;
}

static inline _sb_batch* _sb_create_batch(void) {
    if (_sb.batch_data.batch_size >= _sb.batch_data.batch_capacity) {
        _sb_grow_batch_buffer();
    }
    return &_sb.batch_data.batches[_sb.batch_data.batch_size++];
}

static inline void _sb_init_batch(sg_image image, int num_elements, int base_element) {
    _sb_batch* batch    = _sb_create_batch();
    batch->image        = image;
    batch->num_elements = num_elements;
    batch->base_element = base_element;
    batch->matrix       = _sb.projection_matrix;
}

static inline void _sb_init_batches(void) {
    int batch_size = 0;
    int base_element = 0;
    sg_image current_image = { SG_INVALID_ID };

    for (int i = 0; i < _sb.quad_count; ++i, ++batch_size) {
        if (_sb.quads[i].image.id != current_image.id) {
            const int num_elements = batch_size * 6;
            _sb_init_batch(current_image, num_elements, base_element);
            current_image = _sb.quads[i].image;
            batch_size = 0;
            base_element += num_elements;
        }
    }

    const int num_elements = batch_size * 6;
    _sb_init_batch(current_image, num_elements, base_element);
}

SOKOL_API_IMPL void sb_premultiply_alpha(uint8_t* pixels, int pixel_count) {
    /*
        http://www.realtimerendering.com/blog/gpus-prefer-premultiplication/
        https://shawnhargreaves.com/blog/premultiplied-alpha.html
    */
    SOKOL_ASSERT(pixels);
    for (int i = 0; i < pixel_count; ++i) {
        pixels[0] = pixels[0] * pixels[3] / 255;
        pixels[1] = pixels[1] * pixels[3] / 255;
        pixels[2] = pixels[2] * pixels[3] / 255;
        pixels += 4;
    }
}

SOKOL_API_IMPL void sb_setup(const sb_desc* desc) {
    SOKOL_ASSERT(desc);
    memset(&_sb, 0, sizeof(_sb_t));
    _sb_init_sprite_pool();
    _sb.quads = (_sb_quad*)SOKOL_MALLOC(_SB_MAX_QUADS * sizeof(_sb_quad));
    SOKOL_ASSERT(_sb.quads);
    _sb_init_vertex_buffer();
    _sb_init_index_buffer();
    _sb_init_batch_data();

    _sb.default_shader = sg_make_shader(spritebatch_shader_desc(sg_query_backend()));

    sg_pipeline_desc pipeline_desc;
    memset(&pipeline_desc, 0, sizeof(sg_pipeline_desc));
    pipeline_desc.color_count                      = 1;
    pipeline_desc.colors[0].blend.enabled          = true;
    pipeline_desc.colors[0].blend.src_factor_rgb   = SG_BLENDFACTOR_ONE;
    pipeline_desc.colors[0].blend.src_factor_alpha = SG_BLENDFACTOR_ONE;
    pipeline_desc.colors[0].blend.dst_factor_rgb   = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
    pipeline_desc.colors[0].blend.dst_factor_alpha = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
    pipeline_desc.shader                           = _sb.default_shader;
    pipeline_desc.index_type                       = SG_INDEXTYPE_UINT16;
    pipeline_desc.layout.attrs[0].format           = SG_VERTEXFORMAT_FLOAT3;
    pipeline_desc.layout.attrs[1].format           = SG_VERTEXFORMAT_FLOAT2;
    pipeline_desc.layout.attrs[2].format           = SG_VERTEXFORMAT_UBYTE4N;
    pipeline_desc.label                            = "spritebatch-default-pipeline";

    _sb.default_pipeline = sg_make_pipeline(&pipeline_desc);
}

SOKOL_API_IMPL void sb_shutdown(void) {
    sg_destroy_pipeline(_sb.default_pipeline);
    sg_destroy_shader(_sb.default_shader);
    SOKOL_FREE(_sb.batch_data.batches);
    sg_destroy_buffer(_sb.index_buffer);
    sg_destroy_buffer(_sb.vertex_buffer);
    SOKOL_FREE(_sb.vertex_buffer_data);
    SOKOL_FREE(_sb.quads);
    SOKOL_FREE(_sb.sprite_pool.data);
}

SOKOL_API_IMPL void sb_begin(const sb_render_state* render_state) {
    SOKOL_ASSERT(render_state);
    SOKOL_ASSERT(!_sb.begin_called);
    _sb.begin_called = true;

    _sb.render_state.viewport = render_state->viewport;
    _sb.render_state.sort_mode = render_state->sort_mode;
    _sb.render_state.pipeline.id
        = _SB_DEFAULT(render_state->pipeline.id, _sb.default_pipeline.id);

    const float width = (float)_sb.render_state.viewport.width;
    const float height = (float)_sb.render_state.viewport.height;

    _sb.projection_matrix
        = _sb_orthographic_off_center(0.0f, width, height, 0.0f, 0.0f, SB_MAX_DEPTH);

    _sb.render_state.transform_matrix
        = _sb_matrix_is_null(&render_state->transform_matrix)
            ? _sb_matrix_identity()
            : render_state->transform_matrix;
}

SOKOL_API_IMPL void sb_sprite(const sb_sprite_info* sprite) {
    /* TODO: maybe take an array of sprite info? */
    SOKOL_ASSERT(sprite);
    SOKOL_ASSERT(sprite->image.id != SG_INVALID_ID);
    SOKOL_ASSERT(_sb.quad_count < _SB_MAX_QUADS);

    _sb_sprite_data* cached_sprite_data = &_sb.sprite_pool.data[_sg_image_slot_index(sprite->image.id)];
    if (cached_sprite_data->image.id != sprite->image.id)
    {
        sg_image_info info = sg_query_image_info(sprite->image);
        cached_sprite_data->height = info.height;
        cached_sprite_data->width  = info.width;
        cached_sprite_data->image  = sprite->image;
    }

    const float scale_x = _SB_DEFAULT(sprite->scale.x, 1.0f);
    const float scale_y = _SB_DEFAULT(sprite->scale.y, 1.0f);

    const float sprite_width  = _SB_DEFAULT(sprite->width, (float)cached_sprite_data->width);
    const float sprite_height = _SB_DEFAULT(sprite->height, (float)cached_sprite_data->height);

    const float width  = sprite_width * scale_x;
    const float height = sprite_height * scale_y;

    const float texel_width  = (1.0f / cached_sprite_data->width);
    const float texel_height = (1.0f / cached_sprite_data->height);

    sb_float2 tex_coord_top_left = {
        sprite->source.x * texel_width,
        sprite->source.y * texel_height
    };

    sb_float2 tex_coord_bottom_right = {
        (sprite->source.x + sprite_width)  * texel_width,
        (sprite->source.y + sprite_height) * texel_height
    };

    if ((sprite->flags & SB_FLIP_Y) != SB_FLIP_NONE)
    {
        const float temp         = tex_coord_bottom_right.y;
        tex_coord_bottom_right.y = tex_coord_top_left.y;
        tex_coord_top_left.y     = temp;
    }

    if ((sprite->flags & SB_FLIP_X) != SB_FLIP_NONE)
    {
        const float temp         = tex_coord_bottom_right.x;
        tex_coord_bottom_right.x = tex_coord_top_left.x;
        tex_coord_top_left.x     = temp;
    }

    const float scaled_origin_x = scale_x * sprite->origin.x;
    const float scaled_origin_y = scale_y * sprite->origin.y;

    _sb_quad* quad = &_sb.quads[_sb.quad_count++];
    quad->sort_key = _sb_make_sort_key(sprite);
    quad->image = sprite->image;

    uint32_t packed_color = _sb_pack_color(&sprite->color);
    packed_color = packed_color == 0 ? 0xFFFFFFFF : packed_color;

    if (sprite->rotation == 0.0f)
    {
        _sb_init_quad(quad,
            sprite->flags,
            sprite->position.x - scaled_origin_x,
            sprite->position.y - scaled_origin_y,
            width,
            height,
            packed_color,
            tex_coord_top_left,
            tex_coord_bottom_right,
            sprite->depth);
    }
    else
    {
        _sb_init_quad_rotated(quad,
            sprite->position.x,
            sprite->position.y,
            -scaled_origin_x,
            -scaled_origin_y,
            width,
            height,
            sinf(sprite->rotation),
            cosf(sprite->rotation),
            packed_color,
            tex_coord_top_left,
            tex_coord_bottom_right,
            sprite->depth);
    }
}

SOKOL_API_IMPL void sb_end(void) {

    SOKOL_ASSERT(_sb.begin_called);
    _sb.begin_called = false;

    if (_sb.quad_count == 0) {
        return;
    }

    if (_sb.render_state.sort_mode != SB_SORT_MODE_DEFERRED) {
        qsort(_sb.quads, _sb.quad_count, sizeof(_sb_quad), _sb_quad_compare);
    }

    /*
        If this is moved to storing the quad data SOA, we would be able to use the array that stores all the
        vertex data verbatim without copying vertex data into an auxiliary buffer. This would significantly
        complicate the code though, especially sorting the quads before submission. Can't use a standard sorting
        algorithm to sort SOA data. Would need to implement a bespoke solution and that'd be a bit of a pain to
        profile and maintain. It is something to think about though.
    */
    for (size_t i = 0; i < _sb.quad_count; i++) {
        memcpy(_sb.vertex_buffer_data + (i * 4), &_sb.quads[i], 4 * sizeof(_sb_vertex));
    }

    _sb_init_batches();
}

SOKOL_API_IMPL void sb_draw(void) {

    if (_sb.batch_data.batch_size == 0) {
        return;
    }

    const sg_range range = { _sb.vertex_buffer_data, _sb.quad_count * 4 * sizeof(_sb_vertex) };
    sg_update_buffer(_sb.vertex_buffer, &range);

    for (size_t i = 1; i < _sb.batch_data.batch_size; i++) {
        _sb_batch* batch = _sb.batch_data.batches + i;
        sg_apply_pipeline(_sb.default_pipeline);
        sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, &SG_RANGE(batch->matrix));
        _sb.bindings.fs_images[0] = batch->image;
        sg_apply_bindings(&_sb.bindings);
        sg_draw(batch->base_element, batch->num_elements, 1);
    }

    _sb.quad_count = 0;
    _sb.batch_data.batch_size = 0;
}

#endif /* SOKOL_SPRITEBATCH_IMPL */