@zephyr3d/scene 0.9.27 → 0.10.0

package/dist/asset/texture_settings.js

@@ -0,0 +1,231 @@
+/** Extension of asset sidecar files, appended to the asset's full file name. @public */ const ASSET_META_EXTENSION = '.zmeta';
+/** Current `.zmeta` format version. @public */ const ASSET_META_VERSION = 1;
+/** Usages that hold colour and are sampled as sRGB. */ const SRGB_USAGES = new Set([
+    'color',
+    'ui'
+]);
+const USAGES = [
+    'color',
+    'normal',
+    'mask',
+    'hdr',
+    'ui'
+];
+const COMPRESSIONS = [
+    'auto',
+    'etc1s',
+    'uastc',
+    'none'
+];
+const QUALITIES = [
+    'low',
+    'normal',
+    'high'
+];
+/**
+ * Path of the sidecar `.zmeta` file of an asset.
+ * @public
+ */ function getAssetMetaPath(assetPath) {
+    return `${assetPath}${ASSET_META_EXTENSION}`;
+}
+/**
+ * True if a path is an asset sidecar file rather than an asset.
+ * @public
+ */ function isAssetMetaPath(path) {
+    return path.toLowerCase().endsWith(ASSET_META_EXTENSION);
+}
+/**
+ * Whether textures of a usage are sampled as sRGB.
+ * @public
+ */ function isSRGBTextureUsage(usage) {
+    return SRGB_USAGES.has(usage);
+}
+/**
+ * Default settings for a usage.
+ *
+ * Compression is opt-in: a texture is only compressed when its settings say so,
+ * so updating the engine or editor never changes how an existing project ships.
+ * @public
+ */ function defaultTextureImportSettings(usage, compression = 'none') {
+    return {
+        usage,
+        compression,
+        quality: 'normal',
+        maxSize: 0,
+        mipmaps: usage !== 'ui'
+    };
+}
+/**
+ * The encoding a texture actually gets, with `auto` resolved from its usage.
+ * @public
+ */ function resolveTextureCompression(settings) {
+    if (settings.compression !== 'auto') {
+        return settings.compression;
+    }
+    switch(settings.usage){
+        case 'color':
+            return 'etc1s';
+        case 'normal':
+            return 'uastc';
+        case 'mask':
+            return settings.quality === 'low' ? 'etc1s' : 'uastc';
+        default:
+            return 'none';
+    }
+}
+// File name tokens, matched whole after splitting on separators and case changes.
+// Common suffix conventions of DCC tools and texture libraries (Substance,
+// Quixel, Poly Haven, glTF samples). Only consulted when no material slot told
+// the importer what the image is.
+const NORMAL_TOKENS = new Set([
+    'n',
+    'nrm',
+    'nor',
+    'norm',
+    'normal',
+    'normals',
+    'normalmap',
+    'nml'
+]);
+const MASK_TOKENS = new Set([
+    'orm',
+    'arm',
+    'mra',
+    'rma',
+    'rough',
+    'roughness',
+    'metal',
+    'metallic',
+    'metalness',
+    'ao',
+    'occlusion',
+    'ambientocclusion',
+    'mask',
+    'masks',
+    'spec',
+    'specular',
+    'gloss',
+    'glossiness',
+    'height',
+    'disp',
+    'displacement',
+    'bump',
+    'opacity',
+    'cavity',
+    'thickness'
+]);
+function fileNameTokens(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    const dot = name.lastIndexOf('.');
+    const stem = dot > 0 ? name.slice(0, dot) : name;
+    return stem.replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+}
+/**
+ * Guesses the usage of a texture from its path, for images that arrive without
+ * material context (dropped into the project, or referenced by no material).
+ * @public
+ */ function inferTextureUsageFromPath(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith('.hdr') || lower.endsWith('.exr')) {
+        return 'hdr';
+    }
+    if (/(^|\/)ui\//.test(lower)) {
+        return 'ui';
+    }
+    const tokens = fileNameTokens(path);
+    // The last tokens carry the map type in suffix conventions ("rock_01_nrm")
+    for(let i = tokens.length - 1; i >= 0; i--){
+        if (NORMAL_TOKENS.has(tokens[i])) {
+            return 'normal';
+        }
+        if (MASK_TOKENS.has(tokens[i])) {
+            return 'mask';
+        }
+    }
+    return 'color';
+}
+/**
+ * Usage of an image referenced from a model material slot.
+ *
+ * @param slot - Material property holding the texture, e.g. `normalMap`
+ * @param sRGB - Whether the importer samples the slot as sRGB
+ *
+ * @public
+ */ function inferTextureUsageFromSlot(slot, sRGB) {
+    if (/normal/i.test(slot)) {
+        return 'normal';
+    }
+    return sRGB ? 'color' : 'mask';
+}
+// When one image feeds several slots, the most demanding usage wins: a normal
+// map compressed as colour loses far more than a colour map compressed as data.
+const USAGE_PRIORITY = {
+    normal: 3,
+    mask: 2,
+    hdr: 2,
+    color: 1,
+    ui: 0
+};
+/**
+ * Picks the usage that serves every slot an image is used in.
+ * @public
+ */ function mergeTextureUsage(a, b) {
+    return USAGE_PRIORITY[b] > USAGE_PRIORITY[a] ? b : a;
+}
+function pick(value, allowed, fallback) {
+    return allowed.includes(value) ? value : fallback;
+}
+/**
+ * Validates parsed settings, filling anything missing or invalid from the defaults
+ * of the stored usage (or of `fallbackUsage` when the usage itself is unusable).
+ * @public
+ */ function normalizeTextureImportSettings(value, fallbackUsage) {
+    const v = value && typeof value === 'object' ? value : {};
+    const usage = pick(v.usage, USAGES, fallbackUsage);
+    const defaults = defaultTextureImportSettings(usage);
+    const maxSize = Number(v.maxSize);
+    return {
+        usage,
+        compression: pick(v.compression, COMPRESSIONS, defaults.compression),
+        quality: pick(v.quality, QUALITIES, defaults.quality),
+        maxSize: Number.isFinite(maxSize) && maxSize > 0 ? Math.floor(maxSize) : 0,
+        mipmaps: typeof v.mipmaps === 'boolean' ? v.mipmaps : defaults.mipmaps
+    };
+}
+/**
+ * Reads the import settings of a texture. Without a `.zmeta` file (or with an
+ * unreadable one) the texture is not compressed and its usage is inferred from
+ * the path, so a texture that was never touched in the editor still has
+ * well-defined settings that leave it exactly as it was.
+ * @public
+ */ async function readTextureImportSettings(vfs, path) {
+    const fallbackUsage = inferTextureUsageFromPath(path);
+    const metaPath = getAssetMetaPath(path);
+    try {
+        if (await vfs.exists(metaPath)) {
+            const meta = JSON.parse(await vfs.readFile(metaPath, {
+                encoding: 'utf8'
+            }));
+            return normalizeTextureImportSettings(meta?.texture, fallbackUsage);
+        }
+    } catch (err) {
+        console.warn(`Ignoring unreadable asset meta ${metaPath}: ${err}`);
+    }
+    return defaultTextureImportSettings(fallbackUsage);
+}
+/**
+ * Writes the import settings of a texture to its `.zmeta` file.
+ * @public
+ */ async function writeTextureImportSettings(vfs, path, settings) {
+    const content = JSON.stringify({
+        version: ASSET_META_VERSION,
+        texture: settings
+    }, null, 2);
+    await vfs.writeFile(getAssetMetaPath(path), content, {
+        encoding: 'utf8',
+        create: true
+    });
+}
+
+export { ASSET_META_EXTENSION, ASSET_META_VERSION, defaultTextureImportSettings, getAssetMetaPath, inferTextureUsageFromPath, inferTextureUsageFromSlot, isAssetMetaPath, isSRGBTextureUsage, mergeTextureUsage, normalizeTextureImportSettings, readTextureImportSettings, resolveTextureCompression, writeTextureImportSettings };
+//# sourceMappingURL=texture_settings.js.map

