[feat] add freetype bindings

Author: slukash

libraries/freetype.c3l/README.md

@@ -0,0 +1,213 @@
+# FreeType bindings
+
+It is tested only on arm macos.
+
+To make it work on other systems you need to add your platform to `manifest.json`, something like this:
+
+```json
+"macos-aarch64": {
+  // Extra flags to the linker for this target:
+  "link-args": [
+    "-I/opt/homebrew/opt/freetype/include/freetype2",
+    "-L/opt/homebrew/opt/freetype/lib"
+  ],
+  // C3 libraries this target depends on:
+  "dependencies": [],
+  // The external libraries to link for this target:
+  "linked-libraries": [
+    "freetype"
+  ]
+}
+```
+
+`link-args` and `linked-libraries` can be found with this commands.
+
+```bash
+$ freetype-config --libs
+-L/opt/homebrew/opt/freetype/lib -lfreetype
+$ freetype-config --cflags
+-I/opt/homebrew/opt/freetype/include/freetype2
+```
+
+Note that `-L/opt/homebrew/opt/freetype/lib` goes to `link-args` and not to `linked-libraries`.
+
+Here is a simple program that draws text in the terminal:
+
+```
+import freetype;
+import std::io;
+
+// image of char
+struct Image {
+    char** pixels;
+    int x_max;
+    int y_max;
+}
+
+fn void draw_bitmap(CUChar* buffer, Image* image) {
+    for (int x = 0; x < image.x_max; x++) {
+        for (int y = 0; y < image.y_max; y++) {
+            image.pixels[y][x] |= buffer[y * image.x_max + x];
+        }
+    }
+}
+
+fn int main() {
+    mem::@report_heap_allocs_in_scope() {
+        ft::Library library;
+        ft::Face face;
+        CInt err;
+
+        // init freetype lib
+        err = ft::initFreeType(&library);
+        if (err != 0) {
+            io::printfn("init free type err: %s", err);
+            return err;
+        }
+
+        // load face
+        err = ft::newFace(library, "/Library/Fonts/Arial Unicode.ttf", 0, &face);
+        if (err != ft::Errors.OK.code) {
+            io::printfn("can't load font: %s", err);
+            return err;
+        }
+
+        // set font size
+        err = ft::setPixelSizes(face, 20, 0);
+        if (err != ft::Errors.OK.code) {
+            io::printfn("can't set pixel sizes: %s", err);
+            return err;
+        }
+
+        // our string to print
+        ZString str = "Hi_c3";
+
+        // allocate array of images for out text
+        Allocator allocator = allocator::heap();
+        Image* images = allocator::alloc_array(allocator, Image, (int)str.char_len());
+        defer {
+            for (int i = 0; i < str.char_len(); i++) {
+                for (int j = 0; j < images[i].y_max; j++) {
+                    allocator::free(allocator, images[i].pixels[j]);
+                }
+                allocator::free(allocator, images[i].pixels);
+            }
+            allocator::free(allocator, images);
+        }
+
+        // max height across all chars
+        int height = 0;
+        // total width of all chars
+        int width = 0;
+
+        // loop over our string and generate chars
+        for (int i = 0; i < str.char_len(); i++) {
+            char c = str[i];
+            // loading a char
+            err = ft::loadChar(face, c, ft::LOAD_RENDER);
+            if (err != ft::Errors.OK.code) {
+                io::printfn("can't load char: %s", err);
+                return err;
+            }
+
+            Image image = Image {
+                .x_max = face.glyph.bitmap.width,
+                .y_max = face.glyph.bitmap.rows,
+                .pixels = allocator::alloc_array(allocator, char*, image.y_max),
+            };
+
+            // calculating max heigh
+            if (image.y_max > height) {
+                height = image.y_max;
+            }
+            // calculating total width
+            // add 1 to make distance between chars
+            width += image.x_max + 1;
+
+            for (int j = 0; j < image.y_max; j++) {
+                image.pixels[j] = allocator::alloc_array(allocator, char, image.x_max);
+            }
+
+            draw_bitmap(face.glyph.bitmap.buffer, &image);
+
+            images[i] = image;
+        }
+
+        // horizontal render of our string
+        char** final_image = allocator::alloc_array(allocator, char*, height);
+        for (int i = 0; i < height; i++) {
+            final_image[i] = allocator::alloc_array(allocator, char, width);
+        }
+        defer {
+            for (int i = 0; i < height; i++) {
+                allocator::free(allocator, final_image[i]);
+            }
+            allocator::free(allocator, final_image);
+        }
+
+        // by default final_image contains '\0'
+        // this will cause a broken output to the terminal so we replace it with whitespaces
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width+str.char_len(); x++) {
+                final_image[y][x] = ' ';
+            }
+        }
+
+        // x offset of char
+        int offset = 0;
+        // iterate over our string
+        for (int i = 0; i < str.char_len(); i++) {
+            for (int y = 0; y < images[i].y_max; y++) {
+                for (int x = 0; x < images[i].x_max; x++) {
+                    // v is vertical location of pixel
+                    // char are not equal by height so we need to move smaller chars down
+                    int v = height - images[i].y_max + y;
+                    // h is horizontal location of pixel
+                    // we need to offset it to the right
+                    int h = offset + x + i;
+                    if (images[i].pixels[y][x] == 0) {
+                        final_image[v][h] = ' ';
+                    } else if (images[i].pixels[y][x] < 128) {
+                        final_image[v][h] = '+';
+                    } else {
+                        final_image[v][h] = '*';
+                    }
+                }
+            }
+            offset += images[i].x_max;
+        }
+
+        // draw final_image
+        for (int i = 0; i < height; i++) {
+            for (int j = 0; j < width+str.char_len(); j++) {
+                io::printf("%c", final_image[i][j]);
+            }
+            io::printf("\n");
+        }
+
+        // clean after you are done
+        ft::doneFace(face);
+        ft::doneFreeType(library);
+    };
+
+    return 0;
+}
+```
+
+You should get something like this:
+```
++**      +** **+                           +****++
++**      +** **+                          +*******
++**      +**                              ***+++**+
++**      +**                              **+   +**
++**      +** **+                +*****+         +*+
++**      +** **+               +*******+      ++**+
++*********** **+               ***+++**+     ****+
++*********** **+              +**+           *****+
++**      +** **+              +**             ++***+
++**      +** **+              +**                **+
++**      +** **+              +**+       +**+   +**+
++**      +** **+               ***++++**  ***+++***+
++**      +** **+               +*******+  +*******+
++**      +** **+ +**********+   +*****+    +*****+
+```