Real 3D,
Inside the Graph.

#include <metal_stdlib>
using namespace metal;

struct VertexOut {
    float4 position [[position]];
    float2 uv;           // 0..1 across the render target
};

struct GeneratorUniforms {
    float  time;         // seconds since start (affected by Speed)
    float  beatPhase;    // 0..1 sweep every beat, resets to 0
    float  beatStrength; // 0..1 envelope, peaks on each beat
    float  energy;       // 0..1 overall loudness (rms)
    float2 resolution;   // render target size in pixels
    float  speed;        // Speed pin (0..2+)
    float  reactivity;   // Reactivity pin (0..1)
    float  complexity;   // Complexity pin (0..1)
    int    colorPalette; // 0..32, the selected palette index
    float  jogValue;     // jog wheel / scrub value
    float  pad1;
};

// VKO1 custom shader — audio-reactive raymarched sphere.
// Function name MUST match what you register in the inspector.

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

// Simple cosine-palette ramp. Swap constants for your own look.
static float3 palette(float t) {
    return float3(0.5) + float3(0.5) *
           cos(6.2831 * (float3(1.0, 0.8, 0.5) * t +
                        float3(0.10, 0.25, 0.50)));
}

fragment float4 sphere_pulse(VertexOut in [[stage_in]],
                               constant GeneratorUniforms &u [[buffer(0)]]) {

    // 1. Screen-space setup — aspect-correct, centred at origin.
    float2 uv = in.uv * 2.0 - 1.0;
    uv.x *= u.resolution.x / u.resolution.y;

    // 2. Ray origin and direction. A pinhole camera looking at -Z.
    float3 ro = float3(0.0, 0.0, 3.0);
    float3 rd = normalize(float3(uv, -1.5));

    // 3. Orbit the camera with time — this is your "3D motion" layer.
    float    a = u.time * 0.4;
    float2x2 rot = float2x2(cos(a), -sin(a), sin(a), cos(a));
    ro.xz = rot * ro.xz;
    rd.xz = rot * rd.xz;

    // 4. Audio-reactive radius. Kick drum grows the sphere.
    //    Always gate audio terms on u.reactivity so the user can dial it out.
    float pulse = u.beatStrength * u.reactivity;
    float radius = 0.9 + pulse * 0.35 + u.energy * 0.1 * u.reactivity;

    // 5. Raymarch. Complexity picks step count — users trade detail for FPS.
    int   steps = 32 + (int)(u.complexity * 48.0);
    float t     = 0.0;
    float d     = 0.0;
    bool  hit   = false;
    for (int i = 0; i < steps; ++i) {
        float3 p = ro + rd * t;
        d = sdSphere(p, radius);
        if (d < 0.001) { hit = true; break; }
        if (t > 10.0) break;
        t += d;
    }

    // 6. Background — beat-phase driven vignette so the empty space still breathes.
    float3 bg = palette(u.beatPhase * 0.2) * (0.05 + u.energy * 0.15);
    if (!hit) return float4(bg, 1.0);

    // 7. Analytic normal on a sphere is just the hit point direction.
    float3 hitPos = ro + rd * t;
    float3 n      = normalize(hitPos);

    // 8. Lambert + fresnel rim. Cheap but reads as real lighting.
    float3 L       = normalize(float3(0.6, 0.8, 0.4));
    float  diffuse = max(0.0, dot(n, L));
    float  fres    = pow(1.0 - max(0.0, dot(n, -rd)), 3.0);

    // 9. Palette-driven colour. Beat phase walks along the ramp.
    float3 base = palette(u.beatPhase + n.y * 0.3);
    float3 col  = base * (0.25 + diffuse * 0.9) + fres * base * 0.8;

    // 10. Beat-flash highlight — punches on transients, decays fast.
    col += palette(0.0) * pulse * 0.5;

    return float4(col, 1.0);
}

#include <metal_stdlib>
using namespace metal;

struct Scene3DUniforms {
    float4x4 modelMatrix;       // node rotations + auto-spin
    float4x4 viewMatrix;        // viewport camera (shared across 3D nodes)
    float4x4 projectionMatrix;  // perspective, aspect-correct
    float3   cameraPosition;    // world-space camera, for fresnel / specular
    float    time;              // seconds, post-Speed pin
    float    beatPhase;         // 0..1 ramp per beat
    float    beatStrength;      // transient envelope
    float    energy;            // smoothed rms
    float    speed;
    float    reactivity;        // master audio gate (0..1)
    float    complexity;
    int      colorPalette;      // 0..32
};

struct Vertex3DIn {
    float3 position [[attribute(0)]];   // mesh-local
    float3 normal   [[attribute(1)]];
    float2 uv       [[attribute(2)]];
};

struct Vertex3DOut {
    float4 position [[position]];
    float3 worldPos;
    float3 worldNormal;
    float2 uv;
    float  displacement;
};

// Cosine-gradient palette, same 32 entries as every other VKO1 generator.
static inline float3 get_palette_color_3d(float t, int paletteIndex);

vertex Vertex3DOut my_3d_vertex(Vertex3DIn v [[stage_in]],
                                constant Scene3DUniforms &u [[buffer(1)]]) {
    Vertex3DOut o;

    // 1. Beat-driven displacement along the normal. Always gated by reactivity.
    float kick = u.beatStrength * u.reactivity * 0.25;
    float wave = sin(v.position.y * 4.0 + u.time * 3.0) * 0.05;
    float3 displaced = v.position + v.normal * (kick + wave);

    // 2. Transform to world space for lighting, then to clip space for rasterisation.
    float4 worldPos = u.modelMatrix * float4(displaced, 1.0);
    o.worldPos     = worldPos.xyz;
    o.worldNormal  = normalize((u.modelMatrix * float4(v.normal, 0.0)).xyz);
    o.uv           = v.uv;
    o.displacement = kick + wave;
    o.position     = u.projectionMatrix * u.viewMatrix * worldPos;
    return o;
}

fragment float4 my_3d_fragment(Vertex3DOut in [[stage_in]],
                                constant Scene3DUniforms &u [[buffer(0)]]) {
    float3 N = normalize(in.worldNormal);
    float3 L = normalize(float3(0.6, 0.8, 0.4));
    float  lambert = max(dot(N, L), 0.0);

    // Fresnel rim — world-space camera makes this genuinely view-dependent.
    float3 V = normalize(u.cameraPosition - in.worldPos);
    float  rim = pow(1.0 - max(dot(N, V), 0.0), 3.0);

    // Walk the palette with uv + beat phase + displacement for animated colour.
    float  t    = in.uv.x + u.beatPhase * 0.5 + in.displacement * 2.0;
    float3 base = get_palette_color_3d(t, u.colorPalette);

    float3 color = base * (0.35 + lambert * 0.75) + rim * 0.6;
    color += u.beatStrength * u.reactivity * base * 0.4;

    return float4(color, 1.0);
}