@ignifx/core 0.18.0 → 0.20.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.
Files changed (57) hide show
  1. package/dist/{environment-DZ6WUHbm.js → environment-Bf4aphSb.js} +2 -2
  2. package/dist/{environment-DZ6WUHbm.js.map → environment-Bf4aphSb.js.map} +1 -1
  3. package/dist/{gtao-_nr0b6-E.js → gtao-Bpu5-0Ne.js} +2 -2
  4. package/dist/{gtao-_nr0b6-E.js.map → gtao-Bpu5-0Ne.js.map} +1 -1
  5. package/dist/{hdr-output-Dbv0lhFl.js → hdr-output-DBQwMphy.js} +2 -2
  6. package/dist/{hdr-output-Dbv0lhFl.js.map → hdr-output-DBQwMphy.js.map} +1 -1
  7. package/dist/{ignifx-error-B8ByiSfJ.js → ignifx-error-DwIZKxA2.js} +4 -1
  8. package/dist/ignifx-error-DwIZKxA2.js.map +1 -0
  9. package/dist/index.d.ts +218 -696
  10. package/dist/index.d.ts.map +1 -1
  11. package/dist/index.js +2904 -970
  12. package/dist/index.js.map +1 -1
  13. package/dist/{instanced-mesh-instance-BMhREEfx.js → instanced-mesh-instance-B-fXKSrY.js} +2 -2
  14. package/dist/{instanced-mesh-instance-BMhREEfx.js.map → instanced-mesh-instance-B-fXKSrY.js.map} +1 -1
  15. package/dist/{light-probe-asset-B60_X-yN.js → light-probe-asset-BqfSrJe9.js} +2 -2
  16. package/dist/{light-probe-asset-B60_X-yN.js.map → light-probe-asset-BqfSrJe9.js.map} +1 -1
  17. package/dist/{light-probes-DkYN89Qw.js → light-probes-DDojYajw.js} +4 -4
  18. package/dist/{light-probes-DkYN89Qw.js.map → light-probes-DDojYajw.js.map} +1 -1
  19. package/dist/lightmaps-BUUIIkt9.js +230 -0
  20. package/dist/lightmaps-BUUIIkt9.js.map +1 -0
  21. package/dist/{material-CGk5mAah.js → material-myMbl9mW.js} +37 -2
  22. package/dist/{material-CGk5mAah.js.map → material-myMbl9mW.js.map} +1 -1
  23. package/dist/{material-plugin-CiAmriQ_.js → material-plugin-DapJNj04.js} +2 -2
  24. package/dist/{material-plugin-CiAmriQ_.js.map → material-plugin-DapJNj04.js.map} +1 -1
  25. package/dist/{post-effect-CQnlX1RH.js → post-effect-Cu3Enpz7.js} +2 -2
  26. package/dist/{post-effect-CQnlX1RH.js.map → post-effect-Cu3Enpz7.js.map} +1 -1
  27. package/dist/{post-effect-compiler-C_7HTHZy.js → post-effect-compiler-cCq9lcHt.js} +3 -3
  28. package/dist/{post-effect-compiler-C_7HTHZy.js.map → post-effect-compiler-cCq9lcHt.js.map} +1 -1
  29. package/dist/{prefab-overrides-DT-wHHAJ.js → prefab-overrides-C2GsgOQc.js} +467 -30
  30. package/dist/prefab-overrides-C2GsgOQc.js.map +1 -0
  31. package/dist/{prefab-overrides-BLQn5yHS.d.ts → prefab-overrides-htDc_5Po.d.ts} +1370 -246
  32. package/dist/prefab-overrides-htDc_5Po.d.ts.map +1 -0
  33. package/dist/prefab.d.ts +2 -2
  34. package/dist/prefab.js +2 -2
  35. package/dist/{reflection-probe-DlVsl3zJ.js → reflection-probe-QkD1Fo_d.js} +106 -12
  36. package/dist/{reflection-probe-DlVsl3zJ.js.map → reflection-probe-QkD1Fo_d.js.map} +1 -1
  37. package/dist/reflection-probes-CAzSuqf8.js +921 -0
  38. package/dist/reflection-probes-CAzSuqf8.js.map +1 -0
  39. package/dist/{shader-material-CaAkv5nT.js → shader-material-CJIDFvSb.js} +2 -2
  40. package/dist/{shader-material-CaAkv5nT.js.map → shader-material-CJIDFvSb.js.map} +1 -1
  41. package/dist/{shader-material-C2_UCYdO.js → shader-material-TM4f8eKA.js} +4 -4
  42. package/dist/{shader-material-C2_UCYdO.js.map → shader-material-TM4f8eKA.js.map} +1 -1
  43. package/dist/{shader-pragma-DmZpxGUo.js → shader-pragma-ljmAbVc2.js} +2 -2
  44. package/dist/{shader-pragma-DmZpxGUo.js.map → shader-pragma-ljmAbVc2.js.map} +1 -1
  45. package/dist/{ssgi-Dm-maZrc.js → ssgi-DSnhqotl.js} +2 -2
  46. package/dist/{ssgi-Dm-maZrc.js.map → ssgi-DSnhqotl.js.map} +1 -1
  47. package/dist/{surface-shader-BeDRofOV.js → surface-shader-rpPpeosD.js} +6 -6
  48. package/dist/{surface-shader-BeDRofOV.js.map → surface-shader-rpPpeosD.js.map} +1 -1
  49. package/dist/{vec3-Cc19wl4r.js → vec3-2C3LBZnt.js} +55 -3
  50. package/dist/vec3-2C3LBZnt.js.map +1 -0
  51. package/package.json +1 -1
  52. package/dist/ignifx-error-B8ByiSfJ.js.map +0 -1
  53. package/dist/prefab-overrides-BLQn5yHS.d.ts.map +0 -1
  54. package/dist/prefab-overrides-DT-wHHAJ.js.map +0 -1
  55. package/dist/reflection-probes-B8S9WnVX.js +0 -551
  56. package/dist/reflection-probes-B8S9WnVX.js.map +0 -1
  57. package/dist/vec3-Cc19wl4r.js.map +0 -1
