@galacean/engine-core 1.1.0-beta.19 → 1.1.0-beta.20

package/dist/main.js

@@ -5839,8 +5839,12 @@ var ShaderFactory = /*#__PURE__*/ function() {
                     break;
                 case gl.BOOL_VEC3:
                 case gl.INT_VEC3:
-                    shaderUniform.applyFunc = isArray ? shaderUniform.upload3iv : shaderUniform.upload3i;
-                    shaderUniform.cacheValue = new engineMath.Vector3(0, 0, 0);
+                    if (isArray) {
+                        shaderUniform.applyFunc = shaderUniform.upload3iv;
+                    } else {
+                        shaderUniform.applyFunc = shaderUniform.upload3i;
+                        shaderUniform.cacheValue = new engineMath.Vector3(0, 0, 0);
+                    }
                     break;
                 case gl.BOOL_VEC4:
                 case gl.INT_VEC4:
@@ -7860,6 +7864,9 @@ SimpleSpriteAssembler = __decorate([
             case SpriteModifyFlags.pivot:
                 this._dirtyUpdateFlag |= RendererUpdateFlags.WorldVolume;
                 break;
+            case SpriteModifyFlags.destroy:
+                this.sprite = null;
+                break;
         }
     };
     _create_class(SpriteMask, [
@@ -9060,6 +9067,10 @@ var BlendShapeFrameDirty;
             Logger.error("mesh is null.");
             return;
         }
+        if (this._mesh.destroyed) {
+            Logger.error("mesh is destroyed.");
+            return;
+        }
         Renderer1.prototype._prepareRender.call(this, context);
     };
     /**
@@ -12726,6 +12737,7 @@ var AssetPromise = /*#__PURE__*/ function() {
     function AssetPromise(executor) {
         var _this = this;
         this._state = "pending";
+        this._progress = 0;
         this._onProgressCallback = [];
         this._promise = new Promise(function(resolve, reject) {
             _this._reject = reject;
@@ -12750,6 +12762,7 @@ var AssetPromise = /*#__PURE__*/ function() {
             };
             var setProgress = function(progress) {
                 if (_this._state === "pending") {
+                    _this._progress = progress;
                     _this._onProgressCallback.forEach(function(callback) {
                         return callback(progress);
                     });
@@ -12764,7 +12777,12 @@ var AssetPromise = /*#__PURE__*/ function() {
    * @param callback
    * @returns AssetPromise
    */ _proto.onProgress = function onProgress(callback) {
-        this._onProgressCallback.push(callback);
+        if (this._progress) {
+            callback(this._progress);
+        }
+        if (this._state === "pending") {
+            this._onProgressCallback.push(callback);
+        }
         return this;
     };
     _proto.then = function then(onfulfilled, onrejected) {
@@ -13075,7 +13093,8 @@ var /** @internal */ PromiseState;
         // Check cache
         var cacheObject = this._assetUrlPool[assetBaseURL];
         if (cacheObject) {
-            return new AssetPromise(function(resolve) {
+            return new AssetPromise(function(resolve, _, setProgress) {
+                setProgress(1);
                 resolve(_this._getResolveResource(cacheObject, paths));
             });
         }
@@ -13092,8 +13111,10 @@ var /** @internal */ PromiseState;
         var loadingPromises = this._loadingPromises;
         var loadingPromise = loadingPromises[assetURL];
         if (loadingPromise) {
-            return new AssetPromise(function(resolve, reject) {
-                loadingPromise.then(function(resource) {
+            return new AssetPromise(function(resolve, reject, setProgress) {
+                loadingPromise.onProgress(function(v) {
+                    setProgress(v);
+                }).then(function(resource) {
                     resolve(resource);
                 }).catch(function(error) {
                     reject(error);
@@ -19276,12 +19297,20 @@ ShaderPool.init();
             Logger.warn("The material of sky is not defined.");
             return;
         }
+        if (material.destroyed) {
+            Logger.warn("The material of sky is destroyed.");
+            return;
+        }
         if (!mesh) {
             Logger.warn("The mesh of sky is not defined.");
             return;
         }
-        var _context_camera = context.camera, engine = _context_camera.engine, aspectRatio = _context_camera.aspectRatio, fieldOfView = _context_camera.fieldOfView, viewMatrix = _context_camera.viewMatrix, cameraShaderData = _context_camera.shaderData;
-        var sceneData = context.camera.scene.shaderData;
+        if (mesh.destroyed) {
+            Logger.warn("The mesh of sky is destroyed.");
+            return;
+        }
+        var _context_camera = context.camera, engine = _context_camera.engine, scene = _context_camera.scene, aspectRatio = _context_camera.aspectRatio, fieldOfView = _context_camera.fieldOfView, viewMatrix = _context_camera.viewMatrix, cameraShaderData = _context_camera.shaderData;
+        var sceneData = scene.shaderData;
         var viewProjMatrix = Sky._viewProjMatrix, projectionMatrix = Sky._projectionMatrix;
         var rhi = engine._hardwareRenderer;
         var materialShaderData = material.shaderData, shader = material.shader, renderState = material.renderState;
@@ -24495,7 +24524,7 @@ var BaseMaterial = /*#__PURE__*/ function(Material1) {
 /**
  * @internal
  */ var AnimationCurveOwner = /*#__PURE__*/ function() {
-    function AnimationCurveOwner(target, type, property, cureType) {
+    function AnimationCurveOwner(target, type, component, property, cureType) {
         this.baseEvaluateData = {
             curKeyframeIndex: 0,
             value: null
@@ -24506,9 +24535,8 @@ var BaseMaterial = /*#__PURE__*/ function(Material1) {
         };
         this.updateMark = 0;
         this.target = target;
-        this.type = type;
         this.property = property;
-        this.component = target.getComponent(type);
+        this.component = component;
         this.cureType = cureType;
         this._isBlendShape = _instanceof(this.component, SkinnedMeshRenderer);
         var assemblerType = AnimationCurveOwner.getAssemblerType(type, property);
@@ -24740,9 +24768,9 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
     var _proto = AnimationClipCurveBinding.prototype;
     /**
    * @internal
-   */ _proto._createCurveOwner = function _createCurveOwner(entity) {
+   */ _proto._createCurveOwner = function _createCurveOwner(entity, component) {
         var curveType = this.curve.constructor;
-        var owner = new AnimationCurveOwner(entity, this.type, this.property, curveType);
+        var owner = new AnimationCurveOwner(entity, this.type, component, this.property, curveType);
         curveType._initializeOwner(owner);
         owner.saveDefaultValue();
         return owner;
@@ -24760,10 +24788,10 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
     };
     /**
    * @internal
-   */ _proto._getTempCurveOwner = function _getTempCurveOwner(entity) {
+   */ _proto._getTempCurveOwner = function _getTempCurveOwner(entity, component) {
         var instanceId = entity.instanceId;
         if (!this._tempCurveOwner[instanceId]) {
-            this._tempCurveOwner[instanceId] = this._createCurveOwner(entity);
+            this._tempCurveOwner[instanceId] = this._createCurveOwner(entity, component);
         }
         return this._tempCurveOwner[instanceId];
     };
@@ -24851,9 +24879,15 @@ AnimationCurveOwner.registerAssembler(SkinnedMeshRenderer, "blendShapeWeights",
             var curveData = curveBindings[i];
             var targetEntity = entity.findByPath(curveData.relativePath);
             if (targetEntity) {
-                var curveOwner = curveData._getTempCurveOwner(targetEntity);
-                var value = curveOwner.evaluateValue(curveData.curve, time, false);
-                curveOwner.applyValue(value, 1, false);
+                var component = targetEntity.getComponent(curveData.type);
+                if (!component) {
+                    continue;
+                }
+                var curveOwner = curveData._getTempCurveOwner(targetEntity, component);
+                if (curveOwner && curveData.curve.keys.length) {
+                    var value = curveOwner.evaluateValue(curveData.curve, time, false);
+                    curveOwner.applyValue(value, 1, false);
+                }
             }
         }
     };
@@ -26270,11 +26304,15 @@ exports.AnimatorLayerBlendingMode = void 0;
             var targetEntity = curve.relativePath === "" ? entity : entity.findByPath(curve.relativePath);
             if (targetEntity) {
                 var _curveOwnerPool, _instanceId, _propertyOwners, _property, _layerCurveOwnerPool, _instanceId1, _layerPropertyOwners, _property1;
+                var component = targetEntity.getComponent(curve.type);
+                if (!component) {
+                    continue;
+                }
                 var property = curve.property;
                 var instanceId = targetEntity.instanceId;
                 // Get owner
                 var propertyOwners = (_curveOwnerPool = curveOwnerPool)[_instanceId = instanceId] || (_curveOwnerPool[_instanceId] = Object.create(null));
-                var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity));
+                var owner = (_propertyOwners = propertyOwners)[_property = property] || (_propertyOwners[_property] = curve._createCurveOwner(targetEntity, component));
                 // Get layer owner
                 var layerPropertyOwners = (_layerCurveOwnerPool = layerCurveOwnerPool)[_instanceId1 = instanceId] || (_layerCurveOwnerPool[_instanceId1] = Object.create(null));
                 var layerOwner = (_layerPropertyOwners = layerPropertyOwners)[_property1 = property] || (_layerPropertyOwners[_property1] = curve._createCurveLayerOwner(owner));
@@ -27452,16 +27490,7 @@ exports.ParticleStopMode = void 0;
     };
     _proto._render = function _render(context) {
         var generator = this.generator;
-        var primitive = generator._primitive;
-        if (generator._firstActiveElement < generator._firstFreeElement) {
-            primitive.instanceCount = generator._firstFreeElement - generator._firstActiveElement;
-        } else {
-            var instanceCount = generator._currentParticleCount - generator._firstActiveElement;
-            if (generator._firstFreeElement > 0) {
-                instanceCount += generator._firstFreeElement;
-            }
-            primitive.instanceCount = instanceCount;
-        }
+        generator._primitive.instanceCount = generator._getAliveParticleCount();
         var material = this.getMaterial();
         if (!material) {
             return;
@@ -28246,13 +28275,13 @@ var MainModule = /*#__PURE__*/ function() {
         /** Override the default playback speed of the Particle Generator. */ this.simulationSpeed = 1.0;
         /** Control how the Particle Generator applies its Transform component to the particles it emits. */ this.scalingMode = exports.ParticleScaleMode.Local;
         /** If set to true, the Particle Generator automatically begins to play on startup. */ this.playOnEnabled = true;
-        this._maxParticles = 1000;
-        this._gravity = new engineMath.Vector3();
+        /** @internal */ this._maxParticleBuffer = 1000;
         /** @internal */ this._startSpeedRand = new engineMath.Rand(0, ParticleRandomSubSeeds.StartSpeed);
         /** @internal */ this._startLifeTimeRand = new engineMath.Rand(0, ParticleRandomSubSeeds.StartLifetime);
         /** @internal */ this._startColorRand = new engineMath.Rand(0, ParticleRandomSubSeeds.StartColor);
         /** @internal */ this._startSizeRand = new engineMath.Rand(0, ParticleRandomSubSeeds.StartSize);
         /** @internal */ this._startRotationRand = new engineMath.Rand(0, ParticleRandomSubSeeds.StartRotation);
+        this._gravity = new engineMath.Vector3();
         this._generator = generator;
     }
     var _proto = MainModule.prototype;
@@ -28330,16 +28359,10 @@ var MainModule = /*#__PURE__*/ function() {
             get: /**
    * Max particles count.
    */ function get() {
-                return this._maxParticles;
+                return this._maxParticleBuffer - 1;
             },
             set: function set(value) {
-                if (this._maxParticles !== value) {
-                    this._maxParticles = value;
-                    var generator = this._generator;
-                    if (value < generator._currentParticleCount) {
-                        generator._resizeInstanceBuffer(value);
-                    }
-                }
+                this._maxParticleBuffer = value + 1;
             }
         },
         {
@@ -28421,13 +28444,7 @@ __decorate([
 ], MainModule.prototype, "gravityModifier", void 0);
 __decorate([
     ignoreClone
-], MainModule.prototype, "_maxParticles", void 0);
-__decorate([
-    ignoreClone
-], MainModule.prototype, "_generator", void 0);
-__decorate([
-    ignoreClone
-], MainModule.prototype, "_gravity", void 0);
+], MainModule.prototype, "_maxParticleBuffer", void 0);
 __decorate([
     ignoreClone
 ], MainModule.prototype, "_startSpeedRand", void 0);
@@ -28443,6 +28460,12 @@ __decorate([
 __decorate([
     ignoreClone
 ], MainModule.prototype, "_startRotationRand", void 0);
+__decorate([
+    ignoreClone
+], MainModule.prototype, "_generator", void 0);
+__decorate([
+    ignoreClone
+], MainModule.prototype, "_gravity", void 0);
 
 /**
  * Rotate particles throughout their lifetime.
@@ -29040,7 +29063,7 @@ __decorate([
         subPrimitive.start = 0;
         this._primitive = new Primitive(renderer.engine);
         this._reorganizeGeometryBuffers();
-        this._resizeInstanceBuffer(ParticleGenerator._particleIncreaseCount);
+        this._resizeInstanceBuffer(true, ParticleGenerator._particleIncreaseCount);
         this.emission.enabled = true;
     }
     var _proto = ParticleGenerator.prototype;
@@ -29097,9 +29120,13 @@ __decorate([
     /**
    * @internal
    */ _proto._emit = function _emit(time, count) {
-        var position = ParticleGenerator._tempVector30;
-        var direction = ParticleGenerator._tempVector31;
         if (this.emission.enabled) {
+            // Wait the existing particles to be retired
+            if (this.main._maxParticleBuffer < this._currentParticleCount) {
+                return;
+            }
+            var position = ParticleGenerator._tempVector30;
+            var direction = ParticleGenerator._tempVector31;
             var transform = this._renderer.entity.transform;
             var shape = this.emission.shape;
             for(var i = 0; i < count; i++){
@@ -29126,6 +29153,13 @@ __decorate([
         this._retireActiveParticles();
         this._freeRetiredParticles();
         if (emission.enabled && this._isPlaying) {
+            // If maxParticles is changed dynamically, currentParticleCount may be greater than maxParticles
+            if (this._currentParticleCount > main._maxParticleBuffer) {
+                var notRetireParticleCount = this._getNotRetiredParticleCount();
+                if (notRetireParticleCount < main._maxParticleBuffer) {
+                    this._resizeInstanceBuffer(false);
+                }
+            }
             emission._emit(lastPlayTime, this._playTime);
             if (!main.isLoop && this._playTime > duration) {
                 this._isPlaying = false;
@@ -29197,12 +29231,12 @@ __decorate([
     };
     /**
    * @internal
-   */ _proto._resizeInstanceBuffer = function _resizeInstanceBuffer(increaseCount) {
+   */ _proto._resizeInstanceBuffer = function _resizeInstanceBuffer(isIncrease, increaseCount) {
         var _this__instanceVertexBufferBinding;
         (_this__instanceVertexBufferBinding = this._instanceVertexBufferBinding) == null ? void 0 : _this__instanceVertexBufferBinding.buffer.destroy();
         var particleUtils = this._renderer.engine._particleBufferUtils;
         var stride = particleUtils.instanceVertexStride;
-        var newParticleCount = this._currentParticleCount + increaseCount;
+        var newParticleCount = isIncrease ? this._currentParticleCount + increaseCount : this.main._maxParticleBuffer;
         var newByteLength = stride * newParticleCount;
         var engine = this._renderer.engine;
         var vertexInstanceBuffer = new Buffer(engine, exports.BufferBindFlag.VertexBuffer, newByteLength, exports.BufferUsage.Dynamic, false);
@@ -29213,10 +29247,37 @@ __decorate([
         var lastInstanceVertices = this._instanceVertices;
         if (lastInstanceVertices) {
             var floatStride = particleUtils.instanceVertexFloatStride;
-            var freeOffset = this._firstFreeElement * floatStride;
-            instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, 0, freeOffset));
-            var freeEndOffset = (this._firstFreeElement + increaseCount) * floatStride;
-            instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, freeOffset * 4), freeEndOffset);
+            var firstFreeElement = this._firstFreeElement;
+            var firstRetiredElement = this._firstRetiredElement;
+            if (isIncrease) {
+                var freeOffset = this._firstFreeElement * floatStride;
+                instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, 0, freeOffset));
+                var freeEndOffset = (this._firstFreeElement + increaseCount) * floatStride;
+                instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, freeOffset * 4), freeEndOffset);
+                // Maintain expanded pointers
+                this._firstNewElement > firstFreeElement && (this._firstNewElement += increaseCount);
+                this._firstActiveElement > firstFreeElement && (this._firstActiveElement += increaseCount);
+                firstRetiredElement > firstFreeElement && (this._firstRetiredElement += increaseCount);
+            } else {
+                var migrateCount, bufferOffset;
+                if (firstRetiredElement <= firstFreeElement) {
+                    migrateCount = firstFreeElement - firstRetiredElement;
+                    bufferOffset = 0;
+                    // Maintain expanded pointers
+                    this._firstFreeElement -= firstRetiredElement;
+                    this._firstNewElement -= firstRetiredElement;
+                    this._firstActiveElement -= firstRetiredElement;
+                    this._firstRetiredElement = 0;
+                } else {
+                    migrateCount = this._currentParticleCount - firstRetiredElement;
+                    bufferOffset = firstFreeElement;
+                    // Maintain expanded pointers
+                    this._firstNewElement > firstFreeElement && (this._firstNewElement -= firstFreeElement);
+                    this._firstActiveElement > firstFreeElement && (this._firstActiveElement -= firstFreeElement);
+                    firstRetiredElement > firstFreeElement && (this._firstRetiredElement -= firstFreeElement);
+                }
+                instanceVertices.set(new Float32Array(lastInstanceVertices.buffer, firstRetiredElement * floatStride * 4, migrateCount * floatStride), bufferOffset * floatStride);
+            }
             this._instanceBufferResized = true;
         }
         // Instance buffer always at last
@@ -29225,8 +29286,60 @@ __decorate([
         this._instanceVertexBufferBinding = vertexBufferBinding;
         this._currentParticleCount = newParticleCount;
     };
+    /**
+   * @internal
+   */ _proto._updateShaderData = function _updateShaderData(shaderData) {
+        this.main._updateShaderData(shaderData);
+        this.velocityOverLifetime._updateShaderData(shaderData);
+        this.textureSheetAnimation._updateShaderData(shaderData);
+        this.sizeOverLifetime._updateShaderData(shaderData);
+        this.rotationOverLifetime._updateShaderData(shaderData);
+        this.colorOverLifetime._updateShaderData(shaderData);
+    };
+    /**
+   * @internal
+   */ _proto._resetGlobalRandSeed = function _resetGlobalRandSeed(seed) {
+        this._randomSeed = seed;
+        this.main._resetRandomSeed(seed);
+        this.emission._resetRandomSeed(seed);
+        this.textureSheetAnimation._resetRandomSeed(seed);
+        this.velocityOverLifetime._resetRandomSeed(seed);
+        this.rotationOverLifetime._resetRandomSeed(seed);
+        this.colorOverLifetime._resetRandomSeed(seed);
+    };
+    /**
+   * @internal
+   */ _proto._getAliveParticleCount = function _getAliveParticleCount() {
+        if (this._firstActiveElement <= this._firstFreeElement) {
+            return this._firstFreeElement - this._firstActiveElement;
+        } else {
+            var instanceCount = this._currentParticleCount - this._firstActiveElement;
+            if (this._firstFreeElement > 0) {
+                instanceCount += this._firstFreeElement;
+            }
+            return instanceCount;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._getNotRetiredParticleCount = function _getNotRetiredParticleCount() {
+        if (this._firstRetiredElement <= this._firstFreeElement) {
+            return this._firstFreeElement - this._firstRetiredElement;
+        } else {
+            var instanceCount = this._currentParticleCount - this._firstRetiredElement;
+            if (this._firstFreeElement > 0) {
+                instanceCount += this._firstFreeElement;
+            }
+            return instanceCount;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._destroy = function _destroy() {
+        this._instanceVertexBufferBinding.buffer.destroy();
+        this._primitive.destroy();
+    };
     _proto._addNewParticle = function _addNewParticle(position, direction, transform, time) {
-        var particleUtils = this._renderer.engine._particleBufferUtils;
         var firstFreeElement = this._firstFreeElement;
         var nextFreeElement = firstFreeElement + 1;
         if (nextFreeElement >= this._currentParticleCount) {
@@ -29235,23 +29348,20 @@ __decorate([
         var main = this.main;
         // Check if can be expanded
         if (nextFreeElement === this._firstRetiredElement) {
-            var increaseCount = Math.min(ParticleGenerator._particleIncreaseCount, main.maxParticles - this._currentParticleCount);
+            var increaseCount = Math.min(ParticleGenerator._particleIncreaseCount, main._maxParticleBuffer - this._currentParticleCount);
             if (increaseCount === 0) {
                 return;
             }
-            this._resizeInstanceBuffer(increaseCount);
+            this._resizeInstanceBuffer(true, increaseCount);
             // Recalculate nextFreeElement after resize
             nextFreeElement = firstFreeElement + 1;
-            // Maintain expanded pointers
-            this._firstNewElement > firstFreeElement && (this._firstNewElement += increaseCount);
-            this._firstActiveElement > firstFreeElement && (this._firstActiveElement += increaseCount);
-            this._firstRetiredElement > firstFreeElement && (this._firstRetiredElement += increaseCount);
         }
         var pos, rot;
         if (main.simulationSpace === exports.ParticleSimulationSpace.World) {
             pos = transform.worldPosition;
             rot = transform.worldRotationQuaternion;
         }
+        var particleUtils = this._renderer.engine._particleBufferUtils;
         var startSpeed = main.startSpeed.evaluate(undefined, main._startSpeedRand.random());
         var instanceVertices = this._instanceVertices;
         var offset = firstFreeElement * particleUtils.instanceVertexFloatStride;
@@ -29355,7 +29465,7 @@ __decorate([
         var particleUtils = engine._particleBufferUtils;
         var frameCount = engine.time.frameCount;
         var instanceVertices = this._instanceVertices;
-        while(this._firstActiveElement != this._firstNewElement){
+        while(this._firstActiveElement !== this._firstNewElement){
             var activeParticleOffset = this._firstActiveElement * particleUtils.instanceVertexFloatStride;
             var activeParticleTimeOffset = activeParticleOffset + particleUtils.timeOffset;
             var particleAge = this._playTime - instanceVertices[activeParticleTimeOffset];
@@ -29372,37 +29482,10 @@ __decorate([
             this._waitProcessRetiredElementCount++;
         }
     };
-    /**
-   * @internal
-   */ _proto._updateShaderData = function _updateShaderData(shaderData) {
-        this.main._updateShaderData(shaderData);
-        this.velocityOverLifetime._updateShaderData(shaderData);
-        this.textureSheetAnimation._updateShaderData(shaderData);
-        this.sizeOverLifetime._updateShaderData(shaderData);
-        this.rotationOverLifetime._updateShaderData(shaderData);
-        this.colorOverLifetime._updateShaderData(shaderData);
-    };
-    /**
-   * @internal
-   */ _proto._resetGlobalRandSeed = function _resetGlobalRandSeed(seed) {
-        this._randomSeed = seed;
-        this.main._resetRandomSeed(seed);
-        this.emission._resetRandomSeed(seed);
-        this.textureSheetAnimation._resetRandomSeed(seed);
-        this.velocityOverLifetime._resetRandomSeed(seed);
-        this.rotationOverLifetime._resetRandomSeed(seed);
-        this.colorOverLifetime._resetRandomSeed(seed);
-    };
-    /**
-   * @internal
-   */ _proto._destroy = function _destroy() {
-        this._instanceVertexBufferBinding.buffer.destroy();
-        this._primitive.destroy();
-    };
     _proto._freeRetiredParticles = function _freeRetiredParticles() {
         var particleUtils = this._renderer.engine._particleBufferUtils;
         var frameCount = this._renderer.engine.time.frameCount;
-        while(this._firstRetiredElement != this._firstActiveElement){
+        while(this._firstRetiredElement !== this._firstActiveElement){
             var offset = this._firstRetiredElement * particleUtils.instanceVertexFloatStride + particleUtils.startLifeTimeOffset;
             var age = frameCount - this._instanceVertices[offset];
             // WebGL don't support map buffer range, so off this optimization