@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.
- package/dist/{environment-DZ6WUHbm.js → environment-Bf4aphSb.js} +2 -2
- package/dist/{environment-DZ6WUHbm.js.map → environment-Bf4aphSb.js.map} +1 -1
- package/dist/{gtao-_nr0b6-E.js → gtao-Bpu5-0Ne.js} +2 -2
- package/dist/{gtao-_nr0b6-E.js.map → gtao-Bpu5-0Ne.js.map} +1 -1
- package/dist/{hdr-output-Dbv0lhFl.js → hdr-output-DBQwMphy.js} +2 -2
- package/dist/{hdr-output-Dbv0lhFl.js.map → hdr-output-DBQwMphy.js.map} +1 -1
- package/dist/{ignifx-error-B8ByiSfJ.js → ignifx-error-DwIZKxA2.js} +4 -1
- package/dist/ignifx-error-DwIZKxA2.js.map +1 -0
- package/dist/index.d.ts +218 -696
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2904 -970
- package/dist/index.js.map +1 -1
- package/dist/{instanced-mesh-instance-BMhREEfx.js → instanced-mesh-instance-B-fXKSrY.js} +2 -2
- package/dist/{instanced-mesh-instance-BMhREEfx.js.map → instanced-mesh-instance-B-fXKSrY.js.map} +1 -1
- package/dist/{light-probe-asset-B60_X-yN.js → light-probe-asset-BqfSrJe9.js} +2 -2
- package/dist/{light-probe-asset-B60_X-yN.js.map → light-probe-asset-BqfSrJe9.js.map} +1 -1
- package/dist/{light-probes-DkYN89Qw.js → light-probes-DDojYajw.js} +4 -4
- package/dist/{light-probes-DkYN89Qw.js.map → light-probes-DDojYajw.js.map} +1 -1
- package/dist/lightmaps-BUUIIkt9.js +230 -0
- package/dist/lightmaps-BUUIIkt9.js.map +1 -0
- package/dist/{material-CGk5mAah.js → material-myMbl9mW.js} +37 -2
- package/dist/{material-CGk5mAah.js.map → material-myMbl9mW.js.map} +1 -1
- package/dist/{material-plugin-CiAmriQ_.js → material-plugin-DapJNj04.js} +2 -2
- package/dist/{material-plugin-CiAmriQ_.js.map → material-plugin-DapJNj04.js.map} +1 -1
- package/dist/{post-effect-CQnlX1RH.js → post-effect-Cu3Enpz7.js} +2 -2
- package/dist/{post-effect-CQnlX1RH.js.map → post-effect-Cu3Enpz7.js.map} +1 -1
- package/dist/{post-effect-compiler-C_7HTHZy.js → post-effect-compiler-cCq9lcHt.js} +3 -3
- package/dist/{post-effect-compiler-C_7HTHZy.js.map → post-effect-compiler-cCq9lcHt.js.map} +1 -1
- package/dist/{prefab-overrides-DT-wHHAJ.js → prefab-overrides-C2GsgOQc.js} +467 -30
- package/dist/prefab-overrides-C2GsgOQc.js.map +1 -0
- package/dist/{prefab-overrides-BLQn5yHS.d.ts → prefab-overrides-htDc_5Po.d.ts} +1370 -246
- package/dist/prefab-overrides-htDc_5Po.d.ts.map +1 -0
- package/dist/prefab.d.ts +2 -2
- package/dist/prefab.js +2 -2
- package/dist/{reflection-probe-DlVsl3zJ.js → reflection-probe-QkD1Fo_d.js} +106 -12
- package/dist/{reflection-probe-DlVsl3zJ.js.map → reflection-probe-QkD1Fo_d.js.map} +1 -1
- package/dist/reflection-probes-CAzSuqf8.js +921 -0
- package/dist/reflection-probes-CAzSuqf8.js.map +1 -0
- package/dist/{shader-material-CaAkv5nT.js → shader-material-CJIDFvSb.js} +2 -2
- package/dist/{shader-material-CaAkv5nT.js.map → shader-material-CJIDFvSb.js.map} +1 -1
- package/dist/{shader-material-C2_UCYdO.js → shader-material-TM4f8eKA.js} +4 -4
- package/dist/{shader-material-C2_UCYdO.js.map → shader-material-TM4f8eKA.js.map} +1 -1
- package/dist/{shader-pragma-DmZpxGUo.js → shader-pragma-ljmAbVc2.js} +2 -2
- package/dist/{shader-pragma-DmZpxGUo.js.map → shader-pragma-ljmAbVc2.js.map} +1 -1
- package/dist/{ssgi-Dm-maZrc.js → ssgi-DSnhqotl.js} +2 -2
- package/dist/{ssgi-Dm-maZrc.js.map → ssgi-DSnhqotl.js.map} +1 -1
- package/dist/{surface-shader-BeDRofOV.js → surface-shader-rpPpeosD.js} +6 -6
- package/dist/{surface-shader-BeDRofOV.js.map → surface-shader-rpPpeosD.js.map} +1 -1
- package/dist/{vec3-Cc19wl4r.js → vec3-2C3LBZnt.js} +55 -3
- package/dist/vec3-2C3LBZnt.js.map +1 -0
- package/package.json +1 -1
- package/dist/ignifx-error-B8ByiSfJ.js.map +0 -1
- package/dist/prefab-overrides-BLQn5yHS.d.ts.map +0 -1
- package/dist/prefab-overrides-DT-wHHAJ.js.map +0 -1
- package/dist/reflection-probes-B8S9WnVX.js +0 -551
- package/dist/reflection-probes-B8S9WnVX.js.map +0 -1
- 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
|
|
4144
|
-
* `typeId`
|
|
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/
|
|
5871
|
+
//#region src/lite/material.d.ts
|
|
5869
5872
|
/**
|
|
5870
|
-
*
|
|
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
|
-
*
|
|
5873
|
-
*
|
|
5874
|
-
*
|
|
5875
|
-
*
|
|
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
|
|
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
|
-
|
|
5914
|
+
type LiteMaterial = Material;
|
|
5883
5915
|
/**
|
|
5884
|
-
*
|
|
5916
|
+
* A Babylon Lite physically based material, re-exported under an ignifx name.
|
|
5885
5917
|
*
|
|
5886
5918
|
* @remarks
|
|
5887
|
-
*
|
|
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
|
|
5923
|
+
type LitePbrMaterial = PbrMaterialProps;
|
|
5895
5924
|
/**
|
|
5896
|
-
* A
|
|
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
|
-
*
|
|
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
|
-
* @
|
|
5909
|
-
|
|
5910
|
-
|
|
5911
|
-
|
|
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
|
-
* @
|
|
5937
|
+
* @public
|
|
5915
5938
|
*/
|
|
5916
|
-
declare
|
|
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
|
|
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
|
-
* @
|
|
5943
|
+
* @public
|
|
5968
5944
|
*/
|
|
5969
|
-
|
|
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
|
-
|
|
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
|
-
*
|
|
8723
|
+
* Creates the host; nothing loads until a renderer samples a lightmap.
|
|
7905
8724
|
*
|
|
7906
|
-
* @param
|
|
7907
|
-
* @param
|
|
7908
|
-
*
|
|
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
|
-
|
|
8729
|
+
constructor(app: App, scene: LiteScene, onError: (error: unknown) => void);
|
|
7913
8730
|
/**
|
|
7914
|
-
*
|
|
7915
|
-
* uniform registration and its hot-reload hook.
|
|
8731
|
+
* How many renderers draw with a lightmap right now.
|
|
7916
8732
|
*
|
|
7917
|
-
* @
|
|
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
|
-
|
|
8735
|
+
get count(): number;
|
|
7923
8736
|
/**
|
|
7924
|
-
*
|
|
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
|
-
*
|
|
7929
|
-
*
|
|
7930
|
-
*
|
|
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
|
|
7933
|
-
* @
|
|
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
|
-
|
|
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
|
-
*
|
|
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
|
-
*
|
|
7946
|
-
*
|
|
7947
|
-
*
|
|
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
|
|
8778
|
+
declare const REFLECTION_PROBE_REFRESH_MODES: readonly ["once", "onDemand", "everyFrame"];
|
|
7953
8779
|
/**
|
|
7954
|
-
*
|
|
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
|
-
* @
|
|
7960
|
-
*
|
|
7961
|
-
*
|
|
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
|
-
|
|
8790
|
+
type ReflectionProbeRefreshMode = (typeof REFLECTION_PROBE_REFRESH_MODES)[number];
|
|
7967
8791
|
/**
|
|
7968
|
-
*
|
|
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
|
-
* @
|
|
7971
|
-
*
|
|
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
|
-
*
|
|
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
|
|
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
|
-
*
|
|
8086
|
-
* - `"
|
|
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
|
|
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>`.
|
|
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
|
-
* -
|
|
15093
|
-
* is
|
|
15094
|
-
*
|
|
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-
|
|
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
|