@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/material/sss_kernel.js

@@ -0,0 +1,265 @@
+import { Vector3 } from '@zephyr3d/base';
+
+/**
+ * Taps stored per profile in the kernel LUT, per side of the kernel centre.
+ *
+ * The full separable kernel is `2 * SSS_KERNEL_TAPS_PER_SIDE + 1` wide. Unreal's
+ * separable path uses 13 + 9 + 6 taps across its three kernels; this is the same
+ * order of magnitude, and the quality presets stride across it rather than
+ * baking a different table per preset.
+ */ const SSS_KERNEL_TAPS_PER_SIDE = 15;
+/**
+ * Entries in a baked kernel row: the centre tap plus one side.
+ *
+ * Only half the kernel is stored because it is symmetric about its centre and
+ * the shader mirrors each tap as it walks outwards. The weights are normalized
+ * for the *full* mirrored kernel, so a consumer that does not mirror would come
+ * out half as bright.
+ */ const SSS_KERNEL_TAPS = SSS_KERNEL_TAPS_PER_SIDE + 1;
+/**
+ * Entries in a baked transmission table.
+ *
+ * Unreal's own is 32 wide, which its capture shows holding a per-channel
+ * Beer-Lambert falloff sampled across thickness. Matching the width is not the
+ * point - it is simply enough resolution for a curve this smooth.
+ */ const SSS_TRANSMISSION_SAMPLES = 32;
+/**
+ * Columns of the kernel LUT that precede the baked taps.
+ *
+ * One, holding `(diffusionWorldRadius, transmissionMaxThickness, 0, 0)` - the
+ * two scales the rest of the row is measured against. Named because the baker
+ * writes it and the shader reads it, and an off-by-one between them silently
+ * reads a weight as a radius.
+ */ const SSS_KERNEL_LUT_HEADER_COLUMNS = 1;
+/**
+ * Christensen-Burley shaping parameter.
+ *
+ * The "diffusion" fit rather than the "searchlight" one, matching what Unreal
+ * uses: searchlight is the better match to ground truth for a pencil beam, but
+ * diffusion is what a screen-space pass actually approximates, and mixing the
+ * two is how a profile ends up looking right in isolation and wrong in a scene.
+ */ function burleyScaling(albedo) {
+    const a = Math.min(Math.max(albedo, 0), 1);
+    return 1.9 - a + 3.5 * (a - 0.8) * (a - 0.8);
+}
+/**
+ * Radially symmetric Burley reflectance profile, without the `1/r` Jacobian.
+ *
+ * `R(r) = (e^(-r/d) + e^(-r/(3d))) / (8*pi*d*r)`
+ *
+ * The `1/r` term converts the 1D profile into a 2D disc density. A separable
+ * screen-space blur integrates along a line rather than over a disc, so it is
+ * dropped and the weights are renormalized by their own sum instead - the same
+ * approximation `burleyDiffusionWeight` in `shaders/diffusion.ts` documents, and
+ * it has to be the same one or the two paths would disagree about what a profile
+ * means. The constant factor goes with it, since normalization removes it.
+ */ function burleyProfile(r, d) {
+    const safeD = Math.max(d, 1e-6);
+    const x = Math.abs(r) / safeD;
+    return (Math.exp(-Math.min(x, 40)) + Math.exp(-Math.min(x / 3, 40))) / safeD;
+}
+/**
+ * Inverse of the Burley CDF, `F(r) = 1 - e^(-r/d)/4 - 3*e^(-r/(3d))/4`.
+ *
+ * Solved by bisection rather than Newton: the derivative is well behaved but the
+ * CDF flattens hard in the tail, and a Newton step from a poor bracket there
+ * overshoots into negative radii. This runs once per profile change, so twenty
+ * bisection steps cost nothing worth optimizing.
+ */ function invertBurleyCdf(u, d) {
+    const target = Math.min(Math.max(u, 0), 0.999);
+    const cdf = (r)=>1 - 0.25 * Math.exp(-r / d) - 0.75 * Math.exp(-r / (3 * d));
+    let lo = 0;
+    // The profile has unbounded support; 24d carries >99.9% of the energy.
+    let hi = d * 24;
+    for(let i = 0; i < 40; i++){
+        const mid = (lo + hi) * 0.5;
+        if (cdf(mid) < target) {
+            lo = mid;
+        } else {
+            hi = mid;
+        }
+    }
+    return (lo + hi) * 0.5;
+}
+/**
+ * Pre-integrates a profile into the separable kernel the SSS blur passes sample.
+ *
+ * Why this runs on the CPU at all: the kernel is a function of the profile and
+ * nothing else, profiles change when someone drags a slider, and the alternative
+ * is two `exp` calls per tap per channel per pixel per pass. It is also how
+ * Unreal does it - the `SSProfiles` texture in a UE capture holds baked weights,
+ * not profile parameters - and matching that is the point of the exercise.
+ *
+ * Sample placement is importance-sampled against the profile's own CDF, so taps
+ * cluster where the energy is and thin out in the tail. A uniform placement
+ * spends most of its taps on the tail, which is both where the profile is
+ * flattest and where the depth-aware rejection is most likely to throw the tap
+ * away.
+ *
+ * @param profile - Profile to bake.
+ * @param tapsPerSide - Taps per side; the returned kernel has `n+1` entries.
+ * @returns Half the kernel: entry 0 is the centre, entries 1..n walk outwards
+ *   with increasing positive offsets. Offsets are normalized against the widest
+ *   channel radius, so the shader scales them by one screen-space radius and
+ *   mirrors each one.
+ *
+ * @internal
+ */ function bakeSubsurfaceKernel(profile, tapsPerSide = SSS_KERNEL_TAPS_PER_SIDE) {
+    const albedo = profile.surfaceAlbedo;
+    const mfpColor = profile.meanFreePathColor;
+    const mfpDistance = Math.max(profile.meanFreePathDistance, 0);
+    // Per-channel shaping distance. Kept in millimetres throughout: the offsets
+    // come out normalized, so the only thing that matters here is the ratio
+    // between channels and the ratio of each to the widest.
+    const d = [
+        Math.max(mfpColor.x, 0) * mfpDistance / burleyScaling(albedo.x),
+        Math.max(mfpColor.y, 0) * mfpDistance / burleyScaling(albedo.y),
+        Math.max(mfpColor.z, 0) * mfpDistance / burleyScaling(albedo.z)
+    ];
+    const maxD = Math.max(d[0], d[1], d[2]);
+    const taps = [];
+    if (maxD <= 1e-6) {
+        // Degenerate profile: a single centre tap is an exact identity kernel, which
+        // is the right answer for "no scattering" and keeps the LUT well-formed.
+        taps.push({
+            offset: 0,
+            weight: [
+                1,
+                1,
+                1
+            ]
+        });
+        for(let i = 0; i < tapsPerSide; i++){
+            taps.push({
+                offset: 0,
+                weight: [
+                    0,
+                    0,
+                    0
+                ]
+            });
+        }
+        return {
+            taps,
+            worldRadius: 0
+        };
+    }
+    // Importance-sample the widest channel: it is the one that sets the extent, so
+    // its CDF is what places taps where any channel still has energy. Sampling
+    // each channel's own CDF would need a different offset per channel, which a
+    // single texture fetch per tap cannot express.
+    const offsets = [
+        0
+    ];
+    for(let i = 1; i <= tapsPerSide; i++){
+        // Stratified midpoints over the half-profile. The last stratum stops short
+        // of 1 because the CDF's inverse diverges there.
+        const u = (i - 0.5) / tapsPerSide;
+        offsets.push(invertBurleyCdf(u * 0.97, maxD));
+    }
+    const scale = 1 / offsets[offsets.length - 1];
+    const sum = [
+        0,
+        0,
+        0
+    ];
+    const halfWeights = [];
+    for(let i = 0; i < offsets.length; i++){
+        // Each tap stands for the span between its neighbours' midpoints, so a
+        // sparse tail tap carries proportionally more energy than a dense centre
+        // one. Without this the tail is under-weighted by exactly the factor the
+        // importance sampling spread it by.
+        const prev = i > 0 ? offsets[i - 1] : -offsets[1];
+        const next = i < offsets.length - 1 ? offsets[i + 1] : offsets[i] + (offsets[i] - prev);
+        const span = (next - prev) * 0.5;
+        const w = [
+            burleyProfile(offsets[i], d[0]) * span,
+            burleyProfile(offsets[i], d[1]) * span,
+            burleyProfile(offsets[i], d[2]) * span
+        ];
+        halfWeights.push(w);
+        // The centre tap appears once, every other tap is mirrored.
+        const multiplicity = i === 0 ? 1 : 2;
+        sum[0] += w[0] * multiplicity;
+        sum[1] += w[1] * multiplicity;
+        sum[2] += w[2] * multiplicity;
+    }
+    const norm = [
+        sum[0] > 1e-12 ? 1 / sum[0] : 0,
+        sum[1] > 1e-12 ? 1 / sum[1] : 0,
+        sum[2] > 1e-12 ? 1 / sum[2] : 0
+    ];
+    for(let i = 0; i <= tapsPerSide; i++){
+        const w = halfWeights[i];
+        taps.push({
+            offset: offsets[i] * scale,
+            weight: [
+                w[0] * norm[0],
+                w[1] * norm[1],
+                w[2] * norm[2]
+            ]
+        });
+    }
+    // Offsets were normalized against the outermost tap, so that tap's position -
+    // in millimetres - is what ±1 stands for. Converting it here is what keeps the
+    // definition of "one radius" in one place.
+    return {
+        taps,
+        worldRadius: offsets[offsets.length - 1] * profile.worldUnitsPerMillimetre
+    };
+}
+const tmpExtinction = new Vector3();
+/**
+ * Pre-integrates a profile's Beer-Lambert transmission falloff.
+ *
+ * `T_c(t) = exp(-sigma_c * t)`, where sigma comes from the profile's own mean
+ * free path. The channel spread is where the look comes from: for skin the red
+ * coefficient is several times smaller than blue's, so light that has crossed a
+ * finger or an earlobe arrives red no matter what colour it started as.
+ *
+ * Samples are spaced geometrically rather than uniformly. The curve is an
+ * exponential, so a uniform spacing would spend most of its entries on a tail
+ * that has already decayed to nothing while under-resolving the thin end - and
+ * the thin end is the only part that is bright enough to see.
+ *
+ * @param profile - Profile to bake.
+ * @param sampleCount - Entries in the returned table.
+ * @returns The table and the thickness its last entry stands for.
+ *
+ * @internal
+ */ function bakeTransmissionLUT(profile, sampleCount = SSS_TRANSMISSION_SAMPLES) {
+    const sigma = profile.getExtinctionCoefficient(tmpExtinction);
+    // Range out to where even the least-absorbed channel has gone dark. exp(-8) is
+    // about 3e-4, which is below anything an 8-bit display resolves, so carrying
+    // the table further would only add entries that are all zero.
+    const minSigma = Math.max(Math.min(sigma.x, sigma.y, sigma.z), 1e-6);
+    const maxThickness = 8 / minSigma;
+    const samples = [];
+    for(let i = 0; i < sampleCount; i++){
+        // Geometric from a small fraction of the range up to all of it, with the
+        // first entry pinned at zero thickness so the table starts at full
+        // transmission exactly rather than nearly.
+        const t = i === 0 ? 0 : maxThickness * Math.pow(SSS_TRANSMISSION_MIN_RATIO, 1 - (i - 1) / Math.max(sampleCount - 2, 1));
+        samples.push([
+            Math.exp(-Math.min(sigma.x * t, 80)),
+            Math.exp(-Math.min(sigma.y * t, 80)),
+            Math.exp(-Math.min(sigma.z * t, 80))
+        ]);
+    }
+    return {
+        samples,
+        maxThickness
+    };
+}
+/**
+ * Ratio of the thinnest non-zero entry in the transmission table to the thickest.
+ *
+ * Exported because the shader has to invert the baker's spacing to look the
+ * table up, and the two are one mapping written twice: a reader that assumed
+ * uniform spacing would find the right table at the wrong index.
+ *
+ * @internal
+ */ const SSS_TRANSMISSION_MIN_RATIO = 1 / 512;
+
+export { SSS_KERNEL_LUT_HEADER_COLUMNS, SSS_KERNEL_TAPS, SSS_KERNEL_TAPS_PER_SIDE, SSS_TRANSMISSION_MIN_RATIO, SSS_TRANSMISSION_SAMPLES, bakeSubsurfaceKernel, bakeTransmissionLUT };
+//# sourceMappingURL=sss_kernel.js.map

