@babylonjs/lite 1.11.0 → 1.12.0

package/lib/texture/texture-array.js

@@ -0,0 +1,96 @@
+import { TU } from '../engine/gpu-flags.js';
+import { getOrCreateSampler, acquireTexture } from '../resource/gpu-pool.js';
+import { generateMipmaps } from './generate-mipmaps.js';
+import { mipLevelCount } from './mip-count.js';
+
+function createTexture2DArray(engine, width, height, layers, options = {}) {
+  if (width < 1 || height < 1 || layers < 1) {
+    throw new Error(`createTexture2DArray: width/height/layers must be >= 1 (got ${width}x${height}x${layers})`);
+  }
+  const device = engine._device;
+  const mipMaps = options.mipMaps ?? true;
+  const format = options.srgb ? "rgba8unorm-srgb" : "rgba8unorm";
+  const texture = device.createTexture({
+    size: { width, height, depthOrArrayLayers: layers },
+    dimension: "2d",
+    format,
+    mipLevelCount: mipMaps ? mipLevelCount(width, height) : 1,
+    usage: TU.TEXTURE_BINDING | TU.COPY_DST | TU.RENDER_ATTACHMENT
+  });
+  const sampler = getOrCreateSampler(engine, {
+    addressModeU: options.addressModeU ?? "repeat",
+    addressModeV: options.addressModeV ?? "repeat",
+    minFilter: options.minFilter ?? "linear",
+    magFilter: options.magFilter ?? "linear",
+    mipmapFilter: mipMaps ? "linear" : "nearest"
+  });
+  const tex = { texture, view: texture.createView({ dimension: "2d-array" }), sampler, width, height, layers };
+  acquireTexture(tex);
+  return tex;
+}
+function uploadImageToArrayLayer(engine, tex, layer, source, opts = {}) {
+  if (layer < 0 || layer >= tex.layers || (layer | 0) !== layer) {
+    throw new Error(`uploadImageToArrayLayer: layer must be an integer in [0, ${tex.layers}) (got ${layer})`);
+  }
+  const invertY = opts.invertY ?? true;
+  const premultipliedAlpha = opts.premultiplyAlpha ?? false;
+  engine._device.queue.copyExternalImageToTexture({ source, flipY: invertY }, { texture: tex.texture, origin: [0, 0, layer], premultipliedAlpha }, [tex.width, tex.height, 1]);
+  if (tex.texture.mipLevelCount > 1) {
+    generateMipmaps(engine, tex.texture, layer);
+  }
+}
+async function loadImageToArrayLayer(engine, tex, layer, url, opts = {}) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`loadImageToArrayLayer: fetch failed for ${url} (${response.status})`);
+  }
+  const bitmap = await createImageBitmap(await response.blob(), {
+    premultiplyAlpha: opts.premultiplyAlpha ? "premultiply" : "none",
+    colorSpaceConversion: "none"
+  });
+  try {
+    uploadImageToArrayLayer(engine, tex, layer, bitmap, opts);
+  } finally {
+    bitmap.close();
+  }
+}
+async function createTexture2DArrayFromUrls(engine, urls, options = {}) {
+  const results = await Promise.allSettled(
+    urls.map(async (url) => {
+      const r = await fetch(url);
+      if (!r.ok) {
+        throw new Error(`createTexture2DArrayFromUrls: fetch failed for ${url} (${r.status})`);
+      }
+      return createImageBitmap(await r.blob(), { premultiplyAlpha: "none", colorSpaceConversion: "none" });
+    })
+  );
+  const firstRejection = results.find((res) => res.status === "rejected");
+  if (firstRejection) {
+    for (const res of results) {
+      if (res.status === "fulfilled") {
+        res.value.close();
+      }
+    }
+    throw firstRejection.reason;
+  }
+  const bitmaps = results.filter((res) => res.status === "fulfilled").map((res) => res.value);
+  const width = bitmaps[0].width;
+  const height = bitmaps[0].height;
+  for (const [i, bmp] of bitmaps.entries()) {
+    if (bmp.width !== width || bmp.height !== height) {
+      for (const b of bitmaps) {
+        b.close();
+      }
+      throw new Error(`createTexture2DArrayFromUrls: all layers must share one size; layer 0 is ${width}x${height} but layer ${i} is ${bmp.width}x${bmp.height}`);
+    }
+  }
+  const tex = createTexture2DArray(engine, width, height, bitmaps.length, options);
+  for (const [i, bmp] of bitmaps.entries()) {
+    uploadImageToArrayLayer(engine, tex, i, bmp);
+    bmp.close();
+  }
+  return tex;
+}
+
+export { createTexture2DArray, createTexture2DArrayFromUrls, loadImageToArrayLayer, uploadImageToArrayLayer };
+//# sourceMappingURL=texture-array.js.map

