@woosh/meep-engine 3.52.0 → 3.54.0

package/src/shade/renderer/volumetrics/irradiance_clipmap/shader_irradiance_clipmap_build.js

@@ -0,0 +1,191 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+import { BRICK4_DATA_STRUCT } from "../../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS } from "../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { chunk_light_cluster_counts } from "../../light/cluster/chunk_light_cluster_counts.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../../light/cluster/shader_cluster_assign_lights.js";
+import { ENVIRONMENT_SH_TYPE } from "../../light/environment/shader_project_environment_sh.js";
+import { chunk_world_light_cluster_lookup } from "../../light/world_cluster/chunk_world_light_cluster_lookup.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_get_directional_light_info_by_index
+} from "../../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, i32, u32, vec3i, vec3u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_shadowmap_get_light_visibility } from "../../shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { chunk_volumetrics_irradiance_sh } from "../chunk_volumetrics_irradiance_sh.js";
+import { chunk_volumetrics_local_light_shadow } from "../chunk_volumetrics_local_light_shadow.js";
+import { chunk_irradiance_clipmap_gi_sample } from "./chunk_irradiance_clipmap_gi_sample.js";
+import { chunk_irradiance_clipmap_local_light } from "./chunk_irradiance_clipmap_local_light.js";
+import {
+    IRRADIANCE_CLIPMAP_LIGHT_BUDGET,
+    IRRADIANCE_CLIPMAP_TILE_FORMAT,
+} from "./IRRADIANCE_CLIPMAP.js";
+
+export const IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE = Object.freeze([4, 4, 4]);
+
+export const IRRADIANCE_CLIPMAP_BUILD_STRUCT = WebGPUStruct.from({
+    tile_origin: vec3u,
+    cascade_index: u32,
+    corner: vec3i,
+    cell_size: f32,
+    tile_size: vec3u,
+    border: i32,
+}, "IrradianceClipmapBuild");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("build_settings", IRRADIANCE_CLIPMAP_BUILD_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
+    .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false, true)
+    .addStorageBuffer("light_data", WebGPUArray.u32, false)
+    .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, false)
+    .addStorageBuffer("world_cluster_data", WebGPUArray.u32, false)
+    .addTexture("shadowmapAtlas", "depth")
+    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR)
+    .addStorageTexture("atlas_y", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only")
+    .addStorageTexture("atlas_cocg", IRRADIANCE_CLIPMAP_TILE_FORMAT, "3d", "write-only");
+
+resources.addGroup(LPV_SHADER_RESOURCE_GROUP_WITH_DEFAULTS);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${IRRADIANCE_CLIPMAP_BUILD_GROUP_SIZE.join(", ")})
+fn main(@builtin(global_invocation_id) local_texel: vec3<u32>) {
+    let tile_size = build_settings.tile_size;
+    if (any(local_texel >= tile_size)) {
+        return;
+    }
+
+    let local_cell = vec3<i32>(local_texel) - vec3<i32>(build_settings.border);
+    let world_cell = build_settings.corner + local_cell;
+    let position_ws = (vec3<f32>(world_cell) + vec3<f32>(0.5)) * build_settings.cell_size;
+
+    const INDIRECT_INTENSITY: f32 = ${INDIRECT_LIGHT_INTENSITY};
+    let gi_radiance = irradiance_clipmap_gi_sample(position_ws);
+    let scaled_gi = array<vec3<f32>, 4>(
+        gi_radiance[0] * INDIRECT_INTENSITY,
+        gi_radiance[1] * INDIRECT_INTENSITY,
+        gi_radiance[2] * INDIRECT_INTENSITY,
+        gi_radiance[3] * INDIRECT_INTENSITY,
+    );
+
+    var irradiance: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+    irradiance = volumetrics_irradiance_sh_add_radiance(irradiance, scaled_gi);
+
+    let to_camera = mat4_extract_position(camera.transform) - position_ws;
+    let to_camera_len = max(length(to_camera), 1e-5);
+    let toward_camera = to_camera / to_camera_len;
+
+    var directional_bits = directional_lights_iteration_mask(&light_data);
+    while (directional_bits != 0u) {
+        let directional_index = countTrailingZeros(directional_bits);
+        directional_bits &= ~(1u << directional_index);
+
+        let sun = get_directional_light_info_by_index(&light_data, directional_index);
+
+        let shadow_term = shadowmap_get_directional_light_visibility(
+            &light_data,
+            directional_index,
+            position_ws,
+            toward_camera,
+            sun.direction
+        );
+
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * sun.color, sun.direction);
+    }
+
+    let cluster_meta = world_light_cluster_metadata_by_texel(
+        build_settings.cascade_index,
+        local_texel,
+        tile_size
+    );
+
+    let cluster_offset = cluster_meta.offset;
+    let point_count = light_cluster_count_point(cluster_meta.counts);
+    let spot_count = light_cluster_count_spot(cluster_meta.counts);
+
+    for (var j = 0u; j < min(point_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); j++) {
+        let light_index = world_cluster_data[cluster_offset + j];
+        let direct_light = irradiance_clipmap_get_point_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_point_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    for (var k = 0u; k < min(spot_count, ${IRRADIANCE_CLIPMAP_LIGHT_BUDGET}u); k++) {
+        let light_index = world_cluster_data[cluster_offset + point_count + k];
+        let direct_light = irradiance_clipmap_get_spot_light_info_by_index(
+            &light_data,
+            light_index,
+            position_ws,
+            build_settings.cell_size
+        );
+
+        if (all(direct_light.color == vec3<f32>(0.0))) {
+            continue;
+        }
+
+        let shadow_term = volumetrics_spot_light_shadow(&light_data, light_index, position_ws);
+        irradiance = volumetrics_irradiance_sh_add(irradiance, shadow_term * direct_light.color, direct_light.direction);
+    }
+
+    let stored = volumetrics_irradiance_sh_storable(irradiance);
+    let atlas_texel = build_settings.tile_origin + local_texel;
+
+    textureStore(atlas_y, atlas_texel, stored.Y);
+    textureStore(atlas_cocg, atlas_texel, vec4<f32>(stored.CoCg, 0.0, 0.0));
+}
+`, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_mat4_extract_position,
+        chunk_irradiance_clipmap_gi_sample,
+        chunk_world_light_cluster_lookup,
+        chunk_light_cluster_counts,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_irradiance_clipmap_local_light,
+        chunk_shadowmap_get_light_visibility,
+        chunk_volumetrics_local_light_shadow,
+        chunk_volumetrics_irradiance_sh,
+    ]
+);
+
+/**
+ * Populates one cascade's tile (including its 1-texel trilinear skirt) in the synchronized `Y` and
+ * `CoCg` 3D tile atlases of the world-space irradiance clipmap.
+ *
+ * Evaluates indirect lighting (`INDIRECT_LIGHTING`), directional lights (`SHADOW_DIRECTIONAL_TECHNIQUE`),
+ * and world-space clustered point and spot lights with shadow maps at deterministic world-space
+ * voxel centres.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_irradiance_clipmap_build = ComputeShader.from({
+    label: "Volumetrics / irradiance clipmap build",
+    resources,
+    body,
+});

package/src/shade/renderer/volumetrics/shader_volumetrics_classify_froxels.d.ts

@@ -0,0 +1,16 @@
+export const VOLUMETRICS_CLASSIFY_WORKGROUP_RESOLUTION: readonly number[];
+/**
+ * Classifies every froxel of the volumetric grid into one of the three lighting regimes (Decision 4.2)
+ * using subgroup-coalesced appends ({@link chunk_collection_u32_append}):
+ *
+ * 1. `list_clipmap` — froxels fully inside the world-space irradiance clipmap (`c < count - 1`, or
+ *    `c == count - 1` with `edge_weight == 0`).
+ * 2. `list_blended` — froxels in the outer transition band of the coarsest cascade (`c == count - 1`
+ *    with `edge_weight > 0`), where clipmap irradiance blends into the far-field lighting.
+ * 3. `list_far_field` — froxels outside all cascades (`CLIPMAP_LEVEL_NONE`).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_volumetrics_classify_froxels: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_classify_froxels.d.ts.map

package/src/shade/renderer/volumetrics/shader_volumetrics_classify_froxels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_classify_froxels.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_classify_froxels.js"],"names":[],"mappings":"AAgBA,0EAAkF;AAyDlF;;;;;;;;;;;GAWG;AACH,kDAFU,aAAa,CAMpB;8BApF2B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_lighting_regimes.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Workgroup size (64 threads) used by each of the 3 volumetric lighting regime dispatches.
+ * @type {number}
+ */
+export const VOLUMETRICS_REGIME_WORKGROUP_SIZE: number;
+/**
+ * Evaluates far-field in-scattering at a froxel sample (`VolumetricsFroxelSample`) using the same
+ * full irradiance model as the world-space irradiance clipmap (environment GI + directional lights
+ * with atmospheric transmittance and multiple scattering, evaluated through
+ * `irradiance_clipmap_sh_multiscattering`).
+ *
+ * Shared as a first-class {@link CodeChunk} between `shader_volumetrics_lighting_blended` and
+ * `shader_volumetrics_lighting_far_field`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_volumetrics_far_field_directional: CodeChunk;
+export const shader_volumetrics_lighting_clipmap: ComputeShader;
+export const shader_volumetrics_lighting_blended: ComputeShader;
+export const shader_volumetrics_lighting_far_field: ComputeShader;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_volumetrics_lighting_regimes.d.ts.map

package/src/shade/renderer/volumetrics/shader_volumetrics_lighting_regimes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_volumetrics_lighting_regimes.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_lighting_regimes.js"],"names":[],"mappings":"AA+CA;;;GAGG;AACH,gDAFU,MAAM,CAEoC;AAEpD;;;;;;;;;;GAUG;AACH,sDAFU,SAAS,CA6FjB;AAwFF,gEAIG;AAuFH,gEAIG;AA2DH,kEAIG;0BAhYuB,iCAAiC;8BAC7B,4BAA4B"}

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#172@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#161@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/renderer/wind/GPUSceneWind.js

@@ -126,7 +126,7 @@ export class GPUSceneWind {
 
         return new GPUTileAtlas3D({
             device,
-            format: WIND_FIELD_TILE_FORMAT,
+            formats: [WIND_FIELD_TILE_FORMAT],
             // copied by the atlas; made only when the atlas is
             content_size: [content[0], content[1], content[2]],
             border: WIND_FIELD_TILE_BORDER,

package/src/shade/wgsl/emulator/WGSLJavaScriptCompiler.js

@@ -2975,7 +2975,7 @@ function inferBuiltinReturnType(name, args) {
         // the two values; the third argument is the condition
         return commonArgumentType(args.slice(0, 2));
     }
-    if (name === 'textureLoad' || name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleGrad') {
+    if (name === 'textureLoad' || name === 'textureSampleLevel' || name === 'textureSample' || name === 'textureSampleBias' || name === 'textureSampleGrad') {
         return { kind: 'vec', size: 4, scalar: 'f32' };
     }
     // Both gathers return the four texels of a 2x2 footprint. Saying so here matters more than

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA6jDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IA4oDA;;;;;;;;;;;;;;OAcG;IACH,+DAmDC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -1067,7 +1067,8 @@ export const WGSLLanguageCore = {
     },
 
     /**
-     * `textureSampleLevel(t, s, coords, level) -> vec4<T>`
+     * `textureSampleLevel(t, s, coords, level[, offset]) -> vec4<T>` and the texture_2d_array form
+     * `textureSampleLevel(t, s, coords, array_index, level[, offset])`.
      *
      * Filtered sample at normalised UV coords. Honours the sampler's
      * address modes and `magFilter`. `coords` length matches the texture
@@ -1076,33 +1077,59 @@ export const WGSLLanguageCore = {
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor | null} sampler
      * @param {Float32Array | number[] | number} coords
-     * @param {number} [_level]
+     * @param {number} [p3] — `level`, or `array_index` in the array forms
+     * @param {number | Int32Array | number[]} [p4] — `level` in the array forms, or `offset`
+     * @param {Int32Array | number[]} [p5] — `offset` in the array form
      * @returns {Float32Array}
      */
-    textureSampleLevel(t, sampler, coords, _level_or_index = 0, _array_level = undefined) {
+    textureSampleLevel(t, sampler, coords, p3 = 0, p4 = undefined, p5 = undefined) {
         assert.defined(t, 'texture');
+
+        let array_index = undefined;
+        let offset = undefined;
+
+        if (p5 !== undefined) {
+            // (t, s, coords, array_index, level, offset)
+            array_index = p3;
+            offset = p5;
+        } else if (p4 === undefined) {
+            // (t, s, coords, level)
+        } else if (typeof p4 === 'number') {
+            // (t, s, coords, array_index, level)
+            array_index = p3;
+        } else {
+            // (t, s, coords, level, offset)
+            offset = p4;
+        }
+
         const dim = t.dimensionality;
         // Convert UV (normalised) to texel-space coords expected by
         // cpu_texture_sample. coords for a 1D texture is a scalar in WGSL.
         const u = dim >= 1 ? (typeof coords === 'number' ? coords : coords[0]) : 0;
         const v = dim >= 2 ? coords[1] : 0;
-        const tx = u * t.size[0];
-        const ty = v * t.size[1];
+        const ox = offset !== undefined ? (offset[0] | 0) : 0;
+        const oy = offset !== undefined && offset.length >= 2 ? (offset[1] | 0) : 0;
+        const tx = u * t.size[0] + ox;
+        const ty = v * t.size[1] + oy;
         /**
          * @type {number[]}
          */
         let texel_coord;
-        if (_array_level !== undefined) {
+        if (array_index !== undefined) {
             /*
-             Five arguments is the texture_2d_array form — (t, s, uv, array_index, level) — where the
-             fourth argument selects a slice. A slice's texel-space centre sits at index + 0.5, which
-             lands the linear filter's z weight on exactly that slice: filtering happens in xy and
-             never crosses into a neighbour.
+             The texture_2d_array form — (t, s, uv, array_index, level[, offset]) — where the
+             fourth argument selects a slice. The array index is clamped to the layer count rather
+             than wrapped by addressModeW, and a slice's texel-space centre sits at index + 0.5,
+             which lands the linear filter's z weight on exactly that slice: filtering happens in
+             xy and never crosses into a neighbour.
             */
-            texel_coord = [tx, ty, (_level_or_index | 0) + 0.5];
+            const d = t.size[2];
+            const z = d <= 0 ? 0 : Math.min(Math.max(array_index | 0, 0), d - 1);
+            texel_coord = [tx, ty, z + 0.5];
         } else {
             const w = dim >= 3 ? coords[2] : 0;
-            const tz = w * t.size[2];
+            const oz = offset !== undefined && offset.length >= 3 ? (offset[2] | 0) : 0;
+            const tz = w * t.size[2] + oz;
             texel_coord = dim === 1 ? [tx] : (dim === 2 ? [tx, ty] : [tx, ty, tz]);
         }
         const result = new Float32Array(4);
@@ -1111,8 +1138,8 @@ export const WGSLLanguageCore = {
     },
 
     /**
-     * `textureSample(t, s, coords) -> vec4<T>` and the texture_2d_array form
-     * `textureSample(t, s, coords, array_index)`.
+     * `textureSample(t, s, coords[, offset]) -> vec4<T>` and the texture_2d_array form
+     * `textureSample(t, s, coords, array_index[, offset])`.
      *
      * Implicit-LOD sample. Without mipmaps, this is just
      * `textureSampleLevel` at level 0.
@@ -1120,37 +1147,89 @@ export const WGSLLanguageCore = {
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor | null} sampler
      * @param {Float32Array | number[] | number} coords
-     * @param {number} [array_index]
+     * @param {number | Int32Array | number[]} [p3] — `array_index`, or `offset`
+     * @param {Int32Array | number[]} [p4] — `offset` in the array form
      * @returns {Float32Array}
      */
-    textureSample(t, sampler, coords, array_index = undefined) {
-        if (array_index !== undefined) {
-            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, array_index, 0);
+    textureSample(t, sampler, coords, p3 = undefined, p4 = undefined) {
+        if (p4 !== undefined) {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0, p4);
+        }
+
+        if (typeof p3 === 'number') {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0);
+        }
+
+        if (p3 !== undefined) {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0, p3);
         }
 
         return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0);
     },
 
     /**
-     * `textureSampleGrad(t, s, coords, ddx, ddy) -> vec4<T>` and the texture_2d_array form
-     * `textureSampleGrad(t, s, coords, array_index, ddx, ddy)`.
+     * `textureSampleBias(t, s, coords, bias[, offset]) -> vec4<T>` and the texture_2d_array form
+     * `textureSampleBias(t, s, coords, array_index, bias[, offset])`.
      *
-     * Explicit-gradient sample. Mipmaps are not modelled (see the header), so the gradients only
-     * disambiguate which call shape this is: six arguments carry an array index, five do not.
+     * Implicit-LOD sample with a mip bias. Mipmaps are not modelled (see the header), so the bias
+     * is ignored and this routes through `textureSampleLevel` at level 0. Overloads are told apart
+     * by argument shape: a scalar fifth argument is the array form's `bias` (making the fourth the
+     * `array_index`), while a vector is the const `offset`.
      *
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor | null} sampler
      * @param {Float32Array | number[] | number} coords
-     * @param {Float32Array | number[] | number} p3 gradient, or the array index
-     * @param {Float32Array | number[]} p4 gradient
-     * @param {Float32Array | number[]} [p5] gradient, in the array form
+     * @param {number} p3 — `bias`, or `array_index` in the array forms
+     * @param {number | Int32Array | number[]} [p4] — `bias` in the array forms, or `offset`
+     * @param {Int32Array | number[]} [p5] — `offset` in the array form
      * @returns {Float32Array}
      */
-    textureSampleGrad(t, sampler, coords, p3, p4, p5 = undefined) {
+    textureSampleBias(t, sampler, coords, p3, p4 = undefined, p5 = undefined) {
         if (p5 !== undefined) {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0, p5);
+        }
+
+        if (p4 === undefined) {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0);
+        }
+
+        if (typeof p4 === 'number') {
             return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0);
         }
 
+        return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0, p4);
+    },
+
+    /**
+     * `textureSampleGrad(t, s, coords, ddx, ddy[, offset]) -> vec4<T>` and the texture_2d_array form
+     * `textureSampleGrad(t, s, coords, array_index, ddx, ddy[, offset])`.
+     *
+     * Explicit-gradient sample. Mipmaps are not modelled (see the header), so the gradients are
+     * ignored and this routes through `textureSampleLevel` at level 0. A scalar fourth argument is
+     * the array form's `array_index`; a vector is `ddx`.
+     *
+     * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+     * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor | null} sampler
+     * @param {Float32Array | number[] | number} coords
+     * @param {Float32Array | number[] | number} p3 gradient `ddx`, or the `array_index`
+     * @param {Float32Array | number[]} p4 gradient (`ddy`, or `ddx` in the array form)
+     * @param {Float32Array | Int32Array | number[]} [p5] `ddy` in the array form, or `offset`
+     * @param {Int32Array | number[]} [p6] `offset` in the array form
+     * @returns {Float32Array}
+     */
+    textureSampleGrad(t, sampler, coords, p3, p4, p5 = undefined, p6 = undefined) {
+        if (typeof p3 === 'number') {
+            if (p6 !== undefined) {
+                return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0, p6);
+            }
+
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, p3, 0);
+        }
+
+        if (p5 !== undefined) {
+            return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0, p5);
+        }
+
         return WGSLLanguageCore.textureSampleLevel(t, sampler, coords, 0);
     },
 

package/src/engine/graphics/composit/CompositingStages.d.ts

@@ -1,6 +0,0 @@
-export type CompositingStages = number;
-export namespace CompositingStages {
-    let POST_OPAQUE: number;
-    let POST_TRANSPARENT: number;
-}
-//# sourceMappingURL=CompositingStages.d.ts.map

package/src/engine/graphics/composit/CompositingStages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompositingStages.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/composit/CompositingStages.js"],"names":[],"mappings":"gCAEU,MAAM"}

package/src/engine/graphics/composit/CompositingStages.js

@@ -1,8 +0,0 @@
-/**
- * @readonly
- * @enum {number}
- */
-export const CompositingStages = {
-    POST_OPAQUE: 1,
-    POST_TRANSPARENT: 0
-}

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param {*} attribute
- * @returns {number}
- */
-export function computeBufferAttributeHash(attribute: any): number;
-//# sourceMappingURL=computeBufferAttributeHash.d.ts.map

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeBufferAttributeHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,4DAFa,MAAM,CAgBlB"}

package/src/engine/graphics/geometry/buffered/computeBufferAttributeHash.js

@@ -1,24 +0,0 @@
-import { sparse_typed_array_hash } from "../../../../core/collection/array/typed/sparse_typed_array_hash.js";
-
-/**
- *
- * @param {*} attribute
- * @returns {number}
- */
-export function computeBufferAttributeHash(attribute) {
-    let result = 0;
-
-    if (attribute !== null) {
-        const data = attribute.array;
-        const data_size = data.length;
-
-        result += data_size;
-
-        result ^= sparse_typed_array_hash(data, 0, data_size);
-
-    }
-
-    return result;
-}
-
-

package/src/engine/graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.d.ts

@@ -1,8 +0,0 @@
-/**
- *
- * @param {BufferGeometry} geometry
- * @returns {Vector4} x,y,z are sphere center and w is radius
- */
-export function computeGeometryBoundingSphereMiniball(geometry: BufferGeometry): Vector4;
-import Vector4 from "../../../../core/geom/Vector4.js";
-//# sourceMappingURL=computeGeometryBoundingSphereMiniball.d.ts.map

package/src/engine/graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeGeometryBoundingSphereMiniball.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,iFAFa,OAAO,CAUnB;oBAhBmB,kCAAkC"}

package/src/engine/graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js

@@ -1,17 +0,0 @@
-import Vector4 from "../../../../core/geom/Vector4.js";
-import { computeBoundingSphereFromVertexData } from "../computeBoundingSphereFromVertexData.js";
-
-/**
- *
- * @param {BufferGeometry} geometry
- * @returns {Vector4} x,y,z are sphere center and w is radius
- */
-export function computeGeometryBoundingSphereMiniball(geometry) {
-    const vertexData = geometry.attributes.position.array;
-
-
-    const result = new Vector4();
-    computeBoundingSphereFromVertexData(vertexData, result);
-
-    return result;
-}

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.d.ts

@@ -1,8 +0,0 @@
-/**
- *
- * @param {*} a
- * @param {*} b
- * @returns {boolean}
- */
-export function computeGeometryEquality(a: any, b: any): boolean;
-//# sourceMappingURL=computeGeometryEquality.d.ts.map

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeGeometryEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryEquality.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,yDAFa,OAAO,CAmDnB"}

package/src/engine/graphics/geometry/buffered/computeGeometryEquality.js

@@ -1,60 +0,0 @@
-import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
-import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
-
-
-/**
- *
- * @param {*} a
- * @param {*} b
- * @returns {boolean}
- */
-export function computeGeometryEquality(a, b) {
-    if (a === b) {
-        // identity shortcut
-        return true;
-    }
-
-    const a_index = a.getIndex();
-    const b_index = b.getIndex();
-
-    if (a_index !== b_index) {
-        if (a_index === null || b_index === null) {
-            return false;
-        }
-
-        if (!is_typed_array_equals(a_index.array, b_index.array)) {
-            return false;
-        }
-    }
-
-    const a_attribute_keys = Object.keys(a.attributes);
-    const b_attribute_keys = Object.keys(b.attributes);
-
-    const attribute_count = a_attribute_keys.length;
-    if (attribute_count !== b_attribute_keys.length) {
-        return false;
-    }
-
-    // sorting keys ensures that order is not relevant
-    a_attribute_keys.sort();
-    b_attribute_keys.sort();
-
-
-    if (!isArrayEqualStrict(a_attribute_keys, b_attribute_keys)) {
-        return false;
-    }
-
-    // compare individual attributes
-    for (let i = 0; i < attribute_count; i++) {
-        const key = a_attribute_keys[i];
-
-        const a_attribute = a.attributes[key];
-        const b_attribute = b.attributes[key];
-
-        if (!is_typed_array_equals(a_attribute.array, b_attribute.array)) {
-            return false;
-        }
-    }
-
-    return true;
-}

package/src/engine/graphics/geometry/buffered/computeGeometryHash.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param {*} geometry
- * @returns {number}
- */
-export function computeGeometryHash(geometry: any): number;
-//# sourceMappingURL=computeGeometryHash.d.ts.map

package/src/engine/graphics/geometry/buffered/computeGeometryHash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeGeometryHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/computeGeometryHash.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,oDAFa,MAAM,CAmBlB"}