@woosh/meep-engine 3.29.0 → 3.31.0

package/src/shade/renderer/texture/encode/shader_texture_encode_bc6h.js

@@ -1,62 +1,65 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { chunk_bc6h_encode_block_mode11 } from "./chunk_bc6h_encode_block_mode11.js";
-import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
-import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
-import { texture_encode_resources } from "./texture_encode_resources.js";
-
-/**
- * Every level of an HDR texture to `bc6h-rgb-ufloat`, one invocation per block.
- *
- * The RGB of whatever `encode_source` samples as — an `rgba16float` texture, in practice — fitted
- * by {@link chunk_bc6h_encode_block_mode11}. Alpha is not read: the format has none. Mode 11 only;
- * the dispatch shape is {@link shader_texture_encode_bc4}'s and a block is four words.
- *
- * @type {ComputeShader}
- */
-export const shader_texture_encode_bc6h = ComputeShader.from({
-    label: 'texture_encode/bc6h-rgb-ufloat',
-    resources: texture_encode_resources(),
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-@compute @workgroup_size(${TEXTURE_ENCODE_WORKGROUP_SIZE}, 1, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-    @builtin(num_workgroups) groups: vec3<u32>,
-) {
-    let block = gid.y * groups.x * ${TEXTURE_ENCODE_WORKGROUP_SIZE}u + gid.x;
-
-    if (block >= texture_encode_block_count()) {
-        return;
-    }
-
-    let level = texture_encode_level_of_block(block);
-
-    let local = block - level.first_block;
-
-    let block_x = local % level.blocks_x;
-    let block_y = local / level.blocks_x;
-
-    let texels = texture_encode_load_block(level, block_x, block_y);
-
-    var rgb: array<vec3<f32>, 16>;
-
-    for (var i = 0u; i < 16u; i++) {
-        rgb[i] = texels[i].xyz;
-    }
-
-    let packed = bc6h_encode_block_mode11(rgb);
-
-    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
-
-    encode_output[word] = packed.x;
-    encode_output[word + 1u] = packed.y;
-    encode_output[word + 2u] = packed.z;
-    encode_output[word + 3u] = packed.w;
-}
-`, [
-            chunk_texture_encode_load_block,
-            chunk_bc6h_encode_block_mode11,
-        ]),
-});
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc6h_encode_block_mode11 } from "./chunk_bc6h_encode_block_mode11.js";
+import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
+import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
+import { texture_encode_resources } from "./texture_encode_resources.js";
+
+/**
+ * Every level of an HDR texture to `bc6h-rgb-ufloat`, one invocation per block.
+ *
+ * The RGB of whatever `encode_source` samples as — an `rgba16float` texture, in practice — fitted
+ * by {@link chunk_bc6h_encode_block_mode11}. Alpha is not read: the format has none. Mode 11 only;
+ * the dispatch shape is {@link shader_texture_encode_bc4}'s and a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc6h = ComputeShader.from({
+    label: 'texture_encode/bc6h-rgb-ufloat',
+    resources: texture_encode_resources(),
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${TEXTURE_ENCODE_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) groups: vec3<u32>,
+    @builtin(local_invocation_index) local_index: u32,
+) {
+    let block = grid3d_to_index(workgroup_id, groups.xy) * ${TEXTURE_ENCODE_WORKGROUP_SIZE}u + local_index;
+
+    if (block >= texture_encode_block_count()) {
+        return;
+    }
+
+    let level = texture_encode_level_of_block(block);
+
+    let local = block - level.first_block;
+
+    let block_x = local % level.blocks_x;
+    let block_y = local / level.blocks_x;
+
+    let texels = texture_encode_load_block(level, block_x, block_y);
+
+    var rgb: array<vec3<f32>, 16>;
+
+    for (var i = 0u; i < 16u; i++) {
+        rgb[i] = texels[i].xyz;
+    }
+
+    let packed = bc6h_encode_block_mode11(rgb);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+    encode_output[word + 2u] = packed.z;
+    encode_output[word + 3u] = packed.w;
+}
+`, [
+            chunk_grid3d_to_index,
+            chunk_texture_encode_load_block,
+            chunk_bc6h_encode_block_mode11,
+        ]),
+});

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,wCAFU,aAAa,CAyCpB;8BAxD2B,+BAA+B"}
+{"version":3,"file":"shader_texture_encode_bc7.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/encode/shader_texture_encode_bc7.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,wCAFU,aAAa,CA2CpB;8BA1D2B,+BAA+B"}

