@woosh/meep-engine 2.164.0 → 2.165.1

package/samples/generation/filters/SampleGroundMoistureFilter.js

@@ -1,75 +1,82 @@
-import { CellFilterMultiply } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterMultiply.js";
-import { CellFilterSimplexNoise } from "../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js";
+import { MohGridLayers } from "../../../../../generator/MohGridLayers.js";
+import { DEG_TO_RAD } from "../../../src/core/math/DEG_TO_RAD.js";
+import { CellFilterCache } from "../../../src/generation/filtering/numeric/CellFilterCache.js";
 import { CellFilterLiteralFloat } from "../../../src/generation/filtering/numeric/CellFilterLiteralFloat.js";
+import { CellFilterDilate } from "../../../src/generation/filtering/numeric/complex/CellFilterDilate.js";
 import { CellFilterGaussianBlur } from "../../../src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js";
+import { CellFilterSimplexNoise } from "../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js";
+import { CellFilterMultiply } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterMultiply.js";
+import { CellFilterMax2 } from "../../../src/generation/filtering/numeric/math/CellFilterMax2.js";
+import { CellFilterSmoothStep } from "../../../src/generation/filtering/numeric/math/CellFilterSmoothStep.js";
 import { CellFilterStep } from "../../../src/generation/filtering/numeric/math/CellFilterStep.js";
 import {
     CellFilterSampleLayerLinear
 } from "../../../src/generation/filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import { MirGridLayers } from "../grid/MirGridLayers.js";
-import { CellFilterMax2 } from "../../../src/generation/filtering/numeric/math/CellFilterMax2.js";
-import { CellFilterSmoothStep } from "../../../src/generation/filtering/numeric/math/CellFilterSmoothStep.js";
-import { MohGridLayers } from "../../../../../generator/MohGridLayers.js";
-import { CellFilterDilate } from "../../../src/generation/filtering/numeric/complex/CellFilterDilate.js";
-import { CellFilterCache } from "../../../src/generation/filtering/numeric/CellFilterCache.js";
-import { DEG_TO_RAD } from "../../../src/core/math/DEG_TO_RAD.js";
 
