@babylonjs/lite-compat 1.7.0-preview → 1.8.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 CHANGED
@@ -126,7 +126,7 @@ overloads within a supported area may still be absent.
126
126
  | CSG / CSG2 | ✅ | over Lite boolean ops |
127
127
  | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite |
128
128
  | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial` unsupported |
129
- | Textures (`Texture`, `RawTexture`, `DynamicTexture`, `CubeTexture`) | ⚡ | `HDRCubeTexture` / `RenderTargetTexture` / `MirrorTexture` unsupported |
129
+ | Textures (`Texture`, `RawTexture`, `DynamicTexture`, `CubeTexture`) | ⚡ | `HDRCubeTexture` / `RenderTargetTexture` / `MirrorTexture` / `HtmlTexture` unsupported |
130
130
  | Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | CPU evaluation; loaded glTF skeletal blending supported |
131
131
  | Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
132
132
  | Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
package/index.d.ts CHANGED
@@ -206,8 +206,14 @@ export declare class AbstractMesh extends TransformNode {
206
206
  private _material;
207
207
  get receiveShadows(): boolean;
208
208
  set receiveShadows(value: boolean);
209
209
  setEnabled(enabled: boolean): void;
210
- /** Bounding info accessor — needs a public Lite bounds accessor that does not yet exist. */
211
- getBoundingInfo(): never;
210
+ /**
211
+ * Babylon.js `mesh.getBoundingInfo()` — local-space AABB of this mesh. Babylon
212
+ * Lite stores `boundMin`/`boundMax` (local space) on factory- and loader-built
213
+ * meshes; when absent (e.g. a placeholder mesh whose bounds were never computed)
214
+ * we fold the retained CPU positions through Lite's `computeAabb`. A mesh with
215
+ * no geometry returns a degenerate zero-size box.
216
+ */
217
+ getBoundingInfo(): BoundingInfo;
212
218
  /**
213
219
  * Babylon.js `mesh.getVerticesData(kind)` — read back the CPU geometry buffer
214
220
  * for `position` / `normal` / `uv`. Babylon Lite retains these on the mesh
@@ -1110,6 +1116,9 @@ declare type CompatMaterial = StandardMaterial | PBRMaterial | NodeMaterial | Gr
1110
1116
 
1111
1117
  declare type CompatMaterial_2 = StandardMaterial | PBRMaterial | NodeMaterial;
1112
1118
 
1119
+ /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1120
+ export declare function ComputeOverlayCssTransform(): never;
1121
+
1113
1122
  /** Base class for action conditions. */
1114
1123
  export declare abstract class Condition {
1115
1124
  abstract isValid(): boolean;
@@ -1555,6 +1564,9 @@ export declare class GeospatialCamera extends Camera {
1555
1564
  constructor(name: str
1556
1565
  attachControl(canvas: HTMLCanvasElement, _noPreventDefault?: boolean): void;
1557
1566
  }
1558
1567
 
1568
+ /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
1569
+ export declare function GetElementPixelFromUv(): never;
1570
+
1559
1571
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1560
1572
  declare abstract class GizmoBase {
1561
1573
  protected constructor(layer: UtilityLayerRenderer);
1562
1574
  abstract get attachedMesh(): AbstractMesh | null;
@@ -1701,6 +1713,18 @@ export declare class HighlightLayer {
1701
1713
  constructor();
1702
1714
  }
1703
1715
 
1716
+ export declare class HtmlInteractionManager {
1717
+ constructor();
1718
+ }
1719
+
1720
+ export declare class HtmlRaycastInteractionManager {
1721
+ constructor();
1722
+ }
1723
+
1724
+ export declare class HtmlTexture {
1725
+ constructor();
1726
+ }
1727
+
1704
1728
  /** Babylon.js `IAbstractSoundOptions` (subset). */
1705
1729
  export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptions> {
1706
1730
  /** Play immediately once ready. Defaults to `false`. */
@@ -1780,6 +1804,31 @@ export declare interface IGPUPickingInfo {
1780
1804
  thinInstanceIndex?: number;
1781
1805
  }
1782
1806
 
1807
+ /** Module shape of an HTML-in-canvas polyfill (shape-only stub). */
1808
+ export declare interface IHtmlInCanvasPolyfillModule {
1809
+ [key: string]: unknown;
1810
+ }
1811
+
1812
+ /** Options accepted by Babylon.js `HtmlInteractionManager` (shape-only stub). */
1813
+ export declare interface IHtmlInteractionManagerOptions {
1814
+ [key: string]: unknown;
1815
+ }
1816
+
1817
+ /** Options accepted by Babylon.js `HtmlRaycastInteractionManager` (shape-only stub). */
1818
+ export declare interface IHtmlRaycastInteractionManagerOptions {
1819
+ [key: string]: unknown;
1820
+ }
1821
+
1822
+ /** Options accepted by Babylon.js `HtmlTexture` (shape-only stub for type parity). */
1823
+ export declare interface IHtmlTextureOptions {
1824
+ [key: string]: unknown;
1825
+ }
1826
+
1827
+ /** Options accepted by `InstallHtmlInCanvasPolyfill` (shape-only stub). */
1828
+ export declare interface IInstallHtmlInCanvasPolyfillOptions {
1829
+ [key: string]: unknown;
1830
+ }
1831
+
1783
1832
  /**
1784
1833
  * Babylon.js `ImageProcessingConfiguration` — only the tone-mapping constants are
1785
1834
  * surfaced (the live exposure/contrast/tone-mapping toggle is exposed through
@@ -1821,11 +1870,20 @@ export declare class IncrementValueAction extends Action {
1821
1870
  /** Babylon.js `InitializeCSG2Async()` — load the Manifold runtime before any `CSG2` use. */
1822
1871
  export declare function InitializeCSG2Async(): Promise<void>;
1823
1872
 
1873
+ /** Babylon.js `InstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
1874
+ export declare function InstallHtmlInCanvasPolyfill(): never;
1875
+
1824
1876
  /** Babylon.js `InstancedMesh` — hardware instances are not modelled; use thin instances. */