package/dist/asset/texture_settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture_settings.js","sources":["../../src/asset/texture_settings.ts"],"sourcesContent":["import type { VFS } from '@zephyr3d/base';\r\n\r\n/**\r\n * What a texture holds, which decides its colour space and how it compresses.\r\n *\r\n * - `color`: albedo, emissive and other colour data, sampled as sRGB\r\n * - `normal`: tangent-space normal maps\r\n * - `mask`: linear data such as occlusion/roughness/metallic packs, masks, height\r\n * - `hdr`: high dynamic range images (.hdr, .exr)\r\n * - `ui`: interface images, which keep sharp edges and are never block compressed\r\n *\r\n * @public\r\n */\r\nexport type TextureUsage = 'color' | 'normal' | 'mask' | 'hdr' | 'ui';\r\n\r\n/**\r\n * Basis Universal encoding for a texture.\r\n *\r\n * `auto` picks from the usage: ETC1S for colour (small, block artefacts are hard\r\n * to see), UASTC for normals and masks (artefacts there get amplified by lighting\r\n * or leak between packed channels), none for HDR and UI.\r\n *\r\n * @public\r\n */\r\nexport type TextureCompression = 'auto' | 'etc1s' | 'uastc' | 'none';\r\n\r\n/**\r\n * Encoder effort and fidelity: the ETC1S quality level or the UASTC rate-distortion setting.\r\n * @public\r\n */\r\nexport type TextureQuality = 'low' | 'normal' | 'high';\r\n\r\n/**\r\n * Per-texture import settings, stored next to the source image in a `.zmeta` file.\r\n *\r\n * The source image is never modified; these settings only describe how the asset\r\n * pipeline derives the shipped texture from it.\r\n *\r\n * @public\r\n */\r\nexport interface TextureImportSettings {\r\n  usage: TextureUsage;\r\n  compression: TextureCompression;\r\n  quality: TextureQuality;\r\n  /** Largest allowed width or height in texels, 0 keeps the source size */\r\n  maxSize: number;\r\n  mipmaps: boolean;\r\n}\r\n\r\n/** Extension of asset sidecar files, appended to the asset's full file name. @public */\r\nexport const ASSET_META_EXTENSION = '.zmeta';\r\n\r\n/** Current `.zmeta` format version. @public */\r\nexport const ASSET_META_VERSION = 1;\r\n\r\n/** Usages that hold colour and are sampled as sRGB. */\r\nconst SRGB_USAGES: ReadonlySet<TextureUsage> = new Set(['color', 'ui']);\r\n\r\nconst USAGES: readonly TextureUsage[] = ['color', 'normal', 'mask', 'hdr', 'ui'];\r\nconst COMPRESSIONS: readonly TextureCompression[] = ['auto', 'etc1s', 'uastc', 'none'];\r\nconst QUALITIES: readonly TextureQuality[] = ['low', 'normal', 'high'];\r\n\r\n/**\r\n * Path of the sidecar `.zmeta` file of an asset.\r\n * @public\r\n */\r\nexport function getAssetMetaPath(assetPath: string) {\r\n  return `${assetPath}${ASSET_META_EXTENSION}`;\r\n}\r\n\r\n/**\r\n * True if a path is an asset sidecar file rather than an asset.\r\n * @public\r\n */\r\nexport function isAssetMetaPath(path: string) {\r\n  return path.toLowerCase().endsWith(ASSET_META_EXTENSION);\r\n}\r\n\r\n/**\r\n * Whether textures of a usage are sampled as sRGB.\r\n * @public\r\n */\r\nexport function isSRGBTextureUsage(usage: TextureUsage) {\r\n  return SRGB_USAGES.has(usage);\r\n}\r\n\r\n/**\r\n * Default settings for a usage.\r\n *\r\n * Compression is opt-in: a texture is only compressed when its settings say so,\r\n * so updating the engine or editor never changes how an existing project ships.\r\n * @public\r\n */\r\nexport function defaultTextureImportSettings(\r\n  usage: TextureUsage,\r\n  compression: TextureCompression = 'none'\r\n): TextureImportSettings {\r\n  return { usage, compression, quality: 'normal', maxSize: 0, mipmaps: usage !== 'ui' };\r\n}\r\n\r\n/**\r\n * The encoding a texture actually gets, with `auto` resolved from its usage.\r\n * @public\r\n */\r\nexport function resolveTextureCompression(settings: TextureImportSettings): 'etc1s' | 'uastc' | 'none' {\r\n  if (settings.compression !== 'auto') {\r\n    return settings.compression;\r\n  }\r\n  switch (settings.usage) {\r\n    case 'color':\r\n      return 'etc1s';\r\n    case 'normal':\r\n      return 'uastc';\r\n    case 'mask':\r\n      return settings.quality === 'low' ? 'etc1s' : 'uastc';\r\n    default:\r\n      return 'none';\r\n  }\r\n}\r\n\r\n// File name tokens, matched whole after splitting on separators and case changes.\r\n// Common suffix conventions of DCC tools and texture libraries (Substance,\r\n// Quixel, Poly Haven, glTF samples). Only consulted when no material slot told\r\n// the importer what the image is.\r\nconst NORMAL_TOKENS = new Set(['n', 'nrm', 'nor', 'norm', 'normal', 'normals', 'normalmap', 'nml']);\r\nconst MASK_TOKENS = new Set([\r\n  'orm',\r\n  'arm',\r\n  'mra',\r\n  'rma',\r\n  'rough',\r\n  'roughness',\r\n  'metal',\r\n  'metallic',\r\n  'metalness',\r\n  'ao',\r\n  'occlusion',\r\n  'ambientocclusion',\r\n  'mask',\r\n  'masks',\r\n  'spec',\r\n  'specular',\r\n  'gloss',\r\n  'glossiness',\r\n  'height',\r\n  'disp',\r\n  'displacement',\r\n  'bump',\r\n  'opacity',\r\n  'cavity',\r\n  'thickness'\r\n]);\r\n\r\nfunction fileNameTokens(path: string) {\r\n  const name = path.slice(path.lastIndexOf('/') + 1);\r\n  const dot = name.lastIndexOf('.');\r\n  const stem = dot > 0 ? name.slice(0, dot) : name;\r\n  return stem\r\n    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')\r\n    .toLowerCase()\r\n    .split(/[^a-z0-9]+/)\r\n    .filter(Boolean);\r\n}\r\n\r\n/**\r\n * Guesses the usage of a texture from its path, for images that arrive without\r\n * material context (dropped into the project, or referenced by no material).\r\n * @public\r\n */\r\nexport function inferTextureUsageFromPath(path: string): TextureUsage {\r\n  const lower = path.toLowerCase();\r\n  if (lower.endsWith('.hdr') || lower.endsWith('.exr')) {\r\n    return 'hdr';\r\n  }\r\n  if (/(^|\\/)ui\\//.test(lower)) {\r\n    return 'ui';\r\n  }\r\n  const tokens = fileNameTokens(path);\r\n  // The last tokens carry the map type in suffix conventions (\"rock_01_nrm\")\r\n  for (let i = tokens.length - 1; i >= 0; i--) {\r\n    if (NORMAL_TOKENS.has(tokens[i])) {\r\n      return 'normal';\r\n    }\r\n    if (MASK_TOKENS.has(tokens[i])) {\r\n      return 'mask';\r\n    }\r\n  }\r\n  return 'color';\r\n}\r\n\r\n/**\r\n * Usage of an image referenced from a model material slot.\r\n *\r\n * @param slot - Material property holding the texture, e.g. `normalMap`\r\n * @param sRGB - Whether the importer samples the slot as sRGB\r\n *\r\n * @public\r\n */\r\nexport function inferTextureUsageFromSlot(slot: string, sRGB: boolean): TextureUsage {\r\n  if (/normal/i.test(slot)) {\r\n    return 'normal';\r\n  }\r\n  return sRGB ? 'color' : 'mask';\r\n}\r\n\r\n// When one image feeds several slots, the most demanding usage wins: a normal\r\n// map compressed as colour loses far more than a colour map compressed as data.\r\nconst USAGE_PRIORITY: Record<TextureUsage, number> = { normal: 3, mask: 2, hdr: 2, color: 1, ui: 0 };\r\n\r\n/**\r\n * Picks the usage that serves every slot an image is used in.\r\n * @public\r\n */\r\nexport function mergeTextureUsage(a: TextureUsage, b: TextureUsage): TextureUsage {\r\n  return USAGE_PRIORITY[b] > USAGE_PRIORITY[a] ? b : a;\r\n}\r\n\r\nfunction pick<T>(value: unknown, allowed: readonly T[], fallback: T): T {\r\n  return allowed.includes(value as T) ? (value as T) : fallback;\r\n}\r\n\r\n/**\r\n * Validates parsed settings, filling anything missing or invalid from the defaults\r\n * of the stored usage (or of `fallbackUsage` when the usage itself is unusable).\r\n * @public\r\n */\r\nexport function normalizeTextureImportSettings(\r\n  value: unknown,\r\n  fallbackUsage: TextureUsage\r\n): TextureImportSettings {\r\n  const v = (value && typeof value === 'object' ? value : {}) as Record<string, unknown>;\r\n  const usage = pick(v.usage, USAGES, fallbackUsage);\r\n  const defaults = defaultTextureImportSettings(usage);\r\n  const maxSize = Number(v.maxSize);\r\n  return {\r\n    usage,\r\n    compression: pick(v.compression, COMPRESSIONS, defaults.compression),\r\n    quality: pick(v.quality, QUALITIES, defaults.quality),\r\n    maxSize: Number.isFinite(maxSize) && maxSize > 0 ? Math.floor(maxSize) : 0,\r\n    mipmaps: typeof v.mipmaps === 'boolean' ? v.mipmaps : defaults.mipmaps\r\n  };\r\n}\r\n\r\n/**\r\n * Reads the import settings of a texture. Without a `.zmeta` file (or with an\r\n * unreadable one) the texture is not compressed and its usage is inferred from\r\n * the path, so a texture that was never touched in the editor still has\r\n * well-defined settings that leave it exactly as it was.\r\n * @public\r\n */\r\nexport async function readTextureImportSettings(vfs: VFS, path: string): Promise<TextureImportSettings> {\r\n  const fallbackUsage = inferTextureUsageFromPath(path);\r\n  const metaPath = getAssetMetaPath(path);\r\n  try {\r\n    if (await vfs.exists(metaPath)) {\r\n      const meta = JSON.parse((await vfs.readFile(metaPath, { encoding: 'utf8' })) as string);\r\n      return normalizeTextureImportSettings(meta?.texture, fallbackUsage);\r\n    }\r\n  } catch (err) {\r\n    console.warn(`Ignoring unreadable asset meta ${metaPath}: ${err}`);\r\n  }\r\n  return defaultTextureImportSettings(fallbackUsage);\r\n}\r\n\r\n/**\r\n * Writes the import settings of a texture to its `.zmeta` file.\r\n * @public\r\n */\r\nexport async function writeTextureImportSettings(vfs: VFS, path: string, settings: TextureImportSettings) {\r\n  const content = JSON.stringify({ version: ASSET_META_VERSION, texture: settings }, null, 2);\r\n  await vfs.writeFile(getAssetMetaPath(path), content, { encoding: 'utf8', create: true });\r\n}\r\n"],"names":["ASSET_META_EXTENSION","ASSET_META_VERSION","SRGB_USAGES","Set","USAGES","COMPRESSIONS","QUALITIES","getAssetMetaPath","assetPath","isAssetMetaPath","path","toLowerCase","endsWith","isSRGBTextureUsage","usage","has","defaultTextureImportSettings","compression","quality","maxSize","mipmaps","resolveTextureCompression","settings","NORMAL_TOKENS","MASK_TOKENS","fileNameTokens","name","slice","lastIndexOf","dot","stem","replace","split","filter","Boolean","inferTextureUsageFromPath","lower","test","tokens","i","length","inferTextureUsageFromSlot","slot","sRGB","USAGE_PRIORITY","normal","mask","hdr","color","ui","mergeTextureUsage","a","b","pick","value","allowed","fallback","includes","normalizeTextureImportSettings","fallbackUsage","v","defaults","Number","isFinite","Math","floor","readTextureImportSettings","vfs","metaPath","exists","meta","JSON","parse","readFile","encoding","texture","err","console","warn","writeTextureImportSettings","content","stringify","version","writeFile","create"],"mappings":"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"}

