@babylonjs/lite 1.1.0 → 1.3.0

package/standard-pipeline-DXFOUqU_.js

@@ -1,391 +0,0 @@
-import { bH as appendMeshLightUboFields, M as MAX_LIGHTS, bI as meshLightIndexWGSL, bJ as clearSceneBGLCache, a as F32, ay as createUniformBuffer, bK as _getStdExtsSorted, bL as _standardFeatureKey, aH as MSH_RECEIVE_SHADOWS, bM as HAS_DIFFUSE_TEXTURE, aD as NEEDS_UV, Q as ESM_SHADOW_OUTPUT, y as targetSignatureKey, A as getSceneBindGroupLayout, bN as REVERSE_DEPTH_COMPARE, bO as DOUBLE_SIDED, aC as NO_COLOR_OUTPUT, ap as HAS_OPACITY_TEXTURE, R as MATERIAL_ALPHA_BLEND, bP as DISABLE_LIGHTING, bQ as DIFFUSE_USES_UV2, aF as NEEDS_UV2 } from "./index-BgY3QEzL.js";
-import { a as WGSL_FOG } from "./wgsl-helpers-D8sl1VVA.js";
-import { c as composeShader } from "./shader-composer-CBy2i8nU.js";
-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: "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 F32(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;
-}
-export {
-  createStandardMeshBindGroup as a,
-  getOrCreateStandardPipeline as b,
-  clearStandardPipelineCache as c,
-  composeStandardShader as d,
-  getOrCreateStandardBindings as g,
-  writeStdMaterialData as w
-};
-//# sourceMappingURL=standard-pipeline-DXFOUqU_.js.map

