@woosh/meep-engine 3.60.6 → 3.60.7

package/src/core/collection/heap/FibonacciHeap.js

@@ -1,5 +1,6 @@
 import { assert } from "../../assert.js";
 import { BinaryElementPool } from "../../geom/3d/topology/struct/binary/BinaryElementPool.js";
+import { msb_32 } from "../../binary/msb_32.js";
 
 const UINT32_MAX = 4294967295;
 
@@ -310,7 +311,7 @@ export class FibonacciHeap {
 
         // upper bound on max degree D(n) <= floor(log_phi(n)).
         // log_phi(n) = log2(n) / log2(phi) ~= log2(n) * 1.4404; pad generously.
-        const D = Math.floor(Math.log2(this.__size)) * 2 + 8;
+        const D = msb_32(this.__size) * 2 + 8;
         const A = new Array(D);
         for (let i = 0; i < D; i++) {
             A[i] = NULL_HANDLE;

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAoFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAqEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAoFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cA4EC;CACJ"}

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -5,6 +5,7 @@ import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_swap } from "../../../collection/array/array_swap.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { aabb2_union_array } from "../aabb/aabb2_union_array.js";
+import { msb_32 } from "../../../binary/msb_32.js";
 
 const BINARY_NODE_SIZE = 4;
 const LEAF_NODE_SIZE = 5;
@@ -319,12 +320,17 @@ export class StaticR2Tree {
 
         const leaf_node_block_address = binary_node_count * BINARY_NODE_SIZE;
 
-        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
+        if (binary_node_count === 0) {
+            // no leaves, nothing to build
+            return;
+        }
+
+        let level = msb_32(binary_node_count);
 
         let i, offset, level_node_count;
         //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
         //build one level above leaf nodes
-        level_node_count = Math.pow(2, level);
+        level_node_count = 1 << level;
         offset = (level_node_count - 1) * BINARY_NODE_SIZE;
 
         let parentIndex;

package/src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_compute_triangle_edge_flags.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.js"],"names":[],"mappings":"AAyNA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,4DAJW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,WAAW,CA2JvB"}
+{"version":3,"file":"mesh_compute_triangle_edge_flags.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.js"],"names":[],"mappings":"AAwNA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,4DAJW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,WAAW,CA2JvB"}

package/src/core/geom/3d/shape/util/mesh_compute_triangle_edge_flags.js

@@ -1,6 +1,7 @@
 import { lowbias32 } from "../../../../math/hash/lowbias32.js";
 import { tri3_classify_shared_edge } from "../../triangle/tri3_classify_shared_edge.js";
 import { TriangleEdgeFlags } from "../../triangle/TriangleEdgeFlags.js";
+import { ceilPowerOfTwo } from "../../../../binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Vertices of a mesh closer than this fraction of its scale — the largest coordinate, in absolute
@@ -85,9 +86,7 @@ function weld_tolerance(positions, indices, tri_count) {
  * @returns {number} the smallest power of two ≥ 2n (at least 2)
  */
 function table_size(n) {
-    let size = 2;
-    while (size < 2 * n) size *= 2;
-    return size;
+    return Math.max(2, ceilPowerOfTwo(2 * n));
 }
 
 /**

package/src/engine/graphics/texture/atlas/TextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,yCAHW,MAAM,GACL,UAAU,CAIrB;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAyED;;OAEG;IACH,cASC;;CACJ;qCAlmBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}
+{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAiBA;IAcI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA6ChB;IA9DD;;;OAGG;IACH,gBAAa;IAEb;;;;OAIG;IACH,sBAAsB;IAgBlB;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAEhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAGL;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAqBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,yCAHW,MAAM,GACL,UAAU,CAIrB;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cAsCC;IAyED;;OAEG;IACH,cASC;;CACJ;qCAnmBoC,2BAA2B;oBAL5C,kCAAkC;mBAFnC,0CAA0C;0BAKnC,yBAAyB;2BAGxB,iBAAiB;+BAZb,gDAAgD"}

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import {
     DataType2TypedArrayConstructorMapping
@@ -8,13 +7,13 @@ import Signal from "../../../../core/events/signal/Signal.js";
 import { MaxRectanglesPacker } from "../../../../core/geom/packing/max-rect/MaxRectanglesPacker.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import IdPool from "../../../../core/IdPool.js";
-import { max2 } from "../../../../core/math/max2.js";
 import { invokeObjectClone } from "../../../../core/model/object/invokeObjectClone.js";
 import { Sampler2D } from "../sampler/Sampler2D.js";
 import { sampler2d_sub_copy_same_item_size } from "../sampler/sampler2d_sub_copy_same_item_size.js";
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 import { AtlasPatch } from "./AtlasPatch.js";
 import { AtlasPatchFlag } from "./AtlasPatchFlag.js";
+import { ceil_log2 } from "../../../../core/binary/operations/ceil_log2.js";
 
 export class TextureAtlas extends AbstractTextureAtlas {
     /**
@@ -268,16 +267,16 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @param {number} [padding]
      * @return {AtlasPatch}
      */
-    compute_padding(_sampler, padding = 4) {
-        return padding;
-    }
-
-    /**
-     *
-     * @param {Sampler2D} sampler
-     * @param {number} [padding]
-     * @return {AtlasPatch}
-     */
+    compute_padding(_sampler, padding = 4) {
+        return padding;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {number} [padding]
+     * @return {AtlasPatch}
+     */
     add(sampler, padding = 4) {
 
         assert.notNull(sampler, 'sampler');
@@ -573,8 +572,8 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         const maxPower = 14;
 
-        const initial_p_x = max2(0, Math.log2(ceilPowerOfTwo(this.size.x)));
-        const initial_p_y = max2(0, Math.log2(ceilPowerOfTwo(this.size.y)));
+        const initial_p_x = ceil_log2(this.size.x);
+        const initial_p_y = ceil_log2(this.size.y);
 
         let power_x = initial_p_x;
         let power_y = initial_p_y;

package/src/engine/graphics/texture/atlas/sprite_atlas_border.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite_atlas_border.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/sprite_atlas_border.js"],"names":[],"mappings":"AA2BA;;;;;;;;;GASG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6CAHW,MAAM,GACJ,MAAM,CAOlB;AAlED;;;;;;;;;;;GAWG;AACH,wCAFU,MAAM,CAEgC;AAEhD;;;;;;;;GAQG;AACH,0CAFU,MAAM,CAE6B"}
+{"version":3,"file":"sprite_atlas_border.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/sprite_atlas_border.js"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6CAHW,MAAM,GACJ,MAAM,CAOlB;AAlED;;;;;;;;;;;GAWG;AACH,wCAFU,MAAM,CAEgC;AAEhD;;;;;;;;GAQG;AACH,0CAFU,MAAM,CAE6B"}

package/src/engine/graphics/texture/atlas/sprite_atlas_border.js

@@ -1,69 +1,70 @@
-import { assert } from "../../../../core/assert.js";
-
-/**
- * How much of a patch's own size is spent on its border.
- *
- * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
- * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
- * proportion makes that limit the same for every sprite whatever its resolution. At 1/64 every patch
- * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
- *
- * A fixed border does the opposite: generous for small patches and useless for large ones.
- *
- * @type {number}
- */
-export const SPRITE_ATLAS_BORDER_RATIO = 1 / 64;
-
-/**
- * The smallest border a patch may have, in texels.
- *
- * One, not more. A 64x64 sprite is common and needs four texels at the very most; eight would spend a
- * tenth of the texture on gutter to protect mip levels at which the sprite is a handful of pixels on
- * screen. One texel is also not really one — see {@link sprite_atlas_max_lod}.
- *
- * @type {number}
- */
-export const SPRITE_ATLAS_BORDER_MINIMUM = 1;
-
-/**
- * Border, in texels, for a patch of this size.
- *
- * Driven by the longer side, because one border value protects both axes and the atlas halves both
- * together when it builds its mip chain.
- *
- * @param {number} width
- * @param {number} height
- * @returns {number}
- */
-export function sprite_atlas_border(width, height) {
-    assert.isNonNegativeInteger(width, 'width');
-    assert.isNonNegativeInteger(height, 'height');
-
-    return Math.max(
-        SPRITE_ATLAS_BORDER_MINIMUM,
-        Math.ceil(Math.max(width, height) * SPRITE_ATLAS_BORDER_RATIO)
-    );
-}
-
-/**
- * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
- *
- * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
- * {@link SPRITE_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
- * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
- * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
- * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
- *
- * Past this level the sampler is clamped rather than allowed to keep minifying, so a sprite seen from
- * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
- * shimmering sprite is still that sprite, a bleeding one is somebody else's texture.
- *
- * @param {number} border
- * @returns {number}
- */
-export function sprite_atlas_max_lod(border) {
-    assert.isNonNegativeInteger(border, 'border');
-    assert.greaterThanOrEqual(border, SPRITE_ATLAS_BORDER_MINIMUM, 'border');
-
-    return Math.floor(Math.log2(border + 1));
-}
+import { assert } from "../../../../core/assert.js";
+import { msb_32 } from "../../../../core/binary/msb_32.js";
+
+/**
+ * How much of a patch's own size is spent on its border.
+ *
+ * A **proportional** border rather than a fixed one, and that is the point of it: the border is what
+ * decides how far a patch can be minified before its neighbours bleed into it, so sizing it in
+ * proportion makes that limit the same for every sprite whatever its resolution. At 1/64 every patch
+ * stops minifying at roughly the same ~64 px screen footprint, for a flat ~6.3% of atlas area.
+ *
+ * A fixed border does the opposite: generous for small patches and useless for large ones.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_RATIO = 1 / 64;
+
+/**
+ * The smallest border a patch may have, in texels.
+ *
+ * One, not more. A 64x64 sprite is common and needs four texels at the very most; eight would spend a
+ * tenth of the texture on gutter to protect mip levels at which the sprite is a handful of pixels on
+ * screen. One texel is also not really one — see {@link sprite_atlas_max_lod}.
+ *
+ * @type {number}
+ */
+export const SPRITE_ATLAS_BORDER_MINIMUM = 1;
+
+/**
+ * Border, in texels, for a patch of this size.
+ *
+ * Driven by the longer side, because one border value protects both axes and the atlas halves both
+ * together when it builds its mip chain.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @returns {number}
+ */
+export function sprite_atlas_border(width, height) {
+    assert.isNonNegativeInteger(width, 'width');
+    assert.isNonNegativeInteger(height, 'height');
+
+    return Math.max(
+        SPRITE_ATLAS_BORDER_MINIMUM,
+        Math.ceil(Math.max(width, height) * SPRITE_ATLAS_BORDER_RATIO)
+    );
+}
+
+/**
+ * The deepest mip level a patch with this border can be sampled at without reading a neighbour.
+ *
+ * **A patch's own border is not the whole guard.** Every patch in the atlas has a border of at least
+ * {@link SPRITE_ATLAS_BORDER_MINIMUM}, so whatever sits next to this one contributes at least one
+ * more texel of separation: content is `border + 1` texels apart at worst. At mip level `L` that
+ * separation is `(border + 1) / 2^L` texels, and it has to survive down to one — which is also what
+ * pays for patches not landing on power-of-two boundaries, so alignment is not claimed on top of it.
+ *
+ * Past this level the sampler is clamped rather than allowed to keep minifying, so a sprite seen from
+ * very far away aliases instead of bleeding. That is the trade, and it is the right way round: a
+ * shimmering sprite is still that sprite, a bleeding one is somebody else's texture.
+ *
+ * @param {number} border
+ * @returns {number}
+ */
+export function sprite_atlas_max_lod(border) {
+    assert.isNonNegativeInteger(border, 'border');
+    assert.greaterThanOrEqual(border, SPRITE_ATLAS_BORDER_MINIMUM, 'border');
+
+    return msb_32(border + 1);
+}

package/src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convolve_equirectangular_reflection.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,qEATW,SAAS,SACT,MAAM,SACN,MAAM,SACN,MAAM,aACN,MAAM,gBACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,QAiEhB;AAED;;;;;;;GAOG;AACH,iEALW,SAAS,UACT,SAAS,aACT,MAAM,gBACN,MAAM,QA6BhB;AAED;;;;;;;;;;;;GAYG;AACH,iEAPW,SAAS;IAEQ,YAAY,GAA7B,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACJ,SAAS,EAAE,CAoCvB;0BArLyB,yBAAyB"}
+{"version":3,"file":"convolve_equirectangular_reflection.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;GAaG;AACH,qEATW,SAAS,SACT,MAAM,SACN,MAAM,SACN,MAAM,aACN,MAAM,gBACN,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,QAiEhB;AAED;;;;;;;GAOG;AACH,iEALW,SAAS,UACT,SAAS,aACT,MAAM,gBACN,MAAM,QA6BhB;AAED;;;;;;;;;;;;GAYG;AACH,iEAPW,SAAS;IAEQ,YAAY,GAA7B,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACJ,SAAS,EAAE,CAoCvB;0BAtLyB,yBAAyB"}

package/src/engine/graphics/texture/reflection/convolve_equirectangular_reflection.js

@@ -10,6 +10,7 @@ import {
     equirectangular_reflection_lod_to_roughness,
     roughness_from_relative_mip
 } from "./equirectangular_reflection_roughness.js";
+import { msb_32 } from "../../../../core/binary/msb_32.js";
 
 /**
  * Below this we treat the surface as a perfect mirror.
@@ -159,7 +160,7 @@ export function build_equirectangular_reflection_mip_chain(base, options = {}) {
         max_roughness = 0.7
     } = options;
 
-    const full_levels = Math.floor(Math.log2(Math.max(1, Math.min(base.width, base.height)))) + 1;
+    const full_levels = msb_32(Math.max(1, Math.min(base.width, base.height))) + 1;
     const levels = mip_levels !== undefined ? Math.min(mip_levels, full_levels) : full_levels;
 
     const mips = [base];

package/src/engine/graphics3/GPUParticleEmitterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAopCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAyGnB;AAtvCD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IAgFI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAoB7D;IArGD,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,WAAW,CAEmC;IAiGxD;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IAED;;;;;;;;;;;;OAYG;IACH,uBAHW,MAAM,UACN,UAAU,MAAM,CAAC,QA8B3B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,MAAM,UACN,MAAM,WACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,0BAFW,MAAM,QAIhB;IAyQD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CA0C1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAuChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CA4ChB;;CA0UJ;;YAnnCa,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,OAAO,kDAAkD,EAAE,qBAAqB,GAAC,IAAI;;;;;;;WACrF,IAAI,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,WAAS,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,yDAAyD,EAAE,cAAc,GAAC,IAAI,CAAA;KAAC,CAAC;;;;qBAKvL,OAAO,uDAAuD,EAAE,eAAe,GAAC,IAAI;;gCA1ClE,2DAA2D;+BAU5D,6CAA6C;uBARrD,kBAAkB;4BAEb,iCAAiC;4BAQjC,0CAA0C"}
+{"version":3,"file":"GPUParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUParticleEmitterSystem.js"],"names":[],"mappings":"AAqpCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAJW,eAAe,UACf,cAAc,GACZ,OAAO,CAyGnB;AAtvCD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IAgFI;;;;;OAKG;IACH,sBALW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,gEAoB7D;IArGD,6DAA6C;IAE7C;;;OAGG;IACH,OAFU,WAAW,CAEmC;IAiGxD;;;;;;OAMG;IACH,iEAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,mBAJW,MAAM,GACJ,eAAe,GAAC,IAAI,CAWhC;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,SACN,MAAM,QA4BhB;IAED;;;;;;;;;;;;OAYG;IACH,uBAHW,MAAM,UACN,UAAU,MAAM,CAAC,QA8B3B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,MAAM,UACN,MAAM,WACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,0BAFW,MAAM,QAIhB;IAyQD,+BAA+B;IAC/B,YADc,QAAQ,IAAI,CAAC,CA0C1B;IAED;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAuChB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,4BAHW,MAAM,GACJ,IAAI,CAgBhB;IAoCD;;;;;;;;;;;;OAYG;IACH,eAHW,OAAO,gDAAgD,EAAE,YAAY,GACnE,IAAI,CA4ChB;;CA0UJ;;YAnnCa,MAAM;;;;YACN,cAAc;;;;eACd,WAAW;;;;aACX,eAAe,GAAC,IAAI;;;;;aACpB,OAAO,+CAA+C,EAAE,eAAe,GAAC,IAAI;gCAGjE,IAAI;;;;SACf,MAAM,GAAC,IAAI;;;;aACX,OAAO,kDAAkD,EAAE,qBAAqB,GAAC,IAAI;;;;;;;WACrF,IAAI,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,WAAS,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,yDAAyD,EAAE,cAAc,GAAC,IAAI,CAAA;KAAC,CAAC;;;;qBAKvL,OAAO,uDAAuD,EAAE,eAAe,GAAC,IAAI;;gCA3ClE,2DAA2D;+BAU5D,6CAA6C;uBARrD,kBAAkB;4BAEb,iCAAiC;4BAQjC,0CAA0C"}

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -18,6 +18,7 @@ import { SpriteAtlas } from "../graphics/texture/atlas/SpriteAtlas.js";
 import { SpriteAtlasFill } from "../graphics/texture/atlas/SpriteAtlasFill.js";
 import { TextureFilterType } from "../../shade/renderer/texture/TextureFilterType.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
+import { texture_mip_level_count } from "../../shade/util/texture_mip_extent.js";
 
 /**
  * Bursts {@link GPUParticleEmitterSystem#burst} will hold before it starts dropping them. Reached
@@ -1129,7 +1130,7 @@ export class GPUParticleEmitterSystem extends System {
         const texture = this.#texture;
 
         if (texture.width !== source.width || texture.height !== source.height) {
-            texture.descriptor.mipLevelCount = 1 + Math.floor(Math.log2(Math.max(source.width, source.height)));
+            texture.descriptor.mipLevelCount = texture_mip_level_count(source.width, source.height, 1, "2d");
             texture.resize(source.width, source.height);
 
             this.#uploaded_version = -1;

package/src/engine/graphics3/decal/GPUDecalRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;GAaG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aA+BnC;IA4SD,gBAoBC;;CACJ"}
+{"version":3,"file":"GPUDecalRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/GPUDecalRenderer.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;GAaG;AACH;IA6BI;;;;;;;;;;;OAWG;IACH;QAP8B,KAAK;QACL,OAAO,EAA1B,YAAY;QACC,YAAY,EAAzB,MAAM;QACU,YAAY;QACZ,YAAY;QACZ,SAAS;aA+BnC;IA4SD,gBAoBC;;CACJ"}

package/src/engine/graphics3/decal/GPUDecalRenderer.js

@@ -15,6 +15,7 @@ import { shader_decal_tile_copy } from "./shader_decal_tile_copy.js";
 import { graph_gather_decal_tiles } from "./graph_gather_decal_tiles.js";
 import { build_light_cluster_parameters } from "../../../shade/renderer/light/cluster/build_light_cluster_parameters.js";
 import { DECAL_CLUSTER_RESOLUTION_Z } from "./DECAL_CLUSTER.js";
+import { texture_mip_level_count } from "../../../shade/util/texture_mip_extent.js";
 
 /**
  * Buffers grow with headroom and never shrink — decal counts move every frame as combat spawns and
@@ -416,7 +417,7 @@ export class GPUDecalRenderer {
                 existing.destroy();
             }
 
-            const mip_levels = 1 + Math.floor(Math.log2(Math.max(width, height)));
+            const mip_levels = texture_mip_level_count(width, height, 1, "2d");
 
             residency.texture = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
                 size: [width, height],

package/src/engine/graphics3/decal/chunk_decal_record.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared WGSL accessors for reading packed decal records (`array<f32>`) from a `decal_data` storage buffer.
+ *
+ * ```wgsl
+ * fn decal_vec4(index: u32, field: u32) -> vec4<f32>
+ * fn decal_matrix(index: u32, field: u32) -> mat4x4<f32>
+ * fn decal_transform(index: u32) -> mat4x4<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_record: CodeChunk;
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_decal_record.d.ts.map

package/src/engine/graphics3/decal/chunk_decal_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_decal_record.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/chunk_decal_record.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,iCAFU,SAAS,CA+BjB;0BA3CwB,sDAAsD"}

package/src/engine/graphics3/decal/chunk_decal_record.js

@@ -0,0 +1,44 @@
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+import { DECAL_RECORD_OFFSET_TRANSFORM, DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
+
+/**
+ * Shared WGSL accessors for reading packed decal records (`array<f32>`) from a `decal_data` storage buffer.
+ *
+ * ```wgsl
+ * fn decal_vec4(index: u32, field: u32) -> vec4<f32>
+ * fn decal_matrix(index: u32, field: u32) -> mat4x4<f32>
+ * fn decal_transform(index: u32) -> mat4x4<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_decal_record = CodeChunk.from(
+    //language=WGSL
+    `
+const DECAL_RECORD_WORD_COUNT : u32 = ${DECAL_RECORD_WORD_COUNT}u;
+const DECAL_RECORD_OFFSET_TRANSFORM : u32 = ${DECAL_RECORD_OFFSET_TRANSFORM}u;
+
+fn decal_vec4(index: u32, field: u32) -> vec4<f32> {
+    let base = index * DECAL_RECORD_WORD_COUNT + field;
+
+    return vec4<f32>(
+        decal_data[base], decal_data[base + 1u], decal_data[base + 2u], decal_data[base + 3u]
+    );
+}
+
+fn decal_matrix(index: u32, field: u32) -> mat4x4<f32> {
+    let base = index * DECAL_RECORD_WORD_COUNT + field;
+
+    return mat4x4<f32>(
+        vec4<f32>(decal_data[base + 0u],  decal_data[base + 1u],  decal_data[base + 2u],  decal_data[base + 3u]),
+        vec4<f32>(decal_data[base + 4u],  decal_data[base + 5u],  decal_data[base + 6u],  decal_data[base + 7u]),
+        vec4<f32>(decal_data[base + 8u],  decal_data[base + 9u],  decal_data[base + 10u], decal_data[base + 11u]),
+        vec4<f32>(decal_data[base + 12u], decal_data[base + 13u], decal_data[base + 14u], decal_data[base + 15u])
+    );
+}
+
+fn decal_transform(index: u32) -> mat4x4<f32> {
+    return decal_matrix(index, DECAL_RECORD_OFFSET_TRANSFORM);
+}
+`
+);

package/src/engine/graphics3/decal/shader_cluster_assign_decals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_cluster_assign_decals.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_cluster_assign_decals.js"],"names":[],"mappings":"AAuCA,6DAMG;AAiBH,sDAAoF;AA0JpF;;;;;;;;GAQG;AACH,2CAFU,aAAa,CAMpB;6BAxM0B,qDAAqD;4BADtD,oDAAoD;8BALlD,iDAAiD"}
+{"version":3,"file":"shader_cluster_assign_decals.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_cluster_assign_decals.js"],"names":[],"mappings":"AAuCA,6DAMG;AAiBH,sDAAoF;AA6IpF;;;;;;;;GAQG;AACH,2CAFU,aAAa,CAMpB;6BA3L0B,qDAAqD;4BADtD,oDAAoD;8BALlD,iDAAiD"}

package/src/engine/graphics3/decal/shader_cluster_assign_decals.js

@@ -29,13 +29,13 @@ import { atomic_u32, f32, vec2u, vec3f, vec4f } from "../../../shade/renderer/sh
 import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
 import { chunk_decal_intersects_frustum } from "./chunk_decal_intersects_frustum.js";
+import { chunk_decal_record } from "./chunk_decal_record.js";
 import {
     DECAL_CLUSTER_LOCAL_LIMIT,
     DECAL_CLUSTER_METADATA,
     DECAL_CLUSTER_RESOLUTION_Z,
     DECAL_CLUSTER_TILE_RESOLUTION
 } from "./DECAL_CLUSTER.js";
-import { DECAL_RECORD_OFFSET_TRANSFORM, DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
 
 export const DECAL_CLUSTER_ASSIGNMENT_SETTINGS = WebGPUStruct.from({
     cluster_params: vec3f,
@@ -77,20 +77,6 @@ const DECAL_CLUSTER_WORKGROUP_SIZE = [4, 4, 4];
 const body = CodeChunk.from(
     //language=WGSL
     `
-const DECAL_RECORD_WORD_COUNT : u32 = ${DECAL_RECORD_WORD_COUNT}u;
-const DECAL_RECORD_OFFSET_TRANSFORM : u32 = ${DECAL_RECORD_OFFSET_TRANSFORM}u;
-
-fn decal_transform(index: u32) -> mat4x4<f32> {
-    let base = index * DECAL_RECORD_WORD_COUNT + DECAL_RECORD_OFFSET_TRANSFORM;
-
-    return mat4x4<f32>(
-        vec4<f32>(decal_data[base + 0u],  decal_data[base + 1u],  decal_data[base + 2u],  decal_data[base + 3u]),
-        vec4<f32>(decal_data[base + 4u],  decal_data[base + 5u],  decal_data[base + 6u],  decal_data[base + 7u]),
-        vec4<f32>(decal_data[base + 8u],  decal_data[base + 9u],  decal_data[base + 10u], decal_data[base + 11u]),
-        vec4<f32>(decal_data[base + 12u], decal_data[base + 13u], decal_data[base + 14u], decal_data[base + 15u])
-    );
-}
-
 @compute @workgroup_size(${DECAL_CLUSTER_WORKGROUP_SIZE.join(', ')})
 fn main(
     @builtin(global_invocation_id) voxel_position : vec3<u32>
@@ -208,6 +194,7 @@ fn main(
         chunk_frustum_from_corners,
         chunk_frustum_slice,
         chunk_decal_intersects_frustum,
+        chunk_decal_record,
         chunk_cluster_depth_from_z_slice,
         chunk_light_cluster_resolution_xy_from_screen,
         chunk_inverse_lerp

package/src/engine/graphics3/decal/shader_cull_decals_frustum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_cull_decals_frustum.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_cull_decals_frustum.js"],"names":[],"mappings":"AAyFA;;;;;;;;GAQG;AACH,yCAFU,aAAa,CAMpB;AAEH;;GAEG;AACH,kCAFU,YAAY,CAE6B;8BAtGrB,iDAAiD;6BAMlD,qDAAqD"}
+{"version":3,"file":"shader_cull_decals_frustum.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_cull_decals_frustum.js"],"names":[],"mappings":"AA4EA;;;;;;;;GAQG;AACH,yCAFU,aAAa,CAMpB;AAEH;;GAEG;AACH,kCAFU,YAAY,CAE6B;8BAzFrB,iDAAiD;6BAMlD,qDAAqD"}

package/src/engine/graphics3/decal/shader_cull_decals_frustum.js

@@ -11,7 +11,7 @@ import { atomic_u32, u32, vec4f } from "../../../shade/renderer/shader/type/WEBG
 import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
 import { chunk_decal_intersects_frustum } from "./chunk_decal_intersects_frustum.js";
-import { DECAL_RECORD_OFFSET_TRANSFORM, DECAL_RECORD_WORD_COUNT } from "./DECAL_GPU_RECORD.js";
+import { chunk_decal_record } from "./chunk_decal_record.js";
 
 /**
  * @type {number}
@@ -42,20 +42,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const DECAL_RECORD_WORD_COUNT : u32 = ${DECAL_RECORD_WORD_COUNT}u;
-const DECAL_RECORD_OFFSET_TRANSFORM : u32 = ${DECAL_RECORD_OFFSET_TRANSFORM}u;
-
-fn decal_transform(index: u32) -> mat4x4<f32> {
-    let base = index * DECAL_RECORD_WORD_COUNT + DECAL_RECORD_OFFSET_TRANSFORM;
-
-    return mat4x4<f32>(
-        vec4<f32>(decal_data[base + 0u],  decal_data[base + 1u],  decal_data[base + 2u],  decal_data[base + 3u]),
-        vec4<f32>(decal_data[base + 4u],  decal_data[base + 5u],  decal_data[base + 6u],  decal_data[base + 7u]),
-        vec4<f32>(decal_data[base + 8u],  decal_data[base + 9u],  decal_data[base + 10u], decal_data[base + 11u]),
-        vec4<f32>(decal_data[base + 12u], decal_data[base + 13u], decal_data[base + 14u], decal_data[base + 15u])
-    );
-}
-
 @compute @workgroup_size(${SHADER_CULL_DECALS_WORKGROUP_SIZE}, 1, 1)
 fn main(
     @builtin(global_invocation_id) global_id : vec3<u32>
@@ -83,7 +69,8 @@ fn main(
     }
 }
     `, [
-        chunk_decal_intersects_frustum
+        chunk_decal_intersects_frustum,
+        chunk_decal_record,
     ]
 );
 

package/src/engine/graphics3/decal/shader_decal_composite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAgEA,oDAKG;AA2SH;;;;;;;;;;;;;;GAcG;AACH,qCAFU,eAAe,CActB;6BA9V0B,qDAAqD;gCARlD,sBAAsB"}
+{"version":3,"file":"shader_decal_composite.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/decal/shader_decal_composite.js"],"names":[],"mappings":"AAgEA,oDAKG;AAuRH;;;;;;;;;;;;;;GAcG;AACH,qCAFU,eAAe,CActB;6BAzU0B,qDAAqD;gCARlD,sBAAsB"}

package/src/engine/graphics3/decal/shader_decal_composite.js

@@ -33,6 +33,7 @@ import {
 import {
     GRADIENT_SAMPLING_INFO_STRUCT
 } from "../../../shade/renderer/shader/chunk/texture/GRADIENT_SAMPLING_INFO_STRUCT.js";
+import { chunk_decal_record } from "./chunk_decal_record.js";
 import { chunk_decal_sampling_info } from "./chunk_decal_sampling_info.js";
 import { chunk_decal_surface_frame } from "./chunk_decal_surface_frame.js";
 import { DecalTileShader } from "./DecalTileShader.js";
@@ -58,8 +59,7 @@ import {
     DECAL_RECORD_OFFSET_TRANSFORM_INVERSE,
     DECAL_RECORD_OFFSET_UV_ALBEDO,
     DECAL_RECORD_OFFSET_UV_NORMAL,
-    DECAL_RECORD_OFFSET_UV_ORM,
-    DECAL_RECORD_WORD_COUNT
+    DECAL_RECORD_OFFSET_UV_ORM
 } from "./DECAL_GPU_RECORD.js";
 
 export const DECAL_COMPOSITE_SETTINGS = WebGPUStruct.from({
@@ -113,27 +113,6 @@ resources.createGroup()
 const body = CodeChunk.from(
     //language=WGSL
     `
-const DECAL_RECORD_WORD_COUNT : u32 = ${DECAL_RECORD_WORD_COUNT}u;
-
-fn decal_vec4(index: u32, field: u32) -> vec4<f32> {
-    let base = index * DECAL_RECORD_WORD_COUNT + field;
-
-    return vec4<f32>(
-        decal_data[base], decal_data[base + 1u], decal_data[base + 2u], decal_data[base + 3u]
-    );
-}
-
-fn decal_matrix(index: u32, field: u32) -> mat4x4<f32> {
-    let base = index * DECAL_RECORD_WORD_COUNT + field;
-
-    return mat4x4<f32>(
-        vec4<f32>(decal_data[base + 0u],  decal_data[base + 1u],  decal_data[base + 2u],  decal_data[base + 3u]),
-        vec4<f32>(decal_data[base + 4u],  decal_data[base + 5u],  decal_data[base + 6u],  decal_data[base + 7u]),
-        vec4<f32>(decal_data[base + 8u],  decal_data[base + 9u],  decal_data[base + 10u], decal_data[base + 11u]),
-        vec4<f32>(decal_data[base + 12u], decal_data[base + 13u], decal_data[base + 14u], decal_data[base + 15u])
-    );
-}
-
 struct DecalCompositeOut {
     @location(0) pbr : vec2<f32>,
     @location(1) normal : vec4<u32>,
@@ -349,6 +328,7 @@ fn main(
         GRADIENT_SAMPLING_INFO_STRUCT.declaration_chunk,
         DECAL_CLUSTER_METADATA.declaration_chunk,
         chunk_textureSampleBarycentric,
+        chunk_decal_record,
         chunk_decal_sampling_info,
         chunk_decal_surface_frame,
         chunk_project_position_from_depth,

package/src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TERRAIN_MATERIAL_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AAEH;;;GAGG;AACH,kDAkBqB;AAErB;;;;;;;;;GASG;AACH,8CAFU,6BAA6B,CAE4C;AA2FnF;;GAEG;AACH;IACI,0BAAiC;IACjC,yBAAgC;IAChC,0BAAiC;IACjC,yBAAgC;IAEhC;;;;OAIG;IACH,QAFU,YAAU,IAAI,CAEV;IAEd;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,gBAFU,MAAM,CAEI;CACvB;AA6SD;;GAEG;AACH,wCAFU,qBAAqB,CAQ5B;iCAldU,OAAO,wDAAwD,EAAE,kBAAkB;kCACnF,OAAO,kEAAkE,EAAE,mBAAmB;gCAC9F,OAAO,sDAAsD,EAAE,iBAAiB;mCAChF,OAAO,2BAA2B,EAAE,oBAAoB;6BARxC,qDAAqD;8CAH3E,0EAA0E;AA4GjF;;;GAGG;AACH;IACI;;OAEG;IACH,SAFU,iBAAiB,GAAC,IAAI,CAEjB;IAEf;;OAEG;IACH,SAFU,MAAM,CAEH;IAEb;;OAEG;IACH,YAAc;IAEd,gBAQC;CACJ;sCA5IqC,oEAAoE"}
+{"version":3,"file":"TERRAIN_MATERIAL_TEMPLATE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AAEH;;;GAGG;AACH,kDAkBqB;AAErB;;;;;;;;;GASG;AACH,8CAFU,6BAA6B,CAE4C;AA2FnF;;GAEG;AACH;IACI,0BAAiC;IACjC,yBAAgC;IAChC,0BAAiC;IACjC,yBAAgC;IAEhC;;;;OAIG;IACH,QAFU,YAAU,IAAI,CAEV;IAEd;;OAEG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,gBAFU,MAAM,CAEI;CACvB;AA6SD;;GAEG;AACH,wCAFU,qBAAqB,CAQ5B;iCAldU,OAAO,wDAAwD,EAAE,kBAAkB;kCACnF,OAAO,kEAAkE,EAAE,mBAAmB;gCAC9F,OAAO,sDAAsD,EAAE,iBAAiB;mCAChF,OAAO,2BAA2B,EAAE,oBAAoB;6BATxC,qDAAqD;8CAH3E,0EAA0E;AA6GjF;;;GAGG;AACH;IACI;;OAEG;IACH,SAFU,iBAAiB,GAAC,IAAI,CAEjB;IAEf;;OAEG;IACH,SAFU,MAAM,CAEH;IAEb;;OAEG;IACH,YAAc;IAEd,gBAQC;CACJ;sCA7IqC,oEAAoE"}

package/src/engine/graphics3/terrain/TERRAIN_MATERIAL_TEMPLATE.js

@@ -14,6 +14,7 @@ import { WebGPUArray } from "../../../shade/renderer/shader/type/WebGPUArray.js"
 import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
 import { TextureFilterType } from "../../../shade/renderer/texture/TextureFilterType.js";
 import { chunk_terrain_material_surface } from "./chunk_terrain_material_surface.js";
+import { texture_mip_level_count } from "../../../shade/util/texture_mip_extent.js";
 
 /**
  * @typedef {import("../../../shade/renderer/material/GPUMaterialContext.js").GPUMaterialContext} GPUMaterialContext
@@ -208,7 +209,7 @@ function upload_texture(services, residency, image, depth, format, bytes_per_pix
             existing.destroy();
         }
 
-        const mip_levels = mips ? 1 + Math.floor(Math.log2(Math.max(image.width, image.height))) : 1;
+        const mip_levels = mips ? texture_mip_level_count(image.width, image.height, 1, "2d") : 1;
 
         residency.texture = services.textures.contextFromDescriptor(TextureDescriptor.from({
             label,