package/dist/asset/zmsh_binary.js

@@ -0,0 +1,131 @@
+/** @public */ const ZMSH_MAGIC = 0x48534d5a;
+/** @public */ const ZMSH_BINARY_VERSION = 2;
+const PREAMBLE_SIZE = 12;
+function align4(n) {
+    return n + 3 & -4;
+}
+/**
+ * True if the data is a binary `.zmsh` rather than the JSON form.
+ * @public
+ */ function isZmshBinary(data) {
+    return data.byteLength >= PREAMBLE_SIZE && new DataView(data).getUint32(0, true) === ZMSH_MAGIC;
+}
+/**
+ * Assembles a binary `.zmsh`. Stream offsets and lengths in the header are
+ * filled in from `attributeData` and `indexData`, which must be in the order of
+ * `header.attributes`.
+ * @public
+ */ function writeZmshBinary(header, attributeData, indexData) {
+    if (attributeData.length !== header.attributes.length) {
+        throw new Error('writeZmshBinary(): one data array is needed per attribute');
+    }
+    if (!!indexData !== !!header.indices) {
+        throw new Error('writeZmshBinary(): index data and index header must be given together');
+    }
+    let blobSize = 0;
+    const place = (length)=>{
+        const offset = blobSize;
+        blobSize = align4(blobSize + length);
+        return {
+            offset,
+            length
+        };
+    };
+    const full = {
+        ...header,
+        attributes: header.attributes.map((a, i)=>({
+                ...a,
+                ...place(attributeData[i].byteLength)
+            })),
+        indices: header.indices ? {
+            ...header.indices,
+            ...place(indexData.byteLength)
+        } : null
+    };
+    const json = new TextEncoder().encode(JSON.stringify(full));
+    const headerLength = align4(json.byteLength);
+    const out = new Uint8Array(PREAMBLE_SIZE + headerLength + blobSize);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, ZMSH_MAGIC, true);
+    view.setUint32(4, ZMSH_BINARY_VERSION, true);
+    view.setUint32(8, headerLength, true);
+    out.fill(0x20, PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);
+    out.set(json, PREAMBLE_SIZE);
+    const blobStart = PREAMBLE_SIZE + headerLength;
+    full.attributes.forEach((a, i)=>out.set(attributeData[i], blobStart + a.offset));
+    if (full.indices) {
+        out.set(indexData, blobStart + full.indices.offset);
+    }
+    return out.buffer;
+}
+/**
+ * Splits a binary `.zmsh` into its header and stream views. Streams are returned
+ * as stored, still encoded when the header says `meshopt`.
+ * @public
+ */ function readZmshBinary(data) {
+    if (!isZmshBinary(data)) {
+        throw new Error('Not a binary .zmsh file');
+    }
+    const view = new DataView(data);
+    const version = view.getUint32(4, true);
+    if (version !== ZMSH_BINARY_VERSION) {
+        throw new Error(`Unsupported binary .zmsh version ${version}`);
+    }
+    const headerLength = view.getUint32(8, true);
+    const blobStart = PREAMBLE_SIZE + headerLength;
+    if (blobStart > data.byteLength) {
+        throw new Error('Truncated binary .zmsh header');
+    }
+    const header = JSON.parse(new TextDecoder().decode(new Uint8Array(data, PREAMBLE_SIZE, headerLength)));
+    const slice = (offset, length)=>{
+        if (blobStart + offset + length > data.byteLength) {
+            throw new Error('Truncated binary .zmsh stream');
+        }
+        return new Uint8Array(data, blobStart + offset, length);
+    };
+    return {
+        header,
+        attributes: header.attributes.map((a)=>slice(a.offset, a.length)),
+        indices: header.indices ? slice(header.indices.offset, header.indices.length) : null
+    };
+}
+/**
+ * Decodes the streams of a binary `.zmsh` into raw vertex and index data, ready
+ * for GPU upload.
+ * @public
+ */ function decodeZmshBinary(data, decoder) {
+    const { header, attributes, indices } = readZmshBinary(data);
+    const meshopt = header.encoding === 'meshopt';
+    if (meshopt && !decoder) {
+        throw new Error('A meshopt decoder is required for this .zmsh');
+    }
+    const vertexData = header.attributes.map((a, i)=>{
+        if (!meshopt) {
+            return attributes[i];
+        }
+        const target = new Uint8Array(header.vertexCount * a.byteStride);
+        decoder.decodeGltfBuffer(target, header.vertexCount, a.byteStride, attributes[i], 'ATTRIBUTES', a.filter);
+        return target;
+    });
+    let indexData = null;
+    if (header.indices && indices) {
+        const size = header.indices.type === 'u16' ? 2 : 4;
+        let bytes;
+        if (meshopt) {
+            bytes = new Uint8Array(header.indexCount * size);
+            decoder.decodeGltfBuffer(bytes, header.indexCount, size, indices, header.indices.mode);
+        } else {
+            // Copy so the typed array is aligned regardless of where the stream sat in the file
+            bytes = indices.slice();
+        }
+        indexData = size === 2 ? new Uint16Array(bytes.buffer, bytes.byteOffset, header.indexCount) : new Uint32Array(bytes.buffer, bytes.byteOffset, header.indexCount);
+    }
+    return {
+        header,
+        vertexData,
+        indexData
+    };
+}
+
+export { ZMSH_BINARY_VERSION, ZMSH_MAGIC, decodeZmshBinary, isZmshBinary, readZmshBinary, writeZmshBinary };
+//# sourceMappingURL=zmsh_binary.js.map

