#version 460
precision mediump float;
out vec4 o;
const float PI = 3.14159265;
const float TAU = (2. * PI);
const float PHI = sqrt(5.) * 0.5 + 0.5;
layout(location = 0) uniform float syncs[11];
layout(location = 20) uniform float fft_output[512]; // FFT_SIZE / 4
layout(location = 600) uniform vec3 shapes[15]; // shapes - x = horizontal position, y = vertical position, z = length
layout(location = 700) uniform vec3 test; // shapes test
//layout(binding = 1) uniform sampler2D u_hexGridTex; //uniform sampler2D u_fft_texture;

layout(binding = 0) uniform sampler2D u_ShapesTex; // uniform sampler2D shapes texture
// float u_time = syncs[0];

vec3 palette(float t){
  vec3 a=vec3(0.46,0.2,0.94);
  vec3 b=vec3(0.66,0.64,0.77);
  vec3 c=vec3(0.91,0.62,0.97);
  vec3 d=vec3(0.26,0.2,0.84);
  return a+b*cos(6.28318*(c*t+d));
}


vec2 getUV() {
    const vec2 scale = vec2(0.00104166667, 0.00185185185);
    return gl_FragCoord.xy * scale - 1.0;
}

mat2 rot2D(float angle) {
    float s = sin(angle);
    float c = cos(angle);
    return mat2(c, -s, s, c);
}

float noise(in vec2 xy, in float seed) {
    return fract(tan(distance(xy * PHI, xy) * seed) * xy.x);
}

/////////////////
//   GEOMETRY  //
/////////////////

float fHexagonCircumcircle(vec3 p, vec2 h) {
    vec3 q = abs(p);
    return max(q.y - h.y, max(q.x * sqrt(3.) * 0.5 + q.z * 0.5, q.z) - h.x);
}

// Return local coordinates inside hex AND axial ID
struct HexData {
    vec3 local;   // Local position inside hex
    vec2 axial;   // Axial ID (q, r)
};

HexData hexTile(vec3 p, float radius) {
    float q = (sqrt(3.0) / 3.0 * p.x - 1.0 / 3.0 * p.z) / radius;
    float r = (2.0 / 3.0 * p.z) / radius;

    float rq = round(q);
    float rr = round(r);
    float rs = round(-q - r);

    float dq = abs(rq - q);
    float dr = abs(rr - r);
    float ds = abs(rs + q + r);

    if(dq > dr && dq > ds)
        rq = -rr - rs;
    else if(dr > ds)
        rr = -rq - rs;

    float hx = radius * sqrt(3.0) * (rq + rr * 0.5);
    float hz = radius * 1.5 * rr;

    HexData outData;
    outData.local = p - vec3(hx, 0.0, hz);
    outData.axial = vec2(rq, rr); // Hex ID
    return outData;
}

float hexDistance(vec2 axial) {
    float q = axial.x;
    float r = axial.y;
    float s = -q - r;
    return max(abs(q), max(abs(r), abs(s)));
}

float sdSphere(vec3 p, float r) {
    return length(p) - r;
}

float hexPylon(vec3 p, vec2 h) {
    //vec3 p = vec3(p.x, p.z, p2.y);
    vec3 b = vec3(h.x, h.y, h.x);

    // Hexagon.
    p.xz = abs(p.xz);
    p.xz = vec2(p.x * .866025 + p.z * .5, p.z);
    // The ".015" is a subtle rounding factor. Zero gives sharp edges,
    // and larger numbers give a more rounded look.
    return length(max(abs(p) - b + .15, 0.)) - .15;
}

//////////////
//   SCENE  //
//////////////

// instructions -> opU( { float to union with }  , vec2( {put shape here}, {put material here} ) )
vec2 opU(vec2 d1, vec2 d2) {
    return (d1.x < d2.x) ? d1 : d2;
}

// float opU( float d1, float d2 ) { return -max( -d1, -d2 ); }

