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

package/dev/boids.js

@@ -1,1433 +0,0 @@
-class Vector2 {
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-
-    static get zero() {
-        return new Vector2(0.0, 0.0);
-    }
-
-    static add(v1, v2) {
-        return new Vector2(v1.x + v2.x, v1.y + v2.y);
-    }
-
-    static sub(v1, v2) {
-        return new Vector2(v1.x - v2.x, v1.y - v2.y);
-    }
-
-    static mul(v, s) {
-        return new Vector2(v.x * s, v.y * s);
-    }
-
-    static div(v, s) {
-        return new Vector2(v.x / s, v.y / s);
-    }
-
-    static norm(v) {
-        const m = v.mag();
-        return new Vector2(v.x / m, v.y / m);
-    }
-
-    static dot(v1, v2) {
-        return v1.x * v2.x + v1.y * v2.y;
-    }
-
-    static dist(v1, v2) {
-        const v = Vector2.sub(v1, v2);
-        return v.mag();
-    }
-
-    add(v) {
-        this.x += v.x;
-        this.y += v.y;
-        return this;
-    }
-
-    sub(v) {
-        this.x -= v.x;
-        this.y -= v.y;
-        return this;
-    }
-
-    mul(s) {
-        this.x *= s;
-        this.y *= s;
-        return this;
-    }
-
-    div(s) {
-        this.x /= s;
-        this.y /= s;
-        return this;
-    }
-
-    ceil() {
-        this.x = Math.ceil(this.x);
-        this.y = Math.ceil(this.y);
-        return this;
-    }
-
-    mag() {
-        return Math.sqrt(this.sqMag());
-    }
-
-    sqMag() {
-        return this.x * this.x + this.y * this.y;
-    }
-
-    norm() {
-        return Vector2.norm(this);
-    }
-
-    dot(v) {
-        return Vector3.dot(this, v);
-    }
-}
-
-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 createProgram(gl, vertexShader, fragmentShader) {
-    const program = gl.createProgram();
-    gl.attachShader(program, vertexShader);
-    gl.attachShader(program, fragmentShader);
-    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 createVao(gl, vboObjs, ibo) {
-    const vao = gl.createVertexArray();
-    gl.bindVertexArray(vao);
-    if (ibo !== undefined) {
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
-    }
-    vboObjs.forEach((vboObj) => {
-        gl.bindBuffer(gl.ARRAY_BUFFER, vboObj.buffer);
-        gl.enableVertexAttribArray(vboObj.index);
-        gl.vertexAttribPointer(
-            vboObj.index,
-            vboObj.size,
-            gl.FLOAT,
-            false,
-            0,
-            0
-        );
-    });
-    gl.bindVertexArray(null);
-    if (ibo !== undefined) {
-        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
-    }
-    gl.bindBuffer(gl.ARRAY_BUFFER, null);
-    return vao;
-}
-
-function createTexture(gl, size, internalFormat, format, type) {
-    const texture = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texImage2D(
-        gl.TEXTURE_2D,
-        0,
-        internalFormat,
-        size,
-        size,
-        0,
-        format,
-        type,
-        null
-    );
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-    return texture;
-}
-
-function getUniformLocations(gl, program, keys) {
-    const locations = {};
-    keys.forEach((key) => {
-        locations[key] = gl.getUniformLocation(program, key);
-    });
-    return locations;
-}
-
-function setTextureAsUniform(gl, index, texture, location) {
-    gl.activeTexture(gl.TEXTURE0 + index);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.uniform1i(location, index);
-}
-
-(function() {
-    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_BOID_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  layout (location = 0) out vec2 o_position;
-  layout (location = 1) out vec2 o_velocity;
-
-  uniform vec2 u_randomSeed;
-  uniform uint u_boidNum;
-  uniform uint u_boidTextureSize;
-  uniform float u_maxSpeed;
-  uniform vec2 u_simulationSpace;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  float random(vec2 x){
-    return fract(sin(dot(x,vec2(12.9898, 78.233))) * 43758.5453);
-  }
-
-  void main(void) {
-    uint index = convertCoordToIndex(uvec2(gl_FragCoord.xy), u_boidTextureSize);
-
-    if (index >= u_boidNum) { // unused pixels
-      o_position = vec2(0.0);
-      o_velocity = vec2(0.0);
-      return;
-    }
-
-    o_position = vec2(
-      random(gl_FragCoord.xy * 0.013 + random(u_randomSeed * vec2(32.19, 27.51) * 1000.0)),
-      random(gl_FragCoord.xy * 0.029 + random(u_randomSeed * vec2(19.56, 11.34) * 1000.0))
-    ) * (u_simulationSpace - 1e-5) + 1e-5 * 0.5;
-    o_velocity = normalize(vec2(
-      random(gl_FragCoord.xy * 0.059 + random(u_randomSeed * vec2(27.31, 16.91) * 1000.0)),
-      random(gl_FragCoord.xy * 0.038 + random(u_randomSeed * vec2(25.95, 19.47) * 1000.0))
-    ) * 2.0 - 1.0) * u_maxSpeed;
-  }
-  `;
-
-    const UPDATE_BOID_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  layout (location = 0) out vec2 o_position;
-  layout (location = 1) out vec2 o_velocity;
-
-  uniform sampler2D u_positionTexture;
-  uniform sampler2D u_velocityTexture;
-  uniform sampler2D u_forceTexture;
-  uniform float u_deltaTime;
-  uniform float u_maxSpeed;
-  uniform uint u_boidNum;
-  uniform uint u_boidTextureSize;
-  uniform vec2 u_simulationSpace;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  vec2 limit(vec2 v, float max) {
-    if (length(v) < max) {
-      return normalize(v) * max;
-    }
-    return v;
-  }
-
-  void main(void) {
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-
-    uint index = convertCoordToIndex(uvec2(coord), u_boidTextureSize);
-    if (index >= u_boidNum) { // unused pixels
-      o_position = vec2(0.0);
-      o_velocity = vec2(0.0);
-      return;
-    }
-
-    vec2 position = texelFetch(u_positionTexture, coord, 0).xy;
-    vec2 velocity = texelFetch(u_velocityTexture, coord, 0).xy;
-    vec2 force = texelFetch(u_forceTexture, coord, 0).xy;
-
-    vec2 nextVelocity = limit(velocity + u_deltaTime * force, u_maxSpeed);
-    vec2 nextPosition = position + u_deltaTime * velocity;
-
-    if (nextPosition.x < 1e-6) {
-      nextPosition.x = 1e-6;
-      nextVelocity.x *= -1.0;
-    }
-    if (nextPosition.x > u_simulationSpace.x - 1e-6) {
-      nextPosition.x = u_simulationSpace.x - 1e-6;
-      nextVelocity.x *= -1.0;
-    }
-    if (nextPosition.y < 1e-6) {
-      nextPosition.y = 1e-6;
-      nextVelocity.y *= -1.0;
-    }
-    if (nextPosition.y > u_simulationSpace.y - 1e-6) {
-      nextPosition.y = u_simulationSpace.y - 1e-6;
-      nextVelocity.y *= -1.0;
-    }
-
-    o_position = nextPosition;
-    o_velocity = nextVelocity;
-  }
-  `;
-
-    const COMPUTE_FORCE_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-  precision highp isampler2D;
-  precision highp usampler2D;
-
-  // 4294967295 = 2^32 - 1
-  #define MAX_32UI 4294967295u
-
-  out vec2 o_force;
-
-  uniform sampler2D u_positionTexture;
-  uniform sampler2D u_velocityTexture;
-  uniform usampler2D u_bucketTexture;
-  uniform usampler2D u_bucketReferrerTexture;
-
-  uniform vec3 u_radius; // x: separation, y: alignment: z: cohesion
-  uniform vec3 u_weight; // x: separation, y: alignment: z: cohesion
-  uniform float u_maxSpeed;
-  uniform float u_maxForce;
-  uniform float u_boundaryIntensity;
-  uniform uint u_boidNum;
-  uniform float u_bucketSize;
-  uniform ivec2 u_bucketNum;
-  uniform vec2 u_simulationSpace;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  uvec2 convertIndexToCoord(uint index, uint sizeX) {
-    return uvec2(index % sizeX, index / sizeX);
-  }
-
-  vec2 limit(vec2 v, float max) {
-    if (length(v) > max) {
-      return normalize(v) * max;
-    }
-    return v;
-  }
-
-  void findNeighbors(vec2 position, ivec2 bucketPosition, ivec2 bucketNum, uint boidTextureSizeX, uint bucketReferrerTextureSizeX, inout vec2 separation, inout vec2 alignment, inout vec3 cohesion) {
-    if (bucketPosition.x < 0 || bucketPosition.x >= bucketNum.x ||
-        bucketPosition.y < 0 || bucketPosition.y >= bucketNum.y) {
-      return;
-    }
-    uint bucketIndex = uint(bucketPosition.x + bucketNum.x * bucketPosition.y);
-    ivec2 coord = ivec2(convertIndexToCoord(bucketIndex, bucketReferrerTextureSizeX));
-
-    uvec2 bucketReferrer = texelFetch(u_bucketReferrerTexture, coord, 0).xy;
-
-    if (bucketReferrer.x == MAX_32UI || bucketReferrer.y == MAX_32UI) {
-      return;
-    }
-
-    for (uint i = bucketReferrer.x; i <= bucketReferrer.y; i++) {
-      uint boidIndex = texelFetch(u_bucketTexture, ivec2(convertIndexToCoord(i, boidTextureSizeX)), 0).y;
-
-      ivec2 boidCoord = ivec2(convertIndexToCoord(boidIndex, boidTextureSizeX));
-      vec2 otherPos = texelFetch(u_positionTexture, boidCoord, 0).xy;
-
-      float dist = length(position - otherPos);
-
-      if (dist == 0.0) {
-        continue;
-      }
-
-      if (dist < u_radius.x) {
-        separation += normalize(position - otherPos) / dist;
-      }
-
-      if (dist < u_radius.y) {
-        vec2 otherVel = texelFetch(u_velocityTexture, boidCoord, 0).xy;
-        alignment += otherVel;
-      }
-
-      if (dist < u_radius.z) {
-        cohesion.xy += otherPos;
-        cohesion.z += 1.0;
-      }
-    }
-  }
-
-  vec2 computeForceFromBoids(vec2 position, vec2 velocity, uint boidTextureSizeX) {
-    uint bucketReferrerTextureSizeX = uint(textureSize(u_bucketReferrerTexture, 0).x);
-
-    vec2 bucketPosition = position / u_bucketSize;
-    int xOffset = fract(bucketPosition.x) < 0.5 ? -1 : 1;
-    int yOffset = fract(bucketPosition.y) < 0.5 ? -1 : 1;
-
-    ivec2 bucketPosition00 = ivec2(bucketPosition);
-    ivec2 bucketPosition10 = bucketPosition00 + ivec2(xOffset, 0);
-    ivec2 bucketPosition01 = bucketPosition00 + ivec2(0, yOffset);
-    ivec2 bucketPosition11 = bucketPosition00 + ivec2(xOffset, yOffset);
-
-    vec2 separation = vec2(0.0);
-    vec2 alignment = vec2(0.0);
-    vec3 cohesion = vec3(0.0);
-    findNeighbors(position, bucketPosition00, u_bucketNum, boidTextureSizeX, bucketReferrerTextureSizeX, separation, alignment, cohesion);
-    findNeighbors(position, bucketPosition10, u_bucketNum, boidTextureSizeX, bucketReferrerTextureSizeX, separation, alignment, cohesion);
-    findNeighbors(position, bucketPosition01, u_bucketNum, boidTextureSizeX, bucketReferrerTextureSizeX, separation, alignment, cohesion);
-    findNeighbors(position, bucketPosition11, u_bucketNum, boidTextureSizeX, bucketReferrerTextureSizeX, separation, alignment, cohesion);
-
-    vec2 separationForce = vec2(0.0);
-    if (separation.xy != vec2(0.0)) {
-      vec2 desiredVelocity = normalize(separation.xy) * u_maxSpeed;
-      separationForce = limit(desiredVelocity - velocity, u_maxForce);
-    }
-
-    vec2 alignmentForce = vec2(0.0);
-    if (alignment.xy != vec2(0.0)) {
-      vec2 desiredVelocity = normalize(alignment.xy) * u_maxSpeed;
-      alignmentForce = limit(desiredVelocity - velocity, u_maxForce);
-    }
-
-    vec2 cohesionForce = vec2(0.0);
-    if (cohesion.z != 0.0) {
-      vec2 target = cohesion.xy / cohesion.z;
-      vec2 desiredVelocity = normalize(target - position) * u_maxSpeed;
-      cohesionForce = limit(desiredVelocity - velocity, u_maxForce);
-    }
-
-    separationForce *= u_weight.x;
-    alignmentForce *= u_weight.y;
-    cohesionForce *= u_weight.z;
-
-    return separationForce + alignmentForce + cohesionForce;
-  }
-
-  vec2 computeForceFromWalls(vec2 position) {
-    vec2 force = vec2(0.0);
-    if (position.x < u_radius.x) {
-      force += vec2(u_boundaryIntensity, 0.0) / position.x;
-    }
-    if (u_simulationSpace.x - position.x < u_radius.x) {
-      force += vec2(-u_boundaryIntensity, 0.0) / (u_simulationSpace.x - position.x);
-    }
-    if (position.y < u_radius.x) {
-      force += vec2(0.0, u_boundaryIntensity) / position.y;
-    }
-    if (u_simulationSpace.y - position.y < u_radius.x) {
-      force += vec2(0.0, -u_boundaryIntensity) / (u_simulationSpace.y - position.y);
-    }
-    return force;
-  }
-
-  vec2 computeForce(uint boidTextureSizeX) {
-
-    ivec2 coord = ivec2(gl_FragCoord.xy);
-    vec2 position = texelFetch(u_positionTexture, coord, 0).xy;
-    vec2 velocity = texelFetch(u_velocityTexture, coord, 0).xy;
-
-    vec2 forceFromBoids = computeForceFromBoids(position, velocity, boidTextureSizeX);
-    vec2 forceFromWalls = computeForceFromWalls(position);
-
-    return limit(forceFromBoids + forceFromWalls, u_maxForce);
-  }
-
-  void main(void) {
-    uint boidTextureSizeX = uint(textureSize(u_positionTexture, 0).x);
-    uint index = convertCoordToIndex(uvec2(gl_FragCoord.xy), boidTextureSizeX);
-    if (index >= u_boidNum) { // unused pixels
-      o_force = vec2(0.0);
-      return;
-    }
-    o_force = computeForce(boidTextureSizeX);
-  }
-  `;
-
-    const RENDER_BOID_VERTEX_SHADER_SOURCE = `#version 300 es
-
-  precision highp isampler2D;
-  precision highp usampler2D;
-
-  const float PI = 3.14159265359;
-
-  out float v_angle;
-
-  uniform sampler2D u_positionTexture;
-  uniform sampler2D u_velocityTexture;
-  uniform vec2 u_canvasSize;
-  uniform vec2 u_simulationSpace;
-  uniform float u_boidSize;
-
-  ivec2 convertIndexToCoord(int index, int sizeX) {
-    return ivec2(index % sizeX, index / sizeX);
-  }
-
-  void main(void) {
-    ivec2 coord = convertIndexToCoord(gl_VertexID, textureSize(u_positionTexture, 0).x);
-    vec2 position = texelFetch(u_positionTexture, coord, 0).xy;
-    vec2 scale = min(u_canvasSize.x, u_canvasSize.y) / u_canvasSize;
-    float minSimulationSpace = min(u_simulationSpace.x, u_simulationSpace.y);
-    vec2 canvasPos = scale * ((position / minSimulationSpace) * 2.0 - u_simulationSpace / minSimulationSpace);
-    gl_Position = vec4(canvasPos, 0.0, 1.0);
-    gl_PointSize = u_boidSize;
-
-    vec2 velocity = texelFetch(u_velocityTexture, coord, 0).xy;
-    if (velocity.x == 0.0) {
-      v_angle = 0.25 * PI;
-    } else {
-      v_angle = atan(velocity.y, velocity.x);
-    }
-  }
-  `;
-
-    const RENDER_BOID_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  in float v_angle;
-
-  out vec4 o_color;
-
-  mat2 rotate(float r) {
-    float c = cos(r);
-    float s = sin(r);
-    return mat2(c, s, -s, c);
-  }
-
-  float sdTriangleIsosceles(vec2 p, vec2 q) {
-    p.x = abs(p.x);
-    vec2 a = p - q * clamp(dot(p, q) / dot(q, q), 0.0, 1.0);
-    vec2 b = p - q * vec2(clamp(p.x / q.x, 0.0, 1.0), 1.0);
-    float s = -sign(q.y);
-    vec2 d = min(vec2(dot(a, a), s * (p.x * q.y - p.y * q.x)), vec2(dot(b, b), s * (p.y - q.y)));
-    return -sqrt(d.x) * sign(d.y);
-  }
-
-  void main(void) {
-    vec2 p = ((gl_PointCoord - 0.5) * 2.0).yx;
-    p *= rotate(v_angle);
-    p.y *= -1.0;
-    if (sdTriangleIsosceles(p * 1.25, vec2(1.0, 5.0)) <= 0.0) {
-      o_color = vec4(vec3(0.8), 1.0);
-    } else {
-      discard;
-    }
-  }
-  `;
-
-    const INITIALIZE_BUCKET_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-
-  // 4294967295 = 2^32 - 1
-  #define MAX_32UI 4294967295u
-
-  out uvec2 o_bucket;
-
-  uniform sampler2D u_positionTexture;
-  uniform float u_bucketSize;
-  uniform uint u_boidNum;
-  uniform uvec2 u_bucketNum;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  uint getBucketIndex(vec2 position) {
-    uvec2 bucketCoord = uvec2(position / u_bucketSize);
-    return bucketCoord.x + bucketCoord.y * u_bucketNum.x;
-  }
-
-  void main(void) {
-    uint positionTextureSizeX = uint(textureSize(u_positionTexture, 0).x);
-    uint boidIndex = convertCoordToIndex(uvec2(gl_FragCoord.xy), positionTextureSizeX);
-    if (boidIndex >= u_boidNum) {
-      o_bucket = uvec2(MAX_32UI, 0); // = uvec2(2^32 - 1, 0)
-    }
-    vec2 position = texelFetch(u_positionTexture, ivec2(gl_FragCoord.xy), 0).xy;
-    uint bucketIndex = getBucketIndex(position);
-    o_bucket = uvec2(bucketIndex, boidIndex);
-  }
-  `;
-
-    const SWAP_BUCKET_INDEX_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-  precision highp usampler2D;
-
-  out uvec2 o_bucket;
-
-  uniform usampler2D u_bucketTexture;
-  uniform uint u_size;
-  uniform uint u_blockStep;
-  uniform uint u_subBlockStep;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  uvec2 convertIndexToCoord(uint index, uint sizeX) {
-    return uvec2(index % sizeX, index / sizeX);
-  }
-
-  void main(void) {
-    uint index = convertCoordToIndex(uvec2(gl_FragCoord.xy), u_size);
-    uint d = 1u << (u_blockStep - u_subBlockStep);
-
-    bool up = ((index >> u_blockStep) & 2u) == 0u;
-
-    uint targetIndex;
-    bool first = (index & d) == 0u;
-    if (first) {
-      targetIndex = index | d;
-    } else {
-      targetIndex = index & ~d;
-      up = !up;
-    }
-
-    uvec2 a = texelFetch(u_bucketTexture, ivec2(gl_FragCoord.xy), 0).xy;
-    uvec2 b = texelFetch(u_bucketTexture, ivec2(convertIndexToCoord(targetIndex, u_size)), 0).xy;
-
-    if (a.x == b.x || (a.x >= b.x) == up) {
-      o_bucket = b;
-    } else {
-      o_bucket = a;
-    }
-  }
-
-  `;
-
-    const INITIALIZE_BUCKET_REFERRER_FRAGMENT_SHADER_SOURCE = `#version 300 es
-
-  precision highp float;
-  precision highp usampler2D;
-
-  // 4294967295 = 2^32 - 1
-  #define MAX_32UI 4294967295u
-
-  out uvec2 o_referrer;
-
-  uniform uvec2 u_bucketReferrerTextureSize;
-  uniform usampler2D u_bucketTexture;
-  uniform uint u_boidNumN;
-  uniform uvec2 u_bucketNum;
-
-  uint convertCoordToIndex(uvec2 coord, uint sizeX) {
-    return coord.x + sizeX * coord.y;
-  }
-
-  uvec2 convertIndexToCoord(uint index, uint sizeX) {
-    return uvec2(index % sizeX, index / sizeX);
-  }
-
-  uint getBucketIndex(uint particleIndex, uint particleTextureSizeX) {
-    return texelFetch(u_bucketTexture, ivec2(convertIndexToCoord(particleIndex, particleTextureSizeX)), 0).x;
-  }
-
-
-  uint binarySearchMinIndex(uint target, uint from, uint to, uint particleTextureSizeX) {
-    for (uint i = 0u; i < u_boidNumN + 1u; i++) {
-      uint middle = from + (to - from) / 2u;
-      uint bucketIndex = getBucketIndex(middle, particleTextureSizeX);
-      if (bucketIndex < target) {
-        from = middle + 1u;
-      } else {
-        to = middle;
-      }
-      if (from == to) {
-        if (getBucketIndex(from, particleTextureSizeX) == target) {
-          return from;
-        } else {
-          return MAX_32UI;
-        }
-      }
-    }
-    return MAX_32UI;
-  }
-
-  uint binarySearchMaxIndex(uint target, uint from, uint to, uint particleTextureSizeX) {
-    for (uint i = 0u; i < u_boidNumN + 1u; i++) {
-      uint middle = from + (to - from) / 2u + 1u;
-      uint bucketIndex = getBucketIndex(middle, particleTextureSizeX);
-      if (bucketIndex > target) {
-        to = middle - 1u;
-      } else {
-        from = middle;
-      }
-      if (from == to) {
-        if (getBucketIndex(from, particleTextureSizeX) == target) {
-          return from;
-        } else {
-          return MAX_32UI;
-        }
-      }
-    }
-    return MAX_32UI;
-  }
-
-  uvec2 binarySearchRange(uint target, uint from, uint to) {
-    uint boidTextureSizeX = uint(textureSize(u_bucketTexture, 0).x);
-    from =  binarySearchMinIndex(target, from, to, boidTextureSizeX);
-    to = from == MAX_32UI ? MAX_32UI : binarySearchMaxIndex(target, from, to, boidTextureSizeX);
-    return uvec2(from, to);
-  }
-
-  void main(void) {
-    uint bucketIndex = convertCoordToIndex(uvec2(gl_FragCoord.xy), u_bucketReferrerTextureSize.x);
-    uint maxBucketIndex = u_bucketNum.x * u_bucketNum.y;
-
-    if (bucketIndex >= maxBucketIndex) {
-      o_referrer = uvec2(MAX_32UI, MAX_32UI);
-      return;
-    }
-
-    uvec2 boidTextureSize = uvec2(textureSize(u_bucketTexture, 0));
-    uint boidNum = boidTextureSize.x * boidTextureSize.y;
-
-    o_referrer = binarySearchRange(bucketIndex, 0u, boidNum - 1u);
-  }
-  `;
-
-    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]);
-
-    function createInitializeBoidProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            INITIALIZE_BOID_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createUpdateBoidProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            UPDATE_BOID_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createComputeForceProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            COMPUTE_FORCE_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createRenderBoidProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            RENDER_BOID_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            RENDER_BOID_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createInitializeBucketProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            INITIALIZE_BUCKET_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createSwapBucketIndexProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            SWAP_BUCKET_INDEX_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createInitializeBucketReferrerProgram(gl) {
-        const vertexShader = createShader(
-            gl,
-            FILL_SCREEN_VERTEX_SHADER_SOURCE,
-            gl.VERTEX_SHADER
-        );
-        const fragmentShader = createShader(
-            gl,
-            INITIALIZE_BUCKET_REFERRER_FRAGMENT_SHADER_SOURCE,
-            gl.FRAGMENT_SHADER
-        );
-        return createProgram(gl, vertexShader, fragmentShader);
-    }
-
-    function createBoidFramebuffer(gl, size) {
-        const framebuffer = gl.createFramebuffer();
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        const positionTexture = createTexture(
-            gl,
-            size,
-            gl.RG32F,
-            gl.RG,
-            gl.FLOAT
-        );
-        gl.bindTexture(gl.TEXTURE_2D, positionTexture);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT0,
-            gl.TEXTURE_2D,
-            positionTexture,
-            0
-        );
-        const velocityTexture = createTexture(
-            gl,
-            size,
-            gl.RG32F,
-            gl.RG,
-            gl.FLOAT
-        );
-        gl.bindTexture(gl.TEXTURE_2D, velocityTexture);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT1,
-            gl.TEXTURE_2D,
-            velocityTexture,
-            0
-        );
-        gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1]);
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return {
-            framebuffer: framebuffer,
-            positionTexture: positionTexture,
-            velocityTexture: velocityTexture
-        };
-    }
-
-    function createForceFramebuffer(gl, size) {
-        const framebuffer = gl.createFramebuffer();
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        const forceTexture = createTexture(gl, size, gl.RG32F, gl.RG, gl.FLOAT);
-        gl.bindTexture(gl.TEXTURE_2D, forceTexture);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT0,
-            gl.TEXTURE_2D,
-            forceTexture,
-            0
-        );
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return {
-            framebuffer: framebuffer,
-            forceTexture: forceTexture
-        };
-    }
-
-    function createBucketFramebuffer(gl, size) {
-        const framebuffer = gl.createFramebuffer();
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        const bucketTexture = createTexture(
-            gl,
-            size,
-            gl.RG32UI,
-            gl.RG_INTEGER,
-            gl.UNSIGNED_INT
-        );
-        gl.bindTexture(gl.TEXTURE_2D, bucketTexture);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT0,
-            gl.TEXTURE_2D,
-            bucketTexture,
-            0
-        );
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return {
-            framebuffer: framebuffer,
-            bucketTexture: bucketTexture
-        };
-    }
-
-    function createBucketReferrerFramebuffer(gl, size) {
-        const framebuffer = gl.createFramebuffer();
-        gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-        const bucketReferrerTexture = createTexture(
-            gl,
-            size,
-            gl.RG32UI,
-            gl.RG_INTEGER,
-            gl.UNSIGNED_INT
-        );
-        gl.bindTexture(gl.TEXTURE_2D, bucketReferrerTexture);
-        gl.framebufferTexture2D(
-            gl.FRAMEBUFFER,
-            gl.COLOR_ATTACHMENT0,
-            gl.TEXTURE_2D,
-            bucketReferrerTexture,
-            0
-        );
-        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        gl.bindTexture(gl.TEXTURE_2D, null);
-        return {
-            framebuffer: framebuffer,
-            bucketReferrerTexture: bucketReferrerTexture
-        };
-    }
-
-    const canvas = document.getElementById("canvas");
-    const resizeCanvas = function() {
-        canvas.width = window.innerWidth;
-        canvas.height = window.innerHeight;
-    };
-    window.addEventListener("resize", resizeCanvas);
-    resizeCanvas();
-
-    const gl = canvas.getContext("webgl2");
-    gl.getExtension("EXT_color_buffer_float");
-
-    const initializeBoidProgram = createInitializeBoidProgram(gl);
-    const updateBoidProgram = createUpdateBoidProgram(gl);
-    const computeForceProgram = createComputeForceProgram(gl);
-    const renderBoidProgram = createRenderBoidProgram(gl);
-    const initializeBucketProgram = createInitializeBucketProgram(gl);
-    const swapBucketIndexProgram = createSwapBucketIndexProgram(gl);
-    const initializeBucketReferrerProgram = createInitializeBucketReferrerProgram(
-        gl
-    );
-
-    const initializeBoidUniforms = getUniformLocations(
-        gl,
-        initializeBoidProgram,
-        [
-            "u_randomSeed",
-            "u_boidNum",
-            "u_boidTextureSize",
-            "u_maxSpeed",
-            "u_simulationSpace"
-        ]
-    );
-    const updateBoidUniforms = getUniformLocations(gl, updateBoidProgram, [
-        "u_positionTexture",
-        "u_velocityTexture",
-        "u_forceTexture",
-        "u_deltaTime",
-        "u_boidNum",
-        "u_boidTextureSize",
-        "u_maxSpeed",
-        "u_simulationSpace"
-    ]);
-    const computeForceUniforms = getUniformLocations(gl, computeForceProgram, [
-        "u_positionTexture",
-        "u_velocityTexture",
-        "u_bucketTexture",
-        "u_bucketReferrerTexture",
-        "u_boidNum",
-        "u_radius",
-        "u_weight",
-        "u_maxSpeed",
-        "u_maxForce",
-        "u_boundaryIntensity",
-        "u_bucketSize",
-        "u_bucketNum",
-        "u_simulationSpace"
-    ]);
-    const renderBoidUniforms = getUniformLocations(gl, renderBoidProgram, [
-        "u_positionTexture",
-        "u_velocityTexture",
-        "u_canvasSize",
-        "u_simulationSpace",
-        "u_boidSize"
-    ]);
-    const initializeBucketUniforms = getUniformLocations(
-        gl,
-        initializeBucketProgram,
-        ["u_positionTexture", "u_bucketSize", "u_boidNum", "u_bucketNum"]
-    );
-    const swapBucketIndexUniforms = getUniformLocations(
-        gl,
-        swapBucketIndexProgram,
-        ["u_bucketTexture", "u_size", "u_blockStep", "u_subBlockStep"]
-    );
-    const initializeBucketReferrerUniforms = getUniformLocations(
-        gl,
-        initializeBucketReferrerProgram,
-        [
-            "u_bucketTexture",
-            "u_bucketReferrerTextureSize",
-            "u_boidNumN",
-            "u_bucketNum"
-        ]
-    );
-
-    const fillScreenVao = createVao(
-        gl,
-        [{ buffer: createVbo(gl, VERTICES_POSITION), size: 2, index: 0 }],
-        createIbo(gl, VERTICES_INDEX)
-    );
-
-    const MAX_BOID_NUM = 4294967295; // = 2^32 - 1
-    const MAX_BUCKET_NUM = 4294967295; // = 2^32 - 1
-
-    const parameters = {
-        dynamic: {
-            "separation weight": 1.5,
-            "alignment weight": 1.0,
-            "cohesion weight": 1.0,
-            "max speed": 0.05,
-            "max force": 0.1,
-            "boundary intensity": 10.0,
-            "boid size": 12.0
-        },
-        static: {
-            "boid num": 8192,
-            "separation radius": 0.02,
-            "alignment radius": 0.04,
-            "cohesion radius": 0.03
-        },
-        reset: () => reset()
-    };
-
-    let requestId = null;
-    function reset() {
-        if (requestId !== null) {
-            cancelAnimationFrame(requestId);
-        }
-
-        const boidNum = parameters.static["boid num"];
-        if (boidNum > MAX_BOID_NUM) {
-            throw new Error(
-                `number of boids must be less than ${MAX_BOID_NUM}. current value is ${boidNum}.`
-            );
-        }
-        let boidTextureSize;
-        let boidNumN;
-        for (let i = 0; ; i++) {
-            boidTextureSize = 2 ** i;
-            if (boidTextureSize * boidTextureSize > boidNum) {
-                boidNumN = i * 2;
-                break;
-            }
-        }
-
-        const separationRadius = parameters.static["separation radius"];
-        const alignmentRadius = parameters.static["alignment radius"];
-        const cohesionRadius = parameters.static["cohesion radius"];
-        const neighborRadius = Math.max(
-            separationRadius,
-            alignmentRadius,
-            cohesionRadius
-        );
-        const bucketSize = 2.0 * neighborRadius;
-        const simulationSpace = new Vector2(1.6, 1.2);
-        const bucketNum = Vector2.div(simulationSpace, bucketSize)
-            .ceil()
-            .add(new Vector2(1, 1));
-        const totalBuckets = bucketNum.x * bucketNum.y;
-        if (totalBuckets > MAX_BUCKET_NUM) {
-            throw new Error(
-                `number of buckets must be less than ${MAX_BUCKET_NUM}. current value is ${totalBuckets}.`
-            );
-        }
-        let bucketReferrerTextureSize;
-        for (let i = 0; ; i++) {
-            bucketReferrerTextureSize = 2 ** i;
-            if (
-                bucketReferrerTextureSize * bucketReferrerTextureSize >
-                totalBuckets
-            ) {
-                break;
-            }
-        }
-
-        let boidFbObjR = createBoidFramebuffer(gl, boidTextureSize);
-        let boidFbObjW = createBoidFramebuffer(gl, boidTextureSize);
-        const swapBoidFbObj = function() {
-            const tmp = boidFbObjR;
-            boidFbObjR = boidFbObjW;
-            boidFbObjW = tmp;
-        };
-        let forceFbObj = createForceFramebuffer(gl, boidTextureSize);
-        let bucketFbObjR = createBucketFramebuffer(gl, boidTextureSize);
-        let bucketFbObjW = createBucketFramebuffer(gl, boidTextureSize);
-        const swapBucketFbObj = function() {
-            const tmp = bucketFbObjR;
-            bucketFbObjR = bucketFbObjW;
-            bucketFbObjW = tmp;
-        };
-        const bucketReferrerFbObj = createBucketReferrerFramebuffer(
-            gl,
-            bucketReferrerTextureSize
-        );
-
-        const initializeBoids = function() {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, boidFbObjW.framebuffer);
-            gl.viewport(0.0, 0.0, boidTextureSize, boidTextureSize);
-            gl.useProgram(initializeBoidProgram);
-            gl.uniform2f(
-                initializeBoidUniforms["u_randomSeed"],
-                Math.random() * 1000.0,
-                Math.random() * 1000.0
-            );
-            gl.uniform1ui(initializeBoidUniforms["u_boidNum"], boidNum);
-            gl.uniform1ui(
-                initializeBoidUniforms["u_boidTextureSize"],
-                boidTextureSize
-            );
-            gl.uniform1f(
-                initializeBoidUniforms["u_maxSpeed"],
-                parameters.dynamic["max speed"]
-            );
-            gl.uniform2f(
-                initializeBoidUniforms["u_simulationSpace"],
-                simulationSpace.x,
-                simulationSpace.y
-            );
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapBoidFbObj();
-        };
-
-        const initializeBucket = function() {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, bucketFbObjW.framebuffer);
-            gl.viewport(0.0, 0.0, boidTextureSize, boidTextureSize);
-            gl.useProgram(initializeBucketProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                boidFbObjR.positionTexture,
-                initializeBucketUniforms["u_positionTexture"]
-            );
-            gl.uniform1f(initializeBucketUniforms["u_bucketSize"], bucketSize);
-            gl.uniform1ui(initializeBucketUniforms["u_boidNum"], boidNum);
-            gl.uniform2ui(
-                initializeBucketUniforms["u_bucketNum"],
-                bucketNum.x,
-                bucketNum.y
-            );
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapBucketFbObj();
-        };
-
-        const swapBucketIndex = function(i, j) {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, bucketFbObjW.framebuffer);
-            gl.viewport(0.0, 0.0, boidTextureSize, boidTextureSize);
-            gl.useProgram(swapBucketIndexProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                bucketFbObjR.bucketTexture,
-                swapBucketIndexUniforms["u_bucketTexture"]
-            );
-            gl.uniform1ui(
-                swapBucketIndexUniforms["u_size"],
-                boidTextureSize,
-                boidTextureSize
-            );
-            gl.uniform1ui(swapBucketIndexUniforms["u_blockStep"], i);
-            gl.uniform1ui(swapBucketIndexUniforms["u_subBlockStep"], j);
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapBucketFbObj();
-        };
-
-        const initializeBucketRefrrer = function() {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, bucketReferrerFbObj.framebuffer);
-            gl.viewport(
-                0.0,
-                0.0,
-                bucketReferrerTextureSize,
-                bucketReferrerTextureSize
-            );
-            gl.useProgram(initializeBucketReferrerProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                bucketFbObjR.bucketTexture,
-                initializeBucketReferrerUniforms["u_bucketTexture"]
-            );
-            gl.uniform1ui(
-                initializeBucketReferrerUniforms["u_boidNumN"],
-                boidNumN
-            );
-            gl.uniform2ui(
-                initializeBucketReferrerUniforms["u_bucketReferrerTextureSize"],
-                bucketReferrerTextureSize,
-                bucketReferrerTextureSize
-            );
-            gl.uniform2ui(
-                initializeBucketReferrerUniforms["u_bucketNum"],
-                bucketNum.x,
-                bucketNum.y
-            );
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        };
-
-        const constructBuckets = function() {
-            initializeBucket();
-            // sort by bitonic sort
-            for (let i = 0; i < boidNumN; i++) {
-                for (let j = 0; j <= i; j++) {
-                    swapBucketIndex(i, j);
-                }
-            }
-            initializeBucketRefrrer();
-        };
-
-        const computeForces = function() {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, forceFbObj.framebuffer);
-            gl.viewport(0.0, 0.0, boidTextureSize, boidTextureSize);
-            gl.useProgram(computeForceProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                boidFbObjR.positionTexture,
-                computeForceUniforms["u_positionTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                1,
-                boidFbObjR.velocityTexture,
-                computeForceUniforms["u_velocityTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                2,
-                bucketFbObjR.bucketTexture,
-                computeForceUniforms["u_bucketTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                3,
-                bucketReferrerFbObj.bucketReferrerTexture,
-                computeForceUniforms["u_bucketReferrerTexture"]
-            );
-            gl.uniform1ui(computeForceUniforms["u_boidNum"], boidNum);
-            gl.uniform1f(
-                computeForceUniforms["u_maxSpeed"],
-                parameters.dynamic["max speed"]
-            );
-            gl.uniform1f(
-                computeForceUniforms["u_maxForce"],
-                parameters.dynamic["max force"]
-            );
-            gl.uniform1f(
-                computeForceUniforms["u_boundaryIntensity"],
-                parameters.dynamic["boundary intensity"]
-            );
-            gl.uniform1f(computeForceUniforms["u_bucketSize"], bucketSize);
-            gl.uniform2i(
-                computeForceUniforms["u_bucketNum"],
-                bucketNum.x,
-                bucketNum.y
-            );
-            gl.uniform2f(
-                computeForceUniforms["u_simulationSpace"],
-                simulationSpace.x,
-                simulationSpace.y
-            );
-            gl.uniform3f(
-                computeForceUniforms["u_radius"],
-                separationRadius,
-                alignmentRadius,
-                cohesionRadius
-            );
-            gl.uniform3f(
-                computeForceUniforms["u_weight"],
-                parameters.dynamic["separation weight"],
-                parameters.dynamic["alignment weight"],
-                parameters.dynamic["cohesion weight"]
-            );
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        };
-
-        const updateBoids = function(deltaTime) {
-            gl.bindFramebuffer(gl.FRAMEBUFFER, boidFbObjW.framebuffer);
-            gl.viewport(0.0, 0.0, boidTextureSize, boidTextureSize);
-            gl.useProgram(updateBoidProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                boidFbObjR.positionTexture,
-                updateBoidUniforms["u_positionTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                1,
-                boidFbObjR.velocityTexture,
-                updateBoidUniforms["u_velocityTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                2,
-                forceFbObj.forceTexture,
-                updateBoidUniforms["u_forceTexture"]
-            );
-            gl.uniform1f(updateBoidUniforms["u_deltaTime"], deltaTime);
-            gl.uniform1ui(updateBoidUniforms["u_boidNum"], boidNum);
-            gl.uniform1ui(
-                updateBoidUniforms["u_boidTextureSize"],
-                boidTextureSize
-            );
-            gl.uniform1f(
-                updateBoidUniforms["u_maxSpeed"],
-                parameters.dynamic["max speed"]
-            );
-            gl.uniform2f(
-                updateBoidUniforms["u_simulationSpace"],
-                simulationSpace.x,
-                simulationSpace.y
-            );
-            gl.bindVertexArray(fillScreenVao);
-            gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
-            gl.bindVertexArray(null);
-            gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-            swapBoidFbObj();
-        };
-
-        const stepSimulation = function(deltaTime) {
-            constructBuckets();
-            computeForces();
-            updateBoids(deltaTime);
-        };
-
-        const renderBoids = function() {
-            gl.viewport(0.0, 0.0, canvas.width, canvas.height);
-            gl.clear(gl.COLOR_BUFFER_BIT);
-
-            gl.useProgram(renderBoidProgram);
-            setTextureAsUniform(
-                gl,
-                0,
-                boidFbObjR.positionTexture,
-                renderBoidUniforms["u_positionTexture"]
-            );
-            setTextureAsUniform(
-                gl,
-                1,
-                boidFbObjR.velocityTexture,
-                renderBoidUniforms["u_velocityTexture"]
-            );
-            gl.uniform2f(
-                renderBoidUniforms["u_canvasSize"],
-                canvas.width,
-                canvas.height
-            );
-            gl.uniform2f(
-                renderBoidUniforms["u_simulationSpace"],
-                simulationSpace.x,
-                simulationSpace.y
-            );
-            gl.uniform1f(
-                renderBoidUniforms["u_boidSize"],
-                parameters.dynamic["boid size"]
-            );
-
-            gl.drawArrays(gl.POINTS, 0, boidNum);
-        };
-
-        initializeBoids();
-
-        gl.clearColor(0.2, 0.2, 0.2, 1.0);
-        let previousTime = performance.now();
-        const render = function() {
-            const currentTime = performance.now();
-            const deltaTime = Math.min(
-                0.05,
-                (currentTime - previousTime) * 0.001
-            );
-            previousTime = currentTime;
-
-            stepSimulation(deltaTime);
-            renderBoids();
-
-            requestId = requestAnimationFrame(render);
-        };
-        render();
-    }
-    reset();
-})();