@cosmos.gl/graph 2.6.2 → 2.7.0-beta.1

package/dist/modules/Clusters/index.d.ts

@@ -1,11 +1,8 @@
-import { default as regl } from 'regl';
+import { Framebuffer, RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class Clusters extends CoreModule {
-    centermassFbo: regl.Framebuffer2D | undefined;
+    centermassFbo: Framebuffer | undefined;
     clusterCount: number | undefined;
-    private clusterFbo;
-    private clusterPositionsFbo;
-    private clusterForceCoefficientFbo;
     private clearCentermassCommand;
     private calculateCentermassCommand;
     private applyForcesCommand;
@@ -15,8 +12,16 @@ export declare class Clusters extends CoreModule {
     private centermassTexture;
     private pointIndices;
     private clustersTextureSize;
+    private clearCentermassVertexCoordBuffer;
+    private applyForcesVertexCoordBuffer;
+    private previousPointsTextureSize;
+    private previousClustersTextureSize;
+    private previousClusterCount;
+    private calculateCentermassUniformStore;
+    private applyForcesUniformStore;
     create(): void;
     initPrograms(): void;
     calculateCentermass(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
 }

package/dist/modules/ForceCenter/index.d.ts

@@ -1,12 +1,19 @@
+import { RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class ForceCenter extends CoreModule {
+    private centermassTexture;
     private centermassFbo;
+    private pointIndices;
     private clearCentermassCommand;
     private calculateCentermassCommand;
     private runCommand;
-    private centermassTexture;
-    private pointIndices;
+    private clearVertexCoordBuffer;
+    private forceVertexCoordBuffer;
+    private calculateUniformStore;
+    private forceUniformStore;
+    private previousPointsTextureSize;
     create(): void;
     initPrograms(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
 }

package/dist/modules/ForceGravity/index.d.ts

@@ -1,6 +1,10 @@
+import { RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class ForceGravity extends CoreModule {
     private runCommand;
+    private vertexCoordBuffer;
+    private uniformStore;
     initPrograms(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
 }

package/dist/modules/ForceLink/index.d.ts

@@ -1,22 +1,25 @@
+import { RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare enum LinkDirection {
     OUTGOING = "outgoing",
     INCOMING = "incoming"
 }
 export declare class ForceLink extends CoreModule {
-    private linkFirstIndicesAndAmountFbo;
-    private indicesFbo;
-    private biasAndStrengthFbo;
-    private randomDistanceFbo;
     private linkFirstIndicesAndAmount;
     private indices;
     private maxPointDegree;
+    private previousMaxPointDegree;
+    private previousPointsTextureSize;
+    private previousLinksTextureSize;
     private runCommand;
+    private vertexCoordBuffer;
+    private uniformStore;
     private linkFirstIndicesAndAmountTexture;
     private indicesTexture;
     private biasAndStrengthTexture;
     private randomDistanceTexture;
     create(direction: LinkDirection): void;
     initPrograms(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
 }

package/dist/modules/ForceManyBody/index.d.ts

@@ -1,16 +1,25 @@
+import { RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class ForceManyBody extends CoreModule {
-    private randomValuesFbo;
-    private levelsFbos;
+    private randomValuesTexture;
+    private pointIndices;
+    private levels;
+    private levelTargets;
     private clearLevelsCommand;
-    private clearVelocityCommand;
     private calculateLevelsCommand;
     private forceCommand;
     private forceFromItsOwnCentermassCommand;
-    private quadtreeLevels;
-    private randomValuesTexture;
-    private pointIndices;
+    private clearLevelsVertexCoordBuffer;
+    private forceVertexCoordBuffer;
+    private calculateLevelsUniformStore;
+    private forceUniformStore;
+    private forceCenterUniformStore;
+    private previousPointsTextureSize;
+    private previousSpaceSize;
     create(): void;
     initPrograms(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
+    private drawLevels;
+    private drawForces;
 }

package/dist/modules/ForceMouse/index.d.ts

@@ -1,6 +1,10 @@
+import { RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class ForceMouse extends CoreModule {
     private runCommand;
+    private vertexCoordBuffer;
+    private uniformStore;
     initPrograms(): void;
-    run(): void;
+    run(renderPass?: RenderPass): void;
+    destroy(): void;
 }

package/dist/modules/Lines/index.d.ts

@@ -1,11 +1,12 @@
-import { default as regl } from 'regl';
+import { Framebuffer, RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class Lines extends CoreModule {
-    linkIndexFbo: regl.Framebuffer2D | undefined;
-    hoveredLineIndexFbo: regl.Framebuffer2D | undefined;
+    linkIndexFbo: Framebuffer | undefined;
+    hoveredLineIndexFbo: Framebuffer | undefined;
     private drawCurveCommand;
     private hoveredLineIndexCommand;
-    private pointsBuffer;
+    private pointABuffer;
+    private pointBBuffer;
     private colorBuffer;
     private widthBuffer;
     private arrowBuffer;
@@ -13,8 +14,13 @@ export declare class Lines extends CoreModule {
     private curveLineBuffer;
     private linkIndexBuffer;
     private quadBuffer;
+    private linkIndexTexture;
+    private hoveredLineIndexTexture;
+    private drawLineUniformStore;
+    private hoveredLineIndexUniformStore;
+    private previousScreenSize;
     initPrograms(): void;
-    draw(): void;
+    draw(renderPass: RenderPass): void;
     updateLinkIndexFbo(): void;
     updatePointsBuffer(): void;
     updateColor(): void;

package/dist/modules/Points/index.d.ts

@@ -1,26 +1,27 @@
-import { default as regl } from 'regl';
+import { Framebuffer, Texture, RenderPass } from '@luma.gl/core';
 import { CoreModule } from '../core-module';
 export declare class Points extends CoreModule {
-    currentPositionFbo: regl.Framebuffer2D | undefined;
-    previousPositionFbo: regl.Framebuffer2D | undefined;
-    velocityFbo: regl.Framebuffer2D | undefined;
-    selectedFbo: regl.Framebuffer2D | undefined;
-    hoveredFbo: regl.Framebuffer2D | undefined;
-    greyoutStatusFbo: regl.Framebuffer2D | undefined;
+    currentPositionFbo: Framebuffer | undefined;
+    previousPositionFbo: Framebuffer | undefined;
+    velocityFbo: Framebuffer | undefined;
+    selectedFbo: Framebuffer | undefined;
+    hoveredFbo: Framebuffer | undefined;
     scaleX: ((x: number) => number) | undefined;
     scaleY: ((y: number) => number) | undefined;
     shouldSkipRescale: boolean | undefined;
-    imageAtlasTexture: regl.Texture2D | undefined;
+    imageAtlasTexture: Texture | undefined;
     imageCount: number;
+    currentPositionTexture: Texture | undefined;
+    previousPositionTexture: Texture | undefined;
+    velocityTexture: Texture | undefined;
+    greyoutStatusTexture: Texture | undefined;
     private colorBuffer;
-    private sizeFbo;
     private sizeBuffer;
     private shapeBuffer;
     private imageIndicesBuffer;
     private imageSizesBuffer;
     private imageAtlasCoordsTexture;
     private imageAtlasCoordsTextureSize;
-    private trackedIndicesFbo;
     private trackedPositionsFbo;
     private sampledPointsFbo;
     private trackedPositions;
@@ -36,19 +37,33 @@ export declare class Points extends CoreModule {
     private clearSampledPointsFboCommand;
     private fillSampledPointsFboCommand;
     private trackPointsCommand;
+    private updatePositionVertexCoordBuffer;
+    private dragPointVertexCoordBuffer;
+    private findPointsOnAreaSelectionVertexCoordBuffer;
+    private findPointsOnPolygonSelectionVertexCoordBuffer;
+    private clearHoveredFboVertexCoordBuffer;
+    private clearSampledPointsFboVertexCoordBuffer;
+    private drawHighlightedVertexCoordBuffer;
+    private trackPointsVertexCoordBuffer;
     private trackedIndices;
     private selectedTexture;
-    private greyoutStatusTexture;
     private pinnedStatusTexture;
-    private pinnedStatusFbo;
     private sizeTexture;
     private trackedIndicesTexture;
     private polygonPathTexture;
-    private polygonPathFbo;
     private polygonPathLength;
     private drawPointIndices;
     private hoveredPointIndices;
     private sampledPointIndices;
+    private updatePositionUniformStore;
+    private dragPointUniformStore;
+    private drawUniformStore;
+    private findPointsOnAreaSelectionUniformStore;
+    private findPointsOnPolygonSelectionUniformStore;
+    private findHoveredPointUniformStore;
+    private fillSampledPointsUniformStore;
+    private drawHighlightedUniformStore;
+    private trackPointsUniformStore;
     updatePositions(): void;
     initPrograms(): void;
     updateColor(): void;
@@ -61,7 +76,7 @@ export declare class Points extends CoreModule {
     createAtlas(): void;
     updateSampledPointsGrid(): void;
     trackPoints(): void;
-    draw(): void;
+    draw(renderPass: RenderPass): void;
     updatePosition(): void;
     drag(): void;
     findPointsOnAreaSelection(): void;
@@ -84,6 +99,7 @@ export declare class Points extends CoreModule {
         positions: number[];
     };
     getTrackedPositionsArray(): number[];
+    destroy(): void;
     private swapFbo;
     private rescaleInitialNodePositions;
 }

package/dist/modules/Store/index.d.ts

@@ -15,6 +15,11 @@ export type Hovered = {
 type Focused = {
     index: number;
 };
+/**
+ * Type alias for a 4x4 matrix stored as a 16-element array in column-major order.
+ * Used for std140 uniform buffer layout compatibility.
+ */
+type Mat4Array = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
 export declare class Store {
     pointsTextureSize: number;
     linksTextureSize: number;
@@ -48,6 +53,94 @@ export declare class Store {
     private random;
     private _backgroundColor;
     get backgroundColor(): [number, number, number, number];
+    /**
+     * Gets the transformation matrix as a 4x4 matrix for std140 uniform buffer layout.
+     *
+     * This method converts the internal 3x3 transformation matrix (mat3) to a 4x4 matrix format
+     * required by WebGPU uniform buffers using the std140 layout standard.
+     *
+     * ## Matrix Storage Format
+     *
+     * Matrices are stored in **column-major order** (GLSL convention). The internal `transform`
+     * array is a 9-element array representing a 3x3 matrix:
+     *
+     * ```
+     * [m00, m10, m20, m01, m11, m21, m02, m12, m22]
+     * ```
+     *
+     * Which represents the matrix:
+     * ```
+     * [m00 m01 m02]
+     * [m10 m11 m12]
+     * [m20 m21 m22]
+     * ```
+     *
+     * ## Why This Conversion Is Needed
+     *
+     * The internal `transform` property stores a 3x3 matrix (9 elements) which is sufficient for
+     * 2D transformations (translation, rotation, scaling in x/y plane). However, when passing
+     * transformation matrices to GPU shaders via uniform buffers, we must comply with the std140
+     * layout standard.
+     *
+     * ### std140 Layout Requirements
+     *
+     * The std140 layout standard (used in both OpenGL and WebGPU) defines strict alignment rules:
+     *
+     * 1. **Matrix Alignment**: In std140, matrices are stored as arrays of column vectors
+     *    - `mat3` requires each column to be aligned to 16 bytes (vec4 alignment)
+     *    - This means `mat3` occupies 3 columns × 16 bytes = 48 bytes total
+     *    - `mat4` occupies 4 columns × 16 bytes = 64 bytes total
+     *
+     * 2. **Alignment Issues with mat3**:
+     *    - The 48-byte size of `mat3` creates awkward alignment and padding requirements
+     *    - Different GPU drivers may handle `mat3` padding inconsistently
+     *    - This can lead to data misalignment and incorrect transformations
+     *
+     * 3. **Why mat4 is Preferred**:
+     *    - `mat4` has clean 64-byte alignment (power of 2)
+     *    - Consistent behavior across all GPU drivers and platforms
+     *    - The shader can easily extract the 3x3 portion: `mat3 transformMat3 = mat3(transformationMatrix)`
+     *    - The 4th column is set to `[0, 0, 0, 1]` (homogeneous coordinate) which doesn't affect 2D transforms
+     *
+     * ### Conversion Process
+     *
+     * The 3x3 matrix is converted to 4x4 by:
+     * - Placing the 3x3 values in the top-left corner (preserving column-major order)
+     * - Setting the 4th column to `[0, 0, 0, 1]` (homogeneous coordinate)
+     * - The 4th row is implicitly `[0, 0, 0, 1]` due to column-major storage
+     *
+     * This creates a valid 4x4 transformation matrix that:
+     * - Maintains the same 2D transformation behavior
+     * - Satisfies std140 alignment requirements
+     * - Works consistently across all GPU platforms
+     *
+     * ### Usage in Shaders
+     *
+     * Shaders using uniform buffers receive this as `mat4` and extract the 3x3 portion:
+     * ```glsl
+     * layout(std140) uniform uniforms {
+     *   mat4 transformationMatrix;
+     * } uniforms;
+     *
+     * mat3 transformMat3 = mat3(uniforms.transformationMatrix);
+     * vec3 final = transformMat3 * vec3(position, 1);
+     * ```
+     *
+     * @returns A 16-element array representing a 4x4 matrix in column-major order,
+     *          suitable for std140 uniform buffer layout. The matrix preserves the
+     *          2D transformation from the original 3x3 matrix.
+     *
+     * @example
+     * ```typescript
+     * const matrix = store.transformationMatrix4x4;
+     * uniformStore.setUniforms({
+     *   uniforms: {
+     *     transformationMatrix: matrix  // Expects mat4x4<f32> in shader
+     *   }
+     * });
+     * ```
+     */
+    get transformationMatrix4x4(): Mat4Array;
     set backgroundColor(color: [number, number, number, number]);
     addRandomSeed(seed: number | string): void;
     getRandomFloat(min: number, max: number): number;

package/dist/modules/core-module.d.ts

@@ -1,14 +1,14 @@
-import { default as regl } from 'regl';
+import { Device } from '@luma.gl/core';
 import { GraphConfigInterface } from '../config';
 import { GraphData } from './GraphData';
 import { Points } from './Points';
 import { Store } from './Store';
 export declare class CoreModule {
-    readonly reglInstance: regl.Regl;
+    readonly device: Device;
     readonly config: GraphConfigInterface;
     readonly store: Store;
     readonly data: GraphData;
     readonly points: Points | undefined;
     _debugRandomNumber: number;
-    constructor(reglInstance: regl.Regl, config: GraphConfigInterface, store: Store, data: GraphData, points?: Points);
+    constructor(device: Device, config: GraphConfigInterface, store: Store, data: GraphData, points?: Points);
 }