
// @param shapeAmount float 0.0 0.0 1.0 "Shape" endpoints triangle stadium
// @param triangleCount float 15.0 3.0 30.0 "Iterations" step 0.01
// @param expansionSpeed float 0.4 0.0 2.0 "Expansion Speed"
// @param relativeThickness float 21.0 2.0 95.0 "Relative Thickness"
// @param globalUndulation float 85.0 0.0 300.0 "Global Undulation"
// @param alongContourWave float 70.0 0.0 300.0 "Along-Contour Wave"
// @param outwardRipple float 60.0 0.0 300.0 "Outward Ripple"
// @param localTurbulence float 40.0 0.0 300.0 "Local Turbulence"
// @param axisAngle float 0.0 0.0 180.0 "Axis Angle"

#define PI 3.14159265359

float hash11(float value) {
    return fract(sin(value * 127.1) * 43758.5453123);
}

float smoothNoise(float position, float seed) {
    float cell = floor(position);
    float local = fract(position);
    local = local * local * (3.0 - 2.0 * local);
    float a = hash11(cell + seed * 19.19);
    float b = hash11(cell + 1.0 + seed * 19.19);
    return mix(a, b, local);
}

float turbulenceProfile(float along, float time, float seed) {
    float broad = smoothNoise(along * 5.0 - time * 0.20, seed) * 2.0 - 1.0;
    float detail = smoothNoise(along * 9.0 + time * 0.15, seed + 13.7) * 2.0 - 1.0;
    return broad * 0.65 + detail * 0.35;
}

float diamondExtent(vec2 point, float slope) {
    return (abs(point.y) + slope * abs(point.x)) / slope;
}

float stadiumExtent(vec2 point) {
    vec2 p = abs(point);
    if (p.x <= p.y) {
        return 2.0 * p.y;
    }
    return dot(p, p) / max(p.x, 0.0001);
}

float stadiumAlong(vec2 point, float size) {
    float halfSize = size * 0.5;
    float capShare = PI / (PI + 2.0);
    if (point.x >= halfSize) {
        float capAngle = atan(abs(point.y), max(point.x - halfSize, 0.0001));
        return clamp(capAngle * 2.0 / (PI + 2.0), 0.0, capShare);
    }
    float flatProgress = (halfSize - point.x) / max(halfSize, 0.0001);
    return clamp(capShare + flatProgress * (1.0 - capShare), capShare, 1.0);
}

