@viji-dev/core 0.3.23 → 0.3.25

package/dist/assets/{viji.worker-DTQvTudb.js → viji.worker-Zg128woJ.js}

@@ -201,6 +201,27 @@ class ParameterSystem {
     this.parameterObjects.set(paramName, imageObject);
     return imageObject;
   }
+  createButtonParameter(config) {
+    const paramName = config.label;
+    const buttonObject = {
+      value: false,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "button",
+      defaultValue: false,
+      label: buttonObject.label,
+      description: buttonObject.description,
+      group: buttonObject.group,
+      category: buttonObject.category
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, buttonObject);
+    return buttonObject;
+  }
   storeParameterDefinition(name, definition) {
     this.parameterDefinitions.set(name, definition);
     this.parameterValues.set(name, definition.defaultValue);
@@ -277,8 +298,14 @@ class ParameterSystem {
         }
         break;
       case "image":
-        if (value !== null && !(value instanceof ImageBitmap) && !(value instanceof OffscreenCanvas)) {
-          console.error(`Parameter '${name}' must be null, ImageBitmap, or OffscreenCanvas, got: ${value}`);
+        if (value !== null && !(value instanceof ImageBitmap)) {
+          console.error(`Parameter '${name}' must be null or ImageBitmap, got: ${value}`);
+          return false;
+        }
+        break;
+      case "button":
+        if (typeof value !== "boolean") {
+          console.error(`Parameter '${name}' must be a boolean, got: ${value}`);
           return false;
         }
         break;
@@ -338,10 +365,29 @@ class ParameterSystem {
   getAllParameterObjects() {
     return this.parameterObjects;
   }
+  /**
+   * Reset all button parameters to false after each frame.
+   * Buttons are momentary: true for exactly 1 frame when pressed, then auto-reset.
+   */
+  resetButtonParameters() {
+    for (const [name, definition] of this.parameterDefinitions) {
+      if (definition.type === "button") {
+        const paramObj = this.parameterObjects.get(name);
+        if (paramObj && paramObj.value === true) {
+          paramObj.value = false;
+          this.parameterValues.set(name, false);
+        }
+      }
+    }
+  }
 }
 class InteractionSystem {
   // Interaction enabled state
   isEnabled = true;
+  // Previous button bitmask for detecting press/release transitions
+  previousButtons = 0;
+  // Previous touch positions for computing deltas and velocity
+  previousTouchPositions = /* @__PURE__ */ new Map();
   // Mouse interaction state
   mouseState = {
     x: 0,
@@ -351,7 +397,6 @@ class InteractionSystem {
     leftButton: false,
     rightButton: false,
     middleButton: false,
-    velocity: { x: 0, y: 0 },
     deltaX: 0,
     deltaY: 0,
     wheelDelta: 0,
@@ -374,7 +419,9 @@ class InteractionSystem {
     shift: false,
     ctrl: false,
     alt: false,
-    meta: false
+    meta: false,
+    textureData: null
+    // Assigned in constructor body
   };
   // Touch interaction state
   touchState = {
@@ -383,23 +430,26 @@ class InteractionSystem {
     started: [],
     moved: [],
     ended: [],
-    primary: null,
-    gestures: {
-      isPinching: false,
-      isRotating: false,
-      isPanning: false,
-      isTapping: false,
-      pinchScale: 1,
-      pinchDelta: 0,
-      rotationAngle: 0,
-      rotationDelta: 0,
-      panDelta: { x: 0, y: 0 },
-      tapCount: 0,
-      lastTapTime: 0,
-      tapPosition: null
-    }
+    primary: null
+  };
+  // Keyboard texture buffer (256x3, Shadertoy-compatible)
+  // Row 0: held state, Row 1: pressed this frame, Row 2: toggle
+  keyboardTextureData = new Uint8Array(256 * 3);
+  // Unified pointer state (derived from mouse + touch)
+  pointerState = {
+    x: 0,
+    y: 0,
+    deltaX: 0,
+    deltaY: 0,
+    isDown: false,
+    wasPressed: false,
+    wasReleased: false,
+    isInCanvas: false,
+    type: "none"
   };
+  previousPointerDown = false;
   constructor() {
+    this.keyboardState.textureData = this.keyboardTextureData;
     this.handleMouseUpdate = this.handleMouseUpdate.bind(this);
     this.handleKeyboardUpdate = this.handleKeyboardUpdate.bind(this);
     this.handleTouchUpdate = this.handleTouchUpdate.bind(this);
@@ -412,7 +462,8 @@ class InteractionSystem {
     return {
       mouse: this.mouseState,
       keyboard: this.keyboardState,
-      touches: this.touchState
+      touches: this.touchState,
+      pointer: this.pointerState
     };
   }
   /**
@@ -422,17 +473,17 @@ class InteractionSystem {
     this.mouseState.wasPressed = false;
     this.mouseState.wasReleased = false;
     this.mouseState.wasMoved = false;
+    this.mouseState.deltaX = 0;
+    this.mouseState.deltaY = 0;
     this.mouseState.wheelDelta = 0;
     this.mouseState.wheelX = 0;
     this.mouseState.wheelY = 0;
     this.keyboardState.pressedThisFrame.clear();
     this.keyboardState.releasedThisFrame.clear();
+    this.keyboardTextureData.fill(0, 256, 512);
     this.touchState.started = [];
     this.touchState.moved = [];
     this.touchState.ended = [];
-    this.touchState.gestures.isTapping = false;
-    this.touchState.gestures.pinchDelta = 0;
-    this.touchState.gestures.rotationDelta = 0;
   }
   /**
    * Handle mouse update messages from the host
@@ -446,16 +497,17 @@ class InteractionSystem {
     this.mouseState.rightButton = (data.buttons & 2) !== 0;
     this.mouseState.middleButton = (data.buttons & 4) !== 0;
     this.mouseState.isPressed = data.buttons > 0;
-    this.mouseState.deltaX = data.deltaX || 0;
-    this.mouseState.deltaY = data.deltaY || 0;
+    this.mouseState.deltaX += data.deltaX || 0;
+    this.mouseState.deltaY += data.deltaY || 0;
     this.mouseState.wheelDelta += data.wheelDeltaY || 0;
     this.mouseState.wheelX += data.wheelDeltaX || 0;
     this.mouseState.wheelY += data.wheelDeltaY || 0;
-    this.mouseState.velocity.x = data.deltaX || 0;
-    this.mouseState.velocity.y = data.deltaY || 0;
-    this.mouseState.wasPressed = this.mouseState.wasPressed || (data.wasPressed || false);
-    this.mouseState.wasReleased = this.mouseState.wasReleased || (data.wasReleased || false);
+    const justPressed = data.buttons & ~this.previousButtons;
+    const justReleased = this.previousButtons & ~data.buttons;
+    this.mouseState.wasPressed = this.mouseState.wasPressed || justPressed !== 0;
+    this.mouseState.wasReleased = this.mouseState.wasReleased || justReleased !== 0;
     this.mouseState.wasMoved = this.mouseState.wasMoved || (data.deltaX !== 0 || data.deltaY !== 0);
+    this.previousButtons = data.buttons;
   }
   /**
    * Handle keyboard update messages from the host
@@ -468,11 +520,21 @@ class InteractionSystem {
         this.keyboardState.activeKeys.add(key);
         this.keyboardState.pressedThisFrame.add(key);
         this.keyboardState.lastKeyPressed = data.key;
+        const kc = data.keyCode;
+        if (kc !== void 0 && kc >= 0 && kc <= 255) {
+          this.keyboardTextureData[kc] = 255;
+          this.keyboardTextureData[256 + kc] = 255;
+          this.keyboardTextureData[512 + kc] ^= 255;
+        }
       }
     } else if (data.type === "keyup") {
       this.keyboardState.activeKeys.delete(key);
       this.keyboardState.releasedThisFrame.add(key);
       this.keyboardState.lastKeyReleased = data.key;
+      const kc = data.keyCode;
+      if (kc !== void 0 && kc >= 0 && kc <= 255) {
+        this.keyboardTextureData[kc] = 0;
+      }
     }
     this.keyboardState.shift = data.shiftKey;
     this.keyboardState.ctrl = data.ctrlKey;
@@ -484,52 +546,92 @@ class InteractionSystem {
    */
   handleTouchUpdate(data) {
     if (!this.isEnabled) return;
-    this.touchState.started = [];
-    this.touchState.moved = [];
-    this.touchState.ended = [];
-    const touches = data.touches.map((touch) => ({
-      id: touch.identifier,
-      x: touch.clientX,
-      y: touch.clientY,
-      pressure: touch.pressure || 0,
-      radius: Math.max(touch.radiusX || 0, touch.radiusY || 0),
-      radiusX: touch.radiusX || 0,
-      radiusY: touch.radiusY || 0,
-      rotationAngle: touch.rotationAngle || 0,
-      force: touch.force || touch.pressure || 0,
-      deltaX: 0,
-      // Could be calculated if we track previous positions
-      deltaY: 0,
-      velocity: { x: 0, y: 0 },
-      // Could be calculated if we track movement
-      isNew: data.type === "touchstart",
-      isActive: true,
-      isEnding: data.type === "touchend" || data.type === "touchcancel"
-    }));
-    this.touchState.points = touches;
-    this.touchState.count = touches.length;
-    this.touchState.primary = touches[0] || null;
+    const touches = data.touches.map((touch) => {
+      const id = touch.identifier;
+      const ended = !!touch.ended;
+      let deltaX = 0;
+      let deltaY = 0;
+      let vx = 0;
+      let vy = 0;
+      const prev = this.previousTouchPositions.get(id);
+      if (prev) {
+        deltaX = touch.clientX - prev.x;
+        deltaY = touch.clientY - prev.y;
+        const dt = (data.timestamp - prev.timestamp) / 1e3;
+        if (dt > 0) {
+          vx = deltaX / dt;
+          vy = deltaY / dt;
+        }
+      }
+      if (ended) {
+        this.previousTouchPositions.delete(id);
+      } else {
+        this.previousTouchPositions.set(id, {
+          x: touch.clientX,
+          y: touch.clientY,
+          timestamp: data.timestamp
+        });
+      }
+      return {
+        id,
+        x: touch.clientX,
+        y: touch.clientY,
+        pressure: touch.force,
+        radius: Math.max(touch.radiusX, touch.radiusY),
+        radiusX: touch.radiusX,
+        radiusY: touch.radiusY,
+        rotationAngle: touch.rotationAngle,
+        force: touch.force,
+        isInCanvas: touch.isInCanvas,
+        deltaX,
+        deltaY,
+        velocity: { x: vx, y: vy },
+        isNew: data.type === "touchstart" && !prev,
+        isActive: !ended,
+        isEnding: ended
+      };
+    });
+    const activePoints = touches.filter((t) => t.isActive);
+    const endedPoints = touches.filter((t) => t.isEnding);
+    this.touchState.points = activePoints;
+    this.touchState.count = activePoints.length;
+    this.touchState.primary = activePoints[0] || null;
     if (data.type === "touchstart") {
-      this.touchState.started = touches;
+      this.touchState.started.push(...touches.filter((t) => t.isNew));
     } else if (data.type === "touchmove") {
-      this.touchState.moved = touches;
+      this.touchState.moved = activePoints;
     } else if (data.type === "touchend" || data.type === "touchcancel") {
-      this.touchState.ended = touches;
-    }
-    this.touchState.gestures = {
-      isPinching: false,
-      isRotating: false,
-      isPanning: false,
-      isTapping: false,
-      pinchScale: 1,
-      pinchDelta: 0,
-      rotationAngle: 0,
-      rotationDelta: 0,
-      panDelta: { x: 0, y: 0 },
-      tapCount: 0,
-      lastTapTime: 0,
-      tapPosition: null
-    };
+      this.touchState.ended.push(...endedPoints);
+    }
+  }
+  /**
+   * Compute unified pointer state from current mouse and touch state.
+   * Call after all interaction events are processed, before render.
+   */
+  updatePointerState() {
+    const touch = this.touchState;
+    const mouse = this.mouseState;
+    if (touch.count > 0 && touch.primary) {
+      const p = touch.primary;
+      this.pointerState.x = p.x;
+      this.pointerState.y = p.y;
+      this.pointerState.deltaX = p.deltaX;
+      this.pointerState.deltaY = p.deltaY;
+      this.pointerState.isDown = true;
+      this.pointerState.isInCanvas = p.isInCanvas;
+      this.pointerState.type = "touch";
+    } else {
+      this.pointerState.x = mouse.x;
+      this.pointerState.y = mouse.y;
+      this.pointerState.deltaX = mouse.deltaX;
+      this.pointerState.deltaY = mouse.deltaY;
+      this.pointerState.isDown = mouse.leftButton;
+      this.pointerState.isInCanvas = mouse.isInCanvas;
+      this.pointerState.type = mouse.isInCanvas ? "mouse" : "none";
+    }
+    this.pointerState.wasPressed = this.pointerState.isDown && !this.previousPointerDown;
+    this.pointerState.wasReleased = !this.pointerState.isDown && this.previousPointerDown;
+    this.previousPointerDown = this.pointerState.isDown;
   }
   /**
    * Reset all interaction state (called when loading new scene)
@@ -543,7 +645,6 @@ class InteractionSystem {
       leftButton: false,
       rightButton: false,
       middleButton: false,
-      velocity: { x: 0, y: 0 },
       deltaX: 0,
       deltaY: 0,
       wheelDelta: 0,
@@ -562,26 +663,26 @@ class InteractionSystem {
     this.keyboardState.ctrl = false;
     this.keyboardState.alt = false;
     this.keyboardState.meta = false;
+    this.keyboardTextureData.fill(0);
     this.touchState.points = [];
     this.touchState.count = 0;
     this.touchState.started = [];
     this.touchState.moved = [];
     this.touchState.ended = [];
     this.touchState.primary = null;
-    Object.assign(this.touchState.gestures, {
-      isPinching: false,
-      isRotating: false,
-      isPanning: false,
-      isTapping: false,
-      pinchScale: 1,
-      pinchDelta: 0,
-      rotationAngle: 0,
-      rotationDelta: 0,
-      panDelta: { x: 0, y: 0 },
-      tapCount: 0,
-      lastTapTime: 0,
-      tapPosition: null
+    this.previousTouchPositions.clear();
+    Object.assign(this.pointerState, {
+      x: 0,
+      y: 0,
+      deltaX: 0,
+      deltaY: 0,
+      isDown: false,
+      wasPressed: false,
+      wasReleased: false,
+      isInCanvas: false,
+      type: "none"
     });
+    this.previousPointerDown = false;
   }
   /**
    * Enable or disable interaction processing
@@ -609,8 +710,6 @@ class InteractionSystem {
     this.mouseState.leftButton = false;
     this.mouseState.rightButton = false;
     this.mouseState.middleButton = false;
-    this.mouseState.velocity.x = 0;
-    this.mouseState.velocity.y = 0;
     this.mouseState.deltaX = 0;
     this.mouseState.deltaY = 0;
     this.mouseState.wheelDelta = 0;
@@ -628,24 +727,24 @@ class InteractionSystem {
     this.keyboardState.ctrl = false;
     this.keyboardState.alt = false;
     this.keyboardState.meta = false;
+    this.keyboardTextureData.fill(0);
     this.touchState.points = [];
     this.touchState.count = 0;
     this.touchState.started = [];
     this.touchState.moved = [];
     this.touchState.ended = [];
     this.touchState.primary = null;
-    this.touchState.gestures.isPinching = false;
-    this.touchState.gestures.isRotating = false;
-    this.touchState.gestures.isPanning = false;
-    this.touchState.gestures.isTapping = false;
-    this.touchState.gestures.pinchScale = 1;
-    this.touchState.gestures.pinchDelta = 0;
-    this.touchState.gestures.rotationAngle = 0;
-    this.touchState.gestures.rotationDelta = 0;
-    this.touchState.gestures.panDelta = { x: 0, y: 0 };
-    this.touchState.gestures.tapCount = 0;
-    this.touchState.gestures.lastTapTime = 0;
-    this.touchState.gestures.tapPosition = null;
+    this.previousTouchPositions.clear();
+    this.pointerState.x = 0;
+    this.pointerState.y = 0;
+    this.pointerState.deltaX = 0;
+    this.pointerState.deltaY = 0;
+    this.pointerState.isDown = false;
+    this.pointerState.wasPressed = false;
+    this.pointerState.wasReleased = false;
+    this.pointerState.isInCanvas = false;
+    this.pointerState.type = "none";
+    this.previousPointerDown = false;
   }
 }
 class CVSystem {
@@ -1982,7 +2081,7 @@ class P5WorkerAdapter {
   addP5PropertyToImageParameters(parameterObjects) {
     if (!this.p5Instance) return;
     const isImageLike = (value) => {
-      return value instanceof ImageBitmap || value instanceof OffscreenCanvas || value && typeof value === "object" && "width" in value && "height" in value;
+      return value instanceof ImageBitmap || value && typeof value === "object" && "width" in value && "height" in value;
     };
     for (const [name, param] of parameterObjects) {
       try {
@@ -2191,6 +2290,11 @@ class ShaderParameterParser {
         break;
       case "image":
         break;
+      case "button":
+        if (param.config.default !== void 0) {
+          console.warn(`Parameter ${param.uniformName} of type 'button' ignores 'default' — buttons always start as false`);
+        }
+        break;
       case "accumulator":
         if (param.config.rate === void 0) {
           throw new Error(`Accumulator '${param.uniformName}' requires a 'rate' config key (parameter name or numeric constant)`);
@@ -2198,9 +2302,6 @@ class ShaderParameterParser {
         if (typeof param.config.rate !== "string" && typeof param.config.rate !== "number") {
           throw new Error(`Accumulator '${param.uniformName}' rate must be a parameter name or numeric constant`);
         }
-        if (typeof param.config.rate === "string" && param.config.rate.startsWith("u_")) {
-          throw new Error(`Accumulator '${param.uniformName}' cannot reference built-in uniform '${param.config.rate}' — use a parameter name`);
-        }
         break;
       default:
         console.warn(`Unknown parameter type: ${param.type}`);
@@ -2225,6 +2326,8 @@ class ShaderParameterParser {
         return `uniform int ${param.uniformName};`;
       case "image":
         return `uniform sampler2D ${param.uniformName};`;
+      case "button":
+        return `uniform bool ${param.uniformName};`;
       case "accumulator":
         return `uniform float ${param.uniformName}; // accumulator (rate: ${param.config.rate})`;
       default:
@@ -2244,11 +2347,15 @@ class ShaderParameterParser {
       if (param.type !== "accumulator") continue;
       const rate = param.config.rate;
       if (typeof rate === "string" && !paramNames.has(rate)) {
-        const available = [...paramNames].join(", ");
-        console.warn(
-          `Accumulator '${param.uniformName}' references parameter '${rate}' which does not exist.` + (available ? ` Available parameters: ${available}` : " No parameters declared.")
-        );
-        param.config._rateInvalid = true;
+        if (rate.startsWith("u_")) {
+          param.config._rateIsBuiltIn = true;
+        } else {
+          const available = [...paramNames].join(", ");
+          console.warn(
+            `Accumulator '${param.uniformName}' references parameter '${rate}' which does not exist.` + (available ? ` Available parameters: ${available}` : " No parameters declared.")
+          );
+          param.config._rateInvalid = true;
+        }
       }
     }
   }
@@ -2295,6 +2402,7 @@ class ShaderWorkerAdapter {
   audioWaveformTexture = null;
   videoTexture = null;
   segmentationTexture = null;
+  keyboardTexture = null;
   // Multi-stream textures
   streamTextures = [];
   // Device video textures
@@ -2302,6 +2410,8 @@ class ShaderWorkerAdapter {
   // Accumulator state (CPU-side phase accumulators for smooth parameter-driven animation)
   accumulatorValues = /* @__PURE__ */ new Map();
   accumulatorWarned = /* @__PURE__ */ new Set();
+  // Cache of scalar uniform values for accumulator built-in rate lookups
+  scalarUniformCache = /* @__PURE__ */ new Map();
   // Backbuffer support (ping-pong framebuffers)
   backbufferFramebuffer = null;
   backbufferTexture = null;
@@ -2478,7 +2588,6 @@ uniform vec2 u_resolution; // Canvas width and height in pixels
 uniform float u_time; // Elapsed time in seconds since scene start
 uniform float u_deltaTime; // Time elapsed since last frame in seconds
 uniform int u_frame; // Current frame number
-uniform float u_pixelRatio; // Device pixel ratio for high-DPI displays
 uniform float u_fps; // Current frames per second
 
 // Mouse API
@@ -2488,7 +2597,10 @@ uniform bool u_mousePressed; // True if any mouse button is pressed
 uniform bool u_mouseLeft; // True if left mouse button is pressed
 uniform bool u_mouseRight; // True if right mouse button is pressed
 uniform bool u_mouseMiddle; // True if middle mouse button is pressed
-uniform vec2 u_mouseVelocity; // Mouse movement velocity in pixels per second
+uniform vec2 u_mouseDelta; // Mouse movement delta in pixels (per frame)
+uniform float u_mouseWheel; // Mouse wheel scroll delta (per frame)
+uniform bool u_mouseWasPressed; // True on the frame a mouse button was pressed
+uniform bool u_mouseWasReleased; // True on the frame a mouse button was released
 
 // Keyboard API - Common keys
 uniform bool u_keySpace; // True if spacebar is pressed
@@ -2504,6 +2616,10 @@ uniform bool u_keyDown; // True if Down arrow key is pressed
 uniform bool u_keyLeft; // True if Left arrow key is pressed
 uniform bool u_keyRight; // True if Right arrow key is pressed
 
+// Keyboard Texture (Shadertoy-compatible 256x3)
+// Row 0: held state, Row 1: pressed this frame, Row 2: toggle
+uniform sampler2D u_keyboard; // Keyboard state texture (256x3, LUMINANCE)
+
 // Touch API
 uniform int u_touchCount; // Number of active touch points (0-5)
 uniform vec2 u_touch0; // First touch point position in pixels
@@ -2512,6 +2628,14 @@ uniform vec2 u_touch2; // Third touch point position in pixels
 uniform vec2 u_touch3; // Fourth touch point position in pixels
 uniform vec2 u_touch4; // Fifth touch point position in pixels
 
+// Pointer API (unified mouse/touch)
+uniform vec2 u_pointer; // Primary input position in pixels (WebGL coords)
+uniform vec2 u_pointerDelta; // Primary input movement delta (per frame)
+uniform bool u_pointerDown; // True if primary input is active (left-click or touch)
+uniform bool u_pointerWasPressed; // True on the frame primary input became active
+uniform bool u_pointerWasReleased; // True on the frame primary input was released
+uniform bool u_pointerInCanvas; // True if primary input is inside canvas bounds
+
 // Audio - Volume
 uniform float u_audioVolume; // RMS volume level (0-1)
 uniform float u_audioPeak; // Peak amplitude (0-1)
@@ -2845,6 +2969,7 @@ ${error}`);
     this.textureUnits.set("u_audioWaveform", this.nextTextureUnit++);
     this.textureUnits.set("u_video", this.nextTextureUnit++);
     this.textureUnits.set("u_segmentationMask", this.nextTextureUnit++);
+    this.textureUnits.set("u_keyboard", this.nextTextureUnit++);
     for (let i = 0; i < ShaderWorkerAdapter.MAX_STREAMS; i++) {
       this.textureUnits.set(`u_stream${i}`, this.nextTextureUnit++);
     }
@@ -2929,7 +3054,6 @@ ${error}`);
     this.setUniform("u_time", "float", viji.time);
     this.setUniform("u_deltaTime", "float", viji.deltaTime);
     this.setUniform("u_frame", "int", viji.frameCount);
-    this.setUniform("u_pixelRatio", "float", viji.pixelRatio);
     this.setUniform("u_fps", "float", viji.fps);
     this.setUniform("u_mouse", "vec2", [viji.mouse.x, viji.height - viji.mouse.y]);
     this.setUniform("u_mouseInCanvas", "bool", viji.mouse.isInCanvas);
@@ -2937,7 +3061,10 @@ ${error}`);
     this.setUniform("u_mouseLeft", "bool", viji.mouse.leftButton);
     this.setUniform("u_mouseRight", "bool", viji.mouse.rightButton);
     this.setUniform("u_mouseMiddle", "bool", viji.mouse.middleButton);
-    this.setUniform("u_mouseVelocity", "vec2", [viji.mouse.velocity.x, -viji.mouse.velocity.y]);
+    this.setUniform("u_mouseDelta", "vec2", [viji.mouse.deltaX, -viji.mouse.deltaY]);
+    this.setUniform("u_mouseWheel", "float", viji.mouse.wheelDelta);
+    this.setUniform("u_mouseWasPressed", "bool", viji.mouse.wasPressed);
+    this.setUniform("u_mouseWasReleased", "bool", viji.mouse.wasReleased);
     this.setUniform("u_keySpace", "bool", viji.keyboard.isPressed(" ") || viji.keyboard.isPressed("space"));
     this.setUniform("u_keyShift", "bool", viji.keyboard.shift);
     this.setUniform("u_keyCtrl", "bool", viji.keyboard.ctrl);
@@ -2950,6 +3077,9 @@ ${error}`);
     this.setUniform("u_keyDown", "bool", viji.keyboard.isPressed("ArrowDown"));
     this.setUniform("u_keyLeft", "bool", viji.keyboard.isPressed("ArrowLeft"));
     this.setUniform("u_keyRight", "bool", viji.keyboard.isPressed("ArrowRight"));
+    if (viji.keyboard.textureData) {
+      this.updateKeyboardTexture(viji.keyboard.textureData);
+    }
     this.setUniform("u_touchCount", "int", viji.touches.count);
     for (let i = 0; i < 5; i++) {
       const touch = viji.touches.points[i];
@@ -2959,6 +3089,12 @@ ${error}`);
         this.setUniform(`u_touch${i}`, "vec2", [0, 0]);
       }
     }
+    this.setUniform("u_pointer", "vec2", [viji.pointer.x, viji.height - viji.pointer.y]);
+    this.setUniform("u_pointerDelta", "vec2", [viji.pointer.deltaX, -viji.pointer.deltaY]);
+    this.setUniform("u_pointerDown", "bool", viji.pointer.isDown);
+    this.setUniform("u_pointerWasPressed", "bool", viji.pointer.wasPressed);
+    this.setUniform("u_pointerWasReleased", "bool", viji.pointer.wasReleased);
+    this.setUniform("u_pointerInCanvas", "bool", viji.pointer.isInCanvas);
     const audio = viji.audio;
     this.setUniform("u_audioVolume", "float", audio.volume?.current || 0);
     this.setUniform("u_audioPeak", "float", audio.volume?.peak || 0);
@@ -3294,6 +3430,8 @@ ${error}`);
         const sourceParam = parameterObjects.get(rateConfig);
         if (sourceParam !== void 0) {
           rate = sourceParam.value ?? 0;
+        } else if (this.scalarUniformCache.has(rateConfig)) {
+          rate = this.scalarUniformCache.get(rateConfig);
         } else {
           if (!this.accumulatorWarned.has(param.uniformName)) {
             console.warn(`Accumulator '${param.uniformName}': rate source '${rateConfig}' not found, using 0`);
@@ -3343,6 +3481,9 @@ ${error}`);
             this.updateImageTexture(param.uniformName, value);
           }
           break;
+        case "button":
+          this.setUniform(param.uniformName, "bool", value);
+          break;
       }
     }
   }
@@ -3350,13 +3491,34 @@ ${error}`);
    * Set uniform value
    */
   setUniform(name, type, value) {
-    const location = this.uniformLocations.get(name);
-    if (location === null || location === void 0) {
-      if (name.includes("[") && Math.random() < 0.01) {
-        console.log(`[ShaderAdapter] Uniform '${name}' not found (location is ${location})`);
-      }
-      return;
+    switch (type) {
+      case "float":
+        this.scalarUniformCache.set(name, value);
+        break;
+      case "int":
+        this.scalarUniformCache.set(name, value);
+        break;
+      case "bool":
+        this.scalarUniformCache.set(name, value ? 1 : 0);
+        break;
+      case "vec2":
+        this.scalarUniformCache.set(name + ".x", value[0]);
+        this.scalarUniformCache.set(name + ".y", value[1]);
+        break;
+      case "vec3":
+        this.scalarUniformCache.set(name + ".x", value[0]);
+        this.scalarUniformCache.set(name + ".y", value[1]);
+        this.scalarUniformCache.set(name + ".z", value[2]);
+        break;
+      case "vec4":
+        this.scalarUniformCache.set(name + ".x", value[0]);
+        this.scalarUniformCache.set(name + ".y", value[1]);
+        this.scalarUniformCache.set(name + ".z", value[2]);
+        this.scalarUniformCache.set(name + ".w", value[3]);
+        break;
     }
+    const location = this.uniformLocations.get(name);
+    if (location === null || location === void 0) return;
     const gl = this.gl;
     switch (type) {
       case "float":
@@ -3605,6 +3767,37 @@ ${error}`);
       gl.uniform1i(location, unit);
     }
   }
+  /**
+   * Update keyboard state texture (Shadertoy-compatible 256x3)
+   */
+  updateKeyboardTexture(data) {
+    const gl = this.gl;
+    const unit = this.textureUnits.get("u_keyboard");
+    if (!this.keyboardTexture) {
+      this.keyboardTexture = gl.createTexture();
+    }
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, this.keyboardTexture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.LUMINANCE,
+      256,
+      3,
+      0,
+      gl.LUMINANCE,
+      gl.UNSIGNED_BYTE,
+      data
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const location = this.uniformLocations.get("u_keyboard");
+    if (location) {
+      gl.uniform1i(location, unit);
+    }
+  }
   /**
    * Update image parameter texture
    */
@@ -3806,7 +3999,6 @@ class VijiWorkerRuntime {
     gl: null,
     width: 0,
     height: 0,
-    pixelRatio: 1,
     // Timing
     time: 0,
     deltaTime: 0,
@@ -3895,6 +4087,9 @@ class VijiWorkerRuntime {
     image: (defaultValue, config) => {
       return this.parameterSystem.createImageParameter(defaultValue, config);
     },
+    button: (config) => {
+      return this.parameterSystem.createButtonParameter(config);
+    },
     // Context selection
     useContext: (type) => {
       if (type === "2d") {
@@ -4020,6 +4215,9 @@ class VijiWorkerRuntime {
       case "image":
         this.viji.image(null, paramConfig);
         break;
+      case "button":
+        this.viji.button(paramConfig);
+        break;
     }
   }
   // Reset parameter state (called when loading new scene)
@@ -4572,6 +4770,7 @@ class VijiWorkerRuntime {
       this.viji.frameCount = ++this.frameCount;
       this.trackEffectiveFrameTime(currentTime);
       this.lastTime = currentTime;
+      this.interactionSystem.updatePointerState();
       try {
         if (this.shaderAdapter && this.rendererType === "shader") {
           const parameterObjects = this.parameterSystem.getAllParameterObjects();
@@ -4593,6 +4792,7 @@ class VijiWorkerRuntime {
           stack: error.stack
         });
       }
+      this.parameterSystem.resetButtonParameters();
       if (this.pendingCaptures.length > 0) {
         const captures = [...this.pendingCaptures];
         this.pendingCaptures = [];
@@ -26049,4 +26249,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-DTQvTudb.js.map
+//# sourceMappingURL=viji.worker-Zg128woJ.js.map