@3driseai/3drise-viewer 0.1.21 → 0.1.23

package/dist/components/ledArray/ledMaterials.js

@@ -0,0 +1,151 @@
+// =============================================================================
+// ledMaterials — the dies, their per-die glow, the diffuser and the halo
+// =============================================================================
+//
+// The viewer has no tone mapping and no bloom, so every bright thing here is
+// drawn by hand. An LED array is a set of very small, very bright sources, so
+// the glow is per die rather than one blob: a billboard quad per instance,
+// coloured from an instanced attribute so RGB mode can run a different hue down
+// the array.
+//
+// The diffuser is the other half of the look. A bare die is a point source with
+// a hard-edged shadow; a diffuser turns the whole array into one large soft
+// source. The slab drawn here is that surface — and the component couples the
+// same knob to the light's shadow radius, because the two are the same physics.
+//
+import { AdditiveBlending, Color, DoubleSide, MeshBasicMaterial, ShaderMaterial } from 'three';
+const OUTPUT = /* glsl */ `
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+`;
+/**
+ * A billboard per instance. The quad is built in view space from the instance's
+ * own origin, so the dies always face the camera however the array is turned.
+ */
+function dieGlowMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uStrength: { value: 0 },
+            uSize: { value: 0.09 },
+        },
+        vertexShader: /* glsl */ `
+            attribute vec3 aColor;
+            uniform float uSize;
+            varying vec2 vUv;
+            varying vec3 vColor;
+            void main() {
+                vColor = aColor;
+                vUv = position.xy;
+                // instance origin → view space, then the quad is laid out there
+                vec4 mv = modelViewMatrix * instanceMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                float s = length(modelMatrix[0].xyz) * uSize;
+                mv.xy += position.xy * s;
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform float uStrength;
+            varying vec2 vUv;
+            varying vec3 vColor;
+            void main() {
+                float d = length(vUv);
+                // a tight core with a wide, faint skirt — how a small very bright
+                // source reads through a lens
+                float a = exp(-d * 11.0) + exp(-d * d * 6.0) * 0.35;
+                a *= 1.0 - smoothstep(0.7, 1.0, d);
+                gl_FragColor = vec4(vColor * uStrength * a, 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+}
+/**
+ * The diffuser sheet. Brightest where the dies are (a soft periodic ripple that
+ * fades out as the sheet thickens), dimmer towards the rim where light escapes.
+ */
+function diffuserMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uColor: { value: new Color(1, 1, 1) },
+            uStrength: { value: 0 },
+            /** 0 = the dies still show through, 1 = a single even sheet. */
+            uBlend: { value: 0.5 },
+            /** How many die pitches across the sheet, for the hot-spot ripple. */
+            uPitch: { value: 4 },
+        },
+        vertexShader: /* glsl */ `
+            varying vec2 vUv;
+            void main() {
+                vUv = uv;
+                gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uColor;
+            uniform float uStrength;
+            uniform float uBlend;
+            uniform float uPitch;
+            varying vec2 vUv;
+            void main() {
+                vec2 p = vUv * 2.0 - 1.0;
+                // light leaks away at the rim of any real diffuser
+                float edge = (1.0 - smoothstep(0.72, 1.0, abs(p.x))) * (1.0 - smoothstep(0.72, 1.0, abs(p.y)));
+                // hot spots over each die, washed out as the sheet thickens
+                vec2 c = cos(vUv * uPitch * 6.2831853);
+                float dots = (c.x * c.y) * 0.5 + 0.5;
+                float lit = mix(0.45 + dots * 0.75, 1.0, uBlend);
+                gl_FragColor = vec4(uColor * uStrength * lit * edge, 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        side: DoubleSide,
+        blending: AdditiveBlending,
+    });
+}
+function haloMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uColor: { value: new Color(1, 1, 1) },
+            uStrength: { value: 0 },
+            uRadius: { value: 0.55 },
+        },
+        vertexShader: /* glsl */ `
+            uniform float uRadius;
+            varying vec2 vUv;
+            void main() {
+                vec4 mv = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                float s = length(modelMatrix[0].xyz) * uRadius;
+                mv.xy += position.xy * s;
+                vUv = position.xy;
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uColor;
+            uniform float uStrength;
+            varying vec2 vUv;
+            void main() {
+                float d = length(vUv);
+                float a = (exp(-d * 8.0) + exp(-d * d * 4.0) * 0.3) * (1.0 - smoothstep(0.65, 1.0, d));
+                gl_FragColor = vec4(uColor * uStrength * a, 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+}
+export function createLedArrayMaterials() {
+    return {
+        die: new MeshBasicMaterial({ color: 0xffffff, toneMapped: false }),
+        dieGlow: dieGlowMaterial(),
+        diffuser: diffuserMaterial(),
+        halo: haloMaterial(),
+    };
+}
+export function disposeLedArrayMaterials(m) {
+    m.die.dispose();
+    m.dieGlow.dispose();
+    m.diffuser.dispose();
+    m.halo.dispose();
+}

package/dist/components/lightBulb/LightBulb.d.ts

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

package/dist/components/lightBulb/LightBulb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LightBulb.d.ts","sourceRoot":"","sources":["../../../src/components/lightBulb/LightBulb.tsx"],"names":[],"mappings":"AAqBA,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;AAIhE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG;IAC5C,8EAA8E;IAC9E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,yEAAyE;IACzE,QAAQ,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACzD,CAAC;AAuBF,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CAqHvC,CAAC;AACF,eAAe,SAAS,CAAC"}

package/dist/components/lightBulb/LightBulb.js

@@ -0,0 +1,141 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// =============================================================================
+// LightBulb — a point light you can see: glass, filament, base and glow
+// =============================================================================
+//
+// Rendered by LightObject for `config.type === 'lightBulb'`. The object origin
+// is the filament centre, which is where the point light sits; the bulb stands
+// upright (base down, -Y) — rotate the object 180° for a pendant.
+//
+// Intensity ownership: useLightConfig (keyframes + pointer bindings) and R3F's
+// `intensity` prop write `light.intensity` as usual. This component then
+// multiplies in the power level (on/off, warm-up, flicker) each frame. Any
+// intensity it did not write itself is adopted as the new base, so the
+// multiplier never compounds and external writers stay in charge of the base.
+// The glow reads the light's real output every frame, so an animated or
+// pointer-driven intensity/colour dims and tints the bulb with it.
+//
+// Materials are self-owned: the root carries SELF_OWNED_MATERIAL_KEY so the
+// CreatedObject wrapper's material/shadow application skips the bulb. Only the
+// screw base casts a shadow — the glass and filament surround the light and
+// would otherwise black it out.
+//
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { Color } 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 { buildBulbShape, disposeBulbShape } from './bulbShapes.js';
+import { applyGlass, createBulbMaterials, disposeBulbMaterials, GLASS_RESPONSE } from './bulbMaterials.js';
+import { kelvinToColor } from './kelvin.js';
+const num = (v, fallback) => (typeof v === 'number' ? v : fallback);
+// Smooth 1D value noise for flicker.
+const hash = (n) => {
+    const s = Math.sin(n * 127.1) * 43758.5453;
+    return s - Math.floor(s);
+};
+const noise = (x) => {
+    const i = Math.floor(x), f = x - i, u = f * f * (3 - 2 * f);
+    return hash(i) * (1 - u) + hash(i + 1) * u;
+};
+// Tungsten heating ramp: unlit grey → dull red → orange → the light's own colour.
+const UNLIT = new Color(0.12, 0.12, 0.12);
+const DULL_RED = new Color(0.55, 0.05, 0.0);
+const ORANGE = new Color(1.0, 0.38, 0.06);
+const WHITE = new Color(1, 1, 1);
+const HALO_SEGMENTS = [2, 2];
+const LightBulb = ({ id, config, animations, mouseMove, settings, onObjectReady, onObjectDispose }) => {
+    const groupRef = useRef(null);
+    const lightRef = useRef(null);
+    useObjectReady(groupRef, settings, onObjectReady, onObjectDispose);
+    useLightShadow(lightRef, config.shadow);
+    // Keyframes, pointer bindings and slider drags: the light's own knobs land on
+    // the light, and the merged config is what the filament, glow and halo read.
+    const { merged } = useLightConfig(groupRef, lightRef, id, config, animations, mouseMove);
+    const glass = config.glass ?? 'clear';
+    const glassTint = config.glassTint ?? '#ffb070';
+    const on = config.on ?? true;
+    const baseIntensity = config.intensity ?? 1;
+    const shape = useMemo(() => buildBulbShape(config.shape), [config.shape]);
+    useEffect(() => () => disposeBulbShape(shape), [shape]);
+    const mats = useMemo(() => createBulbMaterials(), []);
+    useEffect(() => () => disposeBulbMaterials(mats), [mats]);
+    useEffect(() => applyGlass(mats, glass, glassTint), [mats, glass, glassTint]);
+    useEffect(() => {
+        mats.halo.uniforms.uRadius.value = shape.haloRadius;
+    }, [mats, shape]);
+    const lightColor = useMemo(() => (config.colorMode ?? 'temperature') === 'color'
+        ? new Color(config.color || '#ffffff')
+        : kelvinToColor(config.temperature ?? 2700), [config.colorMode, config.color, config.temperature]);
+    const tint = useMemo(() => new Color(glass === 'tinted' ? glassTint : '#ffffff'), [glass, glassTint]);
+    // The screw base sits close to the light; three's default shadow near (0.5)
+    // would clip it out of the shadow map.
+    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]);
+    useEffect(() => {
+        const group = groupRef.current;
+        if (!group)
+            return;
+        group.userData[SELF_OWNED_MATERIAL_KEY] = true;
+        return () => {
+            delete group.userData[SELF_OWNED_MATERIAL_KEY];
+        };
+    }, []);
+    const power = useRef({ level: on ? 1 : 0, base: baseIntensity, written: Number.NaN, seed: Math.random() * 1000 });
+    const scratch = useMemo(() => ({ heat: new Color(), glow: new Color() }), []);
+    useFrame(({ clock }, delta) => {
+        const light = lightRef.current;
+        if (!light)
+            return;
+        const p = power.current;
+        const cfg = merged.current;
+        const warmup = Math.max(num(cfg.warmup, 0.25), 0);
+        const flicker = Math.min(Math.max(num(cfg.flicker, 0), 0), 1);
+        const haloAmount = Math.min(Math.max(num(cfg.halo, 1), 0), 2);
+        if (light.intensity !== p.written)
+            p.base = light.intensity;
+        const target = on ? 1 : 0;
+        const tau = target > p.level ? warmup : warmup * 2.5;
+        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.15 * noise(t * 13) + 0.6 * Math.pow(noise(t * 3.1), 4));
+        }
+        const output = Math.pow(p.level, 2.2) * flick;
+        light.intensity = p.base * output;
+        p.written = light.intensity;
+        // Glow follows the light's real output relative to the configured intensity.
+        const glowK = Math.min(output * (p.base / Math.max(baseIntensity, 1e-4)), 2);
+        const response = GLASS_RESPONSE[glass];
+        // Filament: grey when cold, heats through red/orange to near-white of the light colour.
+        const k = p.level * flick;
+        const heat = scratch.heat;
+        if (k < 0.35)
+            heat.copy(UNLIT).lerp(DULL_RED, k / 0.35);
+        else if (k < 0.7)
+            heat.copy(DULL_RED).lerp(ORANGE, (k - 0.35) / 0.35);
+        else
+            heat.copy(ORANGE).lerp(scratch.glow.copy(light.color).lerp(WHITE, 0.55), (k - 0.7) / 0.3);
+        mats.filament.color.copy(heat).multiplyScalar(k < 0.05 ? 1 : 1 + glowK * 2);
+        const glow = scratch.glow.copy(light.color).multiply(tint);
+        mats.glass.emissive.copy(glow).multiplyScalar(response.emissive * glowK);
+        mats.innerGlow.uniforms.uColor.value.copy(glow);
+        mats.innerGlow.uniforms.uStrength.value = response.inner * glowK;
+        mats.halo.uniforms.uColor.value.copy(glow);
+        mats.halo.uniforms.uStrength.value = response.halo * haloAmount * glowK;
+    });
+    const dy = -shape.filamentCenterY;
+    return (_jsxs("group", { ref: groupRef, children: [_jsx("pointLight", { ref: lightRef, color: lightColor, intensity: baseIntensity, decay: config.decay ?? 1, distance: config.distance ?? 0 }), _jsxs("group", { position: [0, dy, 0], children: [_jsx("mesh", { geometry: shape.filament, material: mats.filament }), shape.supports.map((g, i) => (_jsx("mesh", { geometry: g, material: i === 0 ? mats.stem : mats.wire, renderOrder: i === 0 ? 1 : 0 }, i))), _jsx("mesh", { geometry: shape.base, material: mats.metal, castShadow: true }), _jsx("mesh", { geometry: shape.glass, material: mats.glass, renderOrder: 2 }), _jsx("mesh", { geometry: shape.glass, material: mats.innerGlow, scale: 0.97, renderOrder: 3 })] }), _jsx("mesh", { material: mats.halo, renderOrder: 4, frustumCulled: false, children: _jsx("planeGeometry", { args: HALO_SEGMENTS }) })] }));
+};
+export default LightBulb;

package/dist/components/lightBulb/bulbMaterials.d.ts

@@ -0,0 +1,27 @@
+import { MeshBasicMaterial, MeshPhysicalMaterial, MeshStandardMaterial, ShaderMaterial } from 'three';
+import type { LightBulbGlass } from './types';
+export interface BulbMaterials {
+    glass: MeshPhysicalMaterial;
+    filament: MeshBasicMaterial;
+    metal: MeshStandardMaterial;
+    wire: MeshStandardMaterial;
+    stem: MeshPhysicalMaterial;
+    innerGlow: ShaderMaterial;
+    halo: ShaderMaterial;
+}
+/** Per-glass tuning of how much of the light the glass itself shows. */
+export interface GlassResponse {
+    /** Emissive strength of the glass surface itself. */
+    emissive: number;
+    /** innerGlow strength + falloff power (low power = even, frosted-looking fill). */
+    inner: number;
+    innerPower: number;
+    /** Halo multiplier. */
+    halo: number;
+}
+export declare const GLASS_RESPONSE: Record<LightBulbGlass, GlassResponse>;
+export declare function createBulbMaterials(): BulbMaterials;
+/** Configure the glass surface for a finish. Emissive is driven per frame. */
+export declare function applyGlass(m: BulbMaterials, glass: LightBulbGlass, tint: string): void;
+export declare function disposeBulbMaterials(m: BulbMaterials): void;
+//# sourceMappingURL=bulbMaterials.d.ts.map

package/dist/components/lightBulb/bulbMaterials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulbMaterials.d.ts","sourceRoot":"","sources":["../../../src/components/lightBulb/bulbMaterials.ts"],"names":[],"mappings":"AAaA,OAAO,EAAsC,iBAAiB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC1I,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,oBAAoB,CAAC;IAC5B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,KAAK,EAAE,oBAAoB,CAAC;IAC5B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,SAAS,EAAE,cAAc,CAAC;IAC1B,IAAI,EAAE,cAAc,CAAC;CACxB;AAED,wEAAwE;AACxE,MAAM,WAAW,aAAa;IAC1B,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,mFAAmF;IACnF,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,aAAa,CAIhE,CAAC;AA8EF,wBAAgB,mBAAmB,IAAI,aAAa,CAanD;AAED,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAsBtF;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAE3D"}

package/dist/components/lightBulb/bulbMaterials.js

@@ -0,0 +1,133 @@
+// =============================================================================
+// bulbMaterials — glass, filament, metal and the two self-drawn glow layers
+// =============================================================================
+//
+// The viewer renders with NoToneMapping and no postprocessing, so there is no
+// bloom to lean on. The bulb draws its own glow instead:
+//   - innerGlow: a view-facing fresnel shell just inside the glass — light
+//     scattering in the glass, strongest where you look straight through it.
+//   - halo: a camera-facing quad with a soft radial falloff, sized in object
+//     space so it scales with the bulb.
+// Both are additive and depthWrite-off; their strength is set per frame from
+// the light's actual intensity, so animations / mouseMove dim the glow too.
+//
+import { AdditiveBlending, Color, FrontSide, MeshBasicMaterial, MeshPhysicalMaterial, MeshStandardMaterial, ShaderMaterial } from 'three';
+export const GLASS_RESPONSE = {
+    clear: { emissive: 0.02, inner: 0.14, innerPower: 4.0, halo: 0.7 },
+    frosted: { emissive: 0.9, inner: 0.55, innerPower: 0.8, halo: 1.15 },
+    tinted: { emissive: 0.3, inner: 0.5, innerPower: 1.6, halo: 0.9 },
+};
+const OUTPUT = /* glsl */ `
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+`;
+function innerGlowMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uColor: { value: new Color(1, 0.7, 0.4) },
+            uStrength: { value: 0 },
+            uPower: { value: 3 },
+        },
+        vertexShader: /* glsl */ `
+            varying vec3 vNormal;
+            varying vec3 vView;
+            void main() {
+                vec4 mv = modelViewMatrix * vec4(position, 1.0);
+                vNormal = normalize(normalMatrix * normal);
+                vView = normalize(-mv.xyz);
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uColor;
+            uniform float uStrength;
+            uniform float uPower;
+            varying vec3 vNormal;
+            varying vec3 vView;
+            void main() {
+                float facing = clamp(dot(normalize(vNormal), normalize(vView)), 0.0, 1.0);
+                gl_FragColor = vec4(uColor * uStrength * pow(facing, uPower), 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+        side: FrontSide,
+    });
+}
+function haloMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uColor: { value: new Color(1, 0.7, 0.4) },
+            uStrength: { value: 0 },
+            uRadius: { value: 1 },
+        },
+        vertexShader: /* glsl */ `
+            uniform float uRadius;
+            varying vec2 vUv;
+            void main() {
+                // Billboard: expand the quad in view space around the object origin,
+                // sized by the object's world scale so the halo tracks the bulb.
+                vec4 mv = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                float s = length(modelMatrix[0].xyz) * uRadius;
+                mv.xy += position.xy * s;
+                vUv = position.xy;
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uColor;
+            uniform float uStrength;
+            varying vec2 vUv;
+            void main() {
+                float d = length(vUv);
+                float core = exp(-d * 9.0);
+                float wide = exp(-d * d * 5.0) * 0.35;
+                float a = (core + wide) * (1.0 - smoothstep(0.7, 1.0, d));
+                gl_FragColor = vec4(uColor * uStrength * a, 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+}
+export function createBulbMaterials() {
+    return {
+        glass: new MeshPhysicalMaterial({
+            color: '#ffffff', roughness: 0.05, metalness: 0, transparent: true, opacity: 0.18,
+            clearcoat: 1, clearcoatRoughness: 0.05, depthWrite: false, emissive: '#000000',
+        }),
+        filament: new MeshBasicMaterial({ color: '#202020', toneMapped: false }),
+        metal: new MeshStandardMaterial({ color: '#b9ae98', metalness: 1, roughness: 0.3 }),
+        wire: new MeshStandardMaterial({ color: '#9a9a9a', metalness: 1, roughness: 0.35 }),
+        stem: new MeshPhysicalMaterial({ color: '#ffffff', roughness: 0.1, transparent: true, opacity: 0.25, depthWrite: false }),
+        innerGlow: innerGlowMaterial(),
+        halo: haloMaterial(),
+    };
+}
+/** Configure the glass surface for a finish. Emissive is driven per frame. */
+export function applyGlass(m, glass, tint) {
+    const g = m.glass;
+    if (glass === 'frosted') {
+        g.color.set('#f4f1ec');
+        g.roughness = 0.9;
+        g.opacity = 0.88;
+        g.clearcoat = 0;
+    }
+    else if (glass === 'tinted') {
+        g.color.set(tint);
+        g.roughness = 0.08;
+        g.opacity = 0.42;
+        g.clearcoat = 1;
+    }
+    else {
+        g.color.set('#ffffff');
+        g.roughness = 0.05;
+        g.opacity = 0.18;
+        g.clearcoat = 1;
+    }
+    m.innerGlow.uniforms.uPower.value = GLASS_RESPONSE[glass].innerPower;
+    g.needsUpdate = true;
+}
+export function disposeBulbMaterials(m) {
+    Object.values(m).forEach((mat) => mat.dispose());
+}

package/dist/components/lightBulb/bulbShapes.d.ts

@@ -0,0 +1,15 @@
+import type { BufferGeometry } from 'three';
+import type { LightBulbShape } from './types';
+export interface BulbShapeGeometry {
+    glass: BufferGeometry;
+    filament: BufferGeometry;
+    supports: BufferGeometry[];
+    base: BufferGeometry;
+    /** Bulb-space height of the filament centre — becomes the object origin. */
+    filamentCenterY: number;
+    /** Radius of the glow halo, bulb space. */
+    haloRadius: number;
+}
+export declare function buildBulbShape(shape: LightBulbShape | undefined): BulbShapeGeometry;
+export declare function disposeBulbShape(g: BulbShapeGeometry): void;
+//# sourceMappingURL=bulbShapes.d.ts.map

package/dist/components/lightBulb/bulbShapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulbShapes.d.ts","sourceRoot":"","sources":["../../../src/components/lightBulb/bulbShapes.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,MAAM,WAAW,iBAAiB;IAC9B,KAAK,EAAE,cAAc,CAAC;IACtB,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,4EAA4E;IAC5E,eAAe,EAAE,MAAM,CAAC;IACxB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;CACtB;AAyKD,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,GAAG,iBAAiB,CAEnF;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAK3D"}