@woosh/meep-engine 2.164.0 → 2.165.0

package/src/engine/graphics/sh3/lightmap/lightmap_gather.js

@@ -0,0 +1,168 @@
+import { rgb_to_luminance } from "../../../../core/color/rgb_to_luminance.js";
+import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { ray3_compose_array } from "../../../../core/geom/3d/ray/ray3_compose_array.js";
+import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
+import { v3_matrix3_rotate } from "../../../../core/geom/vec3/v3_matrix3_rotate.js";
+import { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
+import { getBiasedNormalSample } from "../path_tracer/sampling/getBiasedNormalSample.js";
+
+const _ray = new Ray3();
+const _normal = new Float32Array(3);
+const _dir = new Float32Array(3);
+const _radiance = new Float32Array(3);
+const _hit = new Float32Array(16);
+const _basis = new Float32Array(9);
+const _tangent = new Float32Array(3);
+const _bitangent = new Float32Array(3);
+
+/**
+ * Estimate the lightmap value at a single surface point in **mixed mode**: the
+ * cosine-weighted average incoming radiance — indirect bounces + sky only (direct
+ * light is supplied at render time by the realtime lights, not baked).
+ *
+ * Reuses {@link PathTracer#path_trace} along cosine-weighted hemisphere directions
+ * ({@link getBiasedNormalSample}, power 1) — bounced light, emissive surfaces, and
+ * the environment. Each texel draws its own independent random directions (no fixed
+ * sample set is shared between texels, which would otherwise show as structured
+ * bias on flat surfaces).
+ *
+ * **Supersampling:** each sample's ray ORIGIN is jittered within the texel's world
+ * footprint (in the surface tangent plane, magnitude `cfg.supersample × texel`), so
+ * a texel straddling a shadow boundary or silhouette averages lit/occluded
+ * sub-positions into a soft gradient instead of a hard one-texel line.
+ *
+ * Also produces two auxiliary signals used by the baker:
+ *  - the **variance of the mean** (luminance), written to `out[3]`, which drives
+ *    the variance-guided denoiser;
+ *  - a **confidence** in [0,1] (the return value): `1 - (fraction of short probes
+ *    that hit a BACK face)`. Flags only buried/wrong-side points; an enclosed-room
+ *    floor (front faces all around) stays confident. `cfg.confidence_probes === 0`
+ *    disables it (confidence 1).
+ *
+ * The stored radiance is `E / π` (cosine-weighted mean); three.js's lightmap path
+ * multiplies it back by `π · albedo / π = albedo`, preserving surface colour.
+ *
+ * @param {Float32Array|number[]} out 4 channels written: linear r, g, b, luminance variance-of-mean
+ * @param {number} px world-space point x (already nudged off the surface)
+ * @param {number} py world-space point y
+ * @param {number} pz world-space point z
+ * @param {number} nx world-space surface normal x (unit)
+ * @param {number} ny world-space surface normal y
+ * @param {number} nz world-space surface normal z
+ * @param {number} texel_world_size world-space size of one lightmap texel at this point
+ * @param {PathTracedScene} scene
+ * @param {PathTracer} path_tracer
+ * @param {{samples:number, max_samples:number, variance_target:number, min_bounce:number, max_bounce:number, confidence_probes:number, inside_probe_texels:number, supersample:number}} cfg
+ *   `samples` is the minimum count; sampling continues up to `max_samples` while the
+ *   relative variance-of-mean exceeds `variance_target` (0 = fixed `samples`).
+ * @param {function():number} random
+ * @returns {number} confidence in [0,1]
+ */
+export function lightmap_gather(
+    out,
+    px, py, pz,
+    nx, ny, nz,
+    texel_world_size,
+    scene,
+    path_tracer,
+    cfg,
+    random
+) {
+    _normal[0] = nx;
+    _normal[1] = ny;
+    _normal[2] = nz;
+
+    const min_samples = cfg.samples;
+    const max_samples = Math.max(min_samples, cfg.max_samples ?? min_samples);
+    const variance_target = cfg.variance_target ?? 0; // relative var-of-mean target; 0 = fixed count
+    const min_bounce = cfg.min_bounce;
+    const max_bounce = cfg.max_bounce;
+
+    // surface tangent frame for sub-texel origin jitter (supersampling)
+    const jitter = (cfg.supersample ?? 0) * texel_world_size;
+    if (jitter > 0) {
+        v3_orthonormal_matrix_from_normal(_basis, 0, nx, ny, nz);
+        v3_matrix3_rotate(_tangent, 0, 1, 0, 0, _basis);
+        v3_matrix3_rotate(_bitangent, 0, 0, 1, 0, _basis);
+    }
+
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let lum_sum = 0;
+    let lum_sum_sq = 0;
+
+    // Variance-adaptive sampling: take at least `min_samples`, then keep going
+    // while the relative noise of the mean is still above target, up to
+    // `max_samples`. Noisy regions (contacts, occlusion edges, high-frequency
+    // bounce) naturally draw more samples; smooth sky-lit areas stop early.
+    let n = 0;
+    let variance_of_mean = 0;
+    while (n < max_samples) {
+        let ox = px;
+        let oy = py;
+        let oz = pz;
+
+        if (jitter > 0) {
+            const ju = (random() - 0.5) * jitter;
+            const jv = (random() - 0.5) * jitter;
+            ox += _tangent[0] * ju + _bitangent[0] * jv;
+            oy += _tangent[1] * ju + _bitangent[1] * jv;
+            oz += _tangent[2] * ju + _bitangent[2] * jv;
+        }
+
+        // cosine-weighted hemisphere direction around the surface normal
+        getBiasedNormalSample(_dir, 0, _normal, 0, 1, random);
+
+        ray3_compose_array(_ray, ox, oy, oz, _dir[0], _dir[1], _dir[2]);
+        _ray.tMax = Infinity;
+
+        path_tracer.path_trace(_radiance, _ray, min_bounce, max_bounce, random, scene);
+
+        r += _radiance[0];
+        g += _radiance[1];
+        b += _radiance[2];
+
+        const lum = rgb_to_luminance(_radiance[0], _radiance[1], _radiance[2]);
+        lum_sum += lum;
+        lum_sum_sq += lum * lum;
+        n++;
+
+        if (n >= min_samples) {
+            const mean = lum_sum / n;
+            // unbiased variance-of-the-mean: (sample variance)/n = popVar/(n-1).
+            // (n > 1 always holds here: min_samples >= 4 in every config.)
+            const pop_var = Math.max(0, lum_sum_sq / n - mean * mean);
+            variance_of_mean = n > 1 ? pop_var / (n - 1) : 0;
+            if (variance_target > 0 && variance_of_mean <= variance_target * (mean * mean + 1e-8)) {
+                break; // relative noise low enough
+            }
+        }
+    }
+
+    const inv = 1 / n;
+    out[0] = r * inv;
+    out[1] = g * inv;
+    out[2] = b * inv;
+    out[3] = variance_of_mean;
+
+    // geometric confidence: is the sample point buried (on the wrong side of
+    // nearby geometry)? Count short probes whose first hit is a BACK face.
+    const probes = cfg.confidence_probes;
+    if (probes <= 0) {
+        return 1;
+    }
+
+    const inside_distance = cfg.inside_probe_texels * texel_world_size;
+    let backface = 0;
+    for (let p = 0; p < probes; p++) {
+        getBiasedNormalSample(_dir, 0, _normal, 0, 1, random);
+        ray3_compose_array(_ray, px, py, pz, _dir[0], _dir[1], _dir[2]);
+        _ray.tMax = inside_distance;
+        if (scene.trace(_hit, _ray) >= 0 && v3_dot(_hit[3], _hit[4], _hit[5], _dir[0], _dir[1], _dir[2]) > 0) {
+            backface++;
+        }
+    }
+
+    return 1 - backface / probes;
+}

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
+ * covered texel with the barycentric weights of the three vertices (A, B, C) at
+ * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
+ * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
+ *
+ * Default (center) mode: a texel is covered iff its CENTER lies inside the
+ * triangle, sampled at that center.
+ *
+ * Conservative mode (`conservative === true`): a texel is also covered if its
+ * cell overlaps the triangle even though its center is outside (thin features,
+ * chart borders). For those, the sample is **clamped to the closest point on the
+ * triangle** so the interpolated position/normal stays on the surface — avoiding
+ * the dropped-edge-texel black gutters of center-only coverage.
+ *
+ * Degenerate (zero-area) triangles produce no callbacks.
+ *
+ * @param {number} ax vertex A x, in pixels
+ * @param {number} ay vertex A y, in pixels
+ * @param {number} bx vertex B x, in pixels
+ * @param {number} by vertex B y, in pixels
+ * @param {number} cx vertex C x, in pixels
+ * @param {number} cy vertex C y, in pixels
+ * @param {number} width raster width (texel centers tested in [0, width))
+ * @param {number} height raster height (texel centers tested in [0, height))
+ * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
+ * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
+ */
+export function lightmap_rasterize_triangle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, width: number, height: number, callback: any, conservative?: boolean): void;
+//# sourceMappingURL=lightmap_rasterize_triangle.d.ts.map

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightmap_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,gCAEN,OAAO,QAgEjB"}

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js