-const fReadHeight = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
+/**
+ * Factory, a fresh filter graph is required per generation — filters bake per-run state
+ * (noise seed, layer sampler binding, cache contents) on initialize.
+ * @returns {CellFilter}
+ */
+export const SampleGroundMoistureFilter = () => {
 
-const WATER_MASK = CellFilterStep.from(fReadHeight, CellFilterLiteralFloat.from(-0.05));
-const CURVATURE = CellFilterSampleLayerLinear.from(MohGridLayers.Curvature);
-const SLOPE = CellFilterSampleLayerLinear.from(MohGridLayers.Slope);
+    const fReadHeight = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
 
+    const WATER_MASK = CellFilterStep.from(fReadHeight, CellFilterLiteralFloat.from(-0.05));
+    const SLOPE = CellFilterSampleLayerLinear.from(MohGridLayers.Slope);
+    const CURVATURE = CellFilterSampleLayerLinear.from(MohGridLayers.Curvature);
 
-export const SampleGroundMoistureFilter = CellFilterMax2.from(
-    // add regional variation in relative moisture
-    CellFilterMultiply.from(
+    return CellFilterMax2.from(
+        // add regional variation in relative moisture
         CellFilterMultiply.from(
-            CellFilterSimplexNoise.fractal(2, 100, 1263),
-            CellFilterMax2.from(
-                // flat areas are more likely to be keep moisture
-                CellFilterSmoothStep.from(
-                    CellFilterLiteralFloat.from(40 * DEG_TO_RAD),
-                    CellFilterLiteralFloat.from(10 * DEG_TO_RAD),
-                    SLOPE
-                ),
-                // water accumulates in crevices
-                CellFilterSmoothStep.from(
-                    CellFilterLiteralFloat.from(0.0),
-                    CellFilterLiteralFloat.from(0.1),
-                    CURVATURE
-                )
-            )
-        ),
-
-        CellFilterLiteralFloat.from(0.5)
-    ),
-
-    //simulate water diffusion from lakes/rivers/sees into the nearby ground
-    CellFilterGaussianBlur.from(
-        CellFilterCache.from(
-            CellFilterMax2.from(
-                WATER_MASK,
-                CellFilterMultiply.from(
-                    CellFilterGaussianBlur.from(
-                        CellFilterCache.from(CellFilterDilate.from(WATER_MASK)),
-                        5,
-                        5,
-                        1
-                    ),
-                    /*
-                     Diffuse more along surfaces with low slope (flat)
-                     NOTE: we don't have to worry about directly of the slope, as water always starts at 0, so any slope will be positive in effect
-                     */
+            CellFilterMultiply.from(
+                CellFilterSimplexNoise.fractal(2, 100, 1263),
+                CellFilterMax2.from(
+                    // flat areas are more likely to be keep moisture
                     CellFilterSmoothStep.from(
-                        CellFilterLiteralFloat.from(35 * DEG_TO_RAD),
+                        CellFilterLiteralFloat.from(40 * DEG_TO_RAD),
                         CellFilterLiteralFloat.from(10 * DEG_TO_RAD),
                         SLOPE
                     ),
+                    // water accumulates in crevices
+                    CellFilterSmoothStep.from(
+                        CellFilterLiteralFloat.from(0.0),
+                        CellFilterLiteralFloat.from(0.1),
+                        CURVATURE
+                    )
                 )
-            )
+            ),
+
+            CellFilterLiteralFloat.from(0.5)
         ),
-        3, 3, 1
-    )
-);
+
+        //simulate water diffusion from lakes/rivers/sees into the nearby ground
+        CellFilterGaussianBlur.from(
+            CellFilterCache.from(
+                CellFilterMax2.from(
+                    WATER_MASK,
+                    CellFilterMultiply.from(
+                        CellFilterGaussianBlur.from(
+                            CellFilterCache.from(CellFilterDilate.from(WATER_MASK)),
+                            5,
+                            5,
+                            1
+                        ),
+                        /*
+                         Diffuse more along surfaces with low slope (flat)
+                         NOTE: we don't have to worry about directly of the slope, as water always starts at 0, so any slope will be positive in effect
+                         */
+                        CellFilterSmoothStep.from(
+                            CellFilterLiteralFloat.from(35 * DEG_TO_RAD),
+                            CellFilterLiteralFloat.from(10 * DEG_TO_RAD),
+                            SLOPE
+                        ),
+                    )
+                )
+            ),
+            3, 3, 1
+        )
+    );
+};
 

package/samples/generation/filters/SampleNoise20_0.js

@@ -1,3 +1,8 @@
 import { CellFilterSimplexNoise } from "../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js";
 
-export const SampleNoise20_0 = CellFilterSimplexNoise.from(20, 20);
+/**
+ * Factory, a fresh filter graph is required per generation — filters bake per-run state
+ * (noise seed) on initialize.
+ * @returns {CellFilter}
+ */
+export const SampleNoise20_0 = () => CellFilterSimplexNoise.from(20, 20);

package/samples/generation/themes/SampleTheme0.js

@@ -1,67 +1,67 @@
-import { Theme } from "../../../src/generation/theme/Theme.js";
-import { TerrainTheme } from "../../../src/generation/theme/TerrainTheme.js";
-import { TerrainLayerRule } from "../../../src/generation/theme/TerrainLayerRule.js";
-import { MarkerProcessingRule } from "../../../src/generation/markers/actions/MarkerProcessingRule.js";
-import { MarkerNodeMatcherByType } from "../../../src/generation/markers/matcher/MarkerNodeMatcherByType.js";
-import {
-    MarkerNodeActionEntityPlacement
-} from "../../../src/generation/markers/actions/MarkerNodeActionEntityPlacement.js";
+import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
+import GeneratedArmy from "../../../../model/game/ecs/component/generator/army/GeneratedArmy.js";
+import Vector2 from "../../../src/core/geom/Vector2js";
+import Vector3 from "../../../src/core/geom/Vector3js";
+import { PI_HALF } from "../../../src/core/math/PI_HALF.js";
+import Tag from "../../../src/engine/ecs/components/Tagjs";
 import { EntityBlueprint } from "../../../src/engine/ecs/EntityBlueprint.js";
-import Mesh from "../../../src/engine/graphics/ecs/mesh/Mesh.js";
+import GUIElement from "../../../src/engine/ecs/gui/GUIElementjs";
+import HeadsUpDisplay from "../../../src/engine/ecs/gui/hud/HeadsUpDisplay.js";
+import ViewportPosition from "../../../src/engine/ecs/gui/position/ViewportPosition.js";
+import ClingToTerrain from "../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrain.js";
 import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import Mesh from "../../../src/engine/graphics/ecs/mesh/Mesh.js";
+import { ParticleEmitter } from "../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitterjs";
 import GridPosition from "../../../src/engine/grid/position/GridPosition.js";
-import { matcher_tag_not_traversable } from "../rules/matcher_tag_not_traversable.js";
-import { CellMatcherLayerBitMaskTest } from "../../../src/generation/rules/CellMatcherLayerBitMaskTest.js";
-import { GridTags } from "../grid/GridTags.js";
+import { SoundEmitter } from "../../../src/engine/sound/ecs/emitter/SoundEmitter.js";
 import { CellFilterCellMatcher } from "../../../src/generation/filtering/CellFilterCellMatcher.js";
-import { CellFilterSimplexNoise } from "../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js";
+import { CellFilterCache } from "../../../src/generation/filtering/numeric/CellFilterCache.js";
+import { CellFilterLiteralFloat } from "../../../src/generation/filtering/numeric/CellFilterLiteralFloat.js";
+import { CellFilterAngleToNormal } from "../../../src/generation/filtering/numeric/complex/CellFilterAngleToNormal.js";
 import { CellFilterFXAA } from "../../../src/generation/filtering/numeric/complex/CellFilterFXAA.js";
+import { CellFilterGaussianBlur } from "../../../src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js";
+import { CellFilterSimplexNoise } from "../../../src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js";
+import { CellFilterAdd } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterAdd.js";
 import { CellFilterMultiply } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterMultiply.js";
+import { CellFilterNegate } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterNegate.js";
+import { CellFilterClamp } from "../../../src/generation/filtering/numeric/math/CellFilterClamp.js";
+import { CellFilterInverseLerp } from "../../../src/generation/filtering/numeric/math/CellFilterInverseLerp.js";
 import { CellFilterLerp } from "../../../src/generation/filtering/numeric/math/CellFilterLerp.js";
-import { CellFilterLiteralFloat } from "../../../src/generation/filtering/numeric/CellFilterLiteralFloat.js";
-import Tag from "../../../src/engine/ecs/components/Tagjs";
-import HeadsUpDisplay from "../../../src/engine/ecs/gui/hud/HeadsUpDisplay.js";
-import ViewportPosition from "../../../src/engine/ecs/gui/position/ViewportPosition.js";
-import GUIElement from "../../../src/engine/ecs/gui/GUIElementjs";
+import { CellFilterOneMinus } from "../../../src/generation/filtering/numeric/math/CellFilterOneMinus.js";
+import { CellFilterSmoothStep } from "../../../src/generation/filtering/numeric/math/CellFilterSmoothStep.js";
 import {
-    MarkerNodeTransformerYRotateByFilterGradient
-} from "../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js";
-import { CellFilterGaussianBlur } from "../../../src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js";
-import { CellProcessingRule } from "../../../src/generation/theme/cell/CellProcessingRule.js";
+    CellFilterSampleLayerLinear
+} from "../../../src/generation/filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import {
     ContinuousGridCellActionSetTerrainHeight
 } from "../../../src/generation/grid/actions/ContinuousGridCellActionSetTerrainHeight.js";
