@babylonjs/viewer/dist/chunks/environment-recovery-tYD5QxX7.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 { T as ThrowLiteError, aK as assembleEnvironmentTextures, aL as acquireGPUTexture, aM as releaseGPUTexture, aN as loadBrdfImage, aO as parseEnvFile } from './index-DMbDahsc.esm.js';

async function rebuildSceneEnvironment(engine, scene) {
  const current = scene._envTextures;
  if (!current) {
    return;
  }
  const source = scene._envRecoverySource;
  if (!source) {
    ThrowLiteError(84);
  }
  const sphericalHarmonics = current.sphericalHarmonics;
  scene._envTextures = void 0;
  let replacement;
  if (source.kind === "env") {
    replacement = await reloadEnvironmentTextures(engine, source, sphericalHarmonics);
  } else {
    const parser = await import('./index-DMbDahsc.esm.js').then(function (n) { return n.bQ; });
    const pipeline = await import('./index-DMbDahsc.esm.js').then(function (n) { return n.bR; });
    const buffer = await fetchRecoverySource(source.url);
    const hdr = parser.parseRGBE(buffer);
    const irradianceSH = parser.computeSHFromEquirect(hdr.data, hdr.width, hdr.height);
    const sourceCube = pipeline.equirectToCubemapGPU(engine, hdr, source.faceSize);
    const specularCube2 = pipeline.prefilterCubemapGPU(engine, sourceCube, source.faceSize, Math.floor(Math.log2(source.faceSize)) + 1);
    replacement = assembleEnvironmentTextures(specularCube2, pipeline.generateBrdfLut(engine), irradianceSH, 1, engine, sphericalHarmonics);
  }
  Object.assign(current, replacement);
  const { specularCube, brdfLut } = current;
  acquireGPUTexture(specularCube);
  acquireGPUTexture(brdfLut);
  scene._disposables.push(() => {
    releaseGPUTexture(specularCube);
    releaseGPUTexture(brdfLut);
  });
  scene._envTextures = current;
  scene._envRecoverySource = source;
}
async function reloadEnvironmentTextures(engine, source, sphericalHarmonics) {
  const brdfPromise = loadBrdfImage(source.brdfUrl);
  brdfPromise.catch(() => {
  });
  const buffer = await fetchRecoverySource(source.url);
  const { faceBlobs, irradianceSH, width, mipCount } = parseEnvFile(buffer);
  const faceImages = await Promise.all(faceBlobs.map((blob) => createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" })));
  const rgbd = await import('./rgbd-decode-BjFbAbyB.esm.js');
  const specularCube = rgbd.uploadCubemapRGBD(engine, faceImages, width, mipCount);
  for (const image of faceImages) {
    image.close();
  }
  const brdfImage = await brdfPromise;
  const brdfLut = rgbd.decodeBrdfPng(engine, brdfImage);
  brdfImage.close();
  return assembleEnvironmentTextures(specularCube, brdfLut, irradianceSH, 0.8, engine, sphericalHarmonics);
}
async function fetchRecoverySource(url) {
  const response = await fetch(url);
  if (!response.ok) {
    ThrowLiteError(85, url, response.status, response.statusText);
  }
  return response.arrayBuffer();
}

export { rebuildSceneEnvironment };
//# sourceMappingURL=environment-recovery-tYD5QxX7.esm.js.map