package/standard-pipeline-DXFOUqU_.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"standard-pipeline-DXFOUqU_.js","sources":["../src/material/standard/standard-template.ts","../src/material/standard/standard-pipeline.ts"],"sourcesContent":["/**\n * Standard Base Template\n *\n * Provides the base Standard (Blinn-Phong) shader structure with slot markers.\n * Parameterized by feature configuration (textures, UV, shadow, reflection, fog).\n *\n * The Standard material uses 3 separate UBOs in group 1:\n *   binding 0: mesh UBO (world matrix)\n *   binding 1: material UBO (colors, levels)\n * Plus optional texture/sampler bindings at fixed slots.\n */\n\nimport type { ShaderTemplate, UboField, VertexAttribute, Varying, BindingDecl } from \"../../shader/fragment-types.js\";\nimport { WGSL_FOG } from \"../../shader/wgsl-helpers.js\";\nimport { MAX_LIGHTS } from \"../../light/types.js\";\nimport { appendMeshLightUboFields, meshLightIndexWGSL } from \"../../render/lights-ubo.js\";\n\nconst STAGE_VERTEX = 0x1;\nconst STAGE_FRAGMENT = 0x2;\n\n// ── Lighting function (always present unless disableLighting) ───\n\nconst LIGHTING_FN = `\nfn computeLighting(viewDir: vec3<f32>, N: vec3<f32>, L: LightEntry, g: f32, P: vec3<f32>) -> array<vec3<f32>, 2> {\nvar lv: vec3<f32>;\nvar a: f32 = 1.0;\nlet t = u32(L.vLightData.w);\nif (t == 3u) {\nlet nl = 0.5 + 0.5 * dot(N, normalize(L.vLightData.xyz));\nlet diff = mix(L.vLightDirection.xyz, L.vLightDiffuse.rgb, nl);\nlet h = normalize(viewDir + normalize(L.vLightData.xyz));\nvar s = pow(max(0.0, dot(N, h)), max(1.0, g));\nreturn array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb);\n}\nif (t == 1u) {\nlv = normalize(-L.vLightData.xyz);\n} else {\nlet d = L.vLightData.xyz - P;\na = max(0.0, 1.0 - length(d) / L.vLightDiffuse.a);\nlv = normalize(d);\nif (t == 2u) {\nlet c = max(0.0, dot(L.vLightDirection.xyz, -lv));\nif (c >= L.vLightDirection.w) { a *= max(0.0, pow(c, L.vLightSpecular.a)); } else { a = 0.0; }\n}\n}\nlet nl = max(0.0, dot(N, lv));\nlet diff = nl * L.vLightDiffuse.rgb * a;\nlet h = normalize(viewDir + lv);\nvar s = max(0.0, dot(N, h));\ns = pow(s, max(1.0, g));\nreturn array<vec3<f32>, 2>(diff, s * L.vLightSpecular.rgb * a);\n}\n`;\n\nexport interface StandardTemplateConfig {\n    /** @internal */\n    readonly _diffuse?: boolean;\n    /** @internal UV coordinate channels used */\n    readonly _needsUV: boolean;\n    /** @internal */\n    readonly _needsUV2: boolean;\n    /** @internal */\n    readonly _diffuseUsesUV2?: boolean;\n    /** @internal Disable lighting (unlit material) */\n    readonly _disableLighting?: boolean;\n    /** @internal Generate a fragment stage that runs discard/alpha-test logic and writes no color. */\n    readonly _noColorOutput?: boolean;\n    /** @internal Generate a fragment stage that runs discard/alpha-test logic and writes ESM shadow color. */\n    readonly _esmShadowOutput?: boolean;\n}\n\n/**\n * Create a Standard material ShaderTemplate from configuration.\n * The template contains slot markers that the composer fills.\n */\nexport function createStandardTemplate(config: StandardTemplateConfig, esmShadowDepthCode = \"\"): ShaderTemplate {\n    const { _diffuse, _needsUV, _needsUV2, _diffuseUsesUV2, _disableLighting, _noColorOutput, _esmShadowOutput } = config;\n\n    // ── Base vertex attributes ──────────────────────────────────\n    const _baseVertexAttributes: VertexAttribute[] = [\n        { _name: \"position\", _type: \"vec3<f32>\", _gpuFormat: \"float32x3\", _arrayStride: 12 },\n        { _name: \"normal\", _type: \"vec3<f32>\", _gpuFormat: \"float32x3\", _arrayStride: 12 },\n    ];\n    if (_needsUV) {\n        _baseVertexAttributes.push({ _name: \"uv\", _type: \"vec2<f32>\", _gpuFormat: \"float32x2\", _arrayStride: 8 });\n    }\n    if (_needsUV2) {\n        _baseVertexAttributes.push({ _name: \"uv2\", _type: \"vec2<f32>\", _gpuFormat: \"float32x2\", _arrayStride: 8 });\n    }\n\n    // ── Base varyings ───────────────────────────────────────────\n    const _baseVaryings: Varying[] = [\n        { _name: \"vp\", _type: \"vec3<f32>\" },\n        { _name: \"vn\", _type: \"vec3<f32>\" },\n        { _name: \"vf\", _type: \"vec3<f32>\" },\n    ];\n    if (_needsUV) {\n        _baseVaryings.push({ _name: \"vu\", _type: \"vec2<f32>\" });\n    }\n    if (_needsUV2) {\n        _baseVaryings.push({ _name: \"vv\", _type: \"vec2<f32>\" });\n    }\n    // shadow varyings (vPositionFromLight, vDepthMetric) are provided by std-shadow-fragment\n\n    // ── Base UBO fields (mesh = world matrix + affected light indices) ──────────────\n    const _baseMeshUboFields: UboField[] = [{ _name: \"world\", _type: \"mat4x4<f32>\" }];\n    appendMeshLightUboFields(_baseMeshUboFields);\n\n    // ── Base bindings (group 1, starting after mesh UBO at 0) ───\n    // Order: material, diffuse*, shadow/UV*, emissive*, bump*, specular*, ambient*, lightmap*, opacity*, reflection*\n    // The shadow/UV UBO is placed AFTER diffuse so its auto-assigned binding index\n    // matches the conventional slot 5 when diffuse is present (bindings 3,4).\n    const _baseBindings: BindingDecl[] = [{ _name: \"mat\", _type: { _kind: \"uniform-buffer\" }, _visibility: STAGE_FRAGMENT }];\n\n    if (_diffuse) {\n        _baseBindings.push(\n            { _name: \"dT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"dS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT }\n        );\n    }\n    // UV params UBO — only when UVs are actually emitted.\n    if (_needsUV) {\n        _baseBindings.push({ _name: \"up\", _type: { _kind: \"uniform-buffer\" }, _visibility: STAGE_VERTEX });\n    }\n    if (_esmShadowOutput) {\n        _baseBindings.push({ _name: \"shadowParams\", _type: { _kind: \"uniform-buffer\" }, _visibility: STAGE_FRAGMENT });\n    }\n    // bump bindings are provided by the normal-map fragment (not baseBindings)\n    // emissive, specular, ambient, lightmap, opacity, reflection bindings\n    // are provided by their respective fragments (not baseBindings)\n\n    // Shadow map bindings (group 2) are provided by std-shadow-fragment\n\n    // ── Vertex template ─────────────────────────────────────────\n\n    const uvPassthrough = _needsUV ? `out.vu = uv * up.u.xy + up.u.zw;` : \"\";\n\n    const uv2Passthrough = _needsUV2 ? `out.vv = uv2;` : \"\";\n\n    // Vertex UBO struct definitions (must be before binding declarations)\n    const vertexUboStructs = _needsUV ? `struct upUniforms { u: vec4<f32>, }` : \"\";\n\n    const _vertexTemplate = `/*SU*/\n/*MU*/\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n${vertexUboStructs}\n/*VH*/\n/*VD*/\n/*VO*/\n@vertex fn main(\n/*VP*/\n) -> VertexOutput {\nvar out: VertexOutput;\n/*VR*/\nvar finalWorld = mesh.world;\n/*VW*/\nlet worldPos4 = finalWorld * vec4<f32>(position, 1.0);\nout.vp = worldPos4.xyz;\nlet normalWorld = mat3x3<f32>(finalWorld[0].xyz, finalWorld[1].xyz, finalWorld[2].xyz);\nout.vn = normalize(normalWorld * normal);\nout.clipPos = scene.viewProjection * worldPos4;\nout.vf = (scene.view * worldPos4).xyz;\n${uvPassthrough}\n${uv2Passthrough}\n/*VB*/\nreturn out;\n}`;\n\n    // ── Fragment template ────────────────────────────────────────\n\n    const lightsStructs = `\nstruct LightEntry { vLightData: vec4<f32>, vLightDiffuse: vec4<f32>, vLightSpecular: vec4<f32>, vLightDirection: vec4<f32> };\nstruct lightsUniforms { count: u32, _p0: u32, _p1: u32, _p2: u32, lights: array<LightEntry, ${MAX_LIGHTS}> };\n@group(0) @binding(1) var<uniform> lights: lightsUniforms;\n`;\n\n    const materialStruct = `\nstruct matUniforms {\ndc: vec4<f32>,\nsc: vec4<f32>,\nec: vec3<f32>,\nbs: f32,\nac: vec3<f32>,\ntl: f32,\nambTexLvl: f32,\nlmLvl: f32,\nopLvl: f32,\naCut: f32,\nrLvl: f32,\nrCm: f32,\n_0: f32,\n_1: f32,\n};\n`;\n\n    const helpers = _disableLighting ? WGSL_FOG : WGSL_FOG + LIGHTING_FN;\n    // reflection, shadow, bump helpers are provided by their respective fragments\n\n    // Main fragment body — mirrors old composeFragmentShader exactly\n    const doubleSidedEntry = `@fragment fn main(input: FragmentInput)${_noColorOutput ? \"\" : \" -> @location(0) vec4<f32>\"} {`;\n\n    // View direction\n    const viewDirCode = !_disableLighting ? `let viewDirectionW = normalize(scene.vEyePosition.xyz - input.vp);` : \"\";\n\n    // Normal computation — fragment can override via AC slot\n    const normalCode = _disableLighting ? \"\" : `var normalW = normalize(input.vn);`;\n\n    // Opacity — default from material alpha, fragment can modify via AT\n    const opacityCode = `var alpha = mat.dc.a;`;\n\n    // Base color + alpha test. Texture alpha used for discard only (not blended into output alpha),\n    // matching BJS ALPHATEST without ALPHAFROMDIFFUSE.\n    const baseColorCode = _diffuse\n        ? `let _ds = textureSample(dT, dS, ${_diffuseUsesUV2 ? \"input.vv\" : \"input.vu\"});\nif (_ds.a < mat.aCut) { discard; }\nvar baseColor = _ds.rgb * mat.tl;`\n        : `var baseColor = vec3<f32>(1.0, 1.0, 1.0);`;\n\n    // Diffuse color + emissive + specular — defaults, fragments can override via AT\n    const diffuseColorCode = `let diffuseColor = mat.dc.rgb;`;\n    const emissiveCode = `var emissiveContrib = mat.ec;`;\n    const specularColorCode = !_disableLighting ? `var specularColor = mat.sc.rgb;` : \"\";\n    // Lighting block (only when lighting enabled)\n    let lightingBlock: string;\n    if (!_disableLighting) {\n        // Shadow — default to 1.0, fragment overrides via AD slot\n        // shadowFactors array is populated by std-shadow-fragment (one per light index)\n        lightingBlock = `var glossiness = mat.sc.a;\nvar diffuseBase = vec3<f32>(0.0);\nvar specularBase = vec3<f32>(0.0);\nvar shadowFactors = array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill(\"1.0\").join(\", \")});\nvar baseAmbientColor = vec3<f32>(1.0, 1.0, 1.0);\nvar reflectionColor = vec3<f32>(0.0);\nlet lc = min(mesh.lc, ${MAX_LIGHTS}u);\n/*AD*/\nfor (var li = 0u; li < lc; li++) {\nlet lightIndex = mli(li);\nlet r = computeLighting(viewDirectionW, normalW, lights.lights[lightIndex], glossiness, input.vp);\nlet sf = shadowFactors[lightIndex];\ndiffuseBase += r[0] * sf;\nspecularBase += r[1] * sf;\n}\nlet finalDiffuse = clamp(diffuseBase * diffuseColor + emissiveContrib + mat.ac, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor;\nlet finalSpecular = specularBase * specularColor;\nvar color = vec4<f32>(finalDiffuse * baseAmbientColor + finalSpecular + reflectionColor, alpha);`;\n    } else {\n        lightingBlock = `var color = vec4<f32>(clamp(emissiveContrib * diffuseColor, vec3<f32>(0.0), vec3<f32>(1.0)) * baseColor, alpha);`;\n    }\n\n    const _fragmentTemplate = `/*SU*/\n${lightsStructs}\n${materialStruct}\n${_esmShadowOutput ? \"struct shadowParamsUniforms { biasAndScale: vec4<f32>, depthValues: vec4<f32>, }\" : \"\"}\n/*MU*/\n@group(1) @binding(0) var<uniform> mesh: MeshUniforms;\n${!_disableLighting ? meshLightIndexWGSL(\"mesh\") : \"\"}\n${helpers}\n/*HF*/\n/*FB*/\n/*FI*/\n${doubleSidedEntry}\n/*SV*/\n${viewDirCode}\n${normalCode}\n/*AC*/\n${opacityCode}\n${baseColorCode}\n${diffuseColorCode}\n${emissiveCode}\n${specularColorCode}\n/*AT*/\n${_noColorOutput ? \"return;\" : _esmShadowOutput ? esmShadowDepthCode : \"\"}\n${lightingBlock}\n/*BC*/\ncolor = vec4<f32>(max(color.rgb, vec3<f32>(0.0)), color.a);\nif (scene.vFogInfos.x > 0.0) {\nlet fog = calcFogFactor(input.vf);\ncolor = vec4<f32>(mix(scene.vFogColor.rgb, color.rgb, fog), color.a);\n}\n/*BA*/\n${_noColorOutput ? \"\" : \"return color;\"}\n}`;\n\n    return {\n        _vertexTemplate,\n        _fragmentTemplate,\n        _baseMeshUboFields,\n        _baseVertexAttributes,\n        _baseVaryings,\n        _baseBindings,\n    };\n}\n","/** Dynamic StandardMaterial pipeline builder — creates and caches GPU render\n *  pipelines based on per-material feature flags.\n *\n *  Feature flags (bitmask):\n *    HAS_DIFFUSE_TEXTURE  — diffuse texture sampling + UV attribute\n *    HAS_EMISSIVE_TEXTURE — emissive texture sampling + UV attribute\n *  Derived flag (computed automatically):\n *    NEEDS_UV = HAS_DIFFUSE_TEXTURE | HAS_EMISSIVE_TEXTURE\n *\n *  Pipelines are cached per (features, format, msaaSamples) tuple.\n *  Shared scene UBO layout is identical across all variants (176 bytes). */\n\nimport { F32 } from \"../../engine/typed-arrays.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport type { StandardMaterialProps } from \"./standard-material.js\";\nimport { _standardFeatureKey } from \"./standard-material.js\";\nimport { getSceneBindGroupLayout, clearSceneBGLCache } from \"../../render/scene-helpers.js\";\nimport { createStandardTemplate } from \"./standard-template.js\";\nimport { composeShader } from \"../../shader/shader-composer.js\";\nimport type { ComposedShader, ShaderFragment } from \"../../shader/fragment-types.js\";\nimport { createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { REVERSE_DEPTH_COMPARE, targetSignatureKey } from \"../../engine/render-target.js\";\nimport {\n    DIFFUSE_USES_UV2,\n    DISABLE_LIGHTING,\n    DOUBLE_SIDED,\n    HAS_DIFFUSE_TEXTURE,\n    HAS_OPACITY_TEXTURE,\n    MATERIAL_ALPHA_BLEND,\n    NEEDS_UV,\n    NEEDS_UV2,\n    NO_COLOR_OUTPUT,\n    ESM_SHADOW_OUTPUT,\n    _getStdExtsSorted,\n} from \"./standard-flags.js\";\nimport { MSH_RECEIVE_SHADOWS } from \"../mesh-features.js\";\n\n// ─── Composer Path (Phase 1) ────────────────────────────────────────\n// Converts feature bitmask → StandardTemplateConfig → ComposedShader.\n// This produces identical WGSL to the old string-builder path but via\n// the generic composer, enabling fragment-based extensions in Phase 2.\n\n/** Compose Standard shader via the generic ShaderComposer.\n *  @param fragments - Optional extra fragments (e.g. thin-instance). */\nexport function composeStandardShader(features: number, _meshFeatures = 0, fragments: ShaderFragment[] = [], esmShadowDepthCode = \"\"): ComposedShader {\n    const has = (bit: number) => (features & bit) !== 0;\n    const template = createStandardTemplate(\n        {\n            _diffuse: has(HAS_DIFFUSE_TEXTURE),\n            _needsUV: has(NEEDS_UV),\n            _needsUV2: has(NEEDS_UV2),\n            _diffuseUsesUV2: has(DIFFUSE_USES_UV2),\n            _disableLighting: has(DISABLE_LIGHTING),\n            _noColorOutput: has(NO_COLOR_OUTPUT),\n            _esmShadowOutput: has(ESM_SHADOW_OUTPUT),\n        },\n        esmShadowDepthCode\n    );\n    return composeShader(template, fragments);\n}\n\n// ─── Shader Bindings (sig-independent) ──────────────────────────────\n\n/** Cached per-(features, fragments) shader bindings: BGLs + composed shader +\n *  per-sig pipeline cache. Created once at renderable build time, shared across\n *  all sig-specific pipelines. */\nexport interface StandardShaderBindings {\n    /** @internal */\n    _features: number;\n    /** @internal */\n    _meshFeatures: number;\n    /** @internal */\n    _meshBGL: GPUBindGroupLayout;\n    /** @internal */\n    _shadowBGL: GPUBindGroupLayout | null;\n    /** @internal */\n    _composed: ComposedShader;\n    /** @internal Per-sig pipeline cache. Key = `targetSignatureKey(sig)`. */\n    _pipelines: Map<string, GPURenderPipeline>;\n}\n\n// ─── Caches ─────────────────────────────────────────────────────────\n\n/** Per-(features:fk) shader bindings cache (sig-independent). */\nconst _bindingsCache = new Map<string, StandardShaderBindings>();\nlet _composedCache: Map<string, ComposedShader> | null = null;\nlet _cachedDevice: GPUDevice | null = null;\n\nfunction getComposedCache(): Map<string, ComposedShader> {\n    if (!_composedCache) {\n        _composedCache = new Map();\n    }\n    return _composedCache;\n}\n\nfunction ensureDevice(engine: EngineContext): void {\n    if (_cachedDevice !== engine._device) {\n        _bindingsCache.clear();\n        _composedCache?.clear();\n        clearSceneBGLCache();\n        _cachedDevice = engine._device;\n    }\n}\n\n/** Clear the pipeline cache. Must be called when a GPU device is destroyed. */\nexport function clearStandardPipelineCache(): void {\n    _bindingsCache.clear();\n    _composedCache?.clear();\n    clearSceneBGLCache();\n    _cachedDevice = null;\n}\n\n/** Get-or-build the sig-independent shader bindings for a given feature/fragment set.\n *  Used at renderable build time so per-mesh bind groups can be created BEFORE the\n *  first bind() call (when sig is known). */\nexport function getOrCreateStandardBindings(\n    engine: EngineContext,\n    features: number,\n    meshFeatures: number,\n    fragments: ShaderFragment[] = [],\n    shaderKey = \"\",\n    esmShadowDepthCode = \"\"\n): StandardShaderBindings {\n    ensureDevice(engine);\n    const key = _standardFeatureKey(features, meshFeatures, shaderKey);\n    const cached = _bindingsCache.get(key);\n    if (cached) {\n        return cached;\n    }\n\n    const cc = getComposedCache();\n    let composed = cc.get(key);\n    if (!composed) {\n        composed = composeStandardShader(features, meshFeatures, fragments, esmShadowDepthCode);\n        cc.set(key, composed);\n    }\n\n    const device = engine._device;\n    const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);\n    let shadowBGL: GPUBindGroupLayout | null = null;\n    const hasShadow = (meshFeatures & MSH_RECEIVE_SHADOWS) !== 0;\n    if (hasShadow && composed._shadowBGLDescriptor) {\n        shadowBGL = device.createBindGroupLayout(composed._shadowBGLDescriptor);\n    }\n\n    const bindings: StandardShaderBindings = {\n        _features: features,\n        _meshFeatures: meshFeatures,\n        _meshBGL: meshBGL,\n        _shadowBGL: shadowBGL,\n        _composed: composed,\n        _pipelines: new Map(),\n    };\n    _bindingsCache.set(key, bindings);\n    return bindings;\n}\n\n/** Get-or-build a sig-specific pipeline on top of a shader bindings. Called at bind() time. */\nexport function getOrCreateStandardPipeline(engine: EngineContext, sig: RenderTargetSignature, bindings: StandardShaderBindings): GPURenderPipeline {\n    ensureDevice(engine);\n    const key = targetSignatureKey(sig);\n    const cached = bindings._pipelines.get(key);\n    if (cached) {\n        return cached;\n    }\n\n    const device = engine._device;\n    const composed = bindings._composed;\n    const features = bindings._features;\n    const sceneBGL = getSceneBindGroupLayout(engine);\n    const bgls: GPUBindGroupLayout[] = bindings._shadowBGL ? [sceneBGL, bindings._meshBGL, bindings._shadowBGL] : [sceneBGL, bindings._meshBGL];\n\n    const vertModule = device.createShaderModule({ code: composed._vertexWGSL });\n    const noColorOutput = (features & NO_COLOR_OUTPUT) !== 0;\n    const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;\n    const fragModule = !sig._colorFormat && !noColorOutput ? null : device.createShaderModule({ code: composed._fragmentWGSL });\n\n    const needsBlend = !esmShadowOutput && ((features & HAS_OPACITY_TEXTURE) !== 0 || (features & MATERIAL_ALPHA_BLEND) !== 0);\n    const colorTarget: GPUColorTargetState | null = noColorOutput\n        ? null\n        : needsBlend\n          ? {\n                format: sig._colorFormat!,\n                blend: {\n                    color: { srcFactor: \"src-alpha\", dstFactor: \"one-minus-src-alpha\" },\n                    alpha: { srcFactor: \"one\", dstFactor: \"one-minus-src-alpha\" },\n                },\n            }\n          : { format: sig._colorFormat! };\n\n    const pipeline = device.createRenderPipeline({\n        layout: device.createPipelineLayout({ bindGroupLayouts: bgls }),\n        vertex: { module: vertModule, entryPoint: \"main\", buffers: composed._vertexBufferLayouts },\n        ...(fragModule ? { fragment: { module: fragModule, entryPoint: \"main\", targets: colorTarget ? [colorTarget] : [] } } : {}),\n        ...(sig._depthStencilFormat\n            ? {\n                  depthStencil: {\n                      format: sig._depthStencilFormat,\n                      depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,\n                      depthWriteEnabled: noColorOutput || esmShadowOutput || !needsBlend,\n                  },\n              }\n            : {}),\n        multisample: { count: sig._sampleCount },\n        primitive: { topology: \"triangle-list\", cullMode: features & DOUBLE_SIDED ? \"none\" : \"back\", frontFace: \"ccw\" },\n    });\n\n    bindings._pipelines.set(key, pipeline);\n    return pipeline;\n}\n\n// ─── Per-Mesh GPU Setup ─────────────────────────────────────────────\n\n/** Build the per-mesh material bind group (group 1). The mesh UBO\n *  and material UBO are created/owned by the caller — this\n *  function only assembles the bind group entries that match the composer's\n *  binding layout.\n *\n *  Mirrors `createPbrMeshBindGroup` in pbr-pipeline.ts. */\nexport function createStandardMeshBindGroup(\n    engine: EngineContext,\n    bindings: StandardShaderBindings,\n    meshUBO: GPUBuffer,\n    materialUBO: GPUBuffer,\n    material: StandardMaterialProps\n): GPUBindGroup {\n    const device = engine._device;\n    const features = bindings._features;\n    const needsUV = (features & NEEDS_UV) !== 0;\n    const hasDiffuseTex = (features & HAS_DIFFUSE_TEXTURE) !== 0;\n    const esmShadowOutput = (features & ESM_SHADOW_OUTPUT) !== 0;\n\n    // Sequential numbering matches composer output.\n    let nextBinding = 0;\n    const entries: GPUBindGroupEntry[] = [\n        { binding: nextBinding++, resource: { buffer: meshUBO } },\n        { binding: nextBinding++, resource: { buffer: materialUBO } },\n    ];\n\n    if (hasDiffuseTex) {\n        const tex = material.diffuseTexture!;\n        entries.push({ binding: nextBinding++, resource: tex.texture.createView() }, { binding: nextBinding++, resource: tex.sampler });\n    }\n\n    // UV params UBO (only when UVs are actually emitted).\n    if (needsUV) {\n        const uvData = new F32(4);\n        const scaleX = material.uvScale[0];\n        let scaleY = material.uvScale[1];\n        let offsetY = 0;\n        // Flip V for y-down source data (e.g. basis/compressed textures).\n        // uv * (sx, sy) + (ox, oy) with vFlip becomes uv.xy * (sx, -sy) + (ox, sy+oy).\n        if (material.diffuseTexture?.invertY) {\n            offsetY = scaleY;\n            scaleY = -scaleY;\n        }\n        uvData[0] = scaleX;\n        uvData[1] = scaleY;\n        uvData[2] = 0;\n        uvData[3] = offsetY;\n        entries.push({ binding: nextBinding++, resource: { buffer: createUniformBuffer(engine, uvData) } });\n    }\n\n    if (esmShadowOutput) {\n        entries.push({\n            binding: nextBinding++,\n            resource: { buffer: (material as StandardMaterialProps & { readonly _esmShadowParamsUBO: GPUBuffer })._esmShadowParamsUBO },\n        });\n    }\n\n    // Fragment-contributed bindings — iterate ext registry in alphabetical id order\n    // to match composer's fragment sort order.\n    const sortedExts = _getStdExtsSorted();\n    for (const ext of sortedExts) {\n        if (features & ext._feature && ext._bind) {\n            nextBinding = ext._bind(material, entries, nextBinding);\n        }\n    }\n\n    return device.createBindGroup({ layout: bindings._meshBGL, entries });\n}\n\n// ─── Internal Helpers ───────────────────────────────────────────────\n\n/** Write standard material properties into a pre-allocated Float32Array (24 floats). */\nexport function writeStdMaterialData(data: Float32Array, mat: StandardMaterialProps, textureLevel: number): void {\n    const { diffuseColor: dc, specularColor: sc, emissiveColor: ec, ambientColor: ac } = mat;\n    data[0] = dc[0];\n    data[1] = dc[1];\n    data[2] = dc[2];\n    data[3] = mat.alpha;\n    data[4] = sc[0];\n    data[5] = sc[1];\n    data[6] = sc[2];\n    data[7] = mat.specularPower;\n    data[8] = ec[0];\n    data[9] = ec[1];\n    data[10] = ec[2];\n    data[11] = 1.0 / mat.bumpLevel;\n    data[12] = ac[0];\n    data[13] = ac[1];\n    data[14] = ac[2];\n    data[15] = textureLevel;\n    data[16] = mat.ambientTexLevel;\n    data[17] = mat.lightmapLevel;\n    data[18] = mat.opacityLevel;\n    data[19] = mat.alphaCutOff;\n    data[20] = mat.reflectionLevel;\n    data[21] = mat.reflectionCoordMode;\n}\n"],"names":[],"mappings":";;;AAiBA,MAAM,eAAe;AACrB,MAAM,iBAAiB;AAIvB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqDb,SAAS,uBAAuB,QAAgC,qBAAqB,IAAoB;AAC5G,QAAM,EAAE,UAAU,UAAU,WAAW,iBAAiB,kBAAkB,gBAAgB,qBAAqB;AAG/G,QAAM,wBAA2C;AAAA,IAC7C,EAAE,OAAO,YAAY,OAAO,aAAa,YAAY,aAAa,cAAc,GAAA;AAAA,IAChF,EAAE,OAAO,UAAU,OAAO,aAAa,YAAY,aAAa,cAAc,GAAA;AAAA,EAAG;AAErF,MAAI,UAAU;AACV,0BAAsB,KAAK,EAAE,OAAO,MAAM,OAAO,aAAa,YAAY,aAAa,cAAc,EAAA,CAAG;AAAA,EAC5G;AACA,MAAI,WAAW;AACX,0BAAsB,KAAK,EAAE,OAAO,OAAO,OAAO,aAAa,YAAY,aAAa,cAAc,EAAA,CAAG;AAAA,EAC7G;AAGA,QAAM,gBAA2B;AAAA,IAC7B,EAAE,OAAO,MAAM,OAAO,YAAA;AAAA,IACtB,EAAE,OAAO,MAAM,OAAO,YAAA;AAAA,IACtB,EAAE,OAAO,MAAM,OAAO,YAAA;AAAA,EAAY;AAEtC,MAAI,UAAU;AACV,kBAAc,KAAK,EAAE,OAAO,MAAM,OAAO,aAAa;AAAA,EAC1D;AACA,MAAI,WAAW;AACX,kBAAc,KAAK,EAAE,OAAO,MAAM,OAAO,aAAa;AAAA,EAC1D;AAIA,QAAM,qBAAiC,CAAC,EAAE,OAAO,SAAS,OAAO,eAAe;AAChF,2BAAyB,kBAAkB;AAM3C,QAAM,gBAA+B,CAAC,EAAE,OAAO,OAAO,OAAO,EAAE,OAAO,iBAAA,GAAoB,aAAa,eAAA,CAAgB;AAEvH,MAAI,UAAU;AACV,kBAAc;AAAA,MACV,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC1F,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAAA,EAEzG;AAEA,MAAI,UAAU;AACV,kBAAc,KAAK,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,iBAAA,GAAoB,aAAa,aAAA,CAAc;AAAA,EACrG;AACA,MAAI,kBAAkB;AAClB,kBAAc,KAAK,EAAE,OAAO,gBAAgB,OAAO,EAAE,OAAO,iBAAA,GAAoB,aAAa,eAAA,CAAgB;AAAA,EACjH;AASA,QAAM,gBAAgB,WAAW,qCAAqC;AAEtE,QAAM,iBAAiB,YAAY,kBAAkB;AAGrD,QAAM,mBAAmB,WAAW,wCAAwC;AAE5E,QAAM,kBAAkB;AAAA;AAAA;AAAA,EAG1B,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBhB,aAAa;AAAA,EACb,cAAc;AAAA;AAAA;AAAA;AAOZ,QAAM,gBAAgB;AAAA;AAAA,8FAEoE,UAAU;AAAA;AAAA;AAIpG,QAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBvB,QAAM,UAAU,mBAAmB,WAAW,WAAW;AAIzD,QAAM,mBAAmB,0CAA0C,iBAAiB,KAAK,4BAA4B;AAGrH,QAAM,cAAc,CAAC,mBAAmB,uEAAuE;AAG/G,QAAM,aAAa,mBAAmB,KAAK;AAG3C,QAAM,cAAc;AAIpB,QAAM,gBAAgB,WAChB,mCAAmC,kBAAkB,aAAa,UAAU;AAAA;AAAA,qCAG5E;AAGN,QAAM,mBAAmB;AACzB,QAAM,eAAe;AACrB,QAAM,oBAAoB,CAAC,mBAAmB,oCAAoC;AAElF,MAAI;AACJ,MAAI,CAAC,kBAAkB;AAGnB,oBAAgB;AAAA;AAAA;AAAA,iCAGS,UAAU,KAAK,IAAI,MAAM,UAAU,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,CAAC;AAAA;AAAA;AAAA,wBAGpE,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAY9B,OAAO;AACH,oBAAgB;AAAA,EACpB;AAEA,QAAM,oBAAoB;AAAA,EAC5B,aAAa;AAAA,EACb,cAAc;AAAA,EACd,mBAAmB,qFAAqF,EAAE;AAAA;AAAA;AAAA,EAG1G,CAAC,mBAAmB,mBAAmB,MAAM,IAAI,EAAE;AAAA,EACnD,OAAO;AAAA;AAAA;AAAA;AAAA,EAIP,gBAAgB;AAAA;AAAA,EAEhB,WAAW;AAAA,EACX,UAAU;AAAA;AAAA,EAEV,WAAW;AAAA,EACX,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,iBAAiB;AAAA;AAAA,EAEjB,iBAAiB,YAAY,mBAAmB,qBAAqB,EAAE;AAAA,EACvE,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQb,iBAAiB,KAAK,eAAe;AAAA;AAGnC,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAER;ACtPO,SAAS,sBAAsB,UAAkB,gBAAgB,GAAG,YAA8B,CAAA,GAAI,qBAAqB,IAAoB;AAClJ,QAAM,MAAM,CAAC,SAAiB,WAAW,SAAS;AAClD,QAAM,WAAW;AAAA,IACb;AAAA,MACI,UAAU,IAAI,mBAAmB;AAAA,MACjC,UAAU,IAAI,QAAQ;AAAA,MACtB,WAAW,IAAI,SAAS;AAAA,MACxB,iBAAiB,IAAI,gBAAgB;AAAA,MACrC,kBAAkB,IAAI,gBAAgB;AAAA,MACtC,gBAAgB,IAAI,eAAe;AAAA,MACnC,kBAAkB,IAAI,iBAAiB;AAAA,IAAA;AAAA,IAE3C;AAAA,EAAA;AAEJ,SAAO,cAAc,UAAU,SAAS;AAC5C;AAyBA,MAAM,qCAAqB,IAAA;AAC3B,IAAI,iBAAqD;AACzD,IAAI,gBAAkC;AAEtC,SAAS,mBAAgD;AACrD,MAAI,CAAC,gBAAgB;AACjB,yCAAqB,IAAA;AAAA,EACzB;AACA,SAAO;AACX;AAEA,SAAS,aAAa,QAA6B;AAC/C,MAAI,kBAAkB,OAAO,SAAS;AAClC,mBAAe,MAAA;AACf,qDAAgB;AAChB,uBAAA;AACA,oBAAgB,OAAO;AAAA,EAC3B;AACJ;AAGO,SAAS,6BAAmC;AAC/C,iBAAe,MAAA;AACf,mDAAgB;AAChB,qBAAA;AACA,kBAAgB;AACpB;AAKO,SAAS,4BACZ,QACA,UACA,cACA,YAA8B,CAAA,GAC9B,YAAY,IACZ,qBAAqB,IACC;AACtB,eAAa,MAAM;AACnB,QAAM,MAAM,oBAAoB,UAAU,cAAc,SAAS;AACjE,QAAM,SAAS,eAAe,IAAI,GAAG;AACrC,MAAI,QAAQ;AACR,WAAO;AAAA,EACX;AAEA,QAAM,KAAK,iBAAA;AACX,MAAI,WAAW,GAAG,IAAI,GAAG;AACzB,MAAI,CAAC,UAAU;AACX,eAAW,sBAAsB,UAAU,cAAc,WAAW,kBAAkB;AACtF,OAAG,IAAI,KAAK,QAAQ;AAAA,EACxB;AAEA,QAAM,SAAS,OAAO;AACtB,QAAM,UAAU,OAAO,sBAAsB,SAAS,kBAAkB;AACxE,MAAI,YAAuC;AAC3C,QAAM,aAAa,eAAe,yBAAyB;AAC3D,MAAI,aAAa,SAAS,sBAAsB;AAC5C,gBAAY,OAAO,sBAAsB,SAAS,oBAAoB;AAAA,EAC1E;AAEA,QAAM,WAAmC;AAAA,IACrC,WAAW;AAAA,IACX,eAAe;AAAA,IACf,UAAU;AAAA,IACV,YAAY;AAAA,IACZ,WAAW;AAAA,IACX,gCAAgB,IAAA;AAAA,EAAI;AAExB,iBAAe,IAAI,KAAK,QAAQ;AAChC,SAAO;AACX;AAGO,SAAS,4BAA4B,QAAuB,KAA4B,UAAqD;AAChJ,eAAa,MAAM;AACnB,QAAM,MAAM,mBAAmB,GAAG;AAClC,QAAM,SAAS,SAAS,WAAW,IAAI,GAAG;AAC1C,MAAI,QAAQ;AACR,WAAO;AAAA,EACX;AAEA,QAAM,SAAS,OAAO;AACtB,QAAM,WAAW,SAAS;AAC1B,QAAM,WAAW,SAAS;AAC1B,QAAM,WAAW,wBAAwB,MAAM;AAC/C,QAAM,OAA6B,SAAS,aAAa,CAAC,UAAU,SAAS,UAAU,SAAS,UAAU,IAAI,CAAC,UAAU,SAAS,QAAQ;AAE1I,QAAM,aAAa,OAAO,mBAAmB,EAAE,MAAM,SAAS,aAAa;AAC3E,QAAM,iBAAiB,WAAW,qBAAqB;AACvD,QAAM,mBAAmB,WAAW,uBAAuB;AAC3D,QAAM,aAAa,CAAC,IAAI,gBAAgB,CAAC,gBAAgB,OAAO,OAAO,mBAAmB,EAAE,MAAM,SAAS,eAAe;AAE1H,QAAM,aAAa,CAAC,qBAAqB,WAAW,yBAAyB,MAAM,WAAW,0BAA0B;AACxH,QAAM,cAA0C,gBAC1C,OACA,aACE;AAAA,IACI,QAAQ,IAAI;AAAA,IACZ,OAAO;AAAA,MACH,OAAO,EAAE,WAAW,aAAa,WAAW,sBAAA;AAAA,MAC5C,OAAO,EAAE,WAAW,OAAO,WAAW,sBAAA;AAAA,IAAsB;AAAA,EAChE,IAEJ,EAAE,QAAQ,IAAI,aAAA;AAEtB,QAAM,WAAW,OAAO,qBAAqB;AAAA,IACzC,QAAQ,OAAO,qBAAqB,EAAE,kBAAkB,MAAM;AAAA,IAC9D,QAAQ,EAAE,QAAQ,YAAY,YAAY,QAAQ,SAAS,SAAS,qBAAA;AAAA,IACpE,GAAI,aAAa,EAAE,UAAU,EAAE,QAAQ,YAAY,YAAY,QAAQ,SAAS,cAAc,CAAC,WAAW,IAAI,CAAA,EAAC,EAAE,IAAM,CAAA;AAAA,IACvH,GAAI,IAAI,sBACF;AAAA,MACI,cAAc;AAAA,QACV,QAAQ,IAAI;AAAA,QACZ,cAAc,IAAI,iBAAiB;AAAA,QACnC,mBAAmB,iBAAiB,mBAAmB,CAAC;AAAA,MAAA;AAAA,IAC5D,IAEJ,CAAA;AAAA,IACN,aAAa,EAAE,OAAO,IAAI,aAAA;AAAA,IAC1B,WAAW,EAAE,UAAU,iBAAiB,UAAU,WAAW,eAAe,SAAS,QAAQ,WAAW,MAAA;AAAA,EAAM,CACjH;AAED,WAAS,WAAW,IAAI,KAAK,QAAQ;AACrC,SAAO;AACX;AAUO,SAAS,4BACZ,QACA,UACA,SACA,aACA,UACY;;AACZ,QAAM,SAAS,OAAO;AACtB,QAAM,WAAW,SAAS;AAC1B,QAAM,WAAW,WAAW,cAAc;AAC1C,QAAM,iBAAiB,WAAW,yBAAyB;AAC3D,QAAM,mBAAmB,WAAW,uBAAuB;AAG3D,MAAI,cAAc;AAClB,QAAM,UAA+B;AAAA,IACjC,EAAE,SAAS,eAAe,UAAU,EAAE,QAAQ,UAAQ;AAAA,IACtD,EAAE,SAAS,eAAe,UAAU,EAAE,QAAQ,cAAY;AAAA,EAAE;AAGhE,MAAI,eAAe;AACf,UAAM,MAAM,SAAS;AACrB,YAAQ,KAAK,EAAE,SAAS,eAAe,UAAU,IAAI,QAAQ,WAAA,EAAW,GAAK,EAAE,SAAS,eAAe,UAAU,IAAI,SAAS;AAAA,EAClI;AAGA,MAAI,SAAS;AACT,UAAM,SAAS,IAAI,IAAI,CAAC;AACxB,UAAM,SAAS,SAAS,QAAQ,CAAC;AACjC,QAAI,SAAS,SAAS,QAAQ,CAAC;AAC/B,QAAI,UAAU;AAGd,SAAI,cAAS,mBAAT,mBAAyB,SAAS;AAClC,gBAAU;AACV,eAAS,CAAC;AAAA,IACd;AACA,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,WAAO,CAAC,IAAI;AACZ,YAAQ,KAAK,EAAE,SAAS,eAAe,UAAU,EAAE,QAAQ,oBAAoB,QAAQ,MAAM,EAAA,EAAE,CAAG;AAAA,EACtG;AAEA,MAAI,iBAAiB;AACjB,YAAQ,KAAK;AAAA,MACT,SAAS;AAAA,MACT,UAAU,EAAE,QAAS,SAAiF,oBAAA;AAAA,IAAoB,CAC7H;AAAA,EACL;AAIA,QAAM,aAAa,kBAAA;AACnB,aAAW,OAAO,YAAY;AAC1B,QAAI,WAAW,IAAI,YAAY,IAAI,OAAO;AACtC,oBAAc,IAAI,MAAM,UAAU,SAAS,WAAW;AAAA,IAC1D;AAAA,EACJ;AAEA,SAAO,OAAO,gBAAgB,EAAE,QAAQ,SAAS,UAAU,SAAS;AACxE;AAKO,SAAS,qBAAqB,MAAoB,KAA4B,cAA4B;AAC7G,QAAM,EAAE,cAAc,IAAI,eAAe,IAAI,eAAe,IAAI,cAAc,GAAA,IAAO;AACrF,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,IAAI;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,IAAI;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,CAAC,IAAI,GAAG,CAAC;AACd,OAAK,EAAE,IAAI,GAAG,CAAC;AACf,OAAK,EAAE,IAAI,IAAM,IAAI;AACrB,OAAK,EAAE,IAAI,GAAG,CAAC;AACf,OAAK,EAAE,IAAI,GAAG,CAAC;AACf,OAAK,EAAE,IAAI,GAAG,CAAC;AACf,OAAK,EAAE,IAAI;AACX,OAAK,EAAE,IAAI,IAAI;AACf,OAAK,EAAE,IAAI,IAAI;AACf,OAAK,EAAE,IAAI,IAAI;AACf,OAAK,EAAE,IAAI,IAAI;AACf,OAAK,EAAE,IAAI,IAAI;AACf,OAAK,EAAE,IAAI,IAAI;AACnB;"}

