allat

.gitignore

@@ -1,5 +1,4 @@
 te
-ded
 SDL2
 *.exe
 *.obj

build.sh

@@ -1,15 +1,37 @@
-#!/bin/sh
+#!/bin/bash
+
+askforoverwrite=true  # Set to false to disable overwrite prompt
+
+if [ ! -d "$HOME/.config/ded" ]; then
+    cp -r ./config/ded "$HOME/.config/"
+elif [ "$askforoverwrite" = true ]; then
+    echo "Config already exists. Overwrite? (y/n)"
+    read -r -n 1 overwrite_confirmation
+    echo  # Move to a new line
+
+    if [ "$overwrite_confirmation" = "y" ]; then
+        rm -rf "$HOME/.config/ded"
+        cp -r ./config/ded "$HOME/.config/"
+        echo "Config overwritten."
+    else
+        echo "Not overwriting the config."
+    fi
+else
+    echo "Config already exists. Overwrite not allowed."
+fi
 
 set -xe
 
 CC="${CXX:-cc}"
 PKGS="sdl2 glew freetype2"
-CFLAGS="-Wall -Wextra -std=c11 -pedantic -ggdb"
+CFLAGS="-Wall -Wextra -std=c11 -pedantic -ggdb -ljson-c -lpthread -D_DEFAULT_SOURCE"
 LIBS=-lm
-SRC="src/main.c src/la.c src/editor.c src/file_browser.c src/free_glyph.c src/simple_renderer.c src/common.c src/lexer.c"
+SRC="src/*.c"
 
 if [ `uname` = "Darwin" ]; then
     CFLAGS+=" -framework OpenGL"
 fi
 
-$CC $CFLAGS `pkg-config --cflags $PKGS` -o ded $SRC $LIBS `pkg-config --libs $PKGS`
+$CC $CFLAGS `pkg-config --cflags $PKGS` -o ded $SRC $LIBS `pkg-config --libs $PKGS `
+
+

config/ded/shaders/cursor.frag

@@ -0,0 +1,67 @@
+/* #version 330 core */
+
+/* in vec4 out_color; */
+
+/* void main() { */
+/*     gl_FragColor = out_color; */
+/* } */
+
+
+#version 330 core
+
+in vec4 out_color;  // Color input for the object.
+in vec2 frag_coord;  // The coordinate of the current fragment in screen space.
+
+uniform vec2 light_position;  // The position of the light source in screen space.
+
+out vec4 frag_color;  // Output color of the fragment.
+
+void main() {
+    // Calculate the distance between the fragment and the light source.
+    float distance_to_light = length(frag_coord - light_position);
+
+    // Define a shadow radius and adjust the shadow intensity.
+    float shadow_radius = 100.0;
+    float shadow_intensity = 0.3;  // Adjust this value to control the shadow intensity.
+
+    // Calculate the shadow factor based on distance.
+    float shadow_factor = smoothstep(shadow_radius, shadow_radius + 1.0, distance_to_light);
+
+    // Apply the shadow factor to darken the input color.
+    vec3 fragment_color = out_color.rgb * (1.0 - shadow_intensity * shadow_factor);
+
+    frag_color = vec4(fragment_color, out_color.a);
+}
+
+
+
+
+// GRADIENT
+/* #version 330 core */
+
+/* in vec2 fragTexCoord; // Texture coordinate, if you're using textures */
+/* uniform float time;   // Uniform variable for time */
+/* uniform vec2 cursorPos; // Cursor position in screen coordinates */
+/* uniform vec2 resolution; // Screen resolution */
+
+/* out vec4 color; */
+
+/* void main() { */
+/*     // Calculate normalized coordinates */
+/*     vec2 uv = fragTexCoord / resolution; */
+
+/*     // Create a dynamic gradient based on time */
+/*     vec3 gradient = 0.5 + 0.9 * cos(time + uv.xyx + vec3(0, 2, 4)); */
+
+/*     // Create a glow effect */
+/*     float dist = distance(uv, cursorPos / resolution); */
+/*     float glow = exp(20.0 * dist); */
+
+/*     // Combine the gradient and glow */
+/*     vec3 finalColor = gradient * glow; */
+
+/*     // Output the color */
+/*     color = vec4(finalColor, 0.7); // Fully opaque */
+/* } */
+
+