@@ -0,0 +1,145 @@
+/** Half the diagonal of a unit texel — the conservative overlap reach from a center. */
+const HALF_TEXEL_DIAGONAL = Math.SQRT2 * 0.5;
+
+/**
+ * Closest point to (px,py) on segment (ax,ay)->(bx,by), written to out[0..1].
+ *
+ * @param {Float32Array|number[]} out
+ * @param {number} px
+ * @param {number} py
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ */
+function closest_on_segment(out, px, py, ax, ay, bx, by) {
+    const ex = bx - ax;
+    const ey = by - ay;
+    const len2 = ex * ex + ey * ey;
+    let t = len2 > 0 ? ((px - ax) * ex + (py - ay) * ey) / len2 : 0;
+    if (t < 0) t = 0; else if (t > 1) t = 1;
+    out[0] = ax + t * ex;
+    out[1] = ay + t * ey;
+}
+
+const _q = new Float32Array(2);
+const _e = new Float32Array(2);
+
+/**
+ * Closest point to (px,py) on the (filled) triangle, written to out[0..1].
+ * Assumes the point is outside the triangle (callers test inside first).
+ *
+ * @param {Float32Array|number[]} out
+ */
+function closest_on_triangle(out, px, py, ax, ay, bx, by, cx, cy) {
+    let best_d2 = Infinity;
+
+    closest_on_segment(_e, px, py, ax, ay, bx, by);
+    let dx = px - _e[0], dy = py - _e[1];
+    let d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, bx, by, cx, cy);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, cx, cy, ax, ay);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    return Math.sqrt(best_d2);
+}
+
+/**
+ * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
+ * covered texel with the barycentric weights of the three vertices (A, B, C) at
+ * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
+ * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
+ *
+ * Default (center) mode: a texel is covered iff its CENTER lies inside the
+ * triangle, sampled at that center.
+ *
+ * Conservative mode (`conservative === true`): a texel is also covered if its
+ * cell overlaps the triangle even though its center is outside (thin features,
+ * chart borders). For those, the sample is **clamped to the closest point on the
+ * triangle** so the interpolated position/normal stays on the surface — avoiding
+ * the dropped-edge-texel black gutters of center-only coverage.
+ *
+ * Degenerate (zero-area) triangles produce no callbacks.
+ *
+ * @param {number} ax vertex A x, in pixels
+ * @param {number} ay vertex A y, in pixels
+ * @param {number} bx vertex B x, in pixels
+ * @param {number} by vertex B y, in pixels
+ * @param {number} cx vertex C x, in pixels
+ * @param {number} cy vertex C y, in pixels
+ * @param {number} width raster width (texel centers tested in [0, width))
+ * @param {number} height raster height (texel centers tested in [0, height))
+ * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
+ * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
+ */
+export function lightmap_rasterize_triangle(ax, ay, bx, by, cx, cy, width, height, callback, conservative = false) {
+    // conservative mode reaches one extra texel of overlap, so widen the scan box
+    const margin = conservative ? 1 : 0;
+
+    const min_x = Math.max(0, Math.floor(Math.min(ax, bx, cx)) - margin);
+    const max_x = Math.min(width - 1, Math.floor(Math.max(ax, bx, cx)) + margin);
+    const min_y = Math.max(0, Math.floor(Math.min(ay, by, cy)) - margin);
+    const max_y = Math.min(height - 1, Math.floor(Math.max(ay, by, cy)) + margin);
+
+    const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
+
+    if (d === 0) {
+        // degenerate triangle, no area to cover
+        return;
+    }
+
+    const inv_d = 1 / d;
+
+    for (let py = min_y; py <= max_y; py++) {
+        const sy = py + 0.5;
+
+        for (let px = min_x; px <= max_x; px++) {
+            const sx = px + 0.5;
+
+            const wA = ((by - cy) * (sx - cx) + (cx - bx) * (sy - cy)) * inv_d;
+            const wB = ((cy - ay) * (sx - cx) + (ax - cx) * (sy - cy)) * inv_d;
+            const wC = 1 - wA - wB;
+
+            if (wA >= 0 && wB >= 0 && wC >= 0) {
+                callback(px, py, wA, wB, wC);
+                continue;
+            }
+
+            if (!conservative) {
+                continue;
+            }
+
+            // center is outside: keep the texel only if its cell overlaps the
+            // triangle, sampling the clamped (on-triangle) closest point
+            const dist = closest_on_triangle(_q, sx, sy, ax, ay, bx, by, cx, cy);
+            if (dist > HALF_TEXEL_DIAGONAL) {
+                continue;
+            }
+
+            const qx = _q[0];
+            const qy = _q[1];
+            let cwA = ((by - cy) * (qx - cx) + (cx - bx) * (qy - cy)) * inv_d;
+            let cwB = ((cy - ay) * (qx - cx) + (ax - cx) * (qy - cy)) * inv_d;
+            // clamp tiny negative fp drift so the weights stay a valid convex combo
+            if (cwA < 0) cwA = 0;
+            if (cwB < 0) cwB = 0;
+            let cwC = 1 - cwA - cwB;
+            if (cwC < 0) {
+                cwC = 0;
+                const s = cwA + cwB;
+                cwA /= s;
+                cwB /= s;
+            }
+
+            callback(px, py, cwA, cwB, cwC);
+        }
+    }
+}

