@babylonjs/lite 0.1.1

package/standard-renderable-GjxL9xSf.js

@@ -0,0 +1,636 @@
+import { by as _getStdExts, bz as HAS_DIFFUSE_TEXTURE, bA as DIFFUSE_USES_UV2, ad as HAS_EMISSIVE_TEXTURE, ae as HAS_DEPTH_EMISSIVE_TEXTURE, ac as HAS_BUMP_TEXTURE, af as HAS_SPECULAR_TEXTURE, ag as SPECULAR_USES_UV2, ah as HAS_AMBIENT_TEXTURE, ai as AMBIENT_USES_UV2, aj as HAS_LIGHTMAP_TEXTURE, ak as LIGHTMAP_USES_UV2, al as HAS_OPACITY_TEXTURE, am as OPACITY_FROM_RGB, bB as DOUBLE_SIDED, an as HAS_REFLECTION_TEXTURE, ao as HAS_CUBE_REFLECTION, bC as DISABLE_LIGHTING, S as MATERIAL_ALPHA_BLEND, b9 as appendMeshLightUboFields, M as MAX_LIGHTS, ba as meshLightIndexWGSL, bD as clearSceneBGLCache, aY as createUniformBuffer, bE as _getStdExtsSorted, bF as NEEDS_UV, R as ESM_SHADOW_OUTPUT, D as targetSignatureKey, F as getSceneBindGroupLayout, b5 as REVERSE_DEPTH_COMPARE, bG as NO_COLOR_OUTPUT, bH as NEEDS_UV2, bm as clearSamplerCache, a as writeMeshLightSelection, aU as acquireTexture, b1 as releaseTexture } from "./index-C8HOR2sB.js";
+import { c as WGSL_FOG } from "./wgsl-helpers-DyzNzCeE.js";
+import { e as composeShader, f as MSH_RECEIVE_SHADOWS, _ as _computeMeshFeatures, g as MSH_HAS_THIN_INSTANCES, i as MSH_HAS_INSTANCE_COLOR } from "./mesh-features-BLENkYVt.js";
+function collectStdBoundTextures(mat) {
+  var _a;
+  const t = [];
+  if (mat.diffuseTexture) {
+    t.push(mat.diffuseTexture);
+  }
+  for (const ext of _getStdExts().values()) {
+    (_a = ext._textures) == null ? void 0 : _a.call(ext, mat, t);
+  }
+  return t;
+}
+function _computeStandardMaterialFeatures(m) {
+  let f = 0;
+  if (m.diffuseTexture) {
+    f |= HAS_DIFFUSE_TEXTURE;
+    if (m.diffuseCoordIndex === 1) {
+      f |= DIFFUSE_USES_UV2;
+    }
+  }
+  if (m.emissiveTexture) {
+    f |= HAS_EMISSIVE_TEXTURE;
+    if (m.emissiveTexture._sampleType === "depth") {
+      f |= HAS_DEPTH_EMISSIVE_TEXTURE;
+    }
+  }
+  if (m.bumpTexture) {
+    f |= HAS_BUMP_TEXTURE;
+  }
+  if (m.specularTexture) {
+    f |= HAS_SPECULAR_TEXTURE;
+    if (m.specularCoordIndex === 1) {
+      f |= SPECULAR_USES_UV2;
+    }
+  }
+  if (m.ambientTexture) {
+    f |= HAS_AMBIENT_TEXTURE;
+    if (m.ambientCoordIndex === 1) {
+      f |= AMBIENT_USES_UV2;
+    }
+  }
+  if (m.lightmapTexture) {
+    f |= HAS_LIGHTMAP_TEXTURE;
+    if (m.lightmapCoordIndex === 1) {
+      f |= LIGHTMAP_USES_UV2;
+    }
+  }
+  if (m.opacityTexture) {
+    f |= HAS_OPACITY_TEXTURE;
+    if (m.opacityFromRGB) {
+      f |= OPACITY_FROM_RGB;
+    }
+  }
+  if (!m.backFaceCulling) {
+    f |= DOUBLE_SIDED;
+  }
+  if (m.reflectionTexture) {
+    f |= HAS_REFLECTION_TEXTURE;
+  }
+  if (m.reflectionCubeTexture) {
+    f |= HAS_CUBE_REFLECTION;
+  }
+  if (m.disableLighting) {
+    f |= DISABLE_LIGHTING;
+  }
+  if (m.alpha < 1) {
+    f |= MATERIAL_ALPHA_BLEND;
+  }
+  return f;
+}
+function _standardFeatureKey(features, meshFeatures, variant = "") {
+  return variant ? `${features}:${meshFeatures}:${variant}` : `${features}:${meshFeatures}`;
+}
+function _standardShaderVariantKey(shadowLights) {
+  return shadowLights.length === 0 ? "" : shadowLights.map((sl) => `${sl.lightIndex}${sl.shadowType === "pcf" ? "p" : "e"}`).join(",");
+}
+const STAGE_VERTEX = 1;
+const STAGE_FRAGMENT = 2;
+const LIGHTING_FN = `
+fn computeLighting(viewDir: vec3<f32>, N: vec3<f32>, L: LightEntry, g: f32, P: vec3<f32>) -> array<vec3<f32>, 2> {
+var lv: vec3<f32>;
+var a: f32 = 1.0;
+let t = u32(L.vLightData.w);
+if (t == 3u) {
+let nl = 0.5 + 0.5 * dot(N, normalize(L.vLightData.xyz));
+let diff = mix(L.vLightDirection.xyz, L.vLightDiffuse.rgb, nl);
+let h = normalize(viewDir + normalize(L.vLightData.xyz));
+var s = pow(max(0.0, dot(N, h)), max(1.0, g));
+return array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb);
+}
+if (t == 1u) {
+lv = normalize(-L.vLightData.xyz);
+} else {
+let d = L.vLightData.xyz - P;
+a = max(0.0, 1.0 - length(d) / L.vLightDiffuse.a);
+lv = normalize(d);
+if (t == 2u) {
+let c = max(0.0, dot(L.vLightDirection.xyz, -lv));
+if (c >= L.vLightDirection.w) { a *= max(0.0, pow(c, L.vLightSpecular.a)); } else { a = 0.0; }
+}
+}
+let nl = max(0.0, dot(N, lv));
+let diff = nl * L.vLightDiffuse.rgb * a;
+let h = normalize(viewDir + lv);
+var s = max(0.0, dot(N, h));
+s = pow(s, max(1.0, g));
+return array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb * a);
+}
+`;
+function createStandardTemplate(config, esmShadowDepthCode = "") {
+  const { _diffuse, _needsUV, _needsUV2, _diffuseUsesUV2, _disableLighting, _noColorOutput, _esmShadowOutput } = config;
+  const _baseVertexAttributes = [
+    { _name: "position", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: 12 },
+    { _name: "normal", _type: "vec3<f32>", _gpuFormat: "float32x3", _arrayStride: 12 }
+  ];
+  if (_needsUV) {
+    _baseVertexAttributes.push({ _name: "uv", _type: "vec2<f32>", _gpuFormat: "float32x2", _arrayStride: 8 });
+  }
+  if (_needsUV2) {
+    _baseVertexAttributes.push({ _name: "uv2", _type: "vec2<f32>", _gpuFormat: "float32x2", _arrayStride: 8 });
+  }
+  const _baseVaryings = [
+    { _name: "vp", _type: "vec3<f32>" },
+    { _name: "vn", _type: "vec3<f32>" },
+    { _name: "vf", _type: "vec3<f32>" }
+  ];
+  if (_needsUV) {
+    _baseVaryings.push({ _name: "vu", _type: "vec2<f32>" });
+  }
+  if (_needsUV2) {
+    _baseVaryings.push({ _name: "vv", _type: "vec2<f32>" });
+  }
+  const _baseMeshUboFields = [{ _name: "world", _type: "mat4x4<f32>" }];
+  appendMeshLightUboFields(_baseMeshUboFields);
+  const _baseBindings = [{ _name: "mat", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT }];
+  if (_diffuse) {
+    _baseBindings.push(
+      { _name: "dT", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "dS", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    );
+  }
+  if (_needsUV) {
+    _baseBindings.push({ _name: "up", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_VERTEX });
+  }
+  if (_esmShadowOutput) {
+    _baseBindings.push({ _name: "shadowParams", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT });
+  }
+  const uvPassthrough = _needsUV ? `out.vu = uv * up.u.xy + up.u.zw;` : "";
+  const uv2Passthrough = _needsUV2 ? `out.vv = uv2;` : "";
+  const vertexUboStructs = _needsUV ? `struct upUniforms { u: vec4<f32>, }` : "";
+  const _vertexTemplate = `/*SU*/
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+${vertexUboStructs}
+/*VH*/
+/*VD*/
+/*VO*/
+@vertex fn main(
+/*VP*/
+) -> VertexOutput {
+var out: VertexOutput;
+/*VR*/
+var finalWorld = mesh.world;
+/*VW*/
+let worldPos4 = finalWorld * vec4<f32>(position, 1.0);
+out.vp = worldPos4.xyz;
+let normalWorld = mat3x3<f32>(finalWorld[0].xyz, finalWorld[1].xyz, finalWorld[2].xyz);
+out.vn = normalize(normalWorld * normal);
+out.clipPos = scene.viewProjection * worldPos4;
+out.vf = (scene.view * worldPos4).xyz;
+${uvPassthrough}
+${uv2Passthrough}
+/*VB*/
+return out;
+}`;
+  const lightsStructs = `
+struct LightEntry { vLightData: vec4<f32>, vLightDiffuse: vec4<f32>, vLightSpecular: vec4<f32>, vLightDirection: vec4<f32> };
+struct lightsUniforms { count: u32, _p0: u32, _p1: u32, _p2: u32, lights: array<LightEntry, ${MAX_LIGHTS}> };
+@group(0) @binding(1) var<uniform> lights: lightsUniforms;
+`;
+  const materialStruct = `
+struct matUniforms {
+dc: vec4<f32>,
+sc: vec4<f32>,
+ec: vec3<f32>,
+bs: f32,
+ac: vec3<f32>,
+tl: f32,
+ambTexLvl: f32,
+lmLvl: f32,
+opLvl: f32,
+aCut: f32,
+rLvl: f32,
+rCm: f32,
+_0: f32,
+_1: f32,
+};
+`;
+  const helpers = _disableLighting ? WGSL_FOG : WGSL_FOG + LIGHTING_FN;
+  const doubleSidedEntry = `@fragment fn main(input: FragmentInput)${_noColorOutput ? "" : " -> @location(0) vec4<f32>"} {`;
+  const viewDirCode = !_disableLighting ? `let viewDirectionW = normalize(scene.vEyePosition.xyz - input.vp);` : "";
+  const normalCode = _disableLighting ? "" : `var normalW = normalize(input.vn);`;
+  const opacityCode = `var alpha = mat.dc.a;`;
+  const baseColorCode = _diffuse ? `let _ds = textureSample(dT, dS, ${_diffuseUsesUV2 ? "input.vv" : "input.vu"});
+if (_ds.a < mat.aCut) { discard; }
+var baseColor = _ds.rgb * mat.tl;` : `var baseColor = vec3<f32>(1.0, 1.0, 1.0);`;
+  const diffuseColorCode = `let diffuseColor = mat.dc.rgb;`;
+  const emissiveCode = `var emissiveContrib = mat.ec;`;
+  const specularColorCode = !_disableLighting ? `var specularColor = mat.sc.rgb;` : "";
+  let lightingBlock;
+  if (!_disableLighting) {
+    lightingBlock = `var glossiness = mat.sc.a;
+var diffuseBase = vec3<f32>(0.0);
+var specularBase = vec3<f32>(0.0);
+var shadowFactors = array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill("1.0").join(", ")});
+var baseAmbientColor = vec3<f32>(1.0, 1.0, 1.0);
+var reflectionColor = vec3<f32>(0.0);
+let lc = min(mesh.lc, ${MAX_LIGHTS}u);
+/*AD*/
+for (var li = 0u; li < lc; li++) {
+let lightIndex = mli(li);
+let r = computeLighting(viewDirectionW, normalW, lights.lights[lightIndex], glossiness, input.vp);
+let sf = shadowFactors[lightIndex];
+diffuseBase += r[0] * sf;
+specularBase += r[1] * sf;
+}
+let finalDiffuse = clamp(diffuseBase * diffuseColor + emissiveContrib + mat.ac, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor;
+let finalSpecular = specularBase * specularColor;
+var color = vec4<f32>(finalDiffuse * baseAmbientColor + finalSpecular + reflectionColor, alpha);`;
+  } else {
+    lightingBlock = `var color = vec4<f32>(clamp(emissiveContrib * diffuseColor, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor, alpha);`;
+  }
+  const _fragmentTemplate = `/*SU*/
+${lightsStructs}
+${materialStruct}
+${_esmShadowOutput ? "struct shadowParamsUniforms { biasAndScale: vec4<f32>, depthValues: vec4<f32>, }" : ""}
+/*MU*/
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+${!_disableLighting ? meshLightIndexWGSL("mesh") : ""}
+${helpers}
+/*HF*/
+/*FB*/
+/*FI*/
+${doubleSidedEntry}
+/*SV*/
+${viewDirCode}
+${normalCode}
+/*AC*/
+${opacityCode}
+${baseColorCode}
+${diffuseColorCode}
+${emissiveCode}
+${specularColorCode}
+/*AT*/
+${_noColorOutput ? "return;" : _esmShadowOutput ? esmShadowDepthCode : ""}
+${lightingBlock}
+/*BC*/
+color = vec4<f32>(max(color.rgb, vec3<f32>(0.0)), color.a);
+if (scene.vFogInfos.x > 0.0) {
+let fog = calcFogFactor(input.vf);
+color = vec4<f32>(mix(scene.vFogColor.rgb, color.rgb, fog), color.a);
+}
+/*BA*/
+${_noColorOutput ? "" : "return color;"}
+}`;
+  return {
+    _vertexTemplate,
+    _fragmentTemplate,
+    _baseMeshUboFields,
+    _baseVertexAttributes,
+    _baseVaryings,
+    _baseBindings
+  };
+}
+function composeStandardShader(features, _meshFeatures = 0, fragments = [], esmShadowDepthCode = "") {
+  const has = (bit) => (features & bit) !== 0;
+  const template = createStandardTemplate(
+    {
+      _diffuse: has(HAS_DIFFUSE_TEXTURE),
+      _needsUV: has(NEEDS_UV),
+      _needsUV2: has(NEEDS_UV2),
+      _diffuseUsesUV2: has(DIFFUSE_USES_UV2),
+      _disableLighting: has(DISABLE_LIGHTING),
+      _noColorOutput: has(NO_COLOR_OUTPUT),
+      _esmShadowOutput: has(ESM_SHADOW_OUTPUT)
+    },
+    esmShadowDepthCode
+  );
+  return composeShader(template, fragments);
+}
+const _bindingsCache = /* @__PURE__ */ new Map();
+let _composedCache = null;
+let _cachedDevice = null;
+function getComposedCache() {
+  if (!_composedCache) {
+    _composedCache = /* @__PURE__ */ new Map();
+  }
+  return _composedCache;
+}
+function ensureDevice(engine) {
+  if (_cachedDevice !== engine._device) {
+    _bindingsCache.clear();
+    _composedCache == null ? void 0 : _composedCache.clear();
+    clearSceneBGLCache();
+    _cachedDevice = engine._device;
+  }
+}
+function clearStandardPipelineCache() {
+  _bindingsCache.clear();
+  _composedCache == null ? void 0 : _composedCache.clear();
+  clearSceneBGLCache();
+  _cachedDevice = null;
+}
+function getOrCreateStandardBindings(engine, features, meshFeatures, fragments = [], shaderKey = "", esmShadowDepthCode = "") {
+  ensureDevice(engine);
+  const key = _standardFeatureKey(features, meshFeatures, shaderKey);
+  const cached = _bindingsCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const cc = getComposedCache();
+  let composed = cc.get(key);
+  if (!composed) {
+    composed = composeStandardShader(features, meshFeatures, fragments, esmShadowDepthCode);
+    cc.set(key, composed);
+  }
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  let shadowBGL = null;
+  const hasShadow = (meshFeatures & MSH_RECEIVE_SHADOWS) !== 0;
+  if (hasShadow && composed._shadowBGLDescriptor) {
+    shadowBGL = device.createBindGroupLayout(composed._shadowBGLDescriptor);
+  }
+  const bindings = {
+    _features: features,
+    _meshFeatures: meshFeatures,
+    _meshBGL: meshBGL,
+    _shadowBGL: shadowBGL,
+    _composed: composed,
+    _pipelines: /* @__PURE__ */ new Map()
+  };
+  _bindingsCache.set(key, bindings);
+  return bindings;
+}
+function getOrCreateStandardPipeline(engine, sig, bindings) {
+  ensureDevice(engine);
+  const key = targetSignatureKey(sig);
+  const cached = bindings._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const composed = bindings._composed;
+  const features = bindings._features;
+  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 = (features & NO_COLOR_OUTPUT) !== 0;
+  const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;
+  const fragModule = !sig._colorFormat && !noColorOutput ? null : device.createShaderModule({ code: composed._fragmentWGSL });
+  const needsBlend = !esmShadowOutput && ((features & HAS_OPACITY_TEXTURE) !== 0 || (features & MATERIAL_ALPHA_BLEND) !== 0);
+  const colorTarget = noColorOutput ? null : needsBlend ? {
+    format: sig._colorFormat,
+    blend: {
+      color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha" },
+      alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha" }
+    }
+  } : { format: sig._colorFormat };
+  const pipeline = device.createRenderPipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: bgls }),
+    vertex: { module: vertModule, entryPoint: "main", buffers: composed._vertexBufferLayouts },
+    ...fragModule ? { fragment: { module: fragModule, entryPoint: "main", targets: colorTarget ? [colorTarget] : [] } } : {},
+    ...sig._depthStencilFormat ? {
+      depthStencil: {
+        format: sig._depthStencilFormat,
+        depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,
+        depthWriteEnabled: noColorOutput || esmShadowOutput || !needsBlend
+      }
+    } : {},
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "triangle-list", cullMode: features & DOUBLE_SIDED ? "none" : "back", frontFace: sig._flipY ? "cw" : "ccw" }
+  });
+  bindings._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function createStandardMeshBindGroup(engine, bindings, meshUBO, materialUBO, material) {
+  var _a;
+  const device = engine._device;
+  const features = bindings._features;
+  const needsUV = (features & NEEDS_UV) !== 0;
+  const hasDiffuseTex = (features & HAS_DIFFUSE_TEXTURE) !== 0;
+  const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;
+  let nextBinding = 0;
+  const entries = [
+    { binding: nextBinding++, resource: { buffer: meshUBO } },
+    { binding: nextBinding++, resource: { buffer: materialUBO } }
+  ];
+  if (hasDiffuseTex) {
+    const tex = material.diffuseTexture;
+    entries.push({ binding: nextBinding++, resource: tex.texture.createView() }, { binding: nextBinding++, resource: tex.sampler });
+  }
+  if (needsUV) {
+    const uvData = new Float32Array(4);
+    const scaleX = material.uvScale[0];
+    let scaleY = material.uvScale[1];
+    let offsetY = 0;
+    if ((_a = material.diffuseTexture) == null ? void 0 : _a.invertY) {
+      offsetY = scaleY;
+      scaleY = -scaleY;
+    }
+    uvData[0] = scaleX;
+    uvData[1] = scaleY;
+    uvData[2] = 0;
+    uvData[3] = offsetY;
+    entries.push({ binding: nextBinding++, resource: { buffer: createUniformBuffer(engine, uvData) } });
+  }
+  if (esmShadowOutput) {
+    entries.push({
+      binding: nextBinding++,
+      resource: { buffer: material._esmShadowParamsUBO }
+    });
+  }
+  const sortedExts = _getStdExtsSorted();
+  for (const ext of sortedExts) {
+    if (features & ext._feature && ext._bind) {
+      nextBinding = ext._bind(material, entries, nextBinding);
+    }
+  }
+  return device.createBindGroup({ layout: bindings._meshBGL, entries });
+}
+function writeStdMaterialData(data, mat, textureLevel) {
+  const { diffuseColor: dc, specularColor: sc, emissiveColor: ec, ambientColor: ac } = mat;
+  data[0] = dc[0];
+  data[1] = dc[1];
+  data[2] = dc[2];
+  data[3] = mat.alpha;
+  data[4] = sc[0];
+  data[5] = sc[1];
+  data[6] = sc[2];
+  data[7] = mat.specularPower;
+  data[8] = ec[0];
+  data[9] = ec[1];
+  data[10] = ec[2];
+  data[11] = 1 / mat.bumpLevel;
+  data[12] = ac[0];
+  data[13] = ac[1];
+  data[14] = ac[2];
+  data[15] = textureLevel;
+  data[16] = mat.ambientTexLevel;
+  data[17] = mat.lightmapLevel;
+  data[18] = mat.opacityLevel;
+  data[19] = mat.alphaCutOff;
+  data[20] = mat.reflectionLevel;
+  data[21] = mat.reflectionCoordMode;
+}
+const _stdMatScratch = new Float32Array(24);
+function buildStandardMeshRenderables(scene, meshes, factories) {
+  const engine = scene.engine;
+  const device = engine._device;
+  const { tiSync, tiFragment, shadowFragment } = factories;
+  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;
+  const shadowBGCache = /* @__PURE__ */ new Map();
+  const rebuildSingle = (s, mesh, materialOverride) => {
+    const mat = materialOverride ?? mesh.material;
+    const renderFeatures = mat._renderFeatures ?? (mat._renderFeatures = { features: _computeStandardMaterialFeatures(mat) });
+    const isOverride = materialOverride != null;
+    const features = renderFeatures.features;
+    const shadowOutput = (features & (NO_COLOR_OUTPUT | ESM_SHADOW_OUTPUT)) !== 0;
+    const receiveShadows = !shadowOutput && mesh.receiveShadows && hasSomeShadows;
+    const meshFeatures = _computeMeshFeatures(mesh, receiveShadows);
+    const frags = [];
+    for (const ext of _getStdExts().values()) {
+      if (features & ext._feature) {
+        const f = ext._frag(features);
+        if (f) {
+          frags.push(f);
+        }
+      }
+    }
+    let shaderKey = "";
+    if (meshFeatures & MSH_RECEIVE_SHADOWS && shadowFragment) {
+      const slots = shadowLights.map((sl) => ({ lightIndex: sl.lightIndex, shadowType: sl.shadowType }));
+      shaderKey = _standardShaderVariantKey(slots);
+      frags.push(shadowFragment(slots));
+    }
+    if (meshFeatures & MSH_HAS_THIN_INSTANCES && tiFragment) {
+      const hasColor = !!(meshFeatures & MSH_HAS_INSTANCE_COLOR);
+      const tiFrag = tiFragment(hasColor);
+      if (hasColor) {
+        const { _fragmentSlots, ...rest } = tiFrag;
+        frags.push({
+          ...rest,
+          _fragmentSlots: {
+            BC: `color = vec4<f32>(color.rgb * input.vInstanceColor.rgb, color.a * input.vInstanceColor.a);`
+          }
+        });
+      } else {
+        frags.push(tiFrag);
+      }
+    }
+    const esmShadowDepthCode = (features & ESM_SHADOW_OUTPUT) !== 0 ? mat._esmShadowDepthCode : "";
+    const bindings = getOrCreateStandardBindings(engine, features, meshFeatures, frags, shaderKey, esmShadowDepthCode);
+    const meshShadowGens = receiveShadows ? shadowLights.map((sl) => sl.gen) : [];
+    const meshUboData = new Float32Array(bindings._composed._meshUboSpec._totalBytes / 4);
+    meshUboData.set(mesh.worldMatrix, 0);
+    writeMeshLightSelection(mesh, s.lights, meshUboData);
+    const meshUBO = createUniformBuffer(engine, meshUboData);
+    const textureLevel = (features & NEEDS_UV) !== 0 ? 1 : 0;
+    const matData = new Float32Array(24);
+    writeStdMaterialData(matData, mat, textureLevel);
+    const materialUBO = createUniformBuffer(engine, matData);
+    const meshBindGroup = createStandardMeshBindGroup(engine, bindings, meshUBO, materialUBO, mat);
+    let shadowBindGroup = null;
+    if (meshShadowGens.length > 0 && bindings._shadowBGL) {
+      let cached = shadowBGCache.get(bindings._shadowBGL);
+      if (!cached) {
+        const entries = [];
+        let b = 0;
+        for (const sg of meshShadowGens) {
+          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 needsUV = (features & NEEDS_UV) !== 0;
+    const needsUV2 = (features & NEEDS_UV2) !== 0;
+    const hasThinInstances = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;
+    const hasInstanceColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;
+    const isTransparent = !shadowOutput && ((features & HAS_OPACITY_TEXTURE) !== 0 || mat.alpha < 1);
+    const boundTextures = collectStdBoundTextures(mat);
+    for (const t of boundTextures) {
+      acquireTexture(t);
+    }
+    s._meshDisposables.set(mesh, [
+      () => {
+        for (const t of boundTextures) {
+          releaseTexture(t);
+        }
+      }
+    ]);
+    let _lastWorldVersion = mesh.worldMatrixVersion;
+    let _lastLightsCount = s.lights.length;
+    const sortCenter = [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]];
+    const update = () => {
+      const worldVersion = mesh.worldMatrixVersion;
+      if (worldVersion !== _lastWorldVersion || s.lights.length !== _lastLightsCount) {
+        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;
+        _stdMatScratch.fill(0);
+        writeStdMaterialData(_stdMatScratch, mat, textureLevel);
+        device.queue.writeBuffer(materialUBO, 0, _stdMatScratch.buffer, 0, 96);
+      }
+    };
+    const draw = (pass) => {
+      var _a, _b, _c, _d;
+      if (!isOverride && mesh.material !== mat) {
+        return 0;
+      }
+      const g = mesh._gpu;
+      let slot = 0;
+      const vb = g._vbLayout;
+      pass.setVertexBuffer(slot++, g.positionBuffer, (_a = vb == null ? void 0 : vb._p) == null ? void 0 : _a._offset);
+      pass.setVertexBuffer(slot++, g.normalBuffer, (_b = vb == null ? void 0 : vb._n) == null ? void 0 : _b._offset);
+      if (needsUV) {
+        pass.setVertexBuffer(slot++, g.uvBuffer, (_c = vb == null ? void 0 : vb._u) == null ? void 0 : _c._offset);
+      }
+      if (needsUV2 && g.uv2Buffer) {
+        pass.setVertexBuffer(slot++, g.uv2Buffer, (_d = vb == null ? void 0 : vb._u2) == null ? void 0 : _d._offset);
+      }
+      const ti = hasThinInstances ? mesh.thinInstances : null;
+      if (ti && tiSync) {
+        slot = tiSync(engine, ti, pass, slot, hasInstanceColor);
+      }
+      pass.setIndexBuffer(g.indexBuffer, g.indexFormat);
+      pass.setBindGroup(1, meshBindGroup);
+      if (receiveShadows && shadowBindGroup) {
+        pass.setBindGroup(2, shadowBindGroup);
+      }
+      if (ti && ti.count > 0) {
+        pass.drawIndexed(g.indexCount, ti.count);
+      } else {
+        pass.drawIndexed(g.indexCount);
+      }
+      return 1;
+    };
+    const r = {
+      order: mesh.renderOrder ?? (isTransparent ? 200 : 100),
+      isTransparent,
+      mesh,
+      bind(eng, sig) {
+        return {
+          renderable: r,
+          pipeline: getOrCreateStandardPipeline(eng, sig, bindings),
+          update,
+          draw
+        };
+      }
+    };
+    r._worldCenter = sortCenter;
+    let _lastUboVersion = mat._uboVersion;
+    return r;
+  };
+  const renderables = meshes.map((m) => rebuildSingle(scene, m));
+  scene._disposables.push(
+    () => clearStandardPipelineCache(),
+    () => clearSamplerCache(engine)
+  );
+  return { renderables, rebuildSingle };
+}
+export {
+  buildStandardMeshRenderables
+};
+//# sourceMappingURL=standard-renderable-GjxL9xSf.js.map