package/dist/material/sss_kernel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sss_kernel.js","sources":["../../src/material/sss_kernel.ts"],"sourcesContent":["import { Vector3 } from '@zephyr3d/base';\nimport type { SubsurfaceProfile } from './subsurfaceprofile';\n\n/**\n * Taps stored per profile in the kernel LUT, per side of the kernel centre.\n *\n * The full separable kernel is `2 * SSS_KERNEL_TAPS_PER_SIDE + 1` wide. Unreal's\n * separable path uses 13 + 9 + 6 taps across its three kernels; this is the same\n * order of magnitude, and the quality presets stride across it rather than\n * baking a different table per preset.\n */\nexport const SSS_KERNEL_TAPS_PER_SIDE = 15;\n\n/**\n * Entries in a baked kernel row: the centre tap plus one side.\n *\n * Only half the kernel is stored because it is symmetric about its centre and\n * the shader mirrors each tap as it walks outwards. The weights are normalized\n * for the *full* mirrored kernel, so a consumer that does not mirror would come\n * out half as bright.\n */\nexport const SSS_KERNEL_TAPS = SSS_KERNEL_TAPS_PER_SIDE + 1;\n\n/** One pre-integrated tap: where to sample, and how much of each channel to take. */\nexport interface SubsurfaceKernelTap {\n  /** Offset from the kernel centre, normalized so 1 is the profile's widest channel radius. */\n  offset: number;\n  /** Per-channel weight, normalized so the full mirrored kernel sums to one per channel. */\n  weight: [number, number, number];\n}\n\n/** A baked kernel and the world-space distance its normalized offsets are measured against. */\nexport interface SubsurfaceKernel {\n  taps: SubsurfaceKernelTap[];\n  /**\n   * World-space distance corresponding to a normalized offset of 1 - the radius\n   * the blur pass projects into screen space. Returned alongside the taps rather\n   * than recomputed by the caller so the two cannot disagree about what ±1 means.\n   */\n  worldRadius: number;\n}\n\n/**\n * Entries in a baked transmission table.\n *\n * Unreal's own is 32 wide, which its capture shows holding a per-channel\n * Beer-Lambert falloff sampled across thickness. Matching the width is not the\n * point - it is simply enough resolution for a curve this smooth.\n */\nexport const SSS_TRANSMISSION_SAMPLES = 32;\n\n/**\n * Columns of the kernel LUT that precede the baked taps.\n *\n * One, holding `(diffusionWorldRadius, transmissionMaxThickness, 0, 0)` - the\n * two scales the rest of the row is measured against. Named because the baker\n * writes it and the shader reads it, and an off-by-one between them silently\n * reads a weight as a radius.\n */\nexport const SSS_KERNEL_LUT_HEADER_COLUMNS = 1;\n\n/** A baked transmission table and the thickness range it spans. */\nexport interface SubsurfaceTransmission {\n  /** `exp(-sigma * t)` per channel, from `t = 0` out to `maxThickness`. */\n  samples: Array<[number, number, number]>;\n  /**\n   * Thickness, in world units, at which the table ends. The shader normalizes\n   * its measured thickness against this before looking up, so it is what the\n   * last entry means.\n   */\n  maxThickness: number;\n}\n\n/**\n * Christensen-Burley shaping parameter.\n *\n * The \"diffusion\" fit rather than the \"searchlight\" one, matching what Unreal\n * uses: searchlight is the better match to ground truth for a pencil beam, but\n * diffusion is what a screen-space pass actually approximates, and mixing the\n * two is how a profile ends up looking right in isolation and wrong in a scene.\n */\nfunction burleyScaling(albedo: number): number {\n  const a = Math.min(Math.max(albedo, 0), 1);\n  return 1.9 - a + 3.5 * (a - 0.8) * (a - 0.8);\n}\n\n/**\n * Radially symmetric Burley reflectance profile, without the `1/r` Jacobian.\n *\n * `R(r) = (e^(-r/d) + e^(-r/(3d))) / (8*pi*d*r)`\n *\n * The `1/r` term converts the 1D profile into a 2D disc density. A separable\n * screen-space blur integrates along a line rather than over a disc, so it is\n * dropped and the weights are renormalized by their own sum instead - the same\n * approximation `burleyDiffusionWeight` in `shaders/diffusion.ts` documents, and\n * it has to be the same one or the two paths would disagree about what a profile\n * means. The constant factor goes with it, since normalization removes it.\n */\nfunction burleyProfile(r: number, d: number): number {\n  const safeD = Math.max(d, 1e-6);\n  const x = Math.abs(r) / safeD;\n  return (Math.exp(-Math.min(x, 40)) + Math.exp(-Math.min(x / 3, 40))) / safeD;\n}\n\n/**\n * Inverse of the Burley CDF, `F(r) = 1 - e^(-r/d)/4 - 3*e^(-r/(3d))/4`.\n *\n * Solved by bisection rather than Newton: the derivative is well behaved but the\n * CDF flattens hard in the tail, and a Newton step from a poor bracket there\n * overshoots into negative radii. This runs once per profile change, so twenty\n * bisection steps cost nothing worth optimizing.\n */\nfunction invertBurleyCdf(u: number, d: number): number {\n  const target = Math.min(Math.max(u, 0), 0.999);\n  const cdf = (r: number) => 1 - 0.25 * Math.exp(-r / d) - 0.75 * Math.exp(-r / (3 * d));\n  let lo = 0;\n  // The profile has unbounded support; 24d carries >99.9% of the energy.\n  let hi = d * 24;\n  for (let i = 0; i < 40; i++) {\n    const mid = (lo + hi) * 0.5;\n    if (cdf(mid) < target) {\n      lo = mid;\n    } else {\n      hi = mid;\n    }\n  }\n  return (lo + hi) * 0.5;\n}\n\n/**\n * Pre-integrates a profile into the separable kernel the SSS blur passes sample.\n *\n * Why this runs on the CPU at all: the kernel is a function of the profile and\n * nothing else, profiles change when someone drags a slider, and the alternative\n * is two `exp` calls per tap per channel per pixel per pass. It is also how\n * Unreal does it - the `SSProfiles` texture in a UE capture holds baked weights,\n * not profile parameters - and matching that is the point of the exercise.\n *\n * Sample placement is importance-sampled against the profile's own CDF, so taps\n * cluster where the energy is and thin out in the tail. A uniform placement\n * spends most of its taps on the tail, which is both where the profile is\n * flattest and where the depth-aware rejection is most likely to throw the tap\n * away.\n *\n * @param profile - Profile to bake.\n * @param tapsPerSide - Taps per side; the returned kernel has `n+1` entries.\n * @returns Half the kernel: entry 0 is the centre, entries 1..n walk outwards\n *   with increasing positive offsets. Offsets are normalized against the widest\n *   channel radius, so the shader scales them by one screen-space radius and\n *   mirrors each one.\n *\n * @internal\n */\nexport function bakeSubsurfaceKernel(\n  profile: SubsurfaceProfile,\n  tapsPerSide = SSS_KERNEL_TAPS_PER_SIDE\n): SubsurfaceKernel {\n  const albedo = profile.surfaceAlbedo;\n  const mfpColor = profile.meanFreePathColor;\n  const mfpDistance = Math.max(profile.meanFreePathDistance, 0);\n\n  // Per-channel shaping distance. Kept in millimetres throughout: the offsets\n  // come out normalized, so the only thing that matters here is the ratio\n  // between channels and the ratio of each to the widest.\n  const d: [number, number, number] = [\n    (Math.max(mfpColor.x, 0) * mfpDistance) / burleyScaling(albedo.x),\n    (Math.max(mfpColor.y, 0) * mfpDistance) / burleyScaling(albedo.y),\n    (Math.max(mfpColor.z, 0) * mfpDistance) / burleyScaling(albedo.z)\n  ];\n  const maxD = Math.max(d[0], d[1], d[2]);\n  const taps: SubsurfaceKernelTap[] = [];\n\n  if (maxD <= 1e-6) {\n    // Degenerate profile: a single centre tap is an exact identity kernel, which\n    // is the right answer for \"no scattering\" and keeps the LUT well-formed.\n    taps.push({ offset: 0, weight: [1, 1, 1] });\n    for (let i = 0; i < tapsPerSide; i++) {\n      taps.push({ offset: 0, weight: [0, 0, 0] });\n    }\n    return { taps, worldRadius: 0 };\n  }\n\n  // Importance-sample the widest channel: it is the one that sets the extent, so\n  // its CDF is what places taps where any channel still has energy. Sampling\n  // each channel's own CDF would need a different offset per channel, which a\n  // single texture fetch per tap cannot express.\n  const offsets: number[] = [0];\n  for (let i = 1; i <= tapsPerSide; i++) {\n    // Stratified midpoints over the half-profile. The last stratum stops short\n    // of 1 because the CDF's inverse diverges there.\n    const u = (i - 0.5) / tapsPerSide;\n    offsets.push(invertBurleyCdf(u * 0.97, maxD));\n  }\n\n  const scale = 1 / offsets[offsets.length - 1];\n  const sum: [number, number, number] = [0, 0, 0];\n  const halfWeights: Array<[number, number, number]> = [];\n\n  for (let i = 0; i < offsets.length; i++) {\n    // Each tap stands for the span between its neighbours' midpoints, so a\n    // sparse tail tap carries proportionally more energy than a dense centre\n    // one. Without this the tail is under-weighted by exactly the factor the\n    // importance sampling spread it by.\n    const prev = i > 0 ? offsets[i - 1] : -offsets[1];\n    const next = i < offsets.length - 1 ? offsets[i + 1] : offsets[i] + (offsets[i] - prev);\n    const span = (next - prev) * 0.5;\n    const w: [number, number, number] = [\n      burleyProfile(offsets[i], d[0]) * span,\n      burleyProfile(offsets[i], d[1]) * span,\n      burleyProfile(offsets[i], d[2]) * span\n    ];\n    halfWeights.push(w);\n    // The centre tap appears once, every other tap is mirrored.\n    const multiplicity = i === 0 ? 1 : 2;\n    sum[0] += w[0] * multiplicity;\n    sum[1] += w[1] * multiplicity;\n    sum[2] += w[2] * multiplicity;\n  }\n\n  const norm: [number, number, number] = [\n    sum[0] > 1e-12 ? 1 / sum[0] : 0,\n    sum[1] > 1e-12 ? 1 / sum[1] : 0,\n    sum[2] > 1e-12 ? 1 / sum[2] : 0\n  ];\n\n  for (let i = 0; i <= tapsPerSide; i++) {\n    const w = halfWeights[i];\n    taps.push({\n      offset: offsets[i] * scale,\n      weight: [w[0] * norm[0], w[1] * norm[1], w[2] * norm[2]]\n    });\n  }\n\n  // Offsets were normalized against the outermost tap, so that tap's position -\n  // in millimetres - is what ±1 stands for. Converting it here is what keeps the\n  // definition of \"one radius\" in one place.\n  return { taps, worldRadius: offsets[offsets.length - 1] * profile.worldUnitsPerMillimetre };\n}\n\nconst tmpExtinction = new Vector3();\n\n/**\n * Pre-integrates a profile's Beer-Lambert transmission falloff.\n *\n * `T_c(t) = exp(-sigma_c * t)`, where sigma comes from the profile's own mean\n * free path. The channel spread is where the look comes from: for skin the red\n * coefficient is several times smaller than blue's, so light that has crossed a\n * finger or an earlobe arrives red no matter what colour it started as.\n *\n * Samples are spaced geometrically rather than uniformly. The curve is an\n * exponential, so a uniform spacing would spend most of its entries on a tail\n * that has already decayed to nothing while under-resolving the thin end - and\n * the thin end is the only part that is bright enough to see.\n *\n * @param profile - Profile to bake.\n * @param sampleCount - Entries in the returned table.\n * @returns The table and the thickness its last entry stands for.\n *\n * @internal\n */\nexport function bakeTransmissionLUT(\n  profile: SubsurfaceProfile,\n  sampleCount = SSS_TRANSMISSION_SAMPLES\n): SubsurfaceTransmission {\n  const sigma = profile.getExtinctionCoefficient(tmpExtinction);\n  // Range out to where even the least-absorbed channel has gone dark. exp(-8) is\n  // about 3e-4, which is below anything an 8-bit display resolves, so carrying\n  // the table further would only add entries that are all zero.\n  const minSigma = Math.max(Math.min(sigma.x, sigma.y, sigma.z), 1e-6);\n  const maxThickness = 8 / minSigma;\n  const samples: Array<[number, number, number]> = [];\n\n  for (let i = 0; i < sampleCount; i++) {\n    // Geometric from a small fraction of the range up to all of it, with the\n    // first entry pinned at zero thickness so the table starts at full\n    // transmission exactly rather than nearly.\n    const t =\n      i === 0\n        ? 0\n        : maxThickness * Math.pow(SSS_TRANSMISSION_MIN_RATIO, 1 - (i - 1) / Math.max(sampleCount - 2, 1));\n    samples.push([\n      Math.exp(-Math.min(sigma.x * t, 80)),\n      Math.exp(-Math.min(sigma.y * t, 80)),\n      Math.exp(-Math.min(sigma.z * t, 80))\n    ]);\n  }\n\n  return { samples, maxThickness };\n}\n\n/**\n * Ratio of the thinnest non-zero entry in the transmission table to the thickest.\n *\n * Exported because the shader has to invert the baker's spacing to look the\n * table up, and the two are one mapping written twice: a reader that assumed\n * uniform spacing would find the right table at the wrong index.\n *\n * @internal\n */\nexport const SSS_TRANSMISSION_MIN_RATIO = 1 / 512;\n"],"names":["SSS_KERNEL_TAPS_PER_SIDE","SSS_KERNEL_TAPS","SSS_TRANSMISSION_SAMPLES","SSS_KERNEL_LUT_HEADER_COLUMNS","burleyScaling","albedo","a","Math","min","max","burleyProfile","r","d","safeD","x","abs","exp","invertBurleyCdf","u","target","cdf","lo","hi","i","mid","bakeSubsurfaceKernel","profile","tapsPerSide","surfaceAlbedo","mfpColor","meanFreePathColor","mfpDistance","meanFreePathDistance","y","z","maxD","taps","push","offset","weight","worldRadius","offsets","scale","length","sum","halfWeights","prev","next","span","w","multiplicity","norm","worldUnitsPerMillimetre","tmpExtinction","Vector3","bakeTransmissionLUT","sampleCount","sigma","getExtinctionCoefficient","minSigma","maxThickness","samples","t","pow","SSS_TRANSMISSION_MIN_RATIO"],"mappings":"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"}