fix(ci): still trying to get gpg to work

Closes #34

.gitea/scripts/create-release.sh

@@ -75,18 +75,22 @@ pnpm exec dprint fmt CHANGELOG.md
 # -------------------------------------------------------------------
 # 5. Setup GPG signing
 # -------------------------------------------------------------------
-echo "$BOT_PGP_PRIVATE_KEY" | base64 -d | gpg --batch --import --
+echo "$BOT_PGP_PRIVATE_KEY" | base64 -d | gpg --batch --import
-GPG_KEY_ID=$(gpg --list-secret-keys --keyid-format LONG nodarium-bot@max-richter.dev 2>/dev/null | grep sec | head -n1 | sed 's/.*\///' | tr -d ' ')
+GPG_KEY_ID=$(gpg --list-secret-keys --keyid-format LONG | grep sec | awk '{print $2}' | cut -d'/' -f2)
+
+export GPG_TTY=$(tty)
+echo "allow-loopback-pinentry" >>~/.gnupg/gpg-agent.conf
+gpg-connect-agent reloadagent /bye
 
 git config user.name "nodarium-bot"
 git config user.email "nodarium-bot@max-richter.dev"
-git config user.signingkey "$GPG_KEY_ID"
+git config --global user.signingkey "$GPG_KEY_ID"
-git config commit.gpgsign true
+git config --global commit.gpgsign true
 
 # -------------------------------------------------------------------
 # 6. Create release commit
 # -------------------------------------------------------------------
-git add CHANGELOG.md $(find . -name package.json ! -path "*/node_modules/*")
+git add CHANGELOG.md $(git ls-files '**/package.json')
 
 if git diff --cached --quiet; then
   echo "No changes to commit for release $TAG"

.gitea/workflows/release.yaml

@@ -15,7 +15,7 @@ env:
 jobs:
   release:
     runs-on: ubuntu-latest
-    container: git.max-richter.dev/max/nodarium-ci:fd7268d6208aede435e1685817ae6b271c68bd83
+    container: git.max-richter.dev/max/nodarium-ci:bce06da456e3c008851ac006033cfff256015a47
 
     steps:
       - name: 📑 Checkout Code

.gitignore

@@ -5,3 +5,5 @@ node_modules/
 
 /target
 .direnv/
+
+.pnpm-store/

.pnpm-store/v10/tmp/_tmp_246_3d4e72dd61afc4a70a63a40107e5b425/package.json

@@ -1,106 +0,0 @@
-{
-  "name": "chokidar-cli",
-  "description": "Ultra-fast cross-platform command line utility to watch file system changes.",
-  "version": "0.0.4",
-  "keywords": [
-    "fs",
-    "watch",
-    "watchFile",
-    "watcher",
-    "watching",
-    "file",
-    "fsevents",
-    "chokidar",
-    "cli",
-    "command",
-    "shell",
-    "bash"
-  ],
-  "bin": {
-    "chokidar": "index.js"
-  },
-  "homepage": "https://github.com/open-cli-tools/chokidar-cli",
-  "author": "Kimmo Brunfeldt <kimmobrunfeldt@gmail.com>",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/open-cli-tools/chokidar-cli.git"
-  },
-  "bugs": {
-    "url": "http://github.com/open-cli-tools/chokidar-cli/issues"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "chokidar": "^3.5.2",
-    "lodash.debounce": "^4.0.8",
-    "lodash.throttle": "^4.1.1",
-    "yargs": "^18.0.0"
-  },
-  "devDependencies": {
-    "eslint": "^8.57.1",
-    "mocha": "^11.7.2"
-  },
-  "scripts": {
-    "lint": "eslint --report-unused-disable-directives --ignore-path .gitignore .",
-    "mocha": "mocha",
-    "test": "npm run lint && npm run mocha"
-  },
-  "engines": {
-    "node": ">= 20.0.0"
-  },
-  "files": [
-    "*.js"
-  ],
-  "eslintConfig": {
-    "extends": "eslint:recommended",
-    "parserOptions": {
-      "ecmaVersion": 9,
-      "sourceType": "script"
-    },
-    "env": {
-      "node": true,
-      "es6": true
-    },
-    "rules": {
-      "array-callback-return": "error",
-      "indent": [
-        "error",
-        4
-      ],
-      "no-empty": [
-        "error",
-        {
-          "allowEmptyCatch": true
-        }
-      ],
-      "object-shorthand": "error",
-      "prefer-arrow-callback": [
-        "error",
-        {
-          "allowNamedFunctions": true
-        }
-      ],
-      "prefer-const": [
-        "error",
-        {
-          "ignoreReadBeforeAssign": true
-        }
-      ],
-      "prefer-destructuring": [
-        "error",
-        {
-          "object": true,
-          "array": false
-        }
-      ],
-      "prefer-spread": "error",
-      "prefer-template": "error",
-      "radix": "error",
-      "strict": "error",
-      "quotes": [
-        "error",
-        "single"
-      ],
-      "no-var": "error"
-    }
-  }
-}

Dockerfile.ci

@@ -6,6 +6,8 @@ ENV RUSTUP_HOME=/usr/local/rustup \
 
 RUN apt-get update && apt-get install -y \
   ca-certificates=20230311+deb12u1 \
+  gpg=2.2.40-1.1+deb12u2 \
+  gpg-agent=2.2.40-1.1+deb12u2 \
   curl=7.88.1-10+deb12u14 \
   git=1:2.39.5-0+deb12u3 \
   jq=1.6-2.1+deb12u1 \

app/src/lib/graph-interface/edges/Edge.svelte

@@ -6,15 +6,12 @@
     toneMapped: false
   });
 
-  let lineColor = $state(colors.outline.clone().convertSRGBToLinear());
-
   $effect.root(() => {
     $effect(() => {
       if (appSettings.value.theme === undefined) {
         return;
       }
       circleMaterial.color = colors.outline.clone().convertSRGBToLinear();
-      lineColor = colors.outline.clone().convertSRGBToLinear();
     });
   });
 
@@ -35,6 +32,7 @@
   import { CubicBezierCurve } from 'three/src/extras/curves/CubicBezierCurve.js';
   import { Vector2 } from 'three/src/math/Vector2.js';
   import { getGraphState } from '../graph-state.svelte';
+  import MeshGradientLineMaterial from './MeshGradientLine/MeshGradientLineMaterial.svelte';
 
   const graphState = getGraphState();
 
@@ -45,12 +43,17 @@
     y2: number;
     z: number;
     id?: string;
+    inputType?: string;
+    outputType?: string;
   };
 
-  const { x1, y1, x2, y2, z, id }: Props = $props();
+  const { x1, y1, x2, y2, z, inputType = 'unknown', outputType = 'unknown', id }: Props = $props();
 
   const thickness = $derived(Math.max(0.001, 0.00082 * Math.exp(0.055 * z)));
 
+  const inputColor = $derived(graphState.colors.getColor(inputType));
+  const outputColor = $derived(graphState.colors.getColor(outputType));
+
   let points = $state<Vector3[]>([]);
 
   let lastId: string | null = null;
@@ -106,9 +109,9 @@
   position.z={y1}
   position.y={0.8}
   rotation.x={-Math.PI / 2}
-  material={circleMaterial}
 >
   <T.CircleGeometry args={[0.5, 16]} />
+  <T.MeshBasicMaterial color={inputColor} toneMapped={false} />
 </T.Mesh>
 
 <T.Mesh
@@ -119,6 +122,7 @@
   material={circleMaterial}
 >
   <T.CircleGeometry args={[0.5, 16]} />