-import { MirGridLayers } from "../grid/MirGridLayers.js";
 import {
-    CellFilterSampleLayerLinear
-} from "../../../src/generation/filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
-import ClingToTerrain from "../../../src/engine/ecs/terrain/ecs/cling/ClingToTerrain.js";
+    MarkerNodeActionEntityPlacement
+} from "../../../src/generation/markers/actions/MarkerNodeActionEntityPlacement.js";
+import { MarkerProcessingRule } from "../../../src/generation/markers/actions/MarkerProcessingRule.js";
 import {
-    MarkerNodeTransformerYRotateByFilter
-} from "../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.js";
-import { CellFilterAngleToNormal } from "../../../src/generation/filtering/numeric/complex/CellFilterAngleToNormal.js";
-import Vector3 from "../../../src/core/geom/Vector3js";
-import { CellFilterClamp } from "../../../src/generation/filtering/numeric/math/CellFilterClamp.js";
-import { CellFilterOneMinus } from "../../../src/generation/filtering/numeric/math/CellFilterOneMinus.js";
-import { CellFilterSmoothStep } from "../../../src/generation/filtering/numeric/math/CellFilterSmoothStep.js";
-import { CellFilterInverseLerp } from "../../../src/generation/filtering/numeric/math/CellFilterInverseLerp.js";
-import { CellFilterAdd } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterAdd.js";
-import { CellFilterNegate } from "../../../src/generation/filtering/numeric/math/algebra/CellFilterNegate.js";
+    MarkerNodeActionSelectWeighted
+} from "../../../src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.js";
 import {
     MarkerNodeActionWeightedElement
 } from "../../../src/generation/markers/actions/probability/MarkerNodeActionWeightedElement.js";
