lava_visual.py

import moderngl
import moderngl_window
from moderngl_window import geometry
import math


class LavaShader(moderngl_window.WindowConfig):
    """🔥 RTX Lava Shader — seamless & 3D-like version"""
    title = "🔥 Seamless 3D Lava Shader"
    gl_version = (3, 3)
    window_size = (1280, 720)
    aspect_ratio = None
    resizable = True
    resource_dir = '.'

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.quad = geometry.quad_fs()

        self.prog = self.ctx.program(
            vertex_shader="""
                #version 330
                in vec2 in_position;
                out vec2 v_uv;
                void main() {
                    v_uv = in_position * 0.5 + 0.5;
                    gl_Position = vec4(in_position, 0.0, 1.0);
                }
            """,
            fragment_shader="""
                #version 330

                uniform vec2 u_res;
                uniform float u_time;
                uniform vec2 u_mouse;

                in vec2 v_uv;
                out vec4 fragColor;

                // --- Smooth Noise ---
                float hash(vec2 p) {
                    p = fract(p * vec2(123.34, 456.21));
                    p += dot(p, p + 78.233);
                    return fract(p.x * p.y);
                }

                float noise(vec2 p) {
                    vec2 i = floor(p);
                    vec2 f = fract(p);
                    vec2 u = f * f * (3.0 - 2.0 * f);
                    float a = hash(i + vec2(0.0,0.0));
                    float b = hash(i + vec2(1.0,0.0));
                    float c = hash(i + vec2(0.0,1.0));
                    float d = hash(i + vec2(1.0,1.0));
                    return mix(mix(a,b,u.x), mix(c,d,u.x), u.y);
                }

                float fbm(vec2 p) {
                    float v = 0.0;
                    float a = 0.5;
                    for(int i = 0; i < 6; i++) {
                        v += a * noise(p);
                        p *= 2.0;
                        a *= 0.5;
                    }
                    return v;
                }

                vec3 palette(float t) {
                    vec3 black = vec3(0.02, 0.01, 0.005);
                    vec3 red = vec3(0.6, 0.04, 0.0);
                    vec3 orange = vec3(1.0, 0.45, 0.1);
                    vec3 yellow = vec3(1.0, 0.85, 0.35);
                    if(t < 0.35) return mix(black, red, smoothstep(0.0,0.35,t));
                    else if(t < 0.7) return mix(red, orange, smoothstep(0.35,0.7,t));
                    else return mix(orange, yellow, smoothstep(0.7,1.0,t));
                }

                void main() {
                    vec2 uv = v_uv * 2.0 - 1.0;
                    uv.x *= u_res.x / u_res.y;
                    float t = u_time * 0.35;

                    // Use sine warp to make motion seamless
                    vec2 motion = vec2(
                        fbm(uv * 2.0 + vec2(t*0.3, t*0.15)),
                        fbm(uv * 2.0 + vec2(-t*0.25, t*0.4))
                    );

                    // Scroll pattern
                    vec2 p = uv * 2.5 + motion * 1.2;
                    float n = fbm(p + vec2(t*0.7, -t*0.3));

                    // Add layered detail
                    n += 0.25 * fbm(p * 3.0 + vec2(-t*0.2, t*0.3));

                    // Mouse interaction
                    vec2 m = u_mouse / u_res * 2.0 - 1.0;
                    m.x *= u_res.x / u_res.y;
                    n += 0.15 * exp(-8.0 * distance(uv, m));

                    // Fake 3D shading (based on gradient)
                    vec3 base = palette(n);
                    float depth = smoothstep(0.2, 0.8, n);
                    vec3 normal = normalize(vec3(dFdx(n), dFdy(n), 0.4));
                    vec3 lightDir = normalize(vec3(0.4, 0.6, 0.9));
                    float diff = max(dot(normal, lightDir), 0.0);
                    vec3 col = base * (0.3 + 0.7 * diff);

                    fragColor = vec4(pow(col, vec3(1.2)), 1.0);
                }
            """,
        )

        self.time = 0.0
        self.mouse = (0.5, 0.5)

    def on_render(self, time: float, frame_time: float):
        self.time += frame_time
        self.ctx.clear(0.0, 0.0, 0.0)
        self.prog['u_res'].value = self.window_size
        self.prog['u_time'].value = self.time
        self.prog['u_mouse'].value = self.mouse
        self.quad.render(self.prog)

    def on_mouse_motion(self, x, y, dx, dy):
        self.mouse = (x, self.window_size[1] - y)


if __name__ == "__main__":
    moderngl_window.run_window_config(LavaShader)