+  <T.MeshBasicMaterial color={outputColor} toneMapped={false} />
 </T.Mesh>
 
 {#if graphState.hoveredEdgeId === id}
@@ -126,7 +130,8 @@
     <MeshLineGeometry {points} />
     <MeshLineMaterial
       width={thickness * 5}
-      color={lineColor}
+      color={inputColor}
+      tonemapped={false}
       opacity={0.5}
       transparent
     />
@@ -135,5 +140,10 @@
 
 <T.Mesh position.x={x1} position.z={y1} position.y={0.1}>
   <MeshLineGeometry {points} />
-  <MeshLineMaterial width={thickness} color={lineColor} />
+  <MeshGradientLineMaterial
+    width={thickness}
+    colorStart={inputColor}
+    colorEnd={outputColor}
+    tonemapped={false}
+  />
 </T.Mesh>

app/src/lib/graph-interface/edges/MeshGradientLine/MeshGradientLineMaterial.svelte

@@ -0,0 +1,112 @@
+<script lang="ts">
+  import { T, useThrelte } from '@threlte/core';
+  import { Color, ShaderMaterial, Vector2 } from 'three';
+  import fragmentShader from './fragment.frag';
+  import type { MeshLineMaterialProps } from './types';
+  import vertexShader from './vertex.vert';
+
+  let {
+    opacity = 1,
+    colorStart = '#ffffff',
+    colorEnd = '#ffffff',
+    dashOffset = 0,
+    dashArray = 0,
+    dashRatio = 0,
+    attenuate = true,
+    width = 1,
+    scaleDown = 0,
+    alphaMap,
+    ref = $bindable(),
+    children,
+    ...props
+  }: MeshLineMaterialProps = $props();
+
+  let { invalidate, size } = useThrelte();
+
+  // svelte-ignore state_referenced_locally
+  const uniforms = {
+    lineWidth: { value: width },
+    colorStart: { value: new Color(colorStart) },
+    colorEnd: { value: new Color(colorEnd) },
+    opacity: { value: opacity },
+    resolution: { value: new Vector2(1, 1) },
+    sizeAttenuation: { value: attenuate ? 1 : 0 },
+    dashArray: { value: dashArray },
+    useDash: { value: dashArray > 0 ? 1 : 0 },
+    dashOffset: { value: dashOffset },
+    dashRatio: { value: dashRatio },
+    scaleDown: { value: scaleDown / 10 },
+    alphaTest: { value: 0 },
+    alphaMap: { value: alphaMap },
+    useAlphaMap: { value: alphaMap ? 1 : 0 }
+  };
+
+  const material = new ShaderMaterial({ uniforms });
+
+  $effect.pre(() => {
+    uniforms.lineWidth.value = width;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.opacity.value = opacity;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.resolution.value.set($size.width, $size.height);
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.sizeAttenuation.value = attenuate ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashArray.value = dashArray;
+    uniforms.useDash.value = dashArray > 0 ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashOffset.value = dashOffset;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.dashRatio.value = dashRatio;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.scaleDown.value = scaleDown / 10;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.alphaMap.value = alphaMap;
+    uniforms.useAlphaMap.value = alphaMap ? 1 : 0;
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.colorStart.value.set(colorStart);
+    invalidate();
+  });
+
+  $effect.pre(() => {
+    uniforms.colorEnd.value.set(colorEnd);
+    invalidate();
+  });
+</script>
+
+<T
+  is={material}
+  bind:ref
+  {fragmentShader}
+  {vertexShader}
+  {...props}
+>
+  {@render children?.({ ref: material })}
+</T>

app/src/lib/graph-interface/edges/MeshGradientLine/fragment.frag

@@ -0,0 +1,30 @@
+uniform vec3 colorStart;
+uniform vec3 colorEnd;
+
+uniform float useDash;
+uniform float dashArray;
+uniform float dashOffset;
+uniform float dashRatio;
+uniform sampler2D alphaMap;
+uniform float useAlphaMap;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying float vCounters;
+
+vec4 CustomLinearTosRGB( in vec4 value ) {
+	return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );
+}
+
+void main()	{
+
+  vec4 c = mix(vec4(colorStart,1.0),vec4(colorEnd, 1.0), vCounters);
+
+	if( useAlphaMap == 1. ) c.a *= texture2D( alphaMap, vUV ).r;
+
+	if( useDash == 1. ){
+		c.a *= ceil(mod(vCounters + dashOffset, dashArray) - (dashArray * dashRatio));
+	}
+
+	gl_FragColor = CustomLinearTosRGB(c);
+}

app/src/lib/graph-interface/edges/MeshGradientLine/types.ts

@@ -0,0 +1,68 @@
+import type { Props } from '@threlte/core';
+import type { BufferGeometry, Vector3 } from 'three';
+import type { ColorRepresentation, ShaderMaterial, Texture } from 'three';
+
+export type MeshLineGeometryProps = Props<BufferGeometry> & {
+  /**
+   * @default []
+   */
+  points: Vector3[];
+
+  /**
+   * @default 'none'
+   */
+  shape?: 'none' | 'taper' | 'custom';
+
+  /**
+   * @default () => 1
+   */
+  shapeFunction?: (p: number) => number;
+};
+
+export type MeshLineMaterialProps =
+  & Omit<
+    Props<ShaderMaterial>,
+    'uniforms' | 'fragmentShader' | 'vertexShader'
+  >
+  & {
+    /**
+     * @default 1
+     */
+    opacity?: number;
+
+    /**
+     * @default '#ffffff'
+     */
+    color?: ColorRepresentation;
+
+    /**
+     * @default 0
+     */
+    dashOffset?: number;
+
+    /**
+     * @default 0
+     */
+    dashArray?: number;
+
+    /**
+     * @default 0
+     */
+    dashRatio?: number;
+
+    /**
+     * @default true
+     */
+    attenuate?: boolean;
+
+    /**
+     * @default 1
+     */
+    width?: number;
+
+    /**
+     * @default 0
+     */
+    scaleDown?: number;
+    alphaMap?: Texture | undefined;
+  };

app/src/lib/graph-interface/edges/MeshGradientLine/vertex.vert

@@ -0,0 +1,83 @@
+attribute vec3 previous;
+attribute vec3 next;
+attribute float side;
+attribute float width;
+attribute float counters;
+
+uniform vec2 resolution;
+uniform float lineWidth;
+uniform vec3 color;
+uniform float opacity;
+uniform float sizeAttenuation;
+uniform float scaleDown;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying float vCounters;
+
+vec2 intoScreen(vec4 i) {
+    return resolution * (0.5 * i.xy / i.w + 0.5);
+}
+
+void main() {
+    float aspect = resolution.y / resolution.x;
+
+    mat4 m = projectionMatrix * modelViewMatrix;
+
+    vec4 currentClip = m * vec4( position, 1.0 );
+    vec4 prevClip = m * vec4( previous, 1.0 );
+    vec4 nextClip = m * vec4( next, 1.0 );
+
+    vec4 currentNormed = currentClip / currentClip.w;
+    vec4 prevNormed = prevClip / prevClip.w;
+    vec4 nextNormed = nextClip / nextClip.w;
+
+    vec2 currentScreen = intoScreen(currentNormed);
+    vec2 prevScreen = intoScreen(prevNormed);
+    vec2 nextScreen = intoScreen(nextNormed);
+
+    float actualWidth = lineWidth * width;
+
+    vec2 dir;
+    if(nextScreen == currentScreen) {
+        dir = normalize( currentScreen - prevScreen );
+    } else if(prevScreen == currentScreen) {
+        dir = normalize( nextScreen - currentScreen );
+    } else {
+        vec2 inDir = currentScreen - prevScreen;
+        vec2 outDir = nextScreen - currentScreen;
+        vec2 fullDir = nextScreen - prevScreen;
+
+        if(length(fullDir) > 0.0) {
+            dir = normalize(fullDir);
+        } else if(length(inDir) > 0.0){
+            dir = normalize(inDir);
+        } else {
+            dir = normalize(outDir);
+        }
+    }
+
+    vec2 normal = vec2(-dir.y, dir.x);
+
+    if(sizeAttenuation != 0.0) {
+        normal /= currentClip.w;
+        normal *= min(resolution.x, resolution.y);
+    }
+
+    if (scaleDown > 0.0) {
+        float dist = length(nextNormed - prevNormed);
+        normal *= smoothstep(0.0, scaleDown, dist);
+    }
+
+    vec2 offsetInScreen = actualWidth * normal * side * 0.5;
+
+    vec2 withOffsetScreen = currentScreen + offsetInScreen;
+    vec3 withOffsetNormed = vec3((2.0 * withOffsetScreen/resolution - 1.0), currentNormed.z);
+
+    vCounters = counters;
+    vColor = vec4( color, opacity );
+    vUV = uv;
+
+    gl_Position = currentClip.w * vec4(withOffsetNormed, 1.0);
+
+}

app/src/lib/graph-interface/graph-state.svelte.ts