+import { MarkerNodeMatcherByType } from "../../../src/generation/markers/matcher/MarkerNodeMatcherByType.js";
 import {
-    MarkerNodeActionSelectWeighted
-} from "../../../src/generation/markers/actions/probability/MarkerNodeActionSelectWeighted.js";
-import { ParticleEmitter } from "../../../src/engine/graphics/particles/particular/engine/emitter/ParticleEmitterjs";
-import { CellFilterCache } from "../../../src/generation/filtering/numeric/CellFilterCache.js";
-import { SoundEmitter } from "../../../src/engine/sound/ecs/emitter/SoundEmitter.js";
-import { SampleGroundMoistureFilter } from "../filters/SampleGroundMoistureFilter.js";
-import GeneratedArmy from "../../../../model/game/ecs/component/generator/army/GeneratedArmy.js";
-import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
+    MarkerNodeTransformerYRotateByFilter
+} from "../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilter.js";
+import {
+    MarkerNodeTransformerYRotateByFilterGradient
+} from "../../../src/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.js";
+import { CellMatcherLayerBitMaskTest } from "../../../src/generation/rules/CellMatcherLayerBitMaskTest.js";
+import { CellProcessingRule } from "../../../src/generation/theme/cell/CellProcessingRule.js";
 import { TerrainLayerDescription } from "../../../src/generation/theme/TerrainLayerDescription.js";
-import Vector2 from "../../../src/core/geom/Vector2js";
-import { PI_HALF } from "../../../src/core/math/PI_HALF.js";
+import { TerrainLayerRule } from "../../../src/generation/theme/TerrainLayerRule.js";
+import { TerrainTheme } from "../../../src/generation/theme/TerrainTheme.js";
+import { Theme } from "../../../src/generation/theme/Theme.js";
+import { SampleGroundMoistureFilter } from "../filters/SampleGroundMoistureFilter.js";
+import { GridTags } from "../grid/GridTags.js";
+import { MirGridLayers } from "../grid/MirGridLayers.js";
+import { matcher_tag_not_traversable } from "../rules/matcher_tag_not_traversable.js";
 
 export const SampleTheme0 = new Theme();
 