config/ded/shaders/fixed.vert

@@ -0,0 +1,24 @@
+#version 330 core
+
+uniform vec2 resolution;
+uniform float time;
+
+layout(location = 0) in vec2 position;
+layout(location = 1) in vec4 color;
+layout(location = 2) in vec2 uv;
+
+out vec4 out_color;
+out vec2 out_uv;
+
+vec2 simple_project(vec2 point)
+{
+    // Project the point directly based on the resolution
+    return (2.0 * point / resolution) - vec2(1.0);
+}
+
+void main() {
+    // Use the simple projection method without camera transformations
+    gl_Position = vec4(simple_project(position), 0.0, 1.0);
+    out_color = color;
+    out_uv = uv;
+}

config/ded/shaders/minibuffer.vert

@@ -0,0 +1,28 @@
+#version 330 core
+
+uniform vec2 resolution;
+uniform float time;
+
+layout(location = 0) in vec2 position;
+layout(location = 1) in vec4 color;
+layout(location = 2) in vec2 uv;
+
+out vec4 out_color;
+out vec2 out_uv;
+
+const float scaleFactor = 0.25;
+
+vec2 simple_project(vec2 point) {
+    // Project the point directly based on the resolution
+    return (2.0 * point / resolution) - vec2(1.0);
+}
+
+void main() {
+    // Apply the scale factor to the position
+    vec2 scaledPosition = position * scaleFactor;
+
+    // Use the simple projection method without camera transformations
+    gl_Position = vec4(simple_project(scaledPosition), 0.0, 1.0);
+    out_color = color;
+    out_uv = uv;
+}

config/ded/shaders/simple_acid.frag

@@ -0,0 +1,36 @@
+#version 330 core
+
+uniform float time;
+uniform vec2 resolution;
+uniform sampler2D image;
+
+in vec2 out_uv;
+
+vec3 hsl2rgb(vec3 c) {
+    vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0);
+    return c.z + c.y * (rgb-0.5)*(1.0-abs(2.0*c.z-1.0));
+}
+
+void main() {
+    vec4 tc = texture(image, out_uv);
+    float d = tc.r;
+    float aaf = fwidth(d);
+    float alpha = smoothstep(0.5 - aaf, 0.5 + aaf, d);
+
+    vec2 frag_uv = gl_FragCoord.xy / resolution;
+
+    // Firefly movement: This simulates the movement of 3 "fireflies"
+    float f1 = abs(sin(frag_uv.x * 10.0 + time));
+    float f2 = abs(cos(frag_uv.y * 8.0 + time * 1.5));
+    float f3 = abs(sin(frag_uv.x * 12.0 + frag_uv.y * 12.0 + time * 0.7));
+
+    // Combine fireflies' impact
+    float fireflyEffect = f1 + f2 + f3;
+
+    // Translate that to a color-shifting effect
+    vec3 fireflyColor = hsl2rgb(vec3(fireflyEffect * 0.3, 0.6, 0.5));
+
+    vec3 finalColor = mix(tc.rgb, fireflyColor, d * fireflyEffect);
+
+    gl_FragColor = vec4(finalColor, alpha);
+}

config/ded/shaders/simple_epic.frag