package/standard-renderable-BAc-i-ig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"standard-renderable-BAc-i-ig.js","sources":["../src/material/standard/standard-renderable.ts"],"sourcesContent":["/** Standard mesh renderable — builds Renderables from Mesh + StandardMaterial.\n *\n *  `buildStandardMeshRenderables` does shared per-scene setup, then delegates\n *  per-mesh work to `buildSingleStandardRenderable`. The same single-mesh\n *  function is reused by the material-swap path. */\n\nimport { F32 } from \"../../engine/typed-arrays.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { SceneContext } from \"../../scene/scene.js\";\nimport type { Mesh } from \"../../mesh/mesh.js\";\nimport type { Renderable, MeshGroupBuildResult } from \"../../render/renderable.js\";\nimport { collectStdBoundTextures } from \"./collect-std-bound-textures.js\";\nimport type { StandardMaterialProps } from \"./standard-material.js\";\nimport { _computeStandardMaterialFeatures, _standardShaderVariantKey } from \"./standard-material.js\";\nimport { acquireTexture, releaseTexture, clearSamplerCache } from \"../../resource/gpu-pool.js\";\nimport { createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { getOrCreateStandardBindings, getOrCreateStandardPipeline, createStandardMeshBindGroup, clearStandardPipelineCache, writeStdMaterialData } from \"./standard-pipeline.js\";\nimport { ESM_SHADOW_OUTPUT, NO_COLOR_OUTPUT, NEEDS_UV, NEEDS_UV2, HAS_OPACITY_TEXTURE, _getStdExts } from \"./standard-flags.js\";\nimport type { ShaderFragment } from \"../../shader/fragment-types.js\";\nimport type { ShadowGenerator } from \"../../shadow/shadow-generator.js\";\nimport { writeMeshLightSelection } from \"../../render/lights-ubo.js\";\nimport type { Material, MaterialRenderFeatures } from \"../material.js\";\nimport { _computeMeshFeatures, MSH_HAS_INSTANCE_COLOR, MSH_HAS_THIN_INSTANCES, MSH_RECEIVE_SHADOWS } from \"../mesh-features.js\";\nimport { packMat4IntoF32 } from \"../../math/pack-mat4-into-f32.js\";\n\n/** Scratch buffer for material UBO writes (24 floats = 96 bytes). Reused across\n *  every Standard renderable since binding updates are single-threaded per frame. */\nconst _stdMatScratch = new F32(24);\n\n/** Thin instance GPU sync callback type — loaded dynamically only when needed. */\ntype ThinInstanceSync = (\n    engine: EngineContext,\n    ti: any,\n    pass: GPURenderPassEncoder | GPURenderBundleEncoder,\n    slot: number,\n    hasColor: boolean,\n    drawBuffers?: import(\"../../mesh/thin-instance-gpu.js\").ThinInstanceDrawBuffers | null\n) => number;\n\n/** Fragment factories passed from the async group builder. */\nexport interface StdFragmentFactories {\n    tiSync?: ThinInstanceSync;\n    tiFragment?: (hasColor: boolean) => ShaderFragment;\n    shadowFragment?: (shadowLights: import(\"./fragments/std-shadow-fragment.js\").ShadowLightSlot[]) => ShaderFragment;\n    /** Present only when the scene has at least one culling-enabled thin-instance mesh. */\n    cull?: typeof import(\"../../mesh/thin-instance-cull-binding.js\");\n}\n\n/** Build Renderable(s) + a SceneUniformUpdater for a set of standard meshes.\n *  The `rebuildSingle` closure is reused later (via `_rebuildSingle` on the group\n *  builder) for material swaps + per-pass material overrides. */\nexport function buildStandardMeshRenderables(scene: SceneContext, meshes: Mesh[], factories: StdFragmentFactories): MeshGroupBuildResult {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n    const { tiSync, tiFragment, shadowFragment, cull } = factories;\n\n    // Collect per-light shadow info.\n    const shadowLights: { lightIndex: number; shadowType: \"esm\" | \"pcf\" | \"csm\"; gen: ShadowGenerator }[] = [];\n    for (let i = 0; i < scene.lights.length; i++) {\n        const sg = scene.lights[i]!.shadowGenerator;\n        if (sg) {\n            shadowLights.push({ lightIndex: i, shadowType: sg._shadowType, gen: sg });\n        }\n    }\n    const hasSomeShadows = shadowLights.length > 0;\n\n    // All receiving meshes in this build share the same shadow generators,\n    // so keying the shadow BG by `bindings._shadowBGL` alone is correct.\n    const shadowBGCache = new Map<GPUBindGroupLayout, GPUBindGroup>();\n    // Closure used both for the initial per-mesh build below AND for later\n    // material-swap / per-pass-override rebuilds (set on standardGroupBuilder._rebuildSingle).\n    const rebuildSingle = (s: SceneContext, mesh: Mesh, materialOverride?: Material): Renderable => {\n        const mat = (materialOverride ?? mesh.material) as StandardMaterialProps;\n        const renderFeatures = (mat._renderFeatures ??= { features: _computeStandardMaterialFeatures(mat) }) as MaterialRenderFeatures;\n        const isOverride = materialOverride != null;\n        const features = renderFeatures.features;\n        const shadowOutput = (features & (NO_COLOR_OUTPUT | ESM_SHADOW_OUTPUT)) !== 0;\n        const receiveShadows = !shadowOutput && mesh.receiveShadows && hasSomeShadows;\n        const meshFeatures = _computeMeshFeatures(mesh, receiveShadows);\n        // Build per-feature fragment list (deduped via pipeline cache).\n        const frags: ShaderFragment[] = [];\n        for (const ext of _getStdExts().values()) {\n            if (features & ext._feature) {\n                const f = ext._frag(features);\n                if (f) {\n                    frags.push(f);\n                }\n            }\n        }\n        let shaderKey = \"\";\n        if (meshFeatures & MSH_RECEIVE_SHADOWS && shadowFragment) {\n            const slots = shadowLights.map((sl) => ({ lightIndex: sl.lightIndex, shadowType: sl.shadowType }));\n            shaderKey = _standardShaderVariantKey(slots);\n            frags.push(shadowFragment(slots));\n        }\n        if (meshFeatures & MSH_HAS_THIN_INSTANCES && tiFragment) {\n            const hasColor = !!(meshFeatures & MSH_HAS_INSTANCE_COLOR);\n            const tiFrag = tiFragment(hasColor);\n            if (hasColor) {\n                // Standard applies instance color to final color (BC), not to baseColor (AT) like PBR.\n                const { _fragmentSlots: _fragmentSlots, ...rest } = tiFrag;\n                frags.push({\n                    ...rest,\n                    _fragmentSlots: {\n                        BC: `color = vec4<f32>(color.rgb * input.vInstanceColor.rgb, color.a * input.vInstanceColor.a);`,\n                    },\n                });\n            } else {\n                frags.push(tiFrag);\n            }\n        }\n        const esmShadowDepthCode = (features & ESM_SHADOW_OUTPUT) !== 0 ? (mat as StandardMaterialProps & { readonly _esmShadowDepthCode: string })._esmShadowDepthCode : \"\";\n        const bindings = getOrCreateStandardBindings(engine, features, meshFeatures, frags, shaderKey, esmShadowDepthCode);\n\n        const meshShadowGens = receiveShadows ? shadowLights.map((sl) => sl.gen) : [];\n\n        const meshUboData = new F32(bindings._composed._meshUboSpec._totalBytes / 4);\n        const _packMeshWorld = engine._makePackMeshWorld?.(s as SceneContext) ?? packMat4IntoF32;\n        _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);\n        writeMeshLightSelection(mesh, s.lights, meshUboData);\n        const meshUBO = createUniformBuffer(engine, meshUboData);\n        const textureLevel = (features & NEEDS_UV) !== 0 ? 1.0 : 0;\n        const matData = new F32(24);\n        writeStdMaterialData(matData, mat, textureLevel);\n        const materialUBO = createUniformBuffer(engine, matData);\n        const meshBindGroup = createStandardMeshBindGroup(engine, bindings, meshUBO, materialUBO, mat);\n\n        // Shadow bind group (group 2) — shared across receiving meshes via shadowBGCache.\n        let shadowBindGroup: GPUBindGroup | null = null;\n        if (meshShadowGens.length > 0 && bindings._shadowBGL) {\n            let cached = shadowBGCache.get(bindings._shadowBGL);\n            if (!cached) {\n                const entries: GPUBindGroupEntry[] = [];\n                let b = 0;\n                for (const sg of meshShadowGens) {\n                    entries.push({ binding: b++, resource: sg._depthTexture.createView() });\n                    entries.push({ binding: b++, resource: sg._depthSampler });\n                    entries.push({ binding: b++, resource: { buffer: sg._shadowUBO } });\n                }\n                cached = device.createBindGroup({ layout: bindings._shadowBGL, entries });\n                shadowBGCache.set(bindings._shadowBGL, cached);\n            }\n            shadowBindGroup = cached;\n        }\n\n        const needsUV = (features & NEEDS_UV) !== 0;\n        const needsUV2 = (features & NEEDS_UV2) !== 0;\n        const hasThinInstances = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;\n        const hasInstanceColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;\n        const isTransparent = !shadowOutput && ((features & HAS_OPACITY_TEXTURE) !== 0 || mat.alpha < 1);\n\n        const boundTextures = collectStdBoundTextures(mat);\n        for (const t of boundTextures) {\n            acquireTexture(t);\n        }\n        s._meshDisposables.set(mesh, [\n            () => {\n                for (const t of boundTextures) {\n                    releaseTexture(t);\n                }\n            },\n        ]);\n\n        let _lastWorldVersion = mesh.worldMatrixVersion;\n        let _lastLightsCount = s.lights.length;\n        const sortCenter = [mesh.worldMatrix[12]!, mesh.worldMatrix[13]!, mesh.worldMatrix[14]!] as [number, number, number];\n        const _baseUpdate = (): void => {\n            const worldVersion = mesh.worldMatrixVersion;\n            if (worldVersion !== _lastWorldVersion || s.lights.length !== _lastLightsCount) {\n                sortCenter[0] = mesh.worldMatrix[12]!;\n                sortCenter[1] = mesh.worldMatrix[13]!;\n                sortCenter[2] = mesh.worldMatrix[14]!;\n                _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);\n                writeMeshLightSelection(mesh, s.lights, meshUboData);\n                device.queue.writeBuffer(meshUBO, 0, meshUboData as Float32Array<ArrayBuffer>);\n                _lastWorldVersion = worldVersion;\n                _lastLightsCount = s.lights.length;\n            }\n            const uboVersion = mat._uboVersion;\n            if (uboVersion !== _lastUboVersion) {\n                _lastUboVersion = uboVersion;\n                _stdMatScratch.fill(0);\n                writeStdMaterialData(_stdMatScratch, mat, textureLevel);\n                device.queue.writeBuffer(materialUBO, 0, _stdMatScratch.buffer, 0, 96);\n            }\n        };\n        // FO-version wrapper applied only when the engine has floating-origin\n        // on. The wrapper lives in the dynamic-imported `floating-origin.ts`\n        // module and is the sole owner of `_lastFoVersion` tracking. For\n        // non-LWR engines `_wrapRenderableForFO` is undefined and `update`\n        // is the bare closure — no FO bytes in the closure body.\n        const _invalidate = (): void => {\n            _lastWorldVersion = -1;\n        };\n        const update = engine._wrapRenderableForFO?.(_baseUpdate, s as SceneContext, _invalidate) ?? _baseUpdate;\n\n        const draw = (pass: GPURenderPassEncoder | GPURenderBundleEncoder, cullBinding?: import(\"../../mesh/thin-instance-cull-binding.js\").TiCullBinding): number => {\n            // For per-pass material overrides, skip the mesh.material === mat guard\n            // because the override material is intentionally not the mesh's current one.\n            if (!isOverride && mesh.material !== mat) {\n                return 0;\n            }\n            const g = mesh._gpu;\n            let slot = 0;\n            const vb = g._vbLayout;\n            pass.setVertexBuffer(slot++, g.positionBuffer, vb?._p?._offset);\n            pass.setVertexBuffer(slot++, g.normalBuffer, vb?._n?._offset);\n            if (needsUV) {\n                pass.setVertexBuffer(slot++, g.uvBuffer, vb?._u?._offset);\n            }\n            if (needsUV2 && g.uv2Buffer) {\n                pass.setVertexBuffer(slot++, g.uv2Buffer, vb?._u2?._offset);\n            }\n\n            const ti = hasThinInstances ? mesh.thinInstances : null;\n            if (ti && tiSync) {\n                slot = tiSync(engine, ti, pass, slot, hasInstanceColor, cullBinding?.cullDrawBufs);\n            }\n\n            pass.setIndexBuffer(g.indexBuffer, g.indexFormat);\n            pass.setBindGroup(1, meshBindGroup);\n            if (receiveShadows && shadowBindGroup) {\n                pass.setBindGroup(2, shadowBindGroup);\n            }\n            if (cullBinding) {\n                cullBinding.draw(pass, g.indexCount, ti!.count);\n            } else if (ti && ti.count > 0) {\n                pass.drawIndexed(g.indexCount, ti.count);\n            } else {\n                pass.drawIndexed(g.indexCount);\n            }\n            return 1;\n        };\n\n        const r: Renderable = {\n            order: mesh.renderOrder ?? (isTransparent ? 200 : 100),\n            isTransparent,\n            mesh,\n            bind(eng, sig) {\n                const pipeline = getOrCreateStandardPipeline(eng as EngineContext, sig, bindings);\n                // Opaque-only GPU culling (opt-in): tryBind gates on opt-in + transparency, returns the per-binding cull lifecycle.\n                const cb = cull?.tryBind(r, s, mesh, engine, hasInstanceColor, isTransparent, update);\n                return {\n                    renderable: r,\n                    pipeline,\n                    update: cb ? cb.update : update,\n                    draw: (pass) => draw(pass, cb),\n                };\n            },\n        };\n        r._worldCenter = sortCenter;\n        let _lastUboVersion = mat._uboVersion;\n        return r;\n    };\n\n    const renderables = meshes.map((m) => rebuildSingle(scene, m));\n\n    scene._disposables.push(\n        () => clearStandardPipelineCache(),\n        () => clearSamplerCache(engine)\n    );\n\n    return { renderables, rebuildSingle };\n}\n"],"names":["_a","_b"],"mappings":"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"}

