@triforge/volume-core 0.1.0

package/dist/PointDensity.d.ts

@@ -0,0 +1,76 @@
+import { Data3DTexture } from 'three';
+export interface PointDensityOptions {
+    /**
+     * 3D texture resolution per axis. Default 32.
+     * Higher = finer density detail, more GPU memory (res³ × 16 bytes).
+     */
+    resolution?: number;
+    /**
+     * World-space bounding box to map into the texture.
+     * Default: [-2,-2,-2] to [2,2,2].
+     */
+    boundsMin?: [number, number, number];
+    boundsMax?: [number, number, number];
+    /**
+     * Gaussian splat radius in world units. Default 0.3.
+     * Each point smears its density across neighbouring voxels within this radius.
+     */
+    radius?: number;
+    /**
+     * Colour of the density field. Default [1,1,1].
+     */
+    color?: [number, number, number];
+}
+/**
+ * PointDensity — builds a live `THREE.Data3DTexture` from a point cloud
+ * (particle positions, fluid particles, or any Float32Array of xyz triples).
+ *
+ * Blender equivalent: the PointDensity shader node — samples a volumetric
+ * density field built from object point cloud data to drive surface shading.
+ *
+ * Usage:
+ * 1. Create once: `const pd = new PointDensity({ resolution: 32 })`
+ * 2. Call each frame: `pd.update(particleSystem.getPositions())`
+ * 3. Inject into a material uniform: `mat.uniforms.uPointDensity = { value: pd.texture }`
+ * 4. In your GLSL: `float density = texture(uPointDensity, worldToUV(pos)).r`
+ *
+ * @example
+ * const pd = new PointDensity({ resolution: 32, radius: 0.4, boundsMin: [-2,-2,-2], boundsMax: [2,2,2] })
+ * // in animate():
+ * pd.update(fluid.getPositions())
+ * mat.uniforms.uPointDensity.value = pd.texture
+ */
+export declare class PointDensity {
+    readonly texture: Data3DTexture;
+    parameters: {
+        resolution: number;
+        radius: number;
+        color: [number, number, number];
+    };
+    private readonly _res;
+    private readonly _bMin;
+    private readonly _bMax;
+    private readonly _bSize;
+    private readonly _data;
+    constructor(opts?: PointDensityOptions);
+    /**
+     * Rebuild the density texture from a flat Float32Array of xyz positions.
+     * Pass `particleSystem.getPositions()` or `FLIPSimulator.getPositions()` directly.
+     * Call each frame when particle positions change.
+     */
+    update(positions: Float32Array | number[]): void;
+    /**
+     * Returns a GLSL helper snippet to sample this texture in a ShaderMaterial.
+     * Inject into fragmentShader and call `samplePointDensity(worldPos)`.
+     *
+     * @param uniformName - Name of the sampler3D uniform. Default 'uPointDensity'.
+     */
+    /**
+     * Returns a GLSL snippet (for GLSL 3 / WebGL 2) declaring the sampler3D
+     * uniform and a helper function to sample it from world position.
+     *
+     * Requires `glslVersion: THREE.GLSL3` on the ShaderMaterial.
+     */
+    glslSampler(uniformName?: string): string;
+}
+//# sourceMappingURL=PointDensity.d.ts.map

package/dist/PointDensity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointDensity.d.ts","sourceRoot":"","sources":["../src/PointDensity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAGd,MAAM,OAAO,CAAA;AAEd,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAEpC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf;;OAEG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY;IACvB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAE/B,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,CAAA;QAClB,MAAM,EAAM,MAAM,CAAA;QAClB,KAAK,EAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;KACrC,CAAA;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;gBAEzC,IAAI,GAAE,mBAAwB;IA4B1C;;;;OAIG;IACH,MAAM,CAAC,SAAS,EAAE,YAAY,GAAG,MAAM,EAAE,GAAG,IAAI;IAsDhD;;;;;OAKG;IACH;;;;;OAKG;IACH,WAAW,CAAC,WAAW,SAAkB,GAAG,MAAM;CAYnD"}

package/dist/PointDensity.js