1825
1877
  export declare class InstancedMesh {
1826
1878
  constructor();
1827
1879
  }
1828
1880
 
1881
+ /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
1882
+ export declare function IsHtmlInCanvasSupportedNatively(): never;
1883
+
1884
+ /** Babylon.js `IsHtmlInCanvasUploadSupported` — HTML texture upload is unsupported by the compat layer. */
1885
+ export declare function IsHtmlInCanvasUploadSupported(): never;
1886
+
1829
1887
  /** Babylon.js `ISoundSourceOptions` (subset). */
1830
1888
  export declare interface ISoundSourceOptions extends Partial<IVolumeAudioOptions> {
1831
1889
  /** Name. */
@@ -3698,6 +3756,9 @@ export declare class TransformNode extends Node_2 {
3698
3756
  constructor(name: string
3699
3757
 
3700
3758
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
3701
3759
 
3760
+ /** Babylon.js `UninstallHtmlInCanvasPolyfill` — the HTML-in-canvas polyfill is unsupported by the compat layer. */
3761
+ export declare function UninstallHtmlInCanvasPolyfill(): never;
3762
+
3702
3763
  /** Babylon.js `UniversalCamera` — touch-friendly free camera. */
3703
3764
  export declare class UniversalCamera extends FreeCamera {
3704
3765
  getClassName(): string;
@@ -3706,6 +3767,9 @@ export declare class UniversalCamera extends FreeCamera {
3706
3767
  /** Throw a {@link LiteCompatError} for an unsupported API. */
3707
3768
  export declare function unsupported(api: string, detail?: string): never;
3708
3769
 
3770
+ /** Babylon.js `UploadHtmlElementToTexture` — HTML texture upload is unsupported by the compat layer. */
3771
+ export declare function UploadHtmlElementToTexture(): never;
3772
+
3709
3773
  /** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
3710
3774
  export declare class UtilityLayerRenderer {
3711
3775
  private _registered;
3712
3776
  constructor(scene: Scene);
3713
3777
  dispose(): void;
package/index.js CHANGED
@@ -1,8 +1,8 @@
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, a as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-a59_KvbH.js";
5
- import { A, C, b, c, d, e, f, g, G, I, h, i, j, k, m, t, n } from "./meshes-a59_KvbH.js";
4
+ import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, a as Mesh, T as TransformNode, l as liteBackedVector3, B as BoundingInfo, Q as Quaternion } from "./meshes-CPZtn6G5.js";
5
+ import { A, b, c, C, d, e, f, g, h, i, G, I, j, k, m, n, o, t, p } from "./meshes-CPZtn6G5.js";
6
6
  import { createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, registerSceneWithShadowSupport, registerScene, startEngine, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, markMaterialUboDirty, createPbrMaterial, createSolidTexture2D, createStandardMaterial, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, 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, createTexture2DFromPixels, updateTexture2DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, getContainerMeshes, 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 } from "@babylonjs/lite";
7
7
  class Color3 {
8
8
  constructor(r = 0, g2 = 0, b2 = 0) {
@@ -422,7 +422,7 @@ class Path3D {
422
422
  __publicField(this, "_curve");
423
423
  __publicField(this, "_distances", []);
424
424
  __publicField(this, "_length", 0);
425
- this._curve = points.map((p) => p.clone());
425
+ this._curve = points.map((p2) => p2.clone());
426
426
  this._distances[0] = 0;
427
427
  for (let i2 = 1; i2 < this._curve.length; i2++) {
428
428
  this._length += Vector3.Distance(this._curve[i2], this._curve[i2 - 1]);
@@ -443,83 +443,6 @@ class Path3D {
443
443
  return this._distances;
444
444
  }
445
445
  }
446
- class BoundingSphere {
447
- constructor(min, max) {
448
- __publicField(this, "center");
449
- __publicField(this, "radius");
450
- __publicField(this, "minimum");
451
- __publicField(this, "maximum");
452
- this.minimum = min.clone();
453
- this.maximum = max.clone();
454
- this.center = Vector3.Lerp(min, max, 0.5);
455
- this.radius = max.subtract(min).length() * 0.5;
456
- }
457
- intersectsPoint(point) {
458
- return Vector3.DistanceSquared(this.center, point) <= this.radius * this.radius;
459
- }
460
- static Intersects(a, b2) {
461
- const r = a.radius + b2.radius;
462
- return Vector3.DistanceSquared(a.center, b2.center) <= r * r;
463
- }
464
- }
465
- class BoundingBox {
466
- constructor(min, max) {
467
- __publicField(this, "minimum");
468
- __publicField(this, "maximum");
469
- __publicField(this, "center");
470
- __publicField(this, "extendSize");
471
- /** World-space AABB corners. Equal to `minimum`/`maximum` when the box is
472
- * already built in world space (as the loader's `getBoundingInfo` does). */
473
- __publicField(this, "minimumWorld");
474
- __publicField(this, "maximumWorld");
475
- /** The 8 corner points (min/max combinations). */
476
- __publicField(this, "vectors");
477
- this.minimum = min.clone();
478
- this.maximum = max.clone();
479
- this.minimumWorld = min.clone();
480
- this.maximumWorld = max.clone();
481
- this.center = Vector3.Lerp(min, max, 0.5);
482
- this.extendSize = max.subtract(min).scale(0.5);
483
- this.vectors = [
484
- new Vector3(min.x, min.y, min.z),
485
- new Vector3(max.x, max.y, max.z),
486
- new Vector3(max.x, min.y, min.z),
487
- new Vector3(min.x, max.y, min.z),
488
- new Vector3(min.x, min.y, max.z),
489
- new Vector3(max.x, max.y, min.z),
490
- new Vector3(min.x, max.y, max.z),
491
- new Vector3(max.x, min.y, max.z)
492
- ];
493
- }
494
- intersectsPoint(point) {
495
- return point.x >= this.minimum.x && point.x <= this.maximum.x && point.y >= this.minimum.y && point.y <= this.maximum.y && point.z >= this.minimum.z && point.z <= this.maximum.z;
496
- }
497
- static Intersects(a, b2) {
498
- return a.minimum.x <= b2.maximum.x && a.maximum.x >= b2.minimum.x && a.minimum.y <= b2.maximum.y && a.maximum.y >= b2.minimum.y && a.minimum.z <= b2.maximum.z && a.maximum.z >= b2.minimum.z;
499
- }
500
- }
501
- class BoundingInfo {
502
- constructor(min, max) {
503
- __publicField(this, "boundingBox");
504
- __publicField(this, "boundingSphere");
505
- this.boundingBox = new BoundingBox(min, max);
506
- this.boundingSphere = new BoundingSphere(min, max);
507
- }
508
- get minimum() {
509
- return this.boundingBox.minimum;
510
- }
511
- get maximum() {
512
- return this.boundingBox.maximum;
513
- }
514
- intersectsPoint(point) {
515
- return this.boundingSphere.intersectsPoint(point) && this.boundingBox.intersectsPoint(point);
516
- }
517
- /** World-matrix-aware reframe is not modelled here; reframe by rebuilding from transformed corners. */
518
- reConstruct(min, max, _worldMatrix) {
519
- this.boundingBox = new BoundingBox(min, max);
520
- this.boundingSphere = new BoundingSphere(min, max);
521
- }
522
- }
523
446
  class Observable {
524
447
  constructor() {
525
448
  __publicField(this, "_observers", []);
@@ -1039,8 +962,8 @@ class Camera extends Node {
1039
962
  }
1040
963
  /** World-space position of the camera. */
1041
964
  get globalPosition() {
1042
- const p = getCameraPosition(this._lite);
1043
- return new Vector3(p.x, p.y, p.z);
965
+ const p2 = getCameraPosition(this._lite);
966
+ return new Vector3(p2.x, p2.y, p2.z);
1044
967
  }
1045
968
  /** Babylon.js `camera.getViewMatrix()` — the camera's view matrix. */
1046
969
  getViewMatrix() {
@@ -1149,8 +1072,8 @@ class TargetCamera extends Camera {
1149
1072
  return "TargetCamera";
1150
1073
  }
1151
1074
  get position() {
1152
- const p = this._lite.position;
1153
- return new Vector3(p.x, p.y, p.z);
1075
+ const p2 = this._lite.position;
1076
+ return new Vector3(p2.x, p2.y, p2.z);
1154
1077
  }
1155
1078
  set position(value) {
1156
1079
  this._lite.position.set(value.x, value.y, value.z);
@@ -1177,8 +1100,8 @@ class FreeCamera extends TargetCamera {
1177
1100
  }
1178
1101
  /** @internal Wrap an already-built Lite free camera (e.g. one parsed from a `.babylon` file). */
1179
1102
  static _adopt(name, lite, scene) {
1180
- const p = lite.position;
1181
- return new FreeCamera(name, new Vector3(p.x, p.y, p.z), scene, lite);
1103
+ const p2 = lite.position;
1104
+ return new FreeCamera(name, new Vector3(p2.x, p2.y, p2.z), scene, lite);
1182
1105
  }
1183
1106
  }
1184
1107
  class UniversalCamera extends FreeCamera {
@@ -3538,10 +3461,10 @@ const _Texture = class _Texture extends BaseTexture {
3538
3461
  if (typeof noMipmapOrOptions === "boolean") {
3539
3462
  noMipmap = noMipmapOrOptions;
3540
3463
  } else if (noMipmapOrOptions && typeof noMipmapOrOptions === "object") {
3541
- const o = noMipmapOrOptions;
3542
- noMipmap = o.noMipmap ?? false;
3543
- invertYOpt = invertYOpt ?? o.invertY;
3544
- samplingMode = samplingMode ?? o.samplingMode;
3464
+ const o2 = noMipmapOrOptions;
3465
+ noMipmap = o2.noMipmap ?? false;
3466
+ invertYOpt = invertYOpt ?? o2.invertY;
3467
+ samplingMode = samplingMode ?? o2.samplingMode;
3545
3468
  }
3546
3469
  this._invertY = invertYOpt ?? true;
3547
3470
  this._noMipmap = noMipmap;
@@ -6906,6 +6829,42 @@ class MirrorTexture {
6906
6829
  unsupported("MirrorTexture", "Mirror/reflection textures are not implemented in Babylon Lite. Build one from a native render-target texture + clip plane if required.");
6907
6830
  }
6908
6831
  }
6832
+ class HtmlTexture {
6833
+ constructor() {
6834
+ unsupported("HtmlTexture", "Rendering a live DOM element into a texture is a host-page/DOM feature with no Babylon Lite equivalent.");
6835
+ }
6836
+ }
6837
+ class HtmlInteractionManager {
6838
+ constructor() {
6839
+ unsupported("HtmlInteractionManager", "HTML overlay interaction is not part of Babylon Lite's WebGPU renderer.");
6840
+ }
6841
+ }
6842
+ class HtmlRaycastInteractionManager {
6843
+ constructor() {
6844
+ unsupported("HtmlRaycastInteractionManager", "HTML overlay raycast interaction is not part of Babylon Lite's WebGPU renderer.");
6845
+ }
6846
+ }
6847
+ function IsHtmlInCanvasUploadSupported() {
6848
+ return unsupported("IsHtmlInCanvasUploadSupported", "HTML-element texture upload is not supported by Babylon Lite.");
6849
+ }
6850
+ function UploadHtmlElementToTexture() {
6851
+ return unsupported("UploadHtmlElementToTexture", "HTML-element texture upload is not supported by Babylon Lite.");
6852
+ }
6853
+ function ComputeOverlayCssTransform() {
6854
+ return unsupported("ComputeOverlayCssTransform", "HTML overlay interaction is not supported by Babylon Lite.");
6855
+ }
6856
+ function GetElementPixelFromUv() {
6857
+ return unsupported("GetElementPixelFromUv", "HTML overlay raycast interaction is not supported by Babylon Lite.");
6858
+ }
6859
+ function IsHtmlInCanvasSupportedNatively() {
6860
+ return unsupported("IsHtmlInCanvasSupportedNatively", "The HTML-in-canvas feature is not supported by Babylon Lite.");
6861
+ }
6862
+ function InstallHtmlInCanvasPolyfill() {
6863
+ return unsupported("InstallHtmlInCanvasPolyfill", "The HTML-in-canvas polyfill is not supported by Babylon Lite.");
6864
+ }
6865
+ function UninstallHtmlInCanvasPolyfill() {
6866
+ return unsupported("UninstallHtmlInCanvasPolyfill", "The HTML-in-canvas polyfill is not supported by Babylon Lite.");
6867
+ }
6909
6868
  class Sound {
6910
6869
  constructor() {
6911
6870
  unsupported("Sound", "Audio is not part of Babylon Lite. Use the Web Audio API directly.");
@@ -7146,11 +7105,11 @@ export {
7146
7105
  Bone,
7147
7106
  BounceEase,
7148
7107
  BouncingBehavior,
7149
- BoundingBox,
7108
+ b as BoundingBox,
7150
7109
  BoundingBoxGizmo,
7151
7110
  BoundingBoxRenderer,
7152
7111
  BoundingInfo,
7153
- BoundingSphere,
7112
+ c as BoundingSphere,
7154
7113
  CSG,
7155
7114
  CSG2,
7156
7115
  Camera,
@@ -7163,23 +7122,24 @@ export {
7163
7122
  Color3,
7164
7123
  Color4,
7165
7124
  ColorGradient,
7125
+ ComputeOverlayCssTransform,
7166
7126
  Condition,
7167
7127
  Constants,
7168
7128
  CreateAudioBusAsync,
7169
7129
  CreateAudioEngineAsync,
7170
7130
  C as CreateBox,
7171
- b as CreateCylinder,
7172
- c as CreateDisc,
7173
- d as CreateGround,
7131
+ d as CreateCylinder,
7132
+ e as CreateDisc,
7133
+ f as CreateGround,
7174
7134
  CreateMainAudioBusAsync,
7175
7135
  CreateMicrophoneSoundSourceAsync,
7176
- e as CreatePlane,
7136
+ g as CreatePlane,
7177
7137
  CreateSoundAsync,
7178
7138
  CreateSoundBufferAsync,
7179
7139
  CreateSoundSourceAsync,
7180
- f as CreateSphere,
7140
+ h as CreateSphere,
7181
7141
  CreateStreamingSoundAsync,
7182
- g as CreateTorus,
7142
+ i as CreateTorus,
7183
7143
  CubeTexture,
7184
7144
  CubicEase,
7185
7145
  Curve3,
@@ -7215,6 +7175,7 @@ export {
7215
7175
  GaussianSplattingMesh,
7216
7176
  GeometryBufferRenderer,
7217
7177
  GeospatialCamera,
7178
+ GetElementPixelFromUv,
7218
7179
  GizmoManager,
7219
7180
  GlowLayer,
7220
7181
  GreasedLineMesh,
@@ -7224,11 +7185,17 @@ export {
7224
7185
  HavokPlugin,
7225
7186
  HemisphericLight,
7226
7187
  HighlightLayer,
7188
+ HtmlInteractionManager,
7189
+ HtmlRaycastInteractionManager,
7190
+ HtmlTexture,
7227
7191
  ImageProcessingConfiguration,
7228
7192
  ImportMeshAsync,
7229
7193
  IncrementValueAction,
7230
7194
  InitializeCSG2Async,
7195
+ InstallHtmlInCanvasPolyfill,
7231
7196
  I as InstancedMesh,
7197
+ IsHtmlInCanvasSupportedNatively,
7198
+ IsHtmlInCanvasUploadSupported,
7232
7199
  KHR_materials_variants,
7233
7200
  LastCreatedAudioEngine,
7234
7201
  Layer,
@@ -7242,7 +7209,7 @@ export {
7242
7209
  Material,
7243
7210
  Matrix,
7244
7211
  Mesh,
7245
- h as MeshBuilder,
7212
+ j as MeshBuilder,
7246
7213
  MeshoptCompression,
7247
7214
  MirrorTexture,
7248
7215
  MorphTarget,
@@ -7335,22 +7302,24 @@ export {
7335
7302
  Tools,
7336
7303
  TouchCamera,
7337
7304
  TransformNode,
7305
+ UninstallHtmlInCanvasPolyfill,
7338
7306
  UniversalCamera,
7307
+ UploadHtmlElementToTexture,
7339
7308
  UtilityLayerRenderer,
7340
7309
  ValueCondition,
7341
7310
  ValueConditionOperators,
7342
- i as Vector2,
7311
+ k as Vector2,
7343
7312
  Vector3,
7344
- j as Vector4,
7345
- k as VertexBuffer,
7346
- m as VertexData,
7313
+ m as Vector4,
7314
+ n as VertexBuffer,
7315
+ o as VertexData,
7347
7316
  Viewport,
7348
7317
  VirtualJoystick,
7349
7318
  WebGPUEngine,
7350
7319
  WebXRCamera,
7351
7320
  WeightedSound,
7352
7321
  t as transformCoordinates,
7353
- n as transformNormal,
7322
+ p as transformNormal,
7354
7323
  unsupported
7355
7324
  };
7356
7325
  //# sourceMappingURL=index.js.map