@ignifx/core 0.15.0 → 0.17.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/decoders/draco3dgltf.LICENSE.md +201 -0
- package/decoders/draco_decoder.js +116 -0
- package/decoders/draco_decoder_gltf.wasm +0 -0
- package/decoders/vendored.json +22 -0
- package/dist/{decoders-CHJ7vduE.js → decoders-BUQrlS8U.js} +3 -2
- package/dist/decoders-BUQrlS8U.js.map +1 -0
- package/dist/{environment-DPi0_0SP.js → environment-CMpzGXTz.js} +2 -2
- package/dist/{environment-DPi0_0SP.js.map → environment-CMpzGXTz.js.map} +1 -1
- package/dist/{ignifx-error-oYdVnT1S.js → ignifx-error-Der0bpHK.js} +7 -1
- package/dist/ignifx-error-Der0bpHK.js.map +1 -0
- package/dist/index.d.ts +29 -14609
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1715 -4899
- package/dist/index.js.map +1 -1
- package/dist/{instanced-mesh-instance-NnODkvqK.js → instanced-mesh-instance-BMhREEfx.js} +3 -2
- package/dist/{instanced-mesh-instance-NnODkvqK.js.map → instanced-mesh-instance-BMhREEfx.js.map} +1 -1
- package/dist/{material-plugin-BUlqLsap.js → material-plugin-B-hartHR.js} +2 -2
- package/dist/{material-plugin-BUlqLsap.js.map → material-plugin-B-hartHR.js.map} +1 -1
- package/dist/node-DznSvwap.js +301 -0
- package/dist/node-DznSvwap.js.map +1 -0
- package/dist/{post-effect-BHl7U56q.js → post-effect-CuoYvrhb.js} +3 -30
- package/dist/post-effect-CuoYvrhb.js.map +1 -0
- package/dist/{post-effect-compiler-CRek8VxQ.js → post-effect-compiler-Bps8QbiJ.js} +3 -3
- package/dist/{post-effect-compiler-CRek8VxQ.js.map → post-effect-compiler-Bps8QbiJ.js.map} +1 -1
- package/dist/prefab-overrides-76IhcF-e.d.ts +14925 -0
- package/dist/prefab-overrides-76IhcF-e.d.ts.map +1 -0
- package/dist/prefab-overrides-DGiGTSN-.js +2396 -0
- package/dist/prefab-overrides-DGiGTSN-.js.map +1 -0
- package/dist/prefab.d.ts +2 -0
- package/dist/prefab.js +2 -0
- package/dist/reflection-probe-C0pzGrG_.js +1883 -0
- package/dist/reflection-probe-C0pzGrG_.js.map +1 -0
- package/dist/reflection-probes-B8_vK9YR.js +551 -0
- package/dist/reflection-probes-B8_vK9YR.js.map +1 -0
- package/dist/{render-texture-C_TnaSz2.js → render-texture-UqRHRLQy.js} +15 -2
- package/dist/{render-texture-C_TnaSz2.js.map → render-texture-UqRHRLQy.js.map} +1 -1
- package/dist/rolldown-runtime-D7D4PA-g.js +13 -0
- package/dist/{shader-material-B6p66wB8.js → shader-material-Cjfq7nFS.js} +5 -16
- package/dist/{shader-material-B6p66wB8.js.map → shader-material-Cjfq7nFS.js.map} +1 -1
- package/dist/{shader-material-C0TAUr4t.js → shader-material-DCjYDdkh.js} +2 -2
- package/dist/{shader-material-C0TAUr4t.js.map → shader-material-DCjYDdkh.js.map} +1 -1
- package/dist/{shader-pragma-BKCoZTTA.js → shader-pragma-cjEC-EPK.js} +2 -2
- package/dist/{shader-pragma-BKCoZTTA.js.map → shader-pragma-cjEC-EPK.js.map} +1 -1
- package/dist/{surface-shader-BaK0kvBB.js → surface-shader-D40hXQ8c.js} +4 -4
- package/dist/{surface-shader-BaK0kvBB.js.map → surface-shader-D40hXQ8c.js.map} +1 -1
- package/dist/{vec3-D-0Y2mzE.js → vec3-Cc19wl4r.js} +3 -300
- package/dist/vec3-Cc19wl4r.js.map +1 -0
- package/package.json +11 -5
- package/dist/decoders-CHJ7vduE.js.map +0 -1
- package/dist/ignifx-error-oYdVnT1S.js.map +0 -1
- package/dist/json-CzZZ6K4x.js +0 -24
- package/dist/json-CzZZ6K4x.js.map +0 -1
- package/dist/post-effect-BHl7U56q.js.map +0 -1
- package/dist/vec3-D-0Y2mzE.js.map +0 -1
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { p as tagNode } from "./node-DznSvwap.js";
|
|
2
|
+
import { A as setMeshReceiveShadows, D as setMeshId, E as setMeshBounds, M as setMeshSubtreeVisible, O as setMeshMaterial, T as removeMeshFromScene, d as cloneMeshUnderNode, j as setMeshRenderOrder, k as setMeshPickable, l as Vec3, u as addMeshToScene, x as detachMeshBounds } from "./vec3-Cc19wl4r.js";
|
|
2
3
|
import { clearThinInstanceLodPartner, enableThinInstanceDynamicDrawCount, enableThinInstanceGpuCulling, enableThinInstanceWorldBounds, flushThinInstances, setThinInstanceColors, setThinInstanceCount, setThinInstanceCullBoundsPad, setThinInstanceDrawCount, setThinInstanceLodPartner, setThinInstances } from "@babylonjs/lite";
|
|
3
4
|
//#region src/lite/gpu/thin-instances.ts
|
|
4
5
|
/**
|
|
@@ -762,4 +763,4 @@ function asMesh(node) {
|
|
|
762
763
|
//#endregion
|
|
763
764
|
export { InstancedMeshInstance, createInstancedMesh, releaseInstancedMesh };
|
|
764
765
|
|
|
765
|
-
//# sourceMappingURL=instanced-mesh-instance-
|
|
766
|
+
//# sourceMappingURL=instanced-mesh-instance-BMhREEfx.js.map
|
package/dist/{instanced-mesh-instance-NnODkvqK.js.map → instanced-mesh-instance-BMhREEfx.js.map}
RENAMED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"instanced-mesh-instance-NnODkvqK.js","names":["setThinInstances","setThinInstanceCount","flushThinInstances","setThinInstanceColors","enableThinInstanceGpuCulling","setThinInstanceCullBoundsPad","enableThinInstanceWorldBounds","enableThinInstanceDynamicDrawCount","setThinInstanceLodPartner","clearThinInstanceLodPartner"],"sources":["../src/lite/gpu/thin-instances.ts","../src/render/gpu/instanced-mesh-instance.ts"],"sourcesContent":["import {\n clearThinInstanceLodPartner as liteClearThinInstanceLodPartner,\n enableThinInstanceDynamicDrawCount as liteEnableThinInstanceDynamicDrawCount,\n enableThinInstanceGpuCulling as liteEnableThinInstanceGpuCulling,\n enableThinInstanceWorldBounds as liteEnableThinInstanceWorldBounds,\n flushThinInstances as liteFlushThinInstances,\n setThinInstanceColors as liteSetThinInstanceColors,\n setThinInstanceCount as liteSetThinInstanceCount,\n setThinInstanceCullBoundsPad as liteSetThinInstanceCullBoundsPad,\n setThinInstanceDrawCount as liteSetThinInstanceDrawCount,\n setThinInstanceLodPartner as liteSetThinInstanceLodPartner,\n setThinInstances as liteSetThinInstances,\n} from \"@babylonjs/lite\";\nimport type { Mesh } from \"@babylonjs/lite\";\n\n/**\n * Thin-instance half of the Babylon Lite adapter (`docs/architecture/07-rendering.md` §2.3,\n * `docs/plan/2026-09-terrain-particles-shaders.md` §3.5). Everything here is `@internal` and needs a\n * WebGPU device, so the browser project is what covers it.\n *\n * Lite fixes the order these must be called in, and both the culling opt-in and the LOD pairing only\n * take effect through the renderable `registerScene` compiles:\n *\n * 1. {@link setThinInstances} — its `count` argument becomes `_capacity`, and the GPU buffer is\n * sized `_capacity * 64` bytes for the life of the mesh, so pass the **capacity** here once and\n * lower the active count with {@link setThinInstanceCount} straight afterwards.\n * 2. {@link enableThinInstanceWorldBounds} — gives the scene AABB the cloud rather than the\n * prototype. It does not fix a shadow frustum: `computeDirectionalLightMatrix` reads\n * `boundMin`/`boundMax` directly (`lib/shadow/shadow-base.js` 54).\n * 3. {@link enableThinInstanceGpuCulling} — compute-based, opaque only.\n * 4. {@link enableThinInstanceDynamicDrawCount} — indirect draw arguments, so a later count change\n * keeps the cached bundle valid.\n * 5. {@link setThinInstanceLodPartner} — needs both meshes instanced already and stamps both\n * `_clone`, so neither can be cloned afterwards.\n * 6. `addMeshToScene`, and only then `registerScene`.\n *\n * Moving instances costs three different amounts (`lib/mesh/thin-instance.js`):\n * {@link flushThinInstances} re-uploads the whole active range and is the only sub-range-free path\n * Lite exposes; {@link setThinInstanceCount} re-uploads as well; {@link setThinInstanceDrawCount}\n * uploads nothing but throws until the pool has completed one GPU synchronisation, which is private\n * state — {@link trySetThinInstanceDrawCount} asks by trying.\n */\n\n/**\n * Points a mesh at a matrix slab and fixes its capacity.\n *\n * @remarks\n * The `capacity` argument is written straight to Lite's `_capacity`, which sizes the GPU buffer\n * (`_capacity * 64` bytes) once and for good. Only the first `count` matrices are ever read from\n * `matrices`, and Lite clamps its dirty range to the active count\n * (`lib/mesh/thin-instance-gpu.js`), so a slab shorter than `capacity * 16` floats is safe as long\n * as the active count is lowered with {@link setThinInstanceCount} before the next frame.\n *\n * Lite keeps the array by reference and never copies it: the caller owns it, and mutating it is the\n * intended way to move instances, followed by {@link flushThinInstances}.\n *\n * @param mesh - The mesh to instance.\n * @param matrices - 16 floats per instance, column-major, caller-owned.\n * @param capacity - The largest instance count this mesh will ever draw.\n *\n * @internal\n */\nexport function setThinInstances(mesh: Mesh, matrices: Float32Array, capacity: number): void {\n liteSetThinInstances(mesh, matrices, capacity);\n}\n\n/**\n * Sets how many instances draw, re-uploading the active range.\n *\n * @remarks\n * Prefer {@link trySetThinInstanceDrawCount} for a per-frame change: this one marks `[0, count)`\n * dirty as well, so it costs a `count * 64`-byte upload.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count, at most the capacity.\n *\n * @internal\n */\nexport function setThinInstanceCount(mesh: Mesh, count: number): void {\n liteSetThinInstanceCount(mesh, count);\n}\n\n/**\n * Sets how many instances draw without re-uploading anything, when Lite accepts it.\n *\n * @remarks\n * Lite requires the pool to have completed one full-capacity GPU synchronisation first and throws\n * otherwise (`lib/mesh/thin-instance.js`, `ThrowLiteError(369)`); the state it checks — the matrix\n * buffer's existence and its version — is private, so the only way to ask is to call. The throw\n * happens before anything is mutated, so a refusal leaves the mesh untouched and the caller can\n * fall back to {@link setThinInstanceCount}.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count, at most the capacity.\n * @returns `true` when the count was changed, `false` when Lite is not ready for a bare count\n * change yet.\n *\n * @internal\n */\nexport function trySetThinInstanceDrawCount(mesh: Mesh, count: number): boolean {\n try {\n liteSetThinInstanceDrawCount(mesh, count);\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Marks the whole active matrix range dirty, after the caller mutated the slab in place.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function flushThinInstances(mesh: Mesh): void {\n liteFlushThinInstances(mesh);\n}\n\n/**\n * Installs, replaces, or removes the per-instance RGBA colours.\n *\n * @remarks\n * Lite exports no way to *remove* colours: `setThinInstanceColors` only assigns, and the colour\n * version counters that drive the upload are private. `ThinInstanceData.colors` is declared\n * optional and mutable (`index.d.ts` 12985), so clearing is a direct field write —\n * which is enough, because `syncThinInstanceGpuData` skips the colour upload entirely while\n * `colors` is null, and the renderable rebuild the caller triggers is what drops\n * `useThinInstanceColors` from the compiled pipeline.\n *\n * @param mesh - The instanced mesh.\n * @param colors - Four floats per instance (linear RGBA), or `null` to stop reading colours.\n *\n * @internal\n */\nexport function setThinInstanceColors(mesh: Mesh, colors: Float32Array | null): void {\n if (colors !== null) {\n liteSetThinInstanceColors(mesh, colors);\n return;\n }\n const data = mesh.thinInstances;\n if (data !== null && data !== undefined) {\n data.colors = null;\n }\n}\n\n/**\n * Turns compute-based GPU frustum culling on or off for an instanced mesh.\n *\n * @remarks\n * Opaque meshes only, and it must run after {@link setThinInstances} and before the scene is\n * registered.\n *\n * @param mesh - The instanced mesh.\n * @param enabled - Whether the culling compute pass runs.\n *\n * @internal\n */\nexport function enableThinInstanceGpuCulling(mesh: Mesh, enabled: boolean): void {\n liteEnableThinInstanceGpuCulling(mesh, enabled);\n}\n\n/**\n * Grows every instance's GPU-culling sphere by a world-space distance.\n *\n * @remarks\n * The culler builds each sphere from the prototype's vertices (`lib/mesh/thin-instance-gpu-culling.js`\n * 426), so a vertex stage that moves an instance outside it gets the instance culled while it is\n * still on screen. Lite reads the pad on every culled pass (`index.d.ts` 11232), so it can change\n * live. Needs {@link setThinInstances} first.\n *\n * @param mesh - The instanced mesh that owns the culling pass.\n * @param pad - The extra radius in world units; `0` is the exact sphere.\n *\n * @internal\n */\nexport function setThinInstanceCullBoundsPad(mesh: Mesh, pad: number): void {\n liteSetThinInstanceCullBoundsPad(mesh, pad);\n}\n\n/**\n * Makes a mesh's world bounds the union of its instances' boxes rather than the prototype's own.\n *\n * @remarks\n * The hook it installs is `O(count)` per bounds computation, and it clamps to\n * `matrices.length / 16`, so a short slab cannot walk off the end. It is read by\n * `expandWorldAabbForMesh` — the scene camera's extent and PBR's scene-size probe — and **not** by\n * the directional shadow fit; see the module note.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function enableThinInstanceWorldBounds(mesh: Mesh): void {\n liteEnableThinInstanceWorldBounds(mesh);\n}\n\n/**\n * Opts a fixed-capacity pool into indirect draw arguments, so a later count change keeps the\n * cached render bundle valid.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function enableThinInstanceDynamicDrawCount(mesh: Mesh): void {\n liteEnableThinInstanceDynamicDrawCount(mesh);\n}\n\n/**\n * Where a LOD pairing switches, and how softly.\n *\n * @internal\n */\nexport interface ThinInstanceLodOptions {\n /** The camera distance, in world units, at which an in-frustum instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance threshold dither window centred on `distance`; `0` is a hard cut. */\n readonly band: number;\n}\n\n/**\n * Pairs a GPU-culled instanced mesh with a lower-detail partner.\n *\n * @remarks\n * Both meshes must already carry thin instances, and the partner may reference the very same matrix\n * slab. While paired the partner draws **only** the far bucket, and the pairing switches its own\n * GPU culling on. Lite refuses the pairing when either mesh has more than one thin-instance owner,\n * when the partner is already paired, or when the partner carries colours the full mesh does not\n * (`ThrowLiteError(375)`, `(377)`, `(379)`). Calling it again with the same pair re-sets `distance`\n * and `band` live.\n *\n * @param fullMesh - The near mesh, which owns the culling pass.\n * @param lodMesh - The far mesh.\n * @param options - Where the switch happens, and how softly.\n *\n * @internal\n */\nexport function setThinInstanceLodPartner(fullMesh: Mesh, lodMesh: Mesh, options: ThinInstanceLodOptions): void {\n liteSetThinInstanceLodPartner(fullMesh, lodMesh, { distance: options.distance, band: options.band });\n}\n\n/**\n * Dissolves a LOD pairing, returning both meshes to independent rendering.\n *\n * @remarks\n * A no-op when the mesh is not paired, so it is safe on the teardown path.\n *\n * @param fullMesh - The near mesh of the pair.\n *\n * @internal\n */\nexport function clearThinInstanceLodPartner(fullMesh: Mesh): void {\n liteClearThinInstanceLodPartner(fullMesh);\n}\n\n/**\n * How many instances a mesh is currently drawing, as Lite sees it.\n *\n * @remarks\n * The browser tests assert against Lite's own state rather than against the component's copy of it,\n * which is the only way to prove the two agree.\n *\n * @param mesh - The mesh to read.\n * @returns The active count, or `0` when the mesh carries no thin instances.\n *\n * @internal\n */\nexport function thinInstanceCount(mesh: Mesh): number {\n return mesh.thinInstances?.count ?? 0;\n}\n","import {\n addMeshToScene,\n cloneMeshUnderNode,\n detachMeshBounds,\n removeMeshFromScene,\n setMeshBounds,\n setMeshId,\n setMeshMaterial,\n setMeshPickable,\n setMeshReceiveShadows,\n setMeshRenderOrder,\n setMeshSubtreeVisible,\n} from \"../../lite/gpu/mesh.js\";\nimport {\n clearThinInstanceLodPartner,\n enableThinInstanceDynamicDrawCount,\n enableThinInstanceGpuCulling,\n enableThinInstanceWorldBounds,\n flushThinInstances,\n setThinInstanceColors,\n setThinInstanceCount,\n setThinInstanceCullBoundsPad,\n setThinInstanceLodPartner,\n setThinInstances,\n trySetThinInstanceDrawCount,\n} from \"../../lite/gpu/thin-instances.js\";\nimport { tagNode } from \"../../lite/node.js\";\nimport { Vec3 } from \"../../math/vec3.js\";\nimport type { LiteMesh } from \"../../lite/gpu/mesh.js\";\nimport type { LiteMaterial } from \"../../lite/material.js\";\nimport type { LiteSceneNode, NodeTag } from \"../../lite/node.js\";\nimport type { LiteScene } from \"../../lite/scene.js\";\nimport type { Transform } from \"../../transform/transform.js\";\n\n/**\n * One `InstancedMeshRenderer`'s near mesh and its optional LOD partner, and everything that writes\n * to them (`docs/plan/2026-09-terrain-particles-shaders.md` §3.5).\n *\n * Every line needs a WebGPU device, which is why it sits in `src/render/gpu/` — excluded from the\n * Node coverage floor and measured by the browser project — and why the component reaches it through\n * a dynamic `import()` (`../instanced-mesh-support.ts`).\n *\n * `capacity`, `gpuCulling` and the partner's identity are constructor arguments rather than `apply*`\n * methods because Lite fixes all three at `registerScene`; `distance` and `band` may be re-set live\n * by calling the pairing again. Both meshes share one matrix slab, which the pairing requires: it\n * compacts the near mesh's culling output into two buckets drawn from the same matrices.\n *\n * Bounds are the one thing an instanced caster needs that a plain mesh does not.\n * `computeDirectionalLightMatrix` composes `mesh.worldMatrix × mesh.boundMin/boundMax` directly\n * (`lib/shadow/shadow-base.js` 54) and never consults the `_expandWorldBounds` hook\n * `enableThinInstanceWorldBounds` installs, so a cloud left at its prototype's box casts nothing\n * (measured on SwiftShader, 2026-09-08). {@link InstancedMeshInstance.applyBounds} publishes the\n * union of the live placements instead; culling accuracy is unaffected because each instance's cull\n * sphere comes from the real vertices (`lib/mesh/thin-instance-gpu-culling.js` 426).\n */\n\n/** What the component remembers between uploads. Mutated in place, so a frame allocates nothing. */\nexport interface InstancedUploadState {\n /** The whole slab has to be re-pointed and re-uploaded. */\n isSlabDirty: boolean;\n /** The caller mutated the slab in place, so the active range has to be re-uploaded. */\n isRangeDirty: boolean;\n /** The count the meshes were last told about. */\n appliedCount: number;\n /** The capacity the meshes were built with. */\n appliedCapacity: number;\n /** Whether the union bounds have been published at least once. */\n hasAppliedBounds: boolean;\n /** Whether the last upload carried a colour slab. */\n hadColors: boolean;\n}\n\n/** The LOD switch the component declares, as much of it as the adapter reads. */\nexport interface InstancedLodFields {\n /** The camera distance at which an instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance dither window. */\n readonly band: number;\n}\n\n/** The LOD partner an instance is built with. */\nexport interface InstancedLodConfig {\n /** The coarse template to clone. */\n readonly template: LiteMesh;\n /** The camera distance, in world units, at which an instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance dither window centred on `distance`. */\n readonly band: number;\n}\n\n/** The settings Lite fixes when the meshes are built. */\nexport interface InstancedMeshSettings {\n /** The largest instance count the meshes will ever draw. */\n readonly capacity: number;\n /** Whether the compute culling pass runs. */\n readonly gpuCulling: boolean;\n /** The LOD partner, or `null`. */\n readonly lod: InstancedLodConfig | null;\n}\n\n/**\n * A live instanced mesh, and its LOD partner, in a scene.\n *\n * @internal\n */\nexport class InstancedMeshInstance {\n /** The cloned near mesh, parented under the entity's node. */\n readonly clone: LiteSceneNode;\n\n readonly #lod: LiteSceneNode | null;\n\n #material: LiteMaterial;\n\n #receiveShadows: boolean | null = null;\n\n #renderOrder = Number.NaN;\n\n #pickable: boolean | null = null;\n\n #visible = false;\n\n #lodDistance: number;\n\n #lodBand: number;\n\n readonly #nearBox: Float64Array;\n\n readonly #lodBox: Float64Array | null;\n\n readonly #union = new Float64Array(6);\n\n /** The world-space displacement the culling pad and the bounds were last widened by. */\n #displacement = 0;\n\n /** The same displacement in object units, per axis, as the published bounds carry it. */\n readonly #margin = new Vec3();\n\n /** Scratch for the entity's world scale. */\n readonly #scale = new Vec3();\n\n /**\n * Clones the templates, gives them thin instances, applies the baked settings in Lite's required\n * order, and adds them to the scene.\n *\n * @param scene - The render scene.\n * @param template - The near mesh's template.\n * @param parent - The entity's transform node.\n * @param tag - The owning entity and component, for picking.\n * @param meshId - The string id Lite's light include/exclude sets match on.\n * @param material - The material both meshes draw with. Assigned **before** the meshes join the\n * scene, for the reason `MeshInstance`'s constructor records: `addToScene` buckets a mesh by its\n * material's build group.\n * @param settings - Capacity, GPU culling, and the LOD pairing.\n * @param matrices - The matrix slab, caller-owned and never copied.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\n constructor(\n scene: LiteScene,\n template: LiteMesh,\n parent: LiteSceneNode,\n tag: NodeTag,\n meshId: string,\n material: LiteMaterial,\n settings: InstancedMeshSettings,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n ) {\n const clone = cloneMeshUnderNode(template, parent);\n tagNode(clone, tag);\n const mesh = asMesh(clone);\n setMeshId(mesh, meshId);\n setMeshMaterial(mesh, material);\n // A clone shares the template's bound arrays, and `applyBounds` mutates them in place.\n detachMeshBounds(mesh);\n this.#nearBox = readBox(mesh);\n installThinInstances(mesh, settings.capacity, matrices, count, colors);\n enableThinInstanceGpuCulling(mesh, settings.gpuCulling);\n enableThinInstanceDynamicDrawCount(mesh);\n\n const lodConfig = settings.lod;\n let lodClone: LiteSceneNode | null = null;\n let lodBox: Float64Array | null = null;\n if (lodConfig !== null) {\n lodClone = cloneMeshUnderNode(lodConfig.template, parent);\n tagNode(lodClone, tag);\n const lodMesh = asMesh(lodClone);\n setMeshId(lodMesh, `${meshId}#lod`);\n setMeshMaterial(lodMesh, material);\n detachMeshBounds(lodMesh);\n lodBox = readBox(lodMesh);\n installThinInstances(lodMesh, settings.capacity, matrices, count, colors);\n setThinInstanceLodPartner(mesh, lodMesh, { distance: lodConfig.distance, band: lodConfig.band });\n }\n this.#lodBox = lodBox;\n\n this.#material = material;\n this.#lodDistance = lodConfig?.distance ?? 0;\n this.#lodBand = lodConfig?.band ?? 0;\n // Hidden until the first `applyVisible`, so a renderer on an inactive entity never flashes.\n setMeshSubtreeVisible(clone, false);\n addMeshToScene(scene, clone);\n if (lodClone !== null) {\n setMeshSubtreeVisible(lodClone, false);\n addMeshToScene(scene, lodClone);\n }\n this.clone = clone;\n this.#lod = lodClone;\n }\n\n /**\n * Whether the meshes are currently drawn.\n *\n * @returns `true` when Lite's `visible` is set on them.\n */\n get isVisible(): boolean {\n return this.#visible;\n }\n\n /**\n * The near mesh.\n *\n * @returns The clone, typed as a mesh.\n */\n get mesh(): LiteMesh {\n return asMesh(this.clone);\n }\n\n /**\n * The LOD partner.\n *\n * @returns The partner clone, or `null` when the renderer declares no LOD.\n */\n get lodMesh(): LiteMesh | null {\n const lod = this.#lod;\n return lod === null ? null : asMesh(lod);\n }\n\n /**\n * Assigns the material to both meshes, when it changed.\n *\n * @param material - The Lite material to draw with.\n */\n applyMaterial(material: LiteMaterial): void {\n if (material === this.#material) {\n return;\n }\n this.#material = material;\n setMeshMaterial(this.mesh, material);\n const lod = this.lodMesh;\n if (lod !== null) {\n setMeshMaterial(lod, material);\n }\n }\n\n /**\n * Writes the per-mesh flags that changed, to both meshes.\n *\n * @param receiveShadows - Whether shadow maps darken the meshes.\n * @param renderOrder - The sort key within the phase.\n * @param pickable - Whether picking considers the meshes at all.\n */\n applyFlags(receiveShadows: boolean, renderOrder: number, pickable: boolean): void {\n if (this.#receiveShadows !== receiveShadows) {\n this.#receiveShadows = receiveShadows;\n this.#eachMesh(setMeshReceiveShadows, receiveShadows);\n }\n if (this.#renderOrder !== renderOrder) {\n this.#renderOrder = renderOrder;\n this.#eachMesh(setMeshRenderOrder, renderOrder);\n }\n if (this.#pickable !== pickable) {\n this.#pickable = pickable;\n this.#eachMesh(setMeshPickable, pickable);\n }\n }\n\n /**\n * Re-sets the LOD switch distance and dither band, when either changed.\n *\n * @param distance - The camera distance at which an instance switches to the partner.\n * @param band - The width of the per-instance dither window centred on `distance`.\n */\n applyLod(distance: number, band: number): void {\n const lod = this.lodMesh;\n if (lod === null || (distance === this.#lodDistance && band === this.#lodBand)) {\n return;\n }\n this.#lodDistance = distance;\n this.#lodBand = band;\n setThinInstanceLodPartner(this.mesh, lod, { distance, band });\n }\n\n /**\n * Shows or hides both meshes, when the state changed.\n *\n * @param visible - `entity.activeInHierarchy && component.enabled`.\n */\n applyVisible(visible: boolean): void {\n if (visible === this.#visible) {\n return;\n }\n this.#visible = visible;\n setMeshSubtreeVisible(this.clone, visible);\n const lod = this.#lod;\n if (lod !== null) {\n setMeshSubtreeVisible(lod, visible);\n }\n }\n\n /**\n * Re-points both meshes at a matrix slab and re-uploads the active range.\n *\n * @param capacity - The capacity the meshes were built with; re-stating it keeps `_capacity`\n * unchanged, which is what stops Lite from re-creating the GPU buffer.\n * @param matrices - The slab, caller-owned.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\n applySlab(capacity: number, matrices: Float32Array, count: number, colors: Float32Array | null): void {\n installThinInstances(this.mesh, capacity, matrices, count, colors);\n const lod = this.lodMesh;\n if (lod !== null) {\n installThinInstances(lod, capacity, matrices, count, colors);\n }\n }\n\n /**\n * Changes how many instances draw, by the cheapest route Lite accepts.\n *\n * @param count - The active count, at most the capacity.\n */\n applyCount(count: number): void {\n applyMeshCount(this.mesh, count);\n const lod = this.lodMesh;\n if (lod !== null) {\n applyMeshCount(lod, count);\n }\n }\n\n /**\n * Marks the whole active range dirty, after the caller mutated the slab in place.\n *\n * @param colors - The colour slab, when the renderer has one, so its own dirty range moves too.\n */\n flush(colors: Float32Array | null): void {\n flushThinInstances(this.mesh);\n const lod = this.lodMesh;\n if (lod !== null) {\n flushThinInstances(lod);\n }\n if (colors !== null) {\n setThinInstanceColors(this.mesh, colors);\n if (lod !== null) {\n setThinInstanceColors(lod, colors);\n }\n }\n }\n\n /**\n * Publishes the union of the live instance placements as both meshes' object-local bounds, so a\n * directional light's shadow frustum is fitted to the cloud rather than to the prototype.\n *\n * @remarks\n * `O(count)`, allocation-free, and worth paying only for a caster — see the module note. A count\n * of zero restores the prototype's own box, so an empty cloud does not report an infinite one.\n *\n * @param matrices - The live matrix slab.\n * @param count - How many instances are drawn.\n */\n applyBounds(matrices: Float32Array, count: number): void {\n const near = this.#nearBox;\n const lodBox = this.#lodBox;\n const lod = this.lodMesh;\n const margin = this.#margin;\n if (count <= 0) {\n writeBox(this.mesh, near, margin);\n if (lod !== null && lodBox !== null) {\n writeBox(lod, lodBox, margin);\n }\n return;\n }\n const union = this.#union;\n unionOfPlacements(matrices, count, near, union);\n writeBox(this.mesh, union, margin);\n if (lod !== null && lodBox !== null) {\n unionOfPlacements(matrices, count, lodBox, union);\n writeBox(lod, union, margin);\n }\n }\n\n /**\n * Widens both meshes for a vertex stage that moves vertices up to `displacement` metres: the GPU\n * culler pads every instance's sphere, and the bounds published for a shadow frustum grow too.\n *\n * @remarks\n * The culling pad is world-space already. The bounds are object-local, so each axis is divided by\n * the entity's world scale along it. A change clears `state.hasAppliedBounds`, so the next\n * {@link InstancedMeshInstance.sync} re-publishes them.\n *\n * @param state - The component's upload state.\n * @param displacement - The material's displacement, in world metres.\n * @param transform - The entity's transform, whose world scale the meshes inherit.\n */\n applyDisplacement(state: InstancedUploadState, displacement: number, transform: Transform): void {\n if (displacement !== this.#displacement) {\n this.#displacement = displacement;\n // Only the near mesh runs the culling pass; the partner draws from its output.\n setThinInstanceCullBoundsPad(this.mesh, displacement);\n }\n const scale = this.#scale;\n if (displacement > 0) {\n transform.lossyScaleToRef(scale);\n }\n const x = objectMargin(displacement, scale.x);\n const y = objectMargin(displacement, scale.y);\n const z = objectMargin(displacement, scale.z);\n const margin = this.#margin;\n if (x !== margin.x || y !== margin.y || z !== margin.z) {\n margin.set(x, y, z);\n state.hasAppliedBounds = false;\n }\n }\n\n /**\n * Writes everything the component changed since the last frame onto both meshes.\n *\n * @param state - The component's upload state, mutated in place.\n * @param material - The material both meshes draw with.\n * @param receiveShadows - Whether shadow maps darken them.\n * @param renderOrder - The sort key within the phase.\n * @param pickable - Whether picking considers them.\n * @param lod - The LOD record, whose `distance` and `band` Lite re-applies live; `null` for none.\n * @param matrices - The caller-owned matrix slab.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n * @param castShadows - Whether the union bounds have to be published for a shadow frustum.\n * @param visible - `entity.activeInHierarchy && component.enabled`.\n * @returns `true` when the compiled pipeline has to change, which only a colour slab arriving or\n * leaving does.\n */\n sync(\n state: InstancedUploadState,\n material: LiteMaterial,\n receiveShadows: boolean,\n renderOrder: number,\n pickable: boolean,\n lod: InstancedLodFields | null,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n castShadows: boolean,\n visible: boolean,\n ): boolean {\n this.applyMaterial(material);\n this.applyFlags(receiveShadows, renderOrder, pickable);\n if (lod !== null) {\n this.applyLod(lod.distance, lod.band);\n }\n let renderablesChanged = false;\n let placementsMoved = false;\n if (state.isSlabDirty) {\n state.isSlabDirty = false;\n state.isRangeDirty = false;\n this.applySlab(state.appliedCapacity, matrices, count, colors);\n state.appliedCount = count;\n placementsMoved = true;\n const hasColors = colors !== null;\n renderablesChanged = hasColors !== state.hadColors;\n state.hadColors = hasColors;\n } else {\n if (state.isRangeDirty) {\n state.isRangeDirty = false;\n this.flush(colors);\n placementsMoved = true;\n }\n if (count !== state.appliedCount) {\n state.appliedCount = count;\n this.applyCount(count);\n placementsMoved = true;\n }\n }\n // Only a caster pays the `O(count)` bounds pass, and only in a frame whose placements moved.\n if (castShadows && (placementsMoved || !state.hasAppliedBounds)) {\n state.hasAppliedBounds = true;\n this.applyBounds(matrices, count);\n }\n this.applyVisible(visible);\n return renderablesChanged;\n }\n\n /**\n * Appends both meshes to a shadow caster list, when the renderer casts and they are drawn.\n *\n * @param castShadows - Whether the renderer casts.\n * @param out - The caster list being built.\n */\n collectCasters(castShadows: boolean, out: LiteMesh[]): void {\n if (!castShadows || !this.#visible) {\n return;\n }\n out.push(this.mesh);\n const lod = this.lodMesh;\n if (lod !== null) {\n out.push(lod);\n }\n }\n\n /**\n * Dissolves the LOD pairing and removes both meshes from the scene, releasing their share of the\n * templates' buffers.\n *\n * @param scene - The render scene.\n */\n destroy(scene: LiteScene): void {\n const lod = this.#lod;\n if (lod !== null) {\n clearThinInstanceLodPartner(this.mesh);\n removeMeshFromScene(scene, lod);\n }\n removeMeshFromScene(scene, this.clone);\n }\n\n /**\n * Runs a per-mesh Lite setter over the near mesh and the partner.\n *\n * @typeParam T - The setter's value type.\n * @param write - The adapter function to call.\n * @param value - What to write.\n */\n #eachMesh<T>(write: (mesh: LiteMesh, value: T) => void, value: T): void {\n write(this.mesh, value);\n const lod = this.lodMesh;\n if (lod !== null) {\n write(lod, value);\n }\n }\n}\n\n/**\n * Builds the live meshes, filling in the LOD pairing when both templates exist.\n *\n * @param scene - The render scene.\n * @param template - The near mesh's template.\n * @param lodTemplate - The coarse template, or `null`.\n * @param lod - The LOD record the component declares, or `null`.\n * @param parent - The entity's transform node.\n * @param tag - The owning entity and component, for picking.\n * @param meshId - The string id Lite's light include/exclude sets match on.\n * @param material - The material both meshes draw with.\n * @param capacity - The largest instance count the meshes will ever draw.\n * @param gpuCulling - Whether the compute culling pass runs.\n * @param matrices - The matrix slab.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n * @returns The instance.\n *\n * @internal\n */\nexport function createInstancedMesh(\n scene: LiteScene,\n template: LiteMesh,\n lodTemplate: LiteMesh | null,\n lod: InstancedLodFields | null,\n parent: LiteSceneNode,\n tag: NodeTag,\n meshId: string,\n material: LiteMaterial,\n capacity: number,\n gpuCulling: boolean,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n): InstancedMeshInstance {\n const pairing: InstancedLodConfig | null =\n lodTemplate === null || lod === null ? null : { template: lodTemplate, distance: lod.distance, band: lod.band };\n return new InstancedMeshInstance(\n scene,\n template,\n parent,\n tag,\n meshId,\n material,\n { capacity, gpuCulling, lod: pairing },\n matrices,\n count,\n colors,\n );\n}\n\n/**\n * Removes the meshes from the scene, when there are any.\n *\n * @param instance - The live meshes, or `null`.\n * @param scene - The render scene.\n * @returns `true` when something left the scene.\n *\n * @internal\n */\nexport function releaseInstancedMesh(instance: InstancedMeshInstance | null, scene: LiteScene): boolean {\n if (instance === null) {\n return false;\n }\n instance.destroy(scene);\n return true;\n}\n\n/**\n * Gives one mesh its thin instances in the order Lite requires, at a fixed capacity.\n *\n * @remarks\n * `setThinInstances` is handed the **capacity** so that `_capacity` — and the GPU buffer it sizes —\n * never moves; the active count is then lowered in the same breath, before any frame can read the\n * range in between (`src/lite/gpu/thin-instances.ts`).\n *\n * @param mesh - The mesh to instance.\n * @param capacity - The capacity to fix.\n * @param matrices - The slab, caller-owned.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\nfunction installThinInstances(\n mesh: LiteMesh,\n capacity: number,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n): void {\n setThinInstances(mesh, matrices, capacity);\n setThinInstanceCount(mesh, count);\n setThinInstanceColors(mesh, colors);\n enableThinInstanceWorldBounds(mesh);\n}\n\n/**\n * Changes one mesh's active count without re-uploading when Lite allows it, and with a re-upload\n * when it does not.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count.\n */\nfunction applyMeshCount(mesh: LiteMesh, count: number): void {\n if (!trySetThinInstanceDrawCount(mesh, count)) {\n setThinInstanceCount(mesh, count);\n }\n}\n\n/**\n * Reads a mesh's object-local box into six numbers.\n *\n * @remarks\n * A mesh built by any Lite factory carries bounds; the fallback half-metre cube is the same default\n * `computeDirectionalLightMatrix` uses for a mesh that does not\n * (`lib/shadow/shadow-base.js` 62).\n *\n * @param mesh - The mesh to read.\n * @returns `minX, minY, minZ, maxX, maxY, maxZ`.\n */\nfunction readBox(mesh: LiteMesh): Float64Array {\n const min = mesh.boundMin ?? [-0.5, -0.5, -0.5];\n const max = mesh.boundMax ?? [0.5, 0.5, 0.5];\n return Float64Array.of(min[0], min[1], min[2], max[0], max[1], max[2]);\n}\n\n/**\n * Writes a six-number box back onto a mesh, grown by a margin on every side.\n *\n * @param mesh - The mesh to re-bound.\n * @param box - `minX, minY, minZ, maxX, maxY, maxZ`.\n * @param margin - How far to grow each axis, in object units.\n */\nfunction writeBox(mesh: LiteMesh, box: Float64Array, margin: Vec3): void {\n setMeshBounds(\n mesh,\n (box[0] ?? 0) - margin.x,\n (box[1] ?? 0) - margin.y,\n (box[2] ?? 0) - margin.z,\n (box[3] ?? 0) + margin.x,\n (box[4] ?? 0) + margin.y,\n (box[5] ?? 0) + margin.z,\n );\n}\n\n/**\n * Converts a world-space margin into the object-space margin along one axis.\n *\n * @param margin - The margin, in world metres.\n * @param scale - The entity's world scale along the axis.\n * @returns The margin in object units; `0` for no margin or a collapsed axis.\n */\nfunction objectMargin(margin: number, scale: number): number {\n return margin > 0 && scale > 1e-9 ? margin / scale : 0;\n}\n\n/**\n * The axis-aligned union of a prototype box placed under every live instance matrix.\n *\n * @remarks\n * The same oriented-box-to-AABB composition Lite's own\n * `expandThinInstanceWorldBounds` uses, minus the world matrix — because `Mesh.boundMin`/`boundMax`\n * are documented to be **object-local**, the frame `worldMatrix` maps out of. Degenerate matrices\n * are skipped, exactly as Lite skips them, so a slot that has not been written yet does not drag\n * the box to the origin.\n *\n * @param matrices - The slab, 16 column-major floats per instance.\n * @param count - How many instances to consider.\n * @param box - The prototype's own box.\n * @param out - Receives `minX, minY, minZ, maxX, maxY, maxZ`.\n */\nfunction unionOfPlacements(matrices: Float32Array, count: number, box: Float64Array, out: Float64Array): void {\n const centreX = ((box[0] ?? 0) + (box[3] ?? 0)) * 0.5;\n const centreY = ((box[1] ?? 0) + (box[4] ?? 0)) * 0.5;\n const centreZ = ((box[2] ?? 0) + (box[5] ?? 0)) * 0.5;\n const extentX = ((box[3] ?? 0) - (box[0] ?? 0)) * 0.5;\n const extentY = ((box[4] ?? 0) - (box[1] ?? 0)) * 0.5;\n const extentZ = ((box[5] ?? 0) - (box[2] ?? 0)) * 0.5;\n out[0] = Number.POSITIVE_INFINITY;\n out[1] = Number.POSITIVE_INFINITY;\n out[2] = Number.POSITIVE_INFINITY;\n out[3] = Number.NEGATIVE_INFINITY;\n out[4] = Number.NEGATIVE_INFINITY;\n out[5] = Number.NEGATIVE_INFINITY;\n const usable = Math.min(count, Math.floor(matrices.length / 16));\n let placed = 0;\n for (let index = 0; index < usable; index += 1) {\n const base = index * 16;\n let scale = 0;\n for (let element = 0; element < 12; element += 1) {\n if (element % 4 !== 3) {\n scale += Math.abs(matrices[base + element] ?? 0);\n }\n }\n if (scale < 1e-9) {\n continue;\n }\n placed += 1;\n for (let row = 0; row < 3; row += 1) {\n const m0 = matrices[base + row] ?? 0;\n const m1 = matrices[base + 4 + row] ?? 0;\n const m2 = matrices[base + 8 + row] ?? 0;\n const centre = (matrices[base + 12 + row] ?? 0) + m0 * centreX + m1 * centreY + m2 * centreZ;\n const radius = Math.abs(m0) * extentX + Math.abs(m1) * extentY + Math.abs(m2) * extentZ;\n const low = centre - radius;\n const high = centre + radius;\n if (low < (out[row] ?? 0)) {\n out[row] = low;\n }\n if (high > (out[row + 3] ?? 0)) {\n out[row + 3] = high;\n }\n }\n }\n if (placed === 0) {\n out.set(box);\n }\n}\n\n/**\n * Narrows a cloned subtree root to a mesh.\n *\n * @remarks\n * The same boundary assertion `MeshInstance` makes, for the same reason: `cloneTransformNode` is\n * typed as returning the wider `SceneNode` because it also clones plain transform nodes, and the\n * clone of a mesh is a mesh (coding standards §5.2).\n *\n * @param node - The clone.\n * @returns The same object, typed as a mesh.\n */\nfunction asMesh(node: LiteSceneNode): LiteMesh {\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- see the note above.\n return node as LiteMesh;\n}\n"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"instanced-mesh-instance-BMhREEfx.js","names":["setThinInstances","setThinInstanceCount","flushThinInstances","setThinInstanceColors","enableThinInstanceGpuCulling","setThinInstanceCullBoundsPad","enableThinInstanceWorldBounds","enableThinInstanceDynamicDrawCount","setThinInstanceLodPartner","clearThinInstanceLodPartner"],"sources":["../src/lite/gpu/thin-instances.ts","../src/render/gpu/instanced-mesh-instance.ts"],"sourcesContent":["import {\n clearThinInstanceLodPartner as liteClearThinInstanceLodPartner,\n enableThinInstanceDynamicDrawCount as liteEnableThinInstanceDynamicDrawCount,\n enableThinInstanceGpuCulling as liteEnableThinInstanceGpuCulling,\n enableThinInstanceWorldBounds as liteEnableThinInstanceWorldBounds,\n flushThinInstances as liteFlushThinInstances,\n setThinInstanceColors as liteSetThinInstanceColors,\n setThinInstanceCount as liteSetThinInstanceCount,\n setThinInstanceCullBoundsPad as liteSetThinInstanceCullBoundsPad,\n setThinInstanceDrawCount as liteSetThinInstanceDrawCount,\n setThinInstanceLodPartner as liteSetThinInstanceLodPartner,\n setThinInstances as liteSetThinInstances,\n} from \"@babylonjs/lite\";\nimport type { Mesh } from \"@babylonjs/lite\";\n\n/**\n * Thin-instance half of the Babylon Lite adapter (`docs/architecture/07-rendering.md` §2.3,\n * `docs/plan/2026-09-terrain-particles-shaders.md` §3.5). Everything here is `@internal` and needs a\n * WebGPU device, so the browser project is what covers it.\n *\n * Lite fixes the order these must be called in, and both the culling opt-in and the LOD pairing only\n * take effect through the renderable `registerScene` compiles:\n *\n * 1. {@link setThinInstances} — its `count` argument becomes `_capacity`, and the GPU buffer is\n * sized `_capacity * 64` bytes for the life of the mesh, so pass the **capacity** here once and\n * lower the active count with {@link setThinInstanceCount} straight afterwards.\n * 2. {@link enableThinInstanceWorldBounds} — gives the scene AABB the cloud rather than the\n * prototype. It does not fix a shadow frustum: `computeDirectionalLightMatrix` reads\n * `boundMin`/`boundMax` directly (`lib/shadow/shadow-base.js` 54).\n * 3. {@link enableThinInstanceGpuCulling} — compute-based, opaque only.\n * 4. {@link enableThinInstanceDynamicDrawCount} — indirect draw arguments, so a later count change\n * keeps the cached bundle valid.\n * 5. {@link setThinInstanceLodPartner} — needs both meshes instanced already and stamps both\n * `_clone`, so neither can be cloned afterwards.\n * 6. `addMeshToScene`, and only then `registerScene`.\n *\n * Moving instances costs three different amounts (`lib/mesh/thin-instance.js`):\n * {@link flushThinInstances} re-uploads the whole active range and is the only sub-range-free path\n * Lite exposes; {@link setThinInstanceCount} re-uploads as well; {@link setThinInstanceDrawCount}\n * uploads nothing but throws until the pool has completed one GPU synchronisation, which is private\n * state — {@link trySetThinInstanceDrawCount} asks by trying.\n */\n\n/**\n * Points a mesh at a matrix slab and fixes its capacity.\n *\n * @remarks\n * The `capacity` argument is written straight to Lite's `_capacity`, which sizes the GPU buffer\n * (`_capacity * 64` bytes) once and for good. Only the first `count` matrices are ever read from\n * `matrices`, and Lite clamps its dirty range to the active count\n * (`lib/mesh/thin-instance-gpu.js`), so a slab shorter than `capacity * 16` floats is safe as long\n * as the active count is lowered with {@link setThinInstanceCount} before the next frame.\n *\n * Lite keeps the array by reference and never copies it: the caller owns it, and mutating it is the\n * intended way to move instances, followed by {@link flushThinInstances}.\n *\n * @param mesh - The mesh to instance.\n * @param matrices - 16 floats per instance, column-major, caller-owned.\n * @param capacity - The largest instance count this mesh will ever draw.\n *\n * @internal\n */\nexport function setThinInstances(mesh: Mesh, matrices: Float32Array, capacity: number): void {\n liteSetThinInstances(mesh, matrices, capacity);\n}\n\n/**\n * Sets how many instances draw, re-uploading the active range.\n *\n * @remarks\n * Prefer {@link trySetThinInstanceDrawCount} for a per-frame change: this one marks `[0, count)`\n * dirty as well, so it costs a `count * 64`-byte upload.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count, at most the capacity.\n *\n * @internal\n */\nexport function setThinInstanceCount(mesh: Mesh, count: number): void {\n liteSetThinInstanceCount(mesh, count);\n}\n\n/**\n * Sets how many instances draw without re-uploading anything, when Lite accepts it.\n *\n * @remarks\n * Lite requires the pool to have completed one full-capacity GPU synchronisation first and throws\n * otherwise (`lib/mesh/thin-instance.js`, `ThrowLiteError(369)`); the state it checks — the matrix\n * buffer's existence and its version — is private, so the only way to ask is to call. The throw\n * happens before anything is mutated, so a refusal leaves the mesh untouched and the caller can\n * fall back to {@link setThinInstanceCount}.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count, at most the capacity.\n * @returns `true` when the count was changed, `false` when Lite is not ready for a bare count\n * change yet.\n *\n * @internal\n */\nexport function trySetThinInstanceDrawCount(mesh: Mesh, count: number): boolean {\n try {\n liteSetThinInstanceDrawCount(mesh, count);\n return true;\n } catch {\n return false;\n }\n}\n\n/**\n * Marks the whole active matrix range dirty, after the caller mutated the slab in place.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function flushThinInstances(mesh: Mesh): void {\n liteFlushThinInstances(mesh);\n}\n\n/**\n * Installs, replaces, or removes the per-instance RGBA colours.\n *\n * @remarks\n * Lite exports no way to *remove* colours: `setThinInstanceColors` only assigns, and the colour\n * version counters that drive the upload are private. `ThinInstanceData.colors` is declared\n * optional and mutable (`index.d.ts` 12985), so clearing is a direct field write —\n * which is enough, because `syncThinInstanceGpuData` skips the colour upload entirely while\n * `colors` is null, and the renderable rebuild the caller triggers is what drops\n * `useThinInstanceColors` from the compiled pipeline.\n *\n * @param mesh - The instanced mesh.\n * @param colors - Four floats per instance (linear RGBA), or `null` to stop reading colours.\n *\n * @internal\n */\nexport function setThinInstanceColors(mesh: Mesh, colors: Float32Array | null): void {\n if (colors !== null) {\n liteSetThinInstanceColors(mesh, colors);\n return;\n }\n const data = mesh.thinInstances;\n if (data !== null && data !== undefined) {\n data.colors = null;\n }\n}\n\n/**\n * Turns compute-based GPU frustum culling on or off for an instanced mesh.\n *\n * @remarks\n * Opaque meshes only, and it must run after {@link setThinInstances} and before the scene is\n * registered.\n *\n * @param mesh - The instanced mesh.\n * @param enabled - Whether the culling compute pass runs.\n *\n * @internal\n */\nexport function enableThinInstanceGpuCulling(mesh: Mesh, enabled: boolean): void {\n liteEnableThinInstanceGpuCulling(mesh, enabled);\n}\n\n/**\n * Grows every instance's GPU-culling sphere by a world-space distance.\n *\n * @remarks\n * The culler builds each sphere from the prototype's vertices (`lib/mesh/thin-instance-gpu-culling.js`\n * 426), so a vertex stage that moves an instance outside it gets the instance culled while it is\n * still on screen. Lite reads the pad on every culled pass (`index.d.ts` 11232), so it can change\n * live. Needs {@link setThinInstances} first.\n *\n * @param mesh - The instanced mesh that owns the culling pass.\n * @param pad - The extra radius in world units; `0` is the exact sphere.\n *\n * @internal\n */\nexport function setThinInstanceCullBoundsPad(mesh: Mesh, pad: number): void {\n liteSetThinInstanceCullBoundsPad(mesh, pad);\n}\n\n/**\n * Makes a mesh's world bounds the union of its instances' boxes rather than the prototype's own.\n *\n * @remarks\n * The hook it installs is `O(count)` per bounds computation, and it clamps to\n * `matrices.length / 16`, so a short slab cannot walk off the end. It is read by\n * `expandWorldAabbForMesh` — the scene camera's extent and PBR's scene-size probe — and **not** by\n * the directional shadow fit; see the module note.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function enableThinInstanceWorldBounds(mesh: Mesh): void {\n liteEnableThinInstanceWorldBounds(mesh);\n}\n\n/**\n * Opts a fixed-capacity pool into indirect draw arguments, so a later count change keeps the\n * cached render bundle valid.\n *\n * @param mesh - The instanced mesh.\n *\n * @internal\n */\nexport function enableThinInstanceDynamicDrawCount(mesh: Mesh): void {\n liteEnableThinInstanceDynamicDrawCount(mesh);\n}\n\n/**\n * Where a LOD pairing switches, and how softly.\n *\n * @internal\n */\nexport interface ThinInstanceLodOptions {\n /** The camera distance, in world units, at which an in-frustum instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance threshold dither window centred on `distance`; `0` is a hard cut. */\n readonly band: number;\n}\n\n/**\n * Pairs a GPU-culled instanced mesh with a lower-detail partner.\n *\n * @remarks\n * Both meshes must already carry thin instances, and the partner may reference the very same matrix\n * slab. While paired the partner draws **only** the far bucket, and the pairing switches its own\n * GPU culling on. Lite refuses the pairing when either mesh has more than one thin-instance owner,\n * when the partner is already paired, or when the partner carries colours the full mesh does not\n * (`ThrowLiteError(375)`, `(377)`, `(379)`). Calling it again with the same pair re-sets `distance`\n * and `band` live.\n *\n * @param fullMesh - The near mesh, which owns the culling pass.\n * @param lodMesh - The far mesh.\n * @param options - Where the switch happens, and how softly.\n *\n * @internal\n */\nexport function setThinInstanceLodPartner(fullMesh: Mesh, lodMesh: Mesh, options: ThinInstanceLodOptions): void {\n liteSetThinInstanceLodPartner(fullMesh, lodMesh, { distance: options.distance, band: options.band });\n}\n\n/**\n * Dissolves a LOD pairing, returning both meshes to independent rendering.\n *\n * @remarks\n * A no-op when the mesh is not paired, so it is safe on the teardown path.\n *\n * @param fullMesh - The near mesh of the pair.\n *\n * @internal\n */\nexport function clearThinInstanceLodPartner(fullMesh: Mesh): void {\n liteClearThinInstanceLodPartner(fullMesh);\n}\n\n/**\n * How many instances a mesh is currently drawing, as Lite sees it.\n *\n * @remarks\n * The browser tests assert against Lite's own state rather than against the component's copy of it,\n * which is the only way to prove the two agree.\n *\n * @param mesh - The mesh to read.\n * @returns The active count, or `0` when the mesh carries no thin instances.\n *\n * @internal\n */\nexport function thinInstanceCount(mesh: Mesh): number {\n return mesh.thinInstances?.count ?? 0;\n}\n","import {\n addMeshToScene,\n cloneMeshUnderNode,\n detachMeshBounds,\n removeMeshFromScene,\n setMeshBounds,\n setMeshId,\n setMeshMaterial,\n setMeshPickable,\n setMeshReceiveShadows,\n setMeshRenderOrder,\n setMeshSubtreeVisible,\n} from \"../../lite/gpu/mesh.js\";\nimport {\n clearThinInstanceLodPartner,\n enableThinInstanceDynamicDrawCount,\n enableThinInstanceGpuCulling,\n enableThinInstanceWorldBounds,\n flushThinInstances,\n setThinInstanceColors,\n setThinInstanceCount,\n setThinInstanceCullBoundsPad,\n setThinInstanceLodPartner,\n setThinInstances,\n trySetThinInstanceDrawCount,\n} from \"../../lite/gpu/thin-instances.js\";\nimport { tagNode } from \"../../lite/node.js\";\nimport { Vec3 } from \"../../math/vec3.js\";\nimport type { LiteMesh } from \"../../lite/gpu/mesh.js\";\nimport type { LiteMaterial } from \"../../lite/material.js\";\nimport type { LiteSceneNode, NodeTag } from \"../../lite/node.js\";\nimport type { LiteScene } from \"../../lite/scene.js\";\nimport type { Transform } from \"../../transform/transform.js\";\n\n/**\n * One `InstancedMeshRenderer`'s near mesh and its optional LOD partner, and everything that writes\n * to them (`docs/plan/2026-09-terrain-particles-shaders.md` §3.5).\n *\n * Every line needs a WebGPU device, which is why it sits in `src/render/gpu/` — excluded from the\n * Node coverage floor and measured by the browser project — and why the component reaches it through\n * a dynamic `import()` (`../instanced-mesh-support.ts`).\n *\n * `capacity`, `gpuCulling` and the partner's identity are constructor arguments rather than `apply*`\n * methods because Lite fixes all three at `registerScene`; `distance` and `band` may be re-set live\n * by calling the pairing again. Both meshes share one matrix slab, which the pairing requires: it\n * compacts the near mesh's culling output into two buckets drawn from the same matrices.\n *\n * Bounds are the one thing an instanced caster needs that a plain mesh does not.\n * `computeDirectionalLightMatrix` composes `mesh.worldMatrix × mesh.boundMin/boundMax` directly\n * (`lib/shadow/shadow-base.js` 54) and never consults the `_expandWorldBounds` hook\n * `enableThinInstanceWorldBounds` installs, so a cloud left at its prototype's box casts nothing\n * (measured on SwiftShader, 2026-09-08). {@link InstancedMeshInstance.applyBounds} publishes the\n * union of the live placements instead; culling accuracy is unaffected because each instance's cull\n * sphere comes from the real vertices (`lib/mesh/thin-instance-gpu-culling.js` 426).\n */\n\n/** What the component remembers between uploads. Mutated in place, so a frame allocates nothing. */\nexport interface InstancedUploadState {\n /** The whole slab has to be re-pointed and re-uploaded. */\n isSlabDirty: boolean;\n /** The caller mutated the slab in place, so the active range has to be re-uploaded. */\n isRangeDirty: boolean;\n /** The count the meshes were last told about. */\n appliedCount: number;\n /** The capacity the meshes were built with. */\n appliedCapacity: number;\n /** Whether the union bounds have been published at least once. */\n hasAppliedBounds: boolean;\n /** Whether the last upload carried a colour slab. */\n hadColors: boolean;\n}\n\n/** The LOD switch the component declares, as much of it as the adapter reads. */\nexport interface InstancedLodFields {\n /** The camera distance at which an instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance dither window. */\n readonly band: number;\n}\n\n/** The LOD partner an instance is built with. */\nexport interface InstancedLodConfig {\n /** The coarse template to clone. */\n readonly template: LiteMesh;\n /** The camera distance, in world units, at which an instance switches to the partner. */\n readonly distance: number;\n /** The width of the per-instance dither window centred on `distance`. */\n readonly band: number;\n}\n\n/** The settings Lite fixes when the meshes are built. */\nexport interface InstancedMeshSettings {\n /** The largest instance count the meshes will ever draw. */\n readonly capacity: number;\n /** Whether the compute culling pass runs. */\n readonly gpuCulling: boolean;\n /** The LOD partner, or `null`. */\n readonly lod: InstancedLodConfig | null;\n}\n\n/**\n * A live instanced mesh, and its LOD partner, in a scene.\n *\n * @internal\n */\nexport class InstancedMeshInstance {\n /** The cloned near mesh, parented under the entity's node. */\n readonly clone: LiteSceneNode;\n\n readonly #lod: LiteSceneNode | null;\n\n #material: LiteMaterial;\n\n #receiveShadows: boolean | null = null;\n\n #renderOrder = Number.NaN;\n\n #pickable: boolean | null = null;\n\n #visible = false;\n\n #lodDistance: number;\n\n #lodBand: number;\n\n readonly #nearBox: Float64Array;\n\n readonly #lodBox: Float64Array | null;\n\n readonly #union = new Float64Array(6);\n\n /** The world-space displacement the culling pad and the bounds were last widened by. */\n #displacement = 0;\n\n /** The same displacement in object units, per axis, as the published bounds carry it. */\n readonly #margin = new Vec3();\n\n /** Scratch for the entity's world scale. */\n readonly #scale = new Vec3();\n\n /**\n * Clones the templates, gives them thin instances, applies the baked settings in Lite's required\n * order, and adds them to the scene.\n *\n * @param scene - The render scene.\n * @param template - The near mesh's template.\n * @param parent - The entity's transform node.\n * @param tag - The owning entity and component, for picking.\n * @param meshId - The string id Lite's light include/exclude sets match on.\n * @param material - The material both meshes draw with. Assigned **before** the meshes join the\n * scene, for the reason `MeshInstance`'s constructor records: `addToScene` buckets a mesh by its\n * material's build group.\n * @param settings - Capacity, GPU culling, and the LOD pairing.\n * @param matrices - The matrix slab, caller-owned and never copied.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\n constructor(\n scene: LiteScene,\n template: LiteMesh,\n parent: LiteSceneNode,\n tag: NodeTag,\n meshId: string,\n material: LiteMaterial,\n settings: InstancedMeshSettings,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n ) {\n const clone = cloneMeshUnderNode(template, parent);\n tagNode(clone, tag);\n const mesh = asMesh(clone);\n setMeshId(mesh, meshId);\n setMeshMaterial(mesh, material);\n // A clone shares the template's bound arrays, and `applyBounds` mutates them in place.\n detachMeshBounds(mesh);\n this.#nearBox = readBox(mesh);\n installThinInstances(mesh, settings.capacity, matrices, count, colors);\n enableThinInstanceGpuCulling(mesh, settings.gpuCulling);\n enableThinInstanceDynamicDrawCount(mesh);\n\n const lodConfig = settings.lod;\n let lodClone: LiteSceneNode | null = null;\n let lodBox: Float64Array | null = null;\n if (lodConfig !== null) {\n lodClone = cloneMeshUnderNode(lodConfig.template, parent);\n tagNode(lodClone, tag);\n const lodMesh = asMesh(lodClone);\n setMeshId(lodMesh, `${meshId}#lod`);\n setMeshMaterial(lodMesh, material);\n detachMeshBounds(lodMesh);\n lodBox = readBox(lodMesh);\n installThinInstances(lodMesh, settings.capacity, matrices, count, colors);\n setThinInstanceLodPartner(mesh, lodMesh, { distance: lodConfig.distance, band: lodConfig.band });\n }\n this.#lodBox = lodBox;\n\n this.#material = material;\n this.#lodDistance = lodConfig?.distance ?? 0;\n this.#lodBand = lodConfig?.band ?? 0;\n // Hidden until the first `applyVisible`, so a renderer on an inactive entity never flashes.\n setMeshSubtreeVisible(clone, false);\n addMeshToScene(scene, clone);\n if (lodClone !== null) {\n setMeshSubtreeVisible(lodClone, false);\n addMeshToScene(scene, lodClone);\n }\n this.clone = clone;\n this.#lod = lodClone;\n }\n\n /**\n * Whether the meshes are currently drawn.\n *\n * @returns `true` when Lite's `visible` is set on them.\n */\n get isVisible(): boolean {\n return this.#visible;\n }\n\n /**\n * The near mesh.\n *\n * @returns The clone, typed as a mesh.\n */\n get mesh(): LiteMesh {\n return asMesh(this.clone);\n }\n\n /**\n * The LOD partner.\n *\n * @returns The partner clone, or `null` when the renderer declares no LOD.\n */\n get lodMesh(): LiteMesh | null {\n const lod = this.#lod;\n return lod === null ? null : asMesh(lod);\n }\n\n /**\n * Assigns the material to both meshes, when it changed.\n *\n * @param material - The Lite material to draw with.\n */\n applyMaterial(material: LiteMaterial): void {\n if (material === this.#material) {\n return;\n }\n this.#material = material;\n setMeshMaterial(this.mesh, material);\n const lod = this.lodMesh;\n if (lod !== null) {\n setMeshMaterial(lod, material);\n }\n }\n\n /**\n * Writes the per-mesh flags that changed, to both meshes.\n *\n * @param receiveShadows - Whether shadow maps darken the meshes.\n * @param renderOrder - The sort key within the phase.\n * @param pickable - Whether picking considers the meshes at all.\n */\n applyFlags(receiveShadows: boolean, renderOrder: number, pickable: boolean): void {\n if (this.#receiveShadows !== receiveShadows) {\n this.#receiveShadows = receiveShadows;\n this.#eachMesh(setMeshReceiveShadows, receiveShadows);\n }\n if (this.#renderOrder !== renderOrder) {\n this.#renderOrder = renderOrder;\n this.#eachMesh(setMeshRenderOrder, renderOrder);\n }\n if (this.#pickable !== pickable) {\n this.#pickable = pickable;\n this.#eachMesh(setMeshPickable, pickable);\n }\n }\n\n /**\n * Re-sets the LOD switch distance and dither band, when either changed.\n *\n * @param distance - The camera distance at which an instance switches to the partner.\n * @param band - The width of the per-instance dither window centred on `distance`.\n */\n applyLod(distance: number, band: number): void {\n const lod = this.lodMesh;\n if (lod === null || (distance === this.#lodDistance && band === this.#lodBand)) {\n return;\n }\n this.#lodDistance = distance;\n this.#lodBand = band;\n setThinInstanceLodPartner(this.mesh, lod, { distance, band });\n }\n\n /**\n * Shows or hides both meshes, when the state changed.\n *\n * @param visible - `entity.activeInHierarchy && component.enabled`.\n */\n applyVisible(visible: boolean): void {\n if (visible === this.#visible) {\n return;\n }\n this.#visible = visible;\n setMeshSubtreeVisible(this.clone, visible);\n const lod = this.#lod;\n if (lod !== null) {\n setMeshSubtreeVisible(lod, visible);\n }\n }\n\n /**\n * Re-points both meshes at a matrix slab and re-uploads the active range.\n *\n * @param capacity - The capacity the meshes were built with; re-stating it keeps `_capacity`\n * unchanged, which is what stops Lite from re-creating the GPU buffer.\n * @param matrices - The slab, caller-owned.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\n applySlab(capacity: number, matrices: Float32Array, count: number, colors: Float32Array | null): void {\n installThinInstances(this.mesh, capacity, matrices, count, colors);\n const lod = this.lodMesh;\n if (lod !== null) {\n installThinInstances(lod, capacity, matrices, count, colors);\n }\n }\n\n /**\n * Changes how many instances draw, by the cheapest route Lite accepts.\n *\n * @param count - The active count, at most the capacity.\n */\n applyCount(count: number): void {\n applyMeshCount(this.mesh, count);\n const lod = this.lodMesh;\n if (lod !== null) {\n applyMeshCount(lod, count);\n }\n }\n\n /**\n * Marks the whole active range dirty, after the caller mutated the slab in place.\n *\n * @param colors - The colour slab, when the renderer has one, so its own dirty range moves too.\n */\n flush(colors: Float32Array | null): void {\n flushThinInstances(this.mesh);\n const lod = this.lodMesh;\n if (lod !== null) {\n flushThinInstances(lod);\n }\n if (colors !== null) {\n setThinInstanceColors(this.mesh, colors);\n if (lod !== null) {\n setThinInstanceColors(lod, colors);\n }\n }\n }\n\n /**\n * Publishes the union of the live instance placements as both meshes' object-local bounds, so a\n * directional light's shadow frustum is fitted to the cloud rather than to the prototype.\n *\n * @remarks\n * `O(count)`, allocation-free, and worth paying only for a caster — see the module note. A count\n * of zero restores the prototype's own box, so an empty cloud does not report an infinite one.\n *\n * @param matrices - The live matrix slab.\n * @param count - How many instances are drawn.\n */\n applyBounds(matrices: Float32Array, count: number): void {\n const near = this.#nearBox;\n const lodBox = this.#lodBox;\n const lod = this.lodMesh;\n const margin = this.#margin;\n if (count <= 0) {\n writeBox(this.mesh, near, margin);\n if (lod !== null && lodBox !== null) {\n writeBox(lod, lodBox, margin);\n }\n return;\n }\n const union = this.#union;\n unionOfPlacements(matrices, count, near, union);\n writeBox(this.mesh, union, margin);\n if (lod !== null && lodBox !== null) {\n unionOfPlacements(matrices, count, lodBox, union);\n writeBox(lod, union, margin);\n }\n }\n\n /**\n * Widens both meshes for a vertex stage that moves vertices up to `displacement` metres: the GPU\n * culler pads every instance's sphere, and the bounds published for a shadow frustum grow too.\n *\n * @remarks\n * The culling pad is world-space already. The bounds are object-local, so each axis is divided by\n * the entity's world scale along it. A change clears `state.hasAppliedBounds`, so the next\n * {@link InstancedMeshInstance.sync} re-publishes them.\n *\n * @param state - The component's upload state.\n * @param displacement - The material's displacement, in world metres.\n * @param transform - The entity's transform, whose world scale the meshes inherit.\n */\n applyDisplacement(state: InstancedUploadState, displacement: number, transform: Transform): void {\n if (displacement !== this.#displacement) {\n this.#displacement = displacement;\n // Only the near mesh runs the culling pass; the partner draws from its output.\n setThinInstanceCullBoundsPad(this.mesh, displacement);\n }\n const scale = this.#scale;\n if (displacement > 0) {\n transform.lossyScaleToRef(scale);\n }\n const x = objectMargin(displacement, scale.x);\n const y = objectMargin(displacement, scale.y);\n const z = objectMargin(displacement, scale.z);\n const margin = this.#margin;\n if (x !== margin.x || y !== margin.y || z !== margin.z) {\n margin.set(x, y, z);\n state.hasAppliedBounds = false;\n }\n }\n\n /**\n * Writes everything the component changed since the last frame onto both meshes.\n *\n * @param state - The component's upload state, mutated in place.\n * @param material - The material both meshes draw with.\n * @param receiveShadows - Whether shadow maps darken them.\n * @param renderOrder - The sort key within the phase.\n * @param pickable - Whether picking considers them.\n * @param lod - The LOD record, whose `distance` and `band` Lite re-applies live; `null` for none.\n * @param matrices - The caller-owned matrix slab.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n * @param castShadows - Whether the union bounds have to be published for a shadow frustum.\n * @param visible - `entity.activeInHierarchy && component.enabled`.\n * @returns `true` when the compiled pipeline has to change, which only a colour slab arriving or\n * leaving does.\n */\n sync(\n state: InstancedUploadState,\n material: LiteMaterial,\n receiveShadows: boolean,\n renderOrder: number,\n pickable: boolean,\n lod: InstancedLodFields | null,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n castShadows: boolean,\n visible: boolean,\n ): boolean {\n this.applyMaterial(material);\n this.applyFlags(receiveShadows, renderOrder, pickable);\n if (lod !== null) {\n this.applyLod(lod.distance, lod.band);\n }\n let renderablesChanged = false;\n let placementsMoved = false;\n if (state.isSlabDirty) {\n state.isSlabDirty = false;\n state.isRangeDirty = false;\n this.applySlab(state.appliedCapacity, matrices, count, colors);\n state.appliedCount = count;\n placementsMoved = true;\n const hasColors = colors !== null;\n renderablesChanged = hasColors !== state.hadColors;\n state.hadColors = hasColors;\n } else {\n if (state.isRangeDirty) {\n state.isRangeDirty = false;\n this.flush(colors);\n placementsMoved = true;\n }\n if (count !== state.appliedCount) {\n state.appliedCount = count;\n this.applyCount(count);\n placementsMoved = true;\n }\n }\n // Only a caster pays the `O(count)` bounds pass, and only in a frame whose placements moved.\n if (castShadows && (placementsMoved || !state.hasAppliedBounds)) {\n state.hasAppliedBounds = true;\n this.applyBounds(matrices, count);\n }\n this.applyVisible(visible);\n return renderablesChanged;\n }\n\n /**\n * Appends both meshes to a shadow caster list, when the renderer casts and they are drawn.\n *\n * @param castShadows - Whether the renderer casts.\n * @param out - The caster list being built.\n */\n collectCasters(castShadows: boolean, out: LiteMesh[]): void {\n if (!castShadows || !this.#visible) {\n return;\n }\n out.push(this.mesh);\n const lod = this.lodMesh;\n if (lod !== null) {\n out.push(lod);\n }\n }\n\n /**\n * Dissolves the LOD pairing and removes both meshes from the scene, releasing their share of the\n * templates' buffers.\n *\n * @param scene - The render scene.\n */\n destroy(scene: LiteScene): void {\n const lod = this.#lod;\n if (lod !== null) {\n clearThinInstanceLodPartner(this.mesh);\n removeMeshFromScene(scene, lod);\n }\n removeMeshFromScene(scene, this.clone);\n }\n\n /**\n * Runs a per-mesh Lite setter over the near mesh and the partner.\n *\n * @typeParam T - The setter's value type.\n * @param write - The adapter function to call.\n * @param value - What to write.\n */\n #eachMesh<T>(write: (mesh: LiteMesh, value: T) => void, value: T): void {\n write(this.mesh, value);\n const lod = this.lodMesh;\n if (lod !== null) {\n write(lod, value);\n }\n }\n}\n\n/**\n * Builds the live meshes, filling in the LOD pairing when both templates exist.\n *\n * @param scene - The render scene.\n * @param template - The near mesh's template.\n * @param lodTemplate - The coarse template, or `null`.\n * @param lod - The LOD record the component declares, or `null`.\n * @param parent - The entity's transform node.\n * @param tag - The owning entity and component, for picking.\n * @param meshId - The string id Lite's light include/exclude sets match on.\n * @param material - The material both meshes draw with.\n * @param capacity - The largest instance count the meshes will ever draw.\n * @param gpuCulling - Whether the compute culling pass runs.\n * @param matrices - The matrix slab.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n * @returns The instance.\n *\n * @internal\n */\nexport function createInstancedMesh(\n scene: LiteScene,\n template: LiteMesh,\n lodTemplate: LiteMesh | null,\n lod: InstancedLodFields | null,\n parent: LiteSceneNode,\n tag: NodeTag,\n meshId: string,\n material: LiteMaterial,\n capacity: number,\n gpuCulling: boolean,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n): InstancedMeshInstance {\n const pairing: InstancedLodConfig | null =\n lodTemplate === null || lod === null ? null : { template: lodTemplate, distance: lod.distance, band: lod.band };\n return new InstancedMeshInstance(\n scene,\n template,\n parent,\n tag,\n meshId,\n material,\n { capacity, gpuCulling, lod: pairing },\n matrices,\n count,\n colors,\n );\n}\n\n/**\n * Removes the meshes from the scene, when there are any.\n *\n * @param instance - The live meshes, or `null`.\n * @param scene - The render scene.\n * @returns `true` when something left the scene.\n *\n * @internal\n */\nexport function releaseInstancedMesh(instance: InstancedMeshInstance | null, scene: LiteScene): boolean {\n if (instance === null) {\n return false;\n }\n instance.destroy(scene);\n return true;\n}\n\n/**\n * Gives one mesh its thin instances in the order Lite requires, at a fixed capacity.\n *\n * @remarks\n * `setThinInstances` is handed the **capacity** so that `_capacity` — and the GPU buffer it sizes —\n * never moves; the active count is then lowered in the same breath, before any frame can read the\n * range in between (`src/lite/gpu/thin-instances.ts`).\n *\n * @param mesh - The mesh to instance.\n * @param capacity - The capacity to fix.\n * @param matrices - The slab, caller-owned.\n * @param count - How many instances draw.\n * @param colors - Four floats per instance, or `null`.\n */\nfunction installThinInstances(\n mesh: LiteMesh,\n capacity: number,\n matrices: Float32Array,\n count: number,\n colors: Float32Array | null,\n): void {\n setThinInstances(mesh, matrices, capacity);\n setThinInstanceCount(mesh, count);\n setThinInstanceColors(mesh, colors);\n enableThinInstanceWorldBounds(mesh);\n}\n\n/**\n * Changes one mesh's active count without re-uploading when Lite allows it, and with a re-upload\n * when it does not.\n *\n * @param mesh - The instanced mesh.\n * @param count - The active count.\n */\nfunction applyMeshCount(mesh: LiteMesh, count: number): void {\n if (!trySetThinInstanceDrawCount(mesh, count)) {\n setThinInstanceCount(mesh, count);\n }\n}\n\n/**\n * Reads a mesh's object-local box into six numbers.\n *\n * @remarks\n * A mesh built by any Lite factory carries bounds; the fallback half-metre cube is the same default\n * `computeDirectionalLightMatrix` uses for a mesh that does not\n * (`lib/shadow/shadow-base.js` 62).\n *\n * @param mesh - The mesh to read.\n * @returns `minX, minY, minZ, maxX, maxY, maxZ`.\n */\nfunction readBox(mesh: LiteMesh): Float64Array {\n const min = mesh.boundMin ?? [-0.5, -0.5, -0.5];\n const max = mesh.boundMax ?? [0.5, 0.5, 0.5];\n return Float64Array.of(min[0], min[1], min[2], max[0], max[1], max[2]);\n}\n\n/**\n * Writes a six-number box back onto a mesh, grown by a margin on every side.\n *\n * @param mesh - The mesh to re-bound.\n * @param box - `minX, minY, minZ, maxX, maxY, maxZ`.\n * @param margin - How far to grow each axis, in object units.\n */\nfunction writeBox(mesh: LiteMesh, box: Float64Array, margin: Vec3): void {\n setMeshBounds(\n mesh,\n (box[0] ?? 0) - margin.x,\n (box[1] ?? 0) - margin.y,\n (box[2] ?? 0) - margin.z,\n (box[3] ?? 0) + margin.x,\n (box[4] ?? 0) + margin.y,\n (box[5] ?? 0) + margin.z,\n );\n}\n\n/**\n * Converts a world-space margin into the object-space margin along one axis.\n *\n * @param margin - The margin, in world metres.\n * @param scale - The entity's world scale along the axis.\n * @returns The margin in object units; `0` for no margin or a collapsed axis.\n */\nfunction objectMargin(margin: number, scale: number): number {\n return margin > 0 && scale > 1e-9 ? margin / scale : 0;\n}\n\n/**\n * The axis-aligned union of a prototype box placed under every live instance matrix.\n *\n * @remarks\n * The same oriented-box-to-AABB composition Lite's own\n * `expandThinInstanceWorldBounds` uses, minus the world matrix — because `Mesh.boundMin`/`boundMax`\n * are documented to be **object-local**, the frame `worldMatrix` maps out of. Degenerate matrices\n * are skipped, exactly as Lite skips them, so a slot that has not been written yet does not drag\n * the box to the origin.\n *\n * @param matrices - The slab, 16 column-major floats per instance.\n * @param count - How many instances to consider.\n * @param box - The prototype's own box.\n * @param out - Receives `minX, minY, minZ, maxX, maxY, maxZ`.\n */\nfunction unionOfPlacements(matrices: Float32Array, count: number, box: Float64Array, out: Float64Array): void {\n const centreX = ((box[0] ?? 0) + (box[3] ?? 0)) * 0.5;\n const centreY = ((box[1] ?? 0) + (box[4] ?? 0)) * 0.5;\n const centreZ = ((box[2] ?? 0) + (box[5] ?? 0)) * 0.5;\n const extentX = ((box[3] ?? 0) - (box[0] ?? 0)) * 0.5;\n const extentY = ((box[4] ?? 0) - (box[1] ?? 0)) * 0.5;\n const extentZ = ((box[5] ?? 0) - (box[2] ?? 0)) * 0.5;\n out[0] = Number.POSITIVE_INFINITY;\n out[1] = Number.POSITIVE_INFINITY;\n out[2] = Number.POSITIVE_INFINITY;\n out[3] = Number.NEGATIVE_INFINITY;\n out[4] = Number.NEGATIVE_INFINITY;\n out[5] = Number.NEGATIVE_INFINITY;\n const usable = Math.min(count, Math.floor(matrices.length / 16));\n let placed = 0;\n for (let index = 0; index < usable; index += 1) {\n const base = index * 16;\n let scale = 0;\n for (let element = 0; element < 12; element += 1) {\n if (element % 4 !== 3) {\n scale += Math.abs(matrices[base + element] ?? 0);\n }\n }\n if (scale < 1e-9) {\n continue;\n }\n placed += 1;\n for (let row = 0; row < 3; row += 1) {\n const m0 = matrices[base + row] ?? 0;\n const m1 = matrices[base + 4 + row] ?? 0;\n const m2 = matrices[base + 8 + row] ?? 0;\n const centre = (matrices[base + 12 + row] ?? 0) + m0 * centreX + m1 * centreY + m2 * centreZ;\n const radius = Math.abs(m0) * extentX + Math.abs(m1) * extentY + Math.abs(m2) * extentZ;\n const low = centre - radius;\n const high = centre + radius;\n if (low < (out[row] ?? 0)) {\n out[row] = low;\n }\n if (high > (out[row + 3] ?? 0)) {\n out[row + 3] = high;\n }\n }\n }\n if (placed === 0) {\n out.set(box);\n }\n}\n\n/**\n * Narrows a cloned subtree root to a mesh.\n *\n * @remarks\n * The same boundary assertion `MeshInstance` makes, for the same reason: `cloneTransformNode` is\n * typed as returning the wider `SceneNode` because it also clones plain transform nodes, and the\n * clone of a mesh is a mesh (coding standards §5.2).\n *\n * @param node - The clone.\n * @returns The same object, typed as a mesh.\n */\nfunction asMesh(node: LiteSceneNode): LiteMesh {\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- see the note above.\n return node as LiteMesh;\n}\n"],"mappings":"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"}
|
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import { n as assertNever, o as CoreErrorCode, t as IgnifxError } from "./ignifx-error-
|
|
1
|
+
import { n as assertNever, o as CoreErrorCode, t as IgnifxError } from "./ignifx-error-Der0bpHK.js";
|
|
2
2
|
import { u as SHADER_UNIFORM_TYPES } from "./shader-declaration-5q__jycG.js";
|
|
3
3
|
//#region src/render/material-plugin.ts
|
|
4
4
|
/**
|
|
@@ -281,4 +281,4 @@ function assertUniformType(plugin, binding, type) {
|
|
|
281
281
|
//#endregion
|
|
282
282
|
export { defineMaterialPlugin as a, MATERIAL_PLUGIN_SAMPLER_BUDGET as i, MATERIAL_PLUGIN_DEFAULT_PRIORITY as n, isLiteMaterialPluginPoint as o, MATERIAL_PLUGIN_RESERVED_NAMES as r, uniformComponentCount as s, LITE_MATERIAL_PLUGIN_POINTS as t };
|
|
283
283
|
|
|
284
|
-
//# sourceMappingURL=material-plugin-
|
|
284
|
+
//# sourceMappingURL=material-plugin-B-hartHR.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"material-plugin-BUlqLsap.js","names":[],"sources":["../src/render/material-plugin.ts"],"sourcesContent":["import { CoreErrorCode } from \"../errors/error-codes.js\";\nimport { assertNever, IgnifxError } from \"../errors/ignifx-error.js\";\nimport { SHADER_UNIFORM_TYPES } from \"./shader-declaration.js\";\nimport type { ShaderTextureDeclaration, ShaderUniformDeclaration, ShaderUniformType } from \"./shader-declaration.js\";\n\n/**\n * The raw Babylon Lite material-plugin points, as a `@beta` escape hatch\n * (`docs/plan/2026-09-terrain-particles-shaders.md` §3.2, ADR-0024).\n *\n * `@beta` because the meaning of each point is whatever the surrounding Lite template declares at\n * that line; ignifx's stable contract is the three hooks of `./surface-shader.ts`. Four rules read\n * out of `@babylonjs/lite@1.27.0`'s `lib/` on 2026-09-08:\n *\n * - Plugin uniforms and samplers are **fragment-stage only** on both families\n * (`lib/material/plugin/plugin-bridge-shared.js` 99), and there is no vertex helper-function\n * channel, so vertex code may read only attributes, `mesh.world` and the scene block, and must be\n * statements rather than functions.\n * - `CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION` is injected **twice** — Lite maps it to the two\n * adjacent PBR slots `AI` and `NI` — so its code must be idempotent or guard itself with a flag\n * set at an earlier point, and must declare nothing at statement level.\n * - Only PBR carries `CUSTOM_FRAGMENT_UPDATE_DIFFUSE` after `CUSTOM_FRAGMENT_UPDATE_ALPHA`;\n * Standard's template orders them the other way and has no `AI`/`NI`/`MF` slots.\n * - `roughness` and `metallic` are `let` in the PBR template and cannot be written.\n */\n\n/**\n * The Babylon Lite injection points a {@link MaterialPluginDefinition} may fill in.\n *\n * @remarks\n * The names are Lite's own (`MaterialPluginPoint`, `index.d.ts` 7084) and are taught verbatim,\n * because a plugin's code is written against the template around the point.\n *\n * @beta\n */\nexport const LITE_MATERIAL_PLUGIN_POINTS = [\n \"CUSTOM_FRAGMENT_DEFINITIONS\",\n \"CUSTOM_FRAGMENT_MAIN_BEGIN\",\n \"CUSTOM_FRAGMENT_UPDATE_ALPHA\",\n \"CUSTOM_FRAGMENT_UPDATE_DIFFUSE\",\n \"CUSTOM_FRAGMENT_BEFORE_LIGHTS\",\n \"CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\",\n \"CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\",\n \"CUSTOM_VERTEX_MAIN_BEGIN\",\n \"CUSTOM_VERTEX_UPDATE_WORLDPOS\",\n \"CUSTOM_VERTEX_MAIN_END\",\n] as const;\n\n/**\n * One of Babylon Lite's ten material-plugin injection points.\n *\n * @beta\n */\nexport type LiteMaterialPluginPoint = (typeof LITE_MATERIAL_PLUGIN_POINTS)[number];\n\n/**\n * The default priority Babylon Lite gives a plugin with none (`index.d.ts` 7057).\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_DEFAULT_PRIORITY = 500;\n\n/**\n * How many `texture`/`sampler` pairs one material's plugins may declare together.\n *\n * @remarks\n * Measured on a device on 2026-09-08 (spike S0.2): a fully textured PBR material — base colour,\n * normal, ORM, emissive — with image-based lighting and one PCF shadow light already binds seven\n * textures and seven samplers of the sixteen per stage that every WebGPU implementation guarantees,\n * SwiftShader included, and Lite requests no higher `requiredLimits`. Nine is what is left, and it\n * drops to eight with a second shadow light and seven with a lightmap, so a material that means to\n * be portable should stay well under the cap.\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_SAMPLER_BUDGET = 9;\n\n/**\n * The WGSL names the PBR and Standard templates already own, which a plugin may not reuse for a\n * uniform field or a sampler.\n *\n * @remarks\n * A plugin's fields land in the host's own uniform block and its samplers in the host's own bind\n * group, so a collision is a duplicate WGSL declaration and the whole material stops compiling with\n * a message that names neither the plugin nor the field. Refusing at attach time is the difference\n * between a sentence and a shader dump. Read from `pbr-template.js` `_baseMaterialUboFields` and\n * `_baseBindings`, and `standard-template.js` `materialStruct` and `_baseBindings`.\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_RESERVED_NAMES: readonly string[] = Object.freeze([\n // Blocks and entry points the templates declare.\n \"material\",\n \"mesh\",\n \"scene\",\n \"lights\",\n \"pluginUbo\",\n \"shadowParams\",\n \"main\",\n // PBR material uniform fields.\n \"environmentIntensity\",\n \"directIntensity\",\n \"reflectance\",\n \"materialAlpha\",\n \"baseColorFactor\",\n \"metallicFactor\",\n \"roughnessFactor\",\n \"normalScale\",\n \"lightFalloffMode\",\n \"anisotropyParams\",\n // PBR samplers.\n \"baseColorTexture\",\n \"baseColorSampler\",\n \"normalTexture\",\n \"normalSampler_\",\n \"ormTexture\",\n \"ormSampler\",\n \"emissiveTexture\",\n \"emissiveSampler\",\n \"specGlossTexture\",\n \"specGlossSampler\",\n // Standard samplers (`standard-template.js` uses two-letter names).\n \"dT\",\n \"dS\",\n \"mat\",\n \"up\",\n]);\n\n/**\n * What a raw material plugin declares: a name, the values and textures it wants beside the host\n * material's own, and the WGSL it injects.\n *\n * @beta\n */\nexport interface MaterialPluginDefinition {\n /** The plugin's identity. It is part of Lite's pipeline cache key, so it must be stable. */\n readonly name: string;\n /** Lower runs first; Lite's own default is {@link MATERIAL_PLUGIN_DEFAULT_PRIORITY}. */\n readonly priority: number;\n /** The uniform fields appended to the host material's uniform block. Fragment stage only. */\n readonly uniforms: readonly ShaderUniformDeclaration[];\n /** The `texture`/`sampler` pairs added to the host material's bind group. Fragment stage only. */\n readonly textures: readonly ShaderTextureDeclaration[];\n /** The WGSL to inject, by point. Vertex points take statements; there are no vertex helpers. */\n readonly code: Readonly<Partial<Record<LiteMaterialPluginPoint, string>>>;\n}\n\n/**\n * The properties {@link defineMaterialPlugin} accepts; everything but `name` and `code` has a\n * default.\n *\n * @beta\n */\nexport interface MaterialPluginDefinitionInit {\n /** The plugin's identity. */\n readonly name: string;\n /** Lower runs first. Defaults to {@link MATERIAL_PLUGIN_DEFAULT_PRIORITY}. */\n readonly priority?: number;\n /** The uniform fields. Defaults to none. */\n readonly uniforms?: readonly ShaderUniformDeclaration[];\n /** The samplers. Defaults to none. */\n readonly textures?: readonly ShaderTextureDeclaration[];\n /** The WGSL to inject, by point. */\n readonly code: Readonly<Partial<Record<LiteMaterialPluginPoint, string>>>;\n}\n\n/** Matches a WGSL identifier. */\nconst IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\n/** Matches a legal plugin name: an identifier, optionally with `.`, `:`, or `-` inside it. */\nconst PLUGIN_NAME = /^[A-Za-z_][A-Za-z0-9_]*(?:[.:-][A-Za-z0-9_]+)*$/;\n\n/**\n * Validates a raw material-plugin declaration and fills in its defaults.\n *\n * @remarks\n * Nothing here reaches a device: the result is plain data that `attachSurfaceShaders` and\n * `attachMaterialPlugin` turn into a Lite plugin. The checks are the ones whose failure would\n * otherwise surface as a WGSL compile error with no mention of the plugin — an empty `code`, a\n * duplicate or reserved binding name, a name that is not a WGSL identifier, an unknown injection\n * point, or more samplers than {@link MATERIAL_PLUGIN_SAMPLER_BUDGET}.\n *\n * The **surface-shader compiler produces one of these**, so a bug in this validation is a bug in\n * every surface shader too, which is why it lives here rather than inside the compiler.\n *\n * @param definition - The declaration.\n * @returns The same declaration with `priority`, `uniforms`, and `textures` filled in.\n * @throws IgnifxError with code `IGX-0723` when `code` fills in no point, `IGX-0712` when a name is\n * not a legal, unique, unreserved WGSL identifier or a point name is unknown, or `IGX-0726` when the\n * plugin alone exceeds the sampler budget.\n *\n * @example\n * ```ts\n * const tint = defineMaterialPlugin({\n * name: \"tint\",\n * code: { CUSTOM_FRAGMENT_UPDATE_ALPHA: \"baseColor = baseColor * vec3<f32>(1.0, 0.5, 0.5);\" },\n * });\n * ```\n *\n * @beta\n */\nexport function defineMaterialPlugin(definition: MaterialPluginDefinitionInit): MaterialPluginDefinition {\n const name = definition.name;\n if (!PLUGIN_NAME.test(name)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${JSON.stringify(name)} is not a legal material-plugin name.`,\n {\n context: { plugin: name, name },\n hint: \"Start with a letter or underscore; letters, digits, underscores, and inner . : - follow.\",\n },\n );\n }\n const points = Object.keys(definition.code);\n let filled = 0;\n for (const point of points) {\n if (!isLiteMaterialPluginPoint(point)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${name} declares no Lite point named ${point}.`, {\n context: { plugin: name, name: point, point },\n hint: `The ten points are ${LITE_MATERIAL_PLUGIN_POINTS.join(\", \")}.`,\n });\n }\n if ((definition.code[point] ?? \"\").trim().length > 0) {\n filled += 1;\n }\n }\n if (filled === 0) {\n throw new IgnifxError(CoreErrorCode.surfaceHookMissing, `${name} injects no WGSL at any Lite point.`, {\n context: { plugin: name, name },\n hint: \"Fill in at least one of the ten points, or do not attach the plugin.\",\n });\n }\n const uniforms = definition.uniforms ?? [];\n const textures = definition.textures ?? [];\n const seen = new Set<string>();\n for (const uniform of uniforms) {\n assertBindingName(name, uniform.name, seen);\n assertUniformType(name, uniform.name, uniform.type);\n }\n for (const texture of textures) {\n assertBindingName(name, texture.name, seen);\n assertBindingName(name, `${texture.name}Sampler`, seen);\n }\n if (textures.length > MATERIAL_PLUGIN_SAMPLER_BUDGET) {\n throw new IgnifxError(\n CoreErrorCode.surfaceSamplerBudgetExceeded,\n `${name} declares ${String(textures.length)} samplers; a material's plugins may declare ${String(MATERIAL_PLUGIN_SAMPLER_BUDGET)} together.`,\n {\n context: { plugin: name, samplers: textures.length, budget: MATERIAL_PLUGIN_SAMPLER_BUDGET },\n hint: \"Pack the maps into fewer textures — an RGBA control map rather than four masks.\",\n },\n );\n }\n return {\n name,\n priority: definition.priority ?? MATERIAL_PLUGIN_DEFAULT_PRIORITY,\n uniforms,\n textures,\n code: definition.code,\n };\n}\n\n/**\n * Whether a string is one of Lite's ten injection points.\n *\n * @param value - The candidate.\n * @returns `true` when Lite accepts it.\n *\n * @beta\n */\nexport function isLiteMaterialPluginPoint(value: string): value is LiteMaterialPluginPoint {\n for (const point of LITE_MATERIAL_PLUGIN_POINTS) {\n if (point === value) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * How many floats one uniform of a declared type occupies on the CPU side.\n *\n * @param type - The declared WGSL type.\n * @returns The component count: 1, 2, 3, 4, or 16.\n *\n * @internal\n */\nexport function uniformComponentCount(type: ShaderUniformType): number {\n switch (type) {\n case \"vec2<f32>\": {\n return 2;\n }\n case \"vec3<f32>\": {\n return 3;\n }\n case \"vec4<f32>\": {\n return 4;\n }\n case \"mat4x4<f32>\": {\n return 16;\n }\n case \"f32\":\n case \"u32\":\n case \"i32\": {\n return 1;\n }\n default: {\n return assertNever(type, \"shader uniform type\");\n }\n }\n}\n\n/**\n * Refuses a binding name that is not a unique, unreserved WGSL identifier.\n *\n * @param plugin - The plugin's name, for the message.\n * @param binding - The candidate name.\n * @param seen - The names already taken by this plugin; the accepted name is added.\n * @throws IgnifxError with code `IGX-0712`.\n */\nfunction assertBindingName(plugin: string, binding: string, seen: Set<string>): void {\n if (!IDENTIFIER.test(binding)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${plugin} declares ${JSON.stringify(binding)}, which is not a WGSL identifier.`,\n { context: { plugin, name: binding }, hint: \"Use letters, digits, and underscores, starting with a letter.\" },\n );\n }\n if (MATERIAL_PLUGIN_RESERVED_NAMES.includes(binding)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${plugin} declares ${binding}, which Babylon Lite's own PBR or Standard shader already owns.`,\n { context: { plugin, name: binding }, hint: \"Rename it; a plugin shares the host material's WGSL namespace.\" },\n );\n }\n if (seen.has(binding)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${plugin} declares ${binding} twice.`, {\n context: { plugin, name: binding },\n hint: \"Every uniform and texture of one plugin needs its own name.\",\n });\n }\n seen.add(binding);\n}\n\n/**\n * Refuses a uniform type Lite's plugin bridge cannot carry.\n *\n * @param plugin - The plugin's name, for the message.\n * @param binding - The uniform's name.\n * @param type - The declared type.\n * @throws IgnifxError with code `IGX-0712`.\n */\nfunction assertUniformType(plugin: string, binding: string, type: ShaderUniformType): void {\n if (!SHADER_UNIFORM_TYPES.includes(type)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${plugin}.${binding} declares the type ${type}.`, {\n context: { plugin, name: binding, type },\n hint: `The plugin uniform types are ${SHADER_UNIFORM_TYPES.join(\", \")}.`,\n });\n }\n}\n"],"mappings":"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"}
|
|
1
|
+
{"version":3,"file":"material-plugin-B-hartHR.js","names":[],"sources":["../src/render/material-plugin.ts"],"sourcesContent":["import { CoreErrorCode } from \"../errors/error-codes.js\";\nimport { assertNever, IgnifxError } from \"../errors/ignifx-error.js\";\nimport { SHADER_UNIFORM_TYPES } from \"./shader-declaration.js\";\nimport type { ShaderTextureDeclaration, ShaderUniformDeclaration, ShaderUniformType } from \"./shader-declaration.js\";\n\n/**\n * The raw Babylon Lite material-plugin points, as a `@beta` escape hatch\n * (`docs/plan/2026-09-terrain-particles-shaders.md` §3.2, ADR-0024).\n *\n * `@beta` because the meaning of each point is whatever the surrounding Lite template declares at\n * that line; ignifx's stable contract is the three hooks of `./surface-shader.ts`. Four rules read\n * out of `@babylonjs/lite@1.27.0`'s `lib/` on 2026-09-08:\n *\n * - Plugin uniforms and samplers are **fragment-stage only** on both families\n * (`lib/material/plugin/plugin-bridge-shared.js` 99), and there is no vertex helper-function\n * channel, so vertex code may read only attributes, `mesh.world` and the scene block, and must be\n * statements rather than functions.\n * - `CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION` is injected **twice** — Lite maps it to the two\n * adjacent PBR slots `AI` and `NI` — so its code must be idempotent or guard itself with a flag\n * set at an earlier point, and must declare nothing at statement level.\n * - Only PBR carries `CUSTOM_FRAGMENT_UPDATE_DIFFUSE` after `CUSTOM_FRAGMENT_UPDATE_ALPHA`;\n * Standard's template orders them the other way and has no `AI`/`NI`/`MF` slots.\n * - `roughness` and `metallic` are `let` in the PBR template and cannot be written.\n */\n\n/**\n * The Babylon Lite injection points a {@link MaterialPluginDefinition} may fill in.\n *\n * @remarks\n * The names are Lite's own (`MaterialPluginPoint`, `index.d.ts` 7084) and are taught verbatim,\n * because a plugin's code is written against the template around the point.\n *\n * @beta\n */\nexport const LITE_MATERIAL_PLUGIN_POINTS = [\n \"CUSTOM_FRAGMENT_DEFINITIONS\",\n \"CUSTOM_FRAGMENT_MAIN_BEGIN\",\n \"CUSTOM_FRAGMENT_UPDATE_ALPHA\",\n \"CUSTOM_FRAGMENT_UPDATE_DIFFUSE\",\n \"CUSTOM_FRAGMENT_BEFORE_LIGHTS\",\n \"CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION\",\n \"CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR\",\n \"CUSTOM_VERTEX_MAIN_BEGIN\",\n \"CUSTOM_VERTEX_UPDATE_WORLDPOS\",\n \"CUSTOM_VERTEX_MAIN_END\",\n] as const;\n\n/**\n * One of Babylon Lite's ten material-plugin injection points.\n *\n * @beta\n */\nexport type LiteMaterialPluginPoint = (typeof LITE_MATERIAL_PLUGIN_POINTS)[number];\n\n/**\n * The default priority Babylon Lite gives a plugin with none (`index.d.ts` 7057).\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_DEFAULT_PRIORITY = 500;\n\n/**\n * How many `texture`/`sampler` pairs one material's plugins may declare together.\n *\n * @remarks\n * Measured on a device on 2026-09-08 (spike S0.2): a fully textured PBR material — base colour,\n * normal, ORM, emissive — with image-based lighting and one PCF shadow light already binds seven\n * textures and seven samplers of the sixteen per stage that every WebGPU implementation guarantees,\n * SwiftShader included, and Lite requests no higher `requiredLimits`. Nine is what is left, and it\n * drops to eight with a second shadow light and seven with a lightmap, so a material that means to\n * be portable should stay well under the cap.\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_SAMPLER_BUDGET = 9;\n\n/**\n * The WGSL names the PBR and Standard templates already own, which a plugin may not reuse for a\n * uniform field or a sampler.\n *\n * @remarks\n * A plugin's fields land in the host's own uniform block and its samplers in the host's own bind\n * group, so a collision is a duplicate WGSL declaration and the whole material stops compiling with\n * a message that names neither the plugin nor the field. Refusing at attach time is the difference\n * between a sentence and a shader dump. Read from `pbr-template.js` `_baseMaterialUboFields` and\n * `_baseBindings`, and `standard-template.js` `materialStruct` and `_baseBindings`.\n *\n * @beta\n */\nexport const MATERIAL_PLUGIN_RESERVED_NAMES: readonly string[] = Object.freeze([\n // Blocks and entry points the templates declare.\n \"material\",\n \"mesh\",\n \"scene\",\n \"lights\",\n \"pluginUbo\",\n \"shadowParams\",\n \"main\",\n // PBR material uniform fields.\n \"environmentIntensity\",\n \"directIntensity\",\n \"reflectance\",\n \"materialAlpha\",\n \"baseColorFactor\",\n \"metallicFactor\",\n \"roughnessFactor\",\n \"normalScale\",\n \"lightFalloffMode\",\n \"anisotropyParams\",\n // PBR samplers.\n \"baseColorTexture\",\n \"baseColorSampler\",\n \"normalTexture\",\n \"normalSampler_\",\n \"ormTexture\",\n \"ormSampler\",\n \"emissiveTexture\",\n \"emissiveSampler\",\n \"specGlossTexture\",\n \"specGlossSampler\",\n // Standard samplers (`standard-template.js` uses two-letter names).\n \"dT\",\n \"dS\",\n \"mat\",\n \"up\",\n]);\n\n/**\n * What a raw material plugin declares: a name, the values and textures it wants beside the host\n * material's own, and the WGSL it injects.\n *\n * @beta\n */\nexport interface MaterialPluginDefinition {\n /** The plugin's identity. It is part of Lite's pipeline cache key, so it must be stable. */\n readonly name: string;\n /** Lower runs first; Lite's own default is {@link MATERIAL_PLUGIN_DEFAULT_PRIORITY}. */\n readonly priority: number;\n /** The uniform fields appended to the host material's uniform block. Fragment stage only. */\n readonly uniforms: readonly ShaderUniformDeclaration[];\n /** The `texture`/`sampler` pairs added to the host material's bind group. Fragment stage only. */\n readonly textures: readonly ShaderTextureDeclaration[];\n /** The WGSL to inject, by point. Vertex points take statements; there are no vertex helpers. */\n readonly code: Readonly<Partial<Record<LiteMaterialPluginPoint, string>>>;\n}\n\n/**\n * The properties {@link defineMaterialPlugin} accepts; everything but `name` and `code` has a\n * default.\n *\n * @beta\n */\nexport interface MaterialPluginDefinitionInit {\n /** The plugin's identity. */\n readonly name: string;\n /** Lower runs first. Defaults to {@link MATERIAL_PLUGIN_DEFAULT_PRIORITY}. */\n readonly priority?: number;\n /** The uniform fields. Defaults to none. */\n readonly uniforms?: readonly ShaderUniformDeclaration[];\n /** The samplers. Defaults to none. */\n readonly textures?: readonly ShaderTextureDeclaration[];\n /** The WGSL to inject, by point. */\n readonly code: Readonly<Partial<Record<LiteMaterialPluginPoint, string>>>;\n}\n\n/** Matches a WGSL identifier. */\nconst IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\n/** Matches a legal plugin name: an identifier, optionally with `.`, `:`, or `-` inside it. */\nconst PLUGIN_NAME = /^[A-Za-z_][A-Za-z0-9_]*(?:[.:-][A-Za-z0-9_]+)*$/;\n\n/**\n * Validates a raw material-plugin declaration and fills in its defaults.\n *\n * @remarks\n * Nothing here reaches a device: the result is plain data that `attachSurfaceShaders` and\n * `attachMaterialPlugin` turn into a Lite plugin. The checks are the ones whose failure would\n * otherwise surface as a WGSL compile error with no mention of the plugin — an empty `code`, a\n * duplicate or reserved binding name, a name that is not a WGSL identifier, an unknown injection\n * point, or more samplers than {@link MATERIAL_PLUGIN_SAMPLER_BUDGET}.\n *\n * The **surface-shader compiler produces one of these**, so a bug in this validation is a bug in\n * every surface shader too, which is why it lives here rather than inside the compiler.\n *\n * @param definition - The declaration.\n * @returns The same declaration with `priority`, `uniforms`, and `textures` filled in.\n * @throws IgnifxError with code `IGX-0723` when `code` fills in no point, `IGX-0712` when a name is\n * not a legal, unique, unreserved WGSL identifier or a point name is unknown, or `IGX-0726` when the\n * plugin alone exceeds the sampler budget.\n *\n * @example\n * ```ts\n * const tint = defineMaterialPlugin({\n * name: \"tint\",\n * code: { CUSTOM_FRAGMENT_UPDATE_ALPHA: \"baseColor = baseColor * vec3<f32>(1.0, 0.5, 0.5);\" },\n * });\n * ```\n *\n * @beta\n */\nexport function defineMaterialPlugin(definition: MaterialPluginDefinitionInit): MaterialPluginDefinition {\n const name = definition.name;\n if (!PLUGIN_NAME.test(name)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${JSON.stringify(name)} is not a legal material-plugin name.`,\n {\n context: { plugin: name, name },\n hint: \"Start with a letter or underscore; letters, digits, underscores, and inner . : - follow.\",\n },\n );\n }\n const points = Object.keys(definition.code);\n let filled = 0;\n for (const point of points) {\n if (!isLiteMaterialPluginPoint(point)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${name} declares no Lite point named ${point}.`, {\n context: { plugin: name, name: point, point },\n hint: `The ten points are ${LITE_MATERIAL_PLUGIN_POINTS.join(\", \")}.`,\n });\n }\n if ((definition.code[point] ?? \"\").trim().length > 0) {\n filled += 1;\n }\n }\n if (filled === 0) {\n throw new IgnifxError(CoreErrorCode.surfaceHookMissing, `${name} injects no WGSL at any Lite point.`, {\n context: { plugin: name, name },\n hint: \"Fill in at least one of the ten points, or do not attach the plugin.\",\n });\n }\n const uniforms = definition.uniforms ?? [];\n const textures = definition.textures ?? [];\n const seen = new Set<string>();\n for (const uniform of uniforms) {\n assertBindingName(name, uniform.name, seen);\n assertUniformType(name, uniform.name, uniform.type);\n }\n for (const texture of textures) {\n assertBindingName(name, texture.name, seen);\n assertBindingName(name, `${texture.name}Sampler`, seen);\n }\n if (textures.length > MATERIAL_PLUGIN_SAMPLER_BUDGET) {\n throw new IgnifxError(\n CoreErrorCode.surfaceSamplerBudgetExceeded,\n `${name} declares ${String(textures.length)} samplers; a material's plugins may declare ${String(MATERIAL_PLUGIN_SAMPLER_BUDGET)} together.`,\n {\n context: { plugin: name, samplers: textures.length, budget: MATERIAL_PLUGIN_SAMPLER_BUDGET },\n hint: \"Pack the maps into fewer textures — an RGBA control map rather than four masks.\",\n },\n );\n }\n return {\n name,\n priority: definition.priority ?? MATERIAL_PLUGIN_DEFAULT_PRIORITY,\n uniforms,\n textures,\n code: definition.code,\n };\n}\n\n/**\n * Whether a string is one of Lite's ten injection points.\n *\n * @param value - The candidate.\n * @returns `true` when Lite accepts it.\n *\n * @beta\n */\nexport function isLiteMaterialPluginPoint(value: string): value is LiteMaterialPluginPoint {\n for (const point of LITE_MATERIAL_PLUGIN_POINTS) {\n if (point === value) {\n return true;\n }\n }\n return false;\n}\n\n/**\n * How many floats one uniform of a declared type occupies on the CPU side.\n *\n * @param type - The declared WGSL type.\n * @returns The component count: 1, 2, 3, 4, or 16.\n *\n * @internal\n */\nexport function uniformComponentCount(type: ShaderUniformType): number {\n switch (type) {\n case \"vec2<f32>\": {\n return 2;\n }\n case \"vec3<f32>\": {\n return 3;\n }\n case \"vec4<f32>\": {\n return 4;\n }\n case \"mat4x4<f32>\": {\n return 16;\n }\n case \"f32\":\n case \"u32\":\n case \"i32\": {\n return 1;\n }\n default: {\n return assertNever(type, \"shader uniform type\");\n }\n }\n}\n\n/**\n * Refuses a binding name that is not a unique, unreserved WGSL identifier.\n *\n * @param plugin - The plugin's name, for the message.\n * @param binding - The candidate name.\n * @param seen - The names already taken by this plugin; the accepted name is added.\n * @throws IgnifxError with code `IGX-0712`.\n */\nfunction assertBindingName(plugin: string, binding: string, seen: Set<string>): void {\n if (!IDENTIFIER.test(binding)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${plugin} declares ${JSON.stringify(binding)}, which is not a WGSL identifier.`,\n { context: { plugin, name: binding }, hint: \"Use letters, digits, and underscores, starting with a letter.\" },\n );\n }\n if (MATERIAL_PLUGIN_RESERVED_NAMES.includes(binding)) {\n throw new IgnifxError(\n CoreErrorCode.unknownShaderBinding,\n `${plugin} declares ${binding}, which Babylon Lite's own PBR or Standard shader already owns.`,\n { context: { plugin, name: binding }, hint: \"Rename it; a plugin shares the host material's WGSL namespace.\" },\n );\n }\n if (seen.has(binding)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${plugin} declares ${binding} twice.`, {\n context: { plugin, name: binding },\n hint: \"Every uniform and texture of one plugin needs its own name.\",\n });\n }\n seen.add(binding);\n}\n\n/**\n * Refuses a uniform type Lite's plugin bridge cannot carry.\n *\n * @param plugin - The plugin's name, for the message.\n * @param binding - The uniform's name.\n * @param type - The declared type.\n * @throws IgnifxError with code `IGX-0712`.\n */\nfunction assertUniformType(plugin: string, binding: string, type: ShaderUniformType): void {\n if (!SHADER_UNIFORM_TYPES.includes(type)) {\n throw new IgnifxError(CoreErrorCode.unknownShaderBinding, `${plugin}.${binding} declares the type ${type}.`, {\n context: { plugin, name: binding, type },\n hint: `The plugin uniform types are ${SHADER_UNIFORM_TYPES.join(\", \")}.`,\n });\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,8BAA8B;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;AAcA,MAAa,mCAAmC;;;;;;;;;;;;;;AAehD,MAAa,iCAAiC;;;;;;;;;;;;;;AAe9C,MAAa,iCAAoD,OAAO,OAAO;CAE7E;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;AACF,CAAC;;AAyCD,MAAM,aAAa;;AAGnB,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BpB,SAAgB,qBAAqB,YAAoE;CACvG,MAAM,OAAO,WAAW;CACxB,IAAI,CAAC,YAAY,KAAK,IAAI,GACxB,MAAM,IAAI,YACR,cAAc,sBACd,GAAG,KAAK,UAAU,IAAI,EAAE,wCACxB;EACE,SAAS;GAAE,QAAQ;GAAM;EAAK;EAC9B,MAAM;CACR,CACF;CAEF,MAAM,SAAS,OAAO,KAAK,WAAW,IAAI;CAC1C,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,CAAC,0BAA0B,KAAK,GAClC,MAAM,IAAI,YAAY,cAAc,sBAAsB,GAAG,KAAK,gCAAgC,MAAM,IAAI;GAC1G,SAAS;IAAE,QAAQ;IAAM,MAAM;IAAO;GAAM;GAC5C,MAAM,sBAAsB,4BAA4B,KAAK,IAAI,EAAE;EACrE,CAAC;EAEH,KAAK,WAAW,KAAK,UAAU,GAAA,CAAI,KAAK,CAAC,CAAC,SAAS,GACjD,UAAU;CAEd;CACA,IAAI,WAAW,GACb,MAAM,IAAI,YAAY,cAAc,oBAAoB,GAAG,KAAK,sCAAsC;EACpG,SAAS;GAAE,QAAQ;GAAM;EAAK;EAC9B,MAAM;CACR,CAAC;CAEH,MAAM,WAAW,WAAW,YAAY,CAAC;CACzC,MAAM,WAAW,WAAW,YAAY,CAAC;CACzC,MAAM,uBAAO,IAAI,IAAY;CAC7B,KAAK,MAAM,WAAW,UAAU;EAC9B,kBAAkB,MAAM,QAAQ,MAAM,IAAI;EAC1C,kBAAkB,MAAM,QAAQ,MAAM,QAAQ,IAAI;CACpD;CACA,KAAK,MAAM,WAAW,UAAU;EAC9B,kBAAkB,MAAM,QAAQ,MAAM,IAAI;EAC1C,kBAAkB,MAAM,GAAG,QAAQ,KAAK,UAAU,IAAI;CACxD;CACA,IAAI,SAAS,SAAA,GACX,MAAM,IAAI,YACR,cAAc,8BACd,GAAG,KAAK,YAAY,OAAO,SAAS,MAAM,EAAE,8CAA8C,OAAA,CAAqC,EAAE,aACjI;EACE,SAAS;GAAE,QAAQ;GAAM,UAAU,SAAS;GAAQ,QAAA;EAAuC;EAC3F,MAAM;CACR,CACF;CAEF,OAAO;EACL;EACA,UAAU,WAAW,YAAA;EACrB;EACA;EACA,MAAM,WAAW;CACnB;AACF;;;;;;;;;AAUA,SAAgB,0BAA0B,OAAiD;CACzF,KAAK,MAAM,SAAS,6BAClB,IAAI,UAAU,OACZ,OAAO;CAGX,OAAO;AACT;;;;;;;;;AAUA,SAAgB,sBAAsB,MAAiC;CACrE,QAAQ,MAAR;EACE,KAAK,aACH,OAAO;EAET,KAAK,aACH,OAAO;EAET,KAAK,aACH,OAAO;EAET,KAAK,eACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK,OACH,OAAO;EAET,SACE,OAAO,YAAY,MAAM,qBAAqB;CAElD;AACF;;;;;;;;;AAUA,SAAS,kBAAkB,QAAgB,SAAiB,MAAyB;CACnF,IAAI,CAAC,WAAW,KAAK,OAAO,GAC1B,MAAM,IAAI,YACR,cAAc,sBACd,GAAG,OAAO,YAAY,KAAK,UAAU,OAAO,EAAE,oCAC9C;EAAE,SAAS;GAAE;GAAQ,MAAM;EAAQ;EAAG,MAAM;CAAgE,CAC9G;CAEF,IAAI,+BAA+B,SAAS,OAAO,GACjD,MAAM,IAAI,YACR,cAAc,sBACd,GAAG,OAAO,YAAY,QAAQ,kEAC9B;EAAE,SAAS;GAAE;GAAQ,MAAM;EAAQ;EAAG,MAAM;CAAiE,CAC/G;CAEF,IAAI,KAAK,IAAI,OAAO,GAClB,MAAM,IAAI,YAAY,cAAc,sBAAsB,GAAG,OAAO,YAAY,QAAQ,UAAU;EAChG,SAAS;GAAE;GAAQ,MAAM;EAAQ;EACjC,MAAM;CACR,CAAC;CAEH,KAAK,IAAI,OAAO;AAClB;;;;;;;;;AAUA,SAAS,kBAAkB,QAAgB,SAAiB,MAA+B;CACzF,IAAI,CAAC,qBAAqB,SAAS,IAAI,GACrC,MAAM,IAAI,YAAY,cAAc,sBAAsB,GAAG,OAAO,GAAG,QAAQ,qBAAqB,KAAK,IAAI;EAC3G,SAAS;GAAE;GAAQ,MAAM;GAAS;EAAK;EACvC,MAAM,gCAAgC,qBAAqB,KAAK,IAAI,EAAE;CACxE,CAAC;AAEL"}
|
|
@@ -0,0 +1,301 @@
|
|
|
1
|
+
import { createTransformNode, setParent } from "@babylonjs/lite";
|
|
2
|
+
//#region src/lite/node.ts
|
|
3
|
+
/** The single key ignifx owns inside Lite's open `metadata` record. */
|
|
4
|
+
const METADATA_KEY = "ignifx";
|
|
5
|
+
/** Number of elements in a 4x4 matrix. */
|
|
6
|
+
const MATRIX_LENGTH = 16;
|
|
7
|
+
/**
|
|
8
|
+
* Creates a pure transform node at the origin with an identity rotation and unit scale.
|
|
9
|
+
*
|
|
10
|
+
* @remarks
|
|
11
|
+
* The node is deliberately **not** added to any Lite scene: a transform node is only a matrix
|
|
12
|
+
* provider, and `worldMatrix` is valid the moment the node exists (see rule 5 in the module
|
|
13
|
+
* documentation). Renderable Lite objects created by components are parented under it and added
|
|
14
|
+
* with `addToScene` separately.
|
|
15
|
+
*
|
|
16
|
+
* @param name - A human-readable name; Lite never uses it for lookup and it need not be unique.
|
|
17
|
+
* @returns A fresh, unparented transform node.
|
|
18
|
+
*
|
|
19
|
+
* @example
|
|
20
|
+
* ```ts
|
|
21
|
+
* const node = createNode("Player");
|
|
22
|
+
* node.position.set(1, 2, 3);
|
|
23
|
+
* ```
|
|
24
|
+
*
|
|
25
|
+
* @internal
|
|
26
|
+
*/
|
|
27
|
+
function createNode(name) {
|
|
28
|
+
return createTransformNode(name);
|
|
29
|
+
}
|
|
30
|
+
/**
|
|
31
|
+
* Releases a pure transform node.
|
|
32
|
+
*
|
|
33
|
+
* @remarks
|
|
34
|
+
* Lite requires nothing to release a transform node that was never added to a scene: verified in
|
|
35
|
+
* `lib/scene/transform-node.js` and `lib/scene/scene-node.js`, the node is a plain object holding
|
|
36
|
+
* three observable values, one `Float32Array` for the cached world matrix, and closures — no GPU
|
|
37
|
+
* resource, no ref count, no scene registry. (Reference counting in `lib/resource/ref-count.js`
|
|
38
|
+
* applies to meshes and their GPU buffers only, and `disposeScene` never walks transform nodes.)
|
|
39
|
+
*
|
|
40
|
+
* What *does* need doing is breaking the parent link: a linked parent keeps a reference to this
|
|
41
|
+
* node's world-matrix state so it can invalidate it, so a node dropped while still parented is
|
|
42
|
+
* retained by its parent. This function therefore unlinks the node and drops the ignifx tag. It
|
|
43
|
+
* leaves the node's own `children` alone: the kernel destroys children before parents
|
|
44
|
+
* (`docs/architecture/01-lifecycle-and-time.md` §3 step 9), so each child unlinks itself first.
|
|
45
|
+
*
|
|
46
|
+
* @param node - A node from {@link createNode}.
|
|
47
|
+
*
|
|
48
|
+
* @internal
|
|
49
|
+
*/
|
|
50
|
+
function disposeNode(node) {
|
|
51
|
+
linkParent(node, null);
|
|
52
|
+
const metadata = node.metadata;
|
|
53
|
+
if (metadata !== void 0) delete metadata[METADATA_KEY];
|
|
54
|
+
}
|
|
55
|
+
/**
|
|
56
|
+
* Links `child` under `parent`, **keeping the child's local values** — its world transform moves
|
|
57
|
+
* with the new parent. This is `setParent(parent, { worldPositionStays: false })` in
|
|
58
|
+
* `docs/architecture/02-scene-graph.md` §5.1.
|
|
59
|
+
*
|
|
60
|
+
* @remarks
|
|
61
|
+
* Lite has no public helper for this case (its own `setParent` preserves the world transform), so
|
|
62
|
+
* the adapter does the linking itself: it assigns `child.parent`, which is the setter that
|
|
63
|
+
* re-registers the child's world-matrix state with the new parent and invalidates the subtree, and
|
|
64
|
+
* maintains the `children` arrays on both the old and the new parent so tree traversal stays
|
|
65
|
+
* consistent. Passing the parent the child already has is a no-op.
|
|
66
|
+
*
|
|
67
|
+
* @param child - The node to move.
|
|
68
|
+
* @param parent - The new parent, or `null` to detach the child to world space.
|
|
69
|
+
*
|
|
70
|
+
* @example
|
|
71
|
+
* ```ts
|
|
72
|
+
* linkParent(child, parent); // child keeps localPosition; its world position changes
|
|
73
|
+
* ```
|
|
74
|
+
*
|
|
75
|
+
* @internal
|
|
76
|
+
*/
|
|
77
|
+
function linkParent(child, parent) {
|
|
78
|
+
const previous = child.parent;
|
|
79
|
+
if (previous === parent) return;
|
|
80
|
+
const previousChildren = childrenOf(previous);
|
|
81
|
+
if (previousChildren !== null) {
|
|
82
|
+
const index = previousChildren.indexOf(child);
|
|
83
|
+
if (index >= 0) previousChildren.splice(index, 1);
|
|
84
|
+
}
|
|
85
|
+
child.parent = parent;
|
|
86
|
+
if (parent !== null && !parent.children.includes(child)) parent.children.push(child);
|
|
87
|
+
}
|
|
88
|
+
/**
|
|
89
|
+
* Reparents `child` under `parent` **keeping its world transform**, by delegating to Lite's own
|
|
90
|
+
* `setParent`. This is `setParent(parent, { worldPositionStays: true })`, the ignifx default
|
|
91
|
+
* (`docs/architecture/02-scene-graph.md` §5.1).
|
|
92
|
+
*
|
|
93
|
+
* @remarks
|
|
94
|
+
* Lite snapshots the child's world matrix, relinks the node (maintaining both `children` arrays),
|
|
95
|
+
* then decomposes `inverse(parentWorld) × childWorld` back into local TRS. Two documented caveats
|
|
96
|
+
* carry straight through to ignifx:
|
|
97
|
+
*
|
|
98
|
+
* - **Singular parent matrices.** When the parent's world matrix has a collapsed axis it cannot be
|
|
99
|
+
* inverted, so no local transform can reproduce the child's world. Lite then keeps the parent
|
|
100
|
+
* link and copies the child's world *position* into its local position, leaving rotation and
|
|
101
|
+
* scale uncompensated. Non-uniform-but-invertible parents are fine; zero scale on any axis is
|
|
102
|
+
* not.
|
|
103
|
+
* - **Canonical, not sign-faithful, decomposition.** The local TRS comes from `decomposeMat4`,
|
|
104
|
+
* which folds a reflection into a negative Y scale. The world matrix is reproduced exactly, but a
|
|
105
|
+
* child that had a negative X scale comes back with a negative Y scale and a different rotation.
|
|
106
|
+
*
|
|
107
|
+
* A third caveat in Lite's TSDoc — that `child.parent` links are only established by `addToScene`,
|
|
108
|
+
* so a node from a freshly loaded asset must have its container added before it is reparented —
|
|
109
|
+
* does not apply to nodes ignifx creates, because {@link linkParent} establishes the link itself.
|
|
110
|
+
*
|
|
111
|
+
* @param child - The node to move.
|
|
112
|
+
* @param parent - The new parent, or `null` to detach the child to world space.
|
|
113
|
+
*
|
|
114
|
+
* @internal
|
|
115
|
+
*/
|
|
116
|
+
function reparentKeepingWorld(child, parent) {
|
|
117
|
+
setParent(child, parent);
|
|
118
|
+
}
|
|
119
|
+
/**
|
|
120
|
+
* Copies a node's world matrix into `out`.
|
|
121
|
+
*
|
|
122
|
+
* @remarks
|
|
123
|
+
* Allocation-free on the ignifx side, which is why the destination is a parameter: Lite's
|
|
124
|
+
* `worldMatrix` getter may recompute up the parent chain, and the object it returns is Lite's own
|
|
125
|
+
* cache — never hold on to it. Lite documents `Mat4` as opaque ("callers MUST NOT depend on the
|
|
126
|
+
* underlying storage"); it is a `Float32Array` in 1.27.0 (`lib/math/_matrix-allocator.js`), so
|
|
127
|
+
* copying element by element is the only supported read.
|
|
128
|
+
*
|
|
129
|
+
* @param node - The node to read.
|
|
130
|
+
* @param out - A sink of at least 16 elements, written in column-major order.
|
|
131
|
+
* @returns `out`, for chaining.
|
|
132
|
+
*
|
|
133
|
+
* @internal
|
|
134
|
+
*/
|
|
135
|
+
function readWorldMatrix(node, out) {
|
|
136
|
+
const matrix = node.worldMatrix;
|
|
137
|
+
for (let index = 0; index < MATRIX_LENGTH; index += 1) out[index] = matrix[index] ?? 0;
|
|
138
|
+
return out;
|
|
139
|
+
}
|
|
140
|
+
/**
|
|
141
|
+
* Reads a node's world-matrix version — the counter that increases whenever the node's world
|
|
142
|
+
* matrix is invalidated, by its own TRS or by any ancestor's.
|
|
143
|
+
*
|
|
144
|
+
* @remarks
|
|
145
|
+
* Snapshot it to detect movement without comparing matrices; systems that maintain acceleration
|
|
146
|
+
* structures do exactly that (`docs/architecture/02-scene-graph.md` §9). The counter is
|
|
147
|
+
* monotonically increasing but not a change *count*: it moves on invalidation, not on
|
|
148
|
+
* recomputation, and a bulk `position.set(...)` bumps it even when the values are unchanged.
|
|
149
|
+
*
|
|
150
|
+
* @param node - The node to read.
|
|
151
|
+
* @returns The current version.
|
|
152
|
+
*
|
|
153
|
+
* @internal
|
|
154
|
+
*/
|
|
155
|
+
function worldMatrixVersion(node) {
|
|
156
|
+
return node.worldMatrixVersion;
|
|
157
|
+
}
|
|
158
|
+
/**
|
|
159
|
+
* Shows or hides **one** node, without touching its subtree.
|
|
160
|
+
*
|
|
161
|
+
* @remarks
|
|
162
|
+
* Lite's `visible` is per node — the renderer reads each node's own flag, and `setSubtreeVisible`
|
|
163
|
+
* is only a bulk helper that materialises a cascade at write time. ignifx already materialises
|
|
164
|
+
* `activeInHierarchy` over the subtree itself, so it writes one flag per entity: correct for a
|
|
165
|
+
* subtree that mixes active and inactive entities, and linear rather than quadratic.
|
|
166
|
+
*
|
|
167
|
+
* @param node - The node to show or hide.
|
|
168
|
+
* @param visible - `true` to show it, `false` to hide it.
|
|
169
|
+
*
|
|
170
|
+
* @internal
|
|
171
|
+
*/
|
|
172
|
+
function setNodeSelfVisible(node, visible) {
|
|
173
|
+
node.visible = visible;
|
|
174
|
+
}
|
|
175
|
+
/**
|
|
176
|
+
* Writes the ignifx identity into a node's Lite metadata bag, under the single `ignifx` key.
|
|
177
|
+
*
|
|
178
|
+
* @remarks
|
|
179
|
+
* `LiteMetadata` is an open record (`{ gltf?: GltfMetadata; [key: string]: unknown }`), so the tag
|
|
180
|
+
* coexists with the `gltf.extras` a glTF load writes. The metadata object is created on demand;
|
|
181
|
+
* nodes ignifx never tags keep `metadata` undefined.
|
|
182
|
+
*
|
|
183
|
+
* @param node - The node to tag.
|
|
184
|
+
* @param tag - The owning entity, and the component that created the node when it is not the
|
|
185
|
+
* entity's own transform.
|
|
186
|
+
*
|
|
187
|
+
* @internal
|
|
188
|
+
*/
|
|
189
|
+
function tagNode(node, tag) {
|
|
190
|
+
const metadata = node.metadata ??= {};
|
|
191
|
+
metadata[METADATA_KEY] = tag;
|
|
192
|
+
}
|
|
193
|
+
/**
|
|
194
|
+
* Reads the ignifx identity back from a node.
|
|
195
|
+
*
|
|
196
|
+
* @param node - The node to read; it may be any Lite node, including one ignifx never created.
|
|
197
|
+
* @returns The tag {@link tagNode} wrote, or `null` when the node carries none.
|
|
198
|
+
*
|
|
199
|
+
* @internal
|
|
200
|
+
*/
|
|
201
|
+
function readNodeTag(node) {
|
|
202
|
+
const metadata = node.metadata;
|
|
203
|
+
if (metadata === void 0) return null;
|
|
204
|
+
const value = metadata[METADATA_KEY];
|
|
205
|
+
if (typeof value !== "object" || value === null || !("entity" in value)) return null;
|
|
206
|
+
const entity = value.entity;
|
|
207
|
+
if (typeof entity !== "number") return null;
|
|
208
|
+
const component = "component" in value ? value.component : void 0;
|
|
209
|
+
return typeof component === "number" ? {
|
|
210
|
+
entity,
|
|
211
|
+
component
|
|
212
|
+
} : { entity };
|
|
213
|
+
}
|
|
214
|
+
/**
|
|
215
|
+
* The `children` array of a world-matrix provider, when it has one.
|
|
216
|
+
*
|
|
217
|
+
* @remarks
|
|
218
|
+
* `SceneNode.parent` is typed as the minimal {@link IWorldMatrixProvider}, which declares no
|
|
219
|
+
* `children`, but every parent ignifx links is a scene node. Lite's own `setParent` solves this the
|
|
220
|
+
* same way (`lib/scene/set-parent.js`), and the array check keeps a non-node provider — a camera,
|
|
221
|
+
* say — from being treated as a tree node.
|
|
222
|
+
*
|
|
223
|
+
* @param provider - The candidate parent.
|
|
224
|
+
* @returns The provider's children, or `null` when it is not a tree node.
|
|
225
|
+
*/
|
|
226
|
+
function childrenOf(provider) {
|
|
227
|
+
if (provider === null || !("children" in provider)) return null;
|
|
228
|
+
const children = provider.children;
|
|
229
|
+
return Array.isArray(children) ? children : null;
|
|
230
|
+
}
|
|
231
|
+
/**
|
|
232
|
+
* The node's local position as a live, writable view.
|
|
233
|
+
*
|
|
234
|
+
* @remarks
|
|
235
|
+
* Zero-copy: the returned object *is* Lite's `ObservableVec3` over the node's TRS, so `.x += 1`,
|
|
236
|
+
* `.set(x, y, z)`, and `.copyFrom(v)` write straight through and invalidate the subtree's world
|
|
237
|
+
* matrices (`docs/architecture/02-scene-graph.md` §5). Never hold it past the node's lifetime.
|
|
238
|
+
*
|
|
239
|
+
* @param node - The node to view.
|
|
240
|
+
* @returns The live local position.
|
|
241
|
+
*
|
|
242
|
+
* @internal
|
|
243
|
+
*/
|
|
244
|
+
function localPosition(node) {
|
|
245
|
+
return node.position;
|
|
246
|
+
}
|
|
247
|
+
/**
|
|
248
|
+
* The node's local rotation as a live, writable view.
|
|
249
|
+
*
|
|
250
|
+
* @param node - The node to view.
|
|
251
|
+
* @returns The live local rotation quaternion.
|
|
252
|
+
*
|
|
253
|
+
* @internal
|
|
254
|
+
*/
|
|
255
|
+
function localRotation(node) {
|
|
256
|
+
return node.rotationQuaternion;
|
|
257
|
+
}
|
|
258
|
+
/**
|
|
259
|
+
* The node's local scale as a live, writable view.
|
|
260
|
+
*
|
|
261
|
+
* @param node - The node to view.
|
|
262
|
+
* @returns The live local scale.
|
|
263
|
+
*
|
|
264
|
+
* @internal
|
|
265
|
+
*/
|
|
266
|
+
function localScale(node) {
|
|
267
|
+
return node.scaling;
|
|
268
|
+
}
|
|
269
|
+
/**
|
|
270
|
+
* Renames a node.
|
|
271
|
+
*
|
|
272
|
+
* @remarks
|
|
273
|
+
* Lite never uses the name for lookup, so this is purely for debugging and for the names that show
|
|
274
|
+
* up in Lite-side tooling; ignifx keeps `Entity.name` as the source of truth and mirrors it here.
|
|
275
|
+
*
|
|
276
|
+
* @param node - The node to rename.
|
|
277
|
+
* @param name - The new name.
|
|
278
|
+
*
|
|
279
|
+
* @internal
|
|
280
|
+
*/
|
|
281
|
+
function setNodeName(node, name) {
|
|
282
|
+
node.name = name;
|
|
283
|
+
}
|
|
284
|
+
/**
|
|
285
|
+
* The parent a node is currently linked to, when that parent is itself a scene node.
|
|
286
|
+
*
|
|
287
|
+
* @param node - The node to read.
|
|
288
|
+
* @returns The parent node, or `null` when the node is unparented or its parent is a bare
|
|
289
|
+
* world-matrix provider such as a camera.
|
|
290
|
+
*
|
|
291
|
+
* @internal
|
|
292
|
+
*/
|
|
293
|
+
function parentNode(node) {
|
|
294
|
+
const parent = node.parent;
|
|
295
|
+
if (parent === null || !("children" in parent)) return null;
|
|
296
|
+
return parent;
|
|
297
|
+
}
|
|
298
|
+
//#endregion
|
|
299
|
+
export { localRotation as a, readNodeTag as c, setNodeName as d, setNodeSelfVisible as f, localPosition as i, readWorldMatrix as l, worldMatrixVersion as m, disposeNode as n, localScale as o, tagNode as p, linkParent as r, parentNode as s, createNode as t, reparentKeepingWorld as u };
|
|
300
|
+
|
|
301
|
+
//# sourceMappingURL=node-DznSvwap.js.map
|