@@ -0,0 +1,122 @@
+import { Data3DTexture, RGBAFormat, FloatType, LinearFilter, ClampToEdgeWrapping, Vector3, } from 'three';
+/**
+ * PointDensity — builds a live `THREE.Data3DTexture` from a point cloud
+ * (particle positions, fluid particles, or any Float32Array of xyz triples).
+ *
+ * Blender equivalent: the PointDensity shader node — samples a volumetric
+ * density field built from object point cloud data to drive surface shading.
+ *
+ * Usage:
+ * 1. Create once: `const pd = new PointDensity({ resolution: 32 })`
+ * 2. Call each frame: `pd.update(particleSystem.getPositions())`
+ * 3. Inject into a material uniform: `mat.uniforms.uPointDensity = { value: pd.texture }`
+ * 4. In your GLSL: `float density = texture(uPointDensity, worldToUV(pos)).r`
+ *
+ * @example
+ * const pd = new PointDensity({ resolution: 32, radius: 0.4, boundsMin: [-2,-2,-2], boundsMax: [2,2,2] })
+ * // in animate():
+ * pd.update(fluid.getPositions())
+ * mat.uniforms.uPointDensity.value = pd.texture
+ */
+export class PointDensity {
+    constructor(opts = {}) {
+        const res = opts.resolution ?? 32;
+        const bMin = opts.boundsMin ?? [-2, -2, -2];
+        const bMax = opts.boundsMax ?? [2, 2, 2];
+        this._res = res;
+        this._bMin = new Vector3(...bMin);
+        this._bMax = new Vector3(...bMax);
+        this._bSize = new Vector3().subVectors(this._bMax, this._bMin);
+        this._data = new Float32Array(res * res * res * 4);
+        this.parameters = {
+            resolution: res,
+            radius: opts.radius ?? 0.3,
+            color: opts.color ?? [1, 1, 1],
+        };
+        this.texture = new Data3DTexture(this._data, res, res, res);
+        this.texture.format = RGBAFormat;
+        this.texture.type = FloatType;
+        this.texture.minFilter = LinearFilter;
+        this.texture.magFilter = LinearFilter;
+        this.texture.wrapS = ClampToEdgeWrapping;
+        this.texture.wrapT = ClampToEdgeWrapping;
+        this.texture.wrapR = ClampToEdgeWrapping;
+        this.texture.needsUpdate = true;
+    }
+    /**
+     * Rebuild the density texture from a flat Float32Array of xyz positions.
+     * Pass `particleSystem.getPositions()` or `FLIPSimulator.getPositions()` directly.
+     * Call each frame when particle positions change.
+     */
+    update(positions) {
+        const res = this._res;
+        const data = this._data;
+        const radius = this.parameters.radius;
+        const [cr, cg, cb] = this.parameters.color;
+        // Clear
+        data.fill(0);
+        const invSizeX = res / this._bSize.x;
+        const invSizeY = res / this._bSize.y;
+        const invSizeZ = res / this._bSize.z;
+        const r2 = radius * radius;
+        const n = Math.floor(positions.length / 3);
+        for (let p = 0; p < n; p++) {
+            const wx = positions[p * 3];
+            const wy = positions[p * 3 + 1];
+            const wz = positions[p * 3 + 2];
+            // Map to voxel space
+            const vx = (wx - this._bMin.x) * invSizeX;
+            const vy = (wy - this._bMin.y) * invSizeY;
+            const vz = (wz - this._bMin.z) * invSizeZ;
+            // Splat into a small neighbourhood
+            const vrad = radius * invSizeX; // approx voxel radius
+            const r0x = Math.max(0, Math.floor(vx - vrad));
+            const r1x = Math.min(res - 1, Math.ceil(vx + vrad));
+            const r0y = Math.max(0, Math.floor(vy - vrad));
+            const r1y = Math.min(res - 1, Math.ceil(vy + vrad));
+            const r0z = Math.max(0, Math.floor(vz - vrad));
+            const r1z = Math.min(res - 1, Math.ceil(vz + vrad));
+            for (let iz = r0z; iz <= r1z; iz++)
+                for (let iy = r0y; iy <= r1y; iy++)
+                    for (let ix = r0x; ix <= r1x; ix++) {
+                        const dwx = (ix / invSizeX + this._bMin.x) - wx;
+                        const dwy = (iy / invSizeY + this._bMin.y) - wy;
+                        const dwz = (iz / invSizeZ + this._bMin.z) - wz;
+                        const d2 = dwx * dwx + dwy * dwy + dwz * dwz;
+                        if (d2 > r2)
+                            continue;
+                        const weight = 1 - d2 / r2; // linear falloff
+                        const idx = (iz * res * res + iy * res + ix) * 4;
+                        data[idx] += weight * cr;
+                        data[idx + 1] += weight * cg;
+                        data[idx + 2] += weight * cb;
+                        data[idx + 3] += weight;
+                    }
+        }
+        this.texture.needsUpdate = true;
+    }
+    /**
+     * Returns a GLSL helper snippet to sample this texture in a ShaderMaterial.
+     * Inject into fragmentShader and call `samplePointDensity(worldPos)`.
+     *
+     * @param uniformName - Name of the sampler3D uniform. Default 'uPointDensity'.
+     */
+    /**
+     * Returns a GLSL snippet (for GLSL 3 / WebGL 2) declaring the sampler3D
+     * uniform and a helper function to sample it from world position.
+     *
+     * Requires `glslVersion: THREE.GLSL3` on the ShaderMaterial.
+     */
+    glslSampler(uniformName = 'uPointDensity') {
+        const bMin = this._bMin;
+        const bSize = this._bSize;
+        return `
+uniform sampler3D ${uniformName};
+vec4 samplePointDensity(vec3 worldPos) {
+  vec3 uv = (worldPos - vec3(${bMin.x.toFixed(4)}, ${bMin.y.toFixed(4)}, ${bMin.z.toFixed(4)}))
+          / vec3(${bSize.x.toFixed(4)}, ${bSize.y.toFixed(4)}, ${bSize.z.toFixed(4)});
+  uv = clamp(uv, 0.0, 1.0);
+  return texture(${uniformName}, uv);
+}`.trim();
+    }
+}

