@babylonjs/viewer/dist/chunks/gltf-feature-registry-2SiGrklx.esm.js

The Babylon Viewer aims to simplify a specific but common Babylon.js use case: loading, viewing, and interacting with a 3D model.

import { al as needsOrmComposite, am as anyPrimitive } from './index-By0tcgYN.esm.js';

const M = "KHR_materials_";
const _features = [
  // Pre-parse features (buffer-level): order matters — meshopt decompresses
  // bufferViews first, then sparse accessors are materialized (so their base can
  // read decompressed data), then quantization dequantizes the resulting accessors.
  ["EXT_meshopt_compression", () => import('./gltf-feature-meshopt-Bdj0KhKJ.esm.js')],
  [(j) => !!j.accessors?.some((a) => a.sparse), () => import('./gltf-feature-sparse-usmYxXwF.esm.js')],
  ["KHR_mesh_quantization", () => import('./gltf-ext-quantization-D_TWzdbd.esm.js')],
  // Pre-mesh features (geometry decompression)
  ["KHR_draco_mesh_compression", () => import('./gltf-feature-draco-DSCbuFAk.esm.js')],
  // Material extensions
  [M + "clearcoat", () => import('./gltf-ext-clearcoat-DggoWrNx.esm.js')],
  [M + "iridescence", () => import('./gltf-ext-iridescence-BBQHpaCO.esm.js')],
  [M + "emissive_strength", () => import('./gltf-ext-emissive-strength-CIvH5qSE.esm.js')],
  [M + "sheen", () => import('./gltf-ext-sheen-CFu97G55.esm.js')],
  [M + "anisotropy", () => import('./gltf-ext-anisotropy-l1Zw3YTh.esm.js')],
  [M + "diffuse_transmission", () => import('./gltf-ext-diffuse-transmission-B6LFJcNz.esm.js')],
  [M + "unlit", () => import('./gltf-ext-unlit-BZbGP65q.esm.js')],
  [M + "pbrSpecularGlossiness", () => import('./gltf-ext-spec-gloss-HSzoR1ZR.esm.js')],
  // Dielectric cluster (ior/specular/transmission/volume/dispersion) — any of the five triggers the
  // loader; transmission refraction is wired dynamically by the PBR material path when needed.
  [(j) => ["transmission", "volume", "ior", "specular", "dispersion"].some((e) => j.extensionsUsed?.includes(M + e)), () => import('./gltf-ext-dielectric-BKGcH-t4.esm.js')],
  ["KHR_texture_transform", () => import('./gltf-ext-uv-transform-BuxByHwO.esm.js')],
  ["KHR_texture_basisu", () => import('./gltf-ext-basisu-DHhPqw5C.esm.js')],
  [needsOrmComposite, () => import('./gltf-ext-orm-CSBI7gEy.esm.js')],
  // Per-mesh features (predicates inlined to avoid eager imports)
  [(j) => !!j.skins?.length && anyPrimitive(j, (p) => p.attributes?.JOINTS_0 !== void 0), () => import('./gltf-feature-skeleton-RTJMQrTP.esm.js')],
  [(j) => anyPrimitive(j, (p) => !!p.targets?.length), () => import('./gltf-feature-morph-B2-qmXTu.esm.js')],
  // Non-triangle primitive topology (POINTS/LINES/LINE_STRIP/TRIANGLE_STRIP) or a
  // negative-determinant node (negative scale / mirrored matrix): both need the lazy primitive
  // feature (topology threading + winding reversal). Triangle-list positive-winding never triggers.
  [(j) => hasNegDetNode(j) || anyPrimitive(j, (p) => p.mode !== void 0 && p.mode !== 4), () => import('./gltf-feature-primitive-lq8p4Yd3.esm.js')],
  // Per-asset features
  [hasGltfExtras, () => import('./gltf-feature-extras-DWMyMqbH.esm.js')],
  ["KHR_lights_punctual", () => import('./gltf-feature-lights-punctual-DgLamI8D.esm.js')],
  ["EXT_lights_image_based", () => import('./gltf-ext-lights-image-based-D13b8ty7.esm.js')],
  [(j) => !!j.animations?.length, () => import('./gltf-feature-animations-Jzr-4mRO.esm.js')],
  // Non-Float32 / normalized animation sampler accessors (e.g. Animation_SamplerType normalized
  // BYTE/SHORT rotation) need the lazy denorm converter; plain float samplers never load it.
  [hasNonFloatAnimSampler, () => import('./gltf-sampler-denorm-0Kc9m7Xv.esm.js')],
  [M + "variants", () => import('./gltf-feature-variants-CVhXG0Ql.esm.js')],
  ["KHR_node_visibility", () => import('./gltf-ext-node-visibility-DRF5sRTL.esm.js')],
  ["KHR_animation_pointer", () => import('./gltf-feature-animation-pointer-DbLO7iMT.esm.js').then(function (n) { return n.g; })],
  ["EXT_mesh_gpu_instancing", () => import('./gltf-feature-gpu-instancing-BNBgA0Y7.esm.js')],
  ["KHR_xmp_json_ld", () => import('./gltf-feature-xmp-DA66RV4C.esm.js')]
];
async function loadGltfFeatures(json) {
  const used = json.extensionsUsed ?? [];
  const mods = await Promise.all(_features.flatMap(([t, load]) => (typeof t === "string" ? used.includes(t) : t(json)) ? [load()] : []));
  return mods.map((m) => m.default);
}
async function runGltfMaterialFeatures(mat, features, ctx) {
  const fragments = await Promise.all(features.map((feature) => feature.applyMaterial(mat, ctx)));
  let layers;
  for (const fragment of fragments) {
    if (fragment) {
      Object.assign(layers ??= {}, fragment);
    }
  }
  return layers;
}
function hasGltfExtras(json) {
  const hasExtras = (item) => item?.extras !== void 0;
  return hasExtras(json.asset) || !!json.nodes?.some(hasExtras) || !!json.materials?.some(hasExtras) || !!json.animations?.some(hasExtras) || !!json.meshes?.some(hasExtras) || anyPrimitive(json, hasExtras);
}
function hasNonFloatAnimSampler(json) {
  const accessors = json.accessors;
  return !!json.animations?.some(
    (a) => a.samplers?.some((s) => accessors[s.input]?.componentType !== 5126 || accessors[s.output]?.componentType !== 5126)
  );
}
function hasNegDetNode(json) {
  return !!json.nodes?.some((n) => {
    if (n.scale) {
      return n.scale[0] * n.scale[1] * n.scale[2] < 0;
    }
    if (n.matrix) {
      const m = n.matrix;
      return m[0] * (m[5] * m[10] - m[6] * m[9]) + m[1] * (m[6] * m[8] - m[4] * m[10]) + m[2] * (m[4] * m[9] - m[5] * m[8]) < 0;
    }
    return false;
  });
}

export { loadGltfFeatures, runGltfMaterialFeatures };
//# sourceMappingURL=gltf-feature-registry-2SiGrklx.esm.js.map