@cosmos.gl/graph 2.6.0 → 2.6.2-rc.0

package/src/modules/ForceLink/index.ts

@@ -1,149 +0,0 @@
-import regl from 'regl'
-import { CoreModule } from '@/graph/modules/core-module'
-import { forceFrag } from '@/graph/modules/ForceLink/force-spring'
-import { createQuadBuffer } from '@/graph/modules/Shared/buffer'
-import updateVert from '@/graph/modules/Shared/quad.vert'
-
-export enum LinkDirection {
-  OUTGOING = 'outgoing',
-  INCOMING = 'incoming'
-}
-
-export class ForceLink extends CoreModule {
-  private linkFirstIndicesAndAmountFbo: regl.Framebuffer2D | undefined
-  private indicesFbo: regl.Framebuffer2D | undefined
-  private biasAndStrengthFbo: regl.Framebuffer2D | undefined
-  private randomDistanceFbo: regl.Framebuffer2D | undefined
-  private linkFirstIndicesAndAmount: Float32Array = new Float32Array()
-  private indices: Float32Array = new Float32Array()
-  private maxPointDegree = 0
-  private runCommand: regl.DrawCommand | undefined
-  private linkFirstIndicesAndAmountTexture: regl.Texture2D | undefined
-  private indicesTexture: regl.Texture2D | undefined
-  private biasAndStrengthTexture: regl.Texture2D | undefined
-  private randomDistanceTexture: regl.Texture2D | undefined
-
-  public create (direction: LinkDirection): void {
-    const { reglInstance, store: { pointsTextureSize, linksTextureSize }, data } = this
-    if (!pointsTextureSize || !linksTextureSize) return
-    this.linkFirstIndicesAndAmount = new Float32Array(pointsTextureSize * pointsTextureSize * 4)
-    this.indices = new Float32Array(linksTextureSize * linksTextureSize * 4)
-    const linkBiasAndStrengthState = new Float32Array(linksTextureSize * linksTextureSize * 4)
-    const linkDistanceState = new Float32Array(linksTextureSize * linksTextureSize * 4)
-
-    const grouped = direction === LinkDirection.INCOMING ? data.sourceIndexToTargetIndices : data.targetIndexToSourceIndices
-    this.maxPointDegree = 0
-    let linkIndex = 0
-    grouped?.forEach((connectedPointIndices, pointIndex) => {
-      if (connectedPointIndices) {
-        this.linkFirstIndicesAndAmount[pointIndex * 4 + 0] = linkIndex % linksTextureSize
-        this.linkFirstIndicesAndAmount[pointIndex * 4 + 1] = Math.floor(linkIndex / linksTextureSize)
-        this.linkFirstIndicesAndAmount[pointIndex * 4 + 2] = connectedPointIndices.length ?? 0
-
-        connectedPointIndices.forEach(([connectedPointIndex, initialLinkIndex]) => {
-          this.indices[linkIndex * 4 + 0] = connectedPointIndex % pointsTextureSize
-          this.indices[linkIndex * 4 + 1] = Math.floor(connectedPointIndex / pointsTextureSize)
-          const degree = data.degree?.[connectedPointIndex] ?? 0
-          const connectedDegree = data.degree?.[pointIndex] ?? 0
-          const degreeSum = degree + connectedDegree
-          // Prevent division by zero
-          const bias = degreeSum !== 0 ? degree / degreeSum : 0.5
-          const minDegree = Math.min(degree, connectedDegree)
-          // Prevent division by zero
-          let strength = data.linkStrength?.[initialLinkIndex] ?? (1 / Math.max(minDegree, 1))
-          strength = Math.sqrt(strength)
-          linkBiasAndStrengthState[linkIndex * 4 + 0] = bias
-          linkBiasAndStrengthState[linkIndex * 4 + 1] = strength
-          linkDistanceState[linkIndex * 4] = this.store.getRandomFloat(0, 1)
-
-          linkIndex += 1
-        })
-
-        this.maxPointDegree = Math.max(this.maxPointDegree, connectedPointIndices.length ?? 0)
-      }
-    })
-
-    if (!this.linkFirstIndicesAndAmountTexture) this.linkFirstIndicesAndAmountTexture = reglInstance.texture()
-    this.linkFirstIndicesAndAmountTexture({
-      data: this.linkFirstIndicesAndAmount,
-      shape: [pointsTextureSize, pointsTextureSize, 4],
-      type: 'float',
-    })
-    if (!this.linkFirstIndicesAndAmountFbo) this.linkFirstIndicesAndAmountFbo = reglInstance.framebuffer()
-    this.linkFirstIndicesAndAmountFbo({
-      color: this.linkFirstIndicesAndAmountTexture,
-      depth: false,
-      stencil: false,
-    })
-
-    if (!this.indicesTexture) this.indicesTexture = reglInstance.texture()
-    this.indicesTexture({
-      data: this.indices,
-      shape: [linksTextureSize, linksTextureSize, 4],
-      type: 'float',
-    })
-    if (!this.indicesFbo) this.indicesFbo = reglInstance.framebuffer()
-    this.indicesFbo({
-      color: this.indicesTexture,
-      depth: false,
-      stencil: false,
-    })
-
-    if (!this.biasAndStrengthTexture) this.biasAndStrengthTexture = reglInstance.texture()
-    this.biasAndStrengthTexture({
-      data: linkBiasAndStrengthState,
-      shape: [linksTextureSize, linksTextureSize, 4],
-      type: 'float',
-    })
-    if (!this.biasAndStrengthFbo) this.biasAndStrengthFbo = reglInstance.framebuffer()
-    this.biasAndStrengthFbo({
-      color: this.biasAndStrengthTexture,
-      depth: false,
-      stencil: false,
-    })
-
-    if (!this.randomDistanceTexture) this.randomDistanceTexture = reglInstance.texture()
-    this.randomDistanceTexture({
-      data: linkDistanceState,
-      shape: [linksTextureSize, linksTextureSize, 4],
-      type: 'float',
-    })
-    if (!this.randomDistanceFbo) this.randomDistanceFbo = reglInstance.framebuffer()
-    this.randomDistanceFbo({
-      color: this.randomDistanceTexture,
-      depth: false,
-      stencil: false,
-    })
-  }
-
-  public initPrograms (): void {
-    const { reglInstance, config, store, points } = this
-    if (!this.runCommand) {
-      this.runCommand = reglInstance({
-        frag: () => forceFrag(this.maxPointDegree),
-        vert: updateVert,
-        framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-        uniforms: {
-          positionsTexture: () => points?.previousPositionFbo,
-          linkSpring: () => config.simulationLinkSpring,
-          linkDistance: () => config.simulationLinkDistance,
-          linkDistRandomVariationRange: () => config.simulationLinkDistRandomVariationRange,
-          linkInfoTexture: () => this.linkFirstIndicesAndAmountFbo,
-          linkIndicesTexture: () => this.indicesFbo,
-          linkPropertiesTexture: () => this.biasAndStrengthFbo,
-          linkRandomDistanceTexture: () => this.randomDistanceFbo,
-          pointsTextureSize: () => store.pointsTextureSize,
-          linksTextureSize: () => store.linksTextureSize,
-          alpha: () => store.alpha,
-        },
-      })
-    }
-  }
-
-  public run (): void {
-    this.runCommand?.()
-  }
-}

