@babylonjs/lite-compat 1.16.0-preview → 1.18.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 +141 -18
- package/index.js +333 -984
- package/index.js.map +1 -1
- package/{meshes-DduMsRJk.js → meshes-0TVZfbq3.js} +1070 -27
- package/meshes-0TVZfbq3.js.map +1 -0
- package/navigation.d.ts +21 -6
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-DduMsRJk.js.map +0 -1
package/index.js
CHANGED
|
@@ -1,141 +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, a as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-
|
|
5
|
-
import { A, B,
|
|
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,
|
|
7
|
-
class Color3 {
|
|
8
|
-
constructor(r2 = 0, g2 = 0, b2 = 0) {
|
|
9
|
-
this.r = r2;
|
|
10
|
-
this.g = g2;
|
|
11
|
-
this.b = b2;
|
|
12
|
-
}
|
|
13
|
-
set(r2, g2, b2) {
|
|
14
|
-
this.r = r2;
|
|
15
|
-
this.g = g2;
|
|
16
|
-
this.b = b2;
|
|
17
|
-
return this;
|
|
18
|
-
}
|
|
19
|
-
copyFrom(source) {
|
|
20
|
-
this.r = source.r;
|
|
21
|
-
this.g = source.g;
|
|
22
|
-
this.b = source.b;
|
|
23
|
-
return this;
|
|
24
|
-
}
|
|
25
|
-
scale(scale) {
|
|
26
|
-
return new Color3(this.r * scale, this.g * scale, this.b * scale);
|
|
27
|
-
}
|
|
28
|
-
scaleInPlace(scale) {
|
|
29
|
-
this.r *= scale;
|
|
30
|
-
this.g *= scale;
|
|
31
|
-
this.b *= scale;
|
|
32
|
-
return this;
|
|
33
|
-
}
|
|
34
|
-
multiply(other) {
|
|
35
|
-
return new Color3(this.r * other.r, this.g * other.g, this.b * other.b);
|
|
36
|
-
}
|
|
37
|
-
add(other) {
|
|
38
|
-
return new Color3(this.r + other.r, this.g + other.g, this.b + other.b);
|
|
39
|
-
}
|
|
40
|
-
clone() {
|
|
41
|
-
return new Color3(this.r, this.g, this.b);
|
|
42
|
-
}
|
|
43
|
-
equals(other) {
|
|
44
|
-
return this.r === other.r && this.g === other.g && this.b === other.b;
|
|
45
|
-
}
|
|
46
|
-
asArray() {
|
|
47
|
-
return [this.r, this.g, this.b];
|
|
48
|
-
}
|
|
49
|
-
toColor4(alpha = 1) {
|
|
50
|
-
return new Color4(this.r, this.g, this.b, alpha);
|
|
51
|
-
}
|
|
52
|
-
toHexString() {
|
|
53
|
-
const intR = Math.round(Math.min(Math.max(this.r, 0), 1) * 255);
|
|
54
|
-
const intG = Math.round(Math.min(Math.max(this.g, 0), 1) * 255);
|
|
55
|
-
const intB = Math.round(Math.min(Math.max(this.b, 0), 1) * 255);
|
|
56
|
-
return "#" + toHex(intR) + toHex(intG) + toHex(intB);
|
|
57
|
-
}
|
|
58
|
-
static Black() {
|
|
59
|
-
return new Color3(0, 0, 0);
|
|
60
|
-
}
|
|
61
|
-
static White() {
|
|
62
|
-
return new Color3(1, 1, 1);
|
|
63
|
-
}
|
|
64
|
-
static Red() {
|
|
65
|
-
return new Color3(1, 0, 0);
|
|
66
|
-
}
|
|
67
|
-
static Green() {
|
|
68
|
-
return new Color3(0, 1, 0);
|
|
69
|
-
}
|
|
70
|
-
static Blue() {
|
|
71
|
-
return new Color3(0, 0, 1);
|
|
72
|
-
}
|
|
73
|
-
static FromArray(array, offset = 0) {
|
|
74
|
-
return new Color3(array[offset] ?? 0, array[offset + 1] ?? 0, array[offset + 2] ?? 0);
|
|
75
|
-
}
|
|
76
|
-
static FromInts(r2, g2, b2) {
|
|
77
|
-
return new Color3(r2 / 255, g2 / 255, b2 / 255);
|
|
78
|
-
}
|
|
79
|
-
static FromHexString(hex) {
|
|
80
|
-
if (hex.charAt(0) !== "#" || hex.length < 7) {
|
|
81
|
-
return new Color3(0, 0, 0);
|
|
82
|
-
}
|
|
83
|
-
const r2 = parseInt(hex.substring(1, 3), 16);
|
|
84
|
-
const g2 = parseInt(hex.substring(3, 5), 16);
|
|
85
|
-
const b2 = parseInt(hex.substring(5, 7), 16);
|
|
86
|
-
return Color3.FromInts(r2, g2, b2);
|
|
87
|
-
}
|
|
88
|
-
static Lerp(start, end, amount) {
|
|
89
|
-
return new Color3(start.r + (end.r - start.r) * amount, start.g + (end.g - start.g) * amount, start.b + (end.b - start.b) * amount);
|
|
90
|
-
}
|
|
91
|
-
}
|
|
92
|
-
class Color4 {
|
|
93
|
-
constructor(r2 = 0, g2 = 0, b2 = 0, a = 1) {
|
|
94
|
-
this.r = r2;
|
|
95
|
-
this.g = g2;
|
|
96
|
-
this.b = b2;
|
|
97
|
-
this.a = a;
|
|
98
|
-
}
|
|
99
|
-
set(r2, g2, b2, a) {
|
|
100
|
-
this.r = r2;
|
|
101
|
-
this.g = g2;
|
|
102
|
-
this.b = b2;
|
|
103
|
-
this.a = a;
|
|
104
|
-
return this;
|
|
105
|
-
}
|
|
106
|
-
copyFrom(source) {
|
|
107
|
-
this.r = source.r;
|
|
108
|
-
this.g = source.g;
|
|
109
|
-
this.b = source.b;
|
|
110
|
-
this.a = source.a;
|
|
111
|
-
return this;
|
|
112
|
-
}
|
|
113
|
-
scale(scale) {
|
|
114
|
-
return new Color4(this.r * scale, this.g * scale, this.b * scale, this.a * scale);
|
|
115
|
-
}
|
|
116
|
-
add(other) {
|
|
117
|
-
return new Color4(this.r + other.r, this.g + other.g, this.b + other.b, this.a + other.a);
|
|
118
|
-
}
|
|
119
|
-
clone() {
|
|
120
|
-
return new Color4(this.r, this.g, this.b, this.a);
|
|
121
|
-
}
|
|
122
|
-
equals(other) {
|
|
123
|
-
return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
|
|
124
|
-
}
|
|
125
|
-
asArray() {
|
|
126
|
-
return [this.r, this.g, this.b, this.a];
|
|
127
|
-
}
|
|
128
|
-
static FromArray(array, offset = 0) {
|
|
129
|
-
return new Color4(array[offset] ?? 0, array[offset + 1] ?? 0, array[offset + 2] ?? 0, array[offset + 3] ?? 1);
|
|
130
|
-
}
|
|
131
|
-
static FromInts(r2, g2, b2, a) {
|
|
132
|
-
return new Color4(r2 / 255, g2 / 255, b2 / 255, a / 255);
|
|
133
|
-
}
|
|
134
|
-
}
|
|
135
|
-
function toHex(value) {
|
|
136
|
-
const hex = value.toString(16).toUpperCase();
|
|
137
|
-
return hex.length === 1 ? "0" + hex : hex;
|
|
138
|
-
}
|
|
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-0TVZfbq3.js";
|
|
5
|
+
import { A, B, c, d, e, f, g, h, i, j, k, m, n, o, p, G, I, q, r, s, P, t, v, w, x, y, z, D, E, F, H, J, K, O } from "./meshes-0TVZfbq3.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, 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";
|
|
139
7
|
const Epsilon = 1e-3;
|
|
140
8
|
const ToRadians = Math.PI / 180;
|
|
141
9
|
const ToDegrees = 180 / Math.PI;
|
|
@@ -146,8 +14,8 @@ const Scalar = {
|
|
|
146
14
|
Lerp(start, end, amount) {
|
|
147
15
|
return start + (end - start) * amount;
|
|
148
16
|
},
|
|
149
|
-
InverseLerp(a,
|
|
150
|
-
return a ===
|
|
17
|
+
InverseLerp(a, b, value) {
|
|
18
|
+
return a === b ? 0 : (value - a) / (b - a);
|
|
151
19
|
},
|
|
152
20
|
DegreesToRadians(degrees) {
|
|
153
21
|
return degrees * ToRadians;
|
|
@@ -155,8 +23,8 @@ const Scalar = {
|
|
|
155
23
|
RadiansToDegrees(radians) {
|
|
156
24
|
return radians * ToDegrees;
|
|
157
25
|
},
|
|
158
|
-
WithinEpsilon(a,
|
|
159
|
-
return Math.abs(a -
|
|
26
|
+
WithinEpsilon(a, b, epsilon = 1401298e-51) {
|
|
27
|
+
return Math.abs(a - b) <= epsilon;
|
|
160
28
|
},
|
|
161
29
|
Normalize(value, min, max) {
|
|
162
30
|
return (value - min) / (max - min);
|
|
@@ -186,11 +54,11 @@ var Space = /* @__PURE__ */ ((Space2) => {
|
|
|
186
54
|
return Space2;
|
|
187
55
|
})(Space || {});
|
|
188
56
|
class Plane {
|
|
189
|
-
constructor(a,
|
|
57
|
+
constructor(a, b, c2, d2) {
|
|
190
58
|
/** Normal x/y/z and signed distance `d` from the origin (`normal · p + d = 0`). */
|
|
191
59
|
__publicField(this, "normal");
|
|
192
60
|
__publicField(this, "d");
|
|
193
|
-
this.normal = new Vector3(a,
|
|
61
|
+
this.normal = new Vector3(a, b, c2);
|
|
194
62
|
this.d = d2;
|
|
195
63
|
}
|
|
196
64
|
asArray() {
|
|
@@ -228,14 +96,14 @@ class Plane {
|
|
|
228
96
|
/** Transform a copy of this plane by the transpose of the inverse of `transformation`. */
|
|
229
97
|
transform(transformation) {
|
|
230
98
|
const m2 = transformation.m;
|
|
231
|
-
const
|
|
232
|
-
const
|
|
233
|
-
const
|
|
99
|
+
const x2 = this.normal.x;
|
|
100
|
+
const y2 = this.normal.y;
|
|
101
|
+
const z2 = this.normal.z;
|
|
234
102
|
const d2 = this.d;
|
|
235
|
-
const nx =
|
|
236
|
-
const ny =
|
|
237
|
-
const nz =
|
|
238
|
-
const nd =
|
|
103
|
+
const nx = x2 * m2[0] + y2 * m2[1] + z2 * m2[2] + d2 * m2[3];
|
|
104
|
+
const ny = x2 * m2[4] + y2 * m2[5] + z2 * m2[6] + d2 * m2[7];
|
|
105
|
+
const nz = x2 * m2[8] + y2 * m2[9] + z2 * m2[10] + d2 * m2[11];
|
|
106
|
+
const nd = x2 * m2[12] + y2 * m2[13] + z2 * m2[14] + d2 * m2[15];
|
|
239
107
|
return new Plane(nx, ny, nz, nd);
|
|
240
108
|
}
|
|
241
109
|
}
|
|
@@ -262,15 +130,15 @@ class Ray {
|
|
|
262
130
|
}
|
|
263
131
|
/** True if this ray passes within `sphereRadius` of `spherePosition`. */
|
|
264
132
|
intersectsSphere(spherePosition, sphereRadius) {
|
|
265
|
-
const
|
|
266
|
-
const
|
|
267
|
-
const
|
|
268
|
-
const pyth =
|
|
133
|
+
const x2 = spherePosition.x - this.origin.x;
|
|
134
|
+
const y2 = spherePosition.y - this.origin.y;
|
|
135
|
+
const z2 = spherePosition.z - this.origin.z;
|
|
136
|
+
const pyth = x2 * x2 + y2 * y2 + z2 * z2;
|
|
269
137
|
const rr = sphereRadius * sphereRadius;
|
|
270
138
|
if (pyth <= rr) {
|
|
271
139
|
return true;
|
|
272
140
|
}
|
|
273
|
-
const dot =
|
|
141
|
+
const dot = x2 * this.direction.x + y2 * this.direction.y + z2 * this.direction.z;
|
|
274
142
|
if (dot < 0) {
|
|
275
143
|
return false;
|
|
276
144
|
}
|
|
@@ -280,8 +148,8 @@ class Ray {
|
|
|
280
148
|
static Zero() {
|
|
281
149
|
return new Ray(Vector3.Zero(), new Vector3(0, 0, 1), Number.MAX_VALUE);
|
|
282
150
|
}
|
|
283
|
-
static CreateNew(
|
|
284
|
-
return new Ray(new Vector3(
|
|
151
|
+
static CreateNew(x2, y2, z2, dx, dy, dz, length = Number.MAX_VALUE) {
|
|
152
|
+
return new Ray(new Vector3(x2, y2, z2), new Vector3(dx, dy, dz), length);
|
|
285
153
|
}
|
|
286
154
|
}
|
|
287
155
|
const Frustum = {
|
|
@@ -305,8 +173,8 @@ const Frustum = {
|
|
|
305
173
|
set(planes[5], m2[3] - m2[2], m2[7] - m2[6], m2[11] - m2[10], m2[15] - m2[14]);
|
|
306
174
|
}
|
|
307
175
|
};
|
|
308
|
-
function set(plane, a,
|
|
309
|
-
plane.normal.set(a,
|
|
176
|
+
function set(plane, a, b, c2, d2) {
|
|
177
|
+
plane.normal.set(a, b, c2);
|
|
310
178
|
plane.d = d2;
|
|
311
179
|
plane.normalize();
|
|
312
180
|
}
|
|
@@ -332,9 +200,9 @@ class Size {
|
|
|
332
200
|
}
|
|
333
201
|
}
|
|
334
202
|
class Viewport {
|
|
335
|
-
constructor(
|
|
336
|
-
this.x =
|
|
337
|
-
this.y =
|
|
203
|
+
constructor(x2, y2, width, height) {
|
|
204
|
+
this.x = x2;
|
|
205
|
+
this.y = y2;
|
|
338
206
|
this.width = width;
|
|
339
207
|
this.height = height;
|
|
340
208
|
}
|
|
@@ -394,10 +262,10 @@ class Curve3 {
|
|
|
394
262
|
for (let i2 = 0; i2 <= count; i2++) {
|
|
395
263
|
const t2 = i2 / count;
|
|
396
264
|
const u = 1 - t2;
|
|
397
|
-
const
|
|
398
|
-
const
|
|
399
|
-
const
|
|
400
|
-
points.push(new Vector3(
|
|
265
|
+
const x2 = u * u * v0.x + 2 * u * t2 * v1.x + t2 * t2 * v2.x;
|
|
266
|
+
const y2 = u * u * v0.y + 2 * u * t2 * v1.y + t2 * t2 * v2.y;
|
|
267
|
+
const z2 = u * u * v0.z + 2 * u * t2 * v1.z + t2 * t2 * v2.z;
|
|
268
|
+
points.push(new Vector3(x2, y2, z2));
|
|
401
269
|
}
|
|
402
270
|
return new Curve3(points);
|
|
403
271
|
}
|
|
@@ -572,7 +440,7 @@ class PerformanceMonitor {
|
|
|
572
440
|
if (this._samples.length === 0) {
|
|
573
441
|
return 0;
|
|
574
442
|
}
|
|
575
|
-
return this._samples.reduce((a,
|
|
443
|
+
return this._samples.reduce((a, b) => a + b, 0) / this._samples.length;
|
|
576
444
|
}
|
|
577
445
|
get averageFPS() {
|
|
578
446
|
const avg = this.averageFrameTime;
|
|
@@ -1001,7 +869,7 @@ class AbstractEngine {
|
|
|
1001
869
|
}
|
|
1002
870
|
async _startCore() {
|
|
1003
871
|
if (this._startupWork.length > 0) {
|
|
1004
|
-
await Promise.all(this._startupWork.map((
|
|
872
|
+
await Promise.all(this._startupWork.map((w2) => w2()));
|
|
1005
873
|
this._startupWork.length = 0;
|
|
1006
874
|
}
|
|
1007
875
|
for (const scene of this._scenes) {
|
|
@@ -1463,9 +1331,9 @@ class Camera extends Node {
|
|
|
1463
1331
|
_aspectRatio() {
|
|
1464
1332
|
const scene = this._scene;
|
|
1465
1333
|
const canvas = scene == null ? void 0 : scene.getEngine().getRenderingCanvas();
|
|
1466
|
-
const
|
|
1334
|
+
const w2 = (canvas == null ? void 0 : canvas.width) ?? 1;
|
|
1467
1335
|
const h2 = (canvas == null ? void 0 : canvas.height) ?? 1;
|
|
1468
|
-
return h2 !== 0 ?
|
|
1336
|
+
return h2 !== 0 ? w2 / h2 : 1;
|
|
1469
1337
|
}
|
|
1470
1338
|
detachControl() {
|
|
1471
1339
|
if (this._detach) {
|
|
@@ -1661,10 +1529,10 @@ class FollowCamera extends TargetCamera {
|
|
|
1661
1529
|
return;
|
|
1662
1530
|
}
|
|
1663
1531
|
const radians = this.rotationOffset * Math.PI / 180;
|
|
1664
|
-
const
|
|
1665
|
-
const
|
|
1666
|
-
const
|
|
1667
|
-
this._lite.position.set(
|
|
1532
|
+
const x2 = target.position.x + this.radius * Math.sin(radians);
|
|
1533
|
+
const z2 = target.position.z + this.radius * Math.cos(radians);
|
|
1534
|
+
const y2 = target.position.y + this.heightOffset;
|
|
1535
|
+
this._lite.position.set(x2, y2, z2);
|
|
1668
1536
|
this.setTarget(new Vector3(target.position.x, target.position.y, target.position.z));
|
|
1669
1537
|
}
|
|
1670
1538
|
}
|
|
@@ -1730,720 +1598,6 @@ class AnaglyphArcRotateCamera {
|
|
|
1730
1598
|
unsupported("AnaglyphArcRotateCamera", "Stereoscopic camera rigs are not implemented in Babylon Lite. (An anaglyph post-process exists separately.)");
|
|
1731
1599
|
}
|
|
1732
1600
|
}
|
|
1733
|
-
class Material {
|
|
1734
|
-
constructor(name, scene) {
|
|
1735
|
-
__publicField(this, "name");
|
|
1736
|
-
/** Common transparency mode flag (Babylon.js `Material.transparencyMode`). */
|
|
1737
|
-
__publicField(this, "transparencyMode", null);
|
|
1738
|
-
/** Back-face culling toggle (Babylon.js `Material.backFaceCulling`). */
|
|
1739
|
-
__publicField(this, "_backFaceCulling", true);
|
|
1740
|
-
/** Wireframe rendering toggle (not honoured by all Lite materials). */
|
|
1741
|
-
__publicField(this, "wireframe", false);
|
|
1742
|
-
/** @internal Owning compat scene, when constructed against one. */
|
|
1743
|
-
__publicField(this, "_scene");
|
|
1744
|
-
this.name = name;
|
|
1745
|
-
this._scene = scene;
|
|
1746
|
-
scene == null ? void 0 : scene._registerMaterial(this);
|
|
1747
|
-
}
|
|
1748
|
-
get backFaceCulling() {
|
|
1749
|
-
return this._backFaceCulling;
|
|
1750
|
-
}
|
|
1751
|
-
set backFaceCulling(value) {
|
|
1752
|
-
this._backFaceCulling = value;
|
|
1753
|
-
this._applyBackFaceCulling(value);
|
|
1754
|
-
this._markDirty();
|
|
1755
|
-
}
|
|
1756
|
-
/** @internal Per-material hook to push culling onto the Lite props (Standard vs PBR differ). */
|
|
1757
|
-
_applyBackFaceCulling(_value) {
|
|
1758
|
-
}
|
|
1759
|
-
getClassName() {
|
|
1760
|
-
return "Material";
|
|
1761
|
-
}
|
|
1762
|
-
/**
|
|
1763
|
-
* @internal Copy the shared base + Lite data-property state onto a freshly
|
|
1764
|
-
* constructed clone. The clone keeps the `_buildGroup`/UBO its own factory
|
|
1765
|
-
* created (internal `_`-prefixed fields are never copied), so only the observable
|
|
1766
|
-
* data properties — colours, scalars, and shared texture references — carry over.
|
|
1767
|
-
*/
|
|
1768
|
-
_cloneBaseInto(target) {
|
|
1769
|
-
copyLiteMaterialData(this._lite, target._lite);
|
|
1770
|
-
target.transparencyMode = this.transparencyMode;
|
|
1771
|
-
target.wireframe = this.wireframe;
|
|
1772
|
-
target.backFaceCulling = this._backFaceCulling;
|
|
1773
|
-
}
|
|
1774
|
-
/** The scene this material was constructed against (Babylon.js `Material.getScene`). */
|
|
1775
|
-
getScene() {
|
|
1776
|
-
return this._scene;
|
|
1777
|
-
}
|
|
1778
|
-
/**
|
|
1779
|
-
* The textures currently bound to this material (Babylon.js
|
|
1780
|
-
* `Material.getActiveTextures`). The base material owns no texture slots, so
|
|
1781
|
-
* this returns an empty array; each subclass overrides it to enumerate its own
|
|
1782
|
-
* slots and those of its extensions.
|
|
1783
|
-
*/
|
|
1784
|
-
getActiveTextures() {
|
|
1785
|
-
return [];
|
|
1786
|
-
}
|
|
1787
|
-
_markDirty() {
|
|
1788
|
-
markMaterialUboDirty(this._lite);
|
|
1789
|
-
}
|
|
1790
|
-
/**
|
|
1791
|
-
* @internal Finalize GPU-facing resources before the mesh is registered.
|
|
1792
|
-
* Base materials need nothing; PBR overrides this to synthesize the solid
|
|
1793
|
-
* textures Babylon Lite's PBR pipeline requires from factor-only materials.
|
|
1794
|
-
*/
|
|
1795
|
-
_ensureRenderable(_engine) {
|
|
1796
|
-
}
|
|
1797
|
-
/**
|
|
1798
|
-
* @internal Adopt an owning scene discovered when the material is first assigned
|
|
1799
|
-
* to a mesh (Babylon.js allows `new StandardMaterial(name)` with no scene, then
|
|
1800
|
-
* `mesh.material = mat`). Needed so the texture-readiness path can reconcile the
|
|
1801
|
-
* material into the running scene. Registers with the scene the first time.
|
|
1802
|
-
*/
|
|
1803
|
-
_adoptScene(scene) {
|
|
1804
|
-
if (!this._scene) {
|
|
1805
|
-
this._scene = scene;
|
|
1806
|
-
scene._registerMaterial(this);
|
|
1807
|
-
}
|
|
1808
|
-
}
|
|
1809
|
-
/**
|
|
1810
|
-
* @internal Reconcile this material into its scene when the scene is already
|
|
1811
|
-
* live: finalize GPU-facing resources ({@link _ensureRenderable}) and rebuild
|
|
1812
|
-
* the renderables of every mesh using it. A no-op before engine start (the
|
|
1813
|
-
* boot-time build handles those meshes) or when the material has no scene.
|
|
1814
|
-
* Shared by the mesh `material` setter and the texture-readiness callback.
|
|
1815
|
-
*/
|
|
1816
|
-
_refreshInScene() {
|
|
1817
|
-
const scene = this._scene;
|
|
1818
|
-
if (!(scene == null ? void 0 : scene._hasStarted)) {
|
|
1819
|
-
return;
|
|
1820
|
-
}
|
|
1821
|
-
this._ensureRenderable(scene.getEngine()._lite);
|
|
1822
|
-
rebuildMaterial(scene._lite, this._lite);
|
|
1823
|
-
}
|
|
1824
|
-
/**
|
|
1825
|
-
* @internal Rebind + rebuild this material once an asynchronously loaded texture
|
|
1826
|
-
* assigned to it becomes GPU-ready. Babylon.js `Texture`s load in the background,
|
|
1827
|
-
* so a texture assigned to a material (or a material assigned to a mesh) before
|
|
1828
|
-
* the load resolves must go back through the rebuild path once the handle exists.
|
|
1829
|
-
* Fires immediately when the texture is already ready (then gated by scene state).
|
|
1830
|
-
*/
|
|
1831
|
-
_watchTexture(texture) {
|
|
1832
|
-
var _a;
|
|
1833
|
-
(_a = texture == null ? void 0 : texture._onReady) == null ? void 0 : _a.call(texture, () => this._refreshInScene());
|
|
1834
|
-
}
|
|
1835
|
-
dispose() {
|
|
1836
|
-
var _a;
|
|
1837
|
-
(_a = this._scene) == null ? void 0 : _a._unregisterMaterial(this);
|
|
1838
|
-
this._scene = void 0;
|
|
1839
|
-
}
|
|
1840
|
-
}
|
|
1841
|
-
class PushMaterial extends Material {
|
|
1842
|
-
getClassName() {
|
|
1843
|
-
return "PushMaterial";
|
|
1844
|
-
}
|
|
1845
|
-
}
|
|
1846
|
-
function readColor3(tuple) {
|
|
1847
|
-
return tuple ? new Color3(tuple[0], tuple[1], tuple[2]) : new Color3(0, 0, 0);
|
|
1848
|
-
}
|
|
1849
|
-
function copyLiteMaterialData(src, dst) {
|
|
1850
|
-
const s = src;
|
|
1851
|
-
const d2 = dst;
|
|
1852
|
-
for (const key of Object.keys(s)) {
|
|
1853
|
-
if (key.startsWith("_")) {
|
|
1854
|
-
continue;
|
|
1855
|
-
}
|
|
1856
|
-
const value = s[key];
|
|
1857
|
-
d2[key] = Array.isArray(value) ? value.slice() : value;
|
|
1858
|
-
}
|
|
1859
|
-
}
|
|
1860
|
-
class StandardMaterial extends PushMaterial {
|
|
1861
|
-
constructor(name, scene) {
|
|
1862
|
-
super(name, scene);
|
|
1863
|
-
/** @internal Underlying Babylon Lite standard-material props. */
|
|
1864
|
-
__publicField(this, "_lite");
|
|
1865
|
-
/**
|
|
1866
|
-
* Babylon.js `StandardMaterial.useAlphaFromDiffuseTexture`. Babylon Lite's
|
|
1867
|
-
* alpha test already samples the diffuse texture's alpha (enabled via
|
|
1868
|
-
* `alphaCutOff`), so this is accepted for parity.
|
|
1869
|
-
*/
|
|
1870
|
-
__publicField(this, "useAlphaFromDiffuseTexture", false);
|
|
1871
|
-
__publicField(this, "_diffuseTexture", null);
|
|
1872
|
-
__publicField(this, "_bumpTexture", null);
|
|
1873
|
-
__publicField(this, "_emissiveTexture", null);
|
|
1874
|
-
this._lite = createStandardMaterial();
|
|
1875
|
-
}
|
|
1876
|
-
getClassName() {
|
|
1877
|
-
return "StandardMaterial";
|
|
1878
|
-
}
|
|
1879
|
-
get diffuseColor() {
|
|
1880
|
-
return readColor3(this._lite.diffuseColor);
|
|
1881
|
-
}
|
|
1882
|
-
set diffuseColor(value) {
|
|
1883
|
-
this._lite.diffuseColor = [value.r, value.g, value.b];
|
|
1884
|
-
this._markDirty();
|
|
1885
|
-
}
|
|
1886
|
-
get specularColor() {
|
|
1887
|
-
return readColor3(this._lite.specularColor);
|
|
1888
|
-
}
|
|
1889
|
-
set specularColor(value) {
|
|
1890
|
-
this._lite.specularColor = [value.r, value.g, value.b];
|
|
1891
|
-
this._markDirty();
|
|
1892
|
-
}
|
|
1893
|
-
get emissiveColor() {
|
|
1894
|
-
return readColor3(this._lite.emissiveColor);
|
|
1895
|
-
}
|
|
1896
|
-
set emissiveColor(value) {
|
|
1897
|
-
this._lite.emissiveColor = [value.r, value.g, value.b];
|
|
1898
|
-
this._markDirty();
|
|
1899
|
-
}
|
|
1900
|
-
get ambientColor() {
|
|
1901
|
-
return readColor3(this._lite.ambientColor);
|
|
1902
|
-
}
|
|
1903
|
-
set ambientColor(value) {
|
|
1904
|
-
this._lite.ambientColor = [value.r, value.g, value.b];
|
|
1905
|
-
this._markDirty();
|
|
1906
|
-
}
|
|
1907
|
-
get disableLighting() {
|
|
1908
|
-
return this._lite.disableLighting;
|
|
1909
|
-
}
|
|
1910
|
-
set disableLighting(value) {
|
|
1911
|
-
this._lite.disableLighting = value;
|
|
1912
|
-
this._markDirty();
|
|
1913
|
-
}
|
|
1914
|
-
_applyBackFaceCulling(value) {
|
|
1915
|
-
this._lite.backFaceCulling = value;
|
|
1916
|
-
}
|
|
1917
|
-
get alpha() {
|
|
1918
|
-
return this._lite.alpha;
|
|
1919
|
-
}
|
|
1920
|
-
set alpha(value) {
|
|
1921
|
-
this._lite.alpha = value;
|
|
1922
|
-
this._markDirty();
|
|
1923
|
-
}
|
|
1924
|
-
get diffuseTexture() {
|
|
1925
|
-
return this._diffuseTexture;
|
|
1926
|
-
}
|
|
1927
|
-
set diffuseTexture(texture) {
|
|
1928
|
-
this._diffuseTexture = texture;
|
|
1929
|
-
this._lite.diffuseTexture = (texture == null ? void 0 : texture._lite) ?? null;
|
|
1930
|
-
this._watchTexture(texture);
|
|
1931
|
-
this._markDirty();
|
|
1932
|
-
}
|
|
1933
|
-
/**
|
|
1934
|
-
* Babylon.js `StandardMaterial.alphaCutOff` — alpha-test threshold. Fragments
|
|
1935
|
-
* whose diffuse-texture alpha is below this value are discarded. Babylon Lite's
|
|
1936
|
-
* Standard pipeline alpha-tests against the diffuse texture's alpha when
|
|
1937
|
-
* `alphaCutOff > 0`, so this is wired directly.
|
|
1938
|
-
*/
|
|
1939
|
-
get alphaCutOff() {
|
|
1940
|
-
return this._lite.alphaCutOff;
|
|
1941
|
-
}
|
|
1942
|
-
set alphaCutOff(value) {
|
|
1943
|
-
this._lite.alphaCutOff = value;
|
|
1944
|
-
this._markDirty();
|
|
1945
|
-
}
|
|
1946
|
-
get bumpTexture() {
|
|
1947
|
-
return this._bumpTexture;
|
|
1948
|
-
}
|
|
1949
|
-
set bumpTexture(texture) {
|
|
1950
|
-
this._bumpTexture = texture;
|
|
1951
|
-
this._lite.bumpTexture = (texture == null ? void 0 : texture._lite) ?? null;
|
|
1952
|
-
this._watchTexture(texture);
|
|
1953
|
-
this._markDirty();
|
|
1954
|
-
}
|
|
1955
|
-
get emissiveTexture() {
|
|
1956
|
-
return this._emissiveTexture;
|
|
1957
|
-
}
|
|
1958
|
-
set emissiveTexture(texture) {
|
|
1959
|
-
this._emissiveTexture = texture;
|
|
1960
|
-
this._lite.emissiveTexture = (texture == null ? void 0 : texture._lite) ?? null;
|
|
1961
|
-
this._watchTexture(texture);
|
|
1962
|
-
this._markDirty();
|
|
1963
|
-
}
|
|
1964
|
-
/** Enumerate the standard-material texture slots that are bound (Babylon.js `getActiveTextures`). */
|
|
1965
|
-
getActiveTextures() {
|
|
1966
|
-
const textures = [];
|
|
1967
|
-
if (this._diffuseTexture) {
|
|
1968
|
-
textures.push(this._diffuseTexture);
|
|
1969
|
-
}
|
|
1970
|
-
if (this._bumpTexture) {
|
|
1971
|
-
textures.push(this._bumpTexture);
|
|
1972
|
-
}
|
|
1973
|
-
if (this._emissiveTexture) {
|
|
1974
|
-
textures.push(this._emissiveTexture);
|
|
1975
|
-
}
|
|
1976
|
-
return textures;
|
|
1977
|
-
}
|
|
1978
|
-
/**
|
|
1979
|
-
* @internal Re-bind texture maps to the Lite material. Babylon.js `Texture`s
|
|
1980
|
-
* load asynchronously, so when `material.diffuseTexture = new Texture(url)` ran
|
|
1981
|
-
* the Lite handle was still undefined. By engine-start the scene has awaited the
|
|
1982
|
-
* loads, so copy the now-resolved handles (and UV tiling) onto the Lite props.
|
|
1983
|
-
*/
|
|
1984
|
-
_ensureRenderable(_engine) {
|
|
1985
|
-
const diff = this._diffuseTexture;
|
|
1986
|
-
if (diff == null ? void 0 : diff._lite) {
|
|
1987
|
-
this._lite.diffuseTexture = diff._lite;
|
|
1988
|
-
if (diff.uScale !== void 0 && diff.vScale !== void 0) {
|
|
1989
|
-
this._lite.uvScale = [diff.uScale, diff.vScale];
|
|
1990
|
-
}
|
|
1991
|
-
}
|
|
1992
|
-
const bump = this._bumpTexture;
|
|
1993
|
-
if (bump == null ? void 0 : bump._lite) {
|
|
1994
|
-
this._lite.bumpTexture = bump._lite;
|
|
1995
|
-
}
|
|
1996
|
-
const emissive = this._emissiveTexture;
|
|
1997
|
-
if (emissive == null ? void 0 : emissive._lite) {
|
|
1998
|
-
this._lite.emissiveTexture = emissive._lite;
|
|
1999
|
-
}
|
|
2000
|
-
this._markDirty();
|
|
2001
|
-
}
|
|
2002
|
-
/**
|
|
2003
|
-
* Babylon.js `StandardMaterial.clone(name)`. Copies the diffuse/specular/emissive/
|
|
2004
|
-
* ambient colours and scalars, shares the diffuse/bump/emissive texture references,
|
|
2005
|
-
* and gives the clone its own Lite standard-material renderable.
|
|
2006
|
-
*/
|
|
2007
|
-
clone(name) {
|
|
2008
|
-
const cloned = new StandardMaterial(name, this._scene);
|
|
2009
|
-
this._cloneBaseInto(cloned);
|
|
2010
|
-
cloned.useAlphaFromDiffuseTexture = this.useAlphaFromDiffuseTexture;
|
|
2011
|
-
cloned._diffuseTexture = this._diffuseTexture;
|
|
2012
|
-
cloned._bumpTexture = this._bumpTexture;
|
|
2013
|
-
cloned._emissiveTexture = this._emissiveTexture;
|
|
2014
|
-
return cloned;
|
|
2015
|
-
}
|
|
2016
|
-
}
|
|
2017
|
-
class PBRClearCoatConfiguration {
|
|
2018
|
-
constructor(_props, _markDirty) {
|
|
2019
|
-
this._props = _props;
|
|
2020
|
-
this._markDirty = _markDirty;
|
|
2021
|
-
}
|
|
2022
|
-
get isEnabled() {
|
|
2023
|
-
return this._props.isEnabled ?? false;
|
|
2024
|
-
}
|
|
2025
|
-
set isEnabled(value) {
|
|
2026
|
-
this._props.isEnabled = value;
|
|
2027
|
-
this._markDirty();
|
|
2028
|
-
}
|
|
2029
|
-
get intensity() {
|
|
2030
|
-
return this._props.intensity ?? 1;
|
|
2031
|
-
}
|
|
2032
|
-
set intensity(value) {
|
|
2033
|
-
this._props.intensity = value;
|
|
2034
|
-
this._markDirty();
|
|
2035
|
-
}
|
|
2036
|
-
get roughness() {
|
|
2037
|
-
return this._props.roughness ?? 0;
|
|
2038
|
-
}
|
|
2039
|
-
set roughness(value) {
|
|
2040
|
-
this._props.roughness = value;
|
|
2041
|
-
this._markDirty();
|
|
2042
|
-
}
|
|
2043
|
-
get indexOfRefraction() {
|
|
2044
|
-
return this._props.indexOfRefraction ?? 1.5;
|
|
2045
|
-
}
|
|
2046
|
-
set indexOfRefraction(value) {
|
|
2047
|
-
this._props.indexOfRefraction = value;
|
|
2048
|
-
this._markDirty();
|
|
2049
|
-
}
|
|
2050
|
-
}
|
|
2051
|
-
class PBRSheenConfiguration {
|
|
2052
|
-
constructor(_props, _markDirty) {
|
|
2053
|
-
__publicField(this, "_texture", null);
|
|
2054
|
-
this._props = _props;
|
|
2055
|
-
this._markDirty = _markDirty;
|
|
2056
|
-
}
|
|
2057
|
-
get isEnabled() {
|
|
2058
|
-
return this._props.isEnabled;
|
|
2059
|
-
}
|
|
2060
|
-
set isEnabled(value) {
|
|
2061
|
-
this._props.isEnabled = value;
|
|
2062
|
-
this._markDirty();
|
|
2063
|
-
}
|
|
2064
|
-
get intensity() {
|
|
2065
|
-
return this._props.intensity ?? 1;
|
|
2066
|
-
}
|
|
2067
|
-
set intensity(value) {
|
|
2068
|
-
this._props.intensity = value;
|
|
2069
|
-
this._markDirty();
|
|
2070
|
-
}
|
|
2071
|
-
get roughness() {
|
|
2072
|
-
return this._props.roughness ?? 0;
|
|
2073
|
-
}
|
|
2074
|
-
set roughness(value) {
|
|
2075
|
-
this._props.roughness = value;
|
|
2076
|
-
this._markDirty();
|
|
2077
|
-
}
|
|
2078
|
-
get color() {
|
|
2079
|
-
const c2 = this._props.color ?? [1, 1, 1];
|
|
2080
|
-
return new Color3(c2[0], c2[1], c2[2]);
|
|
2081
|
-
}
|
|
2082
|
-
set color(value) {
|
|
2083
|
-
this._props.color = [value.r, value.g, value.b];
|
|
2084
|
-
this._markDirty();
|
|
2085
|
-
}
|
|
2086
|
-
/** Babylon.js `sheen.texture`. Retains the wrapper and binds the Lite handle if the texture has resolved. */
|
|
2087
|
-
get texture() {
|
|
2088
|
-
return this._texture;
|
|
2089
|
-
}
|
|
2090
|
-
set texture(value) {
|
|
2091
|
-
this._texture = value;
|
|
2092
|
-
if (value == null ? void 0 : value._lite) {
|
|
2093
|
-
this._props.texture = value._lite;
|
|
2094
|
-
} else {
|
|
2095
|
-
delete this._props.texture;
|
|
2096
|
-
}
|
|
2097
|
-
this._markDirty();
|
|
2098
|
-
}
|
|
2099
|
-
/** Enumerate the sheen texture slot for `Material.getActiveTextures`. */
|
|
2100
|
-
getActiveTextures() {
|
|
2101
|
-
return this._texture ? [this._texture] : [];
|
|
2102
|
-
}
|
|
2103
|
-
}
|
|
2104
|
-
class PBRAnisotropicConfiguration {
|
|
2105
|
-
constructor(_props, _markDirty) {
|
|
2106
|
-
this._props = _props;
|
|
2107
|
-
this._markDirty = _markDirty;
|
|
2108
|
-
}
|
|
2109
|
-
get isEnabled() {
|
|
2110
|
-
return this._props.isEnabled;
|
|
2111
|
-
}
|
|
2112
|
-
set isEnabled(value) {
|
|
2113
|
-
this._props.isEnabled = value;
|
|
2114
|
-
this._markDirty();
|
|
2115
|
-
}
|
|
2116
|
-
get intensity() {
|
|
2117
|
-
return this._props.intensity ?? 1;
|
|
2118
|
-
}
|
|
2119
|
-
set intensity(value) {
|
|
2120
|
-
this._props.intensity = value;
|
|
2121
|
-
this._markDirty();
|
|
2122
|
-
}
|
|
2123
|
-
get direction() {
|
|
2124
|
-
const d2 = this._props.direction ?? [1, 0];
|
|
2125
|
-
return { x: d2[0], y: d2[1] };
|
|
2126
|
-
}
|
|
2127
|
-
set direction(value) {
|
|
2128
|
-
this._props.direction = [value.x, value.y];
|
|
2129
|
-
this._markDirty();
|
|
2130
|
-
}
|
|
2131
|
-
}
|
|
2132
|
-
class PBRIridescenceConfiguration {
|
|
2133
|
-
constructor(_props, _markDirty) {
|
|
2134
|
-
this._props = _props;
|
|
2135
|
-
this._markDirty = _markDirty;
|
|
2136
|
-
}
|
|
2137
|
-
get isEnabled() {
|
|
2138
|
-
return this._props.isEnabled ?? false;
|
|
2139
|
-
}
|
|
2140
|
-
set isEnabled(value) {
|
|
2141
|
-
this._props.isEnabled = value;
|
|
2142
|
-
this._markDirty();
|
|
2143
|
-
}
|
|
2144
|
-
get intensity() {
|
|
2145
|
-
return this._props.intensity ?? 1;
|
|
2146
|
-
}
|
|
2147
|
-
set intensity(value) {
|
|
2148
|
-
this._props.intensity = value;
|
|
2149
|
-
this._markDirty();
|
|
2150
|
-
}
|
|
2151
|
-
get indexOfRefraction() {
|
|
2152
|
-
return this._props.indexOfRefraction ?? 1.3;
|
|
2153
|
-
}
|
|
2154
|
-
set indexOfRefraction(value) {
|
|
2155
|
-
this._props.indexOfRefraction = value;
|
|
2156
|
-
this._markDirty();
|
|
2157
|
-
}
|
|
2158
|
-
get minimumThickness() {
|
|
2159
|
-
return this._props.minimumThickness ?? 100;
|
|
2160
|
-
}
|
|
2161
|
-
set minimumThickness(value) {
|
|
2162
|
-
this._props.minimumThickness = value;
|
|
2163
|
-
this._markDirty();
|
|
2164
|
-
}
|
|
2165
|
-
get maximumThickness() {
|
|
2166
|
-
return this._props.maximumThickness ?? 400;
|
|
2167
|
-
}
|
|
2168
|
-
set maximumThickness(value) {
|
|
2169
|
-
this._props.maximumThickness = value;
|
|
2170
|
-
this._markDirty();
|
|
2171
|
-
}
|
|
2172
|
-
}
|
|
2173
|
-
class PBRMaterial extends PushMaterial {
|
|
2174
|
-
constructor(name, scene) {
|
|
2175
|
-
super(name, scene);
|
|
2176
|
-
/** @internal Underlying Babylon Lite PBR-material props. */
|
|
2177
|
-
__publicField(this, "_lite");
|
|
2178
|
-
__publicField(this, "_albedoFactor", [1, 1, 1, 1]);
|
|
2179
|
-
__publicField(this, "_albedoTexture", null);
|
|
2180
|
-
/**
|
|
2181
|
-
* Babylon.js `material.forceIrradianceInFragment`. Babylon Lite computes
|
|
2182
|
-
* irradiance in the fragment stage already, so this is accepted for parity.
|
|
2183
|
-
*/
|
|
2184
|
-
__publicField(this, "forceIrradianceInFragment", false);
|
|
2185
|
-
__publicField(this, "_clearCoat");
|
|
2186
|
-
__publicField(this, "_sheen");
|
|
2187
|
-
__publicField(this, "_anisotropy");
|
|
2188
|
-
__publicField(this, "_iridescence");
|
|
2189
|
-
__publicField(this, "_environmentTexture", null);
|
|
2190
|
-
this._lite = createPbrMaterial();
|
|
2191
|
-
if (!this._lite.baseColorFactor) {
|
|
2192
|
-
this._lite.baseColorFactor = [1, 1, 1, 1];
|
|
2193
|
-
}
|
|
2194
|
-
}
|
|
2195
|
-
getClassName() {
|
|
2196
|
-
return "PBRMaterial";
|
|
2197
|
-
}
|
|
2198
|
-
get albedoColor() {
|
|
2199
|
-
return new Color3(this._albedoFactor[0], this._albedoFactor[1], this._albedoFactor[2]);
|
|
2200
|
-
}
|
|
2201
|
-
set albedoColor(value) {
|
|
2202
|
-
this._albedoFactor = [value.r, value.g, value.b, this._albedoFactor[3]];
|
|
2203
|
-
this._lite.baseColorFactor = [...this._albedoFactor];
|
|
2204
|
-
this._markDirty();
|
|
2205
|
-
}
|
|
2206
|
-
/**
|
|
2207
|
-
* Babylon.js `pbr.albedoTexture` (glTF base-color map). The texture loads
|
|
2208
|
-
* asynchronously, so the resolved Lite handle (+ sRGB flag) is bound in
|
|
2209
|
-
* {@link _ensureRenderable} at engine start rather than here.
|
|
2210
|
-
*/
|
|
2211
|
-
get albedoTexture() {
|
|
2212
|
-
return this._albedoTexture;
|
|
2213
|
-
}
|
|
2214
|
-
set albedoTexture(texture) {
|
|
2215
|
-
this._albedoTexture = texture;
|
|
2216
|
-
this._watchTexture(texture);
|
|
2217
|
-
this._markDirty();
|
|
2218
|
-
}
|
|
2219
|
-
/**
|
|
2220
|
-
* Enumerate every bound PBR texture slot, including extension sub-configurations
|
|
2221
|
-
* (Babylon.js `PBRMaterial.getActiveTextures`).
|
|
2222
|
-
*/
|
|
2223
|
-
getActiveTextures() {
|
|
2224
|
-
const textures = [];
|
|
2225
|
-
if (this._albedoTexture) {
|
|
2226
|
-
textures.push(this._albedoTexture);
|
|
2227
|
-
}
|
|
2228
|
-
const environmentTexture = this.environmentTexture;
|
|
2229
|
-
if (environmentTexture) {
|
|
2230
|
-
textures.push(environmentTexture);
|
|
2231
|
-
}
|
|
2232
|
-
if (this._sheen) {
|
|
2233
|
-
textures.push(...this._sheen.getActiveTextures());
|
|
2234
|
-
}
|
|
2235
|
-
return textures;
|
|
2236
|
-
}
|
|
2237
|
-
get metallic() {
|
|
2238
|
-
return this._lite.metallicFactor ?? 1;
|
|
2239
|
-
}
|
|
2240
|
-
set metallic(value) {
|
|
2241
|
-
this._lite.metallicFactor = value;
|
|
2242
|
-
this._markDirty();
|
|
2243
|
-
}
|
|
2244
|
-
get roughness() {
|
|
2245
|
-
return this._lite.roughnessFactor ?? 1;
|
|
2246
|
-
}
|
|
2247
|
-
set roughness(value) {
|
|
2248
|
-
this._lite.roughnessFactor = value;
|
|
2249
|
-
this._markDirty();
|
|
2250
|
-
}
|
|
2251
|
-
get emissiveColor() {
|
|
2252
|
-
return readColor3(this._lite.emissiveColor);
|
|
2253
|
-
}
|
|
2254
|
-
set emissiveColor(value) {
|
|
2255
|
-
this._lite.emissiveColor = [value.r, value.g, value.b];
|
|
2256
|
-
this._markDirty();
|
|
2257
|
-
}
|
|
2258
|
-
/**
|
|
2259
|
-
* Babylon.js `pbr.usePhysicalLightFalloff`. When false, point/spot lights use
|
|
2260
|
-
* Standard-style linear range falloff instead of physical inverse-square.
|
|
2261
|
-
* Default true (matches Babylon.js PBRMaterial).
|
|
2262
|
-
*/
|
|
2263
|
-
get usePhysicalLightFalloff() {
|
|
2264
|
-
return this._lite.usePhysicalLightFalloff ?? true;
|
|
2265
|
-
}
|
|
2266
|
-
set usePhysicalLightFalloff(value) {
|
|
2267
|
-
this._lite.usePhysicalLightFalloff = value;
|
|
2268
|
-
this._markDirty();
|
|
2269
|
-
}
|
|
2270
|
-
get alpha() {
|
|
2271
|
-
return this._lite.alpha ?? 1;
|
|
2272
|
-
}
|
|
2273
|
-
set alpha(value) {
|
|
2274
|
-
this._lite.alpha = value;
|
|
2275
|
-
this._markDirty();
|
|
2276
|
-
}
|
|
2277
|
-
_applyBackFaceCulling(value) {
|
|
2278
|
-
this._lite.doubleSided = !value;
|
|
2279
|
-
}
|
|
2280
|
-
/**
|
|
2281
|
-
* Babylon.js `pbr.clearCoat` sub-configuration. Lazily allocates the Lite
|
|
2282
|
-
* `clearCoat` props on first access and proxies the common fields
|
|
2283
|
-
* (`isEnabled`, `intensity`, `roughness`, `indexOfRefraction`) onto them.
|
|
2284
|
-
*/
|
|
2285
|
-
get clearCoat() {
|
|
2286
|
-
if (!this._clearCoat) {
|
|
2287
|
-
if (!this._lite.clearCoat) {
|
|
2288
|
-
this._lite.clearCoat = { isEnabled: false };
|
|
2289
|
-
}
|
|
2290
|
-
this._clearCoat = new PBRClearCoatConfiguration(this._lite.clearCoat, () => this._markDirty());
|
|
2291
|
-
}
|
|
2292
|
-
return this._clearCoat;
|
|
2293
|
-
}
|
|
2294
|
-
/** Babylon.js `pbr.sheen` sub-configuration (Lite `SheenProps`). */
|
|
2295
|
-
get sheen() {
|
|
2296
|
-
if (!this._sheen) {
|
|
2297
|
-
if (!this._lite.sheen) {
|
|
2298
|
-
this._lite.sheen = { isEnabled: false };
|
|
2299
|
-
}
|
|
2300
|
-
this._sheen = new PBRSheenConfiguration(this._lite.sheen, () => this._markDirty());
|
|
2301
|
-
}
|
|
2302
|
-
return this._sheen;
|
|
2303
|
-
}
|
|
2304
|
-
/** Babylon.js `pbr.anisotropy` sub-configuration (Lite `AnisotropyProps`). */
|
|
2305
|
-
get anisotropy() {
|
|
2306
|
-
if (!this._anisotropy) {
|
|
2307
|
-
if (!this._lite.anisotropy) {
|
|
2308
|
-
this._lite.anisotropy = { isEnabled: false };
|
|
2309
|
-
}
|
|
2310
|
-
this._anisotropy = new PBRAnisotropicConfiguration(this._lite.anisotropy, () => this._markDirty());
|
|
2311
|
-
}
|
|
2312
|
-
return this._anisotropy;
|
|
2313
|
-
}
|
|
2314
|
-
/** Babylon.js `pbr.iridescence` sub-configuration (Lite `IridescenceProps`). */
|
|
2315
|
-
get iridescence() {
|
|
2316
|
-
if (!this._iridescence) {
|
|
2317
|
-
if (!this._lite.iridescence) {
|
|
2318
|
-
this._lite.iridescence = { isEnabled: false };
|
|
2319
|
-
}
|
|
2320
|
-
this._iridescence = new PBRIridescenceConfiguration(this._lite.iridescence, () => this._markDirty());
|
|
2321
|
-
}
|
|
2322
|
-
return this._iridescence;
|
|
2323
|
-
}
|
|
2324
|
-
/**
|
|
2325
|
-
* Babylon.js `material.environmentTexture` / `reflectionTexture`. Babylon Lite
|
|
2326
|
-
* applies image-based lighting scene-wide rather than per-material, so a cube
|
|
2327
|
-
* environment assigned to a material is routed to the owning scene's
|
|
2328
|
-
* environment (the dominant single-IBL case Babylon.js scenes use).
|
|
2329
|
-
*/
|
|
2330
|
-
get environmentTexture() {
|
|
2331
|
-
var _a;
|
|
2332
|
-
return this._environmentTexture ?? ((_a = this._scene) == null ? void 0 : _a.environmentTexture) ?? null;
|
|
2333
|
-
}
|
|
2334
|
-
set environmentTexture(value) {
|
|
2335
|
-
this._environmentTexture = value;
|
|
2336
|
-
if (this._scene) {
|
|
2337
|
-
this._scene.environmentTexture = value;
|
|
2338
|
-
}
|
|
2339
|
-
}
|
|
2340
|
-
get reflectionTexture() {
|
|
2341
|
-
return this.environmentTexture;
|
|
2342
|
-
}
|
|
2343
|
-
set reflectionTexture(value) {
|
|
2344
|
-
this.environmentTexture = value;
|
|
2345
|
-
}
|
|
2346
|
-
/** @internal Bind resolved textures and synthesize the solid textures Babylon Lite's PBR pipeline requires from a factor-only material. */
|
|
2347
|
-
_ensureRenderable(engine) {
|
|
2348
|
-
const lite = this._lite;
|
|
2349
|
-
const albedo = this._albedoTexture;
|
|
2350
|
-
if (albedo == null ? void 0 : albedo._lite) {
|
|
2351
|
-
lite.baseColorTexture = albedo._lite;
|
|
2352
|
-
lite.baseColorFactor = [...this._albedoFactor];
|
|
2353
|
-
lite.gammaAlbedo = albedo.gammaSpace ?? true;
|
|
2354
|
-
}
|
|
2355
|
-
if (!lite.baseColorTexture) {
|
|
2356
|
-
const f2 = this._albedoFactor;
|
|
2357
|
-
lite.baseColorTexture = createSolidTexture2D(engine, f2[0], f2[1], f2[2], f2[3]);
|
|
2358
|
-
lite.baseColorFactor = [1, 1, 1, 1];
|
|
2359
|
-
}
|
|
2360
|
-
if (!lite.ormTexture) {
|
|
2361
|
-
const rough = lite.roughnessFactor ?? 1;
|
|
2362
|
-
const metal = lite.metallicFactor ?? 1;
|
|
2363
|
-
lite.ormTexture = createSolidTexture2D(engine, 1, rough, metal);
|
|
2364
|
-
lite.roughnessFactor = 1;
|
|
2365
|
-
lite.metallicFactor = 1;
|
|
2366
|
-
}
|
|
2367
|
-
}
|
|
2368
|
-
/**
|
|
2369
|
-
* Babylon.js `PBRMaterial.clone(name)`. Copies the albedo/metallic/roughness/
|
|
2370
|
-
* emissive state, shares the albedo texture reference, gives the clone independent
|
|
2371
|
-
* clearcoat/sheen/anisotropy/iridescence sub-configurations (sharing any nested
|
|
2372
|
-
* texture), and a fresh Lite PBR renderable.
|
|
2373
|
-
*/
|
|
2374
|
-
clone(name) {
|
|
2375
|
-
const cloned = new PBRMaterial(name, this._scene);
|
|
2376
|
-
this._clonePbrInto(cloned);
|
|
2377
|
-
return cloned;
|
|
2378
|
-
}
|
|
2379
|
-
/**
|
|
2380
|
-
* @internal Copy PBR-specific compat + Lite state onto a freshly constructed PBR
|
|
2381
|
-
* clone (used by every `PBRMaterial` subclass so each returns its own concrete
|
|
2382
|
-
* type). The base `_cloneBaseInto` shares the sub-config objects by reference; this
|
|
2383
|
-
* re-copies them so the clone's `clearCoat`/`sheen`/… mutate independently while
|
|
2384
|
-
* still sharing any nested texture handle.
|
|
2385
|
-
*/
|
|
2386
|
-
_clonePbrInto(target) {
|
|
2387
|
-
this._cloneBaseInto(target);
|
|
2388
|
-
target.forceIrradianceInFragment = this.forceIrradianceInFragment;
|
|
2389
|
-
target._albedoFactor = [...this._albedoFactor];
|
|
2390
|
-
target._albedoTexture = this._albedoTexture;
|
|
2391
|
-
const src = this._lite;
|
|
2392
|
-
const dst = target._lite;
|
|
2393
|
-
if (src.clearCoat) {
|
|
2394
|
-
dst.clearCoat = { ...src.clearCoat };
|
|
2395
|
-
}
|
|
2396
|
-
if (src.sheen) {
|
|
2397
|
-
dst.sheen = { ...src.sheen };
|
|
2398
|
-
}
|
|
2399
|
-
if (src.anisotropy) {
|
|
2400
|
-
dst.anisotropy = { ...src.anisotropy };
|
|
2401
|
-
}
|
|
2402
|
-
if (src.iridescence) {
|
|
2403
|
-
dst.iridescence = { ...src.iridescence };
|
|
2404
|
-
}
|
|
2405
|
-
}
|
|
2406
|
-
}
|
|
2407
|
-
class PBRMetallicRoughnessMaterial extends PBRMaterial {
|
|
2408
|
-
getClassName() {
|
|
2409
|
-
return "PBRMetallicRoughnessMaterial";
|
|
2410
|
-
}
|
|
2411
|
-
/** Alias of `albedoColor` (glTF "base color"). */
|
|
2412
|
-
get baseColor() {
|
|
2413
|
-
return this.albedoColor;
|
|
2414
|
-
}
|
|
2415
|
-
set baseColor(value) {
|
|
2416
|
-
this.albedoColor = value;
|
|
2417
|
-
}
|
|
2418
|
-
clone(name) {
|
|
2419
|
-
const cloned = new PBRMetallicRoughnessMaterial(name, this._scene);
|
|
2420
|
-
this._clonePbrInto(cloned);
|
|
2421
|
-
return cloned;
|
|
2422
|
-
}
|
|
2423
|
-
}
|
|
2424
|
-
class PBRSpecularGlossinessMaterial extends PBRMaterial {
|
|
2425
|
-
getClassName() {
|
|
2426
|
-
return "PBRSpecularGlossinessMaterial";
|
|
2427
|
-
}
|
|
2428
|
-
get diffuseColor() {
|
|
2429
|
-
return this.albedoColor;
|
|
2430
|
-
}
|
|
2431
|
-
set diffuseColor(value) {
|
|
2432
|
-
this.albedoColor = value;
|
|
2433
|
-
}
|
|
2434
|
-
/** Maps glossiness → (1 - roughness). */
|
|
2435
|
-
get glossiness() {
|
|
2436
|
-
return 1 - this.roughness;
|
|
2437
|
-
}
|
|
2438
|
-
set glossiness(value) {
|
|
2439
|
-
this.roughness = 1 - value;
|
|
2440
|
-
}
|
|
2441
|
-
clone(name) {
|
|
2442
|
-
const cloned = new PBRSpecularGlossinessMaterial(name, this._scene);
|
|
2443
|
-
this._clonePbrInto(cloned);
|
|
2444
|
-
return cloned;
|
|
2445
|
-
}
|
|
2446
|
-
}
|
|
2447
1601
|
const AnimationKeyInterpolation = {
|
|
2448
1602
|
NONE: 0,
|
|
2449
1603
|
STEP: 1
|
|
@@ -2472,7 +1626,7 @@ const _Animation = class _Animation {
|
|
|
2472
1626
|
this.loopMode = loopMode;
|
|
2473
1627
|
}
|
|
2474
1628
|
setKeys(keys) {
|
|
2475
|
-
this._keys = keys.slice().sort((a,
|
|
1629
|
+
this._keys = keys.slice().sort((a, b) => a.frame - b.frame);
|
|
2476
1630
|
}
|
|
2477
1631
|
getKeys() {
|
|
2478
1632
|
return this._keys;
|
|
@@ -2494,13 +1648,13 @@ const _Animation = class _Animation {
|
|
|
2494
1648
|
}
|
|
2495
1649
|
for (let i2 = 0; i2 < keys.length - 1; i2++) {
|
|
2496
1650
|
const a = keys[i2];
|
|
2497
|
-
const
|
|
2498
|
-
if (frame >= a.frame && frame <
|
|
1651
|
+
const b = keys[i2 + 1];
|
|
1652
|
+
if (frame >= a.frame && frame < b.frame) {
|
|
2499
1653
|
if (a.interpolation === AnimationKeyInterpolation.STEP) {
|
|
2500
1654
|
return a.value;
|
|
2501
1655
|
}
|
|
2502
|
-
const t2 = (frame - a.frame) / (
|
|
2503
|
-
return lerpValue(a.value,
|
|
1656
|
+
const t2 = (frame - a.frame) / (b.frame - a.frame);
|
|
1657
|
+
return lerpValue(a.value, b.value, t2);
|
|
2504
1658
|
}
|
|
2505
1659
|
}
|
|
2506
1660
|
return keys[keys.length - 1].value;
|
|
@@ -2524,24 +1678,24 @@ __publicField(_Animation, "ANIMATIONLOOPMODE_RELATIVE", AnimationLoopModes.ANIMA
|
|
|
2524
1678
|
__publicField(_Animation, "ANIMATIONLOOPMODE_CYCLE", AnimationLoopModes.ANIMATIONLOOPMODE_CYCLE);
|
|
2525
1679
|
__publicField(_Animation, "ANIMATIONLOOPMODE_CONSTANT", AnimationLoopModes.ANIMATIONLOOPMODE_CONSTANT);
|
|
2526
1680
|
let Animation = _Animation;
|
|
2527
|
-
function lerpValue(a,
|
|
2528
|
-
if (typeof a === "number" && typeof
|
|
2529
|
-
return a + (
|
|
1681
|
+
function lerpValue(a, b, t2) {
|
|
1682
|
+
if (typeof a === "number" && typeof b === "number") {
|
|
1683
|
+
return a + (b - a) * t2;
|
|
2530
1684
|
}
|
|
2531
1685
|
const av = a;
|
|
2532
|
-
const bv =
|
|
1686
|
+
const bv = b;
|
|
2533
1687
|
return av.map((value, i2) => value + ((bv[i2] ?? value) - value) * t2);
|
|
2534
1688
|
}
|
|
2535
1689
|
function scaleValue(value, scale) {
|
|
2536
|
-
return typeof value === "number" ? value * scale : value.map((
|
|
1690
|
+
return typeof value === "number" ? value * scale : value.map((v2) => v2 * scale);
|
|
2537
1691
|
}
|
|
2538
1692
|
function addValue(acc, value) {
|
|
2539
1693
|
if (typeof acc === "number" && typeof value === "number") {
|
|
2540
1694
|
return acc + value;
|
|
2541
1695
|
}
|
|
2542
1696
|
const a = acc;
|
|
2543
|
-
const
|
|
2544
|
-
return a.map((
|
|
1697
|
+
const v2 = value;
|
|
1698
|
+
return a.map((x2, i2) => x2 + (v2[i2] ?? 0));
|
|
2545
1699
|
}
|
|
2546
1700
|
function zeroLike(value) {
|
|
2547
1701
|
return typeof value === "number" ? 0 : value.map(() => 0);
|
|
@@ -4276,7 +3430,7 @@ class GaussianSplattingMesh extends TransformNode {
|
|
|
4276
3430
|
}
|
|
4277
3431
|
/** @internal Babylon.js's worker-throttle flag; ported scenes poll it to detect the first sort. */
|
|
4278
3432
|
get _canPostToWorker() {
|
|
4279
|
-
return this._gs ? this._gs.
|
|
3433
|
+
return this._gs ? this._gs._orderPool.length === 2 : false;
|
|
4280
3434
|
}
|
|
4281
3435
|
/** @internal The loaded Lite splat node, for the GPU picker's result mapping (undefined until loaded). */
|
|
4282
3436
|
get _pickLiteNode() {
|
|
@@ -4571,7 +3725,7 @@ class DynamicTexture extends BaseTexture {
|
|
|
4571
3725
|
return { width: this._width, height: this._height };
|
|
4572
3726
|
}
|
|
4573
3727
|
/** Draw `text` and refresh the GPU texture. */
|
|
4574
|
-
drawText(text,
|
|
3728
|
+
drawText(text, x2, y2, font, color, clearColor) {
|
|
4575
3729
|
const ctx = this._context;
|
|
4576
3730
|
if (clearColor) {
|
|
4577
3731
|
ctx.fillStyle = clearColor;
|
|
@@ -4579,7 +3733,7 @@ class DynamicTexture extends BaseTexture {
|
|
|
4579
3733
|
}
|
|
4580
3734
|
ctx.font = font;
|
|
4581
3735
|
ctx.fillStyle = color;
|
|
4582
|
-
ctx.fillText(text,
|
|
3736
|
+
ctx.fillText(text, x2, y2);
|
|
4583
3737
|
this.update();
|
|
4584
3738
|
}
|
|
4585
3739
|
/**
|
|
@@ -4595,13 +3749,13 @@ class DynamicTexture extends BaseTexture {
|
|
|
4595
3749
|
return Promise.resolve();
|
|
4596
3750
|
}
|
|
4597
3751
|
}
|
|
4598
|
-
class CubeTexture {
|
|
3752
|
+
class CubeTexture extends BaseTexture {
|
|
4599
3753
|
constructor(url, _scene, _extensions, _noMipmap, _files, onLoad, _onError, _format, _prefiltered) {
|
|
3754
|
+
super();
|
|
4600
3755
|
/** Source URL of the (prefiltered) environment. */
|
|
4601
3756
|
__publicField(this, "url");
|
|
4602
3757
|
/** Babylon.js `coordinatesMode` (skybox = 5). Recorded for API parity. */
|
|
4603
3758
|
__publicField(this, "coordinatesMode", 0);
|
|
4604
|
-
__publicField(this, "name");
|
|
4605
3759
|
__publicField(this, "gammaSpace", true);
|
|
4606
3760
|
__publicField(this, "level", 1);
|
|
4607
3761
|
/**
|
|
@@ -4614,20 +3768,30 @@ class CubeTexture {
|
|
|
4614
3768
|
/** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
|
|
4615
3769
|
__publicField(this, "onLoadObservable", new Observable());
|
|
4616
3770
|
__publicField(this, "_ready", false);
|
|
3771
|
+
__publicField(this, "_readyPromise");
|
|
4617
3772
|
this.url = url;
|
|
4618
3773
|
this.name = url;
|
|
4619
|
-
|
|
4620
|
-
|
|
4621
|
-
|
|
4622
|
-
onLoad
|
|
4623
|
-
|
|
4624
|
-
|
|
3774
|
+
this._readyPromise = new Promise((resolve) => {
|
|
3775
|
+
queueMicrotask(() => {
|
|
3776
|
+
this._ready = true;
|
|
3777
|
+
if (onLoad) {
|
|
3778
|
+
onLoad();
|
|
3779
|
+
}
|
|
3780
|
+
this.onLoadObservable.notifyObservers(this);
|
|
3781
|
+
resolve();
|
|
3782
|
+
});
|
|
4625
3783
|
});
|
|
4626
3784
|
}
|
|
3785
|
+
getClassName() {
|
|
3786
|
+
return "CubeTexture";
|
|
3787
|
+
}
|
|
4627
3788
|
/** Babylon.js `BaseTexture.isReady()`. */
|
|
4628
3789
|
isReady() {
|
|
4629
3790
|
return this._ready;
|
|
4630
3791
|
}
|
|
3792
|
+
whenReadyAsync() {
|
|
3793
|
+
return this._readyPromise;
|
|
3794
|
+
}
|
|
4631
3795
|
/** Babylon.js `CubeTexture.CreateFromPrefilteredData(url, scene)`. */
|
|
4632
3796
|
static CreateFromPrefilteredData(url, scene) {
|
|
4633
3797
|
return new CubeTexture(url, scene);
|
|
@@ -4635,15 +3799,15 @@ class CubeTexture {
|
|
|
4635
3799
|
dispose() {
|
|
4636
3800
|
}
|
|
4637
3801
|
}
|
|
4638
|
-
class HDRCubeTexture {
|
|
3802
|
+
class HDRCubeTexture extends BaseTexture {
|
|
4639
3803
|
constructor(url, _sceneOrEngine, size = 256, _noMipmap, _generateHarmonics, _gammaSpace, _prefilterOnLoad, onLoad) {
|
|
3804
|
+
super();
|
|
4640
3805
|
/** Source URL of the `.hdr` panorama. */
|
|
4641
3806
|
__publicField(this, "url");
|
|
4642
3807
|
/** Requested cubemap face size (BJS `size`); forwarded to Lite's `faceSize`. */
|
|
4643
3808
|
__publicField(this, "size");
|
|
4644
3809
|
/** Babylon.js `coordinatesMode` (skybox = 5). Recorded for API parity. */
|
|
4645
3810
|
__publicField(this, "coordinatesMode", 0);
|
|
4646
|
-
__publicField(this, "name");
|
|
4647
3811
|
__publicField(this, "gammaSpace", true);
|
|
4648
3812
|
__publicField(this, "level", 1);
|
|
4649
3813
|
/** @internal Selects Lite's `loadHdrEnvironment` in the scene's env loader. */
|
|
@@ -4651,21 +3815,31 @@ class HDRCubeTexture {
|
|
|
4651
3815
|
/** Fires when the HDR environment is "ready" (resolved on a microtask). */
|
|
4652
3816
|
__publicField(this, "onLoadObservable", new Observable());
|
|
4653
3817
|
__publicField(this, "_ready", false);
|
|
3818
|
+
__publicField(this, "_readyPromise");
|
|
4654
3819
|
this.url = url;
|
|
4655
3820
|
this.size = size;
|
|
4656
3821
|
this.name = url;
|
|
4657
|
-
|
|
4658
|
-
|
|
4659
|
-
|
|
4660
|
-
onLoad
|
|
4661
|
-
|
|
4662
|
-
|
|
3822
|
+
this._readyPromise = new Promise((resolve) => {
|
|
3823
|
+
queueMicrotask(() => {
|
|
3824
|
+
this._ready = true;
|
|
3825
|
+
if (onLoad) {
|
|
3826
|
+
onLoad();
|
|
3827
|
+
}
|
|
3828
|
+
this.onLoadObservable.notifyObservers(this);
|
|
3829
|
+
resolve();
|
|
3830
|
+
});
|
|
4663
3831
|
});
|
|
4664
3832
|
}
|
|
3833
|
+
getClassName() {
|
|
3834
|
+
return "HDRCubeTexture";
|
|
3835
|
+
}
|
|
4665
3836
|
/** Babylon.js `BaseTexture.isReady()`. */
|
|
4666
3837
|
isReady() {
|
|
4667
3838
|
return this._ready;
|
|
4668
3839
|
}
|
|
3840
|
+
whenReadyAsync() {
|
|
3841
|
+
return this._readyPromise;
|
|
3842
|
+
}
|
|
4669
3843
|
dispose() {
|
|
4670
3844
|
}
|
|
4671
3845
|
}
|
|
@@ -5190,13 +4364,13 @@ class GPUPicker {
|
|
|
5190
4364
|
this._pickable = /* @__PURE__ */ new Set();
|
|
5191
4365
|
}
|
|
5192
4366
|
/** Pick the mesh at canvas coordinates `(x, y)`. Resolves to `null` on a miss. */
|
|
5193
|
-
async pickAsync(
|
|
4367
|
+
async pickAsync(x2, y2, disposeWhenDone = false) {
|
|
5194
4368
|
if (this._inProgress || !this._picker || this._liteToCompat.size === 0) {
|
|
5195
4369
|
return null;
|
|
5196
4370
|
}
|
|
5197
4371
|
this._inProgress = true;
|
|
5198
4372
|
try {
|
|
5199
|
-
const info = await pickAsync(this._picker,
|
|
4373
|
+
const info = await pickAsync(this._picker, x2, y2, { filter: (mesh2) => this._pickable.has(mesh2) });
|
|
5200
4374
|
if (!info.hit || !info.pickedMesh) {
|
|
5201
4375
|
return null;
|
|
5202
4376
|
}
|
|
@@ -5467,8 +4641,8 @@ class LightGizmo {
|
|
|
5467
4641
|
get position() {
|
|
5468
4642
|
return root.position;
|
|
5469
4643
|
},
|
|
5470
|
-
set position(
|
|
5471
|
-
root.position.set(
|
|
4644
|
+
set position(v2) {
|
|
4645
|
+
root.position.set(v2.x, v2.y, v2.z);
|
|
5472
4646
|
}
|
|
5473
4647
|
};
|
|
5474
4648
|
}
|
|
@@ -6032,8 +5206,8 @@ class SpriteRenderer {
|
|
|
6032
5206
|
const canvasHeight = this._engine.getRenderingCanvas().height;
|
|
6033
5207
|
if (!this._built) {
|
|
6034
5208
|
const layer2 = createSprite2DLayer(this._atlas, { capacity: this._capacity, depth: "none", blendMode: this._blend() });
|
|
6035
|
-
for (const
|
|
6036
|
-
this._indices.push(addSprite2DIndex(layer2, this._spriteProps(
|
|
5209
|
+
for (const s2 of this._sprites) {
|
|
5210
|
+
this._indices.push(addSprite2DIndex(layer2, this._spriteProps(s2, canvasHeight)));
|
|
6037
5211
|
}
|
|
6038
5212
|
this._layer = layer2;
|
|
6039
5213
|
const renderer = createSpriteRenderer(this._engine._lite, {
|
|
@@ -6055,16 +5229,16 @@ class SpriteRenderer {
|
|
|
6055
5229
|
}
|
|
6056
5230
|
}
|
|
6057
5231
|
/** @internal Convert a BJS `ThinSprite` to Lite `Sprite2DProps` (Y-flip + rotation negate). */
|
|
6058
|
-
_spriteProps(
|
|
5232
|
+
_spriteProps(s2, canvasHeight) {
|
|
6059
5233
|
return {
|
|
6060
|
-
positionPx: [
|
|
6061
|
-
sizePx: [
|
|
6062
|
-
frame:
|
|
6063
|
-
rotation: -
|
|
6064
|
-
color: [
|
|
6065
|
-
flipX:
|
|
6066
|
-
flipY:
|
|
6067
|
-
visible:
|
|
5234
|
+
positionPx: [s2.position.x, canvasHeight - s2.position.y],
|
|
5235
|
+
sizePx: [s2.width, s2.height],
|
|
5236
|
+
frame: s2.cellIndex,
|
|
5237
|
+
rotation: -s2.angle,
|
|
5238
|
+
color: [s2.color.r, s2.color.g, s2.color.b, s2.color.a],
|
|
5239
|
+
flipX: s2.invertU,
|
|
5240
|
+
flipY: s2.invertV,
|
|
5241
|
+
visible: s2.isVisible
|
|
6068
5242
|
};
|
|
6069
5243
|
}
|
|
6070
5244
|
}
|
|
@@ -6523,8 +5697,8 @@ const Tools = {
|
|
|
6523
5697
|
RandomId() {
|
|
6524
5698
|
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c2) => {
|
|
6525
5699
|
const r2 = Math.random() * 16 | 0;
|
|
6526
|
-
const
|
|
6527
|
-
return
|
|
5700
|
+
const v2 = c2 === "x" ? r2 : r2 & 3 | 8;
|
|
5701
|
+
return v2.toString(16);
|
|
6528
5702
|
});
|
|
6529
5703
|
}
|
|
6530
5704
|
};
|
|
@@ -7857,14 +7031,6 @@ class ClusteredLightContainer {
|
|
|
7857
7031
|
unsupported("ClusteredLightContainer", "Clustered lighting is not exposed by the Babylon Lite public API; the compat layer cannot wrap it.");
|
|
7858
7032
|
}
|
|
7859
7033
|
}
|
|
7860
|
-
class ParticleSystem {
|
|
7861
|
-
constructor() {
|
|
7862
|
-
unsupported(
|
|
7863
|
-
"ParticleSystem",
|
|
7864
|
-
"Babylon Lite backs serialized Node Particle Editor graphs via `NodeParticleSystemSet` (`Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`), not the imperative classic `ParticleSystem` construction API (emitters, over-lifetime gradients, `minEmitBox`)."
|
|
7865
|
-
);
|
|
7866
|
-
}
|
|
7867
|
-
}
|
|
7868
7034
|
class GPUParticleSystem {
|
|
7869
7035
|
constructor() {
|
|
7870
7036
|
unsupported(
|
|
@@ -7891,11 +7057,6 @@ class GlowLayer {
|
|
|
7891
7057
|
unsupported("GlowLayer", "Effect layers are not implemented in Babylon Lite. For a bloom-style glow, use the native bloom post-process task.");
|
|
7892
7058
|
}
|
|
7893
7059
|
}
|
|
7894
|
-
class LinesMesh {
|
|
7895
|
-
constructor() {
|
|
7896
|
-
unsupported("LinesMesh", "Line meshes are not implemented in Babylon Lite.");
|
|
7897
|
-
}
|
|
7898
|
-
}
|
|
7899
7060
|
class GreasedLineMesh {
|
|
7900
7061
|
constructor() {
|
|
7901
7062
|
unsupported("GreasedLineMesh", "Greased-line meshes are not implemented in Babylon Lite.");
|
|
@@ -8194,6 +7355,162 @@ class SceneOptimizer {
|
|
|
8194
7355
|
unsupported("SceneOptimizer", "Automatic scene optimisation is not implemented in the compat layer.");
|
|
8195
7356
|
}
|
|
8196
7357
|
}
|
|
7358
|
+
class ParticleSystem {
|
|
7359
|
+
/**
|
|
7360
|
+
* Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
|
|
7361
|
+
* construction API (emitters, over-lifetime gradients, `minEmitBox`, a
|
|
7362
|
+
* GPU-compute path) is not backed: Babylon Lite builds particle systems only
|
|
7363
|
+
* from a serialized Node Particle Editor graph. Load a graph via
|
|
7364
|
+
* `NodeParticleSystemSet.Parse` / `ParseFromSnippetAsync` → `buildAsync` and read
|
|
7365
|
+
* its {@link ParticleSystemSet.systems} instead.
|
|
7366
|
+
*/
|
|
7367
|
+
constructor() {
|
|
7368
|
+
__publicField(this, "name", "");
|
|
7369
|
+
/** @internal The backing Lite particle system (null on a bare, unbuilt instance). */
|
|
7370
|
+
__publicField(this, "_lite", null);
|
|
7371
|
+
/** @internal The compat scene this system was built against. */
|
|
7372
|
+
__publicField(this, "_scene", null);
|
|
7373
|
+
/**
|
|
7374
|
+
* Babylon.js `ParticleSystem.preWarmStepOffset` — the step ratio applied during
|
|
7375
|
+
* prewarm cycles. Multiplies {@link updateSpeed} on every `animate(true)` call,
|
|
7376
|
+
* matching Babylon.js (which uses `updateSpeed * preWarmStepOffset` while
|
|
7377
|
+
* prewarming and the regular animation ratio otherwise).
|
|
7378
|
+
*/
|
|
7379
|
+
__publicField(this, "preWarmStepOffset", 1);
|
|
7380
|
+
__publicField(this, "_texture", null);
|
|
7381
|
+
__publicField(this, "_billboardScheduled", false);
|
|
7382
|
+
__publicField(this, "_billboardOwnedBySet", false);
|
|
7383
|
+
unsupported(
|
|
7384
|
+
"ParticleSystem",
|
|
7385
|
+
"Babylon Lite builds particle systems only from a serialized Node Particle Editor graph, not the imperative classic `ParticleSystem` construction API (emitters, over-lifetime gradients, `minEmitBox`). Use `NodeParticleSystemSet.Parse`/`ParseFromSnippetAsync` → `buildAsync` and drive `set.systems[i]`."
|
|
7386
|
+
);
|
|
7387
|
+
}
|
|
7388
|
+
/**
|
|
7389
|
+
* @internal Build a `ParticleSystem` backed by a Lite `ParticleSystem` produced
|
|
7390
|
+
* by an NPE graph build. Bypasses the throwing public constructor.
|
|
7391
|
+
*/
|
|
7392
|
+
static _fromLite(lite, scene) {
|
|
7393
|
+
const system = Object.create(ParticleSystem.prototype);
|
|
7394
|
+
system.name = "";
|
|
7395
|
+
system._lite = lite;
|
|
7396
|
+
system._scene = scene;
|
|
7397
|
+
system.preWarmStepOffset = 1;
|
|
7398
|
+
system._texture = null;
|
|
7399
|
+
system._billboardScheduled = false;
|
|
7400
|
+
system._billboardOwnedBySet = false;
|
|
7401
|
+
return system;
|
|
7402
|
+
}
|
|
7403
|
+
getClassName() {
|
|
7404
|
+
return "ParticleSystem";
|
|
7405
|
+
}
|
|
7406
|
+
/** Babylon.js `ParticleSystem.updateSpeed` — simulation advance per frame. Proxies the Lite system. */
|
|
7407
|
+
get updateSpeed() {
|
|
7408
|
+
var _a;
|
|
7409
|
+
return ((_a = this._lite) == null ? void 0 : _a.updateSpeed) ?? 0;
|
|
7410
|
+
}
|
|
7411
|
+
set updateSpeed(value) {
|
|
7412
|
+
if (this._lite) {
|
|
7413
|
+
this._lite.updateSpeed = value;
|
|
7414
|
+
}
|
|
7415
|
+
}
|
|
7416
|
+
/**
|
|
7417
|
+
* Babylon.js `ParticleSystem.particleTexture` — the sprite texture. Recorded and
|
|
7418
|
+
* bound onto the Lite system when the billboard is built at engine start (the
|
|
7419
|
+
* compat `Texture` loads asynchronously, so its GPU handle is read after the
|
|
7420
|
+
* scene's pending texture loads settle).
|
|
7421
|
+
*/
|
|
7422
|
+
get particleTexture() {
|
|
7423
|
+
return this._texture;
|
|
7424
|
+
}
|
|
7425
|
+
set particleTexture(value) {
|
|
7426
|
+
this._texture = value;
|
|
7427
|
+
}
|
|
7428
|
+
/**
|
|
7429
|
+
* Babylon.js `ParticleSystem.start()` — begin emission. Forwards to Lite
|
|
7430
|
+
* `startParticleSystem` (which clears the stopped flag and resets the frame
|
|
7431
|
+
* counter, so `start()` → `stop()` → `start()` resumes emission) and schedules
|
|
7432
|
+
* the camera-facing billboard build for engine start. The billboard build is
|
|
7433
|
+
* separately guarded, so it happens exactly once however often `start()` runs.
|
|
7434
|
+
*/
|
|
7435
|
+
start() {
|
|
7436
|
+
if (!this._lite) {
|
|
7437
|
+
return;
|
|
7438
|
+
}
|
|
7439
|
+
startParticleSystem(this._lite);
|
|
7440
|
+
this._scheduleBillboard();
|
|
7441
|
+
}
|
|
7442
|
+
/**
|
|
7443
|
+
* Babylon.js `ParticleSystem.animate(preWarmOnly?)` — advance the simulation by
|
|
7444
|
+
* one deterministic step. Forwards to Lite `animateParticleSystem` with Babylon.js's
|
|
7445
|
+
* step ratio: {@link preWarmStepOffset} while prewarming, otherwise the ratio `1`
|
|
7446
|
+
* used by the parity ports' seeded step loop.
|
|
7447
|
+
*/
|
|
7448
|
+
animate(preWarmOnly = false) {
|
|
7449
|
+
if (this._lite) {
|
|
7450
|
+
animateParticleSystem(this._lite, preWarmOnly ? this.preWarmStepOffset : 1);
|
|
7451
|
+
}
|
|
7452
|
+
}
|
|
7453
|
+
/** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
|
|
7454
|
+
stop() {
|
|
7455
|
+
if (this._lite) {
|
|
7456
|
+
stopParticleSystem(this._lite);
|
|
7457
|
+
}
|
|
7458
|
+
}
|
|
7459
|
+
/** Babylon.js `ParticleSystem.dispose()` — stop the system. */
|
|
7460
|
+
dispose() {
|
|
7461
|
+
this.stop();
|
|
7462
|
+
}
|
|
7463
|
+
/**
|
|
7464
|
+
* @internal Bind the recorded {@link particleTexture}'s GPU handle onto the backing
|
|
7465
|
+
* Lite system. Called from the deferred per-system billboard build and from
|
|
7466
|
+
* {@link ParticleSystemSet.start} before set-level registration, so a
|
|
7467
|
+
* wrapper-assigned texture wins over whatever the graph baked in. A no-op while
|
|
7468
|
+
* the compat `Texture` is still loading (callers run after the scene's pending
|
|
7469
|
+
* texture loads settle).
|
|
7470
|
+
*/
|
|
7471
|
+
_bindTexture() {
|
|
7472
|
+
var _a;
|
|
7473
|
+
const liteTexture = (_a = this._texture) == null ? void 0 : _a._lite;
|
|
7474
|
+
if (this._lite && liteTexture) {
|
|
7475
|
+
this._lite.texture = liteTexture;
|
|
7476
|
+
}
|
|
7477
|
+
}
|
|
7478
|
+
/**
|
|
7479
|
+
* @internal Hand billboard rendering to the owning {@link ParticleSystemSet}: Lite's
|
|
7480
|
+
* `registerNodeParticleSet` builds and per-frame syncs a billboard for every system
|
|
7481
|
+
* in the set, so this wrapper's one-shot build must be skipped to avoid rendering
|
|
7482
|
+
* the same particles twice.
|
|
7483
|
+
*/
|
|
7484
|
+
_releaseBillboardToSet() {
|
|
7485
|
+
this._billboardOwnedBySet = true;
|
|
7486
|
+
}
|
|
7487
|
+
/**
|
|
7488
|
+
* Schedule the one-time billboard build. Deferred to engine start (via the
|
|
7489
|
+
* scene's `_deferAdd`, which runs after pending texture loads settle), so the
|
|
7490
|
+
* particle system is already prewarmed/frozen and its texture GPU handle is
|
|
7491
|
+
* ready. Mirrors the native Lite port's build → sync → add sequence.
|
|
7492
|
+
*/
|
|
7493
|
+
_scheduleBillboard() {
|
|
7494
|
+
if (this._billboardScheduled || !this._scene || !this._lite) {
|
|
7495
|
+
return;
|
|
7496
|
+
}
|
|
7497
|
+
this._billboardScheduled = true;
|
|
7498
|
+
const scene = this._scene;
|
|
7499
|
+
const lite = this._lite;
|
|
7500
|
+
scene._deferAdd(() => {
|
|
7501
|
+
if (this._billboardOwnedBySet) {
|
|
7502
|
+
return;
|
|
7503
|
+
}
|
|
7504
|
+
this._bindTexture();
|
|
7505
|
+
if (!lite.texture) {
|
|
7506
|
+
return;
|
|
7507
|
+
}
|
|
7508
|
+
const billboard = createParticleBillboard(lite);
|
|
7509
|
+
syncParticleBillboard(lite, billboard);
|
|
7510
|
+
addFacingBillboardSystem(scene._lite, billboard);
|
|
7511
|
+
});
|
|
7512
|
+
}
|
|
7513
|
+
}
|
|
8197
7514
|
class ParticleSystemSet {
|
|
8198
7515
|
constructor() {
|
|
8199
7516
|
/** @internal The built Lite node-particle set (null for a directly-constructed empty set). */
|
|
@@ -8201,33 +7518,63 @@ class ParticleSystemSet {
|
|
|
8201
7518
|
/** @internal The compat scene the set was built against (set by `buildAsync`). */
|
|
8202
7519
|
__publicField(this, "_scene", null);
|
|
8203
7520
|
__publicField(this, "_started", false);
|
|
7521
|
+
/** @internal Cached per-system wrappers (stable identity across `systems` reads). */
|
|
7522
|
+
__publicField(this, "_systems", null);
|
|
8204
7523
|
}
|
|
8205
7524
|
getClassName() {
|
|
8206
7525
|
return "ParticleSystemSet";
|
|
8207
7526
|
}
|
|
8208
7527
|
/**
|
|
8209
|
-
* Babylon.js `ParticleSystemSet.systems` — the
|
|
8210
|
-
*
|
|
8211
|
-
*
|
|
8212
|
-
*
|
|
7528
|
+
* Babylon.js `ParticleSystemSet.systems` — the per-system {@link ParticleSystem}
|
|
7529
|
+
* handles. Each wraps one Lite `NodeParticleSet.systems[i]`, exposing the
|
|
7530
|
+
* runtime subset Lite backs (`start` / `animate` / `stop` / `updateSpeed` /
|
|
7531
|
+
* `particleTexture`). An empty (directly-constructed) set has no systems.
|
|
8213
7532
|
*/
|
|
8214
7533
|
get systems() {
|
|
8215
|
-
|
|
8216
|
-
|
|
8217
|
-
|
|
8218
|
-
)
|
|
7534
|
+
if (!this._lite || !this._scene) {
|
|
7535
|
+
return [];
|
|
7536
|
+
}
|
|
7537
|
+
if (!this._systems) {
|
|
7538
|
+
const scene = this._scene;
|
|
7539
|
+
this._systems = this._lite.systems.map((s2) => {
|
|
7540
|
+
const system = ParticleSystem._fromLite(s2, scene);
|
|
7541
|
+
if (this._started) {
|
|
7542
|
+
system._releaseBillboardToSet();
|
|
7543
|
+
}
|
|
7544
|
+
return system;
|
|
7545
|
+
});
|
|
7546
|
+
}
|
|
7547
|
+
return this._systems;
|
|
8219
7548
|
}
|
|
8220
7549
|
/**
|
|
8221
7550
|
* Babylon.js `ParticleSystemSet.start()` — begin all systems. Forwards to Lite
|
|
8222
7551
|
* `registerNodeParticleSet`, which renders each system as a camera-facing
|
|
8223
7552
|
* billboard and advances it once per frame. Idempotent.
|
|
7553
|
+
*
|
|
7554
|
+
* Per-system wrapper state (`systems[i].particleTexture`) is pushed onto the
|
|
7555
|
+
* backing Lite systems first, so the standard
|
|
7556
|
+
* `set.systems[i].particleTexture = texture; set.start()` sequence renders with
|
|
7557
|
+
* the assigned texture rather than the graph's. Registration is deferred to
|
|
7558
|
+
* engine start (`scene._deferAdd`, which runs after the scene's pending texture
|
|
7559
|
+
* loads settle) because a compat `Texture` resolves its GPU handle
|
|
7560
|
+
* asynchronously and Lite's billboard build needs it.
|
|
8224
7561
|
*/
|
|
8225
7562
|
start() {
|
|
8226
7563
|
if (this._started || !this._lite || !this._scene) {
|
|
8227
7564
|
return;
|
|
8228
7565
|
}
|
|
8229
7566
|
this._started = true;
|
|
8230
|
-
|
|
7567
|
+
const scene = this._scene;
|
|
7568
|
+
const lite = this._lite;
|
|
7569
|
+
for (const system of this._systems ?? []) {
|
|
7570
|
+
system._releaseBillboardToSet();
|
|
7571
|
+
}
|
|
7572
|
+
scene._deferAdd(() => {
|
|
7573
|
+
for (const system of this._systems ?? []) {
|
|
7574
|
+
system._bindTexture();
|
|
7575
|
+
}
|
|
7576
|
+
registerNodeParticleSet(scene._lite, lite, { autoStart: true });
|
|
7577
|
+
});
|
|
8231
7578
|
}
|
|
8232
7579
|
/**
|
|
8233
7580
|
* Babylon.js `ParticleSystemSet.dispose()` — stop the systems. Lite exposes no
|
|
@@ -8381,8 +7728,8 @@ export {
|
|
|
8381
7728
|
B as BoundingBox,
|
|
8382
7729
|
BoundingBoxGizmo,
|
|
8383
7730
|
BoundingBoxRenderer,
|
|
8384
|
-
|
|
8385
|
-
|
|
7731
|
+
c as BoundingInfo,
|
|
7732
|
+
d as BoundingSphere,
|
|
8386
7733
|
CSG,
|
|
8387
7734
|
CSG2,
|
|
8388
7735
|
Camera,
|
|
@@ -8400,23 +7747,25 @@ export {
|
|
|
8400
7747
|
Constants,
|
|
8401
7748
|
CreateAudioBusAsync,
|
|
8402
7749
|
CreateAudioEngineAsync,
|
|
8403
|
-
|
|
8404
|
-
|
|
8405
|
-
|
|
8406
|
-
|
|
7750
|
+
e as CreateBox,
|
|
7751
|
+
f as CreateCylinder,
|
|
7752
|
+
g as CreateDisc,
|
|
7753
|
+
h as CreateGround,
|
|
7754
|
+
i as CreateLineSystem,
|
|
7755
|
+
j as CreateLines,
|
|
8407
7756
|
CreateMainAudioBusAsync,
|
|
8408
7757
|
CreateMicrophoneSoundSourceAsync,
|
|
8409
|
-
|
|
7758
|
+
k as CreatePlane,
|
|
8410
7759
|
CreateSoundAsync,
|
|
8411
7760
|
CreateSoundBufferAsync,
|
|
8412
7761
|
CreateSoundSourceAsync,
|
|
8413
|
-
|
|
7762
|
+
m as CreateSphere,
|
|
8414
7763
|
CreateStreamingSoundAsync,
|
|
8415
7764
|
CreateTexture2DArrayFromImageUrlsAsync,
|
|
8416
7765
|
CreateTexture2DArrayFromKTX2Async,
|
|
8417
|
-
|
|
8418
|
-
|
|
8419
|
-
|
|
7766
|
+
n as CreateTiledBox,
|
|
7767
|
+
o as CreateTiledPlane,
|
|
7768
|
+
p as CreateTorus,
|
|
8420
7769
|
CubeTexture,
|
|
8421
7770
|
CubicEase,
|
|
8422
7771
|
Curve3,
|
|
@@ -8483,16 +7832,16 @@ export {
|
|
|
8483
7832
|
Layer,
|
|
8484
7833
|
Light,
|
|
8485
7834
|
LightGizmo,
|
|
8486
|
-
LinesMesh,
|
|
7835
|
+
q as LinesMesh,
|
|
8487
7836
|
LiteCompatError,
|
|
8488
7837
|
LoadAssetContainerAsync,
|
|
8489
7838
|
LoadImageToTexture2DArrayLayerAsync,
|
|
8490
7839
|
Logger,
|
|
8491
7840
|
MainAudioBus,
|
|
8492
|
-
Material,
|
|
7841
|
+
r as Material,
|
|
8493
7842
|
Matrix,
|
|
8494
7843
|
Mesh,
|
|
8495
|
-
|
|
7844
|
+
s as MeshBuilder,
|
|
8496
7845
|
MeshoptCompression,
|
|
8497
7846
|
MirrorTexture,
|
|
8498
7847
|
MorphTarget,
|
|
@@ -8507,13 +7856,13 @@ export {
|
|
|
8507
7856
|
Observable,
|
|
8508
7857
|
OnAudioEngineV2CreatedObservable,
|
|
8509
7858
|
OutlineRenderer,
|
|
8510
|
-
PBRAnisotropicConfiguration,
|
|
8511
|
-
PBRClearCoatConfiguration,
|
|
8512
|
-
PBRIridescenceConfiguration,
|
|
8513
|
-
PBRMaterial,
|
|
8514
|
-
PBRMetallicRoughnessMaterial,
|
|
8515
|
-
PBRSheenConfiguration,
|
|
8516
|
-
PBRSpecularGlossinessMaterial,
|
|
7859
|
+
P as PBRAnisotropicConfiguration,
|
|
7860
|
+
t as PBRClearCoatConfiguration,
|
|
7861
|
+
v as PBRIridescenceConfiguration,
|
|
7862
|
+
w as PBRMaterial,
|
|
7863
|
+
x as PBRMetallicRoughnessMaterial,
|
|
7864
|
+
y as PBRSheenConfiguration,
|
|
7865
|
+
z as PBRSpecularGlossinessMaterial,
|
|
8517
7866
|
ParticleHelper,
|
|
8518
7867
|
ParticleSystem,
|
|
8519
7868
|
ParticleSystemSet,
|
|
@@ -8537,7 +7886,7 @@ export {
|
|
|
8537
7886
|
PostProcess,
|
|
8538
7887
|
PrecisionDate,
|
|
8539
7888
|
PredicateCondition,
|
|
8540
|
-
PushMaterial,
|
|
7889
|
+
D as PushMaterial,
|
|
8541
7890
|
QuadraticEase,
|
|
8542
7891
|
QuarticEase,
|
|
8543
7892
|
Quaternion,
|
|
@@ -8604,18 +7953,18 @@ export {
|
|
|
8604
7953
|
UtilityLayerRenderer,
|
|
8605
7954
|
ValueCondition,
|
|
8606
7955
|
ValueConditionOperators,
|
|
8607
|
-
|
|
7956
|
+
E as Vector2,
|
|
8608
7957
|
Vector3,
|
|
8609
|
-
|
|
8610
|
-
|
|
8611
|
-
|
|
7958
|
+
F as Vector4,
|
|
7959
|
+
H as VertexBuffer,
|
|
7960
|
+
J as VertexData,
|
|
8612
7961
|
Viewport,
|
|
8613
7962
|
VirtualJoystick,
|
|
8614
7963
|
WebGPUEngine,
|
|
8615
7964
|
WebXRCamera,
|
|
8616
7965
|
WeightedSound,
|
|
8617
|
-
|
|
8618
|
-
|
|
7966
|
+
K as transformCoordinates,
|
|
7967
|
+
O as transformNormal,
|
|
8619
7968
|
unsupported
|
|
8620
7969
|
};
|
|
8621
7970
|
//# sourceMappingURL=index.js.map
|