add networking, 3d improvements, reorganize src structure

src/gfx/pxl8_colormap.c

@@ -0,0 +1,116 @@
+#include "pxl8_colormap.h"
+#include <string.h>
+
+static void rgb_to_hsl(u8 r, u8 g, u8 b, i32* h, i32* s, i32* l) {
+    i32 max = r > g ? (r > b ? r : b) : (g > b ? g : b);
+    i32 min = r < g ? (r < b ? r : b) : (g < b ? g : b);
+    i32 chroma = max - min;
+
+    *l = (max + min) / 2;
+
+    if (chroma == 0) {
+        *h = 0;
+        *s = 0;
+    } else {
+        i32 denom = 255 - (*l > 127 ? 2 * (*l) - 255 : 255 - 2 * (*l));
+        if (denom <= 0) denom = 1;
+        *s = (chroma * 255) / denom;
+        if (*s > 255) *s = 255;
+
+        if (max == (i32)r) {
+            *h = (((i32)g - (i32)b) * 60) / chroma;
+            if (*h < 0) *h += 360;
+        } else if (max == (i32)g) {
+            *h = 120 + (((i32)b - (i32)r) * 60) / chroma;
+        } else {
+            *h = 240 + (((i32)r - (i32)g) * 60) / chroma;
+        }
+    }
+}
+
+static u8 find_closest_color(const u32* palette, u8 target_r, u8 target_g, u8 target_b) {
+    u8 best_idx = 1;
+    u32 best_dist = 0xFFFFFFFF;
+
+    u8 dynamic_end = PXL8_DYNAMIC_RANGE_START + PXL8_DYNAMIC_RANGE_COUNT;
+
+    i32 th, ts, tl;
+    rgb_to_hsl(target_r, target_g, target_b, &th, &ts, &tl);
+
+    for (u32 i = 1; i < PXL8_FULLBRIGHT_START; i++) {
+        if (i >= PXL8_DYNAMIC_RANGE_START && i < dynamic_end) {
+            continue;
+        }
+
+        u32 c = palette[i];
+        u8 pr = c & 0xFF;
+        u8 pg = (c >> 8) & 0xFF;
+        u8 pb = (c >> 16) & 0xFF;
+
+        i32 ph, ps, pl;
+        rgb_to_hsl(pr, pg, pb, &ph, &ps, &pl);
+
+        i32 dh = th - ph;
+        if (dh > 180) dh -= 360;
+        if (dh < -180) dh += 360;
+
+        i32 ds = ts - ps;
+        i32 dl = tl - pl;
+
+        u32 dist = (u32)(dh * dh * 4 + ds * ds + dl * dl);
+
+        if (dist < best_dist) {
+            best_dist = dist;
+            best_idx = (u8)i;
+            if (dist == 0) break;
+        }
+    }
+
+    return best_idx;
+}
+
+void pxl8_colormap_generate(pxl8_colormap* cm, const u32* palette, const pxl8_level_tint* tint) {
+    if (!cm || !palette) return;
+
+    u8 dark_r, dark_g, dark_b;
+    if (tint && tint->tint_strength > 0.0f) {
+        f32 t = tint->tint_strength;
+        f32 inv = 1.0f - t;
+        dark_r = (u8)(tint->dark_r * inv + tint->tint_r * t);
+        dark_g = (u8)(tint->dark_g * inv + tint->tint_g * t);
+        dark_b = (u8)(tint->dark_b * inv + tint->tint_b * t);
+    } else if (tint) {
+        dark_r = tint->dark_r;
+        dark_g = tint->dark_g;
+        dark_b = tint->dark_b;
+    } else {
+        dark_r = dark_g = dark_b = 0;
+    }
+
+    for (u32 light = 0; light < PXL8_LIGHT_LEVELS; light++) {
+        f32 brightness = (f32)light / (f32)(PXL8_LIGHT_LEVELS - 1);
+
+        for (u32 pal_idx = 0; pal_idx < 256; pal_idx++) {
+            u8 result_idx;
+
+            if (pal_idx == PXL8_TRANSPARENT) {
+                result_idx = PXL8_TRANSPARENT;
+            } else if (pal_idx >= PXL8_FULLBRIGHT_START) {
+                result_idx = (u8)pal_idx;
+            } else {
+                u32 c = palette[pal_idx];
+                u8 r = c & 0xFF;
+                u8 g = (c >> 8) & 0xFF;
+                u8 b = (c >> 16) & 0xFF;
+
+                u8 target_r = (u8)(dark_r + (r - dark_r) * brightness);
+                u8 target_g = (u8)(dark_g + (g - dark_g) * brightness);
+                u8 target_b = (u8)(dark_b + (b - dark_b) * brightness);
+
+                result_idx = find_closest_color(palette, target_r, target_g, target_b);
+            }
+
+            cm->table[light * 256 + pal_idx] = result_idx;
+        }
+    }
+}