package/src/modules/ForceManyBody/calculate-level.frag

@@ -1,9 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-varying vec4 rgba;
-
-void main() {
-  gl_FragColor = rgba;
-}

package/src/modules/ForceManyBody/calculate-level.vert

@@ -1,25 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform float pointsTextureSize;
-uniform float levelTextureSize;
-uniform float cellSize;
-
-attribute vec2 pointIndices;
-
-varying vec4 rgba;
-
-void main() {
-  vec4 pointPosition = texture2D(positionsTexture, pointIndices / pointsTextureSize);
-  rgba = vec4(pointPosition.rg, 1.0, 0.0);
-
-  float n = floor(pointPosition.x / cellSize);
-  float m = floor(pointPosition.y / cellSize);
-  
-  vec2 levelPosition = 2.0 * (vec2(n, m) + 0.5) / levelTextureSize - 1.0;
-
-  gl_Position = vec4(levelPosition, 0.0, 1.0);
-  gl_PointSize = 1.0;
-}

package/src/modules/ForceManyBody/force-centermass.frag

@@ -1,52 +0,0 @@
-// The fragment shader calculates the velocity of a point based on its position,
-// the positions of other points in a spatial hierarchy, and random factors.
-
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform sampler2D levelFbo;
-uniform sampler2D randomValues;
-
-uniform float levelTextureSize;
-uniform float repulsion;
-uniform float alpha;
-
-varying vec2 textureCoords;
-
-// Calculate the additional velocity based on the center of mass
-vec2 calculateAdditionalVelocity (vec2 ij, vec2 pp) {
-  vec2 add = vec2(0.0);
-  vec4 centermass = texture2D(levelFbo, ij);
-  if (centermass.r > 0.0 && centermass.g > 0.0 && centermass.b > 0.0) {
-    vec2 centermassPosition = vec2(centermass.rg / centermass.b);
-    vec2 distVector = pp - centermassPosition;
-    float l = dot(distVector, distVector);
-    float dist = sqrt(l);
-    if (l > 0.0) {
-      float angle = atan(distVector.y, distVector.x);
-      float c = alpha * repulsion * centermass.b;
-
-      float distanceMin2 = 1.0;
-      if (l < distanceMin2) l = sqrt(distanceMin2 * l);
-      float addV = c / sqrt(l);
-      add = addV * vec2(cos(angle), sin(angle));
-    }
-  }
-  return add;
-}
-
-void main() {
-  vec4 pointPosition = texture2D(positionsTexture, textureCoords);
-  vec4 random = texture2D(randomValues, textureCoords);
-
-  vec4 velocity = vec4(0.0);
-
-  // Calculate additional velocity based on the point position
-  velocity.xy += calculateAdditionalVelocity(pointPosition.xy / levelTextureSize, pointPosition.xy);
-  // Apply random factor to the velocity
-  velocity.xy += velocity.xy * random.rg;
-
-  gl_FragColor = velocity;
-}