package/src/shade/renderer/texture/encode/shader_texture_encode_bc7.js

@@ -1,58 +1,61 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { chunk_bc7_encode_block_mode6 } from "./chunk_bc7_encode_block_mode6.js";
-import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
-import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
-import { texture_encode_resources } from "./texture_encode_resources.js";
-
-/**
- * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
- *
- * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
- * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
- * partitioned modes is a later quality step, and a separate chunk — this shader would call it
- * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
- * {@link shader_texture_encode_bc4}'s; a block is four words.
- *
- * @type {ComputeShader}
- */
-export const shader_texture_encode_bc7 = ComputeShader.from({
-    label: 'texture_encode/bc7-rgba-unorm',
-    resources: texture_encode_resources(),
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-@compute @workgroup_size(${TEXTURE_ENCODE_WORKGROUP_SIZE}, 1, 1)
-fn main(
-    @builtin(global_invocation_id) gid: vec3<u32>,
-    @builtin(num_workgroups) groups: vec3<u32>,
-) {
-    let block = gid.y * groups.x * ${TEXTURE_ENCODE_WORKGROUP_SIZE}u + gid.x;
-
-    if (block >= texture_encode_block_count()) {
-        return;
-    }
-
-    let level = texture_encode_level_of_block(block);
-
-    let local = block - level.first_block;
-
-    let block_x = local % level.blocks_x;
-    let block_y = local / level.blocks_x;
-
-    let texels = texture_encode_load_block(level, block_x, block_y);
-
-    let packed = bc7_encode_block_mode6(texels);
-
-    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
-
-    encode_output[word] = packed.x;
-    encode_output[word + 1u] = packed.y;
-    encode_output[word + 2u] = packed.z;
-    encode_output[word + 3u] = packed.w;
-}
-`, [
-            chunk_texture_encode_load_block,
-            chunk_bc7_encode_block_mode6,
-        ]),
-});
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_bc7_encode_block_mode6 } from "./chunk_bc7_encode_block_mode6.js";
+import { chunk_texture_encode_load_block } from "./chunk_texture_encode_load_block.js";
+import { TEXTURE_ENCODE_WORKGROUP_SIZE } from "./shader_texture_encode_bc4.js";
+import { texture_encode_resources } from "./texture_encode_resources.js";
+
+/**
+ * Every level of a texture to `bc7-rgba-unorm` or its sRGB twin, one invocation per block.
+ *
+ * **Mode 6 only**, today: the single-subset mode with the finest indices, fitted by
+ * {@link chunk_bc7_encode_block_mode6} over all four channels. A mode search across the
+ * partitioned modes is a later quality step, and a separate chunk — this shader would call it
+ * instead, and nothing about the format or the bytes it produces changes. The dispatch shape is
+ * {@link shader_texture_encode_bc4}'s; a block is four words.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_texture_encode_bc7 = ComputeShader.from({
+    label: 'texture_encode/bc7-rgba-unorm',
+    resources: texture_encode_resources(),
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${TEXTURE_ENCODE_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(num_workgroups) groups: vec3<u32>,
+    @builtin(local_invocation_index) local_index: u32,
+) {
+    let block = grid3d_to_index(workgroup_id, groups.xy) * ${TEXTURE_ENCODE_WORKGROUP_SIZE}u + local_index;
+
+    if (block >= texture_encode_block_count()) {
+        return;
+    }
+
+    let level = texture_encode_level_of_block(block);
+
+    let local = block - level.first_block;
+
+    let block_x = local % level.blocks_x;
+    let block_y = local / level.blocks_x;
+
+    let texels = texture_encode_load_block(level, block_x, block_y);
+
+    let packed = bc7_encode_block_mode6(texels);
+
+    let word = level.word_offset + block_y * level.row_stride_words + block_x * 4u;
+
+    encode_output[word] = packed.x;
+    encode_output[word + 1u] = packed.y;
+    encode_output[word + 2u] = packed.z;
+    encode_output[word + 3u] = packed.w;
+}
+`, [
+            chunk_grid3d_to_index,
+            chunk_texture_encode_load_block,
+            chunk_bc7_encode_block_mode6,
+        ]),
+});

package/src/shade/renderer/texture/format/texture_format_from_shade_image.d.ts

@@ -15,10 +15,16 @@
  * (`gltf_create_material` among them), so a format captured once would leave every glTF albedo map
  * on `rgba8unorm` and silently drop its sRGB decode.
  *
