fn_registry/cpp/apps/primitives_gallery/demos_gfx.cpp

// Demos del dominio gfx — primitivos OpenGL/shader que viven en
// cpp/functions/gfx/. La pieza distintiva de shaders_lab es el
// shader_canvas: framebuffer + fullscreen quad + programa GL animado por
// time/resolution/mouse.

#include "demos.h"
#include "demo.h"

#include "gfx/shader_canvas.h"
#include "gfx/gl_shader.h"
#include "gfx/gl_loader.h"

#include <imgui.h>
#include <chrono>

namespace gallery {

namespace {

// Fragment shader sintetico — gradiente animado con celdas. Usa los uniforms
// estandar que compile_fragment inyecta: u_resolution, u_time, u_mouse.
const char* kShaderSrc = R"(
void mainImage() {
    vec2 uv = gl_FragCoord.xy / u_resolution;
    vec2 cell = uv * 8.0;
    vec2 ipos = floor(cell);
    vec2 fpos = fract(cell) - 0.5;

    float t = u_time * 0.6;
    float wave = sin(ipos.x * 0.7 + ipos.y * 0.5 + t);
    float dist = length(fpos);

    vec3 a = vec3(0.30, 0.43, 0.96); // indigo
    vec3 b = vec3(0.95, 0.45, 0.85); // pink
    vec3 col = mix(a, b, 0.5 + 0.5 * wave);

    // Mouse focus: oscurecemos celdas lejanas al cursor.
    vec2 m = u_mouse / u_resolution;
    float fm = 1.0 - smoothstep(0.0, 0.6, length(uv - m));
    col *= 0.6 + 0.4 * fm;

    // Disco interior por celda con borde suave.
    col *= smoothstep(0.5, 0.45, dist);

    fragColor = vec4(col, 1.0);
}

void main() {
    mainImage();
}
)";

struct CanvasState {
    fn::gfx::ShaderCanvas canvas;
    bool   compiled        = false;
    bool   compile_failed  = false;
    std::string err_msg;
    std::chrono::steady_clock::time_point t0;
};

CanvasState& state() {
    static CanvasState s;
    return s;
}

} // namespace

void demo_shader_canvas() {
    demo_header("shader_canvas", "v1.0.0",
        "Framebuffer + fullscreen quad + shader GLSL animado. La misma pieza "
        "que usa shaders_lab para el preview en vivo. Uniforms u_time / u_resolution / u_mouse "
        "los inyecta gl_shader::compile_fragment automaticamente.");

    auto& s = state();

    // Compilacion lazy (en el primer frame ya hay contexto GL valido).
    if (!s.compiled && !s.compile_failed) {
        fn::gfx::gl_loader_init();
        fn::gfx::canvas_init(s.canvas);

        auto cr = fn::gfx::compile_fragment(kShaderSrc);
        if (!cr.ok) {
            s.compile_failed = true;
            s.err_msg = cr.err_msg;
        } else {
            fn::gfx::canvas_set_program(s.canvas, cr.program);
            s.t0 = std::chrono::steady_clock::now();
            s.compiled = true;
        }
    }

    if (s.compile_failed) {
        ImGui::TextColored(ImVec4(1, 0.4f, 0.4f, 1),
            "Compilacion del fragment shader fallo:\n%s",
            s.err_msg.c_str());
        return;
    }

    section("Live preview");

    // Render del shader en un panel ~480x300 px. canvas_render hace resize
    // automatico segun GetContentRegionAvail si lo dejas crecer.
    ImGui::BeginChild("##shader_preview", ImVec2(480, 300),
                      ImGuiChildFlags_Borders);
    const float dt = std::chrono::duration<float>(
        std::chrono::steady_clock::now() - s.t0).count();
    fn::gfx::canvas_render(s.canvas, dt);
    ImGui::EndChild();

    code_block(
        "#include \"gfx/shader_canvas.h\"\n"
        "#include \"gfx/gl_shader.h\"\n\n"
        "static fn::gfx::ShaderCanvas canvas;\n"
        "// Setup (una vez):\n"
        "fn::gfx::canvas_init(canvas);\n"
        "auto cr = fn::gfx::compile_fragment(user_glsl);\n"
        "if (cr.ok) fn::gfx::canvas_set_program(canvas, cr.program);\n\n"
        "// Cada frame, dentro de un Begin/End:\n"
        "fn::gfx::canvas_render(canvas, time_seconds);"
    );
}

