|
|
@@ -11874,7 +11874,7 @@ var BABYLON;
|
|
|
}
|
|
|
// Create Audio Engine if needed.
|
|
|
if (!Engine.audioEngine && options.audioEngine && Engine.AudioEngineFactory) {
|
|
|
- Engine.audioEngine = Engine.AudioEngineFactory();
|
|
|
+ Engine.audioEngine = Engine.AudioEngineFactory(this);
|
|
|
}
|
|
|
// Prepare buffer pointers
|
|
|
for (var i = 0; i < this._caps.maxVertexAttribs; i++) {
|
|
|
@@ -24578,7 +24578,7 @@ var BABYLON;
|
|
|
_this._alternateViewUpdateFlag = -1;
|
|
|
_this._alternateProjectionUpdateFlag = -1;
|
|
|
/** @hidden */
|
|
|
- _this._toBeDisposed = new BABYLON.SmartArray(256);
|
|
|
+ _this._toBeDisposed = new Array(256);
|
|
|
_this._activeRequests = new Array();
|
|
|
_this._pendingData = new Array();
|
|
|
_this._isDisposed = false;
|
|
|
@@ -28065,13 +28065,15 @@ var BABYLON;
|
|
|
}
|
|
|
this.onAfterRenderObservable.notifyObservers(this);
|
|
|
// Cleaning
|
|
|
- for (var index = 0; index < this._toBeDisposed.length; index++) {
|
|
|
- var data = this._toBeDisposed.data[index];
|
|
|
- if (data) {
|
|
|
- data.dispose();
|
|
|
+ if (this._toBeDisposed.length) {
|
|
|
+ for (var index = 0; index < this._toBeDisposed.length; index++) {
|
|
|
+ var data = this._toBeDisposed[index];
|
|
|
+ if (data) {
|
|
|
+ data.dispose();
|
|
|
+ }
|
|
|
}
|
|
|
+ this._toBeDisposed = [];
|
|
|
}
|
|
|
- this._toBeDisposed.reset();
|
|
|
if (this.dumpNextRenderTargets) {
|
|
|
this.dumpNextRenderTargets = false;
|
|
|
}
|
|
|
@@ -28146,7 +28148,7 @@ var BABYLON;
|
|
|
this._renderTargets.dispose();
|
|
|
this._registeredForLateAnimationBindings.dispose();
|
|
|
this._meshesForIntersections.dispose();
|
|
|
- this._toBeDisposed.dispose();
|
|
|
+ this._toBeDisposed = [];
|
|
|
// Abort active requests
|
|
|
for (var _b = 0, _c = this._activeRequests; _b < _c.length; _b++) {
|
|
|
var request = _c[_b];
|
|
|
@@ -57577,6 +57579,138 @@ var BABYLON;
|
|
|
}
|
|
|
var _loop_1 = function () {
|
|
|
particle = particles[index];
|
|
|
+ var scaledUpdateSpeed = _this._scaledUpdateSpeed;
|
|
|
+ var previousAge = particle.age;
|
|
|
+ particle.age += scaledUpdateSpeed;
|
|
|
+ // Evaluate step to death
|
|
|
+ if (particle.age > particle.lifeTime) {
|
|
|
+ var diff = particle.age - previousAge;
|
|
|
+ var oldDiff = particle.lifeTime - previousAge;
|
|
|
+ scaledUpdateSpeed = (oldDiff * scaledUpdateSpeed) / diff;
|
|
|
+ particle.age = particle.lifeTime;
|
|
|
+ }
|
|
|
+ var ratio = particle.age / particle.lifeTime;
|
|
|
+ // Color
|
|
|
+ if (_this._colorGradients && _this._colorGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._colorGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentColorGradient) {
|
|
|
+ particle._currentColor1.copyFrom(particle._currentColor2);
|
|
|
+ nextGradient.getColorToRef(particle._currentColor2);
|
|
|
+ particle._currentColorGradient = currentGradient;
|
|
|
+ }
|
|
|
+ BABYLON.Color4.LerpToRef(particle._currentColor1, particle._currentColor2, scale, particle.color);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ particle.colorStep.scaleToRef(scaledUpdateSpeed, _this._scaledColorStep);
|
|
|
+ particle.color.addInPlace(_this._scaledColorStep);
|
|
|
+ if (particle.color.a < 0) {
|
|
|
+ particle.color.a = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // Angular speed
|
|
|
+ if (_this._angularSpeedGradients && _this._angularSpeedGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._angularSpeedGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentAngularSpeedGradient) {
|
|
|
+ particle._currentAngularSpeed1 = particle._currentAngularSpeed2;
|
|
|
+ particle._currentAngularSpeed2 = nextGradient.getFactor();
|
|
|
+ particle._currentAngularSpeedGradient = currentGradient;
|
|
|
+ }
|
|
|
+ particle.angularSpeed = BABYLON.Scalar.Lerp(particle._currentAngularSpeed1, particle._currentAngularSpeed2, scale);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ particle.angle += particle.angularSpeed * scaledUpdateSpeed;
|
|
|
+ // Direction
|
|
|
+ var directionScale = scaledUpdateSpeed;
|
|
|
+ /// Velocity
|
|
|
+ if (_this._velocityGradients && _this._velocityGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._velocityGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentVelocityGradient) {
|
|
|
+ particle._currentVelocity1 = particle._currentVelocity2;
|
|
|
+ particle._currentVelocity2 = nextGradient.getFactor();
|
|
|
+ particle._currentVelocityGradient = currentGradient;
|
|
|
+ }
|
|
|
+ directionScale *= BABYLON.Scalar.Lerp(particle._currentVelocity1, particle._currentVelocity2, scale);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ particle.direction.scaleToRef(directionScale, _this._scaledDirection);
|
|
|
+ /// Limit velocity
|
|
|
+ if (_this._limitVelocityGradients && _this._limitVelocityGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._limitVelocityGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentLimitVelocityGradient) {
|
|
|
+ particle._currentLimitVelocity1 = particle._currentLimitVelocity2;
|
|
|
+ particle._currentLimitVelocity2 = nextGradient.getFactor();
|
|
|
+ particle._currentLimitVelocityGradient = currentGradient;
|
|
|
+ }
|
|
|
+ var limitVelocity = BABYLON.Scalar.Lerp(particle._currentLimitVelocity1, particle._currentLimitVelocity2, scale);
|
|
|
+ var currentVelocity = particle.direction.length();
|
|
|
+ if (currentVelocity > limitVelocity) {
|
|
|
+ particle.direction.scaleInPlace(_this.limitVelocityDamping);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /// Drag
|
|
|
+ if (_this._dragGradients && _this._dragGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._dragGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentDragGradient) {
|
|
|
+ particle._currentDrag1 = particle._currentDrag2;
|
|
|
+ particle._currentDrag2 = nextGradient.getFactor();
|
|
|
+ particle._currentDragGradient = currentGradient;
|
|
|
+ }
|
|
|
+ var drag = BABYLON.Scalar.Lerp(particle._currentDrag1, particle._currentDrag2, scale);
|
|
|
+ _this._scaledDirection.scaleInPlace(1.0 - drag);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ particle.position.addInPlace(_this._scaledDirection);
|
|
|
+ // Noise
|
|
|
+ if (noiseTextureData && noiseTextureSize) {
|
|
|
+ var fetchedColorR = _this._fetchR(particle._randomNoiseCoordinates1.x, particle._randomNoiseCoordinates1.y, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
+ var fetchedColorG = _this._fetchR(particle._randomNoiseCoordinates1.z, particle._randomNoiseCoordinates2.x, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
+ var fetchedColorB = _this._fetchR(particle._randomNoiseCoordinates2.y, particle._randomNoiseCoordinates2.z, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
+ var force = BABYLON.Tmp.Vector3[0];
|
|
|
+ var scaledForce = BABYLON.Tmp.Vector3[1];
|
|
|
+ force.copyFromFloats((2 * fetchedColorR - 1) * _this.noiseStrength.x, (2 * fetchedColorG - 1) * _this.noiseStrength.y, (2 * fetchedColorB - 1) * _this.noiseStrength.z);
|
|
|
+ force.scaleToRef(scaledUpdateSpeed, scaledForce);
|
|
|
+ particle.direction.addInPlace(scaledForce);
|
|
|
+ }
|
|
|
+ // Gravity
|
|
|
+ _this.gravity.scaleToRef(scaledUpdateSpeed, _this._scaledGravity);
|
|
|
+ particle.direction.addInPlace(_this._scaledGravity);
|
|
|
+ // Size
|
|
|
+ if (_this._sizeGradients && _this._sizeGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ if (currentGradient !== particle._currentSizeGradient) {
|
|
|
+ particle._currentSize1 = particle._currentSize2;
|
|
|
+ particle._currentSize2 = nextGradient.getFactor();
|
|
|
+ particle._currentSizeGradient = currentGradient;
|
|
|
+ }
|
|
|
+ particle.size = BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ // Remap data
|
|
|
+ if (_this._useRampGradients) {
|
|
|
+ if (_this._colorRemapGradients && _this._colorRemapGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._colorRemapGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ var min = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
|
|
|
+ var max = BABYLON.Scalar.Lerp(currentGradient.factor2, nextGradient.factor2, scale);
|
|
|
+ particle.remapData.x = min;
|
|
|
+ particle.remapData.y = max - min;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ if (_this._alphaRemapGradients && _this._alphaRemapGradients.length > 0) {
|
|
|
+ BABYLON.Tools.GetCurrentGradient(ratio, _this._alphaRemapGradients, function (currentGradient, nextGradient, scale) {
|
|
|
+ var min = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
|
|
|
+ var max = BABYLON.Scalar.Lerp(currentGradient.factor2, nextGradient.factor2, scale);
|
|
|
+ particle.remapData.z = min;
|
|
|
+ particle.remapData.w = max - min;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (_this._isAnimationSheetEnabled) {
|
|
|
+ particle.updateCellIndex();
|
|
|
+ }
|
|
|
+ // Update the position of the attached sub-emitters to match their attached particle
|
|
|
+ particle._inheritParticleInfoToSubEmitters();
|
|
|
if (particle.age >= particle.lifeTime) { // Recycle by swapping with last particle
|
|
|
_this._emitFromParticle(particle);
|
|
|
if (particle._attachedSubEmitters) {
|
|
|
@@ -57590,140 +57724,6 @@ var BABYLON;
|
|
|
index--;
|
|
|
return "continue";
|
|
|
}
|
|
|
- else {
|
|
|
- var scaledUpdateSpeed = _this._scaledUpdateSpeed;
|
|
|
- var previousAge = particle.age;
|
|
|
- particle.age += scaledUpdateSpeed;
|
|
|
- // Evaluate step to death
|
|
|
- if (particle.age > particle.lifeTime) {
|
|
|
- var diff = particle.age - previousAge;
|
|
|
- var oldDiff = particle.lifeTime - previousAge;
|
|
|
- scaledUpdateSpeed = (diff * scaledUpdateSpeed) / oldDiff;
|
|
|
- particle.age = particle.lifeTime;
|
|
|
- }
|
|
|
- var ratio = particle.age / particle.lifeTime;
|
|
|
- // Color
|
|
|
- if (_this._colorGradients && _this._colorGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._colorGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentColorGradient) {
|
|
|
- particle._currentColor1.copyFrom(particle._currentColor2);
|
|
|
- nextGradient.getColorToRef(particle._currentColor2);
|
|
|
- particle._currentColorGradient = currentGradient;
|
|
|
- }
|
|
|
- BABYLON.Color4.LerpToRef(particle._currentColor1, particle._currentColor2, scale, particle.color);
|
|
|
- });
|
|
|
- }
|
|
|
- else {
|
|
|
- particle.colorStep.scaleToRef(scaledUpdateSpeed, _this._scaledColorStep);
|
|
|
- particle.color.addInPlace(_this._scaledColorStep);
|
|
|
- if (particle.color.a < 0) {
|
|
|
- particle.color.a = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- // Angular speed
|
|
|
- if (_this._angularSpeedGradients && _this._angularSpeedGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._angularSpeedGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentAngularSpeedGradient) {
|
|
|
- particle._currentAngularSpeed1 = particle._currentAngularSpeed2;
|
|
|
- particle._currentAngularSpeed2 = nextGradient.getFactor();
|
|
|
- particle._currentAngularSpeedGradient = currentGradient;
|
|
|
- }
|
|
|
- particle.angularSpeed = BABYLON.Scalar.Lerp(particle._currentAngularSpeed1, particle._currentAngularSpeed2, scale);
|
|
|
- });
|
|
|
- }
|
|
|
- particle.angle += particle.angularSpeed * scaledUpdateSpeed;
|
|
|
- // Direction
|
|
|
- var directionScale_1 = scaledUpdateSpeed;
|
|
|
- /// Velocity
|
|
|
- if (_this._velocityGradients && _this._velocityGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._velocityGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentVelocityGradient) {
|
|
|
- particle._currentVelocity1 = particle._currentVelocity2;
|
|
|
- particle._currentVelocity2 = nextGradient.getFactor();
|
|
|
- particle._currentVelocityGradient = currentGradient;
|
|
|
- }
|
|
|
- directionScale_1 *= BABYLON.Scalar.Lerp(particle._currentVelocity1, particle._currentVelocity2, scale);
|
|
|
- });
|
|
|
- }
|
|
|
- particle.direction.scaleToRef(directionScale_1, _this._scaledDirection);
|
|
|
- /// Limit velocity
|
|
|
- if (_this._limitVelocityGradients && _this._limitVelocityGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._limitVelocityGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentLimitVelocityGradient) {
|
|
|
- particle._currentLimitVelocity1 = particle._currentLimitVelocity2;
|
|
|
- particle._currentLimitVelocity2 = nextGradient.getFactor();
|
|
|
- particle._currentLimitVelocityGradient = currentGradient;
|
|
|
- }
|
|
|
- var limitVelocity = BABYLON.Scalar.Lerp(particle._currentLimitVelocity1, particle._currentLimitVelocity2, scale);
|
|
|
- var currentVelocity = particle.direction.length();
|
|
|
- if (currentVelocity > limitVelocity) {
|
|
|
- particle.direction.scaleInPlace(_this.limitVelocityDamping);
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- /// Drag
|
|
|
- if (_this._dragGradients && _this._dragGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._dragGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentDragGradient) {
|
|
|
- particle._currentDrag1 = particle._currentDrag2;
|
|
|
- particle._currentDrag2 = nextGradient.getFactor();
|
|
|
- particle._currentDragGradient = currentGradient;
|
|
|
- }
|
|
|
- var drag = BABYLON.Scalar.Lerp(particle._currentDrag1, particle._currentDrag2, scale);
|
|
|
- _this._scaledDirection.scaleInPlace(1.0 - drag);
|
|
|
- });
|
|
|
- }
|
|
|
- particle.position.addInPlace(_this._scaledDirection);
|
|
|
- // Noise
|
|
|
- if (noiseTextureData && noiseTextureSize) {
|
|
|
- var fetchedColorR = _this._fetchR(particle._randomNoiseCoordinates1.x, particle._randomNoiseCoordinates1.y, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
- var fetchedColorG = _this._fetchR(particle._randomNoiseCoordinates1.z, particle._randomNoiseCoordinates2.x, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
- var fetchedColorB = _this._fetchR(particle._randomNoiseCoordinates2.y, particle._randomNoiseCoordinates2.z, noiseTextureSize.width, noiseTextureSize.height, noiseTextureData);
|
|
|
- var force = BABYLON.Tmp.Vector3[0];
|
|
|
- var scaledForce = BABYLON.Tmp.Vector3[1];
|
|
|
- force.copyFromFloats((2 * fetchedColorR - 1) * _this.noiseStrength.x, (2 * fetchedColorG - 1) * _this.noiseStrength.y, (2 * fetchedColorB - 1) * _this.noiseStrength.z);
|
|
|
- force.scaleToRef(scaledUpdateSpeed, scaledForce);
|
|
|
- particle.direction.addInPlace(scaledForce);
|
|
|
- }
|
|
|
- // Gravity
|
|
|
- _this.gravity.scaleToRef(scaledUpdateSpeed, _this._scaledGravity);
|
|
|
- particle.direction.addInPlace(_this._scaledGravity);
|
|
|
- // Size
|
|
|
- if (_this._sizeGradients && _this._sizeGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._sizeGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- if (currentGradient !== particle._currentSizeGradient) {
|
|
|
- particle._currentSize1 = particle._currentSize2;
|
|
|
- particle._currentSize2 = nextGradient.getFactor();
|
|
|
- particle._currentSizeGradient = currentGradient;
|
|
|
- }
|
|
|
- particle.size = BABYLON.Scalar.Lerp(particle._currentSize1, particle._currentSize2, scale);
|
|
|
- });
|
|
|
- }
|
|
|
- // Remap data
|
|
|
- if (_this._useRampGradients) {
|
|
|
- if (_this._colorRemapGradients && _this._colorRemapGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._colorRemapGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- var min = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
|
|
|
- var max = BABYLON.Scalar.Lerp(currentGradient.factor2, nextGradient.factor2, scale);
|
|
|
- particle.remapData.x = min;
|
|
|
- particle.remapData.y = max - min;
|
|
|
- });
|
|
|
- }
|
|
|
- if (_this._alphaRemapGradients && _this._alphaRemapGradients.length > 0) {
|
|
|
- BABYLON.Tools.GetCurrentGradient(ratio, _this._alphaRemapGradients, function (currentGradient, nextGradient, scale) {
|
|
|
- var min = BABYLON.Scalar.Lerp(currentGradient.factor1, nextGradient.factor1, scale);
|
|
|
- var max = BABYLON.Scalar.Lerp(currentGradient.factor2, nextGradient.factor2, scale);
|
|
|
- particle.remapData.z = min;
|
|
|
- particle.remapData.w = max - min;
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- if (_this._isAnimationSheetEnabled) {
|
|
|
- particle.updateCellIndex();
|
|
|
- }
|
|
|
- // Update the position of the attached sub-emitters to match their attached particle
|
|
|
- particle._inheritParticleInfoToSubEmitters();
|
|
|
- }
|
|
|
};
|
|
|
var particle;
|
|
|
for (var index = 0; index < particles.length; index++) {
|
|
|
@@ -58440,6 +58440,7 @@ var BABYLON;
|
|
|
if (index !== -1) {
|
|
|
this._rootParticleSystem.activeSubSystems.splice(index, 1);
|
|
|
}
|
|
|
+ this._rootParticleSystem = null;
|
|
|
};
|
|
|
// End of sub system methods
|
|
|
ParticleSystem.prototype._update = function (newParticles) {
|
|
|
@@ -58952,6 +58953,16 @@ var BABYLON;
|
|
|
this._rampGradientsTexture = null;
|
|
|
}
|
|
|
this._removeFromRoot();
|
|
|
+ if (this._subEmitters && this._subEmitters.length) {
|
|
|
+ for (var index = 0; index < this._subEmitters.length; index++) {
|
|
|
+ for (var _i = 0, _a = this._subEmitters[index]; _i < _a.length; _i++) {
|
|
|
+ var subEmitter = _a[_i];
|
|
|
+ subEmitter.dispose();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ this._subEmitters = [];
|
|
|
+ this.subEmitters = [];
|
|
|
+ }
|
|
|
if (this._disposeEmitterOnDispose && this.emitter && this.emitter.dispose) {
|
|
|
this.emitter.dispose(true);
|
|
|
}
|
|
|
@@ -58960,9 +58971,11 @@ var BABYLON;
|
|
|
if (index > -1) {
|
|
|
this._scene.particleSystems.splice(index, 1);
|
|
|
}
|
|
|
+ this._scene._activeParticleSystems.dispose();
|
|
|
// Callback
|
|
|
this.onDisposeObservable.notifyObservers(this);
|
|
|
this.onDisposeObservable.clear();
|
|
|
+ this.reset();
|
|
|
};
|
|
|
// Clone
|
|
|
/**
|
|
|
@@ -60650,6 +60663,10 @@ var BABYLON;
|
|
|
clone.particleSystem.disposeOnStop = true;
|
|
|
return clone;
|
|
|
};
|
|
|
+ /** Release associated resources */
|
|
|
+ SubEmitter.prototype.dispose = function () {
|
|
|
+ this.particleSystem.dispose();
|
|
|
+ };
|
|
|
return SubEmitter;
|
|
|
}());
|
|
|
BABYLON.SubEmitter = SubEmitter;
|
|
|
@@ -67129,7 +67146,7 @@ var BABYLON;
|
|
|
var BABYLON;
|
|
|
(function (BABYLON) {
|
|
|
// Sets the default audio engine to Babylon JS.
|
|
|
- BABYLON.Engine.AudioEngineFactory = function () { return new AudioEngine(); };
|
|
|
+ BABYLON.Engine.AudioEngineFactory = function (engine) { return new AudioEngine(engine); };
|
|
|
/**
|
|
|
* This represents the default audio engine used in babylon.
|
|
|
* It is responsible to play, synchronize and analyse sounds throughout the application.
|
|
|
@@ -67922,6 +67939,7 @@ var BABYLON;
|
|
|
playPromise.catch(function (error) {
|
|
|
// Automatic playback failed.
|
|
|
// Waiting for the audio engine to be unlocked by user click on unmute
|
|
|
+ BABYLON.Engine.audioEngine.onAudioUnlockedObservable.addOnce(function () { return tryToPlay; });
|
|
|
});
|
|
|
}
|
|
|
}
|
David Catuhe