@shogo-ai/voice 1.10.0 → 2.4.2

package/dist/chunk-KMSL5PWK.js

@@ -0,0 +1,540 @@
+import {
+  ORGANIC_PARTICLES_FRAGMENT_SHADER,
+  ORGANIC_PARTICLES_VERTEX_SHADER,
+  ORGANIC_SPHERE_FRAGMENT_SHADER,
+  ORGANIC_SPHERE_VERTEX_SHADER,
+  resolveOrganicParticlesConfig,
+  resolveOrganicSphereConfig
+} from "./chunk-BI6SL35K.js";
+
+// src/react/OrganicSphere.tsx
+import { useEffect, useMemo, useRef } from "react";
+import * as THREE from "three";
+import { jsx } from "react/jsx-runtime";
+function seededUnit(seed, salt) {
+  const s = Math.sin((seed + salt * 7919) * 12.9898 + salt * 78.233) * 43758.5453;
+  return s - Math.floor(s);
+}
+function OrganicSphere({
+  getFrequencyData,
+  active = true,
+  config: configProp,
+  lightAColor,
+  lightBColor,
+  rimColor,
+  rimThreshold,
+  rimPower,
+  backgroundColor,
+  subdivisions,
+  maxPixelRatio,
+  className,
+  style
+}) {
+  const containerRef = useRef(null);
+  const resolvedConfig = useMemo(() => {
+    const base = resolveOrganicSphereConfig(configProp);
+    const overrides = {};
+    if (lightAColor !== void 0) overrides.lightAColor = lightAColor;
+    if (lightBColor !== void 0) overrides.lightBColor = lightBColor;
+    if (rimColor !== void 0) overrides.rimColor = rimColor;
+    if (rimThreshold !== void 0) overrides.rimThreshold = rimThreshold;
+    if (rimPower !== void 0) overrides.rimPower = rimPower;
+    if (backgroundColor !== void 0) overrides.backgroundColor = backgroundColor;
+    if (subdivisions !== void 0) overrides.subdivisions = subdivisions;
+    if (maxPixelRatio !== void 0) overrides.maxPixelRatio = maxPixelRatio;
+    return { ...base, ...overrides };
+  }, [
+    configProp,
+    lightAColor,
+    lightBColor,
+    rimColor,
+    rimThreshold,
+    rimPower,
+    backgroundColor,
+    subdivisions,
+    maxPixelRatio
+  ]);
+  const configRef = useRef(resolvedConfig);
+  useEffect(() => {
+    configRef.current = resolvedConfig;
+  }, [resolvedConfig]);
+  const getFrequencyDataRef = useRef(getFrequencyData);
+  const activeRef = useRef(active);
+  useEffect(() => {
+    getFrequencyDataRef.current = getFrequencyData;
+  }, [getFrequencyData]);
+  useEffect(() => {
+    activeRef.current = active;
+  }, [active]);
+  const initSubdivisions = resolvedConfig.subdivisions;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const cfg0 = configRef.current;
+    const width = container.clientWidth || 1;
+    const height = container.clientHeight || 1;
+    const pixelRatio = Math.min(
+      initMaxPixelRatio ?? (typeof window !== "undefined" ? window.devicePixelRatio : 1),
+      2
+    );
+    const scene = new THREE.Scene();
+    if (initBackgroundColor) scene.background = new THREE.Color(initBackgroundColor);
+    const camera = new THREE.PerspectiveCamera(cfg0.fov, width / height, 0.1, 100);
+    camera.position.set(0, 0, cfg0.cameraZ);
+    scene.add(camera);
+    const renderer = new THREE.WebGLRenderer({
+      antialias: true,
+      alpha: initBackgroundColor === null,
+      powerPreference: "high-performance"
+    });
+    renderer.setSize(width, height, false);
+    renderer.setPixelRatio(pixelRatio);
+    renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+    container.appendChild(renderer.domElement);
+    renderer.domElement.style.display = "block";
+    renderer.domElement.style.width = "100%";
+    renderer.domElement.style.height = "100%";
+    const geometry = new THREE.SphereGeometry(1, initSubdivisions, initSubdivisions);
+    geometry.computeTangents();
+    const lightAPos = new THREE.Vector3().setFromSpherical(
+      new THREE.Spherical(1, 0.615, 2.049)
+    );
+    const lightBPos = new THREE.Vector3().setFromSpherical(
+      new THREE.Spherical(1, 2.561, -1.844)
+    );
+    const lightAColorObj = new THREE.Color(cfg0.lightAColor);
+    const lightBColorObj = new THREE.Color(cfg0.lightBColor);
+    const rimColorObj = new THREE.Color(cfg0.rimColor ?? cfg0.lightBColor);
+    const material = new THREE.ShaderMaterial({
+      uniforms: {
+        uLightAColor: { value: lightAColorObj },
+        uLightAPosition: { value: lightAPos },
+        uLightAIntensity: { value: cfg0.lightAIntensity },
+        uLightBColor: { value: lightBColorObj },
+        uLightBPosition: { value: lightBPos },
+        uLightBIntensity: { value: cfg0.lightBIntensity },
+        uSubdivision: {
+          value: new THREE.Vector2(initSubdivisions, initSubdivisions)
+        },
+        uOffset: { value: new THREE.Vector3() },
+        uDistortionFrequency: { value: cfg0.distortionFrequency },
+        uDistortionStrength: { value: cfg0.high.idle },
+        uDisplacementFrequency: { value: cfg0.displacementFrequency },
+        uDisplacementStrength: { value: cfg0.volume.idle },
+        uFresnelOffset: { value: cfg0.fresnelOffset },
+        uFresnelMultiplier: { value: cfg0.medium.idle },
+        uFresnelPower: { value: cfg0.fresnelPower },
+        uRimColor: { value: rimColorObj },
+        uRimThreshold: { value: cfg0.rimThreshold },
+        uRimPower: { value: cfg0.rimPower },
+        uTime: { value: 0 }
+      },
+      defines: { USE_TANGENT: "" },
+      vertexShader: ORGANIC_SPHERE_VERTEX_SHADER,
+      fragmentShader: ORGANIC_SPHERE_FRAGMENT_SHADER
+    });
+    const mesh = new THREE.Mesh(geometry, material);
+    scene.add(mesh);
+    const seedInitialPhase = (seed) => ({
+      phi: seededUnit(seed, 1) * Math.PI,
+      theta: seededUnit(seed, 2) * Math.PI * 2
+    });
+    const initialPhase = seedInitialPhase(cfg0.seed);
+    const offsetSpherical = new THREE.Spherical(1, initialPhase.phi, initialPhase.theta);
+    const offsetDirection = new THREE.Vector3().setFromSpherical(offsetSpherical);
+    const variations = {
+      volume: { target: 0, current: cfg0.volume.idle },
+      medium: { target: 0, current: cfg0.medium.idle },
+      high: { target: 0, current: cfg0.high.idle },
+      low: { target: 0, current: cfg0.low.idle }
+    };
+    const resetAnimationState = (cfg) => {
+      material.uniforms.uTime.value = 0;
+      material.uniforms.uOffset.value.set(0, 0, 0);
+      const phase = seedInitialPhase(cfg.seed);
+      offsetSpherical.radius = 1;
+      offsetSpherical.phi = phase.phi;
+      offsetSpherical.theta = phase.theta;
+      variations.volume.current = cfg.volume.idle;
+      variations.medium.current = cfg.medium.idle;
+      variations.high.current = cfg.high.idle;
+      variations.low.current = cfg.low.idle;
+      variations.volume.target = cfg.volume.idle;
+      variations.medium.target = cfg.medium.idle;
+      variations.high.target = cfg.high.idle;
+      variations.low.target = cfg.low.idle;
+    };
+    const LEVEL_COUNT = 8;
+    function computeLevels(buf) {
+      const bins = Math.floor(buf.length / LEVEL_COUNT);
+      const levels = new Array(LEVEL_COUNT).fill(0);
+      if (bins <= 0) return levels;
+      for (let i = 0; i < LEVEL_COUNT; i++) {
+        let sum = 0;
+        for (let j = 0; j < bins; j++) sum += buf[i * bins + j];
+        levels[i] = sum / bins / 256;
+      }
+      return levels;
+    }
+    function bandTarget(reactivity, levels, sourceLevel) {
+      if (!levels) return reactivity.idle;
+      return Math.max(reactivity.floor, reactivity.floor + sourceLevel * reactivity.gain);
+    }
+    let rafId = 0;
+    let lastTs = performance.now();
+    let disposed = false;
+    let wasActive = activeRef.current;
+    let lastSeed = cfg0.seed;
+    const render = () => {
+      if (disposed) return;
+      const now = performance.now();
+      const delta = Math.min(now - lastTs, 100);
+      lastTs = now;
+      const cfg = configRef.current;
+      lightAColorObj.set(cfg.lightAColor);
+      lightBColorObj.set(cfg.lightBColor);
+      rimColorObj.set(cfg.rimColor ?? cfg.lightBColor);
+      material.uniforms.uLightAIntensity.value = cfg.lightAIntensity;
+      material.uniforms.uLightBIntensity.value = cfg.lightBIntensity;
+      material.uniforms.uDistortionFrequency.value = cfg.distortionFrequency;
+      material.uniforms.uDisplacementFrequency.value = cfg.displacementFrequency;
+      material.uniforms.uFresnelOffset.value = cfg.fresnelOffset;
+      material.uniforms.uFresnelPower.value = cfg.fresnelPower;
+      material.uniforms.uRimThreshold.value = cfg.rimThreshold;
+      material.uniforms.uRimPower.value = cfg.rimPower;
+      if (camera.position.z !== cfg.cameraZ) camera.position.z = cfg.cameraZ;
+      if (camera.fov !== cfg.fov) {
+        camera.fov = cfg.fov;
+        camera.updateProjectionMatrix();
+      }
+      const isActive = activeRef.current;
+      if (isActive && !wasActive || cfg.seed !== lastSeed) {
+        resetAnimationState(cfg);
+        lastSeed = cfg.seed;
+      }
+      wasActive = isActive;
+      if (isActive) {
+        let levels = null;
+        if (getFrequencyDataRef.current) {
+          try {
+            const buf = getFrequencyDataRef.current();
+            if (buf && buf.length > 0) levels = computeLevels(buf);
+          } catch {
+            levels = null;
+          }
+        }
+        const l0 = levels ? levels[0] || 0 : 0;
+        const l1 = levels ? levels[1] || 0 : 0;
+        const l2 = levels ? levels[2] || 0 : 0;
+        const loudest = Math.max(l0, l1, l2);
+        const update = (variation, reactivity, sourceLevel) => {
+          variation.target = bandTarget(reactivity, levels, sourceLevel);
+          const easing = variation.target > variation.current ? reactivity.attack : reactivity.decay;
+          variation.current += (variation.target - variation.current) * easing * delta;
+        };
+        update(variations.volume, cfg.volume, loudest);
+        update(variations.medium, cfg.medium, l1);
+        update(variations.high, cfg.high, l2);
+        update(variations.low, cfg.low, l0);
+        const timeFrequency = variations.low.current;
+        const elapsed = delta * timeFrequency;
+        material.uniforms.uDisplacementStrength.value = variations.volume.current;
+        material.uniforms.uDistortionStrength.value = variations.high.current;
+        material.uniforms.uFresnelMultiplier.value = variations.medium.current;
+        const offsetTime = (material.uniforms.uTime.value + elapsed) * 0.3;
+        offsetSpherical.phi = (Math.sin(offsetTime * 1e-3) * Math.sin(offsetTime * 321e-5) * 0.5 + 0.5) * Math.PI;
+        offsetSpherical.theta = (Math.sin(offsetTime * 1e-4) * Math.sin(offsetTime * 321e-6) * 0.5 + 0.5) * Math.PI * 2;
+        offsetDirection.setFromSpherical(offsetSpherical);
+        offsetDirection.multiplyScalar(timeFrequency * 2);
+        material.uniforms.uOffset.value.add(offsetDirection);
+        material.uniforms.uTime.value += elapsed;
+      }
+      renderer.render(scene, camera);
+      rafId = requestAnimationFrame(render);
+    };
+    rafId = requestAnimationFrame(render);
+    const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => {
+      const w = container.clientWidth || 1;
+      const h = container.clientHeight || 1;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h, false);
+    }) : null;
+    resizeObserver?.observe(container);
+    return () => {
+      disposed = true;
+      cancelAnimationFrame(rafId);
+      resizeObserver?.disconnect();
+      geometry.dispose();
+      material.dispose();
+      renderer.dispose();
+      if (renderer.domElement.parentNode === container) {
+        container.removeChild(renderer.domElement);
+      }
+    };
+  }, [initSubdivisions, initMaxPixelRatio, initBackgroundColor]);
+  return /* @__PURE__ */ jsx("div", { ref: containerRef, className, style });
+}
+
+// src/react/OrganicParticles.tsx
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2 } from "react";
+import * as THREE2 from "three";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function seededUnit2(seed, salt) {
+  const s = Math.sin((seed + salt * 7919) * 12.9898 + salt * 78.233) * 43758.5453;
+  return s - Math.floor(s);
+}
+function buildParticleAttributes(count, innerRadius, outerRadius, seed) {
+  const positions = new Float32Array(count * 3);
+  const seeds = new Float32Array(count);
+  for (let i = 0; i < count; i++) {
+    const u = seededUnit2(seed, i * 4 + 1);
+    const v = seededUnit2(seed, i * 4 + 2);
+    const w = seededUnit2(seed, i * 4 + 3);
+    const s = seededUnit2(seed, i * 4 + 4);
+    const theta = v * Math.PI * 2;
+    const phi = Math.acos(2 * w - 1);
+    const r = innerRadius + u * Math.max(0, outerRadius - innerRadius);
+    const sinPhi = Math.sin(phi);
+    positions[i * 3 + 0] = r * sinPhi * Math.cos(theta);
+    positions[i * 3 + 1] = r * sinPhi * Math.sin(theta);
+    positions[i * 3 + 2] = r * Math.cos(phi);
+    seeds[i] = s;
+  }
+  return { positions, seeds };
+}
+function OrganicParticles({
+  getFrequencyData,
+  active = true,
+  config: configProp,
+  className,
+  style
+}) {
+  const containerRef = useRef2(null);
+  const resolvedConfig = useMemo2(
+    () => resolveOrganicParticlesConfig(configProp),
+    [configProp]
+  );
+  const configRef = useRef2(resolvedConfig);
+  useEffect2(() => {
+    configRef.current = resolvedConfig;
+  }, [resolvedConfig]);
+  const getFrequencyDataRef = useRef2(getFrequencyData);
+  const activeRef = useRef2(active);
+  useEffect2(() => {
+    getFrequencyDataRef.current = getFrequencyData;
+  }, [getFrequencyData]);
+  useEffect2(() => {
+    activeRef.current = active;
+  }, [active]);
+  const initCount = resolvedConfig.count;
+  const initInnerRadius = resolvedConfig.innerRadius;
+  const initOuterRadius = resolvedConfig.outerRadius;
+  const initSeed = resolvedConfig.seed;
+  const initMaxPixelRatio = resolvedConfig.maxPixelRatio;
+  const initBackgroundColor = resolvedConfig.backgroundColor;
+  useEffect2(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const cfg0 = configRef.current;
+    const width = container.clientWidth || 1;
+    const height = container.clientHeight || 1;
+    const pixelRatio = Math.min(
+      initMaxPixelRatio ?? (typeof window !== "undefined" ? window.devicePixelRatio : 1),
+      2
+    );
+    const scene = new THREE2.Scene();
+    if (initBackgroundColor) scene.background = new THREE2.Color(initBackgroundColor);
+    const camera = new THREE2.PerspectiveCamera(cfg0.fov, width / height, 0.1, 100);
+    camera.position.set(0, 0, cfg0.cameraZ);
+    scene.add(camera);
+    const renderer = new THREE2.WebGLRenderer({
+      antialias: true,
+      alpha: initBackgroundColor === null,
+      powerPreference: "high-performance"
+    });
+    renderer.setSize(width, height, false);
+    renderer.setPixelRatio(pixelRatio);
+    renderer.setClearColor(0, initBackgroundColor === null ? 0 : 1);
+    container.appendChild(renderer.domElement);
+    renderer.domElement.style.display = "block";
+    renderer.domElement.style.width = "100%";
+    renderer.domElement.style.height = "100%";
+    const { positions, seeds } = buildParticleAttributes(
+      initCount,
+      initInnerRadius,
+      initOuterRadius,
+      initSeed
+    );
+    const geometry = new THREE2.BufferGeometry();
+    geometry.setAttribute("aBasePosition", new THREE2.BufferAttribute(positions, 3));
+    geometry.setAttribute("aSeed", new THREE2.BufferAttribute(seeds, 1));
+    geometry.setAttribute("position", new THREE2.BufferAttribute(positions, 3));
+    const colorCoolObj = new THREE2.Color(cfg0.colorCool);
+    const colorHotObj = new THREE2.Color(cfg0.colorHot);
+    const material = new THREE2.ShaderMaterial({
+      uniforms: {
+        uTime: { value: 0 },
+        uNoiseFrequency: { value: cfg0.noiseFrequency },
+        uNoiseStrength: { value: cfg0.noiseStrength },
+        uDisplacement: { value: cfg0.volume.idle },
+        uSwirl: { value: cfg0.high.idle },
+        uSwirlTimeRate: { value: cfg0.swirlTimeRate },
+        uSizeBase: { value: cfg0.sizeBase },
+        uSizeAudio: { value: cfg0.medium.idle },
+        uPixelRatio: { value: pixelRatio },
+        uColorCool: { value: colorCoolObj },
+        uColorHot: { value: colorHotObj },
+        uOpacity: { value: cfg0.opacity },
+        uSoftness: { value: cfg0.softness }
+      },
+      vertexShader: ORGANIC_PARTICLES_VERTEX_SHADER,
+      fragmentShader: ORGANIC_PARTICLES_FRAGMENT_SHADER,
+      transparent: true,
+      depthWrite: false,
+      blending: THREE2.AdditiveBlending
+    });
+    const points = new THREE2.Points(geometry, material);
+    scene.add(points);
+    const variations = {
+      volume: { target: 0, current: cfg0.volume.idle },
+      medium: { target: 0, current: cfg0.medium.idle },
+      high: { target: 0, current: cfg0.high.idle },
+      low: { target: 0, current: cfg0.low.idle }
+    };
+    const LEVEL_COUNT = 8;
+    function computeLevels(buf) {
+      const bins = Math.floor(buf.length / LEVEL_COUNT);
+      const levels = new Array(LEVEL_COUNT).fill(0);
+      if (bins <= 0) return levels;
+      for (let i = 0; i < LEVEL_COUNT; i++) {
+        let sum = 0;
+        for (let j = 0; j < bins; j++) sum += buf[i * bins + j];
+        levels[i] = sum / bins / 256;
+      }
+      return levels;
+    }
+    function bandTarget(reactivity, levels, sourceLevel) {
+      if (!levels) return reactivity.idle;
+      return Math.max(
+        reactivity.floor,
+        reactivity.floor + sourceLevel * reactivity.gain
+      );
+    }
+    const rotationState = { y: 0 };
+    const resetAnimationState = (cfg) => {
+      material.uniforms.uTime.value = 0;
+      rotationState.y = 0;
+      points.rotation.set(0, 0, 0);
+      variations.volume.current = cfg.volume.idle;
+      variations.medium.current = cfg.medium.idle;
+      variations.high.current = cfg.high.idle;
+      variations.low.current = cfg.low.idle;
+      variations.volume.target = cfg.volume.idle;
+      variations.medium.target = cfg.medium.idle;
+      variations.high.target = cfg.high.idle;
+      variations.low.target = cfg.low.idle;
+    };
+    let rafId = 0;
+    let lastTs = performance.now();
+    let disposed = false;
+    let wasActive = activeRef.current;
+    const render = () => {
+      if (disposed) return;
+      const now = performance.now();
+      const delta = Math.min(now - lastTs, 100);
+      lastTs = now;
+      const cfg = configRef.current;
+      colorCoolObj.set(cfg.colorCool);
+      colorHotObj.set(cfg.colorHot);
+      material.uniforms.uNoiseFrequency.value = cfg.noiseFrequency;
+      material.uniforms.uNoiseStrength.value = cfg.noiseStrength;
+      material.uniforms.uSwirlTimeRate.value = cfg.swirlTimeRate;
+      material.uniforms.uSizeBase.value = cfg.sizeBase;
+      material.uniforms.uOpacity.value = cfg.opacity;
+      material.uniforms.uSoftness.value = cfg.softness;
+      if (camera.position.z !== cfg.cameraZ) camera.position.z = cfg.cameraZ;
+      if (camera.fov !== cfg.fov) {
+        camera.fov = cfg.fov;
+        camera.updateProjectionMatrix();
+      }
+      const isActive = activeRef.current;
+      if (isActive && !wasActive) {
+        resetAnimationState(cfg);
+      }
+      wasActive = isActive;
+      if (isActive) {
+        let levels = null;
+        if (getFrequencyDataRef.current) {
+          try {
+            const buf = getFrequencyDataRef.current();
+            if (buf && buf.length > 0) levels = computeLevels(buf);
+          } catch {
+            levels = null;
+          }
+        }
+        const l0 = levels ? levels[0] || 0 : 0;
+        const l1 = levels ? levels[1] || 0 : 0;
+        const l2 = levels ? levels[2] || 0 : 0;
+        const loudest = Math.max(l0, l1, l2);
+        const update = (variation, reactivity, sourceLevel) => {
+          variation.target = bandTarget(reactivity, levels, sourceLevel);
+          const easing = variation.target > variation.current ? reactivity.attack : reactivity.decay;
+          variation.current += (variation.target - variation.current) * easing * delta;
+        };
+        update(variations.volume, cfg.volume, loudest);
+        update(variations.medium, cfg.medium, l1);
+        update(variations.high, cfg.high, l2);
+        update(variations.low, cfg.low, l0);
+        const timeFrequency = variations.low.current;
+        const elapsed = delta * timeFrequency;
+        material.uniforms.uDisplacement.value = variations.volume.current;
+        material.uniforms.uSizeAudio.value = variations.medium.current;
+        material.uniforms.uSwirl.value = variations.high.current;
+        material.uniforms.uTime.value += elapsed;
+        rotationState.y += delta * cfg.rotationBias + variations.high.current * delta * 8e-4;
+        points.rotation.y = rotationState.y;
+      } else {
+        material.uniforms.uTime.value += delta * cfg.idleNoiseRate;
+      }
+      renderer.render(scene, camera);
+      rafId = requestAnimationFrame(render);
+    };
+    rafId = requestAnimationFrame(render);
+    const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => {
+      const w = container.clientWidth || 1;
+      const h = container.clientHeight || 1;
+      camera.aspect = w / h;
+      camera.updateProjectionMatrix();
+      renderer.setSize(w, h, false);
+    }) : null;
+    resizeObserver?.observe(container);
+    return () => {
+      disposed = true;
+      cancelAnimationFrame(rafId);
+      resizeObserver?.disconnect();
+      geometry.dispose();
+      material.dispose();
+      renderer.dispose();
+      if (renderer.domElement.parentNode === container) {
+        container.removeChild(renderer.domElement);
+      }
+    };
+  }, [
+    initCount,
+    initInnerRadius,
+    initOuterRadius,
+    initSeed,
+    initMaxPixelRatio,
+    initBackgroundColor
+  ]);
+  return /* @__PURE__ */ jsx2("div", { ref: containerRef, className, style });
+}
+
+export {
+  OrganicSphere,
+  OrganicParticles
+};
+//# sourceMappingURL=chunk-KMSL5PWK.js.map