// Issue 0049b — Mostrar la version de OpenGL del contexto y un puñado de
// limites 4.3 que confirman que compute shaders / SSBO / image load-store
// estan disponibles. No es codigo del registry, solo introspeccion del
// driver — sin estado, sin side effects: solo glGetString + glGetIntegerv.

#ifndef GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS
#define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS 0x90DD
#endif
#ifndef GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS
#define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS 0x90DC
#endif
#ifndef GL_MAX_COMPUTE_SHARED_MEMORY_SIZE
#define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE 0x8262
#endif

void demo_gl_info() {
    demo_header("gl_info", "v1.0.0",
        "Introspeccion del contexto OpenGL activo (issue 0049b). El framework "
        "ahora pide GL 4.3 core, lo que habilita compute shaders, SSBOs, image "
        "load/store y atomic counters — bloques esenciales del graph_renderer "
        "GPU del proyecto osint_graph.");

    auto gl_str = [](GLenum e) -> const char* {
        const GLubyte* s = glGetString(e);
        return s ? reinterpret_cast<const char*>(s) : "(null)";
    };

    section("Driver");
    ImGui::Text("Vendor:    %s", gl_str(GL_VENDOR));
    ImGui::Text("Renderer:  %s", gl_str(GL_RENDERER));
    ImGui::Text("Version:   %s", gl_str(GL_VERSION));
    ImGui::Text("GLSL:      %s", gl_str(GL_SHADING_LANGUAGE_VERSION));

    GLint major = 0, minor = 0;
    glGetIntegerv(GL_MAJOR_VERSION, &major);
    glGetIntegerv(GL_MINOR_VERSION, &minor);

    const bool has_43 = (major > 4) || (major == 4 && minor >= 3);
    section("Capabilities");
    ImGui::Text("Context: %d.%d core", major, minor);
    if (has_43) {
        ImGui::TextColored(ImVec4(0.40f, 0.85f, 0.40f, 1.0f),
            "OpenGL 4.3+ — compute shaders, SSBOs, image load/store, atomic counters: AVAILABLE");
    } else {
        ImGui::TextColored(ImVec4(0.95f, 0.55f, 0.30f, 1.0f),
            "OpenGL < 4.3 — compute shaders / SSBOs NOT available on this driver");
    }

    section("Limits");
    GLint v = 0;
    auto row = [&](const char* label, GLenum e) {
        v = 0;
        glGetIntegerv(e, &v);
        ImGui::Text("%-44s %d", label, v);
    };
    row("GL_MAX_TEXTURE_SIZE",                    GL_MAX_TEXTURE_SIZE);
    row("GL_MAX_VERTEX_ATTRIBS",                  GL_MAX_VERTEX_ATTRIBS);
    row("GL_MAX_UNIFORM_BLOCK_SIZE",              GL_MAX_UNIFORM_BLOCK_SIZE);
    if (has_43) {
        row("GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS",  GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
        row("GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS",  GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS);
        row("GL_MAX_COMPUTE_SHARED_MEMORY_SIZE",      GL_MAX_COMPUTE_SHARED_MEMORY_SIZE);
    }

    code_block(
        "// Solo glGetString + glGetIntegerv — sin loader extra.\n"
        "GLint major = 0, minor = 0;\n"
        "glGetIntegerv(GL_MAJOR_VERSION, &major);\n"
        "glGetIntegerv(GL_MINOR_VERSION, &minor);\n"
        "bool has_compute = (major > 4) || (major == 4 && minor >= 3);"
    );
}

} // namespace gallery