vec2 mapScene(in vec3 p) {

    float res = p.y;
    float mat = 0.;

    float hexRadius = 0.85;
    vec3 hexpos = vec3(p.x, p.y - 2.5, p.z);
    HexData hex = hexTile(hexpos, 1.5);

    float distFromCenter = hexDistance(hex.axial);
    int fftIndex = int(clamp(distFromCenter + 1.0, 0.0, 511.0));
    float fftVal = fft_output[fftIndex];
    float hexHeight = 1.0 + fftVal * 4.0;

    // Rotate individual hex tiles if needed
    vec3 r = hex.local;
   // r.yz *= rot2D(PI * 0.5);
    r.xz *= rot2D(0.5);

    //float d1 = hexPylon(vec3(r.x, (r.y + hexHeight / 2), r.z), vec2(hexRadius, hexHeight / 2));
    float d1 = hexPylon(vec3(r.x, r.y, r.z), vec2(hexRadius, hexHeight));

    res = (d1 < res) ? d1 : res;

   /* const float gridSize = 16.;

    for(float j = 0.; j < gridSize; j++) {
        for(float i = 0.; i < gridSize; i++) {
            ivec2 texSize = textureSize(u_ShapesTex, 0);
            vec2 texCoord = (vec2(i, j)) / vec2(texSize);
            vec4 shapeData = texture(u_ShapesTex, texCoord); // RGBA: x, y, length, active
            float shapeActive = shapeData.a;

            if(shapeActive < 0.5)
                continue;

            vec3 shapePos = p - vec3(-70.0 + (shapeData.x * 2.), 12. + (shapeData.y * 80.), 0.0);

            float a = sdSphere(shapePos, 0.8);
            res = min(res, a);
            if(res == a) {
                mat = 1.0;
            }
        }
    }*/

    return vec2(res, mat);
}

////////////////
//   RAYCAST  //
////////////////

vec3 castRay(vec3 ro, vec3 rd, inout vec3 pos) {
    float mat = 0.;
    float hit = 0.;
    float t = 0.;
    vec2 res;

    // Raymarching
    for(int i = 0; i < 20; i++) {
        pos = ro + rd * t;
        res = mapScene(pos); // Get distance to objects, x = dist, y = material
        mat = res.y;
        t += res.x; // "march" the ray

       // if(abs(t) < tolerance * (t * 0.0125 + 1.0)) {
        if(abs(res.x) < 0.0001) {
            hit = 1.;
            break;
        }
        if(t > 200)
            break;

    }

    return vec3(t, mat, hit);
}

////////////////
//   SHADING  //
////////////////

float softshadow(in vec3 ro, in vec3 rd, float mint, float maxt, float w) {
    float res = 1.0;
    float t = mint;
    for(int i = 0; i < 6; i++) {
        if(t > maxt)
            break;
        float h = mapScene(ro + t * rd).x;
        res = min(res, h / (w * t));
        t += clamp(h, 0.1, 0.80);
        if(res < -1.0)
            break;
    }
    res = max(res, -1.0);
    return 0.25 * (1.0 + res) * (1.0 + res) * (2.0 - res);
}

vec3 calcNormal(vec3 pos) {
    vec2 e = vec2(.01, 0.);
    vec3 n = vec3(mapScene(pos + e.xyy).x - mapScene(pos - e.xyy).x, mapScene(pos + e.yxy).x - mapScene(pos - e.yxy).x, mapScene(pos + e.yyx).x - mapScene(pos - e.yyx).x);
    return normalize(n);
}

vec3 addPointLight(vec3 lightPos, vec3 lightColor, float intensity, vec3 worldPos, vec3 viewDir, vec3 normal, float roughness) {
    // Light vector from surface to light
    vec3 lightDir = lightPos - worldPos;
    float lightDistance = length(lightDir);
    lightDir = normalize(lightDir);

    // Attenuation (quadratic falloff)
    float attenuation = intensity / (1.0 + 0.09 * lightDistance + 0.032 * lightDistance * lightDistance);

    // Diffuse lighting (Lambert)
    float NdotL = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = lightColor * NdotL * attenuation;

    // Specular lighting (Blinn-Phong)
    vec3 halfDir = normalize(lightDir + (-viewDir));
    float NdotH = max(dot(normal, halfDir), 0.0);
    float shininess = mix(128.0, 8.0, roughness); // Convert roughness to shininess
    vec3 specular = lightColor * pow(NdotH, shininess) * attenuation;

    // Fresnel effect
    vec3 F0 = vec3(0.04); // Base reflectance for dielectrics
    vec3 fresnel = F0 + (1.0 - F0) * pow(clamp(1.0 - max(dot(halfDir, lightDir), 0.0), 0.0, 1.0), 5.0);

    // Soft shadows
    float shadow = softshadow(worldPos + normal * 0.01, lightDir, 0.02, lightDistance, 4.0);

    // Combine diffuse and specular with shadow
    return (diffuse + specular * fresnel) * shadow;
}

float getAmbientOcc(vec3 p, vec3 n) {
    float occ = 0.;
    float weight = 1.;
    for(int i = 0; i < 8; i++) {
        float len = 0.01 + 0.02 * float(i * i);
        float dist = mapScene(p + n * len).x;
        occ += (len - dist) * weight;
        weight *= 0.85;
    }
    return 1.0 - clamp(0.6 * occ, 0., 1.);
}