+ * The colour space is a parameter because it belongs to the (image, ROLE) pair and not to the
+ * image: one glTF image is routinely named by two textures in two slots — a base colour in one
+ * material and a metallic-roughness in another — and the two want different decodes.
+ *
  * @param {ShadeImage} image
+ * @param {ColorSpace|number} [color_space] defaults to the image's own
  * @returns {GPUTextureFormat}
  * @throws {Error} if the image has no source, or one this does not recognise — a format guessed for
  * texels nobody can describe would put the wrong number of bytes on both sides of the upload
  */
-export function texture_format_from_shade_image(image: ShadeImage): GPUTextureFormat;
+export function texture_format_from_shade_image(image: ShadeImage, color_space?: ColorSpace | number): GPUTextureFormat;
+import { ColorSpace } from "../ColorSpace.js";
 //# sourceMappingURL=texture_format_from_shade_image.d.ts.map

package/src/shade/renderer/texture/format/texture_format_from_shade_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_format_from_shade_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/texture_format_from_shade_image.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qFAkEC"}
+{"version":3,"file":"texture_format_from_shade_image.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/format/texture_format_from_shade_image.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,iFALW,UAAU,GAAC,MAAM,oBAuE3B;2BAhG0B,kBAAkB"}

package/src/shade/renderer/texture/format/texture_format_from_shade_image.js

