#version 300 es
precision highp float;

uniform float iTime;
uniform vec2  iResolution;
uniform float u_density; // value=150, min=0, max=100, step=0.1
uniform float u_speed; // value=0.2, min=0, max=10, step=0.01
uniform float u_size; // value=3, min=0, max=10, step=0.1
uniform float u_wind; // value=2, min=0, max=10, step=0.1

out vec4 fragColor;

float onedx(float x) {

	if (x == 0.) {

		return 1.;
        } else {

		return 1./x;
	}
}

float onedx2(float x) {

	return  onedx(x)*onedx(x);
}

float getBetaW(float x, float f, float size) {

	return size*x*3.1415926/f;
}

float getBetaH(float y, float f, float size) {

	return size*y*3.1415926/f;
}

float getI(vec2 uv, float f, vec2 SIZE) {

	return onedx2(getBetaW(uv.x, f, SIZE.x))*onedx2(getBetaH(uv.y, f, SIZE.y));
}

float random(vec2 st) {
    return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}

float noise(vec2 st) {
    vec2 i = floor(st);
    vec2 f = fract(st);

    float a = random(i);
    float b = random(i + vec2(1.0, 0.0));
    float c = random(i + vec2(0.0, 1.0));
    float d = random(i + vec2(1.0, 1.0));

    vec2 u = f * f * (3.0 - 2.0 * f);

    return mix(a, b, u.x) +
           (c - a) * u.y * (1.0 - u.x) +
           (d - b) * u.x * u.y;
}

float fbm(vec2 st) {
    float value = 0.0;
    float amplitude = 0.5;
    float frequency = 2.0;

    for(int i = 0; i < 5; i++) {
        value += amplitude * noise(st * frequency);
        frequency *= 2.0;
        amplitude *= 0.5;
    }
    return value;
}

vec2 getSnowflakeWorldCenter(vec2 gridId, float timeOffset, vec2 snowOffset, float layerScale) {

    vec2 gridWorldPos = (gridId + snowOffset) / layerScale;

    gridWorldPos.x += (timeOffset / layerScale);

    return gridWorldPos;
}

vec2 rotate(vec2 uv, float addtheta) {
    
    float theta = atan(uv.y/uv.x) + addtheta;
    float r = sqrt(uv.x*uv.x + uv.y*uv.y);
    vec2 ruv;
	ruv.x = r*cos(theta);
    ruv.y = r*sin(theta);
        
    return ruv;
}

void main() {

    vec3 color = vec3(0.02, 0.04, 0.12);

    vec2 st = gl_FragCoord.xy / iResolution;
    st.x = st.x/iResolution.y*iResolution.x;
    
    vec2 cuv = (st - 0.5)*2.;

    for(int layer = 0; layer < 3; layer++) {

        float layerScale = float(layer + 1) * u_density * 0.02;
        float layerSpeed = u_speed * (1.0 + float(layer) * 0.3);
        float layerSize = u_size * (1.0 - float(layer) * 0.2);

        vec2 layerSt = st * layerScale;
        vec2 cuvSt = cuv;

        float timeOffset = iTime * layerSpeed * 1.;
        layerSt.x -= timeOffset;

        vec2 gridSt = fract(layerSt);
        vec2 gridId = floor(layerSt);

        float randSeed = random(gridId);

        vec2 snowPos = vec2(
            0.5 + 0.3 * sin(randSeed * 6.28 + iTime * 0.3),
            0.5 + 0.2 * cos(randSeed * 12.56)
        );

        float dist = distance(gridSt, snowPos);

        float snowSize = layerSize * 0.01 * (0.5 + 0.5 * randSeed);
        float brightness = 1.0 - float(layer) * 0.3;
        
        float M = exp(-dist * dist / (snowSize * snowSize));

        float rotateAngle  = 0.01 * (iTime * cos(randSeed * 120.0 + iTime * 0.2)); 

        vec2 fst = rotate(cuvSt - (getSnowflakeWorldCenter(gridId, timeOffset, snowPos, layerScale) - 0.5)*2., rotateAngle);

        float snowflake = getI(fst, 0.8 - dist*42., vec2(1./snowSize))*M*0.5 + M*0.5;

        float twinkle = 0.6 + 0.4 * (sin(randSeed * 100.0 + iTime * 4.0) * cos(randSeed * 120.0 + iTime * 6.0));
        snowflake *= twinkle;

        vec3 colortype = vec3(random(gridId-3.),random(gridId+7.),random(gridId+5.));

        color += (snowflake * brightness) * colortype;
    }

    fragColor = vec4(color, 1.0);
}