@@ -1061,7 +1061,7 @@ const filterAridArea = CellFilterClamp.from(
     CellFilterInverseLerp.from(
         CellFilterLiteralFloat.from(0.5),
         CellFilterLiteralFloat.from(0.1),
-        SampleGroundMoistureFilter
+        SampleGroundMoistureFilter()
     ),
     CellFilterLiteralFloat.from(0),
     CellFilterLiteralFloat.from(1)

package/src/core/binary/BitImage2.d.ts

@@ -0,0 +1,91 @@
+/**
+ * A 2D bitmap with word-packed rows (one bit per cell), built for atlas
+ * packing: fast shifted-OR collision tests between a chart mask and the atlas
+ * occupancy, plus blit, dilation and content-preserving growth. This is the
+ * `BitImage` xatlas uses for `canBlit` placement; meep's 1D {@link BitSet} has
+ * no 2D addressing or shifted collision, so this is a distinct structure.
+ *
+ * Rows are padded to whole 32-bit words. Bits at column >= width are never set
+ * (set() enforces the bound), so the trailing-word garbage that would otherwise
+ * break a shifted collision test simply does not exist — no explicit masking is
+ * needed.
+ *
+ * Fields are public so packing hot loops can read `data`/`words_per_row`
+ * directly, mirroring CSRGraph.
+ */
+export class BitImage2 {
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width: number, height: number);
+    width: number;
+    height: number;
+    words_per_row: number;
+    data: Uint32Array;
+    /** @param {number} x @param {number} y @returns {number} 0 or 1 */
+    get(x: number, y: number): number;
+    /**
+     * Set the bit at (x, y). x must be < width (no out-of-row bits).
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    set(x: number, y: number): void;
+    /** Zero every bit. */
+    reset(): void;
+    /** @returns {number} number of set bits */
+    cardinality(): number;
+    /**
+     * Can `other` be placed with its (0,0) at (ox, oy) of this image without
+     * overlapping any set bit and while fitting fully inside the bounds?
+     *
+     * @param {BitImage2} other
+     * @param {number} ox
+     * @param {number} oy
+     * @returns {boolean}
+     */
+    canBlit(other: BitImage2, ox: number, oy: number): boolean;
+    /**
+     * OR `other`'s set bits into this image with its (0,0) at (ox, oy). Caller
+     * must have verified placement with {@link canBlit}.
+     *
+     * @param {BitImage2} other
+     * @param {number} ox
+     * @param {number} oy
+     */
+    or_blit(other: BitImage2, ox: number, oy: number): void;
+    /**
+     * Grow the set region by `passes` cells (Chebyshev / 3x3 OR per pass),
+     * in place. Used to reserve the padding gutter around a chart mask.
+     *
+     * @param {number} passes
+     */
+    dilate(passes: number): void;
+    /**
+     * Grow to (new_width, new_height) >= current, preserving content. The row
+     * stride changes when the word count per row changes, so each row must be
+     * re-laid-out — a flat copy would corrupt the image.
+     *
+     * @param {number} new_width
+     * @param {number} new_height
+     */
+    grow_preserving(new_width: number, new_height: number): void;
+    /**
+     * A new image that is this image transposed (x/y swapped): the 90-degree
+     * orientation tried during rotated chart placement. Allocates the target;
+     * use {@link copy_transposed} to transpose into a reused buffer.
+     *
+     * @returns {BitImage2}
+     */
+    transposed(): BitImage2;
+    /**
+     * Write this image's transpose (x/y swapped) into `out` — the non-allocating
+     * path. `out` is cleared first and must be sized (this.height x this.width).
+     * Bit count is preserved.
+     *
+     * @param {BitImage2} out target image, dimensions (this.height, this.width)
+     */
+    copy_transposed(out: BitImage2): void;
+}
+//# sourceMappingURL=BitImage2.d.ts.map

