@babylonjs/lite 0.1.1

package/pbr-transmission-ext-BxW4CEGu.js

@@ -0,0 +1,581 @@
+import { aO as getOrCreateSampler, bq as createImageProcessingTask, br as biasedMipLevelCount, b2 as getBilinearSampler, bs as _vis, bt as recordMipmaps, bo as PBR2_HAS_REFRACTION, bu as PBR2_HAS_REFRACTION_MAP, aH as PBR_HAS_THICKNESS_MAP, bv as PBR2_LINEAR_IMAGE_PROCESSING, bw as PBR2_HAS_DISPERSION, aJ as PBR2_HAS_THICKNESS_GLTF_CHANNEL, bx as PBR2_HAS_VOLUME } from "./index-C8HOR2sB.js";
+const _trilinearAnisotropicDesc = {
+  magFilter: "linear",
+  minFilter: "linear",
+  mipmapFilter: "linear",
+  addressModeU: "repeat",
+  addressModeV: "repeat",
+  addressModeW: "repeat",
+  maxAnisotropy: 4
+};
+function getTrilinearAnisotropicSampler(engine) {
+  return getOrCreateSampler(engine, _trilinearAnisotropicDesc);
+}
+const BLIT_SHADER = `@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var s:sampler;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}@fragment fn fs(v:V)->@location(0)vec4f{return textureSample(t,s,v.u);}`;
+const BLIT_MSAA_SHADER = `@group(0)@binding(0)var t:texture_multisampled_2d<f32>;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}fn l(p:vec2i)->vec4f{let n=textureNumSamples(t);var c=vec4f(0);for(var i=0u;i<n;i++){c+=textureLoad(t,p,i);}return c/f32(n);}@fragment fn fs(v:V)->@location(0)vec4f{let d=vec2i(textureDimensions(t));let q=clamp(v.u*vec2f(d)-.5,vec2f(0),vec2f(d-vec2i(1)));let p=vec2i(floor(q));let f=fract(q);let p1=min(p+vec2i(1),d-vec2i(1));return mix(mix(l(p),l(vec2i(p1.x,p.y)),f.x),mix(l(vec2i(p.x,p1.y)),l(p1),f.x),f.y);}`;
+const REFRACTION_LOD_BIAS = 4;
+let blitPipelines = null;
+let blitShader = null;
+let blitMsaaShader = null;
+let blitBgl = null;
+let blitMsaaBgl = null;
+let blitDevice = null;
+function enableSceneTransmission(scene, engine) {
+  markPbrMaterialsLinear(scene);
+  let lastRenderTask = null;
+  for (const task of scene._frameGraph._tasks) {
+    if ("_renderables" in task) {
+      const renderTask = task;
+      enableRenderTaskTransmission(renderTask, engine);
+      lastRenderTask = renderTask;
+    }
+  }
+  if (lastRenderTask && !scene._frameGraph._tasks.some((task) => task.name === "transmission-image-processing")) {
+    scene._frameGraph._tasks.push(createImageProcessingTask({ name: "transmission-image-processing", source: lastRenderTask._config.rt }, engine, scene));
+  }
+}
+function enableRenderTaskTransmission(task, engine) {
+  var _a, _b;
+  if (task._executeWithTransmission) {
+    return;
+  }
+  retargetRenderTaskToLinearOffscreen(task, engine);
+  let state = null;
+  const record = task.record.bind(task);
+  const execute = (_a = task.execute) == null ? void 0 : _a.bind(task);
+  const dispose = (_b = task.dispose) == null ? void 0 : _b.bind(task);
+  task.record = () => {
+    disposeRenderTaskTransmission(state);
+    state = createRenderTaskTransmission(task, engine);
+    task._targetSignature._transmissionTexture = state.texture;
+    record();
+    configureTransmissionSource(state, task, engine);
+  };
+  if (execute) {
+    task.execute = () => executeRenderTaskLinear(task.scene, execute);
+  }
+  task.dispose = () => {
+    disposeRenderTaskTransmission(state);
+    state = null;
+    dispose == null ? void 0 : dispose();
+  };
+  task._executeWithTransmission = (sampleCount) => executePassWithTransmission(task, engine, state, sampleCount);
+}
+function retargetRenderTaskToLinearOffscreen(task, engine) {
+  const desc = task._config.rt._descriptor;
+  if (desc.resolveToSwapchain) {
+    desc.resolveToSwapchain = false;
+    desc.colorFormat = "rgba16float";
+    desc.flipY = false;
+    task._opaqueBundles.length = 0;
+    task._lastVersion = -1;
+  } else if (!desc.colorFormat) {
+    desc.colorFormat = "rgba16float";
+  }
+  desc.sampleCount = engine.msaaSamples;
+  const sig = task._targetSignature;
+  sig._colorFormat = desc.colorFormat;
+  sig._depthStencilFormat = desc.depthStencilFormat;
+  sig._depthCompare = desc._depthCompare;
+  sig._sampleCount = desc.sampleCount;
+  sig._flipY = desc.flipY ?? true;
+}
+function executeRenderTaskLinear(scene, execute) {
+  const imageProcessing = scene.imageProcessing;
+  const toneMappingEnabled = imageProcessing.toneMappingEnabled;
+  const clearColor = scene.clearColor;
+  const linearClearColor = inverseImageProcessedColor(clearColor, imageProcessing.exposure, imageProcessing.contrast, toneMappingEnabled === true);
+  imageProcessing.toneMappingEnabled = -1;
+  scene.clearColor = linearClearColor;
+  try {
+    return execute();
+  } finally {
+    scene.clearColor = clearColor;
+    imageProcessing.toneMappingEnabled = toneMappingEnabled;
+  }
+}
+function inverseImageProcessedColor(color, exposure, contrast, toneMapping) {
+  return {
+    r: inverseImageProcessedChannel(color.r, exposure, contrast, toneMapping),
+    g: inverseImageProcessedChannel(color.g, exposure, contrast, toneMapping),
+    b: inverseImageProcessedChannel(color.b, exposure, contrast, toneMapping),
+    a: color.a
+  };
+}
+function inverseImageProcessedChannel(value, exposure, contrast, toneMapping) {
+  let c = clamp01(value);
+  if (contrast < 1) {
+    c = contrast > 0 ? clamp01((c - 0.5 * (1 - contrast)) / contrast) : 0.5;
+  } else if (contrast > 1) {
+    const mixAmount = contrast - 1;
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 16; i++) {
+      const mid = (lo + hi) * 0.5;
+      const high = mid * mid * (3 - 2 * mid);
+      const out = mid + (high - mid) * mixAmount;
+      if (out < c) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    c = (lo + hi) * 0.5;
+  }
+  c = c ** 2.2;
+  if (toneMapping) {
+    c = -Math.log2(Math.max(1 - c, 1e-6)) / 1.5905790328979492;
+  }
+  return exposure > 0 ? c / exposure : c;
+}
+function clamp01(v) {
+  return Math.min(Math.max(v, 0), 1);
+}
+function markPbrMaterialsLinear(scene) {
+  for (const mesh of scene.meshes) {
+    const mat = mesh.material;
+    if (mat) {
+      mat._linearImageProcessing = true;
+      mat._renderFeatures = void 0;
+    }
+  }
+}
+function createRenderTaskTransmission(task, engine) {
+  const rt = task._config.rt;
+  const width = 1024;
+  const height = 1024;
+  const format = "rgba16float";
+  const generateMipmaps = shouldGenerateMipmaps(task._config.transmission);
+  const texture = engine._device.createTexture({
+    label: task.name,
+    size: { width, height },
+    format,
+    mipLevelCount: generateMipmaps ? biasedMipLevelCount(width, height, REFRACTION_LOD_BIAS) : 1,
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+  });
+  const tex = {
+    texture,
+    view: texture.createView(),
+    sampler: getTrilinearAnisotropicSampler(engine),
+    width,
+    height,
+    invertY: false
+  };
+  return {
+    texture: tex,
+    _baseView: texture.createView({ baseMipLevel: 0, mipLevelCount: 1 }),
+    _sourceWidth: rt._width,
+    _sourceHeight: rt._height,
+    _sourceTexture: null,
+    _blit: null,
+    _copyCount: normalizeCopyCount(task._config.transmission),
+    _generateMipmaps: generateMipmaps,
+    _copies: 0
+  };
+}
+function configureTransmissionSource(state, task, engine) {
+  const rt = task._config.rt;
+  state._sourceWidth = rt._width;
+  state._sourceHeight = rt._height;
+  state._sourceTexture = rt._colorTexture;
+  const sampleCount = task._targetSignature._sampleCount;
+  if (!state._sourceTexture) {
+    return;
+  }
+  state._blit = shouldBlitTransmission(state, sampleCount) ? createTransmissionBlit(state, engine, state._sourceTexture, sampleCount > 1) : null;
+}
+function disposeRenderTaskTransmission(state) {
+  state == null ? void 0 : state.texture.texture.destroy();
+}
+function executePassWithTransmission(task, engine, state, sampleCount) {
+  state._copies = 0;
+  const transparent = task._transparentBindings;
+  let pass = beginTaskPass(task, null, sampleCount, false);
+  let draws = drawBaseTask(task, pass);
+  let lastPipeline = null;
+  for (let i = 0; i < transparent.length; i++) {
+    const binding = transparent[i];
+    const transmissive = binding.renderable._transmissive === true;
+    if (transmissive && canUpdateTransmission(state)) {
+      pass.end();
+      updateTransmissionTexture(state, engine);
+      pass = beginTaskPass(task, null, sampleCount, true);
+      setPassState(task, pass);
+      lastPipeline = null;
+    }
+    const mesh = binding.renderable.mesh;
+    if (mesh && mesh.visible === false) {
+      continue;
+    }
+    if (binding.pipeline !== lastPipeline) {
+      pass.setPipeline(binding.pipeline);
+      lastPipeline = binding.pipeline;
+    }
+    draws += binding.draw(pass, engine);
+  }
+  pass.end();
+  return draws;
+}
+function updateTransmissionTexture(state, engine) {
+  if (!state._sourceTexture) {
+    throw new Error("No transmission source");
+  }
+  if (state._blit) {
+    blitToTransmission(state, engine);
+  } else {
+    engine._currentEncoder.copyTextureToTexture(
+      { texture: state._sourceTexture },
+      { texture: state.texture.texture },
+      { width: state.texture.width, height: state.texture.height }
+    );
+  }
+  if (state._generateMipmaps) {
+    recordMipmaps(engine, state.texture.texture, engine._currentEncoder);
+  }
+  state._copies++;
+}
+function getBlitPipeline(engine, format, multisampled) {
+  const device = engine._device;
+  if (device !== blitDevice) {
+    blitPipelines == null ? void 0 : blitPipelines.clear();
+    blitPipelines = null;
+    blitShader = null;
+    blitMsaaShader = null;
+    blitBgl = null;
+    blitMsaaBgl = null;
+    blitDevice = device;
+  }
+  if (multisampled) {
+    blitMsaaShader ?? (blitMsaaShader = device.createShaderModule({ code: BLIT_MSAA_SHADER }));
+    blitMsaaBgl ?? (blitMsaaBgl = device.createBindGroupLayout({
+      entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "unfilterable-float", multisampled: true } }]
+    }));
+  } else {
+    blitShader ?? (blitShader = device.createShaderModule({ code: BLIT_SHADER }));
+    blitBgl ?? (blitBgl = device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} }
+      ]
+    }));
+  }
+  blitPipelines ?? (blitPipelines = /* @__PURE__ */ new Map());
+  const key = `${format}:${multisampled ? "msaa" : ""}`;
+  let pipeline = blitPipelines.get(key);
+  if (!pipeline) {
+    const bgl = multisampled ? blitMsaaBgl : blitBgl;
+    pipeline = device.createRenderPipeline({
+      label: "transmission-copy",
+      layout: device.createPipelineLayout({ bindGroupLayouts: [bgl] }),
+      vertex: { module: multisampled ? blitMsaaShader : blitShader, entryPoint: "vs" },
+      fragment: { module: multisampled ? blitMsaaShader : blitShader, entryPoint: "fs", targets: [{ format }] },
+      primitive: { topology: "triangle-list" }
+    });
+    blitPipelines.set(key, pipeline);
+  }
+  return pipeline;
+}
+function shouldBlitTransmission(state, sampleCount) {
+  return sampleCount > 1 || state._sourceWidth !== state.texture.width || state._sourceHeight !== state.texture.height;
+}
+function createTransmissionBlit(state, engine, source, multisampled) {
+  const device = engine._device;
+  const pipeline = getBlitPipeline(engine, state.texture.texture.format, multisampled);
+  const bindGroup = device.createBindGroup({
+    layout: multisampled ? blitMsaaBgl : blitBgl,
+    entries: multisampled ? [{ binding: 0, resource: source.createView() }] : [
+      { binding: 0, resource: source.createView() },
+      { binding: 1, resource: getBilinearSampler(engine) }
+    ]
+  });
+  return { _pipeline: pipeline, _bindGroup: bindGroup };
+}
+function blitToTransmission(state, engine) {
+  const blit = state._blit;
+  const pass = engine._currentEncoder.beginRenderPass({
+    colorAttachments: [{ view: state._baseView, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }]
+  });
+  pass.setPipeline(blit._pipeline);
+  pass.setBindGroup(0, blit._bindGroup);
+  pass.draw(3);
+  pass.end();
+}
+function canUpdateTransmission(state) {
+  return state._copyCount === 0 || state._copies < state._copyCount;
+}
+function beginTaskPass(task, resolveTarget, sampleCount, load) {
+  const att = task._colorAttachment;
+  const depthLoadOp = load || !task._config.clr ? "load" : "clear";
+  if (load) {
+    att.loadOp = "load";
+  }
+  const depthAttachment = task._renderPassDescriptor.depthStencilAttachment;
+  if (depthAttachment) {
+    depthAttachment.depthLoadOp = depthLoadOp;
+    if (depthAttachment.stencilLoadOp) {
+      depthAttachment.stencilLoadOp = depthLoadOp;
+    }
+  }
+  if (sampleCount > 1) {
+    att.resolveTarget = void 0;
+  } else {
+    att.resolveTarget = void 0;
+  }
+  return task.engine._currentEncoder.beginRenderPass(task._renderPassDescriptor);
+}
+function setPassState(task, pass) {
+  const cfg = task._config;
+  const rt = cfg.rt;
+  const scene = task.scene;
+  const camera = cfg.cam ?? scene.camera;
+  const v = camera == null ? void 0 : camera.viewport;
+  if (v) {
+    const rw = rt._width;
+    const rh = rt._height;
+    const x = Math.floor(v.x * rw);
+    const y = Math.floor((1 - v.y - v.height) * rh);
+    const w = Math.ceil((v.x + v.width) * rw) - x;
+    const h = Math.ceil((1 - v.y) * rh) - y;
+    pass.setViewport(x, y, w, h, 0, 1);
+    pass.setScissorRect(x, y, w, h);
+  }
+  pass.setBindGroup(0, task._sceneBG);
+}
+function drawBaseTask(task, pass) {
+  const eng = task.engine;
+  const rt = task._config.rt;
+  const scene = task.scene;
+  const opaqueBindings = task._opaqueBindings;
+  const opaqueBundles = task._opaqueBundles;
+  setPassState(task, pass);
+  if (task._lastVersion !== scene._renderableVersion || task._lastVis !== _vis || opaqueBundles.length === 0) {
+    const desc = rt._descriptor;
+    const be = eng._device.createRenderBundleEncoder({
+      colorFormats: desc.colorFormat ? [desc.colorFormat] : [],
+      depthStencilFormat: desc.depthStencilFormat,
+      sampleCount: desc.sampleCount ?? 1
+    });
+    be.setBindGroup(0, task._sceneBG);
+    drawList(be, opaqueBindings, eng);
+    opaqueBundles[0] = be.finish();
+    task._lastVersion = scene._renderableVersion;
+    task._lastVis = _vis;
+  }
+  let draws = opaqueBindings.length;
+  pass.executeBundles(opaqueBundles);
+  pass.setBindGroup(0, task._sceneBG);
+  draws += drawList(pass, task._directBindings, eng);
+  return draws;
+}
+function drawList(enc, list, engine) {
+  let lp = null;
+  let draws = 0;
+  for (const b of list) {
+    const mesh = b.renderable.mesh;
+    if (mesh && mesh.visible === false) {
+      continue;
+    }
+    if (b.pipeline !== lp) {
+      enc.setPipeline(b.pipeline);
+      lp = b.pipeline;
+    }
+    draws += b.draw(enc, engine);
+  }
+  return draws;
+}
+function normalizeCopyCount(cfg) {
+  const count = (cfg == null ? void 0 : cfg.copyCount) ?? 1;
+  return count === Infinity ? 0 : Math.max(0, count | 0);
+}
+function shouldGenerateMipmaps(cfg) {
+  return (cfg == null ? void 0 : cfg.generateMipmaps) !== false;
+}
+const LINEAR_IMAGE_PROCESSING_SLOTS = { NI: `if(scene.vImageInfos.w>=0.0){`, BC: `}` };
+function makeRefractionMod(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, hasDispersion, dispersionSampleWgsl) {
+  const thicknessScaleLine = hasVolume || hasThicknessMap ? `let ts=max(length(mesh.world[0].xyz),max(length(mesh.world[1].xyz),length(mesh.world[2].xyz)));` : ``;
+  const thicknessLine = hasThicknessMap ? `let ths=textureSample(thicknessTexture_,thicknessSampler_,input.uv).${useGltfThicknessChannel ? "g" : "r"};
+let th=(material.thicknessParams.x+ths*material.thicknessParams.y)*ts;` : hasVolume ? `let th=material.refractionParams.z*ts;` : `let th=material.refractionParams.z;`;
+  const textureLine = hasMap ? `let ri=material.refractionParams.x*textureSample(refractionMapTexture,refractionMapSampler,input.uv).r;` : `let ri=material.refractionParams.x;`;
+  const absorptionLine = hasVolume ? `let ab=exp(material.volumeParams.rgb*th);` : ``;
+  const refractionLine = hasVolume ? `let fr=er*surfaceAlbedo*(ri*ab)*(vec3<f32>(1.0)-colorSpecularEnvReflectance.rgb);` : `let fr=er*surfaceAlbedo*ri*(vec3<f32>(1.0)-colorSpecularEnvReflectance.rgb);`;
+  const sampleLines = hasDispersion && dispersionSampleWgsl ? dispersionSampleWgsl : `let rd=refract(-V,N,material.refractionParams.y);
+let cp=scene.viewProjection*vec4<f32>(input.worldPos+rd*th,1.0);
+let ruv=(cp.xy/cp.w)*vec2<f32>(0.5,-0.5)+vec2<f32>(0.5,0.5);
+let er=textureSampleLevel(refractionTexture,refractionSampler_,ruv,lv).rgb*material.environmentIntensity;`;
+  return `{
+${thicknessScaleLine}
+${textureLine}
+${thicknessLine}
+let ro=1.0-ri;
+let ra=mix(alphaG,0.0,clamp(material.refractionParams.w*3.0-2.0,0.0,1.0));
+let lv=clamp(log2(f32(textureDimensions(refractionTexture).x)*ra)-4.0,0.0,f32(textureNumLevels(refractionTexture)-1));
+${sampleLines}
+${absorptionLine}
+${refractionLine}
+color=finalIrradiance*ro*ro+finalRadianceScaled+finalSpecularScaled+directDiffuse*ro*ro+fr+emissive;
+}`;
+}
+function createRefractionRttFragment(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, linearImageProcessing, hasDispersion, dispersionSampleWgsl) {
+  const uboFields = [{ _name: "refractionParams", _type: "vec4<f32>" }];
+  if (hasVolume) {
+    uboFields.push({ _name: "volumeParams", _type: "vec4<f32>" });
+  }
+  if (hasThicknessMap) {
+    uboFields.push({ _name: "thicknessParams", _type: "vec4<f32>" });
+  }
+  const bindings = [
+    { _name: "refractionTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: 2 },
+    { _name: "refractionSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: 2 }
+  ];
+  if (hasMap) {
+    bindings.push(
+      { _name: "refractionMapTexture", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: 2 },
+      { _name: "refractionMapSampler", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: 2 }
+    );
+  }
+  if (hasThicknessMap) {
+    bindings.push(
+      { _name: "thicknessTexture_", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: 2 },
+      { _name: "thicknessSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: 2 }
+    );
+  }
+  return {
+    _id: "refraction",
+    _dependencies: ["ibl"],
+    _uboFields: uboFields,
+    _bindings: bindings,
+    _fragmentSlots: linearImageProcessing ? { AI: makeRefractionMod(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, hasDispersion, dispersionSampleWgsl), ...LINEAR_IMAGE_PROCESSING_SLOTS } : { AI: makeRefractionMod(hasVolume, hasMap, hasThicknessMap, useGltfThicknessChannel, hasDispersion, dispersionSampleWgsl) }
+  };
+}
+function writeRefractionUBO(data, mat, offsets) {
+  var _a, _b;
+  const ss = mat.subsurface;
+  const refr = ss == null ? void 0 : ss.refraction;
+  if (!refr) {
+    return;
+  }
+  const off = offsets.get("refractionParams");
+  if (off === void 0) {
+    return;
+  }
+  const o = off / 4;
+  data[o] = refr.intensity ?? 0;
+  const ior = refr.indexOfRefraction ?? 1.5;
+  const thick = ss.thickness;
+  data[o + 1] = 1 / (refr.useThicknessAsDepth && (thick == null ? void 0 : thick.max) ? ior : 1);
+  data[o + 2] = refr.useThicknessAsDepth ? (thick == null ? void 0 : thick.max) ?? 0 : 1;
+  data[o + 3] = 1 / ior;
+  const vOff = offsets.get("volumeParams");
+  if (vOff !== void 0) {
+    const vo = vOff / 4;
+    const tint = ((_a = ss.tint) == null ? void 0 : _a.color) ?? [1, 1, 1];
+    const dist = Math.max(((_b = ss.tint) == null ? void 0 : _b.atDistance) ?? 1, 1e-4);
+    data[vo] = Math.log(Math.max(tint[0], 1e-6)) / dist;
+    data[vo + 1] = Math.log(Math.max(tint[1], 1e-6)) / dist;
+    data[vo + 2] = Math.log(Math.max(tint[2], 1e-6)) / dist;
+    data[vo + 3] = refr.dispersion ?? 0;
+  }
+  const tOff = offsets.get("thicknessParams");
+  if (tOff !== void 0) {
+    const to = tOff / 4;
+    const min = (thick == null ? void 0 : thick.min) ?? 0;
+    const max = (thick == null ? void 0 : thick.max) ?? 1;
+    data[to] = min;
+    data[to + 1] = max - min;
+  }
+}
+function makeRefractionRttExt(dispersionSampleWgsl) {
+  return {
+    id: "refraction",
+    phase: "fragment",
+    detect(mat) {
+      var _a, _b, _c;
+      const m = mat;
+      const ss = m.subsurface;
+      const refr = ss == null ? void 0 : ss.refraction;
+      const linearImageProcessing = m._linearImageProcessing ? PBR2_LINEAR_IMAGE_PROCESSING : 0;
+      const intensity = m.transmissive ? (refr == null ? void 0 : refr.intensity) ?? 0 : 0;
+      if (intensity <= 0) {
+        return { f: 0, f2: linearImageProcessing };
+      }
+      let f = 0;
+      let f2 = linearImageProcessing | PBR2_HAS_REFRACTION;
+      if (refr == null ? void 0 : refr.texture) {
+        f2 |= PBR2_HAS_REFRACTION_MAP;
+      }
+      if ((_a = ss == null ? void 0 : ss.thickness) == null ? void 0 : _a.texture) {
+        f |= PBR_HAS_THICKNESS_MAP;
+      }
+      if ((_b = ss == null ? void 0 : ss.thickness) == null ? void 0 : _b.useGlTFChannel) {
+        f2 |= PBR2_HAS_THICKNESS_GLTF_CHANNEL;
+      }
+      if (((_c = ss == null ? void 0 : ss.tint) == null ? void 0 : _c.atDistance) !== void 0) {
+        f2 |= PBR2_HAS_VOLUME;
+        if (refr == null ? void 0 : refr.dispersion) {
+          f2 |= PBR2_HAS_DISPERSION;
+        }
+      }
+      return { f, f2 };
+    },
+    frag(ctx) {
+      const linearImageProcessing = (ctx._features2 & PBR2_LINEAR_IMAGE_PROCESSING) !== 0;
+      if (!(ctx._features2 & PBR2_HAS_REFRACTION)) {
+        return linearImageProcessing ? { _id: "linear", _fragmentSlots: LINEAR_IMAGE_PROCESSING_SLOTS } : null;
+      }
+      return createRefractionRttFragment(
+        (ctx._features2 & PBR2_HAS_VOLUME) !== 0,
+        (ctx._features2 & PBR2_HAS_REFRACTION_MAP) !== 0,
+        (ctx._features & PBR_HAS_THICKNESS_MAP) !== 0,
+        (ctx._features2 & PBR2_HAS_THICKNESS_GLTF_CHANNEL) !== 0,
+        linearImageProcessing,
+        (ctx._features2 & PBR2_HAS_DISPERSION) !== 0,
+        dispersionSampleWgsl
+      );
+    },
+    writeUbo(data, mat, offsets) {
+      writeRefractionUBO(data, mat, offsets);
+    },
+    bind(ctx, entries, b) {
+      var _a, _b, _c, _d;
+      if (!(ctx._features2 & PBR2_HAS_REFRACTION)) {
+        return b;
+      }
+      const texture = ctx._refractionTexture;
+      if (!texture) {
+        throw new Error("PBR transmission requires a frame-graph refraction texture.");
+      }
+      entries.push({ binding: b++, resource: texture.view });
+      entries.push({ binding: b++, resource: texture.sampler });
+      if ((ctx._features2 & PBR2_HAS_REFRACTION_MAP) !== 0) {
+        const map = (_b = (_a = ctx._material.subsurface) == null ? void 0 : _a.refraction) == null ? void 0 : _b.texture;
+        entries.push({ binding: b++, resource: map.view });
+        entries.push({ binding: b++, resource: getTrilinearAnisotropicSampler(ctx._engine) });
+      }
+      if ((ctx._features & PBR_HAS_THICKNESS_MAP) !== 0) {
+        const thickness = (_d = (_c = ctx._material.subsurface) == null ? void 0 : _c.thickness) == null ? void 0 : _d.texture;
+        entries.push({ binding: b++, resource: thickness.view });
+        entries.push({ binding: b++, resource: thickness.sampler });
+      }
+      return b;
+    },
+    textures(mat, out) {
+      var _a, _b, _c, _d;
+      const tex = (_b = (_a = mat.subsurface) == null ? void 0 : _a.refraction) == null ? void 0 : _b.texture;
+      if (tex) {
+        out.push(tex);
+      }
+      const thickness = (_d = (_c = mat.subsurface) == null ? void 0 : _c.thickness) == null ? void 0 : _d.texture;
+      if (thickness) {
+        out.push(thickness);
+      }
+    }
+  };
+}
+function registerPbrTransmission(scene, engine, register, dispersionSampleWgsl) {
+  enableSceneTransmission(scene, engine);
+  register(makeRefractionRttExt(dispersionSampleWgsl));
+}
+export {
+  registerPbrTransmission
+};
+//# sourceMappingURL=pbr-transmission-ext-BxW4CEGu.js.map