Initial commit

2021-11-11 21:22:24 +01:00
commit b78045ffe7
812 changed files with 421882 additions and 0 deletions
@@ -0,0 +1,500 @@
+#-------------------------------------------------------------------------------
+#   Generate the sokol_color.h header from a predefined palette
+#-------------------------------------------------------------------------------
+#   LICENSE
+#   =======
+#
+#   zlib/libpng license
+#
+#   Copyright (c) 2020 Stuart Adams
+#
+#   This software is provided 'as-is', without any express or implied warranty.
+#   In no event will the authors be held liable for any damages arising from the
+#   use of this software.
+#
+#   Permission is granted to anyone to use this software for any purpose,
+#   including commercial applications, and to alter it and redistribute it
+#   freely, subject to the following restrictions:
+#
+#       1. The origin of this software must not be misrepresented; you must not
+#       claim that you wrote the original software. If you use this software in a
+#       product, an acknowledgment in the product documentation would be
+#       appreciated but is not required.
+#
+#       2. Altered source versions must be plainly marked as such, and must not
+#       be misrepresented as being the original software.
+#
+#       3. This notice may not be removed or altered from any source
+#       distribution.
+
+colors = [
+("Alice Blue",          0xF0F8FFFF),
+("Antique White",       0xFAEBD7FF),
+("Aqua",                0x00FFFFFF),
+("Aquamarine",          0x7FFFD4FF),
+("Azure",               0xF0FFFFFF),
+("Beige",               0xF5F5DCFF),
+("Bisque",              0xFFE4C4FF),
+("Black",               0x000000FF),
+("Blanched Almond",     0xFFEBCDFF),
+("Blue",                0x0000FFFF),
+("Blue Violet",         0x8A2BE2FF),
+("Brown",               0xA52A2AFF),
+("Burlywood",           0xDEB887FF),
+("Cadet Blue",          0x5F9EA0FF),
+("Chartreuse",          0x7FFF00FF),
+("Chocolate",           0xD2691EFF),
+("Coral",               0xFF7F50FF),
+("Cornflower Blue",     0x6495EDFF),
+("Cornsilk",            0xFFF8DCFF),
+("Crimson",             0xDC143CFF),
+("Cyan",                0x00FFFFFF),
+("Dark Blue",           0x00008BFF),
+("Dark Cyan",           0x008B8BFF),
+("Dark Goldenrod",      0xB8860BFF),
+("Dark Gray",           0xA9A9A9FF),
+("Dark Green",          0x006400FF),
+("Dark Khaki",          0xBDB76BFF),
+("Dark Magenta",        0x8B008BFF),
+("Dark Olive Green",    0x556B2FFF),
+("Dark Orange",         0xFF8C00FF),
+("Dark Orchid",         0x9932CCFF),
+("Dark Red",            0x8B0000FF),
+("Dark Salmon",         0xE9967AFF),
+("Dark Sea Green",      0x8FBC8FFF),
+("Dark Slate Blue",     0x483D8BFF),
+("Dark Slate Gray",     0x2F4F4FFF),
+("Dark Turquoise",      0x00CED1FF),
+("Dark Violet",         0x9400D3FF),
+("Deep Pink",           0xFF1493FF),
+("Deep Sky Blue",       0x00BFFFFF),
+("Dim Gray",            0x696969FF),
+("Dodger Blue",         0x1E90FFFF),
+("Firebrick",           0xB22222FF),
+("Floral White",        0xFFFAF0FF),
+("Forest Green",        0x228B22FF),
+("Fuchsia",             0xFF00FFFF),
+("Gainsboro",           0xDCDCDCFF),
+("Ghost White",         0xF8F8FFFF),
+("Gold",                0xFFD700FF),
+("Goldenrod",           0xDAA520FF),
+("Gray",                0xBEBEBEFF),
+("Web Gray",            0x808080FF),
+("Green",               0x00FF00FF),
+("Web Green",           0x008000FF),
+("Green Yellow",        0xADFF2FFF),
+("Honeydew",            0xF0FFF0FF),
+("Hot Pink",            0xFF69B4FF),
+("Indian Red",          0xCD5C5CFF),
+("Indigo",              0x4B0082FF),
+("Ivory",               0xFFFFF0FF),
+("Khaki",               0xF0E68CFF),
+("Lavender",            0xE6E6FAFF),
+("Lavender Blush",      0xFFF0F5FF),
+("Lawn Green",          0x7CFC00FF),
+("Lemon Chiffon",       0xFFFACDFF),
+("Light Blue",          0xADD8E6FF),
+("Light Coral",         0xF08080FF),
+("Light Cyan",          0xE0FFFFFF),
+("Light Goldenrod",     0xFAFAD2FF),
+("Light Gray",          0xD3D3D3FF),
+("Light Green",         0x90EE90FF),
+("Light Pink",          0xFFB6C1FF),
+("Light Salmon",        0xFFA07AFF),
+("Light Sea Green",     0x20B2AAFF),
+("Light Sky Blue",      0x87CEFAFF),
+("Light Slate Gray",    0x778899FF),
+("Light Steel Blue",    0xB0C4DEFF),
+("Light Yellow",        0xFFFFE0FF),
+("Lime",                0x00FF00FF),
+("Lime Green",          0x32CD32FF),
+("Linen",               0xFAF0E6FF),
+("Magenta",             0xFF00FFFF),
+("Maroon",              0xB03060FF),
+("Web Maroon",          0x800000FF),
+("Medium Aquamarine",   0x66CDAAFF),
+("Medium Blue",         0x0000CDFF),
+("Medium Orchid",       0xBA55D3FF),
+("Medium Purple",       0x9370DBFF),
+("Medium Sea Green",    0x3CB371FF),
+("Medium Slate Blue",   0x7B68EEFF),
+("Medium Spring Green", 0x00FA9AFF),
+("Medium Turquoise",    0x48D1CCFF),
+("Medium Violet Red",   0xC71585FF),
+("Midnight Blue",       0x191970FF),
+("Mint Cream",          0xF5FFFAFF),
+("Misty Rose",          0xFFE4E1FF),
+("Moccasin",            0xFFE4B5FF),
+("Navajo White",        0xFFDEADFF),
+("Navy Blue",           0x000080FF),
+("Old Lace",            0xFDF5E6FF),
+("Olive",               0x808000FF),
+("Olive Drab",          0x6B8E23FF),
+("Orange",              0xFFA500FF),
+("Orange Red",          0xFF4500FF),
+("Orchid",              0xDA70D6FF),
+("Pale Goldenrod",      0xEEE8AAFF),
+("Pale Green",          0x98FB98FF),
+("Pale Turquoise",      0xAFEEEEFF),
+("Pale Violet Red",     0xDB7093FF),
+("Papaya Whip",         0xFFEFD5FF),
+("Peach Puff",          0xFFDAB9FF),
+("Peru",                0xCD853FFF),
+("Pink",                0xFFC0CBFF),
+("Plum",                0xDDA0DDFF),
+("Powder Blue",         0xB0E0E6FF),
+("Purple",              0xA020F0FF),
+("Web Purple",          0x800080FF),
+("Rebecca Purple",      0x663399FF),
+("Red",                 0xFF0000FF),
+("Rosy Brown",          0xBC8F8FFF),
+("Royal Blue",          0x4169E1FF),
+("Saddle Brown",        0x8B4513FF),
+("Salmon",              0xFA8072FF),
+("Sandy Brown",         0xF4A460FF),
+("Sea Green",           0x2E8B57FF),
+("Seashell",            0xFFF5EEFF),
+("Sienna",              0xA0522DFF),
+("Silver",              0xC0C0C0FF),
+("Sky Blue",            0x87CEEBFF),
+("Slate Blue",          0x6A5ACDFF),
+("Slate Gray",          0x708090FF),
+("Snow",                0xFFFAFAFF),
+("Spring Green",        0x00FF7FFF),
+("Steel Blue",          0x4682B4FF),
+("Tan",                 0xD2B48CFF),
+("Teal",                0x008080FF),
+("Thistle",             0xD8BFD8FF),
+("Tomato",              0xFF6347FF),
+("Transparent",         0x00000000),
+("Turquoise",           0x40E0D0FF),
+("Violet",              0xEE82EEFF),
+("Wheat",               0xF5DEB3FF),
+("White",               0xFFFFFFFF),
+("White Smoke",         0xF5F5F5FF),
+("Yellow",              0xFFFF00FF),
+("Yellow Green",        0x9ACD32FF)
+]
+
+header = open("sokol_color.h", "w")
+
+header.write("""#if defined(SOKOL_IMPL) && !defined(SOKOL_COLOR_IMPL)
+#define SOKOL_COLOR_IMPL
+#endif
+#ifndef SOKOL_COLOR_INCLUDED
+/*
+    sokol_color.h -- sg_color utilities
+
+    This header was generated by gen_sokol_color.py. Do not modify it.
+
+    Project URL: https://github.com/floooh/sokol
+
+    Include the following headers before including sokol_color.h:
+
+        sokol_gfx.h
+
+    FEATURE OVERVIEW
+    ================
+    sokol_color.h defines preset colors based on the X11 color names,
+    alongside utility functions to create and modify sg_color objects.
+
+    The predefined colors are based on the X11 color names:
+
+        https://en.wikipedia.org/wiki/X11_color_names
+
+    This palette is useful for prototyping - lots of programmers are familiar with
+    these colours due to their use in X11, web development and XNA / MonoGame. They
+    are also handy when you want to reference a familiar color, but don't want to
+    write it out by hand.
+
+    COLORS
+    ======
+    The palette is defined using static const (or constexpr if you are using a
+    C++ compiler) objects. These objects use lowercase names:
+
+        static SOKOL_COLOR_CONSTEXPR sg_color sg_red = SG_RED;
+        static SOKOL_COLOR_CONSTEXPR sg_color sg_green = SG_GREEN;
+        static SOKOL_COLOR_CONSTEXPR sg_color sg_blue = SG_BLUE;
+
+    An sg_color preset object like sg_red can be used to initialize
+    an sg_pass_action:
+
+        sg_pass_action pass_action = {
+            .colors[0] = { .action=SG_ACTION_CLEAR, .value = sg_red }
+        };
+
+    Initializing an object with static storage duration is more complicated
+    because of C language rules. Technically, a static const is not a
+    compile-time constant in C. To work around this, the palette is also
+    defined as a series of brace-enclosed list macro definitions. These
+    definitions use uppercase names:
+
+        #define SG_RED { 1.0f, 0.0f, 0.0f, 1.0f }
+        #define SG_GREEN { 0.0f, 1.0f, 0.0f, 1.0f }
+        #define SG_BLUE { 0.0f, 0.0f, 1.0f, 1.0f }
+
+    A preset macro like SG_RED can be used to initialize objects with static
+    storage duration:
+
+        static struct {
+            sg_pass_action pass_action;
+        } state = {
+            .pass_action = {
+                .colors[0] = { .action = SG_ACTION_CLEAR, .value = SG_RED }
+            }
+        };
+
+    A second set of macro definitions exists for colors packed as 32 bit integer
+    values. These definitions are also uppercase, but use the _RGBA32 suffix:
+
+        #define SG_RED_RGBA32 0xFF0000FF
+        #define SG_GREEN_RGBA32 0x00FF00FF
+        #define SG_BLUE_RGBA32 0x0000FFFF
+
+    This is useful if your code makes use of packed colors, as sokol_gl.h does for its
+    internal vertex format:
+
+        sgl_begin_triangles();
+        sgl_v2f_c1i( 0.0f,  0.5f, SG_RED_RGBA32);
+        sgl_v2f_c1i( 0.5f, -0.5f, SG_GREEN_RGBA32);
+        sgl_v2f_c1i(-0.5f, -0.5f, SG_BLUE_RGBA32);
+        sgl_end();
+
+    UTILITY FUNCTIONS
+    =================
+
+    Utility functions for creating colours are provided:
+
+        - sg_make_color_4b(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+            Create a sg_color object from separate R, G, B, A bytes.
+
+        - sg_make_color_1i(uint32_t rgba)
+            Create a sg_color object from RGBA bytes packed into a 32-bit unsigned integer.
+
+        - sg_color_lerp(const sg_color* color_a, const sg_color* color_b, float amount)
+            Linearly interpolate a color.
+
+        - sg_color_lerp_precise(const sg_color* color_a, const sg_color* color_b, float amount)
+            Linearly interpolate a color. Less efficient but more precise than sg_color_lerp.
+
+        - sg_color_multiply(const sg_color* color, float scale)
+            Multiply each color component by the scale factor.
+
+    LICENSE
+    =======
+
+    zlib/libpng license
+
+    Copyright (c) 2020 Stuart Adams
+
+    This software is provided 'as-is', without any express or implied warranty.
+    In no event will the authors be held liable for any damages arising from the
+    use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+        1. The origin of this software must not be misrepresented; you must not
+        claim that you wrote the original software. If you use this software in a
+        product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+        2. Altered source versions must be plainly marked as such, and must not
+        be misrepresented as being the original software.
+
+        3. This notice may not be removed or altered from any source
+        distribution.
+*/
+#define SOKOL_COLOR_INCLUDED (1)
+
+#if !defined(SOKOL_GFX_INCLUDED)
+#error "Please include sokol_gfx.h before sokol_color.h"
+#endif
+
+#if defined(SOKOL_API_DECL) && !defined(SOKOL_GL_API_DECL)
+#define SOKOL_COLOR_API_DECL SOKOL_API_DECL
+#endif
+#ifndef SOKOL_COLOR_API_DECL
+#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_COLOR_IMPL)
+#define SOKOL_COLOR_API_DECL __declspec(dllexport)
+#elif defined(_WIN32) && defined(SOKOL_DLL)
+#define SOKOL_COLOR_API_DECL __declspec(dllimport)
+#else
+#define SOKOL_COLOR_API_DECL extern
+#endif
+#endif
+
+#ifdef __cplusplus
+#define SOKOL_COLOR_CONSTEXPR constexpr
+extern "C" {
+#else
+#define SOKOL_COLOR_CONSTEXPR const
+#endif
+
+SOKOL_COLOR_API_DECL sg_color sg_make_color_4b(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
+SOKOL_COLOR_API_DECL sg_color sg_make_color_1i(uint32_t rgba);
+SOKOL_COLOR_API_DECL sg_color sg_color_lerp(const sg_color* color_a, const sg_color* color_b, float amount);
+SOKOL_COLOR_API_DECL sg_color sg_color_lerp_precise(const sg_color* color_a, const sg_color* color_b, float amount);
+SOKOL_COLOR_API_DECL sg_color sg_color_multiply(const sg_color* color, float scale);
+
+""")
+
+def unpack_rgba(color):
+    red   = (color & 0xFF000000) >> 24
+    green = (color & 0xFF0000) >> 16
+    blue  = (color & 0xFF00) >> 8
+    alpha = (color & 0xFF)
+    return (red, green, blue, alpha)
+
+def add_documentation(color):
+    documentation = "/* {name} color {{ R:{r}, G:{g}, B:{b}, A:{a} }} */\n"
+    rgba = unpack_rgba(color[1])
+    header.write(documentation.format(
+        name = color[0], r = rgba[0], g = rgba[1], b = rgba[2], a = rgba[3]))
+
+for color in colors:
+    add_documentation(color)
+    init_color = "SG_" + color[0].upper().replace(" ", "_")
+    init_color_definition = "#define {name} {{ {r}f, {g}f, {b}f, {a}f }}\n"
+    rgba = unpack_rgba(color[1])
+    r = rgba[0] / 255
+    g = rgba[1] / 255
+    b = rgba[2] / 255
+    a = rgba[3] / 255
+    r_text = "{:.1f}".format(r) if r.is_integer() else "{:.9g}".format(r)
+    g_text = "{:.1f}".format(g) if g.is_integer() else "{:.9g}".format(g)
+    b_text = "{:.1f}".format(b) if b.is_integer() else "{:.9g}".format(b)
+    a_text = "{:.1f}".format(a) if a.is_integer() else "{:.9g}".format(a)
+    header.write(init_color_definition.format(
+        name = init_color, r = r_text, g = g_text, b = b_text, a = a_text))
+
+header.write("\n")
+
+for color in colors:
+    add_documentation(color)
+    init_color = "sg_" + color[0].lower().replace(" ", "_")
+    init_color_definition = "static SOKOL_COLOR_CONSTEXPR sg_color {name} = {init};\n"
+    init_color_name = "SG_" + color[0].upper().replace(" ", "_")
+    header.write(init_color_definition.format(name = init_color, init = init_color_name))
+
+header.write("\n")
+
+for color in colors:
+    add_documentation(color)
+    hex_color = "0x{0:08X}".format(color[1])
+    packed_color = "SG_" + color[0].upper().replace(" ", "_") + "_RGBA32"
+    packed_color_definition = "#define {name} {rgba}\n"
+    header.write(packed_color_definition.format(name = packed_color, rgba = hex_color))
+
+header.write("""
+#ifdef __cplusplus
+} /* extern "C" */
+
+inline sg_color sg_make_color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    return sg_make_color_4b(r, g, b, a);
+}
+
+inline sg_color sg_make_color(uint32_t rgba) {
+    return sg_make_color_1i(rgba);
+}
+
+inline sg_color sg_color_lerp(const sg_color& color_a, const sg_color& color_b, float amount) {
+    return sg_color_lerp(&color_a, &color_b, amount);
+}
+
+inline sg_color sg_color_lerp_precise(const sg_color& color_a, const sg_color& color_b, float amount) {
+    return sg_color_lerp_precise(&color_a, &color_b, amount);
+}
+
+inline sg_color sg_color_multiply(const sg_color& color, float scale) {
+    return sg_color_multiply(&color, scale);
+}
+
+#endif /* __cplusplus */
+
+#endif /* SOKOL_COLOR_INCLUDED */
+
+/*-- IMPLEMENTATION ----------------------------------------------------------*/
+#ifdef SOKOL_COLOR_IMPL
+#define SOKOL_COLOR_IMPL_INCLUDED (1)
+
+#ifndef SOKOL_API_IMPL
+    #define SOKOL_API_IMPL
+#endif
+#ifndef SOKOL_ASSERT
+    #include <assert.h>
+    #define SOKOL_ASSERT(c) assert(c)
+#endif
+
+static inline float _sg_color_clamp(float v, float low, float high) {
+    if (v < low) {
+        return low;
+    } else if (v > high) {
+        return high; 
+    }
+    return v;
+}
+
+static inline float _sg_color_lerp(float a, float b, float amount) {
+    return a + (b - a) * amount;
+}
+
+static inline float _sg_color_lerp_precise(float a, float b, float amount) {
+    return ((1.0f - amount) * a) + (b * amount);
+}
+
+SOKOL_API_IMPL sg_color sg_make_color_4b(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+    sg_color result;
+    result.r = r / 255.0f;
+    result.g = g / 255.0f;
+    result.b = b / 255.0f;
+    result.a = a / 255.0f;
+    return result;
+}
+
+SOKOL_API_IMPL sg_color sg_make_color_1i(uint32_t rgba) {
+    return sg_make_color_4b(
+        (uint8_t)(rgba >> 24),
+        (uint8_t)(rgba >> 16),
+        (uint8_t)(rgba >> 8),
+        (uint8_t)(rgba >> 0)
+    );
+}
+
+SOKOL_API_IMPL sg_color sg_color_lerp(const sg_color* color_a, const sg_color* color_b, float amount) {
+    SOKOL_ASSERT(color_a);
+    SOKOL_ASSERT(color_b);
+    amount = _sg_color_clamp(amount, 0.0f, 1.0f);
+    sg_color result;
+    result.r = _sg_color_lerp(color_a->r, color_b->r, amount);
+    result.g = _sg_color_lerp(color_a->g, color_b->g, amount);
+    result.b = _sg_color_lerp(color_a->b, color_b->b, amount);
+    result.a = _sg_color_lerp(color_a->a, color_b->a, amount);
+    return result;
+}
+
+SOKOL_API_IMPL sg_color sg_color_lerp_precise(const sg_color* color_a, const sg_color* color_b, float amount) {
+    SOKOL_ASSERT(color_a);
+    SOKOL_ASSERT(color_b);
+    amount = _sg_color_clamp(amount, 0.0f, 1.0f);
+    sg_color result;
+    result.r = _sg_color_lerp_precise(color_a->r, color_b->r, amount);
+    result.g = _sg_color_lerp_precise(color_a->g, color_b->g, amount);
+    result.b = _sg_color_lerp_precise(color_a->b, color_b->b, amount);
+    result.a = _sg_color_lerp_precise(color_a->a, color_b->a, amount);
+    return result;
+}
+
+SOKOL_API_IMPL sg_color sg_color_multiply(const sg_color* color, float scale) {
+    SOKOL_ASSERT(color);
+    sg_color result;
+    result.r = color->r * scale;
+    result.g = color->g * scale;
+    result.b = color->b * scale;
+    result.a = color->a * scale;
+    return result;
+}
+
+#endif /* SOKOL_COLOR_IMPL */
+""")
@@ -0,0 +1,171 @@
+#if defined(SOKOL_IMPL) && !defined(SOKOL_MEMTRACK_IMPL)
+#define SOKOL_MEMTRACK_IMPL
+#endif
+#ifndef SOKOL_MEMTRACK_INCLUDED
+/*
+    sokol_memtrack.h -- memory allocation wrapper to track memory usage
+                        of sokol libraries
+
+    Project URL: https://github.com/floooh/sokol
+
+    Simply include this file before the sokol header implementation includes
+    and after the SOKOL_IMPL macro:
+
+    #define SOKOL_IMPL
+    #include "sokol_memtrack.h"
+    #include "sokol_app.h"
+    #include "sokol_gfx.h"
+    ...
+
+    Optionally provide the following defines with your own implementations:
+
+    SOKOL_MEMTRACK_API_DECL - public function declaration prefix (default: extern)
+    SOKOL_API_DECL      - same as SOKOL_MEMTRACK_API_DECL
+    SOKOL_API_IMPL      - public function implementation prefix (default: -)
+
+    If sokol_memtrack.h is compiled as a DLL, define the following before
+    including the declaration or implementation:
+
+    SOKOL_DLL
+
+    The sokol_memtrack.h header will redirect the macros SOKOL_MALLOC,
+    SOKOL_FREE and SOKOL_CALLOC to use its own function wrappers which
+    keep track of number and size of allocations. The wrapper functions
+    then call the CRT functions malloc(), calloc() or free().
+
+    Naturally, only the memory management calls in sokol header code are tracked,
+    not in underlying APIs such as D3D11 or OpenGL.
+
+    To get the current number and overall size of allocations, call:
+
+        smemtrack_info_t alloc_info = smemtrack_info();
+
+        int num_allocations = info.num_alloc;
+        int allocation_size = info.num_bytes;
+
+    The allocation wrapper functions are *not* thread-safe (which shouldn't
+    be a problem because the sokol headers don't allocate or deallocate
+    in threads).
+
+    LICENSE
+    =======
+
+    zlib/libpng license
+
+    Copyright (c) 2018 Andre Weissflog
+
+    This software is provided 'as-is', without any express or implied warranty.
+    In no event will the authors be held liable for any damages arising from the
+    use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+        1. The origin of this software must not be misrepresented; you must not
+        claim that you wrote the original software. If you use this software in a
+        product, an acknowledgment in the product documentation would be
+        appreciated but is not required.
+
+        2. Altered source versions must be plainly marked as such, and must not
+        be misrepresented as being the original software.
+
+        3. This notice may not be removed or altered from any source
+        distribution.
+*/
+#define SOKOL_MEMTRACK_INCLUDED (1)
+#include <stdint.h>
+
+#if defined(SOKOL_API_DECL) && !defined(SOKOL_MEMTRACK_API_DECL)
+#define SOKOL_MEMTRACK_API_DECL SOKOL_API_DECL
+#endif
+#ifndef SOKOL_MEMTRACK_API_DECL
+#if defined(_WIN32) && defined(SOKOL_DLL) && defined(SOKOL_MEMTRACK_IMPL)
+#define SOKOL_MEMTRACK_API_DECL __declspec(dllexport)
+#elif defined(_WIN32) && defined(SOKOL_DLL)
+#define SOKOL_MEMTRACK_API_DECL __declspec(dllimport)
+#else
+#define SOKOL_MEMTRACK_API_DECL extern
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct smemtrack_info_t {
+    int num_allocs;
+    int num_bytes;
+} smemtrack_info_t;
+
+SOKOL_MEMTRACK_API_DECL smemtrack_info_t smemtrack_info(void);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+#endif /* SOKOL_MEMTRACK_INCLUDED */
+
+/*=== IMPLEMENTATION =========================================================*/
+#ifdef SOKOL_MEMTRACK_IMPL
+#define SOKOL_MEMTRACK_IMPL_INCLUDED (1)
+#include <stdlib.h> /* malloc, free, calloc */
+#include <string.h> /* memset */
+#include <stddef.h> /* size_t */
+
+#ifndef SOKOL_API_IMPL
+    #define SOKOL_API_IMPL
+#endif
+#ifndef SOKOL_DEBUG
+    #ifndef NDEBUG
+        #define SOKOL_DEBUG (1)
+    #endif
+#endif
+#ifndef _SOKOL_PRIVATE
+    #if defined(__GNUC__) || defined(__clang__)
+        #define _SOKOL_PRIVATE __attribute__((unused)) static
+    #else
+        #define _SOKOL_PRIVATE static
+    #endif
+#endif
+
+#define SOKOL_MALLOC(s) _smemtrack_malloc(s)
+#define SOKOL_FREE(p) _smemtrack_free(p)
+#define SOKOL_CALLOC(n,s) _smemtrack_calloc(n,s)
+
+#define _SMEMTRACK_HEADER_SIZE (16)
+
+static struct {
+    smemtrack_info_t state;
+} _smemtrack;
+
+_SOKOL_PRIVATE void* _smemtrack_malloc(size_t size) {
+    _smemtrack.state.num_allocs++;
+    _smemtrack.state.num_bytes += (int) size;
+    uint8_t* ptr = (uint8_t*) malloc(size + _SMEMTRACK_HEADER_SIZE);
+    *(size_t*)ptr = size;
+    return ptr + _SMEMTRACK_HEADER_SIZE;
+}
+
+_SOKOL_PRIVATE void _smemtrack_free(void* ptr) {
+    uint8_t* alloc_ptr = ((uint8_t*)ptr) - _SMEMTRACK_HEADER_SIZE;
+    size_t size = *(size_t*)alloc_ptr;
+    _smemtrack.state.num_allocs--;
+    _smemtrack.state.num_bytes -= (int) size;
+    free(alloc_ptr);
+}
+
+_SOKOL_PRIVATE void* _smemtrack_calloc(size_t num, size_t size) {
+    size_t mem_size = num * size;
+    _smemtrack.state.num_allocs++;
+    _smemtrack.state.num_bytes += (int) mem_size;
+    uint8_t* ptr = (uint8_t*) malloc(mem_size + _SMEMTRACK_HEADER_SIZE);
+    memset(ptr + _SMEMTRACK_HEADER_SIZE, 0, mem_size);
+    *(size_t*)ptr = size;
+    return ptr + _SMEMTRACK_HEADER_SIZE;
+}
+
+SOKOL_API_IMPL smemtrack_info_t smemtrack_info(void) {
+    return _smemtrack.state;
+}
+
+#endif /* SOKOL_MEMTRACK_IMPL */