@vibecook/ice 0.10.0 → 0.11.0

package/dist/devtools.js

@@ -14,7 +14,7 @@ import {
   WheelPan,
   WheelZoom,
   Wire
-} from "./chunk-5FQS7V2C.js";
+} from "./chunk-VGVDJZSP.js";
 import "./chunk-OR5FNVUE.js";
 
 // ../devtools/src/attach.ts

package/dist/dom.js

@@ -19,8 +19,8 @@ import {
   startRafLoop,
   wheelCede,
   wireMeasurement
-} from "./chunk-JWRHAM7L.js";
-import "./chunk-5FQS7V2C.js";
+} from "./chunk-2TNVB2ON.js";
+import "./chunk-VGVDJZSP.js";
 import "./chunk-OR5FNVUE.js";
 export {
   CLAIM_OWNS_ESCAPE,

package/dist/ground.js

@@ -29,7 +29,7 @@ import {
   defineQuery,
   portSlots,
   widgets
-} from "./chunk-5FQS7V2C.js";
+} from "./chunk-VGVDJZSP.js";
 import {
   portAnchor,
   tessellateCubic,
@@ -141,93 +141,14 @@ function createLayer(host, world, renderer, passes) {
   };
 }
 
-// ../ground/src/passes/grid.ts
-import { Group as Group2 } from "three/webgpu";
-
-// ../ground/src/passes/grid-classic.ts
-import {
-  clamp,
-  float,
-  fract,
-  length,
-  max,
-  min,
-  mix,
-  positionGeometry,
-  screenCoordinate,
-  smoothstep,
-  uniform,
-  vec4
-} from "three/tsl";
-import {
-  BufferAttribute,
-  BufferGeometry,
-  Mesh,
-  MeshBasicNodeMaterial,
-  Vector2,
-  Vector3
-} from "three/webgpu";
-var FULLSCREEN_TRIANGLE = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);
-function createClassicGrid(cfg) {
-  const uCamera = uniform(new Vector2(0, 0));
-  const uZoom = uniform(1);
-  const uDpr = uniform(1);
-  const uSpacings = uniform(new Vector3(...cfg.spacings));
-  const uDotColor = uniform(new Vector3(...cfg.dotColor));
-  const uDotAlpha = uniform(cfg.dotAlpha);
-  const uFadeIn = uniform(new Vector2(...cfg.fadeIn));
-  const uFadeOut = uniform(new Vector2(...cfg.fadeOut));
-  const uDotRadius = uniform(new Vector2(...cfg.dotRadius));
-  const uLevelWeight = uniform(new Vector2(...cfg.levelWeight));
-  const effZoom = uZoom.mul(uDpr);
-  const worldPos = screenCoordinate.xy.div(effZoom).add(uCamera);
-  let total = float(0);
-  for (let i = 0; i < 3; i++) {
-    const spacing = i === 0 ? uSpacings.x : i === 1 ? uSpacings.y : uSpacings.z;
-    const cssSpacing = spacing.mul(uZoom);
-    const rise = cssSpacing.sub(uFadeIn.x).div(uFadeIn.y.sub(uFadeIn.x));
-    const fall = float(1).sub(cssSpacing.sub(uFadeOut.x).div(uFadeOut.y.sub(uFadeOut.x)));
-    const opacity = clamp(min(rise, fall), 0, 1);
-    const f = fract(worldPos.div(spacing).add(0.5)).sub(0.5);
-    const dist = length(f).mul(spacing).mul(effZoom);
-    const t = clamp(cssSpacing.sub(uFadeIn.x).div(40), 0, 1);
-    const radius = mix(uDotRadius.x, uDotRadius.y, t).mul(uDpr);
-    const dot = smoothstep(radius.sub(0.5), radius.add(0.5), dist).oneMinus();
-    const weight = uLevelWeight.x.add(float(i).mul(uLevelWeight.y));
-    total = max(total, dot.mul(opacity).mul(weight));
-  }
-  const material = new MeshBasicNodeMaterial();
-  material.vertexNode = vec4(positionGeometry.xy, 0, 1);
-  material.fragmentNode = vec4(uDotColor, clamp(total.mul(uDotAlpha), 0, 1));
-  material.transparent = true;
-  material.depthTest = false;
-  material.depthWrite = false;
-  const geometry = new BufferGeometry();
-  geometry.setAttribute("position", new BufferAttribute(FULLSCREEN_TRIANGLE, 3));
-  const mesh = new Mesh(geometry, material);
-  mesh.frustumCulled = false;
-  mesh.renderOrder = 0;
-  return {
-    mesh,
-    setCamera(frame) {
-      uCamera.value.set(frame.camera.x, frame.camera.y);
-      uZoom.value = frame.camera.zoom;
-      uDpr.value = frame.dpr;
-    },
-    configure(next) {
-      uSpacings.value.set(...next.spacings);
-      uDotColor.value.set(...next.dotColor);
-      uDotAlpha.value = next.dotAlpha;
-      uFadeIn.value.set(...next.fadeIn);
-      uFadeOut.value.set(...next.fadeOut);
-      uDotRadius.value.set(...next.dotRadius);
-      uLevelWeight.value.set(...next.levelWeight);
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
+// ../ground/src/passes/grid-contract.ts
+function mergeGridConfig(base, next) {
+  const merged = { ...base, ...next };
+  if (next.magnet !== void 0) merged.magnet = { ...base.magnet, ...next.magnet };
+  return merged;
+}
+function resolveInitialGridConfig(initial) {
+  return mergeGridConfig(DEFAULT_GRID_CONFIG, initial);
 }
 
 // ../ground/src/passes/grid-magnet.ts
@@ -236,37 +157,37 @@ import {
   If,
   Loop,
   abs,
-  clamp as clamp2,
-  float as float2,
+  clamp,
+  float,
   instanceIndex,
   int,
-  length as length2,
-  max as max2,
-  min as min2,
-  mix as mix2,
+  length,
+  max,
+  min,
+  mix,
   mod,
-  positionGeometry as positionGeometry2,
+  positionGeometry,
   select,
   sign,
-  smoothstep as smoothstep2,
+  smoothstep,
   sqrt,
   storage,
-  uniform as uniform2,
+  uniform,
   varying,
   vec2,
-  vec4 as vec42,
+  vec4,
   Continue,
   Discard
 } from "three/tsl";
 import {
-  BufferAttribute as BufferAttribute2,
+  BufferAttribute,
   Group,
   InstancedBufferGeometry,
-  Mesh as Mesh2,
-  MeshBasicNodeMaterial as MeshBasicNodeMaterial2,
+  Mesh,
+  MeshBasicNodeMaterial,
   StorageBufferAttribute,
-  Vector2 as Vector22,
-  Vector3 as Vector32
+  Vector2,
+  Vector3
 } from "three/webgpu";
 
 // ../ground/src/passes/soup-collect.ts
@@ -618,33 +539,33 @@ function createMagnetGrid() {
   const sourceArray = new Float32Array(MAX_MAGNET_SOURCES * MAGNET_SOURCE_FLOATS);
   const sourceAttr = new StorageBufferAttribute(sourceArray, 4);
   const sourceBuf = storage(sourceAttr, "vec4", MAX_MAGNET_SOURCES * 2).setPBO(true).toReadOnly();
-  const uCam = uniform2(new Vector22(0, 0));
-  const uZoom = uniform2(1);
-  const uView = uniform2(new Vector22(1, 1));
-  const uDotMode = uniform2(0);
-  const uHalfLen = uniform2(5);
-  const uHalfWidth = uniform2(0.55);
-  const uRestRadius = uniform2(0.75);
-  const uK = uniform2(0);
-  const uPad = uniform2(0);
-  const uPolarity = uniform2(1);
-  const uAlwaysAlign = uniform2(0);
-  const uCount = uniform2(0, "int");
-  const uColor = uniform2(new Vector32(0.75, 0.77, 0.8));
-  const EPS = float2(25);
+  const uCam = uniform(new Vector2(0, 0));
+  const uZoom = uniform(1);
+  const uView = uniform(new Vector2(1, 1));
+  const uDotMode = uniform(0);
+  const uHalfLen = uniform(5);
+  const uHalfWidth = uniform(0.55);
+  const uRestRadius = uniform(0.75);
+  const uK = uniform(0);
+  const uPad = uniform(0);
+  const uPolarity = uniform(1);
+  const uAlwaysAlign = uniform(0);
+  const uCount = uniform(0, "int");
+  const uColor = uniform(new Vector3(0.75, 0.77, 0.8));
+  const EPS = float(25);
   const REST = vec2(0, 1);
   const sdRoundBox = Fn(([p, b, r]) => {
     const q = abs(p).sub(b).add(vec2(r, r));
-    return length2(max2(q, vec2(0, 0))).add(min2(max2(q.x, q.y), 0)).sub(r);
+    return length(max(q, vec2(0, 0))).add(min(max(q.x, q.y), 0)).sub(r);
   });
   const roundBoxNormal = Fn(([p, b, r]) => {
     const s = sign(p);
     const q = abs(p);
-    const inner = max2(b.sub(vec2(r, r)), vec2(0, 0));
+    const inner = max(b.sub(vec2(r, r)), vec2(0, 0));
     const d = q.sub(inner);
     const n = vec2(0, 0).toVar();
     If(d.x.greaterThan(0).and(d.y.greaterThan(0)), () => {
-      const len = length2(d);
+      const len = length(d);
       If(len.greaterThan(1e-4), () => {
         n.assign(s.mul(d.div(len)));
       }).Else(() => {
@@ -658,33 +579,33 @@ function createMagnetGrid() {
     return n;
   });
   const safeNormalize = Fn(([v, fallback]) => {
-    const n = length2(v);
-    return select(n.greaterThan(1e-4), v.div(max2(n, 1e-4)), fallback);
+    const n = length(v);
+    return select(n.greaterThan(1e-4), v.div(max(n, 1e-4)), fallback);
   });
   const group = new Group();
   const geometries = [];
   const materials = [];
   const meshes = [];
   const levelUniforms = Array.from({ length: LEVELS }, () => ({
-    origin: uniform2(new Vector22(0, 0)),
-    dims: uniform2(new Vector22(1, 1)),
-    spacing: uniform2(20),
-    alpha: uniform2(0),
-    skipMod: uniform2(0)
+    origin: uniform(new Vector2(0, 0)),
+    dims: uniform(new Vector2(1, 1)),
+    spacing: uniform(20),
+    alpha: uniform(0),
+    skipMod: uniform(0)
   }));
   for (let level = 0; level < LEVELS; level++) {
     const lu = levelUniforms[level];
     const vUv = varying(vec2(0, 0), `vMagnetUv${level}`);
-    const vAlpha = varying(float2(0), `vMagnetAlpha${level}`);
+    const vAlpha = varying(float(0), `vMagnetAlpha${level}`);
     const vertexNode = Fn(() => {
-      const iid = float2(instanceIndex);
+      const iid = float(instanceIndex);
       const cols = lu.dims.x;
-      const col = mod(iid, cols).floor();
-      const row = iid.div(cols).floor();
+      const col = mod(iid, cols).floor().toVar();
+      const row = iid.div(cols).floor().toVar();
       const world = lu.origin.add(vec2(col, row)).mul(lu.spacing);
-      const screen = world.sub(uCam).mul(uZoom);
+      const screen = world.sub(uCam).mul(uZoom).toVar();
       const field = vec2(0, 0).toVar();
-      const minD = float2(1e9).toVar();
+      const minD = float(1e9).toVar();
       Loop({ start: int(0), end: uCount, type: "int", condition: "<" }, ({ i }) => {
         const a = sourceBuf.element(i.mul(2));
         const b = sourceBuf.element(i.mul(2).add(1));
@@ -693,7 +614,7 @@ function createMagnetGrid() {
         const rad = b.x;
         const strength = b.y;
         const rel = screen.sub(center);
-        const reach = uPad.mul(sqrt(max2(strength, 1e-4)));
+        const reach = uPad.mul(sqrt(max(strength, 1e-4)));
         If(
           abs(rel.x).greaterThan(half.x.add(reach)).or(abs(rel.y).greaterThan(half.y.add(reach))),
           () => {
@@ -701,32 +622,32 @@ function createMagnetGrid() {
           }
         );
         const d = sdRoundBox(rel, half, rad);
-        minD.assign(min2(minD, d));
-        const dist = max2(d, 0);
+        minD.assign(min(minD, d));
+        const dist = max(d, 0);
         const r2 = dist.mul(dist).add(EPS);
         const outward = roundBoxNormal(rel, half, rad);
         field.subAssign(outward.mul(uK.mul(strength).mul(uPolarity).div(r2)));
       });
       const fieldDir = safeNormalize(field, REST);
-      const mag = length2(field);
-      const influence = select(uDotMode.greaterThan(0.5), mag.div(mag.add(1)), clamp2(mag, 0, 1));
-      const corner = positionGeometry2.xy;
-      const dotRadius = mix2(uRestRadius, uHalfLen.mul(1.05), influence);
-      const dotLocal = corner.mul(dotRadius);
+      const mag = length(field);
+      const influence = select(uDotMode.greaterThan(0.5), mag.div(mag.add(1)), clamp(mag, 0, 1));
+      const corner = positionGeometry.xy;
+      const dotRadius = mix(uRestRadius, uHalfLen.mul(1.05), influence);
+      const dotLocal = vec2(corner.x, corner.y.negate()).mul(dotRadius);
       const dir = select(
         uAlwaysAlign.greaterThan(0.5),
         fieldDir,
-        safeNormalize(mix2(REST, fieldDir, influence), REST)
+        safeNormalize(mix(REST, fieldDir, influence), REST)
       );
       const nrm = vec2(dir.y.negate(), dir.x);
-      const nLen = mix2(uHalfLen.mul(0.55), uHalfLen.mul(1.35), influence);
-      const nWid = mix2(uHalfWidth.mul(0.85), uHalfWidth.mul(1.15), influence);
+      const nLen = mix(uHalfLen.mul(0.55), uHalfLen.mul(1.35), influence);
+      const nWid = mix(uHalfWidth.mul(0.85), uHalfWidth.mul(1.15), influence);
       const needleLocal = nrm.mul(corner.x).mul(nWid).add(dir.mul(corner.y).mul(nLen));
       const local = select(uDotMode.greaterThan(0.5), dotLocal, needleLocal);
       const pos = screen.add(local);
-      const restAlpha = select(uDotMode.greaterThan(0.5), float2(0.72), float2(0.35));
-      const fieldAlpha = mix2(restAlpha, float2(1), influence);
-      const alpha = clamp2(lu.alpha.mul(fieldAlpha), 0, 1).toVar();
+      const restAlpha = select(uDotMode.greaterThan(0.5), float(0.72), float(0.35));
+      const fieldAlpha = mix(restAlpha, float(1), influence);
+      const alpha = clamp(lu.alpha.mul(fieldAlpha), 0, 1).toVar();
       If(minD.lessThan(-0.5), () => {
         alpha.assign(0);
       });
@@ -742,29 +663,29 @@ function createMagnetGrid() {
       vAlpha.assign(alpha);
       const ndc = vec2(
         pos.x.div(uView.x).mul(2).sub(1),
-        float2(1).sub(pos.y.div(uView.y).mul(2))
+        float(1).sub(pos.y.div(uView.y).mul(2))
       );
-      return vec42(ndc, 0, 1);
+      return vec4(ndc, 0, 1);
     })();
     const fragmentNode = Fn(() => {
-      const dotEdge = float2(1).sub(smoothstep2(0.62, 1, length2(vUv)));
-      const ax = float2(1).sub(smoothstep2(0.55, 1, abs(vUv.x)));
-      const ay = float2(1).sub(smoothstep2(0.82, 1, abs(vUv.y)));
+      const dotEdge = float(1).sub(smoothstep(0.62, 1, length(vUv)));
+      const ax = float(1).sub(smoothstep(0.55, 1, abs(vUv.x)));
+      const ay = float(1).sub(smoothstep(0.82, 1, abs(vUv.y)));
       const edge = select(uDotMode.greaterThan(0.5), dotEdge, ax.mul(ay));
       const a = vAlpha.mul(edge);
       Discard(a.lessThan(0.01));
-      return vec42(uColor, a);
+      return vec4(uColor, a);
     })();
-    const material = new MeshBasicNodeMaterial2();
+    const material = new MeshBasicNodeMaterial();
     material.vertexNode = vertexNode;
     material.fragmentNode = fragmentNode;
     material.transparent = true;
     material.depthTest = false;
     material.depthWrite = false;
     const geometry = new InstancedBufferGeometry();
-    geometry.setAttribute("position", new BufferAttribute2(CORNERS, 3));
+    geometry.setAttribute("position", new BufferAttribute(CORNERS, 3));
     geometry.instanceCount = 0;
-    const mesh = new Mesh2(geometry, material);
+    const mesh = new Mesh(geometry, material);
     mesh.frustumCulled = false;
     mesh.renderOrder = 0;
     mesh.visible = false;
@@ -820,51 +741,28 @@ function createMagnetGrid() {
   };
 }
 
-// ../ground/src/passes/grid.ts
-function mergeGridConfig(base, next) {
-  const merged = { ...base, ...next };
-  if (next.magnet !== void 0) merged.magnet = { ...base.magnet, ...next.magnet };
-  return merged;
-}
-function createGridPass(initial = {}, deps = {}) {
-  let cfg = mergeGridConfig(DEFAULT_GRID_CONFIG, initial);
-  const group = new Group2();
-  const classic = createClassicGrid(cfg);
-  group.add(classic.mesh);
-  let magnet = null;
+// ../ground/src/passes/grid-magnet-pass.ts
+var createGridPass = (initial = {}, deps = {}) => {
+  let cfg = resolveInitialGridConfig(initial);
+  const renderer = createMagnetGrid();
   const poles = deps.poles ?? [];
   const sourceScratch = new Float32Array(MAX_MAGNET_SOURCES * MAGNET_SOURCE_FLOATS);
   const poleScratch = [];
   return {
     name: "grid",
-    object: group,
+    object: renderer.group,
     arm(world, wake) {
       const wakeIfWidgets = () => {
-        const m = resolveMagnet(cfg);
-        if (m.enabled && m.widgets && deps.readSpatial !== void 0) wake();
-      };
-      const wakeIfEnabled = () => {
-        if (resolveMagnet(cfg).enabled) wake();
+        const magnet = resolveMagnet(cfg);
+        if (magnet.widgets && deps.readSpatial !== void 0) wake();
       };
       const unsubs = [world.reactive.observeResource(SpatialVersion, wakeIfWidgets)];
-      for (const source of poles) unsubs.push(source.subscribe(world, wakeIfEnabled));
+      for (const source of poles) unsubs.push(source.subscribe(world, wake));
       return unsubs;
     },
     collect(world, frame) {
-      const m = resolveMagnet(cfg);
-      if (!m.enabled) {
-        classic.mesh.visible = true;
-        if (magnet !== null) magnet.group.visible = false;
-        classic.setCamera(frame);
-        return;
-      }
-      if (magnet === null) {
-        magnet = createMagnetGrid();
-        group.add(magnet.group);
-      }
-      classic.mesh.visible = false;
-      magnet.group.visible = true;
-      const fieldScale = magnetFieldScale(frame.camera.zoom, m.fadeZoom);
+      const magnet = resolveMagnet(cfg);
+      const fieldScale = magnetFieldScale(frame.camera.zoom, magnet.fadeZoom);
       poleScratch.length = 0;
       if (fieldScale > 0) {
         for (const source of poles) poleScratch.push(...source.read(world));
@@ -872,26 +770,23 @@ function createGridPass(initial = {}, deps = {}) {
       const sourceCount = collectMagnetSources(
         world,
         frame,
-        m,
+        magnet,
         fieldScale,
         poleScratch,
         deps.readSpatial,
         sourceScratch
       );
       const levels = collectMagnetLevels(frame, cfg);
-      magnet.update(frame, cfg, m, levels, sourceScratch, sourceCount);
+      renderer.update(frame, cfg, magnet, levels, sourceScratch, sourceCount);
     },
     configure(next) {
       cfg = mergeGridConfig(cfg, next);
-      classic.configure(cfg);
     },
     dispose() {
-      classic.dispose();
-      magnet?.dispose();
-      magnet = null;
+      renderer.dispose();
     }
   };
-}
+};
 
 // ../ground/src/passes/guides-collect.ts
 var guideQ = defineQuery([GuideLine]);
@@ -947,17 +842,17 @@ function collectGuides(world, frame, config = DEFAULT_SNAP_GUIDES_CONFIG) {
 
 // ../ground/src/passes/soup-mesh.ts
 import { attribute } from "three/tsl";
-import { BufferAttribute as BufferAttribute3, BufferGeometry as BufferGeometry2, DoubleSide, Mesh as Mesh3, MeshBasicNodeMaterial as MeshBasicNodeMaterial3 } from "three/webgpu";
+import { BufferAttribute as BufferAttribute2, BufferGeometry, DoubleSide, Mesh as Mesh2, MeshBasicNodeMaterial as MeshBasicNodeMaterial2 } from "three/webgpu";
 function createSoupMesh(renderOrder) {
-  const material = new MeshBasicNodeMaterial3();
+  const material = new MeshBasicNodeMaterial2();
   material.fragmentNode = attribute("color", "vec4");
   material.transparent = true;
   material.depthTest = false;
   material.depthWrite = false;
   material.side = DoubleSide;
-  let geometry = new BufferGeometry2();
+  let geometry = new BufferGeometry();
   let capacity = 0;
-  const mesh = new Mesh3(geometry, material);
+  const mesh = new Mesh2(geometry, material);
   mesh.frustumCulled = false;
   mesh.renderOrder = renderOrder;
   mesh.visible = false;
@@ -972,13 +867,13 @@ function createSoupMesh(renderOrder) {
       if (soup.vertexCount > capacity) {
         capacity = Math.max(soup.vertexCount, capacity * 2, 256);
         const old = geometry;
-        geometry = new BufferGeometry2();
+        geometry = new BufferGeometry();
         const pos = new Float32Array(capacity * 3);
         const col = new Float32Array(capacity * 4);
         pos.set(soup.positions);
         col.set(soup.colors);
-        geometry.setAttribute("position", new BufferAttribute3(pos, 3));
-        geometry.setAttribute("color", new BufferAttribute3(col, 4));
+        geometry.setAttribute("position", new BufferAttribute2(pos, 3));
+        geometry.setAttribute("color", new BufferAttribute2(col, 4));
         mesh.geometry = geometry;
         old.dispose();
       } else {