vortx-gl 1.0.2 → 1.0.27

package/dist/engine/shaders/edge.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const EDGE_VS = "#version 300 es\nlayout(location = 0) in vec2 a_position;\nlayout(location = 3) in vec2 a_targetPosition;\n\nuniform mat3 u_matrix;\nuniform float u_transitionProgress;\n\nvoid main() {\n    vec2 pos = mix(a_position, a_targetPosition, u_transitionProgress);\n    vec3 position = u_matrix * vec3(pos, 1.0);\n    gl_Position = vec4(position.xy, 0, 1);\n}\n";
+export declare const EDGE_FS = "#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nout vec4 outColor;\n\nvoid main() {\n    outColor = u_color;\n}\n";

package/dist/engine/shaders/node.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const NODE_VS = "#version 300 es\nlayout(location = 0) in vec2 a_position;\nlayout(location = 1) in vec4 a_color;\nlayout(location = 2) in float a_id;\nlayout(location = 3) in vec2 a_targetPosition;\nlayout(location = 4) in float a_shape;\n// Per-node size multiplier. 1.0 = base size, 2.0 = 2x bigger, etc.\n// Sourced from (input.size || input.width || 50) / 50 at ingest.\nlayout(location = 5) in float a_size;\n\nuniform mat3 u_matrix;\nuniform float u_pointSize;\n// GPU's ALIASED_POINT_SIZE_RANGE upper bound, set once at init by the\n// renderer. Clamped here so a node with size > 1 never exceeds the GPU\n// limit and silently mismatches the overlay's idea of where the sprite\n// edge is. Overlay reads the same clamp via getMaxNodePointSize().\nuniform float u_pointSizeMax;\nuniform bool u_pickingMode;\nuniform float u_transitionProgress;\n\nout vec4 v_color;\nflat out uint v_id;\nflat out int v_shape;\n\nvoid main() {\n    // Interpolate between current and target position on GPU\n    vec2 pos = mix(a_position, a_targetPosition, u_transitionProgress);\n    vec3 position = u_matrix * vec3(pos, 1.0);\n    gl_Position = vec4(position.xy, 0, 1);\n    gl_PointSize = min(u_pointSize * a_size, u_pointSizeMax);\n\n    // Visible nodes are forced opaque so edges (drawn before) never leak\n    // through the node body. Hidden nodes (alpha < 0.001) still vanish via\n    // the discard branch in the fragment shader.\n    float alpha = a_color.a < 0.001 ? 0.0 : 1.0;\n    v_color = vec4(a_color.rgb, alpha);\n    v_id = uint(a_id);\n    v_shape = int(a_shape);\n}\n";
+export declare const NODE_FS = "#version 300 es\nprecision highp float;\n\nin vec4 v_color;\nflat in uint v_id;\nflat in int v_shape;\n\nuniform bool u_pickingMode;\nout vec4 outColor;\n\nvoid main() {\n    vec2 p = gl_PointCoord - vec2(0.5);\n\n    // Every shape fills the full pointSize sprite (extent 0.5 from center)\n    // so edges + overlay decorations, which assume node radius == pointSize/2,\n    // actually reach the visible node border.\n    if (v_shape == 0) { // Circle\n        if (length(p) > 0.5) discard;\n    } else if (v_shape == 1) { // Square\n        if (abs(p.x) > 0.5 || abs(p.y) > 0.5) discard;\n    } else if (v_shape == 2) { // Triangle\n        if (p.y > 0.5 || p.y < -0.5 || abs(p.x) > (0.5 - (p.y + 0.5) * 0.5)) discard;\n    } else if (v_shape == 3) { // Diamond\n        if (abs(p.x) + abs(p.y) > 0.5) discard;\n    } else if (v_shape == 4) { // Round Rectangle\n        // Inner half-extent 0.4 + corner radius 0.1 \u2192 reaches 0.5 at edges.\n        float dist = length(max(abs(p) - 0.4, 0.0));\n        if (dist > 0.1) discard;\n    } else if (v_shape == 5) { // Cut Rectangle\n        if (abs(p.x) > 0.5 || abs(p.y) > 0.5 || abs(p.x) + abs(p.y) > 0.85) discard;\n    }\n\n    // Hidden nodes (alpha == 0): skip rendering AND picking.\n    if (v_color.a < 0.001) discard;\n\n    if (u_pickingMode) {\n        uint id = v_id + 1u;\n        float r = float((id >> 16) & 0xFFu) / 255.0;\n        float g = float((id >> 8) & 0xFFu) / 255.0;\n        float b = float(id & 0xFFu) / 255.0;\n        outColor = vec4(r, g, b, 1.0);\n    } else {\n        outColor = v_color;\n    }\n}\n";

package/dist/engine/shaders.d.ts

@@ -0,0 +1,2 @@
+export { NODE_VS, NODE_FS } from './shaders/node.glsl';
+export { EDGE_VS, EDGE_FS } from './shaders/edge.glsl';

package/dist/engine/spatialIndex.d.ts

@@ -0,0 +1,32 @@
+export declare class SpatialIndex {
+    private cellSize;
+    private cells;
+    private nodeCell;
+    ready: boolean;
+    /**
+     * Full rebuild from a position buffer. O(N). Sets `ready = true` on success.
+     * - `positions` is the same `[x0,y0,x1,y1,...]` Float32Array the engine owns.
+     * - `count` is the live node count (positions may be over-allocated).
+     * - Cells auto-size so each one holds ~1 node on average. Floor of `1` keeps
+     *   degenerate (all-at-origin) inputs from producing NaN cell sizes.
+     */
+    rebuild(positions: Float32Array, count: number): void;
+    /**
+     * Incremental move for a single node — keeps the index coherent during
+     * drag. O(1) amortised: only touches the cell entry for this node when
+     * it crosses a cell boundary.
+     */
+    update(id: number, x: number, y: number): void;
+    /** Remove a node from the index (e.g. after removeNode). No-op if not present. */
+    remove(id: number): void;
+    /**
+     * Visit every node whose cell overlaps the world bbox `[minX..maxX] ×
+     * [minY..maxY]`. The visitor sees a superset of the bbox-intersecting
+     * nodes — the caller is expected to do precise containment checks
+     * (which it already does to write `projectedCache`).
+     *
+     * Yields no allocations beyond what the visitor itself does.
+     */
+    forEachInBbox(minX: number, maxX: number, minY: number, maxY: number, visit: (id: number) => void): void;
+    clear(): void;
+}