@thi.ng/shader-ast-stdlib 0.12.21 → 0.12.23

package/dev/grayscott.js

@@ -1,425 +0,0 @@
-(function() {
-    function createShader(gl, source, type) {
-        const shader = gl.createShader(type);
-        gl.shaderSource(shader, source);
-        gl.compileShader(shader);
-        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            throw new Error(gl.getShaderInfoLog(shader) + source);
-        }
-        return shader;
-    }
-
-    function createProgramFromSource(
-        gl,
-        vertexShaderSource,
-        fragmentShaderSource
-    ) {
-        const program = gl.createProgram();
-        gl.attachShader(
-            program,
-            createShader(gl, vertexShaderSource, gl.VERTEX_SHADER)
-        );
-        gl.attachShader(
-            program,
-            createShader(gl, fragmentShaderSource, gl.FRAGMENT_SHADER)
-        );
-        gl.linkProgram(program);
-        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-            throw new Error(gl.getProgramInfoLog(program));
-        }
-        return program;
-    }
-
-    function createVbo(gl, array, usage) {
-        const vbo = gl.createBuffer();
-        gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
-        gl.bufferData(
-            gl.ARRAY_BUFFER,
-            array,
-            usage !== undefined ? usage : gl.STATIC_DRAW
-        );
-        gl.bindBuffer(gl.ARRAY_BUFFER, null);
-        return vbo;
-    }
-
-    function createIbo(gl, array) {
-        const ibo = gl.createBuffer();
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, array, gl.STATIC_DRAW);
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
-        return ibo;
-    }
-
-    function getUniformLocations(gl, program, keys) {
-        const locations = {};
-        keys.forEach((key) => {
-            locations[key] = gl.getUniformLocation(program, key);
-        });
-        return locations;
-    }
-
-    function createFramebuffer(gl, sizeX, sizeY) {
-        const framebuffer = gl.createFramebuffer();
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        const texture = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texImage2D(
-            gl.TEXTURE_2D,
-            0,
-            gl.RG32F,
-            sizeX,
-            sizeY,
-            0,
-            gl.RG,
-            gl.FLOAT,
-            null
-        );
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT0,
-            gl.TEXTURE_2D,
-            texture,
-            0
-        );
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return {
-            framebuffer: framebuffer,
-            texture: texture
-        };
-    }
-
-    const VERTICES_POSITION = new Float32Array([
-        -1.0,
-        -1.0,
-        1.0,
-        -1.0,
-        -1.0,
-        1.0,
-        1.0,
-        1.0
-    ]);
-
-    const VERTICES_INDEX = new Int16Array([0, 1, 2, 3, 2, 1]);
-
-    const FILL_SCREEN_VERTEX_SHADER_SOURCE = `#version 300 es
-
-  layout (location = 0) in vec2 position;
-
-  void main(void) {
-    gl_Position = vec4(position, 0.0, 1.0);
-  }
-  `;
-
-    const INITIALIZE_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  out vec2 o_state;
-
-  uniform vec2 u_resolution;
-  uniform vec2 u_randomSeed;
-
-
-  float random(vec2 x){
-    return fract(sin(dot(x,vec2(12.9898, 78.233))) * 43758.5453);
-  }
-
-
-  float valuenoise(vec2 x) {
-      vec2 i = floor(x);
-      vec2 f = fract(x);
-
-      vec2 u = f * f * (3.0 - 2.0 * f);
-
-      return mix(
-          mix(random(i), random(i + vec2(1.0, 0.0)), u.x),
-          mix(random(i + vec2(0.0, 1.0)), random(vec2(i + vec2(1.0, 1.0))), u.x),
-          u.y
-      );
-  }
-
-  float fbm(vec2 x) {
-    float sum = 0.0;
-    float amp = 0.5;
-    for (int i = 0; i < 5; i++) {
-      sum += amp * valuenoise(x);
-      amp *= 0.5;
-      x *= 2.01;
-    }
-    return sum;
-  }
-
-  void main(void) {
-    vec2 st = (2.0 * gl_FragCoord.xy - u_resolution) / min(u_resolution.x, u_resolution.y);
-    if (fbm(gl_FragCoord.xy * 0.01 + random(u_randomSeed) * 1000.0 + vec2(392.43, 193.34)) < 0.3) {
-      o_state = vec2(1.0);
-    } else {
-      o_state = vec2(0.0);
-    }
-
-  }
-  `;
-
-    const UPDATE_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  out vec2 o_state;
-
-  uniform sampler2D u_stateTexture;
-  uniform float u_timeStep;
-  uniform float u_spaceStep;
-  uniform vec2 u_diffusion;
-  uniform float u_feed;
-  uniform float u_kill;
-
-  void main(void) {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    ivec2 stateTextureSize = textureSize(u_stateTexture, 0);
-
-    vec2 state = texelFetch(u_stateTexture, coord, 0).xy;
-
-    vec2 left = texelFetch(u_stateTexture, ivec2(coord.x != 0 ? coord.x - 1 : stateTextureSize.x - 1, coord.y), 0).xy;
-    vec2 right = texelFetch(u_stateTexture, ivec2(coord.x != stateTextureSize.x - 1 ? coord.x + 1 : 0, coord.y), 0).xy;
-    vec2 down = texelFetch(u_stateTexture, ivec2(coord.x, coord.y != 0 ? coord.y - 1 : stateTextureSize.y - 1), 0).xy;
-    vec2 up = texelFetch(u_stateTexture, ivec2(coord.x, coord.y != stateTextureSize.y - 1 ? coord.y + 1 : 0), 0).xy;
-
-    vec2 laplacian = (left + right + up + down - 4.0 * state) / (u_spaceStep * u_spaceStep);
-
-    o_state = state + u_timeStep * (u_diffusion * laplacian + vec2(
-      state.x * state.x * state.y - (u_feed + u_kill) * state.x,
-      -state.x * state.x * state.y + u_feed * (1.0 - state.y)
-    ));
-  }
-  `;
-
-    const RENDER_FRAGMNET_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  out vec4 o_color;
-
-  uniform sampler2D u_stateTexture;
-  uniform int u_target;
-  uniform int u_rendering;
-  uniform float u_spaceStep;
-
-  float getValue(ivec2 coord) {
-    vec2 state = texelFetch(u_stateTexture, ivec2(coord), 0).xy;
-
-    if (u_target == 0) {
-      return state.x;
-    } else if (u_target == 1) {
-      return state.y;
-    } else {
-      return abs(state.x - state.y);
-    }
-  }
-
-  vec3 render2d(ivec2 coord) {
-    return vec3(getValue(coord));
-  }
-
-  vec3 lambert(vec3 color, vec3 normal, vec3 lightDir) {
-    return color * max(dot(normal, lightDir), 0.0);
-  }
-
-  vec3 render3d(ivec2 coord) {
-    ivec2 stateTextureSize = textureSize(u_stateTexture, 0);
-    float state = getValue(coord);
-    float left = getValue(ivec2(coord.x != 0 ? coord.x - 1 : stateTextureSize.x - 1, coord.y));
-    float right = getValue(ivec2(coord.x != stateTextureSize.x - 1 ? coord.x + 1 : 0, coord.y));
-    float down = getValue(ivec2(coord.x, coord.y != 0 ? coord.y - 1 : stateTextureSize.y - 1));
-    float up = getValue(ivec2(coord.x, coord.y != stateTextureSize.y - 1 ? coord.y + 1 : 0));
-
-    vec3 dx = vec3(2.0 * u_spaceStep, 0.0, (right - left) / (2.0 * u_spaceStep));
-    vec3 dy = vec3(0.0, 2.0 * u_spaceStep, (up - down) / (2.0 * u_spaceStep));
-
-    vec3 normal = mix(normalize(cross(dx, dy)), vec3(0.0, 0.0, 1.0), 0.5);
-
-    vec3 baseColor = mix(vec3(0.0, 0.05, 0.1), vec3(0.7, 1.0, 0.1), clamp(state, 0.0, 1.00));
-    vec3 color = vec3(0.0);
-    color += baseColor * lambert(vec3(1.5), normal, vec3(1.0, 1.0, 1.0));
-    color += baseColor * lambert(vec3(0.5), normal, vec3(-1.0, -1.0, 0.3));
-    return color;
-  }
-
-  void main(void) {
-    vec2 state = texelFetch(u_stateTexture, ivec2(gl_FragCoord.xy), 0).xy;
-
-    if (u_rendering == 0) {
-      o_color = vec4(render2d(ivec2(gl_FragCoord.xy)), 1.0);
-    } else {
-      o_color = vec4(render3d(ivec2(gl_FragCoord.xy)), 1.0);
-    }
-  }
-  `;
-
-    const parameters = {
-        "diffusion U": 0.0009,
-        "diffusion V": 0.004,
-        feed: 0.09,
-        kill: 0.06,
-        "space step": 0.05,
-        "time step": 0.15,
-        "time scale": 50.0,
-        target: 0,
-        rendering: 1,
-        reset: (_) => reset()
-    };
-
-    const canvas = document.getElementById("canvas");
-    const gl = canvas.getContext("webgl2");
-    gl.getExtension("EXT_color_buffer_float");
-
-    const initializeProgram = createProgramFromSource(
-        gl,
-        FILL_SCREEN_VERTEX_SHADER_SOURCE,
-        INITIALIZE_FRAGMENT_SHADER_SOURCE
-    );
-    const updateProgram = createProgramFromSource(
-        gl,
-        FILL_SCREEN_VERTEX_SHADER_SOURCE,
-        UPDATE_FRAGMENT_SHADER_SOURCE
-    );
-    const renderProgram = createProgramFromSource(
-        gl,
-        FILL_SCREEN_VERTEX_SHADER_SOURCE,
-        RENDER_FRAGMNET_SHADER_SOURCE
-    );
-    const initializeUniforms = getUniformLocations(gl, initializeProgram, [
-        "u_resolution",
-        "u_randomSeed"
-    ]);
-    const updateUniforms = getUniformLocations(gl, updateProgram, [
-        "u_stateTexture",
-        "u_diffusion",
-        "u_feed",
-        "u_kill",
-        "u_timeStep",
-        "u_spaceStep"
-    ]);
-    const renderUniforms = getUniformLocations(gl, renderProgram, [
-        "u_stateTexture",
-        "u_target",
-        "u_rendering",
-        "u_spaceStep"
-    ]);
-
-    const vao = gl.createVertexArray();
-    gl.bindVertexArray(vao);
-    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, createIbo(gl, VERTICES_INDEX));
-    gl.bindBuffer(gl.ARRAY_BUFFER, createVbo(gl, VERTICES_POSITION));
-    gl.enableVertexAttribArray(0);
-    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
-    gl.bindVertexArray(null);
-
-    const renderToFillScreen = function() {
-        gl.bindVertexArray(vao);
-        gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-        gl.bindVertexArray(null);
-    };
-
-    let animationId = null;
-    const reset = function() {
-        if (animationId !== null) {
-            cancelAnimationFrame(animationId);
-        }
-
-        canvas.width = window.innerWidth;
-        canvas.height = window.innerHeight;
-        gl.viewport(0.0, 0.0, canvas.width, canvas.height);
-
-        let stateFbObjR = createFramebuffer(gl, canvas.width, canvas.height);
-        let stateFbObjW = createFramebuffer(gl, canvas.width, canvas.height);
-        const swapFramebuffer = function() {
-            const tmp = stateFbObjR;
-            stateFbObjR = stateFbObjW;
-            stateFbObjW = tmp;
-        };
-
-        const initialize = function() {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, stateFbObjW.framebuffer);
-            gl.useProgram(initializeProgram);
-            gl.uniform2f(
-                initializeUniforms["u_resolution"],
-                canvas.width,
-                canvas.height
-            );
-            gl.uniform2f(
-                initializeUniforms["u_randomSeed"],
-                Math.random() * 1000.0,
-                Math.random() * 1000.0
-            );
-            renderToFillScreen();
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapFramebuffer();
-        };
-
-        const update = function(deltaTime) {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, stateFbObjW.framebuffer);
-            gl.useProgram(updateProgram);
-            gl.activeTexture(gl.TEXTURE0);
-            gl.bindTexture(gl.TEXTURE_2D, stateFbObjR.texture);
-            gl.uniform1i(updateUniforms["u_stateTexture"], 0);
-            gl.uniform2f(
-                updateUniforms["u_diffusion"],
-                parameters["diffusion U"],
-                parameters["diffusion V"]
-            );
-            gl.uniform1f(updateUniforms["u_feed"], parameters["feed"]);
-            gl.uniform1f(updateUniforms["u_kill"], parameters["kill"]);
-            gl.uniform1f(updateUniforms["u_timeStep"], deltaTime);
-            gl.uniform1f(
-                updateUniforms["u_spaceStep"],
-                parameters["space step"]
-            );
-            renderToFillScreen();
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapFramebuffer();
-        };
-
-        const render = function() {
-            gl.useProgram(renderProgram);
-            gl.activeTexture(gl.TEXTURE0);
-            gl.bindTexture(gl.TEXTURE_2D, stateFbObjR.texture);
-            gl.uniform1i(renderUniforms["u_stateTexture"], 0);
-            gl.uniform1i(renderUniforms["u_target"], parameters["target"]);
-            gl.uniform1i(
-                renderUniforms["u_rendering"],
-                parameters["rendering"]
-            );
-            gl.uniform1f(
-                renderUniforms["u_spaceStep"],
-                parameters["space step"]
-            );
-            renderToFillScreen();
-        };
-
-        initialize();
-        let simulationSeconds = 0.0;
-        let previousRealSeconds = performance.now() * 0.001;
-        const loop = function() {
-            const currentRealSeconds = performance.now() * 0.001;
-            const nextSimulationSeconds =
-                simulationSeconds +
-                parameters["time scale"] *
-                    Math.min(0.2, currentRealSeconds - previousRealSeconds);
-            previousRealSeconds = currentRealSeconds;
-
-            const timeStep = parameters["time step"];
-            while (nextSimulationSeconds - simulationSeconds > timeStep) {
-                update(timeStep);
-                simulationSeconds += timeStep;
-            }
-            render();
-
-            animationId = requestAnimationFrame(loop);
-        };
-        loop();
-    };
-    reset();
-})();

package/dev/snoise-debug.js

@@ -1,252 +0,0 @@
-/**
- * @param _s27 vec4
- */
-function permute4(_s27) {
-    return vec4.modn(vec4.mul(_s27, vec4.addvn(vec4.mulvn(_s27, 34), 1)), 289);
-}
-/**
- * @param _s28 vec3
- */
-function snoise3(_s28) {
-    let /*vec3*/ _s29 = vec3.floor(
-            vec3.addvn(_s28, vec3.dot(_s28, env.vec3n(0.3333333333333333)))
-        );
-    let /*vec3*/ _s2a = vec3.addvn(
-            vec3.sub(_s28, _s29),
-            vec3.dot(_s29, env.vec3n(0.16666666666666666))
-        );
-    let /*vec3*/ _s2b = vec3.step(env.swizzle3(_s2a, 1, 2, 0), _s2a);
-    let /*vec3*/ _s2c = env.swizzle3(vec3.subnv(1, _s2b), 2, 0, 1);
-    let /*vec3*/ _s2d = vec3.min(_s2b, _s2c);
-    let /*vec3*/ _s2e = vec3.max(_s2b, _s2c);
-    let /*vec3*/ _s2f = vec3.addvn(vec3.sub(_s2a, _s2d), 0.16666666666666666);
-    let /*vec3*/ _s2g = vec3.addvn(vec3.sub(_s2a, _s2e), 0.3333333333333333);
-    let /*vec3*/ _s2h = vec3.subvn(_s2a, 0.5);
-    _s29 = vec3.modn(_s29, 289);
-    let /*vec4*/ _s2i = permute4(
-            vec4.add(
-                permute4(
-                    vec4.add(
-                        permute4(vec4.addnv(_s29[2], [0, _s2d[2], _s2e[2], 1])),
-                        vec4.addnv(_s29[1], [0, _s2d[1], _s2e[1], 1])
-                    )
-                ),
-                vec4.addnv(_s29[0], [0, _s2d[0], _s2e[0], 1])
-            )
-        );
-    let /*vec4*/ _s2j = vec4.sub(
-            _s2i,
-            vec4.mulnv(
-                49,
-                vec4.floor(
-                    vec4.mulvn(vec4.mulvn(_s2i, 0.142857142857), 0.142857142857)
-                )
-            )
-        );
-    let /*vec4*/ _s2k = vec4.floor(vec4.mulvn(_s2j, 0.142857142857));
-    let /*vec4*/ _s2l = vec4.addvn(
-            vec4.mulvn(_s2k, 0.285714285714),
-            -0.9285714285715
-        );
-    let /*vec4*/ _s2m = vec4.addvn(
-            vec4.mulvn(
-                vec4.floor(vec4.sub(_s2j, vec4.mulvn(_s2k, 7))),
-                0.285714285714
-            ),
-            -0.9285714285715
-        );
-    let /*vec4*/ _s2n = vec4.sub(vec4.subnv(1, vec4.abs(_s2l)), vec4.abs(_s2m));
-    let /*vec4*/ _s2o = vec4.sub1(vec4.step(_s2n, env.vec4n(0)));
-    let /*vec4*/ _s2p = env.vec4vv(
-            env.swizzle2(_s2l, 0, 1),
-            env.swizzle2(_s2m, 0, 1)
-        );
-    let /*vec4*/ _s2q = env.vec4vv(
-            env.swizzle2(_s2l, 2, 3),
-            env.swizzle2(_s2m, 2, 3)
-        );
-    let /*vec4*/ _s2r = vec4.add(
-            env.swizzle4(_s2p, 0, 2, 1, 3),
-            vec4.mul(
-                env.swizzle4(
-                    vec4.addvn(vec4.mulvn(vec4.floor(_s2p), 2), 1),
-                    0,
-                    2,
-                    1,
-                    3
-                ),
-                env.swizzle4(_s2o, 0, 0, 1, 1)
-            )
-        );
-    let /*vec4*/ _s2s = vec4.add(
-            env.swizzle4(_s2q, 0, 2, 1, 3),
-            vec4.mul(
-                env.swizzle4(
-                    vec4.addvn(vec4.mulvn(vec4.floor(_s2q), 2), 1),
-                    0,
-                    2,
-                    1,
-                    3
-                ),
-                env.swizzle4(_s2o, 2, 2, 3, 3)
-            )
-        );
-    let /*vec3*/ _s2t = env.vec3vn(env.swizzle2(_s2r, 0, 1), _s2n[0]);
-    let /*vec3*/ _s2u = env.vec3vn(env.swizzle2(_s2r, 2, 3), _s2n[1]);
-    let /*vec3*/ _s2v = env.vec3vn(env.swizzle2(_s2s, 0, 1), _s2n[2]);
-    let /*vec3*/ _s2w = env.vec3vn(env.swizzle2(_s2s, 2, 3), _s2n[3]);
-    let /*vec4*/ _s2x = vec4.subnv(
-            1.79284291400159,
-            vec4.mulvn(
-                [
-                    vec3.dot(_s2t, _s2t),
-                    vec3.dot(_s2u, _s2u),
-                    vec3.dot(_s2v, _s2v),
-                    vec3.dot(_s2w, _s2w)
-                ],
-                0.85373472095314
-            )
-        );
-    _s2t = vec3.mulvn(_s2t, _s2x[0]);
-    _s2u = vec3.mulvn(_s2u, _s2x[1]);
-    _s2v = vec3.mulvn(_s2v, _s2x[2]);
-    _s2w = vec3.mulvn(_s2w, _s2x[3]);
-    let /*vec4*/ _s2y = vec4.max(
-            env.vec4n(0),
-            vec4.subnv(0.6, [
-                vec3.dot(_s2a, _s2a),
-                vec3.dot(_s2f, _s2f),
-                vec3.dot(_s2g, _s2g),
-                vec3.dot(_s2h, _s2h)
-            ])
-        );
-    _s2y = vec4.mul(_s2y, _s2y);
-    return (
-        42 *
-        vec4.dot(vec4.mul(_s2y, _s2y), [
-            vec3.dot(_s2t, _s2a),
-            vec3.dot(_s2u, _s2f),
-            vec3.dot(_s2v, _s2g),
-            vec3.dot(_s2w, _s2h)
-        ])
-    );
-}
-/**
- * @param _s72 vec3
- * @param _s73 vec3
- * @param _s74 float
- */
-function additive(_s72, _s73, _s74) {
-    let /*float*/ _s75 = 0;
-    let /*float*/ _s76 = 0.5;
-    for (let /*float*/ _s77 = 0; _s77 < 4; _s77++) {
-        _s75 = _s75 + _s76 * snoise3(vec3.add(_s72, vec3.mulnv(_s77, _s73)));
-        _s76 = _s76 * _s74;
-        _s72 = vec3.mulvn(_s72, 2);
-    }
-    return _s75;
-}
-/**
- * @param _s51 vec2
- * @param _s52 vec2
- */
-function aspectCorrectedUV(_s51, _s52) {
-    let /*vec2*/ _s53 = vec2.subvn(vec2.mulvn(vec2.div(_s51, _s52), 2), 1);
-    _s53[0] = _s53[0] * (_s52[0] / _s52[1]);
-    return _s53;
-}
-/**
- * @param _s6y vec2
- * @param _s6z vec2
- * @param _s70 float
- */
-function mainImage(_s6y, _s6z, _s70) {
-    let /*vec2*/ _s71 = aspectCorrectedUV(_s6y, _s6z);
-    let /*float*/ _s78 = additive(env.vec3vn(_s71, _s70), env.vec3n(2), 0.5);
-    return env.vec4vn(env.vec3n(_s78 * 0.5 + 0.5), 1);
-}
-
-/*
-vec4 permute4(in vec4 _s27) {
-return mod((_s27 * ((_s27 * 34.0) + 1.0)), 289.0);
-}
-float snoise3(in vec3 _s28) {
-vec3 _s29 = floor((_s28 + dot(_s28, vec3(0.3333333333333333))));
-vec3 _s2a = ((_s28 - _s29) + dot(_s29, vec3(0.16666666666666666)));
-vec3 _s2b = step(_s2a.yzx, _s2a);
-vec3 _s2c = (1.0 - _s2b).zxy;
-vec3 _s2d = min(_s2b, _s2c);
-vec3 _s2e = max(_s2b, _s2c);
-vec3 _s2f = ((_s2a - _s2d) + 0.16666666666666666);
-vec3 _s2g = ((_s2a - _s2e) + 0.3333333333333333);
-vec3 _s2h = (_s2a - 0.5);
-_s29 = mod(_s29, 289.0);
-vec4 _s2i = permute4((permute4((permute4((_s29.z + vec4(0.0, _s2d.z, _s2e.z, 1.0))) + (_s29.y + vec4(0.0, _s2d.y, _s2e.y, 1.0)))) + (_s29.x + vec4(0.0, _s2d.x, _s2e.x, 1.0))));
-vec4 _s2j = (_s2i - (49.0 * floor(((_s2i * 0.142857142857) * 0.142857142857))));
-vec4 _s2k = floor((_s2j * 0.142857142857));
-vec4 _s2l = ((_s2k * 0.285714285714) + -0.9285714285715);
-vec4 _s2m = ((floor((_s2j - (_s2k * 7.0))) * 0.285714285714) + -0.9285714285715);
-vec4 _s2n = ((1.0 - abs(_s2l)) - abs(_s2m));
-vec4 _s2o = (-step(_s2n, vec4(0.0)));
-vec4 _s2p = vec4(_s2l.xy, _s2m.xy);
-vec4 _s2q = vec4(_s2l.zw, _s2m.zw);
-vec4 _s2r = (_s2p.xzyw + (((floor(_s2p) * 2.0) + 1.0).xzyw * _s2o.xxyy));
-vec4 _s2s = (_s2q.xzyw + (((floor(_s2q) * 2.0) + 1.0).xzyw * _s2o.zzww));
-vec3 _s2t = vec3(_s2r.xy, _s2n.x);
-vec3 _s2u = vec3(_s2r.zw, _s2n.y);
-vec3 _s2v = vec3(_s2s.xy, _s2n.z);
-vec3 _s2w = vec3(_s2s.zw, _s2n.w);
-vec4 _s2x = (1.79284291400159 - (vec4(dot(_s2t, _s2t), dot(_s2u, _s2u), dot(_s2v, _s2v), dot(_s2w, _s2w)) * 0.85373472095314));
-_s2t = (_s2t * _s2x.x);
-_s2u = (_s2u * _s2x.y);
-_s2v = (_s2v * _s2x.z);
-_s2w = (_s2w * _s2x.w);
-vec4 _s2y = max(vec4(0.0), (0.6 - vec4(dot(_s2a, _s2a), dot(_s2f, _s2f), dot(_s2g, _s2g), dot(_s2h, _s2h))));
-_s2y = (_s2y * _s2y);
-return (42.0 * dot((_s2y * _s2y), vec4(dot(_s2t, _s2a), dot(_s2u, _s2f), dot(_s2v, _s2g), dot(_s2w, _s2h))));
-}
-float additive(in vec3 _s72, in vec3 _s73, in float _s74) {
-float _s75 = 0.0;
-float _s76 = 0.5;
-for(float _s77 = 0.0; (_s77 < 4.0); (_s77++)) {
-_s75 = (_s75 + (_s76 * snoise3((_s72 + (_s77 * _s73)))));
-_s76 = (_s76 * _s74);
-_s72 = (_s72 * 2.0);
-}
-return _s75;
-}
-vec2 aspectCorrectedUV(in vec2 _s51, in vec2 _s52) {
-vec2 _s53 = (((_s51 / _s52) * 2.0) - 1.0);
-_s53.x = (_s53.x * (_s52.x / _s52.y));
-return _s53;
-}
-vec4 mainImage(in vec2 _s6y, in vec2 _s6z, in float _s70) {
-vec2 _s71 = aspectCorrectedUV(_s6y, _s6z);
-float _s78 = additive(vec3(_s71, _s70), vec3(2.0), 0.5);
-return vec4(vec3(((_s78 * 0.5) + 0.5)), 1.0);
-}
-src.f10117fe.js:34085 #version 100
-#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp int;
-precision highp float;
-#else
-precision mediump int;
-precision mediump float;
-#endif
-#ifndef PI
-#define PI 3.141592653589793
-#endif
-#ifndef TAU
-#define TAU 6.283185307179586
-#endif
-#ifndef HALF_PI
-#define HALF_PI 1.570796326794896
-#endif
-
-uniform vec2 resolution;
-uniform float time;
-attribute vec2 position;
-void main() {
-gl_Position = vec4(position, 0.0, 1.0);
-}
-*/