package/src/modules/ForceManyBody/force-level.frag

@@ -1,121 +0,0 @@
-// The fragment shader calculates the velocity of a point based on its position
-// and the positions of other points in different levels of a spatial hierarchy.
-
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform sampler2D levelFbo;
-
-uniform float level;
-uniform float levels;
-uniform float levelTextureSize;
-uniform float repulsion;
-uniform float alpha;
-uniform float spaceSize;
-uniform float theta;
-
-varying vec2 textureCoords;
-
-const float MAX_LEVELS_NUM = 14.0;
-
-vec2 calculateAdditionalVelocity (vec2 ij, vec2 pp) {
-  vec2 add = vec2(0.0);
-  vec4 centermass = texture2D(levelFbo, ij);
-  if (centermass.r > 0.0 && centermass.g > 0.0 && centermass.b > 0.0) {
-    vec2 centermassPosition = vec2(centermass.rg / centermass.b);
-    vec2 distVector = pp - centermassPosition;
-    float l = dot(distVector, distVector);
-    float dist = sqrt(l);
-    if (l > 0.0) {
-      float c = alpha * repulsion * centermass.b;
-
-      float distanceMin2 = 1.0;
-      if (l < distanceMin2) l = sqrt(distanceMin2 * l);
-      float addV = c / sqrt(l);
-      add = addV * normalize(distVector);
-    }
-  }
-  return add;
-}
-
-void main() {
-  vec4 pointPosition = texture2D(positionsTexture, textureCoords);
-  float x = pointPosition.x;
-  float y = pointPosition.y;
-
-  float left = 0.0;
-  float top = 0.0;
-  float right = spaceSize;
-  float bottom = spaceSize;
-
-  float n_left = 0.0;
-  float n_top = 0.0;
-  float n_right = 0.0;
-  float n_bottom = 0.0;
-
-  float cellSize = 0.0;
-
-  // Iterate over levels to adjust the boundaries based on the current level
-  for (float i = 0.0; i < MAX_LEVELS_NUM; i += 1.0) {
-    if (i <= level) {
-      left += cellSize * n_left;
-      top += cellSize * n_top;
-      right -= cellSize * n_right;
-      bottom -= cellSize * n_bottom;
-
-      cellSize = pow(2.0 , levels - i - 1.0);
-
-      float dist_left = x - left;
-      n_left = max(0.0, floor(dist_left / cellSize - theta));
-
-      float dist_top = y - top;
-      n_top = max(0.0, floor(dist_top / cellSize - theta));
-      
-      float dist_right = right - x;
-      n_right = max(0.0, floor(dist_right / cellSize - theta));
-
-      float dist_bottom = bottom - y;
-      n_bottom = max(0.0, floor(dist_bottom / cellSize - theta));
-
-    }
-  }
-
-  vec4 velocity = vec4(vec2(0.0), 1.0, 0.0);
-
-  // Calculate the additional velocity based on neighboring cells
-  for (float i = 0.0; i < 12.0; i += 1.0) {
-    for (float j = 0.0; j < 4.0; j += 1.0) {
-      float n = left + cellSize * j;
-      float m = top + cellSize * n_top + cellSize * i;
-
-      if (n < (left + n_left * cellSize) && m < bottom) {
-        velocity.xy += calculateAdditionalVelocity(vec2(n / cellSize, m / cellSize) / levelTextureSize, pointPosition.xy);
-      }
-
-      n = left + cellSize * i;
-      m = top + cellSize * j;
-
-      if (n < (right - n_right * cellSize) && m < (top + n_top * cellSize)) {
-        velocity.xy += calculateAdditionalVelocity(vec2(n / cellSize, m / cellSize) / levelTextureSize, pointPosition.xy);
-      }
-
-      n = right - n_right * cellSize + cellSize * j;
-      m = top + cellSize * i;
-
-      if (n < right && m < (bottom - n_bottom * cellSize)) {
-        velocity.xy += calculateAdditionalVelocity(vec2(n / cellSize, m / cellSize) / levelTextureSize, pointPosition.xy);
-      }
-
-      n = left + n_left * cellSize + cellSize * i;
-      m = bottom - n_bottom * cellSize + cellSize * j;
-
-      if (n < right && m < bottom) {
-        velocity.xy += calculateAdditionalVelocity(vec2(n / cellSize, m / cellSize) / levelTextureSize, pointPosition.xy);
-      }
-    }
-  }
-
-  gl_FragColor = velocity;
-}