package/src/engine/graphics/sh3/lightmap/lightmap_seam_fix.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reduce lighting discontinuities across UV seams by blending the two atlas-space
+ * sides of each shared 3D edge toward each other (a CPU take on the Bakery
+ * line-blend seam fix — far simpler than least-squares stitching).
+ *
+ * A seam is a 3D edge that two charts both keep on their boundary: two
+ * {@link Chart#boundary_edges} with the same pair of SOURCE vertices but different
+ * UVs. For each such pair we walk both edges in lockstep (parameter t in [0,1],
+ * aligned by source-vertex order) at ~half-texel steps and average the covered
+ * texels on both sides, repeated a few times so the match propagates.
+ *
+ * **Only smooth seams are blended.** A shared chart-boundary edge can also be a
+ * hard feature crease (a cube's top face meets its side face at 90°), where the
+ * two sides have genuinely different lighting and MUST NOT be merged — blending
+ * there leaks the dark side into the bright one. So a pair of texels is averaged
+ * only when their world normals agree (`dot >= normal_threshold`); creases, whose
+ * normals are perpendicular, are left alone. This is the normal-continuity test
+ * the Bakery seam fix uses.
+ *
+ * Seams only ever occur within a single mesh's unwrap (different meshes don't share
+ * edges), so `chart_groups` is one chart list per mesh.
+ *
+ * @param {Float32Array} data atlas pixels, row-major, stride `channels`
+ * @param {Float32Array} normals per-texel world normal (3 per texel), length width*height*3
+ * @param {Uint8Array} coverage per-texel coverage (1 = valid), length width*height
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channels values per texel
+ * @param {Chart[][]} chart_groups one packed-chart list per mesh
+ * @param {object} [options]
+ * @param {number} [options.iterations] blend passes (default 4)
+ * @param {number} [options.normal_threshold] min normal dot to treat an edge as a smooth seam (default 0.9)
+ */
+export function lightmap_seam_fix(data: Float32Array, normals: Float32Array, coverage: Uint8Array, width: number, height: number, channels: number, chart_groups: Chart[][], options?: {
+    iterations?: number;
+    normal_threshold?: number;
+}): void;
+//# sourceMappingURL=lightmap_seam_fix.d.ts.map

package/src/engine/graphics/sh3/lightmap/lightmap_seam_fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightmap_seam_fix.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_seam_fix.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wCAXW,YAAY,WACZ,YAAY,YACZ,UAAU,SACV,MAAM,UACN,MAAM,YACN,MAAM,gBACN,OAAO,EAAE;IAEQ,UAAU,GAA3B,MAAM;IACW,gBAAgB,GAAjC,MAAM;SAgBhB"}

package/src/engine/graphics/sh3/lightmap/lightmap_seam_fix.js

@@ -0,0 +1,152 @@
+/**
+ * Reduce lighting discontinuities across UV seams by blending the two atlas-space
+ * sides of each shared 3D edge toward each other (a CPU take on the Bakery
+ * line-blend seam fix — far simpler than least-squares stitching).
+ *
+ * A seam is a 3D edge that two charts both keep on their boundary: two
+ * {@link Chart#boundary_edges} with the same pair of SOURCE vertices but different
+ * UVs. For each such pair we walk both edges in lockstep (parameter t in [0,1],
+ * aligned by source-vertex order) at ~half-texel steps and average the covered
+ * texels on both sides, repeated a few times so the match propagates.
+ *
+ * **Only smooth seams are blended.** A shared chart-boundary edge can also be a
+ * hard feature crease (a cube's top face meets its side face at 90°), where the
+ * two sides have genuinely different lighting and MUST NOT be merged — blending
+ * there leaks the dark side into the bright one. So a pair of texels is averaged
+ * only when their world normals agree (`dot >= normal_threshold`); creases, whose
+ * normals are perpendicular, are left alone. This is the normal-continuity test
+ * the Bakery seam fix uses.
+ *
+ * Seams only ever occur within a single mesh's unwrap (different meshes don't share
+ * edges), so `chart_groups` is one chart list per mesh.
+ *
+ * @param {Float32Array} data atlas pixels, row-major, stride `channels`
+ * @param {Float32Array} normals per-texel world normal (3 per texel), length width*height*3
+ * @param {Uint8Array} coverage per-texel coverage (1 = valid), length width*height
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channels values per texel
+ * @param {Chart[][]} chart_groups one packed-chart list per mesh
+ * @param {object} [options]
+ * @param {number} [options.iterations] blend passes (default 4)
+ * @param {number} [options.normal_threshold] min normal dot to treat an edge as a smooth seam (default 0.9)
+ */
+export function lightmap_seam_fix(data, normals, coverage, width, height, channels, chart_groups, options = {}) {
+    const iterations = options.iterations ?? 4;
+    const normal_threshold = options.normal_threshold ?? 0.9;
+
+    const seams = collect_seams(chart_groups);
+    if (seams.length === 0) {
+        return;
+    }
+
+    for (let iter = 0; iter < iterations; iter++) {
+        for (let s = 0; s < seams.length; s++) {
+            blend_seam(data, normals, coverage, width, height, channels, seams[s], normal_threshold);
+        }
+    }
+}
+
+/**
+ * @param {Chart[][]} chart_groups
+ * @returns {Array<{au0:number,av0:number,au1:number,av1:number,bu0:number,bv0:number,bu1:number,bv1:number}>}
+ */
+function collect_seams(chart_groups) {
+    const seams = [];
+
+    for (let g = 0; g < chart_groups.length; g++) {
+        const charts = chart_groups[g];
+        const by_edge = new Map();
+
+        for (let ci = 0; ci < charts.length; ci++) {
+            const chart = charts[ci];
+            const be = chart.boundary_edges;
+            const vol = chart.vertex_of_local;
+            const uv = chart.uv;
+
+            for (let i = 0; i < be.length; i += 2) {
+                const lv0 = be[i];
+                const lv1 = be[i + 1];
+                let o0 = vol[lv0];
+                let o1 = vol[lv1];
+                let u0 = uv[lv0 * 2], v0 = uv[lv0 * 2 + 1];
+                let u1 = uv[lv1 * 2], v1 = uv[lv1 * 2 + 1];
+
+                // orient endpoints by source-vertex id so both sides align in t
+                if (o0 > o1) {
+                    const to = o0; o0 = o1; o1 = to;
+                    const tu = u0; u0 = u1; u1 = tu;
+                    const tv = v0; v0 = v1; v1 = tv;
+                }
+
+                const key = o0 + "_" + o1;
+                const existing = by_edge.get(key);
+                const edge = { u0, v0, u1, v1 };
+                if (existing === undefined) {
+                    by_edge.set(key, edge);
+                } else {
+                    // a second occurrence of this edge -> a seam between two charts
+                    seams.push({
+                        au0: existing.u0, av0: existing.v0, au1: existing.u1, av1: existing.v1,
+                        bu0: edge.u0, bv0: edge.v0, bu1: edge.u1, bv1: edge.v1,
+                    });
+                }
+            }
+        }
+    }
+
+    return seams;
+}
+
+/**
+ * Average the covered texels along both sides of one seam edge — but only where
+ * the two sides are the same continuous surface (normals agree); hard creases are
+ * skipped.
+ */
+function blend_seam(data, normals, coverage, width, height, channels, seam, normal_threshold) {
+    const a_len = Math.hypot((seam.au1 - seam.au0) * width, (seam.av1 - seam.av0) * height);
+    const b_len = Math.hypot((seam.bu1 - seam.bu0) * width, (seam.bv1 - seam.bv0) * height);
+    const steps = Math.max(2, Math.ceil(Math.max(a_len, b_len) * 2)); // ~half-texel steps
+
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+
+        const ax = clamp_index((seam.au0 + (seam.au1 - seam.au0) * t) * width, width);
+        const ay = clamp_index((seam.av0 + (seam.av1 - seam.av0) * t) * height, height);
+        const bx = clamp_index((seam.bu0 + (seam.bu1 - seam.bu0) * t) * width, width);
+        const by = clamp_index((seam.bv0 + (seam.bv1 - seam.bv0) * t) * height, height);
+
+        const pa = ay * width + ax;
+        const pb = by * width + bx;
+        if (coverage[pa] === 0 || coverage[pb] === 0) {
+            continue;
+        }
+
+        // only blend a continuous surface, never a hard feature crease
+        const na = pa * 3;
+        const nb = pb * 3;
+        const dot = normals[na] * normals[nb] + normals[na + 1] * normals[nb + 1] + normals[na + 2] * normals[nb + 2];
+        if (dot < normal_threshold) {
+            continue;
+        }
+
+        const base_a = pa * channels;
+        const base_b = pb * channels;
+        for (let c = 0; c < channels; c++) {
+            const avg = (data[base_a + c] + data[base_b + c]) * 0.5;
+            data[base_a + c] = avg;
+            data[base_b + c] = avg;
+        }
+    }
+}
+
+/**
+ * @param {number} coord pixel coordinate (may be fractional / out of range)
+ * @param {number} size
+ * @returns {number} integer texel index in [0, size)
+ */
+function clamp_index(coord, size) {
+    let v = Math.floor(coord);
+    if (v < 0) v = 0; else if (v >= size) v = size - 1;
+    return v;
+}

package/src/engine/graphics/sh3/lightmap/prototypeLightmapBaker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prototypeLightmapBaker.d.ts.map

package/src/engine/graphics/sh3/lightmap/prototypeLightmapBaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototypeLightmapBaker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/prototypeLightmapBaker.js"],"names":[],"mappings":""}