@babylonjs/viewer/dist/chunks/gltf-variants-VLco5xsJ.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 { bb as identityTexWrap, k as getOrCreateSampler, bc as assembleMaterial, au as uploadTex, bd as makeImageFetcher } from './index-By0tcgYN.esm.js';
import { buildDefaultPbrTexturesExt, assemblePbrPropsExt } from './gltf-pbr-builder-ext-BxJHfsvC.esm.js';
import './texture-2d-CMQ0_OPI.esm.js';

async function loadVariantMaterials(json, binChunk, baseUrl, variantNames, meshes, engine, exts, runMatExts, wrapTex = identityTexWrap) {
  const generateMipmaps = (await import('./generate-mipmaps-BL7R_dXN.esm.js')).generateMipmaps;
  const sampler = getOrCreateSampler(engine, {
    magFilter: "linear",
    minFilter: "linear",
    mipmapFilter: "linear",
    addressModeU: "repeat",
    addressModeV: "repeat",
    maxAnisotropy: 4
  });
  const matCache = [];
  const imageCache = [];
  const fetchImg = makeImageFetcher(json, binChunk, baseUrl, imageCache);
  const getCachedTex = (bitmap, srgb) => uploadTex(engine, bitmap, srgb, sampler, generateMipmaps);
  const extCtx = {
    _engine: engine,
    async _texture(texInfo, sRGB) {
      if (!texInfo) {
        return void 0;
      }
      const img = await fetchImg(texInfo);
      return img ? wrapTex(uploadTex(engine, img, sRGB, sampler, generateMipmaps), texInfo) : void 0;
    },
    _uploadImage(bitmap, sRGB) {
      return uploadTex(engine, bitmap, sRGB, sampler, generateMipmaps);
    }
  };
  const getMat = (matIdx) => {
    return matCache[matIdx] ??= assembleMaterial(json, binChunk, matIdx, baseUrl, imageCache);
  };
  const pbrCache = /* @__PURE__ */ new Map();
  const getPbr = (gltfMat) => {
    let p = pbrCache.get(gltfMat);
    if (!p) {
      p = (async () => {
        const tex = buildDefaultPbrTexturesExt(engine, gltfMat, sampler, generateMipmaps, getCachedTex, wrapTex);
        const layers = await runMatExts(gltfMat, exts, extCtx);
        return assemblePbrPropsExt(gltfMat, tex, layers);
      })();
      pbrCache.set(gltfMat, p);
    }
    return p;
  };
  const originals = [];
  const variants = {};
  for (const name of variantNames) {
    variants[name] = [];
  }
  let meshIdx = 0;
  for (let nodeIdx = 0; nodeIdx < json.nodes.length; nodeIdx++) {
    const node = json.nodes[nodeIdx];
    if (node.mesh === void 0) {
      continue;
    }
    const gltfMesh = json.meshes[node.mesh];
    for (const primitive of gltfMesh.primitives) {
      const mesh = meshes[meshIdx];
      const variantExt = primitive.extensions?.KHR_materials_variants;
      if (variantExt?.mappings) {
        originals.push({ mesh, material: mesh.material });
        for (const mapping of variantExt.mappings) {
          const gltfMat = await getMat(mapping.material);
          const pbrMat = await getPbr(gltfMat);
          for (const vi of mapping.variants) {
            const name = variantNames[vi];
            if (name) {
              variants[name].push({ mesh, material: pbrMat });
            }
          }
        }
      }
      meshIdx++;
    }
  }
  return { names: variantNames, variants, originals };
}

export { loadVariantMaterials };
//# sourceMappingURL=gltf-variants-VLco5xsJ.esm.js.map