Candle - light · ShaderBox

#ifdef GL_ES
precision mediump float;
#endif

#define PI 3.1415926538

uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;

float scale(float v, vec2 scale_in, vec2 scale_out) {
    return scale_out.x + (scale_out.y - scale_out.x) * ((v - scale_in.x) / (scale_in.y - scale_in.x));
}

float noise(vec2 p) {
    return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
}

float fbm(vec2 p) {
    float value = 0.0;
    float amplitude = 0.5;
    for(int i = 0; i < 4; i++) {
        value += amplitude * noise(p);
        p *= 2.0;
        amplitude *= 0.5;
    }
    return value;
}

float candleBody(vec2 uv) {
    float candle = step(abs(uv.x), 0.08);
    candle *= step(uv.y, 0.3);
    candle *= step(-0.6, uv.y);
    return candle;
}

float flame(vec2 uv) {
    vec2 flameUV = uv - vec2(0.0, 0.4);
    
   
    float flicker = sin(u_time * 8.0) * 0.02 + sin(u_time * 15.0) * 0.01;
    flameUV.x += flicker;
    flameUV.y += abs(flicker) * 0.5;
    
    float noiseValue = fbm(flameUV * 8.0 + vec2(0.0, u_time * 2.0));
    flameUV += (noiseValue - 0.5) * 0.1;
    
    float dist = length(flameUV);
    float angle = atan(flameUV.x, flameUV.y);
    
    float flameRadius = 0.12 * (1.0 - smoothstep(0.0, 0.3, flameUV.y));
    flameRadius *= (1.0 + 0.3 * sin(angle * 2.0));
    
    return 1.0 - smoothstep(flameRadius - 0.02, flameRadius, dist);
}

bool hitCandle(vec2 pos) {
    return abs(pos.x) < 0.08 && pos.y > -0.6 && pos.y < 0.3;
}

float castRay(vec2 origin, vec2 direction, vec2 currentPos) {
    vec2 flamePos = vec2(0.0, 0.4);
    
    // Ray from flame through current position
    vec2 rayDir = normalize(currentPos - flamePos);
    float rayLength = distance(currentPos, flamePos);
    
    // Check if this ray direction matches one of our light rays or if it's cooked
    float rayAngle = atan(rayDir.y, rayDir.x);
    
    float numRays = 24.0;
    float rayIndex = floor((rayAngle + PI) / (2.0 * PI) * numRays);
    float rayAngleDiscrete = (rayIndex / numRays) * 2.0 * PI - PI;

//Not my best practice, but I had trouble getting the rotation to work with shader only inputs
    float timeOffset = u_time * 2.0;
    float sinModulation = sin(rayAngleDiscrete * 3.0 + timeOffset) * 0.3;
    rayAngleDiscrete += sinModulation;
    
    vec2 discreteRayDir = vec2(cos(rayAngleDiscrete), sin(rayAngleDiscrete));
    
    float rayAlignment = dot(rayDir, discreteRayDir);
    if (rayAlignment < 0.95) return 0.0; 
    
    float stepSize = 0.02;
    vec2 rayPos = flamePos;
    bool bounced = false;
    vec2 currentRayDir = discreteRayDir;
    float totalDistance = 0.0;
    
    for(int step = 0; step < 100; step++) {
        rayPos += currentRayDir * stepSize;
        totalDistance += stepSize;
        
        if (hitCandle(rayPos) && !bounced) {
            currentRayDir.x *= -1.0;
            bounced = true;
        }
        
        if (distance(rayPos, currentPos) < stepSize * 2.0) {
            // Calculate brightness based on distance and bounces
            float brightness = 1.0 / (1.0 + totalDistance * totalDistance * 0.5);
            brightness *= bounced ? 0.7 : 1.0; // Dimmer after bounce
            return brightness;
        }
        
        if (totalDistance > 2.0) break;
    }
    
    return 0.0;
}

void main() {
    vec2 uv = (gl_FragCoord.xy - u_resolution.xy * 0.5) / u_resolution.y;
    
    vec3 color = vec3(0.05, 0.02, 0.02);
    
    vec2 flamePos = vec2(0.0, 0.4);
    float rayBrightness = castRay(flamePos, normalize(uv - flamePos), uv);
    
    vec3 rayColor = vec3(1.0, 0.7, 0.3) * rayBrightness * 0.8;
    color += rayColor;
    
    float candleMask = candleBody(uv);
    vec3 candleColor = vec3(0.9, 0.8, 0.6);
    
    candleColor *= (0.3 + rayBrightness * 2.0);
    color = mix(color, candleColor, candleMask);
    
    float flameMask = flame(uv);
    vec3 flameColor = vec3(1.0, 0.5, 0.1);
    
    vec2 flameUV = uv - vec2(0.0, 0.4);
    float innerFlame = 1.0 - smoothstep(0.03, 0.08, length(flameUV));
    flameColor = mix(flameColor, vec3(1.0, 0.9, 0.7), innerFlame);
    
    color = mix(color, flameColor, flameMask);
    
    float glow = 1.0 - smoothstep(0.0, 0.3, length(uv - vec2(0.0, 0.4)));
    glow *= 0.2;
    color += vec3(1.0, 0.6, 0.2) * glow;
    
    gl_FragColor = vec4(color, 1.0);
}