@3driseai/3drise-viewer 0.1.22 → 0.1.23

package/dist/components/particles/TidalStreamParticles.js

@@ -3,7 +3,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react'
 import * as THREE from 'three';
 import { useFrame } from '@react-three/fiber';
 import { GENERATIVE_PARTICLES_ANIMATABLE } from '@3driseai/3drise-core';
-import { applyConfigKeyframeAnimations } from '../../utils/configAnimations.js';
+import { applyConfigKeyframeAnimations, applyConfigMouseMove } from '../../utils/configAnimations.js';
 import { createPointerUniforms, stepPointerField, usePointerField } from '../../utils/pointerField.js';
 import { createTrailUniforms, applyTrailConfig, createCpuTrail } from '../../utils/particleTrails.js';
 import { useObjectReady } from '../../hooks/useObjectReady.js';
@@ -768,7 +768,7 @@ const DEFAULTS = {
 const ANIMATABLE = new Set(GENERATIVE_PARTICLES_ANIMATABLE.tidalStream.map((p) => p.value));
 /** Knobs that rebuild the simulation: they change on commit, never through the live path. */
 const STRUCTURAL = ['particleCount', 'satelliteCount', 'orbitEccentricity', 'streamAge', 'discStars'];
-const TidalStreamParticles = ({ id, size, config, animations, onObjectReady, onObjectDispose }) => {
+const TidalStreamParticles = ({ id, size, config, animations, mouseMove, onObjectReady, onObjectDispose }) => {
     const rootRef = useRef(null);
     useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
     const s = size > 0 ? size : 1;
@@ -800,8 +800,12 @@ const TidalStreamParticles = ({ id, size, config, animations, onObjectReady, onO
     const pointer = usePointerField();
     useFrame((state, delta) => {
         instance.update(Math.min(delta, 0.1), state.camera, pointer);
-        if (keyframes?.length) {
+        // Keyframes first, pointer on top: a knob bound to both follows the cursor.
+        const pointerBound = !!mouseMove?.enabled && !!mouseMove.properties?.length;
+        if (keyframes?.length || pointerBound) {
             applyConfigKeyframeAnimations(keyframes, animFrom.current, cfg, animOverride.current, performance.now() - animStart.current, ANIMATABLE);
+            if (pointerBound)
+                applyConfigMouseMove(mouseMove.properties, cfg, animOverride.current, state.pointer, ANIMATABLE);
             push(live.current);
         }
     });

package/dist/components/spotBeam/SpotBeam.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { AnimationOptions, CreatedObjectSettings, MouseMoveDomain } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export type SpotBeamProps = ObjectReadyProps & {
+    /** Scene object id: the light controller finds the live-edit handle by it. */
+    id?: string;
+    config: Record<string, any>;
+    animations?: AnimationOptions[];
+    mouseMove?: MouseMoveDomain;
+    settings: CreatedObjectSettings | Record<string, any>;
+};
+declare const SpotBeam: React.FC<SpotBeamProps>;
+export default SpotBeam;
+//# sourceMappingURL=SpotBeam.d.ts.map

package/dist/components/spotBeam/SpotBeam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpotBeam.d.ts","sourceRoot":"","sources":["../../../src/components/spotBeam/SpotBeam.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAK1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOhE,MAAM,MAAM,aAAa,GAAG,gBAAgB,GAAG;IAC3C,8EAA8E;IAC9E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,QAAQ,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACzD,CAAC;AAuBF,QAAA,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAwOrC,CAAC;AACF,eAAe,QAAQ,CAAC"}

package/dist/components/spotBeam/SpotBeam.js

@@ -0,0 +1,244 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// =============================================================================
+// SpotBeam — a spot light you can see: pattern, beam and pool
+// =============================================================================
+//
+// Rendered by LightObject for `config.type === 'spotBeam'`. This is a light, not
+// a lamp: the geometry is a small emitter you can grab in the editor (and can
+// switch off entirely), because the object is meant to be dropped inside whatever
+// fixture the scene already has.
+//
+// The work is in the optics:
+//   - a procedural mask on SpotLight.map shapes the pool (slot, bars, blinds,
+//     window, leaves) — see beamPatterns.ts;
+//   - the beam samples that same mask, so the haze in the air and the light on
+//     the floor are the same shape;
+//   - the beam is nested cone shells in one InstancedMesh, dense on the axis.
+//
+// The object's origin is the light. It aims at `targetPosition` in world space,
+// the same contract the plain spot light uses.
+//
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import { CircleGeometry, Color, ConeGeometry, InstancedBufferAttribute, Matrix4, Object3D, SphereGeometry, Vector3 } from 'three';
+import { SELF_OWNED_MATERIAL_KEY } from '@3driseai/3drise-core';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useLightShadow } from '../../hooks/useLightShadow.js';
+import { useLightConfig } from '../../hooks/useLightConfig.js';
+import { createBeamPattern } from './beamPatterns.js';
+import { createSpotBeamMaterials, disposeSpotBeamMaterials } from './spotBeamMaterials.js';
+import { kelvinToColor } from '../lightBulb/kelvin.js';
+/** Cone shells: more is smoother haze, and each one is a draw. */
+const LAYERS = 10;
+const num = (v, fallback) => (typeof v === 'number' ? v : fallback);
+const hash = (n) => {
+    const s = Math.sin(n * 127.1) * 43758.5453;
+    return s - Math.floor(s);
+};
+const noise1 = (x) => {
+    const i = Math.floor(x), f = x - i, u = f * f * (3 - 2 * f);
+    return hash(i) * (1 - u) + hash(i + 1) * u;
+};
+const COLD = new Color(0.06, 0.02, 0.0);
+const EMBER = new Color(1.0, 0.4, 0.08);
+const WHITE = new Color(1, 1, 1);
+const scratchVec = new Vector3();
+const scratchScale = new Vector3();
+const scratchMatrix = new Matrix4();
+const SpotBeam = ({ id, config, animations, mouseMove, settings, onObjectReady, onObjectDispose }) => {
+    const scene = useThree((s) => s.scene);
+    const groupRef = useRef(null);
+    const lightRef = useRef(null);
+    const targetRef = useRef(new Object3D());
+    const beamRef = useRef(null);
+    const soloRef = useRef(null);
+    useObjectReady(groupRef, settings, onObjectReady, onObjectDispose);
+    useLightShadow(lightRef, config.shadow);
+    const { merged } = useLightConfig(groupRef, lightRef, id, config, animations, mouseMove);
+    // --- geometry: a unit cone for the beam, a small emitter ---
+    const geometry = useMemo(() => {
+        // apex at the origin, opening along +Y, rim radius == height so the
+        // shader can read x/y as the projector's coordinate
+        const cone = new ConeGeometry(1, 1, 56, 18, true);
+        cone.rotateX(Math.PI);
+        cone.translate(0, 0.5, 0);
+        const lens = new CircleGeometry(0.16, 40);
+        lens.rotateX(-Math.PI / 2);
+        const dot = new SphereGeometry(0.05, 20, 12);
+        return { cone, lens, dot };
+    }, []);
+    useEffect(() => () => {
+        geometry.cone.dispose();
+        geometry.lens.dispose();
+        geometry.dot.dispose();
+    }, [geometry]);
+    const mats = useMemo(() => createSpotBeamMaterials(), []);
+    useEffect(() => () => disposeSpotBeamMaterials(mats), [mats]);
+    // --- the projected mask: shapes the pool and the haze together ---
+    const pattern = (config.pattern ?? 'round');
+    const patternSoftness = Math.min(Math.max(num(config.patternSoftness, 0.25), 0), 1);
+    const patternRotation = num(config.patternRotation, 0);
+    useEffect(() => {
+        const texture = createBeamPattern(pattern, patternSoftness, patternRotation);
+        mats.layered.uniforms.uPattern.value = texture;
+        mats.volumetric.uniforms.uPattern.value = texture;
+        if (lightRef.current)
+            lightRef.current.map = texture;
+        return () => {
+            if (lightRef.current?.map === texture)
+                lightRef.current.map = null;
+            if (mats.layered.uniforms.uPattern.value === texture)
+                mats.layered.uniforms.uPattern.value = null;
+            if (mats.volumetric.uniforms.uPattern.value === texture)
+                mats.volumetric.uniforms.uPattern.value = null;
+            texture.dispose();
+        };
+    }, [mats, pattern, patternSoftness, patternRotation]);
+    // One shell per layer, fraction 0 (axis) → 1 (rim).
+    useEffect(() => {
+        const beam = beamRef.current;
+        if (!beam)
+            return;
+        const fracs = new Float32Array(LAYERS);
+        for (let i = 0; i < LAYERS; i++)
+            fracs[i] = (i + 1) / LAYERS;
+        beam.geometry.setAttribute('aFrac', new InstancedBufferAttribute(fracs, 1));
+        mats.layered.uniforms.uLayers.value = LAYERS;
+    }, [mats]);
+    const lightColor = useMemo(() => ((config.colorMode ?? 'temperature') === 'color'
+        ? new Color(config.color || '#ffffff')
+        : kelvinToColor(config.temperature ?? 3600)), [config.colorMode, config.color, config.temperature]);
+    // targetPosition is world space, like the plain spot light's.
+    const [tx, ty, tz] = (config.targetPosition ?? [0, 0, 0]);
+    useEffect(() => {
+        const light = lightRef.current;
+        if (!light)
+            return;
+        const target = targetRef.current;
+        target.position.set(tx, ty, tz);
+        target.updateMatrixWorld();
+        light.target = target;
+        scene.add(target);
+        return () => { scene.remove(target); };
+    }, [scene, tx, ty, tz]);
+    // The light owns its materials and its shadow flags.
+    useEffect(() => {
+        const group = groupRef.current;
+        if (!group)
+            return;
+        group.userData[SELF_OWNED_MATERIAL_KEY] = true;
+        return () => { delete group.userData[SELF_OWNED_MATERIAL_KEY]; };
+    }, []);
+    // Anything the user puts in front of this light is usually centimetres away.
+    const shadowNear = config.shadow?.cameraNear;
+    useEffect(() => {
+        const light = lightRef.current;
+        if (!light || shadowNear !== undefined)
+            return;
+        light.shadow.camera.near = 0.05;
+        light.shadow.camera.updateProjectionMatrix();
+    }, [shadowNear]);
+    const emitter = (config.emitter ?? 'lens');
+    // Which beam the user picked. Each mode is a different mesh, so this rebuilds
+    // rather than tweens: off, one shell, nested shells, or a raymarched volume.
+    const beamMode = (config.beamMode ?? 'soft');
+    const power = useRef({ level: (config.on ?? true) ? 1 : 0, base: config.intensity ?? 1, written: Number.NaN, seed: Math.random() * 1000 });
+    const scratch = useMemo(() => ({ heat: new Color(), glow: new Color() }), []);
+    useFrame(({ clock, camera }, delta) => {
+        const light = lightRef.current;
+        const group = groupRef.current;
+        if (!light || !group)
+            return;
+        const cfg = merged.current;
+        const p = power.current;
+        const on = cfg.on ?? true;
+        const warmup = Math.max(num(cfg.warmup, 0.3), 0);
+        const flicker = Math.min(Math.max(num(cfg.flicker, 0), 0), 1);
+        const beamAmount = Math.min(Math.max(num(cfg.beam, 1), 0), 3);
+        const haloAmount = Math.min(Math.max(num(cfg.halo, 1), 0), 3);
+        const baseIntensity = Math.max(num(config.intensity, 1), 1e-4);
+        if (light.intensity !== p.written)
+            p.base = light.intensity;
+        const target = on ? 1 : 0;
+        const tau = target > p.level ? warmup : warmup * 2.2;
+        p.level = tau <= 0 ? target : p.level + (target - p.level) * (1 - Math.exp(-Math.min(delta, 0.1) * 3 / tau));
+        if (Math.abs(target - p.level) < 1e-4)
+            p.level = target;
+        let flick = 1;
+        if (flicker > 0) {
+            const t = clock.elapsedTime + p.seed;
+            flick = 1 - flicker * (0.12 * noise1(t * 11) + 0.55 * Math.pow(noise1(t * 2.7), 4));
+        }
+        const output = Math.pow(p.level, 2.0) * flick;
+        light.intensity = p.base * output;
+        p.written = light.intensity;
+        const glowK = Math.min(output * (p.base / baseIntensity), 3);
+        const k = p.level * flick;
+        // Emitter: ember while it warms, then the light's own colour.
+        const heat = scratch.heat;
+        if (k < 0.5)
+            heat.copy(COLD).lerp(EMBER, k / 0.5);
+        else
+            heat.copy(EMBER).lerp(scratch.glow.copy(light.color).lerp(WHITE, 0.55), (k - 0.5) / 0.5);
+        mats.lens.color.copy(heat).multiplyScalar(0.05 + glowK * 2.2);
+        const glow = scratch.glow.copy(light.color);
+        mats.halo.uniforms.uColor.value.copy(glow);
+        mats.halo.uniforms.uStrength.value = haloAmount * glowK * 0.55;
+        const penumbra = num(cfg.penumbra, 0.3);
+        const noise = Math.min(Math.max(num(cfg.beamNoise, 0.35), 0), 1);
+        const active = beamMode === 'layered' ? mats.layered : beamMode === 'volumetric' ? mats.volumetric : mats.soft;
+        active.uniforms.uColor.value.copy(glow);
+        active.uniforms.uPenumbra.value = penumbra;
+        if (beamMode === 'layered') {
+            mats.layered.uniforms.uNoise.value = noise;
+            mats.layered.uniforms.uTime.value = clock.elapsedTime;
+            mats.layered.uniforms.uStrength.value = beamAmount * glowK * 0.45;
+        }
+        else if (beamMode === 'volumetric') {
+            mats.volumetric.uniforms.uNoise.value = noise;
+            mats.volumetric.uniforms.uTime.value = clock.elapsedTime;
+            mats.volumetric.uniforms.uSteps.value = num(cfg.beamSteps, 28);
+            mats.volumetric.uniforms.uStrength.value = beamAmount * glowK * 0.9;
+        }
+        else {
+            mats.soft.uniforms.uStrength.value = beamAmount * glowK * 0.5;
+        }
+        // Size and aim whichever beam mesh is mounted: as wide as the cone, as
+        // long as the throw, pointing down the light's own axis.
+        const mesh = beamMode === 'layered' ? beamRef.current : soloRef.current;
+        if (mesh) {
+            const reach = targetRef.current.position.distanceTo(group.getWorldPosition(scratchVec)) || 6;
+            const worldScale = group.getWorldScale(scratchScale).x || 1;
+            const length = Math.max((reach / worldScale) * num(cfg.beamLength, 1), 0.1);
+            const radius = Math.tan(Math.min(num(cfg.angle, Math.PI / 6), 1.45)) * length;
+            const visible = beamAmount > 0 && glowK > 0.01;
+            mesh.visible = visible;
+            group.worldToLocal(scratchVec.copy(targetRef.current.position));
+            mesh.quaternion.identity();
+            mesh.up.set(0, 0, 1);
+            mesh.lookAt(scratchVec);
+            mesh.rotateX(Math.PI / 2); // the cone opens along +Y, lookAt aims +Z
+            if (beamMode === 'layered') {
+                for (let i = 0; i < LAYERS; i++) {
+                    scratchMatrix.makeScale(radius, length, radius);
+                    mesh.setMatrixAt(i, scratchMatrix);
+                }
+                mesh.instanceMatrix.needsUpdate = true;
+            }
+            else {
+                mesh.scale.set(radius, length, radius);
+            }
+            if (beamMode === 'volumetric' && visible) {
+                // The raymarch runs in the cone's own space, so the camera goes there too.
+                mesh.updateMatrixWorld();
+                mats.volumetric.uniforms.uCamera.value.copy(camera.position);
+                mesh.worldToLocal(mats.volumetric.uniforms.uCamera.value);
+            }
+        }
+    });
+    return (_jsxs("group", { ref: groupRef, children: [_jsx("spotLight", { ref: lightRef, 
+                // THREE.SpotLight's constructor parks itself at (0, 1, 0); left alone
+                // the light sits a unit away from the object it belongs to.
+                position: [0, 0, 0], color: lightColor, intensity: config.intensity ?? 1, angle: config.angle ?? Math.PI / 6, penumbra: config.penumbra ?? 0.3, decay: config.decay ?? 1, distance: config.distance ?? 0 }), emitter === 'lens' && _jsx("mesh", { geometry: geometry.lens, material: mats.lens, renderOrder: 2 }), emitter === 'dot' && _jsx("mesh", { geometry: geometry.dot, material: mats.lens, renderOrder: 2 }), beamMode === 'layered' && (_jsx("instancedMesh", { ref: beamRef, args: [geometry.cone, mats.layered, LAYERS], renderOrder: 3, frustumCulled: false })), (beamMode === 'soft' || beamMode === 'volumetric') && (_jsx("mesh", { ref: soloRef, geometry: geometry.cone, material: beamMode === 'soft' ? mats.soft : mats.volumetric, renderOrder: 3, frustumCulled: false })), _jsx("mesh", { material: mats.halo, renderOrder: 4, frustumCulled: false, children: _jsx("planeGeometry", { args: [2, 2] }) })] }));
+};
+export default SpotBeam;

package/dist/components/spotBeam/beamPatterns.d.ts

@@ -0,0 +1,11 @@
+import type { Texture } from 'three';
+export type BeamPattern = 'round' | 'slot' | 'bars' | 'blinds' | 'window' | 'leaves';
+export declare const BEAM_PATTERNS: BeamPattern[];
+/**
+ * Build the mask. `rotation` is baked in rather than applied as a uv transform:
+ * three samples a spot light's map through the light frustum and ignores the
+ * texture matrix, so rotating it any other way would turn the haze without
+ * turning the pool.
+ */
+export declare function createBeamPattern(pattern: BeamPattern, softness: number, rotationDeg: number): Texture;
+//# sourceMappingURL=beamPatterns.d.ts.map

package/dist/components/spotBeam/beamPatterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beamPatterns.d.ts","sourceRoot":"","sources":["../../../src/components/spotBeam/beamPatterns.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAErF,eAAO,MAAM,aAAa,EAAE,WAAW,EAA4D,CAAC;AA+DpG;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAyBtG"}

package/dist/components/spotBeam/beamPatterns.js

@@ -0,0 +1,106 @@
+// =============================================================================
+// beamPatterns — the shape the light throws
+// =============================================================================
+//
+// A spot light's beam is shaped by what sits in front of it, so this generates
+// that mask once, as a texture: three projects it through the light's own
+// frustum (SpotLight.map), and the beam shader samples the same texture, so the
+// haze in the air and the pool on the floor always agree.
+//
+// Everything is masked by the cone's own circle, so the beam edge stays round
+// whatever the pattern does inside it.
+//
+import { CanvasTexture, LinearFilter, SRGBColorSpace } from 'three';
+export const BEAM_PATTERNS = ['round', 'slot', 'bars', 'blinds', 'window', 'leaves'];
+const SIZE = 512;
+/** Soft-edged mask of the cone itself; everything else multiplies into it. */
+function coneMask(g, softness) {
+    const r = SIZE / 2;
+    const inner = Math.max(0.02, 1 - softness) * r;
+    const grad = g.createRadialGradient(r, r, inner, r, r, r);
+    grad.addColorStop(0, 'rgba(255,255,255,1)');
+    grad.addColorStop(1, 'rgba(255,255,255,0)');
+    g.globalCompositeOperation = 'destination-in';
+    g.fillStyle = grad;
+    g.fillRect(0, 0, SIZE, SIZE);
+    g.globalCompositeOperation = 'source-over';
+}
+function drawPattern(g, pattern, softness) {
+    const s = SIZE;
+    g.fillStyle = '#ffffff';
+    if (pattern === 'round') {
+        g.fillRect(0, 0, s, s);
+        return;
+    }
+    if (pattern === 'slot') {
+        const h = s * 0.3;
+        g.fillRect(0, (s - h) / 2, s, h);
+        return;
+    }
+    if (pattern === 'bars') {
+        const n = 7, w = s / n;
+        for (let i = 0; i < n; i++)
+            if (i % 2 === 0)
+                g.fillRect(i * w, 0, w * 0.62, s);
+        return;
+    }
+    if (pattern === 'blinds') {
+        const n = 9, h = s / n;
+        for (let i = 0; i < n; i++)
+            g.fillRect(0, i * h, s, h * 0.5);
+        return;
+    }
+    if (pattern === 'window') {
+        const bar = s * 0.045;
+        g.fillRect(0, 0, s, s);
+        g.fillStyle = '#000000';
+        g.fillRect(s / 2 - bar / 2, 0, bar, s);
+        g.fillRect(0, s / 2 - bar / 2, s, bar);
+        g.fillRect(0, 0, s, bar * 0.8);
+        g.fillRect(0, s - bar * 0.8, s, bar * 0.8);
+        return;
+    }
+    // leaves: overlapping blobs, deterministic so the same config is the same dapple
+    let seed = 9;
+    const rnd = () => (seed = (seed * 1664525 + 1013904223) % 4294967296) / 4294967296;
+    g.fillRect(0, 0, s, s);
+    g.fillStyle = '#000000';
+    for (let i = 0; i < 34; i++) {
+        const x = rnd() * s, y = rnd() * s, r = s * (0.05 + rnd() * 0.11);
+        g.beginPath();
+        g.ellipse(x, y, r, r * (0.55 + rnd() * 0.7), rnd() * Math.PI, 0, Math.PI * 2);
+        g.fill();
+    }
+    void softness;
+}
+/**
+ * Build the mask. `rotation` is baked in rather than applied as a uv transform:
+ * three samples a spot light's map through the light frustum and ignores the
+ * texture matrix, so rotating it any other way would turn the haze without
+ * turning the pool.
+ */
+export function createBeamPattern(pattern, softness, rotationDeg) {
+    const canvas = document.createElement('canvas');
+    canvas.width = canvas.height = SIZE;
+    const g = canvas.getContext('2d');
+    g.clearRect(0, 0, SIZE, SIZE);
+    g.save();
+    g.translate(SIZE / 2, SIZE / 2);
+    g.rotate((rotationDeg * Math.PI) / 180);
+    g.translate(-SIZE / 2, -SIZE / 2);
+    drawPattern(g, pattern, softness);
+    g.restore();
+    // Soften the pattern edges as well as the cone rim.
+    if (softness > 0.02 && pattern !== 'round') {
+        g.filter = `blur(${Math.round(softness * 26)}px)`;
+        g.drawImage(canvas, 0, 0);
+        g.filter = 'none';
+    }
+    coneMask(g, Math.max(softness, 0.06));
+    const texture = new CanvasTexture(canvas);
+    texture.colorSpace = SRGBColorSpace;
+    texture.minFilter = LinearFilter;
+    texture.magFilter = LinearFilter;
+    texture.needsUpdate = true;
+    return texture;
+}

package/dist/components/spotBeam/index.d.ts

@@ -0,0 +1,7 @@
+export { default as SpotBeam } from './SpotBeam';
+export type { SpotBeamProps } from './SpotBeam';
+export { BEAM_PATTERNS, createBeamPattern } from './beamPatterns';
+export type { BeamPattern } from './beamPatterns';
+export { createSpotBeamMaterials, disposeSpotBeamMaterials } from './spotBeamMaterials';
+export type { SpotBeamMaterials } from './spotBeamMaterials';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/spotBeam/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/spotBeam/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAClE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACxF,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/components/spotBeam/index.js

@@ -0,0 +1,4 @@
+// A spot light with a visible, pattern-shaped beam (config.type 'spotBeam').
+export { default as SpotBeam } from './SpotBeam.js';
+export { BEAM_PATTERNS, createBeamPattern } from './beamPatterns.js';
+export { createSpotBeamMaterials, disposeSpotBeamMaterials } from './spotBeamMaterials.js';

package/dist/components/spotBeam/spotBeamMaterials.d.ts

@@ -0,0 +1,16 @@
+import { MeshBasicMaterial, ShaderMaterial } from 'three';
+export type BeamMode = 'none' | 'soft' | 'layered' | 'volumetric';
+export declare const BEAM_MODES: BeamMode[];
+export interface SpotBeamMaterials {
+    lens: MeshBasicMaterial;
+    halo: ShaderMaterial;
+    /** One cone shell, lit by how obliquely you look through it. One draw. */
+    soft: ShaderMaterial;
+    /** Nested shells: cheap depth, approximates the pattern. */
+    layered: ShaderMaterial;
+    /** Raymarched cone interior: the only mode where the pattern exists in the air. */
+    volumetric: ShaderMaterial;
+}
+export declare function createSpotBeamMaterials(): SpotBeamMaterials;
+export declare function disposeSpotBeamMaterials(m: SpotBeamMaterials): void;
+//# sourceMappingURL=spotBeamMaterials.d.ts.map

package/dist/components/spotBeam/spotBeamMaterials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spotBeamMaterials.d.ts","sourceRoot":"","sources":["../../../src/components/spotBeam/spotBeamMaterials.ts"],"names":[],"mappings":"AAcA,OAAO,EAAiD,iBAAiB,EAAE,cAAc,EAAW,MAAM,OAAO,CAAC;AAGlH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,YAAY,CAAC;AAElE,eAAO,MAAM,UAAU,EAAE,QAAQ,EAA8C,CAAC;AAEhF,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,iBAAiB,CAAC;IACxB,IAAI,EAAE,cAAc,CAAC;IACrB,0EAA0E;IAC1E,IAAI,EAAE,cAAc,CAAC;IACrB,4DAA4D;IAC5D,OAAO,EAAE,cAAc,CAAC;IACxB,mFAAmF;IACnF,UAAU,EAAE,cAAc,CAAC;CAC9B;AA+RD,wBAAgB,uBAAuB,IAAI,iBAAiB,CAQ3D;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAEnE"}