@backbay/glia 0.2.0-alpha.1

package/dist/primitives/three/QuantumField/TrailRTT.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Quantum Field Canvas - Trail RTT System
+ *
+ * Ping-pong render target for etch trail accumulation with decay.
+ */
+import * as THREE from "three";
+export declare class TrailRTT {
+    private rtA;
+    private rtB;
+    private current;
+    private updateMaterial;
+    private quad;
+    private scene;
+    private camera;
+    private renderer;
+    constructor(width?: number, height?: number);
+    /**
+     * Initialize with WebGL renderer (must be called once)
+     */
+    init(renderer: THREE.WebGLRenderer): void;
+    /**
+     * Update the trail with optional injection
+     */
+    update(options: {
+        decay?: number;
+        injectPos?: {
+            x: number;
+            y: number;
+        } | null;
+        injectStrength?: number;
+        injectRadius?: number;
+    }): void;
+    /**
+     * Get the current trail texture
+     */
+    getTexture(): THREE.Texture;
+    /**
+     * Set the decay rate
+     */
+    setDecay(decay: number): void;
+    /**
+     * Clear all trails
+     */
+    clear(): void;
+    /**
+     * Resize the RTT buffers
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=TrailRTT.d.ts.map

package/dist/primitives/three/QuantumField/TrailRTT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrailRTT.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/QuantumField/TrailRTT.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiD/B,qBAAa,QAAQ;IACnB,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,GAAG,CAA0B;IACrC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,QAAQ,CAAoC;gBAExC,KAAK,GAAE,MAAY,EAAE,MAAM,GAAE,MAAY;IAoCrD;;OAEG;IACH,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,GAAG,IAAI;IAkBzC;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,GAAG,IAAI;IA6BR;;OAEG;IACH,UAAU,IAAI,KAAK,CAAC,OAAO;IAI3B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B;;OAEG;IACH,KAAK,IAAI,IAAI;IAiBb;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAM3C;;OAEG;IACH,OAAO,IAAI,IAAI;CAMhB"}

package/dist/primitives/three/QuantumField/TrailRTT.js

@@ -0,0 +1,176 @@
+/**
+ * Quantum Field Canvas - Trail RTT System
+ *
+ * Ping-pong render target for etch trail accumulation with decay.
+ */
+import * as THREE from "three";
+// -----------------------------------------------------------------------------
+// Trail Update Shader
+// -----------------------------------------------------------------------------
+const TRAIL_UPDATE_VERTEX = /* glsl */ `
+varying vec2 vUv;
+
+void main() {
+  vUv = uv;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+}
+`;
+const TRAIL_UPDATE_FRAGMENT = /* glsl */ `
+uniform sampler2D uPrevTex;
+uniform float uDecay;
+uniform vec2 uInjectPos; // UV position to inject
+uniform float uInjectStrength; // 0 = no injection
+uniform float uInjectRadius;
+
+varying vec2 vUv;
+
+void main() {
+  // Sample previous frame
+  vec4 prev = texture2D(uPrevTex, vUv);
+  
+  // Apply decay
+  float decayed = prev.r * (1.0 - uDecay);
+  
+  // Inject new trail at position
+  if (uInjectStrength > 0.0) {
+    float dist = length(vUv - uInjectPos);
+    float injection = smoothstep(uInjectRadius, 0.0, dist) * uInjectStrength;
+    decayed = max(decayed, injection);
+  }
+  
+  // Clamp to prevent runaway values
+  decayed = clamp(decayed, 0.0, 1.0);
+  
+  gl_FragColor = vec4(decayed, decayed, decayed, 1.0);
+}
+`;
+// -----------------------------------------------------------------------------
+// Trail RTT Class
+// -----------------------------------------------------------------------------
+export class TrailRTT {
+    rtA;
+    rtB;
+    current;
+    updateMaterial;
+    quad;
+    scene;
+    camera;
+    renderer = null;
+    constructor(width = 512, height = 512) {
+        // Create render targets
+        const rtOptions = {
+            minFilter: THREE.LinearFilter,
+            magFilter: THREE.LinearFilter,
+            format: THREE.RGBAFormat,
+            type: THREE.FloatType,
+        };
+        this.rtA = new THREE.WebGLRenderTarget(width, height, rtOptions);
+        this.rtB = new THREE.WebGLRenderTarget(width, height, rtOptions);
+        this.current = this.rtA;
+        // Create update material
+        this.updateMaterial = new THREE.ShaderMaterial({
+            vertexShader: TRAIL_UPDATE_VERTEX,
+            fragmentShader: TRAIL_UPDATE_FRAGMENT,
+            uniforms: {
+                uPrevTex: { value: null },
+                uDecay: { value: 0.02 },
+                uInjectPos: { value: new THREE.Vector2(0.5, 0.5) },
+                uInjectStrength: { value: 0 },
+                uInjectRadius: { value: 0.02 },
+            },
+        });
+        // Create fullscreen quad
+        const geometry = new THREE.PlaneGeometry(2, 2);
+        this.quad = new THREE.Mesh(geometry, this.updateMaterial);
+        // Create orthographic scene/camera for RTT
+        this.scene = new THREE.Scene();
+        this.scene.add(this.quad);
+        this.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    }
+    /**
+     * Initialize with WebGL renderer (must be called once)
+     */
+    init(renderer) {
+        this.renderer = renderer;
+        // Clear both targets
+        const clearColor = renderer.getClearColor(new THREE.Color());
+        const clearAlpha = renderer.getClearAlpha();
+        renderer.setRenderTarget(this.rtA);
+        renderer.setClearColor(0x000000, 1);
+        renderer.clear();
+        renderer.setRenderTarget(this.rtB);
+        renderer.clear();
+        renderer.setRenderTarget(null);
+        renderer.setClearColor(clearColor, clearAlpha);
+    }
+    /**
+     * Update the trail with optional injection
+     */
+    update(options) {
+        if (!this.renderer)
+            return;
+        const { decay = 0.02, injectPos = null, injectStrength = 0, injectRadius = 0.02 } = options;
+        // Determine source and target
+        const source = this.current;
+        const target = this.current === this.rtA ? this.rtB : this.rtA;
+        // Update uniforms
+        this.updateMaterial.uniforms.uPrevTex.value = source.texture;
+        this.updateMaterial.uniforms.uDecay.value = decay;
+        this.updateMaterial.uniforms.uInjectStrength.value = injectPos ? injectStrength : 0;
+        if (injectPos) {
+            this.updateMaterial.uniforms.uInjectPos.value.set(injectPos.x, injectPos.y);
+        }
+        this.updateMaterial.uniforms.uInjectRadius.value = injectRadius;
+        // Render to target
+        this.renderer.setRenderTarget(target);
+        this.renderer.render(this.scene, this.camera);
+        this.renderer.setRenderTarget(null);
+        // Swap
+        this.current = target;
+    }
+    /**
+     * Get the current trail texture
+     */
+    getTexture() {
+        return this.current.texture;
+    }
+    /**
+     * Set the decay rate
+     */
+    setDecay(decay) {
+        this.updateMaterial.uniforms.uDecay.value = decay;
+    }
+    /**
+     * Clear all trails
+     */
+    clear() {
+        if (!this.renderer)
+            return;
+        const clearColor = this.renderer.getClearColor(new THREE.Color());
+        const clearAlpha = this.renderer.getClearAlpha();
+        this.renderer.setRenderTarget(this.rtA);
+        this.renderer.setClearColor(0x000000, 1);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(this.rtB);
+        this.renderer.clear();
+        this.renderer.setRenderTarget(null);
+        this.renderer.setClearColor(clearColor, clearAlpha);
+    }
+    /**
+     * Resize the RTT buffers
+     */
+    resize(width, height) {
+        this.rtA.setSize(width, height);
+        this.rtB.setSize(width, height);
+        this.clear();
+    }
+    /**
+     * Dispose of all resources
+     */
+    dispose() {
+        this.rtA.dispose();
+        this.rtB.dispose();
+        this.updateMaterial.dispose();
+        this.quad.geometry.dispose();
+    }
+}

package/dist/primitives/three/QuantumField/WaterField.d.ts

@@ -0,0 +1,9 @@
+import type { FieldBus } from "./FieldBus";
+import type { FieldConfig } from "./types";
+interface WaterFieldProps {
+    bus: FieldBus;
+    config: FieldConfig;
+}
+export declare function WaterField({ bus, config }: WaterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=WaterField.d.ts.map

package/dist/primitives/three/QuantumField/WaterField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterField.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/QuantumField/WaterField.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,SAAS,CAAC;AAO9D,UAAU,eAAe;IACvB,GAAG,EAAE,QAAQ,CAAC;IACd,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,wBAAgB,UAAU,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,eAAe,2CAoM1D"}

package/dist/primitives/three/QuantumField/WaterField.js

@@ -0,0 +1,179 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Water Field - Style C Implementation
+ *
+ * A glassy, watery membrane with damped ripple simulation.
+ * Hover creates small ripples; etch writes capillary trails;
+ * click produces impulse rings; latch creates standing wave nodes.
+ */
+import { useFrame, useThree } from "@react-three/fiber";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { clientToNdc } from "./domMapping";
+import { createWaterMaterial, createWaterUniforms } from "./styles/styleC";
+import { WaterSimRTT } from "./WaterSimRTT";
+// Reusable raycast objects
+const _raycaster = new THREE.Raycaster();
+const _ndcVec = new THREE.Vector2();
+const _intersections = [];
+export function WaterField({ bus, config }) {
+    const { camera, size, gl } = useThree();
+    const meshRef = useRef(null);
+    const simRef = useRef(null);
+    const uniformsRef = useRef(null);
+    // Local refs for state
+    const stateRef = useRef(bus.getSnapshot());
+    // Subscribe to bus updates
+    useEffect(() => {
+        const unsub = bus.subscribe((state) => {
+            stateRef.current = state;
+        });
+        return unsub;
+    }, [bus]);
+    // UV computation via raycast
+    const computeUv = useCallback((clientX, clientY) => {
+        if (!meshRef.current)
+            return null;
+        const canvas = gl.domElement;
+        const rect = canvas.getBoundingClientRect();
+        const ndc = clientToNdc(clientX - rect.left, clientY - rect.top, {
+            width: rect.width,
+            height: rect.height,
+        });
+        _ndcVec.set(ndc.x, ndc.y);
+        _raycaster.setFromCamera(_ndcVec, camera);
+        _intersections.length = 0;
+        meshRef.current.raycast(_raycaster, _intersections);
+        if (_intersections.length > 0 && _intersections[0].uv) {
+            return {
+                x: _intersections[0].uv.x,
+                y: _intersections[0].uv.y,
+            };
+        }
+        return null;
+    }, [camera, gl.domElement]);
+    // Calculate plane size
+    const planeSize = useMemo(() => {
+        if (camera instanceof THREE.PerspectiveCamera) {
+            const distance = camera.position.z;
+            const vFov = (camera.fov * Math.PI) / 180;
+            const height = 2 * Math.tan(vFov / 2) * distance;
+            const width = height * (size.width / size.height);
+            return { width: width * 1.2, height: height * 1.2 };
+        }
+        return { width: 20, height: 15 };
+    }, [camera, size]);
+    // Create uniforms
+    const uniforms = useMemo(() => {
+        const u = createWaterUniforms();
+        u.uResolution.value.set(size.width, size.height);
+        u.uProbeRadius.value = config.probeRadius;
+        uniformsRef.current = u;
+        return u;
+    }, [size.width, size.height, config.probeRadius]);
+    // Create material
+    const material = useMemo(() => {
+        return createWaterMaterial(uniforms);
+    }, [uniforms]);
+    // Initialize water simulation
+    useEffect(() => {
+        simRef.current = new WaterSimRTT(config.rttResolution);
+        simRef.current.init(gl);
+        return () => {
+            if (simRef.current) {
+                simRef.current.dispose();
+                simRef.current = null;
+            }
+        };
+    }, [config.rttResolution, gl]);
+    // Track last hover position for continuous ripples
+    const lastHoverRef = useRef(null);
+    // Animation frame
+    useFrame((state, delta) => {
+        if (!meshRef.current || !simRef.current)
+            return;
+        const currentTs = Date.now();
+        const currentState = stateRef.current;
+        const sim = simRef.current;
+        // Process pending bus events
+        bus.processPendingWithUv(computeUv);
+        // Tick the bus
+        bus.tick(delta * 1000, currentTs);
+        // Update time
+        uniforms.uTime.value = state.clock.elapsedTime;
+        // Prepare impulse for this frame
+        let frameImpulse = null;
+        // Handle hover - create small continuous ripples
+        const hover = currentState.hover;
+        if (hover.active) {
+            uniforms.uHover.value.set(hover.uv.x, hover.uv.y, hover.intent === "etch" ? 1 : 0, 1);
+            // Continuous small ripples while hovering
+            const rippleStrength = hover.intent === "etch" ? 0.15 : 0.05;
+            // Only create ripple if position changed (avoid standing waves from stationary hover)
+            if (lastHoverRef.current) {
+                const moved = Math.abs(hover.uv.x - lastHoverRef.current.x) > 0.005 ||
+                    Math.abs(hover.uv.y - lastHoverRef.current.y) > 0.005;
+                if (moved) {
+                    frameImpulse = {
+                        pos: hover.uv,
+                        strength: rippleStrength,
+                        radius: 0.02,
+                    };
+                }
+            }
+            lastHoverRef.current = { ...hover.uv };
+        }
+        else {
+            uniforms.uHover.value.w = 0;
+            lastHoverRef.current = null;
+        }
+        // Handle bursts - strong impulses
+        const impulses = currentState.impulses;
+        for (const imp of impulses) {
+            const age = (currentTs - imp.startTs) / config.impulseDecayMs;
+            // Only add impulse in first frame
+            if (age < 0.05) {
+                frameImpulse = {
+                    pos: imp.uv,
+                    strength: imp.amplitude * 0.5,
+                    radius: imp.radius,
+                };
+            }
+        }
+        // Prepare anchors for simulation
+        const anchors = Array.from(currentState.anchors.values()).map((anchor) => ({
+            uv: anchor.uv,
+            strength: anchor.strength,
+            phase: (currentTs - anchor.createdTs) * 0.001,
+        }));
+        // Update simulation
+        sim.update({
+            time: state.clock.elapsedTime,
+            damping: 0.015, // Lower damping for longer ripples
+            waveSpeed: 0.4,
+            impulsePos: frameImpulse?.pos ?? null,
+            impulseStrength: frameImpulse?.strength ?? 0,
+            impulseRadius: frameImpulse?.radius ?? 0.03,
+            anchors,
+        });
+        // Update shader textures
+        uniforms.uHeightTex.value = sim.getTexture();
+        uniforms.uPrevHeightTex.value = sim.getPrevTexture();
+        // Update anchor uniforms for shader visualization
+        uniforms.uAnchorCount.value = anchors.length;
+        for (let i = 0; i < 8; i++) {
+            if (i < anchors.length) {
+                const a = anchors[i];
+                uniforms.uAnchors.value[i].set(a.uv.x, a.uv.y, a.strength, a.phase);
+            }
+        }
+    });
+    // Dispose on unmount
+    useEffect(() => {
+        return () => {
+            material.dispose();
+        };
+    }, [material]);
+    return (_jsx("mesh", { ref: meshRef, position: [0, 0, 0], material: material, children: _jsx("planeGeometry", { args: [planeSize.width, planeSize.height] }) }));
+}

package/dist/primitives/three/QuantumField/WaterSimRTT.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Water Simulation RTT
+ *
+ * Ping-pong render targets implementing the damped wave equation for
+ * realistic water ripple simulation.
+ *
+ * Wave equation: d²h/dt² = c² * ∇²h - damping * dh/dt
+ * Discretized: h[t+1] = 2*h[t] - h[t-1] + c²*(laplacian) - damping*(h[t] - h[t-1])
+ */
+import * as THREE from "three";
+export declare class WaterSimRTT {
+    private rtCurrent;
+    private rtPrev;
+    private rtTemp;
+    private updateMaterial;
+    private quad;
+    private scene;
+    private camera;
+    private renderer;
+    constructor(resolution?: number);
+    /**
+     * Initialize with WebGL renderer
+     */
+    init(renderer: THREE.WebGLRenderer): void;
+    /**
+     * Run one simulation step
+     */
+    update(options: {
+        time: number;
+        damping?: number;
+        waveSpeed?: number;
+        impulsePos?: {
+            x: number;
+            y: number;
+        } | null;
+        impulseStrength?: number;
+        impulseRadius?: number;
+        anchors?: Array<{
+            uv: {
+                x: number;
+                y: number;
+            };
+            strength: number;
+            phase: number;
+        }>;
+    }): void;
+    /**
+     * Add an impulse at a specific position
+     */
+    addImpulse(pos: {
+        x: number;
+        y: number;
+    }, strength: number, radius: number): void;
+    /**
+     * Get the current height texture
+     */
+    getTexture(): THREE.Texture;
+    /**
+     * Get the previous height texture (for velocity computation)
+     */
+    getPrevTexture(): THREE.Texture;
+    /**
+     * Clear the simulation
+     */
+    clear(): void;
+    /**
+     * Resize the simulation
+     */
+    resize(resolution: number): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=WaterSimRTT.d.ts.map

package/dist/primitives/three/QuantumField/WaterSimRTT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterSimRTT.d.ts","sourceRoot":"","sources":["../../../../src/primitives/three/QuantumField/WaterSimRTT.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAsF/B,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,QAAQ,CAAoC;gBAExC,UAAU,GAAE,MAAY;IA0CpC;;OAEG;IACH,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,GAAG,IAAI;IAKzC;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE;YAAE,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAC;QAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE;gBAAE,CAAC,EAAE,MAAM,CAAC;gBAAC,CAAC,EAAE,MAAM,CAAA;aAAE,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACpF,GAAG,IAAI;IA+CR;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAOjF;;OAEG;IACH,UAAU,IAAI,KAAK,CAAC,OAAO;IAI3B;;OAEG;IACH,cAAc,IAAI,KAAK,CAAC,OAAO;IAI/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAoBb;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAQhC;;OAEG;IACH,OAAO,IAAI,IAAI;CAOhB"}