package/dist/VolumeBox.d.ts

@@ -0,0 +1,89 @@
+import { Mesh, ShaderMaterial } from 'three';
+export type VolumeType = 'fog' | 'smoke' | 'fire';
+export interface VolumeBoxOptions {
+    /**
+     * Volume preset.
+     * 'fog'   — uniform density absorption (Blender: Volume Absorption)
+     * 'smoke' — animated noise density scatter (Blender: Volume Scatter + noise)
+     * 'fire'  — emission-based fire with density noise (Blender: Principled Volume, fire preset)
+     * Default 'fog'.
+     */
+    type?: VolumeType;
+    /** World-space box size [x,y,z]. Default [2,2,2]. */
+    size?: [number, number, number];
+    /** Overall density multiplier. Default 1. */
+    density?: number;
+    /** Primary scatter/absorption colour (hex string). Default '#aaccff' for fog, '#888' for smoke, '#ff6600' for fire. */
+    color?: string;
+    /** Emission colour for fire type (hex string). Default '#ff4400'. */
+    emissionColor?: string;
+    /** Emission strength (fire only). Default 3. */
+    emissionStrength?: number;
+    /** Noise scale — spatial frequency of heterogeneous density. Default 1.5. */
+    noiseScale?: number;
+    /** Noise animation speed. Default 0.3. */
+    noiseSpeed?: number;
+    /** Number of ray-march steps — quality vs performance. Default 48. */
+    steps?: number;
+    /** Henyey-Greenstein anisotropy [-1, 1]. 0=isotropic. Default 0. */
+    anisotropy?: number;
+}
+/**
+ * VolumeBox — axis-aligned box filled with volumetric media.
+ * Blender equivalents: Volume Absorption · Volume Scatter · Principled Volume.
+ *
+ * Communicates with the scene as a THREE.Mesh — add it to the scene like any mesh.
+ * All animation parameters live in `parameters` for GSAP / st-keyframe compatibility.
+ *
+ * Usage:
+ * ```typescript
+ * const fog = new VolumeBox({ type: 'fog', density: 0.8, color: '#aaccff' })
+ * scene.add(fog.mesh)
+ *
+ * // Animate density
+ * gsap.to(fog.parameters, { density: 0.3, duration: 2 })
+ * // Update uniforms each frame:
+ * fog.tick(clock.getElapsedTime())
+ * ```
+ */
+export declare class VolumeBox {
+    readonly mesh: Mesh;
+    readonly material: ShaderMaterial;
+    /** All scalar parameters — GSAP / st-keyframe compatible. */
+    parameters: {
+        density: number;
+        noiseScale: number;
+        noiseSpeed: number;
+        steps: number;
+        anisotropy: number;
+        emissionStrength: number;
+        colorR: number;
+        colorG: number;
+        colorB: number;
+        emissionR: number;
+        emissionG: number;
+        emissionB: number;
+    };
+    private readonly _type;
+    constructor(opts?: VolumeBoxOptions);
+    /**
+     * Call once per frame to sync animated parameters to GPU uniforms.
+     * @param time — `clock.getElapsedTime()`
+     */
+    private _invModel;
+    private _worldCam;
+    tick(time: number): void;
+    /**
+     * Set the camera world-space position so the ray-march shader knows the
+     * ray origin. Call each frame after the camera has been moved:
+     *   vol.setCameraPosition(camera.position.x, camera.position.y, camera.position.z)
+     *
+     * Converts to object space automatically using the mesh's world matrix.
+     */
+    setCameraPosition(x: number, y: number, z: number): void;
+    dispose(): void;
+    private _typeIndex;
+    private static _vert;
+    private static _frag;
+}
+//# sourceMappingURL=VolumeBox.d.ts.map