package/wgsl-helpers-D8sl1VVA.js

@@ -1,48 +0,0 @@
-const WGSL_PERTURB_NORMAL = `
-fn perturbNormal(vNormalW: vec3<f32>, positionW: vec3<f32>, uv: vec2<f32>, bumpScale: f32) -> vec3<f32> {
-let normalSample = textureSample(bT, bS, uv).rgb * 2.0 - 1.0;
-let N = normalize(vNormalW) * bumpScale;
-let dp1 = dpdx(positionW);
-let dp2 = -dpdy(positionW);
-let duv1 = dpdx(uv);
-let duv2 = -dpdy(uv);
-let dp2perp = cross(dp2, N);
-let dp1perp = cross(N, dp1);
-var tangent = dp2perp * duv1.x + dp1perp * duv2.x;
-var bitangent = dp2perp * duv1.y + dp1perp * duv2.y;
-let det = max(dot(tangent, tangent), dot(bitangent, bitangent));
-let invmax = select(inverseSqrt(det), 0.0, det == 0.0);
-let cotangentFrame = mat3x3<f32>(tangent * invmax, bitangent * invmax, N);
-return normalize(cotangentFrame * normalSample);
-}
-`;
-const WGSL_FOG = `
-const E_FOG: f32 = 2.71828;
-fn calcFogFactor(fogDistance: vec3<f32>) -> f32 {
-var fogCoeff: f32 = 1.0;
-let fogMode = scene.vFogInfos.x;
-let fogStart = scene.vFogInfos.y;
-let fogEnd = scene.vFogInfos.z;
-let fogDensity = scene.vFogInfos.w;
-let dist = length(fogDistance);
-if (fogMode == 3.0) { fogCoeff = (fogEnd - dist) / (fogEnd - fogStart); }
-else if (fogMode == 1.0) { fogCoeff = 1.0 / pow(E_FOG, dist * fogDensity); }
-else if (fogMode == 2.0) { fogCoeff = 1.0 / pow(E_FOG, dist * dist * fogDensity * fogDensity); }
-return clamp(fogCoeff, 0.0, 1.0);
-}
-`;
-const WGSL_DITHER = `
-fn dither(seed: vec2<f32>, varianceAmount: f32) -> f32 {
-let rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);
-let normVariance = varianceAmount / 255.0;
-return mix(-normVariance, normVariance, rand);
-}
-`;
-const WGSL_NO_DITHER = "fn dither(a:vec2<f32>,b:f32)->f32{return 0.0;}";
-export {
-  WGSL_PERTURB_NORMAL as W,
-  WGSL_FOG as a,
-  WGSL_DITHER as b,
-  WGSL_NO_DITHER as c
-};
-//# sourceMappingURL=wgsl-helpers-D8sl1VVA.js.map

