@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/material/sssprofile.js

@@ -0,0 +1,879 @@
+import { Vector3 } from '@zephyr3d/base';
+
+/** Number of scalar parameter columns stored per profile row. */ const SKIN_PROFILE_PARAM_COLUMNS = 6;
+/** Number of texels the baked transmission profile occupies. */ const SKIN_TRANSMISSION_LUT_SIZE = 32;
+/** Total columns per profile row: the scalar parameters followed by the baked transmission profile. */ const SKIN_PROFILE_COLUMNS = SKIN_PROFILE_PARAM_COLUMNS + SKIN_TRANSMISSION_LUT_SIZE;
+/** Maximum number of live skin profiles, matching the 8-bit profile id channel. */ const SKIN_PROFILE_CAPACITY = 256;
+/**
+ * Gate on {@link SSSProfile}'s constructor.
+ *
+ * @remarks
+ * Module-private, so only {@link SSSProfile.createOwned} can pass it. See the
+ * constructor for why a `private` modifier alone is not enough.
+ *
+ * @internal
+ */ const CREATE_TOKEN = Symbol('SSSProfile.create');
+/**
+ * Largest optical depth the transmission profile is defined over.
+ *
+ * @internal
+ **/ const SKIN_MAX_TRANSMISSION_OPTICAL_DEPTH = 5;
+/**
+ * Floor the averaged optical depth is clamped to before encoding.
+ *
+ * @internal
+ **/ const SKIN_TRANSMISSION_OPTICAL_DEPTH_FLOOR = 0.15;
+/**
+ * Constant added to the optical depth after clamping.
+ *
+ * @internal
+ **/ const SKIN_TRANSMISSION_OPTICAL_DEPTH_BIAS = 0.25;
+/**
+ * Largest value the thickness pass can write, and with it the sentinel that
+ * separates a real measurement from "no light wrote this".
+ *
+ * @internal
+ */ const SKIN_TRANSMISSION_NO_DATA_ENCODING = 1 - (SKIN_TRANSMISSION_OPTICAL_DEPTH_FLOOR + SKIN_TRANSMISSION_OPTICAL_DEPTH_BIAS) / SKIN_MAX_TRANSMISSION_OPTICAL_DEPTH;
+/**
+ * Distance, in profile millimetres, the baked transmission profile spans.
+ *
+ * @internal
+ */ const TRANSMISSION_LUT_MAX_DISTANCE_MM = 50;
+/**
+ * Radius the baked transmission profile is offset by, in profile millimetres.
+ *
+ * @internal
+ */ const TRANSMISSION_LUT_RADIUS_OFFSET_MM = 0.6;
+/**
+ * Profile-space millimetres per world unit, before the profile's own world unit
+ * scale is applied.
+ *
+ * @internal
+ */ const WORLD_UNITS_TO_PROFILE_MM = 1000;
+/**
+ * Optical depth accumulated per world unit of light path, before the profile's
+ * `extinctionScale`.
+ *
+ * @internal
+ */ const SKIN_OPTICAL_DEPTH_PER_WORLD_UNIT = WORLD_UNITS_TO_PROFILE_MM * SKIN_MAX_TRANSMISSION_OPTICAL_DEPTH / (TRANSMISSION_LUT_MAX_DISTANCE_MM * ((SKIN_TRANSMISSION_LUT_SIZE - 1) / SKIN_TRANSMISSION_LUT_SIZE));
+/**
+ * `GetSearchLightDiffuseScalingFactor`, the default variant.
+ *
+ * @remarks
+ * `s = 3.5 + 100 (A - 0.33)^4`. The same curve the diffusion evaluates on the
+ * GPU (`posteffect/postsss.ts`, `scalingFactor`); the transmission profile is
+ * baked on the CPU and needs its own copy.
+ *
+ * @internal
+ */ function searchLightDiffuseScalingFactor(albedo) {
+    const v = albedo - 0.33;
+    return 3.5 + 100 * v * v * v * v;
+}
+/**
+ * Preset parameters.
+ *
+ * @internal
+ */ const SKIN_PROFILE_TEMPLATES = {
+    skin: {
+        surfaceAlbedo: [
+            0.91058,
+            0.338275,
+            0.2718
+        ],
+        meanFreePath: [
+            1.0,
+            0.0889636,
+            0.0720951
+        ],
+        meanFreePathDistance: 0.026748,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            1.0,
+            0.42,
+            0.3
+        ],
+        extinctionScale: 1,
+        normalScale: 0.08,
+        scatteringDistribution: 0.93,
+        ior: 1.55,
+        roughness0: 0.75,
+        roughness1: 1.3,
+        lobeMix: 0.85
+    },
+    skin_pale: {
+        surfaceAlbedo: [
+            0.93,
+            0.4,
+            0.33
+        ],
+        meanFreePath: [
+            1.0,
+            0.1,
+            0.083
+        ],
+        meanFreePathDistance: 0.0294,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            1.0,
+            0.48,
+            0.38
+        ],
+        extinctionScale: 1,
+        normalScale: 0.08,
+        scatteringDistribution: 0.93,
+        ior: 1.55,
+        roughness0: 0.72,
+        roughness1: 1.25,
+        lobeMix: 0.85
+    },
+    skin_tan: {
+        surfaceAlbedo: [
+            0.88,
+            0.3,
+            0.235
+        ],
+        meanFreePath: [
+            1.0,
+            0.082,
+            0.066
+        ],
+        meanFreePathDistance: 0.0254,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            1.0,
+            0.38,
+            0.26
+        ],
+        extinctionScale: 1,
+        normalScale: 0.08,
+        scatteringDistribution: 0.93,
+        ior: 1.55,
+        roughness0: 0.76,
+        roughness1: 1.32,
+        lobeMix: 0.85
+    },
+    skin_dark: {
+        surfaceAlbedo: [
+            0.8,
+            0.24,
+            0.185
+        ],
+        meanFreePath: [
+            1.0,
+            0.072,
+            0.057
+        ],
+        meanFreePathDistance: 0.0227,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            1.0,
+            0.3,
+            0.2
+        ],
+        extinctionScale: 1,
+        normalScale: 0.08,
+        scatteringDistribution: 0.93,
+        ior: 1.55,
+        roughness0: 0.78,
+        roughness1: 1.35,
+        lobeMix: 0.85
+    },
+    wax: {
+        surfaceAlbedo: [
+            0.95,
+            0.9,
+            0.8
+        ],
+        meanFreePath: [
+            1.0,
+            0.85,
+            0.68
+        ],
+        meanFreePathDistance: 0.05,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            1.0,
+            0.88,
+            0.74
+        ],
+        extinctionScale: 1,
+        normalScale: 0.05,
+        scatteringDistribution: 0.85,
+        ior: 1.45,
+        roughness0: 0.85,
+        roughness1: 1.4,
+        lobeMix: 0.8
+    },
+    jade: {
+        surfaceAlbedo: [
+            0.75,
+            0.93,
+            0.86
+        ],
+        meanFreePath: [
+            0.6,
+            1.0,
+            0.85
+        ],
+        meanFreePathDistance: 0.045,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            0.68,
+            0.95,
+            0.88
+        ],
+        extinctionScale: 1,
+        normalScale: 0.05,
+        scatteringDistribution: 0.7,
+        ior: 1.6,
+        roughness0: 0.6,
+        roughness1: 1.1,
+        lobeMix: 0.75
+    },
+    marble: {
+        surfaceAlbedo: [
+            0.95,
+            0.94,
+            0.92
+        ],
+        meanFreePath: [
+            1.0,
+            0.96,
+            0.92
+        ],
+        meanFreePathDistance: 0.035,
+        worldUnitScale: 1,
+        scatterScale: 1,
+        boundaryColorBleed: [
+            1,
+            1,
+            1
+        ],
+        transmissionTint: [
+            0.96,
+            0.95,
+            0.94
+        ],
+        extinctionScale: 1,
+        normalScale: 0.04,
+        scatteringDistribution: 0.6,
+        ior: 1.55,
+        roughness0: 0.55,
+        roughness1: 1.05,
+        lobeMix: 0.7
+    }
+};
+/**
+ * Subsurface profile for {@link SSSMaterial}.
+ *
+ * @public
+ */ class SSSProfile {
+    static _profiles = new Array(SKIN_PROFILE_CAPACITY).fill(null);
+    static _table = null;
+    /** Device {@link SSSProfile._table} belongs to, so a device swap can be spotted. */ static _tableDevice = null;
+    static _tableData = null;
+    static _tableDirty = true;
+    static _defaultProfile = null;
+    _id;
+    _surfaceAlbedo;
+    _meanFreePath;
+    _boundaryColorBleed;
+    _transmissionTint;
+    _preset;
+    _meanFreePathDistance;
+    _worldUnitScale;
+    _scatterScale;
+    _extinctionScale;
+    _normalScale;
+    _scatteringDistribution;
+    _ior;
+    _roughness0;
+    _roughness1;
+    _lobeMix;
+    _disposed;
+    _changeListeners;
+    /**
+   * Not constructible from outside. Use {@link SSSMaterial.subsurfaceProfile},
+   * which owns one for the material's lifetime.
+   *
+   * @remarks
+   * The token check is not redundant with `private`: profiles hold a row of a
+   * 256-entry GPU table that only {@link SSSProfile.dispose} returns, and the
+   * editor ships as prebuilt JavaScript that drives this class through
+   * serialization metadata, where TypeScript's visibility rules do not apply.
+   *
+   * @internal
+   */ constructor(token, preset = 'skin'){
+        if (token !== CREATE_TOKEN) {
+            throw new Error('SSSProfile is not constructible directly; it is owned by the SSSMaterial that created it.');
+        }
+        this._surfaceAlbedo = new Vector3();
+        this._meanFreePath = new Vector3();
+        this._boundaryColorBleed = new Vector3();
+        this._transmissionTint = new Vector3();
+        this._preset = preset;
+        this._meanFreePathDistance = 0;
+        this._worldUnitScale = 1;
+        this._scatterScale = 1;
+        this._extinctionScale = 1;
+        this._normalScale = 0.08;
+        this._scatteringDistribution = 0.93;
+        this._ior = 1.55;
+        this._roughness0 = 0.75;
+        this._roughness1 = 1.3;
+        this._lobeMix = 0.85;
+        this._disposed = false;
+        this._changeListeners = new Set();
+        this._id = SSSProfile.allocateId(this);
+        this.applyPreset(preset);
+    }
+    /**
+   * Registers a callback invoked whenever this profile's parameters change.
+   *
+   * @param listener - The callback to add.
+   *
+   * @public
+   */ addChangeListener(listener) {
+        this._changeListeners.add(listener);
+    }
+    /**
+   * Removes a previously registered change listener.
+   *
+   * @param listener - The callback to remove.
+   *
+   * @public
+   */ removeChangeListener(listener) {
+        this._changeListeners.delete(listener);
+    }
+    /**
+   * Creates a profile for a material to own.
+   *
+   * @remarks
+   * The only way to obtain one. The caller takes on releasing its table row — in
+   * practice {@link SSSMaterial}, which disposes the profile with itself.
+   *
+   * @param preset - Preset to start from. Defaults to `'skin'`.
+   * @returns The new profile.
+   *
+   * @internal
+   */ static createOwned(preset = 'skin') {
+        return new SSSProfile(CREATE_TOKEN, preset);
+    }
+    /**
+   * The shared default skin profile.
+   *
+   * @remarks
+   * A fallback for consumers with no material to ask — the diffusion uses it for
+   * pixels whose id is not in the table. Created lazily, since it holds a table
+   * row for the lifetime of the process.
+   *
+   * @public
+   */ static getDefault() {
+        if (!this._defaultProfile) {
+            this._defaultProfile = new SSSProfile(CREATE_TOKEN, 'skin');
+        }
+        return this._defaultProfile;
+    }
+    /**
+   * Looks up a profile by its packed id.
+   *
+   * @param id - The profile id, as written to the per-pixel profile channel.
+   * @returns The profile, or `null` when the id is unused.
+   *
+   * @public
+   */ static getById(id) {
+        return id > 0 && id < SKIN_PROFILE_CAPACITY ? this._profiles[id] : null;
+    }
+    /**
+   * The packed parameter table, rebuilt when any profile has changed.
+   *
+   * @remarks
+   * Rows are indexed by profile id, columns by parameter group. The skin
+   * diffusion passes sample this to recover per-pixel scattering parameters.
+   *
+   * @param device - Device used to create and upload the table.
+   * @returns The table texture, or `null` when it could not be created.
+   *
+   * @public
+   */ static getTable(device) {
+        // The table is static and outlives any one device. A texture belonging to a
+        // dead device silently swallows every `update`, which strands the last values
+        // uploaded before the swap on screen until the page is reloaded.
+        if (this._table && (this._tableDevice !== device || this._table.disposed)) {
+            this._table = null;
+            this._tableData = null;
+        }
+        if (!this._table) {
+            this._table = device.createTexture2D('rgba32f', SKIN_PROFILE_COLUMNS, SKIN_PROFILE_CAPACITY, {
+                mipmapping: false,
+                samplerOptions: {
+                    minFilter: 'nearest',
+                    magFilter: 'nearest',
+                    mipFilter: 'none'
+                }
+            });
+            this._tableDevice = device;
+            this._tableData = new Float32Array(SKIN_PROFILE_COLUMNS * SKIN_PROFILE_CAPACITY * 4);
+            this._tableDirty = true;
+        }
+        if (this._tableDirty && this._table && this._tableData) {
+            this.packTable(this._tableData);
+            this._table.update(this._tableData, 0, 0, SKIN_PROFILE_COLUMNS, SKIN_PROFILE_CAPACITY);
+            this._tableDirty = false;
+        }
+        return this._table;
+    }
+    /** Number of parameter columns in the packed table. @public */ static get tableColumns() {
+        return SKIN_PROFILE_COLUMNS;
+    }
+    /**
+   * Column the baked transmission profile starts at.
+   *
+   * @public
+   */ static get transmissionLutOffset() {
+        return SKIN_PROFILE_PARAM_COLUMNS;
+    }
+    /**
+   * Column holding `(worldUnitScale, scatterScale, 0, 0)`.
+   *
+   * @remarks
+   * Read by the transmission thickness pass, which needs the world unit scale to
+   * size its normal shrink against the asset.
+   *
+   * @public
+   */ static get scalingParamColumn() {
+        return 0;
+    }
+    /**
+   * Column holding `(extinctionScale, normalScale, scatteringDistribution,
+   * 1 / ior)`.
+   *
+   * @public
+   */ static get transmissionParamColumn() {
+        return 4;
+    }
+    /** Number of entries in the baked transmission profile. @public */ static get transmissionLutSize() {
+        return SKIN_TRANSMISSION_LUT_SIZE;
+    }
+    /** Number of rows in the packed table. @public */ static get tableRows() {
+        return SKIN_PROFILE_CAPACITY;
+    }
+    /**
+   * The id this profile occupies in the packed table.
+   *
+   * @remarks
+   * Ids start at 1; 0 means "not skin" in the per-pixel profile channel. The
+   * material encodes this as `id / 255`.
+   *
+   * @public
+   */ get id() {
+        return this._id;
+    }
+    /** Normalized id as written to an 8-bit per-pixel channel. @public */ get encodedId() {
+        return this._id / 255;
+    }
+    /** The preset this profile was last initialized from. @public */ get preset() {
+        return this._preset;
+    }
+    set preset(val) {
+        if (val !== this._preset) {
+            this.applyPreset(val);
+        }
+    }
+    /**
+   * Per-channel scattering albedo.
+   *
+   * @remarks
+   * Drives Burley's shaping term `s = (albedo - 0.33)^4 * 100 + 3.5`, so values
+   * near 0.33 give the widest diffusion and values at either extreme tighten it.
+   *
+   * @public
+   */ get surfaceAlbedo() {
+        return this._surfaceAlbedo;
+    }
+    set surfaceAlbedo(val) {
+        if (!val.equalsTo(this._surfaceAlbedo)) {
+            this._surfaceAlbedo.set(val);
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Per-channel diffuse mean free path, as a ratio.
+   *
+   * @remarks
+   * Scaled by {@link SSSProfile.meanFreePathDistance} to reach world units. The
+   * red channel is normally much longer than blue, which is what makes thin
+   * geometry such as an ear rim glow red.
+   *
+   * @public
+   */ get meanFreePath() {
+        return this._meanFreePath;
+    }
+    set meanFreePath(val) {
+        if (!val.equalsTo(this._meanFreePath)) {
+            this._meanFreePath.set(val);
+            this.notifyChanged();
+        }
+    }
+    /** Mean free path of the widest channel, in profile space. @public */ get meanFreePathDistance() {
+        return this._meanFreePathDistance;
+    }
+    set meanFreePathDistance(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._meanFreePathDistance) {
+            this._meanFreePathDistance = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Profile-space to world-unit conversion, for scenes not authored in metres.
+   *
+   * @public
+   */ get worldUnitScale() {
+        return this._worldUnitScale;
+    }
+    set worldUnitScale(val) {
+        const next = Math.max(0.01, val ?? 1);
+        if (next !== this._worldUnitScale) {
+            this._worldUnitScale = next;
+            this.notifyChanged();
+        }
+    }
+    /** Overall multiplier on the diffusion width. @public */ get scatterScale() {
+        return this._scatterScale;
+    }
+    set scatterScale(val) {
+        const next = Math.max(0, val ?? 1);
+        if (next !== this._scatterScale) {
+            this._scatterScale = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Per-channel tint applied where two different profiles meet.
+   *
+   * @remarks
+   * Taps that belong to another profile are attenuated by this instead of being
+   * rejected outright, so a face/lip boundary softens rather than forming a seam.
+   *
+   * @public
+   */ get boundaryColorBleed() {
+        return this._boundaryColorBleed;
+    }
+    set boundaryColorBleed(val) {
+        if (!val.equalsTo(this._boundaryColorBleed)) {
+            this._boundaryColorBleed.set(val);
+            this.notifyChanged();
+        }
+    }
+    /** Tint applied to light transmitted through thin geometry. @public */ get transmissionTint() {
+        return this._transmissionTint;
+    }
+    set transmissionTint(val) {
+        if (!val.equalsTo(this._transmissionTint)) {
+            this._transmissionTint.set(val);
+            this.notifyChanged();
+        }
+    }
+    /** Extinction multiplier for transmission attenuation. @public */ get extinctionScale() {
+        return this._extinctionScale;
+    }
+    set extinctionScale(val) {
+        const next = Math.max(0, val ?? 1);
+        if (next !== this._extinctionScale) {
+            this._extinctionScale = next;
+            this.notifyChanged();
+        }
+    }
+    /** How much surface normal detail survives the diffusion. @public */ get normalScale() {
+        return this._normalScale;
+    }
+    set normalScale(val) {
+        const next = Math.max(0, val ?? 0);
+        if (next !== this._normalScale) {
+            this._normalScale = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Henyey-Greenstein asymmetry of the transmitted light, in `[-1, 1]`.
+   *
+   * @public
+   */ get scatteringDistribution() {
+        return this._scatteringDistribution;
+    }
+    set scatteringDistribution(val) {
+        const next = Math.min(1, Math.max(-1, val ?? 0));
+        if (next !== this._scatteringDistribution) {
+            this._scatteringDistribution = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Index of refraction used to bend the view ray before the phase function.
+   *
+   * @public
+   */ get ior() {
+        return this._ior;
+    }
+    set ior(val) {
+        const next = Math.min(3, Math.max(1, val ?? 1.55));
+        if (next !== this._ior) {
+            this._ior = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Multiplier on the material roughness for the narrow specular lobe.
+   *
+   * @public
+   */ get roughness0() {
+        return this._roughness0;
+    }
+    set roughness0(val) {
+        const next = Math.min(2, Math.max(0.5, val ?? 0.75));
+        if (next !== this._roughness0) {
+            this._roughness0 = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Multiplier on the material roughness for the wide specular lobe.
+   *
+   * @remarks
+   * Same scaling as {@link SSSProfile.roughness0}; skin's default 1.3 broadens
+   * the second lobe, giving it a soft sheen alongside the tighter highlight.
+   *
+   * @public
+   */ get roughness1() {
+        return this._roughness1;
+    }
+    set roughness1(val) {
+        const next = Math.min(2, Math.max(0.5, val ?? 1.3));
+        if (next !== this._roughness1) {
+            this._roughness1 = next;
+            this.notifyChanged();
+        }
+    }
+    /** Blend between the narrow and wide specular lobes. @public */ get lobeMix() {
+        return this._lobeMix;
+    }
+    set lobeMix(val) {
+        const next = Math.min(0.9, Math.max(0.1, val ?? 0.85));
+        if (next !== this._lobeMix) {
+            this._lobeMix = next;
+            this.notifyChanged();
+        }
+    }
+    /**
+   * Per-channel diffusion distance, in profile space.
+   *
+   * @returns Mean free path scaled by the profile's distance and scatter scale.
+   *
+   * @public
+   */ getScatterDistance() {
+        const s = this._meanFreePathDistance * this._scatterScale;
+        return new Vector3(this._meanFreePath.x * s, this._meanFreePath.y * s, this._meanFreePath.z * s);
+    }
+    /**
+   * Overwrites every parameter from another profile.
+   *
+   * @remarks
+   * The only way to transfer a look, since profiles cannot be shared or cloned.
+   * The table row is untouched: it identifies the profile, not its contents.
+   *
+   * @param other - Profile to copy the parameters from.
+   *
+   * @public
+   */ copyFrom(other) {
+        this._preset = other._preset;
+        this._surfaceAlbedo.set(other._surfaceAlbedo);
+        this._meanFreePath.set(other._meanFreePath);
+        this._boundaryColorBleed.set(other._boundaryColorBleed);
+        this._transmissionTint.set(other._transmissionTint);
+        this._meanFreePathDistance = other._meanFreePathDistance;
+        this._worldUnitScale = other._worldUnitScale;
+        this._scatterScale = other._scatterScale;
+        this._extinctionScale = other._extinctionScale;
+        this._normalScale = other._normalScale;
+        this._scatteringDistribution = other._scatteringDistribution;
+        this._ior = other._ior;
+        this._roughness0 = other._roughness0;
+        this._roughness1 = other._roughness1;
+        this._lobeMix = other._lobeMix;
+        this.notifyChanged();
+    }
+    /**
+   * Releases this profile's table slot.
+   *
+   * @public
+   */ dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        if (SSSProfile._profiles[this._id] === this) {
+            SSSProfile._profiles[this._id] = null;
+            SSSProfile.markDirty();
+        }
+    }
+    applyPreset(preset) {
+        const t = SKIN_PROFILE_TEMPLATES[preset] ?? SKIN_PROFILE_TEMPLATES.skin;
+        this._preset = preset;
+        this._surfaceAlbedo.setXYZ(t.surfaceAlbedo[0], t.surfaceAlbedo[1], t.surfaceAlbedo[2]);
+        this._meanFreePath.setXYZ(t.meanFreePath[0], t.meanFreePath[1], t.meanFreePath[2]);
+        this._boundaryColorBleed.setXYZ(t.boundaryColorBleed[0], t.boundaryColorBleed[1], t.boundaryColorBleed[2]);
+        this._transmissionTint.setXYZ(t.transmissionTint[0], t.transmissionTint[1], t.transmissionTint[2]);
+        this._meanFreePathDistance = t.meanFreePathDistance;
+        this._worldUnitScale = t.worldUnitScale;
+        this._scatterScale = t.scatterScale;
+        this._extinctionScale = t.extinctionScale;
+        this._normalScale = t.normalScale;
+        this._scatteringDistribution = t.scatteringDistribution;
+        this._ior = t.ior;
+        this._roughness0 = t.roughness0;
+        this._roughness1 = t.roughness1;
+        this._lobeMix = t.lobeMix;
+        this.notifyChanged();
+    }
+    static allocateId(profile) {
+        for(let i = 1; i < SKIN_PROFILE_CAPACITY; i++){
+            if (!this._profiles[i]) {
+                this._profiles[i] = profile;
+                this.markDirty();
+                return i;
+            }
+        }
+        throw new Error('SSSProfile limit exceeded');
+    }
+    static markDirty() {
+        this._tableDirty = true;
+    }
+    /**
+   * Flags the packed table for a rebuild and notifies materials using this
+   * profile so they can refresh their uniforms.
+   */ notifyChanged() {
+        SSSProfile.markDirty();
+        this._changeListeners.forEach((listener)=>listener());
+    }
+    static packTable(out) {
+        out.fill(0);
+        const stride = SKIN_PROFILE_COLUMNS * 4;
+        for(let id = 1; id < SKIN_PROFILE_CAPACITY; id++){
+            const p = this._profiles[id];
+            if (!p) {
+                continue;
+            }
+            const row = id * stride;
+            const write = (column, x, y, z, w)=>{
+                const o = row + column * 4;
+                out[o] = x;
+                out[o + 1] = y;
+                out[o + 2] = z;
+                out[o + 3] = w;
+            };
+            const d = p.getScatterDistance();
+            const widest = Math.max(d.x, d.y, d.z);
+            const albedoForSampling = widest > 0 ? [
+                p._surfaceAlbedo.x,
+                p._surfaceAlbedo.y,
+                p._surfaceAlbedo.z
+            ][[
+                d.x,
+                d.y,
+                d.z
+            ].indexOf(widest)] : p._surfaceAlbedo.x;
+            write(0, p._worldUnitScale, p._scatterScale, 0, 0);
+            write(1, p._surfaceAlbedo.x, p._surfaceAlbedo.y, p._surfaceAlbedo.z, albedoForSampling);
+            write(2, d.x, d.y, d.z, widest);
+            write(3, p._boundaryColorBleed.x, p._boundaryColorBleed.y, p._boundaryColorBleed.z, 0);
+            write(4, p._extinctionScale, p._normalScale, p._scatteringDistribution, 1 / Math.max(p._ior, 1e-4));
+            write(5, p._roughness0, p._roughness1, p._lobeMix, 0);
+            // The LUT columns are consecutive within the row, so the baked profile
+            // drops straight in after the scalar parameters.
+            p.writeTransmissionProfile(out, row + SKIN_PROFILE_PARAM_COLUMNS * 4);
+        }
+    }
+    /**
+   * Bakes this profile's transmission table.
+   *
+   * @param out - Destination, `4 x transmissionLutSize` floats from `offset`.
+   * @param offset - Index of the first float to write.
+   *
+   * @public
+   */ writeTransmissionProfile(out, offset = 0) {
+        const invUnitScale = 1 / Math.max(this._worldUnitScale, 1e-4);
+        const d = this.getScatterDistance();
+        const l = [
+            d.x * WORLD_UNITS_TO_PROFILE_MM,
+            d.y * WORLD_UNITS_TO_PROFILE_MM,
+            d.z * WORLD_UNITS_TO_PROFILE_MM
+        ];
+        const s = [
+            searchLightDiffuseScalingFactor(this._surfaceAlbedo.x),
+            searchLightDiffuseScalingFactor(this._surfaceAlbedo.y),
+            searchLightDiffuseScalingFactor(this._surfaceAlbedo.z)
+        ];
+        const tint = [
+            this._transmissionTint.x,
+            this._transmissionTint.y,
+            this._transmissionTint.z
+        ];
+        const offsetMM = TRANSMISSION_LUT_RADIUS_OFFSET_MM * invUnitScale;
+        for(let i = 0; i < SKIN_TRANSMISSION_LUT_SIZE; i++){
+            const o = offset + i * 4;
+            if (i === SKIN_TRANSMISSION_LUT_SIZE - 1) {
+                out[o] = 0;
+                out[o + 1] = 0;
+                out[o + 2] = 0;
+                out[o + 3] = 0;
+                break;
+            }
+            const distanceMM = i / SKIN_TRANSMISSION_LUT_SIZE * TRANSMISSION_LUT_MAX_DISTANCE_MM * invUnitScale;
+            const r = distanceMM + offsetMM;
+            for(let c = 0; c < 3; c++){
+                out[o + c] = l[c] > 0 ? 0.25 * (Math.exp(-s[c] * r / l[c]) + 3 * Math.exp(-s[c] * r / (3 * l[c]))) * tint[c] : 0;
+            }
+            out[o + 3] = Math.exp(-distanceMM * this._extinctionScale);
+        }
+    }
+}
+
+export { SKIN_MAX_TRANSMISSION_OPTICAL_DEPTH, SKIN_OPTICAL_DEPTH_PER_WORLD_UNIT, SKIN_TRANSMISSION_NO_DATA_ENCODING, SKIN_TRANSMISSION_OPTICAL_DEPTH_BIAS, SKIN_TRANSMISSION_OPTICAL_DEPTH_FLOOR, SSSProfile };
+//# sourceMappingURL=sssprofile.js.map