@babylonjs/lite-compat 1.19.0-preview → 1.21.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 +2 -2
- package/index.d.ts +205 -4
- package/index.js +477 -35
- package/index.js.map +1 -1
- package/{meshes-0TVZfbq3.js → meshes-eNVvq5sm.js} +81 -56
- package/meshes-eNVvq5sm.js.map +1 -0
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-0TVZfbq3.js.map +0 -1
package/index.js
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
1
|
var __defProp = Object.defineProperty;
|
|
2
2
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
3
3
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
4
|
-
import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, C as Color3, S as StandardMaterial, a as Color4, b as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-
|
|
5
|
-
import { A, B, c, d, e, f, g, h, i, j, k, m, n, o, p, G, I,
|
|
6
|
-
import { VERSION, createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, uploadImageToArrayLayer, enableMirroredMeshes, registerSceneWithShadowSupport, registerScene, startEngine, createNullEngine, stepScene, setPhysicsTimestep, setPhysicsGravity, disposePhysics, createHavokWorld, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, loadHdrEnvironment, loadDdsEnvironment, loadEnvironment, createDefaultCamera, addToScene, createHemisphericLight, createAnimationManager, enableAnimationBlending, addAnimationGroup, disposeScene, createDirectionalLight, createPointLight, createSpotLight, createCsgFromMesh, csgSubtract, csgIntersect, csgUnion, createMeshFromCsg, createCsg2FromMesh, csg2Subtract, csg2Intersect, csg2Add, createMeshesFromCsg2, disposeCsg2, initializeCsg2Async, createMorphTargets, setMorphTargetWeights, createTransformNode, bakeCurrentTransformIntoVertices, loadSOG, loadSPZ, loadSplat, createDynamicTexture, updateDynamicTexture, createTexture2DFromPixels, updateTexture2DFromPixels, createTexture3DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, createTexture2DArrayFromUrls, createTexture2DArrayFromKtx2, loadImageToArrayLayer, createTexture2DArray, createTexture2DArrayFromPixels, updateTexture2DArrayFromPixels, loadBabylon, loadGltf, resetVariant, getVariantNames, selectVariant, disposePicker, createGpuPicker, pickAsync, createAxisDragGizmo, attachAxisDragGizmoToNode, disposeAxisDragGizmo, createAxisScaleGizmo, attachAxisScaleGizmoToNode, disposeAxisScaleGizmo, createBoundingBoxGizmo, attachBoundingBoxGizmoToNode, disposeBoundingBoxGizmo, createCameraGizmo, attachCameraGizmoToCamera, disposeCameraGizmo, createLightGizmo, attachLightGizmoToLight, disposeLightGizmo, createPlaneDragGizmo, attachPlaneDragGizmoToNode, disposePlaneDragGizmo, createPlaneRotationGizmo, attachPlaneRotationGizmoToNode, disposePlaneRotationGizmo, createPositionGizmo, setPositionGizmoLocalCoordinates, attachPositionGizmoToNode, disposePositionGizmo, createRotationGizmo, setRotationGizmoLocalCoordinates, attachRotationGizmoToNode, disposeRotationGizmo, createScaleGizmo, setScaleGizmoLocalCoordinates, attachScaleGizmoToNode, disposeScaleGizmo, createUtilityLayer, registerUtilityLayer, disposeUtilityLayer, addBillboardSpriteIndex, updateBillboardSpriteIndex, loadSpriteAtlas, createFacingBillboardSystem, addFacingBillboardSystem, billboardBlendAdditive, billboardBlendAlpha, spriteBlendPremultiplied, spriteBlendAdditive, spriteBlendAlpha, createSprite2DLayer, addSprite2DIndex, createSpriteRenderer, registerSpriteRenderer, updateSprite2DIndex, createPcfSpotlightShadowGenerator, createPcfDirectionalShadowGenerator, createEsmDirectionalShadowGenerator, setShadowTaskCasterMeshes, parseNodeMaterialFromSnippet, createGridMaterial, getByteFrequencyData, getFloatFrequencyData, getByteTimeDomainData, getFloatTimeDomainData, enableAnalyzer, setSpatialPosition, setSpatialOrientation, enableSpatial, setSpatialListenerPosition, setSpatialListener, updateSpatialAudio, enableStereo, setStereoPan, disposeAudioBus, setBusVolume, getMasterVolume, setMasterVolume, unlockAudioEngineAsync, createSoundAsync, createSoundBufferAsync, createStreamingSoundAsync, createAudioBusAsync, createSoundSourceAsync, createMicrophoneSoundSourceAsync, disposeAudioEngine, createAudioEngineAsync, disposeSoundSource, setSoundSourceVolume, playSound, pauseSound, resumeSound, stopSound, disposeSound, setSoundVolume, playStreamingSound, pauseStreamingSound, resumeStreamingSound, stopStreamingSound, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, disposeStreamingSound, setStreamingSoundVolume, startParticleSystem, animateParticleSystem, stopParticleSystem, createParticleBillboard, syncParticleBillboard, parseNodeParticleSetFromSnippet, registerNodeParticleSet } from "@babylonjs/lite";
|
|
4
|
+
import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, C as Color3, S as StandardMaterial, a as Color4, b as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-eNVvq5sm.js";
|
|
5
|
+
import { A, B, c, d, e, f, g, h, i, j, k, m, n, o, p, q, G, I, r, s, t, P, v, w, x, y, z, D, E, F, H, J, K, O, R } from "./meshes-eNVvq5sm.js";
|
|
6
|
+
import { VERSION, createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, uploadImageToArrayLayer, enableMirroredMeshes, registerSceneWithShadowSupport, registerScene, startEngine, createNullEngine, stepScene, setPhysicsTimestep, setPhysicsGravity, disposePhysics, createHavokWorld, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, loadHdrEnvironment, loadDdsEnvironment, loadEnvironment, createDefaultCamera, addToScene, createHemisphericLight, createAnimationManager, enableAnimationBlending, addAnimationGroup, disposeScene, createDirectionalLight, createPointLight, createSpotLight, createClusteredLightContainer, createClusteredPointLight, removeFromScene, addClusteredLightContainer, markClusteredLightContainerDirty, createCsgFromMesh, csgSubtract, csgIntersect, csgUnion, createMeshFromCsg, createCsg2FromMesh, csg2Subtract, csg2Intersect, csg2Add, createMeshesFromCsg2, disposeCsg2, initializeCsg2Async, createMorphTargets, setMorphTargetWeights, createTransformNode, bakeCurrentTransformIntoVertices, loadSOG, loadSPZ, loadSplat, createDynamicTexture, updateDynamicTexture, createTexture2DFromPixels, updateTexture2DFromPixels, createTexture3DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, createTexture2DArrayFromUrls, createTexture2DArrayFromKtx2, loadImageToArrayLayer, createTexture2DArray, createTexture2DArrayFromPixels, updateTexture2DArrayFromPixels, loadBabylon, loadGltf, resetVariant, getVariantNames, selectVariant, disposePicker, createGpuPicker, pickAsync, createAxisDragGizmo, attachAxisDragGizmoToNode, disposeAxisDragGizmo, createAxisScaleGizmo, attachAxisScaleGizmoToNode, disposeAxisScaleGizmo, createBoundingBoxGizmo, attachBoundingBoxGizmoToNode, disposeBoundingBoxGizmo, createCameraGizmo, attachCameraGizmoToCamera, disposeCameraGizmo, createLightGizmo, attachLightGizmoToLight, disposeLightGizmo, createPlaneDragGizmo, attachPlaneDragGizmoToNode, disposePlaneDragGizmo, createPlaneRotationGizmo, attachPlaneRotationGizmoToNode, disposePlaneRotationGizmo, createPositionGizmo, setPositionGizmoLocalCoordinates, attachPositionGizmoToNode, disposePositionGizmo, createRotationGizmo, setRotationGizmoLocalCoordinates, attachRotationGizmoToNode, disposeRotationGizmo, createScaleGizmo, setScaleGizmoLocalCoordinates, attachScaleGizmoToNode, disposeScaleGizmo, createUtilityLayer, registerUtilityLayer, disposeUtilityLayer, addBillboardSpriteIndex, updateBillboardSpriteIndex, loadSpriteAtlas, createFacingBillboardSystem, addFacingBillboardSystem, billboardBlendAdditive, billboardBlendAlpha, spriteBlendPremultiplied, spriteBlendAdditive, spriteBlendAlpha, createSprite2DLayer, addSprite2DIndex, createSpriteRenderer, registerSpriteRenderer, updateSprite2DIndex, createPcfSpotlightShadowGenerator, createPcfDirectionalShadowGenerator, createEsmDirectionalShadowGenerator, setShadowTaskCasterMeshes, parseNodeMaterialFromSnippet, createGridMaterial, getByteFrequencyData, getFloatFrequencyData, getByteTimeDomainData, getFloatTimeDomainData, enableAnalyzer, setSpatialPosition, setSpatialOrientation, enableSpatial, setSpatialListenerPosition, setSpatialListener, updateSpatialAudio, enableStereo, setStereoPan, disposeAudioBus, setBusVolume, getMasterVolume, setMasterVolume, unlockAudioEngineAsync, createSoundAsync, createSoundBufferAsync, createStreamingSoundAsync, createAudioBusAsync, createSoundSourceAsync, createMicrophoneSoundSourceAsync, disposeAudioEngine, createAudioEngineAsync, disposeSoundSource, setSoundSourceVolume, playSound, pauseSound, resumeSound, stopSound, disposeSound, setSoundVolume, playStreamingSound, pauseStreamingSound, resumeStreamingSound, stopStreamingSound, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, disposeStreamingSound, setStreamingSoundVolume, startParticleSystem, animateParticleSystem, stopParticleSystem, createParticleBillboard, syncParticleBillboard, parseNodeParticleSetFromSnippet, registerNodeParticleSet } from "@babylonjs/lite";
|
|
7
7
|
const Epsilon = 1e-3;
|
|
8
8
|
const ToRadians = Math.PI / 180;
|
|
9
9
|
const ToDegrees = 180 / Math.PI;
|
|
@@ -879,6 +879,7 @@ class AbstractEngine {
|
|
|
879
879
|
scene._bakeGroundUvs();
|
|
880
880
|
scene._flushPendingAdds();
|
|
881
881
|
scene._buildMorphTargets();
|
|
882
|
+
scene._buildClusteredContainers();
|
|
882
883
|
await scene._loadPendingEnvironment();
|
|
883
884
|
await enableMirroredMeshes(scene._lite);
|
|
884
885
|
if (scene._hasShadows()) {
|
|
@@ -2144,6 +2145,8 @@ const _Scene = class _Scene extends AbstractScene {
|
|
|
2144
2145
|
__publicField(this, "_nodeMaterials", []);
|
|
2145
2146
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
2146
2147
|
__publicField(this, "uniqueId", ++_Scene._uidCounter);
|
|
2148
|
+
/** @internal Clustered light containers to register on the Lite scene at engine start. */
|
|
2149
|
+
__publicField(this, "_pendingClusteredContainers", []);
|
|
2147
2150
|
/** Babylon.js `scene.performancePriority` — accepted for parity; Babylon Lite tunes its own pipeline. */
|
|
2148
2151
|
__publicField(this, "performancePriority", 0);
|
|
2149
2152
|
/**
|
|
@@ -2318,6 +2321,33 @@ const _Scene = class _Scene extends AbstractScene {
|
|
|
2318
2321
|
}
|
|
2319
2322
|
this._pendingMorphBuilds.length = 0;
|
|
2320
2323
|
}
|
|
2324
|
+
/** @internal Register a compat `ClusteredLightContainer` to be wired into the scene at engine start. */
|
|
2325
|
+
_registerClusteredLightContainer(container) {
|
|
2326
|
+
this._pendingClusteredContainers.push(container);
|
|
2327
|
+
}
|
|
2328
|
+
/** @internal Drop a container from the pending list (it was disposed before engine start). */
|
|
2329
|
+
_unregisterClusteredLightContainer(container) {
|
|
2330
|
+
const i2 = this._pendingClusteredContainers.indexOf(container);
|
|
2331
|
+
if (i2 !== -1) {
|
|
2332
|
+
this._pendingClusteredContainers.splice(i2, 1);
|
|
2333
|
+
}
|
|
2334
|
+
}
|
|
2335
|
+
/**
|
|
2336
|
+
* @internal Register all clustered light containers on the Lite scene. Called by
|
|
2337
|
+
* the engine after meshes/materials are settled (clustered wiring reads the
|
|
2338
|
+
* scene's materials) and before `registerScene`. Containers disposed before this
|
|
2339
|
+
* point are skipped — registering one would build GPU state for an object the
|
|
2340
|
+
* caller has already thrown away. The list is drained up front so a container
|
|
2341
|
+
* disposed while another builds cannot perturb the iteration.
|
|
2342
|
+
*/
|
|
2343
|
+
_buildClusteredContainers() {
|
|
2344
|
+
const containers = this._pendingClusteredContainers.splice(0);
|
|
2345
|
+
for (const container of containers) {
|
|
2346
|
+
if (!container.isDisposed()) {
|
|
2347
|
+
container._build();
|
|
2348
|
+
}
|
|
2349
|
+
}
|
|
2350
|
+
}
|
|
2321
2351
|
/** @internal Whether any shadow generator is present (engine uses shadow-aware registration). */
|
|
2322
2352
|
_hasShadows() {
|
|
2323
2353
|
return this._shadowGenerators.length > 0;
|
|
@@ -2790,6 +2820,14 @@ let Scene = _Scene;
|
|
|
2790
2820
|
class Light extends Node {
|
|
2791
2821
|
constructor(name, scene) {
|
|
2792
2822
|
super(name, scene);
|
|
2823
|
+
/**
|
|
2824
|
+
* @internal The {@link ClusteredLightContainer} that owns this light, if any.
|
|
2825
|
+
* Babylon.js moves a light out of the normal light path when it is added to a
|
|
2826
|
+
* clustered container; this back-link mirrors BJS's `light._clusteredContainer`
|
|
2827
|
+
* so a light cannot be added to two containers. Typed loosely to avoid a cycle
|
|
2828
|
+
* with the container module.
|
|
2829
|
+
*/
|
|
2830
|
+
__publicField(this, "_clusteredContainer", null);
|
|
2793
2831
|
/**
|
|
2794
2832
|
* @internal When the light is effectively disabled, its Lite intensity is
|
|
2795
2833
|
* forced to `0` (zero contribution) and the caller-visible intensity is
|
|
@@ -3069,6 +3107,198 @@ class SpotLight extends Light {
|
|
|
3069
3107
|
writeColor(this._lite.specular, value);
|
|
3070
3108
|
}
|
|
3071
3109
|
}
|
|
3110
|
+
const LIGHTTYPEID_CLUSTERED_CONTAINER = 5;
|
|
3111
|
+
class ClusteredLightContainer extends Light {
|
|
3112
|
+
/**
|
|
3113
|
+
* Creates a new clustered light container.
|
|
3114
|
+
*
|
|
3115
|
+
* @param name - The container's node name.
|
|
3116
|
+
* @param lights - Initial lights to cluster (point lights).
|
|
3117
|
+
* @param scene - Owning scene; when supplied the container is registered and
|
|
3118
|
+
* built into the Lite scene at engine start.
|
|
3119
|
+
*/
|
|
3120
|
+
constructor(name, lights = [], scene) {
|
|
3121
|
+
super(name, scene);
|
|
3122
|
+
/**
|
|
3123
|
+
* @internal The underlying Babylon Lite clustered light container. The base
|
|
3124
|
+
* `Light._lite` is typed as `LightBase`, but a clustered container is a distinct
|
|
3125
|
+
* Lite object (not a punctual light); every base member that dereferences `_lite`
|
|
3126
|
+
* as a light is overridden below, so the value is only ever read back through
|
|
3127
|
+
* {@link _container}.
|
|
3128
|
+
*/
|
|
3129
|
+
__publicField(this, "_lite");
|
|
3130
|
+
/** @internal Point lights added to this container (Babylon.js `container.lights`). */
|
|
3131
|
+
__publicField(this, "_childLights", []);
|
|
3132
|
+
/** @internal Lite clustered point lights, parallel to {@link _childLights}. */
|
|
3133
|
+
__publicField(this, "_liteLights", []);
|
|
3134
|
+
/** @internal Whether the container has been registered on the Lite scene (engine start). */
|
|
3135
|
+
__publicField(this, "_built", false);
|
|
3136
|
+
__publicField(this, "_maxRange", 16383);
|
|
3137
|
+
__publicField(this, "_selfIntensity", 1);
|
|
3138
|
+
this._lite = createClusteredLightContainer();
|
|
3139
|
+
if (scene) {
|
|
3140
|
+
scene._registerClusteredLightContainer(this);
|
|
3141
|
+
}
|
|
3142
|
+
for (const light of lights) {
|
|
3143
|
+
this.addLight(light);
|
|
3144
|
+
}
|
|
3145
|
+
}
|
|
3146
|
+
/** @internal Typed handle to the Lite clustered container held in {@link _lite}. */
|
|
3147
|
+
get _container() {
|
|
3148
|
+
return this._lite;
|
|
3149
|
+
}
|
|
3150
|
+
/**
|
|
3151
|
+
* True if a point/spot light can be clustered by this container. Babylon Lite
|
|
3152
|
+
* clusters point lights only.
|
|
3153
|
+
*/
|
|
3154
|
+
static IsLightSupported(light) {
|
|
3155
|
+
return light instanceof PointLight;
|
|
3156
|
+
}
|
|
3157
|
+
getClassName() {
|
|
3158
|
+
return "ClusteredLightContainer";
|
|
3159
|
+
}
|
|
3160
|
+
/** Babylon.js `light.getTypeID()` — `LIGHTTYPEID_CLUSTERED_CONTAINER`. */
|
|
3161
|
+
getTypeID() {
|
|
3162
|
+
return LIGHTTYPEID_CLUSTERED_CONTAINER;
|
|
3163
|
+
}
|
|
3164
|
+
/** True when clustered lighting is available (Babylon Lite backs it on WebGPU). */
|
|
3165
|
+
get isSupported() {
|
|
3166
|
+
return true;
|
|
3167
|
+
}
|
|
3168
|
+
/** The lights added to this clustering system. */
|
|
3169
|
+
get lights() {
|
|
3170
|
+
return this._childLights;
|
|
3171
|
+
}
|
|
3172
|
+
/** Number of cluster tiles across the screen horizontally (default `64`). */
|
|
3173
|
+
get horizontalTiles() {
|
|
3174
|
+
return this._container.horizontalTiles;
|
|
3175
|
+
}
|
|
3176
|
+
set horizontalTiles(value) {
|
|
3177
|
+
this._container.horizontalTiles = value;
|
|
3178
|
+
this._markDirty();
|
|
3179
|
+
}
|
|
3180
|
+
/** Number of cluster tiles across the screen vertically (default `64`). */
|
|
3181
|
+
get verticalTiles() {
|
|
3182
|
+
return this._container.verticalTiles;
|
|
3183
|
+
}
|
|
3184
|
+
set verticalTiles(value) {
|
|
3185
|
+
this._container.verticalTiles = value;
|
|
3186
|
+
this._markDirty();
|
|
3187
|
+
}
|
|
3188
|
+
/** Number of depth slices used to bin lights along view-space Z (default `16`). */
|
|
3189
|
+
get depthSlices() {
|
|
3190
|
+
return this._container.zSlices;
|
|
3191
|
+
}
|
|
3192
|
+
set depthSlices(value) {
|
|
3193
|
+
this._container.zSlices = value;
|
|
3194
|
+
this._markDirty();
|
|
3195
|
+
}
|
|
3196
|
+
/**
|
|
3197
|
+
* Upper bound applied to clustered light ranges. Babylon Lite manages range
|
|
3198
|
+
* binning internally, so this is stored for API-shape parity and does not
|
|
3199
|
+
* re-cluster the lights.
|
|
3200
|
+
*/
|
|
3201
|
+
get maxRange() {
|
|
3202
|
+
return this._maxRange;
|
|
3203
|
+
}
|
|
3204
|
+
set maxRange(value) {
|
|
3205
|
+
this._maxRange = value;
|
|
3206
|
+
}
|
|
3207
|
+
/** Babylon.js `container.addLight(light)`. Only point lights are clustered. */
|
|
3208
|
+
addLight(light) {
|
|
3209
|
+
if (!ClusteredLightContainer.IsLightSupported(light) || light._clusteredContainer) {
|
|
3210
|
+
return;
|
|
3211
|
+
}
|
|
3212
|
+
const point = light;
|
|
3213
|
+
light._clusteredContainer = this;
|
|
3214
|
+
const pos = point.position;
|
|
3215
|
+
const diffuse = point.diffuse;
|
|
3216
|
+
const liteLight = createClusteredPointLight(this._container, {
|
|
3217
|
+
position: [pos.x, pos.y, pos.z],
|
|
3218
|
+
diffuse: [diffuse.r, diffuse.g, diffuse.b],
|
|
3219
|
+
range: point.range,
|
|
3220
|
+
intensity: point.intensity
|
|
3221
|
+
});
|
|
3222
|
+
this._childLights.push(point);
|
|
3223
|
+
this._liteLights.push(liteLight);
|
|
3224
|
+
const lightScene = point.getScene();
|
|
3225
|
+
if (lightScene) {
|
|
3226
|
+
lightScene._unregisterNode(point);
|
|
3227
|
+
removeFromScene(lightScene._lite, point._lite);
|
|
3228
|
+
}
|
|
3229
|
+
this._markDirty();
|
|
3230
|
+
}
|
|
3231
|
+
/**
|
|
3232
|
+
* Babylon.js `container.removeLight(light)`. Returns the index the light held
|
|
3233
|
+
* in the container's light list, or `-1` if it was not present.
|
|
3234
|
+
*/
|
|
3235
|
+
removeLight(light) {
|
|
3236
|
+
const index = this._childLights.indexOf(light);
|
|
3237
|
+
if (index === -1) {
|
|
3238
|
+
return -1;
|
|
3239
|
+
}
|
|
3240
|
+
this._childLights.splice(index, 1);
|
|
3241
|
+
const liteLight = this._liteLights.splice(index, 1)[0];
|
|
3242
|
+
const pool = this._container.pointLights;
|
|
3243
|
+
const j2 = liteLight ? pool.indexOf(liteLight) : -1;
|
|
3244
|
+
if (j2 !== -1) {
|
|
3245
|
+
pool.splice(j2, 1);
|
|
3246
|
+
}
|
|
3247
|
+
light._clusteredContainer = null;
|
|
3248
|
+
const point = light;
|
|
3249
|
+
const lightScene = point.getScene();
|
|
3250
|
+
if (lightScene) {
|
|
3251
|
+
lightScene._registerLight(point);
|
|
3252
|
+
addToScene(lightScene._lite, point._lite);
|
|
3253
|
+
}
|
|
3254
|
+
this._markDirty();
|
|
3255
|
+
return index;
|
|
3256
|
+
}
|
|
3257
|
+
/**
|
|
3258
|
+
* @internal Register the container on the Lite scene, wiring its clustered
|
|
3259
|
+
* lights into the scene's PBR materials. Deferred to engine start so meshes and
|
|
3260
|
+
* materials are settled; skipped on the device-less `NullEngine` and after
|
|
3261
|
+
* disposal. `_built` only flips once registration actually happened, so a skipped
|
|
3262
|
+
* build leaves the container re-buildable and keeps {@link _markDirty} from
|
|
3263
|
+
* touching GPU state that was never created.
|
|
3264
|
+
*/
|
|
3265
|
+
_build() {
|
|
3266
|
+
if (this._built || this.isDisposed()) {
|
|
3267
|
+
return;
|
|
3268
|
+
}
|
|
3269
|
+
const scene = this._scene;
|
|
3270
|
+
if (!scene || scene.getEngine()._headless) {
|
|
3271
|
+
return;
|
|
3272
|
+
}
|
|
3273
|
+
this._built = true;
|
|
3274
|
+
addClusteredLightContainer(scene._lite, this._container);
|
|
3275
|
+
}
|
|
3276
|
+
/** @internal Force a GPU re-upload of the clustered light set on the next frame (post-build). */
|
|
3277
|
+
_markDirty() {
|
|
3278
|
+
if (this._built) {
|
|
3279
|
+
markClusteredLightContainerDirty(this._container);
|
|
3280
|
+
}
|
|
3281
|
+
}
|
|
3282
|
+
// ─── Base `Light` members overridden: a clustered container is not a punctual
|
|
3283
|
+
// Lite light, so intensity/shadow/enable/dispose must not touch `_lite`. ───
|
|
3284
|
+
/** Container-level intensity (Babylon.js inherits it from `Light`; each child light carries its own). */
|
|
3285
|
+
get intensity() {
|
|
3286
|
+
return this._selfIntensity;
|
|
3287
|
+
}
|
|
3288
|
+
set intensity(value) {
|
|
3289
|
+
this._selfIntensity = value;
|
|
3290
|
+
}
|
|
3291
|
+
/** Clustered lights do not cast shadows in Babylon.js; the toggle is a no-op. */
|
|
3292
|
+
set shadowEnabled(_enabled) {
|
|
3293
|
+
}
|
|
3294
|
+
_onEffectiveEnabledStateChanged(_enabled) {
|
|
3295
|
+
}
|
|
3296
|
+
dispose() {
|
|
3297
|
+
var _a;
|
|
3298
|
+
(_a = this._scene) == null ? void 0 : _a._unregisterClusteredLightContainer(this);
|
|
3299
|
+
super.dispose();
|
|
3300
|
+
}
|
|
3301
|
+
}
|
|
3072
3302
|
function deferAddCsgMesh(mesh, scene, material) {
|
|
3073
3303
|
scene._deferAdd(() => {
|
|
3074
3304
|
const engine = scene.getEngine()._lite;
|
|
@@ -7026,11 +7256,6 @@ class RectAreaLight {
|
|
|
7026
7256
|
unsupported("RectAreaLight", "Area lights are not implemented in Babylon Lite. Use Point/Spot/Directional/Hemispheric lights.");
|
|
7027
7257
|
}
|
|
7028
7258
|
}
|
|
7029
|
-
class ClusteredLightContainer {
|
|
7030
|
-
constructor() {
|
|
7031
|
-
unsupported("ClusteredLightContainer", "Clustered lighting is not exposed by the Babylon Lite public API; the compat layer cannot wrap it.");
|
|
7032
|
-
}
|
|
7033
|
-
}
|
|
7034
7259
|
class GPUParticleSystem {
|
|
7035
7260
|
constructor() {
|
|
7036
7261
|
unsupported(
|
|
@@ -7057,11 +7282,186 @@ class GlowLayer {
|
|
|
7057
7282
|
unsupported("GlowLayer", "Effect layers are not implemented in Babylon Lite. For a bloom-style glow, use the native bloom post-process task.");
|
|
7058
7283
|
}
|
|
7059
7284
|
}
|
|
7285
|
+
const GREASED_LINE_REASON = "Greased (thick) lines are a ribbon/tube geometry + dedicated plugin-material subsystem (per-point widths, color/width distribution tables, dashing, camera-facing ribbon modes). Babylon Lite renders only 1px hardware line-lists (MeshBuilder.CreateLines / CreateDashedLines) and has no thick-line ribbon pipeline or plugin material to back it.";
|
|
7286
|
+
class GreasedLineBaseMesh {
|
|
7287
|
+
constructor(..._args) {
|
|
7288
|
+
unsupported("GreasedLineBaseMesh", GREASED_LINE_REASON);
|
|
7289
|
+
}
|
|
7290
|
+
}
|
|
7060
7291
|
class GreasedLineMesh {
|
|
7061
|
-
constructor() {
|
|
7062
|
-
unsupported("GreasedLineMesh",
|
|
7292
|
+
constructor(..._args) {
|
|
7293
|
+
unsupported("GreasedLineMesh", GREASED_LINE_REASON);
|
|
7294
|
+
}
|
|
7295
|
+
}
|
|
7296
|
+
class GreasedLineRibbonMesh {
|
|
7297
|
+
constructor(..._args) {
|
|
7298
|
+
unsupported("GreasedLineRibbonMesh", GREASED_LINE_REASON);
|
|
7299
|
+
}
|
|
7300
|
+
}
|
|
7301
|
+
class GreasedLinePluginMaterial {
|
|
7302
|
+
constructor(..._args) {
|
|
7303
|
+
unsupported("GreasedLinePluginMaterial", GREASED_LINE_REASON);
|
|
7304
|
+
}
|
|
7305
|
+
}
|
|
7306
|
+
class MaterialGreasedLineDefines {
|
|
7307
|
+
constructor(..._args) {
|
|
7308
|
+
unsupported("MaterialGreasedLineDefines", GREASED_LINE_REASON);
|
|
7309
|
+
}
|
|
7310
|
+
}
|
|
7311
|
+
class GreasedLineMaterialDefaults {
|
|
7312
|
+
constructor(..._args) {
|
|
7313
|
+
unsupported("GreasedLineMaterialDefaults", GREASED_LINE_REASON);
|
|
7314
|
+
}
|
|
7315
|
+
static get DEFAULT_COLOR() {
|
|
7316
|
+
return unsupported("GreasedLineMaterialDefaults.DEFAULT_COLOR", GREASED_LINE_REASON);
|
|
7317
|
+
}
|
|
7318
|
+
static get DEFAULT_WIDTH_ATTENUATED() {
|
|
7319
|
+
return unsupported("GreasedLineMaterialDefaults.DEFAULT_WIDTH_ATTENUATED", GREASED_LINE_REASON);
|
|
7320
|
+
}
|
|
7321
|
+
static get DEFAULT_WIDTH() {
|
|
7322
|
+
return unsupported("GreasedLineMaterialDefaults.DEFAULT_WIDTH", GREASED_LINE_REASON);
|
|
7323
|
+
}
|
|
7324
|
+
static get EmptyColorsTexture() {
|
|
7325
|
+
return unsupported("GreasedLineMaterialDefaults.EmptyColorsTexture", GREASED_LINE_REASON);
|
|
7326
|
+
}
|
|
7327
|
+
}
|
|
7328
|
+
function RegisterGreasedLinePluginMaterial(..._args) {
|
|
7329
|
+
return unsupported("RegisterGreasedLinePluginMaterial", GREASED_LINE_REASON);
|
|
7330
|
+
}
|
|
7331
|
+
class GreasedLineSimpleMaterial {
|
|
7332
|
+
constructor(..._args) {
|
|
7333
|
+
unsupported("GreasedLineSimpleMaterial", GREASED_LINE_REASON);
|
|
7334
|
+
}
|
|
7335
|
+
}
|
|
7336
|
+
class GreasedLineTools {
|
|
7337
|
+
constructor(..._args) {
|
|
7338
|
+
unsupported("GreasedLineTools", GREASED_LINE_REASON);
|
|
7339
|
+
}
|
|
7340
|
+
static ConvertPoints(..._args) {
|
|
7341
|
+
return unsupported("GreasedLineTools.ConvertPoints", GREASED_LINE_REASON);
|
|
7342
|
+
}
|
|
7343
|
+
static OmitZeroLengthPredicate(..._args) {
|
|
7344
|
+
return unsupported("GreasedLineTools.OmitZeroLengthPredicate", GREASED_LINE_REASON);
|
|
7063
7345
|
}
|
|
7346
|
+
static OmitDuplicatesPredicate(..._args) {
|
|
7347
|
+
return unsupported("GreasedLineTools.OmitDuplicatesPredicate", GREASED_LINE_REASON);
|
|
7348
|
+
}
|
|
7349
|
+
static MeshesToLines(..._args) {
|
|
7350
|
+
return unsupported("GreasedLineTools.MeshesToLines", GREASED_LINE_REASON);
|
|
7351
|
+
}
|
|
7352
|
+
static ToVector3Array(..._args) {
|
|
7353
|
+
return unsupported("GreasedLineTools.ToVector3Array", GREASED_LINE_REASON);
|
|
7354
|
+
}
|
|
7355
|
+
static ToNumberArray(..._args) {
|
|
7356
|
+
return unsupported("GreasedLineTools.ToNumberArray", GREASED_LINE_REASON);
|
|
7357
|
+
}
|
|
7358
|
+
static GetPointsCountInfo(..._args) {
|
|
7359
|
+
return unsupported("GreasedLineTools.GetPointsCountInfo", GREASED_LINE_REASON);
|
|
7360
|
+
}
|
|
7361
|
+
static GetLineLength(..._args) {
|
|
7362
|
+
return unsupported("GreasedLineTools.GetLineLength", GREASED_LINE_REASON);
|
|
7363
|
+
}
|
|
7364
|
+
static GetLineLengthArray(..._args) {
|
|
7365
|
+
return unsupported("GreasedLineTools.GetLineLengthArray", GREASED_LINE_REASON);
|
|
7366
|
+
}
|
|
7367
|
+
static SegmentizeSegmentByCount(..._args) {
|
|
7368
|
+
return unsupported("GreasedLineTools.SegmentizeSegmentByCount", GREASED_LINE_REASON);
|
|
7369
|
+
}
|
|
7370
|
+
static SegmentizeLineBySegmentLength(..._args) {
|
|
7371
|
+
return unsupported("GreasedLineTools.SegmentizeLineBySegmentLength", GREASED_LINE_REASON);
|
|
7372
|
+
}
|
|
7373
|
+
static SegmentizeLineBySegmentCount(..._args) {
|
|
7374
|
+
return unsupported("GreasedLineTools.SegmentizeLineBySegmentCount", GREASED_LINE_REASON);
|
|
7375
|
+
}
|
|
7376
|
+
static GetLineSegments(..._args) {
|
|
7377
|
+
return unsupported("GreasedLineTools.GetLineSegments", GREASED_LINE_REASON);
|
|
7378
|
+
}
|
|
7379
|
+
static GetMinMaxSegmentLength(..._args) {
|
|
7380
|
+
return unsupported("GreasedLineTools.GetMinMaxSegmentLength", GREASED_LINE_REASON);
|
|
7381
|
+
}
|
|
7382
|
+
static GetPositionOnLineByVisibility(..._args) {
|
|
7383
|
+
return unsupported("GreasedLineTools.GetPositionOnLineByVisibility", GREASED_LINE_REASON);
|
|
7384
|
+
}
|
|
7385
|
+
static GetCircleLinePoints(..._args) {
|
|
7386
|
+
return unsupported("GreasedLineTools.GetCircleLinePoints", GREASED_LINE_REASON);
|
|
7387
|
+
}
|
|
7388
|
+
static GetBezierLinePoints(..._args) {
|
|
7389
|
+
return unsupported("GreasedLineTools.GetBezierLinePoints", GREASED_LINE_REASON);
|
|
7390
|
+
}
|
|
7391
|
+
static GetArrowCap(..._args) {
|
|
7392
|
+
return unsupported("GreasedLineTools.GetArrowCap", GREASED_LINE_REASON);
|
|
7393
|
+
}
|
|
7394
|
+
static GetPointsFromText(..._args) {
|
|
7395
|
+
return unsupported("GreasedLineTools.GetPointsFromText", GREASED_LINE_REASON);
|
|
7396
|
+
}
|
|
7397
|
+
static Color3toRGBAUint8(..._args) {
|
|
7398
|
+
return unsupported("GreasedLineTools.Color3toRGBAUint8", GREASED_LINE_REASON);
|
|
7399
|
+
}
|
|
7400
|
+
static CreateColorsTexture(..._args) {
|
|
7401
|
+
return unsupported("GreasedLineTools.CreateColorsTexture", GREASED_LINE_REASON);
|
|
7402
|
+
}
|
|
7403
|
+
static PrepareEmptyColorsTexture(..._args) {
|
|
7404
|
+
return unsupported("GreasedLineTools.PrepareEmptyColorsTexture", GREASED_LINE_REASON);
|
|
7405
|
+
}
|
|
7406
|
+
static DisposeEmptyColorsTexture(..._args) {
|
|
7407
|
+
return unsupported("GreasedLineTools.DisposeEmptyColorsTexture", GREASED_LINE_REASON);
|
|
7408
|
+
}
|
|
7409
|
+
static BooleanToNumber(..._args) {
|
|
7410
|
+
return unsupported("GreasedLineTools.BooleanToNumber", GREASED_LINE_REASON);
|
|
7411
|
+
}
|
|
7412
|
+
}
|
|
7413
|
+
function CreateGreasedLine(..._args) {
|
|
7414
|
+
return unsupported("CreateGreasedLine", GREASED_LINE_REASON);
|
|
7415
|
+
}
|
|
7416
|
+
function CreateGreasedLineMaterial(..._args) {
|
|
7417
|
+
return unsupported("CreateGreasedLineMaterial", GREASED_LINE_REASON);
|
|
7418
|
+
}
|
|
7419
|
+
function GetPointsCount(..._args) {
|
|
7420
|
+
return unsupported("GetPointsCount", GREASED_LINE_REASON);
|
|
7064
7421
|
}
|
|
7422
|
+
function CompleteGreasedLineWidthTable(..._args) {
|
|
7423
|
+
return unsupported("CompleteGreasedLineWidthTable", GREASED_LINE_REASON);
|
|
7424
|
+
}
|
|
7425
|
+
function CompleteGreasedLineColorTable(..._args) {
|
|
7426
|
+
return unsupported("CompleteGreasedLineColorTable", GREASED_LINE_REASON);
|
|
7427
|
+
}
|
|
7428
|
+
var GreasedLineMeshColorDistribution = /* @__PURE__ */ ((GreasedLineMeshColorDistribution2) => {
|
|
7429
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_NONE"] = 0] = "COLOR_DISTRIBUTION_NONE";
|
|
7430
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_REPEAT"] = 1] = "COLOR_DISTRIBUTION_REPEAT";
|
|
7431
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_EVEN"] = 2] = "COLOR_DISTRIBUTION_EVEN";
|
|
7432
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_START"] = 3] = "COLOR_DISTRIBUTION_START";
|
|
7433
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_END"] = 4] = "COLOR_DISTRIBUTION_END";
|
|
7434
|
+
GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_START_END"] = 5] = "COLOR_DISTRIBUTION_START_END";
|
|
7435
|
+
return GreasedLineMeshColorDistribution2;
|
|
7436
|
+
})(GreasedLineMeshColorDistribution || {});
|
|
7437
|
+
var GreasedLineMeshWidthDistribution = /* @__PURE__ */ ((GreasedLineMeshWidthDistribution2) => {
|
|
7438
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_NONE"] = 0] = "WIDTH_DISTRIBUTION_NONE";
|
|
7439
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_REPEAT"] = 1] = "WIDTH_DISTRIBUTION_REPEAT";
|
|
7440
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_EVEN"] = 2] = "WIDTH_DISTRIBUTION_EVEN";
|
|
7441
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_START"] = 3] = "WIDTH_DISTRIBUTION_START";
|
|
7442
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_END"] = 4] = "WIDTH_DISTRIBUTION_END";
|
|
7443
|
+
GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_START_END"] = 5] = "WIDTH_DISTRIBUTION_START_END";
|
|
7444
|
+
return GreasedLineMeshWidthDistribution2;
|
|
7445
|
+
})(GreasedLineMeshWidthDistribution || {});
|
|
7446
|
+
var GreasedLineRibbonPointsMode = /* @__PURE__ */ ((GreasedLineRibbonPointsMode2) => {
|
|
7447
|
+
GreasedLineRibbonPointsMode2[GreasedLineRibbonPointsMode2["POINTS_MODE_POINTS"] = 0] = "POINTS_MODE_POINTS";
|
|
7448
|
+
GreasedLineRibbonPointsMode2[GreasedLineRibbonPointsMode2["POINTS_MODE_PATHS"] = 1] = "POINTS_MODE_PATHS";
|
|
7449
|
+
return GreasedLineRibbonPointsMode2;
|
|
7450
|
+
})(GreasedLineRibbonPointsMode || {});
|
|
7451
|
+
var GreasedLineRibbonFacesMode = /* @__PURE__ */ ((GreasedLineRibbonFacesMode2) => {
|
|
7452
|
+
GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_SINGLE_SIDED"] = 0] = "FACES_MODE_SINGLE_SIDED";
|
|
7453
|
+
GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING"] = 1] = "FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING";
|
|
7454
|
+
GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_DOUBLE_SIDED"] = 2] = "FACES_MODE_DOUBLE_SIDED";
|
|
7455
|
+
return GreasedLineRibbonFacesMode2;
|
|
7456
|
+
})(GreasedLineRibbonFacesMode || {});
|
|
7457
|
+
var GreasedLineRibbonAutoDirectionMode = /* @__PURE__ */ ((GreasedLineRibbonAutoDirectionMode2) => {
|
|
7458
|
+
GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FROM_FIRST_SEGMENT"] = 0] = "AUTO_DIRECTIONS_FROM_FIRST_SEGMENT";
|
|
7459
|
+
GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FROM_ALL_SEGMENTS"] = 1] = "AUTO_DIRECTIONS_FROM_ALL_SEGMENTS";
|
|
7460
|
+
GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_ENHANCED"] = 2] = "AUTO_DIRECTIONS_ENHANCED";
|
|
7461
|
+
GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FACE_TO"] = 3] = "AUTO_DIRECTIONS_FACE_TO";
|
|
7462
|
+
GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_NONE"] = 99] = "AUTO_DIRECTIONS_NONE";
|
|
7463
|
+
return GreasedLineRibbonAutoDirectionMode2;
|
|
7464
|
+
})(GreasedLineRibbonAutoDirectionMode || {});
|
|
7065
7465
|
class EdgesRenderer {
|
|
7066
7466
|
constructor() {
|
|
7067
7467
|
unsupported("EdgesRenderer", "Edge rendering is not implemented in Babylon Lite.");
|
|
@@ -7113,6 +7513,26 @@ function InstallHtmlInCanvasPolyfill() {
|
|
|
7113
7513
|
function UninstallHtmlInCanvasPolyfill() {
|
|
7114
7514
|
return unsupported("UninstallHtmlInCanvasPolyfill", "The HTML-in-canvas polyfill is not supported by Babylon Lite.");
|
|
7115
7515
|
}
|
|
7516
|
+
class GaussianSplattingStream {
|
|
7517
|
+
constructor(..._args) {
|
|
7518
|
+
unsupported(
|
|
7519
|
+
"GaussianSplattingStream",
|
|
7520
|
+
"Gaussian-Splatting LOD streaming is a whole GPU subsystem (SOG-octree LOD residency + work-buffer decode into render-target atlases) with no Babylon Lite equivalent. Load the full cloud with `GaussianSplattingMesh` / `loadSplat` instead."
|
|
7521
|
+
);
|
|
7522
|
+
}
|
|
7523
|
+
}
|
|
7524
|
+
function AddGaussianSplattingStreamPart(..._args) {
|
|
7525
|
+
return unsupported(
|
|
7526
|
+
"AddGaussianSplattingStreamPart",
|
|
7527
|
+
"Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`."
|
|
7528
|
+
);
|
|
7529
|
+
}
|
|
7530
|
+
function AddGaussianSplattingStreamPartAsync(..._args) {
|
|
7531
|
+
return unsupported(
|
|
7532
|
+
"AddGaussianSplattingStreamPartAsync",
|
|
7533
|
+
"Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`."
|
|
7534
|
+
);
|
|
7535
|
+
}
|
|
7116
7536
|
class Sound {
|
|
7117
7537
|
constructor() {
|
|
7118
7538
|
unsupported("Sound", "Audio is not part of Babylon Lite. Use the Web Audio API directly.");
|
|
@@ -7692,6 +8112,8 @@ export {
|
|
|
7692
8112
|
Action,
|
|
7693
8113
|
ActionManager,
|
|
7694
8114
|
ActionManagerTriggers,
|
|
8115
|
+
AddGaussianSplattingStreamPart,
|
|
8116
|
+
AddGaussianSplattingStreamPartAsync,
|
|
7695
8117
|
AmmoJSPlugin,
|
|
7696
8118
|
AnaglyphArcRotateCamera,
|
|
7697
8119
|
Angle,
|
|
@@ -7742,6 +8164,8 @@ export {
|
|
|
7742
8164
|
Color3,
|
|
7743
8165
|
Color4,
|
|
7744
8166
|
ColorGradient,
|
|
8167
|
+
CompleteGreasedLineColorTable,
|
|
8168
|
+
CompleteGreasedLineWidthTable,
|
|
7745
8169
|
ComputeOverlayCssTransform,
|
|
7746
8170
|
Condition,
|
|
7747
8171
|
Constants,
|
|
@@ -7749,23 +8173,26 @@ export {
|
|
|
7749
8173
|
CreateAudioEngineAsync,
|
|
7750
8174
|
e as CreateBox,
|
|
7751
8175
|
f as CreateCylinder,
|
|
7752
|
-
g as
|
|
7753
|
-
h as
|
|
7754
|
-
|
|
7755
|
-
|
|
8176
|
+
g as CreateDashedLines,
|
|
8177
|
+
h as CreateDisc,
|
|
8178
|
+
CreateGreasedLine,
|
|
8179
|
+
CreateGreasedLineMaterial,
|
|
8180
|
+
i as CreateGround,
|
|
8181
|
+
j as CreateLineSystem,
|
|
8182
|
+
k as CreateLines,
|
|
7756
8183
|
CreateMainAudioBusAsync,
|
|
7757
8184
|
CreateMicrophoneSoundSourceAsync,
|
|
7758
|
-
|
|
8185
|
+
m as CreatePlane,
|
|
7759
8186
|
CreateSoundAsync,
|
|
7760
8187
|
CreateSoundBufferAsync,
|
|
7761
8188
|
CreateSoundSourceAsync,
|
|
7762
|
-
|
|
8189
|
+
n as CreateSphere,
|
|
7763
8190
|
CreateStreamingSoundAsync,
|
|
7764
8191
|
CreateTexture2DArrayFromImageUrlsAsync,
|
|
7765
8192
|
CreateTexture2DArrayFromKTX2Async,
|
|
7766
|
-
|
|
7767
|
-
|
|
7768
|
-
|
|
8193
|
+
o as CreateTiledBox,
|
|
8194
|
+
p as CreateTiledPlane,
|
|
8195
|
+
q as CreateTorus,
|
|
7769
8196
|
CubeTexture,
|
|
7770
8197
|
CubicEase,
|
|
7771
8198
|
Curve3,
|
|
@@ -7801,13 +8228,26 @@ export {
|
|
|
7801
8228
|
GPUPicker,
|
|
7802
8229
|
GamepadCamera,
|
|
7803
8230
|
GaussianSplattingMesh,
|
|
8231
|
+
GaussianSplattingStream,
|
|
7804
8232
|
GeometryBufferRenderer,
|
|
7805
8233
|
GeospatialCamera,
|
|
7806
8234
|
GeospatialClippingBehavior,
|
|
7807
8235
|
GetElementPixelFromUv,
|
|
8236
|
+
GetPointsCount,
|
|
7808
8237
|
GizmoManager,
|
|
7809
8238
|
GlowLayer,
|
|
8239
|
+
GreasedLineBaseMesh,
|
|
8240
|
+
GreasedLineMaterialDefaults,
|
|
7810
8241
|
GreasedLineMesh,
|
|
8242
|
+
GreasedLineMeshColorDistribution,
|
|
8243
|
+
GreasedLineMeshWidthDistribution,
|
|
8244
|
+
GreasedLinePluginMaterial,
|
|
8245
|
+
GreasedLineRibbonAutoDirectionMode,
|
|
8246
|
+
GreasedLineRibbonFacesMode,
|
|
8247
|
+
GreasedLineRibbonMesh,
|
|
8248
|
+
GreasedLineRibbonPointsMode,
|
|
8249
|
+
GreasedLineSimpleMaterial,
|
|
8250
|
+
GreasedLineTools,
|
|
7811
8251
|
GridMaterial,
|
|
7812
8252
|
G as GroundMesh,
|
|
7813
8253
|
HDRCubeTexture,
|
|
@@ -7832,16 +8272,17 @@ export {
|
|
|
7832
8272
|
Layer,
|
|
7833
8273
|
Light,
|
|
7834
8274
|
LightGizmo,
|
|
7835
|
-
|
|
8275
|
+
r as LinesMesh,
|
|
7836
8276
|
LiteCompatError,
|
|
7837
8277
|
LoadAssetContainerAsync,
|
|
7838
8278
|
LoadImageToTexture2DArrayLayerAsync,
|
|
7839
8279
|
Logger,
|
|
7840
8280
|
MainAudioBus,
|
|
7841
|
-
|
|
8281
|
+
s as Material,
|
|
8282
|
+
MaterialGreasedLineDefines,
|
|
7842
8283
|
Matrix,
|
|
7843
8284
|
Mesh,
|
|
7844
|
-
|
|
8285
|
+
t as MeshBuilder,
|
|
7845
8286
|
MeshoptCompression,
|
|
7846
8287
|
MirrorTexture,
|
|
7847
8288
|
MorphTarget,
|
|
@@ -7857,12 +8298,12 @@ export {
|
|
|
7857
8298
|
OnAudioEngineV2CreatedObservable,
|
|
7858
8299
|
OutlineRenderer,
|
|
7859
8300
|
P as PBRAnisotropicConfiguration,
|
|
7860
|
-
|
|
7861
|
-
|
|
7862
|
-
|
|
7863
|
-
|
|
7864
|
-
|
|
7865
|
-
|
|
8301
|
+
v as PBRClearCoatConfiguration,
|
|
8302
|
+
w as PBRIridescenceConfiguration,
|
|
8303
|
+
x as PBRMaterial,
|
|
8304
|
+
y as PBRMetallicRoughnessMaterial,
|
|
8305
|
+
z as PBRSheenConfiguration,
|
|
8306
|
+
D as PBRSpecularGlossinessMaterial,
|
|
7866
8307
|
ParticleHelper,
|
|
7867
8308
|
ParticleSystem,
|
|
7868
8309
|
ParticleSystemSet,
|
|
@@ -7886,7 +8327,7 @@ export {
|
|
|
7886
8327
|
PostProcess,
|
|
7887
8328
|
PrecisionDate,
|
|
7888
8329
|
PredicateCondition,
|
|
7889
|
-
|
|
8330
|
+
E as PushMaterial,
|
|
7890
8331
|
QuadraticEase,
|
|
7891
8332
|
QuarticEase,
|
|
7892
8333
|
Quaternion,
|
|
@@ -7898,6 +8339,7 @@ export {
|
|
|
7898
8339
|
RecastJSPlugin,
|
|
7899
8340
|
RectAreaLight,
|
|
7900
8341
|
ReflectionProbe,
|
|
8342
|
+
RegisterGreasedLinePluginMaterial,
|
|
7901
8343
|
RenderTargetTexture,
|
|
7902
8344
|
RotationGizmo,
|
|
7903
8345
|
SSAO2RenderingPipeline,
|
|
@@ -7953,18 +8395,18 @@ export {
|
|
|
7953
8395
|
UtilityLayerRenderer,
|
|
7954
8396
|
ValueCondition,
|
|
7955
8397
|
ValueConditionOperators,
|
|
7956
|
-
|
|
8398
|
+
F as Vector2,
|
|
7957
8399
|
Vector3,
|
|
7958
|
-
|
|
7959
|
-
|
|
7960
|
-
|
|
8400
|
+
H as Vector4,
|
|
8401
|
+
J as VertexBuffer,
|
|
8402
|
+
K as VertexData,
|
|
7961
8403
|
Viewport,
|
|
7962
8404
|
VirtualJoystick,
|
|
7963
8405
|
WebGPUEngine,
|
|
7964
8406
|
WebXRCamera,
|
|
7965
8407
|
WeightedSound,
|
|
7966
|
-
|
|
7967
|
-
|
|
8408
|
+
O as transformCoordinates,
|
|
8409
|
+
R as transformNormal,
|
|
7968
8410
|
unsupported
|
|
7969
8411
|
};
|
|
7970
8412
|
//# sourceMappingURL=index.js.map
|