@fusion.dev/helix-graph 0.124.0 → 0.125.0

package/dist/three/three-driver.js

@@ -255,6 +255,42 @@ const framed = (geometry) => {
     geometry.setAttribute('frame', new BufferAttribute(frame, 4));
     return geometry;
 };
+const SMOOTH = { surface: 3, ways: 6 };
+const neighborsOf = (index, count) => {
+    const sets = Array.from({ length: count }, () => new Set());
+    for (let at = 0; at < index.count; at += 3) {
+        const a = index.getX(at);
+        const b = index.getX(at + 1);
+        const c = index.getX(at + 2);
+        sets[a]?.add(b).add(c);
+        sets[b]?.add(a).add(c);
+        sets[c]?.add(a).add(b);
+    }
+    return sets.map((set) => Int32Array.from(set));
+};
+const averaged = (values, neighbors, share) => {
+    const out = new Float32Array(values.length);
+    neighbors.forEach((around, at) => {
+        let x = 0;
+        let y = 0;
+        let z = 0;
+        for (const other of around) {
+            x += values[other * 3];
+            y += values[other * 3 + 1];
+            z += values[other * 3 + 2];
+        }
+        const many = around.length || 1;
+        for (const [axis, sum] of [
+            [0, x],
+            [1, y],
+            [2, z],
+        ]) {
+            const value = values[at * 3 + axis];
+            out[at * 3 + axis] = around.length ? value + share * (sum / many - value) : value;
+        }
+    });
+    return out;
+};
 const channels = (color) => {
     const [red = 128, green = 128, blue = 128] = color.match(/[\d.]+/g)?.map(Number) ?? [];
     return [red / 255, green / 255, blue / 255];
@@ -403,17 +439,31 @@ export const threeDriver = (container, options = {}) => {
             geometry.setIndex(new BufferAttribute(field.mesh.triangles, 1));
             geometry = mergeVertices(geometry);
             const place = geometry.getAttribute('position');
+            const count = place.count;
+            const neighbors = neighborsOf(geometry.getIndex(), count);
             const step = Math.max(field.width, field.height, field.depth) / 64;
-            for (let at = 0; at < place.count; at++) {
+            let way = new Float32Array(count * 3);
+            for (let at = 0; at < count; at++) {
                 const x = place.getX(at);
                 const y = place.getY(at);
                 const z = place.getZ(at);
-                const gx = field.distance(x + step, y, z) - field.distance(x - step, y, z);
-                const gy = field.distance(x, y + step, z) - field.distance(x, y - step, z);
-                const gz = field.distance(x, y, z + step) - field.distance(x, y, z - step);
-                const length = Math.hypot(gx, gy, gz) || 1;
-                place.setXYZ(at, x - (gx / length) * inset, y - (gy / length) * inset, z - (gz / length) * inset);
+                way[at * 3] = field.distance(x + step, y, z) - field.distance(x - step, y, z);
+                way[at * 3 + 1] = field.distance(x, y + step, z) - field.distance(x, y - step, z);
+                way[at * 3 + 2] = field.distance(x, y, z + step) - field.distance(x, y, z - step);
+            }
+            for (let pass = 0; pass < SMOOTH.ways; pass++) {
+                way = averaged(way, neighbors, 0.5);
+            }
+            for (let at = 0; at < count; at++) {
+                const length = Math.hypot(way[at * 3], way[at * 3 + 1], way[at * 3 + 2]) ||
+                    1;
+                place.setXYZ(at, place.getX(at) - (way[at * 3] / length) * inset, place.getY(at) - (way[at * 3 + 1] / length) * inset, place.getZ(at) - (way[at * 3 + 2] / length) * inset);
+            }
+            let corners = place.array;
+            for (let pass = 0; pass < SMOOTH.surface; pass++) {
+                corners = averaged(averaged(corners, neighbors, 0.5), neighbors, -0.53);
             }
+            place.array.set(corners);
         }
         else {
             const { corners, triangles } = surfaceOf(field, { at: -inset });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-graph",
   "description": "Connects the Helix Graph frame to a graph renderer: Sigma.js, cosmos.gl, three.js, or a driver of your own.",
-  "version": "0.124.0",
+  "version": "0.125.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -47,12 +47,12 @@
   },
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
-    "@fusion.dev/helix-core": "0.124.0"
+    "@fusion.dev/helix-core": "0.125.0"
   },
   "devDependencies": {
     "@cosmos.gl/graph": "^3.4.2",
-    "@fusion.dev/helix-headless": "0.124.0",
-    "@fusion.dev/helix-testing": "0.124.0",
+    "@fusion.dev/helix-headless": "0.125.0",
+    "@fusion.dev/helix-testing": "0.125.0",
     "@types/bun": "^1.3.0",
     "@types/three": "^0.186.0",
     "d3-force-3d": "^3.0.6",