void mainImage(out vec4 fragColor, in vec2 fragCoord) {
    float longestSide = max(iResolution.x, iResolution.y);
    vec2 uv = (fragCoord * 2.0 - iResolution.xy) / longestSide;

    float angle = radians(u_axisAngle);
    float cosine = cos(angle);
    float sine = sin(angle);
    mat2 rotation = mat2(cosine, -sine, sine, cosine);
    vec2 reflected = rotation * uv;
    reflected.x = abs(reflected.x);

    float count = clamp(u_triangleCount, 3.0, 30.0);
    float travel = iTime * u_expansionSpeed * 0.18;
    float phase = fract(travel);
    float shape = clamp(u_shapeAmount, 0.0, 1.0);
    float edgeSlope = 0.68;
    float contourScale = sqrt(1.0 + edgeSlope * edgeSlope);
    float triangleNormalScale = edgeSlope / contourScale;
    float normalScale = mix(triangleNormalScale, 0.5, shape);

    // Evaluate both unique rotated rectangle corners against both endpoint
    // shapes. A small mid-morph margin keeps interpolation conservative.
    vec2 halfExtent = iResolution.xy / longestSide;
    vec2 cornerA = rotation * halfExtent;
    vec2 cornerB = rotation * vec2(halfExtent.x, -halfExtent.y);
    float cornerExtentA = mix(diamondExtent(cornerA, edgeSlope), stadiumExtent(cornerA), shape);
    float cornerExtentB = mix(diamondExtent(cornerB, edgeSlope), stadiumExtent(cornerB), shape);
    float morphMargin = 1.0 + 0.04 * shape * (1.0 - shape);
    float canvasSize = max(cornerExtentA, cornerExtentB) * morphMargin;
    float sizeSpacing = canvasSize / count;
    float normalSpacing = sizeSpacing * normalScale;
    float pixel = 2.0 / longestSide;
    float matureHalfWidth = normalSpacing * (u_relativeThickness / 100.0) * 0.5;
    float contours = 0.0;

    // Strengths add directly before the topology-preserving soft limit.
    // Values above 100 push further into smooth saturation without changing order.
    float globalStrength = max(u_globalUndulation, 0.0) / 100.0;
    float alongStrength = max(u_alongContourWave, 0.0) / 100.0;
    float outwardStrength = max(u_outwardRipple, 0.0) / 100.0;
    float turbulenceStrength = max(u_localTurbulence, 0.0) / 100.0;

    // Two buffer contours live beyond the rectangular viewport. Fractional
    // presence lets the next buffered contour emerge without a topology pop.
    for (int index = 0; index < 32; index++) {
        float contourPresence = smoothstep(
            0.0, 1.0, clamp(count + 2.0 - float(index), 0.0, 1.0)
        );
        if (contourPresence <= 0.0) {
            continue;
        }

        float size = (float(index) + phase) * sizeSpacing;
        float triangleContour = (abs(reflected.y) + edgeSlope * reflected.x - edgeSlope * size) / contourScale;
        float halfSize = size * 0.5;
        float stadiumContour = length(vec2(max(reflected.x - halfSize, 0.0), reflected.y)) - halfSize;
        float signedContour = mix(triangleContour, stadiumContour, shape);

        // Both endpoint paths run from the outward tip to the reflection seam.
        // Using the exact morphed seam radius keeps every motion component zero
        // at the join and preserves the straight reflection axis.
        float axisRadiusNumerator = mix(triangleNormalScale, 0.5, shape);
        float axisRadiusDenominator = mix(1.0 / contourScale, 1.0, shape);
        float axisRadius = size * axisRadiusNumerator / axisRadiusDenominator;
        float triangleAlong = clamp(abs(reflected.y) / max(axisRadius, 0.0001), 0.0, 1.0);
        float along = mix(triangleAlong, stadiumAlong(reflected, size), shape);
        float endpointGuard = sin(along * PI);
        // Triangle corners need only positional anchoring. A stadium reflection
        // needs a zero endpoint slope so mirrored halves share a tangent.
        endpointGuard = mix(endpointGuard, endpointGuard * endpointGuard, shape);
        float outwardProgress = clamp(size / canvasSize, 0.0, 1.0);

        // Neighboring contours share these phases. Only the explicit outward
        // ripple changes phase through the stack. A fixed upper/lower phase
        // offset avoids mechanical symmetry while left/right reflection stays exact.
        float sidePhase = reflected.y >= 0.0 ? 0.0 : PI * 0.34;
        float sideSeed = reflected.y >= 0.0 ? 7.0 : 41.0;
        float globalMotion =
            sin(iTime * 0.32 + along * PI * 0.70 + sidePhase) * 0.68 +
            sin(iTime * 0.20 - along * PI * 0.45 + sidePhase * 0.60 + 1.40) * 0.32;
        float alongMotion = sin(along * 2.0 * PI - iTime * 0.82 + sidePhase);
        float outwardMotion = sin(outwardProgress * 2.0 * PI - iTime * 0.58 + sidePhase * 0.40);
        float localMotion = turbulenceProfile(along, iTime, sideSeed);

        float motionProfile =
            globalMotion * globalStrength +
            alongMotion * alongStrength +
            outwardMotion * outwardStrength +
            localMotion * turbulenceStrength;

        float rawBend = motionProfile * normalSpacing * 0.70 * outwardProgress * endpointGuard;

        // Adjacent base contours are at least normalSpacing apart. Limit each
        // signed bend to 40% of the thickness-aware free gap, so even opposite
        // displacements retain at least 20% of that gap. The algebraic
        // saturation stays smooth instead of introducing a clamp crease.
        float freeGap = max(normalSpacing - 2.0 * matureHalfWidth, 0.0);
        float bendLimit = freeGap * 0.40;
        float bend = bendLimit * rawBend / max(
            length(vec2(rawBend, bendLimit)), 0.000001
        );

        float innerRadius = size * normalScale;
        float birthHalfWidth = min(matureHalfWidth, innerRadius * 0.45);
        float widthCompensation = matureHalfWidth - birthHalfWidth;
        float adjustedLine = abs(signedContour - bend) + widthCompensation;
        float contourInk = 1.0 - smoothstep(
            matureHalfWidth, matureHalfWidth + pixel * 1.25, adjustedLine
        );
        contours = max(contours, contourInk * contourPresence);
    }


    // The reflection axis remains fine, straight, and independent.
    float axisWidth = 0.7 * pixel;
    float axis = 1.0 - smoothstep(axisWidth, axisWidth + pixel, abs(reflected.x));

    float ink = max(contours, axis);
    fragColor = vec4(vec3(ink), 1.0);
}