@@ -300,6 +300,8 @@ declare const CoreErrorCode: {
300
300
  readonly invalidFrameWait: "IGX-0733";
301
301
  /** `bakeLightProbes` was given a grid, ray count or distance it cannot bake. */
302
302
  readonly invalidLightProbeBake: "IGX-0734";
303
+ /** A `MeshRenderer`'s lightmap is not drawn as declared: the entity is not static, the material is not PBR, or the placement is not the identity. */
304
+ readonly lightmapNotApplied: "IGX-0735";
303
305
  /** The host exposes no Web Crypto implementation. */
304
306
  readonly cryptoUnavailable: "IGX-1420";
305
307
  /** A storage namespace name is not a legal namespace segment. */
@@ -4140,8 +4142,9 @@ interface SchemaDescription {
4140
4142
  */
4141
4143
  readonly builtIn?: boolean;
4142
4144
  /**
4143
- * The components the class lists in `static requires`, as type ids (`null` for a class without a
4144
- * `typeId`), in declaration order. `addComponent` adds each one that is missing, so an editor adds
4145
+ * The components the class lists in `static requires`, as type ids (`null` for a class that
4146
+ * declares no `typeId` of its own, such as an unregistered subclass that only inherits its
4147
+ * parent's), in declaration order. `addComponent` adds each one that is missing, so an editor adds
4145
4148
  * them itself, and a scene file may list them in any order. A component on the entity whose class
4146
4149
  * extends a required class counts as present. Set by {@link describeRegisteredSchemas}, or by the
4147
4150
  * caller through {@link SchemaDescriptionMeta}; absent when the class requires nothing.
@@ -5865,134 +5868,81 @@ declare class LightProbeHost {
5865
5868
  dispose(): void;
5866
5869
  }
5867
5870
  //#endregion
5868
- //#region src/render/reflection-probe.d.ts
5871
+ //#region src/lite/material.d.ts
5869
5872
  /**
5870
- * The `ReflectionProbe` component (`docs/plan/2026-11-gi-phase-2-execution-plan.md`, step B1).
5873
+ * Material half of the Babylon Lite adapter (`docs/architecture/07-rendering.md` §2.6): the three
5874
+ * material kinds a `MaterialAsset` can produce, built from plain ignifx props.
5871
5875
  *
5872
- * The component only holds settings and the "capture again" request. The renderer loads the probe's
5873
- * GPU code (`./gpu/reflection-probes.ts`, `../lite/gpu/reflection-probe.ts`) only once a world has
5874
- * a probe, so a project without one pays nothing for it (`CONSTITUTION.md` §2.5). Headless, a probe
5875
- * captures nothing.
5876
+ * Everything here is `@internal`, and every colour that reaches it is **linear** — the sRGB decode
5877
+ * belongs to the asset layer.
5878
+ *
5879
+ * ## What a Lite material is (verified against `@babylonjs/lite@1.27.0`)
5880
+ *
5881
+ * - A material is plain data plus one private `_buildGroup` function; `createPbrMaterial` is
5882
+ * literally `{ ...props, _buildGroup, _uboVersion: 0 }` (`lib/material/pbr/pbr-material.js`), so
5883
+ * none of these factories touches the GPU and all of them run under the null engine.
5884
+ * - **The build group is a per-family singleton.** `getPbrGroupBuilder()`, `getStandardGroupBuilder()`
5885
+ * and `getShaderGroupBuilder()` each memoise one function for the whole process
5886
+ * (`lib/material/pbr/pbr-material.js`, `lib/material/standard/create-standard-material.js`,
5887
+ * `lib/material/shader/shader-material.js` line 123), and a scene keys its renderable groups by
5888
+ * that function (`lib/scene/scene-core.js`, `addToScene`). "Material family" in
5889
+ * `docs/architecture/07-rendering.md` §1.1 therefore means *pbr*, *standard*, *shader* or *node* —
5890
+ * **not** an individual material. Only node materials get a per-material builder
5891
+ * (`lib/material/node/node-material.js`). This is what makes {@link warmUpMaterialFamilies} in
5892
+ * `./gpu/warm-up.ts` cheap: one hidden mesh per family covers every material in it.
5893
+ * - Scalar and vector edits only need `markMaterialUboDirty` (`index.d.ts` 6974), which bumps
5894
+ * `_uboVersion`. Anything that changes the compiled feature set — binding or clearing a texture,
5895
+ * flipping `doubleSided`, changing culling — needs {@link rebuildMaterialPipelines}.
5896
+ *
5897
+ * ## The custom WGSL family lives elsewhere
5898
+ *
5899
+ * `createShaderMaterial` and the `setShader*` setters are in `./gpu/shader-material.ts`, not here:
5900
+ * this module is statically reachable from every app through the material asset layer, and Babylon
5901
+ * Lite exports one barrel, so a static import of the shader factory would put Lite's whole
5902
+ * shader-material pipeline in every entry chunk. That module is reached through a dynamic
5903
+ * `import()` instead (`docs/plan/2026-09-terrain-particles-shaders.md` §3.1, "Bundle cost").
5876
5904
  */
5877
5905
  /**
5878
- * The `as const` name table behind {@link ReflectionProbeRefreshMode}.
5906
+ * The Babylon Lite material a `MaterialAsset` owns, re-exported under an ignifx name
5907
+ * (`CONSTITUTION.md` §3.4, coding standards §4).
5908
+ *
5909
+ * @remarks
5910
+ * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
5879
5911
  *
5880
5912
  * @public
5881
5913
  */
5882
- declare const REFLECTION_PROBE_REFRESH_MODES: readonly ["once", "onDemand", "everyFrame"];
5914
+ type LiteMaterial = Material;
5883
5915
  /**
5884
- * When a reflection probe renders its cube map again.
5916
+ * A Babylon Lite physically based material, re-exported under an ignifx name.
5885
5917
  *
5886
5918
  * @remarks
5887
- * - `"once"` (default): when the probe is first ready, and again on {@link ReflectionProbe.refresh}.
5888
- * - `"onDemand"`: only on {@link ReflectionProbe.refresh}; until then the probe reflects nothing.
5889
- * - `"everyFrame"`: every frame, six extra scene passes each frame. Use it for one probe at most, and
5890
- * only on desktop at the `high` quality tier (nothing caps it yet).
5919
+ * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
5891
5920
  *
5892
5921
  * @public
5893
5922
  */
5894
- type ReflectionProbeRefreshMode = (typeof REFLECTION_PROBE_REFRESH_MODES)[number];
5923
+ type LitePbrMaterial = PbrMaterialProps;
5895
5924
  /**
5896
- * A point that captures the scene around it into a cube map, which nearby shiny PBR materials then
5897
- * reflect instead of the scene environment.
5925
+ * A Babylon Lite Babylon-Standard material, re-exported under an ignifx name.
5898
5926
  *
5899
5927
  * @remarks
5900
- * Each lit PBR material reflects the nearest enabled probe that has captured: a probe whose
5901
- * `boxProjection` box holds the mesh wins over one that does not, then the closer probe wins. With no
5902
- * probe, materials reflect the `Environment` again. A material shared by several meshes follows the
5903
- * first of them. Diffuse lighting still comes from the scene environment.
5904
- *
5905
- * The probe needs a loaded `Environment` (it reuses its lighting tables) and a canvas-backed app.
5906
- * Mip levels are box-filtered, so very rough materials look blurrier than with a prefiltered `.env`.
5928
+ * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
5907
5929
  *
5908
- * @example
5909
- * ```ts
5910
- * const probe = world.createEntity("Room probe", { position: { x: 0, y: 1.5, z: 0 } });
5911
- * probe.addComponent(ReflectionProbe, { size: 128, boxProjection: { x: 8, y: 3, z: 8 } });
5912
- * ```
5930
+ * @public
5931
+ */
5932
+ type LiteStandardMaterial = StandardMaterialProps;
5933
+ /**
5934
+ * How a material's alpha channel is interpreted, in glTF's vocabulary, in the order the inspector
5935
+ * lists them (`docs/architecture/07-rendering.md` §2.4).
5913
5936
  *
5914
- * @beta
5937
+ * @public
5915
5938
  */
5916
- declare class ReflectionProbe extends Component {
5917
- #private;
5918
- /** The namespaced registration id. */
5919
- static typeId: string;
5920
- /** What the component does, in one line, for an inspector. */
5921
- static description: string;
5922
- /** One probe per entity. */
5923
- static allowMultiple: boolean;
5924
- /** The serialized field declarations (ADR-0004). */
5925
- static schema: Schema;
5926
- /** Cube face size in pixels, rounded down to a power of two from 16 to 1024. Defaults to `128`. */
5927
- size: number;
5928
- /** When the probe captures again. Defaults to `"once"`. */
5929
- refreshMode: ReflectionProbeRefreshMode;
5930
- /**
5931
- * The full size, in metres, of the box (centred on the probe) that reflections are projected onto,
5932
- * or `null` (default) for no box: reflections then look infinitely far away.
5933
- */
5934
- boxProjection: Vec3Like | null;
5935
- /** The layer names the probe captures; empty (default) captures every layer. */
5936
- cullingMask: readonly string[];
5937
- /** The near clip distance of the capture, in metres. Defaults to `0.1`. */
5938
- near: number;
5939
- /** The far clip distance of the capture, in metres. Defaults to `1000`. */
5940
- far: number;
5941
- /** Applies the schema defaults, exactly as `Component.define` would. */
5942
- constructor();
5943
- /**
5944
- * Asks the probe to capture again from the next frame, whatever its `refreshMode`.
5945
- *
5946
- * @remarks
5947
- * Call it after the static scene around the probe changed, such as a door opening. A capture
5948
- * repeats over a few frames, so meshes whose materials are still compiling are caught.
5949
- */
5950
- refresh(): void;
5951
- /**
5952
- * Reads and clears the request {@link ReflectionProbe.refresh} made.
5953
- *
5954
- * @returns Whether a capture was requested since the last call.
5955
- *
5956
- * @internal
5957
- */
5958
- consumeRefreshRequest(): boolean;
5959
- }
5960
- //#endregion
5961
- //#region src/render/gpu/reflection-probe-host.d.ts
5939
+ declare const MATERIAL_ALPHA_MODES: readonly ["opaque", "mask", "blend"];
5962
5940
  /**
5963
- * The renderer's handle on reflection probes (GI B1): it loads the probe chunk
5964
- * (`./reflection-probes.ts`) the first frame a world has a probe and forwards every frame to it.
5965
- * Device-only, like the rest of `src/render/gpu/`: a headless renderer never creates one.
5941
+ * The union of the alpha modes a material can declare.
5966
5942
  *
5967
- * @internal
5943
+ * @public
5968
5944
  */
5969
- declare class ReflectionProbeHost {
5970
- #private;
5971
- /**
5972
- * Creates the host; nothing loads until a probe exists.
5973
- *
5974
- * @param engine - The engine.
5975
- * @param scene - The registered render scene.
5976
- * @param onError - Where a failed chunk load goes.
5977
- */
5978
- constructor(engine: LiteEngine, scene: LiteScene, onError: (error: unknown) => void);
5979
- /**
5980
- * Whether the chunk is loaded and running.
5981
- *
5982
- * @returns `true` once a probe has loaded it.
5983
- */
5984
- get isActive(): boolean;
5985
- /**
5986
- * Runs one frame of probe work, loading the chunk first when a probe exists.
5987
- *
5988
- * @param world - The world.
5989
- * @param probes - Every `ReflectionProbe` in it.
5990
- * @param isHdr - Whether `rendering.hdr` is on.
5991
- */
5992
- update(world: World, probes: readonly ReflectionProbe[], isHdr: boolean): void;
5993
- /** Frees every probe. Idempotent. */
5994
- dispose(): void;
5995
- }
5945
+ type MaterialAlphaMode = (typeof MATERIAL_ALPHA_MODES)[number];
5996
5946
  //#endregion
5997
5947
  //#region src/render/shader-declaration.d.ts
5998
5948
  /**
@@ -7441,82 +7391,6 @@ declare class SurfaceShaderBinding {
7441
7391
  get lite(): LiteMaterialPlugin | null;
7442
7392
  }
7443
7393
  //#endregion
7444
- //#region src/lite/material.d.ts
7445
- /**
7446
- * Material half of the Babylon Lite adapter (`docs/architecture/07-rendering.md` §2.6): the three
7447
- * material kinds a `MaterialAsset` can produce, built from plain ignifx props.
7448
- *
7449
- * Everything here is `@internal`, and every colour that reaches it is **linear** — the sRGB decode
7450
- * belongs to the asset layer.
7451
- *
7452
- * ## What a Lite material is (verified against `@babylonjs/lite@1.27.0`)
7453
- *
7454
- * - A material is plain data plus one private `_buildGroup` function; `createPbrMaterial` is
7455
- * literally `{ ...props, _buildGroup, _uboVersion: 0 }` (`lib/material/pbr/pbr-material.js`), so
7456
- * none of these factories touches the GPU and all of them run under the null engine.
7457
- * - **The build group is a per-family singleton.** `getPbrGroupBuilder()`, `getStandardGroupBuilder()`
7458
- * and `getShaderGroupBuilder()` each memoise one function for the whole process
7459
- * (`lib/material/pbr/pbr-material.js`, `lib/material/standard/create-standard-material.js`,
7460
- * `lib/material/shader/shader-material.js` line 123), and a scene keys its renderable groups by
7461
- * that function (`lib/scene/scene-core.js`, `addToScene`). "Material family" in
7462
- * `docs/architecture/07-rendering.md` §1.1 therefore means *pbr*, *standard*, *shader* or *node* —
7463
- * **not** an individual material. Only node materials get a per-material builder
7464
- * (`lib/material/node/node-material.js`). This is what makes {@link warmUpMaterialFamilies} in
7465
- * `./gpu/warm-up.ts` cheap: one hidden mesh per family covers every material in it.
7466
- * - Scalar and vector edits only need `markMaterialUboDirty` (`index.d.ts` 6974), which bumps
7467
- * `_uboVersion`. Anything that changes the compiled feature set — binding or clearing a texture,
7468
- * flipping `doubleSided`, changing culling — needs {@link rebuildMaterialPipelines}.
7469
- *
7470
- * ## The custom WGSL family lives elsewhere
7471
- *
7472
- * `createShaderMaterial` and the `setShader*` setters are in `./gpu/shader-material.ts`, not here:
7473
- * this module is statically reachable from every app through the material asset layer, and Babylon
7474
- * Lite exports one barrel, so a static import of the shader factory would put Lite's whole
7475
- * shader-material pipeline in every entry chunk. That module is reached through a dynamic
7476
- * `import()` instead (`docs/plan/2026-09-terrain-particles-shaders.md` §3.1, "Bundle cost").
7477
- */
7478
- /**
7479
- * The Babylon Lite material a `MaterialAsset` owns, re-exported under an ignifx name
7480
- * (`CONSTITUTION.md` §3.4, coding standards §4).
7481
- *
7482
- * @remarks
7483
- * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
7484
- *
7485
- * @public
7486
- */
7487
- type LiteMaterial = Material;
7488
- /**
7489
- * A Babylon Lite physically based material, re-exported under an ignifx name.
7490
- *
7491
- * @remarks
7492
- * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
7493
- *
7494
- * @public
7495
- */
7496
- type LitePbrMaterial = PbrMaterialProps;
7497
- /**
7498
- * A Babylon Lite Babylon-Standard material, re-exported under an ignifx name.
7499
- *
7500
- * @remarks
7501
- * Unstable; excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
7502
- *
7503
- * @public
7504
- */
7505
- type LiteStandardMaterial = StandardMaterialProps;
7506
- /**
7507
- * How a material's alpha channel is interpreted, in glTF's vocabulary, in the order the inspector
7508
- * lists them (`docs/architecture/07-rendering.md` §2.4).
7509
- *
7510
- * @public
7511
- */
7512
- declare const MATERIAL_ALPHA_MODES: readonly ["opaque", "mask", "blend"];
7513
- /**
7514
- * The union of the alpha modes a material can declare.
7515
- *
7516
- * @public
7517
- */
7518
- type MaterialAlphaMode = (typeof MATERIAL_ALPHA_MODES)[number];
7519
- //#endregion
7520
7394
  //#region src/render/material-asset.d.ts
7521
7395
  /**
7522
7396
  * `MaterialAsset` and the `ignifx.material` file format
@@ -7894,85 +7768,1107 @@ declare class MaterialAsset {
7894
7768
  * picks the new material up on the next `PreRender`, and the frame after that draws with the new
7895
7769
  * pipeline — so treat it as a level-load or settings-screen operation, not a per-frame one.
7896
7770
  *
7897
- * @param name - The declared define's name.
7898
- * @param value - The new value; a boolean compiles to `bool`, a number to `f32`.
7899
- * @throws IgnifxError with code `IGX-0718` unless this is a `"shader"` material, or `IGX-0712`
7900
- * when the shader declares no such define.
7771
+ * @param name - The declared define's name.
7772
+ * @param value - The new value; a boolean compiles to `bool`, a number to `f32`.
7773
+ * @throws IgnifxError with code `IGX-0718` unless this is a `"shader"` material, or `IGX-0712`
7774
+ * when the shader declares no such define.
7775
+ */
7776
+ setDefine(name: string, value: boolean | number): void;
7777
+ /**
7778
+ * Binds a read-only storage buffer to one of the shader's declared bindings.
7779
+ *
7780
+ * @param name - The declared binding's name.
7781
+ * @param buffer - The buffer, or `null` to unbind. A shader material with an unbound declared
7782
+ * storage buffer is not drawable ({@link MaterialAsset.isDrawable}).
7783
+ * @throws IgnifxError with code `IGX-0718` unless this is a `"shader"` material, or `IGX-0712`
7784
+ * when the shader declares no such storage buffer.
7785
+ */
7786
+ setStorageBuffer(name: string, buffer: AssetHandle<StorageBufferAsset> | null): void;
7787
+ /**
7788
+ * Releases what the material holds beyond its Babylon Lite object: a shader material's per-frame
7789
+ * uniform registration and its hot-reload hook.
7790
+ *
7791
+ * @remarks
7792
+ * The `material` asset type's `unload` runs it when the last holder releases the handle, so a
7793
+ * game that pairs `load`/`release` or uses `using` never has to. Calling it twice is a no-op, and
7794
+ * it is a no-op on a PBR or Standard material, which own nothing of the kind.
7795
+ */
7796
+ dispose(): void;
7797
+ /**
7798
+ * Builds an independent copy of this material from the same declaration — the per-renderer
7799
+ * variation path of `docs/architecture/07-rendering.md` §2.6.
7800
+ *
7801
+ * @remarks
7802
+ * The copy shares the original's *textures* (they are addressed assets, and the handles are
7803
+ * retained by whoever loaded them) and nothing else: it is a second Lite material in the same
7804
+ * family, so it costs no extra shader compilation.
7805
+ *
7806
+ * @param app - The app whose asset service publishes the copy.
7807
+ * @returns The copy's handle, with one holder — the caller.
7808
+ */
7809
+ clone(app: App): AssetHandle<MaterialAsset>;
7810
+ }
7811
+ /**
7812
+ * Builds a Lite material from a declaration and publishes it as an in-memory asset.
7813
+ *
7814
+ * @param app - The app whose asset service publishes it.
7815
+ * @param definition - The declaration.
7816
+ * @param textures - The texture handles the declaration's slots resolved to, in slot order.
7817
+ * @returns The handle, with one holder — the caller.
7818
+ *
7819
+ * @example
7820
+ * ```ts
7821
+ * using red = createMaterialAsset(app, pbrMaterialDefinition({ name: "red", baseColor: { r: 1, g: 0, b: 0, a: 1 } }), []);
7822
+ * ```
7823
+ *
7824
+ * @public
7825
+ */
7826
+ declare function createMaterialAsset(app: App, definition: MaterialDefinition, textures: readonly AssetHandle<TextureAsset>[]): AssetHandle<MaterialAsset>;
7827
+ /**
7828
+ * Fills in a PBR declaration's defaults, so callers name only what they mean to change.
7829
+ *
7830
+ * @param overrides - The properties to set.
7831
+ * @returns A complete declaration.
7832
+ *
7833
+ * @example
7834
+ * ```ts
7835
+ * pbrMaterialDefinition({ name: "gold", metallic: 1, roughness: 0.25 });
7836
+ * ```
7837
+ *
7838
+ * @public
7839
+ */
7840
+ declare function pbrMaterialDefinition(overrides?: Partial<Omit<PbrMaterialDefinition, "kind">>): PbrMaterialDefinition;
7841
+ /**
7842
+ * Fills in a Standard declaration's defaults.
7843
+ *
7844
+ * @param overrides - The properties to set.
7845
+ * @returns A complete declaration.
7846
+ *
7847
+ * @public
7848
+ */
7849
+ declare function standardMaterialDefinition(overrides?: Partial<Omit<StandardMaterialDefinition, "kind">>): StandardMaterialDefinition;
7850
+ //#endregion
7851
+ //#region src/render/lightmap-asset.d.ts
7852
+ /**
7853
+ * Lightmaps (`docs/plan/2026-11-gi-phase-2-execution-plan.md`, step B3): a baked texture that static
7854
+ * `MeshRenderer`s sample through their second UV set, and the per-entity placement of each renderer
7855
+ * in it. Everything here is plain data and runs in Node; the GPU half is `./gpu/lightmaps.ts`.
7856
+ */
7857
+ /**
7858
+ * The asset type lightmaps are registered under.
7859
+ *
7860
+ * @public
7861
+ */
7862
+ declare const LIGHTMAP_ASSET_TYPE = "lightmap";
7863
+ /**
7864
+ * The address extensions that select the lightmap loader.
7865
+ *
7866
+ * @public
7867
+ */
7868
+ declare const LIGHTMAP_FILE_EXTENSIONS: readonly string[];
7869
+ /**
7870
+ * The `format` header every `.lightmap.json` carries.
7871
+ *
7872
+ * @public
7873
+ */
7874
+ declare const LIGHTMAP_FILE_FORMAT = "ignifx-lightmap";
7875
+ /**
7876
+ * The `formatVersion` this engine reads and writes.
7877
+ *
7878
+ * @public
7879
+ */
7880
+ declare const LIGHTMAP_FORMAT_VERSION = 1;
7881
+ /**
7882
+ * Where one renderer's UV2 square sits in a lightmap atlas: the lightmap is sampled at
7883
+ * `uv2 · scale + offset`, component-wise. No rotation: an atlas packer that rotates a chart writes
7884
+ * the rotation into the UV2 it bakes.
7885
+ *
7886
+ * @public
7887
+ */
7888
+ interface LightmapPlacement {
7889
+ /** The atlas-space size of the renderer's UV2 square; each component above 0. */
7890
+ readonly scale: Vec2Like;
7891
+ /** The atlas-space position of the square's `(0, 0)` corner. */
7892
+ readonly offset: Vec2Like;
7893
+ }
7894
+ /**
7895
+ * The placement every entity without an entry gets: the whole texture.
7896
+ *
7897
+ * @public
7898
+ */
7899
+ declare const IDENTITY_LIGHTMAP_PLACEMENT: LightmapPlacement;
7900
+ /**
7901
+ * A lightmap as a `.lightmap.json` stores it.
7902
+ *
7903
+ * @public
7904
+ */
7905
+ interface LightmapFileData {
7906
+ /** The texture's asset address, resolved like any other address against the asset root. */
7907
+ readonly texture: string;
7908
+ /** Per-entity placements, keyed by entity uid; an entity without one samples the whole texture. */
7909
+ readonly entries: Readonly<Record<string, LightmapPlacement>>;
7910
+ }
7911
+ /**
7912
+ * A loaded lightmap: a texture and where each entity's UV2 square sits in it.
7913
+ *
7914
+ * @remarks
7915
+ * A `MeshRenderer` names it in its `lightmap` record. Many renderers can share one atlas
7916
+ * texture: each samples it at `uv2 · scale + offset`, with its entity's entry as the placement, in
7917
+ * the same UV space as an entity without one (so a V flip the texture asks for applies to the
7918
+ * placed coordinate too). A placement other than {@link IDENTITY_LIGHTMAP_PLACEMENT} needs the
7919
+ * renderer's `lightmap.uv2` on and a mesh with `uvs2`; otherwise it logs `IGX-0735` once and
7920
+ * samples the whole texture. Each distinct placement compiles its own pipeline variant.
7921
+ *
7922
+ * @example
7923
+ * ```ts
7924
+ * const lightmap = await app.assets.loadAsync<LightmapAsset>("lighting/hall.lightmap.json");
7925
+ * entity.isStatic = true;
7926
+ * entity.addComponent(MeshRenderer, { mesh, lightmap: { asset: lightmap, mode: "add", level: 1, gamma: false, uv2: true } });
7927
+ * ```
7928
+ *
7929
+ * @beta
7930
+ */
7931
+ declare class LightmapAsset {
7932
+ /** The type name the asset service registers lightmaps under. */
7933
+ static assetType: string;
7934
+ /** The baked texture. The asset does not own the handle: its loader or creator does. */
7935
+ readonly texture: AssetHandle<TextureAsset>;
7936
+ /** Per-entity placements, keyed by entity uid. */
7937
+ readonly entries: Readonly<Record<string, LightmapPlacement>>;
7938
+ /**
7939
+ * Wraps a texture and its checked placements. Use the loader or {@link createLightmapAsset}.
7940
+ *
7941
+ * @param texture - The baked texture.
7942
+ * @param entries - Placements already checked by `readLightmapEntries`.
7943
+ *
7944
+ * @internal
7945
+ */
7946
+ constructor(texture: AssetHandle<TextureAsset>, entries: Readonly<Record<string, LightmapPlacement>>);
7947
+ /**
7948
+ * The placement of one entity's UV2 square.
7949
+ *
7950
+ * @param entityId - The entity's uid.
7951
+ * @returns Its entry, or {@link IDENTITY_LIGHTMAP_PLACEMENT} when it has none.
7952
+ */
7953
+ placementOf(entityId: string): LightmapPlacement;
7954
+ }
7955
+ /**
7956
+ * Publishes a lightmap built in code, such as a texture from `TextureAsset.fromPixels`.
7957
+ *
7958
+ * @param app - The app.
7959
+ * @param texture - The baked texture; the caller keeps owning the handle.
7960
+ * @param entries - Per-entity placements, keyed by entity uid. Defaults to none.
7961
+ * @returns A handle a `MeshRenderer`'s `lightmap.asset` can take.
7962
+ * @throws IgnifxError with code `IGX-0709` when a placement is malformed.
7963
+ *
7964
+ * @beta
7965
+ */
7966
+ declare function createLightmapAsset(app: App, texture: AssetHandle<TextureAsset>, entries?: Readonly<Record<string, LightmapPlacement>>): AssetHandle<LightmapAsset>;
7967
+ /**
7968
+ * Turns a lightmap description into the JSON a `.lightmap.json` file holds.
7969
+ *
7970
+ * @param data - The texture address and placements.
7971
+ * @returns The file contents, with the format header.
7972
+ *
7973
+ * @beta
7974
+ */
7975
+ declare function writeLightmapFile(data: LightmapFileData): Record<string, unknown>;
7976
+ //#endregion
7977
+ //#region src/lite/gpu/mesh.d.ts
7978
+ /**
7979
+ * Mesh half of the Babylon Lite adapter (`docs/architecture/07-rendering.md` §2.3). Every function
7980
+ * here needs a WebGPU device — `createMeshFromData` uploads four vertex buffers through
7981
+ * `engine._device` (`lib/mesh/mesh.js`, `uploadMeshToGPU`) and the null engine has no `_device` —
7982
+ * so the whole module lives under `src/lite/gpu/` and is covered by the browser test project.
7983
+ *
7984
+ * Everything here is `@internal`.
7985
+ *
7986
+ * ## Ownership, cloning, and disposal (verified against `@babylonjs/lite@1.27.0`)
7987
+ *
7988
+ * - `cloneTransformNode(mesh)` (`index.d.ts` 1776, `lib/scene/transform-node.js`) shallow-clones a
7989
+ * mesh: the clone gets a fresh transform and **the same `_gpu` wrapper object**, with
7990
+ * `retain(_gpu)` bumping a reference count. So N clones of one template share exactly one set of
7991
+ * GPU buffers — that is spike S2.4's "instancing shares GPU buffers", and it is provable by
7992
+ * object identity rather than by measuring memory.
7993
+ * - Disposal is driven entirely by scene membership. `removeFromScene` calls `unregisterMeshScene`,
7994
+ * and only when the mesh has left its **last** scene does it queue `disposeMeshGpu`, which calls
7995
+ * `release(_gpu)` and destroys the buffers only when the count drops to one
7996
+ * (`lib/scene/scene-remove.js`, `lib/mesh/mesh-dispose.js`, `lib/resource/ref-count.js`). A
7997
+ * template that is never added to a scene therefore keeps its buffers alive no matter how many
7998
+ * clones come and go — which is what `docs/architecture/07-rendering.md` §2.3 means by "the
7999
+ * template's buffers stay alive while the asset is retained".
8000
+ * - The flip side is that Lite exports **no** mesh disposer. The only public way to release a
8001
+ * template's buffers is {@link disposeMeshTemplate}: add it to a scene and take it out again.
8002
+ * - `removeFromScene` also recursively removes a mesh's `children` and nulls its `parent`, so
8003
+ * removing a `Model`'s root removes the whole instantiated subtree in one call.
8004
+ * - Hiding is `setSubtreeVisible` (exported as `setMeshVisible` too, `index.d.ts` 11199): it
8005
+ * cascades `visible` down the subtree and bumps a global visibility epoch. Never remove a mesh
8006
+ * from the scene to hide it — that disposes it.
8007
+ *
8008
+ * ## Updating a mesh's vertices (verified against `lib/mesh/mesh-factories.js`)
8009
+ *
8010
+ * `updateMesh*` writes the GPU buffer and **nothing else**. Three consequences, all of them
8011
+ * surprising enough to be worth stating where the calls are:
8012
+ *
8013
+ * 1. **The retained CPU arrays are not replaced.** `createMeshFromData` keeps `_cpuPositions`,
8014
+ * `_cpuNormals`, `_cpuUvs` and `_cpuIndices` — the arrays it was handed — and Lite's CPU ray
8015
+ * pick reads them (`lib/picking/ray-pick.js`). Only `updateMeshGeometry`/`resizeMeshGeometry`
8016
+ * re-retain, through `retainMeshGeometry`. So an update that hands over a *different* array
8017
+ * leaves picking looking at the old geometry, while an update after mutating the retained array
8018
+ * in place leaves picking exact. `MeshAsset` keeps its own copy in step for that reason.
8019
+ * 2. **Bounds are not recomputed.** `retainMeshGeometry` is what calls `computeAabb` and writes
8020
+ * `boundMin`/`boundMax`; the partial updaters do not. `Mesh`'s own declaration says a consumer
8021
+ * "MAY overwrite these with a wider hand-computed box", so {@link setMeshBounds} exists and
8022
+ * `MeshAsset.updatePositions` uses it.
8023
+ * 3. **A cloned template cannot be updated at all.** `writeVertexAttributeRange` throws
8024
+ * (`ThrowLiteError(360)`) when `mesh._gpu._refCount > 1`, and cloning a mesh retains that very
8025
+ * wrapper. A `MeshAsset` a `MeshRenderer` has drawn is therefore frozen; a mesh meant to be
8026
+ * edited is a renderable of its own, which is the shape the terrain chunk adapter uses.
8027
+ */
8028
+ /**
8029
+ * The Babylon Lite mesh a `MeshAsset` template and a `MeshRenderer` clone are, re-exported under an
8030
+ * ignifx name so feature code can name the type without importing `@babylonjs/lite`
8031
+ * (`CONSTITUTION.md` §3.4, coding standards §4).
8032
+ *
8033
+ * @remarks
8034
+ * Unstable: it is Lite's own type, reachable only through documented `.lite` escape hatches, and it
8035
+ * is excluded from the stability guarantees of `CONSTITUTION.md` Article IV.
8036
+ *
8037
+ * @public
8038
+ */
8039
+ type LiteMesh = Mesh;
8040
+ //#endregion
8041
+ //#region src/render/mesh-asset.d.ts
8042
+ /**
8043
+ * Mesh templates share geometry with renderer clones (ADR-0002).
8044
+ * Factories register a loaded handle with one caller-owned hold; release it when no longer needed.
8045
+ * Existing clones survive collection, but a disposed template cannot make new clones.
8046
+ * Headless mesh assets keep component state without GPU geometry.
8047
+ */
8048
+ /**
8049
+ * The asset type primitives are registered under.
8050
+ *
8051
+ * @public
8052
+ */
8053
+ declare const MESH_ASSET_TYPE = "mesh";
8054
+ /**
8055
+ * How {@link MeshAsset.box} sizes its box, in metres. Give `size` for a cube, or the three
8056
+ * dimensions.
8057
+ *
8058
+ * @public
8059
+ */
8060
+ interface BoxMeshOptions {
8061
+ /** Edge length on every axis. */
8062
+ readonly size?: number;
8063
+ /** Size along X, overriding `size`. */
8064
+ readonly width?: number;
8065
+ /** Size along Y, overriding `size`. */
8066
+ readonly height?: number;
8067
+ /** Size along Z, overriding `size`. */
8068
+ readonly depth?: number;
8069
+ }
8070
+ /**
8071
+ * How {@link MeshAsset.sphere} tessellates its sphere.
8072
+ *
8073
+ * @public
8074
+ */
8075
+ interface SphereMeshOptions {
8076
+ /** Diameter on every axis, in metres. Lite defaults to 1. */
8077
+ readonly diameter?: number;
8078
+ /** Ring count; higher is smoother. Lite defaults to 32. */
8079
+ readonly segments?: number;
8080
+ }
8081
+ /**
8082
+ * How {@link MeshAsset.plane} sizes its quad, which lies in the XY plane facing `-Z`.
8083
+ *
8084
+ * @public
8085
+ */
8086
+ interface PlaneMeshOptions {
8087
+ /** Edge length on both axes, in metres. */
8088
+ readonly size?: number;
8089
+ /** Width, overriding `size`. */
8090
+ readonly width?: number;
8091
+ /** Height, overriding `size`. */
8092
+ readonly height?: number;
8093
+ }
8094
+ /**
8095
+ * How {@link MeshAsset.ground} sizes and subdivides its grid, which lies in the XZ plane facing
8096
+ * `+Y`.
8097
+ *
8098
+ * @public
8099
+ */
8100
+ interface GroundMeshOptions {
8101
+ /** Size along X, in metres. */
8102
+ readonly width?: number;
8103
+ /** Size along Z, in metres. */
8104
+ readonly height?: number;
8105
+ /** Quads per side. */
8106
+ readonly subdivisions?: number;
8107
+ /** UV multiplier, for tiling a texture across the grid. */
8108
+ readonly uvScale?: readonly [number, number];
8109
+ }
8110
+ /**
8111
+ * How {@link MeshAsset.cylinder} sizes its cylinder, which stands along Y.
8112
+ *
8113
+ * @public
8114
+ */
8115
+ interface CylinderMeshOptions {
8116
+ /** Height along Y, in metres. */
8117
+ readonly height?: number;
8118
+ /** Diameter of both ends. */
8119
+ readonly diameter?: number;
8120
+ /** Diameter of the top cap, overriding `diameter` — a cone is `diameterTop: 0`. */
8121
+ readonly diameterTop?: number;
8122
+ /** Diameter of the bottom cap, overriding `diameter`. */
8123
+ readonly diameterBottom?: number;
8124
+ /** Radial segment count. */
8125
+ readonly tessellation?: number;
8126
+ }
8127
+ /**
8128
+ * How {@link MeshAsset.capsule} sizes its capsule, which stands along Y.
8129
+ *
8130
+ * @remarks
8131
+ * `height` is the **total** height including both caps, the same convention `@ignifx/physics` uses
8132
+ * for a capsule collider, so one pair of numbers describes both.
8133
+ *
8134
+ * @public
8135
+ */
8136
+ interface CapsuleMeshOptions {
8137
+ /** Total height including both caps, in metres. */
8138
+ readonly height?: number;
8139
+ /** Radius of the body and the caps. */
8140
+ readonly radius?: number;
8141
+ /** Radial segment count. */
8142
+ readonly tessellation?: number;
8143
+ }
8144
+ /**
8145
+ * How {@link MeshAsset.torus} sizes its ring, which lies in the XZ plane.
8146
+ *
8147
+ * @public
8148
+ */
8149
+ interface TorusMeshOptions {
8150
+ /** Outer diameter, in metres. */
8151
+ readonly diameter?: number;
8152
+ /** Tube thickness, in metres. */
8153
+ readonly thickness?: number;
8154
+ /** Segment count around the ring. */
8155
+ readonly tessellation?: number;
8156
+ }
8157
+ /**
8158
+ * The primitive shapes a `MeshAsset` factory and a `.mesh.json` file can build.
8159
+ *
8160
+ * @public
8161
+ */
8162
+ declare const MESH_PRIMITIVES: readonly ["box", "sphere", "plane", "ground", "cylinder", "capsule", "torus"];
8163
+ /**
8164
+ * One of {@link MESH_PRIMITIVES}.
8165
+ *
8166
+ * @public
8167
+ */
8168
+ type MeshPrimitive = (typeof MESH_PRIMITIVES)[number];
8169
+ /**
8170
+ * A primitive and the options its factory takes: what a `.mesh.json` file declares.
8171
+ *
8172
+ * @public
8173
+ */
8174
+ type MeshPrimitiveDefinition = {
8175
+ readonly primitive: "box";
8176
+ readonly options: BoxMeshOptions;
8177
+ } | {
8178
+ readonly primitive: "sphere";
8179
+ readonly options: SphereMeshOptions;
8180
+ } | {
8181
+ readonly primitive: "plane";
8182
+ readonly options: PlaneMeshOptions;
8183
+ } | {
8184
+ readonly primitive: "ground";
8185
+ readonly options: GroundMeshOptions;
8186
+ } | {
8187
+ readonly primitive: "cylinder";
8188
+ readonly options: CylinderMeshOptions;
8189
+ } | {
8190
+ readonly primitive: "capsule";
8191
+ readonly options: CapsuleMeshOptions;
8192
+ } | {
8193
+ readonly primitive: "torus";
8194
+ readonly options: TorusMeshOptions;
8195
+ };
8196
+ /**
8197
+ * Raw vertex data for {@link MeshAsset.fromData}.
8198
+ *
8199
+ * @remarks
8200
+ * Lite keeps references to these arrays rather than copying them — they are what its CPU ray pick
8201
+ * and its bounds read (`lib/mesh/mesh-factories.js`). Mutating one behind Lite's back changes what
8202
+ * a pick reports without changing what the GPU draws; the sanctioned way to change geometry after
8203
+ * the fact is {@link MeshAsset.updatePositions} and its three siblings, which re-upload, keep this
8204
+ * copy in step, and re-fit the bounds.
8205
+ *
8206
+ * @public
8207
+ */
8208
+ interface MeshGeometryData {
8209
+ /** Three floats per vertex. */
8210
+ readonly positions: Float32Array;
8211
+ /** Three floats per vertex, one normal each. */
8212
+ readonly normals: Float32Array;
8213
+ /** Three indices per triangle. */
8214
+ readonly indices: Uint32Array;
8215
+ /** Two floats per vertex, or omitted for a mesh with no texture coordinates. */
8216
+ readonly uvs?: Float32Array;
8217
+ /**
8218
+ * Two floats per vertex for the second UV set (`uv2` in a shader), or omitted. Lightmaps, baked
8219
+ * ambient occlusion, and the parent-LOD height a terrain morph reads all ride here.
8220
+ */
8221
+ readonly uvs2?: Float32Array;
8222
+ /** Four floats per vertex — `xyz` plus a handedness `w` — or omitted. A normal map needs them. */
8223
+ readonly tangents?: Float32Array;
8224
+ /**
8225
+ * Four floats per vertex, linear RGBA, or omitted. A material has to be one that reads the colour
8226
+ * attribute; set `hasVertexAlpha` on the Lite mesh if the alpha is meant to blend.
8227
+ */
8228
+ readonly colors?: Float32Array;
8229
+ }
8230
+ /**
8231
+ * The Babylon Lite objects a {@link MeshAsset} owns. Unstable escape hatch
8232
+ * (`docs/architecture/00-overview.md` §3).
8233
+ *
8234
+ * @public
8235
+ */
8236
+ interface MeshAssetLiteHandles {
8237
+ /** The template mesh, or `null` under a headless app, which uploads no geometry. */
8238
+ readonly mesh: LiteMesh | null;
8239
+ }
8240
+ /**
8241
+ * A geometry template a `MeshRenderer` draws (`docs/architecture/07-rendering.md` §2.3).
8242
+ *
8243
+ * @remarks
8244
+ * Build one with a primitive factory or {@link MeshAsset.fromData}; each returns the handle the
8245
+ * `MeshRenderer.mesh` field takes. A `.mesh.json` file loads the same primitives by address
8246
+ * (`app.assets.load("meshes/crate.mesh.json")`), so a scene file can name one. A glTF mesh
8247
+ * arrives as part of a `ModelAsset` instead — a glTF is a tree of meshes, materials, and
8248
+ * animations, not one buffer.
8249
+ *
8250
+ * @example
8251
+ * ```ts
8252
+ * const box = MeshAsset.box(app, { size: 2 }); // one reference, owned by this code
8253
+ * const cube = app.world.createEntity("Cube");
8254
+ * cube.addComponent(MeshRenderer, { mesh: box }); // the field takes no reference
8255
+ * // Once nothing draws the box any more:
8256
+ * box.release();
8257
+ * ```
8258
+ *
8259
+ * @public
8260
+ */
8261
+ declare class MeshAsset {
8262
+ #private;
8263
+ /** The type name the asset service registers meshes under. */
8264
+ static assetType: string;
8265
+ /** A human-readable name, used in diagnostics and as the Lite mesh's name. */
8266
+ readonly name: string;
8267
+ /**
8268
+ * Wraps a template mesh. Use the static factories; the engine constructs assets.
8269
+ *
8270
+ * @param name - A human-readable name.
8271
+ * @param mesh - The template, or `null` when the app is headless.
8272
+ * @param scene - The scene the template is released through, or `null` when there is nothing to
8273
+ * release.
8274
+ * @param geometry - The vertex arrays the asset was built from, when it came from
8275
+ * {@link MeshAsset.fromData}; `null` for a primitive, whose arrays Lite generated and never
8276
+ * handed back. It is what makes the `update*` methods legal.
8277
+ * @param engine - The engine an update writes through, or `null` under a headless app.
8278
+ * @param primitive - The primitive and options it was built from, or `null` for data.
8279
+ *
8280
+ * @internal
8281
+ */
8282
+ constructor(name: string, mesh: LiteMesh | null, scene: LiteScene | null, geometry?: MeshGeometryData | null, engine?: LiteEngine | null, primitive?: MeshPrimitiveDefinition | null);
8283
+ /**
8284
+ * The Babylon Lite objects the asset owns. Unstable escape hatch
8285
+ * (`docs/architecture/00-overview.md` §3).
8286
+ *
8287
+ * @returns The template mesh, or `null` under a headless app.
8288
+ */
8289
+ get lite(): MeshAssetLiteHandles;
8290
+ /**
8291
+ * Whether the template's GPU buffers have been released.
8292
+ *
8293
+ * @returns `true` once {@link MeshAsset.dispose} has run.
8294
+ */
8295
+ get isDisposed(): boolean;
8296
+ /**
8297
+ * The vertex arrays the asset was built from, for CPU-side work such as a light-probe bake.
8298
+ *
8299
+ * @returns The arrays for a mesh built with {@link MeshAsset.fromData}; `null` for a primitive.
8300
+ *
8301
+ * @internal
8302
+ */
8303
+ get cpuGeometry(): MeshGeometryData | null;
8304
+ /**
8305
+ * The primitive and options the asset was built from, so a light-probe bake can rebuild its
8306
+ * triangles on the CPU.
8307
+ *
8308
+ * @returns The definition, or `null` for a mesh built with {@link MeshAsset.fromData}.
8309
+ *
8310
+ * @internal
8311
+ */
8312
+ get primitive(): MeshPrimitiveDefinition | null;
8313
+ /**
8314
+ * How many vertices the geometry has.
8315
+ *
8316
+ * @remarks
8317
+ * Known for a mesh built with {@link MeshAsset.fromData} — headless included — and `0` for a
8318
+ * primitive: Lite generates a primitive's arrays internally and 1.27.0's `Mesh` exposes no vertex
8319
+ * count, only the opaque `MeshGPU` handle it says a user never touches (`index.d.ts` 7230).
8320
+ *
8321
+ * @returns The vertex count, or `0`.
8322
+ */
8323
+ get vertexCount(): number;
8324
+ /**
8325
+ * How many indices the geometry has — three per triangle.
8326
+ *
8327
+ * @returns The index count, or `0`; see {@link MeshAsset.vertexCount}.
8328
+ */
8329
+ get indexCount(): number;
8330
+ /**
8331
+ * Re-uploads vertex positions and re-fits the bounds.
8332
+ *
8333
+ * @remarks
8334
+ * Only a mesh from {@link MeshAsset.fromData} can be updated, and only while nothing has cloned it:
8335
+ * Lite refuses to write a vertex buffer with more than one owner, and a `MeshRenderer` clone is a
8336
+ * second owner.
8337
+ *
8338
+ * Lite's `updateMeshPositions` writes the GPU buffer and stops there, so this also copies the range
8339
+ * into the asset's own position array — the one Lite retained and CPU picking reads — and rewrites
8340
+ * the bounds from the whole of it, `O(vertexCount)` per call. Passing the asset's own array skips
8341
+ * the copy.
8342
+ *
8343
+ * @param data - Three floats per vertex, read from index 0.
8344
+ * @param vertexOffset - The first vertex to overwrite. Defaults to `0`.
8345
+ * @param vertexCount - How many vertices to write. Defaults to as many as `data` holds.
8346
+ * @throws IgnifxError with code `IGX-0702` when the mesh did not come from
8347
+ * {@link MeshAsset.fromData}, or has been disposed.
8348
+ * @throws IgnifxError with code `IGX-0725` when the range falls outside the mesh or `data` is too
8349
+ * short for it.
8350
+ *
8351
+ * @example
8352
+ * ```ts
8353
+ * const grid = MeshAsset.fromData(app, "grid", { positions, normals, indices });
8354
+ * positions[1] += 0.5;
8355
+ * grid.value.updatePositions(positions);
8356
+ * ```
8357
+ */
8358
+ updatePositions(data: Float32Array, vertexOffset?: number, vertexCount?: number): void;
8359
+ /**
8360
+ * Re-uploads vertex normals.
8361
+ *
8362
+ * @remarks
8363
+ * The same rules as {@link MeshAsset.updatePositions}, minus the bounds: a normal cannot move a
8364
+ * bounding box. The range is copied into the asset's own normal array so that a later
8365
+ * `updatePositions` sees a consistent mesh.
8366
+ *
8367
+ * @param data - Three floats per vertex.
8368
+ * @param vertexOffset - The first vertex to overwrite. Defaults to `0`.
8369
+ * @param vertexCount - How many vertices to write. Defaults to as many as `data` holds.
8370
+ * @throws IgnifxError with code `IGX-0702` or `IGX-0725`; see
8371
+ * {@link MeshAsset.updatePositions}.
8372
+ */
8373
+ updateNormals(data: Float32Array, vertexOffset?: number, vertexCount?: number): void;
8374
+ /**
8375
+ * Re-uploads texture coordinates.
8376
+ *
8377
+ * @remarks
8378
+ * Lite makes the upload a **no-op** when the mesh was created without UVs, rather than an error,
8379
+ * so a mesh whose `MeshGeometryData` named none silently ignores this. The range check still runs.
8380
+ *
8381
+ * @param data - Two floats per vertex.
8382
+ * @param vertexOffset - The first vertex to overwrite. Defaults to `0`.
8383
+ * @param vertexCount - How many vertices to write. Defaults to as many as `data` holds.
8384
+ * @throws IgnifxError with code `IGX-0702` or `IGX-0725`; see
8385
+ * {@link MeshAsset.updatePositions}.
8386
+ */
8387
+ updateUvs(data: Float32Array, vertexOffset?: number, vertexCount?: number): void;
8388
+ /**
8389
+ * Re-uploads vertex colours.
8390
+ *
8391
+ * @remarks
8392
+ * Four floats per vertex, linear RGBA. A no-op on the GPU when the mesh was created without
8393
+ * colours, exactly as {@link MeshAsset.updateUvs} is.
8394
+ *
8395
+ * @param data - Four floats per vertex.
8396
+ * @param vertexOffset - The first vertex to overwrite. Defaults to `0`.
8397
+ * @param vertexCount - How many vertices to write. Defaults to as many as `data` holds.
8398
+ * @throws IgnifxError with code `IGX-0702` or `IGX-0725`; see
8399
+ * {@link MeshAsset.updatePositions}.
8400
+ */
8401
+ updateColors(data: Float32Array, vertexOffset?: number, vertexCount?: number): void;
8402
+ /**
8403
+ * Releases the template's GPU buffers.
8404
+ *
8405
+ * @remarks
8406
+ * Lite exports no mesh disposer: a mesh's buffers are freed when it leaves its last scene, so the
8407
+ * adapter adds the template to a scene and takes it straight out again
8408
+ * (`src/lite/gpu/mesh.ts`). Clones still in a scene keep the shared buffers alive; what the
8409
+ * template loses is the ability to be cloned again. Calling it twice is a no-op, and it is a
8410
+ * no-op under a headless app, which has no buffers.
8411
+ */
8412
+ dispose(): void;
8413
+ /** Releases the template when the asset leaves a `using` block. */
8414
+ [Symbol.dispose](): void;
8415
+ /**
8416
+ * Creates a box template and publishes it.
8417
+ *
8418
+ * @param app - The app whose engine uploads the geometry and whose asset service holds the handle.
8419
+ * @param options - A uniform `size`, or per-axis dimensions.
8420
+ * @returns The handle, with one holder — the caller.
8421
+ *
8422
+ * @example
8423
+ * ```ts
8424
+ * const box = MeshAsset.box(app, { width: 2, height: 1, depth: 3 });
8425
+ * ```
8426
+ */
8427
+ static box(app: App, options?: BoxMeshOptions): AssetHandle<MeshAsset>;
8428
+ /**
8429
+ * Creates a sphere template and publishes it.
8430
+ *
8431
+ * @param app - The app that owns the engine and the asset service.
8432
+ * @param options - Diameter and ring count.
8433
+ * @returns The handle, with one holder.
8434
+ */
8435
+ static sphere(app: App, options?: SphereMeshOptions): AssetHandle<MeshAsset>;
8436
+ /**
8437
+ * Creates a quad template in the XY plane and publishes it.
8438
+ *
8439
+ * @param app - The app that owns the engine and the asset service.
8440
+ * @param options - A uniform `size`, or width and height.
8441
+ * @returns The handle, with one holder.
8442
+ */
8443
+ static plane(app: App, options?: PlaneMeshOptions): AssetHandle<MeshAsset>;
8444
+ /**
8445
+ * Creates a subdivided grid in the XZ plane and publishes it.
8446
+ *
8447
+ * @param app - The app that owns the engine and the asset service.
8448
+ * @param options - Width, depth, subdivisions, and UV scale.
8449
+ * @returns The handle, with one holder.
8450
+ */
8451
+ static ground(app: App, options?: GroundMeshOptions): AssetHandle<MeshAsset>;
8452
+ /**
8453
+ * Creates a cylinder template standing along Y and publishes it.
8454
+ *
8455
+ * @param app - The app that owns the engine and the asset service.
8456
+ * @param options - Height, diameters, and tessellation.
8457
+ * @returns The handle, with one holder.
8458
+ */
8459
+ static cylinder(app: App, options?: CylinderMeshOptions): AssetHandle<MeshAsset>;
8460
+ /**
8461
+ * Creates a capsule template standing along Y and publishes it.
8462
+ *
8463
+ * @param app - The app that owns the engine and the asset service.
8464
+ * @param options - Total height, radius, and tessellation.
8465
+ * @returns The handle, with one holder.
8466
+ */
8467
+ static capsule(app: App, options?: CapsuleMeshOptions): AssetHandle<MeshAsset>;
8468
+ /**
8469
+ * Creates a torus template in the XZ plane and publishes it.
8470
+ *
8471
+ * @param app - The app that owns the engine and the asset service.
8472
+ * @param options - Diameter, thickness, and tessellation.
8473
+ * @returns The handle, with one holder.
8474
+ */
8475
+ static torus(app: App, options?: TorusMeshOptions): AssetHandle<MeshAsset>;
8476
+ /**
8477
+ * Creates a template from raw vertex data and publishes it.
8478
+ *
8479
+ * @param app - The app that owns the engine and the asset service.
8480
+ * @param name - A human-readable name.
8481
+ * @param data - Positions, normals, indices, and any of the four optional attributes. Lite keeps
8482
+ * references to the arrays; a caller that means to edit them afterwards does so through the
8483
+ * `update*` methods, which keep Lite's own copy and its bounds in step.
8484
+ * @returns The handle, with one holder.
8485
+ *
8486
+ * @example
8487
+ * ```ts
8488
+ * const triangle = MeshAsset.fromData(app, "triangle", {
8489
+ * positions: Float32Array.from([0, 0, 0, 1, 0, 0, 0, 1, 0]),
8490
+ * normals: Float32Array.from([0, 0, -1, 0, 0, -1, 0, 0, -1]),
8491
+ * indices: Uint32Array.from([0, 1, 2]),
8492
+ * });
8493
+ * ```
8494
+ */
8495
+ static fromData(app: App, name: string, data: MeshGeometryData): AssetHandle<MeshAsset>;
8496
+ }
8497
+ //#endregion
8498
+ //#region src/render/mesh-renderer.d.ts
8499
+ /**
8500
+ * The `MeshRenderer` component (`docs/architecture/07-rendering.md` §2.3): one clone of a
8501
+ * `MeshAsset`, drawn with a `MaterialAsset`.
8502
+ *
8503
+ * ## Cloning, not sharing
8504
+ *
8505
+ * The asset holds the template; the renderer holds a clone parented under the entity's node.
8506
+ * `cloneTransformNode` shallow-clones the mesh — fresh transform, **same** `_gpu` wrapper with its
8507
+ * reference count bumped — so a hundred renderers of one asset upload one set of vertex buffers
8508
+ * (ADR-0002 Validation). Removing the component calls `removeFromScene` on the clone, which is what
8509
+ * frees its share.
8510
+ *
8511
+ * ## Hiding is `visible`, never removal
8512
+ *
8513
+ * Lite disposes a mesh that leaves its last scene, so `enabled = false` must not remove anything.
8514
+ * `visible` is derived from `entity.activeInHierarchy && component.enabled` and written on the
8515
+ * clone's subtree; the mesh stays in the scene, keeps its buffers, and comes back the moment the
8516
+ * flag flips. That is `07-rendering.md` §2.3's rule, and the browser test asserts both halves: the
8517
+ * pixel returns to the clear colour, and the mesh is still in the scene.
8518
+ *
8519
+ * `displayHidden` hides the same way, and makes the clone unpickable too, but is not a field: scene
8520
+ * files do not save it, so a system
8521
+ * that chooses what is drawn without changing the document (a `LodGroup` in an edit-mode app,
8522
+ * ADR-0028) switches it instead of `enabled`.
8523
+ *
8524
+ * ## Decisions the documents left open
8525
+ *
8526
+ * - **The clone's Lite `id` is the entity's uid.** Lite's light include/exclude lists match on
8527
+ * `Mesh.id` strings (`lib/render/lights-ubo.js`), and §2.2 maps `Light.includeOnly` onto them
8528
+ * from *entity* references. The uid is the one identifier both sides can name.
8529
+ * - **`materials` beyond the first is accepted and ignored.** §2.3 says "one per submesh", but
8530
+ * Lite's `Mesh.material` is a single value and Lite has no submesh material list in 1.27.0, so
8531
+ * there is nothing for the extra entries to drive. The field keeps its array shape so files do
8532
+ * not have to change if submeshes land; the renderer uses index 0, or the default material when
8533
+ * the array is empty.
8534
+ *
8535
+ * ## Headless
8536
+ *
8537
+ * A headless `MeshAsset` carries no geometry, so there is nothing to clone: the component keeps its
8538
+ * fields, reports `lite.mesh === null`, and touches no scene (`07-rendering.md` §6).
8539
+ */
8540
+ /**
8541
+ * How a lightmap combines with a material's shading: `"add"` adds the baked light to it,
8542
+ * `"shadowmap"` multiplies it (Babylon Lite's `useAsShadowmap`).
8543
+ *
8544
+ * @beta
8545
+ */
8546
+ declare const LIGHTMAP_MODES: readonly ["add", "shadowmap"];
8547
+ /**
8548
+ * One of {@link LIGHTMAP_MODES}.
8549
+ *
8550
+ * @beta
8551
+ */
8552
+ type LightmapMode = (typeof LIGHTMAP_MODES)[number];
8553
+ /**
8554
+ * The `lightmap` record of a {@link MeshRenderer} (GI Phase 2, step B3).
8555
+ *
8556
+ * @remarks
8557
+ * Mutable, because a schema `record()` field is a plain object a script edits in place.
8558
+ *
8559
+ * @beta
8560
+ */
8561
+ interface MeshRendererLightmap {
8562
+ /** The `.lightmap.json` to sample, or `null` for none. */
8563
+ asset: AssetHandle<LightmapAsset> | null;
8564
+ /** Add the baked light, or multiply the shading by it. */
8565
+ mode: LightmapMode;
8566
+ /** A multiplier on the sample. */
8567
+ level: number;
8568
+ /** Decode the sample from sRGB to linear; leave it off for a texture already decoded on load. */
8569
+ gamma: boolean;
8570
+ /** Sample with the mesh's second UV set (`uvs2`); `false` uses the first. */
8571
+ uv2: boolean;
8572
+ }
8573
+ /**
8574
+ * Draws a mesh asset with a material (`docs/architecture/07-rendering.md` §2.3).
8575
+ *
8576
+ * @example
8577
+ * ```ts
8578
+ * const box = MeshAsset.box(app, { size: 1 }); // release it once nothing draws it
8579
+ * const cube = world.createEntity("Cube");
8580
+ * cube.addComponent(MeshRenderer, { mesh: box, castShadows: true });
8581
+ * ```
8582
+ *
8583
+ * @public
8584
+ */
8585
+ declare class MeshRenderer extends Component implements ComponentHooks {
8586
+ #private;
8587
+ /** The namespaced registration id. */
8588
+ static typeId: string;
8589
+ /** What the component does, in one line, for an inspector. */
8590
+ static description: string;
8591
+ /** Several renderers on one entity draw several meshes from one transform, which is useful. */
8592
+ static allowMultiple: boolean;
8593
+ /** The serialized field declarations (ADR-0004). */
8594
+ static schema: Schema;
8595
+ mesh: AssetHandle<MeshAsset> | null;
8596
+ materials: (AssetHandle<MaterialAsset> | null)[];
8597
+ castShadows: boolean;
8598
+ receiveShadows: boolean;
8599
+ renderOrder: number;
8600
+ pickable: boolean;
8601
+ /**
8602
+ * A baked lightmap, or `null` (default) for none (GI Phase 2, step B3).
8603
+ *
8604
+ * @remarks
8605
+ * Only a renderer on a static entity (`entity.isStatic`) with a PBR material samples it; it then
8606
+ * draws with its own copy of the material (`MaterialAsset.clone`), so later edits of the shared
8607
+ * material do not reach it. Anything else draws without the lightmap and logs `IGX-0735` once.
8608
+ * The GPU code loads only once a renderer samples one, and headless nothing happens.
8609
+ *
8610
+ * @beta
8611
+ */
8612
+ lightmap: MeshRendererLightmap | null;
8613
+ /** Applies the schema defaults, exactly as `Component.define` would. */
8614
+ constructor();
8615
+ /**
8616
+ * The Babylon Lite mesh this renderer draws. Unstable escape hatch
8617
+ * (`docs/architecture/00-overview.md` §3).
8618
+ *
8619
+ * @returns The clone, or `null` when there is nothing to draw.
8620
+ */
8621
+ get lite(): {
8622
+ readonly mesh: LiteSceneNode | null;
8623
+ };
8624
+ /**
8625
+ * A display-only hide: while `true` the mesh is neither drawn nor picked, whatever `enabled` and
8626
+ * `pickable` say.
8627
+ *
8628
+ * @remarks
8629
+ * It is not a schema field, so scene files do not save it, a serializer never reads it, and
8630
+ * `enabled` keeps its authored value. That makes it the switch for a system that chooses what is
8631
+ * drawn without changing the document: `@ignifx/3d`'s `LodGroup` uses it in place of `enabled` in
8632
+ * an edit-mode app (ADR-0028). It starts `false` and takes effect at the next render sync;
8633
+ * {@link MeshRenderer.isVisible} reports the outcome. Lite's pickers ignore visibility, so the
8634
+ * clone is also made unpickable while hidden: `app.renderer.pickAsync` and `world.raycastRender`
8635
+ * neither return it nor let it occlude, as with `pickable: false`.
8636
+ *
8637
+ * It is one flag with one owner, not a count. In an edit-mode app the `LodGroup` that lists the
8638
+ * renderer as a level owns it: the group sets and clears it whenever it switches, so a value
8639
+ * written by anything else lasts only until then. A renderer belongs to at most one `LodGroup`; a
8640
+ * second group that lists it leaves it alone and warns with `IGX-1217`.
8641
+ *
8642
+ * @returns `true` while the mesh is hidden for display.
8643
+ *
8644
+ * @example
8645
+ * ```ts
8646
+ * renderer.displayHidden = true; // not drawn, and `renderer.enabled` is still `true`
8647
+ * ```
8648
+ */
8649
+ get displayHidden(): boolean;
8650
+ /**
8651
+ * Hides the mesh for display, or shows it again; `enabled` is not touched.
8652
+ *
8653
+ * @param value - `true` to hide it.
8654
+ */
8655
+ set displayHidden(value: boolean);
8656
+ /**
8657
+ * Whether the mesh is currently drawn: its own `enabled` flag and its entity's
8658
+ * `activeInHierarchy`, less {@link MeshRenderer.displayHidden}, materialised onto Lite's
8659
+ * `visible`.
8660
+ *
8661
+ * @returns `true` when the clone is visible.
8662
+ */
8663
+ get isVisible(): boolean;
8664
+ /** Nothing to do at attach: the clone is built on the first sync, once `mesh` has been decoded. */
8665
+ onAttach(): void;
8666
+ /** Removes the clone from the scene, releasing its share of the template's buffers. */
8667
+ onDetach(): void;
8668
+ /**
8669
+ * Rebuilds the clone when `mesh` changed, then writes every other field that changed. The
8670
+ * `PreRender` system calls it.
8671
+ *
8672
+ * @param renderer - The rendering service, for the scene and the default material.
8673
+ * @returns `true` when the scene's renderable set changed, which the system coalesces into one
8674
+ * `rebuildSceneRenderables`.
8675
+ *
8676
+ * @internal
8677
+ */
8678
+ sync(renderer: RendererImpl): boolean;
8679
+ /**
8680
+ * Whether the material this renderer draws with is a `"shader"` material.
8681
+ *
8682
+ * @remarks
8683
+ * The render sync system asks before it builds an ESM caster list: Babylon Lite 1.27.0 has no ESM
8684
+ * shadow view for the shader family and writes the fragment colour's red channel into the map
8685
+ * (`lib/shadow/esm-directional-shadow-generator.js` 230–245), so such a mesh is left out of it and
8686
+ * reported once with `IGX-0724`. PCF and CSM generators take it.
8687
+ *
8688
+ * @returns `true` when the first declared material is loaded and is a shader material.
8689
+ *
8690
+ * @internal
8691
+ */
8692
+ get usesShaderMaterial(): boolean;
8693
+ /**
8694
+ * Appends this renderer's mesh to a shadow caster list, when it casts.
8695
+ *
8696
+ * @param out - The caster list being built.
8697
+ *
8698
+ * @internal
8699
+ */
8700
+ collectCasters(out: LiteMesh[]): void;
8701
+ /**
8702
+ * Whether the caster contribution of this renderer changed since the last frame.
8703
+ *
8704
+ * @returns `true` when `castShadows` or visibility moved.
8705
+ *
8706
+ * @internal
7901
8707
  */
7902
- setDefine(name: string, value: boolean | number): void;
8708
+ consumeCasterChange(): boolean;
8709
+ }
8710
+ //#endregion
8711
+ //#region src/render/gpu/lightmap-host.d.ts
8712
+ /**
8713
+ * The renderer's handle on lightmaps (GI B3): it decides whether a `MeshRenderer` samples its
8714
+ * lightmap, loads the lightmap chunk (`./lightmaps.ts`) the first time one does, and hands the
8715
+ * renderer its lightmapped material. Device-only, like the rest of `src/render/gpu/`: only a
8716
+ * renderer with a clone in the scene asks.
8717
+ *
8718
+ * @internal
8719
+ */
8720
+ declare class LightmapHost {
8721
+ #private;
7903
8722
  /**
7904
- * Binds a read-only storage buffer to one of the shader's declared bindings.
8723
+ * Creates the host; nothing loads until a renderer samples a lightmap.
7905
8724
  *
7906
- * @param name - The declared binding's name.
7907
- * @param buffer - The buffer, or `null` to unbind. A shader material with an unbound declared
7908
- * storage buffer is not drawable ({@link MaterialAsset.isDrawable}).
7909
- * @throws IgnifxError with code `IGX-0718` unless this is a `"shader"` material, or `IGX-0712`
7910
- * when the shader declares no such storage buffer.
8725
+ * @param app - The app, for the clones and the log.
8726
+ * @param scene - The registered render scene.
8727
+ * @param onError - Where a failed chunk load goes.
7911
8728
  */
7912
- setStorageBuffer(name: string, buffer: AssetHandle<StorageBufferAsset> | null): void;
8729
+ constructor(app: App, scene: LiteScene, onError: (error: unknown) => void);
7913
8730
  /**
7914
- * Releases what the material holds beyond its Babylon Lite object: a shader material's per-frame
7915
- * uniform registration and its hot-reload hook.
8731
+ * How many renderers draw with a lightmap right now.
7916
8732
  *
7917
- * @remarks
7918
- * The `material` asset type's `unload` runs it when the last holder releases the handle, so a
7919
- * game that pairs `load`/`release` or uses `using` never has to. Calling it twice is a no-op, and
7920
- * it is a no-op on a PBR or Standard material, which own nothing of the kind.
8733
+ * @returns The number of lightmapped clones.
7921
8734
  */
7922
- dispose(): void;
8735
+ get count(): number;
7923
8736
  /**
7924
- * Builds an independent copy of this material from the same declaration — the per-renderer
7925
- * variation path of `docs/architecture/07-rendering.md` §2.6.
8737
+ * The material a renderer draws with this frame.
7926
8738
  *
7927
8739
  * @remarks
7928
- * The copy shares the original's *textures* (they are addressed assets, and the handles are
7929
- * retained by whoever loaded them) and nothing else: it is a second Lite material in the same
7930
- * family, so it costs no extra shader compilation.
8740
+ * A renderer samples its lightmap when its `lightmap.asset` is loaded, its entity is static and its
8741
+ * material is PBR; otherwise it draws with `base`, and a static or PBR mismatch logs `IGX-0735`
8742
+ * once. Its entry's placement (scale and offset) moves its UV2 into its square of the atlas. A
8743
+ * placement other than the identity needs `uv2: true` and a mesh with `uvs2`, since the first UV
8744
+ * set also drives the material's own textures; without them it logs `IGX-0735` once and samples
8745
+ * the whole texture.
7931
8746
  *
7932
- * @param app - The app whose asset service publishes the copy.
7933
- * @returns The copy's handle, with one holder — the caller.
8747
+ * @param owner - The renderer.
8748
+ * @param base - The material it declares (or the default material).
8749
+ * @returns The Lite material to draw with.
7934
8750
  */
7935
- clone(app: App): AssetHandle<MaterialAsset>;
8751
+ materialFor(owner: MeshRenderer, base: MaterialAsset): LiteMaterial;
8752
+ /**
8753
+ * Drops a renderer's lightmapped clone, if it has one.
8754
+ *
8755
+ * @param owner - The renderer.
8756
+ */
8757
+ release(owner: MeshRenderer): void;
8758
+ /** Rebuilds the clones made this frame; the renderer calls it after every `MeshRenderer` synced. */
8759
+ flush(): void;
8760
+ /** Drops every clone. Idempotent. */
8761
+ dispose(): void;
7936
8762
  }
8763
+ //#endregion
8764
+ //#region src/render/reflection-probe.d.ts
7937
8765
  /**
7938
- * Builds a Lite material from a declaration and publishes it as an in-memory asset.
7939
- *
7940
- * @param app - The app whose asset service publishes it.
7941
- * @param definition - The declaration.
7942
- * @param textures - The texture handles the declaration's slots resolved to, in slot order.
7943
- * @returns The handle, with one holder — the caller.
8766
+ * The `ReflectionProbe` component (`docs/plan/2026-11-gi-phase-2-execution-plan.md`, step B1).
7944
8767
  *
7945
- * @example
7946
- * ```ts
7947
- * using red = createMaterialAsset(app, pbrMaterialDefinition({ name: "red", baseColor: { r: 1, g: 0, b: 0, a: 1 } }), []);
7948
- * ```
8768
+ * The component only holds settings and the "capture again" request. The renderer loads the probe's
8769
+ * GPU code (`./gpu/reflection-probes.ts`, `../lite/gpu/reflection-probe.ts`) only once a world has
8770
+ * a probe, so a project without one pays nothing for it (`CONSTITUTION.md` §2.5). Headless, a probe
8771
+ * captures nothing.
8772
+ */
8773
+ /**
8774
+ * The `as const` name table behind {@link ReflectionProbeRefreshMode}.
7949
8775
  *
7950
8776
  * @public
7951
8777
  */
7952
- declare function createMaterialAsset(app: App, definition: MaterialDefinition, textures: readonly AssetHandle<TextureAsset>[]): AssetHandle<MaterialAsset>;
8778
+ declare const REFLECTION_PROBE_REFRESH_MODES: readonly ["once", "onDemand", "everyFrame"];
7953
8779
  /**
7954
- * Fills in a PBR declaration's defaults, so callers name only what they mean to change.
7955
- *
7956
- * @param overrides - The properties to set.
7957
- * @returns A complete declaration.
8780
+ * When a reflection probe renders its cube map again.
7958
8781
  *
7959
- * @example
7960
- * ```ts
7961
- * pbrMaterialDefinition({ name: "gold", metallic: 1, roughness: 0.25 });
7962
- * ```
8782
+ * @remarks
8783
+ * - `"once"` (default): when the probe is first ready, and again on {@link ReflectionProbe.refresh}.
8784
+ * - `"onDemand"`: only on {@link ReflectionProbe.refresh}; until then the probe reflects nothing.
8785
+ * - `"everyFrame"`: every frame, six extra scene passes each frame. Use it for one probe at most, on
8786
+ * desktop. The `low` and `medium` quality tiers (`rendering.quality`) treat it as `"once"`.
7963
8787
  *
7964
8788
  * @public
7965
8789
  */
7966
- declare function pbrMaterialDefinition(overrides?: Partial<Omit<PbrMaterialDefinition, "kind">>): PbrMaterialDefinition;
8790
+ type ReflectionProbeRefreshMode = (typeof REFLECTION_PROBE_REFRESH_MODES)[number];
7967
8791
  /**
7968
- * Fills in a Standard declaration's defaults.
8792
+ * A point that captures the scene around it into a cube map, which nearby shiny PBR materials then
8793
+ * reflect instead of the scene environment.
7969
8794
  *
7970
- * @param overrides - The properties to set.
7971
- * @returns A complete declaration.
8795
+ * @remarks
8796
+ * Each lit PBR material reflects the nearest enabled probe that has captured: a probe whose
8797
+ * `boxProjection` box holds the mesh wins over one that does not, then the closer probe wins. With no
8798
+ * probe, materials reflect the `Environment` again. A material shared by several meshes follows the
8799
+ * first of them. Diffuse lighting still comes from the scene environment.
7972
8800
  *
7973
- * @public
8801
+ * Blending: once two or more box probes have captured and one of them has a `blendDistance` above
8802
+ * 0, every lit PBR material blends them per fragment instead, fading each probe out over the last
8803
+ * `blendDistance` metres inside its box. Probes without a box take no part then, and a probe that
8804
+ * captures `"everyFrame"` (or is still capturing) keeps the nearest-probe choice for that frame.
8805
+ *
8806
+ * The probe needs a loaded `Environment` (it reuses its lighting tables) and a canvas-backed app;
8807
+ * until an environment map is loaded it waits, holding no GPU memory and costing no frame time. A
8808
+ * `rendering.quality` tier caps `size` and allows `"everyFrame"` only at `high` (below, the probe
8809
+ * captures as `"once"`); with the `custom` tier nothing is capped.
8810
+ * Mip levels are box-filtered, so very rough materials look blurrier than with a prefiltered `.env`.
8811
+ *
8812
+ * @example
8813
+ * ```ts
8814
+ * const probe = world.createEntity("Room probe", { position: { x: 0, y: 1.5, z: 0 } });
8815
+ * probe.addComponent(ReflectionProbe, { size: 128, boxProjection: { x: 8, y: 3, z: 8 } });
8816
+ * ```
8817
+ *
8818
+ * @beta
7974
8819
  */
7975
- declare function standardMaterialDefinition(overrides?: Partial<Omit<StandardMaterialDefinition, "kind">>): StandardMaterialDefinition;
8820
+ declare class ReflectionProbe extends Component {
8821
+ #private;
8822
+ /** The namespaced registration id. */
8823
+ static typeId: string;
8824
+ /** What the component does, in one line, for an inspector. */
8825
+ static description: string;
8826
+ /** One probe per entity. */
8827
+ static allowMultiple: boolean;
8828
+ /** The serialized field declarations (ADR-0004). */
8829
+ static schema: Schema;
8830
+ /**
8831
+ * Cube face size in pixels, rounded down to a power of two from 16 to 1024. Defaults to `128`. A
8832
+ * `rendering.quality` tier caps it: 64 at `low`, 128 at `medium`, 256 at `high`.
8833
+ */
8834
+ size: number;
8835
+ /** When the probe captures again. Defaults to `"once"`. */
8836
+ refreshMode: ReflectionProbeRefreshMode;
8837
+ /**
8838
+ * The full size, in metres, of the box (centred on the probe) that reflections are projected onto,
8839
+ * or `null` (default) for no box: reflections then look infinitely far away.
8840
+ */
8841
+ boxProjection: Vec3Like | null;
8842
+ /**
8843
+ * How far inside its box, in metres, the probe fades out where it overlaps another box probe.
8844
+ * Defaults to `0`, no blending; see the class remarks. Needs `boxProjection`.
8845
+ */
8846
+ blendDistance: number;
8847
+ /** The layer names the probe captures; empty (default) captures every layer. */
8848
+ cullingMask: readonly string[];
8849
+ /** The near clip distance of the capture, in metres. Defaults to `0.1`. */
8850
+ near: number;
8851
+ /** The far clip distance of the capture, in metres. Defaults to `1000`. */
8852
+ far: number;
8853
+ /** Applies the schema defaults, exactly as `Component.define` would. */
8854
+ constructor();
8855
+ /**
8856
+ * Asks the probe to capture again from the next frame, whatever its `refreshMode`.
8857
+ *
8858
+ * @remarks
8859
+ * Call it after the static scene around the probe changed, such as a door opening. A capture
8860
+ * repeats over a few frames, so meshes whose materials are still compiling are caught.
8861
+ */
8862
+ refresh(): void;
8863
+ /**
8864
+ * Reads and clears the request {@link ReflectionProbe.refresh} made.
8865
+ *
8866
+ * @returns Whether a capture was requested since the last call.
8867
+ *
8868
+ * @internal
8869
+ */
8870
+ consumeRefreshRequest(): boolean;
8871
+ }
7976
8872
  //#endregion
7977
8873
  //#region src/lite/render-features.d.ts
7978
8874
  /**
@@ -8081,9 +8977,14 @@ type AmbientOcclusionQuality = (typeof AMBIENT_OCCLUSION_QUALITIES)[number];
8081
8977
  *
8082
8978
  * @remarks
8083
8979
  * - `"custom"` (default): every effect is exactly as the section and the `PostProcessStack`s say.
8084
- * - `"low"`: GTAO at half resolution; no HDR, TAA, contact shadows or SSGI.
8085
- * - `"medium"`: adds HDR and TAA, and lets a stack run contact shadows.
8086
- * - `"high"`: GTAO at full resolution, and lets a stack run SSGI.
8980
+ * - `"low"`: GTAO at half resolution; no HDR, TAA, contact shadows or SSGI; reflection probes at
8981
+ * 64 pixels a face at most.
8982
+ * - `"medium"`: adds HDR and TAA, lets a stack run contact shadows, and reflection probes up to 128.
8983
+ * - `"high"`: GTAO at full resolution, lets a stack run SSGI, reflection probes up to 256, and lets
8984
+ * a probe capture every frame.
8985
+ *
8986
+ * Below `"high"`, a `ReflectionProbe` with `refreshMode: "everyFrame"` captures as `"once"`.
8987
+ * Light probes and lightmaps run at every tier.
8087
8988
  *
8088
8989
  * @public
8089
8990
  */
@@ -8112,6 +9013,10 @@ interface RenderingQualityPreset {
8112
9013
  readonly contactShadows: boolean;
8113
9014
  /** Whether a `PostProcessStack`'s `ssgi` record may run. */
8114
9015
  readonly ssgi: boolean;
9016
+ /** The largest cube face a `ReflectionProbe` captures at, in pixels; a larger `size` is clamped. */
9017
+ readonly reflectionProbeMaxSize: number;
9018
+ /** Whether a `ReflectionProbe` may use `refreshMode: "everyFrame"`; below, it acts as `"once"`. */
9019
+ readonly reflectionProbeEveryFrame: boolean;
8115
9020
  }
8116
9021
  /**
8117
9022
  * Screen-space ambient occlusion (GTAO) on indirect light: `rendering.ambientOcclusion`
@@ -8347,6 +9252,53 @@ declare function defaultAutoExposureSettings(): AutoExposureSettings;
8347
9252
  */
8348
9253
  declare function defaultRenderingSettings(): RenderingSettings;
8349
9254
  //#endregion
9255
+ //#region src/render/gpu/reflection-probe-host.d.ts
9256
+ /**
9257
+ * The renderer's handle on reflection probes (GI B1): it loads the probe chunk
9258
+ * (`./reflection-probes.ts`) the first frame a world has a probe and forwards every frame to it.
9259
+ * Device-only, like the rest of `src/render/gpu/`: a headless renderer never creates one.
9260
+ *
9261
+ * @internal
9262
+ */
9263
+ declare class ReflectionProbeHost {
9264
+ #private;
9265
+ /**
9266
+ * Creates the host; nothing loads until a probe exists.
9267
+ *
9268
+ * @param engine - The engine.
9269
+ * @param scene - The registered render scene.
9270
+ * @param onError - Where a failed chunk load goes.
9271
+ * @param warn - Where a probe's warning goes, with the entity's name already in the message.
9272
+ */
9273
+ constructor(engine: LiteEngine, scene: LiteScene, onError: (error: unknown) => void, warn: (message: string) => void);
9274
+ /**
9275
+ * Whether the chunk is loaded and running.
9276
+ *
9277
+ * @returns `true` once a probe has loaded it.
9278
+ */
9279
+ get isActive(): boolean;
9280
+ /**
9281
+ * Runs one frame of probe work, loading the chunk first when a probe exists.
9282
+ *
9283
+ * @param world - The world.
9284
+ * @param probes - Every `ReflectionProbe` in it.
9285
+ * @param isHdr - Whether `rendering.hdr` is on.
9286
+ * @param tier - The `rendering.quality` preset; `null` for `"custom"`.
9287
+ * @param hasEnvironment - Whether the scene has an environment map; until it has, the chunk is
9288
+ * not even loaded, since a probe needs the map's lighting tables.
9289
+ */
9290
+ update(world: World, probes: readonly ReflectionProbe[], isHdr: boolean, tier: RenderingQualityPreset | null, hasEnvironment: boolean): void;
9291
+ /**
9292
+ * Drops the probes' GPU state when the device is lost (`app.events.onDeviceLost`), before Lite's
9293
+ * recovery rebuilds the materials; they capture again once frames resume.
9294
+ */
9295
+ handleDeviceLost(): void;
9296
+ /** Resumes probe work once Lite rebuilt the scene (`app.events.onDeviceRecovered`). */
9297
+ handleDeviceRecovered(): void;
9298
+ /** Frees every probe. Idempotent. */
9299
+ dispose(): void;
9300
+ }
9301
+ //#endregion
8350
9302
  //#region src/lite/gpu/render-path.d.ts
8351
9303
  /**
8352
9304
  * The HDR half of a presenter, when `rendering.hdr` built one (`./hdr-output.ts`).
@@ -9591,7 +10543,8 @@ declare class RendererImpl implements Renderer {
9591
10543
  /**
9592
10544
  * The baked-lighting components' per-frame work (GI Phase 2): `ReflectionProbe` (B1) captures
9593
10545
  * what is due and points each lit PBR material at its probe; `LightProbeVolume` (B2) keeps the
9594
- * winning grid on every lit PBR material. Each loads its own chunk the first time a world has one
10546
+ * winning grid on every lit PBR material; lightmaps (B3) rebuild the material copies the
10547
+ * `MeshRenderer`s took this frame. Each loads its own chunk the first time a world has one
9595
10548
  * of its components. The `PreRender` system calls it every frame; it does nothing on a headless
9596
10549
  * app.
9597
10550
  *
@@ -9602,6 +10555,34 @@ declare class RendererImpl implements Renderer {
9602
10555
  * @internal
9603
10556
  */
9604
10557
  updateBakedLighting(world: World, probes: readonly ReflectionProbe[], volumes: readonly LightProbeVolume[]): void;
10558
+ /**
10559
+ * The material a `MeshRenderer` draws with this frame: its own lightmapped copy of `base` when it
10560
+ * samples a lightmap (GI B3), else `base`'s. Only a renderer with a clone in the scene asks, so
10561
+ * never a headless one.
10562
+ *
10563
+ * @param owner - The renderer.
10564
+ * @param base - The material asset it declares, or the default material.
10565
+ * @returns The Lite material.
10566
+ *
10567
+ * @internal
10568
+ */
10569
+ lightmapMaterial(owner: MeshRenderer, base: MaterialAsset): LiteMaterial;
10570
+ /**
10571
+ * Drops a `MeshRenderer`'s lightmapped material copy, if it has one.
10572
+ *
10573
+ * @param owner - The renderer.
10574
+ *
10575
+ * @internal
10576
+ */
10577
+ releaseLightmap(owner: MeshRenderer): void;
10578
+ /**
10579
+ * The lightmaps' host, for tests and diagnostics.
10580
+ *
10581
+ * @returns The host, or `null` before a renderer asked for a material.
10582
+ *
10583
+ * @internal
10584
+ */
10585
+ get lightmapHost(): LightmapHost | null;
9605
10586
  /**
9606
10587
  * The light probes' host, for tests and diagnostics.
9607
10588
  *
@@ -11568,6 +12549,18 @@ interface EntityInstanceLink {
11568
12549
  * holding the scene's roots (`06-serialization-and-scene-format.md` §2).
11569
12550
  */
11570
12551
  readonly root: InstancedRoot | null;
12552
+ /**
12553
+ * The records of the components the instanced scene's own nested prefabs produced, by runtime
12554
+ * uid, as the instanced scene alone makes them: what the serializer diffs those components
12555
+ * against to write nested overrides. `null` when the scene instances nothing.
12556
+ */
12557
+ readonly nestedBaseline: ReadonlyMap<string, SceneFileComponent> | null;
12558
+ /**
12559
+ * When the instanced scene's single root itself instances a scene, the components those scenes'
12560
+ * roots merged into the instance root, by runtime uid, to the uid the file declaring each gives
12561
+ * it; the serializer diffs them as nested (instance path `<rootUid>/<uid>`). `null` otherwise.
12562
+ */
12563
+ readonly nestedRootSourceUids: ReadonlyMap<string, string> | null;
11571
12564
  }