package/lib/texture/texture-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture-array.js","sources":["../../../src/texture/texture-array.ts"],"sourcesContent":["/**\n * 2D texture arrays — the WebGPU-native analog of Babylon.js `RawTexture2DArray`.\n *\n * A texture array is a single GPU texture holding N same-size, same-format\n * layers, sampled in WGSL as `texture_2d_array<f32>` with an explicit integer\n * layer index. This module is the missing convenience layer called out in the\n * forum (populating a texture array directly from image assets): it lets an\n * application create an array and fill individual layers from any WebGPU\n * external-image source — `ImageBitmap`, `ImageData`, a canvas, or a video —\n * without the \"draw to an offscreen canvas and read back raw bytes\" dance.\n *\n * The whole feature is a set of free functions with zero module-level side\n * effects, so an app that never touches texture arrays strips it entirely, and\n * an app that already holds an `ImageBitmap` never bundles the URL-fetch path.\n *\n * There is no built-in material that samples an array layer, so consuming a\n * `Texture2DArray` means sampling it from your own WGSL: declare a sampler with\n * `viewDimension: \"2d-array\"` on a {@link createShaderMaterial | ShaderMaterial}\n * (which emits a `texture_2d_array<f32>` binding) and sample it with an explicit\n * integer layer index. `StandardMaterial`/`PBRMaterial` slots are plain\n * `texture_2d<f32>` and cannot read a layer.\n *\n * @example\n * ```ts\n * // Build a 3-layer array from images, then sample a chosen layer in a shader.\n * const atlas = await createTexture2DArrayFromUrls(engine, [\"grass.png\", \"rock.png\", \"sand.png\"]);\n *\n * const material = createShaderMaterial({\n *     attributes: [\"position\", \"uv\"],\n *     // Custom uniforms are exposed in WGSL via the `shaderUniforms` struct.\n *     uniforms: [{ name: \"layer\", type: \"f32\", defaultValue: 0 }],\n *     // A sampler named \"atlas\" emits `var atlas: texture_2d_array<f32>` plus `var atlasSampler: sampler`.\n *     samplers: [{ name: \"atlas\", viewDimension: \"2d-array\" }],\n *     vertexSource,\n *     fragmentSource: `\n *         @fragment fn main(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> {\n *             return textureSample(atlas, atlasSampler, uv, i32(shaderUniforms.layer));\n *         }`,\n * });\n * setShaderTexture(material, \"atlas\", atlas);\n * setShaderUniform(material, \"layer\", 1); // sample the \"rock\" layer\n * ```\n */\n\nimport { TU } from \"../engine/gpu-flags.js\";\nimport { acquireTexture, getOrCreateSampler } from \"../resource/gpu-pool.js\";\nimport { generateMipmaps } from \"./generate-mipmaps.js\";\nimport { mipLevelCount } from \"./mip-count.js\";\nimport type { Texture2D } from \"./texture-2d.js\";\nimport type { EngineContext } from \"../engine/engine.js\";\n\n/** A 2D texture array handle. It is a `Texture2D` (so it drops straight into\n *  `setEffectTexture` / material sampler bindings) whose `view` is created with\n *  `dimension:\"2d-array\"`, plus a `layers` count. Bind it to a shader sampler\n *  declared `viewDimension:\"2d-array\"` and sample it in WGSL as\n *  `texture_2d_array<f32>`. */\nexport interface Texture2DArray extends Texture2D {\n    layers: number;\n}\n\n/** Sampler and format options for `createTexture2DArray()`. */\nexport interface TextureArrayOptions {\n    /** Generate a full mip chain for each layer on upload. Default true. */\n    mipMaps?: boolean;\n    /** Use sRGB format (rgba8unorm-srgb) so the hardware converts to linear on\n     *  sample. Use for color/albedo layers in PBR workflows. Default false. */\n    srgb?: boolean;\n    /** Address mode U. Default 'repeat'. */\n    addressModeU?: GPUAddressMode;\n    /** Address mode V. Default 'repeat'. */\n    addressModeV?: GPUAddressMode;\n    /** Min filter. Default 'linear'. */\n    minFilter?: GPUFilterMode;\n    /** Mag filter. Default 'linear'. */\n    magFilter?: GPUFilterMode;\n}\n\n/** Per-layer upload options for `uploadImageToArrayLayer()` / `loadImageToArrayLayer()`. */\nexport interface ArrayLayerUploadOptions {\n    /** Flip Y during upload. Default true (matches Babylon.js convention). */\n    invertY?: boolean;\n    /** Treat the destination as premultiplied-alpha. Default false (straight RGBA). */\n    premultiplyAlpha?: boolean;\n}\n\n/**\n * Create an empty 2D texture array of `layers` same-size RGBA8 layers, ready to\n * be filled with `uploadImageToArrayLayer()` / `loadImageToArrayLayer()`.\n *\n * The texture is created with `TEXTURE_BINDING | COPY_DST | RENDER_ATTACHMENT`\n * usage — `copyExternalImageToTexture` (used by the upload helpers) requires\n * both `COPY_DST` and `RENDER_ATTACHMENT` on the destination, and the render\n * attachment is also what the mipmap-blit pass writes into.\n *\n * @param engine - Engine context.\n * @param width - Layer width in texels (\\>= 1).\n * @param height - Layer height in texels (\\>= 1).\n * @param layers - Number of array layers (\\>= 1).\n * @param options - Sampler / format overrides.\n */\nexport function createTexture2DArray(engine: EngineContext, width: number, height: number, layers: number, options: TextureArrayOptions = {}): Texture2DArray {\n    if (width < 1 || height < 1 || layers < 1) {\n        throw new Error(`createTexture2DArray: width/height/layers must be >= 1 (got ${width}x${height}x${layers})`);\n    }\n\n    const device = engine._device;\n    const mipMaps = options.mipMaps ?? true;\n    const format: GPUTextureFormat = options.srgb ? \"rgba8unorm-srgb\" : \"rgba8unorm\";\n\n    const texture = device.createTexture({\n        size: { width, height, depthOrArrayLayers: layers },\n        dimension: \"2d\",\n        format,\n        mipLevelCount: mipMaps ? mipLevelCount(width, height) : 1,\n        usage: TU.TEXTURE_BINDING | TU.COPY_DST | TU.RENDER_ATTACHMENT,\n    });\n\n    const sampler = getOrCreateSampler(engine, {\n        addressModeU: options.addressModeU ?? \"repeat\",\n        addressModeV: options.addressModeV ?? \"repeat\",\n        minFilter: options.minFilter ?? \"linear\",\n        magFilter: options.magFilter ?? \"linear\",\n        mipmapFilter: mipMaps ? \"linear\" : \"nearest\",\n    });\n\n    const tex: Texture2DArray = { texture, view: texture.createView({ dimension: \"2d-array\" }), sampler, width, height, layers };\n    acquireTexture(tex);\n    return tex;\n}\n\n/**\n * Fill one layer of a texture array from an already-decoded external image\n * source — an `ImageBitmap`, `ImageData`, canvas (`HTMLCanvasElement` /\n * `OffscreenCanvas`), `HTMLImageElement`, `HTMLVideoElement`, or `VideoFrame`.\n * All of these are accepted directly by WebGPU's `copyExternalImageToTexture`,\n * so this is a single GPU copy with no per-source-type branching. If the array\n * was created with mipmaps, the layer's mip chain is regenerated after upload.\n *\n * @param engine - Engine context.\n * @param tex - Target texture array (from `createTexture2DArray`).\n * @param layer - Destination layer index in `[0, tex.layers)`.\n * @param source - Any WebGPU external-image source sized `tex.width`×`tex.height`.\n * @param opts - Flip-Y / premultiply overrides.\n */\nexport function uploadImageToArrayLayer(engine: EngineContext, tex: Texture2DArray, layer: number, source: GPUCopyExternalImageSource, opts: ArrayLayerUploadOptions = {}): void {\n    if (layer < 0 || layer >= tex.layers || (layer | 0) !== layer) {\n        throw new Error(`uploadImageToArrayLayer: layer must be an integer in [0, ${tex.layers}) (got ${layer})`);\n    }\n    const invertY = opts.invertY ?? true;\n    const premultipliedAlpha = opts.premultiplyAlpha ?? false;\n\n    engine._device.queue.copyExternalImageToTexture({ source, flipY: invertY }, { texture: tex.texture, origin: [0, 0, layer], premultipliedAlpha }, [tex.width, tex.height, 1]);\n\n    if (tex.texture.mipLevelCount > 1) {\n        generateMipmaps(engine, tex.texture, layer);\n    }\n}\n\n/**\n * Fetch an image from `url`, decode it to an `ImageBitmap`, and upload it into\n * `layer` of a texture array. This is the optional URL-loading counterpart to\n * `uploadImageToArrayLayer()`; keeping it a separate function means apps that\n * already hold a decoded source never pull in the fetch/decode path.\n *\n * @param engine - Engine context.\n * @param tex - Target texture array (from `createTexture2DArray`).\n * @param layer - Destination layer index in `[0, tex.layers)`.\n * @param url - Image URL to fetch and decode.\n * @param opts - Flip-Y / premultiply overrides.\n */\nexport async function loadImageToArrayLayer(engine: EngineContext, tex: Texture2DArray, layer: number, url: string, opts: ArrayLayerUploadOptions = {}): Promise<void> {\n    const response = await fetch(url);\n    if (!response.ok) {\n        throw new Error(`loadImageToArrayLayer: fetch failed for ${url} (${response.status})`);\n    }\n    const bitmap = await createImageBitmap(await response.blob(), {\n        premultiplyAlpha: opts.premultiplyAlpha ? \"premultiply\" : \"none\",\n        colorSpaceConversion: \"none\",\n    });\n    try {\n        uploadImageToArrayLayer(engine, tex, layer, bitmap, opts);\n    } finally {\n        bitmap.close();\n    }\n}\n\n/**\n * Create a 2D texture array and populate every layer from a list of image URLs\n * — one URL per layer, in order. All images must decode to the same dimensions\n * (the array's `width`/`height` are taken from the first). This is the\n * highest-level, most ergonomic entry point.\n *\n * @param engine - Engine context.\n * @param urls - One image URL per layer (`urls.length` \\>= 1).\n * @param options - Sampler / format overrides.\n * @returns A promise resolving to the populated `Texture2DArray`.\n */\nexport async function createTexture2DArrayFromUrls(engine: EngineContext, urls: readonly [string, ...string[]], options: TextureArrayOptions = {}): Promise<Texture2DArray> {\n    // allSettled (not all): a rejected fetch/decode must not leak the layers that\n    // already decoded — Promise.all would reject on the first failure and orphan\n    // every fulfilled ImageBitmap. Close the fulfilled ones, then rethrow.\n    const results = await Promise.allSettled(\n        urls.map(async (url) => {\n            const r = await fetch(url);\n            if (!r.ok) {\n                throw new Error(`createTexture2DArrayFromUrls: fetch failed for ${url} (${r.status})`);\n            }\n            return createImageBitmap(await r.blob(), { premultiplyAlpha: \"none\", colorSpaceConversion: \"none\" });\n        })\n    );\n\n    const firstRejection = results.find((res) => res.status === \"rejected\");\n    if (firstRejection) {\n        for (const res of results) {\n            if (res.status === \"fulfilled\") {\n                res.value.close();\n            }\n        }\n        throw firstRejection.reason;\n    }\n\n    const bitmaps = results.filter((res): res is PromiseFulfilledResult<ImageBitmap> => res.status === \"fulfilled\").map((res) => res.value) as [ImageBitmap, ...ImageBitmap[]];\n\n    const width = bitmaps[0].width;\n    const height = bitmaps[0].height;\n    for (const [i, bmp] of bitmaps.entries()) {\n        if (bmp.width !== width || bmp.height !== height) {\n            for (const b of bitmaps) {\n                b.close();\n            }\n            throw new Error(`createTexture2DArrayFromUrls: all layers must share one size; layer 0 is ${width}x${height} but layer ${i} is ${bmp.width}x${bmp.height}`);\n        }\n    }\n\n    const tex = createTexture2DArray(engine, width, height, bitmaps.length, options);\n    for (const [i, bmp] of bitmaps.entries()) {\n        uploadImageToArrayLayer(engine, tex, i, bmp);\n        bmp.close();\n    }\n    return tex;\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonjs/lite",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "A lightweight, tree-shakable, WebGPU-first rendering library derived from Babylon.js.",
   "license": "Apache-2.0",
   "homepage": "https://doc.babylonjs.com/lite/",
@@ -34,7 +34,7 @@
     }
   },
   "babylonLiteRelease": {
-    "azureBuildId": "56283",
-    "sourceVersion": "b7993d58a709edc4c3299014d300b992ee0b8e7c"
+    "azureBuildId": "56431",
+    "sourceVersion": "cc7a45f9ac8732b65f7fd37d5d66ef26f7a86df5"
   }
 }