@@ -1,95 +1,100 @@
-import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
-import { isImageBitmap } from "../../../../core/dom/isImageBitmap.js";
-import { gpu_texture_format_srgb } from "../../../descriptor/texture/format/gpu_texture_format_srgb.js";
-import { ColorSpace } from "../ColorSpace.js";
-import { infer_format_from_parameters } from "./infer_format_from_parameters.js";
-
-/**
- * The {@link GPUTextureFormat} a {@link ShadeImage}'s texels are in.
- *
- * A free function rather than a getter on the image, because {@link ShadeImage} describes *data* —
- * a channel count, a data type, a colour space, some bytes — and what WebGPU calls that arrangement
- * is not the data's business. The image stays a model the encoder, the container readers and the
- * asset pipeline can hold without any of them importing a graphics API.
- *
- * What this replaces is the same inference run at *upload* time, inside the descriptor builder. The
- * move matters more than the mechanism: a format worked out by inspecting pixels is a question
- * block-compressed texels cannot answer, so a {@link ShadeTexelData} states its format instead and
- * this function simply reports it. That is what lets both kinds share one path.
- *
- * **Not cached anywhere.** `color_space` is assigned *after* construction in nine places
- * (`gltf_create_material` among them), so a format captured once would leave every glTF albedo map
- * on `rgba8unorm` and silently drop its sRGB decode.
- *
- * @param {ShadeImage} image
- * @returns {GPUTextureFormat}
- * @throws {Error} if the image has no source, or one this does not recognise — a format guessed for
- * texels nobody can describe would put the wrong number of bytes on both sides of the upload
- */
-export function texture_format_from_shade_image(image) {
-    const source = image.source;
-
-    if (source === undefined || source === null) {
-        throw new Error(`image ${image.id} has no source, so no format`);
-    }
-
-    if (source.isShadeTexelData === true) {
-        /*
-         Already in a GPU format; it says which — but not whether sampling it decodes sRGB, which is
-         the image's business and not the payload's. `bc7-rgba-unorm` and `bc7-rgba-unorm-srgb` are
-         the same bytes, so a transcoder targeting one does exactly the work of the other and has no
-         reason to prefer either; what settles it is what the texture *means*, which is `color_space`
-         and is assigned after construction. Returning the payload's name verbatim ignored that and
-         put all 25 of Sponza's albedo maps on a linear format, sampling sRGB-encoded values as
-         though they were linear — brighter, flatter, and cold, because the decode that stretches
-         the gap between channels was the part being skipped.
-        */
-        if (image.color_space !== ColorSpace.SRGB) {
-            return source.format;
-        }
-
-        const srgb = gpu_texture_format_srgb(source.format);
-
-        if (srgb === undefined) {
-            throw new Error(
-                `image ${image.id} is sRGB but its payload is '${source.format}', which has no sRGB`
-                + ` counterpart, so the decode cannot be expressed. Transcode it to a format that`
-                + ` has one, or set color_space to something other than SRGB.`
-            );
-        }
-
-        return srgb;
-    }
-
-    if (source.isSampler2D === true) {
-        return infer_format_from_parameters(
-            image.channel_count, image.data_type, image.normalized, image.color_space
-        );
-    }
-
-    if (isImageBitmap(source)) {
-        /*
-         A bitmap is whatever the browser decoded it to, which is 8-bit RGBA — the channel count and
-         data type the image carries describe the file, not the decode.
-        */
-        if (image.data_type === BinaryDataType.Float16) {
-            return "rgba16float";
-        }
-
-        if (image.color_space === ColorSpace.SRGB) {
-            // sampling decodes sRGB to linear for free
-            // @see https://www.w3.org/TR/webgpu/#texture-formats
-            return "rgba8unorm-srgb";
-        }
-
-        return "rgba8unorm";
-    }
-
-    if (source instanceof ArrayBuffer) {
-        return infer_format_from_parameters(
-            image.channel_count, image.data_type, image.normalized, image.color_space
-        );
-    }
-
-    throw new Error(`Unsupported image data`);
-}
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
+import { isImageBitmap } from "../../../../core/dom/isImageBitmap.js";
+import { gpu_texture_format_srgb } from "../../../descriptor/texture/format/gpu_texture_format_srgb.js";
+import { ColorSpace } from "../ColorSpace.js";
+import { infer_format_from_parameters } from "./infer_format_from_parameters.js";
+
+/**
+ * The {@link GPUTextureFormat} a {@link ShadeImage}'s texels are in.
+ *
+ * A free function rather than a getter on the image, because {@link ShadeImage} describes *data* —
+ * a channel count, a data type, a colour space, some bytes — and what WebGPU calls that arrangement
+ * is not the data's business. The image stays a model the encoder, the container readers and the
+ * asset pipeline can hold without any of them importing a graphics API.
+ *
+ * What this replaces is the same inference run at *upload* time, inside the descriptor builder. The
+ * move matters more than the mechanism: a format worked out by inspecting pixels is a question
+ * block-compressed texels cannot answer, so a {@link ShadeTexelData} states its format instead and
+ * this function simply reports it. That is what lets both kinds share one path.
+ *
+ * **Not cached anywhere.** `color_space` is assigned *after* construction in nine places
+ * (`gltf_create_material` among them), so a format captured once would leave every glTF albedo map
+ * on `rgba8unorm` and silently drop its sRGB decode.
+ *
+ * The colour space is a parameter because it belongs to the (image, ROLE) pair and not to the
+ * image: one glTF image is routinely named by two textures in two slots — a base colour in one
+ * material and a metallic-roughness in another — and the two want different decodes.
+ *
+ * @param {ShadeImage} image
+ * @param {ColorSpace|number} [color_space] defaults to the image's own
+ * @returns {GPUTextureFormat}
+ * @throws {Error} if the image has no source, or one this does not recognise — a format guessed for
+ * texels nobody can describe would put the wrong number of bytes on both sides of the upload
+ */
+export function texture_format_from_shade_image(image, color_space = image.color_space) {
+    const source = image.source;
+
+    if (source === undefined || source === null) {
+        throw new Error(`image ${image.id} has no source, so no format`);
+    }
+
+    if (source.isShadeTexelData === true) {
+        /*
+         Already in a GPU format; it says which — but not whether sampling it decodes sRGB, which is
+         the image's business and not the payload's. `bc7-rgba-unorm` and `bc7-rgba-unorm-srgb` are
+         the same bytes, so a transcoder targeting one does exactly the work of the other and has no
+         reason to prefer either; what settles it is what the texture *means*, which is `color_space`
+         and is assigned after construction. Returning the payload's name verbatim ignored that and
+         put all 25 of Sponza's albedo maps on a linear format, sampling sRGB-encoded values as
+         though they were linear — brighter, flatter, and cold, because the decode that stretches
+         the gap between channels was the part being skipped.
+        */
+        if (color_space !== ColorSpace.SRGB) {
+            return source.format;
+        }
+
+        const srgb = gpu_texture_format_srgb(source.format);
+
+        if (srgb === undefined) {
+            throw new Error(
+                `image ${image.id} is sRGB but its payload is '${source.format}', which has no sRGB`
+                + ` counterpart, so the decode cannot be expressed. Transcode it to a format that`
+                + ` has one, or set color_space to something other than SRGB.`
+            );
+        }
+
+        return srgb;
+    }
+
+    if (source.isSampler2D === true) {
+        return infer_format_from_parameters(
+            image.channel_count, image.data_type, image.normalized, color_space
+        );
+    }
+
+    if (isImageBitmap(source)) {
+        /*
+         A bitmap is whatever the browser decoded it to, which is 8-bit RGBA — the channel count and
+         data type the image carries describe the file, not the decode.
+        */
+        if (image.data_type === BinaryDataType.Float16) {
+            return "rgba16float";
+        }
+
+        if (color_space === ColorSpace.SRGB) {
+            // sampling decodes sRGB to linear for free
+            // @see https://www.w3.org/TR/webgpu/#texture-formats
+            return "rgba8unorm-srgb";
+        }
+
+        return "rgba8unorm";
+    }
+
+    if (source instanceof ArrayBuffer) {
+        return infer_format_from_parameters(
+            image.channel_count, image.data_type, image.normalized, color_space
+        );
+    }
+
+    throw new Error(`Unsupported image data`);
+}

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.d.ts