package/dist/VolumeBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VolumeBox.d.ts","sourceRoot":"","sources":["../src/VolumeBox.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAAe,cAAc,EAIlC,MAAM,OAAO,CAAA;AAEd,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,CAAA;AAEjD,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,UAAU,CAAA;IAEjB,qDAAqD;IACrD,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAE/B,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB,uHAAuH;IACvH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAEzB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,SAAS;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;IAEjC,6DAA6D;IAC7D,UAAU,EAAE;QACV,OAAO,EAAW,MAAM,CAAA;QACxB,UAAU,EAAQ,MAAM,CAAA;QACxB,UAAU,EAAQ,MAAM,CAAA;QACxB,KAAK,EAAa,MAAM,CAAA;QACxB,UAAU,EAAQ,MAAM,CAAA;QACxB,gBAAgB,EAAE,MAAM,CAAA;QACxB,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;QAC9C,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KACxD,CAAA;IAED,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;gBAEtB,IAAI,GAAE,gBAAqB;IAmDvC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,SAAS,CAAgB;IAEjC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAcxB;;;;;;OAMG;IACH,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IASxD,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,MAAM,CAAC,KAAK,CAUnB;IAID,OAAO,CAAC,MAAM,CAAC,KAAK,CAgKnB;CACF"}

package/dist/VolumeBox.js