package/wgsl-helpers-D8sl1VVA.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wgsl-helpers-D8sl1VVA.js","sources":["../src/shader/wgsl-helpers.ts"],"sourcesContent":["/** Shared WGSL helper snippets used by both PBR and Standard material systems.\n *\n *  These are pure WGSL function strings — no bindings, no UBO declarations.\n *  Each material system wraps them with its own binding declarations. */\n\n/** Cotangent-frame bump mapping.\n *  Requires: `bT` (texture_2d) and `bS` (sampler) in scope. */\nexport const WGSL_PERTURB_NORMAL = `\nfn perturbNormal(vNormalW: vec3<f32>, positionW: vec3<f32>, uv: vec2<f32>, bumpScale: f32) -> vec3<f32> {\nlet normalSample = textureSample(bT, bS, uv).rgb * 2.0 - 1.0;\nlet N = normalize(vNormalW) * bumpScale;\nlet dp1 = dpdx(positionW);\nlet dp2 = -dpdy(positionW);\nlet duv1 = dpdx(uv);\nlet duv2 = -dpdy(uv);\nlet dp2perp = cross(dp2, N);\nlet dp1perp = cross(N, dp1);\nvar tangent = dp2perp * duv1.x + dp1perp * duv2.x;\nvar bitangent = dp2perp * duv1.y + dp1perp * duv2.y;\nlet det = max(dot(tangent, tangent), dot(bitangent, bitangent));\nlet invmax = select(inverseSqrt(det), 0.0, det == 0.0);\nlet cotangentFrame = mat3x3<f32>(tangent * invmax, bitangent * invmax, N);\nreturn normalize(cotangentFrame * normalSample);\n}\n`;\n\n/** ESM shadow helper functions.\n *  Requires: `shadowTex` (texture_2d), `shadowSampler` (sampler) in scope. */\nexport const WGSL_SHADOW_ESM = `\nfn computeFallOff(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {\nlet mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));\nreturn mix(value, 1.0, mask);\n}\nfn computeShadowWithESM(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {\nlet clipSpace = posFromLight.xyz / posFromLight.w;\nlet uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\nif (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\nlet shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);\nlet shadowMapSample = textureSampleLevel(shadowTex, shadowSampler, uv, 0.0).x;\nlet esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);\nreturn computeFallOff(esm, clipSpace.xy, frustumEdgeFalloff);\n}\n`;\n\n/** Fog calculation helper.\n *  Requires: `scene.vFogInfos` (vec4) in scope. */\nexport const WGSL_FOG = `\nconst E_FOG: f32 = 2.71828;\nfn calcFogFactor(fogDistance: vec3<f32>) -> f32 {\nvar fogCoeff: f32 = 1.0;\nlet fogMode = scene.vFogInfos.x;\nlet fogStart = scene.vFogInfos.y;\nlet fogEnd = scene.vFogInfos.z;\nlet fogDensity = scene.vFogInfos.w;\nlet dist = length(fogDistance);\nif (fogMode == 3.0) { fogCoeff = (fogEnd - dist) / (fogEnd - fogStart); }\nelse if (fogMode == 1.0) { fogCoeff = 1.0 / pow(E_FOG, dist * fogDensity); }\nelse if (fogMode == 2.0) { fogCoeff = 1.0 / pow(E_FOG, dist * dist * fogDensity * fogDensity); }\nreturn clamp(fogCoeff, 0.0, 1.0);\n}\n`;\n\n/** Dither noise function.\n *  Pure math — no UBO dependency. */\nexport const WGSL_DITHER = `\nfn dither(seed: vec2<f32>, varianceAmount: f32) -> f32 {\nlet rand = fract(sin(dot(seed, vec2<f32>(12.9898, 78.233))) * 43758.5453);\nlet normVariance = varianceAmount / 255.0;\nreturn mix(-normVariance, normVariance, rand);\n}\n`;\n\n/** Noise-disabled replacement for shaders that still call dither(). */\nexport const WGSL_NO_DITHER = \"fn dither(a:vec2<f32>,b:f32)->f32{return 0.0;}\";\n"],"names":[],"mappings":"AAOO,MAAM,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuC5B,MAAM,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBjB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASpB,MAAM,iBAAiB;"}