@cosmos.gl/graph 2.5.0 → 2.6.1

package/src/modules/ForceManyBodyQuadtree/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/ForceManyBodyQuadtree/index.ts

@@ -1,157 +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/quadtree-frag-shader'
-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 ForceManyBodyQuadtree extends CoreModule {
-  private randomValuesFbo: regl.Framebuffer2D | undefined
-  private levelsTextures = new Map<string, regl.Texture2D>()
-  private levelsFbos = new Map<string, regl.Framebuffer2D>()
-  private clearLevelsCommand: regl.DrawCommand | undefined
-  private calculateLevelsCommand: regl.DrawCommand | undefined
-  private quadtreeCommand: 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)
-      const levelKey = `level[${i}]`
-      if (!this.levelsTextures.has(levelKey)) {
-        this.levelsTextures.set(levelKey, reglInstance.texture())
-      }
-      const texture = this.levelsTextures.get(levelKey)
-      if (texture) {
-        texture({
-          data: new Float32Array(levelTextureSize * levelTextureSize * 4),
-          shape: [levelTextureSize, levelTextureSize, 4],
-          type: 'float',
-        })
-      }
-      if (!this.levelsFbos.has(levelKey)) {
-        this.levelsFbos.set(levelKey, reglInstance.framebuffer())
-      }
-      const fbo = this.levelsFbos.get(levelKey)
-      if (fbo) {
-        fbo({
-          color: this.levelsTextures.get(levelKey),
-          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 },
-      })
-    }
-
-    this.quadtreeCommand = reglInstance({
-      frag: forceFrag(config.simulationRepulsionQuadtreeLevels ?? this.quadtreeLevels, this.quadtreeLevels),
-      vert: updateVert,
-      framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-      primitive: 'triangle strip',
-      count: 4,
-      attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-      uniforms: {
-        positionsTexture: () => points?.previousPositionFbo,
-        randomValues: () => this.randomValuesFbo,
-        spaceSize: () => store.adjustedSpaceSize,
-        repulsion: () => config.simulationRepulsion,
-        theta: () => config.simulationRepulsionTheta,
-        alpha: () => store.alpha,
-        ...Object.fromEntries(this.levelsFbos),
-      },
-    })
-  }
-
-  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.quadtreeCommand?.()
-  }
-}

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

@@ -1,93 +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.
-**/
-export function forceFrag (startLevel: number, maxLevels: number): string {
-  startLevel = Math.min(startLevel, maxLevels)
-  const delta = maxLevels - startLevel
-  const calculateVelocityAdjustment = `
-    float dist = sqrt(l);
-    if (dist > 0.0) {
-      float c = alpha * repulsion * centermass.b;
-      addVelocity += calculateAdditionalVelocity(vec2(x, y), l, c);
-      addVelocity += addVelocity * random.rg;
-    }
-  `
-  function quad (level: number): string {
-    if (level >= maxLevels) {
-      return calculateVelocityAdjustment
-    } 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) {
-            ${calculateVelocityAdjustment}
-          } 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 calculateAdditionalVelocity(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/ForceMouse/force-mouse.frag

@@ -1,24 +0,0 @@
-#ifdef GL_ES
-precision highp float;
-#endif
-
-uniform sampler2D positionsTexture;
-uniform float repulsion;
-uniform vec2 mousePos;
-
-varying vec2 textureCoords;
-
-void main() {  
-  vec4 pointPosition = texture2D(positionsTexture, textureCoords);
-  vec4 velocity = vec4(0.0);
-  vec2 mouse = mousePos;
-  // Move particles away from the mouse position using a repulsive force
-  vec2 distVector = mouse - pointPosition.rg;
-  float dist = sqrt(dot(distVector, distVector));
-  dist = max(dist, 10.0);
-  float angle = atan(distVector.y, distVector.x);
-  float addV = 100.0 * repulsion / (dist * dist);
-  velocity.rg -= addV * vec2(cos(angle), sin(angle));
-
-  gl_FragColor = velocity;
-}

package/src/modules/ForceMouse/index.ts

@@ -1,32 +0,0 @@
-import regl from 'regl'
-import { CoreModule } from '@/graph/modules/core-module'
-import forceFrag from '@/graph/modules/ForceMouse/force-mouse.frag'
-import { createQuadBuffer } from '@/graph/modules/Shared/buffer'
-import updateVert from '@/graph/modules/Shared/quad.vert'
-
-export class ForceMouse extends CoreModule {
-  private runCommand: regl.DrawCommand | undefined
-
-  public initPrograms (): void {
-    const { reglInstance, config, store, points } = this
-    if (!this.runCommand) {
-      this.runCommand = reglInstance({
-        frag: forceFrag,
-        vert: updateVert,
-        framebuffer: () => points?.velocityFbo as regl.Framebuffer2D,
-        primitive: 'triangle strip',
-        count: 4,
-        attributes: { vertexCoord: createQuadBuffer(reglInstance) },
-        uniforms: {
-          positionsTexture: () => points?.previousPositionFbo,
-          mousePos: () => store.mousePosition,
-          repulsion: () => config.simulationRepulsionFromMouse,
-        },
-      })
-    }
-  }
-
-  public run (): void {
-    this.runCommand?.()
-  }
-}