package/src/modules/ForceManyBody/index.ts

@@ -1,223 +0,0 @@
-import regl from 'regl'
-import { CoreModule } from '@/graph/modules/core-module'
-import calculateLevelFrag from '@/graph/modules/ForceManyBody/calculate-level.frag'
-import calculateLevelVert from '@/graph/modules/ForceManyBody/calculate-level.vert'
-import forceFrag from '@/graph/modules/ForceManyBody/force-level.frag'
-import forceCenterFrag from '@/graph/modules/ForceManyBody/force-centermass.frag'
-import { createIndexesForBuffer, createQuadBuffer } from '@/graph/modules/Shared/buffer'
-import clearFrag from '@/graph/modules/Shared/clear.frag'
-import updateVert from '@/graph/modules/Shared/quad.vert'
-
-export class ForceManyBody extends CoreModule {
-  private randomValuesFbo: regl.Framebuffer2D | undefined
-  private levelsFbos = new Map<string, regl.Framebuffer2D>()
-  private clearLevelsCommand: regl.DrawCommand | undefined
-  private clearVelocityCommand: regl.DrawCommand | undefined
-  private calculateLevelsCommand: regl.DrawCommand | undefined
-  private forceCommand: regl.DrawCommand | undefined
-  private forceFromItsOwnCentermassCommand: regl.DrawCommand | undefined
-  private quadtreeLevels = 0
-  private randomValuesTexture: regl.Texture2D | undefined
-  private pointIndices: regl.Buffer | undefined
-
-  public create (): void {
-    const { reglInstance, store } = this
-    if (!store.pointsTextureSize) return
-    this.quadtreeLevels = Math.log2(store.adjustedSpaceSize)
-    for (let i = 0; i < this.quadtreeLevels; i += 1) {
-      const levelTextureSize = Math.pow(2, i + 1)
-      if (!this.levelsFbos.has(`level[${i}]`)) {
-        this.levelsFbos.set(`level[${i}]`, reglInstance.framebuffer())
-      }
-      const fbo = this.levelsFbos.get(`level[${i}]`)
-      if (fbo) {
-        fbo({
-          shape: [levelTextureSize, levelTextureSize],
-          colorType: 'float',
-          depth: false,
-          stencil: false,
-        })
-      }
-    }
-    // Create random number to prevent point to stick together in one coordinate
-    const randomValuesState = new Float32Array(store.pointsTextureSize * store.pointsTextureSize * 4)
-    for (let i = 0; i < store.pointsTextureSize * store.pointsTextureSize; ++i) {
-      randomValuesState[i * 4] = store.getRandomFloat(-1, 1) * 0.00001
-      randomValuesState[i * 4 + 1] = store.getRandomFloat(-1, 1) * 0.00001
-    }
-
-    if (!this.randomValuesTexture) this.randomValuesTexture = reglInstance.texture()
-    this.randomValuesTexture({
-      data: randomValuesState,
-      shape: [store.pointsTextureSize, store.pointsTextureSize, 4],
-      type: 'float',
-    })
-    if (!this.randomValuesFbo) this.randomValuesFbo = reglInstance.framebuffer()
-    this.randomValuesFbo({
-      color: this.randomValuesTexture,
-      depth: false,
-      stencil: false,
-    })
-
-    if (!this.pointIndices) this.pointIndices = reglInstance.buffer(0)
-    this.pointIndices(createIndexesForBuffer(store.pointsTextureSize))
-  }
-
-  public initPrograms (): void {
-    const { reglInstance, config, store, data, points } = this
-    if (!this.clearLevelsCommand) {
-      this.clearLevelsCommand = reglInstance({
-        frag: clearFrag,
-        vert: updateVert,
-        framebuffer: (_: regl.DefaultContext, props: { levelFbo: regl.Framebuffer2D }) => props.levelFbo,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-      })
-    }
-    if (!this.calculateLevelsCommand) {
-      this.calculateLevelsCommand = reglInstance({
-        frag: calculateLevelFrag,
-        vert: calculateLevelVert,
-        framebuffer: (_: regl.DefaultContext, props: { levelFbo: regl.Framebuffer2D; levelTextureSize: number; cellSize: number }) => props.levelFbo,
-        primitive: 'points',
-        count: () => data.pointsNumber ?? 0,
-        attributes: {
-          pointIndices: {
-            buffer: this.pointIndices,
-            size: 2,
-          },
-        },
-        uniforms: {
-          positionsTexture: () => points?.previousPositionFbo,
-          pointsTextureSize: () => store.pointsTextureSize,
-          levelTextureSize: (_: regl.DefaultContext, props: { levelTextureSize: number }) => props.levelTextureSize,
-          cellSize: (_: regl.DefaultContext, props: { cellSize: number }) => props.cellSize,
-        },
-        blend: {
-          enable: true,
-          func: {
-            src: 'one',
-            dst: 'one',
-          },
-          equation: {
-            rgb: 'add',
-            alpha: 'add',
-          },
-        },
-        depth: { enable: false, mask: false },
-        stencil: { enable: false },
-      })
-    }
-
-    if (!this.forceCommand) {
-      this.forceCommand = reglInstance({
-        frag: forceFrag,
-        vert: updateVert,
-        framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-        uniforms: {
-          positionsTexture: () => points?.previousPositionFbo,
-          level: (_, props: { levelFbo: regl.Framebuffer2D; levelTextureSize: number; level: number }) => props.level,
-          levels: this.quadtreeLevels,
-          levelFbo: (_, props) => props.levelFbo,
-          levelTextureSize: (_, props) => props.levelTextureSize,
-          alpha: () => store.alpha,
-          repulsion: () => config.simulationRepulsion,
-          spaceSize: () => store.adjustedSpaceSize,
-          theta: () => config.simulationRepulsionTheta,
-        },
-        blend: {
-          enable: true,
-          func: {
-            src: 'one',
-            dst: 'one',
-          },
-          equation: {
-            rgb: 'add',
-            alpha: 'add',
-          },
-        },
-        depth: { enable: false, mask: false },
-        stencil: { enable: false },
-      })
-    }
-
-    if (!this.forceFromItsOwnCentermassCommand) {
-      this.forceFromItsOwnCentermassCommand = reglInstance({
-        frag: forceCenterFrag,
-        vert: updateVert,
-        framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-        uniforms: {
-          positionsTexture: () => points?.previousPositionFbo,
-          randomValues: () => this.randomValuesFbo,
-          levelFbo: (_, props: { levelFbo: regl.Framebuffer2D; levelTextureSize: number }) => props.levelFbo,
-          levelTextureSize: (_, props) => props.levelTextureSize,
-          alpha: () => store.alpha,
-          repulsion: () => config.simulationRepulsion,
-          spaceSize: () => store.adjustedSpaceSize,
-        },
-        blend: {
-          enable: true,
-          func: {
-            src: 'one',
-            dst: 'one',
-          },
-          equation: {
-            rgb: 'add',
-            alpha: 'add',
-          },
-        },
-        depth: { enable: false, mask: false },
-        stencil: { enable: false },
-      })
-    }
-
-    if (!this.clearVelocityCommand) {
-      this.clearVelocityCommand = reglInstance({
-        frag: clearFrag,
-        vert: updateVert,
-        framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-      })
-    }
-  }
-
-  public run (): void {
-    const { store } = this
-    for (let i = 0; i < this.quadtreeLevels; i += 1) {
-      this.clearLevelsCommand?.({ levelFbo: this.levelsFbos.get(`level[${i}]`) })
-      const levelTextureSize = Math.pow(2, i + 1)
-      const cellSize = store.adjustedSpaceSize / levelTextureSize
-      this.calculateLevelsCommand?.({
-        levelFbo: this.levelsFbos.get(`level[${i}]`),
-        levelTextureSize,
-        cellSize,
-      })
-    }
-    this.clearVelocityCommand?.()
-    for (let i = 0; i < this.quadtreeLevels; i += 1) {
-      const levelTextureSize = Math.pow(2, i + 1)
-      this.forceCommand?.({
-        levelFbo: this.levelsFbos.get(`level[${i}]`),
-        levelTextureSize,
-        level: i,
-      })
-
-      if (i === this.quadtreeLevels - 1) {
-        this.forceFromItsOwnCentermassCommand?.({
-          levelFbo: this.levelsFbos.get(`level[${i}]`),
-          levelTextureSize,
-          level: i,
-        })
-      }
-    }
-  }
-}

