@babylonjs/lite-compat 1.28.0-preview → 1.30.0-preview
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/README.md +24 -22
- package/brdf-lut-data-BRUnY8c5.js +17 -0
- package/brdf-lut-data-BRUnY8c5.js.map +1 -0
- package/bundler-resolve-CVkl7m-0.js +57 -0
- package/bundler-resolve-CVkl7m-0.js.map +1 -0
- package/esbuild.js +51 -25
- package/esbuild.js.map +1 -1
- package/index.d.ts +335 -40
- package/index.js +10405 -9545
- package/index.js.map +1 -1
- package/meshes-DJ46g22_.js +3511 -0
- package/meshes-DJ46g22_.js.map +1 -0
- package/navigation.d.ts +149 -26
- package/navigation.js +198 -135
- package/navigation.js.map +1 -1
- package/package.json +4 -4
- package/recast-shim.js +19 -6
- package/recast-shim.js.map +1 -1
- package/rollup.js +39 -16
- package/rollup.js.map +1 -1
- package/vite.js +23 -22
- package/vite.js.map +1 -1
- package/webpack.js +44 -15
- package/webpack.js.map +1 -1
- package/brdf-lut-data-BFfYlW71.js +0 -5
- package/brdf-lut-data-BFfYlW71.js.map +0 -1
- package/bundler-resolve-0pEkTP9X.js +0 -33
- package/bundler-resolve-0pEkTP9X.js.map +0 -1
- package/meshes-CgaKo90D.js +0 -3468
- package/meshes-CgaKo90D.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -315,7 +315,6 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
315
315
|
private _material;
|
|
316
316
|
* reset: the supplied matrix is independent of the node transform.
|
|
317
317
|
*/
|
|
318
318
|
bakeTransformIntoVertices(transform: Matrix): this;
|
|
319
|
-
dispose(): void;
|
|
320
319
|
}
|
|
321
320
|
|
|
322
321
|
/** Babylon.js `AbstractNamedAudioNode` — an `AbstractAudioNode` with a mutable name. */
|
|
@@ -788,7 +787,7 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
788
787
|
constructor(name: stri
|
|
789
788
|
/** Right-drag panning sensitivity in pixels-per-unit (LOWER = faster pan). Babylon default 50. */
|
|
790
789
|
get panningSensibility(): number;
|
|
791
790
|
set panningSensibility(value: number);
|
|
792
|
-
attachControl(canvas: HTMLCanvasElement,
|
|
791
|
+
attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
|
|
793
792
|
|
|
794
793
|
export declare class AssetContainer {
|
|
795
794
|
constructor(lite: AssetContainer_2);
|
|
796
795
|
get animationGroups(): AnimationGroup_2[];
|
|
@@ -1140,7 +1139,13 @@ export declare class BVHFileLoader {
|
|
|
1140
1139
|
}
|
|
1141
1140
|
|
|
1142
1141
|
/** Babylon.js `Camera` — base class for all cameras (derives from `Node`). */
|
|
1143
|
-
export declare abstract class Camera extends Node_2 {
|
|
1144
1142
|
private _detach;
|
|
1143
|
+
export declare abstract class Camera extends Node_2 {
|
|
1144
|
+
static readonly PERSPECTIVE_CAMERA = 0;
|
|
1145
|
+
static readonly ORTHOGRAPHIC_CAMERA = 1;
|
|
1145
1146
|
private _detach;
|
|
1147
|
+
private _orthoLeft;
|
|
1148
|
+
private _orthoRight;
|
|
1149
|
+
private _orthoBottom;
|
|
1150
|
+
private _orthoTop;
|
|
1146
1151
|
protected constructor(name: string, scene?: Scene);
|
|
1147
1152
|
getClassName(): string;
|
|
1148
1153
|
get fov(): number;
|
|
@@ -1149,6 +1154,18 @@ export declare abstract class Camera extends Node_2 {
|
|
|
1149
1154
|
private _detach;
|
|
1150
1155
|
set minZ(value: number);
|
|
1151
1156
|
get maxZ(): number;
|
|
1152
1157
|
set maxZ(value: number);
|
|
1158
|
+
get orthoLeft(): number | null;
|
|
1159
|
+
set orthoLeft(value: number | null);
|
|
1160
|
+
get orthoRight(): number | null;
|
|
1161
|
+
set orthoRight(value: number | null);
|
|
1162
|
+
get orthoBottom(): number | null;
|
|
1163
|
+
set orthoBottom(value: number | null);
|
|
1164
|
+
get orthoTop(): number | null;
|
|
1165
|
+
set orthoTop(value: number | null);
|
|
1166
|
+
get mode(): number;
|
|
1167
|
+
set mode(value: number);
|
|
1168
|
+
get viewport(): Viewport;
|
|
1169
|
+
set viewport(value: Viewport);
|
|
1153
1170
|
/** World-space position of the camera. */
|
|
1154
1171
|
get globalPosition(): Vector3;
|
|
1155
1172
|
/** Babylon.js `camera.getViewMatrix()` — the camera's view matrix. */
|
|
@@ -1186,6 +1203,23 @@ export declare class CascadedShadowGenerator extends ShadowGenerator {
|
|
|
1186
1203
|
getClassName(): string;
|
|
1187
1204
|
}
|
|
1188
1205
|
|
|
1206
|
+
/** Base result shared by Babylon.js physics casting queries. */
|
|
1207
|
+
export declare class CastingResult {
|
|
1208
|
+
protected readonly _hitNormal: Vector3;
|
|
1209
|
+
protected readonly _hitPoint: Vector3;
|
|
1210
|
+
private _hasHit;
|
|
1211
|
+
private _triangleIndex;
|
|
1212
|
+
body?: PhysicsBody;
|
|
1213
|
+
bodyIndex?: number;
|
|
1214
|
+
shape?: PhysicsShape;
|
|
1215
|
+
get hitPoint(): Vector3;
|
|
1216
|
+
get hitNormal(): Vector3;
|
|
1217
|
+
get hasHit(): boolean;
|
|
1218
|
+
get triangleIndex(): number;
|
|
1219
|
+
setHitData(hitNormal: Vec3Like, hitPoint: Vec3Like, triangleIndex?: number): void;
|
|
1220
|
+
reset(): void;
|
|
1221
|
+
}
|
|
1222
|
+
|
|
1189
1223
|
declare interface CellSize {
|
|
1190
1224
|
width: number;
|
|
1191
1225
|
height: number;
|
|
@@ -1637,6 +1671,20 @@ export declare class DistanceConstraint extends PhysicsConstraint {
|
|
|
1637
1671
|
constructor(maxDistance: number, scene: Scene);
|
|
1638
1672
|
}
|
|
1639
1673
|
|
|
1674
|
+
/** Babylon.js drag move payload. */
|
|
1675
|
+
declare type DragEvent_2 = {
|
|
1676
|
+
delta: Vector3;
|
|
1677
|
+
dragPlanePoint: Vector3;
|
|
1678
|
+
dragPlaneNormal: Vector3;
|
|
1679
|
+
dragDistance: number;
|
|
1680
|
+
pointerId: number;
|
|
1681
|
+
pointerInfo: PointerInfo | null;
|
|
1682
|
+
};
|
|
1683
|
+
export { DragEvent_2 as DragEvent }
|
|
1684
|
+
|
|
1685
|
+
/** Babylon.js drag start/end payload. */
|
|
1686
|
+
export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
|
|
1687
|
+
|
|
1640
1688
|
/**
|
|
1641
1689
|
* Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
|
|
1642
1690
|
* `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
|
|
@@ -1752,6 +1800,31 @@ export declare class FBXFileLoader {
|
|
|
1752
1800
|
constructor();
|
|
1753
1801
|
}
|
|
1754
1802
|
|
|
1803
|
+
export declare class FluidRenderer {
|
|
1804
|
+
constructor(_scene: Scene);
|
|
1805
|
+
}
|
|
1806
|
+
|
|
1807
|
+
export declare class FluidRendererSceneComponent {
|
|
1808
|
+
constructor(_scene: Scene);
|
|
1809
|
+
}
|
|
1810
|
+
|
|
1811
|
+
export declare abstract class FluidRenderingObject {
|
|
1812
|
+
static UsePerParticleSizeAttribute: boolean;
|
|
1813
|
+
protected constructor(_scene: Scene, _shaderLanguage?: ShaderLanguage);
|
|
1814
|
+
}
|
|
1815
|
+
|
|
1816
|
+
export declare class FluidRenderingObjectCustomParticles extends FluidRenderingObject {
|
|
1817
|
+
constructor(scene: Scene, _buffers: Record<string, ArrayLike<number>>, _numParticles: number, shaderLanguage?: ShaderLanguage);
|
|
1818
|
+
}
|
|
1819
|
+
|
|
1820
|
+
export declare class FluidRenderingObjectParticleSystem extends FluidRenderingObject {
|
|
1821
|
+
constructor(scene: Scene, _particleSystem: unknown, shaderLanguage?: ShaderLanguage);
|
|
1822
|
+
}
|
|
1823
|
+
|
|
1824
|
+
export declare class FluidRenderingTargetRenderer {
|
|
1825
|
+
constructor(_scene: Scene, _camera?: Camera, _shaderLanguage?: ShaderLanguage);
|
|
1826
|
+
}
|
|
1827
|
+
|
|
1755
1828
|
/** Babylon.js `FlyCamera` — 6-DOF free-flight camera. */
|
|
1756
1829
|
export declare class FlyCamera extends TargetCamera {
|
|
1757
1830
|
constructor(name: string, position: Vector3, scene?: Scene);
|
|
1758
1831
|
get upVector(): Vector3;
|
|
@@ -1865,10 +1938,22 @@ export declare class GaussianSplattingStream {
|
|
|
1865
1938
|
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
1866
1939
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
1867
1940
|
|
|
1941
|
+
/** Babylon.js finest-LOD splat-count resolution state. */
|
|
1942
|
+
export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
|
|
1943
|
+
status: "pending";
|
|
1944
|
+
}> | Readonly<{
|
|
1945
|
+
status: "available";
|
|
1946
|
+
count: number;
|
|
1947
|
+
}> | Readonly<{
|
|
1948
|
+
status: "unavailable";
|
|
1949
|
+
}>;
|
|
1950
|
+
|
|
1868
1951
|
export declare class GeometryBufferRenderer {
|
|
1869
1952
|
constructor();
|
|
1870
1953
|
}
|
|
1871
1954
|
|
|
1955
|
+
export declare type GeometryRenderingObjectIdProvider = (mesh: AbstractMesh) => number;
|
|
1956
|
+
|
|
1872
1957
|
/**
|
|
1873
1958
|
* Babylon.js `GeospatialCamera` — globe-orbit camera anchored to a surface
|
|
1874
1959
|
* `center` (ECEF), orbiting at `radius` with `yaw`/`pitch`. Wraps Babylon Lite's
|
|
@@ -1916,6 +2001,8 @@ export declare function GetPointsCount(..._args: unknown[]): never;
|
|
|
1916
2001
|
*/
|
|
1917
2002
|
export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
|
|
1918
2003
|
|
|
2004
|
+
export declare function GetWhiteBalanceMatrix(_temperatureKelvin: number, _tint: number): Float32Array | number[];
|
|
2005
|
+
|
|
1919
2006
|
/** Shared base for compat gizmos (Babylon.js `Gizmo`). */
|
|
1920
2007
|
declare abstract class GizmoBase {
|
|
1921
2008
|
protected constructor(layer: UtilityLayerRenderer);
|
|
1922
2009
|
abstract get attachedMesh(): AbstractMesh | null;
|
|
@@ -1950,6 +2037,18 @@ export declare class GlowLayer {
|
|
|
1950
2037
|
constructor();
|
|
1951
2038
|
}
|
|
1952
2039
|
|
|
2040
|
+
export declare namespace GLTF1 {
|
|
2041
|
+
export {
|
|
2042
|
+
RegisterGLTF1Loader,
|
|
2043
|
+
RegisterGLTFBinaryExtension,
|
|
2044
|
+
RegisterGLTFMaterialsCommonExtension,
|
|
2045
|
+
GLTFLoaderBase,
|
|
2046
|
+
GLTFLoader,
|
|
2047
|
+
GLTFBinaryExtension,
|
|
2048
|
+
GLTFMaterialsCommonExtension
|
|
2049
|
+
}
|
|
2050
|
+
}
|
|
2051
|
+
|
|
1953
2052
|
export declare namespace GLTF2 {
|
|
1954
2053
|
export {
|
|
1955
2054
|
OpenPBRMaterialLoadingAdapter
|
|
@@ -2248,8 +2347,23 @@ export declare class HtmlRaycastInteractionManager {
|
|
|
2248
2347
|
constructor();
|
|
2249
2348
|
}
|
|
2250
2349
|
|
|
2251
|
-
|
|
2252
|
-
|
|
2350
|
+
/** Babylon.js `HtmlTexture`, forwarding DOM capture and updates to Babylon Lite. */
|
|
2351
|
+
export declare class HtmlTexture extends BaseTexture {
|
|
2352
|
+
readonly element: HTMLElement;
|
|
2353
|
+
readonly host: HTMLElement | null;
|
|
2354
|
+
readonly onLoadObservable: Observable<HtmlTexture>;
|
|
2355
|
+
private readonly _engine;
|
|
2356
|
+
private readonly _textureMatrix;
|
|
2357
|
+
private readonly _ready;
|
|
2358
|
+
private _htmlTexture;
|
|
2359
|
+
private _disposed;
|
|
2360
|
+
constructor(name: string, element: HTMLElement, options: IHtmlTextureOptions);
|
|
2361
|
+
getTextureMatrix(): Matrix;
|
|
2362
|
+
requestUpdate(): void;
|
|
2363
|
+
update(invertY?: boolean): void;
|
|
2364
|
+
getClassName(): string;
|
|
2365
|
+
whenReadyAsync(): Promise<void>;
|
|
2366
|
+
dispose(): void;
|
|
2253
2367
|
}
|
|
2254
2368
|
|
|
2255
2369
|
/** Babylon.js `IAbstractSoundOptions` (subset). */
|
|
@@ -2385,9 +2499,17 @@ export declare interface IHtmlRaycastInteractionManagerOptions {
|
|
|
2385
2499
|
[key: string]: unknown;
|
|
2386
2500
|
}
|
|
2387
2501
|
|
|
2388
|
-
/** Options accepted by Babylon.js `HtmlTexture
|
|
2502
|
+
/** Options accepted by Babylon.js `HtmlTexture`. */
|
|
2389
2503
|
export declare interface IHtmlTextureOptions {
|
|
2390
|
-
|
|
2504
|
+
width?: number;
|
|
2505
|
+
height?: number;
|
|
2506
|
+
generateMipMaps?: boolean;
|
|
2507
|
+
samplingMode?: number;
|
|
2508
|
+
format?: number;
|
|
2509
|
+
autoUpdate?: boolean;
|
|
2510
|
+
useSvgFallback?: boolean;
|
|
2511
|
+
engine?: AbstractEngine | null;
|
|
2512
|
+
scene?: Scene | null;
|
|
2391
2513
|
}
|
|
2392
2514
|
|
|
2393
2515
|
/** Options accepted by `InstallHtmlInCanvasPolyfill` (shape-only stub). */
|
|
@@ -2396,14 +2518,25 @@ export declare interface IInstallHtmlInCanvasPolyfillOptions {
|
|
|
2396
2518
|
}
|
|
2397
2519
|
|
|
2398
2520
|
/**
|
|
2399
|
-
* Babylon.js `ImageProcessingConfiguration`
|
|
2400
|
-
*
|
|
2401
|
-
* `scene.imageProcessingConfiguration`).
|
|
2521
|
+
* Minimal Babylon.js `ImageProcessingConfiguration` facade over Lite's image
|
|
2522
|
+
* processing state.
|
|
2402
2523
|
*/
|
|
2403
2524
|
export declare class ImageProcessingConfiguration {
|
|
2404
2525
|
static readonly TONEMAPPING_STANDARD = 0;
|
|
2405
2526
|
static readonly TONEMAPPING_ACES = 1;
|
|
2406
2527
|
static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
|
|
2528
|
+
private _backing;
|
|
2407
2529
|
get exposure(): number;
|
|
2530
|
+
set exposure(value: number);
|
|
2531
|
+
get contrast(): number;
|
|
2532
|
+
set contrast(value: number);
|
|
2533
|
+
get toneMappingEnabled(): boolean;
|
|
2534
|
+
set toneMappingEnabled(value: boolean);
|
|
2535
|
+
get whiteBalanceEnabled(): boolean;
|
|
2536
|
+
set whiteBalanceEnabled(value: boolean);
|
|
2537
|
+
get temperature(): number;
|
|
2538
|
+
set temperature(value: number);
|
|
2539
|
+
get tint(): number;
|
|
2540
|
+
set tint(value: number);
|
|
2408
2541
|
}
|
|
2409
2542
|
|
|
2410
2543
|
/** The decoded image sources WebGPU (and therefore Lite) can upload into a layer. */
|
|
@@ -2455,6 +2588,14 @@ export declare class InterpolatingBehavior {
|
|
|
2455
2588
|
constructor();
|
|
2456
2589
|
}
|
|
2457
2590
|
|
|
2591
|
+
/** Babylon.js raycast collision-filter options. */
|
|
2592
|
+
export declare interface IRaycastQuery {
|
|
2593
|
+
membership?: number;
|
|
2594
|
+
collideWith?: number;
|
|
2595
|
+
shouldHitTriggers?: boolean;
|
|
2596
|
+
ignoreBody?: PhysicsBody;
|
|
2597
|
+
}
|
|
2598
|
+
|
|
2458
2599
|
/**
|
|
2459
2600
|
* Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
|
|
2460
2601
|
* Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
|
|
@@ -2489,8 +2630,8 @@ export declare interface ISceneLoaderProgressEvent {
|
|
|
2489
2630
|
/** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
|
|
2490
2631
|
export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
2491
2632
|
|
|
2492
|
-
/** Babylon.js `IsHtmlInCanvasUploadSupported` —
|
|
2493
|
-
export declare function IsHtmlInCanvasUploadSupported():
|
|
2633
|
+
/** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
|
|
2634
|
+
export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
|
|
2494
2635
|
|
|
2495
2636
|
/** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
|
|
2496
2637
|
export declare interface ISOGLODMetadata {
|
|
@@ -2637,6 +2778,8 @@ export declare interface IWebAudioEngineOptions extends IAudioEngineV2Options {
|
|
|
2637
2778
|
resumeOnPause: boolean;
|
|
2638
2779
|
/** Retry interval (ms) for `resumeOnPause`. Defaults to `1000`. */
|
|
2639
2780
|
resumeOnPauseRetryInterval: number;
|
|
2781
|
+
/** Disable Babylon.js's iOS ringer-switch workaround. Lite does not install that workaround. */
|
|
2782
|
+
disableIOSRingerSwitchWorkaround?: boolean;
|
|
2640
2783
|
}
|
|
2641
2784
|
|
|
2642
2785
|
/**
|
|
@@ -2668,9 +2811,7 @@ export declare abstract class Light extends Node_2 {
|
|
|
2668
2811
|
protected constructor(n
|
|
2669
2812
|
*/
|
|
2670
2813
|
get intensity(): number;
|
|
2671
2814
|
set intensity(value: number);
|
|
2672
2815
|
/** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
|
|
2673
|
-
set shadowEnabled(enabled: boolean);
|
|
2674
|
-
dispose(): void;
|
|
2675
|
-
}
|
|
2816
|
+
set shadowEnabled(enabled: boolean);
|
|
2676
2817
|
|
|
2677
2818
|
export declare class LightGizmo {
|
|
2678
2819
|
private _attached;
|
|
2679
2820
|
constructor(layer: UtilityLayerRenderer);
|
|
@@ -2829,6 +2970,8 @@ export declare class Matrix {
|
|
|
2829
2970
|
constructor();
|
|
2830
2971
|
set(index: number, value: number): this;
|
|
2831
2972
|
copyFrom(source: Matrix): this;
|
|
2973
|
+
/** Set only this matrix's translation components. */
|
|
2974
|
+
setTranslationFromFloats(x: number, y: number, z: number): this;
|
|
2832
2975
|
maximizeInPlace(other: Matrix): this;
|
|
2833
2976
|
maximizeInPlaceFromFloats(m0: number, m1: number, m2: number, m3: number, m4: number, m5: number, m6: number, m7: number, m8: number, m9: number, m10: number, m11: number, m12: number, m13: number, m14: number, m15: number): this;
|
|
2834
2977
|
clone(): Matrix;
|
|
@@ -2849,7 +2992,7 @@ export declare class Matrix {
|
|
|
2849
2992
|
* TRS matrix into its scale, rotation (quaternion), and translation parts,
|
|
2850
2993
|
* writing into any provided out-params. Returns `false` (matching BJS) when a
|
|
2851
2994
|
* scale axis is zero. The rotation extraction is backed by Lite's
|
|
2852
|
-
* `
|
|
2995
|
+
* `createQuatFromRotationMat4` (via `Quaternion.FromRotationMatrixToRef`); the
|
|
2853
2996
|
* negative-determinant `scale.y` flip matches Babylon.js exactly.
|
|
2854
2997
|
*/
|
|
2855
2998
|
decompose(scale?: Vector3, rotation?: Quaternion, translation?: Vector3): boolean;
|
|
@@ -2881,6 +3024,8 @@ export declare class Matrix {
|
|
|
2881
3024
|
markAsUpdated(): this;
|
|
2882
3025
|
}
|
|
2883
3026
|
|
|
3027
|
+
export declare const MaxTintMagnitude = 150;
|
|
3028
|
+
|
|
2884
3029
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
2885
3030
|
export declare class Mesh extends AbstractMesh {
|
|
2886
3031
|
constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
|
|
@@ -3016,6 +3161,8 @@ export declare class MeshoptCompression {
|
|
|
3016
3161
|
static get Default(): MeshoptCompression;
|
|
3017
3162
|
}
|
|
3018
3163
|
|
|
3164
|
+
export declare const MinTemperatureKelvin: number;
|
|
3165
|
+
|
|
3019
3166
|
export declare class MirrorTexture {
|
|
3020
3167
|
constructor();
|
|
3021
3168
|
}
|
|
@@ -3198,12 +3345,13 @@ export declare class Observable<T> {
|
|
|
3198
3345
|
private _observers;
|
|
3199
3346
|
private _hasNotified;
|
|
3200
3347
|
private _lastNotifiedValue;
|
|
3348
|
+
private _lastNotifiedMask;
|
|
3201
3349
|
constructor(_onObserverAdded?: ((observer: ObserverCallback<T>) => void) | undefined, notifyIfTriggered?: boolean);
|
|
3202
|
-
add(callback: ObserverCallback<T
|
|
3203
|
-
addOnce(callback: ObserverCallback<T
|
|
3350
|
+
add(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3351
|
+
addOnce(callback: ObserverCallback<T>, mask?: number): ObserverCallback<T>;
|
|
3204
3352
|
remove(callback: ObserverCallback<T> | null | undefined): boolean;
|
|
3205
3353
|
removeCallback(callback: ObserverCallback<T>): boolean;
|
|
3206
|
-
notifyObservers(eventData?: T): void;
|
|
3354
|
+
notifyObservers(eventData?: T, mask?: number): void;
|
|
3207
3355
|
hasObservers(): boolean;
|
|
3208
3356
|
clear(): void;
|
|
3209
3357
|
cleanLastNotifiedState(): void;
|
|
@@ -3747,6 +3895,10 @@ export declare class PhysicsEngine {
|
|
|
3747
3895
|
/** Current world gravity. */
|
|
3748
3896
|
setTimeStep(newTimeStep: number): void;
|
|
3749
3897
|
/** Get the fixed timestep. */
|
|
3750
3898
|
getTimeStep(): number;
|
|
3899
|
+
/** Cast a ray through the active Lite Havok world. */
|
|
3900
|
+
raycast(from: Vector3, to: Vector3, query?: IRaycastQuery): PhysicsRaycastResult;
|
|
3901
|
+
/** Cast a ray through the active Lite Havok world and write into `result`. */
|
|
3902
|
+
raycastToRef(from: Vector3, to: Vector3, result: PhysicsRaycastResult, query?: IRaycastQuery): void;
|
|
3751
3903
|
/** Release the underlying physics world. */
|
|
3752
3904
|
dispose(): void;
|
|
3753
3905
|
}
|
|
@@ -3777,6 +3929,21 @@ export declare enum PhysicsPrestepType {
|
|
|
3777
3929
|
ACTION = 2
|
|
3778
3930
|
}
|
|
3779
3931
|
|
|
3932
|
+
/** Babylon.js raycast result backed by Lite's native Havok query result. */
|
|
3933
|
+
export declare class PhysicsRaycastResult extends CastingResult {
|
|
3934
|
+
private _hitDistance;
|
|
3935
|
+
private readonly _rayFromWorld;
|
|
3936
|
+
private readonly _rayToWorld;
|
|
3937
|
+
get hitDistance(): number;
|
|
3938
|
+
get hitNormalWorld(): Vector3;
|
|
3939
|
+
get hitPointWorld(): Vector3;
|
|
3940
|
+
get rayFromWorld(): Vector3;
|
|
3941
|
+
get rayToWorld(): Vector3;
|
|
3942
|
+
setHitDistance(distance: number): void;
|
|
3943
|
+
calculateHitDistance(): void;
|
|
3944
|
+
reset(from?: Vector3, to?: Vector3): void;
|
|
3945
|
+
}
|
|
3946
|
+
|
|
3780
3947
|
/** Babylon.js-shaped collision shape backed by a Babylon Lite physics shape. */
|
|
3781
3948
|
export declare class PhysicsShape {
|
|
3782
3949
|
constructor(options: PhysicShapeOptions, scene: Scene);
|
|
3783
3950
|
getClassName(): string;
|
|
3784
3951
|
get type(): PhysicsShapeType;
|
|
@@ -3885,6 +4052,26 @@ export declare class PointerDragBehavior {
|
|
|
3885
4052
|
constructor();
|
|
3886
4053
|
}
|
|
3887
4054
|
|
|
4055
|
+
/** Babylon.js pointer event masks emitted by `Scene.onPointerObservable`. */
|
|
4056
|
+
export declare class PointerEventTypes {
|
|
4057
|
+
static readonly POINTERDOWN = 1;
|
|
4058
|
+
static readonly POINTERUP = 2;
|
|
4059
|
+
static readonly POINTERMOVE = 4;
|
|
4060
|
+
static readonly POINTERWHEEL = 8;
|
|
4061
|
+
static readonly POINTERPICK = 16;
|
|
4062
|
+
static readonly POINTERTAP = 32;
|
|
4063
|
+
static readonly POINTERDOUBLETAP = 64;
|
|
4064
|
+
}
|
|
4065
|
+
|
|
4066
|
+
/** Babylon.js-shaped payload emitted by `Scene.onPointerObservable`. */
|
|
4067
|
+
export declare class PointerInfo {
|
|
4068
|
+
type: number;
|
|
4069
|
+
event: PointerEvent | WheelEvent;
|
|
4070
|
+
private readonly _pickInfo;
|
|
4071
|
+
constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null);
|
|
4072
|
+
get pickInfo(): PickingInfo | null;
|
|
4073
|
+
}
|
|
4074
|
+
|
|
3888
4075
|
export declare class PointLight extends Light {
|
|
3889
4076
|
constructor(name: string, position: Vector3, scene?: Scene);
|
|
3890
4077
|
getClassName(): string;
|
|
3891
4078
|
get range(): number;
|
|
@@ -3943,6 +4130,10 @@ export declare class PositionGizmo extends GizmoBase {
|
|
|
3943
4130
|
private _attached;
|
|
3944
4131
|
private _xGizmo;
|
|
3945
4132
|
private _yGizmo;
|
|
3946
4133
|
private _zGizmo;
|
|
4134
|
+
private _dragSubscriptions;
|
|
4135
|
+
readonly onDragStartObservable: Observable<DragStartEndEvent>;
|
|
4136
|
+
readonly onDragObservable: Observable<DragEvent_2>;
|
|
4137
|
+
readonly onDragEndObservable: Observable<DragStartEndEvent>;
|
|
3947
4138
|
constructor(layer: UtilityLayerRenderer);
|
|
3948
4139
|
/** Babylon.js `PositionGizmo.xGizmo/yGizmo/zGizmo` — the per-axis drag sub-gizmos.
|
|
3949
4140
|
* Exposed so callers can toggle interactivity per axis (e.g. `xGizmo.isEnabled = false`
|
|
@@ -4009,7 +4200,7 @@ export declare class Quaternion {
|
|
|
4009
4200
|
conjugate(): Quaternion;
|
|
4010
4201
|
/**
|
|
4011
4202
|
* Babylon.js `Quaternion.fromRotationMatrix` — update this quaternion in place
|
|
4012
|
-
* from the rotation part of `matrix`. Backed by Lite's `
|
|
4203
|
+
* from the rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4013
4204
|
*/
|
|
4014
4205
|
fromRotationMatrix(matrix: Matrix): this;
|
|
4015
4206
|
/**
|
|
@@ -4024,12 +4215,12 @@ export declare class Quaternion {
|
|
|
4024
4215
|
static Identity(): Quaternion;
|
|
4025
4216
|
/**
|
|
4026
4217
|
* Babylon.js `Quaternion.FromRotationMatrix` — create a new quaternion from the
|
|
4027
|
-
* rotation part of `matrix`. Backed by Lite's `
|
|
4218
|
+
* rotation part of `matrix`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4028
4219
|
*/
|
|
4029
4220
|
static FromRotationMatrix(matrix: Matrix): Quaternion;
|
|
4030
4221
|
/**
|
|
4031
4222
|
* Babylon.js `Quaternion.FromRotationMatrixToRef` — write the rotation part of
|
|
4032
|
-
* `matrix` into `result`. Backed by Lite's `
|
|
4223
|
+
* `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4033
4224
|
*/
|
|
4034
4225
|
static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
|
|
4035
4226
|
static FromEulerAngles(x: number, y: number, z: number): Quaternion;
|
|
@@ -4171,10 +4362,30 @@ export declare class ReflectionProbe {
|
|
|
4171
4362
|
constructor();
|
|
4172
4363
|
}
|
|
4173
4364
|
|
|
4365
|
+
/**
|
|
4366
|
+
* Babylon.js pure-module texture-loader registration hook. Lite dispatches its
|
|
4367
|
+
* supported texture formats directly, so no registration is required.
|
|
4368
|
+
*/
|
|
4369
|
+
export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
4370
|
+
|
|
4371
|
+
/**
|
|
4372
|
+
* Babylon.js registers built-in loader factories through a global plugin
|
|
4373
|
+
* registry. Compat dispatches its supported formats directly, so registration
|
|
4374
|
+
* is already complete and this compatibility hook is intentionally idempotent.
|
|
4375
|
+
*/
|
|
4376
|
+
export declare function registerBuiltInLoaders(): void;
|
|
4377
|
+
|
|
4378
|
+
export declare function RegisterFluidRenderer(): void;
|
|
4379
|
+
|
|
4174
4380
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
4175
4381
|
|
|
4382
|
+
/** Babylon.js pure-module registration hook. */
|
|
4383
|
+
export declare function RegisterImageProcessingConfiguration(): void;
|
|
4384
|
+
|
|
4176
4385
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4177
4386
|
|
|
4387
|
+
export declare function RegisterUSDFileLoader(): never;
|
|
4388
|
+
|
|
4178
4389
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
4179
4390
|
export declare class RenderTargetTexture {
|
|
4180
4391
|
constructor();
|
|
@@ -4184,6 +4395,10 @@ export declare class RotationGizmo extends GizmoBase {
|
|
|
4184
4395
|
private _attached;
|
|
4185
4396
|
private _xGizmo;
|
|
4186
4397
|
private _yGizmo;
|
|
4187
4398
|
private _zGizmo;
|
|
4399
|
+
private _dragSubscriptions;
|
|
4400
|
+
readonly onDragStartObservable: Observable<DragStartEndEvent>;
|
|
4401
|
+
readonly onDragObservable: Observable<DragEvent_2>;
|
|
4402
|
+
readonly onDragEndObservable: Observable<DragStartEndEvent>;
|
|
4188
4403
|
constructor(layer: UtilityLayerRenderer);
|
|
4189
4404
|
/** Babylon.js `RotationGizmo.xGizmo/yGizmo/zGizmo` — the per-plane rotation sub-gizmos. */
|
|
4190
4405
|
get xGizmo(): PlaneRotationGizmo;
|
|
@@ -4239,9 +4454,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4239
4454
|
/** Babylon.js fog-mode c
|
|
4240
4455
|
readonly onBeforeAnimationsObservable: Observable<Scene>;
|
|
4241
4456
|
/** Fires after each scene render. */
|
|
4242
4457
|
readonly onAfterRenderObservable: Observable<Scene>;
|
|
4458
|
+
/** Fires after each Lite Havok simulation step. */
|
|
4459
|
+
readonly onAfterPhysicsObservable: Observable<Scene>;
|
|
4243
4460
|
/** Fires once when the scene is disposed. */
|
|
4244
4461
|
readonly onDisposeObservable: Observable<Scene>;
|
|
4245
|
-
/**
|
|
4462
|
+
/** Babylon.js scene-level pointer events from the engine rendering canvas. */
|
|
4463
|
+
readonly onPointerObservable: Observable<PointerInfo>;
|
|
4246
4464
|
/**
|
|
4247
4465
|
* Babylon.js `scene.animationGroups` / `scene.animatables`. Loaded glTF /
|
|
4248
4466
|
* `.babylon` animation clips live on the Lite scene; `animationGroups` returns
|
|
4249
4467
|
* BJS-shaped `AnimationGroup`s over them (so scenes can `goToFrame`/`pause`/`stop`
|
|
@@ -4254,6 +4472,7 @@ export declare class Scene extends AbstractScene {
|
|
|
4254
4472
|
/** Babylon.js fog-mode c
|
|
4255
4473
|
get animatables(): Animatable_2[];
|
|
4256
4474
|
private readonly _engine;
|
|
4257
4475
|
private _activeCamera;
|
|
4476
|
+
cameraToUseForPointers: Camera | null;
|
|
4258
4477
|
private _defaultMaterial;
|
|
4259
4478
|
private _fogMode;
|
|
4260
4479
|
private _fogStart;
|
|
@@ -4269,9 +4488,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4269
4488
|
/** Babylon.js fog-mode c
|
|
4270
4489
|
private readonly _pendingMorphBuilds;
|
|
4271
4490
|
private readonly _runningAnimatables;
|
|
4272
4491
|
private readonly _animationGroupCache;
|
|
4273
4492
|
private _ambientColor;
|
|
4274
|
-
private _environmentIntensity;
|
|
4275
4493
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4494
|
+
private _environmentIntensity;
|
|
4495
|
+
private _imageProcessingConfiguration;
|
|
4276
4496
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
4277
4497
|
readonly uniqueId: number;
|
|
4278
|
-
constructor(engine: WebGPUEngine);
|
|
4279
4498
|
getEngine(): WebGPUEngine;
|
|
4499
|
+
constructor(engine: WebGPUEngine);
|
|
4500
|
+
private _attachPointerEvents;
|
|
4501
|
+
private _detachPointerEvents;
|
|
4280
4502
|
getEngine(): WebGPUEngine;
|
|
4281
4503
|
/** Babylon.js `scene.getClassName()`. */
|
|
4282
4504
|
getClassName(): string;
|
|
4283
4505
|
/** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
|
|
@@ -4286,12 +4508,12 @@ export declare class Scene extends AbstractScene {
|
|
|
4286
4508
|
/** Babylon.js fog-mode c
|
|
4287
4509
|
get clearColor(): Color4;
|
|
4288
4510
|
set clearColor(value: Color4);
|
|
4289
4511
|
get activeCamera(): Camera | null;
|
|
4290
|
-
set activeCamera(camera: Camera | null);
|
|
4291
4512
|
/** Image-processing exposure proxy (Babylon.js `imageProcessingConfiguration.exposure`). */
|
|
4292
|
-
|
|
4293
|
-
exposure: number;
|
|
4294
|
-
contrast: number;
|
|
4295
|
-
toneMappingEnabled: boolean;
|
|
4296
|
-
};
|
|
4513
|
+
set activeCamera(camera: Camera | null);
|
|
4297
4514
|
/** Babylon.js image-processing facade over the scene's Lite state. */
|
|
4515
|
+
get imageProcessingConfiguration(): ImageProcessingConfiguration;
|
|
4516
|
+
get fluidRenderer(): FluidRenderer | null;
|
|
4517
|
+
set fluidRenderer(value: FluidRenderer | null);
|
|
4518
|
+
enableFluidRenderer(): FluidRenderer | null;
|
|
4519
|
+
disableFluidRenderer(): void;
|
|
4298
4520
|
/** Babylon.js `scene.performancePriority` — accepted for parity; Babylon Lite tunes its own pipeline. */
|
|
4299
4521
|
performancePriority: number;
|
|
4300
4522
|
/**
|
|
@@ -4395,10 +4617,15 @@ export declare class Scene extends AbstractScene {
|
|
|
4395
4617
|
/** Babylon.js fog-mode c
|
|
4396
4618
|
whenReadyAsync(): Promise<void>;
|
|
4397
4619
|
/** Babylon.js synchronous readiness check — always ready in the compat layer. */
|
|
4398
4620
|
isReady(): boolean;
|
|
4399
|
-
/**
|
|
4400
|
-
pick():
|
|
4621
|
+
/** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
|
|
4622
|
+
pick(x: number, y: number, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4623
|
+
/**
|
|
4624
|
+
* Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
|
|
4625
|
+
* transforms into Lite's reverse-Z unprojection helper.
|
|
4626
|
+
*/
|
|
4627
|
+
createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
|
|
4401
4628
|
/** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
|
|
4402
|
-
pickWithRay(ray: Ray, predicate?: (mesh: TransformNode) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4403
4629
|
/**
|
|
4630
|
+
pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
4404
4631
|
/**
|
|
4405
4632
|
* Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
|
|
4406
4633
|
* {@link HavokPlugin} to this scene, creating the native Lite physics world and
|
|
4407
4634
|
* registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
|
|
@@ -4499,7 +4726,11 @@ export declare class ShaderMaterial {
|
|
|
4499
4726
|
export declare class ShadowGenerator {
|
|
4500
4727
|
private readonly _mapSize;
|
|
4501
4728
|
private readonly _light;
|
|
4502
|
-
private readonly _casters;
|
|
4503
4729
|
getClassName(): string;
|
|
4730
|
+
private readonly _casters;
|
|
4731
|
+
private readonly _casterDisposeObservers;
|
|
4732
|
+
private _casterSyncScheduled;
|
|
4733
|
+
private _casterSyncDirty;
|
|
4734
|
+
private readonly _disposeBeforeRenderFlush;
|
|
4504
4735
|
getClassName(): string;
|
|
4505
4736
|
/** Percentage-closer filtering. */
|
|
4506
4737
|
usePercentageCloserFiltering: boolean;
|
|
4507
4738
|
/** Contact-hardening (treated as PCF here). */
|
|
@@ -4524,9 +4755,14 @@ export declare class ShadowGenerator {
|
|
|
4524
4755
|
orthoMaxZ: number | undefined;
|
|
4525
4756
|
constructor(mapSize: number, light: Light);
|
|
4526
4757
|
/** Babylon.js `addShadowCaster(mesh, includeDescendants?)`. */
|
|
4527
|
-
addShadowCaster(mesh: AbstractMesh,
|
|
4528
|
-
/** Babylon.js `removeShadowCaster(mesh)`. */
|
|
4529
|
-
removeShadowCaster(mesh: AbstractMesh): ShadowGenerator;
|
|
4758
|
+
addShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
|
|
4759
|
+
/** Babylon.js `removeShadowCaster(mesh, includeDescendants?)`. */
|
|
4760
|
+
removeShadowCaster(mesh: AbstractMesh, includeDescendants?: boolean): ShadowGenerator;
|
|
4761
|
+
private _casterTree;
|
|
4762
|
+
private _detachCasterDisposeObserver;
|
|
4763
|
+
private _removeCaster;
|
|
4764
|
+
private _scheduleCasterSync;
|
|
4765
|
+
private _flushCasterSync;
|
|
4530
4766
|
/** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
|
|
4531
4767
|
getShadowMap(): {
|
|
4532
4768
|
renderList: AbstractMesh[];
|
|
@@ -5023,6 +5259,8 @@ export declare class TargetCamera extends Camera {
|
|
|
5023
5259
|
constructor(name: string,
|
|
5024
5260
|
|
|
5025
5261
|
declare type TaskState = "init" | "running" | "done" | "error";
|
|
5026
5262
|
|
|
5263
|
+
export declare function TemperatureTintToXyz(_temperatureKelvin: number, _tint: number): Vector3;
|
|
5264
|
+
|
|
5027
5265
|
export declare class Texture extends BaseTexture {
|
|
5028
5266
|
private readonly _ready;
|
|
5029
5267
|
private _onLoadObservable;
|
|
@@ -5179,8 +5417,7 @@ export declare class TransformNode extends Node_2 {
|
|
|
5179
5417
|
physicsBody: PhysicsBody
|
|
5180
5418
|
* setter, which keeps the local transform and lets the world move.
|
|
5181
5419
|
*/
|
|
5182
5420
|
setParent(parent: Node_2 | null): TransformNode;
|
|
5183
|
-
protected _applyParent(parent: Node_2 | null): void;
|
|
5184
|
-
}
|
|
5421
|
+
protected _applyParent(parent: Node_2 | null): void;
|
|
5185
5422
|
|
|
5186
5423
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
5187
5424
|
|
|
@@ -5206,6 +5443,60 @@ export declare function UploadHtmlElementToTexture(): never;
|
|
|
5206
5443
|
*/
|
|
5207
5444
|
export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DArray, source: ImageSource, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): void;
|
|
5208
5445
|
|
|
5446
|
+
export declare type USDBinaryInput = ArrayBuffer | ArrayBufferView;
|
|
5447
|
+
|
|
5448
|
+
export declare class USDFileLoader {
|
|
5449
|
+
constructor(_options?: Partial<USDFileLoaderOptions>);
|
|
5450
|
+
}
|
|
5451
|
+
|
|
5452
|
+
export declare interface USDFileLoaderOptions {
|
|
5453
|
+
rootFileName?: string;
|
|
5454
|
+
files?: USDVirtualFiles;
|
|
5455
|
+
resolveByFileName?: boolean;
|
|
5456
|
+
workerUrl?: string | URL;
|
|
5457
|
+
glueUrl?: string;
|
|
5458
|
+
wasmUrl?: string;
|
|
5459
|
+
dataUrl?: string;
|
|
5460
|
+
onProgress?: (progress: USDLoadProgress) => void;
|
|
5461
|
+
onLog?: (level: "info" | "warning" | "error", message: string) => void;
|
|
5462
|
+
onComplete?: (diagnostics: USDImportDiagnostics) => void;
|
|
5463
|
+
}
|
|
5464
|
+
|
|
5465
|
+
export declare interface USDImportDiagnostics {
|
|
5466
|
+
timings: USDImportTimings;
|
|
5467
|
+
statistics: USDImportStatistics;
|
|
5468
|
+
missingAssets: readonly string[];
|
|
5469
|
+
}
|
|
5470
|
+
|
|
5471
|
+
export declare interface USDImportStatistics {
|
|
5472
|
+
nodes: number;
|
|
5473
|
+
meshes: number;
|
|
5474
|
+
analyticPrimitives: number;
|
|
5475
|
+
instances: number;
|
|
5476
|
+
materials: number;
|
|
5477
|
+
vertices: number;
|
|
5478
|
+
triangles: number;
|
|
5479
|
+
commandBytes: number;
|
|
5480
|
+
dataBytes: number;
|
|
5481
|
+
}
|
|
5482
|
+
|
|
5483
|
+
export declare interface USDImportTimings {
|
|
5484
|
+
totalMs: number;
|
|
5485
|
+
stageOpenMs: number;
|
|
5486
|
+
stageReadMs: number;
|
|
5487
|
+
preparationMs: number;
|
|
5488
|
+
packingMs: number;
|
|
5489
|
+
heapCopyMs: number;
|
|
5490
|
+
materializeMs: number;
|
|
5491
|
+
}
|
|
5492
|
+
|
|
5493
|
+
export declare interface USDLoadProgress {
|
|
5494
|
+
phase: "initializing" | "staging" | "extracting" | "materializing";
|
|
5495
|
+
message: string;
|
|
5496
|
+
}
|
|
5497
|
+
|
|
5498
|
+
export declare type USDVirtualFiles = Readonly<Record<string, USDBinaryInput>>;
|
|
5499
|
+
|
|
5209
5500
|
/** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
|
|
5210
5501
|
export declare class UtilityLayerRenderer {
|
|
5211
5502
|
private _registered;
|
|
5212
5503
|
constructor(scene: Scene);
|
|
5213
5504
|
dispose(): void;
|
|
@@ -5318,6 +5609,10 @@ export declare class Vector3 {
|
|
|
5318
5609
|
static NormalizeToRef<T extends Vector3>(vector: Vector3, result: T): T;
|
|
5319
5610
|
static Minimize(a: Vector3, b: Vector3): Vector3;
|
|
5320
5611
|
static Maximize(a: Vector3, b: Vector3): Vector3;
|
|
5612
|
+
/** Project a world-space point into a Babylon.js viewport. */
|
|
5613
|
+
static Project(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport): Vector3;
|
|
5614
|
+
/** Project a world-space point into a Babylon.js viewport, writing into `result`. */
|
|
5615
|
+
static ProjectToRef<T extends Vector3>(vector: Vector3, world: Matrix, transform: Matrix, viewport: Viewport, result: T): T;
|
|
5321
5616
|
/** Transform a coordinate (point) by a matrix using the row-vector convention. */
|
|
5322
5617
|
static TransformCoordinates(vector: Vector3, transformation: Matrix): Vector3;
|
|
5323
5618
|
/** Transform a coordinate (point) by a matrix using the row-vector convention. */
|