@babylonjs/viewer
Version:
The Babylon Viewer aims to simplify a specific but common Babylon.js use case: loading, viewing, and interacting with a 3D model.
114 lines (111 loc) • 4.07 kB
JavaScript
import { T as ThrowLiteError, ba as brdfLutWGSL, i as TU, F as F32 } from './index-By0tcgYN.esm.js';
const _bilinearDesc = { magFilter: "linear", minFilter: "linear" };
const _trilinearDesc = { magFilter: "linear", minFilter: "linear", mipmapFilter: "linear" };
function polynomialToPreScaledHarmonics(poly) {
const C00xy = 0.3333338747897695;
const C00z = 0.33333298856284405;
const C1 = 1.4999984284682104;
const C2 = 3.999982863580422;
const C20zz = 1.3333326611423701;
const C20xy = 0.6666653397393608;
const C22 = 1.999991431790211;
const out = new F32(36);
for (let i = 0; i < 3; i++) {
const x = poly[i];
const y = poly[3 + i];
const z = poly[6 + i];
const xx = poly[9 + i];
const yy = poly[12 + i];
const zz = poly[15 + i];
const yz = poly[18 + i];
const zx = poly[21 + i];
const xy = poly[24 + i];
out[i] = (xx + yy) * C00xy + zz * C00z;
out[4 + i] = y * C1;
out[8 + i] = z * C1;
out[12 + i] = x * C1;
out[16 + i] = xy * C2;
out[20 + i] = yz * C2;
out[24 + i] = zz * C20zz - (xx + yy) * C20xy;
out[28 + i] = zx * C2;
out[32 + i] = (xx - yy) * C22;
}
return out;
}
function assembleEnvironmentTextures(specularCube, brdfLut, irradianceSH, lodGenerationScale, engine) {
return {
specularCube,
specularCubeView: specularCube.createView({ dimension: "cube" }),
brdfLut,
brdfLutView: brdfLut.createView(),
cubeSampler: engine._device.createSampler(_trilinearDesc),
brdfSampler: engine._device.createSampler(_bilinearDesc),
irradianceSH,
sphericalHarmonics: polynomialToPreScaledHarmonics(irradianceSH),
lodGenerationScale
};
}
let _brdfPipeline = null;
let _brdfPipelineDevice = null;
function generateBrdfLut(engine) {
const device = engine._device;
if (!_brdfPipeline || _brdfPipelineDevice !== device) {
_brdfPipeline = device.createComputePipeline({
layout: "auto",
compute: { module: device.createShaderModule({ code: brdfLutWGSL }), entryPoint: "main" }
});
_brdfPipelineDevice = device;
}
const size = 256;
const texture = device.createTexture({
size: { width: size, height: size },
format: "rgba16float",
usage: TU.TEXTURE_BINDING | TU.STORAGE_BINDING
});
const bindGroup = device.createBindGroup({
layout: _brdfPipeline.getBindGroupLayout(0),
entries: [{ binding: 0, resource: texture.createView() }]
});
const encoder = device.createCommandEncoder();
const pass = encoder.beginComputePass();
pass.setPipeline(_brdfPipeline);
pass.setBindGroup(0, bindGroup);
pass.dispatchWorkgroups(Math.ceil(size / 8), Math.ceil(size / 8));
pass.end();
device.queue.submit([encoder.finish()]);
return texture;
}
async function resolveImage(json, binChunk, imageIdx, baseUrl) {
const image = json.images[imageIdx];
if (image.bufferView !== void 0) {
const bv = json.bufferViews[image.bufferView];
const offset = binChunk.byteOffset + (bv.byteOffset ?? 0);
const slice = binChunk.buffer.slice(offset, offset + bv.byteLength);
const blob = new Blob([slice], { type: image.mimeType ?? "image/png" });
return createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" });
}
if (image.uri) {
const imageUrl = new URL(image.uri, baseUrl + "x").href;
const response = await fetch(imageUrl);
if (!response.ok) {
ThrowLiteError(100, response.status, response.statusText);
}
const blob = await response.blob();
return createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" });
}
ThrowLiteError(101);
}
function writeEnvShUbo(data, scene) {
const sh = scene._envTextures?.sphericalHarmonics;
if (sh) {
data.set(sh, 40);
}
}
function registerEnvSceneUniforms(scene) {
const list = scene._sceneUboContributors ??= [];
if (!list.includes(writeEnvShUbo)) {
list.push(writeEnvShUbo);
}
}
export { assembleEnvironmentTextures, generateBrdfLut, registerEnvSceneUniforms, resolveImage };
//# sourceMappingURL=ibl-env-assembly-BDhyzzL4.esm.js.map