11572
12565
  /**
11573
12566
  * What an instance root that stands for its scene's single root took from that root.
@@ -14915,6 +15908,113 @@ interface Extension {
14915
15908
  dispose?(app: App): void;
14916
15909
  }
14917
15910
  //#endregion
15911
+ //#region src/serialization/instance-targets.d.ts
15912
+ /**
15913
+ * Reads a prefab (or any scene) file by the address an `instance` entry names, for
15914
+ * {@link resolveInstancePath} and {@link enumerateInstanceTargets}.
15915
+ *
15916
+ * @remarks
15917
+ * The address is passed exactly as the entry's `scene.$asset` holds it. Return `null` or
15918
+ * `undefined` for a file that is not available; the walk then stops there, as the loader stops at
15919
+ * a scene that is not loaded.
15920
+ *
15921
+ * @param address - The instanced scene's address.
15922
+ * @returns The parsed file, or `null`/`undefined` when it cannot be read.
15923
+ *
15924
+ * @public
15925
+ */
15926
+ type PrefabReader = (address: string) => SceneFile | null | undefined;
15927
+ /**
15928
+ * One entity or component inside a prefab instance of a scene file, named by its instance path
15929
+ * (`docs/architecture/06-serialization-and-scene-format.md` §2).
15930
+ *
15931
+ * @public
15932
+ */
15933
+ interface InstanceTarget {
15934
+ /** What the path names: an `$entity` or a `$component` reference target. */
15935
+ readonly kind: "entity" | "component";
15936
+ /**
15937
+ * The instance path, `"<carrierUid>/…/<uid>"`: what a `{ "$entity" | "$component": … }`
15938
+ * reference in the scene writes to reach the target.
15939
+ */
15940
+ readonly path: string;
15941
+ /** The uid of the scene entity carrying the `instance` entry: the path's first segment. */
15942
+ readonly carrier: string;
15943
+ /** The address of the prefab file that declares the target, as its `instance` entry names it. */
15944
+ readonly address: string;
15945
+ /** The target's record in that file, or for a component the record of the entity holding it. */
15946
+ readonly entity: SceneFileEntity;
15947
+ /** The component's record, or `null` for an entity. */
15948
+ readonly component: SceneFileComponent | null;
15949
+ /**
15950
+ * The display names from the carrier down to {@link InstanceTarget.entity}: the carrier's name
15951
+ * first, then each entity's. A prefab's single root merges into the entity instancing it, so it
15952
+ * adds no name. A label reads `labels.join(" › ")`, plus the component type for a component.
15953
+ */
15954
+ readonly labels: readonly string[];
15955
+ /**
15956
+ * The prefix of an override path on the carrier's `instance` entry that addresses the target:
15957
+ * `"<entityUid>/components/<componentPath>"` for a component (append `/props/<field>` or
15958
+ * `/enabled`), where the component path is an instance path when the component sits in a nested
15959
+ * prefab, and `"<entityUid>"` for an entity of the instanced file itself. `null` for an entity
15960
+ * inside a nested prefab, which overrides do not reach.
15961
+ */
15962
+ readonly overridePath: string | null;
15963
+ }
15964
+ /**
15965
+ * Finds the entity or component an instance path names inside a scene file's prefab instances,
15966
+ * without loading anything: the rules the loader resolves `$entity` and `$component` references
15967
+ * by.
15968
+ *
15969
+ * @remarks
15970
+ * A pure function over files. The path's first segment is the uid of an entity of `scene` that
15971
+ * carries an `instance` entry; each later segment but the last names an entity of the prefab
15972
+ * reached so far that itself instances a prefab; the last names the target by the uid its own file
15973
+ * gives it. A prefab's single root merges into the entity instancing it, so a prefab that root
15974
+ * instances is searched at the same level, with no extra segment.
15975
+ *
15976
+ * @param scene - The scene file holding the path.
15977
+ * @param path - The instance path, `"<carrierUid>/…/<uid>"`.
15978
+ * @param readScene - Reads the prefab files the path walks through.
15979
+ * @param kind - What the reference expects: `"entity"` for `$entity`, `"component"` for
15980
+ * `$component`. Omitted, an entity is looked for first, then a component.
15981
+ * @returns The target, or `null` when the path is a plain uid or names nothing.
15982
+ *
15983
+ * @example
15984
+ * ```ts
15985
+ * const target = resolveInstancePath(sceneFile, "01J…CRATE/01J…LID", (address) => files.get(address));
15986
+ * ```
15987
+ *
15988
+ * @public
15989
+ */
15990
+ declare function resolveInstancePath(scene: SceneFile, path: string, readScene: PrefabReader, kind?: "entity" | "component"): InstanceTarget | null;
15991
+ /**
15992
+ * Lists every entity and component an instance path can reach inside a scene file's prefab
15993
+ * instances, with the path, a label chain, and the override path that addresses it.
15994
+ *
15995
+ * @remarks
15996
+ * A pure function over files, for tools such as an editor's reference picker. Each path is the
15997
+ * shortest form {@link resolveInstancePath} resolves. A prefab's single root is not listed as an
15998
+ * entity: it merges into the carrier, which the scene names by its plain uid; its components are
15999
+ * listed. Components an override `add`s are not listed: they keep no uid from a prefab file. The
16000
+ * walk stops at a file `readScene` cannot read, at a prefab that would instance itself, and 16
16001
+ * files deep.
16002
+ *
16003
+ * @param scene - The scene file.
16004
+ * @param readScene - Reads the prefab files.
16005
+ * @returns The targets, in scene order of their carriers, then depth first in file order.
16006
+ *
16007
+ * @example
16008
+ * ```ts
16009
+ * const components = enumerateInstanceTargets(sceneFile, (address) => files.get(address)).filter(
16010
+ * (target) => target.kind === "component",
16011
+ * );
16012
+ * ```
16013
+ *
16014
+ * @public
16015
+ */
16016
+ declare function enumerateInstanceTargets(scene: SceneFile, readScene: PrefabReader): InstanceTarget[];
16017
+ //#endregion
14918
16018
  //#region src/serialization/overrides.d.ts
