@viji-dev/core 0.2.11 → 0.2.13

package/dist/assets/renderers/ShaderWorkerAdapter.js

@@ -1,939 +0,0 @@
-class ShaderParameterParser {
-  /**
-   * Parse all parameter declarations from shader code
-   */
-  static parseParameters(shaderCode) {
-    const parameters = [];
-    const lines = shaderCode.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      const match = trimmed.match(/\/\/\s*@viji-(\w+):(\w+)\s+(.+)/);
-      if (match) {
-        const [, type, uniformName, configStr] = match;
-        try {
-          const config = this.parseKeyValuePairs(configStr);
-          const param = {
-            type,
-            uniformName,
-            label: config.label || uniformName,
-            default: config.default,
-            config
-          };
-          this.validateParameter(param);
-          parameters.push(param);
-        } catch (error) {
-          console.warn(`Failed to parse shader parameter: ${line}`, error);
-        }
-      }
-    }
-    return parameters;
-  }
-  /**
-   * Parse key:value pairs from configuration string
-   */
-  static parseKeyValuePairs(configStr) {
-    const config = {};
-    const keyValueRegex = /(\w+):((?:"[^"]*"|\[[^\]]*\]|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|[^\s]+))/g;
-    let match;
-    while ((match = keyValueRegex.exec(configStr)) !== null) {
-      const [, key, value] = match;
-      config[key] = this.parseValue(value);
-    }
-    return config;
-  }
-  /**
-   * Parse individual value from string
-   */
-  static parseValue(value) {
-    if (value.startsWith('"') && value.endsWith('"')) {
-      return value.slice(1, -1);
-    }
-    if (value.startsWith("[") && value.endsWith("]")) {
-      try {
-        return JSON.parse(value);
-      } catch {
-        const items = value.slice(1, -1).split(",").map((s) => s.trim());
-        return items.map((item) => {
-          if (item.startsWith('"') && item.endsWith('"')) {
-            return item.slice(1, -1);
-          }
-          const num2 = parseFloat(item);
-          return isNaN(num2) ? item : num2;
-        });
-      }
-    }
-    if (value.startsWith("#")) {
-      return value;
-    }
-    if (value === "true") return true;
-    if (value === "false") return false;
-    const num = parseFloat(value);
-    if (!isNaN(num)) return num;
-    return value;
-  }
-  /**
-   * Validate parameter definition
-   */
-  static validateParameter(param) {
-    if (!param.type) {
-      throw new Error("Parameter type is required");
-    }
-    if (!param.uniformName) {
-      throw new Error("Parameter uniformName is required");
-    }
-    if (!param.config.label) {
-      throw new Error(`Parameter ${param.uniformName} missing required 'label' key`);
-    }
-    switch (param.type) {
-      case "slider":
-      case "number":
-        if (param.config.default === void 0) {
-          throw new Error(`Parameter ${param.uniformName} of type ${param.type} missing required 'default' key`);
-        }
-        break;
-      case "color":
-        if (param.config.default === void 0) {
-          throw new Error(`Parameter ${param.uniformName} of type 'color' missing required 'default' key`);
-        }
-        if (!param.config.default.startsWith("#")) {
-          throw new Error(`Parameter ${param.uniformName} of type 'color' default must be hex color (e.g., #ff0000)`);
-        }
-        break;
-      case "toggle":
-        if (param.config.default === void 0) {
-          throw new Error(`Parameter ${param.uniformName} of type 'toggle' missing required 'default' key`);
-        }
-        if (typeof param.config.default !== "boolean") {
-          throw new Error(`Parameter ${param.uniformName} of type 'toggle' default must be boolean (true or false)`);
-        }
-        break;
-      case "select":
-        if (param.config.default === void 0) {
-          throw new Error(`Parameter ${param.uniformName} of type 'select' missing required 'default' key`);
-        }
-        if (!param.config.options || !Array.isArray(param.config.options)) {
-          throw new Error(`Parameter ${param.uniformName} of type 'select' missing required 'options' key (array)`);
-        }
-        break;
-      case "image":
-        break;
-      default:
-        console.warn(`Unknown parameter type: ${param.type}`);
-    }
-    if (param.uniformName.startsWith("u_")) {
-      console.warn(`Parameter name "${param.uniformName}" uses reserved prefix "u_". Consider renaming to avoid conflicts with built-in uniforms.`);
-    }
-  }
-  /**
-   * Generate uniform declaration for a parameter
-   */
-  static generateUniformDeclaration(param) {
-    switch (param.type) {
-      case "slider":
-      case "number":
-        return `uniform float ${param.uniformName};`;
-      case "color":
-        return `uniform vec3 ${param.uniformName};`;
-      case "toggle":
-        return `uniform bool ${param.uniformName};`;
-      case "select":
-        return `uniform int ${param.uniformName};`;
-      case "image":
-        return `uniform sampler2D ${param.uniformName};`;
-      default:
-        return `// Unknown parameter type: ${param.type}`;
-    }
-  }
-}
-class ShaderWorkerAdapter {
-  constructor(offscreenCanvas, _vijiAPI, shaderCode) {
-    this.shaderCode = shaderCode;
-    this.glslVersion = this.detectGLSLVersion(shaderCode);
-    this.backbufferEnabled = shaderCode.includes("backbuffer");
-    if (this.glslVersion === "glsl300") {
-      const gl = offscreenCanvas.getContext("webgl2");
-      if (!gl) {
-        throw new Error("WebGL 2 not supported. Use GLSL ES 1.00 syntax instead.");
-      }
-      this.gl = gl;
-    } else {
-      const gl = offscreenCanvas.getContext("webgl");
-      if (!gl) {
-        throw new Error("WebGL not supported");
-      }
-      this.gl = gl;
-    }
-  }
-  gl;
-  program = null;
-  uniformLocations = /* @__PURE__ */ new Map();
-  textureUnits = /* @__PURE__ */ new Map();
-  nextTextureUnit = 0;
-  textures = /* @__PURE__ */ new Map();
-  // Fullscreen quad
-  quadBuffer = null;
-  // Parameter definitions
-  parameters = [];
-  // GLSL version detection
-  glslVersion = "glsl100";
-  // Audio FFT texture
-  audioFFTTexture = null;
-  videoTexture = null;
-  segmentationTexture = null;
-  // Backbuffer support (ping-pong framebuffers)
-  backbufferFramebuffer = null;
-  backbufferTexture = null;
-  currentFramebuffer = null;
-  currentTexture = null;
-  backbufferEnabled = false;
-  /**
-   * Initialize the shader adapter
-   */
-  async init() {
-    try {
-      this.parameters = ShaderParameterParser.parseParameters(this.shaderCode);
-      this.createFullscreenQuad();
-      const processedCode = this.injectUniforms(this.shaderCode);
-      this.compileAndLinkShader(processedCode);
-      this.cacheUniformLocations();
-      this.reserveTextureUnits();
-      if (this.backbufferEnabled) {
-        this.createBackbufferFramebuffers();
-      }
-    } catch (error) {
-      console.error("Failed to initialize ShaderWorkerAdapter:", error);
-      throw error;
-    }
-  }
-  /**
-   * Detect GLSL version from shader code
-   */
-  detectGLSLVersion(code) {
-    return code.includes("#version 300") ? "glsl300" : "glsl100";
-  }
-  /**
-   * Create fullscreen quad geometry
-   */
-  createFullscreenQuad() {
-    const vertices = new Float32Array([
-      -1,
-      -1,
-      // Bottom-left
-      1,
-      -1,
-      // Bottom-right
-      -1,
-      1,
-      // Top-left
-      1,
-      1
-      // Top-right
-    ]);
-    this.quadBuffer = this.gl.createBuffer();
-    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.quadBuffer);
-    this.gl.bufferData(this.gl.ARRAY_BUFFER, vertices, this.gl.STATIC_DRAW);
-  }
-  /**
-   * Inject built-in and parameter uniforms into shader code
-   */
-  injectUniforms(artistCode) {
-    let versionLine = "";
-    let codeWithoutVersion = artistCode;
-    const lines = artistCode.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const trimmed = lines[i].trim();
-      if (trimmed.startsWith("#version")) {
-        versionLine = trimmed;
-        lines[i] = "";
-        codeWithoutVersion = lines.join("\n");
-        break;
-      }
-    }
-    const injectionPoint = this.findInjectionPoint(codeWithoutVersion);
-    const builtInUniforms = this.getBuiltInUniforms();
-    const parameterUniforms = this.parameters.map((p) => ShaderParameterParser.generateUniformDeclaration(p)).join("\n");
-    const usesFwidth = artistCode.includes("fwidth");
-    if (usesFwidth && this.glslVersion === "glsl100") {
-      const ext = this.gl.getExtension("OES_standard_derivatives");
-      if (!ext) {
-        console.warn("Shader uses fwidth() but OES_standard_derivatives extension is not supported. Shader may not compile.");
-      }
-    }
-    const parts = [];
-    if (usesFwidth && this.glslVersion === "glsl100") {
-      parts.push("#extension GL_OES_standard_derivatives : enable");
-    }
-    if (this.glslVersion === "glsl100") {
-      parts.push("");
-      parts.push("#ifdef GL_ES");
-      parts.push("precision mediump float;");
-      parts.push("#endif");
-    } else {
-      parts.push("");
-      parts.push("precision mediump float;");
-    }
-    parts.push("");
-    parts.push("// ===== VIJI AUTO-INJECTED UNIFORMS =====");
-    parts.push("// Built-in uniforms (auto-provided)");
-    parts.push(builtInUniforms);
-    parts.push("");
-    parts.push("// Parameter uniforms (from @viji-* declarations)");
-    parts.push(parameterUniforms);
-    parts.push("");
-    parts.push("// ===== ARTIST CODE =====");
-    const uniformBlock = parts.join("\n");
-    const codeWithUniforms = codeWithoutVersion.slice(0, injectionPoint) + "\n" + uniformBlock + "\n" + codeWithoutVersion.slice(injectionPoint);
-    const finalCode = versionLine ? versionLine + "\n" + codeWithUniforms : codeWithUniforms;
-    console.log("=== INJECTED SHADER CODE (first 50 lines) ===");
-    console.log(finalCode.split("\n").slice(0, 50).join("\n"));
-    console.log("=== END INJECTED CODE ===");
-    return finalCode;
-  }
-  /**
-   * Find where to inject extensions and uniforms
-   * Extensions must come after #version but before any code
-   * 
-   * Strategy: 
-   * 1. If #version exists, inject right after it
-   * 2. Otherwise, skip ALL comments (single and multi-line) and inject before first code
-   */
-  findInjectionPoint(code) {
-    const lines = code.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      if (line.startsWith("#version")) {
-        return this.getLineEndPosition(code, i);
-      }
-    }
-    let inMultiLineComment = false;
-    let firstCodeLine = 0;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      if (line.includes("/*")) {
-        inMultiLineComment = true;
-      }
-      if (line.includes("*/")) {
-        inMultiLineComment = false;
-        firstCodeLine = i + 1;
-        continue;
-      }
-      if (inMultiLineComment) {
-        continue;
-      }
-      if (line === "" || line.startsWith("//")) {
-        firstCodeLine = i + 1;
-        continue;
-      }
-      break;
-    }
-    if (firstCodeLine > 0 && firstCodeLine < lines.length) {
-      return this.getLineEndPosition(code, firstCodeLine - 1);
-    }
-    return 0;
-  }
-  /**
-   * Get byte position of end of line N
-   */
-  getLineEndPosition(code, lineNumber) {
-    const lines = code.split("\n");
-    let position = 0;
-    for (let i = 0; i <= lineNumber && i < lines.length; i++) {
-      position += lines[i].length + 1;
-    }
-    return position;
-  }
-  /**
-   * Get built-in uniform declarations
-   */
-  getBuiltInUniforms() {
-    return `// Core - Canvas & Timing
-uniform vec2 u_resolution;
-uniform float u_time;
-uniform float u_deltaTime;
-uniform int u_frame;
-uniform float u_pixelRatio;
-uniform float u_fps;
-
-// Mouse API
-uniform vec2 u_mouse;
-uniform bool u_mouseInCanvas;
-uniform bool u_mousePressed;
-uniform bool u_mouseLeft;
-uniform bool u_mouseRight;
-uniform bool u_mouseMiddle;
-uniform vec2 u_mouseVelocity;
-
-// Keyboard API - Common keys
-uniform bool u_keySpace;
-uniform bool u_keyShift;
-uniform bool u_keyCtrl;
-uniform bool u_keyAlt;
-uniform bool u_keyW;
-uniform bool u_keyA;
-uniform bool u_keyS;
-uniform bool u_keyD;
-uniform bool u_keyUp;
-uniform bool u_keyDown;
-uniform bool u_keyLeft;
-uniform bool u_keyRight;
-
-// Touch API
-uniform int u_touchCount;
-uniform vec2 u_touch0;
-uniform vec2 u_touch1;
-uniform vec2 u_touch2;
-uniform vec2 u_touch3;
-uniform vec2 u_touch4;
-
-// Audio
-uniform float u_audioVolume;
-uniform float u_audioPeak;
-uniform float u_audioBass;
-uniform float u_audioMid;
-uniform float u_audioTreble;
-uniform float u_audioSubBass;
-uniform float u_audioLowMid;
-uniform float u_audioHighMid;
-uniform float u_audioPresence;
-uniform float u_audioBrilliance;
-uniform sampler2D u_audioFFT;
-
-// Video
-uniform sampler2D u_video;
-uniform vec2 u_videoResolution;
-uniform float u_videoFrameRate;
-
-// CV - Face Detection
-uniform int u_faceCount;
-uniform vec4 u_face0Bounds;
-uniform vec3 u_face0HeadPose;
-uniform float u_face0Confidence;
-uniform float u_face0Happy;
-uniform float u_face0Sad;
-uniform float u_face0Angry;
-uniform float u_face0Surprised;
-
-// CV - Hand Tracking
-uniform int u_handCount;
-uniform vec3 u_leftHandPalm;
-uniform vec3 u_rightHandPalm;
-uniform float u_leftHandFist;
-uniform float u_leftHandOpen;
-uniform float u_rightHandFist;
-uniform float u_rightHandOpen;
-
-// CV - Pose Detection
-uniform bool u_poseDetected;
-uniform vec2 u_nosePosition;
-uniform vec2 u_leftWristPosition;
-uniform vec2 u_rightWristPosition;
-uniform vec2 u_leftAnklePosition;
-uniform vec2 u_rightAnklePosition;
-
-// CV - Segmentation
-uniform sampler2D u_segmentationMask;
-uniform vec2 u_segmentationRes;
-
-// Backbuffer (previous frame feedback)
-${this.backbufferEnabled ? "uniform sampler2D backbuffer;" : "// backbuffer not enabled"}
-`;
-  }
-  /**
-   * Compile and link shader program
-   */
-  compileAndLinkShader(fragmentShaderCode) {
-    const gl = this.gl;
-    const vertexShaderCode = this.glslVersion === "glsl300" ? `#version 300 es
-         precision mediump float;
-         in vec2 a_position;
-         void main() {
-           gl_Position = vec4(a_position, 0.0, 1.0);
-         }` : `attribute vec2 a_position;
-         void main() {
-           gl_Position = vec4(a_position, 0.0, 1.0);
-         }`;
-    const vertexShader = this.compileShader(gl.VERTEX_SHADER, vertexShaderCode);
-    const fragmentShader = this.compileShader(gl.FRAGMENT_SHADER, fragmentShaderCode);
-    const program = gl.createProgram();
-    if (!program) {
-      throw new Error("Failed to create WebGL program");
-    }
-    gl.attachShader(program, vertexShader);
-    gl.attachShader(program, fragmentShader);
-    gl.linkProgram(program);
-    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-      const error = gl.getProgramInfoLog(program);
-      throw new Error(`Shader program link failed: ${error}`);
-    }
-    this.program = program;
-    gl.useProgram(program);
-    gl.deleteShader(vertexShader);
-    gl.deleteShader(fragmentShader);
-  }
-  /**
-   * Compile a shader
-   */
-  compileShader(type, source) {
-    const gl = this.gl;
-    const shader = gl.createShader(type);
-    if (!shader) {
-      throw new Error("Failed to create shader");
-    }
-    gl.shaderSource(shader, source);
-    gl.compileShader(shader);
-    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-      const error = gl.getShaderInfoLog(shader);
-      const shaderType = type === gl.VERTEX_SHADER ? "vertex" : "fragment";
-      throw new Error(`${shaderType} shader compilation failed:
-${error}`);
-    }
-    return shader;
-  }
-  /**
-   * Cache uniform locations for fast access
-   */
-  cacheUniformLocations() {
-    if (!this.program) return;
-    const gl = this.gl;
-    const numUniforms = gl.getProgramParameter(this.program, gl.ACTIVE_UNIFORMS);
-    for (let i = 0; i < numUniforms; i++) {
-      const info = gl.getActiveUniform(this.program, i);
-      if (info) {
-        const location = gl.getUniformLocation(this.program, info.name);
-        this.uniformLocations.set(info.name, location);
-      }
-    }
-  }
-  /**
-   * Reserve texture units for special textures
-   */
-  reserveTextureUnits() {
-    this.textureUnits.set("u_audioFFT", this.nextTextureUnit++);
-    this.textureUnits.set("u_video", this.nextTextureUnit++);
-    this.textureUnits.set("u_segmentationMask", this.nextTextureUnit++);
-    if (this.backbufferEnabled) {
-      this.textureUnits.set("backbuffer", this.nextTextureUnit++);
-    }
-  }
-  /**
-   * Create ping-pong framebuffers for backbuffer support
-   */
-  createBackbufferFramebuffers() {
-    const gl = this.gl;
-    const width = gl.canvas.width;
-    const height = gl.canvas.height;
-    const createFBOTexture = () => {
-      const texture = gl.createTexture();
-      gl.bindTexture(gl.TEXTURE_2D, texture);
-      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-      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 framebuffer = gl.createFramebuffer();
-      gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
-      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
-      return { framebuffer, texture };
-    };
-    const fbo1 = createFBOTexture();
-    const fbo2 = createFBOTexture();
-    this.backbufferFramebuffer = fbo1.framebuffer;
-    this.backbufferTexture = fbo1.texture;
-    this.currentFramebuffer = fbo2.framebuffer;
-    this.currentTexture = fbo2.texture;
-    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-    gl.bindTexture(gl.TEXTURE_2D, null);
-  }
-  /**
-   * Main render method
-   */
-  render(viji, parameterObjects) {
-    const gl = this.gl;
-    if (!this.program || !this.quadBuffer) {
-      console.warn("Shader not initialized");
-      return;
-    }
-    gl.useProgram(this.program);
-    this.updateBuiltInUniforms(viji);
-    this.updateParameterUniforms(parameterObjects);
-    if (this.backbufferEnabled && this.backbufferTexture) {
-      const backbufferUnit = this.textureUnits.get("backbuffer");
-      if (backbufferUnit !== void 0) {
-        gl.activeTexture(gl.TEXTURE0 + backbufferUnit);
-        gl.bindTexture(gl.TEXTURE_2D, this.backbufferTexture);
-        this.setUniform("backbuffer", "sampler2D", backbufferUnit);
-      }
-      gl.bindFramebuffer(gl.FRAMEBUFFER, this.currentFramebuffer);
-    }
-    const positionLocation = gl.getAttribLocation(this.program, "a_position");
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
-    gl.enableVertexAttribArray(positionLocation);
-    gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-    if (this.backbufferEnabled) {
-      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-      gl.activeTexture(gl.TEXTURE0);
-      gl.bindTexture(gl.TEXTURE_2D, this.currentTexture);
-      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-      const tempFB = this.backbufferFramebuffer;
-      const tempTex = this.backbufferTexture;
-      this.backbufferFramebuffer = this.currentFramebuffer;
-      this.backbufferTexture = this.currentTexture;
-      this.currentFramebuffer = tempFB;
-      this.currentTexture = tempTex;
-    }
-  }
-  /**
-   * Update built-in uniforms from viji object
-   */
-  updateBuiltInUniforms(viji) {
-    this.setUniform("u_resolution", "vec2", [viji.width, viji.height]);
-    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);
-    this.setUniform("u_mousePressed", "bool", viji.mouse.isPressed);
-    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_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);
-    this.setUniform("u_keyAlt", "bool", viji.keyboard.alt);
-    this.setUniform("u_keyW", "bool", viji.keyboard.isPressed("w") || viji.keyboard.isPressed("W"));
-    this.setUniform("u_keyA", "bool", viji.keyboard.isPressed("a") || viji.keyboard.isPressed("A"));
-    this.setUniform("u_keyS", "bool", viji.keyboard.isPressed("s") || viji.keyboard.isPressed("S"));
-    this.setUniform("u_keyD", "bool", viji.keyboard.isPressed("d") || viji.keyboard.isPressed("D"));
-    this.setUniform("u_keyUp", "bool", viji.keyboard.isPressed("ArrowUp"));
-    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"));
-    this.setUniform("u_touchCount", "int", viji.touches.count);
-    for (let i = 0; i < 5; i++) {
-      const touch = viji.touches.points[i];
-      if (touch) {
-        this.setUniform(`u_touch${i}`, "vec2", [touch.x, viji.height - touch.y]);
-      } else {
-        this.setUniform(`u_touch${i}`, "vec2", [0, 0]);
-      }
-    }
-    const audio = viji.audio;
-    this.setUniform("u_audioVolume", "float", audio.volume?.rms || 0);
-    this.setUniform("u_audioPeak", "float", audio.volume?.peak || 0);
-    this.setUniform("u_audioBass", "float", audio.bands?.bass || 0);
-    this.setUniform("u_audioMid", "float", audio.bands?.mid || 0);
-    this.setUniform("u_audioTreble", "float", audio.bands?.treble || 0);
-    this.setUniform("u_audioSubBass", "float", audio.bands?.subBass || 0);
-    this.setUniform("u_audioLowMid", "float", audio.bands?.lowMid || 0);
-    this.setUniform("u_audioHighMid", "float", audio.bands?.highMid || 0);
-    this.setUniform("u_audioPresence", "float", audio.bands?.presence || 0);
-    this.setUniform("u_audioBrilliance", "float", audio.bands?.brilliance || 0);
-    if (audio.isConnected) {
-      this.updateAudioFFTTexture(audio.getFrequencyData());
-    }
-    const video = viji.video;
-    if (video.isConnected && video.currentFrame) {
-      this.updateVideoTexture(video.currentFrame);
-      this.setUniform("u_videoResolution", "vec2", [video.frameWidth, video.frameHeight]);
-      this.setUniform("u_videoFrameRate", "float", video.frameRate);
-    } else {
-      this.setUniform("u_videoResolution", "vec2", [0, 0]);
-      this.setUniform("u_videoFrameRate", "float", 0);
-    }
-    const faces = video.faces || [];
-    this.setUniform("u_faceCount", "int", faces.length);
-    if (faces.length > 0) {
-      const face = faces[0];
-      this.setUniform("u_face0Bounds", "vec4", [face.bounds.x, face.bounds.y, face.bounds.width, face.bounds.height]);
-      this.setUniform("u_face0HeadPose", "vec3", [face.headPose.pitch, face.headPose.yaw, face.headPose.roll]);
-      this.setUniform("u_face0Confidence", "float", face.confidence);
-      this.setUniform("u_face0Happy", "float", face.expressions.happy);
-      this.setUniform("u_face0Sad", "float", face.expressions.sad);
-      this.setUniform("u_face0Angry", "float", face.expressions.angry);
-      this.setUniform("u_face0Surprised", "float", face.expressions.surprised);
-    } else {
-      this.setUniform("u_face0Bounds", "vec4", [0, 0, 0, 0]);
-      this.setUniform("u_face0HeadPose", "vec3", [0, 0, 0]);
-      this.setUniform("u_face0Confidence", "float", 0);
-      this.setUniform("u_face0Happy", "float", 0);
-      this.setUniform("u_face0Sad", "float", 0);
-      this.setUniform("u_face0Angry", "float", 0);
-      this.setUniform("u_face0Surprised", "float", 0);
-    }
-    const hands = video.hands || [];
-    this.setUniform("u_handCount", "int", hands.length);
-    const leftHand = hands.find((h) => h.handedness === "left");
-    const rightHand = hands.find((h) => h.handedness === "right");
-    if (leftHand) {
-      this.setUniform("u_leftHandPalm", "vec3", [leftHand.palm.x, leftHand.palm.y, leftHand.palm.z]);
-      this.setUniform("u_leftHandFist", "float", leftHand.gestures?.fist || 0);
-      this.setUniform("u_leftHandOpen", "float", leftHand.gestures?.openPalm || 0);
-    } else {
-      this.setUniform("u_leftHandPalm", "vec3", [0, 0, 0]);
-      this.setUniform("u_leftHandFist", "float", 0);
-      this.setUniform("u_leftHandOpen", "float", 0);
-    }
-    if (rightHand) {
-      this.setUniform("u_rightHandPalm", "vec3", [rightHand.palm.x, rightHand.palm.y, rightHand.palm.z]);
-      this.setUniform("u_rightHandFist", "float", rightHand.gestures?.fist || 0);
-      this.setUniform("u_rightHandOpen", "float", rightHand.gestures?.openPalm || 0);
-    } else {
-      this.setUniform("u_rightHandPalm", "vec3", [0, 0, 0]);
-      this.setUniform("u_rightHandFist", "float", 0);
-      this.setUniform("u_rightHandOpen", "float", 0);
-    }
-    const pose = video.pose;
-    this.setUniform("u_poseDetected", "bool", pose !== null);
-    if (pose) {
-      const nose = pose.landmarks[0];
-      const leftWrist = pose.landmarks[15];
-      const rightWrist = pose.landmarks[16];
-      const leftAnkle = pose.landmarks[27];
-      const rightAnkle = pose.landmarks[28];
-      this.setUniform("u_nosePosition", "vec2", [nose?.x || 0, nose?.y || 0]);
-      this.setUniform("u_leftWristPosition", "vec2", [leftWrist?.x || 0, leftWrist?.y || 0]);
-      this.setUniform("u_rightWristPosition", "vec2", [rightWrist?.x || 0, rightWrist?.y || 0]);
-      this.setUniform("u_leftAnklePosition", "vec2", [leftAnkle?.x || 0, leftAnkle?.y || 0]);
-      this.setUniform("u_rightAnklePosition", "vec2", [rightAnkle?.x || 0, rightAnkle?.y || 0]);
-    } else {
-      this.setUniform("u_nosePosition", "vec2", [0, 0]);
-      this.setUniform("u_leftWristPosition", "vec2", [0, 0]);
-      this.setUniform("u_rightWristPosition", "vec2", [0, 0]);
-      this.setUniform("u_leftAnklePosition", "vec2", [0, 0]);
-      this.setUniform("u_rightAnklePosition", "vec2", [0, 0]);
-    }
-    const segmentation = video.segmentation;
-    if (segmentation) {
-      this.updateSegmentationTexture(segmentation.mask, segmentation.width, segmentation.height);
-      this.setUniform("u_segmentationRes", "vec2", [segmentation.width, segmentation.height]);
-    } else {
-      this.setUniform("u_segmentationRes", "vec2", [0, 0]);
-    }
-  }
-  /**
-   * Update parameter uniforms from parameter objects
-   */
-  updateParameterUniforms(parameterObjects) {
-    for (const param of this.parameters) {
-      const paramObj = parameterObjects.get(param.uniformName);
-      if (!paramObj) continue;
-      const value = paramObj.value;
-      switch (param.type) {
-        case "slider":
-        case "number":
-          this.setUniform(param.uniformName, "float", value);
-          break;
-        case "color":
-          const rgb = this.hexToRgb(value);
-          this.setUniform(param.uniformName, "vec3", rgb);
-          break;
-        case "toggle":
-          this.setUniform(param.uniformName, "bool", value);
-          break;
-        case "select":
-          const index = param.config.options?.indexOf(value) || 0;
-          this.setUniform(param.uniformName, "int", index);
-          break;
-        case "image":
-          if (value) {
-            this.updateImageTexture(param.uniformName, value);
-          }
-          break;
-      }
-    }
-  }
-  /**
-   * Set uniform value
-   */
-  setUniform(name, type, value) {
-    const location = this.uniformLocations.get(name);
-    if (location === null || location === void 0) {
-      return;
-    }
-    const gl = this.gl;
-    switch (type) {
-      case "float":
-        gl.uniform1f(location, value);
-        break;
-      case "int":
-        gl.uniform1i(location, value);
-        break;
-      case "bool":
-        gl.uniform1i(location, value ? 1 : 0);
-        break;
-      case "vec2":
-        gl.uniform2f(location, value[0], value[1]);
-        break;
-      case "vec3":
-        gl.uniform3f(location, value[0], value[1], value[2]);
-        break;
-      case "vec4":
-        gl.uniform4f(location, value[0], value[1], value[2], value[3]);
-        break;
-    }
-  }
-  /**
-   * Convert hex color to RGB [0-1]
-   */
-  hexToRgb(hex) {
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    if (result) {
-      return [
-        parseInt(result[1], 16) / 255,
-        parseInt(result[2], 16) / 255,
-        parseInt(result[3], 16) / 255
-      ];
-    }
-    return [0, 0, 0];
-  }
-  /**
-   * Update audio FFT texture
-   */
-  updateAudioFFTTexture(frequencyData) {
-    const gl = this.gl;
-    const unit = this.textureUnits.get("u_audioFFT");
-    if (!this.audioFFTTexture) {
-      this.audioFFTTexture = gl.createTexture();
-    }
-    gl.activeTexture(gl.TEXTURE0 + unit);
-    gl.bindTexture(gl.TEXTURE_2D, this.audioFFTTexture);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      0,
-      gl.LUMINANCE,
-      frequencyData.length,
-      1,
-      0,
-      gl.LUMINANCE,
-      gl.UNSIGNED_BYTE,
-      frequencyData
-    );
-    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_audioFFT");
-    if (location) {
-      gl.uniform1i(location, unit);
-    }
-  }
-  /**
-   * Update video texture
-   */
-  updateVideoTexture(videoFrame) {
-    const gl = this.gl;
-    const unit = this.textureUnits.get("u_video");
-    if (!this.videoTexture) {
-      this.videoTexture = gl.createTexture();
-    }
-    gl.activeTexture(gl.TEXTURE0 + unit);
-    gl.bindTexture(gl.TEXTURE_2D, this.videoTexture);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      0,
-      gl.RGBA,
-      gl.RGBA,
-      gl.UNSIGNED_BYTE,
-      videoFrame
-    );
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    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_video");
-    if (location) {
-      gl.uniform1i(location, unit);
-    }
-  }
-  /**
-   * Update segmentation mask texture
-   */
-  updateSegmentationTexture(mask, width, height) {
-    const gl = this.gl;
-    const unit = this.textureUnits.get("u_segmentationMask");
-    if (!this.segmentationTexture) {
-      this.segmentationTexture = gl.createTexture();
-    }
-    gl.activeTexture(gl.TEXTURE0 + unit);
-    gl.bindTexture(gl.TEXTURE_2D, this.segmentationTexture);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      0,
-      gl.LUMINANCE,
-      width,
-      height,
-      0,
-      gl.LUMINANCE,
-      gl.UNSIGNED_BYTE,
-      mask
-    );
-    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_segmentationMask");
-    if (location) {
-      gl.uniform1i(location, unit);
-    }
-  }
-  /**
-   * Update image parameter texture
-   */
-  updateImageTexture(name, imageBitmap) {
-    const gl = this.gl;
-    if (!this.textureUnits.has(name)) {
-      this.textureUnits.set(name, this.nextTextureUnit++);
-    }
-    const unit = this.textureUnits.get(name);
-    if (!this.textures.has(name)) {
-      const texture2 = gl.createTexture();
-      if (texture2) {
-        this.textures.set(name, texture2);
-      }
-    }
-    const texture = this.textures.get(name);
-    if (!texture) return;
-    gl.activeTexture(gl.TEXTURE0 + unit);
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texImage2D(
-      gl.TEXTURE_2D,
-      0,
-      gl.RGBA,
-      gl.RGBA,
-      gl.UNSIGNED_BYTE,
-      imageBitmap
-    );
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-    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(name);
-    if (location) {
-      gl.uniform1i(location, unit);
-    }
-  }
-  /**
-   * Handle canvas resize
-   */
-  resize(width, height) {
-    const gl = this.gl;
-    gl.viewport(0, 0, width, height);
-    if (this.backbufferEnabled) {
-      this.createBackbufferFramebuffers();
-    }
-  }
-  /**
-   * Get parameter definitions for host
-   */
-  getParameterDefinitions() {
-    return this.parameters;
-  }
-}
-export {
-  ShaderWorkerAdapter
-};
-//# sourceMappingURL=ShaderWorkerAdapter.js.map