@@ -0,0 +1,31 @@
+#version 330 core
+
+uniform float time;
+uniform vec2 resolution;
+uniform sampler2D image;
+
+in vec2 out_uv;
+
+vec3 hsl2rgb(vec3 c) {
+    vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0);
+    return c.z + c.y * (rgb-0.5)*(1.0-abs(2.0*c.z-1.0));
+}
+
+void main() {
+    vec4 tc = texture(image, out_uv);
+    float d = tc.r;
+    float aaf = fwidth(d);
+    float alpha = smoothstep(0.5 - aaf, 0.5 + aaf, d);
+
+    vec2 frag_uv = gl_FragCoord.xy / resolution;
+
+    // Dynamic color-shifting aura
+    vec3 auraColor = hsl2rgb(vec3(mod(time * 0.2 + frag_uv.y, 1.0), 0.5, 0.5));
+
+    // Shimmering gradient across the text
+    float shimmer = (sin(time * 3.0 + frag_uv.x * 10.0) + 1.0) * 0.5;
+    vec3 shimmerColor = mix(vec3(1.0, 0.8, 0.6), vec3(0.6, 0.8, 1.0), shimmer);
+
+    vec3 finalColor = mix(auraColor, shimmerColor, d);
+    gl_FragColor = vec4(finalColor, alpha);
+}

config/ded/shaders/simple_glow.frag

@@ -0,0 +1,20 @@
+#version 330 core
+
+uniform sampler2D image; // The off-screen texture with the cursor
+uniform float blurSize;  // The size of the blur effect (experiment with this value)
+
+in vec2 out_uv;
+
+const float offset[5] = float[](0.0, 1.333, 2.666, 4.0, 5.333); // Offsets for Gaussian blur
+
+void main() {
+    vec4 sum = texture(image, out_uv) * 0.2941; // Central sample (weight is highest)
+
+    sum += texture(image, out_uv + vec2(blurSize * offset[1], 0.0)) * 0.2353;
+    sum += texture(image, out_uv - vec2(blurSize * offset[1], 0.0)) * 0.2353;
+    sum += texture(image, out_uv + vec2(blurSize * offset[2], 0.0)) * 0.1176;
+    sum += texture(image, out_uv - vec2(blurSize * offset[2], 0.0)) * 0.1176;
+    // ... Add more samples if needed
+
+    gl_FragColor = sum;
+}

config/ded/shaders/simple_pony.frag

@@ -0,0 +1,31 @@
+#version 330 core
+
+uniform float time;
+uniform vec2 resolution;
+uniform sampler2D image;
+
+in vec2 out_uv;
+
+vec3 hsl2rgb(vec3 c) {
+    vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0);
+    return c.z + c.y * (rgb-0.5)*(1.0-abs(2.0*c.z-1.0));
+}
+
+void main() {
+    vec4 tc = texture(image, out_uv);
+    float d = tc.r;
+    float aaf = fwidth(d);
+    float alpha = smoothstep(0.5 - aaf, 0.5 + aaf, d);
+
+    vec2 frag_uv = gl_FragCoord.xy / resolution;
+
+    // Dynamic color-shifting aura
+    vec3 auraColor = hsl2rgb(vec3(mod(time * 0.2 + frag_uv.y, 1.0), 0.5, 0.5));
+
+    // Shimmering gradient across the text
+    float shimmer = (sin(time * 3.0 + frag_uv.x * 10.0) + 1.0) * 0.5;
+    vec3 shimmerColor = mix(vec3(1.0, 0.8, 0.6), vec3(0.6, 0.8, 1.0), shimmer);
+
+    vec3 finalColor = mix(auraColor, shimmerColor, d);
+    gl_FragColor = vec4(finalColor, alpha);
+}

config/ded/shaders/simple_text.frag

