bru

h

text_rendering/msdf_c/sample/sample.c

@@ -0,0 +1,210 @@
+//#include "svpng.h"
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+#define STB_TRUETYPE_IMPLEMENTATION
+#include "../stb_truetype.h"
+#define MSDF_IMPLEMENTATION
+#include "../msdf.h"
+
+#include "stdio.h"
+
+
+#ifndef SAMPLE_ROOT
+#define SAMPLE_ROOT ""
+#endif
+
+typedef struct Range {
+    void* content;
+    size_t size;
+} Range;
+
+Range g_fileRead(const char* fileName) {
+    Range range = {NULL, 0};
+
+    FILE* fileHandle = fopen(fileName, "rb");
+    if (fileHandle == NULL) {
+        assert(!"File not fount");
+        return range;
+    }
+
+    fseek(fileHandle, 0, SEEK_END); // seek to end of file
+    size_t size = ftell(fileHandle); // get current file pointer
+    fseek(fileHandle, 0, SEEK_SET); // seek back to beginning of file
+
+    if (size == 0) {
+        assert(!"File size zero");
+        return range;
+    }
+
+    void* mem = malloc(size);
+    size_t readSize = fread(mem, 1, size, fileHandle);
+    if (readSize == size) {
+        range.content = mem;
+        range.size = size;
+    } else {
+        free(mem);
+    }
+    fclose(fileHandle);
+    return range;
+}
+
+static void* g_alloc(size_t size, void* ctx) {
+    return malloc(size);
+}
+
+static void g_free(void* ptr, void* ctx) {
+    return free(ptr);
+}
+
+float g_min(float a, float b) {
+    return a > b ? b : a;
+}
+
+float g_max(float a, float b) {
+    return a > b ? a : b;
+}
+
+float g_clamp(float val, float min, float max) {
+    return g_min(g_max(val, min), max);
+}
+
+float g_median(float r, float g, float b) {
+    return g_max(g_min(r, g), g_min(g_max(r, g), b));
+}
+
+float g_map(float min, float max, float v) {
+    return (v - min) / (max - min);
+}
+
+int main() {
+    stbtt_fontinfo stbttInfo;
+
+    Range fontFile = g_fileRead("./fonts/Roboto-Regular.ttf");
+
+    if (fontFile.content == NULL) {
+        assert(!"could not load font from disk");
+        return 1;
+    }
+
+    if (!stbtt_InitFont(&stbttInfo, fontFile.content, stbtt_GetFontOffsetForIndex(fontFile.content, 0))) {
+        assert(!"Couldn't parse font");
+		return 1;
+    }
+
+
+    int ascent, descent;
+    stbtt_GetFontVMetrics(&stbttInfo, &ascent, &descent, 0);
+
+    int borderSize = 4;
+    int genSize = 32+borderSize;
+    float genScale = stbtt_ScaleForPixelHeight(&stbttInfo, genSize);
+
+   // int glyph = 0x00e8; // è
+	int glyph = 0x069D;
+
+    int glyphIdx = stbtt_FindGlyphIndex(&stbttInfo, glyph);
+
+    msdf_AllocCtx allocCtx = {g_alloc, g_free, NULL};
+
+
+	printf("bruh\n");
+
+    msdf_Result result;
+    int success = msdf_genGlyph(&result, &stbttInfo, glyphIdx, borderSize, genScale, 2.0f / genSize, &allocCtx);
+
+    if (success == 0) {
+        assert(!"Failed to generate msdf glyph");
+        return 1;
+    }
+	printf("bruh\n");
+
+//    FILE* fp = fopen(SAMPLE_ROOT "/sdf.png", "wb");
+
+    uint8_t* pixels = malloc(sizeof(uint8_t) * result.width * result.height * 3);
+    float scale = genSize;
+    float maxValue = 1.0 * (scale);
+    float transistionWidth = ((((((float) genSize) * 0.7f) + scale) / (scale * 2.0f)));
+    float transistionAbs = (transistionWidth - 0.5);
+    float transistStart = 0.5 - transistionAbs / 2;
+    float transistEnd = transistStart + transistionAbs;
+   
+    //float ff = expf(0.01);
+    for (int y = 0; y < result.height; y++) {
+        int yPos = result.width * 3 * y;
+        uint8_t* pixelRow = pixels + (y * result.width * 3);
+        for (int x = 0; x < result.width; x++) {
+            int indexSdf = yPos + (x * 3);
+            float r = result.rgb[indexSdf + 0];
+            float g = result.rgb[indexSdf + 1];
+            float b = result.rgb[indexSdf + 2];
+
+
+            r = ((((r) + scale) / (scale * 2.0f)));
+            g = ((((g) + scale) / (scale * 2.0f)));
+            b = ((((b) + scale) / (scale * 2.0f)));
+
+            if (r > transistStart) {
+                if (r > (transistEnd)) {
+                    r = 1.0f;
+                } else {
+                    r = 0.0f + (r - transistStart) / (transistionAbs);
+                }
+            } else {
+                r = 0.0f;
+            }
+            if (g > transistStart) {
+                if (g > (transistEnd)) {
+                    g = 1.0f;
+                } else {
+                    g = 0.0f + (g - transistStart) / (transistionAbs);
+                }
+            } else {
+                g = 0.0f;
+            }
+            if (b > transistStart) {
+                if (b > (transistEnd)) {
+                    b = 1.0f;
+                } else {
+                    b = 0.0f + (b - transistStart) / (transistionAbs);
+                }
+            } else {
+                b = 0.0f;
+            }
+
+            pixelRow[x * 3 + 0] = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f;
+            pixelRow[x * 3 + 1] = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f;
+            pixelRow[x * 3 + 2] = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f;
+        }
+    }
+//	printf("bruh\n");
+//
+//    svpng(fp, result.width, result.height, pixels, 0);
+	stbi_write_png("./sdf.png", result.width, result.height, 3, pixels, 3*result.width);
+//    fclose(fp);
+
+    // apply sdf
+//
+//    FILE* finalImage = fopen(SAMPLE_ROOT "/final.png", "wb");
+//
+//    uint8_t* rgbaFinal = malloc(sizeof(uint8_t) * result.width * result.height * 4);
+//
+//    for (int y = 0; y < result.height; y++) {
+//        uint8_t* pixelRow = pixels + (y * result.width * 3);
+//        uint8_t* rgbaFinalRow = rgbaFinal + (y * result.width * 4);
+//        for (int x = 0; x < result.width; x++) {
+//            float r = ((float)pixelRow[x * 3 + 0]) / 255.0f;// = r * 255.0f; // (r > 0.5f) ? 255.0f : r * 255.0f;
+//            float g = ((float)pixelRow[x * 3 + 1]) / 255.0f;// = g * 255.0f; // (g > 0.5f) ? 255.0f : g * 255.0f;
+//            float b = ((float)pixelRow[x * 3 + 2]) / 255.0f;// = b * 255.0f; // (b > 0.5f) ? 255.0f : b * 255.0f;
+//            float dist = g_median(r, g, b);
+//            float opacity = g_clamp(dist - 0.5f, 0, 1) * 2.0f;
+//            rgbaFinalRow[x * 4 + 0] = 0;//255.0f;
+//            rgbaFinalRow[x * 4 + 1] = 0;//255.0f;
+//            rgbaFinalRow[x * 4 + 2] = 0;//255.0f;
+//            rgbaFinalRow[x * 4 + 3] = opacity * 255.0f;
+//
+//        }
+//    }
+//    svpng(finalImage, result.width, result.height, rgbaFinal, 1);
+//    fclose(finalImage);
+    return 0;
+}