// Ported from party-stage's "Classic Wave". The original picked a hue from a
// rolling HSV ramp; here the ramp indexes the palette instead, so the look
// generator can actually recolour it.

export const classicWave = {
    name: 'Classic Wave',
    family: 'flow',
    kind: 'fragment',

    params: {
        rings:     { type: 'float', range: [4, 40],    default: 18,  uniform: 'u_rings', bias: 'density' },
        spokes:    { type: 'int',   range: [0, 12],    default: 5,   uniform: 'u_spokes' },
        speed:     { type: 'float', range: [0.2, 2.5], default: 1.0, uniform: 'u_speed', bias: 'motion', rate: true },
        // colorRoll is capped low on purpose. palRamp() steps through all six
        // palette entries per unit of t, and the palette generator deliberately
        // spreads their luminance — so this multiplies into a whole-frame
        // brightness oscillation at six times its own rate. At the original
        // range of [0, 0.5] this scene measured 7 flashes per second at every
        // output resolution, well past the WCAG 2.3.1 ceiling of 3. Capped here,
        // the worst case is ~0.9 Hz. See engine/flash.js.
        colorRoll: { type: 'float', range: [0, 0.06],  default: 0.02, uniform: 'u_colorRoll', rate: true },
        softness:  { type: 'float', range: [0, 1],     default: 0.4, uniform: 'u_softness' },
        bloomCore: { type: 'float', range: [0, 1.5],   default: 0.5, uniform: 'u_bloomCore', bias: 'energy' },
        palette:   { type: 'palette', count: 5 },
    },

    reactive: {
        bloomCore: { feature: 'beat',    amount: 0.4, response: 'spike' },
        rings:     { feature: 'bandMid', amount: 0.12 },
    },

    shader: `
vec4 scene(vec2 uv, vec2 p) {
    float d = length(p);
    float angle = atan(p.y, p.x);
    float t = u_time * u_speed + u_seed;

    float wave = sin(d * u_rings - t * 2.0);
    float spoke = u_spokes > 0 ? sin(angle * float(u_spokes) + t) * u_beat : 0.0;

    float v = 0.5 + 0.5 * sin(wave + spoke);
    v = mix(v, smoothstep(0.2, 0.8, v), u_softness);

    vec3 col = palRamp(t * u_colorRoll + d * 0.25) * v;

    // Core glow, the part that reads as the "hit".
    col += pal(0) * (1.0 - smoothstep(0.0, 0.7, d)) * u_bloomCore * 0.6;

    // Keep the corners from clipping to flat colour.
    col *= 0.6 + 0.4 * (1.0 - smoothstep(0.8, 1.8, d));

    return vec4(col, 1.0);
}
`,
};

export default classicWave;