package/src/modules/ForceManyBody/quadtree-frag-shader.ts

@@ -1,90 +0,0 @@
-export function forceFrag (startLevel: number, maxLevels: number): string {
-  startLevel = Math.min(startLevel, maxLevels)
-  const delta = maxLevels - startLevel
-  const calcAdd = `
-    float dist = sqrt(l);
-    if (dist > 0.0) {
-      float c = alpha * repulsion * centermass.b;
-      addVelocity += calcAdd(vec2(x, y), l, c);
-      addVelocity += addVelocity * random.rg;
-    }
-  `
-  function quad (level: number): string {
-    if (level >= maxLevels) {
-      return calcAdd
-    } else {
-      const groupSize = Math.pow(2, level + 1)
-
-      const iEnding = new Array(level + 1 - delta).fill(0).map((_, l) => `pow(2.0, ${level - (l + delta)}.0) * i${l + delta}`).join('+')
-      const jEnding = new Array(level + 1 - delta).fill(0).map((_, l) => `pow(2.0, ${level - (l + delta)}.0) * j${l + delta}`).join('+')
-
-      return `
-      for (float ij${level} = 0.0; ij${level} < 4.0; ij${level} += 1.0) {
-        float i${level} = 0.0;
-        float j${level} = 0.0;
-        if (ij${level} == 1.0 || ij${level} == 3.0) i${level} = 1.0;
-        if (ij${level} == 2.0 || ij${level} == 3.0) j${level} = 1.0;
-        float i = pow(2.0, ${startLevel}.0) * n / width${level + 1} + ${iEnding};
-        float j = pow(2.0, ${startLevel}.0) * m / width${level + 1} + ${jEnding};
-        float groupPosX = (i + 0.5) / ${groupSize}.0;
-        float groupPosY = (j + 0.5) / ${groupSize}.0;
-        
-        vec4 centermass = texture2D(level[${level}], vec2(groupPosX, groupPosY));
-        if (centermass.r > 0.0 && centermass.g > 0.0 && centermass.b > 0.0) {
-          float x = centermass.r / centermass.b - pointPosition.r;
-          float y = centermass.g / centermass.b - pointPosition.g;
-          float l = x * x + y * y;
-          if ((width${level + 1} * width${level + 1}) / theta < l) {
-            ${calcAdd}
-          } else {
-            ${quad(level + 1)}
-          }
-        }
-      }
-      `
-    }
-  }
-  return `
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform sampler2D randomValues;
-uniform float spaceSize;
-uniform float repulsion;
-uniform float theta;
-uniform float alpha;
-uniform sampler2D level[${maxLevels}];
-varying vec2 textureCoords;
-
-vec2 calcAdd(vec2 xy, float l, float c) {
-  float distanceMin2 = 1.0;
-  if (l < distanceMin2) l = sqrt(distanceMin2 * l);
-  float add = c / l;
-  return add * xy;
-}
-
-void main() {
-  vec4 pointPosition = texture2D(positionsTexture, textureCoords);
-  vec4 random = texture2D(randomValues, textureCoords);
-
-  float width0 = spaceSize;
-
-  vec2 velocity = vec2(0.0);
-  vec2 addVelocity = vec2(0.0);
-
-  ${new Array(maxLevels).fill(0).map((_, i) => `float width${i + 1} = width${i} / 2.0;`).join('\n')}
-
-  for (float n = 0.0; n < pow(2.0, ${delta}.0); n += 1.0) {
-    for (float m = 0.0; m < pow(2.0, ${delta}.0); m += 1.0) {
-      ${quad(delta)}
-    }
-  }
-
-  velocity -= addVelocity;
-
-  gl_FragColor = vec4(velocity, 0.0, 0.0);
-}
-`
-}

package/src/modules/ForceManyBodyQuadtree/calculate-level.frag

@@ -1,9 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-varying vec4 rgba;
-
-void main() {
-  gl_FragColor = rgba;
-}