@babylonjs/lite-compat 1.29.0-preview → 1.31.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 +32 -31
- 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 +492 -9
- package/index.js +11148 -10214
- package/index.js.map +1 -1
- package/meshes-Fu955h5M.js +3642 -0
- package/meshes-Fu955h5M.js.map +1 -0
- package/navigation.d.ts +130 -2
- package/navigation.js +191 -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-C1K63hzW.js +0 -3503
- package/meshes-C1K63hzW.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -7,7 +7,9 @@ import { EngineContext } from '@babylonjs/lite';
|
|
|
7
7
|
import { EngineOptions } from '@babylonjs/lite';
|
|
8
8
|
import { IridescenceProps } from '@babylonjs/lite';
|
|
9
9
|
import { LineMaterial } from '@babylonjs/lite';
|
|
10
|
+
import { MaxTintMagnitude } from '@babylonjs/lite';
|
|
10
11
|
import { Mesh as Mesh_2 } from '@babylonjs/lite';
|
|
12
|
+
import { MinTemperatureKelvin } from '@babylonjs/lite';
|
|
11
13
|
import { PhysicsMassProperties } from '@babylonjs/lite';
|
|
12
14
|
import { PhysicsShape as PhysicsShape_2 } from '@babylonjs/lite';
|
|
13
15
|
import { PhysicsShapeParameters } from '@babylonjs/lite';
|
|
@@ -236,6 +238,7 @@ export declare abstract class AbstractEngine {
|
|
|
236
238
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
237
239
|
*/
|
|
238
240
|
export declare class AbstractMesh extends TransformNode {
|
|
239
241
|
private _material;
|
|
242
|
+
private _meshBlendingTag;
|
|
240
243
|
protected _visible: boolean;
|
|
241
244
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
242
245
|
getClassName(): string;
|
|
243
246
|
get material(): CompatMaterial | null;
|
|
@@ -246,6 +249,8 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
246
249
|
private _material;
|
|
247
250
|
set isPickable(value: boolean);
|
|
248
251
|
get receiveShadows(): boolean;
|
|
249
252
|
set receiveShadows(value: boolean);
|
|
253
|
+
get meshBlendingTag(): number;
|
|
254
|
+
set meshBlendingTag(value: number);
|
|
250
255
|
protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
|
|
251
256
|
/**
|
|
252
257
|
* Babylon.js `mesh.getBoundingInfo()` — the mesh's AABB. `minimum`/`maximum`
|
|
253
258
|
* are the local-space bounds; the returned `BoundingInfo`'s world members
|
|
@@ -787,7 +792,7 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
787
792
|
constructor(name: stri
|
|
788
793
|
/** Right-drag panning sensitivity in pixels-per-unit (LOWER = faster pan). Babylon default 50. */
|
|
789
794
|
get panningSensibility(): number;
|
|
790
795
|
set panningSensibility(value: number);
|
|
791
|
-
attachControl(canvas: HTMLCanvasElement,
|
|
796
|
+
attachControl(canvas: HTMLCanvasElement, noPreventDefault?: boolean): void;
|
|
792
797
|
|
|
793
798
|
export declare class AssetContainer {
|
|
794
799
|
constructor(lite: AssetContainer_2);
|
|
795
800
|
get animationGroups(): AnimationGroup_2[];
|
|
@@ -1429,6 +1434,8 @@ export declare function CreateCylinder(name: string, options: CylinderOptions, s
|
|
|
1429
1434
|
/** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
|
|
1430
1435
|
export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
|
|
1431
1436
|
|
|
1437
|
+
export declare function CreateDefaultMeshBlendRadiusDefinitions(): MeshBlendRadiusDefinitions;
|
|
1438
|
+
|
|
1432
1439
|
/** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
|
|
1433
1440
|
export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
|
|
1434
1441
|
|
|
@@ -1671,6 +1678,43 @@ export declare class DistanceConstraint extends PhysicsConstraint {
|
|
|
1671
1678
|
constructor(maxDistance: number, scene: Scene);
|
|
1672
1679
|
}
|
|
1673
1680
|
|
|
1681
|
+
export declare class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
|
|
1682
|
+
static readonly Name = "DitheredTileFade";
|
|
1674
1683
|
constructor(material: DitheredTileFadeSupportedMaterial);
|
|
1684
|
+
static GetOrCreate(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1685
|
+
get isEnabled(): boolean;
|
|
1686
|
+
set isEnabled(_value: boolean);
|
|
1687
|
+
setFadeBounds(_mesh: DitheredTileFadeMesh, _lowerBound: number, _upperBound: number): void;
|
|
1688
|
+
setFadeLowerBound(_mesh: DitheredTileFadeMesh, _lowerBound: number): void;
|
|
1689
|
+
setFadeUpperBound(_mesh: DitheredTileFadeMesh, _upperBound: number): void;
|
|
1690
|
+
getFadeBoundsToRef(_mesh: DitheredTileFadeMesh, _result: IDitheredTileFadeBounds): boolean;
|
|
1691
|
+
resetFade(_mesh: DitheredTileFadeMesh): void;
|
|
1692
|
+
setThinInstanceFadeBounds(_mesh: Mesh, _index: number, _lowerBound: number, _upperBound: number, _refresh?: boolean): void;
|
|
1693
|
+
setThinInstanceFadeBoundsBuffer(_mesh: Mesh, _bounds: Float32Array): void;
|
|
1694
|
+
commitThinInstanceFadeBounds(_mesh: Mesh): void;
|
|
1695
|
+
resetThinInstanceFade(_mesh: Mesh, _index: number, _refresh?: boolean): void;
|
|
1696
|
+
reset(): void;
|
|
1697
|
+
copyToMaterial(_material: DitheredTileFadeSupportedMaterial): DitheredTileFadeMaterialPlugin;
|
|
1698
|
+
getClassName(): string;
|
|
1699
|
+
}
|
|
1700
|
+
|
|
1701
|
+
export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
|
|
1702
|
+
|
|
1703
|
+
export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
|
|
1704
|
+
|
|
1705
|
+
/** Babylon.js drag move payload. */
|
|
1706
|
+
declare type DragEvent_2 = {
|
|
1707
|
+
delta: Vector3;
|
|
1708
|
+
dragPlanePoint: Vector3;
|
|
1709
|
+
dragPlaneNormal: Vector3;
|
|
1710
|
+
dragDistance: number;
|
|
1711
|
+
pointerId: number;
|
|
1712
|
+
pointerInfo: PointerInfo | null;
|
|
1713
|
+
};
|
|
1714
|
+
export { DragEvent_2 as DragEvent }
|
|
1715
|
+
|
|
1716
|
+
/** Babylon.js drag start/end payload. */
|
|
1717
|
+
export declare type DragStartEndEvent = Pick<DragEvent_2, "dragPlanePoint" | "pointerId" | "pointerInfo">;
|
|
1718
|
+
|
|
1675
1719
|
/**
|
|
1676
1720
|
* Babylon.js `DynamicTexture` — a canvas-backed texture. Draw into
|
|
1677
1721
|
* `getContext()`, then call `update()` to upload the canvas pixels to the GPU.
|
|
@@ -1782,8 +1826,126 @@ export declare class FadeInOutBehavior {
|
|
|
1782
1826
|
constructor();
|
|
1783
1827
|
}
|
|
1784
1828
|
|
|
1829
|
+
export declare class FBXConstraintBehavior {
|
|
1830
|
+
readonly constraint: FBXConstraintData;
|
|
1831
|
+
readonly name: string;
|
|
1832
|
+
attachedNode: TransformNode | null;
|
|
1833
|
+
enabled: boolean;
|
|
1834
|
+
constructor(constraint: FBXConstraintData, _options: FBXConstraintBehaviorOptions);
|
|
1835
|
+
init(): void;
|
|
1836
|
+
attach(_target: TransformNode): void;
|
|
1837
|
+
detach(): void;
|
|
1838
|
+
captureBase(): void;
|
|
1839
|
+
restoreBase(): void;
|
|
1840
|
+
dependencyNodes(): Array<Node_2 | null>;
|
|
1841
|
+
evaluate(): void;
|
|
1842
|
+
}
|
|
1843
|
+
|
|
1844
|
+
export declare interface FBXConstraintBehaviorOptions {
|
|
1845
|
+
root: TransformNode;
|
|
1846
|
+
targets: FBXConstraintBehaviorTarget[];
|
|
1847
|
+
upNode: TransformNode | null;
|
|
1848
|
+
sceneUp: Vector3;
|
|
1849
|
+
}
|
|
1850
|
+
|
|
1851
|
+
export declare interface FBXConstraintBehaviorTarget {
|
|
1852
|
+
node: TransformNode;
|
|
1853
|
+
weight: number;
|
|
1854
|
+
offset: Matrix;
|
|
1855
|
+
}
|
|
1856
|
+
|
|
1857
|
+
declare type FBXConstraintBoolean3 = [boolean, boolean, boolean];
|
|
1858
|
+
|
|
1859
|
+
export declare interface FBXConstraintData {
|
|
1860
|
+
id: number;
|
|
1861
|
+
name: string;
|
|
1862
|
+
type: FBXConstraintType;
|
|
1863
|
+
typeName: string;
|
|
1864
|
+
nodeId?: number;
|
|
1865
|
+
targets: FBXConstraintTarget[];
|
|
1866
|
+
weight: number;
|
|
1867
|
+
active: boolean;
|
|
1868
|
+
affectTranslation: FBXConstraintBoolean3;
|
|
1869
|
+
affectRotation: FBXConstraintBoolean3;
|
|
1870
|
+
affectScale: FBXConstraintBoolean3;
|
|
1871
|
+
offsetTranslation: FBXConstraintVector3;
|
|
1872
|
+
offsetRotation: FBXConstraintVector3;
|
|
1873
|
+
offsetScale: FBXConstraintVector3;
|
|
1874
|
+
aimVector: FBXConstraintVector3;
|
|
1875
|
+
upVector: FBXConstraintVector3;
|
|
1876
|
+
worldUpVector: FBXConstraintVector3;
|
|
1877
|
+
worldUpType: number;
|
|
1878
|
+
worldUpNodeId?: number;
|
|
1879
|
+
ikFirstJointId?: number;
|
|
1880
|
+
ikEndJointId?: number;
|
|
1881
|
+
ikEffectorId?: number;
|
|
1882
|
+
ikPoleVector: FBXConstraintVector3;
|
|
1883
|
+
}
|
|
1884
|
+
|
|
1885
|
+
export declare class FBXConstraintSolver {
|
|
1886
|
+
private constructor();
|
|
1887
|
+
static Get(_scene: Scene): FBXConstraintSolver | undefined;
|
|
1888
|
+
static GetOrCreate(_scene: Scene): FBXConstraintSolver;
|
|
1889
|
+
get constraints(): readonly FBXConstraintBehavior[];
|
|
1890
|
+
get cyclicConstraints(): readonly FBXConstraintBehavior[];
|
|
1891
|
+
register(_behavior: FBXConstraintBehavior): void;
|
|
1892
|
+
unregister(_behavior: FBXConstraintBehavior): void;
|
|
1893
|
+
invalidateOrder(): void;
|
|
1894
|
+
beginFrame(): void;
|
|
1895
|
+
solve(): void;
|
|
1896
|
+
}
|
|
1897
|
+
|
|
1898
|
+
export declare interface FBXConstraintTarget {
|
|
1899
|
+
modelId: number;
|
|
1900
|
+
weight: number;
|
|
1901
|
+
offsetTranslation: FBXConstraintVector3;
|
|
1902
|
+
offsetRotation: FBXConstraintVector3;
|
|
1903
|
+
offsetScale: FBXConstraintVector3;
|
|
1904
|
+
}
|
|
1905
|
+
|
|
1906
|
+
export declare type FBXConstraintType = "aim" | "parent" | "position" | "rotation" | "scale" | "singleChainIK" | "unknown";
|
|
1907
|
+
|
|
1908
|
+
declare type FBXConstraintVector3 = [number, number, number];
|
|
1909
|
+
|
|
1785
1910
|
export declare class FBXFileLoader {
|
|
1786
|
-
constructor();
|
|
1911
|
+
constructor(_options?: Partial<FBXFileLoaderOptions>);
|
|
1912
|
+
}
|
|
1913
|
+
|
|
1914
|
+
export declare const FBXFileLoaderMetadata: {
|
|
1915
|
+
readonly name: "fbx";
|
|
1916
|
+
readonly extensions: {
|
|
1917
|
+
readonly ".fbx": {
|
|
1918
|
+
readonly isBinary: true;
|
|
1919
|
+
};
|
|
1920
|
+
};
|
|
1921
|
+
};
|
|
1922
|
+
|
|
1923
|
+
export declare interface FBXFileLoaderOptions {
|
|
1924
|
+
preset?: "compatible" | "full";
|
|
1925
|
+
normalMapCoordinateSystem?: FBXNormalMapCoordinateSystem;
|
|
1926
|
+
materials?: "auto" | "standard" | "pbr";
|
|
1927
|
+
unitScale?: "preserve" | "meters" | number;
|
|
1928
|
+
shareGeometry?: boolean;
|
|
1929
|
+
onWarning?: (warning: FBXLoaderWarning) => void;
|
|
1930
|
+
nurbsSubdivision?: number;
|
|
1931
|
+
curves?: "lines" | "skip";
|
|
1932
|
+
constraints?: "apply" | "metadata";
|
|
1933
|
+
rebaseAnimations?: boolean;
|
|
1934
|
+
attachCamerasAndLights?: boolean;
|
|
1935
|
+
}
|
|
1936
|
+
|
|
1937
|
+
export declare interface FBXLoaderWarning {
|
|
1938
|
+
source: "scene" | "model" | "geometry" | "skin" | "rig" | "animation" | "blendShape" | "camera" | "light";
|
|
1939
|
+
message: string;
|
|
1940
|
+
objectName?: string;
|
|
1941
|
+
details?: unknown;
|
|
1942
|
+
}
|
|
1943
|
+
|
|
1944
|
+
export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
1945
|
+
|
|
1946
|
+
export declare enum FlowGraphValidationSeverity {
|
|
1947
|
+
Error = 0,
|
|
1948
|
+
Warning = 1
|
|
1787
1949
|
}
|
|
1788
1950
|
|
|
1789
1951
|
export declare class FluidRenderer {
|
|
@@ -1837,6 +1999,10 @@ export declare class FollowCamera extends TargetCamera {
|
|
|
1837
1999
|
private _follow;
|
|
1838
2000
|
}
|
|
1839
2001
|
|
|
2002
|
+
export declare class FrameGraphMeshBlendingTask {
|
|
2003
|
+
constructor(..._args: unknown[]);
|
|
2004
|
+
}
|
|
2005
|
+
|
|
1840
2006
|
/** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
|
|
1841
2007
|
export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
|
|
1842
2008
|
readonly name = "Framing";
|
|
@@ -1919,15 +2085,28 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
1919
2085
|
/**
|
|
1920
2086
|
|
|
1921
2087
|
export declare class GaussianSplattingStream {
|
|
1922
2088
|
constructor(..._args: unknown[]);
|
|
2089
|
+
get minimumResidentSplats(): never;
|
|
1923
2090
|
}
|
|
1924
2091
|
|
|
1925
2092
|
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
1926
2093
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
1927
2094
|
|
|
2095
|
+
/** Babylon.js finest-LOD splat-count resolution state. */
|
|
2096
|
+
export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
|
|
2097
|
+
status: "pending";
|
|
2098
|
+
}> | Readonly<{
|
|
2099
|
+
status: "available";
|
|
2100
|
+
count: number;
|
|
2101
|
+
}> | Readonly<{
|
|
2102
|
+
status: "unavailable";
|
|
2103
|
+
}>;
|
|
2104
|
+
|
|
1928
2105
|
export declare class GeometryBufferRenderer {
|
|
1929
2106
|
constructor();
|
|
1930
2107
|
}
|
|
1931
2108
|
|
|
2109
|
+
export declare type GeometryRenderingObjectIdProvider = (mesh: AbstractMesh) => number;
|
|
2110
|
+
|
|
1932
2111
|
/**
|
|
1933
2112
|
* Babylon.js `GeospatialCamera` — globe-orbit camera anchored to a surface
|
|
1934
2113
|
* `center` (ECEF), orbiting at `radius` with `yaw`/`pitch`. Wraps Babylon Lite's
|
|
@@ -1975,7 +2154,7 @@ export declare function GetPointsCount(..._args: unknown[]): never;
|
|
|
1975
2154
|
*/
|
|
1976
2155
|
export declare function GetSupportedSimultaneousLights(scene: Scene, maxSimultaneousLights: number): number;
|
|
1977
2156
|
|
|
1978
|
-
export declare function GetWhiteBalanceMatrix(
|
|
2157
|
+
export declare function GetWhiteBalanceMatrix(temperatureKelvin: number, tint: number): Float32Array;
|
|
1979
2158
|
|
|
1980
2159
|
/** Shared base for compat gizmos (Babylon.js `Gizmo`). */
|
|
1981
2160
|
declare abstract class GizmoBase {
|
|
1982
2161
|
protected constructor(layer: UtilityLayerRenderer);
|
|
@@ -2025,7 +2204,82 @@ export declare namespace GLTF1 {
|
|
|
2025
2204
|
|
|
2026
2205
|
export declare namespace GLTF2 {
|
|
2027
2206
|
export {
|
|
2028
|
-
OpenPBRMaterialLoadingAdapter
|
|
2207
|
+
OpenPBRMaterialLoadingAdapter,
|
|
2208
|
+
ParseDebugLogTemplate,
|
|
2209
|
+
getMappingForFullOperationName,
|
|
2210
|
+
getMappingForDeclaration,
|
|
2211
|
+
getNoOpMappingForDeclaration,
|
|
2212
|
+
addNewInteractivityFlowGraphMapping,
|
|
2213
|
+
getAllSupportedNativeNodeTypes,
|
|
2214
|
+
HasDefaultInteractivityFlowInput,
|
|
2215
|
+
NormalizeInteractivityEventDataConfiguration,
|
|
2216
|
+
GetInteractivityOperationRegistry,
|
|
2217
|
+
GetInteractivityObjectReference,
|
|
2218
|
+
_NormalizeKHRInteractivityRuntimeValue,
|
|
2219
|
+
_CreateKHRInteractivityRuntimeValueSnapshot,
|
|
2220
|
+
CloneKHRInteractivityGraph,
|
|
2221
|
+
CreateEffectiveKHRInteractivityGraph,
|
|
2222
|
+
CreateKHRInteractivityGraphModel,
|
|
2223
|
+
CreateKHRInteractivityDocument,
|
|
2224
|
+
_CaptureKHRInteractivityRuntimeInputDefaults,
|
|
2225
|
+
CreateKHRInteractivityExportPlan,
|
|
2226
|
+
InitializeInteractivityNodeState,
|
|
2227
|
+
GetInteractivityNodeState,
|
|
2228
|
+
SetInteractivityNodeState,
|
|
2229
|
+
KHRInteractivitySignature,
|
|
2230
|
+
IKHRInteractivityNode,
|
|
2231
|
+
IKHRInteractivityGraph,
|
|
2232
|
+
IKHRInteractivityDeclaration,
|
|
2233
|
+
IKHRInteractivityType,
|
|
2234
|
+
IKHRInteractivityVariable,
|
|
2235
|
+
IKHRInteractivityEvent,
|
|
2236
|
+
IKHRInteractivityOutputSocketReference,
|
|
2237
|
+
IKHRInteractivityOutputFlow,
|
|
2238
|
+
IKHRInteractivityConfiguration,
|
|
2239
|
+
IGLTF,
|
|
2240
|
+
ISerializedFlowGraphConnection,
|
|
2241
|
+
ISerializedFlowGraphBlock,
|
|
2242
|
+
ISerializedFlowGraphContext,
|
|
2243
|
+
ISerializedFlowGraph,
|
|
2244
|
+
IGLTFToFlowGraphMappingObject,
|
|
2245
|
+
IGLTFToFlowGraphMapping,
|
|
2246
|
+
IKHRInteractivityOperationRegistryEntry,
|
|
2247
|
+
IDebugLogTemplateParseResult,
|
|
2248
|
+
KHRInteractivityFlowGraphType,
|
|
2249
|
+
IKHRInteractivityTypeMapping,
|
|
2250
|
+
gltfTypeToBabylonType,
|
|
2251
|
+
IFlowGraphEventReferenceBlockConfiguration,
|
|
2252
|
+
FlowGraphEventReferenceBlock,
|
|
2253
|
+
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2254
|
+
FlowGraphGLTFDataProvider,
|
|
2255
|
+
FlowGraphObjectReferenceBlock,
|
|
2256
|
+
IFlowGraphUnsupportedInteractivitySocket,
|
|
2257
|
+
IFlowGraphUnsupportedInteractivityBlockConfiguration,
|
|
2258
|
+
FlowGraphUnsupportedInteractivityBlock,
|
|
2259
|
+
KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
|
|
2260
|
+
KHRInteractivityDeclarationSupport,
|
|
2261
|
+
IKHRInteractivityDiagnostic,
|
|
2262
|
+
IKHRInteractivityDeclarationModel,
|
|
2263
|
+
IKHRInteractivityGraphModel,
|
|
2264
|
+
IKHRInteractivityInputDefaultProvenance,
|
|
2265
|
+
IKHRInteractivityConfigurationProvenance,
|
|
2266
|
+
IKHRInteractivityBlockProvenance,
|
|
2267
|
+
IKHRInteractivitySocketProvenance,
|
|
2268
|
+
IKHRInteractivityGraphProvenance,
|
|
2269
|
+
IKHRInteractivityDocument,
|
|
2270
|
+
KHRInteractivityExportClassification,
|
|
2271
|
+
IKHRInteractivityExportDiagnostic,
|
|
2272
|
+
IKHRInteractivityNodeExportAnalysis,
|
|
2273
|
+
IKHRInteractivityExportAnalysis,
|
|
2274
|
+
KhrInteractivityRootCollection,
|
|
2275
|
+
IKHRInteractivitySerializerContext,
|
|
2276
|
+
IKHRInteractivityExportProvider,
|
|
2277
|
+
IKHRInteractivityExportOptions,
|
|
2278
|
+
KHRInteractivityExportError,
|
|
2279
|
+
KHRInteractivityExportPlan,
|
|
2280
|
+
InteractivityEvent,
|
|
2281
|
+
InteractivityGraphToFlowGraphParser,
|
|
2282
|
+
InteractivityNodeState
|
|
2029
2283
|
}
|
|
2030
2284
|
}
|
|
2031
2285
|
|
|
@@ -2436,6 +2690,26 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
|
|
|
2436
2690
|
invertY?: boolean;
|
|
2437
2691
|
}
|
|
2438
2692
|
|
|
2693
|
+
export declare interface IDitheredTileFadeBounds {
|
|
2694
|
+
lowerBound: number;
|
|
2695
|
+
upperBound: number;
|
|
2696
|
+
}
|
|
2697
|
+
|
|
2698
|
+
export declare interface IFlowGraphValidationIssue {
|
|
2699
|
+
severity: FlowGraphValidationSeverity;
|
|
2700
|
+
message: string;
|
|
2701
|
+
block?: unknown;
|
|
2702
|
+
connectionName?: string;
|
|
2703
|
+
}
|
|
2704
|
+
|
|
2705
|
+
export declare interface IFlowGraphValidationResult {
|
|
2706
|
+
isValid: boolean;
|
|
2707
|
+
issues: IFlowGraphValidationIssue[];
|
|
2708
|
+
errorCount: number;
|
|
2709
|
+
warningCount: number;
|
|
2710
|
+
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
2711
|
+
}
|
|
2712
|
+
|
|
2439
2713
|
/** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
|
|
2440
2714
|
export declare interface IGaussianSplattingStreamingPart {
|
|
2441
2715
|
[key: string]: unknown;
|
|
@@ -2520,6 +2794,32 @@ declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement |
|
|
|
2520
2794
|
export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
|
|
2521
2795
|
}
|
|
2522
2796
|
|
|
2797
|
+
export declare interface IMeshBlendConfiguration {
|
|
2798
|
+
quality?: MeshBlendQuality;
|
|
2799
|
+
radiusClasses?: MeshBlendRadiusDefinitions;
|
|
2800
|
+
slopeFactor?: number;
|
|
2801
|
+
depthType?: MeshBlendDepthType;
|
|
2802
|
+
debugMode?: MeshBlendDebugMode;
|
|
2803
|
+
}
|
|
2804
|
+
|
|
2805
|
+
export declare interface IMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
2806
|
+
effectWrapper?: ThinMeshBlendingPostProcess;
|
|
2807
|
+
meshBlendTagTexture: unknown;
|
|
2808
|
+
depthTexture: unknown;
|
|
2809
|
+
baseColorTexture?: unknown;
|
|
2810
|
+
[key: string]: unknown;
|
|
2811
|
+
}
|
|
2812
|
+
|
|
2813
|
+
export declare interface IMeshBlendingTag {
|
|
2814
|
+
groupId: number;
|
|
2815
|
+
radiusClass: MeshBlendingRadiusClass;
|
|
2816
|
+
}
|
|
2817
|
+
|
|
2818
|
+
export declare interface IMeshBlendRadiusDefinition {
|
|
2819
|
+
worldRadius: number;
|
|
2820
|
+
minimumProjectedRadius: number;
|
|
2821
|
+
}
|
|
2822
|
+
|
|
2523
2823
|
/** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
|
|
2524
2824
|
export declare function ImportMeshAsync(source: string, scene: Scene, options?: ImportMeshOptions): Promise<ImportResult>;
|
|
2525
2825
|
|
|
@@ -2728,6 +3028,10 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
2728
3028
|
volume?: number;
|
|
2729
3029
|
}
|
|
2730
3030
|
|
|
3031
|
+
export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
3032
|
+
[key: string]: unknown;
|
|
3033
|
+
}
|
|
3034
|
+
|
|
2731
3035
|
/** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
|
|
2732
3036
|
export declare interface IUploadImageToTexture2DArrayLayerOptions {
|
|
2733
3037
|
/** Store the source with the Y axis inverted (false by default). */
|
|
@@ -2907,7 +3211,8 @@ export declare class MainAudioBus extends AbstractAudioBus {
|
|
|
2907
3211
|
getClassName():
|
|
2908
3212
|
|
|
2909
3213
|
/** Babylon.js `Material` — base class for all materials. */
|
|
2910
3214
|
export declare abstract class Material {
|
|
2911
|
-
name: string;
|
|
3215
|
+
name: string;
|
|
2912
3216
|
/** Babylon.js plugin manager, created lazily by the first `MaterialPluginBase`. */
|
|
3217
|
+
pluginManager: MaterialPluginManager | undefined;
|
|
2913
3218
|
/** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
|
|
2914
3219
|
transparencyMode: number | null;
|
|
2915
3220
|
/** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
|
|
@@ -2939,6 +3244,75 @@ export declare class MaterialGreasedLineDefines {
|
|
|
2939
3244
|
constructor(..._args: unknown[]);
|
|
2940
3245
|
}
|
|
2941
3246
|
|
|
3247
|
+
/**
|
|
3248
|
+
* Babylon.js `MaterialPluginBase` adapter over Lite's opt-in material-plugin
|
|
3249
|
+
* bridge. Subclasses keep the Babylon.js override shape while Lite receives a
|
|
3250
|
+
* plain plugin descriptor.
|
|
3251
|
+
*/
|
|
3252
|
+
export declare class MaterialPluginBase {
|
|
3253
|
+
private _name;
|
|
3254
|
+
private _priority;
|
|
3255
|
+
private _resolveIncludes;
|
|
3256
|
+
readonly markAllDefinesAsDirty: () => void;
|
|
3257
|
+
registerForExtraEvents: boolean;
|
|
3258
|
+
doNotSerialize: boolean;
|
|
3259
|
+
protected readonly _material: Material;
|
|
3260
|
+
protected readonly _pluginManager: MaterialPluginManager;
|
|
3261
|
+
protected readonly _pluginDefineNames?: MaterialPluginDefines;
|
|
2942
3262
|
constructor(material: Material, name: string, priority: number, defines?: MaterialPluginDefines, addToPluginList?: boolean, enable?: boolean, resolveIncludes?: boolean);
|
|
3263
|
+
get name(): string;
|
|
3264
|
+
set name(value: string);
|
|
3265
|
+
get priority(): number;
|
|
3266
|
+
set priority(value: number);
|
|
3267
|
+
get resolveIncludes(): boolean;
|
|
3268
|
+
set resolveIncludes(value: boolean);
|
|
2943
3269
|
protected _enable(enable: boolean): void;
|
|
2944
3270
|
private _assertSupportedExecution;
|
|
3271
|
+
isCompatible(_shaderLanguage: ShaderLanguage): boolean;
|
|
3272
|
+
getCustomCode(_shaderType: string, _shaderLanguage?: ShaderLanguage): MaterialPluginCustomCode | null;
|
|
3273
|
+
isReadyForSubMesh(_defines: object, _scene: Scene, _engine: object, _subMesh: object): boolean;
|
|
3274
|
+
hardBindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3275
|
+
bindForSubMesh(_uniformBuffer: object, _scene: Scene, _engine: object, _subMesh: object): void;
|
|
3276
|
+
collectDefines(defines: Record<string, {
|
|
3277
|
+
type: string;
|
|
3278
|
+
default: unknown;
|
|
3279
|
+
}>): void;
|
|
3280
|
+
prepareDefinesBeforeAttributes(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3281
|
+
prepareDefines(_defines: object, _scene: Scene, _mesh: AbstractMesh): void;
|
|
3282
|
+
hasTexture(_texture: BaseTexture): boolean;
|
|
3283
|
+
hasRenderTargetTextures(): boolean;
|
|
3284
|
+
fillRenderTargetTextures(_renderTargets: SmartArray<RenderTargetTexture>): void;
|
|
3285
|
+
getActiveTextures(_activeTextures: BaseTexture[]): void;
|
|
3286
|
+
getAnimatables(_animatables: object[]): void;
|
|
3287
|
+
addFallbacks(_defines: object, _fallbacks: object, currentRank: number): number;
|
|
3288
|
+
getSamplers(_samplers: string[]): void;
|
|
3289
|
+
getAttributes(_attributes: string[], _scene: Scene, _mesh: AbstractMesh): void;
|
|
3290
|
+
getUniformBuffersNames(_ubos: string[]): void;
|
|
3291
|
+
getUniforms(_shaderLanguage?: ShaderLanguage): {
|
|
3292
|
+
ubo?: Array<{
|
|
3293
|
+
name: string;
|
|
3294
|
+
size?: number;
|
|
3295
|
+
type?: string;
|
|
3296
|
+
arraySize?: number;
|
|
3297
|
+
}>;
|
|
3298
|
+
vertex?: string;
|
|
3299
|
+
fragment?: string;
|
|
3300
|
+
externalUniforms?: string[];
|
|
3301
|
+
};
|
|
3302
|
+
getClassName(): string;
|
|
3303
|
+
copyTo(plugin: MaterialPluginBase): void;
|
|
3304
|
+
serialize(): Record<string, unknown>;
|
|
3305
|
+
parse(source: Record<string, unknown>, _scene: Scene, _rootUrl: string): void;
|
|
3306
|
+
dispose(_forceDisposeTextures?: boolean): void;
|
|
3307
|
+
}
|
|
3308
|
+
|
|
3309
|
+
export declare type MaterialPluginCustomCode = Record<string, string>;
|
|
3310
|
+
|
|
3311
|
+
export declare type MaterialPluginDefines = Record<string, unknown>;
|
|
3312
|
+
|
|
3313
|
+
/** Babylon.js-shaped manager for the adapter-visible material plugin list. */
|
|
3314
|
+
export declare class MaterialPluginManager {
|
|
3315
|
+
private readonly _plugins;
|
|
3316
|
+
constructor(material: Material);
|
|
2945
3317
|
getPlugin<T = MaterialPluginBase>(name: string): T | null;
|
|
3318
|
+
}
|
|
3319
|
+
|
|
2946
3320
|
export declare class Matrix {
|
|
2947
3321
|
readonly m: Float32Array;
|
|
2948
3322
|
constructor();
|
|
@@ -2998,7 +3372,7 @@ export declare class Matrix {
|
|
|
2998
3372
|
markAsUpdated(): this;
|
|
2999
3373
|
}
|
|
3000
3374
|
|
|
3001
|
-
export
|
|
3375
|
+
export { MaxTintMagnitude }
|
|
3002
3376
|
|
|
3003
3377
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
3004
3378
|
export declare class Mesh extends AbstractMesh {
|
|
@@ -3071,6 +3445,47 @@ export declare class Mesh extends AbstractMesh {
|
|
|
3071
3445
|
static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
|
|
3072
3446
|
}
|
|
3073
3447
|
|
|
3448
|
+
export declare enum MeshBlendDebugMode {
|
|
3449
|
+
Off = 0,
|
|
3450
|
+
PackedTag = 1,
|
|
3451
|
+
CandidateDirectionDistance = 2,
|
|
3452
|
+
SeamFade = 3,
|
|
3453
|
+
RejectionReason = 4,
|
|
3454
|
+
StageWork = 5,
|
|
3455
|
+
Continuation = 6,
|
|
3456
|
+
TinyObject = 7,
|
|
3457
|
+
MultiTarget = 8,
|
|
3458
|
+
TargetColor = 9,
|
|
3459
|
+
ShadowAttenuation = 10,
|
|
3460
|
+
ColorInterpolation = 11,
|
|
3461
|
+
WorldPosition = 12
|
|
3462
|
+
}
|
|
3463
|
+
|
|
3464
|
+
export declare enum MeshBlendDepthType {
|
|
3465
|
+
View = 0,
|
|
3466
|
+
Screen = 1
|
|
3467
|
+
}
|
|
3468
|
+
|
|
3469
|
+
export declare class MeshBlendingPostProcess {
|
|
3470
|
+
constructor(..._args: unknown[]);
|
|
3471
|
+
}
|
|
3472
|
+
|
|
3473
|
+
export declare enum MeshBlendingRadiusClass {
|
|
3474
|
+
Small = 0,
|
|
3475
|
+
Medium = 1,
|
|
3476
|
+
Large = 2,
|
|
3477
|
+
ExtraLarge = 3
|
|
3478
|
+
}
|
|
3479
|
+
|
|
3480
|
+
export declare enum MeshBlendQuality {
|
|
3481
|
+
Low = 0,
|
|
3482
|
+
Medium = 1,
|
|
3483
|
+
High = 2,
|
|
3484
|
+
Cinematic = 3
|
|
3485
|
+
}
|
|
3486
|
+
|
|
3487
|
+
export declare type MeshBlendRadiusDefinitions = readonly [IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition, IMeshBlendRadiusDefinition];
|
|
3488
|
+
|
|
3074
3489
|
/** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
|
|
3075
3490
|
export declare const MeshBuilder: {
|
|
3076
3491
|
CreateBox(name: string, options: BoxOptions, scene: Scene): Mesh;
|
|
@@ -3135,7 +3550,7 @@ export declare class MeshoptCompression {
|
|
|
3135
3550
|
static get Default(): MeshoptCompression;
|
|
3136
3551
|
}
|
|
3137
3552
|
|
|
3138
|
-
export
|
|
3553
|
+
export { MinTemperatureKelvin }
|
|
3139
3554
|
|
|
3140
3555
|
export declare class MirrorTexture {
|
|
3141
3556
|
constructor();
|
|
@@ -3204,6 +3619,14 @@ declare abstract class Node_2 {
|
|
|
3204
3619
|
* descendant nodes that are meshes (all descendants by default).
|
|
3205
3620
|
*/
|
|
3206
3621
|
getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node_2) => boolean): Node_2[];
|
|
3622
|
+
/**
|
|
3623
|
+
* Babylon.js `node.getHierarchyBoundingVectors(includeDescendants?, predicate?)`
|
|
3624
|
+
* — world-space bounds spanning this mesh and eligible descendant meshes.
|
|
3625
|
+
*/
|
|
3626
|
+
getHierarchyBoundingVectors(includeDescendants?: boolean, predicate?: ((mesh: AbstractMesh) => boolean) | null): {
|
|
3627
|
+
min: Vector3;
|
|
3628
|
+
max: Vector3;
|
|
3629
|
+
};
|
|
3207
3630
|
isEnabled(checkAncestors?: boolean): boolean;
|
|
3208
3631
|
setEnabled(value: boolean): void;
|
|
3209
3632
|
isDisposed(): boolean;
|
|
3210
3633
|
dispose(doNotRecurse?: boolean): void;
|
|
@@ -3282,6 +3705,10 @@ export declare class NodeParticleSystemSet {
|
|
|
3282
3705
|
dispose(): void;
|
|
3283
3706
|
}
|
|
3284
3707
|
|
|
3708
|
+
export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
|
|
3709
|
+
constructor(..._args: unknown[]);
|
|
3710
|
+
}
|
|
3711
|
+
|
|
3285
3712
|
/**
|
|
3286
3713
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
3287
3714
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -3362,6 +3789,8 @@ export declare class OutlineRenderer {
|
|
|
3362
3789
|
constructor();
|
|
3363
3790
|
}
|
|
3364
3791
|
|
|
3792
|
+
export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
|
|
3793
|
+
|
|
3365
3794
|
export declare class ParticleHelper {
|
|
3366
3795
|
constructor();
|
|
3367
3796
|
}
|
|
@@ -4104,6 +4533,10 @@ export declare class PositionGizmo extends GizmoBase {
|
|
|
4104
4533
|
private _attached;
|
|
4105
4534
|
private _xGizmo;
|
|
4106
4535
|
private _yGizmo;
|
|
4107
4536
|
private _zGizmo;
|
|
4537
|
+
private _dragSubscriptions;
|
|
4538
|
+
readonly onDragStartObservable: Observable<DragStartEndEvent>;
|
|
4539
|
+
readonly onDragObservable: Observable<DragEvent_2>;
|
|
4540
|
+
readonly onDragEndObservable: Observable<DragStartEndEvent>;
|
|
4108
4541
|
constructor(layer: UtilityLayerRenderer);
|
|
4109
4542
|
/** Babylon.js `PositionGizmo.xGizmo/yGizmo/zGizmo` — the per-axis drag sub-gizmos.
|
|
4110
4543
|
* Exposed so callers can toggle interactivity per axis (e.g. `xGizmo.isEnabled = false`
|
|
@@ -4338,6 +4771,19 @@ export declare class ReflectionProbe {
|
|
|
4338
4771
|
*/
|
|
4339
4772
|
export declare function RegisterAbstractEngineTextureLoaders(): void;
|
|
4340
4773
|
|
|
4774
|
+
/**
|
|
4775
|
+
* Babylon.js registers built-in loader factories through a global plugin
|
|
4776
|
+
* registry. Compat dispatches its supported formats directly, so registration
|
|
4777
|
+
* is already complete and this compatibility hook is intentionally idempotent.
|
|
4778
|
+
*/
|
|
4779
|
+
export declare function registerBuiltInLoaders(): void;
|
|
4780
|
+
|
|
4781
|
+
/** Pure-build registration shim; compat wires the Lite array upload directly. */
|
|
4782
|
+
export declare function RegisterEnginesExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4783
|
+
|
|
4784
|
+
/** WebGPU pure-build registration shim; Babylon Lite is WebGPU-only. */
|
|
4785
|
+
export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource(): void;
|
|
4786
|
+
|
|
4341
4787
|
export declare function RegisterFluidRenderer(): void;
|
|
4342
4788
|
|
|
4343
4789
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
@@ -4345,6 +4791,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
|
|
|
4345
4791
|
/** Babylon.js pure-module registration hook. */
|
|
4346
4792
|
export declare function RegisterImageProcessingConfiguration(): void;
|
|
4347
4793
|
|
|
4794
|
+
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
4795
|
+
|
|
4348
4796
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4349
4797
|
|
|
4350
4798
|
export declare function RegisterUSDFileLoader(): never;
|
|
@@ -4358,6 +4806,10 @@ export declare class RotationGizmo extends GizmoBase {
|
|
|
4358
4806
|
private _attached;
|
|
4359
4807
|
private _xGizmo;
|
|
4360
4808
|
private _yGizmo;
|
|
4361
4809
|
private _zGizmo;
|
|
4810
|
+
private _dragSubscriptions;
|
|
4811
|
+
readonly onDragStartObservable: Observable<DragStartEndEvent>;
|
|
4812
|
+
readonly onDragObservable: Observable<DragEvent_2>;
|
|
4813
|
+
readonly onDragEndObservable: Observable<DragStartEndEvent>;
|
|
4362
4814
|
constructor(layer: UtilityLayerRenderer);
|
|
4363
4815
|
/** Babylon.js `RotationGizmo.xGizmo/yGizmo/zGizmo` — the per-plane rotation sub-gizmos. */
|
|
4364
4816
|
get xGizmo(): PlaneRotationGizmo;
|
|
@@ -4445,6 +4897,8 @@ export declare class Scene extends AbstractScene {
|
|
|
4445
4897
|
/** Babylon.js fog-mode c
|
|
4446
4898
|
private readonly _pendingTextures;
|
|
4447
4899
|
private readonly _pendingGroundBakes;
|
|
4448
4900
|
private readonly _pendingMorphBuilds;
|
|
4901
|
+
private _materialPluginsRequested;
|
|
4902
|
+
private readonly _pendingMaterialPluginReconciliations;
|
|
4449
4903
|
private readonly _runningAnimatables;
|
|
4450
4904
|
private readonly _animationGroupCache;
|
|
4451
4905
|
private _ambientColor;
|
|
4452
4906
|
private _environmentIntensity;
|
|
@@ -4722,6 +5176,15 @@ export declare class ShadowGenerator {
|
|
|
4722
5176
|
private _removeCaster;
|
|
4723
5177
|
private _scheduleCasterSync;
|
|
4724
5178
|
private _flushCasterSync;
|
|
5179
|
+
/**
|
|
5180
|
+
* The Lite meshes handed to the native shadow task: every requested caster that carries GPU geometry.
|
|
5181
|
+
* The compat loader wraps a model's complete hierarchy as `Mesh`es, so `addShadowCaster(root, true)`
|
|
5182
|
+
* legitimately collects transform-only roots and intermediate nodes into `renderList`, exactly as
|
|
5183
|
+
* Babylon.js does. Those nodes must not reach the native state: the render task cannot build a
|
|
5184
|
+
* renderable for a mesh without `_gpu` (it would throw inside the frame, every frame), and directional
|
|
5185
|
+
* fitting would substitute default bounds for it, distorting the shadow volume.
|
|
5186
|
+
*/
|
|
5187
|
+
private _liteCasterMeshes;
|
|
4725
5188
|
/** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
|
|
4726
5189
|
getShadowMap(): {
|
|
4727
5190
|
renderList: AbstractMesh[];
|
|
@@ -5027,7 +5490,17 @@ export declare class SSAO2RenderingPipeline {
|
|
|
5027
5490
|
constructor();
|
|
5028
5491
|
}
|
|
5029
5492
|
|
|
5030
|
-
export declare class StandardMaterial extends PushMaterial {
|
|
5031
5493
|
constructor(name: string, scene?: Scene);
|
|
5494
|
+
export declare class StandardMaterial extends PushMaterial {
|
|
5032
5495
|
/** Diffuse colour as the app set it. Kept apart from `_lite.diffuseColor`, which is forced to white
|
|
5496
|
+
* while the material is unlit (see `_syncDiffuse`). */
|
|
5497
|
+
private _diffuse;
|
|
5498
|
+
constructor(name: string, scene?: Scene);
|
|
5499
|
+
/**
|
|
5500
|
+
* Babylon.js shades an unlit StandardMaterial as `emissive + ambient`: the diffuse colour only scales
|
|
5501
|
+
* the accumulated light, and there is none. Lite's unlit path is `emissive × diffuse`, so the usual
|
|
5502
|
+
* "unlit colour" setup (black diffuse, colour in emissive) rendered black. Hand Lite a neutral white
|
|
5503
|
+
* diffuse while lighting is disabled and the app's own colour otherwise.
|
|
5504
|
+
*/
|
|
5505
|
+
private _syncDiffuse;
|
|
5033
5506
|
getClassName(): string;
|
|
5034
5507
|
get diffuseColor(): Color3;
|
|
5035
5508
|
set diffuseColor(value: Color3);
|
|
@@ -5218,7 +5691,7 @@ export declare class TargetCamera extends Camera {
|
|
|
5218
5691
|
constructor(name: string,
|
|
5219
5692
|
|
|
5220
5693
|
declare type TaskState = "init" | "running" | "done" | "error";
|
|
5221
5694
|
|
|
5222
|
-
export declare function TemperatureTintToXyz(
|
|
5695
|
+
export declare function TemperatureTintToXyz(temperatureKelvin: number, tint: number): Vector3;
|
|
5223
5696
|
|
|
5224
5697
|
export declare class Texture extends BaseTexture {
|
|
5225
5698
|
private readonly _ready;
|
|
@@ -5284,6 +5757,10 @@ export declare class ThinFSR1UpscalePostProcess {
|
|
|
5284
5757
|
constructor();
|
|
5285
5758
|
}
|
|
5286
5759
|
|
|
5760
|
+
export declare class ThinMeshBlendingPostProcess {
|
|
5761
|
+
constructor(..._args: unknown[]);
|
|
5762
|
+
}
|
|
5763
|
+
|
|
5287
5764
|
/**
|
|
5288
5765
|
* Babylon.js `ThinSprite` — a lightweight pixel-space sprite drawn by a
|
|
5289
5766
|
* {@link SpriteRenderer}. Position is in screen pixels (origin bottom-left, +Y
|
|
@@ -5388,6 +5865,8 @@ export declare class UniversalCamera extends FreeCamera {
|
|
|
5388
5865
|
getClassName(): string;
|
|
5389
5866
|
}
|
|
5390
5867
|
|
|
5868
|
+
export declare function UnpackMeshBlendingTag(tag: number): IMeshBlendingTag;
|
|
5869
|
+
|
|
5391
5870
|
/** Throw a {@link LiteCompatError} for an unsupported API. */
|
|
5392
5871
|
export declare function unsupported(api: string, detail?: string): never;
|
|
5393
5872
|
|
|
@@ -5461,6 +5940,10 @@ export declare class UtilityLayerRenderer {
|
|
|
5461
5940
|
private _registered;
|
|
5462
5941
|
constructor(scene: Scene);
|
|
5463
5942
|
dispose(): void;
|
|
5464
5943
|
}
|
|
5465
5944
|
|
|
5945
|
+
export declare function ValidateFlowGraph(_flowGraph: unknown): IFlowGraphValidationResult;
|
|
5946
|
+
|
|
5947
|
+
export declare function ValidateFlowGraphWithBlockList(_flowGraph: unknown, _allKnownBlocks: unknown[]): IFlowGraphValidationResult;
|
|
5948
|
+
|
|
5466
5949
|
/** Compares `target[propertyPath]` against a value with an operator. */
|
|
5467
5950
|
export declare class ValueCondition extends Condition {
|
|
5468
5951
|
private readonly _target;
|