package/src/core/binary/BitImage2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitImage2.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitImage2.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAUhB;IAJG,cAAkB;IAClB,eAAoB;IACpB,sBAAuD;IACvD,kBAAqE;IAGzE,mEAAmE;IACnE,OADY,MAAM,KAAY,MAAM,GAAc,MAAM,CAGvD;IAED;;;;;OAKG;IACH,OAHW,MAAM,KACN,MAAM,QAIhB;IAED,sBAAsB;IACtB,cAEC;IAED,2CAA2C;IAC3C,eADc,MAAM,CAanB;IAED;;;;;;;;OAQG;IACH,eALW,SAAS,MACT,MAAM,MACN,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;;;;OAOG;IACH,eAJW,SAAS,MACT,MAAM,MACN,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,eAFW,MAAM,QA0BhB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,cACN,MAAM,QA0BhB;IAED;;;;;;OAMG;IACH,cAFa,SAAS,CAMrB;IAED;;;;;;OAMG;IACH,qBAFW,SAAS,QAcnB;CACJ"}

package/src/core/binary/BitImage2.js

@@ -0,0 +1,242 @@
+import { assert } from "../assert.js";
+
+/**
+ * A 2D bitmap with word-packed rows (one bit per cell), built for atlas
+ * packing: fast shifted-OR collision tests between a chart mask and the atlas
+ * occupancy, plus blit, dilation and content-preserving growth. This is the
+ * `BitImage` xatlas uses for `canBlit` placement; meep's 1D {@link BitSet} has
+ * no 2D addressing or shifted collision, so this is a distinct structure.
+ *
+ * Rows are padded to whole 32-bit words. Bits at column >= width are never set
+ * (set() enforces the bound), so the trailing-word garbage that would otherwise
+ * break a shifted collision test simply does not exist — no explicit masking is
+ * needed.
+ *
+ * Fields are public so packing hot loops can read `data`/`words_per_row`
+ * directly, mirroring CSRGraph.
+ */
+export class BitImage2 {
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        assert.isNonNegativeInteger(width, "width");
+        assert.isNonNegativeInteger(height, "height");
+
+        this.width = width;
+        this.height = height;
+        this.words_per_row = Math.max(1, Math.ceil(width / 32));
+        this.data = new Uint32Array(this.words_per_row * Math.max(1, height));
+    }
+
+    /** @param {number} x @param {number} y @returns {number} 0 or 1 */
+    get(x, y) {
+        return (this.data[y * this.words_per_row + (x >>> 5)] >>> (x & 31)) & 1;
+    }
+
+    /**
+     * Set the bit at (x, y). x must be < width (no out-of-row bits).
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    set(x, y) {
+        this.data[y * this.words_per_row + (x >>> 5)] |= (1 << (x & 31));
+    }
+
+    /** Zero every bit. */
+    reset() {
+        this.data.fill(0);
+    }
+
+    /** @returns {number} number of set bits */
+    cardinality() {
+        const data = this.data;
+        let count = 0;
+        for (let i = 0; i < data.length; i++) {
+            let w = data[i];
+            // Hamming weight (SWAR popcount)
+            w = w - ((w >>> 1) & 0x55555555);
+            w = (w & 0x33333333) + ((w >>> 2) & 0x33333333);
+            w = (w + (w >>> 4)) & 0x0f0f0f0f;
+            count += (Math.imul(w, 0x01010101) >>> 24);
+        }
+        return count;
+    }
+
+    /**
+     * Can `other` be placed with its (0,0) at (ox, oy) of this image without
+     * overlapping any set bit and while fitting fully inside the bounds?
+     *
+     * @param {BitImage2} other
+     * @param {number} ox
+     * @param {number} oy
+     * @returns {boolean}
+     */
+    canBlit(other, ox, oy) {
+        if (ox < 0 || oy < 0 || ox + other.width > this.width || oy + other.height > this.height) {
+            return false;
+        }
+
+        const ow = other.words_per_row;
+        const tw = this.words_per_row;
+        const oh = other.height;
+
+        for (let r = 0; r < oh; r++) {
+            const o_base = r * ow;
+            const t_base = (oy + r) * tw;
+            for (let w = 0; w < ow; w++) {
+                const ov = other.data[o_base + w];
+                if (ov === 0) {
+                    continue;
+                }
+                const bit = ox + (w << 5);
+                const wi = bit >>> 5;
+                const bo = bit & 31;
+                if ((this.data[t_base + wi] & (ov << bo)) !== 0) {
+                    return false;
+                }
+                if (bo !== 0) {
+                    const hi = ov >>> (32 - bo);
+                    if (hi !== 0 && (this.data[t_base + wi + 1] & hi) !== 0) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * OR `other`'s set bits into this image with its (0,0) at (ox, oy). Caller
+     * must have verified placement with {@link canBlit}.
+     *
+     * @param {BitImage2} other
+     * @param {number} ox
+     * @param {number} oy
+     */
+    or_blit(other, ox, oy) {
+        const ow = other.words_per_row;
+        const tw = this.words_per_row;
+        const oh = other.height;
+
+        for (let r = 0; r < oh; r++) {
+            const o_base = r * ow;
+            const t_base = (oy + r) * tw;
+            for (let w = 0; w < ow; w++) {
+                const ov = other.data[o_base + w];
+                if (ov === 0) {
+                    continue;
+                }
+                const bit = ox + (w << 5);
+                const wi = bit >>> 5;
+                const bo = bit & 31;
+                this.data[t_base + wi] |= (ov << bo);
+                if (bo !== 0) {
+                    this.data[t_base + wi + 1] |= (ov >>> (32 - bo));
+                }
+            }
+        }
+    }
+
+    /**
+     * Grow the set region by `passes` cells (Chebyshev / 3x3 OR per pass),
+     * in place. Used to reserve the padding gutter around a chart mask.
+     *
+     * @param {number} passes
+     */
+    dilate(passes) {
+        const wpr = this.words_per_row;
+        const W = this.width;
+        const H = this.height;
+
+        for (let p = 0; p < passes; p++) {
+            const src = this.data.slice();
+            for (let y = 0; y < H; y++) {
+                for (let x = 0; x < W; x++) {
+                    if (((src[y * wpr + (x >>> 5)] >>> (x & 31)) & 1) === 0) {
+                        continue;
+                    }
+                    const x0 = x > 0 ? x - 1 : 0;
+                    const x1 = x < W - 1 ? x + 1 : W - 1;
+                    const y0 = y > 0 ? y - 1 : 0;
+                    const y1 = y < H - 1 ? y + 1 : H - 1;
+                    for (let yy = y0; yy <= y1; yy++) {
+                        for (let xx = x0; xx <= x1; xx++) {
+                            this.set(xx, yy);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Grow to (new_width, new_height) >= current, preserving content. The row
+     * stride changes when the word count per row changes, so each row must be
+     * re-laid-out — a flat copy would corrupt the image.
+     *
+     * @param {number} new_width
+     * @param {number} new_height
+     */
+    grow_preserving(new_width, new_height) {
+        assert.greaterThanOrEqual(new_width, this.width, "new_width");
+        assert.greaterThanOrEqual(new_height, this.height, "new_height");
+
+        if (new_width === this.width && new_height === this.height) {
+            return;
+        }
+
+        const new_wpr = Math.max(1, Math.ceil(new_width / 32));
+        const new_data = new Uint32Array(new_wpr * Math.max(1, new_height));
+
+        const copy_words = Math.min(this.words_per_row, new_wpr);
+        for (let y = 0; y < this.height; y++) {
+            const src_base = y * this.words_per_row;
+            const dst_base = y * new_wpr;
+            for (let w = 0; w < copy_words; w++) {
+                new_data[dst_base + w] = this.data[src_base + w];
+            }
+        }
+
+        this.width = new_width;
+        this.height = new_height;
+        this.words_per_row = new_wpr;
+        this.data = new_data;
+    }
+
+    /**
+     * A new image that is this image transposed (x/y swapped): the 90-degree
+     * orientation tried during rotated chart placement. Allocates the target;
+     * use {@link copy_transposed} to transpose into a reused buffer.
+     *
+     * @returns {BitImage2}
+     */
+    transposed() {
+        const out = new BitImage2(this.height, this.width);
+        this.copy_transposed(out);
+        return out;
+    }
+
+    /**
+     * Write this image's transpose (x/y swapped) into `out` — the non-allocating
+     * path. `out` is cleared first and must be sized (this.height x this.width).
+     * Bit count is preserved.
+     *
+     * @param {BitImage2} out target image, dimensions (this.height, this.width)
+     */
+    copy_transposed(out) {
+        assert.equal(out.width, this.height, "out.width must equal this.height");
+        assert.equal(out.height, this.width, "out.height must equal this.width");
+
+        out.reset();
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                if (this.get(x, y) === 1) {
+                    out.set(y, x);
+                }
+            }
+        }
+    }
+}

package/src/core/color/YCoCg/rgb_to_ycocg.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Convert a linear RGB triple to YCoCg (luminance / chroma-orange / chroma-green).
+ *
+ * The transform is a plain linear map, so it is HDR-safe (works for values outside [0,1]) and, crucially,
+ * commutes with linear interpolation: lerp(ycocg(a), ycocg(b)) === ycocg(lerp(a, b)). That is what lets YCoCg data
+ * be hardware-filtered (bilinear / trilinear) exactly as if it were RGB, and reconstructed afterwards.
+ *
+ * Inverse of {@link ycocg_to_rgb}.
+ *
+ * @param {number[]|Float32Array|Float64Array} result Y, Co, Cg are written at result_offset, +1, +2
+ * @param {number} result_offset
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function rgb_to_ycocg(result: number[] | Float32Array | Float64Array, result_offset: number, r: number, g: number, b: number): void;
+//# sourceMappingURL=rgb_to_ycocg.d.ts.map

package/src/core/color/YCoCg/rgb_to_ycocg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgb_to_ycocg.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/YCoCg/rgb_to_ycocg.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAMhB"}

package/src/core/color/YCoCg/rgb_to_ycocg.js

@@ -0,0 +1,20 @@
+/**
+ * Convert a linear RGB triple to YCoCg (luminance / chroma-orange / chroma-green).
+ *
+ * The transform is a plain linear map, so it is HDR-safe (works for values outside [0,1]) and, crucially,
+ * commutes with linear interpolation: lerp(ycocg(a), ycocg(b)) === ycocg(lerp(a, b)). That is what lets YCoCg data
+ * be hardware-filtered (bilinear / trilinear) exactly as if it were RGB, and reconstructed afterwards.
+ *
+ * Inverse of {@link ycocg_to_rgb}.
+ *
+ * @param {number[]|Float32Array|Float64Array} result Y, Co, Cg are written at result_offset, +1, +2
+ * @param {number} result_offset
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ */
+export function rgb_to_ycocg(result, result_offset, r, g, b) {
+    result[result_offset] = 0.25 * r + 0.5 * g + 0.25 * b;      // Y
+    result[result_offset + 1] = 0.5 * r - 0.5 * b;              // Co
+    result[result_offset + 2] = -0.25 * r + 0.5 * g - 0.25 * b; // Cg
+}