@@ -0,0 +1,281 @@
+import { Mesh, BoxGeometry, ShaderMaterial, Vector3, Matrix4, Color, AdditiveBlending, NormalBlending, BackSide, } from 'three';
+/**
+ * VolumeBox — axis-aligned box filled with volumetric media.
+ * Blender equivalents: Volume Absorption · Volume Scatter · Principled Volume.
+ *
+ * Communicates with the scene as a THREE.Mesh — add it to the scene like any mesh.
+ * All animation parameters live in `parameters` for GSAP / st-keyframe compatibility.
+ *
+ * Usage:
+ * ```typescript
+ * const fog = new VolumeBox({ type: 'fog', density: 0.8, color: '#aaccff' })
+ * scene.add(fog.mesh)
+ *
+ * // Animate density
+ * gsap.to(fog.parameters, { density: 0.3, duration: 2 })
+ * // Update uniforms each frame:
+ * fog.tick(clock.getElapsedTime())
+ * ```
+ */
+export class VolumeBox {
+    constructor(opts = {}) {
+        /**
+         * Call once per frame to sync animated parameters to GPU uniforms.
+         * @param time — `clock.getElapsedTime()`
+         */
+        this._invModel = new Matrix4();
+        this._worldCam = new Vector3();
+        this._type = opts.type ?? 'fog';
+        const defaultColor = this._type === 'fire' ? '#ff6600'
+            : this._type === 'smoke' ? '#888888'
+                : '#aaccff';
+        const colorHex = opts.color ?? defaultColor;
+        const emitHex = opts.emissionColor ?? '#ff4400';
+        const col = new Color(colorHex);
+        const emit = new Color(emitHex);
+        this.parameters = {
+            density: opts.density ?? 1,
+            noiseScale: opts.noiseScale ?? 1.5,
+            noiseSpeed: opts.noiseSpeed ?? 0.3,
+            steps: opts.steps ?? 48,
+            anisotropy: opts.anisotropy ?? 0,
+            emissionStrength: opts.emissionStrength ?? 3,
+            colorR: col.r, colorG: col.g, colorB: col.b,
+            emissionR: emit.r, emissionG: emit.g, emissionB: emit.b,
+        };
+        const [sx, sy, sz] = opts.size ?? [2, 2, 2];
+        const geo = new BoxGeometry(sx, sy, sz);
+        this.material = new ShaderMaterial({
+            uniforms: {
+                uDensity: { value: this.parameters.density },
+                uNoiseScale: { value: this.parameters.noiseScale },
+                uNoiseSpeed: { value: this.parameters.noiseSpeed },
+                uSteps: { value: this.parameters.steps },
+                uAnisotropy: { value: this.parameters.anisotropy },
+                uEmissionStrength: { value: this.parameters.emissionStrength },
+                uColor: { value: new Vector3(col.r, col.g, col.b) },
+                uEmission: { value: new Vector3(emit.r, emit.g, emit.b) },
+                uTime: { value: 0 },
+                uBoxSize: { value: new Vector3(sx, sy, sz) },
+                uVolumeType: { value: this._typeIndex() },
+                uCameraLocalPos: { value: new Vector3() },
+            },
+            vertexShader: VolumeBox._vert,
+            fragmentShader: VolumeBox._frag,
+            side: BackSide,
+            transparent: true,
+            depthWrite: false,
+            blending: this._type === 'fire' ? AdditiveBlending : NormalBlending,
+        });
+        this.mesh = new Mesh(geo, this.material);
+    }
+    tick(time) {
+        const u = this.material.uniforms;
+        const p = this.parameters;
+        u['uTime'].value = time;
+        u['uDensity'].value = p.density;
+        u['uNoiseScale'].value = p.noiseScale;
+        u['uNoiseSpeed'].value = p.noiseSpeed;
+        u['uSteps'].value = Math.max(8, Math.round(p.steps));
+        u['uAnisotropy'].value = p.anisotropy;
+        u['uEmissionStrength'].value = p.emissionStrength;
+        u['uColor'].value.set(p.colorR, p.colorG, p.colorB);
+        u['uEmission'].value.set(p.emissionR, p.emissionG, p.emissionB);
+    }
+    /**
+     * Set the camera world-space position so the ray-march shader knows the
+     * ray origin. Call each frame after the camera has been moved:
+     *   vol.setCameraPosition(camera.position.x, camera.position.y, camera.position.z)
+     *
+     * Converts to object space automatically using the mesh's world matrix.
+     */
+    setCameraPosition(x, y, z) {
+        this.mesh.updateWorldMatrix(true, false);
+        this._invModel.copy(this.mesh.matrixWorld).invert();
+        this._worldCam.set(x, y, z);
+        this.material.uniforms['uCameraLocalPos'].value
+            .copy(this._worldCam)
+            .applyMatrix4(this._invModel);
+    }
+    dispose() {
+        this.mesh.geometry.dispose();
+        this.material.dispose();
+    }
+    _typeIndex() {
+        return this._type === 'fog' ? 0 : this._type === 'smoke' ? 1 : 2;
+    }
+}
+// ── Vertex shader ─────────────────────────────────────────────────────────
+VolumeBox._vert = `
+    varying vec3 vWorldPos;
+    varying vec3 vLocalPos;
+
+    void main() {
+      vec4 world = modelMatrix * vec4(position, 1.0);
+      vWorldPos  = world.xyz;
+      vLocalPos  = position;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    }
+  `;
+// ── Fragment shader ───────────────────────────────────────────────────────
+VolumeBox._frag = `
+    precision highp float;
+
+    uniform float uDensity;
+    uniform float uNoiseScale;
+    uniform float uNoiseSpeed;
+    uniform float uSteps;
+    uniform float uAnisotropy;
+    uniform float uEmissionStrength;
+    uniform vec3  uColor;
+    uniform vec3  uEmission;
+    uniform float uTime;
+    uniform vec3  uBoxSize;
+    uniform int   uVolumeType;
+    uniform vec3  uCameraLocalPos;
+
+    varying vec3 vWorldPos;
+    varying vec3 vLocalPos;
+
+    // ── Noise ────────────────────────────────────────────────────────────────
+
+    float hash(vec3 p) {
+      p = fract(p * vec3(127.1, 311.7, 74.7));
+      p += dot(p, p.zyx + 31.32);
+      return fract((p.x + p.y) * p.z);
+    }
+
+    float noise3(vec3 p) {
+      vec3 i = floor(p);
+      vec3 f = fract(p);
+      vec3 u = f * f * (3.0 - 2.0 * f);
+      return mix(
+        mix(mix(hash(i),           hash(i + vec3(1,0,0)), u.x),
+            mix(hash(i+vec3(0,1,0)),hash(i + vec3(1,1,0)), u.x), u.y),
+        mix(mix(hash(i+vec3(0,0,1)),hash(i+vec3(1,0,1)),  u.x),
+            mix(hash(i+vec3(0,1,1)),hash(i + vec3(1,1,1)), u.x), u.y), u.z);
+    }
+
+    float fbm(vec3 p) {
+      float v = 0.0, a = 0.5;
+      for (int i = 0; i < 4; i++) {
+        v += a * noise3(p);
+        p  = p * 2.1 + vec3(1.7, 9.2, 3.4);
+        a *= 0.5;
+      }
+      return v;
+    }
+
+    // ── Phase function (un-normalized HG — visual range ~0.3..3.0) ──────────
+    // Omitting the 1/(4π) denominator keeps scattered values in a visible range.
+
+    float phase(float cosTheta, float g) {
+      float g2 = g * g;
+      return (1.0 - g2) / pow(1.0 + g2 - 2.0 * g * cosTheta, 1.5);
+    }
+
+    // ── Ray–AABB intersection ─────────────────────────────────────────────────
+
+    bool intersectBox(vec3 ro, vec3 rd, vec3 halfSize, out float tMin, out float tMax) {
+      vec3 inv = 1.0 / rd;
+      vec3 tA  = (-halfSize - ro) * inv;
+      vec3 tB  = ( halfSize - ro) * inv;
+      vec3 t0  = min(tA, tB);
+      vec3 t1  = max(tA, tB);
+      tMin = max(max(t0.x, t0.y), t0.z);
+      tMax = min(min(t1.x, t1.y), t1.z);
+      return tMax > max(tMin, 0.0);
+    }
+
+    // ── Density sampling ─────────────────────────────────────────────────────
+
+    float sampleDensity(vec3 localPos) {
+      if (uVolumeType == 0) {
+        // Fog: uniform with soft edge falloff
+        vec3 d = abs(localPos) / (uBoxSize * 0.5);
+        float edge = 1.0 - smoothstep(0.8, 1.0, max(max(d.x, d.y), d.z));
+        return uDensity * edge;
+      } else if (uVolumeType == 1) {
+        // Smoke: animated noise
+        vec3  p   = localPos * uNoiseScale + vec3(0.0, -uTime * uNoiseSpeed, 0.0);
+        float n   = fbm(p);
+        float rim = 1.0 - smoothstep(0.35, 0.5, length(localPos / (uBoxSize * 0.5)));
+        return max(0.0, (n - 0.35) * 2.0) * uDensity * rim;
+      } else {
+        // Fire: density concentrated at base, thinning toward top
+        vec3  hs  = uBoxSize * 0.5;
+        float vy  = (localPos.y + hs.y) / (uBoxSize.y);  // 0=bottom, 1=top
+        vec3  p   = localPos * uNoiseScale + vec3(0.0, -uTime * uNoiseSpeed * 2.0, 0.0);
+        float n   = fbm(p);
+        float rim = 1.0 - smoothstep(0.3, 0.5, length(localPos.xz / hs.xz));
+        return max(0.0, (n - 0.2) * (1.0 - vy * 0.9)) * uDensity * rim;
+      }
+    }
+
+    // ── Emission colour at position ───────────────────────────────────────────
+
+    vec3 sampleEmission(vec3 localPos, float density) {
+      if (uVolumeType != 2) return vec3(0.0);
+      // Fire colour ramp: black → orange → yellow → white
+      vec3 hs  = uBoxSize * 0.5;
+      float vy = (localPos.y + hs.y) / uBoxSize.y;
+      float t  = clamp(density * 1.5, 0.0, 1.0);
+      vec3 c0  = vec3(0.0);
+      vec3 c1  = uColor;              // base fire colour (orange)
+      vec3 c2  = uEmission;           // hot core colour (yellow-white)
+      vec3 col = t < 0.5 ? mix(c0, c1, t * 2.0) : mix(c1, c2, (t - 0.5) * 2.0);
+      return col * uEmissionStrength * (1.0 - vy * 0.5);
+    }
+
+    void main() {
+      // Camera position is already in local (object) space — computed on CPU
+      vec3 ro    = uCameraLocalPos;
+      vec3 rd    = normalize(vLocalPos - ro);
+      vec3 halfS = uBoxSize * 0.5;
+
+      float tMin, tMax;
+      if (!intersectBox(ro, rd, halfS, tMin, tMax)) {
+        discard;
+      }
+      tMin = max(tMin, 0.0);
+
+      // Simple sun direction (fixed — enough for visual quality)
+      vec3 sunDir   = normalize(vec3(0.5, 1.0, 0.3));
+      float cosTheta = dot(rd, sunDir);
+      float ph       = phase(cosTheta, uAnisotropy);
+
+      float stepSize  = (tMax - tMin) / uSteps;
+      vec3  transmit  = vec3(1.0);
+      vec3  scattered = vec3(0.0);
+      vec3  emitted   = vec3(0.0);
+
+      for (int i = 0; i < 128; i++) {
+        if (float(i) >= uSteps) break;
+        float t       = tMin + (float(i) + 0.5) * stepSize;
+        vec3  localP  = ro + rd * t;
+        float dens    = sampleDensity(localP);
+        if (dens < 0.0001) continue;
+
+        // Beer–Lambert extinction
+        vec3 sigma_t  = uColor * dens;
+        vec3 extinction = exp(-sigma_t * stepSize);
+        vec3 weight     = transmit * (vec3(1.0) - extinction);
+
+        // In-scatter: sun (directional) + ambient fill
+        float ambient = 0.35;
+        scattered  += weight * uColor * (ph * 0.45 + ambient);
+
+        // Emission (fire)
+        emitted    += weight * sampleEmission(localP, dens);
+
+        transmit   *= extinction;
+        if (max(transmit.r, max(transmit.g, transmit.b)) < 0.01) break;
+      }
+
+      float alpha = 1.0 - (transmit.r + transmit.g + transmit.b) / 3.0;
+      vec3  color = scattered + emitted;
+
+      if (alpha < 0.001) discard;
+      gl_FragColor = vec4(color, alpha);
+    }
+  `;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { VolumeBox } from './VolumeBox.js';
+export type { VolumeBoxOptions, VolumeType } from './VolumeBox.js';
+export { PointDensity } from './PointDensity.js';
+export type { PointDensityOptions } from './PointDensity.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,YAAY,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { VolumeBox } from './VolumeBox.js';
+export { PointDensity } from './PointDensity.js';

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@triforge/volume-core",
+  "version": "0.1.0",
+  "description": "Volumetric fog, smoke and fire rendering for Three.js — Blender Volume shaders",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node test/run-tests.js"
+  },
+  "keywords": [
+    "volume",
+    "fog",
+    "smoke",
+    "fire",
+    "raymarching",
+    "three.js",
+    "blender"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "three": ">=0.128.0"
+  },
+  "devDependencies": {
+    "@types/three": "^0.156.0",
+    "three": "^0.156.0",
+    "typescript": "^5.3.0"
+  },
+  "author": "Aftab Ibrahim Kazi",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AftabIbrahimKazi/triforge.git",
+    "directory": "st-volume-core"
+  },
+  "homepage": "https://github.com/AftabIbrahimKazi/triforge#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}