@@ -0,0 +1,92 @@
+#version 330 core
+
+uniform sampler2D image;
+
+in vec4 out_color;
+in vec2 out_uv;
+
+void main() {
+    float d = texture(image, out_uv).r;
+    float aaf = fwidth(d);
+    float alpha = smoothstep(0.5 - aaf, 0.5 + aaf, d);
+    gl_FragColor = vec4(out_color.rgb, alpha);
+}
+
+
+
+// Dumb shadow
+/* look good only with radon font */
+/* #version 330 core */
+
+/* uniform sampler2D image; */
+
+/* in vec4 out_color; */
+/* in vec2 out_uv; */
+
+/* void main() { */
+/*     // Shadow properties */
+/*     vec2 shadowOffset = vec2(0.001, -0.001); // Very close offset for the shadow */
+/*     vec4 shadowColor = vec4(0.0, 0.0, 0.0, 0.7); // Black shadow with decent opacity */
+
+/*     // Calculate distance for shadow and text */
+/*     float d = texture(image, out_uv).r; */
+
+/*     float aaf = fwidth(d); */
+/*     float alpha = smoothstep(0.5 - aaf, 0.5 + aaf, d); */
+
+/*     // Basic blur approximation for shadow */
+/*     float blurRadius = 0.0005; // Adjust this value for more/less blur */
+/*     float shadowAlpha = 0.0; */
+/*     for (float x = -blurRadius; x <= blurRadius; x += 0.001) { */
+/*         for (float y = -blurRadius; y <= blurRadius; y += 0.001) { */
+/*             float dShadow = texture(image, out_uv + shadowOffset + vec2(x, y)).r; */
+/*             shadowAlpha += smoothstep(0.5 - aaf, 0.5 + aaf, dShadow); */
+/*         } */
+/*     } */
+/*     shadowAlpha = shadowAlpha / ((2.0 * blurRadius / 0.001 + 1.0) * (2.0 * blurRadius / 0.001 + 1.0)); */
+/*     shadowAlpha *= shadowColor.a; */
+
+/*     // Mix shadow and text */
+/*     vec4 textColor = vec4(out_color.rgb, alpha); */
+/*     vec4 shadow = vec4(shadowColor.rgb, shadowAlpha); */
+/*     gl_FragColor = mix(shadow, textColor, alpha); */
+/* } */
+
+
+// idk
+/* #version 330 core */
+
+/* uniform sampler2D image; */
+/* uniform float time; // Time variable for animation */
+
+/* in vec4 out_color; // Base text color */
+/* in vec2 out_uv; // Texture coordinates */
+
+/* void main() { */
+/*     float d = texture(image, out_uv).r; // Distance field value */
+/*     float aaf = fwidth(d); // Antialiasing factor */
+
+/*     // Outline settings */
+/*     float outlineSize = 0.09; // Width of the outline */
+/*     float movingSegmentLength = 0.8; // Length of the moving segment */
+/*     float speed = 0.5; // Speed of the segment's movement */
+
+/*     // Calculate position of the moving segment */
+/*     float segmentPosition = mod(time * speed, 1.0); */
+
+/*     // Calculate outline alpha based on SDF */
+/*     float outlineAlpha = smoothstep(0.5 - outlineSize - aaf, 0.5 - outlineSize, d) - */
+/*                          smoothstep(0.5 + outlineSize, 0.5 + outlineSize + aaf, d); */
+
+/*     // Determine if we're within the moving segment */
+/*     float sdfCoord = (atan(out_uv.y - 0.5, out_uv.x - 0.5) / 3.14159265 + 1.0) * 0.5; */
+/*     bool inMovingSegment = abs(sdfCoord - segmentPosition) < movingSegmentLength * 0.5 || */
+/*                            abs(sdfCoord - segmentPosition - 1.0) < movingSegmentLength * 0.5; */
+
+/*     // Mix colors: text, outline, and moving segment */
+/*     vec3 outlineColor = vec3(0, 1, 0); // Green for the moving segment */
+/*     vec4 textColor = vec4(out_color.rgb, smoothstep(0.5 - aaf, 0.5 + aaf, d)); */
+/*     vec4 segmentColor = mix(vec4(outlineColor, outlineAlpha), textColor, float(!inMovingSegment)); */
+
+/*     gl_FragColor = segmentColor; */
+/* } */