@babylonjs/lite 0.1.1

package/pbr-renderable-BJxUtPBb.js

@@ -0,0 +1,961 @@
+import { b3 as _getPbrExtsSorted, at as PBR2_HAS_UV2, aL as PBR_HAS_EMISSIVE, b4 as PBR_HAS_SPEC_GLOSS, U as PBR2_ESM_SHADOW_OUTPUT, D as targetSignatureKey, F as getSceneBindGroupLayout, b5 as REVERSE_DEPTH_COMPARE, b6 as PBR_HAS_NORMAL_MAP, b7 as PBR2_NO_COLOR_OUTPUT, V as PBR_HAS_ALPHA_BLEND, b8 as PBR_HAS_DOUBLE_SIDED, b9 as appendMeshLightUboFields, ba as meshLightIndexWGSL, bb as _getPbrExts, bc as PBR2_HAS_UV_TRANSFORM, bd as PBR_HAS_ANISOTROPY, be as PBR_HAS_SKYBOX, bf as PBR_HAS_SPECULAR_AA, bg as PBR_HAS_ENV, bh as PBR_HAS_OCCLUSION, bi as PBR2_HAS_BASE_COLOR_FACTOR, bj as PBR_HAS_GAMMA_ALBEDO, bk as PBR_HAS_TONEMAP, aK as PBR_HAS_EMISSIVE_COLOR, aq as PBR_HAS_METALLIC_REFLECTANCE_MAP, ar as PBR_HAS_REFLECTANCE_MAP, as as PBR2_HAS_REFLECTANCE_FACTORS, a as writeMeshLightSelection, bl as _registerPbrExt, bm as clearSamplerCache, bn as _computePbrMaterialFeatures, aY as createUniformBuffer, bo as PBR2_HAS_REFRACTION, bp as collectPbrBoundTextures, aU as acquireTexture, b1 as releaseTexture } from "./index-C8HOR2sB.js";
+import { c as MSH_HAS_UV2, d as MSH_HAS_TANGENTS, e as composeShader, f as MSH_RECEIVE_SHADOWS, g as MSH_HAS_THIN_INSTANCES, h as MSH_HAS_VERTEX_COLOR, i as MSH_HAS_INSTANCE_COLOR, b as MSH_HAS_MORPH_TARGETS, _ as _computeMeshFeatures } from "./mesh-features-BLENkYVt.js";
+const _bindingsCache = /* @__PURE__ */ new Map();
+let _cachedDevice = null;
+function ensureDevice(engine) {
+  if (_cachedDevice !== engine._device) {
+    _bindingsCache.clear();
+    _cachedDevice = engine._device;
+  }
+}
+function clearPbrPipelineCache() {
+  _bindingsCache.clear();
+  _cachedDevice = null;
+}
+function getOrCreatePbrBindings(engine, features, features2, meshFeatures, sceneFeatures, composed, shaderKey = "") {
+  ensureDevice(engine);
+  const key = `${features}:${features2}:${meshFeatures}:${sceneFeatures}:${shaderKey}`;
+  const cached = _bindingsCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  let shadowBGL = null;
+  if (composed._shadowBGLDescriptor) {
+    shadowBGL = device.createBindGroupLayout(composed._shadowBGLDescriptor);
+  }
+  const bindings = {
+    _features: features,
+    _features2: features2,
+    _meshFeatures: meshFeatures,
+    _meshBGL: meshBGL,
+    _shadowBGL: shadowBGL,
+    _composed: composed,
+    _pipelines: /* @__PURE__ */ new Map()
+  };
+  _bindingsCache.set(key, bindings);
+  return bindings;
+}
+function getOrCreatePbrPipeline(engine, sig, bindings) {
+  ensureDevice(engine);
+  const key = targetSignatureKey(sig);
+  const cached = bindings._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const { _features: features, _features2: features2, _composed: composed } = bindings;
+  const esmShadowOutput = (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0;
+  const hasAlpha = !esmShadowOutput && (features & PBR_HAS_ALPHA_BLEND) !== 0;
+  const hasDoubleSided = (features & PBR_HAS_DOUBLE_SIDED) !== 0;
+  const sceneBGL = getSceneBindGroupLayout(engine);
+  const bgls = bindings._shadowBGL ? [sceneBGL, bindings._meshBGL, bindings._shadowBGL] : [sceneBGL, bindings._meshBGL];
+  const vertModule = device.createShaderModule({ code: composed._vertexWGSL });
+  const noColorOutput = (features2 & PBR2_NO_COLOR_OUTPUT) !== 0;
+  const fragModule = !sig._colorFormat && !noColorOutput ? null : device.createShaderModule({ code: composed._fragmentWGSL });
+  const fragTarget = noColorOutput ? null : { format: sig._colorFormat, writeMask: GPUColorWrite.ALL };
+  if (hasAlpha && fragTarget) {
+    fragTarget.blend = {
+      color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+      alpha: { srcFactor: "one", dstFactor: "one", operation: "add" }
+    };
+  }
+  const pipeline = device.createRenderPipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: bgls }),
+    vertex: { module: vertModule, entryPoint: "main", buffers: composed._vertexBufferLayouts },
+    ...fragModule ? { fragment: { module: fragModule, entryPoint: "main", targets: fragTarget ? [fragTarget] : [] } } : {},
+    ...sig._depthStencilFormat ? {
+      depthStencil: {
+        format: sig._depthStencilFormat,
+        depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,
+        depthWriteEnabled: noColorOutput || esmShadowOutput || !hasAlpha
+      }
+    } : {},
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode: hasDoubleSided ? "none" : "back", frontFace: sig._flipY ? "cw" : "ccw" }
+  });
+  bindings._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function createPbrMeshBindGroup(engine, bindings, composed, meshUBO, materialUBO, material, env, meshCtx, refractionTexture) {
+  const device = engine._device;
+  const features = bindings._features;
+  const features2 = bindings._features2;
+  const meshFeatures = bindings._meshFeatures;
+  const hasNormal = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) !== 0;
+  const hasCotangentNormal = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) === 0;
+  const hasAnyNormal = hasNormal || hasCotangentNormal;
+  const hasEmissive = (features & PBR_HAS_EMISSIVE) !== 0;
+  const hasSpecGloss = (features & PBR_HAS_SPEC_GLOSS) !== 0;
+  const esmShadowOutput = (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0;
+  const entries = [];
+  let b = 0;
+  const addTex = (t) => {
+    entries.push({ binding: b++, resource: t.view });
+    entries.push({ binding: b++, resource: t.sampler });
+  };
+  const ctx = {
+    _engine: engine,
+    _features: features,
+    _features2: features2,
+    _meshFeatures: meshFeatures,
+    _material: material,
+    _mesh: meshCtx ?? void 0,
+    _env: env,
+    _refractionTexture: refractionTexture
+  };
+  const sortedExts = _getPbrExtsSorted();
+  const fragIds = composed._fragmentKey ? composed._fragmentKey.split("|").filter((s) => s.length > 0) : [];
+  entries.push({ binding: b++, resource: { buffer: meshUBO } });
+  entries.push({ binding: b++, resource: { buffer: materialUBO } });
+  for (const ext of sortedExts) {
+    if (ext.phase === "vertex" && ext.bind) {
+      b = ext.bind(ctx, entries, b);
+    }
+  }
+  addTex(material.baseColorTexture);
+  if (hasAnyNormal) {
+    addTex(material.normalTexture);
+  }
+  addTex(material.ormTexture);
+  if ((features2 & PBR2_HAS_UV2) !== 0 && (meshFeatures & MSH_HAS_UV2) !== 0 && material.occlusionTexture) {
+    addTex(material.occlusionTexture);
+  }
+  if (hasEmissive) {
+    addTex(material.emissiveTexture);
+  }
+  if (hasSpecGloss) {
+    addTex(material.specGlossTexture);
+  }
+  if (esmShadowOutput) {
+    entries.push({
+      binding: b++,
+      resource: { buffer: material._esmShadowParamsUBO }
+    });
+  }
+  const seenExts = [];
+  for (const fid of fragIds) {
+    const ext = sortedExts.find((e) => e.id === fid || fid.startsWith(e.id + "-"));
+    if (!ext || ext.phase === "vertex" || !ext.bind || seenExts.includes(ext)) {
+      continue;
+    }
+    seenExts.push(ext);
+    b = ext.bind(ctx, entries, b);
+  }
+  return device.createBindGroup({ layout: bindings._meshBGL, entries });
+}
+const STAGE_FRAGMENT = 2;
+const BRDF_FUNCTIONS = `
+const PI:f32=3.14159265358979323846;
+fn distributionGGX(NdotH:f32,alphaG:f32)->f32{
+let a2=alphaG*alphaG;
+let d=NdotH*NdotH*(a2-1.0)+1.0;
+return a2/(PI*d*d);
+}
+fn geometrySmithGGX(NdotL:f32,NdotV:f32,alphaG:f32)->f32{
+let a2=alphaG*alphaG;
+let gl=NdotL*sqrt(NdotV*(NdotV-a2*NdotV)+a2);
+let gv=NdotV*sqrt(NdotL*(NdotL-a2*NdotL)+a2);
+return 0.5/(gl+gv);
+}
+fn fresnelSchlick(cosTheta:f32,F0:vec3<f32>,F90:vec3<f32>)->vec3<f32>{
+let t=1.0-cosTheta;
+let t2=t*t;
+return F0+(F90-F0)*(t2*t2*t);
+}
+`;
+function createPbrTemplate(config) {
+  var _a, _b, _c, _d;
+  const {
+    _hasSingleLight = false,
+    _hasMultiLight = false,
+    _singleLightWGSL = "",
+    _singleLightBlock = "",
+    _multiLightWGSL = "",
+    _multiLightLoop = "",
+    _normalMode = "none",
+    _hasEmissiveTexture = false,
+    _hasSpecGloss = false,
+    _hasDoubleSided = false,
+    _hasTonemap = false,
+    _acesHelpers = "",
+    _acesTonemapCall = "",
+    _hasAlphaBlend = false,
+    _hasSpecularAA = false,
+    _hasGammaAlbedo = false,
+    _hasBaseColorFactor = false,
+    _hasMorph = false,
+    _hasOcclusion = false,
+    _hasEmissiveColor = false,
+    _hasReflectanceExt = false,
+    _hasIbl = false,
+    _hasAnisotropy = false,
+    _anisoBrdfFunctions = "",
+    _anisoTBBlock = "",
+    _ext,
+    _noColorOutput = false,
+    _esmShadowOutput = false,
+    _esmShadowDepthCode = "",
+    _vbStrides
+  } = config;
+  const hasNormal = _normalMode === "tangent";
+  const hasCotangentNormal = _normalMode === "cotangent";
+  const hasAnyNormal = hasNormal || hasCotangentNormal;
+  const _baseVertexAttributes = [
+    { _name: "position", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: ((_a = _vbStrides == null ? void 0 : _vbStrides._p) == null ? void 0 : _a._stride) ?? 12 },
+    { _name: "normal", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: ((_b = _vbStrides == null ? void 0 : _vbStrides._n) == null ? void 0 : _b._stride) ?? 12 }
+  ];
+  if (hasNormal) {
+    _baseVertexAttributes.push({ _name: "tangent", _type: "vec4<f32>", _gpuFormat: "float32x4", _arrayStride: ((_c = _vbStrides == null ? void 0 : _vbStrides._t) == null ? void 0 : _c._stride) ?? 16 });
+  }
+  _baseVertexAttributes.push({ _name: "uv", _type: "vec2<f32>", _gpuFormat: "float32x2", _arrayStride: ((_d = _vbStrides == null ? void 0 : _vbStrides._u) == null ? void 0 : _d._stride) ?? 8 });
+  if (_ext) {
+    _baseVertexAttributes.push(..._ext.extraVertexAttributes);
+  }
+  const _baseVaryings = [
+    { _name: "worldPos", _type: "vec3<f32>" },
+    { _name: "worldNormal", _type: "vec3<f32>" }
+  ];
+  if (hasNormal) {
+    _baseVaryings.push({ _name: "worldTangent", _type: "vec3<f32>" }, { _name: "worldBitangent", _type: "vec3<f32>" });
+  }
+  _baseVaryings.push({ _name: "uv", _type: "vec2<f32>" });
+  if (_ext) {
+    _baseVaryings.push(..._ext.extraVaryings);
+  }
+  const _baseMeshUboFields = [{ _name: "world", _type: "mat4x4<f32>" }];
+  appendMeshLightUboFields(_baseMeshUboFields);
+  const _baseMaterialUboFields = [
+    { _name: "environmentIntensity", _type: "f32" },
+    { _name: "directIntensity", _type: "f32" },
+    { _name: "reflectance", _type: "f32" },
+    { _name: "materialAlpha", _type: "f32" },
+    ..._hasBaseColorFactor ? [{ _name: "baseColorFactor", _type: "vec4<f32>" }] : [],
+    // glTF metallicFactor / roughnessFactor (default 1.0) — applied over MR texture channels.
+    { _name: "metallicFactor", _type: "f32" },
+    { _name: "roughnessFactor", _type: "f32" },
+    { _name: "normalScale", _type: "f32" },
+    { _name: "lightFalloffMode", _type: "f32" },
+    // Anisotropy UBO field stays on the base template because anisotropy is
+    // template-only (no ShaderFragment) — the anisotropyExt just writes its
+    // slice through the unified ext.writeUbo hook.
+    ..._hasAnisotropy ? [{ _name: "anisotropyParams", _type: "vec4<f32>" }] : [],
+    // ── Extension fields (per-texture UV transforms, etc.) ─
+    ..._ext ? _ext.extraMaterialUboFields : []
+  ];
+  const tex2d = (name, sampler) => [
+    { _name: name, _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+    { _name: sampler, _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+  ];
+  const _baseBindings = tex2d("baseColorTexture", "baseColorSampler");
+  if (hasAnyNormal) {
+    _baseBindings.push(...tex2d("normalTexture", "normalSampler_"));
+  }
+  _baseBindings.push(...tex2d("ormTexture", "ormSampler"));
+  if (_ext) {
+    _baseBindings.push(..._ext.extraBindings);
+  }
+  if (_hasEmissiveTexture) {
+    _baseBindings.push(...tex2d("emissiveTexture", "emissiveSampler"));
+  }
+  if (_hasSpecGloss) {
+    _baseBindings.push(...tex2d("specGlossTexture", "specGlossSampler"));
+  }
+  if (_esmShadowOutput) {
+    _baseBindings.push({ _name: "shadowParams", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT });
+  }
+  const posVar = _hasMorph ? "morphedPos" : "position";
+  const normVar = _hasMorph ? "morphedNorm" : "normal";
+  const tangentBlock = hasNormal ? `let N_local=normalize(${normVar});
+let T_local=normalize(tangent.xyz);
+let B_local=cross(N_local,T_local)*tangent.w;
+out.worldTangent=(finalWorld*vec4<f32>(T_local,0.0)).xyz;
+out.worldBitangent=(finalWorld*vec4<f32>(B_local,0.0)).xyz;` : "";
+  const _vertexTemplate = `/*SU*/
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+/*VH*/
+/*VD*/
+/*VO*/
+@vertex fn main(
+/*VP*/
+) -> VertexOutput {
+var out: VertexOutput;
+/*VR*/
+var finalWorld = mesh.world;
+/*VW*/
+let worldPos4 = finalWorld * vec4<f32>(${posVar}, 1.0);
+out.worldPos = worldPos4.xyz;
+out.clipPos = scene.viewProjection * worldPos4;
+out.worldNormal = (finalWorld * vec4<f32>(normalize(${normVar}), 0.0)).xyz;
+${tangentBlock}
+out.uv = uv;
+    ${_ext ? _ext.vertexBodyExtra : ""}/*VB*/
+return out;
+}`;
+  const normalUV = (_ext == null ? void 0 : _ext.uvForNormal) ?? "input.uv";
+  const normalScaleMod = (_ext == null ? void 0 : _ext.normalScaleMod) ?? "";
+  const normalRef = (_ext == null ? void 0 : _ext.normalScaleMod) ? "scaledNormal" : "normalMapRaw";
+  const normalRefCt = (_ext == null ? void 0 : _ext.normalScaleMod) ? "scaledNormalCT" : "normalMapSample";
+  let normalBlock;
+  if (hasNormal) {
+    normalBlock = `let normalMapRaw=textureSample(normalTexture,normalSampler_,${normalUV}).rgb*2.0-1.0;
+${normalScaleMod}let normalMapNorm=normalize(${normalRef});
+let N_geom=normalize(input.worldNormal);
+let TBN=mat3x3<f32>(input.worldTangent,input.worldBitangent,input.worldNormal);
+var N=normalize(TBN*normalMapNorm);`;
+  } else if (hasCotangentNormal) {
+    normalBlock = `let normalMapSample=textureSample(normalTexture,normalSampler_,${normalUV}).rgb*2.0-1.0;
+${normalScaleMod.replace(/normalMapRaw/g, "normalMapSample").replace(/scaledNormal/g, "scaledNormalCT")}let N_geom=normalize(input.worldNormal);
+let dp1=dpdx(input.worldPos);
+let dp2=dpdy(input.worldPos);
+let duv1=dpdx(${normalUV});
+let duv2=dpdy(${normalUV});
+let dp2perp=cross(dp2,N_geom);
+let dp1perp=cross(N_geom,dp1);
+let tangent_ct=dp2perp*duv1.x+dp1perp*duv2.x;
+let bitangent_ct=-(dp2perp*duv1.y+dp1perp*duv2.y);
+let det=max(dot(tangent_ct,tangent_ct),dot(bitangent_ct,bitangent_ct));
+let invmax=select(inverseSqrt(det),0.0,det==0.0);
+let cotangentFrame=mat3x3<f32>(tangent_ct*invmax,bitangent_ct*invmax,N_geom);
+var N=normalize(cotangentFrame*normalize(${normalRefCt}));`;
+  } else {
+    normalBlock = `let N_geom=normalize(input.worldNormal);
+var N=N_geom;`;
+  }
+  const anisotropyTBBlock = _hasAnisotropy ? _anisoTBBlock : "";
+  const vertexColorMod = (_ext == null ? void 0 : _ext.baseColorMod) ?? "";
+  const baseColorFactorRgb = _hasBaseColorFactor ? "*material.baseColorFactor.rgb" : "";
+  const baseColorFactorAlpha = _hasBaseColorFactor ? "*material.baseColorFactor.a" : "";
+  const baseColorDecode = _hasGammaAlbedo ? `var baseColor=pow(baseColorSample.rgb,vec3<f32>(2.2))${baseColorFactorRgb};
+var alpha=baseColorSample.a${baseColorFactorAlpha};${vertexColorMod}` : `var baseColor=baseColorSample.rgb${baseColorFactorRgb};
+var alpha=baseColorSample.a${baseColorFactorAlpha};${vertexColorMod}`;
+  const specGlossUV = (_ext == null ? void 0 : _ext.uvForSpecGloss) ?? "input.uv";
+  const roughnessMetallic = _hasSpecGloss ? `let specGloss=textureSample(specGlossTexture,specGlossSampler,${specGlossUV});
+let roughness=clamp(1.0-specGloss.a,0.0,1.0);
+let metallic=0.0;` : `let roughness=clamp(orm.g*material.roughnessFactor,0.0,1.0);
+let metallic=orm.b*material.metallicFactor;`;
+  const emissiveUV = (_ext == null ? void 0 : _ext.uvForEmissive) ?? "input.uv";
+  const emissiveDefault = _hasEmissiveColor ? `` : _hasEmissiveTexture ? `let emissive=textureSample(emissiveTexture,emissiveSampler,${emissiveUV}).rgb;` : `let emissive=vec3<f32>(0.0);`;
+  const occlusionDefault = _hasReflectanceExt ? `` : (_ext == null ? void 0 : _ext.occlusionOverride) ? _ext.occlusionOverride : _hasOcclusion ? `let occlusion=orm.r;` : `let occlusion=1.0;`;
+  const f0Default = _hasReflectanceExt ? `` : _hasSpecGloss ? `var colorF0=specGloss.rgb;
+let colorF90=vec3<f32>(1.0);
+let maxSpecular=max(colorF0.r,max(colorF0.g,colorF0.b));
+let surfaceAlbedo=baseColor*(1.0-maxSpecular);` : `let dielectricF0=material.reflectance;
+var colorF0=mix(vec3<f32>(dielectricF0),baseColor,metallic);
+let colorF90=vec3<f32>(1.0);
+let surfaceAlbedo=baseColor*(1.0-dielectricF0)*(1.0-metallic);`;
+  const specularAABlock = _hasSpecularAA || hasAnyNormal ? `var AA_factor_x=0.0;
+var AA_factor_y=0.0;
+{let nDfdx_AA=dpdx(N);
+let nDfdy_AA=dpdy(N);
+let slopeSquare_AA=max(dot(nDfdx_AA,nDfdx_AA),dot(nDfdy_AA,nDfdy_AA));
+AA_factor_x=pow(saturate(slopeSquare_AA),0.333);
+AA_factor_y=sqrt(slopeSquare_AA)*0.75;
+alphaG+=AA_factor_y;}` : `var AA_factor_x=0.0;
+var AA_factor_y=0.0;`;
+  const directLightBlock = _hasMultiLight ? _multiLightLoop : _hasSingleLight ? _singleLightBlock : `var directDiffuse=vec3<f32>(0.0);
+var directSpecular=vec3<f32>(0.0);
+/*BL*/`;
+  const useAces = _hasTonemap && _acesTonemapCall !== "";
+  const acesBlock = useAces ? _acesHelpers : "";
+  const tonemapBlock = _hasTonemap ? useAces ? _acesTonemapCall : `color*=scene.vImageInfos.x;
+color=1.0-exp2(-1.590579*color);` : `color*=scene.vImageInfos.x;`;
+  const alphaBlock = _noColorOutput ? "" : _hasAlphaBlend ? `var finalAlpha=alpha*material.materialAlpha;
+var luminanceOverAlpha=0.0;
+/*BA*/
+luminanceOverAlpha+=dot(${_hasIbl ? "finalSpecularScaled" : "directSpecular"},vec3<f32>(0.2126,0.7152,0.0722));
+finalAlpha=saturate(finalAlpha+luminanceOverAlpha*luminanceOverAlpha);
+return vec4<f32>(color,finalAlpha);` : `return vec4<f32>(color,alpha*material.materialAlpha);`;
+  const doubleSidedEntry = _hasDoubleSided ? `@fragment fn main(input: FragmentInput, @builtin(front_facing) frontFacing: bool)${_noColorOutput ? "" : " -> @location(0) vec4<f32>"} {` : `@fragment fn main(input: FragmentInput)${_noColorOutput ? "" : " -> @location(0) vec4<f32>"} {`;
+  const doubleSidedFlip = _hasDoubleSided ? `if (!frontFacing) { N = -N; }` : "";
+  const lightDecls = _hasMultiLight ? _multiLightWGSL : _hasSingleLight ? _singleLightWGSL : "";
+  const lightBindingDecl = _hasSingleLight || _hasMultiLight ? `@group(0) @binding(1) var<uniform> lights: lightsUniforms;` : "";
+  const meshLightIndexHelper = _hasSingleLight || _hasMultiLight ? meshLightIndexWGSL("mesh") : "";
+  const anisoBrdfBlock = _hasAnisotropy ? _anisoBrdfFunctions : "";
+  const fragmentHelpers = (_ext == null ? void 0 : _ext.fragmentHelpers) ?? "";
+  const fragmentPrelude = (_ext == null ? void 0 : _ext.fragmentPrelude) ?? "";
+  const baseColorUV = (_ext == null ? void 0 : _ext.uvForBaseColor) ?? "input.uv";
+  const ormUV = (_ext == null ? void 0 : _ext.uvForOrm) ?? "input.uv";
+  const _fragmentTemplate = `/*SU*/
+${_esmShadowOutput ? "struct shadowParamsUniforms { biasAndScale: vec4<f32>, depthValues: vec4<f32>, }" : ""}
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+/*HF*/
+/*FB*/
+/*FI*/
+${BRDF_FUNCTIONS}
+${acesBlock}
+${anisoBrdfBlock}
+${lightDecls}
+${lightBindingDecl}
+${meshLightIndexHelper}
+${fragmentHelpers}
+${doubleSidedEntry}
+${fragmentPrelude}/*SV*/
+let baseColorSample=textureSample(baseColorTexture,baseColorSampler,${baseColorUV});
+${baseColorDecode}
+let orm=textureSample(ormTexture,ormSampler,${ormUV}).rgb;
+${occlusionDefault}
+${roughnessMetallic}
+${emissiveDefault}
+/*AT*/
+${_noColorOutput ? "return;" : _esmShadowOutput ? _esmShadowDepthCode : ""}
+${normalBlock}
+${doubleSidedFlip}
+${anisotropyTBBlock}
+/*AC*/
+let V=normalize(scene.vEyePosition.xyz-input.worldPos);
+let NdotVUnclamped=dot(N,V);
+let NdotV=abs(NdotVUnclamped)+0.0000001;
+${f0Default}
+/*MF*/
+var alphaG=roughness*roughness+0.0005;
+${specularAABlock}
+${directLightBlock}
+var color=directDiffuse+directSpecular+emissive;
+/*AI*/
+/*NI*/
+${tonemapBlock}
+color=pow(color,vec3<f32>(1.0/2.2));
+color=clamp(color,vec3<f32>(0.0),vec3<f32>(1.0));
+let highContrast=color*color*(3.0-2.0*color);
+if(scene.vImageInfos.y<1.0){color=mix(vec3<f32>(0.5),color,scene.vImageInfos.y);}
+else{color=mix(color,highContrast,scene.vImageInfos.y-1.0);}
+color=max(color,vec3<f32>(0.0));
+/*BC*/
+${alphaBlock}
+}`;
+  return {
+    _vertexTemplate,
+    _fragmentTemplate,
+    _baseMeshUboFields,
+    _baseMaterialUboFields,
+    _baseVertexAttributes,
+    _baseVaryings,
+    _baseBindings
+  };
+}
+function createPbrComposer(deps) {
+  const cache = /* @__PURE__ */ new Map();
+  const {
+    _singleLightWGSL,
+    _getSingleLightBlock,
+    _multiLightWGSL,
+    _multiLightLoop,
+    _acesHelpers,
+    _acesTonemapCall,
+    _createPbrTemplateExt,
+    _anisoExt,
+    _iblSkyboxCalc,
+    _createPbrShadowFragment,
+    _shadowLights,
+    _createThinInstanceFragment
+  } = deps;
+  return function composePbr(features, features2 = 0, meshFeatures = 0, sceneFeatures = 0, lightMode = 0, singleLightType = "", _esmShadowDepthCode = "", vbStrides, vbKey = "") {
+    const ckey = `${features}:${features2}:${meshFeatures}:${sceneFeatures}:${lightMode}:${singleLightType}${vbKey}`;
+    const cached = cache.get(ckey);
+    if (cached) {
+      return cached;
+    }
+    const has = (bit) => (features & bit) !== 0;
+    const hasMesh = (bit) => (meshFeatures & bit) !== 0;
+    const hasScene = (bit) => (sceneFeatures & bit) !== 0;
+    const hasNormal = has(PBR_HAS_NORMAL_MAP) && hasMesh(MSH_HAS_TANGENTS);
+    const hasCotangent = has(PBR_HAS_NORMAL_MAP) && !hasMesh(MSH_HAS_TANGENTS);
+    const _hasAnyNormal = hasNormal || hasCotangent;
+    const _hasReflectanceExt = has(PBR_HAS_METALLIC_REFLECTANCE_MAP | PBR_HAS_REFLECTANCE_MAP) || (features2 & PBR2_HAS_REFLECTANCE_FACTORS) !== 0;
+    const _hasIbl = hasScene(PBR_HAS_ENV);
+    const _hasMorph = hasMesh(MSH_HAS_MORPH_TARGETS);
+    const hasShadow = hasMesh(MSH_RECEIVE_SHADOWS);
+    const _hasAnisotropy = has(PBR_HAS_ANISOTROPY);
+    const _hasEmissiveColor = has(PBR_HAS_EMISSIVE_COLOR);
+    const _hasEmissiveTexture = has(PBR_HAS_EMISSIVE);
+    const hasTI = hasMesh(MSH_HAS_THIN_INSTANCES);
+    const _hasUvTransform = (features2 & PBR2_HAS_UV_TRANSFORM) !== 0;
+    const _hasVertexColor = hasMesh(MSH_HAS_VERTEX_COLOR);
+    const _hasUv2 = (features2 & PBR2_HAS_UV2) !== 0 && hasMesh(MSH_HAS_UV2);
+    const needsExt = _hasUvTransform || _hasVertexColor || _hasUv2;
+    const _hasSpecularAA = has(PBR_HAS_SPECULAR_AA);
+    const _ext = needsExt && _createPbrTemplateExt ? _createPbrTemplateExt({
+      _hasUvTransform,
+      _hasVertexColor,
+      _hasUv2,
+      _hasOcclusionUv2: _hasUv2,
+      _hasAnyNormal,
+      _hasEmissiveTexture,
+      _hasSpecGloss: has(PBR_HAS_SPEC_GLOSS)
+    }) : void 0;
+    const template = createPbrTemplate({
+      _hasSingleLight: lightMode === 1,
+      _hasMultiLight: lightMode === 2,
+      _singleLightWGSL,
+      _singleLightBlock: lightMode === 1 && _getSingleLightBlock ? _getSingleLightBlock(singleLightType) : "",
+      _multiLightWGSL,
+      _multiLightLoop,
+      _normalMode: hasNormal ? "tangent" : hasCotangent ? "cotangent" : "none",
+      _hasEmissiveTexture,
+      _hasSpecGloss: has(PBR_HAS_SPEC_GLOSS),
+      _hasDoubleSided: has(PBR_HAS_DOUBLE_SIDED),
+      _hasTonemap: hasScene(PBR_HAS_TONEMAP),
+      _acesHelpers,
+      _acesTonemapCall,
+      _hasAlphaBlend: has(PBR_HAS_ALPHA_BLEND),
+      _hasSpecularAA,
+      _hasGammaAlbedo: has(PBR_HAS_GAMMA_ALBEDO),
+      _hasBaseColorFactor: (features2 & PBR2_HAS_BASE_COLOR_FACTOR) !== 0,
+      _hasMorph,
+      _hasOcclusion: has(PBR_HAS_OCCLUSION) && !_hasReflectanceExt,
+      _hasEmissiveColor,
+      _hasReflectanceExt,
+      _hasIbl,
+      _hasAnisotropy,
+      _anisoBrdfFunctions: _hasAnisotropy && _anisoExt ? _anisoExt.ANISO_BRDF_FUNCTIONS : "",
+      _anisoTBBlock: _hasAnisotropy && _anisoExt ? _anisoExt.makeAnisotropyTBBlock(hasNormal) : "",
+      _ext,
+      _noColorOutput: (features2 & PBR2_NO_COLOR_OUTPUT) !== 0,
+      _esmShadowOutput: (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0,
+      _esmShadowDepthCode,
+      _vbStrides: vbStrides
+    });
+    const frags = [];
+    const fragCtx = {
+      _features: features,
+      _features2: features2,
+      _meshFeatures: meshFeatures,
+      _hasIbl,
+      _hasAnyNormal,
+      _hasSpecularAA,
+      _anisoBentNormalCode: _hasAnisotropy && _anisoExt ? _anisoExt.ANISO_BENT_NORMAL : "",
+      _iblSkyboxCalc: has(PBR_HAS_SKYBOX) ? _iblSkyboxCalc : ""
+    };
+    for (const regExt of _getPbrExts().values()) {
+      if (regExt.frag) {
+        const fr = regExt.frag(fragCtx);
+        if (fr) {
+          frags.push(fr);
+        }
+      }
+    }
+    if (hasShadow && _createPbrShadowFragment) {
+      const slots = _shadowLights.map((sl) => ({ lightIndex: sl.lightIndex, shadowType: sl.shadowType }));
+      frags.push(_createPbrShadowFragment(slots));
+    }
+    if (hasTI && _createThinInstanceFragment) {
+      frags.push(_createThinInstanceFragment(hasMesh(MSH_HAS_INSTANCE_COLOR)));
+    }
+    const composed = composeShader(template, frags);
+    cache.set(ckey, composed);
+    return composed;
+  };
+}
+async function buildPbrRenderables(scene, meshes, envTextures) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const engine = scene.engine;
+  const device = engine._device;
+  const materialScratch = /* @__PURE__ */ new Map();
+  const hasEnv = !!envTextures;
+  const shadowLights = [];
+  for (let i = 0; i < scene.lights.length; i++) {
+    const sg = scene.lights[i].shadowGenerator;
+    if (sg) {
+      shadowLights.push({ lightIndex: i, shadowType: sg._shadowType, gen: sg });
+    }
+  }
+  const hasSomeShadows = shadowLights.length > 0;
+  let hasAnyAffectedLight = false;
+  let needsSingleLightPath = false;
+  let needsMultiLightPath = false;
+  const singleLightTypes = [];
+  for (const mesh of meshes) {
+    const lr = writeMeshLightSelection(mesh, scene.lights);
+    const affectedCount = lr > 0 ? 1 : -lr;
+    hasAnyAffectedLight || (hasAnyAffectedLight = affectedCount > 0);
+    if (affectedCount === 1 && !(mesh.receiveShadows && hasSomeShadows)) {
+      needsSingleLightPath = true;
+      const type = getPackedSingleLightType(scene.lights, lr - 1);
+      if (!singleLightTypes.includes(type)) {
+        singleLightTypes.push(type);
+      }
+    } else if (affectedCount > 0) {
+      needsMultiLightPath = true;
+    }
+  }
+  let hasSkybox = false;
+  let hasMetallicReflectance = false;
+  let hasClearcoat = false;
+  let hasSheen = false;
+  let hasIridescence = false;
+  let hasAnyAnisotropy = false;
+  let hasAnySubsurface = false;
+  let hasAlphaTest = false;
+  let hasTransmissionRefraction = false;
+  let needsEmissiveColor = false;
+  let hasSomeSkeletons = false;
+  let hasSomeMorphs = false;
+  let hasSomeThinInstances = false;
+  let hasAnyUnlit = false;
+  let hasAnyUvTransform = false;
+  let hasAnyUv2 = false;
+  let hasAnyVertexColor = false;
+  for (let i = 0; i < meshes.length; i++) {
+    const m = meshes[i];
+    const mat = m.material;
+    const refractionIntensity = ((_b = (_a = mat.subsurface) == null ? void 0 : _a.refraction) == null ? void 0 : _b.intensity) ?? 0;
+    hasSkybox || (hasSkybox = !!mat.skyboxMode);
+    hasMetallicReflectance || (hasMetallicReflectance = !!(mat.metallicReflectanceTexture || mat.reflectanceTexture || mat._hasReflExt));
+    hasClearcoat || (hasClearcoat = !!((_c = mat.clearCoat) == null ? void 0 : _c.isEnabled));
+    hasSheen || (hasSheen = !!((_d = mat.sheen) == null ? void 0 : _d.isEnabled));
+    hasIridescence || (hasIridescence = !!((_e = mat.iridescence) == null ? void 0 : _e.isEnabled));
+    hasAnyAnisotropy || (hasAnyAnisotropy = !!((_f = mat.anisotropy) == null ? void 0 : _f.isEnabled));
+    hasAnySubsurface || (hasAnySubsurface = !!((_g = mat.subsurface) == null ? void 0 : _g.translucency));
+    hasAlphaTest || (hasAlphaTest = mat.alphaCutOff > 0);
+    hasTransmissionRefraction || (hasTransmissionRefraction = refractionIntensity > 0 && !!mat.transmissive);
+    needsEmissiveColor || (needsEmissiveColor = !!mat.emissiveColor);
+    hasSomeSkeletons || (hasSomeSkeletons = !!m.skeleton);
+    hasSomeMorphs || (hasSomeMorphs = !!m.morphTargets);
+    hasSomeThinInstances || (hasSomeThinInstances = !!m.thinInstances);
+    hasAnyUnlit || (hasAnyUnlit = !!mat.unlit);
+    hasAnyUvTransform || (hasAnyUvTransform = !!mat._hasUvTx);
+    hasAnyUv2 || (hasAnyUv2 = !!m._gpu.uv2Buffer && mat.occlusionTexCoord === 1);
+    hasAnyVertexColor || (hasAnyVertexColor = !!m._gpu.colorBuffer);
+  }
+  let _iblSkyboxCalc = "";
+  if (hasEnv) {
+    const mod = await import("./ibl-fragment-DqQVi8k0.js");
+    _registerPbrExt(mod.pbrExt);
+    if (hasSkybox) {
+      const sky = await import("./ibl-skybox-wgsl-DCah0kWV.js");
+      _iblSkyboxCalc = sky.IBL_SKYBOX_CALCULATION;
+    }
+  }
+  let _createPbrShadowFragment = null;
+  let _singleLightWGSL = "";
+  let _getSingleLightBlock = null;
+  const singleLightBlocks = {};
+  let _multiLightWGSL = "";
+  let _multiLightLoop = "";
+  if (needsSingleLightPath) {
+    for (const type of singleLightTypes) {
+      const single = await importSingleLightWgsl(type);
+      _singleLightWGSL = single.SINGLE_LIGHT_STRUCTS;
+      singleLightBlocks[type] = single.getSingleLightBlock;
+    }
+    _getSingleLightBlock = (type) => {
+      var _a2;
+      return ((_a2 = singleLightBlocks[toSingleLightType(type)]) == null ? void 0 : _a2.call(singleLightBlocks)) ?? "";
+    };
+  }
+  if (needsMultiLightPath) {
+    const wgslMod = await import("./multilight-wgsl-BGyiIOp3.js");
+    _multiLightWGSL = wgslMod.MULTI_LIGHT_STRUCTS() + wgslMod.COMPUTE_PBR_LIGHT;
+    _multiLightLoop = wgslMod.getMultiLightLoop();
+  }
+  if (hasAnyAffectedLight && hasSomeShadows) {
+    const shadowMod = await import("./pbr-shadow-fragment-LO9SlbJj.js");
+    _createPbrShadowFragment = shadowMod.createPbrShadowFragment;
+  }
+  const _drainPbrExts = async (loaders) => {
+    for (const [flag, load] of loaders) {
+      if (flag) {
+        _registerPbrExt((await load()).pbrExt);
+      }
+    }
+  };
+  await _drainPbrExts([
+    [hasAlphaTest, () => import("./alpha-test-fragment-CUiHCw7W.js")],
+    [hasMetallicReflectance, () => import("./reflectance-fragment-BCrgPmrt.js")],
+    [hasClearcoat, () => import("./clearcoat-fragment-LCiG98Rf.js")],
+    [hasSheen, () => import("./sheen-fragment-Dze2f7XJ.js")],
+    [hasIridescence, () => import("./iridescence-fragment-Gymp7or5.js")],
+    [hasAnySubsurface, () => import("./subsurface-fragment-liM3y2-P.js")]
+  ]);
+  if (hasTransmissionRefraction) {
+    const mod = await import("./pbr-refraction-DGmMSa2v.js");
+    await mod.registerPbrRefraction(scene, engine, _registerPbrExt);
+  }
+  await _drainPbrExts([
+    [needsEmissiveColor, () => import("./emissive-fragment-BnNvbBCw.js")],
+    [hasAnyUnlit, () => import("./unlit-fragment-BIlhJpz6.js")],
+    [hasSomeSkeletons, () => import("./skeleton-fragment-B_XlFbtx.js")],
+    [hasSomeMorphs, () => import("./morph-fragment-DOVo70gP.js")],
+    [hasAnyUvTransform, () => import("./uv-transform-fragment-hYujGpZg.js")]
+  ]);
+  let _anisoExt = null;
+  if (hasAnyAnisotropy) {
+    _anisoExt = await import("./anisotropy-fragment-HgasXS7l.js");
+    _registerPbrExt(_anisoExt.pbrExt);
+  }
+  let _createPbrTemplateExt = null;
+  if (hasAnyUvTransform || hasAnyVertexColor || hasAnyUv2) {
+    const extMod = await import("./pbr-template-ext-8q7BcTDf.js");
+    _createPbrTemplateExt = extMod.createPbrTemplateExt;
+  }
+  let _createThinInstanceFragment = null;
+  let _syncThinInstanceBuffers = null;
+  if (hasSomeThinInstances) {
+    const mod = await import("./thin-instance-fragment-hsv-RyDs.js");
+    _createThinInstanceFragment = mod.createThinInstanceFragment;
+    const gpuMod = await import("./thin-instance-gpu-C9Gv_Z1w.js");
+    _syncThinInstanceBuffers = gpuMod.syncThinInstanceBuffers;
+  }
+  let _acesHelpers = "";
+  let _acesTonemapCall = "";
+  const hasTonemap = scene.imageProcessing.toneMappingEnabled;
+  if (hasTonemap && scene.imageProcessing.toneMappingType === "aces") {
+    const acesMod = await import("./pbr-aces-wgsl-HpiQHGN_.js");
+    _acesHelpers = acesMod.ACES_HELPERS_WGSL;
+    _acesTonemapCall = acesMod.ACES_TONEMAP_CALL_WGSL;
+  }
+  const composePbr = createPbrComposer({
+    _singleLightWGSL,
+    _getSingleLightBlock,
+    _multiLightWGSL,
+    _multiLightLoop,
+    _acesHelpers,
+    _acesTonemapCall,
+    _createPbrTemplateExt,
+    _anisoExt,
+    _iblSkyboxCalc,
+    _createPbrShadowFragment,
+    _shadowLights: shadowLights,
+    _createThinInstanceFragment
+  });
+  const sceneFeatures = (hasEnv ? PBR_HAS_ENV : 0) | (hasTonemap ? PBR_HAS_TONEMAP : 0);
+  const shadowBGCache = /* @__PURE__ */ new Map();
+  const syncThinInstanceBuffers = _syncThinInstanceBuffers;
+  const rebuildSingle = (s, mesh, materialOverride) => {
+    const materialInput = materialOverride ?? mesh.material;
+    const mat = materialInput;
+    const renderFeatures = mat._renderFeatures ?? (mat._renderFeatures = _computePbrMaterialFeatures(mat));
+    const isOverride = materialOverride != null;
+    const mi = mesh;
+    const lr = writeMeshLightSelection(mesh, s.lights);
+    const lightCount = lr > 0 ? 1 : -lr;
+    const features = renderFeatures.features;
+    const features2 = renderFeatures.features2 ?? 0;
+    const shadowOutput = (features2 & (PBR2_NO_COLOR_OUTPUT | PBR2_ESM_SHADOW_OUTPUT)) !== 0;
+    const receiveShadows = !shadowOutput && mesh.receiveShadows && hasSomeShadows;
+    const lightMode = lightCount === 0 ? 0 : lightCount === 1 && !receiveShadows ? 1 : 2;
+    const singleLightType = lightMode === 1 ? getPackedSingleLightType(s.lights, lr - 1) : "";
+    const meshFeatures = _computeMeshFeatures(mesh, receiveShadows);
+    const esmShadowDepthCode = (features2 & PBR2_ESM_SHADOW_OUTPUT) !== 0 ? mat._esmShadowDepthCode : "";
+    const vbLayout = mi._gpu._vbLayout;
+    const vbKey = mi._gpu._vbKey ?? "";
+    const composed = composePbr(features, features2, meshFeatures, sceneFeatures, lightMode, singleLightType, esmShadowDepthCode, vbLayout, vbKey);
+    const bindings = getOrCreatePbrBindings(engine, features, features2, meshFeatures, sceneFeatures, composed, `${lightMode}:${singleLightType}${vbKey}`);
+    const meshUboData = new Float32Array(composed._meshUboSpec._totalBytes / 4);
+    meshUboData.set(mesh.worldMatrix, 0);
+    writeMeshLightSelection(mesh, s.lights, meshUboData);
+    const meshUBO = createUniformBuffer(engine, meshUboData);
+    const materialSpec = composed._materialUboSpec;
+    const matInitData = new Float32Array(materialSpec._totalBytes / 4);
+    writeMaterialData(matInitData, mat, materialSpec);
+    const materialUBO = createUniformBuffer(engine, matInitData);
+    const needsTaskRefraction = !!mat.transmissive && (features2 & PBR2_HAS_REFRACTION) !== 0;
+    const materialBindGroupStatic = needsTaskRefraction ? null : createPbrMeshBindGroup(engine, bindings, composed, meshUBO, materialUBO, mat, envTextures ?? null, mesh);
+    let shadowBindGroup = null;
+    const meshShadowLights = receiveShadows ? shadowLights : [];
+    if (meshShadowLights.length > 0 && bindings._shadowBGL) {
+      let cached = shadowBGCache.get(bindings._shadowBGL);
+      if (!cached) {
+        const entries = [];
+        let b = 0;
+        for (const sl of meshShadowLights) {
+          const sg = sl.gen;
+          entries.push({ binding: b++, resource: sg._depthTexture.createView() });
+          entries.push({ binding: b++, resource: sg._depthSampler });
+          entries.push({ binding: b++, resource: { buffer: sg._shadowUBO } });
+        }
+        cached = device.createBindGroup({ layout: bindings._shadowBGL, entries });
+        shadowBGCache.set(bindings._shadowBGL, cached);
+      }
+      shadowBindGroup = cached;
+    }
+    const boundTextures = collectPbrBoundTextures(mat);
+    for (const t of boundTextures) {
+      acquireTexture(t);
+    }
+    s._meshDisposables.set(mesh, [
+      () => {
+        meshUBO.destroy();
+        materialUBO.destroy();
+      },
+      () => {
+        for (const t of boundTextures) {
+          releaseTexture(t);
+        }
+      }
+    ]);
+    const isTransparent = (features2 & (PBR2_NO_COLOR_OUTPUT | PBR2_ESM_SHADOW_OUTPUT)) === 0 && (features & PBR_HAS_ALPHA_BLEND) !== 0;
+    const order = mesh.renderOrder ?? (isTransparent || needsTaskRefraction ? 150 : 100);
+    const hasNormalMap = (features & PBR_HAS_NORMAL_MAP) !== 0;
+    const hasUV2 = (features2 & PBR2_HAS_UV2) !== 0 && (meshFeatures & MSH_HAS_UV2) !== 0;
+    const hasVertexColor = (meshFeatures & MSH_HAS_VERTEX_COLOR) !== 0;
+    const hasTI = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;
+    const hasTIColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;
+    let _lastWorldVersion = -1;
+    let _lastLightsCount = s.lights.length;
+    const sortCenter = isTransparent || needsTaskRefraction ? [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]] : null;
+    const update = () => {
+      const worldVersion = mesh.worldMatrixVersion;
+      if (worldVersion !== _lastWorldVersion || s.lights.length !== _lastLightsCount) {
+        if (sortCenter) {
+          sortCenter[0] = mesh.worldMatrix[12];
+          sortCenter[1] = mesh.worldMatrix[13];
+          sortCenter[2] = mesh.worldMatrix[14];
+        }
+        meshUboData.set(mesh.worldMatrix, 0);
+        writeMeshLightSelection(mesh, s.lights, meshUboData);
+        device.queue.writeBuffer(meshUBO, 0, meshUboData);
+        _lastWorldVersion = worldVersion;
+        _lastLightsCount = s.lights.length;
+      }
+      const uboVersion = mat._uboVersion;
+      if (uboVersion !== _lastUboVersion) {
+        _lastUboVersion = uboVersion;
+        let data = materialScratch.get(materialSpec._totalBytes);
+        if (!data) {
+          data = new Float32Array(materialSpec._totalBytes / 4);
+          materialScratch.set(materialSpec._totalBytes, data);
+        } else {
+          data.fill(0);
+        }
+        writeMaterialData(data, mat, materialSpec);
+        device.queue.writeBuffer(materialUBO, 0, data.buffer, 0, data.byteLength);
+      }
+    };
+    const drawWith = (pass, materialBindGroup) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2;
+      if (!isOverride && mesh.material !== materialInput) {
+        return 0;
+      }
+      const gpu = mi._gpu;
+      pass.setBindGroup(1, materialBindGroup);
+      if (shadowBindGroup) {
+        pass.setBindGroup(2, shadowBindGroup);
+      }
+      let slot = 0;
+      const vb = gpu._vbLayout;
+      pass.setVertexBuffer(slot++, gpu.positionBuffer, (_a2 = vb == null ? void 0 : vb._p) == null ? void 0 : _a2._offset);
+      pass.setVertexBuffer(slot++, gpu.normalBuffer, (_b2 = vb == null ? void 0 : vb._n) == null ? void 0 : _b2._offset);
+      if (hasNormalMap && gpu.tangentBuffer) {
+        pass.setVertexBuffer(slot++, gpu.tangentBuffer, (_c2 = vb == null ? void 0 : vb._t) == null ? void 0 : _c2._offset);
+      }
+      pass.setVertexBuffer(slot++, gpu.uvBuffer, (_d2 = vb == null ? void 0 : vb._u) == null ? void 0 : _d2._offset);
+      if (hasUV2 && gpu.uv2Buffer) {
+        pass.setVertexBuffer(slot++, gpu.uv2Buffer, (_e2 = vb == null ? void 0 : vb._u2) == null ? void 0 : _e2._offset);
+      }
+      if (hasVertexColor && gpu.colorBuffer) {
+        pass.setVertexBuffer(slot++, gpu.colorBuffer, (_f2 = vb == null ? void 0 : vb._c) == null ? void 0 : _f2._offset);
+      }
+      if (mesh.skeleton) {
+        pass.setVertexBuffer(slot++, mesh.skeleton.jointsBuffer);
+        pass.setVertexBuffer(slot++, mesh.skeleton.weightsBuffer);
+        if (mesh.skeleton.joints1Buffer && mesh.skeleton.weights1Buffer) {
+          pass.setVertexBuffer(slot++, mesh.skeleton.joints1Buffer);
+          pass.setVertexBuffer(slot++, mesh.skeleton.weights1Buffer);
+        }
+      }
+      const ti = hasTI ? mesh.thinInstances : null;
+      if (ti && syncThinInstanceBuffers) {
+        slot = syncThinInstanceBuffers(engine, ti, pass, slot, hasTIColor);
+      }
+      pass.setIndexBuffer(gpu.indexBuffer, gpu.indexFormat);
+      if (ti && ti.count > 0) {
+        pass.drawIndexed(gpu.indexCount, ti.count);
+      } else {
+        pass.drawIndexed(gpu.indexCount);
+      }
+      return 1;
+    };
+    const draw = (pass) => drawWith(pass, materialBindGroupStatic);
+    const r = {
+      order,
+      isTransparent,
+      _transmissive: needsTaskRefraction,
+      mesh,
+      bind(eng, sig) {
+        const pipeline = getOrCreatePbrPipeline(eng, sig, bindings);
+        const materialBindGroup = needsTaskRefraction ? createPbrMeshBindGroup(engine, bindings, composed, meshUBO, materialUBO, mat, envTextures ?? null, mesh, sig._transmissionTexture) : materialBindGroupStatic;
+        return {
+          renderable: r,
+          pipeline,
+          update,
+          draw: needsTaskRefraction ? (pass) => drawWith(pass, materialBindGroup) : draw
+        };
+      }
+    };
+    if (sortCenter) {
+      r._worldCenter = sortCenter;
+    }
+    let _lastUboVersion = mat._uboVersion;
+    return r;
+  };
+  const renderables = meshes.map((m) => rebuildSingle(scene, m));
+  scene._disposables.push(
+    () => clearPbrPipelineCache(),
+    () => clearSamplerCache(engine)
+  );
+  return { renderables, rebuildSingle };
+}
+function toSingleLightType(type) {
+  return type === "hemispheric" || type === "directional" || type === "spot" ? type : "point";
+}
+function getPackedSingleLightType(lights, packedIndex) {
+  let packed = 0;
+  for (const light of lights) {
+    if (!light._writeLightUbo) {
+      continue;
+    }
+    if (packed === packedIndex) {
+      return toSingleLightType(light.lightType);
+    }
+    packed++;
+  }
+  return "point";
+}
+async function importSingleLightWgsl(type) {
+  if (type === "hemispheric") {
+    return import("./singlelight-hemispheric-wgsl-t-83IP_s.js");
+  }
+  if (type === "directional") {
+    return import("./singlelight-directional-wgsl-CmUDZxwz.js");
+  }
+  if (type === "spot") {
+    return import("./singlelight-spot-wgsl-DEEUrfVM.js");
+  }
+  return import("./singlelight-point-wgsl-CLzULIYV.js");
+}
+function writeMaterialData(data, material, spec) {
+  data[0] = material.environmentIntensity ?? 1;
+  data[1] = material.directIntensity ?? 1;
+  data[2] = material.reflectance ?? 0.04;
+  data[3] = material.alpha ?? 1;
+  const baseColorFactorOffset = spec._offsets.get("baseColorFactor");
+  if (baseColorFactorOffset !== void 0) {
+    const off = baseColorFactorOffset / 4;
+    const factor = material.baseColorFactor;
+    data[off] = factor ? factor[0] : 1;
+    data[off + 1] = factor ? factor[1] : 1;
+    data[off + 2] = factor ? factor[2] : 1;
+    data[off + 3] = factor ? factor[3] : 1;
+  }
+  if (spec._offsets.has("metallicFactor")) {
+    const off = spec._offsets.get("metallicFactor") / 4;
+    data[off] = material.metallicFactor ?? 1;
+    data[off + 1] = material.roughnessFactor ?? 1;
+    data[off + 2] = material.normalTextureScale ?? 1;
+    data[off + 3] = material.usePhysicalLightFalloff === false ? 0 : 1;
+  }
+  for (const ext of _getPbrExts().values()) {
+    if (ext.writeUbo) {
+      ext.writeUbo(data, material, spec._offsets);
+    }
+  }
+}
+export {
+  buildPbrRenderables
+};
+//# sourceMappingURL=pbr-renderable-BJxUtPBb.js.map