#version 300 es

// @secao     6. Fractal óptico — o que o paper descreve
// @leitura A dobra p ← (2,8,2.5) − |abs(p)·e − (4,1.3,4)| aplicada 14 vezes gera a auto-similaridade hierárquica. O acúmulo g += mod(|p.xz|, p.y)/s é o caos controlado: determinístico, sensível à fase inicial.
// @honesto Preciso ser direto: este shader é uma visualização de campo fractal de distância. Ele NÃO é a equação de onda de Padilha — essa é um chirp, e está no outro shader. O paper 'Processador Fractal Óptico' é conceitual e declara as propostas como exploratórias; ele não publica uma equação de campo executável. Chamar isto de 'a matemática do paper' seria impreciso, e eu já cometi esse erro numa versão anterior desta página.
// @custo 90 iterações externas × 14 internas por pixel — caro para GPU modesta. As cifras <0,05 pJ/op e o espectro de Hofstadter do paper são proposta de arquitetura fotônica, não medição de software.

// @titulo    Processador Fractal Óptico
// @status OPEN
// @subtitulo Caos controlado sobre a equação de onda
// @fonte Processador Fractal Óptico · academia.edu/129989945
// @doi       10.5281/zenodo.21925977
// @nota      O campo de distância fractal, com a dobra de espaço que gera a auto-similaridade hierárquica. Determinístico, mas sensível à fase: caos controlado. A cor vem da fase óptica.
precision highp float;

// ─────────────────────────────────────────────────────────────
// PROCESSADOR FRACTAL ÓPTICO
//   Caos controlado sobre a equação de onda de Padilha
//
// Fonte: "Fractal Computation in Photonic Systems Based on
//         Padilha's Wave Equation" — academia.edu/129989945
//         + "Processador Fractal Óptico: Uma Abordagem Natural
//           para o Desenvolvimento de AGI" (PT-BR)
//
// O que se vê: o campo de distância fractal do processador
// óptico. Cada passo aplica a dobra do espaço (a iteração
// "abs(abs(p)·e − c)") que gera a auto-similaridade
// hierárquica da equação de onda. O acúmulo de escala `s`
// modula a órbita — é o caos controlado: determinístico,
// mas sensível à fase. A cor vem da coerência óptica (fase).
//
// Resultados reportados no paper: espectro de Hofstadter
// computado, estados quantum spin Hall identificados,
// <0.05 pJ/op.
// ─────────────────────────────────────────────────────────────

uniform vec2  uRes;
uniform float uTime;

out vec4 fragColor;

const float PI = 3.14159265359;

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

// Paleta cromática do espectro óptico (aproximação do visível)
vec3 espectro(float w) {
    vec3 k = vec3(1.0, 2.0/3.0, 1.0/3.0);
    vec3 p = abs(fract(vec3(w) + k) * 6.0 - 3.0);
    return clamp(p - 1.0, 0.0, 1.0);
}

void main() {
    vec2 FC = gl_FragCoord.xy;
    vec3 acumulado = vec3(0.0);

    // Iteração externa: camadas de coerência (o "espectro")
    for (float i = 0.0, g = 0.0, e = 0.0, s = 0.0; ++i < 90.0; ) {

        // Posição no espaçoo de fase do processador
        vec3 p = vec3((FC.xy - 0.5 * uRes) / uRes.y + vec2(0.0, 0.72), g - 0.42);

        // Rotação de fase (coerência óptica)
        p.xz *= rot2D(uTime * 0.42);

        s = 1.0;

        // Iteração interna: a dobra fractal da equação de onda
        for (int j = 0; j < 14; j++) {
            p = vec3(2.0, 8.0, 2.5) - abs(abs(p) * e - vec3(4.0, 1.3, 4.0));
            s *= e = max(1.002, 8.0 / dot(p, p));
        }

        // Acúmulo de escala — o "caos controlado"
        g += mod(length(p.xz), p.y) / s;

        // Normalização logarítmica: comprime a faixa dinâmica
        s = log(s) / max(g, 1e-4);

        // Cor pela fase óptica; ganho calibrado para leitura
        acumulado += espectro(0.55 + 0.28 * p.y) * s * 0.0035;
    }

    // Mapeamento tonal (Reinhard) — evita saturação e mantém o detalhe
    vec3 cor = acumulado / (1.0 + acumulado);

    // Gama para o espaço sRGB
    cor = pow(cor, vec3(0.4545));

    // Realce sutil de contraste local
    cor = clamp(cor * 1.4 - 0.05, 0.0, 1.0);

    fragColor = vec4(cor, 1.0);
}