vec3 applyFog(vec3 col, float t, vec3 rd, vec3 lightDir, float fogAmount) {

    float syncsBass = clamp((syncs[1] + syncs[2] + syncs[3]), 0., 1.);

    float fogAmount2 = 1.0 - exp(-t * fogAmount);
    float sunAmount = max(dot(rd, lightDir), 0.0);
     // highlight color
    vec3 fogColor = mix(vec3(0.2706, 0.2706, 0.2863), vec3(0.2314, 0.2314, 0.2314), // Main color
    pow(sunAmount, syncsBass * 1.0));
    return mix(col, fogColor, fogAmount2);
}

// Point light with no shadow and radius based falloff
vec3 addPointLightNoShadow(vec3 lightPos, vec3 lightColor, float intensity, float radius, vec3 worldPos, vec3 viewDir, vec3 normal, float roughness) {
    // Light vector from surface to light
    vec3 lightDir = lightPos - worldPos;
    float lightDistance = length(lightDir);
    lightDir = normalize(lightDir);

    // Attenuation (radius based falloff)
    float attenuation = clamp(intensity - lightDistance * lightDistance / (radius * radius), 0.0, 1.0);

    // Diffuse lighting (Lambert)
    float NdotL = max(dot(normal, lightDir), 0.0);
    vec3 diffuse = lightColor * NdotL * attenuation;

    // Specular lighting (Blinn-Phong)
    vec3 halfDir = normalize(lightDir + (-viewDir));
    float NdotH = max(dot(normal, halfDir), 0.0);
    float shininess = mix(128.0, 8.0, roughness); // Convert roughness to shininess
    vec3 specular = lightColor * pow(NdotH, shininess) * attenuation;

    // Fresnel effect
    vec3 F0 = vec3(0.04); // Base reflectance for dielectrics
    vec3 fresnel = F0 + (1.0 - F0) * pow(clamp(1.0 - max(dot(halfDir, lightDir), 0.0), 0.0, 1.0), 5.0);

    // Soft shadows
    //float shadow = softshadow(worldPos + normal * 0.01, lightDir, 0.02, lightDistance, 4.0);

    // Combine diffuse and specular with shadow
    return diffuse + specular * fresnel;
}

/*vec3 addPointLight(vec3 lightPos, vec3 lightColor, float intensity, vec3 worldPos, vec3 viewDir, vec3 normal) {
    vec3 lightDir = normalize(lightPos - worldPos);
    float lightDistance = length(lightPos - worldPos);

    // Attenuation
    float attenuation = intensity / (1.0 + 0.1 * lightDistance + 0.01 * lightDistance * lightDistance);

    // Diffuse
    float NdotL = max(dot(normal, lightDir), 0.0);

    // Specular (Blinn-Phong)
    vec3 halfDir = normalize(lightDir - viewDir);
    float NdotH = max(dot(normal, halfDir), 0.0);
    float specular = pow(NdotH, 32.0);

    // Shadow
    float shadow = softshadow(worldPos + normal * 0.01, lightDir, 0.01, lightDistance, 8.0);

    return lightColor * (NdotL + specular * 0.5) * attenuation * shadow;
}
*/

vec3 shading(vec3 p, vec3 n, vec3 dir, float material) {
    float shininess = 0.01;

    vec3 outMaterial = vec3(0.);

    if(material == 0.) {
        outMaterial = vec3(0.4941, 0.4941, 0.4941);
        shininess = 0.6;
    } else if(material == 1.) {
        outMaterial = vec3(0.6196, 0.6118, 0.6118);
        shininess = .7;
    } else if(material == 2.) {
        outMaterial = vec3(0.3255, 0.4784, 0.3255);
        shininess = .2;
    } else if(material == 3.) {
        outMaterial = vec3(0.2471, 0.3059, 0.6314);
        shininess = 1.0;
    } else if(material == 4.) {
        outMaterial = vec3(0.9961, 1.0, 0.9922);
        shininess = .1;
    } else if(material == 5.) {
        outMaterial = vec3(0.9961, 1.0, 0.9922);
        shininess = .3;
    }

    vec3 lights = vec3(0.);
    lights += addPointLight(vec3(0., 20.0, 10.), vec3(0.77, 0.26, 0.73), 15.0, p, dir, n, shininess);
    lights += addPointLight(vec3(-10., 20.0, -10.), vec3(0.18, 0.61, 0.86), 15., p, dir, n, shininess);

    // LIGHTS IN HEX GRID PATTERN
    /*
    float gridsize = 16.0; // or GRID if you want full size
    vec3 p = vec3(0.);
    for(float j = 0.; j < gridsize; j++) {
        for(float i = 0.; i < gridsize; i++) {
            ivec2 texSize = textureSize(u_hexGridTex, 0);
            vec2 texCoord = (vec2(i, j)) / vec2(texSize);

            vec4 hexData = texture(u_hexGridTex, texCoord); // RGBA: x, y, z, dist

            vec3 hexPos = hexData.rgb;
            float hexDist = hexData.a;

            // Optionally use hexDist for ripple effect with FFT
            int index = clamp(int((hexDist / 34.)*512.), 0, 511);
            float hexSize = getScaledFFT(index, 15. ,0.);
            //float a = sdHex(p - hexPos, 1.0 + hexSize, 0.0);

            lights += addPointLightNoShadow(vec3(hexPos.x, (hexPos.y + hexSize) + 2., hexPos.z), palette(hexSize* 1.5), clamp(hexSize * 5., 0., 1.), 3.4 ,v, dir, n, shininess);
        }
    }
    */

    vec3 lightDir = vec3(0., 2., 3);
    //float sun_dif = clamp(dot(n, lightDir), 0., 1.);
    //float shadow = softshadow(v + n * 0.01, lightDir, .01, 30., 18.);
    //lights += vec3(0.6431, 0.7804, 0.8588) * sun_dif * shadow * occ;

    float ind = clamp(dot(n, normalize(lightDir * vec3(.0, 1.0, -2.0))), 0.0, 1.0);
    lights += vec3(0.08, 0.62, 0.75) * ind * 0.8;

    outMaterial *= max(vec3(0.), lights); // output with lights;

    return outMaterial;
}

