@3driseai/3drise-viewer 0.1.22 → 0.1.24

package/dist/components/candle/candleMaterials.js

@@ -0,0 +1,433 @@
+// =============================================================================
+// candleMaterials — the flame volume, the wax, the wick and the halo
+// =============================================================================
+//
+// The flame is raymarched. A candle flame is not one glowing blob: it has three
+// zones, and rendering only the third is what makes fake candles look fake.
+//
+//   - a blue base around the wick, where there is plenty of oxygen. That light
+//     is chemiluminescence from CH and C2 radicals, NOT blackbody, so it is a
+//     separate additive term rather than the cold end of a temperature ramp;
+//   - a dark inner zone just above the wick: vaporised wax, dense but not yet
+//     burning, so high density and almost no emission;
+//   - the luminous yellow body: incandescent soot, a greybody, which is what the
+//     temperature ramp actually describes.
+//
+// The viewer has no tone mapping, so the shader carries its own knee (extended
+// Reinhard, per channel). Without it the whole flame clips to a white blob and
+// the blue base disappears entirely — the single biggest risk to this looking
+// real, so the knee is not optional.
+//
+import { AdditiveBlending, BackSide, Color, DoubleSide, MeshBasicMaterial, MeshPhysicalMaterial, ShaderMaterial, Vector2, Vector3, } from 'three';
+export const FLAME_MODES = ['volumetric', 'billboard'];
+const OUTPUT = /* glsl */ `
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+`;
+/** Value noise + 3-octave fbm, shared by the flame and the smoke. */
+const NOISE = /* glsl */ `
+    float hash13(vec3 p) {
+        p = fract(p * 0.1031);
+        p += dot(p, p.zyx + 31.32);
+        return fract((p.x + p.y) * p.z);
+    }
+    float vnoise(vec3 p) {
+        vec3 i = floor(p), f = fract(p);
+        f = f * f * (3.0 - 2.0 * f);
+        float n000 = hash13(i),                  n100 = hash13(i + vec3(1,0,0));
+        float n010 = hash13(i + vec3(0,1,0)),    n110 = hash13(i + vec3(1,1,0));
+        float n001 = hash13(i + vec3(0,0,1)),    n101 = hash13(i + vec3(1,0,1));
+        float n011 = hash13(i + vec3(0,1,1)),    n111 = hash13(i + vec3(1,1,1));
+        return mix(mix(mix(n000, n100, f.x), mix(n010, n110, f.x), f.y),
+                   mix(mix(n001, n101, f.x), mix(n011, n111, f.x), f.y), f.z);
+    }
+    float fbm(vec3 p) {
+        return vnoise(p) * 0.55 + vnoise(p * 2.03) * 0.3 + vnoise(p * 4.11) * 0.15;
+    }
+`;
+/**
+ * The flame's shape and emission, in the box's own space (-0.5..0.5 on each
+ * axis, the flame standing on the bottom face). Shared by both modes so the
+ * billboard is the same flame, only cheaper.
+ */
+const FLAME_FIELD = /* glsl */ `
+    uniform float uTime;
+    uniform float uLevel;      // 0 out, 1 established
+    uniform float uPulse;      // buoyancy oscillation, around 1
+    uniform float uPhase;      // that oscillation's phase, for the travelling wave
+    uniform vec2  uLean;       // steady wind bend, box units
+    uniform vec2  uSwayDir;    // the plane it is swaying in; drifts
+    uniform float uSway;       // amplitude of the undulation running up the flame
+    uniform float uSeed;       // per candle, so two of them never match
+    uniform float uScroll;     // how fast the eddies travel up. 0 freezes them
+    uniform float uShed;       // how hard the neck pinches before it sheds
+    uniform float uShedPhase;
+    uniform float uDetach;     // how far wind has lifted the root off the wick
+    uniform float uStretch;
+    uniform float uTurb;
+    uniform float uRadius;     // flame half-width at its widest, box units
+    uniform float uTop;        // where the tip sits in the box, 0..1
+    uniform float uGap;        // quench gap: the flame does not touch the wick
+    uniform float uBlueHeight; // fraction of the flame that reads blue
+    uniform float uBlue;
+    uniform float uBlueBias;
+    uniform float uSoot;
+    uniform vec3  uFringe;     // cooling soot at the edges and the tip
+    uniform vec3  uBody;       // greybody at this temperature
+    uniform vec3  uCore;       // white-hot core
+    uniform vec3  uBlueColor;
+    uniform float uGain;
+    uniform float uWhite;      // knee white point
+
+    /** Teardrop: rounded at the base, widest about a quarter up, pinching out. */
+    float profile(float y) {
+        return pow(max(y, 0.0), 0.38) * pow(max(1.0 - y, 0.0), 1.0) / 0.40;
+    }
+
+    /**
+     * The flame's centreline. Wind bends it, but the part that makes a candle
+     * look alive is the second term: the oscillation's phase lags with height,
+     * so a wave travels UP the flame and it undulates like a ribbon instead of
+     * tilting rigidly. A flame that only leans is the giveaway of a fake one.
+     */
+    vec2 centreline(float y) {
+        vec2 bend = uLean * pow(y, 1.6);
+        float ph = uPhase - y * 4.2;
+        // Elliptical, in a plane that drifts: a flame that rocks along one fixed
+        // axis reads as a mechanism.
+        vec2 d1 = uSwayDir;
+        vec2 d2 = vec2(-uSwayDir.y, uSwayDir.x);
+        vec2 wave = (d1 * sin(ph) + d2 * sin(ph * 0.61 + uSeed) * 0.55)
+            * uSway * smoothstep(0.04, 0.7, y);
+        return bend + wave;
+    }
+
+    /** Density, plus the two coordinates the emission needs. */
+    float flameDensity(vec3 p, out float y, out float r) {
+        float top = min(uTop * uLevel * uStretch, 1.0);
+        y = (p.y + 0.5) / max(top, 1e-3);
+        r = 999.0;
+        if (y <= 0.0 || y >= 1.0 || uLevel <= 0.001) return 0.0;
+
+        vec2 q = p.xz - centreline(y);
+
+        // The neck: a pinch that travels up the flame and repeats, so the tip
+        // necks down and sheds a parcel of gas rather than sitting still.
+        float pinchAt = 0.42 + fract(uShedPhase) * 0.62;
+        float pinch = uShed * exp(-pow((y - pinchAt) / 0.11, 2.0));
+        float width = uRadius * uLevel * profile(y) * (1.0 - pinch);
+        if (width <= 1e-4) return 0.0;
+        r = length(q) / width;
+        if (r > 2.2) return 0.0;
+
+        // Wind lifts the root clear of the wick before it blows the flame out.
+        float root = smoothstep(0.0, 0.04 + uDetach * 0.26, y);
+
+        // Eddies travel upward, and the gas accelerates as it rises, so the
+        // noise coordinate is compressed with height: features stretch as they
+        // go, which is what the upper half of a real flame does.
+        float turb = uTurb * smoothstep(0.08, 0.8, y);
+        float ny = pow(y, 0.72) * 6.5 - uTime * uScroll + uSeed * 13.0;
+        float n = (fbm(vec3(q * 24.0 + uSeed * 2.7, ny)) - 0.5) * 2.0;
+        return smoothstep(1.0, 0.42, r + n * turb) * root;
+    }
+
+    /** The blue collar: low down and on the oxygen-rich surface, wrapping under
+        the yellow rather than sitting inside it. */
+    float collar(float y, float r) {
+        // As the blue reaches further up it also fills in: a flame with plenty of
+        // oxygen is blue through, not just at its skin.
+        float shell = smoothstep(0.60 * (1.0 - uBlueHeight * 0.85), 1.05, r);
+        return smoothstep(max(uBlueHeight, 0.001), 0.0, y) * shell;
+    }
+
+    vec3 flameEmission(float d, float y, float r) {
+        // The luminous zone starts ABOVE the wick — there is a quench layer the
+        // flame does not reach into, and the gap is clearly visible in a macro
+        // shot as a dark collar under the yellow.
+        float yl = clamp((y - uGap) / max(1.0 - uGap, 1e-3), 0.0, 1.0);
+
+        // Soot has to be carried up and heated before it glows, so the luminous
+        // zone is the UPPER half. Getting this backwards makes a flame read as a
+        // glowing blob on a stick.
+        float hot = smoothstep(0.05, 0.42, yl) * (1.0 - smoothstep(0.70, 1.06, yl));
+        // The dark zone: unburnt vapour on the axis, just above the wick.
+        float dark = (1.0 - smoothstep(0.0, 0.78, r)) * (1.0 - smoothstep(0.02, 0.34, yl));
+        float lum = d * (0.10 + 2.0 * hot) * (1.0 - 0.92 * dark)
+            * smoothstep(0.0, max(0.3, uBlueHeight * 1.15), yl);
+
+        // Three stops, not two. Soot cools at the outer fringe and at the tip,
+        // and drops to a deep red long before it stops glowing — leaving that
+        // out is what makes a flame look like an airbrushed gradient.
+        // Mostly radial: the fringe is the cool outside of the sheet, not a
+        // horizontal stripe across it.
+        float cool = clamp(smoothstep(0.58, 1.05, r) * 0.8 + smoothstep(0.80, 1.1, yl) * 0.45, 0.0, 1.0);
+        vec3 col = mix(uBody, uFringe, cool);
+        col = mix(col, uCore, smoothstep(0.5, 1.4, lum));
+
+        // The blue is faint next to the yellow and the first thing the knee
+        // eats, so it is weighted up rather than left proportionate and invisible.
+        float blue = uBlue * uBlueBias * collar(y, r) * d;
+        return col * lum + uBlueColor * blue * 7.5;
+    }
+
+    /** Extended Reinhard, per channel: the core desaturates to white, the rest
+        stays where it was. Stands in for the tone mapping the viewer does not do. */
+    vec3 knee(vec3 c) {
+        float w = max(uWhite, 1.0);
+        return c * (1.0 + c / (w * w)) / (1.0 + c);
+    }
+`;
+const FLAME_UNIFORMS = () => ({
+    uTime: { value: 0 },
+    uLevel: { value: 1 },
+    uPulse: { value: 1 },
+    uPhase: { value: 0 },
+    uLean: { value: new Vector2(0, 0) },
+    uSwayDir: { value: new Vector2(1, 0) },
+    uSway: { value: 0.02 },
+    uSeed: { value: 0 },
+    uScroll: { value: 1.4 },
+    uShed: { value: 0.18 },
+    uShedPhase: { value: 0 },
+    uDetach: { value: 0 },
+    uGap: { value: 0.05 },
+    uBlueHeight: { value: 0.16 },
+    uStretch: { value: 1 },
+    uTurb: { value: 0.3 },
+    uRadius: { value: 0.16 },
+    uTop: { value: 0.78 },
+    uBlue: { value: 0.7 },
+    uBlueBias: { value: 1 },
+    uSoot: { value: 0.25 },
+    uFringe: { value: new Color(1, 0.26, 0.04) },
+    uBody: { value: new Color(1, 0.62, 0.18) },
+    uCore: { value: new Color(1, 0.95, 0.82) },
+    uBlueColor: { value: new Color(0.14, 0.42, 1) },
+    uGain: { value: 5 },
+    uWhite: { value: 3.5 },
+    uSteps: { value: 24 },
+    /** Camera in the box's object space; only the raymarched mode reads it. */
+    uCamera: { value: new Vector3() },
+});
+function flameMaterial() {
+    return new ShaderMaterial({
+        uniforms: FLAME_UNIFORMS(),
+        vertexShader: /* glsl */ `
+            varying vec3 vLocal;
+            void main() {
+                vLocal = position;
+                gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uCamera;   // camera in the box's object space
+            uniform float uSteps;
+            varying vec3 vLocal;
+            ${NOISE}
+            ${FLAME_FIELD}
+
+            void main() {
+                // Back faces are rendered, so this fragment is where the ray
+                // leaves the box; the entry comes from the slab intersection and
+                // is clamped to 0 so the camera can sit inside.
+                vec3 ro = uCamera;
+                vec3 rd = vLocal - ro;
+                float far = length(rd);
+                rd /= max(far, 1e-6);
+
+                // March the flame's own bounds, not the whole box. The box has to
+                // be big enough for the lean and the undulation, but a ray that
+                // spends half its steps on empty air bands badly where the flame
+                // is thin — which is exactly where the blue collar lives.
+                float topB = min(uTop * uLevel * uStretch, 1.0);
+                float halfW = min(uRadius * uLevel + max(abs(uLean.x), abs(uLean.y)) + uSway + 0.03, 0.5);
+                vec3 bmin = vec3(-halfW, -0.5, -halfW);
+                vec3 bmax = vec3( halfW, -0.5 + topB, halfW);
+
+                vec3 inv = 1.0 / max(abs(rd), vec3(1e-6)) * sign(rd + 1e-9);
+                vec3 t0 = (bmin - ro) * inv;
+                vec3 t1 = (bmax - ro) * inv;
+                vec3 tlo = min(t0, t1), thi = max(t0, t1);
+                float near = max(max(tlo.x, tlo.y), max(tlo.z, 0.0));
+                float exit = min(min(thi.x, thi.y), thi.z);
+                far = min(far, exit);
+                if (near >= far) discard;
+
+                const int MAX_STEPS = 40;
+                float steps = clamp(uSteps, 8.0, float(MAX_STEPS));
+                float stepLen = (far - near) / steps;
+                // Dither the entry point: 20 steps through a small volume bands
+                // badly otherwise, and a flame shows it more than most things.
+                // A third of a step of interleaved gradient noise, on the pixel
+                // only. Full-width jitter trades banding for a diagonal moiré
+                // that is worse than what it fixes; a third is enough to break
+                // the rings now that the march is confined to the flame.
+                float ign = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
+                float t = near + stepLen * (0.5 + (ign - 0.5) * 0.34);
+
+                vec3 acc = vec3(0.0);
+                float trans = 1.0;
+                for (int i = 0; i < MAX_STEPS; i++) {
+                    if (float(i) >= steps || trans < 0.01) break;
+                    vec3 p = ro + rd * t;
+                    float y, r;
+                    float d = flameDensity(p, y, r);
+                    if (d > 0.002) {
+                        acc += flameEmission(d, y, r) * stepLen * trans * uGain;
+                        // Soot absorbs a little, which is what gives a flame a body
+                        // rather than making it a pure additive ghost.
+                        trans *= exp(-d * uSoot * stepLen * 14.0);
+                    }
+                    t += stepLen;
+                }
+                if (acc.r + acc.g + acc.b < 1e-4) discard;
+                gl_FragColor = vec4(knee(acc), 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        side: BackSide,
+        blending: AdditiveBlending,
+    });
+}
+/** The same flame on one camera-facing quad: no depth, a fraction of the cost. */
+function flameBillboardMaterial() {
+    return new ShaderMaterial({
+        uniforms: FLAME_UNIFORMS(),
+        vertexShader: /* glsl */ `
+            varying vec2 vUv;
+            void main() {
+                vUv = position.xy;
+                vec4 mv = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                float s = length(modelMatrix[0].xyz);
+                mv.xy += position.xy * s * 0.5;
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            varying vec2 vUv;
+            ${NOISE}
+            ${FLAME_FIELD}
+            void main() {
+                // Three slices instead of a march: enough to keep the dark zone
+                // and the blue base, without the depth.
+                vec3 acc = vec3(0.0);
+                for (int i = 0; i < 3; i++) {
+                    float z = (float(i) - 1.0) * 0.11;
+                    float y, r;
+                    vec3 p = vec3(vUv.x * 0.5, vUv.y * 0.5, z);
+                    float d = flameDensity(p, y, r);
+                    if (d > 0.002) acc += flameEmission(d, y, r) * uGain * 0.17;
+                }
+                if (acc.r + acc.g + acc.b < 1e-4) discard;
+                gl_FragColor = vec4(knee(acc), 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+}
+/** The wisp left behind for a few seconds after it is snuffed. */
+function smokeMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uTime: { value: 0 },
+            uAge: { value: 0 },
+            uColor: { value: new Color(0.6, 0.6, 0.62) },
+        },
+        // A plain quad, turned to face the camera about Y by the component. A
+        // view-space billboard would ignore the mesh's own height and park the
+        // wisp wherever the X scale put it.
+        vertexShader: /* glsl */ `
+            varying vec2 vUv;
+            void main() {
+                vUv = position.xy;
+                gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform float uTime;
+            uniform float uAge;
+            uniform vec3 uColor;
+            varying vec2 vUv;
+            ${NOISE}
+            void main() {
+                // The quad's bottom sits on the wick, so the wisp has to start at
+                // y = 0 or it detaches and floats in mid-air.
+                float y = vUv.y * 0.5 + 0.5;
+                float rise = clamp(uAge * 0.55, 0.0, 1.0);
+                float band = smoothstep(0.0, 0.03, y) * (1.0 - smoothstep(rise, rise + 0.4, y));
+                float wobble = (fbm(vec3(vUv * 3.0, uTime * 0.5)) - 0.5) * (0.1 + y * 0.55);
+                // Thin. Snuffing a candle gives a thread of smoke, not a plume.
+                float w = 0.02 + y * 0.15;
+                float a = band * exp(-pow((vUv.x - wobble) / w, 2.0));
+                a *= (1.0 - smoothstep(1.6, 3.4, uAge)) * 0.33;
+                if (a < 0.002) discard;
+                gl_FragColor = vec4(uColor, a);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+    });
+}
+function haloMaterial() {
+    return new ShaderMaterial({
+        uniforms: {
+            uColor: { value: new Color(1, 0.7, 0.35) },
+            uStrength: { value: 0 },
+            uRadius: { value: 0.3 },
+        },
+        vertexShader: /* glsl */ `
+            uniform float uRadius;
+            varying vec2 vUv;
+            void main() {
+                vec4 mv = modelViewMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+                mv.xy += position.xy * length(modelMatrix[0].xyz) * uRadius;
+                vUv = position.xy;
+                gl_Position = projectionMatrix * mv;
+            }`,
+        fragmentShader: /* glsl */ `
+            uniform vec3 uColor;
+            uniform float uStrength;
+            varying vec2 vUv;
+            void main() {
+                float d = length(vUv);
+                // Tight. A wide soft halo round a candle reads as fog, not flame.
+                float a = exp(-d * d * 7.0);
+                gl_FragColor = vec4(uColor * uStrength * a, 1.0);
+                ${OUTPUT}
+            }`,
+        transparent: true,
+        depthWrite: false,
+        blending: AdditiveBlending,
+    });
+}
+export function createCandleMaterials() {
+    return {
+        flame: flameMaterial(),
+        flameBillboard: flameBillboardMaterial(),
+        smoke: smokeMaterial(),
+        wax: new MeshPhysicalMaterial({
+            color: 0xf3e7d2, roughness: 0.42, transmission: 0.6, thickness: 0.05,
+            ior: 1.45, attenuationColor: new Color(0.95, 0.82, 0.62), attenuationDistance: 0.06,
+            sheen: 0.7, sheenColor: new Color(1, 0.94, 0.85), sheenRoughness: 0.6,
+            clearcoat: 0.15, clearcoatRoughness: 0.5, side: DoubleSide,
+        }),
+        melt: new MeshPhysicalMaterial({
+            color: 0xf6ead6, roughness: 0.1, transmission: 0.75, thickness: 0.02,
+            ior: 1.45, clearcoat: 1, clearcoatRoughness: 0.05, side: DoubleSide,
+        }),
+        wick: new MeshBasicMaterial({ color: 0x1a1512, toneMapped: false }),
+        ember: new MeshBasicMaterial({ color: 0xff6a1e, toneMapped: false }),
+        halo: haloMaterial(),
+    };
+}
+export function disposeCandleMaterials(m) {
+    m.flame.dispose();
+    m.flameBillboard.dispose();
+    m.smoke.dispose();
+    m.wax.dispose();
+    m.melt.dispose();
+    m.wick.dispose();
+    m.ember.dispose();
+    m.halo.dispose();
+}

package/dist/components/candle/flameMotion.d.ts

@@ -0,0 +1,64 @@
+export interface FlameMotionConfig {
+    /** Depth of the brightness dip, 0-1. Light output only — not shape. */
+    flicker: number;
+    /** How much the flame moves at all, 0-1. 0 freezes the shape. */
+    movement: number;
+    /** Carrier rate in Hz. Real candles sit around 10-12 whatever their size. */
+    flickerHz: number;
+    /** Air movement, 0-1: lean, stretch, turbulence and eventually guttering. */
+    draught: number;
+    /** Seconds for the wick to catch and the flame to establish. */
+    ignite: number;
+    /** Whether the candle is lit. */
+    on: boolean;
+}
+export interface FlameMotionState {
+    /** 0 = out, 1 = established. Drives size and output together. */
+    level: number;
+    /** Height multiplier from the buoyancy pulse, around 1. */
+    pulse: number;
+    /** Lean of the flame's tip, in flame-height units. */
+    leanX: number;
+    leanZ: number;
+    /** Vertical stretch; draught pulls a flame long and thin. */
+    stretch: number;
+    /** How turbulent the shape noise is, 0-1. */
+    turbulence: number;
+    /** How fast the eddies travel up the flame. 0 freezes them. */
+    scroll: number;
+    /** Luminous output, lagging the shape a little, as the real thing does. */
+    output: number;
+    /** How blue the flame reads: high while it is catching, low once established. */
+    blueBias: number;
+    /** Seconds since it was snuffed, for the smoke wisp. -1 when lit or long out. */
+    smokeAge: number;
+    /** Carrier phase, so the shader can run the wave up the flame. */
+    phaseOut: number;
+    /** Amplitude of that undulation, in flame-height units. */
+    sway: number;
+    /** The plane it is swaying in, as a unit vector. Wanders. */
+    swayX: number;
+    swayZ: number;
+    /** How hard the neck pinches before the tip sheds. */
+    shed: number;
+    /** Where that pinch has travelled to, 0-1. */
+    shedPhase: number;
+    /** Fixed per candle, so two of them never move identically. */
+    noiseSeed: number;
+    /** How far wind has lifted the flame's root off the wick, 0-1. */
+    detach: number;
+    phase: number;
+    pinks: number[][];
+    windAngle: number;
+    swayAngle: number;
+    shedT: number;
+    shedPeriod: number;
+    shedStrength: number;
+    wasOn: boolean;
+    since: number;
+    gutter: number;
+    seed: number;
+}
+export declare function createFlameMotion(on: boolean): FlameMotionState;
+export declare function stepFlameMotion(s: FlameMotionState, cfg: FlameMotionConfig, deltaSeconds: number): FlameMotionState;
+//# sourceMappingURL=flameMotion.d.ts.map

package/dist/components/candle/flameMotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flameMotion.d.ts","sourceRoot":"","sources":["../../../src/components/candle/flameMotion.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,iBAAiB;IAC9B,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,EAAE,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC7B,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IAEjB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IAGf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CAChB;AAMD,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,gBAAgB,CAgB/D;AAmBD,wBAAgB,eAAe,CAAC,CAAC,EAAE,gBAAgB,EAAE,GAAG,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAsGnH"}

package/dist/components/candle/flameMotion.js

@@ -0,0 +1,138 @@
+const TWO_PI = Math.PI * 2;
+const clamp01 = (v) => Math.min(Math.max(v, 0), 1);
+const rand = () => Math.random() * 2 - 1;
+export function createFlameMotion(on) {
+    const swayAngle = Math.random() * TWO_PI;
+    return {
+        level: 0, pulse: 1, leanX: 0, leanZ: 0, stretch: 1, turbulence: 0.25, scroll: 1.4,
+        output: 0, blueBias: 1, smokeAge: -1,
+        phaseOut: 0, sway: 0.02, swayX: Math.cos(swayAngle), swayZ: Math.sin(swayAngle),
+        shed: 0.18, shedPhase: 0, noiseSeed: Math.random() * 100, detach: 0,
+        phase: Math.random() * TWO_PI,
+        // One channel each for lean, frequency, amplitude and sway direction.
+        pinks: [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]],
+        windAngle: Math.random() * TWO_PI,
+        swayAngle,
+        shedT: 0.2, shedPeriod: 0.35, shedStrength: 1,
+        wasOn: on, since: 0, gutter: 0,
+        seed: Math.random() * 1000,
+    };
+}
+/**
+ * Pink-ish noise: three leaky integrators at spaced cutoffs, summed. Cheap, and
+ * it gives the slow drift-and-return of air in a room rather than the twitch of
+ * white noise. Cutoffs roughly 0.35 / 1.4 / 5 Hz.
+ */
+function pink(s, dt, channel) {
+    const p = s.pinks[channel];
+    const k = [0.35, 1.4, 5.0];
+    let sum = 0;
+    for (let i = 0; i < 3; i++) {
+        const a = 1 - Math.exp(-dt * k[i] * TWO_PI);
+        p[i] += (rand() - p[i]) * a;
+        sum += p[i] / (i + 1);
+    }
+    return sum * 0.85;
+}
+export function stepFlameMotion(s, cfg, deltaSeconds) {
+    const dt = Math.min(Math.max(deltaSeconds, 0), 0.1);
+    const draught = clamp01(cfg.draught);
+    const flicker = clamp01(cfg.flicker);
+    const move = clamp01(cfg.movement);
+    if (cfg.on !== s.wasOn) {
+        s.wasOn = cfg.on;
+        s.since = 0;
+        s.seed = Math.random() * 1000;
+        if (!cfg.on)
+            s.smokeAge = 0;
+    }
+    s.since += dt;
+    if (s.smokeAge >= 0) {
+        s.smokeAge += dt;
+        if (s.smokeAge > 3.5)
+            s.smokeAge = -1;
+    }
+    // --- the carrier, with a wandering rate and amplitude --------------------
+    // The frequency drift is what breaks the loop: with a fixed rate the two
+    // sines below re-phase on a cycle of a few seconds and the eye finds it.
+    const rateDrift = 1 + pink(s, dt, 1) * 0.3 * move;
+    const hz = Math.max(cfg.flickerHz, 1) * (1 + draught * 0.35) * rateDrift;
+    s.phase += dt * hz * TWO_PI;
+    if (s.phase > 1e6)
+        s.phase -= 1e6;
+    const ampDrift = 0.6 + clamp01(pink(s, dt, 2) * 0.5 + 0.5) * 0.85;
+    // Golden ratio, not a near-rational one: the two components never line up.
+    const wobble = (Math.sin(s.phase) * 0.62
+        + Math.sin(s.phase * 1.618034 + s.seed) * 0.24
+        + pink(s, dt, 0) * 0.34) * ampDrift;
+    s.pulse = 1 + wobble * move * 0.17;
+    s.phaseOut = s.phase;
+    // --- guttering ----------------------------------------------------------
+    // A rare, real event: the flame is momentarily starved and nearly goes out.
+    // Rate climbs with the square of the draught, so a still room never gutters.
+    if (s.gutter > 0)
+        s.gutter = Math.max(s.gutter - dt / 0.45, 0);
+    else if (cfg.on && draught > 0.25 && Math.random() < dt * draught * draught * 1.6)
+        s.gutter = 1;
+    const gutterDip = s.gutter > 0 ? 1 - Math.sin(s.gutter * Math.PI) * 0.72 : 1;
+    // --- ignition and snuffing ---------------------------------------------
+    if (!cfg.on) {
+        s.level += (0 - s.level) * (1 - Math.exp(-dt / 0.1));
+        if (s.level < 1e-3)
+            s.level = 0;
+        s.blueBias = 1;
+    }
+    else {
+        const ignite = Math.max(cfg.ignite, 0);
+        if (ignite <= 0)
+            s.level = 1;
+        else {
+            // A wick catches small and blue, flares slightly past full, settles.
+            const t = s.since / ignite;
+            const target = t >= 1 ? 1 : 1 - Math.exp(-t * 3.4);
+            const flare = t < 1 ? Math.sin(Math.min(t, 1) * Math.PI) * 0.12 : 0;
+            s.level += (Math.min(target + flare, 1.12) - s.level) * (1 - Math.exp(-dt * 9));
+        }
+        // Blue dominates while the flame is small: less soot, more oxygen.
+        s.blueBias = 1 + Math.max(0, 1 - s.level) * 2.2;
+    }
+    // --- lean, stretch, turbulence -----------------------------------------
+    // No wind direction knob: each candle picks its own and it drifts, which is
+    // what a room does anyway and one less thing to set.
+    s.windAngle += pink(s, dt, 3) * dt * 0.55;
+    const wander = pink(s, dt, 0) * (0.06 + draught * 0.34) * move;
+    const push = draught * 0.55;
+    s.leanX += (Math.cos(s.windAngle) * push + wander - s.leanX) * (1 - Math.exp(-dt * 6));
+    s.leanZ += (Math.sin(s.windAngle) * push + wander * 0.7 - s.leanZ) * (1 - Math.exp(-dt * 5));
+    s.stretch = 1 + draught * 0.9 + wobble * move * 0.1;
+    // Frozen noise still has shape, so a still flame is irregular rather than a
+    // perfect cone — it just stops moving.
+    s.turbulence = (0.16 + draught * 0.95) * (0.35 + 0.65 * move);
+    s.scroll = (1.4 + s.turbulence * 2.4) * move;
+    // --- the undulation running up the flame --------------------------------
+    // The plane it sways in drifts, so the flame does not rock back and forth
+    // along one fixed axis.
+    s.swayAngle += pink(s, dt, 3) * dt * 2.4 * move;
+    s.swayX = Math.cos(s.swayAngle);
+    s.swayZ = Math.sin(s.swayAngle);
+    s.sway = (0.022 + draught * 0.17) * move * ampDrift;
+    // --- the tip sheds, on its own schedule ---------------------------------
+    // Event-driven rather than a fixed phase march: each shed gets its own
+    // interval and strength, so the tip never lets go on a beat.
+    s.shedT -= dt * move;
+    if (s.shedT <= 0) {
+        s.shedPeriod = 0.16 + Math.random() * 0.55;
+        s.shedT = s.shedPeriod;
+        s.shedStrength = 0.45 + Math.random() * 1.0;
+    }
+    s.shedPhase = clamp01(1 - s.shedT / Math.max(s.shedPeriod, 1e-3));
+    s.shed = (0.12 + draught * 0.4) * move * s.shedStrength;
+    // Hard wind lifts the flame clear of the wick before it puts it out.
+    s.detach = Math.max(0, (draught - 0.5) / 0.5) * (0.5 + 0.5 * wobble);
+    // --- luminous output ----------------------------------------------------
+    // The light comes from the whole glowing volume, so it lags the shape and
+    // swings less than the height does. ~35 ms is about right.
+    const target = s.level * gutterDip * (1 + wobble * flicker * 0.12);
+    s.output += (target - s.output) * (1 - Math.exp(-dt / 0.035));
+    return s;
+}

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

@@ -0,0 +1,9 @@
+export { default as Candle } from './Candle';
+export type { CandleProps } from './Candle';
+export { createCandleMaterials, disposeCandleMaterials, FLAME_MODES } from './candleMaterials';
+export type { CandleMaterials, FlameMode } from './candleMaterials';
+export { buildCandle, CANDLE_BODIES } from './candleGeometry';
+export type { CandleBody, CandleGeometry } from './candleGeometry';
+export { createFlameMotion, stepFlameMotion } from './flameMotion';
+export type { FlameMotionConfig, FlameMotionState } from './flameMotion';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/candle/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC9D,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/dist/components/candle/index.js

@@ -0,0 +1,6 @@
+// A candle: a raymarched flame with a real point light, and the wax under it
+// (config.type 'candle').
+export { default as Candle } from './Candle.js';
+export { createCandleMaterials, disposeCandleMaterials, FLAME_MODES } from './candleMaterials.js';
+export { buildCandle, CANDLE_BODIES } from './candleGeometry.js';
+export { createFlameMotion, stepFlameMotion } from './flameMotion.js';

package/dist/components/fluorescentTube/FluorescentTube.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 FluorescentTubeProps = 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 FluorescentTube: React.FC<FluorescentTubeProps>;
+export default FluorescentTube;
+//# sourceMappingURL=FluorescentTube.d.ts.map