14919
16019
  /**
14920
16020
  * The parsed form of an instance override `path`
@@ -14934,6 +16034,18 @@ interface Extension {
14934
16034
  * <uid>/components/<uid>/props/<field>[/<key>…] → prop
14935
16035
  * ```
14936
16036
  *
16037
+ * The component segment may also be an instance path, which reaches a component of a prefab the
16038
+ * instanced file itself instances: `"<nestedInstanceUid>/<componentUid>"`, where the first segment
16039
+ * is the uid of the entity carrying the nested `instance` entry in the instanced file and must
16040
+ * equal the path's entity segment, and the last is the uid the nested prefab file gives the
16041
+ * component. Deeper nesting adds one segment per nested instance, as in references
16042
+ * (`"<nestedInstanceUid>/<deeperInstanceUid>/<componentUid>"`). The component segment then runs up to
16043
+ * the first `props` or `enabled` segment, so a component uid cannot be either word.
16044
+ *
16045
+ * ```text
16046
+ * <uid>/components/<uid>/<uid>…/<uid>/props/<field> → prop, component "<uid>/<uid>…/<uid>"
16047
+ * ```
16048
+ *
14937
16049
  * @public
14938
16050
  */
14939
16051
  type OverridePath = {
@@ -14999,7 +16111,9 @@ interface PrefabOverrideSelection {
14999
16111
  * Override paths to act on. A path selects every override at that path or below it, so
15000
16112
  * `"<entityUid>"` selects everything on that entity and `"<entityUid>/components/<componentUid>"`
15001
16113
  * selects a component's removal, its `enabled` flag, and its props. An `add` to
15002
- * `<entityUid>/components` sits at `<entityUid>/components/<addedUid>`. Omitted, every override
16114
+ * `<entityUid>/components` sits at `<entityUid>/components/<addedUid>`. A component of a nested
16115
+ * prefab is selected by its instance path the same way:
16116
+ * `"<nestedInstanceUid>/components/<nestedInstanceUid>/<componentUid>"`. Omitted, every override
15003
16117
  * is selected.
15004
16118
  */
15005
16119
  readonly paths?: readonly string[];
@@ -15020,6 +16134,13 @@ interface PrefabApplyOptions extends PrefabOverrideSelection {
15020
16134
  * Omitted, none is applied.
15021
16135
  */
15022
16136
  readonly rootComponents?: readonly SceneFileComponent[];
16137
+ /**
16138
+ * Reads the prefabs the prefab file itself instances, by the address its `instance` entries name.
16139
+ * An override of a nested prefab's component (an instance path in its component segment) is
16140
+ * applied by moving it onto the nested `instance` entry of the prefab file, which needs the
16141
+ * nested file to find the entity holding the component. Omitted, such overrides are skipped.
16142
+ */
16143
+ readonly readScene?: PrefabReader;
15023
16144
  }
15024
16145
  /**
15025
16146
  * A component of the instance root that {@link applyOverridesToAsset} left on the instance, and why.
@@ -15089,9 +16210,12 @@ interface PrefabApplyResult {
15089
16210
  * - On a prefab with exactly one root, the instance root's own `name`, `transform`, and other entity
15090
16211
  * fields are its placement, not prefab content, so overrides of the root's entity fields and
15091
16212
  * transform are skipped.
15092
- * - Overrides reach only the prefab's own entities. Content of a scene the prefab itself instances
15093
- * is not addressable by an override path, so a nested prefab is never edited: an override that
15094
- * names something the prefab file does not hold is skipped.
16213
+ * - A nested prefab is never edited. An override of a nested prefab's component, whose component
16214
+ * segment is an instance path (`"<nestedInstanceUid>/<componentUid>"`), moves onto the prefab
16215
+ * file's nested `instance` entry instead, rewritten into that entry's own paths, replacing an
16216
+ * override there at the same path and op. It needs {@link PrefabApplyOptions.readScene}; without
16217
+ * it, or when the path names nothing, it is skipped. Any other override that names something the
16218
+ * prefab file does not hold is skipped.
15095
16219
  * - An override is skipped when an earlier override that stays on the instance overlaps its path, so
15096
16220
  * the instance keeps the value it had.
15097
16221
  * - A skipped override stays on the returned instance.
@@ -15145,5 +16269,5 @@ declare function applyOverridesToAsset(instance: SceneFileInstance, asset: Scene
15145
16269
  */
15146
16270
  declare function revertOverrides(instance: SceneFileInstance, selection?: PrefabOverrideSelection): SceneFileInstance;
15147
16271
  //#endregion
15148
- export { TWEEN_VALUE_KINDS as $, ComponentClassInfo as $a, SchemaIssue as $i, RENDERING_SETTINGS_SECTION as $n, RegisterAssetOptions as $o, SHADER_BLEND_MODES as $r, InstantiateOptions as $t, ServiceClassKey as A, VEC3_FORWARD as Aa, LightProbeData as Ai, RenderOverlay as An, StringFieldSpec as Ao, LiteShaderMaterial as Ar, FRAME_HISTORY_LENGTH as At, WaitInstruction as B, QUAT_IDENTITY as Ba, Script as Bi, forceRendererDeviceLossForTesting as Bn, AssetLoader as Bo, TEXTURE_ASSET_TYPE as Br, ComponentInitValue as Bt, FrameState as C, SchemaFieldDescription as Ca, ReflectionProbeRefreshMode as Ci, RENDER_TEXTURE_MAX_SIZE as Cn, LayerMaskFieldSpec as Co, LitePbrMaterial as Cr, ErrorRange as Cs, HotReloadModule as Ct, Phase as D, LiteSceneNode as Da, LIGHT_PROBE_FILE_FORMAT as Di, RENDER_DIAGNOSTICS_COUNTERS as Dn, PartialFieldsOf as Do, SurfaceShaderBinding as Dr, HotReloadStatics as Dt, PHASE_NAMES as E, Transform as Ea, LIGHT_PROBE_FILE_EXTENSIONS as Ei, FrameWaitOptions as En, OptionalFieldSpec as Eo, MaterialAlphaMode as Er, HotReloadReport as Et, System as F, VEC3_ZERO as Fa, LayerTable as Fi, RenderTaskTiming as Fn, EntityHandle as Fo, LiteStorageBuffer as Fr, createFrameSample as Ft, TWEEN_LOOP_FOREVER as G, MutableVec2 as Ga, DecodeResult as Gi, AMBIENT_OCCLUSION_QUALITIES as Gn, AssetState as Go, SHADER_ASSET_TYPE as Gr, Component as Gt, TweenProps as H, ColorLike as Ha, ScriptDefinition as Hi, isWebGpuAvailable as Hn, AssetManifestEntry as Ho, TextureAssetLiteHandles as Hr, ComponentType as Ht, SystemContext as I, Vec3 as Ia, MAX_LAYERS as Ii, RenderTaskTimings as In, INVALID_HANDLE as Io, ShaderMaterialDefinition as Ir, resetFrameSample as It, EASINGS as J, QuatLike as Ja, canonicalizeNumber as Ji, AutoExposureSettings as Jn, AssetsSettings as Jo, IGNIFX_UNIFORM_NAMES as Jr, Entity as Jt, Tween as K, MutableVec3 as Ka, ReferenceDecoder as Ki, AmbientOcclusionQuality as Kn, AssetTypeDefinition as Ko, SHADER_FILE_EXTENSIONS as Kr, ComponentDefinition as Kt, SystemEditMode as L, VEC2_ONE as La, RESERVED_LAYER_NAMES as Li, Renderer as Ln, AssetHandle as Lo, ShaderMaterialDefinitionInput as Lr, DiagnosticsGroup as Lt, ServiceNameKey as M, VEC3_ONE as Ma, sampleLightProbes as Mi, RenderPick as Mn, PhysicsCallbackName as Mo, StorageBufferAsset as Mr, FrameSample as Mt, ServiceRegistry as N, VEC3_RIGHT as Na, writeLightProbeFile as Ni, RenderPickIgnore as Nn, ScriptCallbackKind as No, StorageBufferAssetLiteHandles as Nr, PHASE_COUNT as Nt, RegisterComponentOptions as O, VEC3_BACKWARD as Oa, LIGHT_PROBE_FORMAT_VERSION as Oi, RENDER_DIAGNOSTICS_GROUP as On, RecordFieldSpec as Oo, SurfaceShaderInit as Or, Diagnostics as Ot, SortingLayersSettings as P, VEC3_UP as Pa, DEFAULT_LAYER as Pi, RenderPickOptions as Pn, ComponentHandle as Po, createStorageBufferAsset as Pr, PhaseIndex as Pt, resolveEase as Q, TagSet as Qa, encodeValue as Qi, RENDERING_QUALITIES as Qn, LoaderContext as Qo, SHADER_ATTRIBUTE_NAMES as Qr, CreateSceneOptions as Qt, Time as R, VEC2_ZERO as Ra, createLayerTable as Ri, RendererImpl as Rn, AssetLoadError as Ro, shaderMaterialDefinition as Rr, createDiagnosticsGroup as Rt, ExtensionContext as S, SchemaDescriptionMeta as Sa, ReflectionProbe as Si, EDITOR_ONLY_METADATA_KEY as Sn, FieldsOf as So, LiteMaterial as Sr, ErrorCode as Ss, HotReloadKind as St, PHASES as T, toJsonSchema as Ta, LIGHT_PROBE_ASSET_TYPE as Ti, LiteCamera as Tn, NumberFieldSpec as To, MATERIAL_ALPHA_MODES as Tr, isValidErrorCode as Ts, HotReloadPolicy as Tt, TweenTargetValue as U, Mat4Like as Ua, SceneInstance as Ui, LiteShadowGenerator as Un, AssetProgress as Uo, TextureImportOptions as Ur, ConcreteComponentType as Ut, createServiceKey as V, Quat as Va, ScriptCallbacks as Vi, RenderSurface as Vn, AssetManifest as Vo, TextureAsset as Vr, ComponentStatics as Vt, Tweens as W, MutableQuat as Wa, UidRemap as Wi, SHADOW_TECHNIQUES as Wn, AssetRef as Wo, LiteTexture2D as Wr, ScriptStatics as Wt, EasingFunction as X, Vec3Like as Xa, decodeValue as Xi, CanvasAlphaMode as Xn, FetchLike as Xo, LITE_SYSTEM_UNIFORM_NAMES as Xr, SetParentOptions as Xt, EASING_NAMES as Y, Vec2Like as Ya, decodeProps as Yi, CANVAS_ALPHA_MODES as Yn, BatchHandle as Yo, IgnifxUniformName as Yr, EntityPrefabLink as Yt, EasingName as Z, Vec4Like as Za, encodeProps as Zi, DEFAULT_BRDF_LUT_ADDRESS as Zn, LoadOptions as Zo, LiteSystemUniformName as Zr, CreateEntityOptions as Zt, CoroutineHost as _, isSceneFileHeader as _a, ShaderTextureFallback as _i, RayVector as _n, EnumFieldSpec as _o, STANDARD_TEXTURE_SLOTS as _r, assertNever as _s, LogLevel as _t, PrefabOverrideSkip as a, SCENE_ASSET_TYPE as aa, SURFACE_HOOK_NAMES as ai, AddComponentFromRecordOptions as an, AssetRefValue as ao, defaultRenderingSettings as ar, SignalLike as as, StoredValue as at, ErrorReport as b, JsonSchemaObject as ba, SurfaceHookName as bi, Mat4 as bn, FieldOptions as bo, pbrMaterialDefinition as br, CORE_ERROR_MESSAGES as bs, LogThreshold as bt, EntityOverrideField as c, SCENE_FORMAT_VERSION as ca, ShaderBlendMode as ci, SceneBuildResult as cn, ColorFieldSpec as co, MATERIAL_FILE_FORMAT as cr, JsonArray as cs, PlatformInfo as ct, App as d, SceneFileComponent as da, ShaderDefineDeclaration as di, assertSceneDependenciesLoaded as dn, CurveFieldSpec as do, MaterialAsset as dr, LiteEngine as ds, WebGpuInfo as dt, SchemaIssueCode as ea, SHADER_CULL_MODES as ei, LoadProgress as en, ComponentRegistry as eo, RenderingFeatureSettings as er, ConnectOptions as es, TweenValueKind as et, AppEvents as f, SceneFileEntity as fa, ShaderInstancingMode as fi, instantiateScene as fn, CurveKey as fo, MaterialAssetLiteHandles as fr, LiteScene as fs, platformInternals as ft, CoroutineHandle as g, describeSceneFileFormat as ga, ShaderTextureDeclaration as gi, Ray as gn, EntityRefFieldSpec as go, PbrMaterialDefinition as gr, IgnifxErrorOptions as gs, LOG_LEVEL_SEVERITY as gt, Coroutine as h, SceneFileTransform as ha, ShaderStorageDeclaration as hi, PROJECTIONS as hn, CustomFieldSpec as ho, PBR_TEXTURE_SLOTS as hr, IgnifxError as hs, createLogger as ht, PrefabOverrideSelection as i, createSceneAsset as ia, SHADER_UNIFORM_TYPES as ii, WorldLiteHandles as in, AssetFieldSpec as io, defaultAutoExposureSettings as ir, SignalHandler as is, StorageBackend as it, ServiceKey as j, VEC3_LEFT as ja, createLightProbeAsset as ji, RenderOverlayLiteHandles as jn, VectorFieldSpec as jo, STORAGE_BUFFER_ASSET_TYPE as jr, ProfileScope as jt, RegisterSystemOptions as k, VEC3_DOWN as ka, LightProbeAsset as ki, RenderCapture as kn, Schema as ko, SurfaceShaderReference as kr, DiagnosticsOptions as kt, OverridePath as l, SceneFile as la, ShaderCullMode as li, SceneLoadIssue as ln, ComponentRefFieldSpec as lo, MATERIAL_FORMAT_VERSION as lr, JsonObject as ls, PlatformKind as lt, AppSettings as m, SceneFileOverride as ma, ShaderPipelineState as mi, CameraProjection as mn, CustomFieldCodec as mo, MaterialKind as mr, ErrorFormatMode as ms, LoggerOptions as mt, PrefabApplyResult as n, SceneAssetToken as na, SHADER_KINDS as ni, LoadSceneOptions as nn, ScriptClassInfo as no, RenderingSettings as nr, Disconnect as ns, Storage as nt, applyOverridesToAsset as o, SCENE_FILE_EXTENSIONS as oa, SURFACE_UNIFORM_BLOCK as oi, ComponentBuildResult as on, AssetTypeToken as oo, MATERIAL_ASSET_TYPE as or, SignalOptions as os, StoredValueKind as ot, AppLiteHandles as p, SceneFileInstance as pa, ShaderKind as pi, Camera as pn, CurveValue as po, MaterialDefinition as pr, ErrorContext as ps, Logger as pt, TweenOptions as q, MutableVec4 as qa, ReferenceEncoder as qi, AmbientOcclusionSettings as qn, Assets as qo, ShaderAsset as qr, ComponentHooks as qt, PrefabComponentSkip as r, computeSceneHash as ra, SHADER_TEXTURE_FALLBACKS as ri, World as rn, ArrayFieldSpec as ro, TaaSettings as rr, Signal as rs, storageInternals as rt, revertOverrides as s, SCENE_FILE_FORMAT as sa, ShaderAttributeName$1 as si, InstantiateSceneOptions as sn, BoolFieldSpec as so, MATERIAL_FILE_EXTENSION as sr, SignalOwner as ss, GpuAdapterInfo as st, PrefabApplyOptions as t, SceneAsset as ta, SHADER_INSTANCING_MODES as ti, LoadSceneFileOptions as tn, ComponentReplacement as to, RenderingQuality as tr, DeferredQueue as ts, TweenableValue as tt, parseOverridePath as u, SceneFileAssetRef as ua, ShaderDeclaration as ui, addComponentFromRecord as un, ComponentTypeToken as uo, MATERIAL_KINDS as ur, JsonValue as us, PlatformOs as ut, CoroutineYield as v, sceneFileJsonSchema as va, ShaderUniformDeclaration as vi, createRay as vn, FieldDefinition as vo, StandardMaterialDefinition as vr, formatErrorMessage as vs, LogRecord as vt, LayersSettings as w, describeSchema as wa, LightProbeVolume as wi, RenderTexture as wn, MapFieldSpec as wo, LiteStandardMaterial as wr, THIRD_PARTY_ERROR_PREFIX as ws, HotReloadOptions as wt, Extension as x, SchemaDescription as xa, REFLECTION_PROBE_REFRESH_MODES as xi, Mat4Elements as xn, FieldSpec as xo, standardMaterialDefinition as xr, CoreErrorCode as xs, HotReloadHost as xt, DeviceLostInfo as y, stringifySceneFile as ya, ShaderUniformType$1 as yi, MAT4_IDENTITY as yn, FieldKind as yo, createMaterialAsset as yr, isIgnifxError as ys, LogSink as yt, TimeSettings as z, Vec2 as za, LayerMask as zi, RenderingFeature as zn, AssetLoadErrorOptions as zo, PixelTextureOptions as zr, ComponentInit as zt };
15149
- //# sourceMappingURL=prefab-overrides-BLQn5yHS.d.ts.map
16272
+ export { EASING_NAMES as $, JsonSchemaObject as $a, LitePbrMaterial as $i, CANVAS_ALPHA_MODES as $n, FieldOptions as $o, STANDARD_TEXTURE_SLOTS as $r, CORE_ERROR_MESSAGES as $s, EntityPrefabLink as $t, PHASE_NAMES as A, encodeProps as Aa, SHADER_BLEND_MODES as Ai, FrameWaitOptions as An, Vec4Like as Ao, TorusMeshOptions as Ar, LoadOptions as As, HotReloadReport as At, SystemContext as B, SCENE_FILE_FORMAT as Ba, ShaderCullMode as Bi, RenderTaskTimings as Bn, BoolFieldSpec as Bo, createLightmapAsset as Br, SignalOwner as Bs, resetFrameSample as Bt, DeviceLostInfo as C, UidRemap as Ca, SHADER_FILE_EXTENSIONS as Ci, MAT4_IDENTITY as Cn, MutableQuat as Co, MeshAsset as Cr, AssetRef as Cs, LogSink as Ct, FrameState as D, canonicalizeNumber as Da, LITE_SYSTEM_UNIFORM_NAMES as Di, RENDER_TEXTURE_MAX_SIZE as Dn, QuatLike as Do, MeshPrimitiveDefinition as Dr, AssetsSettings as Ds, HotReloadModule as Dt, ExtensionContext as E, ReferenceEncoder as Ea, IgnifxUniformName as Ei, EDITOR_ONLY_METADATA_KEY as En, MutableVec4 as Eo, MeshPrimitive as Er, Assets as Es, HotReloadKind as Et, ServiceKey as F, SceneAssetToken as Fa, SHADER_UNIFORM_TYPES as Fi, RenderOverlayLiteHandles as Fn, ScriptClassInfo as Fo, LIGHTMAP_FILE_FORMAT as Fr, Disconnect as Fs, ProfileScope as Ft, createServiceKey as G, SceneFileEntity as Ga, ShaderPipelineState as Gi, RenderSurface as Gn, CurveKey as Go, MATERIAL_FORMAT_VERSION as Gr, LiteScene as Gs, ComponentStatics as Gt, Time as H, SceneFile as Ha, ShaderDefineDeclaration as Hi, RendererImpl as Hn, ComponentRefFieldSpec as Ho, MATERIAL_ASSET_TYPE as Hr, JsonObject as Hs, createDiagnosticsGroup as Ht, ServiceNameKey as I, computeSceneHash as Ia, SURFACE_HOOK_NAMES as Ii, RenderPick as In, ArrayFieldSpec as Io, LIGHTMAP_FORMAT_VERSION as Ir, Signal as Is, FrameSample as It, Tweens as J, SceneFileTransform as Ja, ShaderTextureFallback as Ji, SHADOW_TECHNIQUES as Jn, CustomFieldSpec as Jo, MaterialAssetLiteHandles as Jr, IgnifxError as Js, ScriptStatics as Jt, TweenProps as K, SceneFileInstance as Ka, ShaderStorageDeclaration as Ki, isWebGpuAvailable as Kn, CurveValue as Ko, MATERIAL_KINDS as Kr, ErrorContext as Ks, ComponentType as Kt, ServiceRegistry as L, createSceneAsset as La, SURFACE_UNIFORM_BLOCK as Li, RenderPickIgnore as Ln, AssetFieldSpec as Lo, LightmapAsset as Lr, SignalHandler as Ls, PHASE_COUNT as Lt, RegisterComponentOptions as M, SchemaIssue as Ma, SHADER_INSTANCING_MODES as Mi, RENDER_DIAGNOSTICS_GROUP as Mn, ComponentClassInfo as Mo, IDENTITY_LIGHTMAP_PLACEMENT as Mr, RegisterAssetOptions as Ms, Diagnostics as Mt, RegisterSystemOptions as N, SchemaIssueCode as Na, SHADER_KINDS as Ni, RenderCapture as Nn, ComponentRegistry as No, LIGHTMAP_ASSET_TYPE as Nr, ConnectOptions as Ns, DiagnosticsOptions as Nt, LayersSettings as O, decodeProps as Oa, LiteSystemUniformName as Oi, RenderTexture as On, Vec2Like as Oo, PlaneMeshOptions as Or, BatchHandle as Os, HotReloadOptions as Ot, ServiceClassKey as P, SceneAsset as Pa, SHADER_TEXTURE_FALLBACKS as Pi, RenderOverlay as Pn, ComponentReplacement as Po, LIGHTMAP_FILE_EXTENSIONS as Pr, DeferredQueue as Ps, FRAME_HISTORY_LENGTH as Pt, EASINGS as Q, stringifySceneFile as Qa, LiteMaterial as Qi, AutoExposureSettings as Qn, FieldKind as Qo, PbrMaterialDefinition as Qr, isIgnifxError as Qs, Entity as Qt, SortingLayersSettings as R, SCENE_ASSET_TYPE as Ra, ShaderAttributeName$1 as Ri, RenderPickOptions as Rn, AssetRefValue as Ro, LightmapFileData as Rr, SignalLike as Rs, PhaseIndex as Rt, CoroutineYield as S, SceneInstance as Sa, SHADER_ASSET_TYPE as Si, createRay as Sn, Mat4Like as So, MESH_PRIMITIVES as Sr, AssetProgress as Ss, LogRecord as St, Extension as T, ReferenceDecoder as Ta, IGNIFX_UNIFORM_NAMES as Ti, Mat4Elements as Tn, MutableVec3 as To, MeshGeometryData as Tr, AssetTypeDefinition as Ts, HotReloadHost as Tt, TimeSettings as U, SceneFileAssetRef as Ua, ShaderInstancingMode as Ui, RenderingFeature as Un, ComponentTypeToken as Uo, MATERIAL_FILE_EXTENSION as Ur, JsonValue as Us, ComponentInit as Ut, SystemEditMode as V, SCENE_FORMAT_VERSION as Va, ShaderDeclaration as Vi, Renderer as Vn, ColorFieldSpec as Vo, writeLightmapFile as Vr, JsonArray as Vs, DiagnosticsGroup as Vt, WaitInstruction as W, SceneFileComponent as Wa, ShaderKind as Wi, forceRendererDeviceLossForTesting as Wn, CurveFieldSpec as Wo, MATERIAL_FILE_FORMAT as Wr, LiteEngine as Ws, ComponentInitValue as Wt, Tween as X, isSceneFileHeader as Xa, ShaderUniformType$1 as Xi, AmbientOcclusionQuality as Xn, EnumFieldSpec as Xo, MaterialKind as Xr, assertNever as Xs, ComponentDefinition as Xt, TWEEN_LOOP_FOREVER as Y, describeSceneFileFormat as Ya, ShaderUniformDeclaration as Yi, AMBIENT_OCCLUSION_QUALITIES as Yn, EntityRefFieldSpec as Yo, MaterialDefinition as Yr, IgnifxErrorOptions as Ys, Component as Yt, TweenOptions as Z, sceneFileJsonSchema as Za, SurfaceHookName as Zi, AmbientOcclusionSettings as Zn, FieldDefinition as Zo, PBR_TEXTURE_SLOTS as Zr, formatErrorMessage as Zs, ComponentHooks as Zt, AppLiteHandles as _, createLayerTable as _a, TEXTURE_ASSET_TYPE as _i, Camera as _n, VEC2_ZERO as _o, BoxMeshOptions as _r, AssetLoadError as _s, Logger as _t, PrefabOverrideSkip as a, LIGHT_PROBE_FILE_EXTENSIONS as aa, SurfaceShaderInit as ai, LoadSceneFileOptions as an, Transform as ao, RenderingQuality as ar, OptionalFieldSpec as as, TweenableValue as at, CoroutineHandle as b, ScriptCallbacks as ba, TextureImportOptions as bi, Ray as bn, Quat as bo, GroundMeshOptions as br, AssetManifest as bs, LOG_LEVEL_SEVERITY as bt, EntityOverrideField as c, LightProbeAsset as ca, STORAGE_BUFFER_ASSET_TYPE as ci, WorldLiteHandles as cn, VEC3_DOWN as co, defaultAutoExposureSettings as cr, Schema as cs, StorageBackend as ct, InstanceTarget as d, sampleLightProbes as da, createStorageBufferAsset as di, InstantiateSceneOptions as dn, VEC3_ONE as do, ReflectionProbe as dr, PhysicsCallbackName as ds, GpuAdapterInfo as dt, LiteStandardMaterial as ea, CoreErrorCode as ec, StandardMaterialDefinition as ei, SetParentOptions as en, SchemaDescription as eo, CanvasAlphaMode as er, FieldSpec as es, EasingFunction as et, PrefabReader as f, writeLightProbeFile as fa, LiteStorageBuffer as fi, SceneBuildResult as fn, VEC3_RIGHT as fo, ReflectionProbeRefreshMode as fr, ScriptCallbackKind as fs, PlatformInfo as ft, AppEvents as g, RESERVED_LAYER_NAMES as ga, PixelTextureOptions as gi, instantiateScene as gn, VEC2_ONE as go, MeshRendererLightmap as gr, AssetHandle as gs, platformInternals as gt, App as h, MAX_LAYERS as ha, shaderMaterialDefinition as hi, assertSceneDependenciesLoaded as hn, Vec3 as ho, MeshRenderer as hr, INVALID_HANDLE as hs, WebGpuInfo as ht, PrefabOverrideSelection as i, LIGHT_PROBE_ASSET_TYPE as ia, isValidErrorCode as ic, SurfaceShaderBinding as ii, LoadProgress as in, toJsonSchema as io, RenderingFeatureSettings as ir, NumberFieldSpec as is, TweenValueKind as it, Phase as j, encodeValue as ja, SHADER_CULL_MODES as ji, RENDER_DIAGNOSTICS_COUNTERS as jn, TagSet as jo, LiteMesh as jr, LoaderContext as js, HotReloadStatics as jt, PHASES as k, decodeValue as ka, SHADER_ATTRIBUTE_NAMES as ki, LiteCamera as kn, Vec3Like as ko, SphereMeshOptions as kr, FetchLike as ks, HotReloadPolicy as kt, OverridePath as l, LightProbeData as la, StorageBufferAsset as li, AddComponentFromRecordOptions as ln, VEC3_FORWARD as lo, defaultRenderingSettings as lr, StringFieldSpec as ls, StoredValue as lt, resolveInstancePath as m, LayerTable as ma, ShaderMaterialDefinitionInput as mi, addComponentFromRecord as mn, VEC3_ZERO as mo, LightmapMode as mr, EntityHandle as ms, PlatformOs as mt, PrefabApplyResult as n, MaterialAlphaMode as na, ErrorRange as nc, pbrMaterialDefinition as ni, CreateSceneOptions as nn, SchemaFieldDescription as no, RENDERING_QUALITIES as nr, LayerMaskFieldSpec as ns, resolveEase as nt, applyOverridesToAsset as o, LIGHT_PROBE_FILE_FORMAT as oa, SurfaceShaderReference as oi, LoadSceneOptions as on, LiteSceneNode as oo, RenderingSettings as or, PartialFieldsOf as os, Storage as ot, enumerateInstanceTargets as p, DEFAULT_LAYER as pa, ShaderMaterialDefinition as pi, SceneLoadIssue as pn, VEC3_UP as po, LIGHTMAP_MODES as pr, ComponentHandle as ps, PlatformKind as pt, TweenTargetValue as q, SceneFileOverride as qa, ShaderTextureDeclaration as qi, LiteShadowGenerator as qn, CustomFieldCodec as qo, MaterialAsset as qr, ErrorFormatMode as qs, ConcreteComponentType as qt, PrefabComponentSkip as r, LightProbeVolume as ra, THIRD_PARTY_ERROR_PREFIX as rc, standardMaterialDefinition as ri, InstantiateOptions as rn, describeSchema as ro, RENDERING_SETTINGS_SECTION as rr, MapFieldSpec as rs, TWEEN_VALUE_KINDS as rt, revertOverrides as s, LIGHT_PROBE_FORMAT_VERSION as sa, LiteShaderMaterial as si, World as sn, VEC3_BACKWARD as so, TaaSettings as sr, RecordFieldSpec as ss, storageInternals as st, PrefabApplyOptions as t, MATERIAL_ALPHA_MODES as ta, ErrorCode as tc, createMaterialAsset as ti, CreateEntityOptions as tn, SchemaDescriptionMeta as to, DEFAULT_BRDF_LUT_ADDRESS as tr, FieldsOf as ts, EasingName as tt, parseOverridePath as u, createLightProbeAsset as ua, StorageBufferAssetLiteHandles as ui, ComponentBuildResult as un, VEC3_LEFT as uo, REFLECTION_PROBE_REFRESH_MODES as ur, VectorFieldSpec as us, StoredValueKind as ut, AppSettings as v, LayerMask as va, TextureAsset as vi, CameraProjection as vn, Vec2 as vo, CapsuleMeshOptions as vr, AssetLoadErrorOptions as vs, LoggerOptions as vt, ErrorReport as w, DecodeResult as wa, ShaderAsset as wi, Mat4 as wn, MutableVec2 as wo, MeshAssetLiteHandles as wr, AssetState as ws, LogThreshold as wt, CoroutineHost as x, ScriptDefinition as xa, LiteTexture2D as xi, RayVector as xn, ColorLike as xo, MESH_ASSET_TYPE as xr, AssetManifestEntry as xs, LogLevel as xt, Coroutine as y, Script as ya, TextureAssetLiteHandles as yi, PROJECTIONS as yn, QUAT_IDENTITY as yo, CylinderMeshOptions as yr, AssetLoader as ys, createLogger as yt, System as z, SCENE_FILE_EXTENSIONS as za, ShaderBlendMode as zi, RenderTaskTiming as zn, AssetTypeToken as zo, LightmapPlacement as zr, SignalOptions as zs, createFrameSample as zt };
16273
+ //# sourceMappingURL=prefab-overrides-htDc_5Po.d.ts.map