@@ -47,10 +47,16 @@ export class WebGPUMipmapGenerator {
      * @param {GPUTexture} texture - Texture to generate mipmaps for.
      * @param {GPUTextureDescriptor} texture_descriptor - GPUTextureDescriptor the texture was created with.
      * @param {TextureFilterType} [filter]
-     * @param {GPUCommandEncoder} [commandEncoder]
+     * @param {GPUCommandEncoder} [commandEncoder] when supplied, the commands are recorded rather
+     *   than submitted, so the scratch resources outlive this call and `release_after_submit` is
+     *   required
+     * @param {{destroy: function():void}[]} [release_after_submit] where the scratch buffer and
+     *   textures go when the encoder is the caller's; destroy them once it has submitted
      * @returns {GPUTexture} - The originally passed texture
      */
-    generateMipmap(texture: GPUTexture, texture_descriptor: GPUTextureDescriptor, filter?: TextureFilterType, commandEncoder?: GPUCommandEncoder): GPUTexture;
+    generateMipmap(texture: GPUTexture, texture_descriptor: GPUTextureDescriptor, filter?: TextureFilterType, commandEncoder?: GPUCommandEncoder, release_after_submit?: {
+        destroy: () => void;
+    }[]): GPUTexture;
     #private;
 }
 import { HashMap } from "../../../../core/collection/map/HashMap.js";

package/src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGPUMipmapGenerator.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js"],"names":[],"mappings":"AAkMA;;;GAGG;AACH;IAqDI;;;OAGG;IACH,+BAWC;IAnED;;OAEG;IACH,kBAAM;IAEN;;;;OAIG;IACH,oBAFU,QAAQ,eAAe,oBAAoB,CAE3B;IAE1B;;OAEG;IACH,oBAAQ;IAgCR,gBAGC;IA6DD;;;;;OAKG;IACH,yEAFW,iBAAiB,QAY3B;IAED;;;OAGG;IACH,wBAFW,MAAM,QAyBhB;IAED;;OAEG;IACH,cAEC;IAmGG,qBAiBE;IAEF,oBAGE;IAGN;;;;;;;;OAQG;IACH,uFAJW,iBAAiB,kDA0X3B;;CACJ;wBAl2BuB,4CAA4C;AA2CpE;IAEI;;OAEG;IACH,yBAAO;IAEP;;OAEG;IACH;;;;QA1BA;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;;MAgBI;IAEP;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAMlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;CAEJ;kCAjEiC,yBAAyB"}
+{"version":3,"file":"WebGPUMipmapGenerator.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/mipmaps/WebGPUMipmapGenerator.js"],"names":[],"mappings":"AA8LA;;;GAGG;AACH;IAqDI;;;OAGG;IACH,+BAkBC;IA1ED;;OAEG;IACH,kBAAM;IAEN;;;;OAIG;IACH,oBAFU,QAAQ,eAAe,oBAAoB,CAE3B;IAE1B;;OAEG;IACH,oBAAQ;IAgCR,gBAGC;IAoED;;;;;OAKG;IACH,yEAFW,iBAAiB,QAY3B;IAED;;;OAGG;IACH,wBAFW,MAAM,QAyBhB;IAED;;OAEG;IACH,cAEC;IAmGG,qBAiBE;IAEF,oBAGE;IAGN;;;;;;;;;;;;OAYG;IACH,uFARW,iBAAiB,6DAIjB;QAAC,OAAO,QAAa,IAAI,CAAA;KAAC,EAAE,cA6YtC;;CACJ;wBA53BuB,4CAA4C;AAuCpE;IAEI;;OAEG;IACH,yBAAO;IAEP;;OAEG;IACH;;;;QA1BA;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;;;MAgBI;IAEP;;;;OAIG;IACH,cAHW,eAAe,GACd,OAAO,CAMlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;CAEJ;kCAjEiC,yBAAyB"}