vec3 postProcess(vec3 col) {
    // Contrast
    float contrast = 0.75;

    col = mix(col, smoothstep(0.0, 1.0, col), contrast);

    // Colour mapping
    // col *= vec3(1.0, 1.0, 1.0);

    // Gamma
    col = pow(col, vec3(0.4545)); // gamma 2.2

    // fade in at the beginning
    //col*=vec3(clamp((u_time-1.8)*0.5,0., 1.));

    // fade out at the end
    // col*=vec3(clamp((120.-u_time)*.35, 0., 1.));

    return col;
}

//////////////////
//   RENDERING  //
//////////////////

vec3 getCameraRayDir(vec2 uv, vec3 camPos, vec3 camTarget, float fov) {
    vec3 f = normalize(camTarget - camPos), r = normalize(cross(vec3(0, 1, 0), f)), u = cross(f, r), c = f * fov, i = c + uv.x * r + uv.y * u, d = normalize(i);
    return d;
}

vec3 render(vec2 uv) {
    vec3 camPos = vec3(-20.0 + sin(syncs[0] * 0.25) * 5, abs(sin(syncs[0] * 0.25) * 10) + 25.0, -20.0);
    vec3 camTarget = vec3(0.0, 0.0, 0.0); // Adjust target as needed
    float fov = 1.0;

    vec3 rayDir = getCameraRayDir(uv, camPos, camTarget, fov);

    vec3 col = vec3(0.); // background color

    vec3 hitPos = vec3(0);
    vec3 t = castRay(camPos, rayDir, hitPos);

    if(t.x > 0.0) {
        vec3 nor = calcNormal(hitPos);
        col = shading(hitPos, nor, rayDir, t.y);
    }

    //glow from the bottom
    vec3 bGlowColor = palette(syncs[0] * .5); // color change
    float bGlowDistance = 0.3;
    vec3 p = camPos + t.x * rayDir;

    vec3 bGlowLevel = bGlowColor * exp(-(p.y + 0.0) / bGlowDistance) * 9900.;
    col += bGlowLevel;
    col = clamp(mix(bGlowLevel, col, t.z), 0.0, 1.0);

    // distance fog + bass thunder
    float fogAmount = 0.01;
    col = col * exp(-t.x * fogAmount) + applyFog(col, t.x, rayDir, vec3(0., -0.5, 1.8), fogAmount) * (1.0 - exp(-t.x * fogAmount));

    return col;
}

void main() {
    vec3 finalColor = render(getUV());
    finalColor = postProcess(finalColor);
    o = vec4(finalColor, 1.);
}

/*
vec3 render2(vec2 uv, float time) {

    vec3 res = vec3(.0);

    float pos = syncs[5];
    if (uv.x >= pos && uv.x <= pos+0.01 ) {
        res += vec3(1.);
    }

    //if (uv.x >= 0.0 && uv.x <= 0.01 ) {
    //    res += vec3(abs(syncs[4]*2));
    //}

    //res += vec3(0.1, 0.2, 0.3) * abs(syncs[2]*1.2);

    return res;
}


void main() {
  	vec2 uv = gl_FragCoord.xy * 2. / vec2(1920,1080);
    vec3 col = render2(uv, u_time);
    o = vec4(col,1.0);
}
*/