@@ -1,8 +1,10 @@
-import type { NodeDefinition, NodeInstance, Socket } from '@nodarium/types';
+import type { NodeInstance, Socket } from '@nodarium/types';
 import { getContext, setContext } from 'svelte';
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { OrthographicCamera, Vector3 } from 'three';
 import type { GraphManager } from './graph-manager.svelte';
+import { ColorGenerator } from './graph/colors';
+import { getNodeHeight, getSocketPosition } from './helpers/nodeHelpers';
 
 const graphStateKey = Symbol('graph-state');
 export function getGraphState() {
@@ -27,7 +29,32 @@ type EdgeData = {
   points: Vector3[];
 };
 
+const predefinedColors = {
+  path: {
+    hue: 80,
+    lightness: 20,
+    saturation: 80
+  },
+  float: {
+    hue: 70,
+    lightness: 10,
+    saturation: 0
+  },
+  geometry: {
+    hue: 0,
+    lightness: 50,
+    saturation: 70
+  },
+  '*': {
+    hue: 200,
+    lightness: 20,
+    saturation: 100
+  }
+} as const;
+
 export class GraphState {
+  colors = new ColorGenerator(predefinedColors);
+
   constructor(private graph: GraphManager) {
     $effect.root(() => {
       $effect(() => {
@@ -159,74 +186,27 @@ export class GraphState {
     return 1;
   }
 
-  getParameterHeight(node: NodeDefinition, inputKey: string) {
+  tryConnectToDebugNode(nodeId: number) {
-    const input = node.inputs?.[inputKey];
+    const node = this.graph.nodes.get(nodeId);
-    if (!input) {
+    if (!node) return;
-      return 100;
+    if (node.type.endsWith('/debug')) return;
-    }
+    if (!node.state.type?.outputs?.length) return;
-
+    for (const _node of this.graph.nodes.values()) {
-    if (input.type === 'shape' && input.external !== true) {
+      if (_node.type.endsWith('/debug')) {
-      return 200;
+        this.graph.createEdge(node, 0, _node, 'input');
-    }
+        return;
-    if (
-      input?.label !== '' && !input.external && input.type !== 'path'
-      && input.type !== 'geometry'
-    ) {
-      return 100;
-    }
-    return 50;
-  }
-
-  getSocketPosition(
-    node: NodeInstance,
-    index: string | number
-  ): [number, number] {
-    if (typeof index === 'number') {
-      return [
-        (node?.state?.x ?? node.position[0]) + 20,
-        (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
-      ];
-    } else {
-      let height = 5;
-      let nodeType = node.state.type!;
-      const inputs = nodeType.inputs || {};
-      for (const inputKey in inputs) {
-        const h = this.getParameterHeight(nodeType, inputKey) / 10;
-        console.log({ inputKey, h });
-        if (inputKey === index) {
-          height += h / 2;
-          break;
-        }
-        height += h;
-      }
-      return [
-        node?.state?.x ?? node.position[0],
-        (node?.state?.y ?? node.position[1]) + height
-      ];
       }
     }
 
-  private nodeHeightCache: Record<string, number> = {};
+    const debugNode = this.graph.createNode({
-  getNodeHeight(nodeTypeId: string) {
+      type: 'max/plantarium/debug',
-    if (nodeTypeId in this.nodeHeightCache) {
+      position: [node.position[0] + 30, node.position[1]],
-      return this.nodeHeightCache[nodeTypeId];
+      props: {}
-    }
+    });
-    const node = this.graph.getNodeType(nodeTypeId);
-    if (!node?.inputs) {
-      return 5;
-    }
-    let height = 5;
-    console.log('Get Node Height', nodeTypeId);
 
-    for (const key in node.inputs) {
+    if (debugNode) {
-      const h = this.getParameterHeight(node, key);
+      this.graph.createEdge(node, 0, debugNode, 'input');
-      console.log({ key, h });
-      height += h;
     }
-
-    this.nodeHeightCache[nodeTypeId] = height;
-    console.log(this.nodeHeightCache);
-    return height;
   }
 
   copyNodes() {
@@ -286,7 +266,7 @@ export class GraphState {
         if (edge[3] === index) {
           node = edge[0];
           index = edge[1];
-          position = this.getSocketPosition(node, index);
+          position = getSocketPosition(node, index);
           this.graph.removeEdge(edge);
           break;
         }
@@ -306,7 +286,7 @@ export class GraphState {
         return {
           node,
           index,
-          position: this.getSocketPosition(node, index)
+          position: getSocketPosition(node, index)
         };
       });
   }
@@ -343,7 +323,7 @@ export class GraphState {
         for (const node of this.graph.nodes.values()) {
           const x = node.position[0];
           const y = node.position[1];
-          const height = this.getNodeHeight(node.type);
+          const height = getNodeHeight(node.state.type!);
           if (downX > x && downX < x + 20 && downY > y && downY < y + height) {
             clickedNodeId = node.id;
             break;
@@ -355,14 +335,12 @@ export class GraphState {
   }
 
   isNodeInView(node: NodeInstance) {
-    const height = this.getNodeHeight(node.type);
+    const height = getNodeHeight(node.state.type!);
     const width = 20;
-    const inView = node.position[0] > this.cameraBounds[0] - width
+    return node.position[0] > this.cameraBounds[0] - width
       && node.position[0] < this.cameraBounds[1]
       && node.position[1] > this.cameraBounds[2] - height
       && node.position[1] < this.cameraBounds[3];
-    console.log({ inView, height });
-    return inView;
   }
 
   openNodePalette() {

app/src/lib/graph-interface/graph/Graph.svelte

@@ -11,6 +11,7 @@
   import Debug from '../debug/Debug.svelte';
   import EdgeEl from '../edges/Edge.svelte';
   import { getGraphManager, getGraphState } from '../graph-state.svelte';
+  import { getSocketPosition } from '../helpers/nodeHelpers';
   import NodeEl from '../node/Node.svelte';
   import { maxZoom, minZoom } from './constants';
   import { FileDropEventManager } from './drop.events';
@@ -38,8 +39,8 @@
       return [0, 0, 0, 0];
     }
 
-    const pos1 = graphState.getSocketPosition(fromNode, edge[1]);
+    const pos1 = getSocketPosition(fromNode, edge[1]);
-    const pos2 = graphState.getSocketPosition(toNode, edge[3]);
+    const pos2 = getSocketPosition(toNode, edge[3]);
     return [pos1[0], pos1[1], pos2[0], pos2[1]];
   }
 
@@ -94,6 +95,13 @@
     graphState.activeSocket = null;
     graphState.addMenuPosition = null;
   }
+
+  function getSocketType(node: NodeInstance, index: number | string): string {
+    if (typeof index === 'string') {
+      return node.state.type?.inputs?.[index].type || 'unknown';
+    }
+    return node.state.type?.outputs?.[index] || 'unknown';
+  }
 </script>
 
 <svelte:window
@@ -174,6 +182,8 @@
       {#if graphState.activeSocket}
         <EdgeEl
           z={graphState.cameraPosition[2]}
+          inputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index)}
+          outputType={getSocketType(graphState.activeSocket.node, graphState.activeSocket.index)}
           x1={graphState.activeSocket.position[0]}
           y1={graphState.activeSocket.position[1]}
           x2={graphState.edgeEndPosition?.[0] ?? graphState.mousePosition[0]}
@@ -186,6 +196,8 @@
         <EdgeEl
           id={graph.getEdgeId(edge)}
           z={graphState.cameraPosition[2]}
+          inputType={getSocketType(edge[0], edge[1])}
+          outputType={getSocketType(edge[2], edge[3])}
           {x1}
           {y1}
           {x2}
@@ -208,7 +220,6 @@
             <NodeEl
               {node}
               inView={graphState.isNodeInView(node)}
-              z={graphState.cameraPosition[2]}
             />
           {/each}
         </div>

app/src/lib/graph-interface/graph/colors.ts

@@ -0,0 +1,44 @@
+type Color = { hue: number; saturation: number; lightness: number };
+
+export class ColorGenerator {
+  private colors: Map<string, Color> = new Map();
+  private lightnessLevels = [10, 60];
+
+  constructor(predefined: Record<string, Color>) {
+    for (const [id, colorStr] of Object.entries(predefined)) {
+      this.colors.set(id, colorStr);
+    }
+  }
+
+  public getColor(id: string): string {
+    if (this.colors.has(id)) {
+      return this.colorToHsl(this.colors.get(id)!);
+    }
+
+    const newColor = this.generateNewColor();
+    this.colors.set(id, newColor);
+    return this.colorToHsl(newColor);
+  }
+
+  private generateNewColor(): Color {
+    const existingHues = Array.from(this.colors.values()).map(c => c.hue).sort();
+    let hue = existingHues[0];
+    let attempts = 0;
+
+    while (
+      existingHues.some(h => Math.abs(h - hue) < 30 || Math.abs(h - hue) > 330)
+      && attempts < 360
+    ) {
+      hue = (hue + 30) % 360;
+      attempts++;
+    }
+
+    const lightness = 60;
+
+    return { hue, lightness, saturation: 100 };
+  }
+
+  private colorToHsl(c: Color): string {
+    return `hsl(${c.hue}, ${c.saturation}%, ${c.lightness}%)`;
+  }
+}

app/src/lib/graph-interface/graph/mouse.events.ts

@@ -3,6 +3,7 @@ import { type NodeInstance } from '@nodarium/types';
 import type { GraphManager } from '../graph-manager.svelte';
 import { type GraphState } from '../graph-state.svelte';
 import { snapToGrid as snapPointToGrid } from '../helpers';
+import { getNodeHeight } from '../helpers/nodeHelpers';
 import { maxZoom, minZoom, zoomSpeed } from './constants';
 import { EdgeInteractionManager } from './edge.events';
 
@@ -188,6 +189,10 @@ export class MouseEventManager {
 
     // if we clicked on a node
     if (clickedNodeId !== -1) {
+      if (event.ctrlKey && event.shiftKey) {
+        this.state.tryConnectToDebugNode(clickedNodeId);
+        return;
+      }
       if (this.state.activeNodeId === -1) {
         this.state.activeNodeId = clickedNodeId;
         // if the selected node is the same as the clicked node
@@ -289,7 +294,7 @@ export class MouseEventManager {
         if (!node?.state) continue;
         const x = node.position[0];
         const y = node.position[1];
-        const height = this.state.getNodeHeight(node.type);
+        const height = getNodeHeight(node.state.type!);
         if (x > x1 - 20 && x < x2 && y > y1 - height && y < y2) {
           this.state.selectedNodes?.add(node.id);
         } else {

app/src/lib/graph-interface/helpers/index.ts

@@ -35,6 +35,9 @@ export function createNodePath({
   rightBump = false,
   aspectRatio = 1
 } = {}) {
+  const leftBumpTopY = y + height / 2;
+  const leftBumpBottomY = y - height / 2;
+
   return `M0,${cornerTop}
       ${
     cornerTop
@@ -64,9 +67,7 @@ export function createNodePath({
   }
       ${
     leftBump
-      ? ` V${y + height / 2} C${depth},${y + height / 2} ${depth},${y - height / 2} 0,${
+      ? ` V${leftBumpTopY} C${depth},${leftBumpTopY} ${depth},${leftBumpBottomY} 0,${leftBumpBottomY}`
-        y - height / 2
-      }`
       : ` H0`
   }
       Z`.replace(/\s+/g, ' ');

app/src/lib/graph-interface/helpers/nodeHelpers.ts

@@ -0,0 +1,71 @@
+import type { NodeDefinition, NodeInstance } from '@nodarium/types';
+
+export function getParameterHeight(node: NodeDefinition, inputKey: string) {
+  const input = node.inputs?.[inputKey];
+  if (!input) {
+    return 0;
+  }
+
+  if (inputKey === 'seed') return 0;
+  if (!node.inputs) return 0;
+  if ('setting' in input) return 0;
+  if (input.hidden) return 0;
+
+  if (input.type === 'shape' && input.external !== true) {
+    return 200;
+  }
+  if (
+    input?.label !== '' && !input.external && input.type !== 'path'
+    && input.type !== 'geometry'
+  ) {
+    return 100;
+  }
+  return 50;
+}
+
+export function getSocketPosition(
+  node: NodeInstance,
+  index: string | number
+): [number, number] {
+  if (typeof index === 'number') {
+    return [
+      (node?.state?.x ?? node.position[0]) + 20,
+      (node?.state?.y ?? node.position[1]) + 2.5 + 10 * index
+    ];
+  } else {
+    let height = 5;
+    const nodeType = node.state.type!;
+    const inputs = nodeType.inputs || {};
+    for (const inputKey in inputs) {
+      const h = getParameterHeight(nodeType, inputKey) / 10;
+      if (inputKey === index) {
+        height += h / 2;
+        break;
+      }
+      height += h;
+    }
+    return [
+      node?.state?.x ?? node.position[0],
+      (node?.state?.y ?? node.position[1]) + height
+    ];
+  }
+}
+
+const nodeHeightCache: Record<string, number> = {};
+export function getNodeHeight(node: NodeDefinition) {
+  if (node.id in nodeHeightCache) {
+    return nodeHeightCache[node.id];
+  }
+  if (!node?.inputs) {
+    return 5;
+  }
+  let height = 5;
+
+  for (const key in node.inputs) {
+    const h = getParameterHeight(node, key) / 10;
+    height += h;
+  }
+
+  nodeHeightCache[node.id] = height;
+  return height;
+}

app/src/lib/graph-interface/node/Node.frag

@@ -1,56 +1,88 @@
-
 varying vec2 vUv;
 
 uniform float uWidth;
 uniform float uHeight;
+uniform float uZoom; 
 
 uniform vec3 uColorDark;
 uniform vec3 uColorBright;
-
 uniform vec3 uStrokeColor;
-uniform float uStrokeWidth;
+
+const float uHeaderHeight = 5.0; 
+uniform float uSectionHeights[16]; 
+uniform int uNumSections;
 
 float msign(in float x) { return (x < 0.0) ? -1.0 : 1.0; }
+float sdCircle(vec2 p, float r) { return length(p) - r; }
 
 vec4 roundedBoxSDF( in vec2 p, in vec2 b, in float r, in float s) {
   vec2 q = abs(p) - b + r;
   float l = b.x + b.y + 1.570796 * r;
-
   float k1 = min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r;
   float k2 = ((q.x > 0.0) ? atan(q.y, q.x) : 1.570796);
   float k3 = 3.0 + 2.0 * msign(min(p.x, -p.y)) - msign(p.x);
   float k4 = msign(p.x * p.y);
   float k5 = r * k2 + max(-q.x, 0.0);
-
   float ra = s * round(k1 / s);
   float l2 = l + 1.570796 * ra;
-
   return vec4(k1 - ra, k3 * l2 + k4 * (b.y + ((q.y > 0.0) ? k5 + k2 * ra : q.y)), 4.0 * l2, k1);
 }
 
 void main(){
+  float strokeWidth = mix(2.0, 0.5, uZoom);
   
-  float y = (1.0-vUv.y) * uHeight;
+  float borderRadius = 0.5;
+  float dentRadius = 0.8;
+
+  float y = (1.0 - vUv.y) * uHeight;
   float x = vUv.x * uWidth;
-
   vec2 size = vec2(uWidth, uHeight);
-  vec2 uv = (vUv - 0.5) * 2.0;
+  vec2 uvCenter = (vUv - 0.5) * 2.0;
 
-  float u_border_radius = 0.4;
+  vec4 boxData = roundedBoxSDF(uvCenter * size, size, borderRadius * 2.0, 0.0);
-  vec4 distance = roundedBoxSDF(uv * size, size, u_border_radius*2.0, 0.0);
+  float sceneSDF = boxData.w;
 
-  if (distance.w > 0.0 ) {
+  vec2 headerDentPos = vec2(uWidth, uHeaderHeight * 0.5);
-    // outside
+  float headerDentDist = sdCircle(vec2(x, y) - headerDentPos, dentRadius);
-    gl_FragColor = vec4(0.0,0.0,0.0, 0.0);
+  sceneSDF = max(sceneSDF, -headerDentDist*2.0);
-  }else{
+
-    if (distance.w > -uStrokeWidth || mod(y+5.0, 10.0) < uStrokeWidth/2.0) {
+  float currentYBoundary = uHeaderHeight;
-      // draw the outer stroke
+  float previousYBoundary = uHeaderHeight;
-      gl_FragColor = vec4(uStrokeColor, 1.0);
+
-    }else if (y<5.0){
+  for (int i = 0; i < 16; i++) {
-      // draw the header
+    if (i >= uNumSections) break;
-      gl_FragColor = vec4(uColorBright, 1.0);
+    
-    }else{
+    float sectionHeight = uSectionHeights[i];
-      gl_FragColor = vec4(uColorDark, 1.0);
+    currentYBoundary += sectionHeight;
+    
+    float centerY = previousYBoundary + (sectionHeight * 0.5);
+    vec2 circlePos = vec2(0.0, centerY);
+    float circleDist = sdCircle(vec2(x, y) - circlePos, dentRadius);
+    
+    sceneSDF = max(sceneSDF, -circleDist*2.0);
+    previousYBoundary = currentYBoundary;
   }
+
+  if (sceneSDF > 0.05) { 
+    gl_FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    return;
+  }
+
+  vec3 finalColor = (y < uHeaderHeight) ? uColorBright : uColorDark;
+  bool isDivider = false;
+
+  float dividerY = uHeaderHeight;
+  if (abs(y - dividerY) < strokeWidth * 0.25) isDivider = true;
+  
+  for (int i = 0; i < 16; i++) {
+    if (i >= uNumSections - 1) break;
+    dividerY += uSectionHeights[i];
+    if (abs(y - dividerY) < strokeWidth * 0.25) isDivider = true;
+  }
+
+  if (sceneSDF > -strokeWidth || isDivider) {
+    gl_FragColor = vec4(uStrokeColor, 1.0);
+  } else {
+    gl_FragColor = vec4(finalColor, 1.0);
   }
 }

app/src/lib/graph-interface/node/Node.svelte

@@ -5,6 +5,7 @@
   import { type Mesh } from 'three';
   import { getGraphState } from '../graph-state.svelte';
   import { colors } from '../graph/colors.svelte';
+  import { getNodeHeight, getParameterHeight } from '../helpers/nodeHelpers';
   import NodeFrag from './Node.frag';
   import NodeVert from './Node.vert';
   import NodeHtml from './NodeHTML.svelte';
@@ -14,9 +15,10 @@
   type Props = {
     node: NodeInstance;
     inView: boolean;
-    z: number;
   };
-  let { node = $bindable(), inView, z }: Props = $props();
+  let { node = $bindable(), inView }: Props = $props();
+
+  const nodeType = $derived(node.state.type!);
 
   const isActive = $derived(graphState.activeNodeId === node.id);
   const isSelected = $derived(graphState.selectedNodes.has(node.id));
@@ -29,9 +31,18 @@
         : colors.outline)
   );
 
+  const sectionHeights = $derived(
+    Object
+      .keys(nodeType.inputs || {})
+      .map(key => getParameterHeight(nodeType, key) / 10)
+      .filter(b => !!b)
+  );
+
   let meshRef: Mesh | undefined = $state();
 
-  const height = graphState.getNodeHeight(node.type);
+  const height = getNodeHeight(node.state.type!);
+
+  const zoom = $derived(graphState.cameraPosition[2]);
 
   $effect(() => {
     if (meshRef && !node.state?.mesh) {
@@ -39,6 +50,10 @@
       graphState.updateNodePosition(node);
     }
   });
+  const zoomValue = $derived(
+    (Math.log(graphState.cameraPosition[2]) - Math.log(1)) / (Math.log(40) - Math.log(1))
+  );
+  // const zoomValue = (graphState.cameraPosition[2] - 1) / 39;
 </script>
 
 <T.Mesh
@@ -47,7 +62,7 @@
   position.y={0.8}
   rotation.x={-Math.PI / 2}
   bind:ref={meshRef}
-  visible={inView && z < 7}
+  visible={inView && zoom < 7}
 >
   <T.PlaneGeometry args={[20, height]} radius={1} />
   <T.ShaderMaterial
@@ -57,14 +72,19 @@
     uniforms={{
       uColorBright: { value: colors['layer-2'] },
       uColorDark: { value: colors['layer-1'] },
-      uStrokeColor: { value: colors['layer-2'].clone() },
+      uStrokeColor: { value: colors.outline.clone() },
-      uStrokeWidth: { value: 1.0 },
+      uSectionHeights: { value: [5, 10] },
+      uNumSections: { value: 2 },
       uWidth: { value: 20 },
-      uHeight: { value: height }
+      uHeight: { value: 200 },
+      uZoom: { value: 1.0 }
     }}
-    uniforms.uStrokeColor.value={strokeColor.clone()}
+    uniforms.uZoom.value={zoomValue}
-    uniforms.uStrokeWidth.value={(7 - z) / 3}
+    uniforms.uHeight.value={height}
+    uniforms.uSectionHeights.value={sectionHeights}
+    uniforms.uNumSections.value={sectionHeights.length}
+    uniforms.uStrokeColor.value={strokeColor}
   />
 </T.Mesh>
 
-<NodeHtml bind:node {inView} {isActive} {isSelected} {z} />
+<NodeHtml bind:node {inView} {isActive} {isSelected} z={zoom} />

app/src/lib/graph-interface/node/NodeHeader.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
   import { appSettings } from '$lib/settings/app-settings.svelte';
-  import type { NodeInstance } from '@nodarium/types';
+  import type { NodeInstance, Socket } from '@nodarium/types';
   import { getGraphState } from '../graph-state.svelte';
   import { createNodePath } from '../helpers/index.js';
+  import { getSocketPosition } from '../helpers/nodeHelpers';
 
   const graphState = getGraphState();
 
@@ -15,7 +16,7 @@
       graphState.setDownSocket?.({
         node,
         index: 0,
-        position: graphState.getSocketPosition?.(node, 0)
+        position: getSocketPosition?.(node, 0)
       });
     }
   }
@@ -44,9 +45,27 @@
       aspectRatio
     })
   );
+
+  const socketId = $derived(`${node.id}-${0}`);
+
+  function getSocketType(s: Socket | null) {
+    if (!s) return 'unknown';
+    if (typeof s.index === 'string') {
+      return s.node.state.type?.inputs?.[s.index].type || 'unknown';
+    }
+    return s.node.state.type?.outputs?.[s.index] || 'unknown';
+  }
+  const socketType = $derived(getSocketType(graphState.activeSocket));
+  const hoverColor = $derived(graphState.colors.getColor(socketType));
 </script>
 
-<div class="wrapper" data-node-id={node.id} data-node-type={node.type}>
+<div
+  class="wrapper"
+  data-node-id={node.id}
+  data-node-type={node.type}
+  style:--socket-color={hoverColor}
+  class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
+>
   <div class="content">
     {#if appSettings.value.debug.advancedMode}
       <span class="bg-white text-black! mr-2 px-1 rounded-sm opacity-30">{node.id}</span>
@@ -54,7 +73,7 @@
     {node.type.split('/').pop()}
   </div>
   <div
-    class="click-target"
+    class="target"
     role="button"
     tabindex="0"
     onmousedown={handleMouseDown}
@@ -82,7 +101,20 @@
     height: 50px;
   }
 
-  .click-target {
+  .possible-socket .target::before {
+    content: "";
+    position: absolute;
+    width: 30px;
+    height: 30px;
+    border-radius: 100%;
+    box-shadow: 0px 0px 10px var(--socket-color);
+    background-color: var(--socket-color);
+    outline: solid thin var(--socket-color);
+    opacity: 0.7;
+    z-index: -10;
+  }
+
+  .target {
     position: absolute;
     right: 0px;
     top: 50%;
@@ -93,7 +125,7 @@
     border-radius: 50%;
   }
 
-  .click-target:hover + svg path {
+  .target:hover + svg path {
     d: var(--hover-path);
   }
 

app/src/lib/graph-interface/node/NodeParameter.svelte

@@ -1,7 +1,8 @@
 <script lang="ts">
-  import type { NodeInput, NodeInstance } from '@nodarium/types';
+  import type { NodeInput, NodeInstance, Socket } from '@nodarium/types';
   import { getGraphManager, getGraphState } from '../graph-state.svelte';
   import { createNodePath } from '../helpers';
+  import { getParameterHeight, getSocketPosition } from '../helpers/nodeHelpers';
   import NodeInputEl from './NodeInput.svelte';
 
   type Props = {
@@ -23,7 +24,7 @@
   const inputType = $derived(nodeType.inputs?.[id]);
 
   const socketId = $derived(`${node.id}-${id}`);
-  const height = $derived(graphState.getParameterHeight(nodeType, id));
+  const height = $derived(getParameterHeight(nodeType, id));
 
   function handleMouseDown(ev: MouseEvent) {
     ev.preventDefault();
@@ -31,7 +32,7 @@
     graphState.setDownSocket({
       node,
       index: id,
-      position: graphState.getSocketPosition?.(node, id)
+      position: getSocketPosition(node, id)
     });
   }
 
@@ -42,7 +43,7 @@
   const path = $derived(
     createNodePath({
       depth: 6,
-      height: 18,
+      height: 2000 / height,
       y: 50.5,
       cornerBottom,
       leftBump,
@@ -52,13 +53,24 @@
   const pathHover = $derived(
     createNodePath({
       depth: 7,
-      height: 20,
+      height: 2200 / height,
       y: 50.5,
       cornerBottom,
       leftBump,
       aspectRatio
     })
   );
+
+  function getSocketType(s: Socket | null) {
+    if (!s) return 'unknown';
+    if (typeof s.index === 'string') {
+      return s.node.state.type?.inputs?.[s.index].type || 'unknown';
+    }
+    return s.node.state.type?.outputs?.[s.index] || 'unknown';
+  }
+
+  const socketType = $derived(getSocketType(graphState.activeSocket));
+  const hoverColor = $derived(graphState.colors.getColor(socketType));
 </script>
 
 <div
@@ -66,6 +78,7 @@
   data-node-type={node.type}
   data-node-input={id}
   style:height="{height}px"
+  style:--socket-color={hoverColor}
   class:possible-socket={graphState?.possibleSocketIds.has(socketId)}
 >
   {#key id && graphId}
@@ -94,10 +107,8 @@
     xmlns="http://www.w3.org/2000/svg"
     viewBox="0 0 100 100"
     preserveAspectRatio="none"
-    style={`
+    style:--path={`path("${path}")`}
-      --path: path("${path}");
+    style:--hover-path={`path("${pathHover}")`}
-      --hover-path: path("${pathHover}");
-    `}
   >
     <path vector-effect="non-scaling-stroke"></path>
   </svg>
@@ -119,9 +130,16 @@
     transform: translateY(-50%) translateX(-50%);
   }
 
-  .possible-socket .target {
+  .possible-socket .target::before {
-    box-shadow: 0px 0px 10px rgba(255, 255, 255, 0.5);
+    content: "";
-    background-color: rgba(255, 255, 255, 0.2);
+    position: absolute;
+    width: 30px;
+    height: 30px;
+    border-radius: 100%;
+    box-shadow: 0px 0px 10px var(--socket-color);
+    background-color: var(--socket-color);
+    outline: solid thin var(--socket-color);
+    opacity: 0.5;
     z-index: -10;
   }
 
@@ -131,11 +149,12 @@
 
   .content {
     position: relative;
-    padding: 10px 20px;
     display: flex;
     flex-direction: column;
+    padding-inline: 20px;
     height: 100%;
-    justify-content: space-around;
+    justify-content: center;
+    gap: 10px;
     box-sizing: border-box;
   }
 

app/src/lib/node-registry/debugNode.ts

@@ -1,23 +1,11 @@
-const data: Record<string, unknown> = {};
-
-export function clearDebugData() {
-  for (const key in data) {
-    delete data[key];
-  }
-}
-
-export function getDebugData() {
-  return { ...data };
-}
-
 export const debugNode = {
   id: 'max/plantarium/debug',
   inputs: {
-    a: {
+    input: {
       type: '*'
     }
   },
-  execute(data: Int32Array) {
+  execute(_data: Int32Array): Int32Array {
-    return data;
+    return _data;
   }
 } as const;

app/src/lib/result-viewer/Debug.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+  import { T } from '@threlte/core';
+  import type { Group } from 'three';
+  import { updateDebugScene } from './debug';
+
+  type Props = {
+    debugData?: Record<number, { type: string; data: Int32Array }>;
+  };
+
+  let group = $state<Group>(null!);
+  const { debugData }: Props = $props();
+
+  $effect(() => {
+    if (!group || !debugData) return;
+    updateDebugScene(group, $state.snapshot(debugData));
+  });
+</script>
+
+<T.Group bind:ref={group} />

app/src/lib/result-viewer/Scene.svelte

@@ -1,33 +1,26 @@
 <script lang="ts">
   import { colors } from '$lib/graph-interface/graph/colors.svelte';
   import { T, useTask, useThrelte } from '@threlte/core';
-  import { Grid, MeshLineGeometry, MeshLineMaterial, Text } from '@threlte/extras';
+  import { Grid } from '@threlte/extras';
-  import {
+  import { Box3, type BufferGeometry, type Group, Mesh, MeshBasicMaterial, Vector3 } from 'three';
-    Box3,
-    type BufferGeometry,
-    type Group,
-    Mesh,
-    MeshBasicMaterial,
-    Vector3,
-    type Vector3Tuple
-  } from 'three';
   import { appSettings } from '../settings/app-settings.svelte';
   import Camera from './Camera.svelte';
+  import Debug from './Debug.svelte';
 
   const { renderStage, invalidate: _invalidate } = useThrelte();
 
   type Props = {
     fps: number[];
-    lines: Vector3[][];
+    debugData?: Record<number, { type: string; data: Int32Array }>;
     scene: Group;
     centerCamera: boolean;
   };
 
   let {
-    lines,
     centerCamera,
     fps = $bindable(),
-    scene = $bindable()
+    scene = $bindable(),
+    debugData
   }: Props = $props();
 
   let geometries = $state.raw<BufferGeometry[]>([]);
@@ -91,18 +84,12 @@
     });
     _invalidate();
   });
-
-  function getPosition(geo: BufferGeometry, i: number) {
-    return [
-      geo.attributes.position.array[i],
-      geo.attributes.position.array[i + 1],
-      geo.attributes.position.array[i + 2]
-    ] as Vector3Tuple;
-  }
 </script>
 
 <Camera {center} {centerCamera} />
 
+<Debug {debugData} />
+
 {#if appSettings.value.showGrid}
   <Grid
     cellColor={colors['outline']}
@@ -116,35 +103,4 @@
     fadeOrigin={new Vector3(0, 0, 0)}
   />
 {/if}
-
+<T.Group bind:ref={scene}></T.Group>
-<T.Group>
-  {#if geometries}
-    {#each geometries as geo (geo.id)}
-      {#if appSettings.value.debug.showIndices}
-        {#each geo.attributes.position.array, i (i)}
-          {#if i % 3 === 0}
-            <Text fontSize={0.25} position={getPosition(geo, i)} />
-          {/if}
-        {/each}
-      {/if}
-
-      {#if appSettings.value.debug.showVertices}
-        <T.Points visible={true}>
-          <T is={geo} />
-          <T.PointsMaterial size={0.25} />
-        </T.Points>
-      {/if}
-    {/each}
-  {/if}
-
-  <T.Group bind:ref={scene}></T.Group>
-</T.Group>
-
-{#if appSettings.value.debug.showStemLines && lines}
-  {#each lines as line (line[0].x + '-' + line[0].y + '-' + '' + line[0].z)}
-    <T.Mesh>
-      <MeshLineGeometry points={line} />
-      <MeshLineMaterial width={0.1} color="red" depthTest={false} />
-    </T.Mesh>
-  {/each}
-{/if}

app/src/lib/result-viewer/Viewer.svelte

@@ -1,10 +1,10 @@
 <script lang="ts">
   import SmallPerformanceViewer from '$lib/performance/SmallPerformanceViewer.svelte';
   import { appSettings } from '$lib/settings/app-settings.svelte';
-  import { decodeFloat, splitNestedArray } from '@nodarium/utils';
+  import { splitNestedArray } from '@nodarium/utils';
   import type { PerformanceStore } from '@nodarium/utils';
   import { Canvas } from '@threlte/core';
-  import { DoubleSide, Vector3 } from 'three';
+  import { DoubleSide } from 'three';
   import { type Group, MeshMatcapMaterial, TextureLoader } from 'three';
   import { createGeometryPool, createInstancedGeometryPool } from './geometryPool';
   import Scene from './Scene.svelte';
@@ -23,6 +23,7 @@
 
   let geometryPool: ReturnType<typeof createGeometryPool>;
   let instancePool: ReturnType<typeof createInstancedGeometryPool>;
+
   export function updateGeometries(inputs: Int32Array[], group: Group) {
     geometryPool = geometryPool || createGeometryPool(group, material);
     instancePool = instancePool || createInstancedGeometryPool(group, material);
@@ -40,44 +41,16 @@
     scene: Group;
     centerCamera: boolean;
     perf: PerformanceStore;
+    debugData?: Record<number, { type: string; data: Int32Array }>;
   };
 
-  let { scene = $bindable(), centerCamera, perf }: Props = $props();
+  let { scene = $bindable(), centerCamera, debugData, perf }: Props = $props();
-
-  let lines = $state<Vector3[][]>([]);
-
-  function createLineGeometryFromEncodedData(encodedData: Int32Array) {
-    const positions: Vector3[] = [];
-
-    const amount = (encodedData.length - 1) / 4;
-
-    for (let i = 0; i < amount; i++) {
-      const x = decodeFloat(encodedData[2 + i * 4 + 0]);
-      const y = decodeFloat(encodedData[2 + i * 4 + 1]);
-      const z = decodeFloat(encodedData[2 + i * 4 + 2]);
-      positions.push(new Vector3(x, y, z));
-    }
-
-    return positions;
-  }
 
   export const update = function update(result: Int32Array) {
     perf.addPoint('split-result');
     const inputs = splitNestedArray(result);
     perf.endPoint();
 
-    if (appSettings.value.debug.showStemLines) {
-      perf.addPoint('create-lines');
-      lines = inputs
-        .map((input) => {
-          if (input[0] === 0) {
-            return createLineGeometryFromEncodedData(input);
-          }
-        })
-        .filter(Boolean) as Vector3[][];
-      perf.endPoint();
-    }
-
     perf.addPoint('update-geometries');
 
     const { totalVertices, totalFaces } = updateGeometries(inputs, scene);
@@ -97,8 +70,8 @@
   <Canvas>
     <Scene
       bind:this={sceneComponent}
-      {lines}
       {centerCamera}
+      {debugData}
       bind:scene
       bind:fps
     />

app/src/lib/result-viewer/debug.ts

@@ -0,0 +1,90 @@
+import { splitNestedArray } from '@nodarium/utils';
+import {
+  BufferGeometry,
+  type Group,
+  InstancedMesh,
+  Line,
+  LineBasicMaterial,
+  Matrix4,
+  MeshBasicMaterial,
+  SphereGeometry,
+  Vector3
+} from 'three';
+
+function writePath(scene: Group, data: Int32Array): Vector3[] {
+  const positions: Vector3[] = [];
+  const f32 = new Float32Array(data.buffer);
+
+  for (let i = 2; i + 2 < f32.length; i += 4) {
+    const vec = new Vector3(f32[i], f32[i + 1], f32[i + 2]);
+    positions.push(vec);
+  }
+
+  // Path line
+  if (positions.length >= 2) {
+    const geometry = new BufferGeometry().setFromPoints(positions);
+    const line = new Line(
+      geometry,
+      new LineBasicMaterial({ color: 0xff0000, depthTest: false })
+    );
+    scene.add(line);
+  }
+
+  // Instanced spheres at points
+  if (positions.length > 0) {
+    const sphereGeometry = new SphereGeometry(0.05, 8, 8); // keep low-poly
+    const sphereMaterial = new MeshBasicMaterial({
+      color: 0xff0000,
+      depthTest: false
+    });
+
+    const spheres = new InstancedMesh(
+      sphereGeometry,
+      sphereMaterial,
+      positions.length
+    );
+
+    const matrix = new Matrix4();
+    for (let i = 0; i < positions.length; i++) {
+      matrix.makeTranslation(
+        positions[i].x,
+        positions[i].y,
+        positions[i].z
+      );
+      spheres.setMatrixAt(i, matrix);
+    }
+
+    spheres.instanceMatrix.needsUpdate = true;
+    scene.add(spheres);
+  }
+
+  return positions;
+}
+
+function clearGroup(group: Group) {
+  for (let i = group.children.length - 1; i >= 0; i--) {
+    const child = group.children[i];
+    group.remove(child);
+    // optional but correct: free GPU memory
+    // @ts-expect-error three.js runtime fields
+    child.geometry?.dispose?.();
+    // @ts-expect-error three.js runtime fields
+    child.material?.dispose?.();
+  }
+}
+
+export function updateDebugScene(
+  group: Group,
+  data: Record<number, { type: string; data: Int32Array }>
+) {
+  clearGroup(group);
+  return Object.entries(data || {}).map(([, d]) => {
+    switch (d.type) {
+      case 'path':
+        splitNestedArray(d.data)
+          .forEach(p => writePath(group, p));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return (_g: Group) => {};
+  }).flat();
+}

app/src/lib/runtime/runtime-executor.ts

@@ -59,7 +59,7 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
   private definitionMap: Map<string, NodeDefinition> = new Map();
 
   private seed = Math.floor(Math.random() * 100000000);
-  private debugData: Record<string, Int32Array> = {};
+  private debugData: Record<number, { type: string; data: Int32Array }> = {};
 
   perf?: PerformanceStore;
 
@@ -125,10 +125,10 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
       }
     }
 
-    const nodes = [];
+    const nodes = new Map<number, RuntimeNode>();
 
     // loop through all the nodes and assign each nodes its depth
-    const stack = [outputNode];
+    const stack = [outputNode, ...graphNodes.filter(n => n.type.endsWith('/debug'))];
     while (stack.length) {
       const node = stack.pop();
       if (!node) continue;
@@ -137,18 +137,24 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
         parent.state.depth = node.state.depth + 1;
         stack.push(parent);
       }
-      nodes.push(node);
+      nodes.set(node.id, node);
     }
 
     for (const node of graphNodes) {
       if (node.type.endsWith('/debug')) {
         node.state = node.state || {};
-        node.state.depth = Math.min(...node.state.parents.map(s => s.state.depth), 1) - 1;
+        const parent = node.state.parents[0];
-        nodes.push(node);
+        if (parent) {
+          node.state.depth = parent.state.depth - 1;
+          parent.state.debugNode = true;
+        }
+        nodes.set(node.id, node);
       }
     }
 
-    return [outputNode, nodes] as const;
+    const _nodes = [...nodes.values()];
+
+    return [outputNode, _nodes] as const;
   }
 
   async execute(graph: Graph, settings: Record<string, unknown>) {
@@ -247,6 +253,12 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
           log.log(`Using cached value for ${node_type.id || node.id}`);
           this.perf?.addPoint('cache-hit', 1);
           results[node.id] = cachedValue as Int32Array;
+          if (node.state.debugNode && node_type.outputs) {
+            this.debugData[node.id] = {
+              type: node_type.outputs[0],
+              data: cachedValue
+            };
+          }
           continue;
         }
         this.perf?.addPoint('cache-hit', 0);
@@ -255,8 +267,11 @@ export class MemoryRuntimeExecutor implements RuntimeExecutor {
         log.log(`Inputs:`, inputs);
         a = performance.now();
         results[node.id] = node_type.execute(encoded_inputs);
-        if (node_type.id.endsWith('/debug')) {
+        if (node.state.debugNode && node_type.outputs) {
-          this.debugData[node.id] = results[node.id];
+          this.debugData[node.id] = {
+            type: node_type.outputs[0],
+            data: results[node.id]
+          };
         }
         log.log('Executed', node.type, node.id);
         b = performance.now();

app/src/lib/runtime/types.ts

@@ -5,6 +5,7 @@ type RuntimeState = {
   parents: RuntimeNode[];
   children: RuntimeNode[];
   inputNodes: Record<string, RuntimeNode>;
+  debugNode?: boolean;
 };
 
 export type RuntimeNode = SerializedNode & { state: RuntimeState };

app/src/lib/runtime/worker-runtime-executor.ts

@@ -6,12 +6,15 @@ export class WorkerRuntimeExecutor implements RuntimeExecutor {
     new URL(`./worker-runtime-executor-backend.ts`, import.meta.url)
   );
 
-  async execute(graph: Graph, settings: Record<string, unknown>) {
+  execute(graph: Graph, settings: Record<string, unknown>) {
     return this.worker.executeGraph(graph, settings);
   }
-  async getPerformanceData() {
+  getPerformanceData() {
     return this.worker.getPerformanceData();
   }
+  getDebugData() {
+    return this.worker.getDebugData();
+  }
   set useRuntimeCache(useCache: boolean) {
     this.worker.setUseRuntimeCache(useCache);
   }

app/src/lib/settings/app-settings.svelte.ts

@@ -59,26 +59,11 @@ export const AppSettingTypes = {
       label: 'Execute in WebWorker',
       value: true
     },
-    showIndices: {
-      type: 'boolean',
-      label: 'Show Indices',
-      value: false
-    },
     advancedMode: {
       type: 'boolean',
       label: 'Advanced Mode',
       value: false
     },
-    showVertices: {
-      type: 'boolean',
-      label: 'Show Vertices',
-      value: false
-    },
-    showStemLines: {
-      type: 'boolean',
-      label: 'Show Stem Lines',
-      value: false
-    },
     cache: {
       title: 'Cache',
       useRuntimeCache: {

app/src/lib/sidebar/panels/ActiveNodeSelected.svelte

@@ -42,11 +42,13 @@
     const store: Store = {};
     Object.keys(inputs).forEach((key) => {
       if (props) {
-        const value = props[key] || inputs[key].value;
+        const value = props[key] !== undefined ? props[key] : inputs[key].value;
         if (Array.isArray(value) || typeof value === 'number') {
           store[key] = value;
+        } else if (typeof value === 'boolean') {
+          store[key] = value ? 1 : 0;
         } else {
-          console.error('Wrong error');
+          console.error('Wrong error', { value });
         }
       }
     });

app/src/routes/+page.svelte

@@ -68,6 +68,7 @@
   let sidebarOpen = $state(false);
   let graphInterface = $state<ReturnType<typeof GraphInterface>>(null!);
   let viewerComponent = $state<ReturnType<typeof Viewer>>();
+  let debugData = $state<Record<number, { type: string; data: Int32Array }>>();
   const manager = $derived(graphInterface?.manager);
 
   async function randomGenerate() {
@@ -107,6 +108,7 @@
 
       if (appSettings.value.debug.useWorker) {
         let perfData = await runtime.getPerformanceData();
+        debugData = await runtime.getDebugData();
         let lastRun = perfData?.at(-1);
         if (lastRun?.total) {
           lastRun.runtime = lastRun.total;
@@ -165,6 +167,7 @@
         bind:scene
         bind:this={viewerComponent}
         perf={performanceStore}
+        debugData={debugData}
         centerCamera={appSettings.value.centerCamera}
       />
     </Grid.Cell>

package.json

@@ -3,6 +3,7 @@
   "scripts": {
     "postinstall": "pnpm run -r --filter 'ui' build",
     "lint": "pnpm run -r --parallel lint",
+    "qa": "pnpm lint && pnpm check && pnpm test",
     "format": "pnpm dprint fmt",
     "format:check": "pnpm dprint check",
     "test": "pnpm run -r --parallel test",

packages/types/src/inputs.ts

@@ -91,7 +91,8 @@ export const NodeInputPathSchema = z.object({
 
 export const NodeInputAnySchema = z.object({
   ...DefaultOptionsSchema.shape,
-  type: z.literal('*')
+  type: z.literal('*'),
+  value: z.any().optional()
 });
 
 export const NodeInputSchema = z.union([

packages/ui/src/lib/app.css

@@ -3,10 +3,10 @@
   prefix: "i";
 }
 
-@source inline("{hover:,}{bg-,outline-,text-,}layer-0");
+@source inline("{hover:,}{bg-,outline-,text-,}layer-0{/30,/50,}");
-@source inline("{hover:,}{bg-,outline-,text-,}layer-1");
+@source inline("{hover:,}{bg-,outline-,text-,}layer-1{/30,/50,}");
-@source inline("{hover:,}{bg-,outline-,text-,}layer-2");
+@source inline("{hover:,}{bg-,outline-,text-,}layer-2{/30,/50,}");
-@source inline("{hover:,}{bg-,outline-,text-,}layer-3");
+@source inline("{hover:,}{bg-,outline-,text-,}layer-3{/30,/50,}");
 @source inline("{hover:,}{bg-,outline-,text-,}active");
 @source inline("{hover:,}{bg-,outline-,text-,}selected");
 @source inline("{hover:,}{bg-,outline-,text-,}outline{!,}");

packages/utils/src/flatTree.test.ts

@@ -1,5 +1,10 @@
 import { expect, test } from 'vitest';
-import { concatEncodedArrays, decodeNestedArray, encodeNestedArray } from './flatTree';
+import {
+  concatEncodedArrays,
+  decodeNestedArray,
+  encodeNestedArray,
+  splitNestedArray
+} from './flatTree';
 
 test('it correctly concats nested arrays', () => {
   const input_a = encodeNestedArray([1, 2, 3]);
@@ -82,3 +87,80 @@ test('it correctly handles arrays with mixed data types', () => {
   const decoded = decodeNestedArray(encodeNestedArray(input));
   expect(decoded).toEqual(input);
 });
+
+// Test splitNestedArray function
+test('it splits nested array into segments based on structure', () => {
+  const input = [[1, 2], [3, 4]];
+  const encoded = new Int32Array(encodeNestedArray(input));
+  const split = splitNestedArray(encoded);
+
+  // Based on the actual behavior, splitNestedArray returns segments
+  // but the specific behavior needs to match the implementation
+  expect(Array.isArray(split)).toBe(true);
+  expect(split.length).toBe(2);
+  expect(split[0][0]).toBe(1);
+  expect(split[0][1]).toBe(2);
+  expect(split[1][0]).toBe(3);
+  expect(split[1][1]).toBe(4);
+});
+
+// Test splitNestedArray function
+test('it splits nested array into segments based on structure 2', () => {
+  // dprint-ignore
+  const encoded = new Int32Array([
+    0, 1,
+      0, 19,
+        0, 1,
+        0,          0,           0,          1060487823,
+        1067592955, 1079491492, -1086248132, 1056069822,
+       -1078247113, 1086620820,  1073133800, 1047681214,
+       -1068353940, 1094067306,  1078792112, 0,
+      1, 1,
+      0, 19,
+        0, 1,
+        0,          0,           0,          1060487823,
+       -1089446963, 1080524584,  1041006274, 1056069822,
+       -1092176382, 1087031528, -1088851934, 1047681214,
+        1081482392, 1094426140, -1107842261, 0,
+      1, 1,
+    1, 1
+  ]);
+
+  // Should be split into two seperate arrays
+  const split = splitNestedArray(encoded);
+
+  // Based on the actual behavior, splitNestedArray returns segments
+  // but the specific behavior needs to match the implementation
+  expect(Array.isArray(split)).toBe(true);
+  expect(split.length).toBe(2);
+  expect(split[0][0]).toBe(0);
+  expect(split[0][1]).toBe(1);
+  expect(split[1][0]).toBe(0);
+  expect(split[1][1]).toBe(1);
+});
+
+// Test splitNestedArray function
+test('it splits nested array into segments based on structure 2', () => {
+  // dprint-ignore
+  const encoded = new Int32Array( [
+    0, 1,
+      0, 27,
+        0, 1,
+        0, 0,          0, 1065353216,
+        0, 1067757391, 0, 1061997773,
+        0, 1076145999, 0, 1058642330,
+        0, 1081542391, 0, 1053609164,
+        0, 1084534607, 0, 1045220556,
+        0, 1087232803, 0, 0,
+      1, 1,
+    1, 1
+  ]);
+
+  // Should be split into two seperate arrays
+  const split = splitNestedArray(encoded);
+
+  // Based on the actual behavior, splitNestedArray returns segments
+  // but the specific behavior needs to match the implementation
+  expect(Array.isArray(split)).toBe(true);
+  expect(split.length).toBe(1);
+});