package/dist/asset/zmsh_binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zmsh_binary.js","sources":["../../src/asset/zmsh_binary.ts"],"sourcesContent":["import type { VertexAttribFormat } from '@zephyr3d/device';\r\nimport type { PrimitiveType } from '@zephyr3d/device';\r\n\r\n/**\r\n * Binary `.zmsh` container, version 2.\r\n *\r\n * Laid out like GLB: a fixed preamble, a JSON header describing the mesh, then\r\n * one binary blob holding every stream back to back.\r\n *\r\n * ```\r\n * u32 magic        'ZMSH' (0x48534d5a little endian)\r\n * u32 version      2\r\n * u32 headerLength byte length of the JSON header, a multiple of 4\r\n * u8[headerLength] JSON header (UTF-8, padded with spaces)\r\n * u8[...]          blob; every stream offset is relative to its start and 4-byte aligned\r\n * ```\r\n *\r\n * Streams are meshoptimizer-encoded when `encoding` is `meshopt` (the\r\n * KHR_meshopt_compression bitstream, decoded with `decodeGltfBuffer`), raw\r\n * otherwise. Version 1 is the JSON + base64 form, which readers keep accepting.\r\n *\r\n * @public\r\n */\r\nexport interface ZmshBinaryHeader {\r\n  primitiveType: PrimitiveType;\r\n  vertexCount: number;\r\n  indexCount: number;\r\n  boxMin: [number, number, number];\r\n  boxMax: [number, number, number];\r\n  encoding: 'meshopt' | 'none';\r\n  attributes: ZmshBinaryStream[];\r\n  indices: ZmshBinaryIndexStream | null;\r\n  /**\r\n   * Levels of detail, finest first, each a range of the index stream drawing the shared vertices.\r\n   * Absent for a single level, which draws all indexCount indices. The screen size of the first\r\n   * level is not used.\r\n   */\r\n  lods?: ZmshBinaryLod[];\r\n}\r\n\r\n/**\r\n * One level of detail of a binary `.zmsh`, see {@link PrimitiveLod}.\r\n * @public\r\n */\r\nexport interface ZmshBinaryLod {\r\n  indexStart: number;\r\n  indexCount: number;\r\n  screenSize: number;\r\n  hysteresis: number;\r\n}\r\n\r\n/**\r\n * One vertex stream of a binary `.zmsh`.\r\n * @public\r\n */\r\nexport interface ZmshBinaryStream {\r\n  format: VertexAttribFormat;\r\n  /** Bytes per vertex; meshopt requires a multiple of 4 no larger than 256 */\r\n  byteStride: number;\r\n  /** meshopt filter the stream was encoded with: OCTAHEDRAL, QUATERNION, EXPONENTIAL or COLOR */\r\n  filter?: string;\r\n  offset: number;\r\n  length: number;\r\n}\r\n\r\n/**\r\n * The index stream of a binary `.zmsh`.\r\n * @public\r\n */\r\nexport interface ZmshBinaryIndexStream {\r\n  type: 'u16' | 'u32';\r\n  /** meshopt mode: TRIANGLES for triangle lists, INDICES for any other topology */\r\n  mode: 'TRIANGLES' | 'INDICES';\r\n  offset: number;\r\n  length: number;\r\n}\r\n\r\n/** @public */\r\nexport const ZMSH_MAGIC = 0x48534d5a;\r\n/** @public */\r\nexport const ZMSH_BINARY_VERSION = 2;\r\n\r\nconst PREAMBLE_SIZE = 12;\r\n\r\nfunction align4(n: number) {\r\n  return (n + 3) & ~3;\r\n}\r\n\r\n/**\r\n * True if the data is a binary `.zmsh` rather than the JSON form.\r\n * @public\r\n */\r\nexport function isZmshBinary(data: ArrayBuffer) {\r\n  return data.byteLength >= PREAMBLE_SIZE && new DataView(data).getUint32(0, true) === ZMSH_MAGIC;\r\n}\r\n\r\n/**\r\n * Assembles a binary `.zmsh`. Stream offsets and lengths in the header are\r\n * filled in from `attributeData` and `indexData`, which must be in the order of\r\n * `header.attributes`.\r\n * @public\r\n */\r\nexport function writeZmshBinary(\r\n  header: Omit<ZmshBinaryHeader, 'attributes' | 'indices'> & {\r\n    attributes: Omit<ZmshBinaryStream, 'offset' | 'length'>[];\r\n    indices: Omit<ZmshBinaryIndexStream, 'offset' | 'length'> | null;\r\n  },\r\n  attributeData: Uint8Array[],\r\n  indexData: Uint8Array | null\r\n): ArrayBuffer {\r\n  if (attributeData.length !== header.attributes.length) {\r\n    throw new Error('writeZmshBinary(): one data array is needed per attribute');\r\n  }\r\n  if (!!indexData !== !!header.indices) {\r\n    throw new Error('writeZmshBinary(): index data and index header must be given together');\r\n  }\r\n  let blobSize = 0;\r\n  const place = (length: number) => {\r\n    const offset = blobSize;\r\n    blobSize = align4(blobSize + length);\r\n    return { offset, length };\r\n  };\r\n  const full: ZmshBinaryHeader = {\r\n    ...header,\r\n    attributes: header.attributes.map((a, i) => ({ ...a, ...place(attributeData[i].byteLength) })),\r\n    indices: header.indices ? { ...header.indices, ...place(indexData!.byteLength) } : null\r\n  };\r\n  const json = new TextEncoder().encode(JSON.stringify(full));\r\n  const headerLength = align4(json.byteLength);\r\n  const out = new Uint8Array(PREAMBLE_SIZE + headerLength + blobSize);\r\n  const view = new DataView(out.buffer);\r\n  view.setUint32(0, ZMSH_MAGIC, true);\r\n  view.setUint32(4, ZMSH_BINARY_VERSION, true);\r\n  view.setUint32(8, headerLength, true);\r\n  out.fill(0x20, PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);\r\n  out.set(json, PREAMBLE_SIZE);\r\n  const blobStart = PREAMBLE_SIZE + headerLength;\r\n  full.attributes.forEach((a, i) => out.set(attributeData[i], blobStart + a.offset));\r\n  if (full.indices) {\r\n    out.set(indexData!, blobStart + full.indices.offset);\r\n  }\r\n  return out.buffer;\r\n}\r\n\r\n/**\r\n * Splits a binary `.zmsh` into its header and stream views. Streams are returned\r\n * as stored, still encoded when the header says `meshopt`.\r\n * @public\r\n */\r\nexport function readZmshBinary(data: ArrayBuffer) {\r\n  if (!isZmshBinary(data)) {\r\n    throw new Error('Not a binary .zmsh file');\r\n  }\r\n  const view = new DataView(data);\r\n  const version = view.getUint32(4, true);\r\n  if (version !== ZMSH_BINARY_VERSION) {\r\n    throw new Error(`Unsupported binary .zmsh version ${version}`);\r\n  }\r\n  const headerLength = view.getUint32(8, true);\r\n  const blobStart = PREAMBLE_SIZE + headerLength;\r\n  if (blobStart > data.byteLength) {\r\n    throw new Error('Truncated binary .zmsh header');\r\n  }\r\n  const header = JSON.parse(\r\n    new TextDecoder().decode(new Uint8Array(data, PREAMBLE_SIZE, headerLength))\r\n  ) as ZmshBinaryHeader;\r\n  const slice = (offset: number, length: number) => {\r\n    if (blobStart + offset + length > data.byteLength) {\r\n      throw new Error('Truncated binary .zmsh stream');\r\n    }\r\n    return new Uint8Array(data, blobStart + offset, length);\r\n  };\r\n  return {\r\n    header,\r\n    attributes: header.attributes.map((a) => slice(a.offset, a.length)),\r\n    indices: header.indices ? slice(header.indices.offset, header.indices.length) : null\r\n  };\r\n}\r\n\r\n/**\r\n * The subset of meshoptimizer's MeshoptDecoder the engine uses.\r\n * @public\r\n */\r\nexport interface MeshoptDecoderModule {\r\n  ready: Promise<void>;\r\n  decodeGltfBuffer(\r\n    target: Uint8Array,\r\n    count: number,\r\n    size: number,\r\n    source: Uint8Array,\r\n    mode: string,\r\n    filter?: string\r\n  ): void;\r\n}\r\n\r\n/**\r\n * Decodes the streams of a binary `.zmsh` into raw vertex and index data, ready\r\n * for GPU upload.\r\n * @public\r\n */\r\nexport function decodeZmshBinary(data: ArrayBuffer, decoder: MeshoptDecoderModule | null) {\r\n  const { header, attributes, indices } = readZmshBinary(data);\r\n  const meshopt = header.encoding === 'meshopt';\r\n  if (meshopt && !decoder) {\r\n    throw new Error('A meshopt decoder is required for this .zmsh');\r\n  }\r\n  const vertexData = header.attributes.map((a, i) => {\r\n    if (!meshopt) {\r\n      return attributes[i];\r\n    }\r\n    const target = new Uint8Array(header.vertexCount * a.byteStride);\r\n    decoder!.decodeGltfBuffer(\r\n      target,\r\n      header.vertexCount,\r\n      a.byteStride,\r\n      attributes[i],\r\n      'ATTRIBUTES',\r\n      a.filter\r\n    );\r\n    return target;\r\n  });\r\n  let indexData: Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | null = null;\r\n  if (header.indices && indices) {\r\n    const size = header.indices.type === 'u16' ? 2 : 4;\r\n    let bytes: Uint8Array;\r\n    if (meshopt) {\r\n      bytes = new Uint8Array(header.indexCount * size);\r\n      decoder!.decodeGltfBuffer(bytes, header.indexCount, size, indices, header.indices.mode);\r\n    } else {\r\n      // Copy so the typed array is aligned regardless of where the stream sat in the file\r\n      bytes = indices.slice();\r\n    }\r\n    indexData =\r\n      size === 2\r\n        ? new Uint16Array(bytes.buffer as ArrayBuffer, bytes.byteOffset, header.indexCount)\r\n        : new Uint32Array(bytes.buffer as ArrayBuffer, bytes.byteOffset, header.indexCount);\r\n  }\r\n  return { header, vertexData, indexData };\r\n}\r\n"],"names":["ZMSH_MAGIC","ZMSH_BINARY_VERSION","PREAMBLE_SIZE","align4","n","isZmshBinary","data","byteLength","DataView","getUint32","writeZmshBinary","header","attributeData","indexData","length","attributes","Error","indices","blobSize","place","offset","full","map","a","i","json","TextEncoder","encode","JSON","stringify","headerLength","out","Uint8Array","view","buffer","setUint32","fill","set","blobStart","forEach","readZmshBinary","version","parse","TextDecoder","decode","slice","decodeZmshBinary","decoder","meshopt","encoding","vertexData","target","vertexCount","byteStride","decodeGltfBuffer","filter","size","type","bytes","indexCount","mode","Uint16Array","byteOffset","Uint32Array"],"mappings":"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"}

package/dist/asset/zsdf_binary.js

@@ -0,0 +1,111 @@
+import { float2half, halfToFloat } from '@zephyr3d/base';
+
+/** @public */ const ZSDF_MAGIC = 0x4644535a;
+/** @public */ const ZSDF_VERSION = 1;
+const PREAMBLE_SIZE = 12;
+/**
+ * True if the data is a `.zsdf`.
+ * @public
+ */ function isZsdf(data) {
+    return data.byteLength >= PREAMBLE_SIZE && new DataView(data).getUint32(0, true) === ZSDF_MAGIC;
+}
+/**
+ * Encodes a baked field as a `.zsdf`.
+ * @public
+ */ function writeZsdf(sdf, source) {
+    const header = {
+        encoding: 'f16',
+        boxMin: sdf.boxMin,
+        boxMax: sdf.boxMax,
+        resolution: sdf.resolution,
+        voxelSize: sdf.voxelSize,
+        meshBoxMin: sdf.meshBoxMin,
+        meshBoxMax: sdf.meshBoxMax,
+        twoSided: sdf.twoSided,
+        minDistance: sdf.minDistance,
+        maxDistance: sdf.maxDistance,
+        ...source ? {
+            source
+        } : {}
+    };
+    const json = new TextEncoder().encode(JSON.stringify(header));
+    const headerLength = json.byteLength + 3 & -4;
+    const count = sdf.distances.length;
+    const out = new Uint8Array(PREAMBLE_SIZE + headerLength + count * 2);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, ZSDF_MAGIC, true);
+    view.setUint32(4, ZSDF_VERSION, true);
+    view.setUint32(8, headerLength, true);
+    out.fill(0x20, PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);
+    out.set(json, PREAMBLE_SIZE);
+    const voxels = new Uint16Array(out.buffer, PREAMBLE_SIZE + headerLength, count);
+    for(let i = 0; i < count; i++){
+        voxels[i] = float2half(sdf.distances[i]);
+    }
+    return out.buffer;
+}
+/**
+ * Splits a `.zsdf` into its header and its raw half-float voxels, as stored,
+ * ready for upload to an `r16f` texture.
+ * @public
+ */ function readZsdf(data) {
+    if (!isZsdf(data)) {
+        throw new Error('Not a .zsdf file');
+    }
+    const view = new DataView(data);
+    const version = view.getUint32(4, true);
+    if (version !== ZSDF_VERSION) {
+        throw new Error(`Unsupported .zsdf version ${version}`);
+    }
+    const headerLength = view.getUint32(8, true);
+    const header = JSON.parse(new TextDecoder().decode(new Uint8Array(data, PREAMBLE_SIZE, headerLength)));
+    if (header.encoding !== 'f16') {
+        throw new Error(`Unsupported .zsdf encoding ${header.encoding}`);
+    }
+    const count = header.resolution[0] * header.resolution[1] * header.resolution[2];
+    const start = PREAMBLE_SIZE + headerLength;
+    if (start + count * 2 > data.byteLength) {
+        throw new Error('Truncated .zsdf');
+    }
+    // Copy so the view is aligned and independent of the file buffer
+    const voxels = new Uint16Array(data.slice(start, start + count * 2));
+    return {
+        header,
+        voxels
+    };
+}
+/**
+ * Decodes a `.zsdf` into a {@link MeshSDFData} with float distances, for CPU queries.
+ * @public
+ */ function decodeZsdf(data) {
+    const { header, voxels } = readZsdf(data);
+    const distances = new Float32Array(voxels.length);
+    for(let i = 0; i < voxels.length; i++){
+        distances[i] = halfToFloat(voxels[i]);
+    }
+    return {
+        boxMin: header.boxMin,
+        boxMax: header.boxMax,
+        resolution: header.resolution,
+        voxelSize: header.voxelSize,
+        meshBoxMin: header.meshBoxMin,
+        meshBoxMax: header.meshBoxMax,
+        twoSided: header.twoSided,
+        minDistance: header.minDistance,
+        maxDistance: header.maxDistance,
+        distances
+    };
+}
+/** Directory the baked fields of a project live in. @public */ const MESH_SDF_DIR = '/assets/.sdf';
+/**
+ * Path of the field baked for a mesh asset: the asset path flattened into one
+ * file name under {@link MESH_SDF_DIR}, so the runtime finds it without an index.
+ * @param primitivePath - Asset path of the `.zmsh`, e.g. `/assets/models/car/chassis.zmsh`.
+ * @public
+ */ function getMeshSDFPath(primitivePath) {
+    const rel = primitivePath.replace(/^\/assets\//, '').replace(/^\/+/, '');
+    return `${MESH_SDF_DIR}/${rel.replace(/[\\/]/g, '__')}.zsdf`;
+}
+
+export { MESH_SDF_DIR, ZSDF_MAGIC, ZSDF_VERSION, decodeZsdf, getMeshSDFPath, isZsdf, readZsdf, writeZsdf };
+//# sourceMappingURL=zsdf_binary.js.map

package/dist/asset/zsdf_binary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zsdf_binary.js","sources":["../../src/asset/zsdf_binary.ts"],"sourcesContent":["import { float2half, halfToFloat } from '@zephyr3d/base';\r\nimport type { MeshSDFData } from '../utility/sdf/bake';\r\n\r\n/**\r\n * Binary `.zsdf` container: the signed distance field baked for a mesh.\r\n *\r\n * ```\r\n * u32 magic        'ZSDF' (0x4644535a little endian)\r\n * u32 version      1\r\n * u32 headerLength byte length of the JSON header, a multiple of 4\r\n * u8[headerLength] JSON header (UTF-8, padded with spaces)\r\n * u8[...]          voxel data, `resolution` x * y * z samples, x fastest\r\n * ```\r\n *\r\n * `encoding` `f16` stores one half float per voxel, the distance in the\r\n * mesh's local units. The field leaves room for sparse or quantized encodings.\r\n *\r\n * @public\r\n */\r\nexport interface ZsdfHeader {\r\n  encoding: 'f16';\r\n  boxMin: [number, number, number];\r\n  boxMax: [number, number, number];\r\n  resolution: [number, number, number];\r\n  voxelSize: number;\r\n  meshBoxMin: [number, number, number];\r\n  meshBoxMax: [number, number, number];\r\n  twoSided: boolean;\r\n  minDistance: number;\r\n  maxDistance: number;\r\n  /**\r\n   * What the field was baked from, for the editor to tell a stale bake: the\r\n   * content hash of the source mesh and the bake settings key.\r\n   */\r\n  source?: { hash: string; settings: string };\r\n}\r\n\r\n/** @public */\r\nexport const ZSDF_MAGIC = 0x4644535a;\r\n/** @public */\r\nexport const ZSDF_VERSION = 1;\r\n\r\nconst PREAMBLE_SIZE = 12;\r\n\r\n/**\r\n * True if the data is a `.zsdf`.\r\n * @public\r\n */\r\nexport function isZsdf(data: ArrayBuffer) {\r\n  return data.byteLength >= PREAMBLE_SIZE && new DataView(data).getUint32(0, true) === ZSDF_MAGIC;\r\n}\r\n\r\n/**\r\n * Encodes a baked field as a `.zsdf`.\r\n * @public\r\n */\r\nexport function writeZsdf(sdf: MeshSDFData, source?: ZsdfHeader['source']): ArrayBuffer {\r\n  const header: ZsdfHeader = {\r\n    encoding: 'f16',\r\n    boxMin: sdf.boxMin,\r\n    boxMax: sdf.boxMax,\r\n    resolution: sdf.resolution,\r\n    voxelSize: sdf.voxelSize,\r\n    meshBoxMin: sdf.meshBoxMin,\r\n    meshBoxMax: sdf.meshBoxMax,\r\n    twoSided: sdf.twoSided,\r\n    minDistance: sdf.minDistance,\r\n    maxDistance: sdf.maxDistance,\r\n    ...(source ? { source } : {})\r\n  };\r\n  const json = new TextEncoder().encode(JSON.stringify(header));\r\n  const headerLength = (json.byteLength + 3) & ~3;\r\n  const count = sdf.distances.length;\r\n  const out = new Uint8Array(PREAMBLE_SIZE + headerLength + count * 2);\r\n  const view = new DataView(out.buffer);\r\n  view.setUint32(0, ZSDF_MAGIC, true);\r\n  view.setUint32(4, ZSDF_VERSION, true);\r\n  view.setUint32(8, headerLength, true);\r\n  out.fill(0x20, PREAMBLE_SIZE, PREAMBLE_SIZE + headerLength);\r\n  out.set(json, PREAMBLE_SIZE);\r\n  const voxels = new Uint16Array(out.buffer, PREAMBLE_SIZE + headerLength, count);\r\n  for (let i = 0; i < count; i++) {\r\n    voxels[i] = float2half(sdf.distances[i]);\r\n  }\r\n  return out.buffer;\r\n}\r\n\r\n/**\r\n * Splits a `.zsdf` into its header and its raw half-float voxels, as stored,\r\n * ready for upload to an `r16f` texture.\r\n * @public\r\n */\r\nexport function readZsdf(data: ArrayBuffer) {\r\n  if (!isZsdf(data)) {\r\n    throw new Error('Not a .zsdf file');\r\n  }\r\n  const view = new DataView(data);\r\n  const version = view.getUint32(4, true);\r\n  if (version !== ZSDF_VERSION) {\r\n    throw new Error(`Unsupported .zsdf version ${version}`);\r\n  }\r\n  const headerLength = view.getUint32(8, true);\r\n  const header = JSON.parse(\r\n    new TextDecoder().decode(new Uint8Array(data, PREAMBLE_SIZE, headerLength))\r\n  ) as ZsdfHeader;\r\n  if (header.encoding !== 'f16') {\r\n    throw new Error(`Unsupported .zsdf encoding ${header.encoding}`);\r\n  }\r\n  const count = header.resolution[0] * header.resolution[1] * header.resolution[2];\r\n  const start = PREAMBLE_SIZE + headerLength;\r\n  if (start + count * 2 > data.byteLength) {\r\n    throw new Error('Truncated .zsdf');\r\n  }\r\n  // Copy so the view is aligned and independent of the file buffer\r\n  const voxels = new Uint16Array(data.slice(start, start + count * 2));\r\n  return { header, voxels };\r\n}\r\n\r\n/**\r\n * Decodes a `.zsdf` into a {@link MeshSDFData} with float distances, for CPU queries.\r\n * @public\r\n */\r\nexport function decodeZsdf(data: ArrayBuffer): MeshSDFData {\r\n  const { header, voxels } = readZsdf(data);\r\n  const distances = new Float32Array(voxels.length);\r\n  for (let i = 0; i < voxels.length; i++) {\r\n    distances[i] = halfToFloat(voxels[i]);\r\n  }\r\n  return {\r\n    boxMin: header.boxMin,\r\n    boxMax: header.boxMax,\r\n    resolution: header.resolution,\r\n    voxelSize: header.voxelSize,\r\n    meshBoxMin: header.meshBoxMin,\r\n    meshBoxMax: header.meshBoxMax,\r\n    twoSided: header.twoSided,\r\n    minDistance: header.minDistance,\r\n    maxDistance: header.maxDistance,\r\n    distances\r\n  };\r\n}\r\n\r\n/** Directory the baked fields of a project live in. @public */\r\nexport const MESH_SDF_DIR = '/assets/.sdf';\r\n\r\n/**\r\n * Path of the field baked for a mesh asset: the asset path flattened into one\r\n * file name under {@link MESH_SDF_DIR}, so the runtime finds it without an index.\r\n * @param primitivePath - Asset path of the `.zmsh`, e.g. `/assets/models/car/chassis.zmsh`.\r\n * @public\r\n */\r\nexport function getMeshSDFPath(primitivePath: string) {\r\n  const rel = primitivePath.replace(/^\\/assets\\//, '').replace(/^\\/+/, '');\r\n  return `${MESH_SDF_DIR}/${rel.replace(/[\\\\/]/g, '__')}.zsdf`;\r\n}\r\n"],"names":["ZSDF_MAGIC","ZSDF_VERSION","PREAMBLE_SIZE","isZsdf","data","byteLength","DataView","getUint32","writeZsdf","sdf","source","header","encoding","boxMin","boxMax","resolution","voxelSize","meshBoxMin","meshBoxMax","twoSided","minDistance","maxDistance","json","TextEncoder","encode","JSON","stringify","headerLength","count","distances","length","out","Uint8Array","view","buffer","setUint32","fill","set","voxels","Uint16Array","i","float2half","readZsdf","Error","version","parse","TextDecoder","decode","start","slice","decodeZsdf","Float32Array","halfToFloat","MESH_SDF_DIR","getMeshSDFPath","primitivePath","rel","replace"],"mappings":"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"}

package/dist/blitter/bilateralblur.js

@@ -1,5 +1,4 @@
 import { Blitter } from './blitter.js';
-import { decodeNormalizedFloatFromRGBA } from '../shaders/misc.js';
 import { Vector2 } from '@zephyr3d/base';
 import { fetchSampler } from '../utility/misc.js';
 
@@ -173,7 +172,7 @@ import { fetchSampler } from '../utility/misc.js';
             pb.vec2('uv')
         ], function() {
             this.$l.depthValue = pb.textureSample(this.depthTex, this.uv);
-            this.$l.depth01 = pb.getDevice().type === 'webgl' ? decodeNormalizedFloatFromRGBA(this, this.depthValue) : this.depthValue.r;
+            this.$l.depth01 = this.depthValue.r;
             this.$return(pb.mul(this.depth01, this.cameraNearFar.y));
         });
         pb.func('getLogDepth', [