unicode fonts support

.gitmodules

@@ -8,3 +8,6 @@
 [submodule "dependencies/imnodes"]
 	path = dependencies/imnodes
 	url = https://github.com/Nelarius/imnodes.git
+[submodule "dependencies/resource_embedder"]
+	path = dependencies/resource_embedder
+	url = https://timerix.ddns.net:3322/Timerix/resource_embedder.git

.vscode/.gitignore

@@ -0,0 +1 @@
+settings.json

.vscode/c_cpp_properties.json

@@ -0,0 +1,17 @@
+{
+    "configurations": [
+        {
+            "name": "all",
+            "defines": [ 
+                "SDL_DISABLE_ANALYZE_MACROS",
+                "DEBUG=1"
+            ],
+            "includePath": [
+                "dependencies/include/SDL2",
+                "dependencies/imgui",
+                "${default}"
+            ]
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -1,14 +0,0 @@
-{
-    "C_Cpp.codeAnalysis.exclude": {
-        "**/dependencies/": true
-    },
-    "C_Cpp.default.defines": [ 
-        "SDL_DISABLE_ANALYZE_MACROS",
-        "DEBUG=1"
-    ],
-    "C_Cpp.default.includePath": [
-        "dependencies/include/SDL2",
-        "dependencies/imgui",
-        "${default}"
-    ]
-}

.vscode/tasks.json

@@ -7,9 +7,10 @@
         "label": "build_exec_dbg",
         "detail": "build project with debug symbols",
         "type": "cppbuild",
-        "command": "make",
+        "command": "bash",
         "args": [
-            "build_exec_dbg"
+            "-c",
+            "cbuild build_exec_dbg"
         ],
         "options": {
           "cwd": "${workspaceFolder}"

README.md

@@ -12,7 +12,6 @@ git clone --recurse-submodules https://timerix.ddns.net:3322/Timerix/GraphC.git
 3. Install **SDL2** from package manager or compile it from source.  
     **If you are using msys, switch to mingw64 sh.**
     ```sh
-    cd ..
     git clone https://github.com/libsdl-org/SDL.git
     cd SDL
     ./configure
@@ -22,20 +21,20 @@ git clone --recurse-submodules https://timerix.ddns.net:3322/Timerix/GraphC.git
     ```sh
     sudo make install
     ```
-    or copy to ./libs (on **Windows**): 
+    or copy to ./dependencies/precompiled/ (on **Windows**): 
     ```sh
-    mkdir -p GraphC/libs
-    cp ./build/.libs/SDL2.dll GraphC/libs/
+    mkdir -p ../GraphC/dependencies/precompiled/
+    cp ./build/.libs/SDL2.dll ../GraphC/dependencies/precompiled/
     ```
     If it doesn't work, read [SDL/INSTALL.txt](https://github.com/libsdl-org/SDL/blob/SDL2/INSTALL.txt) and [SDL/docs/README.md](https://github.com/libsdl-org/SDL/blob/SDL2/docs/README.md).  
 4. Symlink SDL headers directory to `dependencies/include`
     ```sh
-    cd GraphC
-    ln -s SDL2_HEADERS_DIRECTORY_ABSOLUTE_PATH dependencies/include/
+    cd ../GraphC
+    ln -s SDL2_HEADERS_DIRECTORY_ABSOLUTE_PATH -T dependencies/include/SDL2
     ```
-    Location of the headers can be found by `pkg-config --cppflags --libs sdl2`. 
+    Location of the headers can be found by `pkg-config --cflags --libs sdl2`. 
     Mingw installs SDL2 headers to `/mingw64/include/SDL2`. 
 5. Compile the program
     ```sh
-    cbuild build_exec
+    cbuild build_exec_dbg
     ```

dependencies/compile_resources.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+echo 'compiling resources...'
+inputs=""
+for f in $(find ../../resources -type f); do
+    inputs+="-i $f "
+done
+mkdir -p ../obj
+mkdir -p ../bin
+set -x
+./resource_embedder -o ../obj/resources.c -d ../../resources $inputs
+gcc -Wall -Wextra -O2 -DEMBEDDED_RESOURCE_DEFINITION -c ../obj/resources.c -o ../bin/resources.o
+set +x
+mkdir -p ../../src/generated
+cat ../obj/resources.c | head -n42 > ../../src/generated/resources.h
+echo "embedded resources header was created at src/generated/resources.h"

dependencies/precompiled.config

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+mkdir -p 'dependencies/precompiled'
 DEP_WORKING_DIR='dependencies/precompiled'
 DEP_PRE_BUILD_COMMAND=''
 DEP_BUILD_COMMAND=''

dependencies/resources.config

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+DEP_WORKING_DIR='dependencies/resource_embedder'
+DEP_PRE_BUILD_COMMAND='./build.sh'
+DEP_BUILD_COMMAND='../compile_resources.sh'
+DEP_POST_BUILD_COMMAND=''
+DEP_CLEAN_COMMAND='rm -f ./resource_embedder ./resource_embedder.exe ../obj/resources.c ../bin/resources.o'
+DEP_STATIC_OUT_FILES='../bin/resources.o'
+DEP_DYNAMIC_OUT_FILES=

fonts/.gitignore

@@ -1 +0,0 @@
-generated/

fonts/binary_to_compressed_c.cpp

@@ -1,388 +0,0 @@
-// dear imgui
-// (binary_to_compressed_c.cpp)
-// Helper tool to turn a file into a C array, if you want to embed font data in your source code.
-
-// The data is first compressed with stb_compress() to reduce source code size,
-// then encoded in Base85 to fit in a string so we can fit roughly 4 bytes of compressed data into 5 bytes of source code (suggested by @mmalex)
-// (If we used 32-bit constants it would require take 11 bytes of source code to encode 4 bytes, and be endianness dependent)
-// Note that even with compression, the output array is likely to be bigger than the binary file..
-// Load compressed TTF fonts with ImGui::GetIO().Fonts->AddFontFromMemoryCompressedTTF()
-
-// Build with, e.g:
-//   # cl.exe binary_to_compressed_c.cpp
-//   # g++ binary_to_compressed_c.cpp
-//   # clang++ binary_to_compressed_c.cpp
-// You can also find a precompiled Windows binary in the binary/demo package available from https://github.com/ocornut/imgui
-
-// Usage:
-//   binary_to_compressed_c.exe [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname>
-// Usage example:
-//   # binary_to_compressed_c.exe myfont.ttf MyFont > myfont.cpp
-//   # binary_to_compressed_c.exe -base85 myfont.ttf MyFont > myfont.cpp
-
-#define _CRT_SECURE_NO_WARNINGS
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <assert.h>
-
-// stb_compress* from stb.h - declaration
-typedef unsigned int stb_uint;
-typedef unsigned char stb_uchar;
-stb_uint stb_compress(stb_uchar* out, stb_uchar* in, stb_uint len);
-
-static bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static);
-
-int main(int argc, char** argv)
-{
-    if (argc < 3)
-    {
-        printf("Syntax: %s [-base85] [-nocompress] [-nostatic] <inputfile> <symbolname>\n", argv[0]);
-        return 0;
-    }
-
-    int argn = 1;
-    bool use_base85_encoding = false;
-    bool use_compression = true;
-    bool use_static = true;
-    while (argn < (argc - 2) && argv[argn][0] == '-')
-    {
-        if (strcmp(argv[argn], "-base85") == 0) { use_base85_encoding = true; argn++; }
-        else if (strcmp(argv[argn], "-nocompress") == 0) { use_compression = false; argn++; }
-        else if (strcmp(argv[argn], "-nostatic") == 0) { use_static = false; argn++; }
-        else
-        {
-            fprintf(stderr, "Unknown argument: '%s'\n", argv[argn]);
-            return 1;
-        }
-    }
-
-    bool ret = binary_to_compressed_c(argv[argn], argv[argn + 1], use_base85_encoding, use_compression, use_static);
-    if (!ret)
-        fprintf(stderr, "Error opening or reading file: '%s'\n", argv[argn]);
-    return ret ? 0 : 1;
-}
-
-char Encode85Byte(unsigned int x)
-{
-    x = (x % 85) + 35;
-    return (char)((x >= '\\') ? x + 1 : x);
-}
-
-bool binary_to_compressed_c(const char* filename, const char* symbol, bool use_base85_encoding, bool use_compression, bool use_static)
-{
-    // Read file
-    FILE* f = fopen(filename, "rb");
-    if (!f) return false;
-    int data_sz;
-    if (fseek(f, 0, SEEK_END) || (data_sz = (int)ftell(f)) == -1 || fseek(f, 0, SEEK_SET)) { fclose(f); return false; }
-    char* data = new char[data_sz + 4];
-    if (fread(data, 1, data_sz, f) != (size_t)data_sz) { fclose(f); delete[] data; return false; }
-    memset((void*)(((char*)data) + data_sz), 0, 4);
-    fclose(f);
-
-    // Compress
-    int maxlen = data_sz + 512 + (data_sz >> 2) + sizeof(int); // total guess
-    char* compressed = use_compression ? new char[maxlen] : data;
-    int compressed_sz = use_compression ? stb_compress((stb_uchar*)compressed, (stb_uchar*)data, data_sz) : data_sz;
-    if (use_compression)
-        memset(compressed + compressed_sz, 0, maxlen - compressed_sz);
-
-    // Output as Base85 encoded
-    FILE* out = stdout;
-    fprintf(out, "// File: '%s' (%d bytes)\n", filename, (int)data_sz);
-    fprintf(out, "// Exported using binary_to_compressed_c.cpp\n");
-    const char* static_str = use_static ? "static " : "";
-    const char* compressed_str = use_compression ? "compressed_" : "";
-    if (use_base85_encoding)
-    {
-        fprintf(out, "%sconst char %s_%sdata_base85[%d+1] =\n    \"", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4)*5);
-        char prev_c = 0;
-        for (int src_i = 0; src_i < compressed_sz; src_i += 4)
-        {
-            // This is made a little more complicated by the fact that ??X sequences are interpreted as trigraphs by old C/C++ compilers. So we need to escape pairs of ??.
-            unsigned int d = *(unsigned int*)(compressed + src_i);
-            for (unsigned int n5 = 0; n5 < 5; n5++, d /= 85)
-            {
-                char c = Encode85Byte(d);
-                fprintf(out, (c == '?' && prev_c == '?') ? "\\%c" : "%c", c);
-                prev_c = c;
-            }
-            if ((src_i % 112) == 112 - 4)
-                fprintf(out, "\"\n    \"");
-        }
-        fprintf(out, "\";\n\n");
-    }
-    else
-    {
-        fprintf(out, "%sconst unsigned int %s_%ssize = %d;\n", static_str, symbol, compressed_str, (int)compressed_sz);
-        fprintf(out, "%sconst unsigned int %s_%sdata[%d/4] =\n{", static_str, symbol, compressed_str, (int)((compressed_sz + 3) / 4)*4);
-        int column = 0;
-        for (int i = 0; i < compressed_sz; i += 4)
-        {
-            unsigned int d = *(unsigned int*)(compressed + i);
-            if ((column++ % 12) == 0)
-                fprintf(out, "\n    0x%08x, ", d);
-            else
-                fprintf(out, "0x%08x, ", d);
-        }
-        fprintf(out, "\n};\n\n");
-    }
-
-    // Cleanup
-    delete[] data;
-    if (use_compression)
-        delete[] compressed;
-    return true;
-}
-
-// stb_compress* from stb.h - definition
-
-////////////////////           compressor         ///////////////////////
-
-static stb_uint stb_adler32(stb_uint adler32, stb_uchar *buffer, stb_uint buflen)
-{
-    const unsigned long ADLER_MOD = 65521;
-    unsigned long s1 = adler32 & 0xffff, s2 = adler32 >> 16;
-    unsigned long blocklen, i;
-
-    blocklen = buflen % 5552;
-    while (buflen) {
-        for (i=0; i + 7 < blocklen; i += 8) {
-            s1 += buffer[0], s2 += s1;
-            s1 += buffer[1], s2 += s1;
-            s1 += buffer[2], s2 += s1;
-            s1 += buffer[3], s2 += s1;
-            s1 += buffer[4], s2 += s1;
-            s1 += buffer[5], s2 += s1;
-            s1 += buffer[6], s2 += s1;
-            s1 += buffer[7], s2 += s1;
-
-            buffer += 8;
-        }
-
-        for (; i < blocklen; ++i)
-            s1 += *buffer++, s2 += s1;
-
-        s1 %= ADLER_MOD, s2 %= ADLER_MOD;
-        buflen -= blocklen;
-        blocklen = 5552;
-    }
-    return (s2 << 16) + s1;
-}
-
-static unsigned int stb_matchlen(stb_uchar *m1, stb_uchar *m2, stb_uint maxlen)
-{
-    stb_uint i;
-    for (i=0; i < maxlen; ++i)
-        if (m1[i] != m2[i]) return i;
-    return i;
-}
-
-// simple implementation that just takes the source data in a big block
-
-static stb_uchar *stb__out;
-static FILE      *stb__outfile;
-static stb_uint   stb__outbytes;
-
-static void stb__write(unsigned char v)
-{
-    fputc(v, stb__outfile);
-    ++stb__outbytes;
-}
-
-//#define stb_out(v)    (stb__out ? *stb__out++ = (stb_uchar) (v) : stb__write((stb_uchar) (v)))
-#define stb_out(v)    do { if (stb__out) *stb__out++ = (stb_uchar) (v); else stb__write((stb_uchar) (v)); } while (0)
-
-static void stb_out2(stb_uint v) { stb_out(v >> 8); stb_out(v); }
-static void stb_out3(stb_uint v) { stb_out(v >> 16); stb_out(v >> 8); stb_out(v); }
-static void stb_out4(stb_uint v) { stb_out(v >> 24); stb_out(v >> 16); stb_out(v >> 8 ); stb_out(v); }
-
-static void outliterals(stb_uchar *in, int numlit)
-{
-    while (numlit > 65536) {
-        outliterals(in,65536);
-        in     += 65536;
-        numlit -= 65536;
-    }
-
-    if      (numlit ==     0)    ;
-    else if (numlit <=    32)    stb_out (0x000020 + numlit-1);
-    else if (numlit <=  2048)    stb_out2(0x000800 + numlit-1);
-    else /*  numlit <= 65536) */ stb_out3(0x070000 + numlit-1);
-
-    if (stb__out) {
-        memcpy(stb__out,in,numlit);
-        stb__out += numlit;
-    } else
-        fwrite(in, 1, numlit, stb__outfile);
-}
-
-static int stb__window = 0x40000; // 256K
-
-static int stb_not_crap(int best, int dist)
-{
-    return   ((best > 2  &&  dist <= 0x00100)
-        || (best > 5  &&  dist <= 0x04000)
-        || (best > 7  &&  dist <= 0x80000));
-}
-
-static  stb_uint stb__hashsize = 32768;
-
-// note that you can play with the hashing functions all you
-// want without needing to change the decompressor
-#define stb__hc(q,h,c)      (((h) << 7) + ((h) >> 25) + q[c])
-#define stb__hc2(q,h,c,d)   (((h) << 14) + ((h) >> 18) + (q[c] << 7) + q[d])
-#define stb__hc3(q,c,d,e)   ((q[c] << 14) + (q[d] << 7) + q[e])
-
-static unsigned int stb__running_adler;
-
-static int stb_compress_chunk(stb_uchar *history,
-    stb_uchar *start,
-    stb_uchar *end,
-    int length,
-    int *pending_literals,
-    stb_uchar **chash,
-    stb_uint mask)
-{
-    (void)history;
-    int window = stb__window;
-    stb_uint match_max;
-    stb_uchar *lit_start = start - *pending_literals;
-    stb_uchar *q = start;
-
-#define STB__SCRAMBLE(h)   (((h) + ((h) >> 16)) & mask)
-
-    // stop short of the end so we don't scan off the end doing
-    // the hashing; this means we won't compress the last few bytes
-    // unless they were part of something longer
-    while (q < start+length && q+12 < end) {
-        int m;
-        stb_uint h1,h2,h3,h4, h;
-        stb_uchar *t;
-        int best = 2, dist=0;
-
-        if (q+65536 > end)
-            match_max = (stb_uint)(end-q);
-        else
-            match_max = 65536;
-
-#define stb__nc(b,d)  ((d) <= window && ((b) > 9 || stb_not_crap((int)(b),(int)(d))))
-
-#define STB__TRY(t,p)  /* avoid retrying a match we already tried */ \
-    if (p ? dist != (int)(q-t) : 1)                             \
-    if ((m = stb_matchlen(t, q, match_max)) > best)     \
-    if (stb__nc(m,q-(t)))                                \
-    best = m, dist = (int)(q - (t))
-
-        // rather than search for all matches, only try 4 candidate locations,
-        // chosen based on 4 different hash functions of different lengths.
-        // this strategy is inspired by LZO; hashing is unrolled here using the
-        // 'hc' macro
-        h = stb__hc3(q,0, 1, 2); h1 = STB__SCRAMBLE(h);
-        t = chash[h1]; if (t) STB__TRY(t,0);
-        h = stb__hc2(q,h, 3, 4); h2 = STB__SCRAMBLE(h);
-        h = stb__hc2(q,h, 5, 6);        t = chash[h2]; if (t) STB__TRY(t,1);
-        h = stb__hc2(q,h, 7, 8); h3 = STB__SCRAMBLE(h);
-        h = stb__hc2(q,h, 9,10);        t = chash[h3]; if (t) STB__TRY(t,1);
-        h = stb__hc2(q,h,11,12); h4 = STB__SCRAMBLE(h);
-        t = chash[h4]; if (t) STB__TRY(t,1);
-
-        // because we use a shared hash table, can only update it
-        // _after_ we've probed all of them
-        chash[h1] = chash[h2] = chash[h3] = chash[h4] = q;
-
-        if (best > 2)
-            assert(dist > 0);
-
-        // see if our best match qualifies
-        if (best < 3) { // fast path literals
-            ++q;
-        } else if (best > 2  &&  best <= 0x80    &&  dist <= 0x100) {
-            outliterals(lit_start, (int)(q-lit_start)); lit_start = (q += best);
-            stb_out(0x80 + best-1);
-            stb_out(dist-1);
-        } else if (best > 5  &&  best <= 0x100   &&  dist <= 0x4000) {
-            outliterals(lit_start, (int)(q-lit_start)); lit_start = (q += best);
-            stb_out2(0x4000 + dist-1);
-            stb_out(best-1);
-        } else if (best > 7  &&  best <= 0x100   &&  dist <= 0x80000) {
-            outliterals(lit_start, (int)(q-lit_start)); lit_start = (q += best);
-            stb_out3(0x180000 + dist-1);
-            stb_out(best-1);
-        } else if (best > 8  &&  best <= 0x10000 &&  dist <= 0x80000) {
-            outliterals(lit_start, (int)(q-lit_start)); lit_start = (q += best);
-            stb_out3(0x100000 + dist-1);
-            stb_out2(best-1);
-        } else if (best > 9                      &&  dist <= 0x1000000) {
-            if (best > 65536) best = 65536;
-            outliterals(lit_start, (int)(q-lit_start)); lit_start = (q += best);
-            if (best <= 0x100) {
-                stb_out(0x06);
-                stb_out3(dist-1);
-                stb_out(best-1);
-            } else {
-                stb_out(0x04);
-                stb_out3(dist-1);
-                stb_out2(best-1);
-            }
-        } else {  // fallback literals if no match was a balanced tradeoff
-            ++q;
-        }
-    }
-
-    // if we didn't get all the way, add the rest to literals
-    if (q-start < length)
-        q = start+length;
-
-    // the literals are everything from lit_start to q
-    *pending_literals = (int)(q - lit_start);
-
-    stb__running_adler = stb_adler32(stb__running_adler, start, (stb_uint)(q - start));
-    return (int)(q - start);
-}
-
-static int stb_compress_inner(stb_uchar *input, stb_uint length)
-{
-    int literals = 0;
-    stb_uint len,i;
-
-    stb_uchar **chash;
-    chash = (stb_uchar**) malloc(stb__hashsize * sizeof(stb_uchar*));
-    if (chash == NULL) return 0; // failure
-    for (i=0; i < stb__hashsize; ++i)
-        chash[i] = NULL;
-
-    // stream signature
-    stb_out(0x57); stb_out(0xbc);
-    stb_out2(0);
-
-    stb_out4(0);       // 64-bit length requires 32-bit leading 0
-    stb_out4(length);
-    stb_out4(stb__window);
-
-    stb__running_adler = 1;
-
-    len = stb_compress_chunk(input, input, input+length, length, &literals, chash, stb__hashsize-1);
-    assert(len == length);
-
-    outliterals(input+length - literals, literals);
-
-    free(chash);
-
-    stb_out2(0x05fa); // end opcode
-
-    stb_out4(stb__running_adler);
-
-    return 1; // success
-}
-
-stb_uint stb_compress(stb_uchar *out, stb_uchar *input, stb_uint length)
-{
-    stb__out = out;
-    stb__outfile = NULL;
-
-    stb_compress_inner(input, length);
-
-    return (stb_uint)(stb__out - out);
-}

project.config

@@ -16,7 +16,7 @@ SRC_CPP="$(find src -name '*.cpp')"
 # See cbuild/example_dependency_configs
 DEPENDENCY_CONFIGS_DIR='dependencies'
 # List of dependency config files in DEPENDENCY_CONFIGS_DIR separated by space.
-ENABLED_DEPENDENCIES='precompiled kerep imgui imnodes'
+ENABLED_DEPENDENCIES='precompiled resources kerep imgui imnodes'
 
 # OBJDIR structure:
 #  ├── objects/      - Compiled object files. Cleans on each call of build task
@@ -49,18 +49,6 @@ esac
 
 # TASKS
 case "$TASK" in
-    # writes ttf fonts fron ./fonts/ to C compressed arrays in C source files
-    # builds static library from font arrays definitions
-    embed_fonts)
-        SRC_CPP=""
-        SRC_C=""
-        C_ARGS="-O0 -fpic"
-        WARN_C="-Wno-unused-const-variable"
-        CPP_ARGS="$C_ARGS"
-        STATIC_LIB_FILE="fonts_embedded.a"
-        TASK_SCRIPT=tasks/embed_fonts.sh
-        ;;
-
     # creates executable using profile info generated by build_profile
     build_exec)
         # -flto applies more optimizations across object files
@@ -143,6 +131,12 @@ case "$TASK" in
         TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
         POST_TASK_SCRIPT=cbuild/default_tasks/callgrind.sh
         ;;
+    # rebuilds specified dependencies
+    # EXAMPLE: `cbuild rebuild_dependencies=libexample1,fonts`
+    # 'all' can be specified to rebuild all dependencies
+    rebuild_dependencies)
+        TASK_SCRIPT=cbuild/default_tasks/rebuild_dependencies.sh
+        ;;
     # deletes generated files
     clean)
         TASK_SCRIPT=cbuild/default_tasks/clean.sh

src/RBTree.hpp

@@ -44,14 +44,20 @@ private:
         {}
 
         bool isLeaf() const {
-            return parent == this;
+            return this == null_node_ptr;
         }
 
-        ~Node(){
-            if(!left->isLeaf())
+        void deleteChildren(){
+            if(isLeaf())
+                return;
+            if(!left->isLeaf()){
+                left->deleteChildren();
                 delete left;
-            if(!right->isLeaf())
+            }
+            if(!right->isLeaf()){
+                right->deleteChildren();
                 delete right;
+            }
         }
 
         /// if is leaf returns itself
@@ -298,8 +304,10 @@ public:
     RBTree() {}
 
     ~RBTree(){
-        if(!root->isLeaf())
+        if(!root->isLeaf()){
+            root->deleteChildren();
             delete root;
+        }
     }
 
 
@@ -478,7 +486,10 @@ public:
         // delete node without children
         n->left = null_node_ptr;
         n->right = null_node_ptr;
-        delete n;
+        if(!n->isLeaf()){
+            n->deleteChildren();
+            delete n;
+        }
         return true;
     }
 

src/gui/exceptions.hpp

@@ -11,7 +11,6 @@ public:
     SDLException_(const std::string& _file, const std::string& _func, int line_n);
 };
 
-#define SDL_TRY_ZERO(FUNC_CALL) if(FUNC_CALL != 0) throw SDLException();
-#define SDL_TRY_ONE(FUNC_CALL) if(FUNC_CALL != 1) throw SDLException();
+#define SDL_TRY(EXPR) if(EXPR) throw SDLException();
 
 }

src/gui/fonts.cpp

@@ -1,19 +1,33 @@
 #include "gui.hpp"
+#include "../resources.hpp"
 
 namespace GraphC::gui::fonts {
 
-ImFont* ImFont_LoadFromFile(const char* file_path, f32 font_size, f32 dpi){
+// select all glyphs from font
+static const ImWchar glyph_ranges[] = {
+    0x0020, 0xFFFF, 0
+};
+
+ImFont* ImFont_LoadFromFile(const std::string& file_path, f32 font_size, f32 dpi){
     ImGuiIO& io = ImGui::GetIO();
     font_size *= dpi;
-    return io.Fonts->AddFontFromFileTTF(file_path, font_size);
+    return io.Fonts->AddFontFromFileTTF(file_path.c_str(), font_size, nullptr, glyph_ranges);
 }
 
-ImFont* _ImFont_LoadEmbedded(const void* data, int data_size, const char* font_name, f32 font_size, f32 dpi){
+ImFont* ImFont_LoadEmbedded(const std::string& font_name, f32 font_size, f32 dpi){
     ImGuiIO& io = ImGui::GetIO();
     font_size *= dpi;
     ImFontConfig font_cfg = ImFontConfig();
-    ksprintf(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s, %.0fpx", font_name, font_size);
-    return io.Fonts->AddFontFromMemoryCompressedTTF(data, data_size, font_size, &font_cfg);
+    font_cfg.FontDataOwnedByAtlas = false;
+    ksprintf(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s %ipx", font_name.c_str(), (i32)font_size);
+    
+    const resources::EmbeddedResource** _res = nullptr;
+    if(!resources::getMap()->tryGet("fonts/" + font_name + ".ttf", &_res))
+        throw UsefulException(format("can't load embedded font '%s'", font_name.c_str()));
+    const resources::EmbeddedResource* res = *_res;
+
+    return io.Fonts->AddFontFromMemoryTTF((void*)(res->data), res->size,
+        font_size, &font_cfg, glyph_ranges);
 }
 
 }

src/gui/fonts.hpp

@@ -1,23 +1,12 @@
 #pragma once
 
 #include "imgui.h"
-#include "../generated/fonts_embedded.h"
+#include "../../dependencies/kerep/src/base/std.h"
 
 namespace GraphC::gui::fonts {
 
-#define __CAT3(A,B,C) A##B##C
-#define embedded_font_data(FONT) __CAT3(font_,FONT,_compressed_data)
-#define embedded_font_data_size(FONT) __CAT3(font_,FONT,_compressed_size)
-#define embedded_font_name(FONT) #FONT
+ImFont* ImFont_LoadFromFile(const std::string& file_path, f32 font_size, f32 dpi);
 
-
-ImFont* ImFont_LoadFromFile(const char* file_path, f32 font_size, f32 dpi);
-
-#define ImFont_LoadEmbedded(FONT, FONT_SIZE, DPI) _ImFont_LoadEmbedded( \
-    embedded_font_data(FONT), \
-    embedded_font_data_size(FONT), \
-    embedded_font_name(FONT), \
-    FONT_SIZE, DPI)
-ImFont* _ImFont_LoadEmbedded(const void* data, int data_size, const char* font_name, f32 font_size, f32 dpi);
+ImFont* ImFont_LoadEmbedded(const std::string& font_name, f32 font_size, f32 dpi);
 
 }

src/gui/gui.cpp

@@ -16,16 +16,16 @@ f32 GUI::getDPI(){
 }
 
 void GUI::init(const char* window_title){
-    SDL_TRY_ZERO(SDL_Init(SDL_INIT_VIDEO));
+    SDL_TRY(SDL_Init(SDL_INIT_VIDEO));
     SDL_version v;
     SDL_GetVersion(&v);
     kprintf("SDL version: %u.%u.%u\n", v.major, v.minor, v.patch);
     // GL 3.0 + GLSL 130
     const char* glsl_version = "#version 130";
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0));
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE));
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3));
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0));
 
     // From 2.0.18: Enable native IME.
 #ifdef SDL_HINT_IME_SHOW_UI
@@ -33,9 +33,9 @@ void GUI::init(const char* window_title){
 #endif
     
     // Create window with graphics context
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1));
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24));
-    SDL_TRY_ZERO( SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24));
+    SDL_TRY( SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8));
     SDL_WindowFlags window_flags = (SDL_WindowFlags)(
         SDL_WINDOW_OPENGL |
         SDL_WINDOW_RESIZABLE |
@@ -48,8 +48,8 @@ void GUI::init(const char* window_title){
     gl_context = SDL_GL_CreateContext(sdl_window);
     if(gl_context == nullptr)
         throw SDLException();
-    SDL_TRY_ZERO( SDL_GL_MakeCurrent(sdl_window, gl_context));
-    SDL_TRY_ZERO( SDL_GL_SetSwapInterval(1)); // Enable vsync
+    SDL_TRY( SDL_GL_MakeCurrent(sdl_window, gl_context));
+    SDL_TRY( SDL_GL_SetSwapInterval(1)); // Enable vsync
 
     // Setup Dear ImGui context
     IMGUI_CHECKVERSION();
@@ -73,8 +73,7 @@ void GUI::init(const char* window_title){
     // Setup Dear ImGui style
     ImGui::StyleColorsDark();
     f32 dpi = getDPI();
-    io.FontDefault=fonts:: ImFont_LoadEmbedded(default_font, default_font_size, dpi);
-    fonts:: ImFont_LoadEmbedded(font_Cousine_Regular, default_font_size, dpi);
+    io.FontDefault = fonts::ImFont_LoadEmbedded(default_font, default_font_size, dpi);
 
     ImNodes::CreateContext();
     ImNodes::StyleColorsDark();
@@ -88,7 +87,7 @@ void GUI::poll_events(u16& frame_updates_requested, bool wait){
     SDL_Event event;
     if(wait){
         // waits for first event in cpu-efficient way
-        SDL_TRY_ONE(SDL_WaitEvent(&event)); 
+        SDL_TRY(SDL_WaitEvent(&event) != 1); 
     }
     // dont wait for event
     else if(!SDL_PollEvent(&event))

src/gui/gui.hpp

@@ -20,7 +20,7 @@
 
 namespace GraphC::gui {
 
-#define default_font font_DroidSans
+#define default_font "DroidSans"
 
 class GUI {
 public:

src/main.cpp

@@ -3,6 +3,7 @@
 // THe following define disables this feature.
 #define SDL_MAIN_HANDLED
 #include "gui/gui.hpp"
+#include "resources.hpp"
 
 int main(const int argc, const char* const* argv){
     if(setlocale(LC_CTYPE, "C.UTF-8")!=0)
@@ -13,6 +14,8 @@ int main(const int argc, const char* const* argv){
     kt_endInit();
 
     try {
+        resources::init();
+
         GraphC::gui::GUI gui;
         gui.init("GraphC");
         gui.startAndWait();

src/resources.cpp

@@ -0,0 +1,24 @@
+#include "gui/gui.hpp"
+#include "resources.hpp"
+#include "UsefulException.hpp"
+
+namespace resources {
+
+static RBTree<std::string, const EmbeddedResource*>* _resourceMap = nullptr;
+
+void init(){
+    if(_resourceMap != nullptr)
+        throw UsefulException("resource has been initialized already");
+    _resourceMap = new RBTree<std::string, const EmbeddedResource*>();
+    for(int i = 0; i < EmbeddedResource_table_count; i++){
+        kprintf("loading resource '%s' (%lliK)\n", 
+            EmbeddedResource_table[i].path, EmbeddedResource_table[i].size/1024);
+        _resourceMap->tryAdd(EmbeddedResource_table[i].path, &EmbeddedResource_table[i], nullptr);
+    }
+}
+
+const RBTree<std::string, const EmbeddedResource*>* getMap(){
+    return _resourceMap;
+}
+
+}

src/resources.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+#include "RBTree.hpp"
+
+namespace resources {
+extern "C" {
+    #include "generated/resources.h"
+}
+
+void init();
+
+const RBTree<std::string, const EmbeddedResource*>* getMap();
+
+}

tasks/clean_additions.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-try_delete_dir_or_file fonts/generated
+try_delete_dir_or_file src/generated

tasks/embed_fonts.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-cd fonts
-SRC_C=""
-HEADER="generated/fonts_embedded.h"
-
-function append_def_to_header {
-    local c_src_file=$1
-    local c_var_name=$2
-    local header_file=$3
-    echo "#define $c_var_name $(echo $c_var_name | sed 's/font_//')" >> "$header_file"
-    sed '3!d;' $c_src_file | sed 's/const/static const/' >> "$header_file"
-    sed '4!d;' $c_src_file | sed 's/const/extern const/' | sed 's/\[.*/[];/' >> "$header_file"
-}
-
-rm -rf generated
-mkdir generated
-mkdir generated/src
-$CMP_CPP binary_to_compressed_c.cpp -o generated/binary_to_compressed_c.exe
-for ttf_file in $(ls *.ttf); do
-    c_var_name="font_$(basename $ttf_file .ttf | tr ' ' '_' | tr '-' '_')"
-    c_src_file="generated/src/$c_var_name.c"
-    myprint "$ttf_file : $c_var_name > c_src_file"
-    generated/binary_to_compressed_c.exe -nostatic "$ttf_file" "$c_var_name" > "$c_src_file"
-    SRC_C="$SRC_C fonts/$c_src_file"
-    append_def_to_header "$c_src_file" "$c_var_name" "$HEADER"
-done
-cd ..
-mkdir -p src/generated/
-cp -v fonts/$HEADER src/$HEADER
-myprint "${GREEN}font arrays external definitions have been written to ${CYAN}src/$HEADER"
-
-# delete old objects
-clean_dir "$OBJDIR/objects"
-# compiling
-compile_c "$C_ARGS" "$SRC_C"
-pack_static_lib "$STATIC_LIB_FILE"
-# moving lib file
-mv "$OUTDIR/$STATIC_LIB_FILE" libs/
-mkdir -p "libs"
-myprint "$OUTDIR/$STATIC_LIB_FILE -> libs/"